1
2
3
4
5
6
7
8
9
10
11#include "resctrl.h"
12
13static 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
52
53
54
55
56
57
58
59
60int remount_resctrlfs(bool mum_resctrlfs)
61{
62 char mountpoint[256];
63 int ret;
64
65 ret = find_resctrl_mount(mountpoint);
66 if (ret)
67 strcpy(mountpoint, RESCTRL_PATH);
68
69 if (!ret && mum_resctrlfs && umount(mountpoint))
70 ksft_print_msg("Fail: unmounting \"%s\"\n", mountpoint);
71
72 if (!ret && !mum_resctrlfs)
73 return 0;
74
75 ksft_print_msg("Mounting resctrl to \"%s\"\n", RESCTRL_PATH);
76 ret = mount("resctrl", RESCTRL_PATH, "resctrl", 0, NULL);
77 if (ret)
78 perror("# mount");
79
80 return ret;
81}
82
83int umount_resctrlfs(void)
84{
85 if (find_resctrl_mount(NULL))
86 return 0;
87
88 if (umount(RESCTRL_PATH)) {
89 perror("# Unable to umount resctrl");
90
91 return errno;
92 }
93
94 return 0;
95}
96
97
98
99
100
101
102
103
104int get_resource_id(int cpu_no, int *resource_id)
105{
106 char phys_pkg_path[1024];
107 FILE *fp;
108
109 if (is_amd)
110 sprintf(phys_pkg_path, "%s%d/cache/index3/id",
111 PHYS_ID_PATH, cpu_no);
112 else
113 sprintf(phys_pkg_path, "%s%d/topology/physical_package_id",
114 PHYS_ID_PATH, cpu_no);
115
116 fp = fopen(phys_pkg_path, "r");
117 if (!fp) {
118 perror("Failed to open physical_package_id");
119
120 return -1;
121 }
122 if (fscanf(fp, "%d", resource_id) <= 0) {
123 perror("Could not get socket number or l3 id");
124 fclose(fp);
125
126 return -1;
127 }
128 fclose(fp);
129
130 return 0;
131}
132
133
134
135
136
137
138
139
140
141int get_cache_size(int cpu_no, char *cache_type, unsigned long *cache_size)
142{
143 char cache_path[1024], cache_str[64];
144 int length, i, cache_num;
145 FILE *fp;
146
147 if (!strcmp(cache_type, "L3")) {
148 cache_num = 3;
149 } else if (!strcmp(cache_type, "L2")) {
150 cache_num = 2;
151 } else {
152 perror("Invalid cache level");
153 return -1;
154 }
155
156 sprintf(cache_path, "/sys/bus/cpu/devices/cpu%d/cache/index%d/size",
157 cpu_no, cache_num);
158 fp = fopen(cache_path, "r");
159 if (!fp) {
160 perror("Failed to open cache size");
161
162 return -1;
163 }
164 if (fscanf(fp, "%s", cache_str) <= 0) {
165 perror("Could not get cache_size");
166 fclose(fp);
167
168 return -1;
169 }
170 fclose(fp);
171
172 length = (int)strlen(cache_str);
173
174 *cache_size = 0;
175
176 for (i = 0; i < length; i++) {
177 if ((cache_str[i] >= '0') && (cache_str[i] <= '9'))
178
179 *cache_size = *cache_size * 10 + (cache_str[i] - '0');
180
181 else if (cache_str[i] == 'K')
182
183 *cache_size = *cache_size * 1024;
184
185 else if (cache_str[i] == 'M')
186
187 *cache_size = *cache_size * 1024 * 1024;
188
189 else
190 break;
191 }
192
193 return 0;
194}
195
196#define CORE_SIBLINGS_PATH "/sys/bus/cpu/devices/cpu"
197
198
199
200
201
202
203
204
205int get_cbm_mask(char *cache_type, char *cbm_mask)
206{
207 char cbm_mask_path[1024];
208 FILE *fp;
209
210 if (!cbm_mask)
211 return -1;
212
213 sprintf(cbm_mask_path, "%s/%s/cbm_mask", CBM_MASK_PATH, cache_type);
214
215 fp = fopen(cbm_mask_path, "r");
216 if (!fp) {
217 perror("Failed to open cache level");
218
219 return -1;
220 }
221 if (fscanf(fp, "%s", cbm_mask) <= 0) {
222 perror("Could not get max cbm_mask");
223 fclose(fp);
224
225 return -1;
226 }
227 fclose(fp);
228
229 return 0;
230}
231
232
233
234
235
236
237
238int get_core_sibling(int cpu_no)
239{
240 char core_siblings_path[1024], cpu_list_str[64];
241 int sibling_cpu_no = -1;
242 FILE *fp;
243
244 sprintf(core_siblings_path, "%s%d/topology/core_siblings_list",
245 CORE_SIBLINGS_PATH, cpu_no);
246
247 fp = fopen(core_siblings_path, "r");
248 if (!fp) {
249 perror("Failed to open core siblings path");
250
251 return -1;
252 }
253 if (fscanf(fp, "%s", cpu_list_str) <= 0) {
254 perror("Could not get core_siblings list");
255 fclose(fp);
256
257 return -1;
258 }
259 fclose(fp);
260
261 char *token = strtok(cpu_list_str, "-,");
262
263 while (token) {
264 sibling_cpu_no = atoi(token);
265
266 if (sibling_cpu_no != 0 && sibling_cpu_no != cpu_no)
267 break;
268 token = strtok(NULL, "-,");
269 }
270
271 return sibling_cpu_no;
272}
273
274
275
276
277
278
279
280
281int taskset_benchmark(pid_t bm_pid, int cpu_no)
282{
283 cpu_set_t my_set;
284
285 CPU_ZERO(&my_set);
286 CPU_SET(cpu_no, &my_set);
287
288 if (sched_setaffinity(bm_pid, sizeof(cpu_set_t), &my_set)) {
289 perror("Unable to taskset benchmark");
290
291 return -1;
292 }
293
294 return 0;
295}
296
297
298
299
300
301
302
303
304
305
306void run_benchmark(int signum, siginfo_t *info, void *ucontext)
307{
308 int operation, ret, malloc_and_init_memory, memflush;
309 unsigned long span, buffer_span;
310 char **benchmark_cmd;
311 char resctrl_val[64];
312 FILE *fp;
313
314 benchmark_cmd = info->si_ptr;
315
316
317
318
319
320 fp = freopen("/dev/null", "w", stdout);
321 if (!fp)
322 PARENT_EXIT("Unable to direct benchmark status to /dev/null");
323
324 if (strcmp(benchmark_cmd[0], "fill_buf") == 0) {
325
326 span = strtoul(benchmark_cmd[1], NULL, 10);
327 malloc_and_init_memory = atoi(benchmark_cmd[2]);
328 memflush = atoi(benchmark_cmd[3]);
329 operation = atoi(benchmark_cmd[4]);
330 sprintf(resctrl_val, "%s", benchmark_cmd[5]);
331
332 if (strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)))
333 buffer_span = span * MB;
334 else
335 buffer_span = span;
336
337 if (run_fill_buf(buffer_span, malloc_and_init_memory, memflush,
338 operation, resctrl_val))
339 fprintf(stderr, "Error in running fill buffer\n");
340 } else {
341
342 ret = execvp(benchmark_cmd[0], benchmark_cmd);
343 if (ret)
344 perror("wrong\n");
345 }
346
347 fclose(stdout);
348 PARENT_EXIT("Unable to run specified benchmark");
349}
350
351
352
353
354
355
356
357
358
359static int create_grp(const char *grp_name, char *grp, const char *parent_grp)
360{
361 int found_grp = 0;
362 struct dirent *ep;
363 DIR *dp;
364
365
366
367
368
369
370 if (strlen(grp_name) == 0)
371 return 0;
372
373
374 dp = opendir(parent_grp);
375 if (dp) {
376 while ((ep = readdir(dp)) != NULL) {
377 if (strcmp(ep->d_name, grp_name) == 0)
378 found_grp = 1;
379 }
380 closedir(dp);
381 } else {
382 perror("Unable to open resctrl for group");
383
384 return -1;
385 }
386
387
388 if (found_grp == 0) {
389 if (mkdir(grp, 0) == -1) {
390 perror("Unable to create group");
391
392 return -1;
393 }
394 }
395
396 return 0;
397}
398
399static int write_pid_to_tasks(char *tasks, pid_t pid)
400{
401 FILE *fp;
402
403 fp = fopen(tasks, "w");
404 if (!fp) {
405 perror("Failed to open tasks file");
406
407 return -1;
408 }
409 if (fprintf(fp, "%d\n", pid) < 0) {
410 perror("Failed to wr pid to tasks file");
411 fclose(fp);
412
413 return -1;
414 }
415 fclose(fp);
416
417 return 0;
418}
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435int write_bm_pid_to_resctrl(pid_t bm_pid, char *ctrlgrp, char *mongrp,
436 char *resctrl_val)
437{
438 char controlgroup[128], monitorgroup[512], monitorgroup_p[256];
439 char tasks[1024];
440 int ret = 0;
441
442 if (strlen(ctrlgrp))
443 sprintf(controlgroup, "%s/%s", RESCTRL_PATH, ctrlgrp);
444 else
445 sprintf(controlgroup, "%s", RESCTRL_PATH);
446
447
448 ret = create_grp(ctrlgrp, controlgroup, RESCTRL_PATH);
449 if (ret)
450 goto out;
451 sprintf(tasks, "%s/tasks", controlgroup);
452 ret = write_pid_to_tasks(tasks, bm_pid);
453 if (ret)
454 goto out;
455
456
457 if (!strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)) ||
458 !strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR))) {
459 if (strlen(mongrp)) {
460 sprintf(monitorgroup_p, "%s/mon_groups", controlgroup);
461 sprintf(monitorgroup, "%s/%s", monitorgroup_p, mongrp);
462 ret = create_grp(mongrp, monitorgroup, monitorgroup_p);
463 if (ret)
464 goto out;
465
466 sprintf(tasks, "%s/mon_groups/%s/tasks",
467 controlgroup, mongrp);
468 ret = write_pid_to_tasks(tasks, bm_pid);
469 if (ret)
470 goto out;
471 }
472 }
473
474out:
475 ksft_print_msg("Writing benchmark parameters to resctrl FS\n");
476 if (ret)
477 perror("# writing to resctrlfs");
478
479 return ret;
480}
481
482
483
484
485
486
487
488
489
490
491
492
493
494int write_schemata(char *ctrlgrp, char *schemata, int cpu_no, char *resctrl_val)
495{
496 char controlgroup[1024], schema[1024], reason[64];
497 int resource_id, ret = 0;
498 FILE *fp;
499
500 if (strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)) &&
501 strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) &&
502 strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)))
503 return -ENOENT;
504
505 if (!schemata) {
506 ksft_print_msg("Skipping empty schemata update\n");
507
508 return -1;
509 }
510
511 if (get_resource_id(cpu_no, &resource_id) < 0) {
512 sprintf(reason, "Failed to get resource id");
513 ret = -1;
514
515 goto out;
516 }
517
518 if (strlen(ctrlgrp) != 0)
519 sprintf(controlgroup, "%s/%s/schemata", RESCTRL_PATH, ctrlgrp);
520 else
521 sprintf(controlgroup, "%s/schemata", RESCTRL_PATH);
522
523 if (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) ||
524 !strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)))
525 sprintf(schema, "%s%d%c%s", "L3:", resource_id, '=', schemata);
526 if (!strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)))
527 sprintf(schema, "%s%d%c%s", "MB:", resource_id, '=', schemata);
528
529 fp = fopen(controlgroup, "w");
530 if (!fp) {
531 sprintf(reason, "Failed to open control group");
532 ret = -1;
533
534 goto out;
535 }
536
537 if (fprintf(fp, "%s\n", schema) < 0) {
538 sprintf(reason, "Failed to write schemata in control group");
539 fclose(fp);
540 ret = -1;
541
542 goto out;
543 }
544 fclose(fp);
545
546out:
547 ksft_print_msg("Write schema \"%s\" to resctrl FS%s%s\n",
548 schema, ret ? " # " : "",
549 ret ? reason : "");
550
551 return ret;
552}
553
554bool check_resctrlfs_support(void)
555{
556 FILE *inf = fopen("/proc/filesystems", "r");
557 DIR *dp;
558 char *res;
559 bool ret = false;
560
561 if (!inf)
562 return false;
563
564 res = fgrep(inf, "nodev\tresctrl\n");
565
566 if (res) {
567 ret = true;
568 free(res);
569 }
570
571 fclose(inf);
572
573 ksft_print_msg("%s Check kernel supports resctrl filesystem\n",
574 ret ? "Pass:" : "Fail:");
575
576 if (!ret)
577 return ret;
578
579 dp = opendir(RESCTRL_PATH);
580 ksft_print_msg("%s Check resctrl mountpoint \"%s\" exists\n",
581 dp ? "Pass:" : "Fail:", RESCTRL_PATH);
582 if (dp)
583 closedir(dp);
584
585 ksft_print_msg("resctrl filesystem %s mounted\n",
586 find_resctrl_mount(NULL) ? "not" : "is");
587
588 return ret;
589}
590
591char *fgrep(FILE *inf, const char *str)
592{
593 char line[256];
594 int slen = strlen(str);
595
596 while (!feof(inf)) {
597 if (!fgets(line, 256, inf))
598 break;
599 if (strncmp(line, str, slen))
600 continue;
601
602 return strdup(line);
603 }
604
605 return NULL;
606}
607
608
609
610
611
612
613
614bool validate_resctrl_feature_request(const char *resctrl_val)
615{
616 struct stat statbuf;
617 bool found = false;
618 char *res;
619 FILE *inf;
620
621 if (!resctrl_val)
622 return false;
623
624 if (remount_resctrlfs(false))
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
666int 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 pid = fork();
680 if (pid == 0) {
681 close(pipefds[0]);
682 dup2(pipefds[1], STDOUT_FILENO);
683 execlp("dmesg", "dmesg", NULL);
684 perror("executing dmesg");
685 exit(1);
686 }
687 close(pipefds[1]);
688 fp = fdopen(pipefds[0], "r");
689 if (!fp) {
690 perror("fdopen(pipe)");
691 kill(pid, SIGTERM);
692
693 return -1;
694 }
695
696 while (fgets(line, 1024, fp)) {
697 if (strstr(line, "intel_rdt:"))
698 ksft_print_msg("dmesg: %s", line);
699 if (strstr(line, "resctrl:"))
700 ksft_print_msg("dmesg: %s", line);
701 }
702 fclose(fp);
703 waitpid(pid, NULL, 0);
704
705 return 0;
706}
707
708int validate_bw_report_request(char *bw_report)
709{
710 if (strcmp(bw_report, "reads") == 0)
711 return 0;
712 if (strcmp(bw_report, "writes") == 0)
713 return 0;
714 if (strcmp(bw_report, "nt-writes") == 0) {
715 strcpy(bw_report, "writes");
716 return 0;
717 }
718 if (strcmp(bw_report, "total") == 0)
719 return 0;
720
721 fprintf(stderr, "Requested iMC B/W report type unavailable\n");
722
723 return -1;
724}
725
726int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu,
727 int group_fd, unsigned long flags)
728{
729 int ret;
730
731 ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
732 group_fd, flags);
733 return ret;
734}
735
736unsigned int count_bits(unsigned long n)
737{
738 unsigned int count = 0;
739
740 while (n) {
741 count += n & 1;
742 n >>= 1;
743 }
744
745 return count;
746}
747