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 <unistd.h>
 22#include "cap.h"
 23#include "strlist.h"
 24#include "string2.h"
 25
 26/*
 27 * XXX We need to find a better place for these things...
 28 */
 29
 30bool perf_singlethreaded = true;
 31
 32void perf_set_singlethreaded(void)
 33{
 34	perf_singlethreaded = true;
 35}
 36
 37void perf_set_multithreaded(void)
 38{
 39	perf_singlethreaded = false;
 40}
 41
 42int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH;
 43int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK;
 44
 45int sysctl__max_stack(void)
 46{
 47	int value;
 48
 49	if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
 50		sysctl_perf_event_max_stack = value;
 51
 52	if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0)
 53		sysctl_perf_event_max_contexts_per_stack = value;
 54
 55	return sysctl_perf_event_max_stack;
 56}
 57
 58bool test_attr__enabled;
 59
 60bool perf_host  = true;
 61bool perf_guest = false;
 62
 63void event_attr_init(struct perf_event_attr *attr)
 64{
 65	if (!perf_host)
 66		attr->exclude_host  = 1;
 67	if (!perf_guest)
 68		attr->exclude_guest = 1;
 69	/* to capture ABI version */
 70	attr->size = sizeof(*attr);
 71}
 72
 73int mkdir_p(char *path, mode_t mode)
 74{
 75	struct stat st;
 76	int err;
 77	char *d = path;
 78
 79	if (*d != '/')
 80		return -1;
 81
 82	if (stat(path, &st) == 0)
 83		return 0;
 84
 85	while (*++d == '/');
 86
 87	while ((d = strchr(d, '/'))) {
 88		*d = '\0';
 89		err = stat(path, &st) && mkdir(path, mode);
 90		*d++ = '/';
 91		if (err)
 92			return -1;
 93		while (*d == '/')
 94			++d;
 95	}
 96	return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
 97}
 98
 99static bool match_pat(char *file, const char **pat)
100{
101	int i = 0;
102
103	if (!pat)
104		return true;
105
106	while (pat[i]) {
107		if (strglobmatch(file, pat[i]))
108			return true;
109
110		i++;
111	}
112
113	return false;
114}
115
116/*
117 * The depth specify how deep the removal will go.
118 * 0       - will remove only files under the 'path' directory
119 * 1 .. x  - will dive in x-level deep under the 'path' directory
120 *
121 * If specified the pat is array of string patterns ended with NULL,
122 * which are checked upon every file/directory found. Only matching
123 * ones are removed.
124 *
125 * The function returns:
126 *    0 on success
127 *   -1 on removal failure with errno set
128 *   -2 on pattern failure
129 */
130static int rm_rf_depth_pat(const char *path, int depth, const char **pat)
131{
132	DIR *dir;
133	int ret;
134	struct dirent *d;
135	char namebuf[PATH_MAX];
136	struct stat statbuf;
137
138	/* Do not fail if there's no file. */
139	ret = lstat(path, &statbuf);
140	if (ret)
141		return 0;
142
143	/* Try to remove any file we get. */
144	if (!(statbuf.st_mode & S_IFDIR))
145		return unlink(path);
146
147	/* We have directory in path. */
148	dir = opendir(path);
149	if (dir == NULL)
150		return -1;
151
152	while ((d = readdir(dir)) != NULL && !ret) {
153
154		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
155			continue;
156
157		if (!match_pat(d->d_name, pat)) {
158			ret =  -2;
159			break;
160		}
161
162		scnprintf(namebuf, sizeof(namebuf), "%s/%s",
163			  path, d->d_name);
164
165		/* We have to check symbolic link itself */
166		ret = lstat(namebuf, &statbuf);
167		if (ret < 0) {
168			pr_debug("stat failed: %s\n", namebuf);
169			break;
170		}
171
172		if (S_ISDIR(statbuf.st_mode))
173			ret = depth ? rm_rf_depth_pat(namebuf, depth - 1, pat) : 0;
174		else
175			ret = unlink(namebuf);
176	}
177	closedir(dir);
178
179	if (ret < 0)
180		return ret;
181
182	return rmdir(path);
183}
184
185int rm_rf_perf_data(const char *path)
186{
187	const char *pat[] = {
188		"header",
189		"data.*",
190		NULL,
191	};
192
193	return rm_rf_depth_pat(path, 0, pat);
194}
195
196int rm_rf(const char *path)
197{
198	return rm_rf_depth_pat(path, INT_MAX, NULL);
199}
200
201/* A filter which removes dot files */
202bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d)
203{
204	return d->d_name[0] != '.';
205}
206
207/* lsdir reads a directory and store it in strlist */
208struct strlist *lsdir(const char *name,
209		      bool (*filter)(const char *, struct dirent *))
210{
211	struct strlist *list = NULL;
212	DIR *dir;
213	struct dirent *d;
214
215	dir = opendir(name);
216	if (!dir)
217		return NULL;
218
219	list = strlist__new(NULL, NULL);
220	if (!list) {
221		errno = ENOMEM;
222		goto out;
223	}
224
225	while ((d = readdir(dir)) != NULL) {
226		if (!filter || filter(name, d))
227			strlist__add(list, d->d_name);
228	}
229
 
 
 
 
 
 
 
 
 
 
 
 
 
230out:
231	closedir(dir);
232	return list;
233}
234
235size_t hex_width(u64 v)
236{
237	size_t n = 1;
238
239	while ((v >>= 4))
240		++n;
241
242	return n;
243}
244
245int perf_event_paranoid(void)
246{
247	int value;
248
249	if (sysctl__read_int("kernel/perf_event_paranoid", &value))
250		return INT_MAX;
251
252	return value;
253}
 
254
255bool perf_event_paranoid_check(int max_level)
256{
257	return perf_cap__capable(CAP_SYS_ADMIN) ||
258			perf_event_paranoid() <= max_level;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
259}
260
261static int
262fetch_ubuntu_kernel_version(unsigned int *puint)
263{
264	ssize_t len;
265	size_t line_len = 0;
266	char *ptr, *line = NULL;
267	int version, patchlevel, sublevel, err;
268	FILE *vsig;
269
270	if (!puint)
271		return 0;
272
273	vsig = fopen("/proc/version_signature", "r");
274	if (!vsig) {
275		pr_debug("Open /proc/version_signature failed: %s\n",
276			 strerror(errno));
277		return -1;
278	}
279
280	len = getline(&line, &line_len, vsig);
281	fclose(vsig);
282	err = -1;
283	if (len <= 0) {
284		pr_debug("Reading from /proc/version_signature failed: %s\n",
285			 strerror(errno));
286		goto errout;
287	}
288
289	ptr = strrchr(line, ' ');
290	if (!ptr) {
291		pr_debug("Parsing /proc/version_signature failed: %s\n", line);
292		goto errout;
293	}
294
295	err = sscanf(ptr + 1, "%d.%d.%d",
296		     &version, &patchlevel, &sublevel);
297	if (err != 3) {
298		pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n",
299			 line);
300		goto errout;
301	}
302
303	*puint = (version << 16) + (patchlevel << 8) + sublevel;
304	err = 0;
305errout:
306	free(line);
307	return err;
308}
309
310int
311fetch_kernel_version(unsigned int *puint, char *str,
312		     size_t str_size)
313{
314	struct utsname utsname;
315	int version, patchlevel, sublevel, err;
316	bool int_ver_ready = false;
317
318	if (access("/proc/version_signature", R_OK) == 0)
319		if (!fetch_ubuntu_kernel_version(puint))
320			int_ver_ready = true;
321
322	if (uname(&utsname))
323		return -1;
324
325	if (str && str_size) {
326		strncpy(str, utsname.release, str_size);
327		str[str_size - 1] = '\0';
328	}
329
330	if (!puint || int_ver_ready)
331		return 0;
332
333	err = sscanf(utsname.release, "%d.%d.%d",
334		     &version, &patchlevel, &sublevel);
335
336	if (err != 3) {
337		pr_debug("Unable to get kernel version from uname '%s'\n",
338			 utsname.release);
339		return -1;
340	}
341
342	*puint = (version << 16) + (patchlevel << 8) + sublevel;
343	return 0;
344}
345
346const char *perf_tip(const char *dirpath)
347{
348	struct strlist *tips;
349	struct str_node *node;
350	char *tip = NULL;
351	struct strlist_config conf = {
352		.dirname = dirpath,
353		.file_only = true,
354	};
355
356	tips = strlist__new("tips.txt", &conf);
357	if (tips == NULL)
358		return errno == ENOENT ? NULL :
359			"Tip: check path of tips.txt or get more memory! ;-p";
360
361	if (strlist__nr_entries(tips) == 0)
362		goto out;
363
364	node = strlist__entry(tips, random() % strlist__nr_entries(tips));
365	if (asprintf(&tip, "Tip: %s", node->s) < 0)
366		tip = (char *)"Tip: get more memory! ;-)";
367
368out:
369	strlist__delete(tips);
370
371	return tip;
372}
373
374char *perf_exe(char *buf, int len)
375{
376	int n = readlink("/proc/self/exe", buf, len);
377	if (n > 0) {
378		buf[n] = 0;
379		return buf;
380	}
381	return strcpy(buf, "perf");
382}

  1#include "../perf.h"
  2#include "util.h"
  3#include <sys/mman.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  4
  5/*
  6 * XXX We need to find a better place for these things...
  7 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  8bool perf_host  = true;
  9bool perf_guest = false;
 10
 11void event_attr_init(struct perf_event_attr *attr)
 12{
 13	if (!perf_host)
 14		attr->exclude_host  = 1;
 15	if (!perf_guest)
 16		attr->exclude_guest = 1;
 17	/* to capture ABI version */
 18	attr->size = sizeof(*attr);
 19}
 20
 21int mkdir_p(char *path, mode_t mode)
 22{
 23	struct stat st;
 24	int err;
 25	char *d = path;
 26
 27	if (*d != '/')
 28		return -1;
 29
 30	if (stat(path, &st) == 0)
 31		return 0;
 32
 33	while (*++d == '/');
 34
 35	while ((d = strchr(d, '/'))) {
 36		*d = '\0';
 37		err = stat(path, &st) && mkdir(path, mode);
 38		*d++ = '/';
 39		if (err)
 40			return -1;
 41		while (*d == '/')
 42			++d;
 43	}
 44	return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
 45}
 46
 47static int slow_copyfile(const char *from, const char *to)
 48{
 49	int err = 0;
 50	char *line = NULL;
 51	size_t n;
 52	FILE *from_fp = fopen(from, "r"), *to_fp;
 
 
 
 
 
 
 
 
 
 
 53
 54	if (from_fp == NULL)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 55		goto out;
 
 
 
 
 
 
 56
 57	to_fp = fopen(to, "w");
 58	if (to_fp == NULL)
 59		goto out_fclose_from;
 60
 61	while (getline(&line, &n, from_fp) > 0)
 62		if (fputs(line, to_fp) == EOF)
 63			goto out_fclose_to;
 64	err = 0;
 65out_fclose_to:
 66	fclose(to_fp);
 67	free(line);
 68out_fclose_from:
 69	fclose(from_fp);
 70out:
 71	return err;
 
 72}
 73
 74int copyfile(const char *from, const char *to)
 75{
 76	int fromfd, tofd;
 77	struct stat st;
 78	void *addr;
 79	int err = -1;
 
 
 
 80
 81	if (stat(from, &st))
 82		goto out;
 
 83
 84	if (st.st_size == 0) /* /proc? do it slowly... */
 85		return slow_copyfile(from, to);
 86
 87	fromfd = open(from, O_RDONLY);
 88	if (fromfd < 0)
 89		goto out;
 90
 91	tofd = creat(to, 0755);
 92	if (tofd < 0)
 93		goto out_close_from;
 94
 95	addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fromfd, 0);
 96	if (addr == MAP_FAILED)
 97		goto out_close_to;
 98
 99	if (write(tofd, addr, st.st_size) == st.st_size)
100		err = 0;
101
102	munmap(addr, st.st_size);
103out_close_to:
104	close(tofd);
105	if (err)
106		unlink(to);
107out_close_from:
108	close(fromfd);
109out:
110	return err;
111}
112
113unsigned long convert_unit(unsigned long value, char *unit)
 
114{
115	*unit = ' ';
 
 
 
 
 
 
 
116
117	if (value > 1000) {
118		value /= 1000;
119		*unit = 'K';
 
 
120	}
121
122	if (value > 1000) {
123		value /= 1000;
124		*unit = 'M';
 
 
 
 
125	}
126
127	if (value > 1000) {
128		value /= 1000;
129		*unit = 'G';
 
130	}
131
132	return value;
 
 
 
 
 
 
 
 
 
 
 
 
133}
134
135int readn(int fd, void *buf, size_t n)
 
 
136{
137	void *buf_start = buf;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
138
139	while (n) {
140		int ret = read(fd, buf, n);
141
142		if (ret <= 0)
143			return ret;
144
145		n -= ret;
146		buf += ret;
 
 
147	}
148
149	return buf - buf_start;
 
150}
151
152size_t hex_width(u64 v)
153{
154	size_t n = 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
155
156	while ((v >>= 4))
157		++n;
158
159	return n;
 
 
 
 
 
 
 
160}