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
 13int tests_run;
 14
 15static 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
 52char 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 */
 64int 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
 93int 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 */
111int 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 */
148int 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 */
213int 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 */
243int 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 */
286int 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 */
311void 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 */
364static 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
404static 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 */
440int 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
479out:
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 */
502int 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
553out:
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
562bool 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
597char *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 */
620bool 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
642int 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
684int 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
702int 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
712unsigned 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}