trace.c

这个是一个开源项目, 有能力的人可以一起来写

    SysLog(pDrvObj, GetExceptionCode(), L"AnsiStrVaFormat EXCEPTION");
    *pSize = oldSize;
    return pDestStr;
  }
}

PCHAR AnsiStrFormat(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PCHAR pFmt,
    ...)
{
  va_list va;

  va_start(va, pFmt);
  pDestStr = AnsiStrVaFormat(pDestStr, pSize, pFmt, va);
  va_end(va);

  return pDestStr;
}
/********************************************************************/

PCHAR code2name(
    IN ULONG code,
    IN PCODE2NAME pTable)
{
  if (!pTable)
    return NULL;

  while (pTable->name) {
    if (pTable->code == code)
      return pTable->name;
    pTable++;
  }

  return NULL;
}

PCHAR AnsiStrCopyCode(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN ULONG code,
    IN PCODE2NAME pTable,
    IN PCHAR pPref,
    IN ULONG base)
{
  PCHAR pStr;

  pStr = code2name(code, pTable);

  if (pStr) {
    pDestStr = AnsiStrCopyStr(pDestStr, pSize, pStr);
  } else {
    if (pPref)
      pDestStr = AnsiStrCopyStr(pDestStr, pSize, pPref);
    pDestStr = AnsiStrCopyNum(pDestStr, pSize, code, base, 0);
  }

  return pDestStr;
}

PCHAR AnsiStrCopyMask(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PCODE2NAME pTable,
    IN ULONG mask)
{
  ULONG b, unknown;
  int count;

  pDestStr = AnsiStrCopyStr(pDestStr, pSize, "[");

  unknown = 0;
  count = 0;

  for (b = 1 ; b ; b <<= 1) {
    if ((mask & b) != 0) {
      PCHAR pStr;

      pStr = code2name(b, pTable);

      if (pStr) {
        if (count)
          pDestStr = AnsiStrCopyStr(pDestStr, pSize, "|");
        pDestStr = AnsiStrCopyStr(pDestStr, pSize, pStr);
        count++;
      } else {
        unknown |= b;
      }
    }
  }

  if (unknown) {
    if (count)
      pDestStr = AnsiStrCopyStr(pDestStr, pSize, "|");
    pDestStr = AnsiStrFormat(pDestStr, pSize, "0x%lX", (long)unknown);
  }

  return AnsiStrCopyStr(pDestStr, pSize, "]");
}

PCHAR AnsiStrCopyFields(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PFIELD2NAME pTable,
    IN ULONG mask)
{
  int count = 0;

  pDestStr = AnsiStrCopyStr(pDestStr, pSize, "[");

  if (pTable) {
    while (pTable->name) {
      ULONG m = (mask & pTable->mask);

      if (m == pTable->code) {
        mask &= ~pTable->mask;
        if (count)
          pDestStr = AnsiStrCopyStr(pDestStr, pSize, "|");
        pDestStr = AnsiStrCopyStr(pDestStr, pSize, pTable->name);
        count++;
      }
      pTable++;
    }
  }

  if (mask) {
    if (count)
      pDestStr = AnsiStrCopyStr(pDestStr, pSize, "|");
    pDestStr = AnsiStrFormat(pDestStr, pSize, "0x%lX", (long)mask);
  }

  return AnsiStrCopyStr(pDestStr, pSize, "]");
}

PCHAR AnsiStrCopyDump(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PVOID pData,
    IN SIZE_T length)
{
#define DUMP_MAX 16
  CHAR bufA[DUMP_MAX + 1];
  SIZE_T i;

  pDestStr = AnsiStrFormat(pDestStr, pSize, "%lu:", (long)length);

  for (i = 0 ; i < length && i < DUMP_MAX ; i++) {
    UCHAR c = *(((PUCHAR)pData) + i);

    bufA[i] = (CHAR)((c >= 0x20 && c < 0x7F) ? c : '.');

    pDestStr = AnsiStrFormat(pDestStr, pSize, " %02X", (int)c);
  }

  bufA[i] = 0;

  return AnsiStrFormat(pDestStr, pSize, " * %s *", bufA);
}
/********************************************************************/

PCHAR AnsiStrCopyHead(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PC0C_COMMON_EXTENSION pDevExt,
    IN PCHAR pHead)
{
  if (pDevExt) {
    pDestStr = AnsiStrFormat(pDestStr, pSize, "%S/", pDevExt->portName);
    pDestStr = AnsiStrCopyCode(pDestStr, pSize, pDevExt->doType, codeNameTableDoType, NULL, 10);
  }
  if (pHead)
    pDestStr = AnsiStrFormat(pDestStr, pSize, pDevExt ? " %s" : "%s", pHead);

  return pDestStr;
}

PCHAR AnsiStrCopyHandFlow(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_HANDFLOW pHandFlow)
{
  pDestStr = AnsiStrCopyStr(pDestStr, pSize, " Hand");
  pDestStr = AnsiStrCopyFields(pDestStr, pSize,
      codeNameTableControlHandShake,
      pHandFlow->ControlHandShake);

  pDestStr = AnsiStrCopyStr(pDestStr, pSize, " Flow");
  pDestStr = AnsiStrCopyFields(pDestStr, pSize,
      codeNameTableFlowReplace,
      pHandFlow->FlowReplace);

  pDestStr = AnsiStrFormat(pDestStr, pSize, " XonLim=%lu XoffLim=%lu",
      (long)pHandFlow->XonLimit, (long)pHandFlow->XoffLimit);

  return pDestStr;
}

PCHAR AnsiStrCopyTimeouts(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_TIMEOUTS pTimeouts)
{
  return AnsiStrFormat(pDestStr, pSize,
      " Read[Interval=%lu Multiplier=%lu Constant=%lu]"
      " Write[Multiplier=%lu Constant=%lu]",
      (long)pTimeouts->ReadIntervalTimeout,
      (long)pTimeouts->ReadTotalTimeoutMultiplier,
      (long)pTimeouts->ReadTotalTimeoutConstant,
      (long)pTimeouts->WriteTotalTimeoutMultiplier,
      (long)pTimeouts->WriteTotalTimeoutConstant);
}

PCHAR AnsiStrCopyChars(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_CHARS pChars)
{
  return AnsiStrFormat(pDestStr, pSize,
      " EofChar=0x%X ErrorChar=0x%X BreakChar=0x%X"
      " EventChar=0x%X XonChar=0x%X XoffChar=0x%X",
      (int)pChars->EofChar, (int)pChars->ErrorChar, (int)pChars->BreakChar,
      (int)pChars->EventChar, (int)pChars->XonChar, (int)pChars->XoffChar);
}

PCHAR AnsiStrCopyLineControl(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_LINE_CONTROL pLineControl)
{
  return AnsiStrFormat(pDestStr, pSize,
      " StopBits=%u Parity=%u WordLength=%u",
      (int)pLineControl->StopBits,
      (int)pLineControl->Parity,
      (int)pLineControl->WordLength);
}

PCHAR AnsiStrCopyBaudRate(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_BAUD_RATE pBaudRate)
{
  return AnsiStrFormat(pDestStr, pSize, " BaudRate=%lu", (long)pBaudRate->BaudRate);
}

PCHAR AnsiStrCopyQueueSize(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_QUEUE_SIZE pQueueSize)
{
  return AnsiStrFormat(pDestStr, pSize,
      " InSize=%lu OutSize=%lu",
      (long)pQueueSize->InSize, (long)pQueueSize->OutSize);
}

PCHAR AnsiStrCopyCommStatus(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIAL_STATUS pCommStatus)
{
  pDestStr = AnsiStrCopyStr(pDestStr, pSize, " {");

  if (pCommStatus->Errors) {
    pDestStr = AnsiStrCopyStr(pDestStr, pSize, " Errors");
    pDestStr = AnsiStrCopyMask(pDestStr, pSize,
        codeNameTableErrors, pCommStatus->Errors);
  }

  if (pCommStatus->HoldReasons) {
    pDestStr = AnsiStrCopyStr(pDestStr, pSize, " HoldReasons");
    pDestStr = AnsiStrCopyMask(pDestStr, pSize,
        codeNameTableHoldReasons, pCommStatus->HoldReasons);
  }

  if (pCommStatus->WaitForImmediate)
    pDestStr = AnsiStrCopyStr(pDestStr, pSize, " WaitForImmediate=TRUE");

  if (pCommStatus->AmountInInQueue)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " AmountInInQueue=%lu", (long)pCommStatus->AmountInInQueue);

  if (pCommStatus->AmountInOutQueue)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " AmountInOutQueue=%lu", (long)pCommStatus->AmountInOutQueue);

  pDestStr = AnsiStrCopyStr(pDestStr, pSize, " }");
  return pDestStr;
}

PCHAR AnsiStrCopyPerfStats(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PSERIALPERF_STATS pPerfStats)
{
  pDestStr = AnsiStrCopyStr(pDestStr, pSize, " {");

  if (pPerfStats->ReceivedCount)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " ReceivedCount=%lu", (long)pPerfStats->ReceivedCount);

  if (pPerfStats->TransmittedCount)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " TransmittedCount=%lu", (long)pPerfStats->TransmittedCount);

  if (pPerfStats->FrameErrorCount)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " FrameErrorCount=%lu", (long)pPerfStats->FrameErrorCount);

  if (pPerfStats->SerialOverrunErrorCount)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " SerialOverrunErrorCount=%lu", (long)pPerfStats->SerialOverrunErrorCount);

  if (pPerfStats->BufferOverrunErrorCount)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " BufferOverrunErrorCount=%lu", (long)pPerfStats->BufferOverrunErrorCount);

  if (pPerfStats->ParityErrorCount)
    pDestStr = AnsiStrFormat(pDestStr, pSize,
        " ParityErrorCount=%lu", (long)pPerfStats->ParityErrorCount);

  pDestStr = AnsiStrCopyStr(pDestStr, pSize, " }");
  return pDestStr;
}
/********************************************************************/

VOID GetTimeFields(PTIME_FIELDS pTimeFields)
{
  LARGE_INTEGER systemTime;

  KeQuerySystemTime(&systemTime);

#ifndef _WDMDDK_
  {
    LARGE_INTEGER localTime;
    ExSystemTimeToLocalTime(&systemTime, &localTime);
    systemTime = localTime;
  }
#else
  #define LOCAL_TIME_SHIFT (3*60*60)
  systemTime.QuadPart += (LONGLONG)(10000)*1000*LOCAL_TIME_SHIFT;
#endif

  RtlTimeToTimeFields(&systemTime, pTimeFields);
}

PCHAR AnsiStrCopyTimeFields(
    PCHAR pDestStr,
    PSIZE_T pSize,
    IN PTIME_FIELDS pTimeFields)
{
  return AnsiStrFormat(pDestStr, pSize,
      "%04u/%02u/%02u %02u:%02u:%02u.%03u",
      (unsigned)pTimeFields->Year,
      (unsigned)pTimeFields->Month,
      (unsigned)pTimeFields->Day,
      (unsigned)pTimeFields->Hour,
      (unsigned)pTimeFields->Minute,
      (unsigned)pTimeFields->Second,
      (unsigned)pTimeFields->Milliseconds);
}
/********************************************************************/

NTSTATUS TraceWrite(
    IN PVOID pIoObject,
    IN HANDLE handle,
    IN PCHAR pStr)
{
  NTSTATUS status;
  ANSI_STRING str;
  IO_STATUS_BLOCK ioStatusBlock;

  RtlInitAnsiString(&str, pStr);

  status = ZwWriteFile(
      handle,
      NULL,
      NULL,
      NULL,
      &ioStatusBlock,
      str.Buffer,
      str.Length,
      NULL,
      NULL);

  if (!NT_SUCCESS(status))
    SysLog(pIoObject, status, L"TraceWrite ZwWriteFile FAIL");

  return status;
}

VOID TraceOutput(
    IN PC0C_COMMON_EXTENSION pDevExt,
    IN PCHAR pStr)
{
  NTSTATUS status;
  PVOID pIoObject;
  HANDLE handle;
  OBJECT_ATTRIBUTES objectAttributes;
  IO_STATUS_BLOCK ioStatusBlock;

  static CHAR strOld[500];
  static LONG strOldBusyInd = 0;
  static LONG strOldFreeInd = 0;

  if (KeGetCurrentIrql() != PASSIVE_LEVEL) {
    SIZE_T size;
    KIRQL oldIrql;
    PCHAR pDestStr;
    TIME_FIELDS timeFields;

    if (!pStr)
      return;

    GetTimeFields(&timeFields);

    KeAcquireSpinLock(&strOldLock, &oldIrql);

    size = sizeof(strOld) - strOldFreeInd;
    pDestStr = strOld + (sizeof(strOld) - size);

    pDestStr = AnsiStrCopyTimeFields(pDestStr, &size, &timeFields);
    pDestStr = AnsiStrFormat(pDestStr, &size, " *%u* %s\r\n", (unsigned)KeGetCurrentIrql(), pStr);
    HALT_UNLESS3(size > 0, strOldFreeInd, strOldBusyInd, sizeof(strOld));

    if (size == 1) {
      pDestStr -= 6;
      size += 6;
      pDestStr = AnsiStrCopyStr(pDestStr, &size, " ...\r\n");
    }

    strOldFreeInd = (LONG)(sizeof(strOld) - size);

    KeReleaseSpinLock(&strOldLock, oldIrql);

    return;
  }

  if (pDevExt)
    pIoObject = pDevExt->pDevObj;
  else
    pIoObject = pDrvObj;

  HALT_UNLESS(TRACE_FILE_OK);
  InitializeObjectAttributes(&objectAttributes, &traceFileName, 0, NULL, NULL);

  status = ZwCreateFile(
      &handle,
      SYNCHRONIZE | FILE_APPEND_DATA,
      &objectAttributes,
      &ioStatusBlock,
      NULL,
      FILE_ATTRIBUTE_NORMAL,
      FILE_SHARE_READ|FILE_SHARE_WRITE,
      FILE_OPEN_IF,
      FILE_SYNCHRONOUS_IO_NONALERT,
      NULL,
      0);

  if (NT_SUCCESS(status)) {
    PTRACE_BUFFER pBuf;

    pBuf = AllocTraceBuf();

    if (pBuf) {
      PCHAR pDestStr;
      SIZE_T size;
      LONG skipped;

      size = TRACE_BUF_SIZE;
      pDestStr = pBuf->buf;

      while (strOldFreeInd) {
        SIZE_T lenBuf;
        KIRQL oldIrql;

        KeAcquireSpinLock(&strOldLock, &oldIrql);
        lenBuf = strOldFreeInd - strOldBusyInd;
        if (lenBuf) {
          if (lenBuf > size - 1)
            lenBuf = size - 1;
          RtlCopyMemory(pDestStr, &strOld[strOldBusyInd], lenBuf);
          pDestStr[lenBuf] = 0;
          strOldBusyInd += (LONG)lenBuf;
          HALT_UNLESS3(strOldBusyInd <= strOldFreeInd, strOldFreeInd, strOldBusyInd, lenBuf);
          if (strOldBusyInd == strOldFreeInd)
            strOldFreeInd = strOldBusyInd = 0;
        }
        KeReleaseSpinLock(&strOldLock, oldIrql);

        if (lenBuf)
          TraceWrite(pIoObject, handle, pBuf->buf);
      }

      skipped = InterlockedExchange(&skippedTraces, 0);

      if (skipped) {
        SIZE_T tmp_size = size;

        AnsiStrFormat(pDestStr, &tmp_size, "*** skipped %lu lines ***\r\n", (long)skipped);
        TraceWrite(pIoObject, handle, pBuf->buf);
      }

      if (pStr) {
        TIME_FIELDS timeFields;

        GetTimeFields(&timeFields);

        pDestStr = AnsiStrCopyTimeFields(pDestStr, &size, &timeFields);
        pDestStr = AnsiStrFormat(pDestStr, &size, " %s\r\n", pStr);