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
 111 VOID
 112 mlx4_err(
 113         IN struct mlx4_dev *    mdev,
 114         IN char*                                format,
 115         ...
 116         )
 117 {
 118         va_list         list;
 119         UCHAR           buf[MAX_BUFFER_SIZE];
 120         WCHAR           wbuf[MAX_BUFFER_SIZE];
 121
 122         // print to Debugger
 123         va_start(list, format);
 124         buf[MAX_BUFFER_SIZE - 1] = '\0';
 125         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 126         DbgPrint( (char*)buf );
 127         va_end(list);
 128
 129         // print to Event Log
 130         if (!RtlStringCchPrintfW(wbuf, sizeof(wbuf)/sizeof(wbuf[0]), L"%S", buf))
 131                 WriteEventLogEntryStr( mdev->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 );
 132 }
 133
 134 VOID
 135 mlx4_dbg(
 136         IN struct mlx4_dev *    mdev,
 137         IN char*                                format,
 138         ...
 139         )
 140 {
 141 #if DBG
 142         va_list         list;
 143         UCHAR           buf[MAX_BUFFER_SIZE];
 144         UNUSED_PARAM(mdev);
 145
 146         // print to Debugger
 147         va_start(list, format);
 148         buf[MAX_BUFFER_SIZE - 1] = '\0';
 149         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 150         DbgPrint( (char*)buf );
 151         va_end(list);
 152 #else
 153         UNUSED_PARAM(mdev);
 154         UNUSED_PARAM(format);
 155 #endif //DBG
 156 }
 157
 158 VOID
 159 dev_err(
 160         IN struct mlx4_dev **   mdev,
 161         IN char*                                format,
 162         ...
 163         )
 164 {
 165         va_list         list;
 166         UCHAR           buf[MAX_BUFFER_SIZE];
 167         WCHAR           wbuf[MAX_BUFFER_SIZE];
 168
 169         // print to Debugger
 170         va_start(list, format);
 171         buf[MAX_BUFFER_SIZE - 1] = '\0';
 172         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 173         DbgPrint( (char*)buf );
 174         va_end(list);
 175
 176         // print to Event Log
 177         RtlStringCchPrintfW(wbuf, sizeof(wbuf)/sizeof(wbuf[0]), L"%S", buf);
 178         WriteEventLogEntryStr( (*mdev)->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 );
 179 }
 180
 181 VOID
 182 dev_info(
 183         IN struct mlx4_dev **   p_mdev,
 184         IN char*                                format,
 185         ...
 186         )
 187 {
 188 #if DBG
 189         va_list         list;
 190         UCHAR           buf[MAX_BUFFER_SIZE];
 191         UNUSED_PARAM(p_mdev);
 192
 193         // print to Debugger
 194         va_start(list, format);
 195         buf[MAX_BUFFER_SIZE - 1] = '\0';
 196         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
 197         DbgPrint( (char*)buf );
 198         va_end(list);
 199 #else
 200         UNUSED_PARAM(p_mdev);
 201         UNUSED_PARAM(format);
 202 #endif
 203 }
 204
 205
 206