wd_log.c

WinDriver目录下的源码

/* Copyright (C) Jungo 2003 - 2005 */

#ifdef WDLOG
#undef WDLOG
#endif

#include "windrvr.h"
#include <stdio.h>
#if defined(LINUX) || defined(SOLARIS) 
#include <stdarg.h>
#endif 
FILE *fpWdLog;

#define STR(s) ((s) ? (s) : "(null)")

static int print_ioctl_data(DWORD dwIoctl, PVOID src, DWORD src_bytes);

DWORD DLLCALLCONV WD_LogStart(const char *sFileName, const char *sMode)
{
    if (!sMode)
        sMode = "w";
    fpWdLog = fopen(sFileName, sMode);
    if (!fpWdLog)
        return WD_SYSTEM_INTERNAL_ERROR;
    return WD_STATUS_SUCCESS;
}

VOID DLLCALLCONV WD_LogStop()
{
    if (fpWdLog)
        fclose(fpWdLog);
    fpWdLog = NULL;
}

DWORD DLLCALLCONV WdFunctionLog(DWORD dwIoctl, HANDLE h, PVOID pParam,
    DWORD dwSize, BOOL fWait)
{
    DWORD rc;
    /* don't log debug messages - too messy */
    DWORD skip = (dwIoctl == IOCTL_WD_DEBUG_ADD); 
    
    if (fpWdLog && !skip)
    {
        fprintf(fpWdLog, "\nLogging ioctl %x (%x), handle %p, size %lx\n",
            (UINT32)dwIoctl, WD_CTL_DECODE((UINT32)dwIoctl), h, dwSize);
        print_ioctl_data(dwIoctl, pParam, dwSize);
    }
    
    rc = WD_FUNCTION_LOCAL(dwIoctl, h, pParam, dwSize, fWait);

    if (fpWdLog && !skip)
    {
        fprintf(fpWdLog, "ioctl %x (%x) returned status %lx\n",
            (UINT32)dwIoctl, WD_CTL_DECODE((UINT32)dwIoctl), rc);
        print_ioctl_data(dwIoctl, pParam, dwSize);
    }
    return rc;
}

HANDLE DLLCALLCONV WD_OpenLog(void)
{
    HANDLE hWD = WD_Open();
    if (fpWdLog)
        fprintf(fpWdLog, "WD_Open() returned %p\n", hWD);
    return hWD;
}

void DLLCALLCONV WD_CloseLog(HANDLE hWD)
{
    WD_Close(hWD);
    if (fpWdLog)
        fprintf(fpWdLog, "WD_Close() called for handle %p\n", hWD);
}

VOID DLLCALLCONV WD_LogAdd(const char *sFormat, ...)
{
    va_list ap;
    
    if (!fpWdLog)
        return;

    va_start(ap, sFormat);
    vfprintf(fpWdLog, sFormat, ap);
    va_end(ap);
}

static VOID WD_LogAddIdented(int ident, const char *sFormat, ...)
{
    va_list ap;

    if (!fpWdLog)
        return;

    va_start(ap, sFormat);
    for (; ident>0; ident--)
    {
        fprintf(fpWdLog, "  ");
    }
    vfprintf(fpWdLog, sFormat, ap);
    va_end(ap);
}


#define LOG WD_LogAddIdented

static void log_hexbuf(PVOID src, DWORD src_bytes, int ident)
{
    DWORD i;

    LOG(ident, "0x ");
    for(i=0; i<src_bytes; i++)
        LOG(0, "%02x ", ((BYTE *)src)[i]);
    LOG(0, "\n");
}

static void log_WD_PCI_ID(WD_PCI_ID *p, int ident)
{
    LOG(ident, "WD_PCI_ID:\n");
    LOG(ident+1, "dwVendorId=%lx, dwDeviceId=%lx\n", p->dwVendorId, p->dwDeviceId);
}

static void log_WD_PCI_SLOT(WD_PCI_SLOT *p, int ident)
{
    LOG(ident, "WD_PCI_SLOT:\n");
    LOG(ident+1, "dwBus=%lx, dwSlot=%lx, dwFunction=%lx\n", p->dwBus, p->dwSlot, p->dwFunction);
}

static void log_WD_USB_ID(WD_USB_ID *p, int ident)
{
    LOG(ident, "WD_USB_ID:\n");
    LOG(ident+1, "dwVendorId=%lx, dwProductId=%lx\n", p->dwVendorId, p->dwProductId);
}

static void log_WD_PCMCIA_ID(WD_PCMCIA_ID *p, int ident)
{
    LOG(ident, "WD_PCMCIA_ID:\n");
    LOG(ident+1, "wManufacturerId=%04hx, wCardId=%04hx\n", p->wManufacturerId, p->wCardId);
}

static void log_WD_PCMCIA_SLOT(WD_PCMCIA_SLOT *p, int ident)
{
    LOG(ident, "WD_PCMCIA_SLOT:\n");
    LOG(ident+1, "uBus=%x, uSocket=%x, uFunction=%x\n", (UINT32)p->uBus, (UINT32)p->uSocket, (UINT32)p->uFunction);
}

static void log_WDU_MATCH_TABLE(WDU_MATCH_TABLE *p, int ident)
{
    LOG(ident, "WDU_MATCH_TABLE:\n");
    LOG(ident+1, "wVendorId=%hx, wProductId=%hx, bDeviceClass=%x, bDeviceSubClass=%x\n",
        p->wVendorId, p->wProductId, (UINT32)p->bDeviceClass, (UINT32)p->bDeviceSubClass);
    LOG(ident+1, "bInterfaceClass=%x, bInterfaceSubClass=%x, bInterfaceProtocol=%x\n",
        (UINT32)p->bInterfaceClass, (UINT32)p->bInterfaceSubClass, (UINT32)p->bInterfaceProtocol);
}

static void log_WD_ITEMS(WD_ITEMS *p, int ident)
{
    LOG(ident, "WD_ITEMS:\n");
    LOG(ident+1, "item=%lx, fNotSharable=%lx, dwContext=%lx, dwOptions=%lx\n", 
        p->item, p->fNotSharable, p->dwContext, p->dwOptions);

    switch(p->item)
    {
    case ITEM_INTERRUPT:
        LOG(ident+1, "union I <ITEM_INTERRUPT>:\n");
        LOG(ident+2, "dwInterrupt=%lx, dwOptions=%lx, hInterrupt=%lx\n",
            p->I.Int.dwInterrupt, p->I.Int.dwOptions, p->I.Int.hInterrupt);
        break;

    case ITEM_MEMORY:
        LOG(ident+1, "union I <ITEM_MEMORY>:\n");
#if defined(KERNEL_64BIT)
        LOG(ident+2, "dwPhysicalAddr=%lx, dwBytes=%lx, dwTransAddr=%x:%x, dwUserDirectAddr=%lx, "
            "dwCpuPhysicalAddr=%lx, dwBar=%lx\n",
            p->I.Mem.dwPhysicalAddr, p->I.Mem.dwBytes, 
            (UINT32)(p->I.Mem.dwTransAddr>>32), (UINT32)p->I.Mem.dwTransAddr, 
            p->I.Mem.dwUserDirectAddr, p->I.Mem.dwCpuPhysicalAddr, p->I.Mem.dwBar);
#else
        LOG(ident+2, "dwPhysicalAddr=%lx, dwBytes=%lx, dwTransAddr=%lx, dwUserDirectAddr=%lx, "
            "dwCpuPhysicalAddr=%lx, dwBar=%lx\n",
            p->I.Mem.dwPhysicalAddr, p->I.Mem.dwBytes, p->I.Mem.dwTransAddr,  
            p->I.Mem.dwUserDirectAddr, p->I.Mem.dwCpuPhysicalAddr, p->I.Mem.dwBar);
#endif
        break;

    case ITEM_IO:
        LOG(ident+1, "union I <ITEM_IO>:\n");
#if defined(KERNEL_64BIT)
        LOG(ident+2, "dwAddr=%x:%x, dwBytes=%lx, dwBar=%lx\n", 
            (UINT32)(p->I.IO.dwAddr>>32), (UINT32)(p->I.IO.dwAddr), 
            p->I.IO.dwBytes, p->I.IO.dwBar);
#else
        LOG(ident+2, "dwAddr=%lx, dwBytes=%lx, dwBar=%lx\n", p->I.IO.dwAddr, p->I.IO.dwBytes, p->I.IO.dwBar);
#endif
        break;
        
    case ITEM_BUS:
        LOG(ident+1, "union I <ITEM_BUS>:\n");
        LOG(ident+2, "dwBusType=%lx, dwBusNum=%lx, dwSlotFunc=%lx\n",
            p->I.Bus.dwBusType, p->I.Bus.dwBusNum, p->I.Bus.dwSlotFunc);
        break;

    case ITEM_NONE:
    default:
        LOG(ident+1, "union I <ITEM_NONE>:\n");
        log_hexbuf(&p->I, sizeof(p->I), ident+2);
        break;
    }
}

static void log_WD_CARD(WD_CARD *p, int ident)
{
    DWORD i;
    LOG(ident, "WD_CARD:\n");
    LOG(ident+1, "dwItems=%lx\n", p->dwItems);
    for (i=0; i<p->dwItems; i++)
    {
        LOG(ident+1, "[%lx]", i);
        log_WD_ITEMS(&p->Item[i], ident+1);
    }
}

static void log_WD_TRANSFER(WD_TRANSFER *p, int ident)
{
    LOG(ident, "WD_TRANSFER:\n");
#if defined(KERNEL_64BIT)
    LOG(ident+1, "dwPort=%x:%x, cmdTrans=%lx, dwBytes=%lx, fAutoinc=%lx, dwOptions=%lx\n", 
        (UINT32)(p->dwPort>>32), (UINT32)(p->dwPort), p->cmdTrans, p->dwBytes, p->fAutoinc, p->dwOptions);
#else
    LOG(ident+1, "dwPort=%lx, cmdTrans=%lx, dwBytes=%lx, fAutoinc=%lx, dwOptions=%lx\n", 
        p->dwPort, p->cmdTrans, p->dwBytes, p->fAutoinc, p->dwOptions);
#endif
    LOG(ident+1, "Data=");
    log_hexbuf(&p->Data, sizeof(p->Data), 0);
}

static void log_WD_CLEANUP_SETUP(WD_CARD_CLEANUP *p, int ident)
{
    DWORD i;
    LOG(ident, "WD_CLEANUP_SETUP:\n");
    LOG(ident+1, "hCard=%lx, dwOptions=%lx, dwCmds=%lx\n",
        p->hCard, p->dwOptions, p->dwCmds);
    for (i=0; i<p->dwCmds; i++)
    {
        LOG(ident+1, "[%lx]", i);
        log_WD_TRANSFER(&p->Cmd[i], ident+1);
    }
}

static void log_WD_DMA_PAGE(WD_DMA_PAGE *p, int ident)
{
    LOG(ident, "WD_DMA_PAGE:\n");
#if defined(KERNEL_64BIT)
    LOG(ident+1, "pPhysicalAddr=%x:%x, dwBytes=%lx\n", 
        (UINT32)(p->pPhysicalAddr>>32), (UINT32)(p->pPhysicalAddr), p->dwBytes);
#else
    LOG(ident+1, "pPhysicalAddr=%lx, dwBytes=%lx\n", p->pPhysicalAddr, p->dwBytes);
#endif
}

static void log_WD_KERNEL_PLUGIN_CALL(WD_KERNEL_PLUGIN_CALL *p, int ident)
{
    LOG(ident, "WD_KERNEL_PLUGIN_CALL:\n");
    LOG(ident+1, "hKernelPlugIn=%lx, dwMessage=%lx, pData=%p, dwResult=%lx\n", 
        p->hKernelPlugIn, p->dwMessage, p->pData, p->dwResult);
}

static void log_WD_ISAPNP_CARD_ID(WD_ISAPNP_CARD_ID *p, int ident)
{
    LOG(ident, "WD_ISAPNP_CARD_ID:\n");
    LOG(ident+1, "cVendor=%s, dwSerial=%lx\n", STR(p->cVendor), p->dwSerial);
}

static void log_WD_ISAPNP_CARD(WD_ISAPNP_CARD *p, int ident)
{
    LOG(ident, "WD_ISAPNP_CARD:\n");
    log_WD_ISAPNP_CARD_ID(&p->cardId, ident+1); 
    LOG(ident+1, "dwLogicalDevices=%lx, bPnPVersionMajor=%lx, bPnPVersionMinor=%lx, "
        "bVendorVersionMajor=%lx, bVendorVersionMinor=%lx\n",
        p->dwLogicalDevices, (DWORD)p->bPnPVersionMajor, (UINT32)p->bPnPVersionMinor,
        (DWORD)p->bVendorVersionMajor, (DWORD)p->bVendorVersionMinor);
    LOG(ident+1, "cIdent=%s\n", STR(p->cIdent));
}

#define INIT_STRUCT_LOG(s_type) \
        s_type *p = (s_type *)src; \
        LOG(ident, #s_type "\n");

static int print_ioctl_data(DWORD dwIoctl, PVOID src, DWORD src_bytes)
{
    DWORD i;
    int ident = 0;

    switch (dwIoctl)
    {
    case IOCTL_WD_CARD_REGISTER:
    case IOCTL_WD_CARD_UNREGISTER:
    {
        INIT_STRUCT_LOG(WD_CARD_REGISTER);
        log_WD_CARD(&p->Card, ident+1);
        LOG(ident+1, "fCheckLockOnly=%lx, hCard=%lx, dwOptions=%lx\n", p->fCheckLockOnly, p->hCard, p->dwOptions);
        LOG(ident+1, "cName=%s\n", STR(p->cName));
        LOG(ident+1, "cDescription=%s\n", STR(p->cDescription));
        break;
    }