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 bool test_attr__enabled
;
38 bool perf_host
= true;
39 bool perf_guest
= false;
41 void event_attr_init(struct perf_event_attr
*attr
)
44 attr
->exclude_host
= 1;
46 attr
->exclude_guest
= 1;
47 /* to capture ABI version */
48 attr
->size
= sizeof(*attr
);
51 int mkdir_p(char *path
, mode_t mode
)
60 if (stat(path
, &st
) == 0)
65 while ((d
= strchr(d
, '/'))) {
67 err
= stat(path
, &st
) && mkdir(path
, mode
);
74 return (stat(path
, &st
) && mkdir(path
, mode
)) ? -1 : 0;
82 char namebuf
[PATH_MAX
];
88 while ((d
= readdir(dir
)) != NULL
&& !ret
) {
91 if (!strcmp(d
->d_name
, ".") || !strcmp(d
->d_name
, ".."))
94 scnprintf(namebuf
, sizeof(namebuf
), "%s/%s",
97 ret
= stat(namebuf
, &statbuf
);
99 pr_debug("stat failed: %s\n", namebuf
);
103 if (S_ISREG(statbuf
.st_mode
))
104 ret
= unlink(namebuf
);
105 else if (S_ISDIR(statbuf
.st_mode
))
106 ret
= rm_rf(namebuf
);
108 pr_debug("unknown file: %s\n", namebuf
);
120 /* A filter which removes dot files */
121 bool lsdir_no_dot_filter(const char *name __maybe_unused
, struct dirent
*d
)
123 return d
->d_name
[0] != '.';
126 /* lsdir reads a directory and store it in strlist */
127 struct strlist
*lsdir(const char *name
,
128 bool (*filter
)(const char *, struct dirent
*))
130 struct strlist
*list
= NULL
;
138 list
= strlist__new(NULL
, NULL
);
144 while ((d
= readdir(dir
)) != NULL
) {
145 if (!filter
|| filter(name
, d
))
146 strlist__add(list
, d
->d_name
);
154 static int slow_copyfile(const char *from
, const char *to
)
159 FILE *from_fp
= fopen(from
, "r"), *to_fp
;
164 to_fp
= fopen(to
, "w");
166 goto out_fclose_from
;
168 while (getline(&line
, &n
, from_fp
) > 0)
169 if (fputs(line
, to_fp
) == EOF
)
181 int copyfile_offset(int ifd
, loff_t off_in
, int ofd
, loff_t off_out
, u64 size
)
186 pgoff
= off_in
& ~(page_size
- 1);
189 ptr
= mmap(NULL
, off_in
+ size
, PROT_READ
, MAP_PRIVATE
, ifd
, pgoff
);
190 if (ptr
== MAP_FAILED
)
194 ssize_t ret
= pwrite(ofd
, ptr
+ off_in
, size
, off_out
);
195 if (ret
< 0 && errno
== EINTR
)
204 munmap(ptr
, off_in
+ size
);
206 return size
? -1 : 0;
209 int copyfile_mode(const char *from
, const char *to
, mode_t mode
)
214 char *tmp
= NULL
, *ptr
= NULL
;
219 /* extra 'x' at the end is to reserve space for '.' */
220 if (asprintf(&tmp
, "%s.XXXXXXx", to
) < 0) {
224 ptr
= strrchr(tmp
, '/');
227 ptr
= memmove(ptr
+ 1, ptr
, strlen(ptr
) - 1);
234 if (fchmod(tofd
, mode
))
237 if (st
.st_size
== 0) { /* /proc? do it slowly... */
238 err
= slow_copyfile(from
, tmp
);
242 fromfd
= open(from
, O_RDONLY
);
246 err
= copyfile_offset(fromfd
, 0, tofd
, 0, st
.st_size
);
259 int copyfile(const char *from
, const char *to
)
261 return copyfile_mode(from
, to
, 0755);
264 unsigned long convert_unit(unsigned long value
, char *unit
)
286 static ssize_t
ion(bool is_read
, int fd
, void *buf
, size_t n
)
288 void *buf_start
= buf
;
292 ssize_t ret
= is_read
? read(fd
, buf
, left
) :
293 write(fd
, buf
, left
);
295 if (ret
< 0 && errno
== EINTR
)
304 BUG_ON((size_t)(buf
- buf_start
) != n
);
309 * Read exactly 'n' bytes or return an error.
311 ssize_t
readn(int fd
, void *buf
, size_t n
)
313 return ion(true, fd
, buf
, n
);
317 * Write exactly 'n' bytes or return an error.
319 ssize_t
writen(int fd
, void *buf
, size_t n
)
321 return ion(false, fd
, buf
, n
);
324 size_t hex_width(u64 v
)
334 static int hex(char ch
)
336 if ((ch
>= '0') && (ch
<= '9'))
338 if ((ch
>= 'a') && (ch
<= 'f'))
339 return ch
- 'a' + 10;
340 if ((ch
>= 'A') && (ch
<= 'F'))
341 return ch
- 'A' + 10;
346 * While we find nice hex chars, build a long_val.
347 * Return number of chars processed.
349 int hex2u64(const char *ptr
, u64
*long_val
)
355 const int hex_val
= hex(*p
);
360 *long_val
= (*long_val
<< 4) | hex_val
;
367 /* Obtain a backtrace and print it to stdout. */
368 #ifdef HAVE_BACKTRACE_SUPPORT
369 void dump_stack(void)
372 size_t size
= backtrace(array
, ARRAY_SIZE(array
));
373 char **strings
= backtrace_symbols(array
, size
);
376 printf("Obtained %zd stack frames.\n", size
);
378 for (i
= 0; i
< size
; i
++)
379 printf("%s\n", strings
[i
]);
384 void dump_stack(void) {}
387 void sighandler_dump_stack(int sig
)
389 psignal(sig
, "perf");
391 signal(sig
, SIG_DFL
);
395 int parse_nsec_time(const char *str
, u64
*ptime
)
397 u64 time_sec
, time_nsec
;
400 time_sec
= strtoul(str
, &end
, 10);
401 if (*end
!= '.' && *end
!= '\0')
408 if (strlen(++end
) > 9)
411 strncpy(nsec_buf
, end
, 9);
414 /* make it nsec precision */
415 for (i
= strlen(nsec_buf
); i
< 9; i
++)
418 time_nsec
= strtoul(nsec_buf
, &end
, 10);
424 *ptime
= time_sec
* NSEC_PER_SEC
+ time_nsec
;
428 unsigned long parse_tag_value(const char *str
, struct parse_tag
*tags
)
430 struct parse_tag
*i
= tags
;
435 s
= strchr(str
, i
->tag
);
437 unsigned long int value
;
440 value
= strtoul(str
, &endptr
, 10);
444 if (value
> ULONG_MAX
/ i
->mult
)
452 return (unsigned long) -1;
455 int get_stack_size(const char *str
, unsigned long *_size
)
459 unsigned long max_size
= round_down(USHRT_MAX
, sizeof(u64
));
461 size
= strtoul(str
, &endptr
, 0);
467 size
= round_up(size
, sizeof(u64
));
468 if (!size
|| size
> max_size
)
476 pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
481 int parse_callchain_record(const char *arg
, struct callchain_param
*param
)
483 char *tok
, *name
, *saveptr
= NULL
;
487 /* We need buffer that we know we can write to. */
488 buf
= malloc(strlen(arg
) + 1);
494 tok
= strtok_r((char *)buf
, ",", &saveptr
);
495 name
= tok
? : (char *)buf
;
498 /* Framepointer style */
499 if (!strncmp(name
, "fp", sizeof("fp"))) {
500 if (!strtok_r(NULL
, ",", &saveptr
)) {
501 param
->record_mode
= CALLCHAIN_FP
;
504 pr_err("callchain: No more arguments "
505 "needed for --call-graph fp\n");
508 #ifdef HAVE_DWARF_UNWIND_SUPPORT
510 } else if (!strncmp(name
, "dwarf", sizeof("dwarf"))) {
511 const unsigned long default_stack_dump_size
= 8192;
514 param
->record_mode
= CALLCHAIN_DWARF
;
515 param
->dump_size
= default_stack_dump_size
;
517 tok
= strtok_r(NULL
, ",", &saveptr
);
519 unsigned long size
= 0;
521 ret
= get_stack_size(tok
, &size
);
522 param
->dump_size
= size
;
524 #endif /* HAVE_DWARF_UNWIND_SUPPORT */
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
);