celognk.h

WinCE5.0部分核心源码

_inline void CELOG_SemaphoreCloseHandle(HANDLE hSem)
{
    if (IsCeLogZoneEnabled(CELZONE_SYNCH)) {
        CEL_SEM_CLOSE cl;
        cl.hSem = hSem;
        CELOGDATANK(TRUE, CELID_SEM_CLOSE, &cl, sizeof(CEL_SEM_CLOSE), 0, CELZONE_SYNCH);
    }
}

//----------------------------------------------------------
_inline void CELOG_SemaphoreDelete(HANDLE hSem)
{
    if (IsCeLogZoneEnabled(CELZONE_SYNCH)) {
        CEL_SEM_DELETE cl;
        cl.hSem = hSem;
        CELOGDATANK(TRUE, CELID_SEM_DELETE, &cl, sizeof(CEL_SEM_DELETE), 0, CELZONE_SYNCH);
    }
}

//----------------------------------------------------------
_inline void CELOG_CSInit(CRITICAL_SECTION *lpcs)
{
    if (IsCeLogZoneEnabled(CELZONE_CRITSECT)) {
        CEL_CRITSEC_INIT cl;
        cl.hCS = (HANDLE)MapPtrProc(lpcs, pCurProc);
        CELOGDATANK(TRUE, CELID_CS_INIT, &cl, sizeof(CEL_CRITSEC_INIT), 0, CELZONE_CRITSECT);
    }
}

//----------------------------------------------------------
_inline void CELOG_CSDelete(CRITICAL_SECTION *lpcs)
{
    if (IsCeLogZoneEnabled(CELZONE_CRITSECT)) {
        CEL_CRITSEC_DELETE cl;
        cl.hCS = (HANDLE)MapPtrProc(lpcs, pCurProc);
        CELOGDATANK(TRUE, CELID_CS_DELETE, &cl, sizeof(CEL_CRITSEC_DELETE), 0, CELZONE_CRITSECT);
    }
}

//----------------------------------------------------------
// Only logged if we block when entering
_inline void CELOG_CSEnter(CRITICAL_SECTION *lpcs, HANDLE hOwnerThread)
{
    if (IsCeLogZoneEnabled(CELZONE_CRITSECT)) {
        CEL_CRITSEC_ENTER cl;
        
#ifdef MIPSIV
        

        if (IsValidKPtr(&cl)) {
            return;
        }
#endif // MIPSIV
    
        cl.hCS = (HANDLE)MapPtrProc(lpcs, pCurProc);
        cl.hOwnerThread = hOwnerThread;
    
        CELOGDATANK(TRUE, CELID_CS_ENTER, &cl, sizeof(CEL_CRITSEC_ENTER), 0, CELZONE_CRITSECT);
    }
}

//----------------------------------------------------------
// Only logged if another thread was blocked waiting for the CS
_inline void CELOG_CSLeave(CRITICAL_SECTION *lpcs, HANDLE hNewOwner)
{
    if (IsCeLogZoneEnabled(CELZONE_CRITSECT)) {
        CEL_CRITSEC_LEAVE cl;
        
#ifdef MIPSIV
        

        if (IsValidKPtr(&cl)) {
            return;
        }
#endif // MIPSIV
    
        cl.hCS = (HANDLE)MapPtrProc(lpcs, pCurProc);
        cl.hOwnerThread = hNewOwner;
    
        CELOGDATANK(TRUE, CELID_CS_LEAVE, &cl, sizeof(CEL_CRITSEC_LEAVE), 0, CELZONE_CRITSECT);
    }
}

//----------------------------------------------------------
_inline void CELOG_VirtualAlloc(DWORD dwResult, DWORD dwAddress, DWORD dwSize, DWORD dwType, DWORD dwProtect)
{
    if (IsCeLogZoneEnabled(CELZONE_VIRTMEM)) {
        CEL_VIRTUAL_ALLOC cl;
    
        cl.dwResult = dwResult;
        cl.dwAddress = dwAddress;
        cl.dwSize = dwSize;
        cl.dwType = dwType;
        cl.dwProtect = dwProtect;
        
        CELOGDATANK(TRUE, CELID_VIRTUAL_ALLOC, &cl, sizeof(CEL_VIRTUAL_ALLOC), 0, CELZONE_VIRTMEM);
    }
}

//----------------------------------------------------------
_inline void CELOG_VirtualCopy(DWORD dwDest, DWORD dwSource, DWORD dwSize, DWORD dwProtect)
{
    if (IsCeLogZoneEnabled(CELZONE_VIRTMEM)) {
        CEL_VIRTUAL_COPY cl;
    
        cl.dwDest = dwDest;
        cl.dwSource = dwSource;
        cl.dwSize = dwSize;
        cl.dwProtect = dwProtect;
        
        CELOGDATANK(TRUE, CELID_VIRTUAL_COPY, &cl, sizeof(CEL_VIRTUAL_COPY), 0, CELZONE_VIRTMEM);
    }
}

//----------------------------------------------------------
_inline void CELOG_VirtualFree(DWORD dwAddress, DWORD dwSize, DWORD dwType)
{
    if (IsCeLogZoneEnabled(CELZONE_VIRTMEM)) {
        CEL_VIRTUAL_FREE cl;
    
        cl.dwAddress = dwAddress;
        cl.dwSize = dwSize;
        cl.dwType = dwType;
        
        CELOGDATANK(TRUE, CELID_VIRTUAL_FREE, &cl, sizeof(CEL_VIRTUAL_FREE), 0, CELZONE_VIRTMEM);
    }
}

//----------------------------------------------------------
_inline void CELOG_SystemPage(DWORD dwAddress, BOOL fReadWrite)
{
    if (IsCeLogZoneEnabled(CELZONE_DEMANDPAGE)) {
        CEL_SYSTEM_PAGE cl;
        
        cl.dwAddress = dwAddress;
        cl.fReadWrite = fReadWrite;
    
        CELOGDATANK(TRUE, CELID_SYSTEM_PAGE, &cl, sizeof(CEL_SYSTEM_PAGE), 0, CELZONE_DEMANDPAGE);
    }
}

//----------------------------------------------------------
_inline void CELOG_SystemInvert(HANDLE hThread, int nPriority)
{
    if (IsCeLogZoneEnabled(CELZONE_PRIORITYINV)) {
        CEL_SYSTEM_INVERT cl;
        
        cl.hThread = hThread;
        cl.nPriority = nPriority;
    
        CELOGDATANK(TRUE, CELID_SYSTEM_INVERT, &cl, sizeof(CEL_SYSTEM_INVERT), 0, CELZONE_PRIORITYINV);
    }
}


#define CELOG_ModuleFlags(dwVMBase)                                            \
    (IsKernelVa(dwVMBase) ? CEL_MODULE_FLAG_KERNEL                             \
     : (IsInResouceSection(dwVMBase) ? CEL_MODULE_FLAG_DATAONLY : 0))


//----------------------------------------------------------
_inline void CELOG_ModuleLoad(
    HANDLE  hProcess,       // Process that loaded the module, or (-1) for first load
    PMODULE pMod
    )
{
    // Logged for both general and profiling mode
    if (IsCeLogEnabled(CELOGSTATUS_ENABLED_GENERAL | CELOGSTATUS_ENABLED_PROFILE,
                       CELZONE_LOADER | CELZONE_THREAD | CELZONE_MEMTRACKING | CELZONE_PROFILER)
        && pMod) {

        union {  // Union so that the buffer is the max of all these and aligned properly
            struct {
                union {
                    CEL_MODULE_LOAD         ModuleBase;
                    CEL_EXTRA_MODULE_INFO   ModuleExtra;
                    BYTE                    bUnused;     // Work around compiler warning
                };
                WCHAR _sz[MAX_PATH];  // Not used directly; string starts at end of data above
            };
            struct {
                CEL_MODULE_REFERENCES       ModuleRef;
                CEL_PROCESS_REFCOUNT        _ref[MAX_PROCESSES-1];  // Not used directly; list starts at end of ModuleRef
            };
        } temp;
        PCEL_MODULE_LOAD       pclBase  = &temp.ModuleBase;
        PCEL_EXTRA_MODULE_INFO pclExtra = &temp.ModuleExtra;
        PCEL_MODULE_REFERENCES pclRef   = &temp.ModuleRef;
        WORD wLen;
        WORD wProc;
        
        // Log base module info
        wLen = 0;
        pclBase->hProcess = hProcess;
        pclBase->hModule  = (HANDLE) pMod;
        pclBase->dwBase   = ZeroPtr(pMod->BasePtr);
        if (pMod->lpszModName) {
            wLen = strlenW(pMod->lpszModName) + 1;
            if (wLen <= MAX_PATH) {
                kstrcpyW(pclBase->szName, pMod->lpszModName);
            } else {
                wLen = 0;
            }
        }
        CELOGDATANK(TRUE, CELID_MODULE_LOAD, (PVOID) pclBase,
                    (WORD) (sizeof(CEL_MODULE_LOAD) + (wLen * sizeof(WCHAR))), 0,
                    CELZONE_LOADER | CELZONE_THREAD | CELZONE_MEMTRACKING | CELZONE_PROFILER);
        
        // Log extra module info
        pclExtra->hModule = (HANDLE) pMod;
        pclExtra->dwVMLen = pMod->e32.e32_vsize;
        pclExtra->dwModuleFlags = CELOG_ModuleFlags((DWORD)pMod->BasePtr);
        wLen = CELOG_FileInfoFromOE(&pMod->oe, &pclExtra->dwOID,
                                    pclExtra->szFullPath);

        CELOGDATANK(TRUE, CELID_EXTRA_MODULE_INFO, (PVOID) pclExtra,
                    (WORD) (sizeof(CEL_EXTRA_MODULE_INFO) + (wLen * sizeof(WCHAR))), 0,
                    CELZONE_LOADER | CELZONE_PROFILER);
        
        // Log per-process refcounts for the module
        if ((DWORD)hProcess == (DWORD)-1) {
            wLen = 0;
            pclRef->hModule = (HANDLE) pMod;
            for (wProc = 0; wProc < MAX_PROCESSES; wProc++) {
                if (pMod->refcnt[wProc] > 0) {
                    pclRef->ref[wLen].hProcess = ProcArray[wProc].hProc;
                    pclRef->ref[wLen].dwRefCount = pMod->refcnt[wProc];
                    wLen++;
                }
            }
            
            if (wLen > 0) {
                CELOGDATANK(TRUE, CELID_MODULE_REFERENCES, (PVOID) &pclRef,
                            (WORD) (sizeof(CEL_MODULE_REFERENCES) + ((wLen - 1) * sizeof(CEL_PROCESS_REFCOUNT))), 0,
                            CELZONE_LOADER | CELZONE_PROFILER);
            }
        }
    }
}

//----------------------------------------------------------
_inline void CELOG_ModuleFree(HANDLE hProcess, HANDLE hModule)
{
    // Logged for both general and profiling mode
    if (IsCeLogEnabled(CELOGSTATUS_ENABLED_GENERAL | CELOGSTATUS_ENABLED_PROFILE,
                       CELZONE_LOADER | CELZONE_MEMTRACKING | CELZONE_PROFILER)) {

        CEL_MODULE_FREE cl;
        
        cl.hProcess = hProcess;
        cl.hModule = hModule;
    
        CELOGDATANK(TRUE, CELID_MODULE_FREE, &cl, sizeof(CEL_MODULE_FREE), 0, CELZONE_LOADER | CELZONE_MEMTRACKING | CELZONE_PROFILER);
    }
}

//----------------------------------------------------------
_inline void CELOG_LaunchingFilesys(void)
{
    if (IsCeLogZoneEnabled(CELZONE_BOOT_TIME)) {
        CEL_BOOT_TIME cl;
        cl.dwAction = BOOT_TIME_LAUNCHING_FS;
        CELOGDATANK(TRUE, CELID_BOOT_TIME, &cl, sizeof(CEL_BOOT_TIME), 0, CELZONE_BOOT_TIME);
    }
}


//
// Special events that are only logged in profiling builds, to avoid the
// performance hit they'd cause.
//

#ifdef NKPROF

//----------------------------------------------------------
_inline void CELOG_SystemTLB(DWORD dwCount)
{
    if (IsCeLogZoneEnabled(CELZONE_TLB)) {
        CEL_SYSTEM_TLB cl;
        cl.dwCount = dwCount;
        CELOGDATANK(TRUE, CELID_SYSTEM_TLB, &cl, sizeof(CEL_SYSTEM_TLB), 0, CELZONE_TLB);
    }
}

//----------------------------------------------------------
#define CELOG_KCallEnter(nID)                                                  \
    g_pfnCeLogData(TRUE, CELID_KCALL_ENTER, &nID, sizeof(int), 0, CELZONE_KCALL, 0, FALSE)

//----------------------------------------------------------
#define CELOG_KCallLeave(nID)                                                  \
    g_pfnCeLogData(TRUE, CELID_KCALL_LEAVE, &nID, sizeof(int), 0, CELZONE_KCALL, 0, FALSE)

#else // NKPROF

#define CELOG_SystemTLB(dwCount)                                       ((void)0)
#define CELOG_KCallEnter(nID)                                          ((void)0)
#define CELOG_KCallLeave(nID)                                          ((void)0)

#endif // NKPROF


#undef CELOGDATANK

#endif // IN_KERNEL

#endif // __CELOGNK_H_