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 <fcntl.h>
 12#include <limits.h>
 13
 14#include "resctrl.h"
 15
 16static int find_resctrl_mount(char *buffer)
 17{
 18	FILE *mounts;
 19	char line[256], *fs, *mntpoint;
 20
 21	mounts = fopen("/proc/mounts", "r");
 22	if (!mounts) {
 23		perror("/proc/mounts");
 24		return -ENXIO;
 25	}
 26	while (!feof(mounts)) {
 27		if (!fgets(line, 256, mounts))
 28			break;
 29		fs = strtok(line, " \t");
 30		if (!fs)
 31			continue;
 32		mntpoint = strtok(NULL, " \t");
 33		if (!mntpoint)
 34			continue;
 35		fs = strtok(NULL, " \t");
 36		if (!fs)
 37			continue;
 38		if (strcmp(fs, "resctrl"))
 39			continue;
 40
 41		fclose(mounts);
 42		if (buffer)
 43			strncpy(buffer, mntpoint, 256);
 44
 45		return 0;
 46	}
 47
 48	fclose(mounts);
 49
 50	return -ENOENT;
 51}
 52
 53/*
 54 * mount_resctrlfs - Mount resctrl FS at /sys/fs/resctrl
 55 *
 56 * Mounts resctrl FS. Fails if resctrl FS is already mounted to avoid
 57 * pre-existing settings interfering with the test results.
 58 *
 59 * Return: 0 on success, non-zero on failure
 60 */
 61int mount_resctrlfs(void)
 62{
 63	int ret;
 64
 65	ret = find_resctrl_mount(NULL);
 66	if (ret != -ENOENT)
 67		return -1;
 68
 69	ksft_print_msg("Mounting resctrl to \"%s\"\n", RESCTRL_PATH);
 70	ret = mount("resctrl", RESCTRL_PATH, "resctrl", 0, NULL);
 71	if (ret)
 72		perror("# mount");
 73
 74	return ret;
 75}
 76
 77int umount_resctrlfs(void)
 78{
 79	char mountpoint[256];
 80	int ret;
 81
 82	ret = find_resctrl_mount(mountpoint);
 83	if (ret == -ENOENT)
 84		return 0;
 85	if (ret)
 86		return ret;
 87
 88	if (umount(mountpoint)) {
 89		perror("# Unable to umount resctrl");
 90
 91		return errno;
 92	}
 93
 94	return 0;
 95}
 96
 97/*
 98 * get_resource_id - Get socket number/l3 id for a specified CPU
 99 * @cpu_no:	CPU number
100 * @resource_id: Socket number or l3_id
101 *
102 * Return: >= 0 on success, < 0 on failure.
103 */
104int get_resource_id(int cpu_no, int *resource_id)
105{
106	char phys_pkg_path[1024];
107	FILE *fp;
108
109	if (get_vendor() == ARCH_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 * get_cache_size - Get cache size for a specified CPU
135 * @cpu_no:	CPU number
136 * @cache_type:	Cache level L2/L3
137 * @cache_size:	pointer to cache_size
138 *
139 * Return: = 0 on success, < 0 on failure.
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 * get_cbm_mask - Get cbm mask for given cache
200 * @cache_type:	Cache level L2/L3
201 * @cbm_mask:	cbm_mask returned as a string
202 *
203 * Return: = 0 on success, < 0 on failure.
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", INFO_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 * get_core_sibling - Get sibling core id from the same socket for given CPU
234 * @cpu_no:	CPU number
235 *
236 * Return:	> 0 on success, < 0 on failure.
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		/* Skipping core 0 as we don't want to run test on core 0 */
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 * taskset_benchmark - Taskset PID (i.e. benchmark) to a specified cpu
276 * @bm_pid:	PID that should be binded
277 * @cpu_no:	CPU number at which the PID would be binded
278 *
279 * Return: 0 on success, non-zero on failure
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 * create_grp - Create a group only if one doesn't exist
299 * @grp_name:	Name of the group
300 * @grp:	Full path and name of the group
301 * @parent_grp:	Full path and name of the parent group
302 *
303 * Return: 0 on success, non-zero on failure
304 */
305static int create_grp(const char *grp_name, char *grp, const char *parent_grp)
306{
307	int found_grp = 0;
308	struct dirent *ep;
309	DIR *dp;
310
311	/*
312	 * At this point, we are guaranteed to have resctrl FS mounted and if
313	 * length of grp_name == 0, it means, user wants to use root con_mon
314	 * grp, so do nothing
315	 */
316	if (strlen(grp_name) == 0)
317		return 0;
318
319	/* Check if requested grp exists or not */
320	dp = opendir(parent_grp);
321	if (dp) {
322		while ((ep = readdir(dp)) != NULL) {
323			if (strcmp(ep->d_name, grp_name) == 0)
324				found_grp = 1;
325		}
326		closedir(dp);
327	} else {
328		perror("Unable to open resctrl for group");
329
330		return -1;
331	}
332
333	/* Requested grp doesn't exist, hence create it */
334	if (found_grp == 0) {
335		if (mkdir(grp, 0) == -1) {
336			perror("Unable to create group");
337
338			return -1;
339		}
340	}
341
342	return 0;
343}
344
345static int write_pid_to_tasks(char *tasks, pid_t pid)
346{
347	FILE *fp;
348
349	fp = fopen(tasks, "w");
350	if (!fp) {
351		perror("Failed to open tasks file");
352
353		return -1;
354	}
355	if (fprintf(fp, "%d\n", pid) < 0) {
356		perror("Failed to wr pid to tasks file");
357		fclose(fp);
358
359		return -1;
360	}
361	fclose(fp);
362
363	return 0;
364}
365
366/*
367 * write_bm_pid_to_resctrl - Write a PID (i.e. benchmark) to resctrl FS
368 * @bm_pid:		PID that should be written
369 * @ctrlgrp:		Name of the control monitor group (con_mon grp)
370 * @mongrp:		Name of the monitor group (mon grp)
371 * @resctrl_val:	Resctrl feature (Eg: mbm, mba.. etc)
372 *
373 * If a con_mon grp is requested, create it and write pid to it, otherwise
374 * write pid to root con_mon grp.
375 * If a mon grp is requested, create it and write pid to it, otherwise
376 * pid is not written, this means that pid is in con_mon grp and hence
377 * should consult con_mon grp's mon_data directory for results.
378 *
379 * Return: 0 on success, non-zero on failure
380 */
381int write_bm_pid_to_resctrl(pid_t bm_pid, char *ctrlgrp, char *mongrp,
382			    char *resctrl_val)
383{
384	char controlgroup[128], monitorgroup[512], monitorgroup_p[256];
385	char tasks[1024];
386	int ret = 0;
387
388	if (strlen(ctrlgrp))
389		sprintf(controlgroup, "%s/%s", RESCTRL_PATH, ctrlgrp);
390	else
391		sprintf(controlgroup, "%s", RESCTRL_PATH);
392
393	/* Create control and monitoring group and write pid into it */
394	ret = create_grp(ctrlgrp, controlgroup, RESCTRL_PATH);
395	if (ret)
396		goto out;
397	sprintf(tasks, "%s/tasks", controlgroup);
398	ret = write_pid_to_tasks(tasks, bm_pid);
399	if (ret)
400		goto out;
401
402	/* Create mon grp and write pid into it for "mbm" and "cmt" test */
403	if (!strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)) ||
404	    !strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR))) {
405		if (strlen(mongrp)) {
406			sprintf(monitorgroup_p, "%s/mon_groups", controlgroup);
407			sprintf(monitorgroup, "%s/%s", monitorgroup_p, mongrp);
408			ret = create_grp(mongrp, monitorgroup, monitorgroup_p);
409			if (ret)
410				goto out;
411
412			sprintf(tasks, "%s/mon_groups/%s/tasks",
413				controlgroup, mongrp);
414			ret = write_pid_to_tasks(tasks, bm_pid);
415			if (ret)
416				goto out;
417		}
418	}
419
420out:
421	ksft_print_msg("Writing benchmark parameters to resctrl FS\n");
422	if (ret)
423		perror("# writing to resctrlfs");
424
425	return ret;
426}
427
428/*
429 * write_schemata - Update schemata of a con_mon grp
430 * @ctrlgrp:		Name of the con_mon grp
431 * @schemata:		Schemata that should be updated to
432 * @cpu_no:		CPU number that the benchmark PID is binded to
433 * @resctrl_val:	Resctrl feature (Eg: mbm, mba.. etc)
434 *
435 * Update schemata of a con_mon grp *only* if requested resctrl feature is
436 * allocation type
437 *
438 * Return: 0 on success, non-zero on failure
439 */
440int write_schemata(char *ctrlgrp, char *schemata, int cpu_no, char *resctrl_val)
441{
442	char controlgroup[1024], reason[128], schema[1024] = {};
443	int resource_id, fd, schema_len = -1, ret = 0;
444
445	if (strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)) &&
446	    strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR)) &&
447	    strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) &&
448	    strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)))
449		return -ENOENT;
450
451	if (!schemata) {
452		ksft_print_msg("Skipping empty schemata update\n");
453
454		return -1;
455	}
456
457	if (get_resource_id(cpu_no, &resource_id) < 0) {
458		sprintf(reason, "Failed to get resource id");
459		ret = -1;
460
461		goto out;
462	}
463
464	if (strlen(ctrlgrp) != 0)
465		sprintf(controlgroup, "%s/%s/schemata", RESCTRL_PATH, ctrlgrp);
466	else
467		sprintf(controlgroup, "%s/schemata", RESCTRL_PATH);
468
469	if (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)) ||
470	    !strncmp(resctrl_val, CMT_STR, sizeof(CMT_STR)))
471		schema_len = snprintf(schema, sizeof(schema), "%s%d%c%s\n",
472				      "L3:", resource_id, '=', schemata);
473	if (!strncmp(resctrl_val, MBA_STR, sizeof(MBA_STR)) ||
474	    !strncmp(resctrl_val, MBM_STR, sizeof(MBM_STR)))
475		schema_len = snprintf(schema, sizeof(schema), "%s%d%c%s\n",
476				      "MB:", resource_id, '=', schemata);
477	if (schema_len < 0 || schema_len >= sizeof(schema)) {
478		snprintf(reason, sizeof(reason),
479			 "snprintf() failed with return value : %d", schema_len);
480		ret = -1;
481		goto out;
482	}
483
484	fd = open(controlgroup, O_WRONLY);
485	if (fd < 0) {
486		snprintf(reason, sizeof(reason),
487			 "open() failed : %s", strerror(errno));
488		ret = -1;
489
490		goto err_schema_not_empty;
491	}
492	if (write(fd, schema, schema_len) < 0) {
493		snprintf(reason, sizeof(reason),
494			 "write() failed : %s", strerror(errno));
495		close(fd);
496		ret = -1;
497
498		goto err_schema_not_empty;
499	}
500	close(fd);
501
502err_schema_not_empty:
503	schema[schema_len - 1] = 0;
504out:
505	ksft_print_msg("Write schema \"%s\" to resctrl FS%s%s\n",
506		       schema, ret ? " # " : "",
507		       ret ? reason : "");
508
509	return ret;
510}
511
512bool check_resctrlfs_support(void)
513{
514	FILE *inf = fopen("/proc/filesystems", "r");
515	DIR *dp;
516	char *res;
517	bool ret = false;
518
519	if (!inf)
520		return false;
521
522	res = fgrep(inf, "nodev\tresctrl\n");
523
524	if (res) {
525		ret = true;
526		free(res);
527	}
528
529	fclose(inf);
530
531	ksft_print_msg("%s Check kernel supports resctrl filesystem\n",
532		       ret ? "Pass:" : "Fail:");
533
534	if (!ret)
535		return ret;
536
537	dp = opendir(RESCTRL_PATH);
538	ksft_print_msg("%s Check resctrl mountpoint \"%s\" exists\n",
539		       dp ? "Pass:" : "Fail:", RESCTRL_PATH);
540	if (dp)
541		closedir(dp);
542
543	ksft_print_msg("resctrl filesystem %s mounted\n",
544		       find_resctrl_mount(NULL) ? "not" : "is");
545
546	return ret;
547}
548
549char *fgrep(FILE *inf, const char *str)
550{
551	char line[256];
552	int slen = strlen(str);
553
554	while (!feof(inf)) {
555		if (!fgets(line, 256, inf))
556			break;
557		if (strncmp(line, str, slen))
558			continue;
559
560		return strdup(line);
561	}
562
563	return NULL;
564}
565
566/*
567 * validate_resctrl_feature_request - Check if requested feature is valid.
568 * @resource:	Required resource (e.g., MB, L3, L2, L3_MON, etc.)
569 * @feature:	Required monitor feature (in mon_features file). Can only be
570 *		set for L3_MON. Must be NULL for all other resources.
571 *
572 * Return: True if the resource/feature is supported, else false. False is
573 *         also returned if resctrl FS is not mounted.
574 */
575bool validate_resctrl_feature_request(const char *resource, const char *feature)
576{
577	char res_path[PATH_MAX];
578	struct stat statbuf;
579	char *res;
580	FILE *inf;
581	int ret;
582
583	if (!resource)
584		return false;
585
586	ret = find_resctrl_mount(NULL);
587	if (ret)
588		return false;
589
590	snprintf(res_path, sizeof(res_path), "%s/%s", INFO_PATH, resource);
591
592	if (stat(res_path, &statbuf))
593		return false;
594
595	if (!feature)
596		return true;
597
598	snprintf(res_path, sizeof(res_path), "%s/%s/mon_features", INFO_PATH, resource);
599	inf = fopen(res_path, "r");
600	if (!inf)
601		return false;
602
603	res = fgrep(inf, feature);
604	free(res);
605	fclose(inf);
606
607	return !!res;
608}
609
610int filter_dmesg(void)
611{
612	char line[1024];
613	FILE *fp;
614	int pipefds[2];
615	pid_t pid;
616	int ret;
617
618	ret = pipe(pipefds);
619	if (ret) {
620		perror("pipe");
621		return ret;
622	}
623	fflush(stdout);
624	pid = fork();
625	if (pid == 0) {
626		close(pipefds[0]);
627		dup2(pipefds[1], STDOUT_FILENO);
628		execlp("dmesg", "dmesg", NULL);
629		perror("executing dmesg");
630		exit(1);
631	}
632	close(pipefds[1]);
633	fp = fdopen(pipefds[0], "r");
634	if (!fp) {
635		perror("fdopen(pipe)");
636		kill(pid, SIGTERM);
637
638		return -1;
639	}
640
641	while (fgets(line, 1024, fp)) {
642		if (strstr(line, "intel_rdt:"))
643			ksft_print_msg("dmesg: %s", line);
644		if (strstr(line, "resctrl:"))
645			ksft_print_msg("dmesg: %s", line);
646	}
647	fclose(fp);
648	waitpid(pid, NULL, 0);
649
650	return 0;
651}
652
653int validate_bw_report_request(char *bw_report)
654{
655	if (strcmp(bw_report, "reads") == 0)
656		return 0;
657	if (strcmp(bw_report, "writes") == 0)
658		return 0;
659	if (strcmp(bw_report, "nt-writes") == 0) {
660		strcpy(bw_report, "writes");
661		return 0;
662	}
663	if (strcmp(bw_report, "total") == 0)
664		return 0;
665
666	fprintf(stderr, "Requested iMC B/W report type unavailable\n");
667
668	return -1;
669}
670
671int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu,
672		    int group_fd, unsigned long flags)
673{
674	int ret;
675
676	ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
677		      group_fd, flags);
678	return ret;
679}
680
681unsigned int count_bits(unsigned long n)
682{
683	unsigned int count = 0;
684
685	while (n) {
686		count += n & 1;
687		n >>= 1;
688	}
689
690	return count;
691}