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 "resctrl.h" 12 13 int tests_run; 14 15 static int find_resctrl_mount(char *buffer) 16 { 17 FILE *mounts; 18 char line[256], *fs, *mntpoint; 19 20 mounts = fopen("/proc/mounts", "r"); 21 if (!mounts) { 22 perror("/proc/mounts"); 23 return -ENXIO; 24 } 25 while (!feof(mounts)) { 26 if (!fgets(line, 256, mounts)) 27 break; 28 fs = strtok(line, " \t"); 29 if (!fs) 30 continue; 31 mntpoint = strtok(NULL, " \t"); 32 if (!mntpoint) 33 continue; 34 fs = strtok(NULL, " \t"); 35 if (!fs) 36 continue; 37 if (strcmp(fs, "resctrl")) 38 continue; 39 40 fclose(mounts); 41 if (buffer) 42 strncpy(buffer, mntpoint, 256); 43 44 return 0; 45 } 46 47 fclose(mounts); 48 49 return -ENOENT; 50 } 51 52 char cbm_mask[256]; 53 54 /* 55 * remount_resctrlfs - Remount resctrl FS at /sys/fs/resctrl 56 * @mum_resctrlfs: Should the resctrl FS be remounted? 57 * 58 * If not mounted, mount it. 59 * If mounted and mum_resctrlfs then remount resctrl FS. 60 * If mounted and !mum_resctrlfs then noop 61 * 62 * Return: 0 on success, non-zero on failure 63 */ 64 int remount_resctrlfs(bool mum_resctrlfs) 65 { 66 char mountpoint[256]; 67 int ret; 68 69 ret = find_resctrl_mount(mountpoint); 70 if (ret) 71 strcpy(mountpoint, RESCTRL_PATH); 72 73 if (!ret && mum_resctrlfs && umount(mountpoint)) { 74 printf("not ok unmounting \"%s\"\n", mountpoint); 75 perror("# umount"); 76 tests_run++; 77 } 78 79 if (!ret && !mum_resctrlfs) 80 return 0; 81 82 ret = mount("resctrl", RESCTRL_PATH, "resctrl", 0, NULL); 83 printf("%sok mounting resctrl to \"%s\"\n", ret ? "not " : "", 84 RESCTRL_PATH); 85 if (ret) 86 perror("# mount"); 87 88 tests_run++; 89 90 return ret; 91 } 92 93 int umount_resctrlfs(void) 94 { 95 if (umount(RESCTRL_PATH)) { 96 perror("# Unable to umount resctrl"); 97 98 return errno; 99 } 100 101 return 0; 102 } 103 104 /* 105 * get_resource_id - Get socket number/l3 id for a specified CPU 106 * @cpu_no: CPU number 107 * @resource_id: Socket number or l3_id 108 * 109 * Return: >= 0 on success, < 0 on failure. 110 */ 111 int get_resource_id(int cpu_no, int *resource_id) 112 { 113 char phys_pkg_path[1024]; 114 FILE *fp; 115 116 if (is_amd) 117 sprintf(phys_pkg_path, "%s%d/cache/index3/id", 118 PHYS_ID_PATH, cpu_no); 119 else 120 sprintf(phys_pkg_path, "%s%d/topology/physical_package_id", 121 PHYS_ID_PATH, cpu_no); 122 123 fp = fopen(phys_pkg_path, "r"); 124 if (!fp) { 125 perror("Failed to open physical_package_id"); 126 127 return -1; 128 } 129 if (fscanf(fp, "%d", resource_id) <= 0) { 130 perror("Could not get socket number or l3 id"); 131 fclose(fp); 132 133 return -1; 134 } 135 fclose(fp); 136 137 return 0; 138 } 139 140 /* 141 * get_cache_size - Get cache size for a specified CPU 142 * @cpu_no: CPU number 143 * @cache_type: Cache level L2/L3 144 * @cache_size: pointer to cache_size 145 * 146 * Return: = 0 on success, < 0 on failure. 147 */ 148 int get_cache_size(int cpu_no, char *cache_type, unsigned long *cache_size) 149 { 150 char cache_path[1024], cache_str[64]; 151 int length, i, cache_num; 152 FILE *fp; 153 154 if (!strcmp(cache_type, "L3")) { 155 cache_num = 3; 156 } else if (!strcmp(cache_type, "L2")) { 157 cache_num = 2; 158 } else { 159 perror("Invalid cache level"); 160 return -1; 161 } 162 163 sprintf(cache_path, "/sys/bus/cpu/devices/cpu%d/cache/index%d/size", 164 cpu_no, cache_num); 165 fp = fopen(cache_path, "r"); 166 if (!fp) { 167 perror("Failed to open cache size"); 168 169 return -1; 170 } 171 if (fscanf(fp, "%s", cache_str) <= 0) { 172 perror("Could not get cache_size"); 173 fclose(fp); 174 175 return -1; 176 } 177 fclose(fp); 178 179 length = (int)strlen(cache_str); 180 181 *cache_size = 0; 182 183 for (i = 0; i < length; i++) { 184 if ((cache_str[i] >= '0') && (cache_str[i] <= '9')) 185 186 *cache_size = *cache_size * 10 + (cache_str[i] - '0'); 187 188 else if (cache_str[i] == 'K') 189 190 *cache_size = *cache_size * 1024; 191 192 else if (cache_str[i] == 'M') 193 194 *cache_size = *cache_size * 1024 * 1024; 195 196 else 197 break; 198 } 199 200 return 0; 201 } 202 203 #define CORE_SIBLINGS_PATH "/sys/bus/cpu/devices/cpu" 204 205 /* 206 * get_cbm_mask - Get cbm mask for given cache 207 * @cache_type: Cache level L2/L3 208 * 209 * Mask is stored in cbm_mask which is global variable. 210 * 211 * Return: = 0 on success, < 0 on failure. 212 */ 213 int get_cbm_mask(char *cache_type) 214 { 215 char cbm_mask_path[1024]; 216 FILE *fp; 217 218 sprintf(cbm_mask_path, "%s/%s/cbm_mask", CBM_MASK_PATH, cache_type); 219 220 fp = fopen(cbm_mask_path, "r"); 221 if (!fp) { 222 perror("Failed to open cache level"); 223 224 return -1; 225 } 226 if (fscanf(fp, "%s", cbm_mask) <= 0) { 227 perror("Could not get max cbm_mask"); 228 fclose(fp); 229 230 return -1; 231 } 232 fclose(fp); 233 234 return 0; 235 } 236 237 /* 238 * get_core_sibling - Get sibling core id from the same socket for given CPU 239 * @cpu_no: CPU number 240 * 241 * Return: > 0 on success, < 0 on failure. 242 */ 243 int get_core_sibling(int cpu_no) 244 { 245 char core_siblings_path[1024], cpu_list_str[64]; 246 int sibling_cpu_no = -1; 247 FILE *fp; 248 249 sprintf(core_siblings_path, "%s%d/topology/core_siblings_list", 250 CORE_SIBLINGS_PATH, cpu_no); 251 252 fp = fopen(core_siblings_path, "r"); 253 if (!fp) { 254 perror("Failed to open core siblings path"); 255 256 return -1; 257 } 258 if (fscanf(fp, "%s", cpu_list_str) <= 0) { 259 perror("Could not get core_siblings list"); 260 fclose(fp); 261 262 return -1; 263 } 264 fclose(fp); 265 266 char *token = strtok(cpu_list_str, "-,"); 267 268 while (token) { 269 sibling_cpu_no = atoi(token); 270 /* Skipping core 0 as we don't want to run test on core 0 */ 271 if (sibling_cpu_no != 0) 272 break; 273 token = strtok(NULL, "-,"); 274 } 275 276 return sibling_cpu_no; 277 } 278 279 /* 280 * taskset_benchmark - Taskset PID (i.e. benchmark) to a specified cpu 281 * @bm_pid: PID that should be binded 282 * @cpu_no: CPU number at which the PID would be binded 283 * 284 * Return: 0 on success, non-zero on failure 285 */ 286 int taskset_benchmark(pid_t bm_pid, int cpu_no) 287 { 288 cpu_set_t my_set; 289 290 CPU_ZERO(&my_set); 291 CPU_SET(cpu_no, &my_set); 292 293 if (sched_setaffinity(bm_pid, sizeof(cpu_set_t), &my_set)) { 294 perror("Unable to taskset benchmark"); 295 296 return -1; 297 } 298 299 return 0; 300 } 301 302 /* 303 * run_benchmark - Run a specified benchmark or fill_buf (default benchmark) 304 * in specified signal. Direct benchmark stdio to /dev/null. 305 * @signum: signal number 306 * @info: signal info 307 * @ucontext: user context in signal handling 308 * 309 * Return: void 310 */ 311 void run_benchmark(int signum, siginfo_t *info, void *ucontext) 312 { 313 int operation, ret, malloc_and_init_memory, memflush; 314 unsigned long span, buffer_span; 315 char **benchmark_cmd; 316 char resctrl_val[64]; 317 FILE *fp; 318 319 benchmark_cmd = info->si_ptr; 320 321 /* 322 * Direct stdio of child to /dev/null, so that only parent writes to 323 * stdio (console) 324 */ 325 fp = freopen("/dev/null", "w", stdout); 326 if (!fp) 327 PARENT_EXIT("Unable to direct benchmark status to /dev/null"); 328 329 if (strcmp(benchmark_cmd[0], "fill_buf") == 0) { 330 /* Execute default fill_buf benchmark */ 331 span = strtoul(benchmark_cmd[1], NULL, 10); 332 malloc_and_init_memory = atoi(benchmark_cmd[2]); 333 memflush = atoi(benchmark_cmd[3]); 334 operation = atoi(benchmark_cmd[4]); 335 sprintf(resctrl_val, "%s", benchmark_cmd[5]); 336 337 if (strcmp(resctrl_val, "cqm") != 0) 338 buffer_span = span * MB; 339 else 340 buffer_span = span; 341 342 if (run_fill_buf(buffer_span, malloc_and_init_memory, memflush, 343 operation, resctrl_val)) 344 fprintf(stderr, "Error in running fill buffer\n"); 345 } else { 346 /* Execute specified benchmark */ 347 ret = execvp(benchmark_cmd[0], benchmark_cmd); 348 if (ret) 349 perror("wrong\n"); 350 } 351 352 fclose(stdout); 353 PARENT_EXIT("Unable to run specified benchmark"); 354 } 355 356 /* 357 * create_grp - Create a group only if one doesn't exist 358 * @grp_name: Name of the group 359 * @grp: Full path and name of the group 360 * @parent_grp: Full path and name of the parent group 361 * 362 * Return: 0 on success, non-zero on failure 363 */ 364 static int create_grp(const char *grp_name, char *grp, const char *parent_grp) 365 { 366 int found_grp = 0; 367 struct dirent *ep; 368 DIR *dp; 369 370 /* 371 * At this point, we are guaranteed to have resctrl FS mounted and if 372 * length of grp_name == 0, it means, user wants to use root con_mon 373 * grp, so do nothing 374 */ 375 if (strlen(grp_name) == 0) 376 return 0; 377 378 /* Check if requested grp exists or not */ 379 dp = opendir(parent_grp); 380 if (dp) { 381 while ((ep = readdir(dp)) != NULL) { 382 if (strcmp(ep->d_name, grp_name) == 0) 383 found_grp = 1; 384 } 385 closedir(dp); 386 } else { 387 perror("Unable to open resctrl for group"); 388 389 return -1; 390 } 391 392 /* Requested grp doesn't exist, hence create it */ 393 if (found_grp == 0) { 394 if (mkdir(grp, 0) == -1) { 395 perror("Unable to create group"); 396 397 return -1; 398 } 399 } 400 401 return 0; 402 } 403 404 static int write_pid_to_tasks(char *tasks, pid_t pid) 405 { 406 FILE *fp; 407 408 fp = fopen(tasks, "w"); 409 if (!fp) { 410 perror("Failed to open tasks file"); 411 412 return -1; 413 } 414 if (fprintf(fp, "%d\n", pid) < 0) { 415 perror("Failed to wr pid to tasks file"); 416 fclose(fp); 417 418 return -1; 419 } 420 fclose(fp); 421 422 return 0; 423 } 424 425 /* 426 * write_bm_pid_to_resctrl - Write a PID (i.e. benchmark) to resctrl FS 427 * @bm_pid: PID that should be written 428 * @ctrlgrp: Name of the control monitor group (con_mon grp) 429 * @mongrp: Name of the monitor group (mon grp) 430 * @resctrl_val: Resctrl feature (Eg: mbm, mba.. etc) 431 * 432 * If a con_mon grp is requested, create it and write pid to it, otherwise 433 * write pid to root con_mon grp. 434 * If a mon grp is requested, create it and write pid to it, otherwise 435 * pid is not written, this means that pid is in con_mon grp and hence 436 * should consult con_mon grp's mon_data directory for results. 437 * 438 * Return: 0 on success, non-zero on failure 439 */ 440 int write_bm_pid_to_resctrl(pid_t bm_pid, char *ctrlgrp, char *mongrp, 441 char *resctrl_val) 442 { 443 char controlgroup[128], monitorgroup[512], monitorgroup_p[256]; 444 char tasks[1024]; 445 int ret = 0; 446 447 if (strlen(ctrlgrp)) 448 sprintf(controlgroup, "%s/%s", RESCTRL_PATH, ctrlgrp); 449 else 450 sprintf(controlgroup, "%s", RESCTRL_PATH); 451 452 /* Create control and monitoring group and write pid into it */ 453 ret = create_grp(ctrlgrp, controlgroup, RESCTRL_PATH); 454 if (ret) 455 goto out; 456 sprintf(tasks, "%s/tasks", controlgroup); 457 ret = write_pid_to_tasks(tasks, bm_pid); 458 if (ret) 459 goto out; 460 461 /* Create mon grp and write pid into it for "mbm" and "cqm" test */ 462 if ((strcmp(resctrl_val, "cqm") == 0) || 463 (strcmp(resctrl_val, "mbm") == 0)) { 464 if (strlen(mongrp)) { 465 sprintf(monitorgroup_p, "%s/mon_groups", controlgroup); 466 sprintf(monitorgroup, "%s/%s", monitorgroup_p, mongrp); 467 ret = create_grp(mongrp, monitorgroup, monitorgroup_p); 468 if (ret) 469 goto out; 470 471 sprintf(tasks, "%s/mon_groups/%s/tasks", 472 controlgroup, mongrp); 473 ret = write_pid_to_tasks(tasks, bm_pid); 474 if (ret) 475 goto out; 476 } 477 } 478 479 out: 480 printf("%sok writing benchmark parameters to resctrl FS\n", 481 ret ? "not " : ""); 482 if (ret) 483 perror("# writing to resctrlfs"); 484 485 tests_run++; 486 487 return ret; 488 } 489 490 /* 491 * write_schemata - Update schemata of a con_mon grp 492 * @ctrlgrp: Name of the con_mon grp 493 * @schemata: Schemata that should be updated to 494 * @cpu_no: CPU number that the benchmark PID is binded to 495 * @resctrl_val: Resctrl feature (Eg: mbm, mba.. etc) 496 * 497 * Update schemata of a con_mon grp *only* if requested resctrl feature is 498 * allocation type 499 * 500 * Return: 0 on success, non-zero on failure 501 */ 502 int write_schemata(char *ctrlgrp, char *schemata, int cpu_no, char *resctrl_val) 503 { 504 char controlgroup[1024], schema[1024], reason[64]; 505 int resource_id, ret = 0; 506 FILE *fp; 507 508 if ((strcmp(resctrl_val, "mba") != 0) && 509 (strcmp(resctrl_val, "cat") != 0) && 510 (strcmp(resctrl_val, "cqm") != 0)) 511 return -ENOENT; 512 513 if (!schemata) { 514 printf("# Skipping empty schemata update\n"); 515 516 return -1; 517 } 518 519 if (get_resource_id(cpu_no, &resource_id) < 0) { 520 sprintf(reason, "Failed to get resource id"); 521 ret = -1; 522 523 goto out; 524 } 525 526 if (strlen(ctrlgrp) != 0) 527 sprintf(controlgroup, "%s/%s/schemata", RESCTRL_PATH, ctrlgrp); 528 else 529 sprintf(controlgroup, "%s/schemata", RESCTRL_PATH); 530 531 if (!strcmp(resctrl_val, "cat") || !strcmp(resctrl_val, "cqm")) 532 sprintf(schema, "%s%d%c%s", "L3:", resource_id, '=', schemata); 533 if (strcmp(resctrl_val, "mba") == 0) 534 sprintf(schema, "%s%d%c%s", "MB:", resource_id, '=', schemata); 535 536 fp = fopen(controlgroup, "w"); 537 if (!fp) { 538 sprintf(reason, "Failed to open control group"); 539 ret = -1; 540 541 goto out; 542 } 543 544 if (fprintf(fp, "%s\n", schema) < 0) { 545 sprintf(reason, "Failed to write schemata in control group"); 546 fclose(fp); 547 ret = -1; 548 549 goto out; 550 } 551 fclose(fp); 552 553 out: 554 printf("%sok Write schema \"%s\" to resctrl FS%s%s\n", 555 ret ? "not " : "", schema, ret ? " # " : "", 556 ret ? reason : ""); 557 tests_run++; 558 559 return ret; 560 } 561 562 bool check_resctrlfs_support(void) 563 { 564 FILE *inf = fopen("/proc/filesystems", "r"); 565 DIR *dp; 566 char *res; 567 bool ret = false; 568 569 if (!inf) 570 return false; 571 572 res = fgrep(inf, "nodev\tresctrl\n"); 573 574 if (res) { 575 ret = true; 576 free(res); 577 } 578 579 fclose(inf); 580 581 printf("%sok kernel supports resctrl filesystem\n", ret ? "" : "not "); 582 tests_run++; 583 584 dp = opendir(RESCTRL_PATH); 585 printf("%sok resctrl mountpoint \"%s\" exists\n", 586 dp ? "" : "not ", RESCTRL_PATH); 587 if (dp) 588 closedir(dp); 589 tests_run++; 590 591 printf("# resctrl filesystem %s mounted\n", 592 find_resctrl_mount(NULL) ? "not" : "is"); 593 594 return ret; 595 } 596 597 char *fgrep(FILE *inf, const char *str) 598 { 599 char line[256]; 600 int slen = strlen(str); 601 602 while (!feof(inf)) { 603 if (!fgets(line, 256, inf)) 604 break; 605 if (strncmp(line, str, slen)) 606 continue; 607 608 return strdup(line); 609 } 610 611 return NULL; 612 } 613 614 /* 615 * validate_resctrl_feature_request - Check if requested feature is valid. 616 * @resctrl_val: Requested feature 617 * 618 * Return: 0 on success, non-zero on failure 619 */ 620 bool validate_resctrl_feature_request(char *resctrl_val) 621 { 622 FILE *inf = fopen("/proc/cpuinfo", "r"); 623 bool found = false; 624 char *res; 625 626 if (!inf) 627 return false; 628 629 res = fgrep(inf, "flags"); 630 631 if (res) { 632 char *s = strchr(res, ':'); 633 634 found = s && !strstr(s, resctrl_val); 635 free(res); 636 } 637 fclose(inf); 638 639 return found; 640 } 641 642 int filter_dmesg(void) 643 { 644 char line[1024]; 645 FILE *fp; 646 int pipefds[2]; 647 pid_t pid; 648 int ret; 649 650 ret = pipe(pipefds); 651 if (ret) { 652 perror("pipe"); 653 return ret; 654 } 655 pid = fork(); 656 if (pid == 0) { 657 close(pipefds[0]); 658 dup2(pipefds[1], STDOUT_FILENO); 659 execlp("dmesg", "dmesg", NULL); 660 perror("executing dmesg"); 661 exit(1); 662 } 663 close(pipefds[1]); 664 fp = fdopen(pipefds[0], "r"); 665 if (!fp) { 666 perror("fdopen(pipe)"); 667 kill(pid, SIGTERM); 668 669 return -1; 670 } 671 672 while (fgets(line, 1024, fp)) { 673 if (strstr(line, "intel_rdt:")) 674 printf("# dmesg: %s", line); 675 if (strstr(line, "resctrl:")) 676 printf("# dmesg: %s", line); 677 } 678 fclose(fp); 679 waitpid(pid, NULL, 0); 680 681 return 0; 682 } 683 684 int validate_bw_report_request(char *bw_report) 685 { 686 if (strcmp(bw_report, "reads") == 0) 687 return 0; 688 if (strcmp(bw_report, "writes") == 0) 689 return 0; 690 if (strcmp(bw_report, "nt-writes") == 0) { 691 strcpy(bw_report, "writes"); 692 return 0; 693 } 694 if (strcmp(bw_report, "total") == 0) 695 return 0; 696 697 fprintf(stderr, "Requested iMC B/W report type unavailable\n"); 698 699 return -1; 700 } 701 702 int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, 703 int group_fd, unsigned long flags) 704 { 705 int ret; 706 707 ret = syscall(__NR_perf_event_open, hw_event, pid, cpu, 708 group_fd, flags); 709 return ret; 710 } 711 712 unsigned int count_bits(unsigned long n) 713 { 714 unsigned int count = 0; 715 716 while (n) { 717 count += n & 1; 718 n >>= 1; 719 } 720 721 return count; 722 } 723