hw/mlx4/kernel/bus/core/l2w_debug.c

   1 #include "l2w.h"
   2 #include "ev_log.h"
   3
   4 #define MAX_BUFFER_SIZE         256
   5
   6 VOID
   7 WriteEventLogEntryStr(
   8         PVOID   pi_pIoObject,
   9         ULONG   pi_ErrorCode,
  10         ULONG   pi_UniqueErrorCode,
  11         ULONG   pi_FinalStatus,
  12         PWCHAR  pi_InsertionStr,
  13         ULONG   pi_nDataItems,
  14         ...
  15         )
  16 /*++
  17
  18 Routine Description:
  19     Writes an event log entry to the event log.
  20
  21 Arguments:
  22
  23         pi_pIoObject......... The IO object ( driver object or device object ).
  24         pi_ErrorCode......... The error code.
  25         pi_UniqueErrorCode... A specific error code.
  26         pi_FinalStatus....... The final status.
  27         pi_nDataItems........ Number of data items.
  28         .
  29         . data items values
  30         .
  31
  32 Return Value:
  33
  34         None .
  35
  36 --*/
  37 { /* WriteEventLogEntryStr */
  38
  39         /* Variable argument list */
  40         va_list                                 l_Argptr;
  41         /* Pointer to an error log entry */
  42         PIO_ERROR_LOG_PACKET    l_pErrorLogEntry;
  43         /* sizeof insertion string */
  44         int     l_Size = (int)((pi_InsertionStr) ? ((wcslen(pi_InsertionStr) + 1) * sizeof( WCHAR )) : 0);
  45         int l_PktSize =sizeof(IO_ERROR_LOG_PACKET)+pi_nDataItems*sizeof(ULONG);
  46         int l_TotalSize =l_PktSize +l_Size;
  47
  48         /* Init the variable argument list */
  49         va_start(l_Argptr, pi_nDataItems);
  50
  51         /* Allocate an error log entry */
  52         if (l_TotalSize >= ERROR_LOG_MAXIMUM_SIZE - 2)
  53                 l_TotalSize = ERROR_LOG_MAXIMUM_SIZE - 2;
  54         l_pErrorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
  55                 pi_pIoObject,  (UCHAR)l_TotalSize );
  56
  57         /* Check allocation */
  58         if ( l_pErrorLogEntry != NULL)
  59         { /* OK */
  60
  61                 /* Data item index */
  62                 USHORT l_nDataItem ;
  63
  64                 /* Set the error log entry header */
  65                 l_pErrorLogEntry->ErrorCode                     = pi_ErrorCode;
  66                 l_pErrorLogEntry->DumpDataSize          = (USHORT) (pi_nDataItems*sizeof(ULONG));
  67                 l_pErrorLogEntry->SequenceNumber        = 0;
  68                 l_pErrorLogEntry->MajorFunctionCode = 0;
  69                 l_pErrorLogEntry->IoControlCode         = 0;
  70                 l_pErrorLogEntry->RetryCount            = 0;
  71                 l_pErrorLogEntry->UniqueErrorValue      = pi_UniqueErrorCode;
  72                 l_pErrorLogEntry->FinalStatus           = pi_FinalStatus;
  73
  74                 /* Insert the data items */
  75                 for (l_nDataItem = 0; l_nDataItem < pi_nDataItems; l_nDataItem++)
  76                 { /* Inset a data item */
  77
  78                         /* Current data item */
  79                         int l_CurDataItem ;
  80
  81                         /* Get next data item */
  82                         l_CurDataItem = va_arg( l_Argptr, int);
  83
  84                         /* Put it into the data array */
  85                         l_pErrorLogEntry->DumpData[l_nDataItem] = l_CurDataItem ;
  86
  87                 } /* Inset a data item */
  88
  89                 /* add insertion string */
  90                 if (pi_InsertionStr) {
  91                         char *ptr;
  92                         int sz = min( l_TotalSize - l_PktSize, l_Size );
  93                         l_pErrorLogEntry->NumberOfStrings = 1;
  94                         l_pErrorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET) + l_pErrorLogEntry->DumpDataSize;
  95                         ptr = (char*)l_pErrorLogEntry + l_pErrorLogEntry->StringOffset;
  96                         memcpy( ptr, pi_InsertionStr, sz );
  97                         *(WCHAR*)&ptr[sz - 2] = (WCHAR)0;
  98                 }
  99
 100                 /* Write the packet */
 101                 IoWriteErrorLogEntry(l_pErrorLogEntry);
 102
 103         } /* OK */
 104
 105         /* Term the variable argument list */
 106         va_end(l_Argptr);
 107
 108 } /* WriteEventLogEntry */
 109
 110 // bsize is to be a strlen(src)
 111 // dest has to have enough place, i.e at least (2*strlen(src) + 2)
 112 void __ansi_to_wchar( USHORT *dest, UCHAR *src, int bsize)
 113 {
 114         int i;
 115
 116         for (i=0; i<bsize; ++i)
 117                 *dest++ = *src++;
 118         *dest = 0;
 119 }
 120
 121 VOID
 122 mlx4_err(
 123         IN struct mlx4_dev *    mdev,
 124         IN char*                                format,
 125         ...
 126         )
 127 {
 128         va_list         list;
 129         UCHAR           buf[MAX_BUFFER_SIZE];
 130         WCHAR           wbuf[MAX_BUFFER_SIZE];
 131
 132         // print to Debugger
 133         va_start(list, format);
 134         buf[MAX_BUFFER_SIZE - 1] = '\0';
 135         if (RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list))
 136                 return;
 137         DbgPrint( (char*)buf );
 138         va_end(list);
 139
 140         // print to Event Log
 141         // print to Event Log
 142         __ansi_to_wchar( wbuf, buf, (int)strlen((void*)buf) );
 143         WriteEventLogEntryStr( mdev->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 );
 144 }
 145
 146 VOID
 147 mlx4_dbg(
 148         IN struct mlx4_dev *    mdev,
 149         IN char*                                format,
 150         ...
 151         )
 152 {
 153 #if DBG
 154         va_list         list;
 155         UCHAR           buf[MAX_BUFFER_SIZE];
 156         UNUSED_PARAM(mdev);
 157
 158         // print to Debugger
 159         va_start(list, format);
 160         buf[MAX_BUFFER_SIZE - 1] = '\0';
 161         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 162         DbgPrint( (char*)buf );
 163         va_end(list);
 164 #else
 165         UNUSED_PARAM(mdev);
 166         UNUSED_PARAM(format);
 167 #endif //DBG
 168 }
 169
 170 VOID
 171 dev_err(
 172         IN struct mlx4_dev **   mdev,
 173         IN char*                                format,
 174         ...
 175         )
 176 {
 177         va_list         list;
 178         UCHAR           buf[MAX_BUFFER_SIZE];
 179         WCHAR           wbuf[MAX_BUFFER_SIZE];
 180
 181         // print to Debugger
 182         va_start(list, format);
 183         buf[MAX_BUFFER_SIZE - 1] = '\0';
 184         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 185         DbgPrint( (char*)buf );
 186         va_end(list);
 187
 188         // print to Event Log
 189         RtlStringCchPrintfW(wbuf, sizeof(wbuf)/sizeof(wbuf[0]), L"%S", buf);
 190         WriteEventLogEntryStr( (*mdev)->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 );
 191 }
 192
 193 VOID
 194 dev_info(
 195         IN struct mlx4_dev **   p_mdev,
 196         IN char*                                format,
 197         ...
 198         )
 199 {
 200 #if DBG
 201         va_list         list;
 202         UCHAR           buf[MAX_BUFFER_SIZE];
 203         UNUSED_PARAM(p_mdev);
 204
 205         // print to Debugger
 206         va_start(list, format);
 207         buf[MAX_BUFFER_SIZE - 1] = '\0';
 208         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 209         DbgPrint( (char*)buf );
 210         va_end(list);
 211 #else
 212         UNUSED_PARAM(p_mdev);
 213         UNUSED_PARAM(format);
 214 #endif
 215 }
 216
 217
 218