xref: /openbmc/linux/tools/perf/util/util.c (revision bcb84fb4) 
1 #include "../perf.h"
2 #include "util.h"
3 #include "debug.h"
4 #include <api/fs/fs.h>
5 #include <sys/mman.h>
6 #include <sys/utsname.h>
7 #ifdef HAVE_BACKTRACE_SUPPORT
8 #include <execinfo.h>
9 #endif
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <errno.h>
14 #include <limits.h>
15 #include <byteswap.h>
16 #include <linux/kernel.h>
17 #include <linux/log2.h>
18 #include <linux/time64.h>
19 #include <unistd.h>
20 #include "callchain.h"
21 #include "strlist.h"
22 
23 #define CALLCHAIN_PARAM_DEFAULT			\
24 	.mode		= CHAIN_GRAPH_ABS,	\
25 	.min_percent	= 0.5,			\
26 	.order		= ORDER_CALLEE,		\
27 	.key		= CCKEY_FUNCTION,	\
28 	.value		= CCVAL_PERCENT,	\
29 
30 struct callchain_param callchain_param = {
31 	CALLCHAIN_PARAM_DEFAULT
32 };
33 
34 struct callchain_param callchain_param_default = {
35 	CALLCHAIN_PARAM_DEFAULT
36 };
37 
38 /*
39  * XXX We need to find a better place for these things...
40  */
41 unsigned int page_size;
42 int cacheline_size;
43 
44 int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH;
45 int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK;
46 
47 bool test_attr__enabled;
48 
49 bool perf_host  = true;
50 bool perf_guest = false;
51 
52 void event_attr_init(struct perf_event_attr *attr)
53 {
54 	if (!perf_host)
55 		attr->exclude_host  = 1;
56 	if (!perf_guest)
57 		attr->exclude_guest = 1;
58 	/* to capture ABI version */
59 	attr->size = sizeof(*attr);
60 }
61 
62 int mkdir_p(char *path, mode_t mode)
63 {
64 	struct stat st;
65 	int err;
66 	char *d = path;
67 
68 	if (*d != '/')
69 		return -1;
70 
71 	if (stat(path, &st) == 0)
72 		return 0;
73 
74 	while (*++d == '/');
75 
76 	while ((d = strchr(d, '/'))) {
77 		*d = '\0';
78 		err = stat(path, &st) && mkdir(path, mode);
79 		*d++ = '/';
80 		if (err)
81 			return -1;
82 		while (*d == '/')
83 			++d;
84 	}
85 	return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
86 }
87 
88 int rm_rf(const char *path)
89 {
90 	DIR *dir;
91 	int ret = 0;
92 	struct dirent *d;
93 	char namebuf[PATH_MAX];
94 
95 	dir = opendir(path);
96 	if (dir == NULL)
97 		return 0;
98 
99 	while ((d = readdir(dir)) != NULL && !ret) {
100 		struct stat statbuf;
101 
102 		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
103 			continue;
104 
105 		scnprintf(namebuf, sizeof(namebuf), "%s/%s",
106 			  path, d->d_name);
107 
108 		/* We have to check symbolic link itself */
109 		ret = lstat(namebuf, &statbuf);
110 		if (ret < 0) {
111 			pr_debug("stat failed: %s\n", namebuf);
112 			break;
113 		}
114 
115 		if (S_ISDIR(statbuf.st_mode))
116 			ret = rm_rf(namebuf);
117 		else
118 			ret = unlink(namebuf);
119 	}
120 	closedir(dir);
121 
122 	if (ret < 0)
123 		return ret;
124 
125 	return rmdir(path);
126 }
127 
128 /* A filter which removes dot files */
129 bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d)
130 {
131 	return d->d_name[0] != '.';
132 }
133 
134 /* lsdir reads a directory and store it in strlist */
135 struct strlist *lsdir(const char *name,
136 		      bool (*filter)(const char *, struct dirent *))
137 {
138 	struct strlist *list = NULL;
139 	DIR *dir;
140 	struct dirent *d;
141 
142 	dir = opendir(name);
143 	if (!dir)
144 		return NULL;
145 
146 	list = strlist__new(NULL, NULL);
147 	if (!list) {
148 		errno = ENOMEM;
149 		goto out;
150 	}
151 
152 	while ((d = readdir(dir)) != NULL) {
153 		if (!filter || filter(name, d))
154 			strlist__add(list, d->d_name);
155 	}
156 
157 out:
158 	closedir(dir);
159 	return list;
160 }
161 
162 static int slow_copyfile(const char *from, const char *to)
163 {
164 	int err = -1;
165 	char *line = NULL;
166 	size_t n;
167 	FILE *from_fp = fopen(from, "r"), *to_fp;
168 
169 	if (from_fp == NULL)
170 		goto out;
171 
172 	to_fp = fopen(to, "w");
173 	if (to_fp == NULL)
174 		goto out_fclose_from;
175 
176 	while (getline(&line, &n, from_fp) > 0)
177 		if (fputs(line, to_fp) == EOF)
178 			goto out_fclose_to;
179 	err = 0;
180 out_fclose_to:
181 	fclose(to_fp);
182 	free(line);
183 out_fclose_from:
184 	fclose(from_fp);
185 out:
186 	return err;
187 }
188 
189 int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
190 {
191 	void *ptr;
192 	loff_t pgoff;
193 
194 	pgoff = off_in & ~(page_size - 1);
195 	off_in -= pgoff;
196 
197 	ptr = mmap(NULL, off_in + size, PROT_READ, MAP_PRIVATE, ifd, pgoff);
198 	if (ptr == MAP_FAILED)
199 		return -1;
200 
201 	while (size) {
202 		ssize_t ret = pwrite(ofd, ptr + off_in, size, off_out);
203 		if (ret < 0 && errno == EINTR)
204 			continue;
205 		if (ret <= 0)
206 			break;
207 
208 		size -= ret;
209 		off_in += ret;
210 		off_out -= ret;
211 	}
212 	munmap(ptr, off_in + size);
213 
214 	return size ? -1 : 0;
215 }
216 
217 int copyfile_mode(const char *from, const char *to, mode_t mode)
218 {
219 	int fromfd, tofd;
220 	struct stat st;
221 	int err = -1;
222 	char *tmp = NULL, *ptr = NULL;
223 
224 	if (stat(from, &st))
225 		goto out;
226 
227 	/* extra 'x' at the end is to reserve space for '.' */
228 	if (asprintf(&tmp, "%s.XXXXXXx", to) < 0) {
229 		tmp = NULL;
230 		goto out;
231 	}
232 	ptr = strrchr(tmp, '/');
233 	if (!ptr)
234 		goto out;
235 	ptr = memmove(ptr + 1, ptr, strlen(ptr) - 1);
236 	*ptr = '.';
237 
238 	tofd = mkstemp(tmp);
239 	if (tofd < 0)
240 		goto out;
241 
242 	if (fchmod(tofd, mode))
243 		goto out_close_to;
244 
245 	if (st.st_size == 0) { /* /proc? do it slowly... */
246 		err = slow_copyfile(from, tmp);
247 		goto out_close_to;
248 	}
249 
250 	fromfd = open(from, O_RDONLY);
251 	if (fromfd < 0)
252 		goto out_close_to;
253 
254 	err = copyfile_offset(fromfd, 0, tofd, 0, st.st_size);
255 
256 	close(fromfd);
257 out_close_to:
258 	close(tofd);
259 	if (!err)
260 		err = link(tmp, to);
261 	unlink(tmp);
262 out:
263 	free(tmp);
264 	return err;
265 }
266 
267 int copyfile(const char *from, const char *to)
268 {
269 	return copyfile_mode(from, to, 0755);
270 }
271 
272 unsigned long convert_unit(unsigned long value, char *unit)
273 {
274 	*unit = ' ';
275 
276 	if (value > 1000) {
277 		value /= 1000;
278 		*unit = 'K';
279 	}
280 
281 	if (value > 1000) {
282 		value /= 1000;
283 		*unit = 'M';
284 	}
285 
286 	if (value > 1000) {
287 		value /= 1000;
288 		*unit = 'G';
289 	}
290 
291 	return value;
292 }
293 
294 static ssize_t ion(bool is_read, int fd, void *buf, size_t n)
295 {
296 	void *buf_start = buf;
297 	size_t left = n;
298 
299 	while (left) {
300 		ssize_t ret = is_read ? read(fd, buf, left) :
301 					write(fd, buf, left);
302 
303 		if (ret < 0 && errno == EINTR)
304 			continue;
305 		if (ret <= 0)
306 			return ret;
307 
308 		left -= ret;
309 		buf  += ret;
310 	}
311 
312 	BUG_ON((size_t)(buf - buf_start) != n);
313 	return n;
314 }
315 
316 /*
317  * Read exactly 'n' bytes or return an error.
318  */
319 ssize_t readn(int fd, void *buf, size_t n)
320 {
321 	return ion(true, fd, buf, n);
322 }
323 
324 /*
325  * Write exactly 'n' bytes or return an error.
326  */
327 ssize_t writen(int fd, void *buf, size_t n)
328 {
329 	return ion(false, fd, buf, n);
330 }
331 
332 size_t hex_width(u64 v)
333 {
334 	size_t n = 1;
335 
336 	while ((v >>= 4))
337 		++n;
338 
339 	return n;
340 }
341 
342 static int hex(char ch)
343 {
344 	if ((ch >= '0') && (ch <= '9'))
345 		return ch - '0';
346 	if ((ch >= 'a') && (ch <= 'f'))
347 		return ch - 'a' + 10;
348 	if ((ch >= 'A') && (ch <= 'F'))
349 		return ch - 'A' + 10;
350 	return -1;
351 }
352 
353 /*
354  * While we find nice hex chars, build a long_val.
355  * Return number of chars processed.
356  */
357 int hex2u64(const char *ptr, u64 *long_val)
358 {
359 	const char *p = ptr;
360 	*long_val = 0;
361 
362 	while (*p) {
363 		const int hex_val = hex(*p);
364 
365 		if (hex_val < 0)
366 			break;
367 
368 		*long_val = (*long_val << 4) | hex_val;
369 		p++;
370 	}
371 
372 	return p - ptr;
373 }
374 
375 /* Obtain a backtrace and print it to stdout. */
376 #ifdef HAVE_BACKTRACE_SUPPORT
377 void dump_stack(void)
378 {
379 	void *array[16];
380 	size_t size = backtrace(array, ARRAY_SIZE(array));
381 	char **strings = backtrace_symbols(array, size);
382 	size_t i;
383 
384 	printf("Obtained %zd stack frames.\n", size);
385 
386 	for (i = 0; i < size; i++)
387 		printf("%s\n", strings[i]);
388 
389 	free(strings);
390 }
391 #else
392 void dump_stack(void) {}
393 #endif
394 
395 void sighandler_dump_stack(int sig)
396 {
397 	psignal(sig, "perf");
398 	dump_stack();
399 	signal(sig, SIG_DFL);
400 	raise(sig);
401 }
402 
403 int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
404 {
405 	u64  sec = timestamp / NSEC_PER_SEC;
406 	u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;
407 
408 	return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
409 }
410 
411 unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
412 {
413 	struct parse_tag *i = tags;
414 
415 	while (i->tag) {
416 		char *s;
417 
418 		s = strchr(str, i->tag);
419 		if (s) {
420 			unsigned long int value;
421 			char *endptr;
422 
423 			value = strtoul(str, &endptr, 10);
424 			if (s != endptr)
425 				break;
426 
427 			if (value > ULONG_MAX / i->mult)
428 				break;
429 			value *= i->mult;
430 			return value;
431 		}
432 		i++;
433 	}
434 
435 	return (unsigned long) -1;
436 }
437 
438 int get_stack_size(const char *str, unsigned long *_size)
439 {
440 	char *endptr;
441 	unsigned long size;
442 	unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
443 
444 	size = strtoul(str, &endptr, 0);
445 
446 	do {
447 		if (*endptr)
448 			break;
449 
450 		size = round_up(size, sizeof(u64));
451 		if (!size || size > max_size)
452 			break;
453 
454 		*_size = size;
455 		return 0;
456 
457 	} while (0);
458 
459 	pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
460 	       max_size, str);
461 	return -1;
462 }
463 
464 int parse_callchain_record(const char *arg, struct callchain_param *param)
465 {
466 	char *tok, *name, *saveptr = NULL;
467 	char *buf;
468 	int ret = -1;
469 
470 	/* We need buffer that we know we can write to. */
471 	buf = malloc(strlen(arg) + 1);
472 	if (!buf)
473 		return -ENOMEM;
474 
475 	strcpy(buf, arg);
476 
477 	tok = strtok_r((char *)buf, ",", &saveptr);
478 	name = tok ? : (char *)buf;
479 
480 	do {
481 		/* Framepointer style */
482 		if (!strncmp(name, "fp", sizeof("fp"))) {
483 			if (!strtok_r(NULL, ",", &saveptr)) {
484 				param->record_mode = CALLCHAIN_FP;
485 				ret = 0;
486 			} else
487 				pr_err("callchain: No more arguments "
488 				       "needed for --call-graph fp\n");
489 			break;
490 
491 		/* Dwarf style */
492 		} else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
493 			const unsigned long default_stack_dump_size = 8192;
494 
495 			ret = 0;
496 			param->record_mode = CALLCHAIN_DWARF;
497 			param->dump_size = default_stack_dump_size;
498 
499 			tok = strtok_r(NULL, ",", &saveptr);
500 			if (tok) {
501 				unsigned long size = 0;
502 
503 				ret = get_stack_size(tok, &size);
504 				param->dump_size = size;
505 			}
506 		} else if (!strncmp(name, "lbr", sizeof("lbr"))) {
507 			if (!strtok_r(NULL, ",", &saveptr)) {
508 				param->record_mode = CALLCHAIN_LBR;
509 				ret = 0;
510 			} else
511 				pr_err("callchain: No more arguments "
512 					"needed for --call-graph lbr\n");
513 			break;
514 		} else {
515 			pr_err("callchain: Unknown --call-graph option "
516 			       "value: %s\n", arg);
517 			break;
518 		}
519 
520 	} while (0);
521 
522 	free(buf);
523 	return ret;
524 }
525 
526 const char *get_filename_for_perf_kvm(void)
527 {
528 	const char *filename;
529 
530 	if (perf_host && !perf_guest)
531 		filename = strdup("perf.data.host");
532 	else if (!perf_host && perf_guest)
533 		filename = strdup("perf.data.guest");
534 	else
535 		filename = strdup("perf.data.kvm");
536 
537 	return filename;
538 }
539 
540 int perf_event_paranoid(void)
541 {
542 	int value;
543 
544 	if (sysctl__read_int("kernel/perf_event_paranoid", &value))
545 		return INT_MAX;
546 
547 	return value;
548 }
549 
550 void mem_bswap_32(void *src, int byte_size)
551 {
552 	u32 *m = src;
553 	while (byte_size > 0) {
554 		*m = bswap_32(*m);
555 		byte_size -= sizeof(u32);
556 		++m;
557 	}
558 }
559 
560 void mem_bswap_64(void *src, int byte_size)
561 {
562 	u64 *m = src;
563 
564 	while (byte_size > 0) {
565 		*m = bswap_64(*m);
566 		byte_size -= sizeof(u64);
567 		++m;
568 	}
569 }
570 
571 bool find_process(const char *name)
572 {
573 	size_t len = strlen(name);
574 	DIR *dir;
575 	struct dirent *d;
576 	int ret = -1;
577 
578 	dir = opendir(procfs__mountpoint());
579 	if (!dir)
580 		return false;
581 
582 	/* Walk through the directory. */
583 	while (ret && (d = readdir(dir)) != NULL) {
584 		char path[PATH_MAX];
585 		char *data;
586 		size_t size;
587 
588 		if ((d->d_type != DT_DIR) ||
589 		     !strcmp(".", d->d_name) ||
590 		     !strcmp("..", d->d_name))
591 			continue;
592 
593 		scnprintf(path, sizeof(path), "%s/%s/comm",
594 			  procfs__mountpoint(), d->d_name);
595 
596 		if (filename__read_str(path, &data, &size))
597 			continue;
598 
599 		ret = strncmp(name, data, len);
600 		free(data);
601 	}
602 
603 	closedir(dir);
604 	return ret ? false : true;
605 }
606 
607 static int
608 fetch_ubuntu_kernel_version(unsigned int *puint)
609 {
610 	ssize_t len;
611 	size_t line_len = 0;
612 	char *ptr, *line = NULL;
613 	int version, patchlevel, sublevel, err;
614 	FILE *vsig = fopen("/proc/version_signature", "r");
615 
616 	if (!vsig) {
617 		pr_debug("Open /proc/version_signature failed: %s\n",
618 			 strerror(errno));
619 		return -1;
620 	}
621 
622 	len = getline(&line, &line_len, vsig);
623 	fclose(vsig);
624 	err = -1;
625 	if (len <= 0) {
626 		pr_debug("Reading from /proc/version_signature failed: %s\n",
627 			 strerror(errno));
628 		goto errout;
629 	}
630 
631 	ptr = strrchr(line, ' ');
632 	if (!ptr) {
633 		pr_debug("Parsing /proc/version_signature failed: %s\n", line);
634 		goto errout;
635 	}
636 
637 	err = sscanf(ptr + 1, "%d.%d.%d",
638 		     &version, &patchlevel, &sublevel);
639 	if (err != 3) {
640 		pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n",
641 			 line);
642 		goto errout;
643 	}
644 
645 	if (puint)
646 		*puint = (version << 16) + (patchlevel << 8) + sublevel;
647 	err = 0;
648 errout:
649 	free(line);
650 	return err;
651 }
652 
653 int
654 fetch_kernel_version(unsigned int *puint, char *str,
655 		     size_t str_size)
656 {
657 	struct utsname utsname;
658 	int version, patchlevel, sublevel, err;
659 	bool int_ver_ready = false;
660 
661 	if (access("/proc/version_signature", R_OK) == 0)
662 		if (!fetch_ubuntu_kernel_version(puint))
663 			int_ver_ready = true;
664 
665 	if (uname(&utsname))
666 		return -1;
667 
668 	if (str && str_size) {
669 		strncpy(str, utsname.release, str_size);
670 		str[str_size - 1] = '\0';
671 	}
672 
673 	err = sscanf(utsname.release, "%d.%d.%d",
674 		     &version, &patchlevel, &sublevel);
675 
676 	if (err != 3) {
677 		pr_debug("Unable to get kernel version from uname '%s'\n",
678 			 utsname.release);
679 		return -1;
680 	}
681 
682 	if (puint && !int_ver_ready)
683 		*puint = (version << 16) + (patchlevel << 8) + sublevel;
684 	return 0;
685 }
686 
687 const char *perf_tip(const char *dirpath)
688 {
689 	struct strlist *tips;
690 	struct str_node *node;
691 	char *tip = NULL;
692 	struct strlist_config conf = {
693 		.dirname = dirpath,
694 		.file_only = true,
695 	};
696 
697 	tips = strlist__new("tips.txt", &conf);
698 	if (tips == NULL)
699 		return errno == ENOENT ? NULL : "Tip: get more memory! ;-p";
700 
701 	if (strlist__nr_entries(tips) == 0)
702 		goto out;
703 
704 	node = strlist__entry(tips, random() % strlist__nr_entries(tips));
705 	if (asprintf(&tip, "Tip: %s", node->s) < 0)
706 		tip = (char *)"Tip: get more memory! ;-)";
707 
708 out:
709 	strlist__delete(tips);
710 
711 	return tip;
712 }
713 
714 bool is_regular_file(const char *file)
715 {
716 	struct stat st;
717 
718 	if (stat(file, &st))
719 		return false;
720 
721 	return S_ISREG(st.st_mode);
722 }
723 
724 int fetch_current_timestamp(char *buf, size_t sz)
725 {
726 	struct timeval tv;
727 	struct tm tm;
728 	char dt[32];
729 
730 	if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
731 		return -1;
732 
733 	if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
734 		return -1;
735 
736 	scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
737 
738 	return 0;
739 }
740 
741 void print_binary(unsigned char *data, size_t len,
742 		  size_t bytes_per_line, print_binary_t printer,
743 		  void *extra)
744 {
745 	size_t i, j, mask;
746 
747 	if (!printer)
748 		return;
749 
750 	bytes_per_line = roundup_pow_of_two(bytes_per_line);
751 	mask = bytes_per_line - 1;
752 
753 	printer(BINARY_PRINT_DATA_BEGIN, 0, extra);
754 	for (i = 0; i < len; i++) {
755 		if ((i & mask) == 0) {
756 			printer(BINARY_PRINT_LINE_BEGIN, -1, extra);
757 			printer(BINARY_PRINT_ADDR, i, extra);
758 		}
759 
760 		printer(BINARY_PRINT_NUM_DATA, data[i], extra);
761 
762 		if (((i & mask) == mask) || i == len - 1) {
763 			for (j = 0; j < mask-(i & mask); j++)
764 				printer(BINARY_PRINT_NUM_PAD, -1, extra);
765 
766 			printer(BINARY_PRINT_SEP, i, extra);
767 			for (j = i & ~mask; j <= i; j++)
768 				printer(BINARY_PRINT_CHAR_DATA, data[j], extra);
769 			for (j = 0; j < mask-(i & mask); j++)
770 				printer(BINARY_PRINT_CHAR_PAD, i, extra);
771 			printer(BINARY_PRINT_LINE_END, -1, extra);
772 		}
773 	}
774 	printer(BINARY_PRINT_DATA_END, -1, extra);
775 }
776 
777 int is_printable_array(char *p, unsigned int len)
778 {
779 	unsigned int i;
780 
781 	if (!p || !len || p[len - 1] != 0)
782 		return 0;
783 
784 	len--;
785 
786 	for (i = 0; i < len; i++) {
787 		if (!isprint(p[i]) && !isspace(p[i]))
788 			return 0;
789 	}
790 	return 1;
791 }
792 
793 int unit_number__scnprintf(char *buf, size_t size, u64 n)
794 {
795 	char unit[4] = "BKMG";
796 	int i = 0;
797 
798 	while (((n / 1024) > 1) && (i < 3)) {
799 		n /= 1024;
800 		i++;
801 	}
802 
803 	return scnprintf(buf, size, "%" PRIu64 "%c", n, unit[i]);
804 }
805