1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Basic resctrl file system operations 4 * 5 * Copyright (C) 2018 Intel Corporation 6 * 7 * Authors: 8 * Sai Praneeth Prakhya <sai.praneeth.prakhya@intel.com>, 9 * Fenghua Yu <fenghua.yu@intel.com> 10 */ 11 #include <fcntl.h> 12 #include <limits.h> 13 14 #include "resctrl.h" 15 16 static int find_resctrl_mount(char *buffer) 17 { 18 FILE *mounts; 19 char line[256], *fs, *mntpoint; 20 21 mounts = fopen("/proc/mounts", "r"); 22 if (!mounts) { 23 ksft_perror("/proc/mounts"); 24 return -ENXIO; 25 } 26 while (!feof(mounts)) { 27 if (!fgets(line, 256, mounts)) 28 break; 29 fs = strtok(line, " \t"); 30 if (!fs) 31 continue; 32 mntpoint = strtok(NULL, " \t"); 33 if (!mntpoint) 34 continue; 35 fs = strtok(NULL, " \t"); 36 if (!fs) 37 continue; 38 if (strcmp(fs, "resctrl")) 39 continue; 40 41 fclose(mounts); 42 if (buffer) 43 strncpy(buffer, mntpoint, 256); 44 45 return 0; 46 } 47 48 fclose(mounts); 49 50 return -ENOENT; 51 } 52 53 /* 54 * mount_resctrlfs - Mount resctrl FS at /sys/fs/resctrl 55 * 56 * Mounts resctrl FS. Fails if resctrl FS is already mounted to avoid 57 * pre-existing settings interfering with the test results. 58 * 59 * Return: 0 on success, < 0 on error. 60 */ 61 int mount_resctrlfs(void) 62 { 63 int ret; 64 65 ret = find_resctrl_mount(NULL); 66 if (ret != -ENOENT) 67 return -1; 68 69 ksft_print_msg("Mounting resctrl to \"%s\"\n", RESCTRL_PATH); 70 ret = mount("resctrl", RESCTRL_PATH, "resctrl", 0, NULL); 71 if (ret) 72 ksft_perror("mount"); 73 74 return ret; 75 } 76 77 int umount_resctrlfs(void) 78 { 79 char mountpoint[256]; 80 int ret; 81 82 ret = find_resctrl_mount(mountpoint); 83 if (ret == -ENOENT) 84 return 0; 85 if (ret) 86 return ret; 87 88 if (umount(mountpoint)) { 89 ksft_perror("Unable to umount resctrl"); 90 91 return -1; 92 } 93 94 return 0; 95 } 96 97 /* 98 * get_cache_level - Convert cache level from string to integer 99 * @cache_type: Cache level as string 100 * 101 * Return: cache level as integer or -1 if @cache_type is invalid. 102 */ 103 static int get_cache_level(const char *cache_type) 104 { 105 if (!strcmp(cache_type, "L3")) 106 return 3; 107 if (!strcmp(cache_type, "L2")) 108 return 2; 109 110 ksft_print_msg("Invalid cache level\n"); 111 return -1; 112 } 113 114 static int get_resource_cache_level(const char *resource) 115 { 116 /* "MB" use L3 (LLC) as resource */ 117 if (!strcmp(resource, "MB")) 118 return 3; 119 return get_cache_level(resource); 120 } 121 122 /* 123 * get_domain_id - Get resctrl domain ID for a specified CPU 124 * @resource: resource name 125 * @cpu_no: CPU number 126 * @domain_id: domain ID (cache ID; for MB, L3 cache ID) 127 * 128 * Return: >= 0 on success, < 0 on failure. 129 */ 130 int get_domain_id(const char *resource, int cpu_no, int *domain_id) 131 { 132 char phys_pkg_path[1024]; 133 int cache_num; 134 FILE *fp; 135 136 cache_num = get_resource_cache_level(resource); 137 if (cache_num < 0) 138 return cache_num; 139 140 sprintf(phys_pkg_path, "%s%d/cache/index%d/id", PHYS_ID_PATH, cpu_no, cache_num); 141 142 fp = fopen(phys_pkg_path, "r"); 143 if (!fp) { 144 ksft_perror("Failed to open cache id file"); 145 146 return -1; 147 } 148 if (fscanf(fp, "%d", domain_id) <= 0) { 149 ksft_perror("Could not get domain ID"); 150 fclose(fp); 151 152 return -1; 153 } 154 fclose(fp); 155 156 return 0; 157 } 158 159 /* 160 * get_cache_size - Get cache size for a specified CPU 161 * @cpu_no: CPU number 162 * @cache_type: Cache level L2/L3 163 * @cache_size: pointer to cache_size 164 * 165 * Return: = 0 on success, < 0 on failure. 166 */ 167 int get_cache_size(int cpu_no, const char *cache_type, unsigned long *cache_size) 168 { 169 char cache_path[1024], cache_str[64]; 170 int length, i, cache_num; 171 FILE *fp; 172 173 cache_num = get_cache_level(cache_type); 174 if (cache_num < 0) 175 return cache_num; 176 177 sprintf(cache_path, "/sys/bus/cpu/devices/cpu%d/cache/index%d/size", 178 cpu_no, cache_num); 179 fp = fopen(cache_path, "r"); 180 if (!fp) { 181 ksft_perror("Failed to open cache size"); 182 183 return -1; 184 } 185 if (fscanf(fp, "%63s", cache_str) <= 0) { 186 ksft_perror("Could not get cache_size"); 187 fclose(fp); 188 189 return -1; 190 } 191 fclose(fp); 192 193 length = (int)strlen(cache_str); 194 195 *cache_size = 0; 196 197 for (i = 0; i < length; i++) { 198 if ((cache_str[i] >= '0') && (cache_str[i] <= '9')) 199 200 *cache_size = *cache_size * 10 + (cache_str[i] - '0'); 201 202 else if (cache_str[i] == 'K') 203 204 *cache_size = *cache_size * 1024; 205 206 else if (cache_str[i] == 'M') 207 208 *cache_size = *cache_size * 1024 * 1024; 209 210 else 211 break; 212 } 213 214 return 0; 215 } 216 217 #define CORE_SIBLINGS_PATH "/sys/bus/cpu/devices/cpu" 218 219 /* 220 * get_bit_mask - Get bit mask from given file 221 * @filename: File containing the mask 222 * @mask: The bit mask returned as unsigned long 223 * 224 * Return: = 0 on success, < 0 on failure. 225 */ 226 static int get_bit_mask(const char *filename, unsigned long *mask) 227 { 228 FILE *fp; 229 230 if (!filename || !mask) 231 return -1; 232 233 fp = fopen(filename, "r"); 234 if (!fp) { 235 ksft_print_msg("Failed to open bit mask file '%s': %s\n", 236 filename, strerror(errno)); 237 return -1; 238 } 239 240 if (fscanf(fp, "%lx", mask) <= 0) { 241 ksft_print_msg("Could not read bit mask file '%s': %s\n", 242 filename, strerror(errno)); 243 fclose(fp); 244 245 return -1; 246 } 247 fclose(fp); 248 249 return 0; 250 } 251 252 /* 253 * resource_info_unsigned_get - Read an unsigned value from 254 * /sys/fs/resctrl/info/@resource/@filename 255 * @resource: Resource name that matches directory name in 256 * /sys/fs/resctrl/info 257 * @filename: File in /sys/fs/resctrl/info/@resource 258 * @val: Contains read value on success. 259 * 260 * Return: = 0 on success, < 0 on failure. On success the read 261 * value is saved into @val. 262 */ 263 int resource_info_unsigned_get(const char *resource, const char *filename, 264 unsigned int *val) 265 { 266 char file_path[PATH_MAX]; 267 FILE *fp; 268 269 snprintf(file_path, sizeof(file_path), "%s/%s/%s", INFO_PATH, resource, 270 filename); 271 272 fp = fopen(file_path, "r"); 273 if (!fp) { 274 ksft_print_msg("Error opening %s: %m\n", file_path); 275 return -1; 276 } 277 278 if (fscanf(fp, "%u", val) <= 0) { 279 ksft_print_msg("Could not get contents of %s: %m\n", file_path); 280 fclose(fp); 281 return -1; 282 } 283 284 fclose(fp); 285 return 0; 286 } 287 288 /* 289 * create_bit_mask- Create bit mask from start, len pair 290 * @start: LSB of the mask 291 * @len Number of bits in the mask 292 */ 293 unsigned long create_bit_mask(unsigned int start, unsigned int len) 294 { 295 return ((1UL << len) - 1UL) << start; 296 } 297 298 /* 299 * count_contiguous_bits - Returns the longest train of bits in a bit mask 300 * @val A bit mask 301 * @start The location of the least-significant bit of the longest train 302 * 303 * Return: The length of the contiguous bits in the longest train of bits 304 */ 305 unsigned int count_contiguous_bits(unsigned long val, unsigned int *start) 306 { 307 unsigned long last_val; 308 unsigned int count = 0; 309 310 while (val) { 311 last_val = val; 312 val &= (val >> 1); 313 count++; 314 } 315 316 if (start) { 317 if (count) 318 *start = ffsl(last_val) - 1; 319 else 320 *start = 0; 321 } 322 323 return count; 324 } 325 326 /* 327 * get_full_cbm - Get full Cache Bit Mask (CBM) 328 * @cache_type: Cache type as "L2" or "L3" 329 * @mask: Full cache bit mask representing the maximal portion of cache 330 * available for allocation, returned as unsigned long. 331 * 332 * Return: = 0 on success, < 0 on failure. 333 */ 334 int get_full_cbm(const char *cache_type, unsigned long *mask) 335 { 336 char cbm_path[PATH_MAX]; 337 int ret; 338 339 if (!cache_type) 340 return -1; 341 342 snprintf(cbm_path, sizeof(cbm_path), "%s/%s/cbm_mask", 343 INFO_PATH, cache_type); 344 345 ret = get_bit_mask(cbm_path, mask); 346 if (ret || !*mask) 347 return -1; 348 349 return 0; 350 } 351 352 /* 353 * get_shareable_mask - Get shareable mask from shareable_bits 354 * @cache_type: Cache type as "L2" or "L3" 355 * @shareable_mask: Shareable mask returned as unsigned long 356 * 357 * Return: = 0 on success, < 0 on failure. 358 */ 359 static int get_shareable_mask(const char *cache_type, unsigned long *shareable_mask) 360 { 361 char mask_path[PATH_MAX]; 362 363 if (!cache_type) 364 return -1; 365 366 snprintf(mask_path, sizeof(mask_path), "%s/%s/shareable_bits", 367 INFO_PATH, cache_type); 368 369 return get_bit_mask(mask_path, shareable_mask); 370 } 371 372 /* 373 * get_mask_no_shareable - Get Cache Bit Mask (CBM) without shareable bits 374 * @cache_type: Cache type as "L2" or "L3" 375 * @mask: The largest exclusive portion of the cache out of the 376 * full CBM, returned as unsigned long 377 * 378 * Parts of a cache may be shared with other devices such as GPU. This function 379 * calculates the largest exclusive portion of the cache where no other devices 380 * besides CPU have access to the cache portion. 381 * 382 * Return: = 0 on success, < 0 on failure. 383 */ 384 int get_mask_no_shareable(const char *cache_type, unsigned long *mask) 385 { 386 unsigned long full_mask, shareable_mask; 387 unsigned int start, len; 388 389 if (get_full_cbm(cache_type, &full_mask) < 0) 390 return -1; 391 if (get_shareable_mask(cache_type, &shareable_mask) < 0) 392 return -1; 393 394 len = count_contiguous_bits(full_mask & ~shareable_mask, &start); 395 if (!len) 396 return -1; 397 398 *mask = create_bit_mask(start, len); 399 400 return 0; 401 } 402 403 /* 404 * taskset_benchmark - Taskset PID (i.e. benchmark) to a specified cpu 405 * @bm_pid: PID that should be binded 406 * @cpu_no: CPU number at which the PID would be binded 407 * @old_affinity: When not NULL, set to old CPU affinity 408 * 409 * Return: 0 on success, < 0 on error. 410 */ 411 int taskset_benchmark(pid_t bm_pid, int cpu_no, cpu_set_t *old_affinity) 412 { 413 cpu_set_t my_set; 414 415 if (old_affinity) { 416 CPU_ZERO(old_affinity); 417 if (sched_getaffinity(bm_pid, sizeof(*old_affinity), 418 old_affinity)) { 419 ksft_perror("Unable to read CPU affinity"); 420 return -1; 421 } 422 } 423 424 CPU_ZERO(&my_set); 425 CPU_SET(cpu_no, &my_set); 426 427 if (sched_setaffinity(bm_pid, sizeof(cpu_set_t), &my_set)) { 428 ksft_perror("Unable to taskset benchmark"); 429 430 return -1; 431 } 432 433 return 0; 434 } 435 436 /* 437 * taskset_restore - Taskset PID to the earlier CPU affinity 438 * @bm_pid: PID that should be reset 439 * @old_affinity: The old CPU affinity to restore 440 * 441 * Return: 0 on success, < 0 on error. 442 */ 443 int taskset_restore(pid_t bm_pid, cpu_set_t *old_affinity) 444 { 445 if (sched_setaffinity(bm_pid, sizeof(*old_affinity), old_affinity)) { 446 ksft_perror("Unable to restore CPU affinity"); 447 return -1; 448 } 449 450 return 0; 451 } 452 453 /* 454 * create_grp - Create a group only if one doesn't exist 455 * @grp_name: Name of the group 456 * @grp: Full path and name of the group 457 * @parent_grp: Full path and name of the parent group 458 * 459 * Creates a group @grp_name if it does not exist yet. If @grp_name is NULL, 460 * it is interpreted as the root group which always results in success. 461 * 462 * Return: 0 on success, < 0 on error. 463 */ 464 static int create_grp(const char *grp_name, char *grp, const char *parent_grp) 465 { 466 int found_grp = 0; 467 struct dirent *ep; 468 DIR *dp; 469 470 if (!grp_name) 471 return 0; 472 473 /* Check if requested grp exists or not */ 474 dp = opendir(parent_grp); 475 if (dp) { 476 while ((ep = readdir(dp)) != NULL) { 477 if (strcmp(ep->d_name, grp_name) == 0) 478 found_grp = 1; 479 } 480 closedir(dp); 481 } else { 482 ksft_perror("Unable to open resctrl for group"); 483 484 return -1; 485 } 486 487 /* Requested grp doesn't exist, hence create it */ 488 if (found_grp == 0) { 489 if (mkdir(grp, 0) == -1) { 490 ksft_perror("Unable to create group"); 491 492 return -1; 493 } 494 } 495 496 return 0; 497 } 498 499 static int write_pid_to_tasks(char *tasks, pid_t pid) 500 { 501 FILE *fp; 502 503 fp = fopen(tasks, "w"); 504 if (!fp) { 505 ksft_perror("Failed to open tasks file"); 506 507 return -1; 508 } 509 if (fprintf(fp, "%d\n", (int)pid) < 0) { 510 ksft_print_msg("Failed to write pid to tasks file\n"); 511 fclose(fp); 512 513 return -1; 514 } 515 fclose(fp); 516 517 return 0; 518 } 519 520 /* 521 * write_bm_pid_to_resctrl - Write a PID (i.e. benchmark) to resctrl FS 522 * @bm_pid: PID that should be written 523 * @ctrlgrp: Name of the control monitor group (con_mon grp) 524 * @mongrp: Name of the monitor group (mon grp) 525 * 526 * If a con_mon grp is requested, create it and write pid to it, otherwise 527 * write pid to root con_mon grp. 528 * If a mon grp is requested, create it and write pid to it, otherwise 529 * pid is not written, this means that pid is in con_mon grp and hence 530 * should consult con_mon grp's mon_data directory for results. 531 * 532 * Return: 0 on success, < 0 on error. 533 */ 534 int write_bm_pid_to_resctrl(pid_t bm_pid, const char *ctrlgrp, const char *mongrp) 535 { 536 char controlgroup[128], monitorgroup[512], monitorgroup_p[256]; 537 char tasks[1024]; 538 int ret = 0; 539 540 if (ctrlgrp) 541 sprintf(controlgroup, "%s/%s", RESCTRL_PATH, ctrlgrp); 542 else 543 sprintf(controlgroup, "%s", RESCTRL_PATH); 544 545 /* Create control and monitoring group and write pid into it */ 546 ret = create_grp(ctrlgrp, controlgroup, RESCTRL_PATH); 547 if (ret) 548 goto out; 549 sprintf(tasks, "%s/tasks", controlgroup); 550 ret = write_pid_to_tasks(tasks, bm_pid); 551 if (ret) 552 goto out; 553 554 /* Create monitor group and write pid into if it is used */ 555 if (mongrp) { 556 sprintf(monitorgroup_p, "%s/mon_groups", controlgroup); 557 sprintf(monitorgroup, "%s/%s", monitorgroup_p, mongrp); 558 ret = create_grp(mongrp, monitorgroup, monitorgroup_p); 559 if (ret) 560 goto out; 561 562 sprintf(tasks, "%s/mon_groups/%s/tasks", 563 controlgroup, mongrp); 564 ret = write_pid_to_tasks(tasks, bm_pid); 565 if (ret) 566 goto out; 567 } 568 569 out: 570 ksft_print_msg("Writing benchmark parameters to resctrl FS\n"); 571 if (ret) 572 ksft_print_msg("Failed writing to resctrlfs\n"); 573 574 return ret; 575 } 576 577 /* 578 * write_schemata - Update schemata of a con_mon grp 579 * @ctrlgrp: Name of the con_mon grp 580 * @schemata: Schemata that should be updated to 581 * @cpu_no: CPU number that the benchmark PID is binded to 582 * @resource: Resctrl resource (Eg: MB, L3, L2, etc.) 583 * 584 * Update schemata of a con_mon grp *only* if requested resctrl resource is 585 * allocation type 586 * 587 * Return: 0 on success, < 0 on error. 588 */ 589 int write_schemata(const char *ctrlgrp, char *schemata, int cpu_no, 590 const char *resource) 591 { 592 char controlgroup[1024], reason[128], schema[1024] = {}; 593 int domain_id, fd, schema_len, ret = 0; 594 595 if (!schemata) { 596 ksft_print_msg("Skipping empty schemata update\n"); 597 598 return -1; 599 } 600 601 if (get_domain_id(resource, cpu_no, &domain_id) < 0) { 602 sprintf(reason, "Failed to get domain ID"); 603 ret = -1; 604 605 goto out; 606 } 607 608 if (ctrlgrp) 609 sprintf(controlgroup, "%s/%s/schemata", RESCTRL_PATH, ctrlgrp); 610 else 611 sprintf(controlgroup, "%s/schemata", RESCTRL_PATH); 612 613 schema_len = snprintf(schema, sizeof(schema), "%s:%d=%s\n", 614 resource, domain_id, schemata); 615 if (schema_len < 0 || schema_len >= sizeof(schema)) { 616 snprintf(reason, sizeof(reason), 617 "snprintf() failed with return value : %d", schema_len); 618 ret = -1; 619 goto out; 620 } 621 622 fd = open(controlgroup, O_WRONLY); 623 if (fd < 0) { 624 snprintf(reason, sizeof(reason), 625 "open() failed : %s", strerror(errno)); 626 ret = -1; 627 628 goto err_schema_not_empty; 629 } 630 if (write(fd, schema, schema_len) < 0) { 631 snprintf(reason, sizeof(reason), 632 "write() failed : %s", strerror(errno)); 633 close(fd); 634 ret = -1; 635 636 goto err_schema_not_empty; 637 } 638 close(fd); 639 640 err_schema_not_empty: 641 schema[schema_len - 1] = 0; 642 out: 643 ksft_print_msg("Write schema \"%s\" to resctrl FS%s%s\n", 644 schema, ret ? " # " : "", 645 ret ? reason : ""); 646 647 return ret; 648 } 649 650 bool check_resctrlfs_support(void) 651 { 652 FILE *inf = fopen("/proc/filesystems", "r"); 653 DIR *dp; 654 char *res; 655 bool ret = false; 656 657 if (!inf) 658 return false; 659 660 res = fgrep(inf, "nodev\tresctrl\n"); 661 662 if (res) { 663 ret = true; 664 free(res); 665 } 666 667 fclose(inf); 668 669 ksft_print_msg("%s Check kernel supports resctrl filesystem\n", 670 ret ? "Pass:" : "Fail:"); 671 672 if (!ret) 673 return ret; 674 675 dp = opendir(RESCTRL_PATH); 676 ksft_print_msg("%s Check resctrl mountpoint \"%s\" exists\n", 677 dp ? "Pass:" : "Fail:", RESCTRL_PATH); 678 if (dp) 679 closedir(dp); 680 681 ksft_print_msg("resctrl filesystem %s mounted\n", 682 find_resctrl_mount(NULL) ? "not" : "is"); 683 684 return ret; 685 } 686 687 char *fgrep(FILE *inf, const char *str) 688 { 689 char line[256]; 690 int slen = strlen(str); 691 692 while (!feof(inf)) { 693 if (!fgets(line, 256, inf)) 694 break; 695 if (strncmp(line, str, slen)) 696 continue; 697 698 return strdup(line); 699 } 700 701 return NULL; 702 } 703 704 /* 705 * resctrl_resource_exists - Check if a resource is supported. 706 * @resource: Resctrl resource (e.g., MB, L3, L2, L3_MON, etc.) 707 * 708 * Return: True if the resource is supported, else false. False is 709 * also returned if resctrl FS is not mounted. 710 */ 711 bool resctrl_resource_exists(const char *resource) 712 { 713 char res_path[PATH_MAX]; 714 struct stat statbuf; 715 int ret; 716 717 if (!resource) 718 return false; 719 720 ret = find_resctrl_mount(NULL); 721 if (ret) 722 return false; 723 724 snprintf(res_path, sizeof(res_path), "%s/%s", INFO_PATH, resource); 725 726 if (stat(res_path, &statbuf)) 727 return false; 728 729 return true; 730 } 731 732 /* 733 * resctrl_mon_feature_exists - Check if requested monitoring feature is valid. 734 * @resource: Resource that uses the mon_features file. Currently only L3_MON 735 * is valid. 736 * @feature: Required monitor feature (in mon_features file). 737 * 738 * Return: True if the feature is supported, else false. 739 */ 740 bool resctrl_mon_feature_exists(const char *resource, const char *feature) 741 { 742 char res_path[PATH_MAX]; 743 char *res; 744 FILE *inf; 745 746 if (!feature || !resource) 747 return false; 748 749 snprintf(res_path, sizeof(res_path), "%s/%s/mon_features", INFO_PATH, resource); 750 inf = fopen(res_path, "r"); 751 if (!inf) 752 return false; 753 754 res = fgrep(inf, feature); 755 free(res); 756 fclose(inf); 757 758 return !!res; 759 } 760 761 /* 762 * resource_info_file_exists - Check if a file is present inside 763 * /sys/fs/resctrl/info/@resource. 764 * @resource: Required resource (Eg: MB, L3, L2, etc.) 765 * @file: Required file. 766 * 767 * Return: True if the /sys/fs/resctrl/info/@resource/@file exists, else false. 768 */ 769 bool resource_info_file_exists(const char *resource, const char *file) 770 { 771 char res_path[PATH_MAX]; 772 struct stat statbuf; 773 774 if (!file || !resource) 775 return false; 776 777 snprintf(res_path, sizeof(res_path), "%s/%s/%s", INFO_PATH, resource, 778 file); 779 780 if (stat(res_path, &statbuf)) 781 return false; 782 783 return true; 784 } 785 786 bool test_resource_feature_check(const struct resctrl_test *test) 787 { 788 return resctrl_resource_exists(test->resource); 789 } 790 791 int filter_dmesg(void) 792 { 793 char line[1024]; 794 FILE *fp; 795 int pipefds[2]; 796 pid_t pid; 797 int ret; 798 799 ret = pipe(pipefds); 800 if (ret) { 801 ksft_perror("pipe"); 802 return ret; 803 } 804 fflush(stdout); 805 pid = fork(); 806 if (pid == 0) { 807 close(pipefds[0]); 808 dup2(pipefds[1], STDOUT_FILENO); 809 execlp("dmesg", "dmesg", NULL); 810 ksft_perror("Executing dmesg"); 811 exit(1); 812 } 813 close(pipefds[1]); 814 fp = fdopen(pipefds[0], "r"); 815 if (!fp) { 816 ksft_perror("fdopen(pipe)"); 817 kill(pid, SIGTERM); 818 819 return -1; 820 } 821 822 while (fgets(line, 1024, fp)) { 823 if (strstr(line, "intel_rdt:")) 824 ksft_print_msg("dmesg: %s", line); 825 if (strstr(line, "resctrl:")) 826 ksft_print_msg("dmesg: %s", line); 827 } 828 fclose(fp); 829 waitpid(pid, NULL, 0); 830 831 return 0; 832 } 833 834 int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, 835 int group_fd, unsigned long flags) 836 { 837 int ret; 838 839 ret = syscall(__NR_perf_event_open, hw_event, pid, cpu, 840 group_fd, flags); 841 return ret; 842 } 843 844 unsigned int count_bits(unsigned long n) 845 { 846 unsigned int count = 0; 847 848 while (n) { 849 count += n & 1; 850 n >>= 1; 851 } 852 853 return count; 854 } 855