mirror/libcpuid
1
0
Fork 0
mirror of https://github.com/anrieff/libcpuid synced 2024-12-16 16:35:45 +00:00
Code Issues Releases Wiki Activity

Rename set_error -> cpuid_set_error and get_error -> cpuid_get_error (#188)

Browse source
This commit is contained in:
DimasKovas 2023-04-01 02:00:54 +03:00 committed by GitHub
parent 10bebe5d44
commit e3e1c16190
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 71 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
libcpuid/cpuid_main.c
View file

@ -49,13 +49,13 @@
INTERNAL_SCOPE int _libcpuid_errno = ERR_OK;
int set_error(cpu_error_t err)
int cpuid_set_error(cpu_error_t err)
{
_libcpuid_errno = (int) err;
return (int) err;
}
int get_error()
int cpuid_get_error()
{
return _libcpuid_errno;
}
@ -126,7 +126,7 @@ static void cpuid_grow_raw_data_array(struct cpu_raw_data_array_t* raw_array, lo
debugf(3, "Growing cpu_raw_data_array_t from %u to %u items\n", raw_array->num_raw, n);
tmp = realloc(raw_array->raw, sizeof(struct cpu_raw_data_t) * n);
if (tmp == NULL) { /* Memory allocation failure */
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
return;
}
@ -145,7 +145,7 @@ static void cpuid_grow_system_id(struct system_id_t* system, uint8_t n)
debugf(3, "Growing system_id_t from %u to %u items\n", system->num_cpu_types, n);
tmp = realloc(system->cpu_types, sizeof(struct cpu_id_t) * n);
if (tmp == NULL) { /* Memory allocation failure */
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
return;
}
@ -534,7 +534,7 @@ static int cpuid_serialize_raw_data_internal(struct cpu_raw_data_t* single_raw,
/* Open file descriptor */
f = !strcmp(filename, "") ? stdout : fopen(filename, "wt");
if (!f)
return set_error(ERR_OPEN);
return cpuid_set_error(ERR_OPEN);
debugf(1, "Writing raw CPUID dump to '%s'\n", f == stdout ? "stdout" : filename);
/* Write raw data to output file */
@ -580,7 +580,7 @@ static int cpuid_serialize_raw_data_internal(struct cpu_raw_data_t* single_raw,
/* Close file descriptor */
if (strcmp(filename, ""))
fclose(f);
return set_error(ERR_OK);
return cpuid_set_error(ERR_OK);
}
#define RAW_ASSIGN_LINE(__line) __line[EAX] = eax ; __line[EBX] = ebx ; __line[ECX] = ecx ; __line[EDX] = edx
@ -604,7 +604,7 @@ static int cpuid_deserialize_raw_data_internal(struct cpu_raw_data_t* single_raw
/* Open file descriptor */
f = !strcmp(filename, "") ? stdin : fopen(filename, "rt");
if (!f)
return set_error(ERR_OPEN);
return cpuid_set_error(ERR_OPEN);
debugf(1, "Opening raw dump from '%s'\n", f == stdin ? "stdin" : filename);
if (use_raw_array)
@ -717,7 +717,7 @@ static int cpuid_deserialize_raw_data_internal(struct cpu_raw_data_t* single_raw
/* Close file descriptor */
if (strcmp(filename, ""))
fclose(f);
return set_error(ERR_OK);
return cpuid_set_error(ERR_OK);
}
#undef RAW_ASSIGN_LINE
@ -859,7 +859,7 @@ static int cpuid_basic_identify(struct cpu_raw_data_t* raw, struct cpu_id_t* dat
data->vendor = cpuid_vendor_identify(raw->basic_cpuid[0], data->vendor_str);
if (data->vendor == VENDOR_UNKNOWN)
return set_error(ERR_CPU_UNKN);
return cpuid_set_error(ERR_CPU_UNKN);
data->architecture = ARCHITECTURE_X86;
basic = raw->basic_cpuid[0][EAX];
if (basic >= 1) {
@ -890,7 +890,7 @@ static int cpuid_basic_identify(struct cpu_raw_data_t* raw, struct cpu_id_t* dat
}
load_features_common(raw, data);
data->total_logical_cpus = get_total_cpus();
return set_error(ERR_OK);
return cpuid_set_error(ERR_OK);
}
static void make_list_from_string(const char* csv, struct cpu_list_t* list)
@ -903,7 +903,7 @@ static void make_list_from_string(const char* csv, struct cpu_list_t* list)
list->names = (char**) malloc(sizeof(char*) * n);
if (!list->names) { /* Memory allocation failed */
list->num_entries = 0;
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
return;
}
list->num_entries = n;
@ -912,7 +912,7 @@ static void make_list_from_string(const char* csv, struct cpu_list_t* list)
for (i = 0; i <= l; i++) if (i == l || csv[i] == ',') {
list->names[n] = (char*) malloc(i - last);
if (!list->names[n]) { /* Memory allocation failed */
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
for (j = 0; j < n; j++) free(list->names[j]);
free(list->names);
list->num_entries = 0;
@ -946,7 +946,7 @@ static bool cpu_ident_apic_id(logical_cpu_t logical_cpu, struct cpu_raw_data_t*
is_apic_id_supported = true;
break;
case VENDOR_UNKNOWN:
set_error(ERR_CPU_UNKN);
cpuid_set_error(ERR_CPU_UNKN);
/* Fall through */
default:
is_apic_id_supported = false;
@ -1025,7 +1025,7 @@ int cpuid_get_raw_data(struct cpu_raw_data_t* data)
{
unsigned i;
if (!cpuid_present())
return set_error(ERR_NO_CPUID);
return cpuid_set_error(ERR_NO_CPUID);
for (i = 0; i < 32; i++)
cpu_exec_cpuid(i, data->basic_cpuid[i]);
for (i = 0; i < 32; i++)
@ -1060,18 +1060,18 @@ int cpuid_get_raw_data(struct cpu_raw_data_t* data)
data->amd_fn8000001dh[i][ECX] = i;
cpu_exec_cpuid_ext(data->amd_fn8000001dh[i]);
}
return set_error(ERR_OK);
return cpuid_set_error(ERR_OK);
}
int cpuid_get_all_raw_data(struct cpu_raw_data_array_t* data)
{
int cur_error = set_error(ERR_OK);
int ret_error = set_error(ERR_OK);
int cur_error = cpuid_set_error(ERR_OK);
int ret_error = cpuid_set_error(ERR_OK);
logical_cpu_t logical_cpu = 0;
struct cpu_raw_data_t* raw_ptr = NULL;
if (data == NULL)
return set_error(ERR_HANDLE);
return cpuid_set_error(ERR_HANDLE);
bool affinity_saved = save_cpu_affinity();
@ -1119,13 +1119,13 @@ int cpu_ident_internal(struct cpu_raw_data_t* raw, struct cpu_id_t* data, struct
struct cpu_raw_data_t myraw;
if (!raw) {
if ((r = cpuid_get_raw_data(&myraw)) < 0)
return set_error(r);
return cpuid_set_error(r);
raw = &myraw;
}
cpu_id_t_constructor(data);
memset(internal->cache_mask, 0, sizeof(internal->cache_mask));
if ((r = cpuid_basic_identify(raw, data)) < 0)
return set_error(r);
return cpuid_set_error(r);
switch (data->vendor) {
case VENDOR_INTEL:
r = cpuid_identify_intel(raw, data, internal);
@ -1141,7 +1141,7 @@ int cpu_ident_internal(struct cpu_raw_data_t* raw, struct cpu_id_t* data, struct
/* - Deprecated since v0.5.0 */
data->l1_assoc = data->l1_data_assoc;
data->l1_cacheline = data->l1_data_cacheline;
return set_error(r);
return cpuid_set_error(r);
}
static cpu_purpose_t cpu_ident_purpose(struct cpu_raw_data_t* raw)
@ -1152,7 +1152,7 @@ static cpu_purpose_t cpu_ident_purpose(struct cpu_raw_data_t* raw)
vendor = cpuid_vendor_identify(raw->basic_cpuid[0], vendor_str);
if (vendor == VENDOR_UNKNOWN) {
set_error(ERR_CPU_UNKN);
cpuid_set_error(ERR_CPU_UNKN);
return purpose;
}
@ -1233,8 +1233,8 @@ static void update_cache_instances(struct internal_cache_instances_t* caches,
int cpu_identify_all(struct cpu_raw_data_array_t* raw_array, struct system_id_t* system)
{
int cur_error = set_error(ERR_OK);
int ret_error = set_error(ERR_OK);
int cur_error = cpuid_set_error(ERR_OK);
int ret_error = cpuid_set_error(ERR_OK);
double smt_divisor;
bool is_new_cpu_type;
bool is_last_item;
@ -1254,10 +1254,10 @@ int cpu_identify_all(struct cpu_raw_data_array_t* raw_array, struct system_id_t*
struct internal_cache_instances_t caches_type, caches_all;
if (system == NULL)
return set_error(ERR_HANDLE);
return cpuid_set_error(ERR_HANDLE);
if (!raw_array) {
if ((ret_error = cpuid_get_all_raw_data(&my_raw_array)) < 0)
return set_error(ret_error);
return cpuid_set_error(ret_error);
raw_array = &my_raw_array;
}
system_id_t_constructor(system);
@ -1324,7 +1324,7 @@ int cpu_identify_all(struct cpu_raw_data_array_t* raw_array, struct system_id_t*
switch (event) {
case EVENT_NEW_CPU_TYPE: cpu_type_index = system->num_cpu_types - 2; break;
case EVENT_LAST_ITEM: cpu_type_index = system->num_cpu_types - 1; break;
default: warnf("Warning: event %i in cpu_identify_all() not handled.\n", event); return set_error(ERR_NOT_IMP);
default: warnf("Warning: event %i in cpu_identify_all() not handled.\n", event); return cpuid_set_error(ERR_NOT_IMP);
}
copy_affinity_mask(&system->cpu_types[cpu_type_index].affinity_mask, &affinity_mask);
if (event != EVENT_LAST_ITEM) {
@ -1385,18 +1385,18 @@ int cpu_request_core_type(cpu_purpose_t purpose, struct cpu_raw_data_array_t* ra
if (!raw_array) {
if ((error = cpuid_get_all_raw_data(&my_raw_array)) < 0)
return set_error(error);
return cpuid_set_error(error);
raw_array = &my_raw_array;
}
for (logical_cpu = 0; logical_cpu < raw_array->num_raw; logical_cpu++) {
if (cpu_ident_purpose(&raw_array->raw[logical_cpu]) == purpose) {
cpu_ident_internal(&raw_array->raw[logical_cpu], data, &throwaway);
return set_error(ERR_OK);
return cpuid_set_error(ERR_OK);
}
}
return set_error(ERR_NOT_FOUND);
return cpuid_set_error(ERR_NOT_FOUND);
}
const char* cpu_architecture_str(cpu_architecture_t architecture)
@ -1648,7 +1648,7 @@ cpu_vendor_t cpuid_get_vendor(void)
if(vendor == VENDOR_UNKNOWN) {
if (!cpuid_present())
set_error(ERR_NO_CPUID);
cpuid_set_error(ERR_NO_CPUID);
else {
cpu_exec_cpuid(0, raw_vendor);
vendor = cpuid_vendor_identify(raw_vendor, vendor_str);
@ -1693,7 +1693,7 @@ void cpuid_get_cpu_list(cpu_vendor_t vendor, struct cpu_list_t* list)
break;
default:
warnf("Unknown vendor passed to cpuid_get_cpu_list()\n");
set_error(ERR_INVRANGE);
cpuid_set_error(ERR_INVRANGE);
list->num_entries = 0;
list->names = NULL;
break;

4
libcpuid/libcpuid_util.c
View file

@ -153,7 +153,7 @@ void generic_get_cpu_list(const struct match_entry_t* matchtable, int count,
n = 0;
list->names = (char**) malloc(sizeof(char*) * count);
if (!list->names) { /* Memory allocation failure */
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
list->num_entries = 0;
return;
}
@ -172,7 +172,7 @@ void generic_get_cpu_list(const struct match_entry_t* matchtable, int count,
list->names[n] = strdup(matchtable[i].name);
#endif
if (!list->names[n]) { /* Memory allocation failure */
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
list->num_entries = 0;
for (j = 0; j < n; j++) {
free(list->names[j]);

4
libcpuid/libcpuid_util.h
View file

@ -92,12 +92,12 @@ void debug_print_lbits(int debuglevel, uint64_t mask);
/*
* Sets the current errno
*/
int set_error(cpu_error_t err);
int cpuid_set_error(cpu_error_t err);
/*
* Gets the current errno
*/
int get_error(void);
int cpuid_get_error(void);
extern libcpuid_warn_fn_t _warn_fun;
extern int _current_verboselevel;

70
libcpuid/rdmsr.c
View file

@ -72,30 +72,30 @@ struct msr_driver_t* cpu_msr_driver_open_core(unsigned core_num)
char msr[MSR_PATH_LEN];
struct msr_driver_t* handle;
if (core_num >= cpuid_get_total_cpus()) {
set_error(ERR_INVCNB);
cpuid_set_error(ERR_INVCNB);
return NULL;
}
if (!rdmsr_supported()) {
set_error(ERR_NO_RDMSR);
cpuid_set_error(ERR_NO_RDMSR);
return NULL;
}
snprintf(msr, MSR_PATH_LEN, "/dev/cpu/%u/msr", core_num);
if(!load_driver(msr)) {
set_error(ERR_NO_DRIVER);
cpuid_set_error(ERR_NO_DRIVER);
return NULL;
}
int fd = open(msr, O_RDONLY);
if (fd < 0) {
if (errno == EIO) {
set_error(ERR_NO_RDMSR);
cpuid_set_error(ERR_NO_RDMSR);
return NULL;
}
set_error(ERR_NO_DRIVER);
cpuid_set_error(ERR_NO_DRIVER);
return NULL;
}
handle = (struct msr_driver_t*) malloc(sizeof(struct msr_driver_t));
if (!handle) {
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
return NULL;
}
handle->fd = fd;
@ -107,10 +107,10 @@ int cpu_rdmsr(struct msr_driver_t* driver, uint32_t msr_index, uint64_t* result)
ssize_t ret;
if (!driver || driver->fd < 0)
return set_error(ERR_HANDLE);
return cpuid_set_error(ERR_HANDLE);
ret = pread(driver->fd, result, 8, msr_index);
if (ret != 8)
return set_error(ERR_INVMSR);
return cpuid_set_error(ERR_INVMSR);
return 0;
}
@ -160,30 +160,30 @@ struct msr_driver_t* cpu_msr_driver_open_core(unsigned core_num)
char msr[MSR_PATH_LEN];
struct msr_driver_t* handle;
if (core_num >= cpuid_get_total_cpus()) {
set_error(ERR_INVCNB);
cpuid_set_error(ERR_INVCNB);
return NULL;
}
if (!rdmsr_supported()) {
set_error(ERR_NO_RDMSR);
cpuid_set_error(ERR_NO_RDMSR);
return NULL;
}
snprintf(msr, MSR_PATH_LEN, "/dev/cpuctl%u", core_num);
if(!load_driver(msr)) {
set_error(ERR_NO_DRIVER);
cpuid_set_error(ERR_NO_DRIVER);
return NULL;
}
int fd = open(msr, O_RDONLY);
if (fd < 0) {
if (errno == EIO) {
set_error(ERR_NO_RDMSR);
cpuid_set_error(ERR_NO_RDMSR);
return NULL;
}
set_error(ERR_NO_DRIVER);
cpuid_set_error(ERR_NO_DRIVER);
return NULL;
}
handle = (struct msr_driver_t*) malloc(sizeof(struct msr_driver_t));
if (!handle) {
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
return NULL;
}
handle->fd = fd;
@ -196,10 +196,10 @@ int cpu_rdmsr(struct msr_driver_t* driver, uint32_t msr_index, uint64_t* result)
args.msr = msr_index;
if (!driver || driver->fd < 0)
return set_error(ERR_HANDLE);
return cpuid_set_error(ERR_HANDLE);
if(ioctl(driver->fd, CPUCTL_RDMSR, &args))
return set_error(ERR_INVMSR);
return cpuid_set_error(ERR_INVMSR);
*result = args.data;
return 0;
@ -244,20 +244,20 @@ struct msr_driver_t* cpu_msr_driver_open(void)
struct msr_driver_t* drv;
int status;
if (!rdmsr_supported()) {
set_error(ERR_NO_RDMSR);
cpuid_set_error(ERR_NO_RDMSR);
return NULL;
}
drv = (struct msr_driver_t*) malloc(sizeof(struct msr_driver_t));
if (!drv) {
set_error(ERR_NO_MEM);
cpuid_set_error(ERR_NO_MEM);
return NULL;
}
memset(drv, 0, sizeof(struct msr_driver_t));
if (!extract_driver(drv)) {
free(drv);
set_error(ERR_EXTRACT);
cpuid_set_error(ERR_EXTRACT);
return NULL;
}
@ -265,7 +265,7 @@ struct msr_driver_t* cpu_msr_driver_open(void)
if (!DeleteFile(drv->driver_path))
debugf(1, "Deleting temporary driver file failed.\n");
if (!status) {
set_error(drv->errorcode ? drv->errorcode : ERR_NO_DRIVER);
cpuid_set_error(drv->errorcode ? drv->errorcode : ERR_NO_DRIVER);
free(drv);
return NULL;
}
@ -446,7 +446,7 @@ int cpu_rdmsr(struct msr_driver_t* driver, uint32_t msr_index, uint64_t* result)
SERVICE_STATUS srvStatus = {0};
if (!driver)
return set_error(ERR_HANDLE);
return cpuid_set_error(ERR_HANDLE);
DeviceIoControl(driver->hhDriver, IOCTL_PROCVIEW_RDMSR, &msr_index, sizeof(int), &msrdata, sizeof(__int64), &dwBytesReturned, &driver->ovl);
GetOverlappedResult(driver->hhDriver, &driver->ovl, &dwBytesReturned, TRUE);
*result = msrdata;
@ -484,40 +484,40 @@ int cpu_msr_driver_close(struct msr_driver_t* drv)
struct msr_driver_t { int dummy; };
struct msr_driver_t* cpu_msr_driver_open(void)
{
set_error(ERR_NOT_IMP);
cpuid_set_error(ERR_NOT_IMP);
return NULL;
}
struct msr_driver_t* cpu_msr_driver_open_core(unsigned core_num)
{
set_error(ERR_NOT_IMP);
cpuid_set_error(ERR_NOT_IMP);
return NULL;
}
int cpu_rdmsr(struct msr_driver_t* driver, uint32_t msr_index, uint64_t* result)
{
return set_error(ERR_NOT_IMP);
return cpuid_set_error(ERR_NOT_IMP);
}
int cpu_msr_driver_close(struct msr_driver_t* driver)
{
return set_error(ERR_NOT_IMP);
return cpuid_set_error(ERR_NOT_IMP);
}
int cpu_rdmsr_range(struct msr_driver_t* handle, uint32_t msr_index, uint8_t highbit,
uint8_t lowbit, uint64_t* result)
{
return set_error(ERR_NOT_IMP);
return cpuid_set_error(ERR_NOT_IMP);
}
int cpu_msrinfo(struct msr_driver_t* driver, cpu_msrinfo_request_t which)
{
return set_error(ERR_NOT_IMP);
return cpuid_set_error(ERR_NOT_IMP);
}
int msr_serialize_raw_data(struct msr_driver_t* handle, const char* filename)
{
return set_error(ERR_NOT_IMP);
return cpuid_set_error(ERR_NOT_IMP);
}
#endif /* Unsupported OS */
@ -985,7 +985,7 @@ int cpu_rdmsr_range(struct msr_driver_t* handle, uint32_t msr_index, uint8_t hig
const uint8_t bits = highbit - lowbit + 1;
if(highbit > 63 || lowbit > highbit)
return set_error(ERR_INVRANGE);
return cpuid_set_error(ERR_INVRANGE);
err = cpu_rdmsr(handle, msr_index, result);
@ -1007,7 +1007,7 @@ int cpu_msrinfo(struct msr_driver_t* handle, cpu_msrinfo_request_t which)
static struct msr_info_t info;
if (handle == NULL) {
set_error(ERR_HANDLE);
cpuid_set_error(ERR_HANDLE);
return CPU_INVALID_VALUE;
}
@ -1060,17 +1060,17 @@ int msr_serialize_raw_data(struct msr_driver_t* handle, const char* filename)
/* Check if MSR driver is initialized */
if (handle == NULL)
return set_error(ERR_HANDLE);
return cpuid_set_error(ERR_HANDLE);
/* Open file descriptor */
f = ((filename == NULL) || !strcmp(filename, "")) ? stdout : fopen(filename, "wt");
if (!f)
return set_error(ERR_OPEN);
return cpuid_set_error(ERR_OPEN);
/* Get cached decoded CPUID information */
id = get_cached_cpuid();
if (id->vendor == VENDOR_UNKNOWN)
return get_error();
return cpuid_get_error();
/* Get CPU stock speed */
if (cpu_clock == 0)
@ -1082,7 +1082,7 @@ int msr_serialize_raw_data(struct msr_driver_t* handle, const char* filename)
case VENDOR_HYGON:
case VENDOR_AMD: msr = amd_msr; break;
case VENDOR_INTEL: msr = intel_msr; break;
default: return set_error(ERR_CPU_UNKN);
default: return cpuid_set_error(ERR_CPU_UNKN);
}
/* Print raw MSR values */
@ -1097,7 +1097,7 @@ int msr_serialize_raw_data(struct msr_driver_t* handle, const char* filename)
/* Close file descriptor */
if (f != stdout)
fclose(f);
return set_error(ERR_OK);
return cpuid_set_error(ERR_OK);
}
#endif // RDMSR_UNSUPPORTED_OS