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
find_resctrl_mount(char * buffer)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 /*
53 * remount_resctrlfs - Remount resctrl FS at /sys/fs/resctrl
54 * @mum_resctrlfs: Should the resctrl FS be remounted?
55 *
56 * If not mounted, mount it.
57 * If mounted and mum_resctrlfs then remount resctrl FS.
58 * If mounted and !mum_resctrlfs then noop
59 *
60 * Return: 0 on success, non-zero on failure
61 */
remount_resctrlfs(bool mum_resctrlfs)62 int remount_resctrlfs(bool mum_resctrlfs)
63 {
64 char mountpoint[256];
65 int ret;
66
67 ret = find_resctrl_mount(mountpoint);
68 if (ret)
69 strcpy(mountpoint, RESCTRL_PATH);
70
71 if (!ret && mum_resctrlfs && umount(mountpoint)) {
72 printf("not ok unmounting \"%s\"\n", mountpoint);
73 perror("# umount");
74 tests_run++;
75 }
76
77 if (!ret && !mum_resctrlfs)
78 return 0;
79
80 ret = mount("resctrl", RESCTRL_PATH, "resctrl", 0, NULL);
81 printf("%sok mounting resctrl to \"%s\"\n", ret ? "not " : "",
82 RESCTRL_PATH);
83 if (ret)
84 perror("# mount");
85
86 tests_run++;
87
88 return ret;
89 }
90
umount_resctrlfs(void)91 int umount_resctrlfs(void)
92 {
93 if (umount(RESCTRL_PATH)) {
94 perror("# Unable to umount resctrl");
95
96 return errno;
97 }
98
99 return 0;
100 }
101
102 /*
103 * get_resource_id - Get socket number/l3 id for a specified CPU
104 * @cpu_no: CPU number
105 * @resource_id: Socket number or l3_id
106 *
107 * Return: >= 0 on success, < 0 on failure.
108 */
get_resource_id(int cpu_no,int * resource_id)109 int get_resource_id(int cpu_no, int *resource_id)
110 {
111 char phys_pkg_path[1024];
112 FILE *fp;
113
114 if (is_amd)
115 sprintf(phys_pkg_path, "%s%d/cache/index3/id",
116 PHYS_ID_PATH, cpu_no);
117 else
118 sprintf(phys_pkg_path, "%s%d/topology/physical_package_id",
119 PHYS_ID_PATH, cpu_no);
120
121 fp = fopen(phys_pkg_path, "r");
122 if (!fp) {
123 perror("Failed to open physical_package_id");
124
125 return -1;
126 }
127 if (fscanf(fp, "%d", resource_id) <= 0) {
128 perror("Could not get socket number or l3 id");
129 fclose(fp);
130
131 return -1;
132 }
133 fclose(fp);
134
135 return 0;
136 }
137
138 /*
139 * get_cache_size - Get cache size for a specified CPU
140 * @cpu_no: CPU number
141 * @cache_type: Cache level L2/L3
142 * @cache_size: pointer to cache_size
143 *
144 * Return: = 0 on success, < 0 on failure.
145 */
get_cache_size(int cpu_no,char * cache_type,unsigned long * cache_size)146 int get_cache_size(int cpu_no, char *cache_type, unsigned long *cache_size)
147 {
148 char cache_path[1024], cache_str[64];
149 int length, i, cache_num;
150 FILE *fp;
151
152 if (!strcmp(cache_type, "L3")) {
153 cache_num = 3;
154 } else if (!strcmp(cache_type, "L2")) {
155 cache_num = 2;
156 } else {
157 perror("Invalid cache level");
158 return -1;
159 }
160
161 sprintf(cache_path, "/sys/bus/cpu/devices/cpu%d/cache/index%d/size",
162 cpu_no, cache_num);
163 fp = fopen(cache_path, "r");
164 if (!fp) {
165 perror("Failed to open cache size");
166
167 return -1;
168 }
169 if (fscanf(fp, "%s", cache_str) <= 0) {
170 perror("Could not get cache_size");
171 fclose(fp);
172
173 return -1;
174 }
175 fclose(fp);
176
177 length = (int)strlen(cache_str);
178
179 *cache_size = 0;
180
181 for (i = 0; i < length; i++) {
182 if ((cache_str[i] >= '0') && (cache_str[i] <= '9'))
183
184 *cache_size = *cache_size * 10 + (cache_str[i] - '0');
185
186 else if (cache_str[i] == 'K')
187
188 *cache_size = *cache_size * 1024;
189
190 else if (cache_str[i] == 'M')
191
192 *cache_size = *cache_size * 1024 * 1024;
193
194 else
195 break;
196 }
197
198 return 0;
199 }
200
201 #define CORE_SIBLINGS_PATH "/sys/bus/cpu/devices/cpu"
202
203 /*
204 * get_cbm_mask - Get cbm mask for given cache
205 * @cache_type: Cache level L2/L3
206 * @cbm_mask: cbm_mask returned as a string
207 *
208 * Return: = 0 on success, < 0 on failure.
209 */
get_cbm_mask(char * cache_type,char * cbm_mask)210 int get_cbm_mask(char *cache_type, char *cbm_mask)
211 {
212 char cbm_mask_path[1024];
213 FILE *fp;
214
215 if (!cbm_mask)
216 return -1;
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 */
get_core_sibling(int cpu_no)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 */
taskset_benchmark(pid_t bm_pid,int cpu_no)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 */
run_benchmark(int signum,siginfo_t * info,void * ucontext)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 (strncmp(resctrl_val, CQM_STR, sizeof(CQM_STR)))
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 */
create_grp(const char * grp_name,char * grp,const char * parent_grp)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
write_pid_to_tasks(char * tasks,pid_t pid)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 */
write_bm_pid_to_resctrl(pid_t bm_pid,char * ctrlgrp,char * mongrp,char * resctrl_val)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 (!strncmp(resctrl_val, CQM_STR, sizeof(CQM_STR)) ||
463 !strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR))) {
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 */
write_schemata(char * ctrlgrp,char * schemata,int cpu_no,char * resctrl_val)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 (strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)) &&
509 strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) &&
510 strncmp(resctrl_val, CQM_STR, sizeof(CQM_STR)))
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 (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) ||
532 !strncmp(resctrl_val, CQM_STR, sizeof(CQM_STR)))
533 sprintf(schema, "%s%d%c%s", "L3:", resource_id, '=', schemata);
534 if (!strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)))
535 sprintf(schema, "%s%d%c%s", "MB:", resource_id, '=', schemata);
536
537 fp = fopen(controlgroup, "w");
538 if (!fp) {
539 sprintf(reason, "Failed to open control group");
540 ret = -1;
541
542 goto out;
543 }
544
545 if (fprintf(fp, "%s\n", schema) < 0) {
546 sprintf(reason, "Failed to write schemata in control group");
547 fclose(fp);
548 ret = -1;
549
550 goto out;
551 }
552 fclose(fp);
553
554 out:
555 printf("%sok Write schema \"%s\" to resctrl FS%s%s\n",
556 ret ? "not " : "", schema, ret ? " # " : "",
557 ret ? reason : "");
558 tests_run++;
559
560 return ret;
561 }
562
check_resctrlfs_support(void)563 bool check_resctrlfs_support(void)
564 {
565 FILE *inf = fopen("/proc/filesystems", "r");
566 DIR *dp;
567 char *res;
568 bool ret = false;
569
570 if (!inf)
571 return false;
572
573 res = fgrep(inf, "nodev\tresctrl\n");
574
575 if (res) {
576 ret = true;
577 free(res);
578 }
579
580 fclose(inf);
581
582 printf("%sok kernel supports resctrl filesystem\n", ret ? "" : "not ");
583 tests_run++;
584
585 dp = opendir(RESCTRL_PATH);
586 printf("%sok resctrl mountpoint \"%s\" exists\n",
587 dp ? "" : "not ", RESCTRL_PATH);
588 if (dp)
589 closedir(dp);
590 tests_run++;
591
592 printf("# resctrl filesystem %s mounted\n",
593 find_resctrl_mount(NULL) ? "not" : "is");
594
595 return ret;
596 }
597
fgrep(FILE * inf,const char * str)598 char *fgrep(FILE *inf, const char *str)
599 {
600 char line[256];
601 int slen = strlen(str);
602
603 while (!feof(inf)) {
604 if (!fgets(line, 256, inf))
605 break;
606 if (strncmp(line, str, slen))
607 continue;
608
609 return strdup(line);
610 }
611
612 return NULL;
613 }
614
615 /*
616 * validate_resctrl_feature_request - Check if requested feature is valid.
617 * @resctrl_val: Requested feature
618 *
619 * Return: 0 on success, non-zero on failure
620 */
validate_resctrl_feature_request(char * resctrl_val)621 bool validate_resctrl_feature_request(char *resctrl_val)
622 {
623 FILE *inf = fopen("/proc/cpuinfo", "r");
624 bool found = false;
625 char *res;
626
627 if (!inf)
628 return false;
629
630 res = fgrep(inf, "flags");
631
632 if (res) {
633 char *s = strchr(res, ':');
634
635 found = s && !strstr(s, resctrl_val);
636 free(res);
637 }
638 fclose(inf);
639
640 return found;
641 }
642
filter_dmesg(void)643 int filter_dmesg(void)
644 {
645 char line[1024];
646 FILE *fp;
647 int pipefds[2];
648 pid_t pid;
649 int ret;
650
651 ret = pipe(pipefds);
652 if (ret) {
653 perror("pipe");
654 return ret;
655 }
656 pid = fork();
657 if (pid == 0) {
658 close(pipefds[0]);
659 dup2(pipefds[1], STDOUT_FILENO);
660 execlp("dmesg", "dmesg", NULL);
661 perror("executing dmesg");
662 exit(1);
663 }
664 close(pipefds[1]);
665 fp = fdopen(pipefds[0], "r");
666 if (!fp) {
667 perror("fdopen(pipe)");
668 kill(pid, SIGTERM);
669
670 return -1;
671 }
672
673 while (fgets(line, 1024, fp)) {
674 if (strstr(line, "intel_rdt:"))
675 printf("# dmesg: %s", line);
676 if (strstr(line, "resctrl:"))
677 printf("# dmesg: %s", line);
678 }
679 fclose(fp);
680 waitpid(pid, NULL, 0);
681
682 return 0;
683 }
684
validate_bw_report_request(char * bw_report)685 int validate_bw_report_request(char *bw_report)
686 {
687 if (strcmp(bw_report, "reads") == 0)
688 return 0;
689 if (strcmp(bw_report, "writes") == 0)
690 return 0;
691 if (strcmp(bw_report, "nt-writes") == 0) {
692 strcpy(bw_report, "writes");
693 return 0;
694 }
695 if (strcmp(bw_report, "total") == 0)
696 return 0;
697
698 fprintf(stderr, "Requested iMC B/W report type unavailable\n");
699
700 return -1;
701 }
702
perf_event_open(struct perf_event_attr * hw_event,pid_t pid,int cpu,int group_fd,unsigned long flags)703 int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu,
704 int group_fd, unsigned long flags)
705 {
706 int ret;
707
708 ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
709 group_fd, flags);
710 return ret;
711 }
712
count_bits(unsigned long n)713 unsigned int count_bits(unsigned long n)
714 {
715 unsigned int count = 0;
716
717 while (n) {
718 count += n & 1;
719 n >>= 1;
720 }
721
722 return count;
723 }
724