celognk.h

wince下的源代码集合打包

//------------------------------------------------------------------------------
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//  ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//  PARTICULAR PURPOSE.
//  Copyright (c) 1995-2000 Microsoft Corporation.  All rights reserved.
//  
//------------------------------------------------------------------------------
//
//  Module Name:  
//  
//      celognk.h
//  
//  Abstract:  
//
//      Kernel's interface to the event logging functions.
//      
//------------------------------------------------------------------------------
#ifndef __CELOGNK_H_
#define __CELOGNK_H_

#ifdef CELOG

//------------------------------------------------------------------------------
//  Logging operation (NKPROF.LIB)
//

// Include the public SDK structures.                
#include <celog.h>

// Include exported profiler functions
#include <profiler.h>

// Redefine CELOGDATA. We want core logging in NKPROF even in ship-build                    
#undef CELOGDATA
#undef CELOGDATAFLAGGED



extern void CeLogInit(void);
extern void CeLogCreateThread(void);

#define CELOGINIT()                       CeLogInit()
#define CELOGCREATETHREAD()               CeLogCreateThread()
#define CELOGDATA(T,I,D,L,Y,Z)            CeLogData(T,I,D,L,Y,Z,0,FALSE) 
#define CELOGDATAFLAGGED(T,I,D,L,Y,Z,F)   CeLogData(T,I,D,L,Y,Z,F,TRUE) 


// The kernel wrappers

//----------------------------------------------------------
_inline void CELOG_ThreadSwitch(PTHREAD pThread) {
    CEL_THREAD_SWITCH cl;

    if (pThread) {
        cl.hThread = pThread->hTh;
    } else {
        cl.hThread = 0;
    }

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

//----------------------------------------------------------
void CeLogThreadMigrate(HANDLE hProcess, DWORD dwReserved);

#define CELOG_ThreadMigrate(hProcess, dwReserved) \
        CeLogThreadMigrate(hProcess, dwReserved)

//----------------------------------------------------------
_inline void CELOG_ThreadCreate(PTHREAD pThread, HANDLE hProcess, LPCWSTR lpProcName) {

    if (pThread) {
        BYTE pTmp[sizeof(CEL_THREAD_CREATE) + 2*MAX_PATH];
        PCEL_THREAD_CREATE pcl = (PCEL_THREAD_CREATE) pTmp;
        WORD wLen = 0;

        pcl->hProcess = hProcess;
        pcl->hThread  = pThread->hTh;
        
        // If the process name was passed in, we assume this is the primary
        // thread of a process, and take the process' name and module handle.
        // Otherwise, look up the thread's function name and module handle.
        if (lpProcName) {
            wLen = strlenW(lpProcName) + 1;
            kstrcpyW(pcl->szName, lpProcName); 
            pcl->hModule = hProcess;
        } else {
            GetThreadName(pThread, &(pcl->hModule), pcl->szName);
            if (pcl->szName[0] != 0) {
                wLen = strlenW(pcl->szName) + 1;
            }
        }
        
        CELOGDATA(TRUE, CELID_THREAD_CREATE, (PVOID) pcl, 
                  (WORD)(sizeof(CEL_THREAD_CREATE) + (wLen * sizeof(WCHAR))),
                  0, CELZONE_THREAD);
    }

}

//----------------------------------------------------------
_inline void CELOG_ThreadCloseHandle(HANDLE hThread) {
    
    CEL_THREAD_CLOSE cl;
    
    cl.hThread  = hThread;

    CELOGDATA(TRUE, CELID_THREAD_CLOSE, &cl, sizeof(CEL_THREAD_CLOSE), 0, CELZONE_THREAD);
}

//----------------------------------------------------------
_inline void CELOG_ThreadTerminate(HANDLE hThread) {
    
    CEL_THREAD_TERMINATE cl;
    
    cl.hThread  = hThread;

    CELOGDATA(TRUE, CELID_THREAD_TERMINATE, &cl, sizeof(CEL_THREAD_TERMINATE), 0, CELZONE_THREAD);
}

//----------------------------------------------------------
_inline void CELOG_ThreadDelete(HANDLE hThread) {
    
    CEL_THREAD_DELETE cl;
    
    cl.hThread  = hThread;

    CELOGDATA(TRUE, CELID_THREAD_DELETE, &cl, sizeof(CEL_THREAD_DELETE), 0, CELZONE_THREAD);
}

//----------------------------------------------------------
_inline void CELOG_ProcessCreate(HANDLE hProcess, LPCWSTR lpProcName, DWORD dwVmBase) {
    BYTE pTmp[(MAX_PATH*sizeof(WCHAR))+max(sizeof(CEL_PROCESS_CREATE), sizeof(CEL_MEMTRACK_CREATEPROC))];
    PCEL_PROCESS_CREATE pcl = (PCEL_PROCESS_CREATE) pTmp;
    PCEL_MEMTRACK_CREATEPROC pcl2 = (PCEL_MEMTRACK_CREATEPROC) pTmp;
    WORD wLen = 0;
    
    pcl->hProcess = hProcess;
    
    if (lpProcName) {
        wLen = strlenW(lpProcName) + 1;
        kstrcpyW(pcl->szName, lpProcName); 
    }
    
    CELOGDATA(TRUE, CELID_PROCESS_CREATE, (PVOID) pcl, (WORD) (sizeof(CEL_PROCESS_CREATE) + (wLen * sizeof(WCHAR))), 0, CELZONE_PROCESS);

    pcl2->hProcess = hProcess;
    pcl2->dwVmBase = dwVmBase;

    if (wLen)
        kstrcpyW(pcl2->szName, lpProcName); 

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

//----------------------------------------------------------
_inline void CELOG_ProcessCloseHandle(HANDLE hProcess) {
    
    CEL_PROCESS_CLOSE cl;
    
    cl.hProcess = hProcess;
    
    CELOGDATA(TRUE, CELID_PROCESS_CLOSE, &cl, sizeof(CEL_PROCESS_CLOSE), 0, CELZONE_PROCESS);
}

//----------------------------------------------------------
_inline void CELOG_ProcessTerminate(HANDLE hProcess) {
    
    CEL_PROCESS_TERMINATE cl;
    
    cl.hProcess = hProcess;
    
    CELOGDATA(TRUE, CELID_PROCESS_TERMINATE, &cl, sizeof(CEL_PROCESS_TERMINATE), 0, CELZONE_PROCESS | CELZONE_MEMTRACKING);
}

//----------------------------------------------------------
_inline void CELOG_ProcessDelete(HANDLE hProcess) {
    
    CEL_PROCESS_DELETE cl;
    
    cl.hProcess = hProcess;
    
    CELOGDATA(TRUE, CELID_PROCESS_DELETE, &cl, sizeof(CEL_PROCESS_DELETE), 0, CELZONE_PROCESS);
}

//----------------------------------------------------------
_inline void CELOG_Sleep(DWORD dwTimeout) {
    CEL_SLEEP cl;

    cl.dwTimeout = dwTimeout;

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

//----------------------------------------------------------
_inline void CELOG_EventCreate(HANDLE hEvent, BOOL fManReset, BOOL fInitState, LPCWSTR lpEventName) {
    
    BYTE pTmp[MAX_PATH+sizeof(CEL_EVENT_CREATE)];
    PCEL_EVENT_CREATE pcl = (PCEL_EVENT_CREATE) pTmp;
    WORD wLen = 0;
    
    pcl->hEvent = hEvent;
    pcl->fManual = fManReset;
    pcl->fInitialState = fInitState;
     
    if (lpEventName) {
       wLen = strlenW(lpEventName) + 1;
       kstrcpyW(pcl->szName, lpEventName); 
    }

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

//----------------------------------------------------------
// Event Set, Reset, Pulse
_inline void CELOG_Event(HANDLE hEvent, DWORD type) {
    
   switch (type) {
   
   case EVENT_SET: {
      
      CEL_EVENT_SET cl;
      
      cl.hEvent = hEvent;
  
      CELOGDATA(TRUE, CELID_EVENT_SET, &cl, sizeof(CEL_EVENT_SET), 0, CELZONE_SYNCH);
      break;
   }

   case EVENT_RESET: {
      
      CEL_EVENT_RESET cl;
      
      cl.hEvent = hEvent;
  
      CELOGDATA(TRUE, CELID_EVENT_RESET, &cl, sizeof(CEL_EVENT_RESET), 0, CELZONE_SYNCH);
      break;
   }
   
   case EVENT_PULSE: {
      
      CEL_EVENT_PULSE cl;
      
      cl.hEvent = hEvent;
  
      CELOGDATA(TRUE, CELID_EVENT_PULSE, &cl, sizeof(CEL_EVENT_PULSE), 0, CELZONE_SYNCH);
      break;
   }
   
   default:;
   }
}

//----------------------------------------------------------
_inline void CELOG_EventCloseHandle(HANDLE hEvent) {
    
    CEL_EVENT_CLOSE cl;
    
    cl.hEvent = hEvent;

    CELOGDATA(TRUE, CELID_EVENT_CLOSE, &cl, sizeof(CEL_EVENT_CLOSE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_EventDelete(HANDLE hEvent) {
    
    CEL_EVENT_DELETE cl;
    
    cl.hEvent = hEvent;

    CELOGDATA(TRUE, CELID_EVENT_DELETE, &cl, sizeof(CEL_EVENT_DELETE), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_WaitForMultipleObjects(
    DWORD dwNumObjects,
    CONST HANDLE* lpHandles,
    BOOL fWaitAll,
    DWORD dwTimeout
    )
{
    BYTE pTmp[(MAXIMUM_WAIT_OBJECTS * sizeof(HANDLE)) + sizeof(CEL_WAIT_MULTI)];
    PCEL_WAIT_MULTI pcl = (PCEL_WAIT_MULTI) pTmp;
    
    // Impose a limit on the number of handles logged
    if (dwNumObjects > MAXIMUM_WAIT_OBJECTS) {
       dwNumObjects = MAXIMUM_WAIT_OBJECTS;
    }
    
    pcl->fWaitAll = fWaitAll;
    pcl->dwTimeout = dwTimeout;
    memcpy(pcl->hHandles, lpHandles, dwNumObjects * sizeof(HANDLE));

    CELOGDATA(TRUE, CELID_WAIT_MULTI, (LPVOID) pcl, (WORD) (sizeof(CEL_WAIT_MULTI) + (dwNumObjects * sizeof(HANDLE))), 0, CELZONE_SYNCH);
}

//----------------------------------------------------------
_inline void CELOG_MutexCreate(HANDLE hMutex, Name* pName) {
    
    BYTE pTmp[MAX_PATH+sizeof(CEL_MUTEX_CREATE)];
    PCEL_MUTEX_CREATE pcl = (PCEL_MUTEX_CREATE) pTmp;
    WORD wLen = 0;
    
    pcl->hMutex = hMutex;
    if (pName && pName->name) {
       wLen = strlenW(pName->name) + 1;
       kstrcpyW(pcl->szName, pName->name);
    }

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

//----------------------------------------------------------
_inline void CELOG_MutexRelease(HANDLE hMutex) {
    
    CEL_MUTEX_RELEASE cl;
    
    cl.hMutex = hMutex;

    CELOGDATA(TRUE, CELID_MUTEX_RELEASE, &cl, sizeof(CEL_MUTEX_RELEASE), 0, CELZONE_SYNCH);
}