forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
746 lines
16 KiB
746 lines
16 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Basic resctrl file system operations |
|
* |
|
* Copyright (C) 2018 Intel Corporation |
|
* |
|
* Authors: |
|
* Sai Praneeth Prakhya <[email protected]>, |
|
* Fenghua Yu <[email protected]> |
|
*/ |
|
#include "resctrl.h" |
|
|
|
static int find_resctrl_mount(char *buffer) |
|
{ |
|
FILE *mounts; |
|
char line[256], *fs, *mntpoint; |
|
|
|
mounts = fopen("/proc/mounts", "r"); |
|
if (!mounts) { |
|
perror("/proc/mounts"); |
|
return -ENXIO; |
|
} |
|
while (!feof(mounts)) { |
|
if (!fgets(line, 256, mounts)) |
|
break; |
|
fs = strtok(line, " \t"); |
|
if (!fs) |
|
continue; |
|
mntpoint = strtok(NULL, " \t"); |
|
if (!mntpoint) |
|
continue; |
|
fs = strtok(NULL, " \t"); |
|
if (!fs) |
|
continue; |
|
if (strcmp(fs, "resctrl")) |
|
continue; |
|
|
|
fclose(mounts); |
|
if (buffer) |
|
strncpy(buffer, mntpoint, 256); |
|
|
|
return 0; |
|
} |
|
|
|
fclose(mounts); |
|
|
|
return -ENOENT; |
|
} |
|
|
|
/* |
|
* remount_resctrlfs - Remount resctrl FS at /sys/fs/resctrl |
|
* @mum_resctrlfs: Should the resctrl FS be remounted? |
|
* |
|
* If not mounted, mount it. |
|
* If mounted and mum_resctrlfs then remount resctrl FS. |
|
* If mounted and !mum_resctrlfs then noop |
|
* |
|
* Return: 0 on success, non-zero on failure |
|
*/ |
|
int remount_resctrlfs(bool mum_resctrlfs) |
|
{ |
|
char mountpoint[256]; |
|
int ret; |
|
|
|
ret = find_resctrl_mount(mountpoint); |
|
if (ret) |
|
strcpy(mountpoint, RESCTRL_PATH); |
|
|
|
if (!ret && mum_resctrlfs && umount(mountpoint)) |
|
ksft_print_msg("Fail: unmounting \"%s\"\n", mountpoint); |
|
|
|
if (!ret && !mum_resctrlfs) |
|
return 0; |
|
|
|
ksft_print_msg("Mounting resctrl to \"%s\"\n", RESCTRL_PATH); |
|
ret = mount("resctrl", RESCTRL_PATH, "resctrl", 0, NULL); |
|
if (ret) |
|
perror("# mount"); |
|
|
|
return ret; |
|
} |
|
|
|
int umount_resctrlfs(void) |
|
{ |
|
if (find_resctrl_mount(NULL)) |
|
return 0; |
|
|
|
if (umount(RESCTRL_PATH)) { |
|
perror("# Unable to umount resctrl"); |
|
|
|
return errno; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* get_resource_id - Get socket number/l3 id for a specified CPU |
|
* @cpu_no: CPU number |
|
* @resource_id: Socket number or l3_id |
|
* |
|
* Return: >= 0 on success, < 0 on failure. |
|
*/ |
|
int get_resource_id(int cpu_no, int *resource_id) |
|
{ |
|
char phys_pkg_path[1024]; |
|
FILE *fp; |
|
|
|
if (is_amd) |
|
sprintf(phys_pkg_path, "%s%d/cache/index3/id", |
|
PHYS_ID_PATH, cpu_no); |
|
else |
|
sprintf(phys_pkg_path, "%s%d/topology/physical_package_id", |
|
PHYS_ID_PATH, cpu_no); |
|
|
|
fp = fopen(phys_pkg_path, "r"); |
|
if (!fp) { |
|
perror("Failed to open physical_package_id"); |
|
|
|
return -1; |
|
} |
|
if (fscanf(fp, "%d", resource_id) <= 0) { |
|
perror("Could not get socket number or l3 id"); |
|
fclose(fp); |
|
|
|
return -1; |
|
} |
|
fclose(fp); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* get_cache_size - Get cache size for a specified CPU |
|
* @cpu_no: CPU number |
|
* @cache_type: Cache level L2/L3 |
|
* @cache_size: pointer to cache_size |
|
* |
|
* Return: = 0 on success, < 0 on failure. |
|
*/ |
|
int get_cache_size(int cpu_no, char *cache_type, unsigned long *cache_size) |
|
{ |
|
char cache_path[1024], cache_str[64]; |
|
int length, i, cache_num; |
|
FILE *fp; |
|
|
|
if (!strcmp(cache_type, "L3")) { |
|
cache_num = 3; |
|
} else if (!strcmp(cache_type, "L2")) { |
|
cache_num = 2; |
|
} else { |
|
perror("Invalid cache level"); |
|
return -1; |
|
} |
|
|
|
sprintf(cache_path, "/sys/bus/cpu/devices/cpu%d/cache/index%d/size", |
|
cpu_no, cache_num); |
|
fp = fopen(cache_path, "r"); |
|
if (!fp) { |
|
perror("Failed to open cache size"); |
|
|
|
return -1; |
|
} |
|
if (fscanf(fp, "%s", cache_str) <= 0) { |
|
perror("Could not get cache_size"); |
|
fclose(fp); |
|
|
|
return -1; |
|
} |
|
fclose(fp); |
|
|
|
length = (int)strlen(cache_str); |
|
|
|
*cache_size = 0; |
|
|
|
for (i = 0; i < length; i++) { |
|
if ((cache_str[i] >= '0') && (cache_str[i] <= '9')) |
|
|
|
*cache_size = *cache_size * 10 + (cache_str[i] - '0'); |
|
|
|
else if (cache_str[i] == 'K') |
|
|
|
*cache_size = *cache_size * 1024; |
|
|
|
else if (cache_str[i] == 'M') |
|
|
|
*cache_size = *cache_size * 1024 * 1024; |
|
|
|
else |
|
break; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
#define CORE_SIBLINGS_PATH "/sys/bus/cpu/devices/cpu" |
|
|
|
/* |
|
* get_cbm_mask - Get cbm mask for given cache |
|
* @cache_type: Cache level L2/L3 |
|
* @cbm_mask: cbm_mask returned as a string |
|
* |
|
* Return: = 0 on success, < 0 on failure. |
|
*/ |
|
int get_cbm_mask(char *cache_type, char *cbm_mask) |
|
{ |
|
char cbm_mask_path[1024]; |
|
FILE *fp; |
|
|
|
if (!cbm_mask) |
|
return -1; |
|
|
|
sprintf(cbm_mask_path, "%s/%s/cbm_mask", CBM_MASK_PATH, cache_type); |
|
|
|
fp = fopen(cbm_mask_path, "r"); |
|
if (!fp) { |
|
perror("Failed to open cache level"); |
|
|
|
return -1; |
|
} |
|
if (fscanf(fp, "%s", cbm_mask) <= 0) { |
|
perror("Could not get max cbm_mask"); |
|
fclose(fp); |
|
|
|
return -1; |
|
} |
|
fclose(fp); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* get_core_sibling - Get sibling core id from the same socket for given CPU |
|
* @cpu_no: CPU number |
|
* |
|
* Return: > 0 on success, < 0 on failure. |
|
*/ |
|
int get_core_sibling(int cpu_no) |
|
{ |
|
char core_siblings_path[1024], cpu_list_str[64]; |
|
int sibling_cpu_no = -1; |
|
FILE *fp; |
|
|
|
sprintf(core_siblings_path, "%s%d/topology/core_siblings_list", |
|
CORE_SIBLINGS_PATH, cpu_no); |
|
|
|
fp = fopen(core_siblings_path, "r"); |
|
if (!fp) { |
|
perror("Failed to open core siblings path"); |
|
|
|
return -1; |
|
} |
|
if (fscanf(fp, "%s", cpu_list_str) <= 0) { |
|
perror("Could not get core_siblings list"); |
|
fclose(fp); |
|
|
|
return -1; |
|
} |
|
fclose(fp); |
|
|
|
char *token = strtok(cpu_list_str, "-,"); |
|
|
|
while (token) { |
|
sibling_cpu_no = atoi(token); |
|
/* Skipping core 0 as we don't want to run test on core 0 */ |
|
if (sibling_cpu_no != 0 && sibling_cpu_no != cpu_no) |
|
break; |
|
token = strtok(NULL, "-,"); |
|
} |
|
|
|
return sibling_cpu_no; |
|
} |
|
|
|
/* |
|
* taskset_benchmark - Taskset PID (i.e. benchmark) to a specified cpu |
|
* @bm_pid: PID that should be binded |
|
* @cpu_no: CPU number at which the PID would be binded |
|
* |
|
* Return: 0 on success, non-zero on failure |
|
*/ |
|
int taskset_benchmark(pid_t bm_pid, int cpu_no) |
|
{ |
|
cpu_set_t my_set; |
|
|
|
CPU_ZERO(&my_set); |
|
CPU_SET(cpu_no, &my_set); |
|
|
|
if (sched_setaffinity(bm_pid, sizeof(cpu_set_t), &my_set)) { |
|
perror("Unable to taskset benchmark"); |
|
|
|
return -1; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* run_benchmark - Run a specified benchmark or fill_buf (default benchmark) |
|
* in specified signal. Direct benchmark stdio to /dev/null. |
|
* @signum: signal number |
|
* @info: signal info |
|
* @ucontext: user context in signal handling |
|
* |
|
* Return: void |
|
*/ |
|
void run_benchmark(int signum, siginfo_t *info, void *ucontext) |
|
{ |
|
int operation, ret, malloc_and_init_memory, memflush; |
|
unsigned long span, buffer_span; |
|
char **benchmark_cmd; |
|
char resctrl_val[64]; |
|
FILE *fp; |
|
|
|
benchmark_cmd = info->si_ptr; |
|
|
|
/* |
|
* Direct stdio of child to /dev/null, so that only parent writes to |
|
* stdio (console) |
|
*/ |
|
fp = freopen("/dev/null", "w", stdout); |
|
if (!fp) |
|
PARENT_EXIT("Unable to direct benchmark status to /dev/null"); |
|
|
|
if (strcmp(benchmark_cmd[0], "fill_buf") == 0) { |
|
/* Execute default fill_buf benchmark */ |
|
span = strtoul(benchmark_cmd[1], NULL, 10); |
|
malloc_and_init_memory = atoi(benchmark_cmd[2]); |
|
memflush = atoi(benchmark_cmd[3]); |
|
operation = atoi(benchmark_cmd[4]); |
|
sprintf(resctrl_val, "%s", benchmark_cmd[5]); |
|
|
|
if (strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR))) |
|
buffer_span = span * MB; |
|
else |
|
buffer_span = span; |
|
|
|
if (run_fill_buf(buffer_span, malloc_and_init_memory, memflush, |
|
operation, resctrl_val)) |
|
fprintf(stderr, "Error in running fill buffer\n"); |
|
} else { |
|
/* Execute specified benchmark */ |
|
ret = execvp(benchmark_cmd[0], benchmark_cmd); |
|
if (ret) |
|
perror("wrong\n"); |
|
} |
|
|
|
fclose(stdout); |
|
PARENT_EXIT("Unable to run specified benchmark"); |
|
} |
|
|
|
/* |
|
* create_grp - Create a group only if one doesn't exist |
|
* @grp_name: Name of the group |
|
* @grp: Full path and name of the group |
|
* @parent_grp: Full path and name of the parent group |
|
* |
|
* Return: 0 on success, non-zero on failure |
|
*/ |
|
static int create_grp(const char *grp_name, char *grp, const char *parent_grp) |
|
{ |
|
int found_grp = 0; |
|
struct dirent *ep; |
|
DIR *dp; |
|
|
|
/* |
|
* At this point, we are guaranteed to have resctrl FS mounted and if |
|
* length of grp_name == 0, it means, user wants to use root con_mon |
|
* grp, so do nothing |
|
*/ |
|
if (strlen(grp_name) == 0) |
|
return 0; |
|
|
|
/* Check if requested grp exists or not */ |
|
dp = opendir(parent_grp); |
|
if (dp) { |
|
while ((ep = readdir(dp)) != NULL) { |
|
if (strcmp(ep->d_name, grp_name) == 0) |
|
found_grp = 1; |
|
} |
|
closedir(dp); |
|
} else { |
|
perror("Unable to open resctrl for group"); |
|
|
|
return -1; |
|
} |
|
|
|
/* Requested grp doesn't exist, hence create it */ |
|
if (found_grp == 0) { |
|
if (mkdir(grp, 0) == -1) { |
|
perror("Unable to create group"); |
|
|
|
return -1; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int write_pid_to_tasks(char *tasks, pid_t pid) |
|
{ |
|
FILE *fp; |
|
|
|
fp = fopen(tasks, "w"); |
|
if (!fp) { |
|
perror("Failed to open tasks file"); |
|
|
|
return -1; |
|
} |
|
if (fprintf(fp, "%d\n", pid) < 0) { |
|
perror("Failed to wr pid to tasks file"); |
|
fclose(fp); |
|
|
|
return -1; |
|
} |
|
fclose(fp); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* write_bm_pid_to_resctrl - Write a PID (i.e. benchmark) to resctrl FS |
|
* @bm_pid: PID that should be written |
|
* @ctrlgrp: Name of the control monitor group (con_mon grp) |
|
* @mongrp: Name of the monitor group (mon grp) |
|
* @resctrl_val: Resctrl feature (Eg: mbm, mba.. etc) |
|
* |
|
* If a con_mon grp is requested, create it and write pid to it, otherwise |
|
* write pid to root con_mon grp. |
|
* If a mon grp is requested, create it and write pid to it, otherwise |
|
* pid is not written, this means that pid is in con_mon grp and hence |
|
* should consult con_mon grp's mon_data directory for results. |
|
* |
|
* Return: 0 on success, non-zero on failure |
|
*/ |
|
int write_bm_pid_to_resctrl(pid_t bm_pid, char *ctrlgrp, char *mongrp, |
|
char *resctrl_val) |
|
{ |
|
char controlgroup[128], monitorgroup[512], monitorgroup_p[256]; |
|
char tasks[1024]; |
|
int ret = 0; |
|
|
|
if (strlen(ctrlgrp)) |
|
sprintf(controlgroup, "%s/%s", RESCTRL_PATH, ctrlgrp); |
|
else |
|
sprintf(controlgroup, "%s", RESCTRL_PATH); |
|
|
|
/* Create control and monitoring group and write pid into it */ |
|
ret = create_grp(ctrlgrp, controlgroup, RESCTRL_PATH); |
|
if (ret) |
|
goto out; |
|
sprintf(tasks, "%s/tasks", controlgroup); |
|
ret = write_pid_to_tasks(tasks, bm_pid); |
|
if (ret) |
|
goto out; |
|
|
|
/* Create mon grp and write pid into it for "mbm" and "cmt" test */ |
|
if (!strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)) || |
|
!strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR))) { |
|
if (strlen(mongrp)) { |
|
sprintf(monitorgroup_p, "%s/mon_groups", controlgroup); |
|
sprintf(monitorgroup, "%s/%s", monitorgroup_p, mongrp); |
|
ret = create_grp(mongrp, monitorgroup, monitorgroup_p); |
|
if (ret) |
|
goto out; |
|
|
|
sprintf(tasks, "%s/mon_groups/%s/tasks", |
|
controlgroup, mongrp); |
|
ret = write_pid_to_tasks(tasks, bm_pid); |
|
if (ret) |
|
goto out; |
|
} |
|
} |
|
|
|
out: |
|
ksft_print_msg("Writing benchmark parameters to resctrl FS\n"); |
|
if (ret) |
|
perror("# writing to resctrlfs"); |
|
|
|
return ret; |
|
} |
|
|
|
/* |
|
* write_schemata - Update schemata of a con_mon grp |
|
* @ctrlgrp: Name of the con_mon grp |
|
* @schemata: Schemata that should be updated to |
|
* @cpu_no: CPU number that the benchmark PID is binded to |
|
* @resctrl_val: Resctrl feature (Eg: mbm, mba.. etc) |
|
* |
|
* Update schemata of a con_mon grp *only* if requested resctrl feature is |
|
* allocation type |
|
* |
|
* Return: 0 on success, non-zero on failure |
|
*/ |
|
int write_schemata(char *ctrlgrp, char *schemata, int cpu_no, char *resctrl_val) |
|
{ |
|
char controlgroup[1024], schema[1024], reason[64]; |
|
int resource_id, ret = 0; |
|
FILE *fp; |
|
|
|
if (strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)) && |
|
strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) && |
|
strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR))) |
|
return -ENOENT; |
|
|
|
if (!schemata) { |
|
ksft_print_msg("Skipping empty schemata update\n"); |
|
|
|
return -1; |
|
} |
|
|
|
if (get_resource_id(cpu_no, &resource_id) < 0) { |
|
sprintf(reason, "Failed to get resource id"); |
|
ret = -1; |
|
|
|
goto out; |
|
} |
|
|
|
if (strlen(ctrlgrp) != 0) |
|
sprintf(controlgroup, "%s/%s/schemata", RESCTRL_PATH, ctrlgrp); |
|
else |
|
sprintf(controlgroup, "%s/schemata", RESCTRL_PATH); |
|
|
|
if (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) || |
|
!strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR))) |
|
sprintf(schema, "%s%d%c%s", "L3:", resource_id, '=', schemata); |
|
if (!strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR))) |
|
sprintf(schema, "%s%d%c%s", "MB:", resource_id, '=', schemata); |
|
|
|
fp = fopen(controlgroup, "w"); |
|
if (!fp) { |
|
sprintf(reason, "Failed to open control group"); |
|
ret = -1; |
|
|
|
goto out; |
|
} |
|
|
|
if (fprintf(fp, "%s\n", schema) < 0) { |
|
sprintf(reason, "Failed to write schemata in control group"); |
|
fclose(fp); |
|
ret = -1; |
|
|
|
goto out; |
|
} |
|
fclose(fp); |
|
|
|
out: |
|
ksft_print_msg("Write schema \"%s\" to resctrl FS%s%s\n", |
|
schema, ret ? " # " : "", |
|
ret ? reason : ""); |
|
|
|
return ret; |
|
} |
|
|
|
bool check_resctrlfs_support(void) |
|
{ |
|
FILE *inf = fopen("/proc/filesystems", "r"); |
|
DIR *dp; |
|
char *res; |
|
bool ret = false; |
|
|
|
if (!inf) |
|
return false; |
|
|
|
res = fgrep(inf, "nodev\tresctrl\n"); |
|
|
|
if (res) { |
|
ret = true; |
|
free(res); |
|
} |
|
|
|
fclose(inf); |
|
|
|
ksft_print_msg("%s Check kernel supports resctrl filesystem\n", |
|
ret ? "Pass:" : "Fail:"); |
|
|
|
if (!ret) |
|
return ret; |
|
|
|
dp = opendir(RESCTRL_PATH); |
|
ksft_print_msg("%s Check resctrl mountpoint \"%s\" exists\n", |
|
dp ? "Pass:" : "Fail:", RESCTRL_PATH); |
|
if (dp) |
|
closedir(dp); |
|
|
|
ksft_print_msg("resctrl filesystem %s mounted\n", |
|
find_resctrl_mount(NULL) ? "not" : "is"); |
|
|
|
return ret; |
|
} |
|
|
|
char *fgrep(FILE *inf, const char *str) |
|
{ |
|
char line[256]; |
|
int slen = strlen(str); |
|
|
|
while (!feof(inf)) { |
|
if (!fgets(line, 256, inf)) |
|
break; |
|
if (strncmp(line, str, slen)) |
|
continue; |
|
|
|
return strdup(line); |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
/* |
|
* validate_resctrl_feature_request - Check if requested feature is valid. |
|
* @resctrl_val: Requested feature |
|
* |
|
* Return: True if the feature is supported, else false |
|
*/ |
|
bool validate_resctrl_feature_request(const char *resctrl_val) |
|
{ |
|
struct stat statbuf; |
|
bool found = false; |
|
char *res; |
|
FILE *inf; |
|
|
|
if (!resctrl_val) |
|
return false; |
|
|
|
if (remount_resctrlfs(false)) |
|
return false; |
|
|
|
if (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR))) { |
|
if (!stat(L3_PATH, &statbuf)) |
|
return true; |
|
} else if (!strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR))) { |
|
if (!stat(MB_PATH, &statbuf)) |
|
return true; |
|
} else if (!strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR)) || |
|
!strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR))) { |
|
if (!stat(L3_MON_PATH, &statbuf)) { |
|
inf = fopen(L3_MON_FEATURES_PATH, "r"); |
|
if (!inf) |
|
return false; |
|
|
|
if (!strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR))) { |
|
res = fgrep(inf, "llc_occupancy"); |
|
if (res) { |
|
found = true; |
|
free(res); |
|
} |
|
} |
|
|
|
if (!strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR))) { |
|
res = fgrep(inf, "mbm_total_bytes"); |
|
if (res) { |
|
free(res); |
|
res = fgrep(inf, "mbm_local_bytes"); |
|
if (res) { |
|
found = true; |
|
free(res); |
|
} |
|
} |
|
} |
|
fclose(inf); |
|
} |
|
} |
|
|
|
return found; |
|
} |
|
|
|
int filter_dmesg(void) |
|
{ |
|
char line[1024]; |
|
FILE *fp; |
|
int pipefds[2]; |
|
pid_t pid; |
|
int ret; |
|
|
|
ret = pipe(pipefds); |
|
if (ret) { |
|
perror("pipe"); |
|
return ret; |
|
} |
|
pid = fork(); |
|
if (pid == 0) { |
|
close(pipefds[0]); |
|
dup2(pipefds[1], STDOUT_FILENO); |
|
execlp("dmesg", "dmesg", NULL); |
|
perror("executing dmesg"); |
|
exit(1); |
|
} |
|
close(pipefds[1]); |
|
fp = fdopen(pipefds[0], "r"); |
|
if (!fp) { |
|
perror("fdopen(pipe)"); |
|
kill(pid, SIGTERM); |
|
|
|
return -1; |
|
} |
|
|
|
while (fgets(line, 1024, fp)) { |
|
if (strstr(line, "intel_rdt:")) |
|
ksft_print_msg("dmesg: %s", line); |
|
if (strstr(line, "resctrl:")) |
|
ksft_print_msg("dmesg: %s", line); |
|
} |
|
fclose(fp); |
|
waitpid(pid, NULL, 0); |
|
|
|
return 0; |
|
} |
|
|
|
int validate_bw_report_request(char *bw_report) |
|
{ |
|
if (strcmp(bw_report, "reads") == 0) |
|
return 0; |
|
if (strcmp(bw_report, "writes") == 0) |
|
return 0; |
|
if (strcmp(bw_report, "nt-writes") == 0) { |
|
strcpy(bw_report, "writes"); |
|
return 0; |
|
} |
|
if (strcmp(bw_report, "total") == 0) |
|
return 0; |
|
|
|
fprintf(stderr, "Requested iMC B/W report type unavailable\n"); |
|
|
|
return -1; |
|
} |
|
|
|
int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, |
|
int group_fd, unsigned long flags) |
|
{ |
|
int ret; |
|
|
|
ret = syscall(__NR_perf_event_open, hw_event, pid, cpu, |
|
group_fd, flags); |
|
return ret; |
|
} |
|
|
|
unsigned int count_bits(unsigned long n) |
|
{ |
|
unsigned int count = 0; |
|
|
|
while (n) { |
|
count += n & 1; |
|
n >>= 1; |
|
} |
|
|
|
return count; |
|
}
|
|
|