wd_log.c

WinDriver目录下的源码

    case IOCTL_WD_CARD_CLEANUP_SETUP:
    {
        INIT_STRUCT_LOG(WD_CARD_CLEANUP);
        log_WD_CLEANUP_SETUP(p, ident+1);
        break;
    }
    case IOCTL_WD_DEBUG:
    {
        INIT_STRUCT_LOG(WD_DEBUG);
        LOG(ident+1, "dwCmd=%lx, dwLevel=%lx, dwSection=%lx, dwLevelMessageBox=%lx, dwBufferSize=%lx\n",     
            p->dwCmd, p->dwLevel, p->dwSection, p->dwLevelMessageBox, p->dwBufferSize);
        break;
    }
    case IOCTL_WD_DEBUG_ADD:
    {
        INIT_STRUCT_LOG(WD_DEBUG_ADD);
        LOG(ident+1, "pcBuffer=%p, dwLevel=%lx, dwSection=%lx\n", p->pcBuffer, p->dwLevel, p->dwSection);
        break;
    }
    case IOCTL_WD_DEBUG_DUMP:
    {
        INIT_STRUCT_LOG(WD_DEBUG_DUMP);
        LOG(ident+1, "pcBuffer=%p, dwSize=%lx\n", p->pcBuffer, p->dwSize);
        break;
    }
    case IOCTL_WD_DMA_LOCK:
    case IOCTL_WD_DMA_UNLOCK:
    {
        INIT_STRUCT_LOG(WD_DMA);
#if defined(KERNEL_64BIT)
        LOG(ident+1, "hDma=%lx, pUserAddr=%p, pKernelAddr%x:%x\n", p->hDma, p->pUserAddr, 
            (UINT32)(p->pKernelAddr>>32), (UINT32)(p->pKernelAddr));
#else
        LOG(ident+1, "hDma=%lx, pUserAddr=%p, pKernelAddr=%lx\n", p->hDma, p->pUserAddr, p->pKernelAddr);
#endif
        LOG(ident+1, "dwBytes=%lx, dwOptions=%lx, dwPages=%lx, hCard=%lx\n", 
            p->dwBytes, p->dwOptions, p->dwPages, p->hCard);
        if (p->hDma)
        {
            for (i=0; i<p->dwPages; i++)
            {
                LOG(ident+1, "[%lx]", i);
                log_WD_DMA_PAGE(&p->Page[i], ident+1);
            }
        }
        break;
    }
    case IOCTL_WD_EVENT_PULL:
    case IOCTL_WD_EVENT_REGISTER:
    case IOCTL_WD_EVENT_SEND:
    case IOCTL_WD_EVENT_UNREGISTER:
    {
        INIT_STRUCT_LOG(WD_EVENT);
        LOG(ident+1, "handle=%lx, dwAction=%lx, dwStatus=%lx, dwEventId=%lx\n", 
            p->handle, p->dwAction, p->dwStatus, p->dwEventId);
        LOG(ident+1, "dwCardType=%lx, hKernelPlugIn=%lx, dwOptions=%lx\n", 
            p->dwCardType, p->hKernelPlugIn, p->dwOptions);
        if (p->dwCardType == WD_BUS_PCI)
        {
            LOG(ident+1, "union u <WD_BUS_PCI>:\n");
            log_WD_PCI_ID(&p->u.Pci.cardId, ident+2);
            log_WD_PCI_SLOT(&p->u.Pci.pciSlot, ident+2);
        }
        else if (p->dwCardType == WD_BUS_USB)
        {
            LOG(ident+1, "union u <WD_BUS_USB>:\n");
            log_WD_USB_ID(&p->u.Usb.deviceId, ident+2);
            LOG(ident+2, "dwUniqueID=%lx\n", p->u.Usb.dwUniqueID);
        }
        else
            LOG(ident+1, "ERROR: unknown bus type.\n");

        LOG(ident+1, "dwEventVer=%lx, dwNumMatchTables=%lx\n", p->dwEventVer, p->dwNumMatchTables);
        log_WDU_MATCH_TABLE(p->matchTables, ident+1); // pointer to an array of size 1
        break;
    }
    case IOCTL_WD_INT_COUNT:
    case IOCTL_WD_INT_DISABLE:
    case IOCTL_WD_INT_ENABLE:
    case IOCTL_WD_INT_WAIT:
    {
        INIT_STRUCT_LOG(WD_INTERRUPT);
        LOG(ident+1, "hInterrupt=%lx, dwOptions=%lx, dwCmds=%lx\n", p->hInterrupt, p->dwOptions, p->dwCmds);
        for (i=0; i<p->dwCmds; i++)
        {
            LOG(ident+1, "[%lx]", i);
            log_WD_TRANSFER(&p->Cmd[i], ident+1);
        }
        log_WD_KERNEL_PLUGIN_CALL(&p->kpCall, ident+1);
        LOG(ident+1, "fEnableOk=%lx, dwCounter=%lx, dwLost=%lx, fStopped=%lx\n", 
            p->fEnableOk, p->dwCounter, p->dwLost, p->fStopped);
        break;
    }
    case IOCTL_WD_ISAPNP_GET_CARD_INFO:
    {
        INIT_STRUCT_LOG(WD_ISAPNP_CARD_INFO);
        log_WD_ISAPNP_CARD_ID(&p->cardId, ident+1);
        LOG(ident+1, "dwLogicalDevice=%lx, cLogicalDeviceId=%s\n", p->dwLogicalDevice, STR(p->cLogicalDeviceId));
        LOG(ident+1, "dwCompatibleDevices=%lx\n", p->dwCompatibleDevices);
        for (i=0; i<p->dwCompatibleDevices; i++)
        {
            LOG(ident+1, "CompatibleDevice[%lx]=%s\n", i, STR(p->CompatibleDevice[i]));
        }
        LOG(ident+1, "cIdent=%s\n", STR(p->cIdent));
        log_WD_CARD(&p->Card, ident+1);
        break;
    }
    case IOCTL_WD_ISAPNP_SCAN_CARDS:
    {
        INIT_STRUCT_LOG(WD_ISAPNP_SCAN_CARDS);
        log_WD_ISAPNP_CARD_ID(&p->searchId, ident+1);
        LOG(ident+1, "dwCards=%lx\n", p->dwCards);
        for (i=0; i<p->dwCards; i++)
        {
            LOG(ident+1, "[%lx]", i);
            log_WD_ISAPNP_CARD(&p->Card[i], ident+1);
        }
        break;
    }
    case IOCTL_WD_KERNEL_PLUGIN_CALL:
    {
        log_WD_KERNEL_PLUGIN_CALL(src, ident);
        break;
    }
    case IOCTL_WD_KERNEL_PLUGIN_CLOSE:
    case IOCTL_WD_KERNEL_PLUGIN_OPEN:
    {
        INIT_STRUCT_LOG(WD_KERNEL_PLUGIN);
        LOG(ident+1, "hKernelPlugIn=%lx, pcDriverName=%s, pcDriverPath=%s, pOpenData=%p\n",
            p->hKernelPlugIn, STR(p->pcDriverName), STR(p->pcDriverPath), p->pOpenData);
        break;
    }
    case IOCTL_WD_LICENSE:
    {
        INIT_STRUCT_LOG(WD_LICENSE);
        LOG(ident+1, "cLicense=%s, dwLicense=%lx, dwLicense2=%lx\n", STR(p->cLicense), p->dwLicense, p->dwLicense2);
        break;
    }
    case IOCTL_WD_MULTI_TRANSFER:
    {
        WD_TRANSFER *p = src;
        LOG(ident, "WD_MULTI_TRANSFER:\n");
        for (i=0; i<src_bytes / sizeof (WD_TRANSFER); i++)
        {
            LOG(ident+1, "[%lx]", i);
            log_WD_TRANSFER(&p[i], ident+1);
        }
        break;
    }
    case IOCTL_WD_PCI_CONFIG_DUMP:
    {
        INIT_STRUCT_LOG(WD_PCI_CONFIG_DUMP);
        log_WD_PCI_SLOT(&p->pciSlot, ident+1);
        LOG(ident+1, "pBuffer=%p, dwOffset=%lx, dwBytes=%lx, fIsRead=%lx, dwResult=%lx\n", 
            p->pBuffer, p->dwOffset, p->dwBytes, p->fIsRead, p->dwResult);
        break;
    }
    case IOCTL_WD_PCI_GET_CARD_INFO:
    {
        INIT_STRUCT_LOG(WD_PCI_CARD_INFO);
        log_WD_PCI_SLOT(&p->pciSlot, ident+1);
        log_WD_CARD(&p->Card, ident+1);
        break;
    }
    case IOCTL_WD_PCI_SCAN_CARDS:
    {
        INIT_STRUCT_LOG(WD_PCI_SCAN_CARDS);
        LOG(ident+1, "searchId.dwVendorId=%lx, searchId.dwDeviceId=%lx\n",
            p->searchId.dwVendorId, p->searchId.dwDeviceId);
        LOG(ident+1, "dwCards=%lx\n", p->dwCards);
        for (i=0; i<p->dwCards; i++)
        {
            LOG(ident+1, "[%lx]", i);
            log_WD_PCI_ID(&p->cardId[i], ident+1);
            LOG(ident+1, "[%lx]", i);
            log_WD_PCI_SLOT(&p->cardSlot[i], ident+1);
        }
        break;
    }
    case IOCTL_WD_PCMCIA_CONFIG_DUMP:
    {
        INIT_STRUCT_LOG(WD_PCMCIA_CONFIG_DUMP);
        log_WD_PCMCIA_SLOT(&p->pcmciaSlot, ident+1);
        LOG(ident+1, "pBuffer=%p, dwOffset=%lx, dwBytes=%lx, fIsRead=%lx, dwResult=%lx, dwOptions=%lx\n",
            p->pBuffer, p->dwOffset, p->dwBytes, p->fIsRead, p->dwResult, p->dwOptions);
        break;
    }
    case IOCTL_WD_PCMCIA_GET_CARD_INFO:
    {
        INIT_STRUCT_LOG(WD_PCMCIA_CARD_INFO);
        log_WD_PCMCIA_SLOT(&p->pcmciaSlot, ident+1);
        log_WD_CARD(&p->Card, ident+1);
        LOG(ident+1, "cVersion=%s, cManufacturer=%s, cProductName=%s\n", 
            STR(p->cVersion), STR(p->cManufacturer), STR(p->cProductName));
        LOG(ident+1, "wManufacturerId=%04hx, wCardId=%04hx, wFuncId=%04hx, dwOptions=%lx\n", 
            p->wManufacturerId, p->wCardId, p->wFuncId, p->dwOptions);
        break;
    }
    case IOCTL_WD_PCMCIA_SCAN_CARDS:
    {
        INIT_STRUCT_LOG(WD_PCMCIA_SCAN_CARDS);
        LOG(ident+1, "searchId.wManufacturerId=%04hx, searchId.wCardId=%04hx\n", 
            p->searchId.wManufacturerId, p->searchId.wCardId);
        LOG(ident+1, "dwCards=%lx, dwOptions=%lx\n", p->dwCards, p->dwOptions);
        for (i=0; i<p->dwCards; i++)
        {
            LOG(ident+1, "[%lx]", i);
            log_WD_PCMCIA_ID(&p->cardId[i], ident+1);
            LOG(ident+1, "[%lx]", i);
            log_WD_PCMCIA_SLOT(&p->cardSlot[i], ident+1);
        }
        break;
    }
    case IOCTL_WD_SLEEP:
    {
        INIT_STRUCT_LOG(WD_SLEEP);
        LOG(ident+1, "dwMicroSeconds=%lx, dwOptions=%lx\n", p->dwMicroSeconds, p->dwOptions);
        break;
    }
    case IOCTL_WD_TRANSFER:
    {
        INIT_STRUCT_LOG(WD_TRANSFER);
        log_WD_TRANSFER(p, ident+1);
        break;
    }
    case IOCTL_WD_USAGE:
    {
        INIT_STRUCT_LOG(WD_USAGE);
        LOG(ident+1, "applications_num=%lx, devices_num=%lx\n", p->applications_num, p->devices_num);
        break;
    }
    case IOCTL_WD_VERSION:
    {
        INIT_STRUCT_LOG(WD_VERSION);
        LOG(ident+1, "dwVer=%lx, cVer=%s\n", p->dwVer, STR(p->cVer));
        break;
    }
    case IOCTL_WD_WATCH_PCI_START:
    case IOCTL_WD_WATCH_PCI_STOP:
    {
        INIT_STRUCT_LOG(WD_HS_WATCH);
        LOG(ident+1, "handle=%lx\n", p->handle);
        break;
    }
    case IOCTL_WDU_GET_DEVICE_DATA:
    {
        INIT_STRUCT_LOG(WDU_GET_DEVICE_DATA);
        LOG(ident+1, "dwUniqueID=%lx, pBuf=%p, dwBytes=%lx, dwOptions=%lx\n", 
            p->dwUniqueID, p->pBuf, p->dwBytes, p->dwOptions);
        break;
    }
    case IOCTL_WDU_SET_INTERFACE:
    {
        INIT_STRUCT_LOG(WDU_SET_INTERFACE);
        LOG(ident+1, "dwUniqueID=%lx, dwInterfaceNum=%lx, dwAlternateSetting=%lx, dwOptions=%lx\n", 
            p->dwUniqueID, p->dwInterfaceNum, p->dwAlternateSetting, p->dwOptions);
        break;
    }
    case IOCTL_WDU_RESET_PIPE:
    {
        INIT_STRUCT_LOG(WDU_RESET_PIPE);
        LOG(ident+1, "dwUniqueID=%lx, dwPipeNum=%lx, dwOptions=%lx\n", 
            p->dwUniqueID, p->dwPipeNum, p->dwOptions);
        break;
    }
    case IOCTL_WDU_TRANSFER:
    {
        INIT_STRUCT_LOG(WDU_TRANSFER);
        LOG(ident+1, "dwUniqueID=%lx, dwPipeNum=%lx, fRead=%lx, dwOptions=%lx\n", 
            p->dwUniqueID, p->dwPipeNum, p->fRead, p->dwOptions);
        LOG(ident+1, "pBuffer=%p, dwBufferSize=%lx, dwBytesTransferred=%lx, dwTimeout=%lx\n", 
            p->pBuffer, p->dwBufferSize, p->dwBytesTransferred, p->dwTimeout);
        log_hexbuf(p->SetupPacket, sizeof(p->SetupPacket), ident+1);
        break;
    }

    case IOCTL_WDU_HALT_TRANSFER:
    {
        INIT_STRUCT_LOG(WDU_HALT_TRANSFER);
        LOG(ident+1, "dwUniqueID=%lx, dwPipeNum=%lx, dwOptions=%lx\n", 
            p->dwUniqueID, p->dwPipeNum, p->dwOptions);
        break;
    }
    case IOCTL_WDU_WAKEUP:
    {
        INIT_STRUCT_LOG(WDU_WAKEUP);
        LOG(ident+1, "dwUniqueID=%lx, dwOptions=%lx\n", p->dwUniqueID, p->dwOptions);
        break;
    }
    case IOCTL_WDU_RESET_DEVICE:
    {
        INIT_STRUCT_LOG(WDU_RESET_DEVICE);
        LOG(ident+1, "dwUniqueID=%lx, dwOptions=%lx\n", p->dwUniqueID, p->dwOptions);
        break;
    }
    default:
    {
        return WD_INVALID_PARAMETER;
    }
    }
    return WD_STATUS_SUCCESS;
}