xref: /openbmc/linux/tools/perf/util/util.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
1  // SPDX-License-Identifier: GPL-2.0
2  #include "util.h"
3  #include "debug.h"
4  #include "event.h"
5  #include <api/fs/fs.h>
6  #include <sys/stat.h>
7  #include <sys/utsname.h>
8  #include <dirent.h>
9  #include <fcntl.h>
10  #include <inttypes.h>
11  #include <signal.h>
12  #include <stdio.h>
13  #include <stdlib.h>
14  #include <string.h>
15  #include <errno.h>
16  #include <limits.h>
17  #include <linux/capability.h>
18  #include <linux/kernel.h>
19  #include <linux/log2.h>
20  #include <linux/time64.h>
21  #include <linux/overflow.h>
22  #include <unistd.h>
23  #include "cap.h"
24  #include "strlist.h"
25  #include "string2.h"
26  
27  /*
28   * XXX We need to find a better place for these things...
29   */
30  
31  const char *input_name;
32  
33  bool perf_singlethreaded = true;
34  
perf_set_singlethreaded(void)35  void perf_set_singlethreaded(void)
36  {
37  	perf_singlethreaded = true;
38  }
39  
perf_set_multithreaded(void)40  void perf_set_multithreaded(void)
41  {
42  	perf_singlethreaded = false;
43  }
44  
45  int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH;
46  int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK;
47  
sysctl__max_stack(void)48  int sysctl__max_stack(void)
49  {
50  	int value;
51  
52  	if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
53  		sysctl_perf_event_max_stack = value;
54  
55  	if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0)
56  		sysctl_perf_event_max_contexts_per_stack = value;
57  
58  	return sysctl_perf_event_max_stack;
59  }
60  
sysctl__nmi_watchdog_enabled(void)61  bool sysctl__nmi_watchdog_enabled(void)
62  {
63  	static bool cached;
64  	static bool nmi_watchdog;
65  	int value;
66  
67  	if (cached)
68  		return nmi_watchdog;
69  
70  	if (sysctl__read_int("kernel/nmi_watchdog", &value) < 0)
71  		return false;
72  
73  	nmi_watchdog = (value > 0) ? true : false;
74  	cached = true;
75  
76  	return nmi_watchdog;
77  }
78  
79  bool test_attr__enabled;
80  
81  bool perf_host  = true;
82  bool perf_guest = false;
83  
event_attr_init(struct perf_event_attr * attr)84  void event_attr_init(struct perf_event_attr *attr)
85  {
86  	if (!perf_host)
87  		attr->exclude_host  = 1;
88  	if (!perf_guest)
89  		attr->exclude_guest = 1;
90  	/* to capture ABI version */
91  	attr->size = sizeof(*attr);
92  }
93  
mkdir_p(char * path,mode_t mode)94  int mkdir_p(char *path, mode_t mode)
95  {
96  	struct stat st;
97  	int err;
98  	char *d = path;
99  
100  	if (*d != '/')
101  		return -1;
102  
103  	if (stat(path, &st) == 0)
104  		return 0;
105  
106  	while (*++d == '/');
107  
108  	while ((d = strchr(d, '/'))) {
109  		*d = '\0';
110  		err = stat(path, &st) && mkdir(path, mode);
111  		*d++ = '/';
112  		if (err)
113  			return -1;
114  		while (*d == '/')
115  			++d;
116  	}
117  	return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
118  }
119  
match_pat(char * file,const char ** pat)120  static bool match_pat(char *file, const char **pat)
121  {
122  	int i = 0;
123  
124  	if (!pat)
125  		return true;
126  
127  	while (pat[i]) {
128  		if (strglobmatch(file, pat[i]))
129  			return true;
130  
131  		i++;
132  	}
133  
134  	return false;
135  }
136  
137  /*
138   * The depth specify how deep the removal will go.
139   * 0       - will remove only files under the 'path' directory
140   * 1 .. x  - will dive in x-level deep under the 'path' directory
141   *
142   * If specified the pat is array of string patterns ended with NULL,
143   * which are checked upon every file/directory found. Only matching
144   * ones are removed.
145   *
146   * The function returns:
147   *    0 on success
148   *   -1 on removal failure with errno set
149   *   -2 on pattern failure
150   */
rm_rf_depth_pat(const char * path,int depth,const char ** pat)151  static int rm_rf_depth_pat(const char *path, int depth, const char **pat)
152  {
153  	DIR *dir;
154  	int ret;
155  	struct dirent *d;
156  	char namebuf[PATH_MAX];
157  	struct stat statbuf;
158  
159  	/* Do not fail if there's no file. */
160  	ret = lstat(path, &statbuf);
161  	if (ret)
162  		return 0;
163  
164  	/* Try to remove any file we get. */
165  	if (!(statbuf.st_mode & S_IFDIR))
166  		return unlink(path);
167  
168  	/* We have directory in path. */
169  	dir = opendir(path);
170  	if (dir == NULL)
171  		return -1;
172  
173  	while ((d = readdir(dir)) != NULL && !ret) {
174  
175  		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
176  			continue;
177  
178  		if (!match_pat(d->d_name, pat)) {
179  			ret =  -2;
180  			break;
181  		}
182  
183  		scnprintf(namebuf, sizeof(namebuf), "%s/%s",
184  			  path, d->d_name);
185  
186  		/* We have to check symbolic link itself */
187  		ret = lstat(namebuf, &statbuf);
188  		if (ret < 0) {
189  			pr_debug("stat failed: %s\n", namebuf);
190  			break;
191  		}
192  
193  		if (S_ISDIR(statbuf.st_mode))
194  			ret = depth ? rm_rf_depth_pat(namebuf, depth - 1, pat) : 0;
195  		else
196  			ret = unlink(namebuf);
197  	}
198  	closedir(dir);
199  
200  	if (ret < 0)
201  		return ret;
202  
203  	return rmdir(path);
204  }
205  
rm_rf_a_kcore_dir(const char * path,const char * name)206  static int rm_rf_a_kcore_dir(const char *path, const char *name)
207  {
208  	char kcore_dir_path[PATH_MAX];
209  	const char *pat[] = {
210  		"kcore",
211  		"kallsyms",
212  		"modules",
213  		NULL,
214  	};
215  
216  	snprintf(kcore_dir_path, sizeof(kcore_dir_path), "%s/%s", path, name);
217  
218  	return rm_rf_depth_pat(kcore_dir_path, 0, pat);
219  }
220  
kcore_dir_filter(const char * name __maybe_unused,struct dirent * d)221  static bool kcore_dir_filter(const char *name __maybe_unused, struct dirent *d)
222  {
223  	const char *pat[] = {
224  		"kcore_dir",
225  		"kcore_dir__[1-9]*",
226  		NULL,
227  	};
228  
229  	return match_pat(d->d_name, pat);
230  }
231  
rm_rf_kcore_dir(const char * path)232  static int rm_rf_kcore_dir(const char *path)
233  {
234  	struct strlist *kcore_dirs;
235  	struct str_node *nd;
236  	int ret;
237  
238  	kcore_dirs = lsdir(path, kcore_dir_filter);
239  
240  	if (!kcore_dirs)
241  		return 0;
242  
243  	strlist__for_each_entry(nd, kcore_dirs) {
244  		ret = rm_rf_a_kcore_dir(path, nd->s);
245  		if (ret)
246  			return ret;
247  	}
248  
249  	strlist__delete(kcore_dirs);
250  
251  	return 0;
252  }
253  
rm_rf_perf_data(const char * path)254  int rm_rf_perf_data(const char *path)
255  {
256  	const char *pat[] = {
257  		"data",
258  		"data.*",
259  		NULL,
260  	};
261  
262  	rm_rf_kcore_dir(path);
263  
264  	return rm_rf_depth_pat(path, 0, pat);
265  }
266  
rm_rf(const char * path)267  int rm_rf(const char *path)
268  {
269  	return rm_rf_depth_pat(path, INT_MAX, NULL);
270  }
271  
272  /* A filter which removes dot files */
lsdir_no_dot_filter(const char * name __maybe_unused,struct dirent * d)273  bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d)
274  {
275  	return d->d_name[0] != '.';
276  }
277  
278  /* lsdir reads a directory and store it in strlist */
lsdir(const char * name,bool (* filter)(const char *,struct dirent *))279  struct strlist *lsdir(const char *name,
280  		      bool (*filter)(const char *, struct dirent *))
281  {
282  	struct strlist *list = NULL;
283  	DIR *dir;
284  	struct dirent *d;
285  
286  	dir = opendir(name);
287  	if (!dir)
288  		return NULL;
289  
290  	list = strlist__new(NULL, NULL);
291  	if (!list) {
292  		errno = ENOMEM;
293  		goto out;
294  	}
295  
296  	while ((d = readdir(dir)) != NULL) {
297  		if (!filter || filter(name, d))
298  			strlist__add(list, d->d_name);
299  	}
300  
301  out:
302  	closedir(dir);
303  	return list;
304  }
305  
hex_width(u64 v)306  size_t hex_width(u64 v)
307  {
308  	size_t n = 1;
309  
310  	while ((v >>= 4))
311  		++n;
312  
313  	return n;
314  }
315  
perf_event_paranoid(void)316  int perf_event_paranoid(void)
317  {
318  	int value;
319  
320  	if (sysctl__read_int("kernel/perf_event_paranoid", &value))
321  		return INT_MAX;
322  
323  	return value;
324  }
325  
perf_event_paranoid_check(int max_level)326  bool perf_event_paranoid_check(int max_level)
327  {
328  	return perf_cap__capable(CAP_SYS_ADMIN) ||
329  			perf_cap__capable(CAP_PERFMON) ||
330  			perf_event_paranoid() <= max_level;
331  }
332  
333  static int
fetch_ubuntu_kernel_version(unsigned int * puint)334  fetch_ubuntu_kernel_version(unsigned int *puint)
335  {
336  	ssize_t len;
337  	size_t line_len = 0;
338  	char *ptr, *line = NULL;
339  	int version, patchlevel, sublevel, err;
340  	FILE *vsig;
341  
342  	if (!puint)
343  		return 0;
344  
345  	vsig = fopen("/proc/version_signature", "r");
346  	if (!vsig) {
347  		pr_debug("Open /proc/version_signature failed: %s\n",
348  			 strerror(errno));
349  		return -1;
350  	}
351  
352  	len = getline(&line, &line_len, vsig);
353  	fclose(vsig);
354  	err = -1;
355  	if (len <= 0) {
356  		pr_debug("Reading from /proc/version_signature failed: %s\n",
357  			 strerror(errno));
358  		goto errout;
359  	}
360  
361  	ptr = strrchr(line, ' ');
362  	if (!ptr) {
363  		pr_debug("Parsing /proc/version_signature failed: %s\n", line);
364  		goto errout;
365  	}
366  
367  	err = sscanf(ptr + 1, "%d.%d.%d",
368  		     &version, &patchlevel, &sublevel);
369  	if (err != 3) {
370  		pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n",
371  			 line);
372  		goto errout;
373  	}
374  
375  	*puint = (version << 16) + (patchlevel << 8) + sublevel;
376  	err = 0;
377  errout:
378  	free(line);
379  	return err;
380  }
381  
382  int
fetch_kernel_version(unsigned int * puint,char * str,size_t str_size)383  fetch_kernel_version(unsigned int *puint, char *str,
384  		     size_t str_size)
385  {
386  	struct utsname utsname;
387  	int version, patchlevel, sublevel, err;
388  	bool int_ver_ready = false;
389  
390  	if (access("/proc/version_signature", R_OK) == 0)
391  		if (!fetch_ubuntu_kernel_version(puint))
392  			int_ver_ready = true;
393  
394  	if (uname(&utsname))
395  		return -1;
396  
397  	if (str && str_size) {
398  		strncpy(str, utsname.release, str_size);
399  		str[str_size - 1] = '\0';
400  	}
401  
402  	if (!puint || int_ver_ready)
403  		return 0;
404  
405  	err = sscanf(utsname.release, "%d.%d.%d",
406  		     &version, &patchlevel, &sublevel);
407  
408  	if (err != 3) {
409  		pr_debug("Unable to get kernel version from uname '%s'\n",
410  			 utsname.release);
411  		return -1;
412  	}
413  
414  	*puint = (version << 16) + (patchlevel << 8) + sublevel;
415  	return 0;
416  }
417  
perf_tip(char ** strp,const char * dirpath)418  int perf_tip(char **strp, const char *dirpath)
419  {
420  	struct strlist *tips;
421  	struct str_node *node;
422  	struct strlist_config conf = {
423  		.dirname = dirpath,
424  		.file_only = true,
425  	};
426  	int ret = 0;
427  
428  	*strp = NULL;
429  	tips = strlist__new("tips.txt", &conf);
430  	if (tips == NULL)
431  		return -errno;
432  
433  	if (strlist__nr_entries(tips) == 0)
434  		goto out;
435  
436  	node = strlist__entry(tips, random() % strlist__nr_entries(tips));
437  	if (asprintf(strp, "Tip: %s", node->s) < 0)
438  		ret = -ENOMEM;
439  
440  out:
441  	strlist__delete(tips);
442  
443  	return ret;
444  }
445  
perf_exe(char * buf,int len)446  char *perf_exe(char *buf, int len)
447  {
448  	int n = readlink("/proc/self/exe", buf, len);
449  	if (n > 0) {
450  		buf[n] = 0;
451  		return buf;
452  	}
453  	return strcpy(buf, "perf");
454  }
455  
perf_debuginfod_setup(struct perf_debuginfod * di)456  void perf_debuginfod_setup(struct perf_debuginfod *di)
457  {
458  	/*
459  	 * By default '!di->set' we clear DEBUGINFOD_URLS, so debuginfod
460  	 * processing is not triggered, otherwise we set it to 'di->urls'
461  	 * value. If 'di->urls' is "system" we keep DEBUGINFOD_URLS value.
462  	 */
463  	if (!di->set)
464  		setenv("DEBUGINFOD_URLS", "", 1);
465  	else if (di->urls && strcmp(di->urls, "system"))
466  		setenv("DEBUGINFOD_URLS", di->urls, 1);
467  
468  	pr_debug("DEBUGINFOD_URLS=%s\n", getenv("DEBUGINFOD_URLS"));
469  
470  #ifndef HAVE_DEBUGINFOD_SUPPORT
471  	if (di->set)
472  		pr_warning("WARNING: debuginfod support requested, but perf is not built with it\n");
473  #endif
474  }
475  
476  /*
477   * Return a new filename prepended with task's root directory if it's in
478   * a chroot.  Callers should free the returned string.
479   */
filename_with_chroot(int pid,const char * filename)480  char *filename_with_chroot(int pid, const char *filename)
481  {
482  	char buf[PATH_MAX];
483  	char proc_root[32];
484  	char *new_name = NULL;
485  	int ret;
486  
487  	scnprintf(proc_root, sizeof(proc_root), "/proc/%d/root", pid);
488  	ret = readlink(proc_root, buf, sizeof(buf) - 1);
489  	if (ret <= 0)
490  		return NULL;
491  
492  	/* readlink(2) does not append a null byte to buf */
493  	buf[ret] = '\0';
494  
495  	if (!strcmp(buf, "/"))
496  		return NULL;
497  
498  	if (strstr(buf, "(deleted)"))
499  		return NULL;
500  
501  	if (asprintf(&new_name, "%s/%s", buf, filename) < 0)
502  		return NULL;
503  
504  	return new_name;
505  }
506  
507  /*
508   * Reallocate an array *arr of size *arr_sz so that it is big enough to contain
509   * x elements of size msz, initializing new entries to *init_val or zero if
510   * init_val is NULL
511   */
do_realloc_array_as_needed(void ** arr,size_t * arr_sz,size_t x,size_t msz,const void * init_val)512  int do_realloc_array_as_needed(void **arr, size_t *arr_sz, size_t x, size_t msz, const void *init_val)
513  {
514  	size_t new_sz = *arr_sz;
515  	void *new_arr;
516  	size_t i;
517  
518  	if (!new_sz)
519  		new_sz = msz >= 64 ? 1 : roundup(64, msz); /* Start with at least 64 bytes */
520  	while (x >= new_sz) {
521  		if (check_mul_overflow(new_sz, (size_t)2, &new_sz))
522  			return -ENOMEM;
523  	}
524  	if (new_sz == *arr_sz)
525  		return 0;
526  	new_arr = calloc(new_sz, msz);
527  	if (!new_arr)
528  		return -ENOMEM;
529  	if (*arr_sz)
530  		memcpy(new_arr, *arr, *arr_sz * msz);
531  	if (init_val) {
532  		for (i = *arr_sz; i < new_sz; i++)
533  			memcpy(new_arr + (i * msz), init_val, msz);
534  	}
535  	*arr = new_arr;
536  	*arr_sz = new_sz;
537  	return 0;
538  }
539  
540  #ifndef HAVE_SCHED_GETCPU_SUPPORT
sched_getcpu(void)541  int sched_getcpu(void)
542  {
543  #ifdef __NR_getcpu
544  	unsigned int cpu;
545  	int err = syscall(__NR_getcpu, &cpu, NULL, NULL);
546  
547  	if (!err)
548  		return cpu;
549  #else
550  	errno = ENOSYS;
551  #endif
552  	return -1;
553  }
554  #endif
555