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