xref: /linux/tools/testing/selftests/resctrl/resctrlfs.c (revision c34e9ab9a612ee8b18273398ef75c207b01f516d)
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 
16 static 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 		ksft_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, < 0 on error.
60  */
61 int 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 		ksft_perror("mount");
73 
74 	return ret;
75 }
76 
77 int 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 		ksft_perror("Unable to umount resctrl");
90 
91 		return -1;
92 	}
93 
94 	return 0;
95 }
96 
97 /*
98  * get_cache_level - Convert cache level from string to integer
99  * @cache_type:		Cache level as string
100  *
101  * Return: cache level as integer or -1 if @cache_type is invalid.
102  */
103 static int get_cache_level(const char *cache_type)
104 {
105 	if (!strcmp(cache_type, "L3"))
106 		return 3;
107 	if (!strcmp(cache_type, "L2"))
108 		return 2;
109 
110 	ksft_print_msg("Invalid cache level\n");
111 	return -1;
112 }
113 
114 static int get_resource_cache_level(const char *resource)
115 {
116 	/* "MB" use L3 (LLC) as resource */
117 	if (!strcmp(resource, "MB"))
118 		return 3;
119 	return get_cache_level(resource);
120 }
121 
122 /*
123  * get_domain_id - Get resctrl domain ID for a specified CPU
124  * @resource:	resource name
125  * @cpu_no:	CPU number
126  * @domain_id:	domain ID (cache ID; for MB, L3 cache ID)
127  *
128  * Return: >= 0 on success, < 0 on failure.
129  */
130 int get_domain_id(const char *resource, int cpu_no, int *domain_id)
131 {
132 	char phys_pkg_path[1024];
133 	int cache_num;
134 	FILE *fp;
135 
136 	cache_num = get_resource_cache_level(resource);
137 	if (cache_num < 0)
138 		return cache_num;
139 
140 	sprintf(phys_pkg_path, "%s%d/cache/index%d/id", PHYS_ID_PATH, cpu_no, cache_num);
141 
142 	fp = fopen(phys_pkg_path, "r");
143 	if (!fp) {
144 		ksft_perror("Failed to open cache id file");
145 
146 		return -1;
147 	}
148 	if (fscanf(fp, "%d", domain_id) <= 0) {
149 		ksft_perror("Could not get domain ID");
150 		fclose(fp);
151 
152 		return -1;
153 	}
154 	fclose(fp);
155 
156 	return 0;
157 }
158 
159 /*
160  * get_cache_size - Get cache size for a specified CPU
161  * @cpu_no:	CPU number
162  * @cache_type:	Cache level L2/L3
163  * @cache_size:	pointer to cache_size
164  *
165  * Return: = 0 on success, < 0 on failure.
166  */
167 int get_cache_size(int cpu_no, const char *cache_type, unsigned long *cache_size)
168 {
169 	char cache_path[1024], cache_str[64];
170 	int length, i, cache_num;
171 	FILE *fp;
172 
173 	cache_num = get_cache_level(cache_type);
174 	if (cache_num < 0)
175 		return cache_num;
176 
177 	sprintf(cache_path, "/sys/bus/cpu/devices/cpu%d/cache/index%d/size",
178 		cpu_no, cache_num);
179 	fp = fopen(cache_path, "r");
180 	if (!fp) {
181 		ksft_perror("Failed to open cache size");
182 
183 		return -1;
184 	}
185 	if (fscanf(fp, "%63s", cache_str) <= 0) {
186 		ksft_perror("Could not get cache_size");
187 		fclose(fp);
188 
189 		return -1;
190 	}
191 	fclose(fp);
192 
193 	length = (int)strlen(cache_str);
194 
195 	*cache_size = 0;
196 
197 	for (i = 0; i < length; i++) {
198 		if ((cache_str[i] >= '0') && (cache_str[i] <= '9'))
199 
200 			*cache_size = *cache_size * 10 + (cache_str[i] - '0');
201 
202 		else if (cache_str[i] == 'K')
203 
204 			*cache_size = *cache_size * 1024;
205 
206 		else if (cache_str[i] == 'M')
207 
208 			*cache_size = *cache_size * 1024 * 1024;
209 
210 		else
211 			break;
212 	}
213 
214 	return 0;
215 }
216 
217 #define CORE_SIBLINGS_PATH	"/sys/bus/cpu/devices/cpu"
218 
219 /*
220  * get_bit_mask - Get bit mask from given file
221  * @filename:	File containing the mask
222  * @mask:	The bit mask returned as unsigned long
223  *
224  * Return: = 0 on success, < 0 on failure.
225  */
226 static int get_bit_mask(const char *filename, unsigned long *mask)
227 {
228 	FILE *fp;
229 
230 	if (!filename || !mask)
231 		return -1;
232 
233 	fp = fopen(filename, "r");
234 	if (!fp) {
235 		ksft_print_msg("Failed to open bit mask file '%s': %s\n",
236 			       filename, strerror(errno));
237 		return -1;
238 	}
239 
240 	if (fscanf(fp, "%lx", mask) <= 0) {
241 		ksft_print_msg("Could not read bit mask file '%s': %s\n",
242 			       filename, strerror(errno));
243 		fclose(fp);
244 
245 		return -1;
246 	}
247 	fclose(fp);
248 
249 	return 0;
250 }
251 
252 /*
253  * resource_info_unsigned_get - Read an unsigned value from
254  * /sys/fs/resctrl/info/@resource/@filename
255  * @resource:	Resource name that matches directory name in
256  *		/sys/fs/resctrl/info
257  * @filename:	File in /sys/fs/resctrl/info/@resource
258  * @val:	Contains read value on success.
259  *
260  * Return: = 0 on success, < 0 on failure. On success the read
261  * value is saved into @val.
262  */
263 int resource_info_unsigned_get(const char *resource, const char *filename,
264 			       unsigned int *val)
265 {
266 	char file_path[PATH_MAX];
267 	FILE *fp;
268 
269 	snprintf(file_path, sizeof(file_path), "%s/%s/%s", INFO_PATH, resource,
270 		 filename);
271 
272 	fp = fopen(file_path, "r");
273 	if (!fp) {
274 		ksft_print_msg("Error opening %s: %m\n", file_path);
275 		return -1;
276 	}
277 
278 	if (fscanf(fp, "%u", val) <= 0) {
279 		ksft_print_msg("Could not get contents of %s: %m\n", file_path);
280 		fclose(fp);
281 		return -1;
282 	}
283 
284 	fclose(fp);
285 	return 0;
286 }
287 
288 /*
289  * create_bit_mask- Create bit mask from start, len pair
290  * @start:	LSB of the mask
291  * @len		Number of bits in the mask
292  */
293 unsigned long create_bit_mask(unsigned int start, unsigned int len)
294 {
295 	return ((1UL << len) - 1UL) << start;
296 }
297 
298 /*
299  * count_contiguous_bits - Returns the longest train of bits in a bit mask
300  * @val		A bit mask
301  * @start	The location of the least-significant bit of the longest train
302  *
303  * Return:	The length of the contiguous bits in the longest train of bits
304  */
305 unsigned int count_contiguous_bits(unsigned long val, unsigned int *start)
306 {
307 	unsigned long last_val;
308 	unsigned int count = 0;
309 
310 	while (val) {
311 		last_val = val;
312 		val &= (val >> 1);
313 		count++;
314 	}
315 
316 	if (start) {
317 		if (count)
318 			*start = ffsl(last_val) - 1;
319 		else
320 			*start = 0;
321 	}
322 
323 	return count;
324 }
325 
326 /*
327  * get_full_cbm - Get full Cache Bit Mask (CBM)
328  * @cache_type:	Cache type as "L2" or "L3"
329  * @mask:	Full cache bit mask representing the maximal portion of cache
330  *		available for allocation, returned as unsigned long.
331  *
332  * Return: = 0 on success, < 0 on failure.
333  */
334 int get_full_cbm(const char *cache_type, unsigned long *mask)
335 {
336 	char cbm_path[PATH_MAX];
337 	int ret;
338 
339 	if (!cache_type)
340 		return -1;
341 
342 	snprintf(cbm_path, sizeof(cbm_path), "%s/%s/cbm_mask",
343 		 INFO_PATH, cache_type);
344 
345 	ret = get_bit_mask(cbm_path, mask);
346 	if (ret || !*mask)
347 		return -1;
348 
349 	return 0;
350 }
351 
352 /*
353  * get_shareable_mask - Get shareable mask from shareable_bits
354  * @cache_type:		Cache type as "L2" or "L3"
355  * @shareable_mask:	Shareable mask returned as unsigned long
356  *
357  * Return: = 0 on success, < 0 on failure.
358  */
359 static int get_shareable_mask(const char *cache_type, unsigned long *shareable_mask)
360 {
361 	char mask_path[PATH_MAX];
362 
363 	if (!cache_type)
364 		return -1;
365 
366 	snprintf(mask_path, sizeof(mask_path), "%s/%s/shareable_bits",
367 		 INFO_PATH, cache_type);
368 
369 	return get_bit_mask(mask_path, shareable_mask);
370 }
371 
372 /*
373  * get_mask_no_shareable - Get Cache Bit Mask (CBM) without shareable bits
374  * @cache_type:		Cache type as "L2" or "L3"
375  * @mask:		The largest exclusive portion of the cache out of the
376  *			full CBM, returned as unsigned long
377  *
378  * Parts of a cache may be shared with other devices such as GPU. This function
379  * calculates the largest exclusive portion of the cache where no other devices
380  * besides CPU have access to the cache portion.
381  *
382  * Return: = 0 on success, < 0 on failure.
383  */
384 int get_mask_no_shareable(const char *cache_type, unsigned long *mask)
385 {
386 	unsigned long full_mask, shareable_mask;
387 	unsigned int start, len;
388 
389 	if (get_full_cbm(cache_type, &full_mask) < 0)
390 		return -1;
391 	if (get_shareable_mask(cache_type, &shareable_mask) < 0)
392 		return -1;
393 
394 	len = count_contiguous_bits(full_mask & ~shareable_mask, &start);
395 	if (!len)
396 		return -1;
397 
398 	*mask = create_bit_mask(start, len);
399 
400 	return 0;
401 }
402 
403 /*
404  * taskset_benchmark - Taskset PID (i.e. benchmark) to a specified cpu
405  * @bm_pid:		PID that should be binded
406  * @cpu_no:		CPU number at which the PID would be binded
407  * @old_affinity:	When not NULL, set to old CPU affinity
408  *
409  * Return: 0 on success, < 0 on error.
410  */
411 int taskset_benchmark(pid_t bm_pid, int cpu_no, cpu_set_t *old_affinity)
412 {
413 	cpu_set_t my_set;
414 
415 	if (old_affinity) {
416 		CPU_ZERO(old_affinity);
417 		if (sched_getaffinity(bm_pid, sizeof(*old_affinity),
418 				      old_affinity)) {
419 			ksft_perror("Unable to read CPU affinity");
420 			return -1;
421 		}
422 	}
423 
424 	CPU_ZERO(&my_set);
425 	CPU_SET(cpu_no, &my_set);
426 
427 	if (sched_setaffinity(bm_pid, sizeof(cpu_set_t), &my_set)) {
428 		ksft_perror("Unable to taskset benchmark");
429 
430 		return -1;
431 	}
432 
433 	return 0;
434 }
435 
436 /*
437  * taskset_restore - Taskset PID to the earlier CPU affinity
438  * @bm_pid:		PID that should be reset
439  * @old_affinity:	The old CPU affinity to restore
440  *
441  * Return: 0 on success, < 0 on error.
442  */
443 int taskset_restore(pid_t bm_pid, cpu_set_t *old_affinity)
444 {
445 	if (sched_setaffinity(bm_pid, sizeof(*old_affinity), old_affinity)) {
446 		ksft_perror("Unable to restore CPU affinity");
447 		return -1;
448 	}
449 
450 	return 0;
451 }
452 
453 /*
454  * create_grp - Create a group only if one doesn't exist
455  * @grp_name:	Name of the group
456  * @grp:	Full path and name of the group
457  * @parent_grp:	Full path and name of the parent group
458  *
459  * Creates a group @grp_name if it does not exist yet. If @grp_name is NULL,
460  * it is interpreted as the root group which always results in success.
461  *
462  * Return: 0 on success, < 0 on error.
463  */
464 static int create_grp(const char *grp_name, char *grp, const char *parent_grp)
465 {
466 	int found_grp = 0;
467 	struct dirent *ep;
468 	DIR *dp;
469 
470 	if (!grp_name)
471 		return 0;
472 
473 	/* Check if requested grp exists or not */
474 	dp = opendir(parent_grp);
475 	if (dp) {
476 		while ((ep = readdir(dp)) != NULL) {
477 			if (strcmp(ep->d_name, grp_name) == 0)
478 				found_grp = 1;
479 		}
480 		closedir(dp);
481 	} else {
482 		ksft_perror("Unable to open resctrl for group");
483 
484 		return -1;
485 	}
486 
487 	/* Requested grp doesn't exist, hence create it */
488 	if (found_grp == 0) {
489 		if (mkdir(grp, 0) == -1) {
490 			ksft_perror("Unable to create group");
491 
492 			return -1;
493 		}
494 	}
495 
496 	return 0;
497 }
498 
499 static int write_pid_to_tasks(char *tasks, pid_t pid)
500 {
501 	FILE *fp;
502 
503 	fp = fopen(tasks, "w");
504 	if (!fp) {
505 		ksft_perror("Failed to open tasks file");
506 
507 		return -1;
508 	}
509 	if (fprintf(fp, "%d\n", (int)pid) < 0) {
510 		ksft_print_msg("Failed to write pid to tasks file\n");
511 		fclose(fp);
512 
513 		return -1;
514 	}
515 	fclose(fp);
516 
517 	return 0;
518 }
519 
520 /*
521  * write_bm_pid_to_resctrl - Write a PID (i.e. benchmark) to resctrl FS
522  * @bm_pid:		PID that should be written
523  * @ctrlgrp:		Name of the control monitor group (con_mon grp)
524  * @mongrp:		Name of the monitor group (mon grp)
525  *
526  * If a con_mon grp is requested, create it and write pid to it, otherwise
527  * write pid to root con_mon grp.
528  * If a mon grp is requested, create it and write pid to it, otherwise
529  * pid is not written, this means that pid is in con_mon grp and hence
530  * should consult con_mon grp's mon_data directory for results.
531  *
532  * Return: 0 on success, < 0 on error.
533  */
534 int write_bm_pid_to_resctrl(pid_t bm_pid, const char *ctrlgrp, const char *mongrp)
535 {
536 	char controlgroup[128], monitorgroup[512], monitorgroup_p[256];
537 	char tasks[1024];
538 	int ret = 0;
539 
540 	if (ctrlgrp)
541 		sprintf(controlgroup, "%s/%s", RESCTRL_PATH, ctrlgrp);
542 	else
543 		sprintf(controlgroup, "%s", RESCTRL_PATH);
544 
545 	/* Create control and monitoring group and write pid into it */
546 	ret = create_grp(ctrlgrp, controlgroup, RESCTRL_PATH);
547 	if (ret)
548 		goto out;
549 	sprintf(tasks, "%s/tasks", controlgroup);
550 	ret = write_pid_to_tasks(tasks, bm_pid);
551 	if (ret)
552 		goto out;
553 
554 	/* Create monitor group and write pid into if it is used */
555 	if (mongrp) {
556 		sprintf(monitorgroup_p, "%s/mon_groups", controlgroup);
557 		sprintf(monitorgroup, "%s/%s", monitorgroup_p, mongrp);
558 		ret = create_grp(mongrp, monitorgroup, monitorgroup_p);
559 		if (ret)
560 			goto out;
561 
562 		sprintf(tasks, "%s/mon_groups/%s/tasks",
563 			controlgroup, mongrp);
564 		ret = write_pid_to_tasks(tasks, bm_pid);
565 		if (ret)
566 			goto out;
567 	}
568 
569 out:
570 	ksft_print_msg("Writing benchmark parameters to resctrl FS\n");
571 	if (ret)
572 		ksft_print_msg("Failed writing to resctrlfs\n");
573 
574 	return ret;
575 }
576 
577 /*
578  * write_schemata - Update schemata of a con_mon grp
579  * @ctrlgrp:		Name of the con_mon grp
580  * @schemata:		Schemata that should be updated to
581  * @cpu_no:		CPU number that the benchmark PID is binded to
582  * @resource:		Resctrl resource (Eg: MB, L3, L2, etc.)
583  *
584  * Update schemata of a con_mon grp *only* if requested resctrl resource is
585  * allocation type
586  *
587  * Return: 0 on success, < 0 on error.
588  */
589 int write_schemata(const char *ctrlgrp, char *schemata, int cpu_no,
590 		   const char *resource)
591 {
592 	char controlgroup[1024], reason[128], schema[1024] = {};
593 	int domain_id, fd, schema_len, ret = 0;
594 
595 	if (!schemata) {
596 		ksft_print_msg("Skipping empty schemata update\n");
597 
598 		return -1;
599 	}
600 
601 	if (get_domain_id(resource, cpu_no, &domain_id) < 0) {
602 		sprintf(reason, "Failed to get domain ID");
603 		ret = -1;
604 
605 		goto out;
606 	}
607 
608 	if (ctrlgrp)
609 		sprintf(controlgroup, "%s/%s/schemata", RESCTRL_PATH, ctrlgrp);
610 	else
611 		sprintf(controlgroup, "%s/schemata", RESCTRL_PATH);
612 
613 	schema_len = snprintf(schema, sizeof(schema), "%s:%d=%s\n",
614 			      resource, domain_id, schemata);
615 	if (schema_len < 0 || schema_len >= sizeof(schema)) {
616 		snprintf(reason, sizeof(reason),
617 			 "snprintf() failed with return value : %d", schema_len);
618 		ret = -1;
619 		goto out;
620 	}
621 
622 	fd = open(controlgroup, O_WRONLY);
623 	if (fd < 0) {
624 		snprintf(reason, sizeof(reason),
625 			 "open() failed : %s", strerror(errno));
626 		ret = -1;
627 
628 		goto err_schema_not_empty;
629 	}
630 	if (write(fd, schema, schema_len) < 0) {
631 		snprintf(reason, sizeof(reason),
632 			 "write() failed : %s", strerror(errno));
633 		close(fd);
634 		ret = -1;
635 
636 		goto err_schema_not_empty;
637 	}
638 	close(fd);
639 
640 err_schema_not_empty:
641 	schema[schema_len - 1] = 0;
642 out:
643 	ksft_print_msg("Write schema \"%s\" to resctrl FS%s%s\n",
644 		       schema, ret ? " # " : "",
645 		       ret ? reason : "");
646 
647 	return ret;
648 }
649 
650 bool check_resctrlfs_support(void)
651 {
652 	FILE *inf = fopen("/proc/filesystems", "r");
653 	DIR *dp;
654 	char *res;
655 	bool ret = false;
656 
657 	if (!inf)
658 		return false;
659 
660 	res = fgrep(inf, "nodev\tresctrl\n");
661 
662 	if (res) {
663 		ret = true;
664 		free(res);
665 	}
666 
667 	fclose(inf);
668 
669 	ksft_print_msg("%s Check kernel supports resctrl filesystem\n",
670 		       ret ? "Pass:" : "Fail:");
671 
672 	if (!ret)
673 		return ret;
674 
675 	dp = opendir(RESCTRL_PATH);
676 	ksft_print_msg("%s Check resctrl mountpoint \"%s\" exists\n",
677 		       dp ? "Pass:" : "Fail:", RESCTRL_PATH);
678 	if (dp)
679 		closedir(dp);
680 
681 	ksft_print_msg("resctrl filesystem %s mounted\n",
682 		       find_resctrl_mount(NULL) ? "not" : "is");
683 
684 	return ret;
685 }
686 
687 char *fgrep(FILE *inf, const char *str)
688 {
689 	char line[256];
690 	int slen = strlen(str);
691 
692 	while (!feof(inf)) {
693 		if (!fgets(line, 256, inf))
694 			break;
695 		if (strncmp(line, str, slen))
696 			continue;
697 
698 		return strdup(line);
699 	}
700 
701 	return NULL;
702 }
703 
704 /*
705  * resctrl_resource_exists - Check if a resource is supported.
706  * @resource:	Resctrl resource (e.g., MB, L3, L2, L3_MON, etc.)
707  *
708  * Return: True if the resource is supported, else false. False is
709  *         also returned if resctrl FS is not mounted.
710  */
711 bool resctrl_resource_exists(const char *resource)
712 {
713 	char res_path[PATH_MAX];
714 	struct stat statbuf;
715 	int ret;
716 
717 	if (!resource)
718 		return false;
719 
720 	ret = find_resctrl_mount(NULL);
721 	if (ret)
722 		return false;
723 
724 	snprintf(res_path, sizeof(res_path), "%s/%s", INFO_PATH, resource);
725 
726 	if (stat(res_path, &statbuf))
727 		return false;
728 
729 	return true;
730 }
731 
732 /*
733  * resctrl_mon_feature_exists - Check if requested monitoring feature is valid.
734  * @resource:	Resource that uses the mon_features file. Currently only L3_MON
735  *		is valid.
736  * @feature:	Required monitor feature (in mon_features file).
737  *
738  * Return: True if the feature is supported, else false.
739  */
740 bool resctrl_mon_feature_exists(const char *resource, const char *feature)
741 {
742 	char res_path[PATH_MAX];
743 	char *res;
744 	FILE *inf;
745 
746 	if (!feature || !resource)
747 		return false;
748 
749 	snprintf(res_path, sizeof(res_path), "%s/%s/mon_features", INFO_PATH, resource);
750 	inf = fopen(res_path, "r");
751 	if (!inf)
752 		return false;
753 
754 	res = fgrep(inf, feature);
755 	free(res);
756 	fclose(inf);
757 
758 	return !!res;
759 }
760 
761 /*
762  * resource_info_file_exists - Check if a file is present inside
763  * /sys/fs/resctrl/info/@resource.
764  * @resource:	Required resource (Eg: MB, L3, L2, etc.)
765  * @file:	Required file.
766  *
767  * Return: True if the /sys/fs/resctrl/info/@resource/@file exists, else false.
768  */
769 bool resource_info_file_exists(const char *resource, const char *file)
770 {
771 	char res_path[PATH_MAX];
772 	struct stat statbuf;
773 
774 	if (!file || !resource)
775 		return false;
776 
777 	snprintf(res_path, sizeof(res_path), "%s/%s/%s", INFO_PATH, resource,
778 		 file);
779 
780 	if (stat(res_path, &statbuf))
781 		return false;
782 
783 	return true;
784 }
785 
786 bool test_resource_feature_check(const struct resctrl_test *test)
787 {
788 	return resctrl_resource_exists(test->resource);
789 }
790 
791 int filter_dmesg(void)
792 {
793 	char line[1024];
794 	FILE *fp;
795 	int pipefds[2];
796 	pid_t pid;
797 	int ret;
798 
799 	ret = pipe(pipefds);
800 	if (ret) {
801 		ksft_perror("pipe");
802 		return ret;
803 	}
804 	fflush(stdout);
805 	pid = fork();
806 	if (pid == 0) {
807 		close(pipefds[0]);
808 		dup2(pipefds[1], STDOUT_FILENO);
809 		execlp("dmesg", "dmesg", NULL);
810 		ksft_perror("Executing dmesg");
811 		exit(1);
812 	}
813 	close(pipefds[1]);
814 	fp = fdopen(pipefds[0], "r");
815 	if (!fp) {
816 		ksft_perror("fdopen(pipe)");
817 		kill(pid, SIGTERM);
818 
819 		return -1;
820 	}
821 
822 	while (fgets(line, 1024, fp)) {
823 		if (strstr(line, "intel_rdt:"))
824 			ksft_print_msg("dmesg: %s", line);
825 		if (strstr(line, "resctrl:"))
826 			ksft_print_msg("dmesg: %s", line);
827 	}
828 	fclose(fp);
829 	waitpid(pid, NULL, 0);
830 
831 	return 0;
832 }
833 
834 int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu,
835 		    int group_fd, unsigned long flags)
836 {
837 	int ret;
838 
839 	ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
840 		      group_fd, flags);
841 	return ret;
842 }
843 
844 unsigned int count_bits(unsigned long n)
845 {
846 	unsigned int count = 0;
847 
848 	while (n) {
849 		count += n & 1;
850 		n >>= 1;
851 	}
852 
853 	return count;
854 }
855