celognk.h

See Hanoi.cpp for the implementation of this cla

//----------------------------------------------------------
_inline void CELOG_MutexCloseHandle(HANDLE hMutex) {
    
    CEL_MUTEX_CLOSE cl;
    
    cl.hMutex = hMutex;

    CELOGDATA(TRUE, CELID_MUTEX_CLOSE, &cl, sizeof(CEL_MUTEX_CLOSE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_MutexDelete(HANDLE hMutex) {
    
    CEL_MUTEX_DELETE cl;
    
    cl.hMutex = hMutex;

    CELOGDATA(TRUE, CELID_MUTEX_DELETE, &cl, sizeof(CEL_MUTEX_DELETE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_SemaphoreCreate(HANDLE hSem, LONG lInitCount, LONG lMaxCount, LPCWSTR szName) {
    
    BYTE pTmp[MAX_PATH+sizeof(CEL_SEM_CREATE)];
    PCEL_SEM_CREATE pcl = (PCEL_SEM_CREATE) pTmp;
    WORD wLen = 0;
    
    pcl->hSem = hSem;
    pcl->dwInitCount = (DWORD) lInitCount;
    pcl->dwMaxCount = (DWORD) lMaxCount;
    
    if (szName) {
       wLen = strlenW(szName) + 1;
       kstrcpyW(pcl->szName, szName);
    }

    CELOGDATA(TRUE, CELID_SEM_CREATE, (PVOID) pcl, (WORD) (sizeof(CEL_SEM_CREATE) + (wLen * sizeof(WCHAR))), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_SemaphoreRelease(HANDLE hSem, LONG lReleaseCount, LONG lPreviousCount) {
    
    CEL_SEM_RELEASE cl;
    
    cl.hSem = hSem;
    cl.dwReleaseCount = (DWORD) lReleaseCount;
    cl.dwPreviousCount = (DWORD) lPreviousCount;

    CELOGDATA(TRUE, CELID_SEM_RELEASE, &cl, sizeof(CEL_SEM_RELEASE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_SemaphoreCloseHandle(HANDLE hSem) {
    
    CEL_SEM_CLOSE cl;
    
    cl.hSem = hSem;

    CELOGDATA(TRUE, CELID_SEM_CLOSE, &cl, sizeof(CEL_SEM_CLOSE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_SemaphoreDelete(HANDLE hSem) {
    
    CEL_SEM_DELETE cl;
    
    cl.hSem = hSem;

    CELOGDATA(TRUE, CELID_SEM_DELETE, &cl, sizeof(CEL_SEM_DELETE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
// Only logged if we block when entering
_inline void CELOG_CSEnter(HANDLE hCS, HANDLE hOwnerThread) {
    
    CEL_CRITSEC_ENTER cl;
    
    cl.hCS = hCS;
    cl.hOwnerThread = hOwnerThread;

    CELOGDATA(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(HANDLE hCS, HANDLE hNewOwner) {
    
    CEL_CRITSEC_LEAVE cl;
    
    cl.hCS = hCS;
    cl.hOwnerThread = hNewOwner;

    CELOGDATA(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) {
    
    CEL_VIRTUAL_ALLOC cl;

    cl.dwResult = dwResult;
    cl.dwAddress = dwAddress;
    cl.dwSize = dwSize;
    cl.dwType = dwType;
    cl.dwProtect = dwProtect;
    
    CELOGDATA(TRUE, CELID_VIRTUAL_ALLOC, &cl, sizeof(CEL_VIRTUAL_ALLOC), 0, CELZONE_VIRTMEM);
}

//----------------------------------------------------------
_inline void CELOG_VirtualCopy(DWORD dwDest, DWORD dwSource, DWORD dwSize, DWORD dwProtect) {
    
    CEL_VIRTUAL_COPY cl;

    cl.dwDest = dwDest;
    cl.dwSource = dwSource;
    cl.dwSize = dwSize;
    cl.dwProtect = dwProtect;
    
    CELOGDATA(TRUE, CELID_VIRTUAL_COPY, &cl, sizeof(CEL_VIRTUAL_COPY), 0, CELZONE_VIRTMEM);
}

//----------------------------------------------------------
_inline void CELOG_VirtualFree(DWORD dwAddress, DWORD dwSize, DWORD dwType) {
    
    CEL_VIRTUAL_FREE cl;

    cl.dwAddress = dwAddress;
    cl.dwSize = dwSize;
    cl.dwType = dwType;
    
    CELOGDATA(TRUE, CELID_VIRTUAL_FREE, &cl, sizeof(CEL_VIRTUAL_FREE), 0, CELZONE_VIRTMEM);
}

//----------------------------------------------------------
_inline void CELOG_SystemTLB(DWORD dwCount) {
    
    CEL_SYSTEM_TLB cl;
    
    cl.dwCount = dwCount;

    CELOGDATA(TRUE, CELID_SYSTEM_TLB, &cl, sizeof(CEL_SYSTEM_TLB), 0, CELZONE_TLB);
}

//----------------------------------------------------------
_inline void CELOG_SystemPage(DWORD dwAddress, BOOL fReadWrite) {
    
    CEL_SYSTEM_PAGE cl;
    
    cl.dwAddress = dwAddress;
    cl.fReadWrite = fReadWrite;

    CELOGDATA(TRUE, CELID_SYSTEM_PAGE, &cl, sizeof(CEL_SYSTEM_PAGE), 0, CELZONE_DEMANDPAGE);
}

//----------------------------------------------------------
_inline void CELOG_SystemInvert(HANDLE hThread, int nPriority) {
    
    CEL_SYSTEM_INVERT cl;
    
    cl.hThread = hThread;
    cl.nPriority = nPriority;

    CELOGDATA(TRUE, CELID_SYSTEM_INVERT, &cl, sizeof(CEL_SYSTEM_INVERT), 0, CELZONE_PRIORITYINV);
}

//----------------------------------------------------------
_inline void CELOG_ThreadSetPriority(HANDLE hThread, int nPriority) {
    
    CEL_THREAD_PRIORITY cl;
    
    cl.hThread = hThread;
    cl.nPriority = nPriority;

    CELOGDATA(TRUE, CELID_THREAD_PRIORITY, &cl, sizeof(CEL_THREAD_PRIORITY), 0, CELZONE_THREAD);
}

//----------------------------------------------------------
_inline void CELOG_ThreadSetQuantum(HANDLE hThread, DWORD dwQuantum) {
    
    CEL_THREAD_QUANTUM cl;
    
    cl.hThread = hThread;
    cl.dwQuantum = dwQuantum;

    CELOGDATA(TRUE, CELID_THREAD_QUANTUM, &cl, sizeof(CEL_THREAD_QUANTUM), 0, CELZONE_THREAD);
}

//----------------------------------------------------------
_inline void CELOG_ThreadSuspend(HANDLE hThread) {
    
    CEL_THREAD_SUSPEND cl;
    
    cl.hThread = hThread;

    CELOGDATA(TRUE, CELID_THREAD_SUSPEND, &cl, sizeof(CEL_THREAD_SUSPEND), 0, CELZONE_RESCHEDULE);
}

//----------------------------------------------------------
_inline void CELOG_ThreadResume(HANDLE hThread) {
    
    CEL_THREAD_RESUME cl;
    
    cl.hThread = hThread;

    CELOGDATA(TRUE, CELID_THREAD_RESUME, &cl, sizeof(CEL_THREAD_RESUME), 0, CELZONE_RESCHEDULE);
}

//----------------------------------------------------------
_inline void CELOG_ModuleLoad(HANDLE hProcess, HANDLE hModule, LPCWSTR szName, DWORD dwBaseOffset) {
    
    if (hModule) {
       BYTE pTmp[MAX_PATH+max(sizeof(CEL_MODULE_LOAD), sizeof(CEL_MEMTRACK_LOADMODULE))];
       PCEL_MODULE_LOAD pcl = (PCEL_MODULE_LOAD) pTmp;
       PCEL_MEMTRACK_LOADMODULE pcl2 = (PCEL_MEMTRACK_LOADMODULE) pTmp;
       WORD wLen = 0;
      
       pcl->hProcess = hProcess;
       pcl->hModule = hModule;
      
       if (szName) {
          wLen = strlenW(szName) + 1;
          kstrcpyW(pcl->szName, szName);
       }
   
       CELOGDATA(TRUE, CELID_MODULE_LOAD, (PVOID) pcl, (WORD) (sizeof(CEL_MODULE_LOAD) + (wLen * sizeof(WCHAR))), 0, CELZONE_LOADER);
       pcl2->hProcess = hProcess;
       pcl2->hModule  = hModule;
       pcl2->dwBase   = dwBaseOffset;
       
       if (wLen)
          kstrcpyW(pcl2->szName, szName);

       CELOGDATA(TRUE, CELID_MEMTRACK_LOADMODULE, (PVOID) pcl2, (WORD) (sizeof(CEL_MEMTRACK_LOADMODULE) + (wLen * sizeof(WCHAR))), 0, CELZONE_MEMTRACKING);
    }
}

//----------------------------------------------------------
_inline void CELOG_ModuleFree(HANDLE hProcess, HANDLE hModule, DWORD fReally) {
    
    CEL_MODULE_FREE cl;
    
    cl.hProcess = hProcess;
    cl.hModule = hModule;

    CELOGDATA(TRUE, CELID_MODULE_FREE, &cl, sizeof(CEL_MODULE_FREE), 0, CELZONE_LOADER);

    if (fReally) {
        CEL_MEMTRACK_FREEMODULE cl2;
    
    	cl2.hProcess = hProcess;
    	cl2.hModule  = hModule;

    	CELOGDATA(TRUE, CELID_MEMTRACK_FREEMODULE, &cl2, sizeof(CEL_MEMTRACK_FREEMODULE), 0, CELZONE_MEMTRACKING);
    }
}

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

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


#else


//------------------------------------------------------------------------------
//  Normal operation (NK.LIB)
//
#define CELOGINIT()                                                    ((void)0)
#define CELOGCREATETHREAD()                                            ((void)0)
#define CELOGDATA(Time, ID, Data, Len, Zone1, Zone2)                   ((void)0)
#define CELOGDATAFLAGGED(Time, ID, Data, Len, Zone1, Zone2, Flag)      ((void)0)

// The kernel wrappers
#define CELOG_ThreadSwitch(hThread)                                    ((void)0)
#define CELOG_ThreadMigrate(hProcess, dwReserved)                      ((void)0)
#define CELOG_Sleep(dwTimeout)                                         ((void)0)
#define CELOG_ThreadCreate(pThread, hProc, lpProcName)                 ((void)0)
#define CELOG_ThreadCloseHandle(hThread)                               ((void)0)
#define CELOG_ThreadTerminate(hThread)                                 ((void)0)
#define CELOG_ThreadDelete(hThread)                                    ((void)0)
#define CELOG_ProcessCreate(hProc, lpProcName, dwBase)                 ((void)0)
#define CELOG_ProcessCloseHandle(hProc)                                ((void)0)
#define CELOG_ProcessTerminate(hProc)                                  ((void)0)
#define CELOG_ProcessDelete(hProc)                                     ((void)0)
#define CELOG_EventCreate(hEvent, fmanReset, fInitState, lpEventName)  ((void)0)
#define CELOG_Event(hEvent, type)                                      ((void)0)
#define CELOG_EventCloseHandle(hEvent)                                 ((void)0)
#define CELOG_EventDelete(hEvent)                                      ((void)0)
#define CELOG_WaitForMultipleObjects(dwNumObjects, lpHandles, fWaitAll, dwTimeout) ((void)0)
#define CELOG_MutexCreate(hMutex, pName)                               ((void)0)
#define CELOG_MutexRelease(hMutex)                                     ((void)0)
#define CELOG_MutexCloseHandle(hMutex)                                 ((void)0)
#define CELOG_MutexDelete(hMutex)                                      ((void)0)
#define CELOG_SemaphoreCreate(hSem, lInitCount, lMaxCount, szName)     ((void)0)
#define CELOG_SemaphoreRelease(hSem, lReleaseCount, lPreviousCount)    ((void)0)
#define CELOG_SemaphoreCloseHandle(hSem)                               ((void)0)
#define CELOG_SemaphoreDelete(hSem)                                    ((void)0)
#define CELOG_CSEnter(lpcs, hOwnerThread)                              ((void)0)
#define CELOG_CSLeave(lpcs, hNewOwner)                                 ((void)0)
#define CELOG_VirtualAlloc(dwResult, dwAddress, dwSize, dwType, dwProtect) ((void)0)
#define CELOG_VirtualCopy(dwDest, dwSource, dwSize, dwProtect)         ((void)0)
#define CELOG_VirtualFree(dwAddress, dwSize, dwType)                   ((void)0)
#define CELOG_SystemTLB(dwCount)                                       ((void)0)
#define CELOG_SystemPage(dwAddress, fReadWrite)                        ((void)0)
#define CELOG_SystemInvert(hThread, nPriority)                         ((void)0)
#define CELOG_ThreadSetPriority(hThread, nPriority)                    ((void)0)
#define CELOG_ThreadSetQuantum(hThread, dwQuantum)                     ((void)0)
#define CELOG_ModuleLoad(hProcess, hModule, szName, dwOffset)  	     ((void)0)
#define CELOG_ModuleFree(hProcess, hModule, fReally)                   ((void)0)
#define CELOG_KCallEnter(nID)                                          ((void)0)
#define CELOG_KCallLeave(nID)                                          ((void)0)
#define CELOG_ThreadSuspend(hThread)                                   ((void)0)
#define CELOG_ThreadResume(hThread)                                    ((void)0)

#endif      


#endif