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 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 */
remount_resctrlfs(bool mum_resctrlfs)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
umount_resctrlfs(void)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 */
get_resource_id(int cpu_no,int * resource_id)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 */
get_cache_size(int cpu_no,char * cache_type,unsigned long * cache_size)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 */
get_cbm_mask(char * cache_type)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 */
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 (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 */
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 ((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 */
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 ((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
check_resctrlfs_support(void)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
fgrep(FILE * inf,const char * str)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 */
validate_resctrl_feature_request(char * resctrl_val)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
filter_dmesg(void)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
validate_bw_report_request(char * bw_report)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
perf_event_open(struct perf_event_attr * hw_event,pid_t pid,int cpu,int group_fd,unsigned long flags)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
count_bits(unsigned long n)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
