mirror/libcpuid
1
0
Fork 0
mirror of https://github.com/anrieff/libcpuid synced 2025-02-02 20:14:07 +00:00
Code Issues Releases Wiki Activity

Basic Linux support, untested

Browse source 
git-svn-id: https://svn.code.sf.net/p/libcpuid/code/HEAD/libcpuid@72 3b4be424-7ac5-41d7-8526-f4ddcb85d872
This commit is contained in:
Veselin Georgiev 2009-10-01 20:55:01 +00:00
parent e4920d79b0
commit 4729960411
4 changed files with 238 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
libcpuid/Makefile.am
View file

@ -12,7 +12,8 @@ libcpuid_la_SOURCES = \
recog_amd.c \ recog_amd.c \
rdtsc.c \ rdtsc.c \
asm-bits.c \ asm-bits.c \
libcpuid_util.c libcpuid_util.c \
rdmsr.c
libcpuid_la_DEPENDENCIES = \ libcpuid_la_DEPENDENCIES = \
$(srcdir)/libcpuid.sym $(srcdir)/libcpuid.sym

11
libcpuid/libcpuid.h
View file

@ -343,11 +343,12 @@ typedef enum {
ERR_BADFMT = -5, /*!< "Bad file format" */ ERR_BADFMT = -5, /*!< "Bad file format" */
ERR_NOT_IMP = -6, /*!< "Not implemented" */ ERR_NOT_IMP = -6, /*!< "Not implemented" */
ERR_CPU_UNKN = -7, /*!< "Unsupported processor" */ ERR_CPU_UNKN = -7, /*!< "Unsupported processor" */
ERR_NO_RDMSR = -8, /*!< "RDMSR instruction is not supported" */ ERR_NO_RDMSR = -8, /*!< "RDMSR instruction is not supported" */
ERR_NO_DRIVER= -9, /*!< "RDMSR driver error (generic)" */ ERR_NO_DRIVER= -9, /*!< "RDMSR driver error (generic)" */
ERR_NO_PERMS = -10, /*!< "No permissions to install RDMSR driver" */ ERR_NO_PERMS = -10, /*!< "No permissions to install RDMSR driver" */
ERR_EXTRACT = -11, /*!< "Cannot extract RDMSR driver (read only media?)" */ ERR_EXTRACT = -11, /*!< "Cannot extract RDMSR driver (read only media?)" */
ERR_HANDLE = -12, /*!< "Bad handle" */ ERR_HANDLE = -12, /*!< "Bad handle" */
ERR_INVMSR = -13, /*!< "Invalid MSR" */
} cpu_error_t; } cpu_error_t;
/** /**

4
libcpuid/libcpuid.sym
View file

@ -19,3 +19,7 @@ cpuid_set_warn_function
cpuid_set_verbosiness_level cpuid_set_verbosiness_level
cpuid_get_cpu_list cpuid_get_cpu_list
cpuid_free_cpu_list cpuid_free_cpu_list
cpu_msr_driver_open
cpu_rdmsr
cpu_msrinfo
cpu_msr_driver_close

394
libcpuid/rdmsr.c
View file

@ -23,6 +23,7 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#define _XOPEN_SOURCE 500
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "libcpuid.h" #include "libcpuid.h"
@ -30,25 +31,81 @@
#include "libcpuid_util.h" #include "libcpuid_util.h"
#ifndef _WIN32 #ifndef _WIN32
/* On Linux and Apple, we still do not support RDMSR, so supply dummy struct # ifdef __APPLE__
/* On Darwin, we still do not support RDMSR, so supply dummy struct
and functions */ and functions */
struct msr_driver_t { int dummy; } struct msr_driver_t { int dummy; };
struct msr_driver_t* cpu_msr_driver_open(void) struct msr_driver_t* cpu_msr_driver_open(void)
{ {
set_error(ERR_NOT_IMPL); set_error(ERR_NOT_IMP);
return NULL; return NULL;
} }
int cpu_rdmsr(struct msr_driver_t* driver, int msr_index, uint64_t* result) int cpu_rdmsr(struct msr_driver_t* driver, int msr_index, uint64_t* result)
{ {
return set_error(ERR_NOT_IMPL); return set_error(ERR_NOT_IMP);
} }
int cpu_msr_driver_close(struct msr_driver_t* driver) int cpu_msr_driver_close(struct msr_driver_t* driver)
{ {
return set_error(ERR_NOT_IMPL); return set_error(ERR_NOT_IMP);
} }
int cpu_msrinfo(struct msr_driver_t* driver, cpu_msrinfo_request_t which)
{
return set_error(ERR_NOT_IMP);
}
# else /* __APPLE__ */
/* Assuming linux with /dev/cpu/x/msr: */
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
struct msr_driver_t { int fd; };
static int rdmsr_supported(void);
struct msr_driver_t* cpu_msr_driver_open(void)
{
struct msr_driver_t* handle;
if (!rdmsr_supported()) {
set_error(ERR_NO_RDMSR);
return NULL;
}
int fd = open("/dev/cpu/0/msr", O_RDONLY);
if (fd < 0) {
if (errno == EIO) {
set_error(ERR_NO_RDMSR);
return NULL;
}
set_error(ERR_NO_DRIVER);
return NULL;
}
handle = (struct msr_driver_t*) malloc(sizeof(struct msr_driver_t));
handle->fd = fd;
return handle;
}
int cpu_rdmsr(struct msr_driver_t* driver, int msr_index, uint64_t* result)
{
ssize_t ret;
if (!driver || driver->fd < 0)
return set_error(ERR_HANDLE);
ret = pread(driver->fd, result, 8, msr_index * 8);
if (ret != 8)
return set_error(ERR_INVMSR);
return 0;
}
int cpu_msr_driver_close(struct msr_driver_t* drv)
{
if (drv && drv->fd >= 0) {
close(drv->fd);
free(drv);
}
return 0;
}
# endif /* __APPLE__ */
#else /* _WIN32 */ #else /* _WIN32 */
#include <windows.h> #include <windows.h>
@ -60,9 +117,9 @@ extern int cc_x64driver_code_size;
struct msr_driver_t { struct msr_driver_t {
char driver_path[MAX_PATH + 1]; char driver_path[MAX_PATH + 1];
SC_HANDLE scManager; SC_HANDLE scManager;
volatile SC_HANDLE scDriver; volatile SC_HANDLE scDriver;
HANDLE hhDriver; HANDLE hhDriver;
OVERLAPPED ovl; OVERLAPPED ovl;
int errorcode; int errorcode;
}; };
@ -93,7 +150,7 @@ struct msr_driver_t* cpu_msr_driver_open(void)
} }
status = load_driver(drv); status = load_driver(drv);
if (!DeleteFile(drv->driver_path)) if (!DeleteFile(drv->driver_path))
debugf(1, "Deleting temporary driver file failed.\n"); debugf(1, "Deleting temporary driver file failed.\n");
if (!status) { if (!status) {
set_error(drv->errorcode ? drv->errorcode : ERR_NO_DRIVER); set_error(drv->errorcode ? drv->errorcode : ERR_NO_DRIVER);
@ -103,22 +160,16 @@ struct msr_driver_t* cpu_msr_driver_open(void)
return drv; return drv;
} }
static int rdmsr_supported(void) typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
static BOOL is_running_x64(void)
{ {
struct cpu_id_t* id = get_cached_cpuid(); BOOL bIsWow64 = FALSE;
return id->flags[CPU_FEATURE_MSR];
}
typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL); LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle(__TEXT("kernel32")), "IsWow64Process");
static BOOL is_running_x64(void) if(NULL != fnIsWow64Process)
{ fnIsWow64Process(GetCurrentProcess(), &bIsWow64);
BOOL bIsWow64 = FALSE; return bIsWow64;
}
LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle(__TEXT("kernel32")), "IsWow64Process");
if(NULL != fnIsWow64Process)
fnIsWow64Process(GetCurrentProcess(), &bIsWow64);
return bIsWow64;
}
static int extract_driver(struct msr_driver_t* driver) static int extract_driver(struct msr_driver_t* driver)
@ -137,149 +188,149 @@ static int extract_driver(struct msr_driver_t* driver)
return 1; return 1;
} }
static BOOL wait_for_service_state(SC_HANDLE hService, DWORD dwDesiredState, SERVICE_STATUS *lpsrvStatus){ static BOOL wait_for_service_state(SC_HANDLE hService, DWORD dwDesiredState, SERVICE_STATUS *lpsrvStatus){
BOOL fOK = FALSE; BOOL fOK = FALSE;
DWORD dwWaitHint; DWORD dwWaitHint;
if(hService != NULL){ if(hService != NULL){
while(TRUE){ while(TRUE){
fOK = QueryServiceStatus(hService, lpsrvStatus); fOK = QueryServiceStatus(hService, lpsrvStatus);
if(!fOK) if(!fOK)
break; break;
if(lpsrvStatus->dwCurrentState == dwDesiredState) if(lpsrvStatus->dwCurrentState == dwDesiredState)
break; break;
dwWaitHint = lpsrvStatus->dwWaitHint / 10; // Poll 1/10 of the wait hint dwWaitHint = lpsrvStatus->dwWaitHint / 10; // Poll 1/10 of the wait hint
if (dwWaitHint < 1000) if (dwWaitHint < 1000)
dwWaitHint = 1000; // At most once per second dwWaitHint = 1000; // At most once per second
if (dwWaitHint > 10000) if (dwWaitHint > 10000)
dwWaitHint = 10000; // At least every 10 seconds dwWaitHint = 10000; // At least every 10 seconds
Sleep(dwWaitHint); Sleep(dwWaitHint);
} }
} }
return fOK; return fOK;
} }
static int load_driver(struct msr_driver_t* drv) static int load_driver(struct msr_driver_t* drv)
{ {
LPTSTR lpszInfo = __TEXT("RDMSR Executor Driver"); LPTSTR lpszInfo = __TEXT("RDMSR Executor Driver");
USHORT uLen = 0; USHORT uLen = 0;
SERVICE_STATUS srvStatus = {0}; SERVICE_STATUS srvStatus = {0};
BOOL fRunning = FALSE; BOOL fRunning = FALSE;
DWORD dwLastError; DWORD dwLastError;
LPTSTR lpszDriverServiceName = __TEXT("TmpRdr"); LPTSTR lpszDriverServiceName = __TEXT("TmpRdr");
TCHAR lpszDriverName[] = __TEXT("\\\\.\\Global\\TmpRdr"); TCHAR lpszDriverName[] = __TEXT("\\\\.\\Global\\TmpRdr");
if((LPVOID)(drv->scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL) { if((LPVOID)(drv->scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL) {
drv->scDriver = CreateService(drv->scManager, lpszDriverServiceName, lpszInfo, SERVICE_ALL_ACCESS, drv->scDriver = CreateService(drv->scManager, lpszDriverServiceName, lpszInfo, SERVICE_ALL_ACCESS,
SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
drv->driver_path, NULL, NULL, NULL, NULL, NULL); drv->driver_path, NULL, NULL, NULL, NULL, NULL);
if(drv->scDriver == NULL){ if(drv->scDriver == NULL){
switch(dwLastError = GetLastError()){ switch(dwLastError = GetLastError()){
case ERROR_SERVICE_EXISTS: case ERROR_SERVICE_EXISTS:
case ERROR_SERVICE_MARKED_FOR_DELETE:{ case ERROR_SERVICE_MARKED_FOR_DELETE:{
LPQUERY_SERVICE_CONFIG lpqsc; LPQUERY_SERVICE_CONFIG lpqsc;
DWORD dwBytesNeeded; DWORD dwBytesNeeded;
drv->scDriver = OpenService(drv->scManager, lpszDriverServiceName, SERVICE_ALL_ACCESS); drv->scDriver = OpenService(drv->scManager, lpszDriverServiceName, SERVICE_ALL_ACCESS);
if(drv->scDriver == NULL){ if(drv->scDriver == NULL){
debugf(1, "Error opening service: %d\n", GetLastError()); debugf(1, "Error opening service: %d\n", GetLastError());
break; break;
} }
QueryServiceConfig(drv->scDriver, NULL, 0, &dwBytesNeeded); QueryServiceConfig(drv->scDriver, NULL, 0, &dwBytesNeeded);
if((dwLastError = GetLastError()) == ERROR_INSUFFICIENT_BUFFER){ if((dwLastError = GetLastError()) == ERROR_INSUFFICIENT_BUFFER){
lpqsc = calloc(1, dwBytesNeeded); lpqsc = calloc(1, dwBytesNeeded);
if(!QueryServiceConfig(drv->scDriver, lpqsc, dwBytesNeeded, &dwBytesNeeded)){ if(!QueryServiceConfig(drv->scDriver, lpqsc, dwBytesNeeded, &dwBytesNeeded)){
free(lpqsc); free(lpqsc);
debugf(1, "Error query service config(adjusted buffer): %d\n", GetLastError()); debugf(1, "Error query service config(adjusted buffer): %d\n", GetLastError());
goto clean_up; goto clean_up;
} }
else{ else{
free(lpqsc); free(lpqsc);
} }
} }
else{ else{
debugf(1, "Error query service config: %d\n", dwLastError); debugf(1, "Error query service config: %d\n", dwLastError);
goto clean_up; goto clean_up;
} }
break; break;
} }
case ERROR_ACCESS_DENIED: case ERROR_ACCESS_DENIED:
drv->errorcode = ERR_NO_PERMS; drv->errorcode = ERR_NO_PERMS;
break; break;
default: default:
debugf(1, "Create driver service failed: %d\n", dwLastError); debugf(1, "Create driver service failed: %d\n", dwLastError);
break; break;
} }
} }
if(drv->scDriver != NULL){ if(drv->scDriver != NULL){
if(StartService(drv->scDriver, 0, NULL)){ if(StartService(drv->scDriver, 0, NULL)){
if(!wait_for_service_state(drv->scDriver, SERVICE_RUNNING, &srvStatus)){ if(!wait_for_service_state(drv->scDriver, SERVICE_RUNNING, &srvStatus)){
debugf(1, "Driver load failed.\n"); debugf(1, "Driver load failed.\n");
DeleteService(drv->scDriver); DeleteService(drv->scDriver);
CloseServiceHandle(drv->scManager); CloseServiceHandle(drv->scManager);
drv->scDriver = NULL; drv->scDriver = NULL;
goto clean_up; goto clean_up;
} else { } else {
fRunning = TRUE; fRunning = TRUE;
} }
} else{ } else{
if((dwLastError = GetLastError()) == ERROR_SERVICE_ALREADY_RUNNING) if((dwLastError = GetLastError()) == ERROR_SERVICE_ALREADY_RUNNING)
fRunning = TRUE; fRunning = TRUE;
else{ else{
debugf(1, "Driver start failed.\n"); debugf(1, "Driver start failed.\n");
DeleteService(drv->scDriver); DeleteService(drv->scDriver);
CloseServiceHandle(drv->scManager); CloseServiceHandle(drv->scManager);
drv->scDriver = NULL; drv->scDriver = NULL;
goto clean_up; goto clean_up;
} }
} }
if(fRunning) if(fRunning)
debugf(1, "Driver already running.\n"); debugf(1, "Driver already running.\n");
else else
debugf(1, "Driver loaded.\n"); debugf(1, "Driver loaded.\n");
CloseServiceHandle(drv->scManager); CloseServiceHandle(drv->scManager);
drv->hhDriver = CreateFile(lpszDriverName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0); drv->hhDriver = CreateFile(lpszDriverName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
drv->ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); drv->ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
return 1; return 1;
} }
} else { } else {
debugf(1, "Open SCM failed: %d\n", GetLastError()); debugf(1, "Open SCM failed: %d\n", GetLastError());
} }
clean_up: clean_up:
if(drv->scManager != NULL){ if(drv->scManager != NULL){
CloseServiceHandle(drv->scManager); CloseServiceHandle(drv->scManager);
drv->scManager = 0; // pointless drv->scManager = 0; // pointless
} }
if(drv->scDriver != NULL){ if(drv->scDriver != NULL){
if(!DeleteService(drv->scDriver)) if(!DeleteService(drv->scDriver))
debugf(1, "Delete driver service failed: %d\n", GetLastError()); debugf(1, "Delete driver service failed: %d\n", GetLastError());
CloseServiceHandle(drv->scDriver); CloseServiceHandle(drv->scDriver);
drv->scDriver = 0; drv->scDriver = 0;
} }
return 0; return 0;
} }
#define FILE_DEVICE_UNKNOWN 0x00000022 #define FILE_DEVICE_UNKNOWN 0x00000022
#define IOCTL_UNKNOWN_BASE FILE_DEVICE_UNKNOWN #define IOCTL_UNKNOWN_BASE FILE_DEVICE_UNKNOWN
#define IOCTL_PROCVIEW_RDMSR CTL_CODE(IOCTL_UNKNOWN_BASE, 0x0803, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) #define IOCTL_PROCVIEW_RDMSR CTL_CODE(IOCTL_UNKNOWN_BASE, 0x0803, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
int cpu_rdmsr(struct msr_driver_t* driver, int msr_index, uint64_t* result) int cpu_rdmsr(struct msr_driver_t* driver, int msr_index, uint64_t* result)
{ {
DWORD dwBytesReturned; DWORD dwBytesReturned;
__int64 msrdata; __int64 msrdata;
SERVICE_STATUS srvStatus = {0}; SERVICE_STATUS srvStatus = {0};
if (!driver) if (!driver)
return set_error(ERR_HANDLE); return set_error(ERR_HANDLE);
DeviceIoControl(driver->hhDriver, IOCTL_PROCVIEW_RDMSR, &msr_index, sizeof(int), &msrdata, sizeof(__int64), &dwBytesReturned, &driver->ovl); DeviceIoControl(driver->hhDriver, IOCTL_PROCVIEW_RDMSR, &msr_index, sizeof(int), &msrdata, sizeof(__int64), &dwBytesReturned, &driver->ovl);
GetOverlappedResult(driver->hhDriver, &driver->ovl, &dwBytesReturned, TRUE); GetOverlappedResult(driver->hhDriver, &driver->ovl, &dwBytesReturned, TRUE);
*result = msrdata; *result = msrdata;
return 0; return 0;
@ -287,24 +338,33 @@ int cpu_rdmsr(struct msr_driver_t* driver, int msr_index, uint64_t* result)
int cpu_msr_driver_close(struct msr_driver_t* drv) int cpu_msr_driver_close(struct msr_driver_t* drv)
{ {
SERVICE_STATUS srvStatus = {0}; SERVICE_STATUS srvStatus = {0};
if (drv == NULL) return 0; if (drv == NULL) return 0;
if(drv->scDriver != NULL){ if(drv->scDriver != NULL){
if (drv->hhDriver) CancelIo(drv->hhDriver); if (drv->hhDriver) CancelIo(drv->hhDriver);
if(drv->ovl.hEvent != NULL) if(drv->ovl.hEvent != NULL)
CloseHandle(drv->ovl.hEvent); CloseHandle(drv->ovl.hEvent);
if (drv->hhDriver) CloseHandle(drv->hhDriver); if (drv->hhDriver) CloseHandle(drv->hhDriver);
drv->hhDriver = NULL; drv->hhDriver = NULL;
drv->ovl.hEvent = NULL; drv->ovl.hEvent = NULL;
if (ControlService(drv->scDriver, SERVICE_CONTROL_STOP, &srvStatus)){ if (ControlService(drv->scDriver, SERVICE_CONTROL_STOP, &srvStatus)){
if (wait_for_service_state(drv->scDriver, SERVICE_STOPPED, &srvStatus)){ if (wait_for_service_state(drv->scDriver, SERVICE_STOPPED, &srvStatus)){
DeleteService(drv->scDriver); DeleteService(drv->scDriver);
} }
} }
} }
return 0; return 0;
} }
#endif /* _WIN32 */
static int rdmsr_supported(void)
{
struct cpu_id_t* id = get_cached_cpuid();
return id->flags[CPU_FEATURE_MSR];
}
int cpu_msrinfo(struct msr_driver_t* handle, cpu_msrinfo_request_t which) int cpu_msrinfo(struct msr_driver_t* handle, cpu_msrinfo_request_t which)
{ {
uint64_t r; uint64_t r;
@ -339,5 +399,3 @@ int cpu_msrinfo(struct msr_driver_t* handle, cpu_msrinfo_request_t which)
} }
} }
#endif /* _WIN32 */