• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <unistd.h>
18 #include "callchain.h"
19 
20 struct callchain_param	callchain_param = {
21 	.mode	= CHAIN_GRAPH_ABS,
22 	.min_percent = 0.5,
23 	.order  = ORDER_CALLEE,
24 	.key	= CCKEY_FUNCTION
25 };
26 
27 /*
28  * XXX We need to find a better place for these things...
29  */
30 unsigned int page_size;
31 int cacheline_size;
32 
33 bool test_attr__enabled;
34 
35 bool perf_host  = true;
36 bool perf_guest = false;
37 
event_attr_init(struct perf_event_attr * attr)38 void event_attr_init(struct perf_event_attr *attr)
39 {
40 	if (!perf_host)
41 		attr->exclude_host  = 1;
42 	if (!perf_guest)
43 		attr->exclude_guest = 1;
44 	/* to capture ABI version */
45 	attr->size = sizeof(*attr);
46 }
47 
mkdir_p(char * path,mode_t mode)48 int mkdir_p(char *path, mode_t mode)
49 {
50 	struct stat st;
51 	int err;
52 	char *d = path;
53 
54 	if (*d != '/')
55 		return -1;
56 
57 	if (stat(path, &st) == 0)
58 		return 0;
59 
60 	while (*++d == '/');
61 
62 	while ((d = strchr(d, '/'))) {
63 		*d = '\0';
64 		err = stat(path, &st) && mkdir(path, mode);
65 		*d++ = '/';
66 		if (err)
67 			return -1;
68 		while (*d == '/')
69 			++d;
70 	}
71 	return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
72 }
73 
rm_rf(char * path)74 int rm_rf(char *path)
75 {
76 	DIR *dir;
77 	int ret = 0;
78 	struct dirent *d;
79 	char namebuf[PATH_MAX];
80 
81 	dir = opendir(path);
82 	if (dir == NULL)
83 		return 0;
84 
85 	while ((d = readdir(dir)) != NULL && !ret) {
86 		struct stat statbuf;
87 
88 		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
89 			continue;
90 
91 		scnprintf(namebuf, sizeof(namebuf), "%s/%s",
92 			  path, d->d_name);
93 
94 		ret = stat(namebuf, &statbuf);
95 		if (ret < 0) {
96 			pr_debug("stat failed: %s\n", namebuf);
97 			break;
98 		}
99 
100 		if (S_ISREG(statbuf.st_mode))
101 			ret = unlink(namebuf);
102 		else if (S_ISDIR(statbuf.st_mode))
103 			ret = rm_rf(namebuf);
104 		else {
105 			pr_debug("unknown file: %s\n", namebuf);
106 			ret = -1;
107 		}
108 	}
109 	closedir(dir);
110 
111 	if (ret < 0)
112 		return ret;
113 
114 	return rmdir(path);
115 }
116 
slow_copyfile(const char * from,const char * to)117 static int slow_copyfile(const char *from, const char *to)
118 {
119 	int err = -1;
120 	char *line = NULL;
121 	size_t n;
122 	FILE *from_fp = fopen(from, "r"), *to_fp;
123 
124 	if (from_fp == NULL)
125 		goto out;
126 
127 	to_fp = fopen(to, "w");
128 	if (to_fp == NULL)
129 		goto out_fclose_from;
130 
131 	while (getline(&line, &n, from_fp) > 0)
132 		if (fputs(line, to_fp) == EOF)
133 			goto out_fclose_to;
134 	err = 0;
135 out_fclose_to:
136 	fclose(to_fp);
137 	free(line);
138 out_fclose_from:
139 	fclose(from_fp);
140 out:
141 	return err;
142 }
143 
copyfile_offset(int ifd,loff_t off_in,int ofd,loff_t off_out,u64 size)144 int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
145 {
146 	void *ptr;
147 	loff_t pgoff;
148 
149 	pgoff = off_in & ~(page_size - 1);
150 	off_in -= pgoff;
151 
152 	ptr = mmap(NULL, off_in + size, PROT_READ, MAP_PRIVATE, ifd, pgoff);
153 	if (ptr == MAP_FAILED)
154 		return -1;
155 
156 	while (size) {
157 		ssize_t ret = pwrite(ofd, ptr + off_in, size, off_out);
158 		if (ret < 0 && errno == EINTR)
159 			continue;
160 		if (ret <= 0)
161 			break;
162 
163 		size -= ret;
164 		off_in += ret;
165 		off_out += ret;
166 	}
167 	munmap(ptr, off_in + size);
168 
169 	return size ? -1 : 0;
170 }
171 
copyfile_mode(const char * from,const char * to,mode_t mode)172 int copyfile_mode(const char *from, const char *to, mode_t mode)
173 {
174 	int fromfd, tofd;
175 	struct stat st;
176 	int err = -1;
177 	char *tmp = NULL, *ptr = NULL;
178 
179 	if (stat(from, &st))
180 		goto out;
181 
182 	/* extra 'x' at the end is to reserve space for '.' */
183 	if (asprintf(&tmp, "%s.XXXXXXx", to) < 0) {
184 		tmp = NULL;
185 		goto out;
186 	}
187 	ptr = strrchr(tmp, '/');
188 	if (!ptr)
189 		goto out;
190 	ptr = memmove(ptr + 1, ptr, strlen(ptr) - 1);
191 	*ptr = '.';
192 
193 	tofd = mkstemp(tmp);
194 	if (tofd < 0)
195 		goto out;
196 
197 	if (fchmod(tofd, mode))
198 		goto out_close_to;
199 
200 	if (st.st_size == 0) { /* /proc? do it slowly... */
201 		err = slow_copyfile(from, tmp);
202 		goto out_close_to;
203 	}
204 
205 	fromfd = open(from, O_RDONLY);
206 	if (fromfd < 0)
207 		goto out_close_to;
208 
209 	err = copyfile_offset(fromfd, 0, tofd, 0, st.st_size);
210 
211 	close(fromfd);
212 out_close_to:
213 	close(tofd);
214 	if (!err)
215 		err = link(tmp, to);
216 	unlink(tmp);
217 out:
218 	free(tmp);
219 	return err;
220 }
221 
copyfile(const char * from,const char * to)222 int copyfile(const char *from, const char *to)
223 {
224 	return copyfile_mode(from, to, 0755);
225 }
226 
convert_unit(unsigned long value,char * unit)227 unsigned long convert_unit(unsigned long value, char *unit)
228 {
229 	*unit = ' ';
230 
231 	if (value > 1000) {
232 		value /= 1000;
233 		*unit = 'K';
234 	}
235 
236 	if (value > 1000) {
237 		value /= 1000;
238 		*unit = 'M';
239 	}
240 
241 	if (value > 1000) {
242 		value /= 1000;
243 		*unit = 'G';
244 	}
245 
246 	return value;
247 }
248 
ion(bool is_read,int fd,void * buf,size_t n)249 static ssize_t ion(bool is_read, int fd, void *buf, size_t n)
250 {
251 	void *buf_start = buf;
252 	size_t left = n;
253 
254 	while (left) {
255 		ssize_t ret = is_read ? read(fd, buf, left) :
256 					write(fd, buf, left);
257 
258 		if (ret < 0 && errno == EINTR)
259 			continue;
260 		if (ret <= 0)
261 			return ret;
262 
263 		left -= ret;
264 		buf  += ret;
265 	}
266 
267 	BUG_ON((size_t)(buf - buf_start) != n);
268 	return n;
269 }
270 
271 /*
272  * Read exactly 'n' bytes or return an error.
273  */
readn(int fd,void * buf,size_t n)274 ssize_t readn(int fd, void *buf, size_t n)
275 {
276 	return ion(true, fd, buf, n);
277 }
278 
279 /*
280  * Write exactly 'n' bytes or return an error.
281  */
writen(int fd,void * buf,size_t n)282 ssize_t writen(int fd, void *buf, size_t n)
283 {
284 	return ion(false, fd, buf, n);
285 }
286 
hex_width(u64 v)287 size_t hex_width(u64 v)
288 {
289 	size_t n = 1;
290 
291 	while ((v >>= 4))
292 		++n;
293 
294 	return n;
295 }
296 
hex(char ch)297 static int hex(char ch)
298 {
299 	if ((ch >= '0') && (ch <= '9'))
300 		return ch - '0';
301 	if ((ch >= 'a') && (ch <= 'f'))
302 		return ch - 'a' + 10;
303 	if ((ch >= 'A') && (ch <= 'F'))
304 		return ch - 'A' + 10;
305 	return -1;
306 }
307 
308 /*
309  * While we find nice hex chars, build a long_val.
310  * Return number of chars processed.
311  */
hex2u64(const char * ptr,u64 * long_val)312 int hex2u64(const char *ptr, u64 *long_val)
313 {
314 	const char *p = ptr;
315 	*long_val = 0;
316 
317 	while (*p) {
318 		const int hex_val = hex(*p);
319 
320 		if (hex_val < 0)
321 			break;
322 
323 		*long_val = (*long_val << 4) | hex_val;
324 		p++;
325 	}
326 
327 	return p - ptr;
328 }
329 
330 /* Obtain a backtrace and print it to stdout. */
331 #ifdef HAVE_BACKTRACE_SUPPORT
dump_stack(void)332 void dump_stack(void)
333 {
334 	void *array[16];
335 	size_t size = backtrace(array, ARRAY_SIZE(array));
336 	char **strings = backtrace_symbols(array, size);
337 	size_t i;
338 
339 	printf("Obtained %zd stack frames.\n", size);
340 
341 	for (i = 0; i < size; i++)
342 		printf("%s\n", strings[i]);
343 
344 	free(strings);
345 }
346 #else
dump_stack(void)347 void dump_stack(void) {}
348 #endif
349 
sighandler_dump_stack(int sig)350 void sighandler_dump_stack(int sig)
351 {
352 	psignal(sig, "perf");
353 	dump_stack();
354 	exit(sig);
355 }
356 
get_term_dimensions(struct winsize * ws)357 void get_term_dimensions(struct winsize *ws)
358 {
359 	char *s = getenv("LINES");
360 
361 	if (s != NULL) {
362 		ws->ws_row = atoi(s);
363 		s = getenv("COLUMNS");
364 		if (s != NULL) {
365 			ws->ws_col = atoi(s);
366 			if (ws->ws_row && ws->ws_col)
367 				return;
368 		}
369 	}
370 #ifdef TIOCGWINSZ
371 	if (ioctl(1, TIOCGWINSZ, ws) == 0 &&
372 	    ws->ws_row && ws->ws_col)
373 		return;
374 #endif
375 	ws->ws_row = 25;
376 	ws->ws_col = 80;
377 }
378 
set_term_quiet_input(struct termios * old)379 void set_term_quiet_input(struct termios *old)
380 {
381 	struct termios tc;
382 
383 	tcgetattr(0, old);
384 	tc = *old;
385 	tc.c_lflag &= ~(ICANON | ECHO);
386 	tc.c_cc[VMIN] = 0;
387 	tc.c_cc[VTIME] = 0;
388 	tcsetattr(0, TCSANOW, &tc);
389 }
390 
parse_nsec_time(const char * str,u64 * ptime)391 int parse_nsec_time(const char *str, u64 *ptime)
392 {
393 	u64 time_sec, time_nsec;
394 	char *end;
395 
396 	time_sec = strtoul(str, &end, 10);
397 	if (*end != '.' && *end != '\0')
398 		return -1;
399 
400 	if (*end == '.') {
401 		int i;
402 		char nsec_buf[10];
403 
404 		if (strlen(++end) > 9)
405 			return -1;
406 
407 		strncpy(nsec_buf, end, 9);
408 		nsec_buf[9] = '\0';
409 
410 		/* make it nsec precision */
411 		for (i = strlen(nsec_buf); i < 9; i++)
412 			nsec_buf[i] = '0';
413 
414 		time_nsec = strtoul(nsec_buf, &end, 10);
415 		if (*end != '\0')
416 			return -1;
417 	} else
418 		time_nsec = 0;
419 
420 	*ptime = time_sec * NSEC_PER_SEC + time_nsec;
421 	return 0;
422 }
423 
parse_tag_value(const char * str,struct parse_tag * tags)424 unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
425 {
426 	struct parse_tag *i = tags;
427 
428 	while (i->tag) {
429 		char *s;
430 
431 		s = strchr(str, i->tag);
432 		if (s) {
433 			unsigned long int value;
434 			char *endptr;
435 
436 			value = strtoul(str, &endptr, 10);
437 			if (s != endptr)
438 				break;
439 
440 			if (value > ULONG_MAX / i->mult)
441 				break;
442 			value *= i->mult;
443 			return value;
444 		}
445 		i++;
446 	}
447 
448 	return (unsigned long) -1;
449 }
450 
get_stack_size(const char * str,unsigned long * _size)451 int get_stack_size(const char *str, unsigned long *_size)
452 {
453 	char *endptr;
454 	unsigned long size;
455 	unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
456 
457 	size = strtoul(str, &endptr, 0);
458 
459 	do {
460 		if (*endptr)
461 			break;
462 
463 		size = round_up(size, sizeof(u64));
464 		if (!size || size > max_size)
465 			break;
466 
467 		*_size = size;
468 		return 0;
469 
470 	} while (0);
471 
472 	pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
473 	       max_size, str);
474 	return -1;
475 }
476 
parse_callchain_record(const char * arg,struct callchain_param * param)477 int parse_callchain_record(const char *arg, struct callchain_param *param)
478 {
479 	char *tok, *name, *saveptr = NULL;
480 	char *buf;
481 	int ret = -1;
482 
483 	/* We need buffer that we know we can write to. */
484 	buf = malloc(strlen(arg) + 1);
485 	if (!buf)
486 		return -ENOMEM;
487 
488 	strcpy(buf, arg);
489 
490 	tok = strtok_r((char *)buf, ",", &saveptr);
491 	name = tok ? : (char *)buf;
492 
493 	do {
494 		/* Framepointer style */
495 		if (!strncmp(name, "fp", sizeof("fp"))) {
496 			if (!strtok_r(NULL, ",", &saveptr)) {
497 				param->record_mode = CALLCHAIN_FP;
498 				ret = 0;
499 			} else
500 				pr_err("callchain: No more arguments "
501 				       "needed for --call-graph fp\n");
502 			break;
503 
504 #ifdef HAVE_DWARF_UNWIND_SUPPORT
505 		/* Dwarf style */
506 		} else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
507 			const unsigned long default_stack_dump_size = 8192;
508 
509 			ret = 0;
510 			param->record_mode = CALLCHAIN_DWARF;
511 			param->dump_size = default_stack_dump_size;
512 
513 			tok = strtok_r(NULL, ",", &saveptr);
514 			if (tok) {
515 				unsigned long size = 0;
516 
517 				ret = get_stack_size(tok, &size);
518 				param->dump_size = size;
519 			}
520 #endif /* HAVE_DWARF_UNWIND_SUPPORT */
521 		} else if (!strncmp(name, "lbr", sizeof("lbr"))) {
522 			if (!strtok_r(NULL, ",", &saveptr)) {
523 				param->record_mode = CALLCHAIN_LBR;
524 				ret = 0;
525 			} else
526 				pr_err("callchain: No more arguments "
527 					"needed for --call-graph lbr\n");
528 			break;
529 		} else {
530 			pr_err("callchain: Unknown --call-graph option "
531 			       "value: %s\n", arg);
532 			break;
533 		}
534 
535 	} while (0);
536 
537 	free(buf);
538 	return ret;
539 }
540 
filename__read_str(const char * filename,char ** buf,size_t * sizep)541 int filename__read_str(const char *filename, char **buf, size_t *sizep)
542 {
543 	size_t size = 0, alloc_size = 0;
544 	void *bf = NULL, *nbf;
545 	int fd, n, err = 0;
546 	char sbuf[STRERR_BUFSIZE];
547 
548 	fd = open(filename, O_RDONLY);
549 	if (fd < 0)
550 		return -errno;
551 
552 	do {
553 		if (size == alloc_size) {
554 			alloc_size += BUFSIZ;
555 			nbf = realloc(bf, alloc_size);
556 			if (!nbf) {
557 				err = -ENOMEM;
558 				break;
559 			}
560 
561 			bf = nbf;
562 		}
563 
564 		n = read(fd, bf + size, alloc_size - size);
565 		if (n < 0) {
566 			if (size) {
567 				pr_warning("read failed %d: %s\n", errno,
568 					 strerror_r(errno, sbuf, sizeof(sbuf)));
569 				err = 0;
570 			} else
571 				err = -errno;
572 
573 			break;
574 		}
575 
576 		size += n;
577 	} while (n > 0);
578 
579 	if (!err) {
580 		*sizep = size;
581 		*buf   = bf;
582 	} else
583 		free(bf);
584 
585 	close(fd);
586 	return err;
587 }
588 
get_filename_for_perf_kvm(void)589 const char *get_filename_for_perf_kvm(void)
590 {
591 	const char *filename;
592 
593 	if (perf_host && !perf_guest)
594 		filename = strdup("perf.data.host");
595 	else if (!perf_host && perf_guest)
596 		filename = strdup("perf.data.guest");
597 	else
598 		filename = strdup("perf.data.kvm");
599 
600 	return filename;
601 }
602 
perf_event_paranoid(void)603 int perf_event_paranoid(void)
604 {
605 	int value;
606 
607 	if (sysctl__read_int("kernel/perf_event_paranoid", &value))
608 		return INT_MAX;
609 
610 	return value;
611 }
612 
mem_bswap_32(void * src,int byte_size)613 void mem_bswap_32(void *src, int byte_size)
614 {
615 	u32 *m = src;
616 	while (byte_size > 0) {
617 		*m = bswap_32(*m);
618 		byte_size -= sizeof(u32);
619 		++m;
620 	}
621 }
622 
mem_bswap_64(void * src,int byte_size)623 void mem_bswap_64(void *src, int byte_size)
624 {
625 	u64 *m = src;
626 
627 	while (byte_size > 0) {
628 		*m = bswap_64(*m);
629 		byte_size -= sizeof(u64);
630 		++m;
631 	}
632 }
633 
find_process(const char * name)634 bool find_process(const char *name)
635 {
636 	size_t len = strlen(name);
637 	DIR *dir;
638 	struct dirent *d;
639 	int ret = -1;
640 
641 	dir = opendir(procfs__mountpoint());
642 	if (!dir)
643 		return false;
644 
645 	/* Walk through the directory. */
646 	while (ret && (d = readdir(dir)) != NULL) {
647 		char path[PATH_MAX];
648 		char *data;
649 		size_t size;
650 
651 		if ((d->d_type != DT_DIR) ||
652 		     !strcmp(".", d->d_name) ||
653 		     !strcmp("..", d->d_name))
654 			continue;
655 
656 		scnprintf(path, sizeof(path), "%s/%s/comm",
657 			  procfs__mountpoint(), d->d_name);
658 
659 		if (filename__read_str(path, &data, &size))
660 			continue;
661 
662 		ret = strncmp(name, data, len);
663 		free(data);
664 	}
665 
666 	closedir(dir);
667 	return ret ? false : true;
668 }
669 
670 int
fetch_kernel_version(unsigned int * puint,char * str,size_t str_size)671 fetch_kernel_version(unsigned int *puint, char *str,
672 		     size_t str_size)
673 {
674 	struct utsname utsname;
675 	int version, patchlevel, sublevel, err;
676 
677 	if (uname(&utsname))
678 		return -1;
679 
680 	if (str && str_size) {
681 		strncpy(str, utsname.release, str_size);
682 		str[str_size - 1] = '\0';
683 	}
684 
685 	err = sscanf(utsname.release, "%d.%d.%d",
686 		     &version, &patchlevel, &sublevel);
687 
688 	if (err != 3) {
689 		pr_debug("Unablt to get kernel version from uname '%s'\n",
690 			 utsname.release);
691 		return -1;
692 	}
693 
694 	if (puint)
695 		*puint = (version << 16) + (patchlevel << 8) + sublevel;
696 	return 0;
697 }
698