6 #include <sys/utsname.h>
7 #ifdef HAVE_BACKTRACE_SUPPORT
16 #include <linux/kernel.h>
17 #include <linux/log2.h>
19 #include "callchain.h"
22 struct callchain_param callchain_param
= {
23 .mode
= CHAIN_GRAPH_ABS
,
25 .order
= ORDER_CALLEE
,
26 .key
= CCKEY_FUNCTION
,
27 .value
= CCVAL_PERCENT
,
31 * XXX We need to find a better place for these things...
33 unsigned int page_size
;
36 unsigned int sysctl_perf_event_max_stack
= PERF_MAX_STACK_DEPTH
;
38 bool test_attr__enabled
;
40 bool perf_host
= true;
41 bool perf_guest
= false;
43 void event_attr_init(struct perf_event_attr
*attr
)
46 attr
->exclude_host
= 1;
48 attr
->exclude_guest
= 1;
49 /* to capture ABI version */
50 attr
->size
= sizeof(*attr
);
53 int mkdir_p(char *path
, mode_t mode
)
62 if (stat(path
, &st
) == 0)
67 while ((d
= strchr(d
, '/'))) {
69 err
= stat(path
, &st
) && mkdir(path
, mode
);
76 return (stat(path
, &st
) && mkdir(path
, mode
)) ? -1 : 0;
84 char namebuf
[PATH_MAX
];
90 while ((d
= readdir(dir
)) != NULL
&& !ret
) {
93 if (!strcmp(d
->d_name
, ".") || !strcmp(d
->d_name
, ".."))
96 scnprintf(namebuf
, sizeof(namebuf
), "%s/%s",
99 ret
= stat(namebuf
, &statbuf
);
101 pr_debug("stat failed: %s\n", namebuf
);
105 if (S_ISREG(statbuf
.st_mode
))
106 ret
= unlink(namebuf
);
107 else if (S_ISDIR(statbuf
.st_mode
))
108 ret
= rm_rf(namebuf
);
110 pr_debug("unknown file: %s\n", namebuf
);
122 /* A filter which removes dot files */
123 bool lsdir_no_dot_filter(const char *name __maybe_unused
, struct dirent
*d
)
125 return d
->d_name
[0] != '.';
128 /* lsdir reads a directory and store it in strlist */
129 struct strlist
*lsdir(const char *name
,
130 bool (*filter
)(const char *, struct dirent
*))
132 struct strlist
*list
= NULL
;
140 list
= strlist__new(NULL
, NULL
);
146 while ((d
= readdir(dir
)) != NULL
) {
147 if (!filter
|| filter(name
, d
))
148 strlist__add(list
, d
->d_name
);
156 static int slow_copyfile(const char *from
, const char *to
)
161 FILE *from_fp
= fopen(from
, "r"), *to_fp
;
166 to_fp
= fopen(to
, "w");
168 goto out_fclose_from
;
170 while (getline(&line
, &n
, from_fp
) > 0)
171 if (fputs(line
, to_fp
) == EOF
)
183 int copyfile_offset(int ifd
, loff_t off_in
, int ofd
, loff_t off_out
, u64 size
)
188 pgoff
= off_in
& ~(page_size
- 1);
191 ptr
= mmap(NULL
, off_in
+ size
, PROT_READ
, MAP_PRIVATE
, ifd
, pgoff
);
192 if (ptr
== MAP_FAILED
)
196 ssize_t ret
= pwrite(ofd
, ptr
+ off_in
, size
, off_out
);
197 if (ret
< 0 && errno
== EINTR
)
206 munmap(ptr
, off_in
+ size
);
208 return size
? -1 : 0;
211 int copyfile_mode(const char *from
, const char *to
, mode_t mode
)
216 char *tmp
= NULL
, *ptr
= NULL
;
221 /* extra 'x' at the end is to reserve space for '.' */
222 if (asprintf(&tmp
, "%s.XXXXXXx", to
) < 0) {
226 ptr
= strrchr(tmp
, '/');
229 ptr
= memmove(ptr
+ 1, ptr
, strlen(ptr
) - 1);
236 if (fchmod(tofd
, mode
))
239 if (st
.st_size
== 0) { /* /proc? do it slowly... */
240 err
= slow_copyfile(from
, tmp
);
244 fromfd
= open(from
, O_RDONLY
);
248 err
= copyfile_offset(fromfd
, 0, tofd
, 0, st
.st_size
);
261 int copyfile(const char *from
, const char *to
)
263 return copyfile_mode(from
, to
, 0755);
266 unsigned long convert_unit(unsigned long value
, char *unit
)
288 static ssize_t
ion(bool is_read
, int fd
, void *buf
, size_t n
)
290 void *buf_start
= buf
;
294 ssize_t ret
= is_read
? read(fd
, buf
, left
) :
295 write(fd
, buf
, left
);
297 if (ret
< 0 && errno
== EINTR
)
306 BUG_ON((size_t)(buf
- buf_start
) != n
);
311 * Read exactly 'n' bytes or return an error.
313 ssize_t
readn(int fd
, void *buf
, size_t n
)
315 return ion(true, fd
, buf
, n
);
319 * Write exactly 'n' bytes or return an error.
321 ssize_t
writen(int fd
, void *buf
, size_t n
)
323 return ion(false, fd
, buf
, n
);
326 size_t hex_width(u64 v
)
336 static int hex(char ch
)
338 if ((ch
>= '0') && (ch
<= '9'))
340 if ((ch
>= 'a') && (ch
<= 'f'))
341 return ch
- 'a' + 10;
342 if ((ch
>= 'A') && (ch
<= 'F'))
343 return ch
- 'A' + 10;
348 * While we find nice hex chars, build a long_val.
349 * Return number of chars processed.
351 int hex2u64(const char *ptr
, u64
*long_val
)
357 const int hex_val
= hex(*p
);
362 *long_val
= (*long_val
<< 4) | hex_val
;
369 /* Obtain a backtrace and print it to stdout. */
370 #ifdef HAVE_BACKTRACE_SUPPORT
371 void dump_stack(void)
374 size_t size
= backtrace(array
, ARRAY_SIZE(array
));
375 char **strings
= backtrace_symbols(array
, size
);
378 printf("Obtained %zd stack frames.\n", size
);
380 for (i
= 0; i
< size
; i
++)
381 printf("%s\n", strings
[i
]);
386 void dump_stack(void) {}
389 void sighandler_dump_stack(int sig
)
391 psignal(sig
, "perf");
393 signal(sig
, SIG_DFL
);
397 int parse_nsec_time(const char *str
, u64
*ptime
)
399 u64 time_sec
, time_nsec
;
402 time_sec
= strtoul(str
, &end
, 10);
403 if (*end
!= '.' && *end
!= '\0')
410 if (strlen(++end
) > 9)
413 strncpy(nsec_buf
, end
, 9);
416 /* make it nsec precision */
417 for (i
= strlen(nsec_buf
); i
< 9; i
++)
420 time_nsec
= strtoul(nsec_buf
, &end
, 10);
426 *ptime
= time_sec
* NSEC_PER_SEC
+ time_nsec
;
430 unsigned long parse_tag_value(const char *str
, struct parse_tag
*tags
)
432 struct parse_tag
*i
= tags
;
437 s
= strchr(str
, i
->tag
);
439 unsigned long int value
;
442 value
= strtoul(str
, &endptr
, 10);
446 if (value
> ULONG_MAX
/ i
->mult
)
454 return (unsigned long) -1;
457 int get_stack_size(const char *str
, unsigned long *_size
)
461 unsigned long max_size
= round_down(USHRT_MAX
, sizeof(u64
));
463 size
= strtoul(str
, &endptr
, 0);
469 size
= round_up(size
, sizeof(u64
));
470 if (!size
|| size
> max_size
)
478 pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
483 int parse_callchain_record(const char *arg
, struct callchain_param
*param
)
485 char *tok
, *name
, *saveptr
= NULL
;
489 /* We need buffer that we know we can write to. */
490 buf
= malloc(strlen(arg
) + 1);
496 tok
= strtok_r((char *)buf
, ",", &saveptr
);
497 name
= tok
? : (char *)buf
;
500 /* Framepointer style */
501 if (!strncmp(name
, "fp", sizeof("fp"))) {
502 if (!strtok_r(NULL
, ",", &saveptr
)) {
503 param
->record_mode
= CALLCHAIN_FP
;
506 pr_err("callchain: No more arguments "
507 "needed for --call-graph fp\n");
511 } else if (!strncmp(name
, "dwarf", sizeof("dwarf"))) {
512 const unsigned long default_stack_dump_size
= 8192;
515 param
->record_mode
= CALLCHAIN_DWARF
;
516 param
->dump_size
= default_stack_dump_size
;
518 tok
= strtok_r(NULL
, ",", &saveptr
);
520 unsigned long size
= 0;
522 ret
= get_stack_size(tok
, &size
);
523 param
->dump_size
= size
;
525 } else if (!strncmp(name
, "lbr", sizeof("lbr"))) {
526 if (!strtok_r(NULL
, ",", &saveptr
)) {
527 param
->record_mode
= CALLCHAIN_LBR
;
530 pr_err("callchain: No more arguments "
531 "needed for --call-graph lbr\n");
534 pr_err("callchain: Unknown --call-graph option "
545 const char *get_filename_for_perf_kvm(void)
547 const char *filename
;
549 if (perf_host
&& !perf_guest
)
550 filename
= strdup("perf.data.host");
551 else if (!perf_host
&& perf_guest
)
552 filename
= strdup("perf.data.guest");
554 filename
= strdup("perf.data.kvm");
559 int perf_event_paranoid(void)
563 if (sysctl__read_int("kernel/perf_event_paranoid", &value
))
569 void mem_bswap_32(void *src
, int byte_size
)
572 while (byte_size
> 0) {
574 byte_size
-= sizeof(u32
);
579 void mem_bswap_64(void *src
, int byte_size
)
583 while (byte_size
> 0) {
585 byte_size
-= sizeof(u64
);
590 bool find_process(const char *name
)
592 size_t len
= strlen(name
);
597 dir
= opendir(procfs__mountpoint());
601 /* Walk through the directory. */
602 while (ret
&& (d
= readdir(dir
)) != NULL
) {
607 if ((d
->d_type
!= DT_DIR
) ||
608 !strcmp(".", d
->d_name
) ||
609 !strcmp("..", d
->d_name
))
612 scnprintf(path
, sizeof(path
), "%s/%s/comm",
613 procfs__mountpoint(), d
->d_name
);
615 if (filename__read_str(path
, &data
, &size
))
618 ret
= strncmp(name
, data
, len
);
623 return ret
? false : true;
627 fetch_kernel_version(unsigned int *puint
, char *str
,
630 struct utsname utsname
;
631 int version
, patchlevel
, sublevel
, err
;
636 if (str
&& str_size
) {
637 strncpy(str
, utsname
.release
, str_size
);
638 str
[str_size
- 1] = '\0';
641 err
= sscanf(utsname
.release
, "%d.%d.%d",
642 &version
, &patchlevel
, &sublevel
);
645 pr_debug("Unablt to get kernel version from uname '%s'\n",
651 *puint
= (version
<< 16) + (patchlevel
<< 8) + sublevel
;
655 const char *perf_tip(const char *dirpath
)
657 struct strlist
*tips
;
658 struct str_node
*node
;
660 struct strlist_config conf
= {
665 tips
= strlist__new("tips.txt", &conf
);
667 return errno
== ENOENT
? NULL
: "Tip: get more memory! ;-p";
669 if (strlist__nr_entries(tips
) == 0)
672 node
= strlist__entry(tips
, random() % strlist__nr_entries(tips
));
673 if (asprintf(&tip
, "Tip: %s", node
->s
) < 0)
674 tip
= (char *)"Tip: get more memory! ;-)";
677 strlist__delete(tips
);
682 bool is_regular_file(const char *file
)
689 return S_ISREG(st
.st_mode
);
692 int fetch_current_timestamp(char *buf
, size_t sz
)
698 if (gettimeofday(&tv
, NULL
) || !localtime_r(&tv
.tv_sec
, &tm
))
701 if (!strftime(dt
, sizeof(dt
), "%Y%m%d%H%M%S", &tm
))
704 scnprintf(buf
, sz
, "%s%02u", dt
, (unsigned)tv
.tv_usec
/ 10000);
709 void print_binary(unsigned char *data
, size_t len
,
710 size_t bytes_per_line
, print_binary_t printer
,
718 bytes_per_line
= roundup_pow_of_two(bytes_per_line
);
719 mask
= bytes_per_line
- 1;
721 printer(BINARY_PRINT_DATA_BEGIN
, 0, extra
);
722 for (i
= 0; i
< len
; i
++) {
723 if ((i
& mask
) == 0) {
724 printer(BINARY_PRINT_LINE_BEGIN
, -1, extra
);
725 printer(BINARY_PRINT_ADDR
, i
, extra
);
728 printer(BINARY_PRINT_NUM_DATA
, data
[i
], extra
);
730 if (((i
& mask
) == mask
) || i
== len
- 1) {
731 for (j
= 0; j
< mask
-(i
& mask
); j
++)
732 printer(BINARY_PRINT_NUM_PAD
, -1, extra
);
734 printer(BINARY_PRINT_SEP
, i
, extra
);
735 for (j
= i
& ~mask
; j
<= i
; j
++)
736 printer(BINARY_PRINT_CHAR_DATA
, data
[j
], extra
);
737 for (j
= 0; j
< mask
-(i
& mask
); j
++)
738 printer(BINARY_PRINT_CHAR_PAD
, i
, extra
);
739 printer(BINARY_PRINT_LINE_END
, -1, extra
);
742 printer(BINARY_PRINT_DATA_END
, -1, extra
);