root/trunk/blade/Performance/MSRDriver.d

/**
 * Device driver for access to Model-specific registers and control registers
 * in Windows 2000 and later (32 and 64 bit x86 platform).
 * Author: Agner Fog. Translation to D by Don Clugston.
 * License: GNU General Public License (GPL)
 * Copyright: (c) 2007-06-09 Agner Fog.
 * (c) 2005-2007 GNU General Public License www.gnu.org/copyleft/gpl.html
 */
module Blade.Performance.MSRDriver;
import win32.core; //std.c.windows.windows;
import win32.winnt;
import win32.winsvc;
import win32.windef;
import std.string;
/*
alias HANDLE SC_HANDLE;
struct SERVICE_STATUS {
    DWORD dwServiceType;
    DWORD dwCurrentState;
    DWORD dwControlsAccepted;
    DWORD dwWin32ExitCode;
    DWORD dwServiceSpecificExitCode;
    DWORD dwCheckPoint;
    DWORD dwWaitHint;
}

extern(Windows) {
SC_HANDLE OpenServiceA(SC_HANDLE, LPCWSTR, DWORD);
BOOL DeleteService(SC_HANDLE);

}
alias OpenServiceA OpenService;
*/

// commands for MSR driver
enum EMSR_COMMAND {
   MSR_IGNORE = 0,                // do nothing
   MSR_STOP   = 1,                // skip rest of list
   MSR_READ   = 2,                // read model specific register
   MSR_WRITE  = 3,                // write model specific register
   CR_READ    = 4,                // read control register
   CR_WRITE   = 5,                // write control register
   UNUSED1    = 0x7fffffff        // make sure this enum takes 32 bits
};


// input/output data structure for MSR driver
struct SMSRInOut {    
   EMSR_COMMAND msr_command;      // command for read or write register
   uint register_number;  // register number
   union {
      long value;              // 64 bit value to read or write
      uint val[2];        // lower and upper 32 bits
   };
};


// functions defined in MSRDriver2.asm
// replaced by intrinsics in MSRDriver.cpp
//extern "C"  __int64 ReadMSR (int r);  // read model specific register
//extern "C"  void WriteMSR (int r, __int64 value); // write model specific register
//extern (C) size_t ReadCR(int r);                 // read control register
//extern (C) void WriteCR(int r, size_t value);    // write control register


void lockToSingleCPU()
{
   // We must lock the process to a single CPU core in case the system has
   // multiple CPUs or a CPU with multiple cores. Otherwise, we can get
   // errors if the MSRDriver happens to set up the counters on one core
   // and the test code runs on another core.
   uint ProcessAffMask = 0, SystemAffMask = 0;

   // Get mask of possible CPU cores
   GetProcessAffinityMask(GetCurrentProcess(), &ProcessAffMask, &SystemAffMask);
   //printf("\nProcess mask %X, system mask %X\n\n", ProcessAffMask, SystemAffMask);
   if (ProcessAffMask > 1) {
      // more than one CPU core available. Fix to only one:
      if (ProcessAffMask & 2) {
         ProcessAffMask = 2;
      } else {
         ProcessAffMask = 1;
      }
      // Lock process to a single CPU core
      SetProcessAffinityMask(GetCurrentProcess(), ProcessAffMask);
   }
}


// class CMSRDriver encapsulates the interface to the driver MSRDriver32.sys
// which is needed for privileged access to set up the MSRs. This class
// loads, unloads and sends commands to MSRDriver
class CMSRDriver {
public:
const char[]   DriverFileName = "MSRDriver32";
const char[]   DriverSymbolicName = "\\\\.\\slMSRDriver";

    this() {
/*        
       // Define Driver filename
       if (Need64BitDriver()) {
          DriverFileName = "MSRDriver64";
       }
       else {
          DriverFileName = "MSRDriver32";
       }
       
       // Define driver symbolic link name
       DriverSymbolicName = "\\\\.\\slMSRDriver";
    */
        // Initialize
       scm = null;                        
       service = null;
       hDriver = null;
    }
    ~this() {
       // Unload driver if not already unloaded
        if (scm) UnloadDriver();
    }
    int AccessRegisters(SMSRInOut [] data)
    {
        if (data.length==0) return 0;
        
       const int DeviceType = 0x22;        // FILE_DEVICE_UNKNOWN;
       const int Function = 0x800;
       const int Method = 0;               // METHOD_BUFFERED;
       const int Access = 1 | 2;           // FILE_READ_ACCESS | FILE_WRITE_ACCESS;
       const int IOCTL_MSR_DRIVER = DeviceType << 16 | Access << 14 | Function << 2 | Method;
    
       DWORD len = 0;
       
       // This call results in a call to the driver rutine DispatchControl()
       int res = DeviceIoControl(hDriver, IOCTL_MSR_DRIVER, &data[0], data.length*SMSRInOut.sizeof,
          &data[0], data.length*SMSRInOut.sizeof, &len, null);
       if (!res) return GetLastError();
       return 0;
    }
   // send commands to driver to read or write MSR registers
    int AccessRegisters(void * pnIn, int nInLen, void * pnOut, int nOutLen)
    {
        if (nInLen <= 0) return 0;
        
           const int DeviceType = 0x22; // FILE_DEVICE_UNKNOWN;
           const int Function = 0x800;
           const int Method = 0;        // METHOD_BUFFERED;
           const int Access = 1 | 2;    // FILE_READ_ACCESS | FILE_WRITE_ACCESS;
           const int IOCTL_MSR_DRIVER = DeviceType << 16 | Access << 14 | Function << 2 | Method;
        
           DWORD len = 0;
           
           // This call results in a call to the driver rutine DispatchControl()
           int res = DeviceIoControl(hDriver, IOCTL_MSR_DRIVER, pnIn, nInLen,
              pnOut, nOutLen, &len, null);
           if (!res) { 
              // Error
              return GetLastError();}
           return 0;
   }
/+   
// Read a control register cr0 or cr4
size_t CRRead(int r) {
   if (r != 0 && r != 4) return -11;
   SMSRInOut a;
   a.msr_command = CR_READ;
   a.register_number = r;
   a.value = 0;
   AccessRegisters(&a,sizeof(a),&a,sizeof(a));
   return size_t(a.value);
}
   // send command to driver to write one control register
int CRWrite(int r, size_t val) {
   if (r != 0 && r != 4) return -12;
   SMSRInOut a;
   a.msr_command = CR_WRITE;
   a.register_number = r;
   a.value = val;
   return AccessRegisters(&a,sizeof(a),&a,sizeof(a));
}
+/
int LoadDriver() {
    
//           char[MAX_PATH] DriverFileNameE, DriverFilePath;
//           char *p;

   // Open connection to Windows Service Control Manager (SCM)
   scm = OpenSCManager(null, null, SC_MANAGER_ALL_ACCESS);
   if(scm != null) {
      /*
      // Get the full path of the driver file name
      strcpy(DriverFileNameE, DriverFileName);
      strcat(DriverFileNameE, ".sys");           // append .sys to DriverName
      GetFullPathName(DriverFileNameE, MAX_PATH, DriverFilePath, &p);
      */
      char* DriverFilePath = toStringz("C:\\Sandbox\\blade\\performance\\MSRDriver32.sys");
      char*   DriverFileNameE = toStringz("MSRDriver32.sys");
 //     char [MAX_PATH] DriverFilePathBuff;
 //     char *p;
//      GetFullPathName(DriverFileNameE, MAX_PATH, &DriverFilePathBuff[0], &p);
//      char * DriverFilePath = toString(DriverFilePathBuff);

      // Load the driver into memory and call its entry rutine
      service = CreateService(scm, DriverFileNameE, toStringz("MSR driver"),
         SERVICE_START + SERVICE_STOP + DELETE, SERVICE_KERNEL_DRIVER,
         SERVICE_DEMAND_START, SERVICE_ERROR_IGNORE, DriverFilePath, 
         null, null, null, null, null);
      
      if(service == null) {
         // Cannot load driver. 
         // Unload it in case it was not unloaded last time
         service = OpenService(scm, DriverFileNameE, SERVICE_ALL_ACCESS);
         SERVICE_STATUS ss;
         ControlService(service, SERVICE_CONTROL_STOP, &ss);         
         DeleteService(service);
         CloseServiceHandle(service);

         // Try again to load driver
         service = CreateService(scm, DriverFileNameE, toStringz("MSR driver"),
            SERVICE_START + SERVICE_STOP + DELETE, SERVICE_KERNEL_DRIVER,
            SERVICE_DEMAND_START, SERVICE_ERROR_IGNORE, DriverFilePath, 
            null, null, null, null, null);

         if(service is null) {
            // Still cannot load driver
            CloseServiceHandle(scm); scm = null;
            return -3;
         }
      }
      
      // Start the service
      if(!StartService(service, 0, null)) {
         // Error
         int ErrNo = GetLastError();
         // Stop service and cleanup
         service = OpenService(scm, toStringz(DriverFileName), SERVICE_ALL_ACCESS);
         SERVICE_STATUS ss;
         ControlService(service, SERVICE_CONTROL_STOP, &ss);         
         DeleteService(service);
         CloseServiceHandle(service);         
         CloseServiceHandle(scm); scm = null;
         return ErrNo;
      }
      
      if(service) {
         // Get handle to driver
         hDriver = CreateFile(toStringz(DriverSymbolicName), GENERIC_READ + GENERIC_WRITE,
            0, null, OPEN_EXISTING, 0, null);
         
         if(hDriver == null || hDriver == INVALID_HANDLE_VALUE) return -5;
      }
      else return -2;
   }
   else return GetLastError();
   
   return 0;
}

    int UnloadDriver() {
   if(scm == null || service == null || hDriver == null) {
      return -6;}
   
   CloseHandle(hDriver); hDriver = null;
   
   SERVICE_STATUS ss;
   ControlService(service, SERVICE_CONTROL_STOP, &ss);
   
   DeleteService(service);
   CloseServiceHandle(service); service = null;   
   CloseServiceHandle(scm); scm = null;
   
   return 0;
}
protected:
   bool Need64BitDriver() { return 0; }    // tell whether we need 32 bit or 64 bit driver
    SC_HANDLE scm;
    SC_HANDLE service;
    HANDLE hDriver;
//   LPCTSTR DriverFileName;
//   LPCTSTR DriverSymbolicName;
};