aboutsummaryrefslogtreecommitdiffstats
path: root/tools/perf/util
diff options
context:
space:
mode:
Diffstat (limited to 'tools/perf/util')
-rwxr-xr-xtools/perf/util/PERF-VERSION-GEN23
-rw-r--r--tools/perf/util/abspath.c81
-rw-r--r--tools/perf/util/bitmap.c21
-rw-r--r--tools/perf/util/build-id.c24
-rw-r--r--tools/perf/util/build-id.h2
-rw-r--r--tools/perf/util/cache.h67
-rw-r--r--tools/perf/util/callchain.c131
-rw-r--r--tools/perf/util/callchain.h14
-rw-r--r--tools/perf/util/color.c48
-rw-r--r--tools/perf/util/color.h4
-rw-r--r--tools/perf/util/config.c461
-rw-r--r--tools/perf/util/debug.c8
-rw-r--r--tools/perf/util/debug.h30
-rw-r--r--tools/perf/util/event.c385
-rw-r--r--tools/perf/util/event.h66
-rw-r--r--tools/perf/util/exec_cmd.c6
-rw-r--r--tools/perf/util/exec_cmd.h1
-rw-r--r--tools/perf/util/header.c509
-rw-r--r--tools/perf/util/header.h39
-rw-r--r--tools/perf/util/help.c30
-rw-r--r--tools/perf/util/hist.c654
-rw-r--r--tools/perf/util/hist.h122
-rw-r--r--tools/perf/util/hweight.c31
-rw-r--r--tools/perf/util/include/asm/bitops.h18
-rw-r--r--tools/perf/util/include/asm/hweight.h8
-rw-r--r--tools/perf/util/include/dwarf-regs.h8
-rw-r--r--tools/perf/util/include/linux/bitmap.h38
-rw-r--r--tools/perf/util/include/linux/bitops.h20
-rw-r--r--tools/perf/util/include/linux/compiler.h2
-rw-r--r--tools/perf/util/include/linux/kernel.h11
-rw-r--r--tools/perf/util/map.c409
-rw-r--r--tools/perf/util/map.h131
-rw-r--r--tools/perf/util/newt.c1178
-rw-r--r--tools/perf/util/parse-events.c44
-rw-r--r--tools/perf/util/parse-events.h1
-rw-r--r--tools/perf/util/parse-options.c55
-rw-r--r--tools/perf/util/parse-options.h29
-rw-r--r--tools/perf/util/path.c204
-rw-r--r--tools/perf/util/probe-event.c1580
-rw-r--r--tools/perf/util/probe-event.h130
-rw-r--r--tools/perf/util/probe-finder.c1059
-rw-r--r--tools/perf/util/probe-finder.h70
-rw-r--r--tools/perf/util/pstack.c75
-rw-r--r--tools/perf/util/pstack.h12
-rw-r--r--tools/perf/util/quote.c433
-rw-r--r--tools/perf/util/quote.h39
-rw-r--r--tools/perf/util/run-command.c90
-rw-r--r--tools/perf/util/run-command.h30
-rw-r--r--tools/perf/util/scripting-engines/trace-event-perl.c3
-rw-r--r--tools/perf/util/scripting-engines/trace-event-python.c54
-rw-r--r--tools/perf/util/session.c581
-rw-r--r--tools/perf/util/session.h124
-rw-r--r--tools/perf/util/sigchain.c2
-rw-r--r--tools/perf/util/sigchain.h1
-rw-r--r--tools/perf/util/sort.c153
-rw-r--r--tools/perf/util/sort.h35
-rw-r--r--tools/perf/util/strbuf.c229
-rw-r--r--tools/perf/util/strbuf.h45
-rw-r--r--tools/perf/util/string.c45
-rw-r--r--tools/perf/util/string.h18
-rw-r--r--tools/perf/util/symbol.c633
-rw-r--r--tools/perf/util/symbol.h81
-rw-r--r--tools/perf/util/thread.c251
-rw-r--r--tools/perf/util/thread.h58
-rw-r--r--tools/perf/util/trace-event-info.c35
-rw-r--r--tools/perf/util/trace-event-parse.c118
-rw-r--r--tools/perf/util/trace-event-read.c123
-rw-r--r--tools/perf/util/trace-event.h15
-rw-r--r--tools/perf/util/util.c22
-rw-r--r--tools/perf/util/util.h187
-rw-r--r--tools/perf/util/wrapper.c110
71 files changed, 7365 insertions, 3989 deletions
diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index 54552a00a11..97d76562a1a 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -1,17 +1,17 @@
1#!/bin/sh 1#!/bin/sh
2 2
3GVF=PERF-VERSION-FILE 3if [ $# -eq 1 ] ; then
4DEF_VER=v0.0.2.PERF 4 OUTPUT=$1
5fi
6
7GVF=${OUTPUT}PERF-VERSION-FILE
5 8
6LF=' 9LF='
7' 10'
8 11
9# First see if there is a version file (included in release tarballs), 12# First check if there is a .git to get the version from git describe
10# then try git-describe, then default. 13# otherwise try to get the version from the kernel makefile
11if test -f version 14if test -d ../../.git -o -f ../../.git &&
12then
13 VN=$(cat version) || VN="$DEF_VER"
14elif test -d .git -o -f .git &&
15 VN=$(git describe --abbrev=4 HEAD 2>/dev/null) && 15 VN=$(git describe --abbrev=4 HEAD 2>/dev/null) &&
16 case "$VN" in 16 case "$VN" in
17 *$LF*) (exit 1) ;; 17 *$LF*) (exit 1) ;;
@@ -23,7 +23,12 @@ elif test -d .git -o -f .git &&
23then 23then
24 VN=$(echo "$VN" | sed -e 's/-/./g'); 24 VN=$(echo "$VN" | sed -e 's/-/./g');
25else 25else
26 VN="$DEF_VER" 26 eval `grep '^VERSION\s*=' ../../Makefile|tr -d ' '`
27 eval `grep '^PATCHLEVEL\s*=' ../../Makefile|tr -d ' '`
28 eval `grep '^SUBLEVEL\s*=' ../../Makefile|tr -d ' '`
29 eval `grep '^EXTRAVERSION\s*=' ../../Makefile|tr -d ' '`
30
31 VN="${VERSION}.${PATCHLEVEL}.${SUBLEVEL}${EXTRAVERSION}"
27fi 32fi
28 33
29VN=$(expr "$VN" : v*'\(.*\)') 34VN=$(expr "$VN" : v*'\(.*\)')
diff --git a/tools/perf/util/abspath.c b/tools/perf/util/abspath.c
index a791dd46726..0e76affe9c3 100644
--- a/tools/perf/util/abspath.c
+++ b/tools/perf/util/abspath.c
@@ -1,86 +1,5 @@
1#include "cache.h" 1#include "cache.h"
2 2
3/*
4 * Do not use this for inspecting *tracked* content. When path is a
5 * symlink to a directory, we do not want to say it is a directory when
6 * dealing with tracked content in the working tree.
7 */
8static int is_directory(const char *path)
9{
10 struct stat st;
11 return (!stat(path, &st) && S_ISDIR(st.st_mode));
12}
13
14/* We allow "recursive" symbolic links. Only within reason, though. */
15#define MAXDEPTH 5
16
17const char *make_absolute_path(const char *path)
18{
19 static char bufs[2][PATH_MAX + 1], *buf = bufs[0], *next_buf = bufs[1];
20 char cwd[1024] = "";
21 int buf_index = 1, len;
22
23 int depth = MAXDEPTH;
24 char *last_elem = NULL;
25 struct stat st;
26
27 if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
28 die ("Too long path: %.*s", 60, path);
29
30 while (depth--) {
31 if (!is_directory(buf)) {
32 char *last_slash = strrchr(buf, '/');
33 if (last_slash) {
34 *last_slash = '\0';
35 last_elem = xstrdup(last_slash + 1);
36 } else {
37 last_elem = xstrdup(buf);
38 *buf = '\0';
39 }
40 }
41
42 if (*buf) {
43 if (!*cwd && !getcwd(cwd, sizeof(cwd)))
44 die ("Could not get current working directory");
45
46 if (chdir(buf))
47 die ("Could not switch to '%s'", buf);
48 }
49 if (!getcwd(buf, PATH_MAX))
50 die ("Could not get current working directory");
51
52 if (last_elem) {
53 len = strlen(buf);
54
55 if (len + strlen(last_elem) + 2 > PATH_MAX)
56 die ("Too long path name: '%s/%s'",
57 buf, last_elem);
58 buf[len] = '/';
59 strcpy(buf + len + 1, last_elem);
60 free(last_elem);
61 last_elem = NULL;
62 }
63
64 if (!lstat(buf, &st) && S_ISLNK(st.st_mode)) {
65 len = readlink(buf, next_buf, PATH_MAX);
66 if (len < 0)
67 die ("Invalid symlink: %s", buf);
68 if (PATH_MAX <= len)
69 die("symbolic link too long: %s", buf);
70 next_buf[len] = '\0';
71 buf = next_buf;
72 buf_index = 1 - buf_index;
73 next_buf = bufs[buf_index];
74 } else
75 break;
76 }
77
78 if (*cwd && chdir(cwd))
79 die ("Could not change back to '%s'", cwd);
80
81 return buf;
82}
83
84static const char *get_pwd_cwd(void) 3static const char *get_pwd_cwd(void)
85{ 4{
86 static char cwd[PATH_MAX + 1]; 5 static char cwd[PATH_MAX + 1];
diff --git a/tools/perf/util/bitmap.c b/tools/perf/util/bitmap.c
new file mode 100644
index 00000000000..5e230acae1e
--- /dev/null
+++ b/tools/perf/util/bitmap.c
@@ -0,0 +1,21 @@
1/*
2 * From lib/bitmap.c
3 * Helper functions for bitmap.h.
4 *
5 * This source code is licensed under the GNU General Public License,
6 * Version 2. See the file COPYING for more details.
7 */
8#include <linux/bitmap.h>
9
10int __bitmap_weight(const unsigned long *bitmap, int bits)
11{
12 int k, w = 0, lim = bits/BITS_PER_LONG;
13
14 for (k = 0; k < lim; k++)
15 w += hweight_long(bitmap[k]);
16
17 if (bits % BITS_PER_LONG)
18 w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
19
20 return w;
21}
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 04904b35ba8..70c5cf87d02 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -6,6 +6,8 @@
6 * Copyright (C) 2009, 2010 Red Hat Inc. 6 * Copyright (C) 2009, 2010 Red Hat Inc.
7 * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com> 7 * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
8 */ 8 */
9#include "util.h"
10#include <stdio.h>
9#include "build-id.h" 11#include "build-id.h"
10#include "event.h" 12#include "event.h"
11#include "symbol.h" 13#include "symbol.h"
@@ -24,7 +26,7 @@ static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
24 } 26 }
25 27
26 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION, 28 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
27 event->ip.ip, &al); 29 event->ip.pid, event->ip.ip, &al);
28 30
29 if (al.map != NULL) 31 if (al.map != NULL)
30 al.map->dso->hit = 1; 32 al.map->dso->hit = 1;
@@ -37,3 +39,23 @@ struct perf_event_ops build_id__mark_dso_hit_ops = {
37 .mmap = event__process_mmap, 39 .mmap = event__process_mmap,
38 .fork = event__process_task, 40 .fork = event__process_task,
39}; 41};
42
43char *dso__build_id_filename(struct dso *self, char *bf, size_t size)
44{
45 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
46 const char *home;
47
48 if (!self->has_build_id)
49 return NULL;
50
51 build_id__sprintf(self->build_id, sizeof(self->build_id), build_id_hex);
52 home = getenv("HOME");
53 if (bf == NULL) {
54 if (asprintf(&bf, "%s/%s/.build-id/%.2s/%s", home,
55 DEBUG_CACHE_DIR, build_id_hex, build_id_hex + 2) < 0)
56 return NULL;
57 } else
58 snprintf(bf, size, "%s/%s/.build-id/%.2s/%s", home,
59 DEBUG_CACHE_DIR, build_id_hex, build_id_hex + 2);
60 return bf;
61}
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 1d981d63cf9..5dafb00eaa0 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -5,4 +5,6 @@
5 5
6extern struct perf_event_ops build_id__mark_dso_hit_ops; 6extern struct perf_event_ops build_id__mark_dso_hit_ops;
7 7
8char *dso__build_id_filename(struct dso *self, char *bf, size_t size);
9
8#endif 10#endif
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 918eb376abe..65fe664fddf 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -1,6 +1,7 @@
1#ifndef __PERF_CACHE_H 1#ifndef __PERF_CACHE_H
2#define __PERF_CACHE_H 2#define __PERF_CACHE_H
3 3
4#include <stdbool.h>
4#include "util.h" 5#include "util.h"
5#include "strbuf.h" 6#include "strbuf.h"
6#include "../perf.h" 7#include "../perf.h"
@@ -12,56 +13,16 @@
12 13
13#define PERF_DIR_ENVIRONMENT "PERF_DIR" 14#define PERF_DIR_ENVIRONMENT "PERF_DIR"
14#define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE" 15#define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
15#define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
16#define DB_ENVIRONMENT "PERF_OBJECT_DIRECTORY"
17#define INDEX_ENVIRONMENT "PERF_INDEX_FILE"
18#define GRAFT_ENVIRONMENT "PERF_GRAFT_FILE"
19#define TEMPLATE_DIR_ENVIRONMENT "PERF_TEMPLATE_DIR"
20#define CONFIG_ENVIRONMENT "PERF_CONFIG"
21#define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH" 16#define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
22#define CEILING_DIRECTORIES_ENVIRONMENT "PERF_CEILING_DIRECTORIES" 17#define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
23#define PERFATTRIBUTES_FILE ".perfattributes"
24#define INFOATTRIBUTES_FILE "info/attributes"
25#define ATTRIBUTE_MACRO_PREFIX "[attr]"
26#define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR" 18#define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
27 19
28typedef int (*config_fn_t)(const char *, const char *, void *); 20typedef int (*config_fn_t)(const char *, const char *, void *);
29extern int perf_default_config(const char *, const char *, void *); 21extern int perf_default_config(const char *, const char *, void *);
30extern int perf_config_from_file(config_fn_t fn, const char *, void *);
31extern int perf_config(config_fn_t fn, void *); 22extern int perf_config(config_fn_t fn, void *);
32extern int perf_parse_ulong(const char *, unsigned long *);
33extern int perf_config_int(const char *, const char *); 23extern int perf_config_int(const char *, const char *);
34extern unsigned long perf_config_ulong(const char *, const char *);
35extern int perf_config_bool_or_int(const char *, const char *, int *);
36extern int perf_config_bool(const char *, const char *); 24extern int perf_config_bool(const char *, const char *);
37extern int perf_config_string(const char **, const char *, const char *);
38extern int perf_config_set(const char *, const char *);
39extern int perf_config_set_multivar(const char *, const char *, const char *, int);
40extern int perf_config_rename_section(const char *, const char *);
41extern const char *perf_etc_perfconfig(void);
42extern int check_repository_format_version(const char *var, const char *value, void *cb);
43extern int perf_config_system(void);
44extern int perf_config_global(void);
45extern int config_error_nonbool(const char *); 25extern int config_error_nonbool(const char *);
46extern const char *config_exclusive_filename;
47
48#define MAX_PERFNAME (1000)
49extern char perf_default_email[MAX_PERFNAME];
50extern char perf_default_name[MAX_PERFNAME];
51extern int user_ident_explicitly_given;
52
53extern const char *perf_log_output_encoding;
54extern const char *perf_mailmap_file;
55
56/* IO helper functions */
57extern void maybe_flush_or_die(FILE *, const char *);
58extern int copy_fd(int ifd, int ofd);
59extern int copy_file(const char *dst, const char *src, int mode);
60extern ssize_t write_in_full(int fd, const void *buf, size_t count);
61extern void write_or_die(int fd, const void *buf, size_t count);
62extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg);
63extern int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg);
64extern void fsync_or_die(int fd, const char *);
65 26
66/* pager.c */ 27/* pager.c */
67extern void setup_pager(void); 28extern void setup_pager(void);
@@ -69,8 +30,18 @@ extern const char *pager_program;
69extern int pager_in_use(void); 30extern int pager_in_use(void);
70extern int pager_use_color; 31extern int pager_use_color;
71 32
72extern const char *editor_program; 33extern int use_browser;
73extern const char *excludes_file; 34
35#ifdef NO_NEWT_SUPPORT
36static inline void setup_browser(void)
37{
38 setup_pager();
39}
40static inline void exit_browser(bool wait_for_ok __used) {}
41#else
42void setup_browser(void);
43void exit_browser(bool wait_for_ok);
44#endif
74 45
75char *alias_lookup(const char *alias); 46char *alias_lookup(const char *alias);
76int split_cmdline(char *cmdline, const char ***argv); 47int split_cmdline(char *cmdline, const char ***argv);
@@ -101,22 +72,12 @@ static inline int is_absolute_path(const char *path)
101 return path[0] == '/'; 72 return path[0] == '/';
102} 73}
103 74
104const char *make_absolute_path(const char *path);
105const char *make_nonrelative_path(const char *path); 75const char *make_nonrelative_path(const char *path);
106const char *make_relative_path(const char *abs, const char *base);
107int normalize_path_copy(char *dst, const char *src);
108int longest_ancestor_length(const char *path, const char *prefix_list);
109char *strip_path_suffix(const char *path, const char *suffix); 76char *strip_path_suffix(const char *path, const char *suffix);
110 77
111extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2))); 78extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
112extern char *perf_path(const char *fmt, ...) __attribute__((format (printf, 1, 2))); 79extern char *perf_path(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
113/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
114extern int perf_mkstemp(char *path, size_t len, const char *template);
115 80
116extern char *mksnpath(char *buf, size_t n, const char *fmt, ...)
117 __attribute__((format (printf, 3, 4)));
118extern char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
119 __attribute__((format (printf, 3, 4)));
120extern char *perf_pathdup(const char *fmt, ...) 81extern char *perf_pathdup(const char *fmt, ...)
121 __attribute__((format (printf, 1, 2))); 82 __attribute__((format (printf, 1, 2)));
122 83
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index b3b71258272..52c777e451e 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -1,5 +1,5 @@
1/* 1/*
2 * Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com> 2 * Copyright (C) 2009-2010, Frederic Weisbecker <fweisbec@gmail.com>
3 * 3 *
4 * Handle the callchains from the stream in an ad-hoc radix tree and then 4 * Handle the callchains from the stream in an ad-hoc radix tree and then
5 * sort them in an rbtree. 5 * sort them in an rbtree.
@@ -15,8 +15,16 @@
15#include <errno.h> 15#include <errno.h>
16#include <math.h> 16#include <math.h>
17 17
18#include "util.h"
18#include "callchain.h" 19#include "callchain.h"
19 20
21bool ip_callchain__valid(struct ip_callchain *chain, event_t *event)
22{
23 unsigned int chain_size = event->header.size;
24 chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
25 return chain->nr * sizeof(u64) <= chain_size;
26}
27
20#define chain_for_each_child(child, parent) \ 28#define chain_for_each_child(child, parent) \
21 list_for_each_entry(child, &parent->children, brothers) 29 list_for_each_entry(child, &parent->children, brothers)
22 30
@@ -160,7 +168,7 @@ create_child(struct callchain_node *parent, bool inherit_children)
160{ 168{
161 struct callchain_node *new; 169 struct callchain_node *new;
162 170
163 new = malloc(sizeof(*new)); 171 new = zalloc(sizeof(*new));
164 if (!new) { 172 if (!new) {
165 perror("not enough memory to create child for code path tree"); 173 perror("not enough memory to create child for code path tree");
166 return NULL; 174 return NULL;
@@ -183,25 +191,36 @@ create_child(struct callchain_node *parent, bool inherit_children)
183 return new; 191 return new;
184} 192}
185 193
194
195struct resolved_ip {
196 u64 ip;
197 struct map_symbol ms;
198};
199
200struct resolved_chain {
201 u64 nr;
202 struct resolved_ip ips[0];
203};
204
205
186/* 206/*
187 * Fill the node with callchain values 207 * Fill the node with callchain values
188 */ 208 */
189static void 209static void
190fill_node(struct callchain_node *node, struct ip_callchain *chain, 210fill_node(struct callchain_node *node, struct resolved_chain *chain, int start)
191 int start, struct symbol **syms)
192{ 211{
193 unsigned int i; 212 unsigned int i;
194 213
195 for (i = start; i < chain->nr; i++) { 214 for (i = start; i < chain->nr; i++) {
196 struct callchain_list *call; 215 struct callchain_list *call;
197 216
198 call = malloc(sizeof(*call)); 217 call = zalloc(sizeof(*call));
199 if (!call) { 218 if (!call) {
200 perror("not enough memory for the code path tree"); 219 perror("not enough memory for the code path tree");
201 return; 220 return;
202 } 221 }
203 call->ip = chain->ips[i]; 222 call->ip = chain->ips[i].ip;
204 call->sym = syms[i]; 223 call->ms = chain->ips[i].ms;
205 list_add_tail(&call->list, &node->val); 224 list_add_tail(&call->list, &node->val);
206 } 225 }
207 node->val_nr = chain->nr - start; 226 node->val_nr = chain->nr - start;
@@ -210,16 +229,16 @@ fill_node(struct callchain_node *node, struct ip_callchain *chain,
210} 229}
211 230
212static void 231static void
213add_child(struct callchain_node *parent, struct ip_callchain *chain, 232add_child(struct callchain_node *parent, struct resolved_chain *chain,
214 int start, struct symbol **syms) 233 int start, u64 period)
215{ 234{
216 struct callchain_node *new; 235 struct callchain_node *new;
217 236
218 new = create_child(parent, false); 237 new = create_child(parent, false);
219 fill_node(new, chain, start, syms); 238 fill_node(new, chain, start);
220 239
221 new->children_hit = 0; 240 new->children_hit = 0;
222 new->hit = 1; 241 new->hit = period;
223} 242}
224 243
225/* 244/*
@@ -228,9 +247,9 @@ add_child(struct callchain_node *parent, struct ip_callchain *chain,
228 * Then create another child to host the given callchain of new branch 247 * Then create another child to host the given callchain of new branch
229 */ 248 */
230static void 249static void
231split_add_child(struct callchain_node *parent, struct ip_callchain *chain, 250split_add_child(struct callchain_node *parent, struct resolved_chain *chain,
232 struct callchain_list *to_split, int idx_parents, int idx_local, 251 struct callchain_list *to_split, int idx_parents, int idx_local,
233 struct symbol **syms) 252 u64 period)
234{ 253{
235 struct callchain_node *new; 254 struct callchain_node *new;
236 struct list_head *old_tail; 255 struct list_head *old_tail;
@@ -257,40 +276,41 @@ split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
257 /* create a new child for the new branch if any */ 276 /* create a new child for the new branch if any */
258 if (idx_total < chain->nr) { 277 if (idx_total < chain->nr) {
259 parent->hit = 0; 278 parent->hit = 0;
260 add_child(parent, chain, idx_total, syms); 279 add_child(parent, chain, idx_total, period);
261 parent->children_hit++; 280 parent->children_hit += period;
262 } else { 281 } else {
263 parent->hit = 1; 282 parent->hit = period;
264 } 283 }
265} 284}
266 285
267static int 286static int
268__append_chain(struct callchain_node *root, struct ip_callchain *chain, 287__append_chain(struct callchain_node *root, struct resolved_chain *chain,
269 unsigned int start, struct symbol **syms); 288 unsigned int start, u64 period);
270 289
271static void 290static void
272__append_chain_children(struct callchain_node *root, struct ip_callchain *chain, 291__append_chain_children(struct callchain_node *root,
273 struct symbol **syms, unsigned int start) 292 struct resolved_chain *chain,
293 unsigned int start, u64 period)
274{ 294{
275 struct callchain_node *rnode; 295 struct callchain_node *rnode;
276 296
277 /* lookup in childrens */ 297 /* lookup in childrens */
278 chain_for_each_child(rnode, root) { 298 chain_for_each_child(rnode, root) {
279 unsigned int ret = __append_chain(rnode, chain, start, syms); 299 unsigned int ret = __append_chain(rnode, chain, start, period);
280 300
281 if (!ret) 301 if (!ret)
282 goto inc_children_hit; 302 goto inc_children_hit;
283 } 303 }
284 /* nothing in children, add to the current node */ 304 /* nothing in children, add to the current node */
285 add_child(root, chain, start, syms); 305 add_child(root, chain, start, period);
286 306
287inc_children_hit: 307inc_children_hit:
288 root->children_hit++; 308 root->children_hit += period;
289} 309}
290 310
291static int 311static int
292__append_chain(struct callchain_node *root, struct ip_callchain *chain, 312__append_chain(struct callchain_node *root, struct resolved_chain *chain,
293 unsigned int start, struct symbol **syms) 313 unsigned int start, u64 period)
294{ 314{
295 struct callchain_list *cnode; 315 struct callchain_list *cnode;
296 unsigned int i = start; 316 unsigned int i = start;
@@ -302,13 +322,19 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
302 * anywhere inside a function. 322 * anywhere inside a function.
303 */ 323 */
304 list_for_each_entry(cnode, &root->val, list) { 324 list_for_each_entry(cnode, &root->val, list) {
325 struct symbol *sym;
326
305 if (i == chain->nr) 327 if (i == chain->nr)
306 break; 328 break;
307 if (cnode->sym && syms[i]) { 329
308 if (cnode->sym->start != syms[i]->start) 330 sym = chain->ips[i].ms.sym;
331
332 if (cnode->ms.sym && sym) {
333 if (cnode->ms.sym->start != sym->start)
309 break; 334 break;
310 } else if (cnode->ip != chain->ips[i]) 335 } else if (cnode->ip != chain->ips[i].ip)
311 break; 336 break;
337
312 if (!found) 338 if (!found)
313 found = true; 339 found = true;
314 i++; 340 i++;
@@ -320,26 +346,61 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
320 346
321 /* we match only a part of the node. Split it and add the new chain */ 347 /* we match only a part of the node. Split it and add the new chain */
322 if (i - start < root->val_nr) { 348 if (i - start < root->val_nr) {
323 split_add_child(root, chain, cnode, start, i - start, syms); 349 split_add_child(root, chain, cnode, start, i - start, period);
324 return 0; 350 return 0;
325 } 351 }
326 352
327 /* we match 100% of the path, increment the hit */ 353 /* we match 100% of the path, increment the hit */
328 if (i - start == root->val_nr && i == chain->nr) { 354 if (i - start == root->val_nr && i == chain->nr) {
329 root->hit++; 355 root->hit += period;
330 return 0; 356 return 0;
331 } 357 }
332 358
333 /* We match the node and still have a part remaining */ 359 /* We match the node and still have a part remaining */
334 __append_chain_children(root, chain, syms, i); 360 __append_chain_children(root, chain, i, period);
335 361
336 return 0; 362 return 0;
337} 363}
338 364
339void append_chain(struct callchain_node *root, struct ip_callchain *chain, 365static void filter_context(struct ip_callchain *old, struct resolved_chain *new,
340 struct symbol **syms) 366 struct map_symbol *syms)
341{ 367{
368 int i, j = 0;
369
370 for (i = 0; i < (int)old->nr; i++) {
371 if (old->ips[i] >= PERF_CONTEXT_MAX)
372 continue;
373
374 new->ips[j].ip = old->ips[i];
375 new->ips[j].ms = syms[i];
376 j++;
377 }
378
379 new->nr = j;
380}
381
382
383int append_chain(struct callchain_node *root, struct ip_callchain *chain,
384 struct map_symbol *syms, u64 period)
385{
386 struct resolved_chain *filtered;
387
342 if (!chain->nr) 388 if (!chain->nr)
343 return; 389 return 0;
344 __append_chain_children(root, chain, syms, 0); 390
391 filtered = zalloc(sizeof(*filtered) +
392 chain->nr * sizeof(struct resolved_ip));
393 if (!filtered)
394 return -ENOMEM;
395
396 filter_context(chain, filtered, syms);
397
398 if (!filtered->nr)
399 goto end;
400
401 __append_chain_children(root, filtered, 0, period);
402end:
403 free(filtered);
404
405 return 0;
345} 406}
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index ad4626de4c2..f2e9ee164bd 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -4,7 +4,7 @@
4#include "../perf.h" 4#include "../perf.h"
5#include <linux/list.h> 5#include <linux/list.h>
6#include <linux/rbtree.h> 6#include <linux/rbtree.h>
7#include "util.h" 7#include "event.h"
8#include "symbol.h" 8#include "symbol.h"
9 9
10enum chain_mode { 10enum chain_mode {
@@ -33,13 +33,14 @@ typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_node *,
33 33
34struct callchain_param { 34struct callchain_param {
35 enum chain_mode mode; 35 enum chain_mode mode;
36 u32 print_limit;
36 double min_percent; 37 double min_percent;
37 sort_chain_func_t sort; 38 sort_chain_func_t sort;
38}; 39};
39 40
40struct callchain_list { 41struct callchain_list {
41 u64 ip; 42 u64 ip;
42 struct symbol *sym; 43 struct map_symbol ms;
43 struct list_head list; 44 struct list_head list;
44}; 45};
45 46
@@ -48,6 +49,9 @@ static inline void callchain_init(struct callchain_node *node)
48 INIT_LIST_HEAD(&node->brothers); 49 INIT_LIST_HEAD(&node->brothers);
49 INIT_LIST_HEAD(&node->children); 50 INIT_LIST_HEAD(&node->children);
50 INIT_LIST_HEAD(&node->val); 51 INIT_LIST_HEAD(&node->val);
52
53 node->parent = NULL;
54 node->hit = 0;
51} 55}
52 56
53static inline u64 cumul_hits(struct callchain_node *node) 57static inline u64 cumul_hits(struct callchain_node *node)
@@ -56,6 +60,8 @@ static inline u64 cumul_hits(struct callchain_node *node)
56} 60}
57 61
58int register_callchain_param(struct callchain_param *param); 62int register_callchain_param(struct callchain_param *param);
59void append_chain(struct callchain_node *root, struct ip_callchain *chain, 63int append_chain(struct callchain_node *root, struct ip_callchain *chain,
60 struct symbol **syms); 64 struct map_symbol *syms, u64 period);
65
66bool ip_callchain__valid(struct ip_callchain *chain, event_t *event);
61#endif /* __PERF_CALLCHAIN_H */ 67#endif /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index e88bca55a59..e191eb9a667 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -166,6 +166,31 @@ int perf_color_default_config(const char *var, const char *value, void *cb)
166 return perf_default_config(var, value, cb); 166 return perf_default_config(var, value, cb);
167} 167}
168 168
169static int __color_vsnprintf(char *bf, size_t size, const char *color,
170 const char *fmt, va_list args, const char *trail)
171{
172 int r = 0;
173
174 /*
175 * Auto-detect:
176 */
177 if (perf_use_color_default < 0) {
178 if (isatty(1) || pager_in_use())
179 perf_use_color_default = 1;
180 else
181 perf_use_color_default = 0;
182 }
183
184 if (perf_use_color_default && *color)
185 r += snprintf(bf, size, "%s", color);
186 r += vsnprintf(bf + r, size - r, fmt, args);
187 if (perf_use_color_default && *color)
188 r += snprintf(bf + r, size - r, "%s", PERF_COLOR_RESET);
189 if (trail)
190 r += snprintf(bf + r, size - r, "%s", trail);
191 return r;
192}
193
169static int __color_vfprintf(FILE *fp, const char *color, const char *fmt, 194static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
170 va_list args, const char *trail) 195 va_list args, const char *trail)
171{ 196{
@@ -191,11 +216,28 @@ static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
191 return r; 216 return r;
192} 217}
193 218
219int color_vsnprintf(char *bf, size_t size, const char *color,
220 const char *fmt, va_list args)
221{
222 return __color_vsnprintf(bf, size, color, fmt, args, NULL);
223}
224
194int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args) 225int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args)
195{ 226{
196 return __color_vfprintf(fp, color, fmt, args, NULL); 227 return __color_vfprintf(fp, color, fmt, args, NULL);
197} 228}
198 229
230int color_snprintf(char *bf, size_t size, const char *color,
231 const char *fmt, ...)
232{
233 va_list args;
234 int r;
235
236 va_start(args, fmt);
237 r = color_vsnprintf(bf, size, color, fmt, args);
238 va_end(args);
239 return r;
240}
199 241
200int color_fprintf(FILE *fp, const char *color, const char *fmt, ...) 242int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
201{ 243{
@@ -274,3 +316,9 @@ int percent_color_fprintf(FILE *fp, const char *fmt, double percent)
274 316
275 return r; 317 return r;
276} 318}
319
320int percent_color_snprintf(char *bf, size_t size, const char *fmt, double percent)
321{
322 const char *color = get_percent_color(percent);
323 return color_snprintf(bf, size, color, fmt, percent);
324}
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 24e8809210b..dea082b7960 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -32,10 +32,14 @@ int perf_color_default_config(const char *var, const char *value, void *cb);
32int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty); 32int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
33void color_parse(const char *value, const char *var, char *dst); 33void color_parse(const char *value, const char *var, char *dst);
34void color_parse_mem(const char *value, int len, const char *var, char *dst); 34void color_parse_mem(const char *value, int len, const char *var, char *dst);
35int color_vsnprintf(char *bf, size_t size, const char *color,
36 const char *fmt, va_list args);
35int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args); 37int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args);
36int color_fprintf(FILE *fp, const char *color, const char *fmt, ...); 38int color_fprintf(FILE *fp, const char *color, const char *fmt, ...);
39int color_snprintf(char *bf, size_t size, const char *color, const char *fmt, ...);
37int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...); 40int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...);
38int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf); 41int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
42int percent_color_snprintf(char *bf, size_t size, const char *fmt, double percent);
39int percent_color_fprintf(FILE *fp, const char *fmt, double percent); 43int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
40const char *get_percent_color(double percent); 44const char *get_percent_color(double percent);
41 45
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 8784649109c..dabe892d0e5 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -16,7 +16,7 @@ static const char *config_file_name;
16static int config_linenr; 16static int config_linenr;
17static int config_file_eof; 17static int config_file_eof;
18 18
19const char *config_exclusive_filename = NULL; 19static const char *config_exclusive_filename;
20 20
21static int get_next_char(void) 21static int get_next_char(void)
22{ 22{
@@ -291,19 +291,6 @@ static int perf_parse_long(const char *value, long *ret)
291 return 0; 291 return 0;
292} 292}
293 293
294int perf_parse_ulong(const char *value, unsigned long *ret)
295{
296 if (value && *value) {
297 char *end;
298 unsigned long val = strtoul(value, &end, 0);
299 if (!parse_unit_factor(end, &val))
300 return 0;
301 *ret = val;
302 return 1;
303 }
304 return 0;
305}
306
307static void die_bad_config(const char *name) 294static void die_bad_config(const char *name)
308{ 295{
309 if (config_file_name) 296 if (config_file_name)
@@ -319,15 +306,7 @@ int perf_config_int(const char *name, const char *value)
319 return ret; 306 return ret;
320} 307}
321 308
322unsigned long perf_config_ulong(const char *name, const char *value) 309static int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
323{
324 unsigned long ret;
325 if (!perf_parse_ulong(value, &ret))
326 die_bad_config(name);
327 return ret;
328}
329
330int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
331{ 310{
332 *is_bool = 1; 311 *is_bool = 1;
333 if (!value) 312 if (!value)
@@ -348,14 +327,6 @@ int perf_config_bool(const char *name, const char *value)
348 return !!perf_config_bool_or_int(name, value, &discard); 327 return !!perf_config_bool_or_int(name, value, &discard);
349} 328}
350 329
351int perf_config_string(const char **dest, const char *var, const char *value)
352{
353 if (!value)
354 return config_error_nonbool(var);
355 *dest = strdup(value);
356 return 0;
357}
358
359static int perf_default_core_config(const char *var __used, const char *value __used) 330static int perf_default_core_config(const char *var __used, const char *value __used)
360{ 331{
361 /* Add other config variables here and to Documentation/config.txt. */ 332 /* Add other config variables here and to Documentation/config.txt. */
@@ -371,7 +342,7 @@ int perf_default_config(const char *var, const char *value, void *dummy __used)
371 return 0; 342 return 0;
372} 343}
373 344
374int perf_config_from_file(config_fn_t fn, const char *filename, void *data) 345static int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
375{ 346{
376 int ret; 347 int ret;
377 FILE *f = fopen(filename, "r"); 348 FILE *f = fopen(filename, "r");
@@ -389,7 +360,7 @@ int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
389 return ret; 360 return ret;
390} 361}
391 362
392const char *perf_etc_perfconfig(void) 363static const char *perf_etc_perfconfig(void)
393{ 364{
394 static const char *system_wide; 365 static const char *system_wide;
395 if (!system_wide) 366 if (!system_wide)
@@ -403,12 +374,12 @@ static int perf_env_bool(const char *k, int def)
403 return v ? perf_config_bool(k, v) : def; 374 return v ? perf_config_bool(k, v) : def;
404} 375}
405 376
406int perf_config_system(void) 377static int perf_config_system(void)
407{ 378{
408 return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0); 379 return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);
409} 380}
410 381
411int perf_config_global(void) 382static int perf_config_global(void)
412{ 383{
413 return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0); 384 return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
414} 385}
@@ -450,426 +421,6 @@ int perf_config(config_fn_t fn, void *data)
450} 421}
451 422
452/* 423/*
453 * Find all the stuff for perf_config_set() below.
454 */
455
456#define MAX_MATCHES 512
457
458static struct {
459 int baselen;
460 char* key;
461 int do_not_match;
462 regex_t* value_regex;
463 int multi_replace;
464 size_t offset[MAX_MATCHES];
465 enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
466 int seen;
467} store;
468
469static int matches(const char* key, const char* value)
470{
471 return !strcmp(key, store.key) &&
472 (store.value_regex == NULL ||
473 (store.do_not_match ^
474 !regexec(store.value_regex, value, 0, NULL, 0)));
475}
476
477static int store_aux(const char* key, const char* value, void *cb __used)
478{
479 int section_len;
480 const char *ep;
481
482 switch (store.state) {
483 case KEY_SEEN:
484 if (matches(key, value)) {
485 if (store.seen == 1 && store.multi_replace == 0) {
486 warning("%s has multiple values", key);
487 } else if (store.seen >= MAX_MATCHES) {
488 error("too many matches for %s", key);
489 return 1;
490 }
491
492 store.offset[store.seen] = ftell(config_file);
493 store.seen++;
494 }
495 break;
496 case SECTION_SEEN:
497 /*
498 * What we are looking for is in store.key (both
499 * section and var), and its section part is baselen
500 * long. We found key (again, both section and var).
501 * We would want to know if this key is in the same
502 * section as what we are looking for. We already
503 * know we are in the same section as what should
504 * hold store.key.
505 */
506 ep = strrchr(key, '.');
507 section_len = ep - key;
508
509 if ((section_len != store.baselen) ||
510 memcmp(key, store.key, section_len+1)) {
511 store.state = SECTION_END_SEEN;
512 break;
513 }
514
515 /*
516 * Do not increment matches: this is no match, but we
517 * just made sure we are in the desired section.
518 */
519 store.offset[store.seen] = ftell(config_file);
520 /* fallthru */
521 case SECTION_END_SEEN:
522 case START:
523 if (matches(key, value)) {
524 store.offset[store.seen] = ftell(config_file);
525 store.state = KEY_SEEN;
526 store.seen++;
527 } else {
528 if (strrchr(key, '.') - key == store.baselen &&
529 !strncmp(key, store.key, store.baselen)) {
530 store.state = SECTION_SEEN;
531 store.offset[store.seen] = ftell(config_file);
532 }
533 }
534 default:
535 break;
536 }
537 return 0;
538}
539
540static int store_write_section(int fd, const char* key)
541{
542 const char *dot;
543 int i, success;
544 struct strbuf sb = STRBUF_INIT;
545
546 dot = memchr(key, '.', store.baselen);
547 if (dot) {
548 strbuf_addf(&sb, "[%.*s \"", (int)(dot - key), key);
549 for (i = dot - key + 1; i < store.baselen; i++) {
550 if (key[i] == '"' || key[i] == '\\')
551 strbuf_addch(&sb, '\\');
552 strbuf_addch(&sb, key[i]);
553 }
554 strbuf_addstr(&sb, "\"]\n");
555 } else {
556 strbuf_addf(&sb, "[%.*s]\n", store.baselen, key);
557 }
558
559 success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
560 strbuf_release(&sb);
561
562 return success;
563}
564
565static int store_write_pair(int fd, const char* key, const char* value)
566{
567 int i, success;
568 int length = strlen(key + store.baselen + 1);
569 const char *quote = "";
570 struct strbuf sb = STRBUF_INIT;
571
572 /*
573 * Check to see if the value needs to be surrounded with a dq pair.
574 * Note that problematic characters are always backslash-quoted; this
575 * check is about not losing leading or trailing SP and strings that
576 * follow beginning-of-comment characters (i.e. ';' and '#') by the
577 * configuration parser.
578 */
579 if (value[0] == ' ')
580 quote = "\"";
581 for (i = 0; value[i]; i++)
582 if (value[i] == ';' || value[i] == '#')
583 quote = "\"";
584 if (i && value[i - 1] == ' ')
585 quote = "\"";
586
587 strbuf_addf(&sb, "\t%.*s = %s",
588 length, key + store.baselen + 1, quote);
589
590 for (i = 0; value[i]; i++)
591 switch (value[i]) {
592 case '\n':
593 strbuf_addstr(&sb, "\\n");
594 break;
595 case '\t':
596 strbuf_addstr(&sb, "\\t");
597 break;
598 case '"':
599 case '\\':
600 strbuf_addch(&sb, '\\');
601 default:
602 strbuf_addch(&sb, value[i]);
603 break;
604 }
605 strbuf_addf(&sb, "%s\n", quote);
606
607 success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
608 strbuf_release(&sb);
609
610 return success;
611}
612
613static ssize_t find_beginning_of_line(const char* contents, size_t size,
614 size_t offset_, int* found_bracket)
615{
616 size_t equal_offset = size, bracket_offset = size;
617 ssize_t offset;
618
619contline:
620 for (offset = offset_-2; offset > 0
621 && contents[offset] != '\n'; offset--)
622 switch (contents[offset]) {
623 case '=': equal_offset = offset; break;
624 case ']': bracket_offset = offset; break;
625 default: break;
626 }
627 if (offset > 0 && contents[offset-1] == '\\') {
628 offset_ = offset;
629 goto contline;
630 }
631 if (bracket_offset < equal_offset) {
632 *found_bracket = 1;
633 offset = bracket_offset+1;
634 } else
635 offset++;
636
637 return offset;
638}
639
640int perf_config_set(const char* key, const char* value)
641{
642 return perf_config_set_multivar(key, value, NULL, 0);
643}
644
645/*
646 * If value==NULL, unset in (remove from) config,
647 * if value_regex!=NULL, disregard key/value pairs where value does not match.
648 * if multi_replace==0, nothing, or only one matching key/value is replaced,
649 * else all matching key/values (regardless how many) are removed,
650 * before the new pair is written.
651 *
652 * Returns 0 on success.
653 *
654 * This function does this:
655 *
656 * - it locks the config file by creating ".perf/config.lock"
657 *
658 * - it then parses the config using store_aux() as validator to find
659 * the position on the key/value pair to replace. If it is to be unset,
660 * it must be found exactly once.
661 *
662 * - the config file is mmap()ed and the part before the match (if any) is
663 * written to the lock file, then the changed part and the rest.
664 *
665 * - the config file is removed and the lock file rename()d to it.
666 *
667 */
668int perf_config_set_multivar(const char* key, const char* value,
669 const char* value_regex, int multi_replace)
670{
671 int i, dot;
672 int fd = -1, in_fd;
673 int ret = 0;
674 char* config_filename;
675 const char* last_dot = strrchr(key, '.');
676
677 if (config_exclusive_filename)
678 config_filename = strdup(config_exclusive_filename);
679 else
680 config_filename = perf_pathdup("config");
681
682 /*
683 * Since "key" actually contains the section name and the real
684 * key name separated by a dot, we have to know where the dot is.
685 */
686
687 if (last_dot == NULL) {
688 error("key does not contain a section: %s", key);
689 ret = 2;
690 goto out_free;
691 }
692 store.baselen = last_dot - key;
693
694 store.multi_replace = multi_replace;
695
696 /*
697 * Validate the key and while at it, lower case it for matching.
698 */
699 store.key = malloc(strlen(key) + 1);
700 dot = 0;
701 for (i = 0; key[i]; i++) {
702 unsigned char c = key[i];
703 if (c == '.')
704 dot = 1;
705 /* Leave the extended basename untouched.. */
706 if (!dot || i > store.baselen) {
707 if (!iskeychar(c) || (i == store.baselen+1 && !isalpha(c))) {
708 error("invalid key: %s", key);
709 free(store.key);
710 ret = 1;
711 goto out_free;
712 }
713 c = tolower(c);
714 } else if (c == '\n') {
715 error("invalid key (newline): %s", key);
716 free(store.key);
717 ret = 1;
718 goto out_free;
719 }
720 store.key[i] = c;
721 }
722 store.key[i] = 0;
723
724 /*
725 * If .perf/config does not exist yet, write a minimal version.
726 */
727 in_fd = open(config_filename, O_RDONLY);
728 if ( in_fd < 0 ) {
729 free(store.key);
730
731 if ( ENOENT != errno ) {
732 error("opening %s: %s", config_filename,
733 strerror(errno));
734 ret = 3; /* same as "invalid config file" */
735 goto out_free;
736 }
737 /* if nothing to unset, error out */
738 if (value == NULL) {
739 ret = 5;
740 goto out_free;
741 }
742
743 store.key = (char*)key;
744 if (!store_write_section(fd, key) ||
745 !store_write_pair(fd, key, value))
746 goto write_err_out;
747 } else {
748 struct stat st;
749 char *contents;
750 ssize_t contents_sz, copy_begin, copy_end;
751 int new_line = 0;
752
753 if (value_regex == NULL)
754 store.value_regex = NULL;
755 else {
756 if (value_regex[0] == '!') {
757 store.do_not_match = 1;
758 value_regex++;
759 } else
760 store.do_not_match = 0;
761
762 store.value_regex = (regex_t*)malloc(sizeof(regex_t));
763 if (regcomp(store.value_regex, value_regex,
764 REG_EXTENDED)) {
765 error("invalid pattern: %s", value_regex);
766 free(store.value_regex);
767 ret = 6;
768 goto out_free;
769 }
770 }
771
772 store.offset[0] = 0;
773 store.state = START;
774 store.seen = 0;
775
776 /*
777 * After this, store.offset will contain the *end* offset
778 * of the last match, or remain at 0 if no match was found.
779 * As a side effect, we make sure to transform only a valid
780 * existing config file.
781 */
782 if (perf_config_from_file(store_aux, config_filename, NULL)) {
783 error("invalid config file %s", config_filename);
784 free(store.key);
785 if (store.value_regex != NULL) {
786 regfree(store.value_regex);
787 free(store.value_regex);
788 }
789 ret = 3;
790 goto out_free;
791 }
792
793 free(store.key);
794 if (store.value_regex != NULL) {
795 regfree(store.value_regex);
796 free(store.value_regex);
797 }
798
799 /* if nothing to unset, or too many matches, error out */
800 if ((store.seen == 0 && value == NULL) ||
801 (store.seen > 1 && multi_replace == 0)) {
802 ret = 5;
803 goto out_free;
804 }
805
806 fstat(in_fd, &st);
807 contents_sz = xsize_t(st.st_size);
808 contents = mmap(NULL, contents_sz, PROT_READ,
809 MAP_PRIVATE, in_fd, 0);
810 close(in_fd);
811
812 if (store.seen == 0)
813 store.seen = 1;
814
815 for (i = 0, copy_begin = 0; i < store.seen; i++) {
816 if (store.offset[i] == 0) {
817 store.offset[i] = copy_end = contents_sz;
818 } else if (store.state != KEY_SEEN) {
819 copy_end = store.offset[i];
820 } else
821 copy_end = find_beginning_of_line(
822 contents, contents_sz,
823 store.offset[i]-2, &new_line);
824
825 if (copy_end > 0 && contents[copy_end-1] != '\n')
826 new_line = 1;
827
828 /* write the first part of the config */
829 if (copy_end > copy_begin) {
830 if (write_in_full(fd, contents + copy_begin,
831 copy_end - copy_begin) <
832 copy_end - copy_begin)
833 goto write_err_out;
834 if (new_line &&
835 write_in_full(fd, "\n", 1) != 1)
836 goto write_err_out;
837 }
838 copy_begin = store.offset[i];
839 }
840
841 /* write the pair (value == NULL means unset) */
842 if (value != NULL) {
843 if (store.state == START) {
844 if (!store_write_section(fd, key))
845 goto write_err_out;
846 }
847 if (!store_write_pair(fd, key, value))
848 goto write_err_out;
849 }
850
851 /* write the rest of the config */
852 if (copy_begin < contents_sz)
853 if (write_in_full(fd, contents + copy_begin,
854 contents_sz - copy_begin) <
855 contents_sz - copy_begin)
856 goto write_err_out;
857
858 munmap(contents, contents_sz);
859 }
860
861 ret = 0;
862
863out_free:
864 free(config_filename);
865 return ret;
866
867write_err_out:
868 goto out_free;
869
870}
871
872/*
873 * Call this to report error for your variable that should not 424 * Call this to report error for your variable that should not
874 * get a boolean value (i.e. "[my] var" means "true"). 425 * get a boolean value (i.e. "[my] var" means "true").
875 */ 426 */
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 0905600c385..6cddff2bc97 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -6,13 +6,14 @@
6#include <stdarg.h> 6#include <stdarg.h>
7#include <stdio.h> 7#include <stdio.h>
8 8
9#include "cache.h"
9#include "color.h" 10#include "color.h"
10#include "event.h" 11#include "event.h"
11#include "debug.h" 12#include "debug.h"
12#include "util.h" 13#include "util.h"
13 14
14int verbose = 0; 15int verbose = 0;
15int dump_trace = 0; 16bool dump_trace = false;
16 17
17int eprintf(int level, const char *fmt, ...) 18int eprintf(int level, const char *fmt, ...)
18{ 19{
@@ -21,7 +22,10 @@ int eprintf(int level, const char *fmt, ...)
21 22
22 if (verbose >= level) { 23 if (verbose >= level) {
23 va_start(args, fmt); 24 va_start(args, fmt);
24 ret = vfprintf(stderr, fmt, args); 25 if (use_browser > 0)
26 ret = browser__show_help(fmt, args);
27 else
28 ret = vfprintf(stderr, fmt, args);
25 va_end(args); 29 va_end(args);
26 } 30 }
27 31
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index c6c24c522de..047ac3324eb 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -2,14 +2,38 @@
2#ifndef __PERF_DEBUG_H 2#ifndef __PERF_DEBUG_H
3#define __PERF_DEBUG_H 3#define __PERF_DEBUG_H
4 4
5#include <stdbool.h>
5#include "event.h" 6#include "event.h"
6 7
7extern int verbose; 8extern int verbose;
8extern int dump_trace; 9extern bool dump_trace;
9 10
10int eprintf(int level,
11 const char *fmt, ...) __attribute__((format(printf, 2, 3)));
12int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); 11int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
13void trace_event(event_t *event); 12void trace_event(event_t *event);
14 13
14struct ui_progress;
15
16#ifdef NO_NEWT_SUPPORT
17static inline int browser__show_help(const char *format __used, va_list ap __used)
18{
19 return 0;
20}
21
22static inline struct ui_progress *ui_progress__new(const char *title __used,
23 u64 total __used)
24{
25 return (struct ui_progress *)1;
26}
27
28static inline void ui_progress__update(struct ui_progress *self __used,
29 u64 curr __used) {}
30
31static inline void ui_progress__delete(struct ui_progress *self __used) {}
32#else
33int browser__show_help(const char *format, va_list ap);
34struct ui_progress *ui_progress__new(const char *title, u64 total);
35void ui_progress__update(struct ui_progress *self, u64 curr);
36void ui_progress__delete(struct ui_progress *self);
37#endif
38
15#endif /* __PERF_DEBUG_H */ 39#endif /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 705ec63548b..2fbf6a463c8 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -7,6 +7,23 @@
7#include "strlist.h" 7#include "strlist.h"
8#include "thread.h" 8#include "thread.h"
9 9
10const char *event__name[] = {
11 [0] = "TOTAL",
12 [PERF_RECORD_MMAP] = "MMAP",
13 [PERF_RECORD_LOST] = "LOST",
14 [PERF_RECORD_COMM] = "COMM",
15 [PERF_RECORD_EXIT] = "EXIT",
16 [PERF_RECORD_THROTTLE] = "THROTTLE",
17 [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
18 [PERF_RECORD_FORK] = "FORK",
19 [PERF_RECORD_READ] = "READ",
20 [PERF_RECORD_SAMPLE] = "SAMPLE",
21 [PERF_RECORD_HEADER_ATTR] = "ATTR",
22 [PERF_RECORD_HEADER_EVENT_TYPE] = "EVENT_TYPE",
23 [PERF_RECORD_HEADER_TRACING_DATA] = "TRACING_DATA",
24 [PERF_RECORD_HEADER_BUILD_ID] = "BUILD_ID",
25};
26
10static pid_t event__synthesize_comm(pid_t pid, int full, 27static pid_t event__synthesize_comm(pid_t pid, int full,
11 event__handler_t process, 28 event__handler_t process,
12 struct perf_session *session) 29 struct perf_session *session)
@@ -112,7 +129,11 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
112 event_t ev = { 129 event_t ev = {
113 .header = { 130 .header = {
114 .type = PERF_RECORD_MMAP, 131 .type = PERF_RECORD_MMAP,
115 .misc = 0, /* Just like the kernel, see kernel/perf_event.c __perf_event_mmap */ 132 /*
133 * Just like the kernel, see __perf_event_mmap
134 * in kernel/perf_event.c
135 */
136 .misc = PERF_RECORD_MISC_USER,
116 }, 137 },
117 }; 138 };
118 int n; 139 int n;
@@ -130,6 +151,7 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
130 continue; 151 continue;
131 pbf += n + 3; 152 pbf += n + 3;
132 if (*pbf == 'x') { /* vm_exec */ 153 if (*pbf == 'x') { /* vm_exec */
154 u64 vm_pgoff;
133 char *execname = strchr(bf, '/'); 155 char *execname = strchr(bf, '/');
134 156
135 /* Catch VDSO */ 157 /* Catch VDSO */
@@ -139,6 +161,14 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
139 if (execname == NULL) 161 if (execname == NULL)
140 continue; 162 continue;
141 163
164 pbf += 3;
165 n = hex2u64(pbf, &vm_pgoff);
166 /* pgoff is in bytes, not pages */
167 if (n >= 0)
168 ev.mmap.pgoff = vm_pgoff << getpagesize();
169 else
170 ev.mmap.pgoff = 0;
171
142 size = strlen(execname); 172 size = strlen(execname);
143 execname[size - 1] = '\0'; /* Remove \n */ 173 execname[size - 1] = '\0'; /* Remove \n */
144 memcpy(ev.mmap.filename, execname, size); 174 memcpy(ev.mmap.filename, execname, size);
@@ -158,11 +188,23 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
158} 188}
159 189
160int event__synthesize_modules(event__handler_t process, 190int event__synthesize_modules(event__handler_t process,
161 struct perf_session *session) 191 struct perf_session *session,
192 struct machine *machine)
162{ 193{
163 struct rb_node *nd; 194 struct rb_node *nd;
195 struct map_groups *kmaps = &machine->kmaps;
196 u16 misc;
197
198 /*
199 * kernel uses 0 for user space maps, see kernel/perf_event.c
200 * __perf_event_mmap
201 */
202 if (machine__is_host(machine))
203 misc = PERF_RECORD_MISC_KERNEL;
204 else
205 misc = PERF_RECORD_MISC_GUEST_KERNEL;
164 206
165 for (nd = rb_first(&session->kmaps.maps[MAP__FUNCTION]); 207 for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]);
166 nd; nd = rb_next(nd)) { 208 nd; nd = rb_next(nd)) {
167 event_t ev; 209 event_t ev;
168 size_t size; 210 size_t size;
@@ -173,12 +215,13 @@ int event__synthesize_modules(event__handler_t process,
173 215
174 size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64)); 216 size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
175 memset(&ev, 0, sizeof(ev)); 217 memset(&ev, 0, sizeof(ev));
176 ev.mmap.header.misc = 1; /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */ 218 ev.mmap.header.misc = misc;
177 ev.mmap.header.type = PERF_RECORD_MMAP; 219 ev.mmap.header.type = PERF_RECORD_MMAP;
178 ev.mmap.header.size = (sizeof(ev.mmap) - 220 ev.mmap.header.size = (sizeof(ev.mmap) -
179 (sizeof(ev.mmap.filename) - size)); 221 (sizeof(ev.mmap.filename) - size));
180 ev.mmap.start = pos->start; 222 ev.mmap.start = pos->start;
181 ev.mmap.len = pos->end - pos->start; 223 ev.mmap.len = pos->end - pos->start;
224 ev.mmap.pid = machine->pid;
182 225
183 memcpy(ev.mmap.filename, pos->dso->long_name, 226 memcpy(ev.mmap.filename, pos->dso->long_name,
184 pos->dso->long_name_len + 1); 227 pos->dso->long_name_len + 1);
@@ -241,13 +284,18 @@ static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
241 284
242int event__synthesize_kernel_mmap(event__handler_t process, 285int event__synthesize_kernel_mmap(event__handler_t process,
243 struct perf_session *session, 286 struct perf_session *session,
287 struct machine *machine,
244 const char *symbol_name) 288 const char *symbol_name)
245{ 289{
246 size_t size; 290 size_t size;
291 const char *filename, *mmap_name;
292 char path[PATH_MAX];
293 char name_buff[PATH_MAX];
294 struct map *map;
295
247 event_t ev = { 296 event_t ev = {
248 .header = { 297 .header = {
249 .type = PERF_RECORD_MMAP, 298 .type = PERF_RECORD_MMAP,
250 .misc = 1, /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
251 }, 299 },
252 }; 300 };
253 /* 301 /*
@@ -257,16 +305,37 @@ int event__synthesize_kernel_mmap(event__handler_t process,
257 */ 305 */
258 struct process_symbol_args args = { .name = symbol_name, }; 306 struct process_symbol_args args = { .name = symbol_name, };
259 307
260 if (kallsyms__parse("/proc/kallsyms", &args, find_symbol_cb) <= 0) 308 mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff));
309 if (machine__is_host(machine)) {
310 /*
311 * kernel uses PERF_RECORD_MISC_USER for user space maps,
312 * see kernel/perf_event.c __perf_event_mmap
313 */
314 ev.header.misc = PERF_RECORD_MISC_KERNEL;
315 filename = "/proc/kallsyms";
316 } else {
317 ev.header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
318 if (machine__is_default_guest(machine))
319 filename = (char *) symbol_conf.default_guest_kallsyms;
320 else {
321 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
322 filename = path;
323 }
324 }
325
326 if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
261 return -ENOENT; 327 return -ENOENT;
262 328
329 map = machine->vmlinux_maps[MAP__FUNCTION];
263 size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename), 330 size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
264 "[kernel.kallsyms.%s]", symbol_name) + 1; 331 "%s%s", mmap_name, symbol_name) + 1;
265 size = ALIGN(size, sizeof(u64)); 332 size = ALIGN(size, sizeof(u64));
266 ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size)); 333 ev.mmap.header.size = (sizeof(ev.mmap) -
334 (sizeof(ev.mmap.filename) - size));
267 ev.mmap.pgoff = args.start; 335 ev.mmap.pgoff = args.start;
268 ev.mmap.start = session->vmlinux_maps[MAP__FUNCTION]->start; 336 ev.mmap.start = map->start;
269 ev.mmap.len = session->vmlinux_maps[MAP__FUNCTION]->end - ev.mmap.start ; 337 ev.mmap.len = map->end - ev.mmap.start;
338 ev.mmap.pid = machine->pid;
270 339
271 return process(&ev, session); 340 return process(&ev, session);
272} 341}
@@ -301,9 +370,9 @@ static int thread__set_comm_adjust(struct thread *self, const char *comm)
301 370
302int event__process_comm(event_t *self, struct perf_session *session) 371int event__process_comm(event_t *self, struct perf_session *session)
303{ 372{
304 struct thread *thread = perf_session__findnew(session, self->comm.pid); 373 struct thread *thread = perf_session__findnew(session, self->comm.tid);
305 374
306 dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid); 375 dump_printf(": %s:%d\n", self->comm.comm, self->comm.tid);
307 376
308 if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) { 377 if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) {
309 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); 378 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
@@ -316,26 +385,54 @@ int event__process_comm(event_t *self, struct perf_session *session)
316int event__process_lost(event_t *self, struct perf_session *session) 385int event__process_lost(event_t *self, struct perf_session *session)
317{ 386{
318 dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost); 387 dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
319 session->events_stats.lost += self->lost.lost; 388 session->hists.stats.total_lost += self->lost.lost;
320 return 0; 389 return 0;
321} 390}
322 391
323int event__process_mmap(event_t *self, struct perf_session *session) 392static void event_set_kernel_mmap_len(struct map **maps, event_t *self)
393{
394 maps[MAP__FUNCTION]->start = self->mmap.start;
395 maps[MAP__FUNCTION]->end = self->mmap.start + self->mmap.len;
396 /*
397 * Be a bit paranoid here, some perf.data file came with
398 * a zero sized synthesized MMAP event for the kernel.
399 */
400 if (maps[MAP__FUNCTION]->end == 0)
401 maps[MAP__FUNCTION]->end = ~0UL;
402}
403
404static int event__process_kernel_mmap(event_t *self,
405 struct perf_session *session)
324{ 406{
325 struct thread *thread;
326 struct map *map; 407 struct map *map;
408 char kmmap_prefix[PATH_MAX];
409 struct machine *machine;
410 enum dso_kernel_type kernel_type;
411 bool is_kernel_mmap;
412
413 machine = perf_session__findnew_machine(session, self->mmap.pid);
414 if (!machine) {
415 pr_err("Can't find id %d's machine\n", self->mmap.pid);
416 goto out_problem;
417 }
327 418
328 dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n", 419 machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
329 self->mmap.pid, self->mmap.tid, self->mmap.start, 420 if (machine__is_host(machine))
330 self->mmap.len, self->mmap.pgoff, self->mmap.filename); 421 kernel_type = DSO_TYPE_KERNEL;
422 else
423 kernel_type = DSO_TYPE_GUEST_KERNEL;
331 424
332 if (self->mmap.pid == 0) { 425 is_kernel_mmap = memcmp(self->mmap.filename,
333 static const char kmmap_prefix[] = "[kernel.kallsyms."; 426 kmmap_prefix,
427 strlen(kmmap_prefix)) == 0;
428 if (self->mmap.filename[0] == '/' ||
429 (!is_kernel_mmap && self->mmap.filename[0] == '[')) {
334 430
335 if (self->mmap.filename[0] == '/') { 431 char short_module_name[1024];
336 char short_module_name[1024]; 432 char *name, *dot;
337 char *name = strrchr(self->mmap.filename, '/'), *dot;
338 433
434 if (self->mmap.filename[0] == '/') {
435 name = strrchr(self->mmap.filename, '/');
339 if (name == NULL) 436 if (name == NULL)
340 goto out_problem; 437 goto out_problem;
341 438
@@ -343,58 +440,84 @@ int event__process_mmap(event_t *self, struct perf_session *session)
343 dot = strrchr(name, '.'); 440 dot = strrchr(name, '.');
344 if (dot == NULL) 441 if (dot == NULL)
345 goto out_problem; 442 goto out_problem;
346
347 snprintf(short_module_name, sizeof(short_module_name), 443 snprintf(short_module_name, sizeof(short_module_name),
348 "[%.*s]", (int)(dot - name), name); 444 "[%.*s]", (int)(dot - name), name);
349 strxfrchar(short_module_name, '-', '_'); 445 strxfrchar(short_module_name, '-', '_');
350 446 } else
351 map = perf_session__new_module_map(session, 447 strcpy(short_module_name, self->mmap.filename);
352 self->mmap.start, 448
353 self->mmap.filename); 449 map = machine__new_module(machine, self->mmap.start,
354 if (map == NULL) 450 self->mmap.filename);
355 goto out_problem; 451 if (map == NULL)
356 452 goto out_problem;
357 name = strdup(short_module_name); 453
358 if (name == NULL) 454 name = strdup(short_module_name);
359 goto out_problem; 455 if (name == NULL)
360 456 goto out_problem;
361 map->dso->short_name = name; 457
362 map->end = map->start + self->mmap.len; 458 map->dso->short_name = name;
363 } else if (memcmp(self->mmap.filename, kmmap_prefix, 459 map->end = map->start + self->mmap.len;
364 sizeof(kmmap_prefix) - 1) == 0) { 460 } else if (is_kernel_mmap) {
365 const char *symbol_name = (self->mmap.filename + 461 const char *symbol_name = (self->mmap.filename +
366 sizeof(kmmap_prefix) - 1); 462 strlen(kmmap_prefix));
463 /*
464 * Should be there already, from the build-id table in
465 * the header.
466 */
467 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
468 kmmap_prefix);
469 if (kernel == NULL)
470 goto out_problem;
471
472 kernel->kernel = kernel_type;
473 if (__machine__create_kernel_maps(machine, kernel) < 0)
474 goto out_problem;
475
476 event_set_kernel_mmap_len(machine->vmlinux_maps, self);
477 perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
478 symbol_name,
479 self->mmap.pgoff);
480 if (machine__is_default_guest(machine)) {
367 /* 481 /*
368 * Should be there already, from the build-id table in 482 * preload dso of guest kernel and modules
369 * the header.
370 */ 483 */
371 struct dso *kernel = __dsos__findnew(&dsos__kernel, 484 dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
372 "[kernel.kallsyms]"); 485 NULL);
373 if (kernel == NULL) 486 }
374 goto out_problem; 487 }
375 488 return 0;
376 kernel->kernel = 1; 489out_problem:
377 if (__perf_session__create_kernel_maps(session, kernel) < 0) 490 return -1;
378 goto out_problem; 491}
379 492
380 session->vmlinux_maps[MAP__FUNCTION]->start = self->mmap.start; 493int event__process_mmap(event_t *self, struct perf_session *session)
381 session->vmlinux_maps[MAP__FUNCTION]->end = self->mmap.start + self->mmap.len; 494{
382 /* 495 struct machine *machine;
383 * Be a bit paranoid here, some perf.data file came with 496 struct thread *thread;
384 * a zero sized synthesized MMAP event for the kernel. 497 struct map *map;
385 */ 498 u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
386 if (session->vmlinux_maps[MAP__FUNCTION]->end == 0) 499 int ret = 0;
387 session->vmlinux_maps[MAP__FUNCTION]->end = ~0UL;
388 500
389 perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name, 501 dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n",
390 self->mmap.pgoff); 502 self->mmap.pid, self->mmap.tid, self->mmap.start,
391 } 503 self->mmap.len, self->mmap.pgoff, self->mmap.filename);
504
505 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
506 cpumode == PERF_RECORD_MISC_KERNEL) {
507 ret = event__process_kernel_mmap(self, session);
508 if (ret < 0)
509 goto out_problem;
392 return 0; 510 return 0;
393 } 511 }
394 512
513 machine = perf_session__find_host_machine(session);
514 if (machine == NULL)
515 goto out_problem;
395 thread = perf_session__findnew(session, self->mmap.pid); 516 thread = perf_session__findnew(session, self->mmap.pid);
396 map = map__new(&self->mmap, MAP__FUNCTION, 517 map = map__new(&machine->user_dsos, self->mmap.start,
397 session->cwd, session->cwdlen); 518 self->mmap.len, self->mmap.pgoff,
519 self->mmap.pid, self->mmap.filename,
520 MAP__FUNCTION, session->cwd, session->cwdlen);
398 521
399 if (thread == NULL || map == NULL) 522 if (thread == NULL || map == NULL)
400 goto out_problem; 523 goto out_problem;
@@ -409,19 +532,16 @@ out_problem:
409 532
410int event__process_task(event_t *self, struct perf_session *session) 533int event__process_task(event_t *self, struct perf_session *session)
411{ 534{
412 struct thread *thread = perf_session__findnew(session, self->fork.pid); 535 struct thread *thread = perf_session__findnew(session, self->fork.tid);
413 struct thread *parent = perf_session__findnew(session, self->fork.ppid); 536 struct thread *parent = perf_session__findnew(session, self->fork.ptid);
414 537
415 dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid, 538 dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
416 self->fork.ppid, self->fork.ptid); 539 self->fork.ppid, self->fork.ptid);
417 /*
418 * A thread clone will have the same PID for both parent and child.
419 */
420 if (thread == parent)
421 return 0;
422 540
423 if (self->header.type == PERF_RECORD_EXIT) 541 if (self->header.type == PERF_RECORD_EXIT) {
542 perf_session__remove_thread(session, thread);
424 return 0; 543 return 0;
544 }
425 545
426 if (thread == NULL || parent == NULL || 546 if (thread == NULL || parent == NULL ||
427 thread__fork(thread, parent) < 0) { 547 thread__fork(thread, parent) < 0) {
@@ -434,22 +554,56 @@ int event__process_task(event_t *self, struct perf_session *session)
434 554
435void thread__find_addr_map(struct thread *self, 555void thread__find_addr_map(struct thread *self,
436 struct perf_session *session, u8 cpumode, 556 struct perf_session *session, u8 cpumode,
437 enum map_type type, u64 addr, 557 enum map_type type, pid_t pid, u64 addr,
438 struct addr_location *al) 558 struct addr_location *al)
439{ 559{
440 struct map_groups *mg = &self->mg; 560 struct map_groups *mg = &self->mg;
561 struct machine *machine = NULL;
441 562
442 al->thread = self; 563 al->thread = self;
443 al->addr = addr; 564 al->addr = addr;
565 al->cpumode = cpumode;
566 al->filtered = false;
444 567
445 if (cpumode == PERF_RECORD_MISC_KERNEL) { 568 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
446 al->level = 'k'; 569 al->level = 'k';
447 mg = &session->kmaps; 570 machine = perf_session__find_host_machine(session);
448 } else if (cpumode == PERF_RECORD_MISC_USER) 571 if (machine == NULL) {
572 al->map = NULL;
573 return;
574 }
575 mg = &machine->kmaps;
576 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
449 al->level = '.'; 577 al->level = '.';
450 else { 578 machine = perf_session__find_host_machine(session);
451 al->level = 'H'; 579 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
580 al->level = 'g';
581 machine = perf_session__find_machine(session, pid);
582 if (machine == NULL) {
583 al->map = NULL;
584 return;
585 }
586 mg = &machine->kmaps;
587 } else {
588 /*
589 * 'u' means guest os user space.
590 * TODO: We don't support guest user space. Might support late.
591 */
592 if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest)
593 al->level = 'u';
594 else
595 al->level = 'H';
452 al->map = NULL; 596 al->map = NULL;
597
598 if ((cpumode == PERF_RECORD_MISC_GUEST_USER ||
599 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) &&
600 !perf_guest)
601 al->filtered = true;
602 if ((cpumode == PERF_RECORD_MISC_USER ||
603 cpumode == PERF_RECORD_MISC_KERNEL) &&
604 !perf_host)
605 al->filtered = true;
606
453 return; 607 return;
454 } 608 }
455try_again: 609try_again:
@@ -464,8 +618,10 @@ try_again:
464 * "[vdso]" dso, but for now lets use the old trick of looking 618 * "[vdso]" dso, but for now lets use the old trick of looking
465 * in the whole kernel symbol list. 619 * in the whole kernel symbol list.
466 */ 620 */
467 if ((long long)al->addr < 0 && mg != &session->kmaps) { 621 if ((long long)al->addr < 0 &&
468 mg = &session->kmaps; 622 cpumode == PERF_RECORD_MISC_KERNEL &&
623 machine && mg != &machine->kmaps) {
624 mg = &machine->kmaps;
469 goto try_again; 625 goto try_again;
470 } 626 }
471 } else 627 } else
@@ -474,11 +630,11 @@ try_again:
474 630
475void thread__find_addr_location(struct thread *self, 631void thread__find_addr_location(struct thread *self,
476 struct perf_session *session, u8 cpumode, 632 struct perf_session *session, u8 cpumode,
477 enum map_type type, u64 addr, 633 enum map_type type, pid_t pid, u64 addr,
478 struct addr_location *al, 634 struct addr_location *al,
479 symbol_filter_t filter) 635 symbol_filter_t filter)
480{ 636{
481 thread__find_addr_map(self, session, cpumode, type, addr, al); 637 thread__find_addr_map(self, session, cpumode, type, pid, addr, al);
482 if (al->map != NULL) 638 if (al->map != NULL)
483 al->sym = map__find_symbol(al->map, al->addr, filter); 639 al->sym = map__find_symbol(al->map, al->addr, filter);
484 else 640 else
@@ -490,8 +646,10 @@ static void dso__calc_col_width(struct dso *self)
490 if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep && 646 if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
491 (!symbol_conf.dso_list || 647 (!symbol_conf.dso_list ||
492 strlist__has_entry(symbol_conf.dso_list, self->name))) { 648 strlist__has_entry(symbol_conf.dso_list, self->name))) {
493 unsigned int slen = strlen(self->name); 649 u16 slen = self->short_name_len;
494 if (slen > dsos__col_width) 650 if (verbose)
651 slen = self->long_name_len;
652 if (dsos__col_width < slen)
495 dsos__col_width = slen; 653 dsos__col_width = slen;
496 } 654 }
497 655
@@ -512,31 +670,55 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
512 goto out_filtered; 670 goto out_filtered;
513 671
514 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid); 672 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
673 /*
674 * Have we already created the kernel maps for the host machine?
675 *
676 * This should have happened earlier, when we processed the kernel MMAP
677 * events, but for older perf.data files there was no such thing, so do
678 * it now.
679 */
680 if (cpumode == PERF_RECORD_MISC_KERNEL &&
681 session->host_machine.vmlinux_maps[MAP__FUNCTION] == NULL)
682 machine__create_kernel_maps(&session->host_machine);
515 683
516 thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION, 684 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
517 self->ip.ip, al, filter); 685 self->ip.pid, self->ip.ip, al);
518 dump_printf(" ...... dso: %s\n", 686 dump_printf(" ...... dso: %s\n",
519 al->map ? al->map->dso->long_name : 687 al->map ? al->map->dso->long_name :
520 al->level == 'H' ? "[hypervisor]" : "<not found>"); 688 al->level == 'H' ? "[hypervisor]" : "<not found>");
521 /* 689 al->sym = NULL;
522 * We have to do this here as we may have a dso with no symbol hit that 690
523 * has a name longer than the ones with symbols sampled. 691 if (al->map) {
524 */ 692 if (symbol_conf.dso_list &&
525 if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated) 693 (!al->map || !al->map->dso ||
526 dso__calc_col_width(al->map->dso); 694 !(strlist__has_entry(symbol_conf.dso_list,
527 695 al->map->dso->short_name) ||
528 if (symbol_conf.dso_list && 696 (al->map->dso->short_name != al->map->dso->long_name &&
529 (!al->map || !al->map->dso || 697 strlist__has_entry(symbol_conf.dso_list,
530 !(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) || 698 al->map->dso->long_name)))))
531 (al->map->dso->short_name != al->map->dso->long_name && 699 goto out_filtered;
532 strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name))))) 700 /*
533 goto out_filtered; 701 * We have to do this here as we may have a dso with no symbol
702 * hit that has a name longer than the ones with symbols
703 * sampled.
704 */
705 if (!sort_dso.elide && !al->map->dso->slen_calculated)
706 dso__calc_col_width(al->map->dso);
707
708 al->sym = map__find_symbol(al->map, al->addr, filter);
709 } else {
710 const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
711
712 if (dsos__col_width < unresolved_col_width &&
713 !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
714 !symbol_conf.dso_list)
715 dsos__col_width = unresolved_col_width;
716 }
534 717
535 if (symbol_conf.sym_list && al->sym && 718 if (symbol_conf.sym_list && al->sym &&
536 !strlist__has_entry(symbol_conf.sym_list, al->sym->name)) 719 !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
537 goto out_filtered; 720 goto out_filtered;
538 721
539 al->filtered = false;
540 return 0; 722 return 0;
541 723
542out_filtered: 724out_filtered:
@@ -570,6 +752,7 @@ int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
570 array++; 752 array++;
571 } 753 }
572 754
755 data->id = -1ULL;
573 if (type & PERF_SAMPLE_ID) { 756 if (type & PERF_SAMPLE_ID) {
574 data->id = *array; 757 data->id = *array;
575 array++; 758 array++;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index a33b94952e3..8577085db06 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -68,21 +68,54 @@ struct sample_data {
68 u64 addr; 68 u64 addr;
69 u64 id; 69 u64 id;
70 u64 stream_id; 70 u64 stream_id;
71 u32 cpu;
72 u64 period; 71 u64 period;
73 struct ip_callchain *callchain; 72 u32 cpu;
74 u32 raw_size; 73 u32 raw_size;
75 void *raw_data; 74 void *raw_data;
75 struct ip_callchain *callchain;
76}; 76};
77 77
78#define BUILD_ID_SIZE 20 78#define BUILD_ID_SIZE 20
79 79
80struct build_id_event { 80struct build_id_event {
81 struct perf_event_header header; 81 struct perf_event_header header;
82 pid_t pid;
82 u8 build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))]; 83 u8 build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
83 char filename[]; 84 char filename[];
84}; 85};
85 86
87enum perf_user_event_type { /* above any possible kernel type */
88 PERF_RECORD_HEADER_ATTR = 64,
89 PERF_RECORD_HEADER_EVENT_TYPE = 65,
90 PERF_RECORD_HEADER_TRACING_DATA = 66,
91 PERF_RECORD_HEADER_BUILD_ID = 67,
92 PERF_RECORD_FINISHED_ROUND = 68,
93 PERF_RECORD_HEADER_MAX
94};
95
96struct attr_event {
97 struct perf_event_header header;
98 struct perf_event_attr attr;
99 u64 id[];
100};
101
102#define MAX_EVENT_NAME 64
103
104struct perf_trace_event_type {
105 u64 event_id;
106 char name[MAX_EVENT_NAME];
107};
108
109struct event_type_event {
110 struct perf_event_header header;
111 struct perf_trace_event_type event_type;
112};
113
114struct tracing_data_event {
115 struct perf_event_header header;
116 u32 size;
117};
118
86typedef union event_union { 119typedef union event_union {
87 struct perf_event_header header; 120 struct perf_event_header header;
88 struct ip_event ip; 121 struct ip_event ip;
@@ -92,22 +125,12 @@ typedef union event_union {
92 struct lost_event lost; 125 struct lost_event lost;
93 struct read_event read; 126 struct read_event read;
94 struct sample_event sample; 127 struct sample_event sample;
128 struct attr_event attr;
129 struct event_type_event event_type;
130 struct tracing_data_event tracing_data;
131 struct build_id_event build_id;
95} event_t; 132} event_t;
96 133
97struct events_stats {
98 u64 total;
99 u64 lost;
100};
101
102struct event_stat_id {
103 struct rb_node rb_node;
104 struct rb_root hists;
105 struct events_stats stats;
106 u64 config;
107 u64 event_stream;
108 u32 type;
109};
110
111void event__print_totals(void); 134void event__print_totals(void);
112 135
113struct perf_session; 136struct perf_session;
@@ -119,10 +142,13 @@ int event__synthesize_thread(pid_t pid, event__handler_t process,
119void event__synthesize_threads(event__handler_t process, 142void event__synthesize_threads(event__handler_t process,
120 struct perf_session *session); 143 struct perf_session *session);
121int event__synthesize_kernel_mmap(event__handler_t process, 144int event__synthesize_kernel_mmap(event__handler_t process,
122 struct perf_session *session, 145 struct perf_session *session,
123 const char *symbol_name); 146 struct machine *machine,
147 const char *symbol_name);
148
124int event__synthesize_modules(event__handler_t process, 149int event__synthesize_modules(event__handler_t process,
125 struct perf_session *session); 150 struct perf_session *session,
151 struct machine *machine);
126 152
127int event__process_comm(event_t *self, struct perf_session *session); 153int event__process_comm(event_t *self, struct perf_session *session);
128int event__process_lost(event_t *self, struct perf_session *session); 154int event__process_lost(event_t *self, struct perf_session *session);
@@ -134,4 +160,6 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
134 struct addr_location *al, symbol_filter_t filter); 160 struct addr_location *al, symbol_filter_t filter);
135int event__parse_sample(event_t *event, u64 type, struct sample_data *data); 161int event__parse_sample(event_t *event, u64 type, struct sample_data *data);
136 162
163extern const char *event__name[];
164
137#endif /* __PERF_RECORD_H */ 165#endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/exec_cmd.c b/tools/perf/util/exec_cmd.c
index 2745605dba1..67eeff57156 100644
--- a/tools/perf/util/exec_cmd.c
+++ b/tools/perf/util/exec_cmd.c
@@ -53,8 +53,8 @@ const char *perf_extract_argv0_path(const char *argv0)
53 slash--; 53 slash--;
54 54
55 if (slash >= argv0) { 55 if (slash >= argv0) {
56 argv0_path = xstrndup(argv0, slash - argv0); 56 argv0_path = strndup(argv0, slash - argv0);
57 return slash + 1; 57 return argv0_path ? slash + 1 : NULL;
58 } 58 }
59 59
60 return argv0; 60 return argv0;
@@ -116,7 +116,7 @@ void setup_path(void)
116 strbuf_release(&new_path); 116 strbuf_release(&new_path);
117} 117}
118 118
119const char **prepare_perf_cmd(const char **argv) 119static const char **prepare_perf_cmd(const char **argv)
120{ 120{
121 int argc; 121 int argc;
122 const char **nargv; 122 const char **nargv;
diff --git a/tools/perf/util/exec_cmd.h b/tools/perf/util/exec_cmd.h
index 31647ac92ed..bc4b915963f 100644
--- a/tools/perf/util/exec_cmd.h
+++ b/tools/perf/util/exec_cmd.h
@@ -5,7 +5,6 @@ extern void perf_set_argv_exec_path(const char *exec_path);
5extern const char *perf_extract_argv0_path(const char *path); 5extern const char *perf_extract_argv0_path(const char *path);
6extern const char *perf_exec_path(void); 6extern const char *perf_exec_path(void);
7extern void setup_path(void); 7extern void setup_path(void);
8extern const char **prepare_perf_cmd(const char **argv);
9extern int execv_perf_cmd(const char **argv); /* NULL terminated */ 8extern int execv_perf_cmd(const char **argv); /* NULL terminated */
10extern int execl_perf_cmd(const char *cmd, ...); 9extern int execl_perf_cmd(const char *cmd, ...);
11extern const char *system_path(const char *path); 10extern const char *system_path(const char *path);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 6c9aa16ee51..1f62435f96c 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -99,13 +99,6 @@ int perf_header__add_attr(struct perf_header *self,
99 return 0; 99 return 0;
100} 100}
101 101
102#define MAX_EVENT_NAME 64
103
104struct perf_trace_event_type {
105 u64 event_id;
106 char name[MAX_EVENT_NAME];
107};
108
109static int event_count; 102static int event_count;
110static struct perf_trace_event_type *events; 103static struct perf_trace_event_type *events;
111 104
@@ -197,7 +190,8 @@ static int write_padded(int fd, const void *bf, size_t count,
197 continue; \ 190 continue; \
198 else 191 else
199 192
200static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd) 193static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
194 u16 misc, int fd)
201{ 195{
202 struct dso *pos; 196 struct dso *pos;
203 197
@@ -212,6 +206,7 @@ static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
212 len = ALIGN(len, NAME_ALIGN); 206 len = ALIGN(len, NAME_ALIGN);
213 memset(&b, 0, sizeof(b)); 207 memset(&b, 0, sizeof(b));
214 memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id)); 208 memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
209 b.pid = pid;
215 b.header.misc = misc; 210 b.header.misc = misc;
216 b.header.size = sizeof(b) + len; 211 b.header.size = sizeof(b) + len;
217 err = do_write(fd, &b, sizeof(b)); 212 err = do_write(fd, &b, sizeof(b));
@@ -226,13 +221,41 @@ static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
226 return 0; 221 return 0;
227} 222}
228 223
229static int dsos__write_buildid_table(int fd) 224static int machine__write_buildid_table(struct machine *self, int fd)
230{ 225{
231 int err = __dsos__write_buildid_table(&dsos__kernel, 226 int err;
232 PERF_RECORD_MISC_KERNEL, fd); 227 u16 kmisc = PERF_RECORD_MISC_KERNEL,
228 umisc = PERF_RECORD_MISC_USER;
229
230 if (!machine__is_host(self)) {
231 kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
232 umisc = PERF_RECORD_MISC_GUEST_USER;
233 }
234
235 err = __dsos__write_buildid_table(&self->kernel_dsos, self->pid,
236 kmisc, fd);
233 if (err == 0) 237 if (err == 0)
234 err = __dsos__write_buildid_table(&dsos__user, 238 err = __dsos__write_buildid_table(&self->user_dsos,
235 PERF_RECORD_MISC_USER, fd); 239 self->pid, umisc, fd);
240 return err;
241}
242
243static int dsos__write_buildid_table(struct perf_header *header, int fd)
244{
245 struct perf_session *session = container_of(header,
246 struct perf_session, header);
247 struct rb_node *nd;
248 int err = machine__write_buildid_table(&session->host_machine, fd);
249
250 if (err)
251 return err;
252
253 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
254 struct machine *pos = rb_entry(nd, struct machine, rb_node);
255 err = machine__write_buildid_table(pos, fd);
256 if (err)
257 break;
258 }
236 return err; 259 return err;
237} 260}
238 261
@@ -349,9 +372,17 @@ static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
349 return err; 372 return err;
350} 373}
351 374
352static int dsos__cache_build_ids(void) 375static int machine__cache_build_ids(struct machine *self, const char *debugdir)
353{ 376{
354 int err_kernel, err_user; 377 int ret = __dsos__cache_build_ids(&self->kernel_dsos, debugdir);
378 ret |= __dsos__cache_build_ids(&self->user_dsos, debugdir);
379 return ret;
380}
381
382static int perf_session__cache_build_ids(struct perf_session *self)
383{
384 struct rb_node *nd;
385 int ret;
355 char debugdir[PATH_MAX]; 386 char debugdir[PATH_MAX];
356 387
357 snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"), 388 snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"),
@@ -360,20 +391,46 @@ static int dsos__cache_build_ids(void)
360 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST) 391 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
361 return -1; 392 return -1;
362 393
363 err_kernel = __dsos__cache_build_ids(&dsos__kernel, debugdir); 394 ret = machine__cache_build_ids(&self->host_machine, debugdir);
364 err_user = __dsos__cache_build_ids(&dsos__user, debugdir); 395
365 return err_kernel || err_user ? -1 : 0; 396 for (nd = rb_first(&self->machines); nd; nd = rb_next(nd)) {
397 struct machine *pos = rb_entry(nd, struct machine, rb_node);
398 ret |= machine__cache_build_ids(pos, debugdir);
399 }
400 return ret ? -1 : 0;
401}
402
403static bool machine__read_build_ids(struct machine *self, bool with_hits)
404{
405 bool ret = __dsos__read_build_ids(&self->kernel_dsos, with_hits);
406 ret |= __dsos__read_build_ids(&self->user_dsos, with_hits);
407 return ret;
408}
409
410static bool perf_session__read_build_ids(struct perf_session *self, bool with_hits)
411{
412 struct rb_node *nd;
413 bool ret = machine__read_build_ids(&self->host_machine, with_hits);
414
415 for (nd = rb_first(&self->machines); nd; nd = rb_next(nd)) {
416 struct machine *pos = rb_entry(nd, struct machine, rb_node);
417 ret |= machine__read_build_ids(pos, with_hits);
418 }
419
420 return ret;
366} 421}
367 422
368static int perf_header__adds_write(struct perf_header *self, int fd) 423static int perf_header__adds_write(struct perf_header *self, int fd)
369{ 424{
370 int nr_sections; 425 int nr_sections;
426 struct perf_session *session;
371 struct perf_file_section *feat_sec; 427 struct perf_file_section *feat_sec;
372 int sec_size; 428 int sec_size;
373 u64 sec_start; 429 u64 sec_start;
374 int idx = 0, err; 430 int idx = 0, err;
375 431
376 if (dsos__read_build_ids(true)) 432 session = container_of(self, struct perf_session, header);
433 if (perf_session__read_build_ids(session, true))
377 perf_header__set_feat(self, HEADER_BUILD_ID); 434 perf_header__set_feat(self, HEADER_BUILD_ID);
378 435
379 nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS); 436 nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
@@ -400,7 +457,6 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
400 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset; 457 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
401 } 458 }
402 459
403
404 if (perf_header__has_feat(self, HEADER_BUILD_ID)) { 460 if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
405 struct perf_file_section *buildid_sec; 461 struct perf_file_section *buildid_sec;
406 462
@@ -408,14 +464,14 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
408 464
409 /* Write build-ids */ 465 /* Write build-ids */
410 buildid_sec->offset = lseek(fd, 0, SEEK_CUR); 466 buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
411 err = dsos__write_buildid_table(fd); 467 err = dsos__write_buildid_table(self, fd);
412 if (err < 0) { 468 if (err < 0) {
413 pr_debug("failed to write buildid table\n"); 469 pr_debug("failed to write buildid table\n");
414 goto out_free; 470 goto out_free;
415 } 471 }
416 buildid_sec->size = lseek(fd, 0, SEEK_CUR) - 472 buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
417 buildid_sec->offset; 473 buildid_sec->offset;
418 dsos__cache_build_ids(); 474 perf_session__cache_build_ids(session);
419 } 475 }
420 476
421 lseek(fd, sec_start, SEEK_SET); 477 lseek(fd, sec_start, SEEK_SET);
@@ -427,6 +483,25 @@ out_free:
427 return err; 483 return err;
428} 484}
429 485
486int perf_header__write_pipe(int fd)
487{
488 struct perf_pipe_file_header f_header;
489 int err;
490
491 f_header = (struct perf_pipe_file_header){
492 .magic = PERF_MAGIC,
493 .size = sizeof(f_header),
494 };
495
496 err = do_write(fd, &f_header, sizeof(f_header));
497 if (err < 0) {
498 pr_debug("failed to write perf pipe header\n");
499 return err;
500 }
501
502 return 0;
503}
504
430int perf_header__write(struct perf_header *self, int fd, bool at_exit) 505int perf_header__write(struct perf_header *self, int fd, bool at_exit)
431{ 506{
432 struct perf_file_header f_header; 507 struct perf_file_header f_header;
@@ -436,7 +511,6 @@ int perf_header__write(struct perf_header *self, int fd, bool at_exit)
436 511
437 lseek(fd, sizeof(f_header), SEEK_SET); 512 lseek(fd, sizeof(f_header), SEEK_SET);
438 513
439
440 for (i = 0; i < self->attrs; i++) { 514 for (i = 0; i < self->attrs; i++) {
441 attr = self->attr[i]; 515 attr = self->attr[i];
442 516
@@ -518,25 +592,10 @@ int perf_header__write(struct perf_header *self, int fd, bool at_exit)
518 return 0; 592 return 0;
519} 593}
520 594
521static int do_read(int fd, void *buf, size_t size)
522{
523 while (size) {
524 int ret = read(fd, buf, size);
525
526 if (ret <= 0)
527 return -1;
528
529 size -= ret;
530 buf += ret;
531 }
532
533 return 0;
534}
535
536static int perf_header__getbuffer64(struct perf_header *self, 595static int perf_header__getbuffer64(struct perf_header *self,
537 int fd, void *buf, size_t size) 596 int fd, void *buf, size_t size)
538{ 597{
539 if (do_read(fd, buf, size)) 598 if (do_read(fd, buf, size) <= 0)
540 return -1; 599 return -1;
541 600
542 if (self->needs_swap) 601 if (self->needs_swap)
@@ -592,7 +651,7 @@ int perf_file_header__read(struct perf_file_header *self,
592{ 651{
593 lseek(fd, 0, SEEK_SET); 652 lseek(fd, 0, SEEK_SET);
594 653
595 if (do_read(fd, self, sizeof(*self)) || 654 if (do_read(fd, self, sizeof(*self)) <= 0 ||
596 memcmp(&self->magic, __perf_magic, sizeof(self->magic))) 655 memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
597 return -1; 656 return -1;
598 657
@@ -636,6 +695,93 @@ int perf_file_header__read(struct perf_file_header *self,
636 return 0; 695 return 0;
637} 696}
638 697
698static int __event_process_build_id(struct build_id_event *bev,
699 char *filename,
700 struct perf_session *session)
701{
702 int err = -1;
703 struct list_head *head;
704 struct machine *machine;
705 u16 misc;
706 struct dso *dso;
707 enum dso_kernel_type dso_type;
708
709 machine = perf_session__findnew_machine(session, bev->pid);
710 if (!machine)
711 goto out;
712
713 misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
714
715 switch (misc) {
716 case PERF_RECORD_MISC_KERNEL:
717 dso_type = DSO_TYPE_KERNEL;
718 head = &machine->kernel_dsos;
719 break;
720 case PERF_RECORD_MISC_GUEST_KERNEL:
721 dso_type = DSO_TYPE_GUEST_KERNEL;
722 head = &machine->kernel_dsos;
723 break;
724 case PERF_RECORD_MISC_USER:
725 case PERF_RECORD_MISC_GUEST_USER:
726 dso_type = DSO_TYPE_USER;
727 head = &machine->user_dsos;
728 break;
729 default:
730 goto out;
731 }
732
733 dso = __dsos__findnew(head, filename);
734 if (dso != NULL) {
735 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
736
737 dso__set_build_id(dso, &bev->build_id);
738
739 if (filename[0] == '[')
740 dso->kernel = dso_type;
741
742 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
743 sbuild_id);
744 pr_debug("build id event received for %s: %s\n",
745 dso->long_name, sbuild_id);
746 }
747
748 err = 0;
749out:
750 return err;
751}
752
753static int perf_header__read_build_ids(struct perf_header *self,
754 int input, u64 offset, u64 size)
755{
756 struct perf_session *session = container_of(self,
757 struct perf_session, header);
758 struct build_id_event bev;
759 char filename[PATH_MAX];
760 u64 limit = offset + size;
761 int err = -1;
762
763 while (offset < limit) {
764 ssize_t len;
765
766 if (read(input, &bev, sizeof(bev)) != sizeof(bev))
767 goto out;
768
769 if (self->needs_swap)
770 perf_event_header__bswap(&bev.header);
771
772 len = bev.header.size - sizeof(bev);
773 if (read(input, filename, len) != len)
774 goto out;
775
776 __event_process_build_id(&bev, filename, session);
777
778 offset += bev.header.size;
779 }
780 err = 0;
781out:
782 return err;
783}
784
639static int perf_file_section__process(struct perf_file_section *self, 785static int perf_file_section__process(struct perf_file_section *self,
640 struct perf_header *ph, 786 struct perf_header *ph,
641 int feat, int fd) 787 int feat, int fd)
@@ -648,7 +794,7 @@ static int perf_file_section__process(struct perf_file_section *self,
648 794
649 switch (feat) { 795 switch (feat) {
650 case HEADER_TRACE_INFO: 796 case HEADER_TRACE_INFO:
651 trace_report(fd); 797 trace_report(fd, false);
652 break; 798 break;
653 799
654 case HEADER_BUILD_ID: 800 case HEADER_BUILD_ID:
@@ -662,13 +808,56 @@ static int perf_file_section__process(struct perf_file_section *self,
662 return 0; 808 return 0;
663} 809}
664 810
665int perf_header__read(struct perf_header *self, int fd) 811static int perf_file_header__read_pipe(struct perf_pipe_file_header *self,
812 struct perf_header *ph, int fd,
813 bool repipe)
666{ 814{
815 if (do_read(fd, self, sizeof(*self)) <= 0 ||
816 memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
817 return -1;
818
819 if (repipe && do_write(STDOUT_FILENO, self, sizeof(*self)) < 0)
820 return -1;
821
822 if (self->size != sizeof(*self)) {
823 u64 size = bswap_64(self->size);
824
825 if (size != sizeof(*self))
826 return -1;
827
828 ph->needs_swap = true;
829 }
830
831 return 0;
832}
833
834static int perf_header__read_pipe(struct perf_session *session, int fd)
835{
836 struct perf_header *self = &session->header;
837 struct perf_pipe_file_header f_header;
838
839 if (perf_file_header__read_pipe(&f_header, self, fd,
840 session->repipe) < 0) {
841 pr_debug("incompatible file format\n");
842 return -EINVAL;
843 }
844
845 session->fd = fd;
846
847 return 0;
848}
849
850int perf_header__read(struct perf_session *session, int fd)
851{
852 struct perf_header *self = &session->header;
667 struct perf_file_header f_header; 853 struct perf_file_header f_header;
668 struct perf_file_attr f_attr; 854 struct perf_file_attr f_attr;
669 u64 f_id; 855 u64 f_id;
670 int nr_attrs, nr_ids, i, j; 856 int nr_attrs, nr_ids, i, j;
671 857
858 if (session->fd_pipe)
859 return perf_header__read_pipe(session, fd);
860
672 if (perf_file_header__read(&f_header, self, fd) < 0) { 861 if (perf_file_header__read(&f_header, self, fd) < 0) {
673 pr_debug("incompatible file format\n"); 862 pr_debug("incompatible file format\n");
674 return -EINVAL; 863 return -EINVAL;
@@ -753,6 +942,14 @@ perf_header__find_attr(u64 id, struct perf_header *header)
753{ 942{
754 int i; 943 int i;
755 944
945 /*
946 * We set id to -1 if the data file doesn't contain sample
947 * ids. Check for this and avoid walking through the entire
948 * list of ids which may be large.
949 */
950 if (id == -1ULL)
951 return NULL;
952
756 for (i = 0; i < header->attrs; i++) { 953 for (i = 0; i < header->attrs; i++) {
757 struct perf_header_attr *attr = header->attr[i]; 954 struct perf_header_attr *attr = header->attr[i];
758 int j; 955 int j;
@@ -765,3 +962,231 @@ perf_header__find_attr(u64 id, struct perf_header *header)
765 962
766 return NULL; 963 return NULL;
767} 964}
965
966int event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
967 event__handler_t process,
968 struct perf_session *session)
969{
970 event_t *ev;
971 size_t size;
972 int err;
973
974 size = sizeof(struct perf_event_attr);
975 size = ALIGN(size, sizeof(u64));
976 size += sizeof(struct perf_event_header);
977 size += ids * sizeof(u64);
978
979 ev = malloc(size);
980
981 ev->attr.attr = *attr;
982 memcpy(ev->attr.id, id, ids * sizeof(u64));
983
984 ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
985 ev->attr.header.size = size;
986
987 err = process(ev, session);
988
989 free(ev);
990
991 return err;
992}
993
994int event__synthesize_attrs(struct perf_header *self,
995 event__handler_t process,
996 struct perf_session *session)
997{
998 struct perf_header_attr *attr;
999 int i, err = 0;
1000
1001 for (i = 0; i < self->attrs; i++) {
1002 attr = self->attr[i];
1003
1004 err = event__synthesize_attr(&attr->attr, attr->ids, attr->id,
1005 process, session);
1006 if (err) {
1007 pr_debug("failed to create perf header attribute\n");
1008 return err;
1009 }
1010 }
1011
1012 return err;
1013}
1014
1015int event__process_attr(event_t *self, struct perf_session *session)
1016{
1017 struct perf_header_attr *attr;
1018 unsigned int i, ids, n_ids;
1019
1020 attr = perf_header_attr__new(&self->attr.attr);
1021 if (attr == NULL)
1022 return -ENOMEM;
1023
1024 ids = self->header.size;
1025 ids -= (void *)&self->attr.id - (void *)self;
1026 n_ids = ids / sizeof(u64);
1027
1028 for (i = 0; i < n_ids; i++) {
1029 if (perf_header_attr__add_id(attr, self->attr.id[i]) < 0) {
1030 perf_header_attr__delete(attr);
1031 return -ENOMEM;
1032 }
1033 }
1034
1035 if (perf_header__add_attr(&session->header, attr) < 0) {
1036 perf_header_attr__delete(attr);
1037 return -ENOMEM;
1038 }
1039
1040 perf_session__update_sample_type(session);
1041
1042 return 0;
1043}
1044
1045int event__synthesize_event_type(u64 event_id, char *name,
1046 event__handler_t process,
1047 struct perf_session *session)
1048{
1049 event_t ev;
1050 size_t size = 0;
1051 int err = 0;
1052
1053 memset(&ev, 0, sizeof(ev));
1054
1055 ev.event_type.event_type.event_id = event_id;
1056 memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
1057 strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
1058
1059 ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
1060 size = strlen(name);
1061 size = ALIGN(size, sizeof(u64));
1062 ev.event_type.header.size = sizeof(ev.event_type) -
1063 (sizeof(ev.event_type.event_type.name) - size);
1064
1065 err = process(&ev, session);
1066
1067 return err;
1068}
1069
1070int event__synthesize_event_types(event__handler_t process,
1071 struct perf_session *session)
1072{
1073 struct perf_trace_event_type *type;
1074 int i, err = 0;
1075
1076 for (i = 0; i < event_count; i++) {
1077 type = &events[i];
1078
1079 err = event__synthesize_event_type(type->event_id, type->name,
1080 process, session);
1081 if (err) {
1082 pr_debug("failed to create perf header event type\n");
1083 return err;
1084 }
1085 }
1086
1087 return err;
1088}
1089
1090int event__process_event_type(event_t *self,
1091 struct perf_session *session __unused)
1092{
1093 if (perf_header__push_event(self->event_type.event_type.event_id,
1094 self->event_type.event_type.name) < 0)
1095 return -ENOMEM;
1096
1097 return 0;
1098}
1099
1100int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
1101 int nb_events,
1102 event__handler_t process,
1103 struct perf_session *session __unused)
1104{
1105 event_t ev;
1106 ssize_t size = 0, aligned_size = 0, padding;
1107 int err = 0;
1108
1109 memset(&ev, 0, sizeof(ev));
1110
1111 ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
1112 size = read_tracing_data_size(fd, pattrs, nb_events);
1113 if (size <= 0)
1114 return size;
1115 aligned_size = ALIGN(size, sizeof(u64));
1116 padding = aligned_size - size;
1117 ev.tracing_data.header.size = sizeof(ev.tracing_data);
1118 ev.tracing_data.size = aligned_size;
1119
1120 process(&ev, session);
1121
1122 err = read_tracing_data(fd, pattrs, nb_events);
1123 write_padded(fd, NULL, 0, padding);
1124
1125 return aligned_size;
1126}
1127
1128int event__process_tracing_data(event_t *self,
1129 struct perf_session *session)
1130{
1131 ssize_t size_read, padding, size = self->tracing_data.size;
1132 off_t offset = lseek(session->fd, 0, SEEK_CUR);
1133 char buf[BUFSIZ];
1134
1135 /* setup for reading amidst mmap */
1136 lseek(session->fd, offset + sizeof(struct tracing_data_event),
1137 SEEK_SET);
1138
1139 size_read = trace_report(session->fd, session->repipe);
1140
1141 padding = ALIGN(size_read, sizeof(u64)) - size_read;
1142
1143 if (read(session->fd, buf, padding) < 0)
1144 die("reading input file");
1145 if (session->repipe) {
1146 int retw = write(STDOUT_FILENO, buf, padding);
1147 if (retw <= 0 || retw != padding)
1148 die("repiping tracing data padding");
1149 }
1150
1151 if (size_read + padding != size)
1152 die("tracing data size mismatch");
1153
1154 return size_read + padding;
1155}
1156
1157int event__synthesize_build_id(struct dso *pos, u16 misc,
1158 event__handler_t process,
1159 struct machine *machine,
1160 struct perf_session *session)
1161{
1162 event_t ev;
1163 size_t len;
1164 int err = 0;
1165
1166 if (!pos->hit)
1167 return err;
1168
1169 memset(&ev, 0, sizeof(ev));
1170
1171 len = pos->long_name_len + 1;
1172 len = ALIGN(len, NAME_ALIGN);
1173 memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
1174 ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
1175 ev.build_id.header.misc = misc;
1176 ev.build_id.pid = machine->pid;
1177 ev.build_id.header.size = sizeof(ev.build_id) + len;
1178 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
1179
1180 err = process(&ev, session);
1181
1182 return err;
1183}
1184
1185int event__process_build_id(event_t *self,
1186 struct perf_session *session)
1187{
1188 __event_process_build_id(&self->build_id,
1189 self->build_id.filename,
1190 session);
1191 return 0;
1192}
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 82a6af72d4c..402ac2454cf 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -39,6 +39,11 @@ struct perf_file_header {
39 DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS); 39 DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
40}; 40};
41 41
42struct perf_pipe_file_header {
43 u64 magic;
44 u64 size;
45};
46
42struct perf_header; 47struct perf_header;
43 48
44int perf_file_header__read(struct perf_file_header *self, 49int perf_file_header__read(struct perf_file_header *self,
@@ -47,21 +52,22 @@ int perf_file_header__read(struct perf_file_header *self,
47struct perf_header { 52struct perf_header {
48 int frozen; 53 int frozen;
49 int attrs, size; 54 int attrs, size;
55 bool needs_swap;
50 struct perf_header_attr **attr; 56 struct perf_header_attr **attr;
51 s64 attr_offset; 57 s64 attr_offset;
52 u64 data_offset; 58 u64 data_offset;
53 u64 data_size; 59 u64 data_size;
54 u64 event_offset; 60 u64 event_offset;
55 u64 event_size; 61 u64 event_size;
56 bool needs_swap;
57 DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS); 62 DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
58}; 63};
59 64
60int perf_header__init(struct perf_header *self); 65int perf_header__init(struct perf_header *self);
61void perf_header__exit(struct perf_header *self); 66void perf_header__exit(struct perf_header *self);
62 67
63int perf_header__read(struct perf_header *self, int fd); 68int perf_header__read(struct perf_session *session, int fd);
64int perf_header__write(struct perf_header *self, int fd, bool at_exit); 69int perf_header__write(struct perf_header *self, int fd, bool at_exit);
70int perf_header__write_pipe(int fd);
65 71
66int perf_header__add_attr(struct perf_header *self, 72int perf_header__add_attr(struct perf_header *self,
67 struct perf_header_attr *attr); 73 struct perf_header_attr *attr);
@@ -89,4 +95,33 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
89 const char *name, bool is_kallsyms); 95 const char *name, bool is_kallsyms);
90int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir); 96int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
91 97
98int event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
99 event__handler_t process,
100 struct perf_session *session);
101int event__synthesize_attrs(struct perf_header *self,
102 event__handler_t process,
103 struct perf_session *session);
104int event__process_attr(event_t *self, struct perf_session *session);
105
106int event__synthesize_event_type(u64 event_id, char *name,
107 event__handler_t process,
108 struct perf_session *session);
109int event__synthesize_event_types(event__handler_t process,
110 struct perf_session *session);
111int event__process_event_type(event_t *self,
112 struct perf_session *session);
113
114int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
115 int nb_events,
116 event__handler_t process,
117 struct perf_session *session);
118int event__process_tracing_data(event_t *self,
119 struct perf_session *session);
120
121int event__synthesize_build_id(struct dso *pos, u16 misc,
122 event__handler_t process,
123 struct machine *machine,
124 struct perf_session *session);
125int event__process_build_id(event_t *self, struct perf_session *session);
126
92#endif /* __PERF_HEADER_H */ 127#endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/help.c b/tools/perf/util/help.c
index fbb00978b2e..6f2975a0035 100644
--- a/tools/perf/util/help.c
+++ b/tools/perf/util/help.c
@@ -4,28 +4,6 @@
4#include "levenshtein.h" 4#include "levenshtein.h"
5#include "help.h" 5#include "help.h"
6 6
7/* most GUI terminals set COLUMNS (although some don't export it) */
8static int term_columns(void)
9{
10 char *col_string = getenv("COLUMNS");
11 int n_cols;
12
13 if (col_string && (n_cols = atoi(col_string)) > 0)
14 return n_cols;
15
16#ifdef TIOCGWINSZ
17 {
18 struct winsize ws;
19 if (!ioctl(1, TIOCGWINSZ, &ws)) {
20 if (ws.ws_col)
21 return ws.ws_col;
22 }
23 }
24#endif
25
26 return 80;
27}
28
29void add_cmdname(struct cmdnames *cmds, const char *name, size_t len) 7void add_cmdname(struct cmdnames *cmds, const char *name, size_t len)
30{ 8{
31 struct cmdname *ent = malloc(sizeof(*ent) + len + 1); 9 struct cmdname *ent = malloc(sizeof(*ent) + len + 1);
@@ -96,9 +74,13 @@ static void pretty_print_string_list(struct cmdnames *cmds, int longest)
96{ 74{
97 int cols = 1, rows; 75 int cols = 1, rows;
98 int space = longest + 1; /* min 1 SP between words */ 76 int space = longest + 1; /* min 1 SP between words */
99 int max_cols = term_columns() - 1; /* don't print *on* the edge */ 77 struct winsize win;
78 int max_cols;
100 int i, j; 79 int i, j;
101 80
81 get_term_dimensions(&win);
82 max_cols = win.ws_col - 1; /* don't print *on* the edge */
83
102 if (space < max_cols) 84 if (space < max_cols)
103 cols = max_cols / space; 85 cols = max_cols / space;
104 rows = (cmds->cnt + cols - 1) / cols; 86 rows = (cmds->cnt + cols - 1) / cols;
@@ -324,7 +306,7 @@ const char *help_unknown_cmd(const char *cmd)
324 306
325 main_cmds.names[0] = NULL; 307 main_cmds.names[0] = NULL;
326 clean_cmdnames(&main_cmds); 308 clean_cmdnames(&main_cmds);
327 fprintf(stderr, "WARNING: You called a Git program named '%s', " 309 fprintf(stderr, "WARNING: You called a perf program named '%s', "
328 "which does not exist.\n" 310 "which does not exist.\n"
329 "Continuing under the assumption that you meant '%s'\n", 311 "Continuing under the assumption that you meant '%s'\n",
330 cmd, assumed); 312 cmd, assumed);
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 2be33c7dbf0..784ee0bdda7 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -1,3 +1,5 @@
1#include "util.h"
2#include "build-id.h"
1#include "hist.h" 3#include "hist.h"
2#include "session.h" 4#include "session.h"
3#include "sort.h" 5#include "sort.h"
@@ -8,25 +10,69 @@ struct callchain_param callchain_param = {
8 .min_percent = 0.5 10 .min_percent = 0.5
9}; 11};
10 12
13static void hist_entry__add_cpumode_period(struct hist_entry *self,
14 unsigned int cpumode, u64 period)
15{
16 switch (cpumode) {
17 case PERF_RECORD_MISC_KERNEL:
18 self->period_sys += period;
19 break;
20 case PERF_RECORD_MISC_USER:
21 self->period_us += period;
22 break;
23 case PERF_RECORD_MISC_GUEST_KERNEL:
24 self->period_guest_sys += period;
25 break;
26 case PERF_RECORD_MISC_GUEST_USER:
27 self->period_guest_us += period;
28 break;
29 default:
30 break;
31 }
32}
33
11/* 34/*
12 * histogram, sorted on item, collects counts 35 * histogram, sorted on item, collects periods
13 */ 36 */
14 37
15struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists, 38static struct hist_entry *hist_entry__new(struct hist_entry *template)
16 struct addr_location *al, 39{
17 struct symbol *sym_parent, 40 size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_node) : 0;
18 u64 count, bool *hit) 41 struct hist_entry *self = malloc(sizeof(*self) + callchain_size);
42
43 if (self != NULL) {
44 *self = *template;
45 self->nr_events = 1;
46 if (symbol_conf.use_callchain)
47 callchain_init(self->callchain);
48 }
49
50 return self;
51}
52
53static void hists__inc_nr_entries(struct hists *self, struct hist_entry *entry)
54{
55 if (entry->ms.sym && self->max_sym_namelen < entry->ms.sym->namelen)
56 self->max_sym_namelen = entry->ms.sym->namelen;
57 ++self->nr_entries;
58}
59
60struct hist_entry *__hists__add_entry(struct hists *self,
61 struct addr_location *al,
62 struct symbol *sym_parent, u64 period)
19{ 63{
20 struct rb_node **p = &hists->rb_node; 64 struct rb_node **p = &self->entries.rb_node;
21 struct rb_node *parent = NULL; 65 struct rb_node *parent = NULL;
22 struct hist_entry *he; 66 struct hist_entry *he;
23 struct hist_entry entry = { 67 struct hist_entry entry = {
24 .thread = al->thread, 68 .thread = al->thread,
25 .map = al->map, 69 .ms = {
26 .sym = al->sym, 70 .map = al->map,
71 .sym = al->sym,
72 },
27 .ip = al->addr, 73 .ip = al->addr,
28 .level = al->level, 74 .level = al->level,
29 .count = count, 75 .period = period,
30 .parent = sym_parent, 76 .parent = sym_parent,
31 }; 77 };
32 int cmp; 78 int cmp;
@@ -38,8 +84,9 @@ struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
38 cmp = hist_entry__cmp(&entry, he); 84 cmp = hist_entry__cmp(&entry, he);
39 85
40 if (!cmp) { 86 if (!cmp) {
41 *hit = true; 87 he->period += period;
42 return he; 88 ++he->nr_events;
89 goto out;
43 } 90 }
44 91
45 if (cmp < 0) 92 if (cmp < 0)
@@ -48,13 +95,14 @@ struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
48 p = &(*p)->rb_right; 95 p = &(*p)->rb_right;
49 } 96 }
50 97
51 he = malloc(sizeof(*he)); 98 he = hist_entry__new(&entry);
52 if (!he) 99 if (!he)
53 return NULL; 100 return NULL;
54 *he = entry;
55 rb_link_node(&he->rb_node, parent, p); 101 rb_link_node(&he->rb_node, parent, p);
56 rb_insert_color(&he->rb_node, hists); 102 rb_insert_color(&he->rb_node, &self->entries);
57 *hit = false; 103 hists__inc_nr_entries(self, he);
104out:
105 hist_entry__add_cpumode_period(he, al->cpumode, period);
58 return he; 106 return he;
59} 107}
60 108
@@ -65,7 +113,7 @@ hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
65 int64_t cmp = 0; 113 int64_t cmp = 0;
66 114
67 list_for_each_entry(se, &hist_entry__sort_list, list) { 115 list_for_each_entry(se, &hist_entry__sort_list, list) {
68 cmp = se->cmp(left, right); 116 cmp = se->se_cmp(left, right);
69 if (cmp) 117 if (cmp)
70 break; 118 break;
71 } 119 }
@@ -82,7 +130,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
82 list_for_each_entry(se, &hist_entry__sort_list, list) { 130 list_for_each_entry(se, &hist_entry__sort_list, list) {
83 int64_t (*f)(struct hist_entry *, struct hist_entry *); 131 int64_t (*f)(struct hist_entry *, struct hist_entry *);
84 132
85 f = se->collapse ?: se->cmp; 133 f = se->se_collapse ?: se->se_cmp;
86 134
87 cmp = f(left, right); 135 cmp = f(left, right);
88 if (cmp) 136 if (cmp)
@@ -101,7 +149,7 @@ void hist_entry__free(struct hist_entry *he)
101 * collapse the histogram 149 * collapse the histogram
102 */ 150 */
103 151
104static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he) 152static bool collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
105{ 153{
106 struct rb_node **p = &root->rb_node; 154 struct rb_node **p = &root->rb_node;
107 struct rb_node *parent = NULL; 155 struct rb_node *parent = NULL;
@@ -115,9 +163,9 @@ static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
115 cmp = hist_entry__collapse(iter, he); 163 cmp = hist_entry__collapse(iter, he);
116 164
117 if (!cmp) { 165 if (!cmp) {
118 iter->count += he->count; 166 iter->period += he->period;
119 hist_entry__free(he); 167 hist_entry__free(he);
120 return; 168 return false;
121 } 169 }
122 170
123 if (cmp < 0) 171 if (cmp < 0)
@@ -128,9 +176,10 @@ static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
128 176
129 rb_link_node(&he->rb_node, parent, p); 177 rb_link_node(&he->rb_node, parent, p);
130 rb_insert_color(&he->rb_node, root); 178 rb_insert_color(&he->rb_node, root);
179 return true;
131} 180}
132 181
133void perf_session__collapse_resort(struct rb_root *hists) 182void hists__collapse_resort(struct hists *self)
134{ 183{
135 struct rb_root tmp; 184 struct rb_root tmp;
136 struct rb_node *next; 185 struct rb_node *next;
@@ -140,72 +189,77 @@ void perf_session__collapse_resort(struct rb_root *hists)
140 return; 189 return;
141 190
142 tmp = RB_ROOT; 191 tmp = RB_ROOT;
143 next = rb_first(hists); 192 next = rb_first(&self->entries);
193 self->nr_entries = 0;
194 self->max_sym_namelen = 0;
144 195
145 while (next) { 196 while (next) {
146 n = rb_entry(next, struct hist_entry, rb_node); 197 n = rb_entry(next, struct hist_entry, rb_node);
147 next = rb_next(&n->rb_node); 198 next = rb_next(&n->rb_node);
148 199
149 rb_erase(&n->rb_node, hists); 200 rb_erase(&n->rb_node, &self->entries);
150 collapse__insert_entry(&tmp, n); 201 if (collapse__insert_entry(&tmp, n))
202 hists__inc_nr_entries(self, n);
151 } 203 }
152 204
153 *hists = tmp; 205 self->entries = tmp;
154} 206}
155 207
156/* 208/*
157 * reverse the map, sort on count. 209 * reverse the map, sort on period.
158 */ 210 */
159 211
160static void perf_session__insert_output_hist_entry(struct rb_root *root, 212static void __hists__insert_output_entry(struct rb_root *entries,
161 struct hist_entry *he, 213 struct hist_entry *he,
162 u64 min_callchain_hits) 214 u64 min_callchain_hits)
163{ 215{
164 struct rb_node **p = &root->rb_node; 216 struct rb_node **p = &entries->rb_node;
165 struct rb_node *parent = NULL; 217 struct rb_node *parent = NULL;
166 struct hist_entry *iter; 218 struct hist_entry *iter;
167 219
168 if (symbol_conf.use_callchain) 220 if (symbol_conf.use_callchain)
169 callchain_param.sort(&he->sorted_chain, &he->callchain, 221 callchain_param.sort(&he->sorted_chain, he->callchain,
170 min_callchain_hits, &callchain_param); 222 min_callchain_hits, &callchain_param);
171 223
172 while (*p != NULL) { 224 while (*p != NULL) {
173 parent = *p; 225 parent = *p;
174 iter = rb_entry(parent, struct hist_entry, rb_node); 226 iter = rb_entry(parent, struct hist_entry, rb_node);
175 227
176 if (he->count > iter->count) 228 if (he->period > iter->period)
177 p = &(*p)->rb_left; 229 p = &(*p)->rb_left;
178 else 230 else
179 p = &(*p)->rb_right; 231 p = &(*p)->rb_right;
180 } 232 }
181 233
182 rb_link_node(&he->rb_node, parent, p); 234 rb_link_node(&he->rb_node, parent, p);
183 rb_insert_color(&he->rb_node, root); 235 rb_insert_color(&he->rb_node, entries);
184} 236}
185 237
186void perf_session__output_resort(struct rb_root *hists, u64 total_samples) 238void hists__output_resort(struct hists *self)
187{ 239{
188 struct rb_root tmp; 240 struct rb_root tmp;
189 struct rb_node *next; 241 struct rb_node *next;
190 struct hist_entry *n; 242 struct hist_entry *n;
191 u64 min_callchain_hits; 243 u64 min_callchain_hits;
192 244
193 min_callchain_hits = 245 min_callchain_hits = self->stats.total_period * (callchain_param.min_percent / 100);
194 total_samples * (callchain_param.min_percent / 100);
195 246
196 tmp = RB_ROOT; 247 tmp = RB_ROOT;
197 next = rb_first(hists); 248 next = rb_first(&self->entries);
249
250 self->nr_entries = 0;
251 self->max_sym_namelen = 0;
198 252
199 while (next) { 253 while (next) {
200 n = rb_entry(next, struct hist_entry, rb_node); 254 n = rb_entry(next, struct hist_entry, rb_node);
201 next = rb_next(&n->rb_node); 255 next = rb_next(&n->rb_node);
202 256
203 rb_erase(&n->rb_node, hists); 257 rb_erase(&n->rb_node, &self->entries);
204 perf_session__insert_output_hist_entry(&tmp, n, 258 __hists__insert_output_entry(&tmp, n, min_callchain_hits);
205 min_callchain_hits); 259 hists__inc_nr_entries(self, n);
206 } 260 }
207 261
208 *hists = tmp; 262 self->entries = tmp;
209} 263}
210 264
211static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin) 265static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
@@ -237,7 +291,7 @@ static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
237} 291}
238 292
239static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, 293static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
240 int depth, int depth_mask, int count, 294 int depth, int depth_mask, int period,
241 u64 total_samples, int hits, 295 u64 total_samples, int hits,
242 int left_margin) 296 int left_margin)
243{ 297{
@@ -250,7 +304,7 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
250 ret += fprintf(fp, "|"); 304 ret += fprintf(fp, "|");
251 else 305 else
252 ret += fprintf(fp, " "); 306 ret += fprintf(fp, " ");
253 if (!count && i == depth - 1) { 307 if (!period && i == depth - 1) {
254 double percent; 308 double percent;
255 309
256 percent = hits * 100.0 / total_samples; 310 percent = hits * 100.0 / total_samples;
@@ -258,8 +312,8 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
258 } else 312 } else
259 ret += fprintf(fp, "%s", " "); 313 ret += fprintf(fp, "%s", " ");
260 } 314 }
261 if (chain->sym) 315 if (chain->ms.sym)
262 ret += fprintf(fp, "%s\n", chain->sym->name); 316 ret += fprintf(fp, "%s\n", chain->ms.sym->name);
263 else 317 else
264 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip); 318 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
265 319
@@ -278,7 +332,7 @@ static void init_rem_hits(void)
278 } 332 }
279 333
280 strcpy(rem_sq_bracket->name, "[...]"); 334 strcpy(rem_sq_bracket->name, "[...]");
281 rem_hits.sym = rem_sq_bracket; 335 rem_hits.ms.sym = rem_sq_bracket;
282} 336}
283 337
284static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self, 338static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
@@ -293,6 +347,7 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
293 u64 remaining; 347 u64 remaining;
294 size_t ret = 0; 348 size_t ret = 0;
295 int i; 349 int i;
350 uint entries_printed = 0;
296 351
297 if (callchain_param.mode == CHAIN_GRAPH_REL) 352 if (callchain_param.mode == CHAIN_GRAPH_REL)
298 new_total = self->children_hit; 353 new_total = self->children_hit;
@@ -328,8 +383,6 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
328 left_margin); 383 left_margin);
329 i = 0; 384 i = 0;
330 list_for_each_entry(chain, &child->val, list) { 385 list_for_each_entry(chain, &child->val, list) {
331 if (chain->ip >= PERF_CONTEXT_MAX)
332 continue;
333 ret += ipchain__fprintf_graph(fp, chain, depth, 386 ret += ipchain__fprintf_graph(fp, chain, depth,
334 new_depth_mask, i++, 387 new_depth_mask, i++,
335 new_total, 388 new_total,
@@ -341,6 +394,8 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
341 new_depth_mask | (1 << depth), 394 new_depth_mask | (1 << depth),
342 left_margin); 395 left_margin);
343 node = next; 396 node = next;
397 if (++entries_printed == callchain_param.print_limit)
398 break;
344 } 399 }
345 400
346 if (callchain_param.mode == CHAIN_GRAPH_REL && 401 if (callchain_param.mode == CHAIN_GRAPH_REL &&
@@ -366,11 +421,9 @@ static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
366 bool printed = false; 421 bool printed = false;
367 int i = 0; 422 int i = 0;
368 int ret = 0; 423 int ret = 0;
424 u32 entries_printed = 0;
369 425
370 list_for_each_entry(chain, &self->val, list) { 426 list_for_each_entry(chain, &self->val, list) {
371 if (chain->ip >= PERF_CONTEXT_MAX)
372 continue;
373
374 if (!i++ && sort__first_dimension == SORT_SYM) 427 if (!i++ && sort__first_dimension == SORT_SYM)
375 continue; 428 continue;
376 429
@@ -385,10 +438,13 @@ static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
385 } else 438 } else
386 ret += callchain__fprintf_left_margin(fp, left_margin); 439 ret += callchain__fprintf_left_margin(fp, left_margin);
387 440
388 if (chain->sym) 441 if (chain->ms.sym)
389 ret += fprintf(fp, " %s\n", chain->sym->name); 442 ret += fprintf(fp, " %s\n", chain->ms.sym->name);
390 else 443 else
391 ret += fprintf(fp, " %p\n", (void *)(long)chain->ip); 444 ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
445
446 if (++entries_printed == callchain_param.print_limit)
447 break;
392 } 448 }
393 449
394 ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin); 450 ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
@@ -411,8 +467,8 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
411 list_for_each_entry(chain, &self->val, list) { 467 list_for_each_entry(chain, &self->val, list) {
412 if (chain->ip >= PERF_CONTEXT_MAX) 468 if (chain->ip >= PERF_CONTEXT_MAX)
413 continue; 469 continue;
414 if (chain->sym) 470 if (chain->ms.sym)
415 ret += fprintf(fp, " %s\n", chain->sym->name); 471 ret += fprintf(fp, " %s\n", chain->ms.sym->name);
416 else 472 else
417 ret += fprintf(fp, " %p\n", 473 ret += fprintf(fp, " %p\n",
418 (void *)(long)chain->ip); 474 (void *)(long)chain->ip);
@@ -427,6 +483,7 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
427 struct rb_node *rb_node; 483 struct rb_node *rb_node;
428 struct callchain_node *chain; 484 struct callchain_node *chain;
429 size_t ret = 0; 485 size_t ret = 0;
486 u32 entries_printed = 0;
430 487
431 rb_node = rb_first(&self->sorted_chain); 488 rb_node = rb_first(&self->sorted_chain);
432 while (rb_node) { 489 while (rb_node) {
@@ -449,55 +506,88 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
449 break; 506 break;
450 } 507 }
451 ret += fprintf(fp, "\n"); 508 ret += fprintf(fp, "\n");
509 if (++entries_printed == callchain_param.print_limit)
510 break;
452 rb_node = rb_next(rb_node); 511 rb_node = rb_next(rb_node);
453 } 512 }
454 513
455 return ret; 514 return ret;
456} 515}
457 516
458static size_t hist_entry__fprintf(struct hist_entry *self, 517int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
459 struct perf_session *pair_session, 518 struct hists *pair_hists, bool show_displacement,
460 bool show_displacement, 519 long displacement, bool color, u64 session_total)
461 long displacement, FILE *fp,
462 u64 session_total)
463{ 520{
464 struct sort_entry *se; 521 struct sort_entry *se;
465 u64 count, total; 522 u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
466 const char *sep = symbol_conf.field_sep; 523 const char *sep = symbol_conf.field_sep;
467 size_t ret; 524 int ret;
468 525
469 if (symbol_conf.exclude_other && !self->parent) 526 if (symbol_conf.exclude_other && !self->parent)
470 return 0; 527 return 0;
471 528
472 if (pair_session) { 529 if (pair_hists) {
473 count = self->pair ? self->pair->count : 0; 530 period = self->pair ? self->pair->period : 0;
474 total = pair_session->events_stats.total; 531 total = pair_hists->stats.total_period;
532 period_sys = self->pair ? self->pair->period_sys : 0;
533 period_us = self->pair ? self->pair->period_us : 0;
534 period_guest_sys = self->pair ? self->pair->period_guest_sys : 0;
535 period_guest_us = self->pair ? self->pair->period_guest_us : 0;
475 } else { 536 } else {
476 count = self->count; 537 period = self->period;
477 total = session_total; 538 total = session_total;
539 period_sys = self->period_sys;
540 period_us = self->period_us;
541 period_guest_sys = self->period_guest_sys;
542 period_guest_us = self->period_guest_us;
478 } 543 }
479 544
480 if (total) 545 if (total) {
481 ret = percent_color_fprintf(fp, sep ? "%.2f" : " %6.2f%%", 546 if (color)
482 (count * 100.0) / total); 547 ret = percent_color_snprintf(s, size,
483 else 548 sep ? "%.2f" : " %6.2f%%",
484 ret = fprintf(fp, sep ? "%lld" : "%12lld ", count); 549 (period * 100.0) / total);
550 else
551 ret = snprintf(s, size, sep ? "%.2f" : " %6.2f%%",
552 (period * 100.0) / total);
553 if (symbol_conf.show_cpu_utilization) {
554 ret += percent_color_snprintf(s + ret, size - ret,
555 sep ? "%.2f" : " %6.2f%%",
556 (period_sys * 100.0) / total);
557 ret += percent_color_snprintf(s + ret, size - ret,
558 sep ? "%.2f" : " %6.2f%%",
559 (period_us * 100.0) / total);
560 if (perf_guest) {
561 ret += percent_color_snprintf(s + ret,
562 size - ret,
563 sep ? "%.2f" : " %6.2f%%",
564 (period_guest_sys * 100.0) /
565 total);
566 ret += percent_color_snprintf(s + ret,
567 size - ret,
568 sep ? "%.2f" : " %6.2f%%",
569 (period_guest_us * 100.0) /
570 total);
571 }
572 }
573 } else
574 ret = snprintf(s, size, sep ? "%lld" : "%12lld ", period);
485 575
486 if (symbol_conf.show_nr_samples) { 576 if (symbol_conf.show_nr_samples) {
487 if (sep) 577 if (sep)
488 fprintf(fp, "%c%lld", *sep, count); 578 ret += snprintf(s + ret, size - ret, "%c%lld", *sep, period);
489 else 579 else
490 fprintf(fp, "%11lld", count); 580 ret += snprintf(s + ret, size - ret, "%11lld", period);
491 } 581 }
492 582
493 if (pair_session) { 583 if (pair_hists) {
494 char bf[32]; 584 char bf[32];
495 double old_percent = 0, new_percent = 0, diff; 585 double old_percent = 0, new_percent = 0, diff;
496 586
497 if (total > 0) 587 if (total > 0)
498 old_percent = (count * 100.0) / total; 588 old_percent = (period * 100.0) / total;
499 if (session_total > 0) 589 if (session_total > 0)
500 new_percent = (self->count * 100.0) / session_total; 590 new_percent = (self->period * 100.0) / session_total;
501 591
502 diff = new_percent - old_percent; 592 diff = new_percent - old_percent;
503 593
@@ -507,9 +597,9 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
507 snprintf(bf, sizeof(bf), " "); 597 snprintf(bf, sizeof(bf), " ");
508 598
509 if (sep) 599 if (sep)
510 ret += fprintf(fp, "%c%s", *sep, bf); 600 ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
511 else 601 else
512 ret += fprintf(fp, "%11.11s", bf); 602 ret += snprintf(s + ret, size - ret, "%11.11s", bf);
513 603
514 if (show_displacement) { 604 if (show_displacement) {
515 if (displacement) 605 if (displacement)
@@ -518,9 +608,9 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
518 snprintf(bf, sizeof(bf), " "); 608 snprintf(bf, sizeof(bf), " ");
519 609
520 if (sep) 610 if (sep)
521 fprintf(fp, "%c%s", *sep, bf); 611 ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
522 else 612 else
523 fprintf(fp, "%6.6s", bf); 613 ret += snprintf(s + ret, size - ret, "%6.6s", bf);
524 } 614 }
525 } 615 }
526 616
@@ -528,33 +618,48 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
528 if (se->elide) 618 if (se->elide)
529 continue; 619 continue;
530 620
531 fprintf(fp, "%s", sep ?: " "); 621 ret += snprintf(s + ret, size - ret, "%s", sep ?: " ");
532 ret += se->print(fp, self, se->width ? *se->width : 0); 622 ret += se->se_snprintf(self, s + ret, size - ret,
623 se->se_width ? *se->se_width : 0);
533 } 624 }
534 625
535 ret += fprintf(fp, "\n"); 626 return ret;
627}
628
629int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
630 bool show_displacement, long displacement, FILE *fp,
631 u64 session_total)
632{
633 char bf[512];
634 int ret;
536 635
537 if (symbol_conf.use_callchain) { 636 ret = hist_entry__snprintf(self, bf, sizeof(bf), pair_hists,
538 int left_margin = 0; 637 show_displacement, displacement,
638 true, session_total);
639 if (!ret)
640 return 0;
539 641
540 if (sort__first_dimension == SORT_COMM) { 642 return fprintf(fp, "%s\n", bf);
541 se = list_first_entry(&hist_entry__sort_list, typeof(*se), 643}
542 list); 644
543 left_margin = se->width ? *se->width : 0; 645static size_t hist_entry__fprintf_callchain(struct hist_entry *self, FILE *fp,
544 left_margin -= thread__comm_len(self->thread); 646 u64 session_total)
545 } 647{
648 int left_margin = 0;
546 649
547 hist_entry_callchain__fprintf(fp, self, session_total, 650 if (sort__first_dimension == SORT_COMM) {
548 left_margin); 651 struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
652 typeof(*se), list);
653 left_margin = se->se_width ? *se->se_width : 0;
654 left_margin -= thread__comm_len(self->thread);
549 } 655 }
550 656
551 return ret; 657 return hist_entry_callchain__fprintf(fp, self, session_total,
658 left_margin);
552} 659}
553 660
554size_t perf_session__fprintf_hists(struct rb_root *hists, 661size_t hists__fprintf(struct hists *self, struct hists *pair,
555 struct perf_session *pair, 662 bool show_displacement, FILE *fp)
556 bool show_displacement, FILE *fp,
557 u64 session_total)
558{ 663{
559 struct sort_entry *se; 664 struct sort_entry *se;
560 struct rb_node *nd; 665 struct rb_node *nd;
@@ -563,7 +668,7 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
563 long displacement = 0; 668 long displacement = 0;
564 unsigned int width; 669 unsigned int width;
565 const char *sep = symbol_conf.field_sep; 670 const char *sep = symbol_conf.field_sep;
566 char *col_width = symbol_conf.col_width_list_str; 671 const char *col_width = symbol_conf.col_width_list_str;
567 672
568 init_rem_hits(); 673 init_rem_hits();
569 674
@@ -576,6 +681,24 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
576 fputs(" Samples ", fp); 681 fputs(" Samples ", fp);
577 } 682 }
578 683
684 if (symbol_conf.show_cpu_utilization) {
685 if (sep) {
686 ret += fprintf(fp, "%csys", *sep);
687 ret += fprintf(fp, "%cus", *sep);
688 if (perf_guest) {
689 ret += fprintf(fp, "%cguest sys", *sep);
690 ret += fprintf(fp, "%cguest us", *sep);
691 }
692 } else {
693 ret += fprintf(fp, " sys ");
694 ret += fprintf(fp, " us ");
695 if (perf_guest) {
696 ret += fprintf(fp, " guest sys ");
697 ret += fprintf(fp, " guest us ");
698 }
699 }
700 }
701
579 if (pair) { 702 if (pair) {
580 if (sep) 703 if (sep)
581 ret += fprintf(fp, "%cDelta", *sep); 704 ret += fprintf(fp, "%cDelta", *sep);
@@ -594,22 +717,22 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
594 if (se->elide) 717 if (se->elide)
595 continue; 718 continue;
596 if (sep) { 719 if (sep) {
597 fprintf(fp, "%c%s", *sep, se->header); 720 fprintf(fp, "%c%s", *sep, se->se_header);
598 continue; 721 continue;
599 } 722 }
600 width = strlen(se->header); 723 width = strlen(se->se_header);
601 if (se->width) { 724 if (se->se_width) {
602 if (symbol_conf.col_width_list_str) { 725 if (symbol_conf.col_width_list_str) {
603 if (col_width) { 726 if (col_width) {
604 *se->width = atoi(col_width); 727 *se->se_width = atoi(col_width);
605 col_width = strchr(col_width, ','); 728 col_width = strchr(col_width, ',');
606 if (col_width) 729 if (col_width)
607 ++col_width; 730 ++col_width;
608 } 731 }
609 } 732 }
610 width = *se->width = max(*se->width, width); 733 width = *se->se_width = max(*se->se_width, width);
611 } 734 }
612 fprintf(fp, " %*s", width, se->header); 735 fprintf(fp, " %*s", width, se->se_header);
613 } 736 }
614 fprintf(fp, "\n"); 737 fprintf(fp, "\n");
615 738
@@ -631,10 +754,10 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
631 continue; 754 continue;
632 755
633 fprintf(fp, " "); 756 fprintf(fp, " ");
634 if (se->width) 757 if (se->se_width)
635 width = *se->width; 758 width = *se->se_width;
636 else 759 else
637 width = strlen(se->header); 760 width = strlen(se->se_header);
638 for (i = 0; i < width; i++) 761 for (i = 0; i < width; i++)
639 fprintf(fp, "."); 762 fprintf(fp, ".");
640 } 763 }
@@ -642,8 +765,9 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
642 fprintf(fp, "\n#\n"); 765 fprintf(fp, "\n#\n");
643 766
644print_entries: 767print_entries:
645 for (nd = rb_first(hists); nd; nd = rb_next(nd)) { 768 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
646 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); 769 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
770 int cnt;
647 771
648 if (show_displacement) { 772 if (show_displacement) {
649 if (h->pair != NULL) 773 if (h->pair != NULL)
@@ -653,11 +777,20 @@ print_entries:
653 displacement = 0; 777 displacement = 0;
654 ++position; 778 ++position;
655 } 779 }
656 ret += hist_entry__fprintf(h, pair, show_displacement, 780 cnt = hist_entry__fprintf(h, pair, show_displacement,
657 displacement, fp, session_total); 781 displacement, fp, self->stats.total_period);
658 if (h->map == NULL && verbose > 1) { 782 /* Ignore those that didn't match the parent filter */
783 if (!cnt)
784 continue;
785
786 ret += cnt;
787
788 if (symbol_conf.use_callchain)
789 ret += hist_entry__fprintf_callchain(h, fp, self->stats.total_period);
790
791 if (h->ms.map == NULL && verbose > 1) {
659 __map_groups__fprintf_maps(&h->thread->mg, 792 __map_groups__fprintf_maps(&h->thread->mg,
660 MAP__FUNCTION, fp); 793 MAP__FUNCTION, verbose, fp);
661 fprintf(fp, "%.10s end\n", graph_dotted_line); 794 fprintf(fp, "%.10s end\n", graph_dotted_line);
662 } 795 }
663 } 796 }
@@ -666,3 +799,298 @@ print_entries:
666 799
667 return ret; 800 return ret;
668} 801}
802
803enum hist_filter {
804 HIST_FILTER__DSO,
805 HIST_FILTER__THREAD,
806};
807
808void hists__filter_by_dso(struct hists *self, const struct dso *dso)
809{
810 struct rb_node *nd;
811
812 self->nr_entries = self->stats.total_period = 0;
813 self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
814 self->max_sym_namelen = 0;
815
816 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
817 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
818
819 if (symbol_conf.exclude_other && !h->parent)
820 continue;
821
822 if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
823 h->filtered |= (1 << HIST_FILTER__DSO);
824 continue;
825 }
826
827 h->filtered &= ~(1 << HIST_FILTER__DSO);
828 if (!h->filtered) {
829 ++self->nr_entries;
830 self->stats.total_period += h->period;
831 self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
832 if (h->ms.sym &&
833 self->max_sym_namelen < h->ms.sym->namelen)
834 self->max_sym_namelen = h->ms.sym->namelen;
835 }
836 }
837}
838
839void hists__filter_by_thread(struct hists *self, const struct thread *thread)
840{
841 struct rb_node *nd;
842
843 self->nr_entries = self->stats.total_period = 0;
844 self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
845 self->max_sym_namelen = 0;
846
847 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
848 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
849
850 if (thread != NULL && h->thread != thread) {
851 h->filtered |= (1 << HIST_FILTER__THREAD);
852 continue;
853 }
854 h->filtered &= ~(1 << HIST_FILTER__THREAD);
855 if (!h->filtered) {
856 ++self->nr_entries;
857 self->stats.total_period += h->period;
858 self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
859 if (h->ms.sym &&
860 self->max_sym_namelen < h->ms.sym->namelen)
861 self->max_sym_namelen = h->ms.sym->namelen;
862 }
863 }
864}
865
866static int symbol__alloc_hist(struct symbol *self)
867{
868 struct sym_priv *priv = symbol__priv(self);
869 const int size = (sizeof(*priv->hist) +
870 (self->end - self->start) * sizeof(u64));
871
872 priv->hist = zalloc(size);
873 return priv->hist == NULL ? -1 : 0;
874}
875
876int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip)
877{
878 unsigned int sym_size, offset;
879 struct symbol *sym = self->ms.sym;
880 struct sym_priv *priv;
881 struct sym_hist *h;
882
883 if (!sym || !self->ms.map)
884 return 0;
885
886 priv = symbol__priv(sym);
887 if (priv->hist == NULL && symbol__alloc_hist(sym) < 0)
888 return -ENOMEM;
889
890 sym_size = sym->end - sym->start;
891 offset = ip - sym->start;
892
893 pr_debug3("%s: ip=%#Lx\n", __func__, self->ms.map->unmap_ip(self->ms.map, ip));
894
895 if (offset >= sym_size)
896 return 0;
897
898 h = priv->hist;
899 h->sum++;
900 h->ip[offset]++;
901
902 pr_debug3("%#Lx %s: period++ [ip: %#Lx, %#Lx] => %Ld\n", self->ms.sym->start,
903 self->ms.sym->name, ip, ip - self->ms.sym->start, h->ip[offset]);
904 return 0;
905}
906
907static struct objdump_line *objdump_line__new(s64 offset, char *line)
908{
909 struct objdump_line *self = malloc(sizeof(*self));
910
911 if (self != NULL) {
912 self->offset = offset;
913 self->line = line;
914 }
915
916 return self;
917}
918
919void objdump_line__free(struct objdump_line *self)
920{
921 free(self->line);
922 free(self);
923}
924
925static void objdump__add_line(struct list_head *head, struct objdump_line *line)
926{
927 list_add_tail(&line->node, head);
928}
929
930struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
931 struct objdump_line *pos)
932{
933 list_for_each_entry_continue(pos, head, node)
934 if (pos->offset >= 0)
935 return pos;
936
937 return NULL;
938}
939
940static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
941 struct list_head *head)
942{
943 struct symbol *sym = self->ms.sym;
944 struct objdump_line *objdump_line;
945 char *line = NULL, *tmp, *tmp2, *c;
946 size_t line_len;
947 s64 line_ip, offset = -1;
948
949 if (getline(&line, &line_len, file) < 0)
950 return -1;
951
952 if (!line)
953 return -1;
954
955 while (line_len != 0 && isspace(line[line_len - 1]))
956 line[--line_len] = '\0';
957
958 c = strchr(line, '\n');
959 if (c)
960 *c = 0;
961
962 line_ip = -1;
963
964 /*
965 * Strip leading spaces:
966 */
967 tmp = line;
968 while (*tmp) {
969 if (*tmp != ' ')
970 break;
971 tmp++;
972 }
973
974 if (*tmp) {
975 /*
976 * Parse hexa addresses followed by ':'
977 */
978 line_ip = strtoull(tmp, &tmp2, 16);
979 if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0')
980 line_ip = -1;
981 }
982
983 if (line_ip != -1) {
984 u64 start = map__rip_2objdump(self->ms.map, sym->start),
985 end = map__rip_2objdump(self->ms.map, sym->end);
986
987 offset = line_ip - start;
988 if (offset < 0 || (u64)line_ip > end)
989 offset = -1;
990 }
991
992 objdump_line = objdump_line__new(offset, line);
993 if (objdump_line == NULL) {
994 free(line);
995 return -1;
996 }
997 objdump__add_line(head, objdump_line);
998
999 return 0;
1000}
1001
1002int hist_entry__annotate(struct hist_entry *self, struct list_head *head)
1003{
1004 struct symbol *sym = self->ms.sym;
1005 struct map *map = self->ms.map;
1006 struct dso *dso = map->dso;
1007 char *filename = dso__build_id_filename(dso, NULL, 0);
1008 bool free_filename = true;
1009 char command[PATH_MAX * 2];
1010 FILE *file;
1011 int err = 0;
1012 u64 len;
1013
1014 if (filename == NULL) {
1015 if (dso->has_build_id) {
1016 pr_err("Can't annotate %s: not enough memory\n",
1017 sym->name);
1018 return -ENOMEM;
1019 }
1020 goto fallback;
1021 } else if (readlink(filename, command, sizeof(command)) < 0 ||
1022 strstr(command, "[kernel.kallsyms]") ||
1023 access(filename, R_OK)) {
1024 free(filename);
1025fallback:
1026 /*
1027 * If we don't have build-ids or the build-id file isn't in the
1028 * cache, or is just a kallsyms file, well, lets hope that this
1029 * DSO is the same as when 'perf record' ran.
1030 */
1031 filename = dso->long_name;
1032 free_filename = false;
1033 }
1034
1035 if (dso->origin == DSO__ORIG_KERNEL) {
1036 if (dso->annotate_warned)
1037 goto out_free_filename;
1038 err = -ENOENT;
1039 dso->annotate_warned = 1;
1040 pr_err("Can't annotate %s: No vmlinux file was found in the "
1041 "path\n", sym->name);
1042 goto out_free_filename;
1043 }
1044
1045 pr_debug("%s: filename=%s, sym=%s, start=%#Lx, end=%#Lx\n", __func__,
1046 filename, sym->name, map->unmap_ip(map, sym->start),
1047 map->unmap_ip(map, sym->end));
1048
1049 len = sym->end - sym->start;
1050
1051 pr_debug("annotating [%p] %30s : [%p] %30s\n",
1052 dso, dso->long_name, sym, sym->name);
1053
1054 snprintf(command, sizeof(command),
1055 "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s|expand",
1056 map__rip_2objdump(map, sym->start),
1057 map__rip_2objdump(map, sym->end),
1058 filename, filename);
1059
1060 pr_debug("Executing: %s\n", command);
1061
1062 file = popen(command, "r");
1063 if (!file)
1064 goto out_free_filename;
1065
1066 while (!feof(file))
1067 if (hist_entry__parse_objdump_line(self, file, head) < 0)
1068 break;
1069
1070 pclose(file);
1071out_free_filename:
1072 if (free_filename)
1073 free(filename);
1074 return err;
1075}
1076
1077void hists__inc_nr_events(struct hists *self, u32 type)
1078{
1079 ++self->stats.nr_events[0];
1080 ++self->stats.nr_events[type];
1081}
1082
1083size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
1084{
1085 int i;
1086 size_t ret = 0;
1087
1088 for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
1089 if (!event__name[i])
1090 continue;
1091 ret += fprintf(fp, "%10s events: %10d\n",
1092 event__name[i], self->stats.nr_events[i]);
1093 }
1094
1095 return ret;
1096}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 16f360cce5b..83fa33a7b38 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -6,24 +6,124 @@
6 6
7extern struct callchain_param callchain_param; 7extern struct callchain_param callchain_param;
8 8
9struct perf_session;
10struct hist_entry; 9struct hist_entry;
11struct addr_location; 10struct addr_location;
12struct symbol; 11struct symbol;
13struct rb_root; 12struct rb_root;
14 13
15struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists, 14struct objdump_line {
16 struct addr_location *al, 15 struct list_head node;
17 struct symbol *parent, 16 s64 offset;
18 u64 count, bool *hit); 17 char *line;
18};
19
20void objdump_line__free(struct objdump_line *self);
21struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
22 struct objdump_line *pos);
23
24struct sym_hist {
25 u64 sum;
26 u64 ip[0];
27};
28
29struct sym_ext {
30 struct rb_node node;
31 double percent;
32 char *path;
33};
34
35struct sym_priv {
36 struct sym_hist *hist;
37 struct sym_ext *ext;
38};
39
40/*
41 * The kernel collects the number of events it couldn't send in a stretch and
42 * when possible sends this number in a PERF_RECORD_LOST event. The number of
43 * such "chunks" of lost events is stored in .nr_events[PERF_EVENT_LOST] while
44 * total_lost tells exactly how many events the kernel in fact lost, i.e. it is
45 * the sum of all struct lost_event.lost fields reported.
46 *
47 * The total_period is needed because by default auto-freq is used, so
48 * multipling nr_events[PERF_EVENT_SAMPLE] by a frequency isn't possible to get
49 * the total number of low level events, it is necessary to to sum all struct
50 * sample_event.period and stash the result in total_period.
51 */
52struct events_stats {
53 u64 total_period;
54 u64 total_lost;
55 u32 nr_events[PERF_RECORD_HEADER_MAX];
56 u32 nr_unknown_events;
57};
58
59struct hists {
60 struct rb_node rb_node;
61 struct rb_root entries;
62 u64 nr_entries;
63 struct events_stats stats;
64 u64 config;
65 u64 event_stream;
66 u32 type;
67 u32 max_sym_namelen;
68};
69
70struct hist_entry *__hists__add_entry(struct hists *self,
71 struct addr_location *al,
72 struct symbol *parent, u64 period);
19extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *); 73extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
20extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *); 74extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
75int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
76 bool show_displacement, long displacement, FILE *fp,
77 u64 total);
78int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
79 struct hists *pair_hists, bool show_displacement,
80 long displacement, bool color, u64 total);
21void hist_entry__free(struct hist_entry *); 81void hist_entry__free(struct hist_entry *);
22 82
23void perf_session__output_resort(struct rb_root *hists, u64 total_samples); 83void hists__output_resort(struct hists *self);
24void perf_session__collapse_resort(struct rb_root *hists); 84void hists__collapse_resort(struct hists *self);
25size_t perf_session__fprintf_hists(struct rb_root *hists, 85
26 struct perf_session *pair, 86void hists__inc_nr_events(struct hists *self, u32 type);
27 bool show_displacement, FILE *fp, 87size_t hists__fprintf_nr_events(struct hists *self, FILE *fp);
28 u64 session_total); 88
89size_t hists__fprintf(struct hists *self, struct hists *pair,
90 bool show_displacement, FILE *fp);
91
92int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip);
93int hist_entry__annotate(struct hist_entry *self, struct list_head *head);
94
95void hists__filter_by_dso(struct hists *self, const struct dso *dso);
96void hists__filter_by_thread(struct hists *self, const struct thread *thread);
97
98#ifdef NO_NEWT_SUPPORT
99static inline int hists__browse(struct hists *self __used,
100 const char *helpline __used,
101 const char *ev_name __used)
102{
103 return 0;
104}
105
106static inline int hists__tui_browse_tree(struct rb_root *self __used,
107 const char *help __used)
108{
109 return 0;
110}
111
112static inline int hist_entry__tui_annotate(struct hist_entry *self __used)
113{
114 return 0;
115}
116#define KEY_LEFT -1
117#define KEY_RIGHT -2
118#else
119#include <newt.h>
120int hists__browse(struct hists *self, const char *helpline,
121 const char *ev_name);
122int hist_entry__tui_annotate(struct hist_entry *self);
123
124#define KEY_LEFT NEWT_KEY_LEFT
125#define KEY_RIGHT NEWT_KEY_RIGHT
126
127int hists__tui_browse_tree(struct rb_root *self, const char *help);
128#endif
29#endif /* __PERF_HIST_H */ 129#endif /* __PERF_HIST_H */
diff --git a/tools/perf/util/hweight.c b/tools/perf/util/hweight.c
new file mode 100644
index 00000000000..5c1d0d099f0
--- /dev/null
+++ b/tools/perf/util/hweight.c
@@ -0,0 +1,31 @@
1#include <linux/bitops.h>
2
3/**
4 * hweightN - returns the hamming weight of a N-bit word
5 * @x: the word to weigh
6 *
7 * The Hamming Weight of a number is the total number of bits set in it.
8 */
9
10unsigned int hweight32(unsigned int w)
11{
12 unsigned int res = w - ((w >> 1) & 0x55555555);
13 res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
14 res = (res + (res >> 4)) & 0x0F0F0F0F;
15 res = res + (res >> 8);
16 return (res + (res >> 16)) & 0x000000FF;
17}
18
19unsigned long hweight64(__u64 w)
20{
21#if BITS_PER_LONG == 32
22 return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
23#elif BITS_PER_LONG == 64
24 __u64 res = w - ((w >> 1) & 0x5555555555555555ul);
25 res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
26 res = (res + (res >> 4)) & 0x0F0F0F0F0F0F0F0Ful;
27 res = res + (res >> 8);
28 res = res + (res >> 16);
29 return (res + (res >> 32)) & 0x00000000000000FFul;
30#endif
31}
diff --git a/tools/perf/util/include/asm/bitops.h b/tools/perf/util/include/asm/bitops.h
deleted file mode 100644
index 58e9817ffae..00000000000
--- a/tools/perf/util/include/asm/bitops.h
+++ /dev/null
@@ -1,18 +0,0 @@
1#ifndef _PERF_ASM_BITOPS_H_
2#define _PERF_ASM_BITOPS_H_
3
4#include <sys/types.h>
5#include "../../types.h"
6#include <linux/compiler.h>
7
8/* CHECKME: Not sure both always match */
9#define BITS_PER_LONG __WORDSIZE
10
11#include "../../../../include/asm-generic/bitops/__fls.h"
12#include "../../../../include/asm-generic/bitops/fls.h"
13#include "../../../../include/asm-generic/bitops/fls64.h"
14#include "../../../../include/asm-generic/bitops/__ffs.h"
15#include "../../../../include/asm-generic/bitops/ffz.h"
16#include "../../../../include/asm-generic/bitops/hweight.h"
17
18#endif
diff --git a/tools/perf/util/include/asm/hweight.h b/tools/perf/util/include/asm/hweight.h
new file mode 100644
index 00000000000..36cf26d434a
--- /dev/null
+++ b/tools/perf/util/include/asm/hweight.h
@@ -0,0 +1,8 @@
1#ifndef PERF_HWEIGHT_H
2#define PERF_HWEIGHT_H
3
4#include <linux/types.h>
5unsigned int hweight32(unsigned int w);
6unsigned long hweight64(__u64 w);
7
8#endif /* PERF_HWEIGHT_H */
diff --git a/tools/perf/util/include/dwarf-regs.h b/tools/perf/util/include/dwarf-regs.h
new file mode 100644
index 00000000000..cf6727e99c4
--- /dev/null
+++ b/tools/perf/util/include/dwarf-regs.h
@@ -0,0 +1,8 @@
1#ifndef _PERF_DWARF_REGS_H_
2#define _PERF_DWARF_REGS_H_
3
4#ifdef DWARF_SUPPORT
5const char *get_arch_regstr(unsigned int n);
6#endif
7
8#endif
diff --git a/tools/perf/util/include/linux/bitmap.h b/tools/perf/util/include/linux/bitmap.h
index 94507639a8c..eda4416efa0 100644
--- a/tools/perf/util/include/linux/bitmap.h
+++ b/tools/perf/util/include/linux/bitmap.h
@@ -1,3 +1,35 @@
1#include "../../../../include/linux/bitmap.h" 1#ifndef _PERF_BITOPS_H
2#include "../../../../include/asm-generic/bitops/find.h" 2#define _PERF_BITOPS_H
3#include <linux/errno.h> 3
4#include <string.h>
5#include <linux/bitops.h>
6
7int __bitmap_weight(const unsigned long *bitmap, int bits);
8
9#define BITMAP_LAST_WORD_MASK(nbits) \
10( \
11 ((nbits) % BITS_PER_LONG) ? \
12 (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL \
13)
14
15#define small_const_nbits(nbits) \
16 (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
17
18static inline void bitmap_zero(unsigned long *dst, int nbits)
19{
20 if (small_const_nbits(nbits))
21 *dst = 0UL;
22 else {
23 int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
24 memset(dst, 0, len);
25 }
26}
27
28static inline int bitmap_weight(const unsigned long *src, int nbits)
29{
30 if (small_const_nbits(nbits))
31 return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
32 return __bitmap_weight(src, nbits);
33}
34
35#endif /* _PERF_BITOPS_H */
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index 8d63116e943..bb4ac2e0538 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -1,13 +1,12 @@
1#ifndef _PERF_LINUX_BITOPS_H_ 1#ifndef _PERF_LINUX_BITOPS_H_
2#define _PERF_LINUX_BITOPS_H_ 2#define _PERF_LINUX_BITOPS_H_
3 3
4#define __KERNEL__ 4#include <linux/kernel.h>
5#include <asm/hweight.h>
5 6
6#define CONFIG_GENERIC_FIND_NEXT_BIT 7#define BITS_PER_LONG __WORDSIZE
7#define CONFIG_GENERIC_FIND_FIRST_BIT 8#define BITS_PER_BYTE 8
8#include "../../../../include/linux/bitops.h" 9#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
9
10#undef __KERNEL__
11 10
12static inline void set_bit(int nr, unsigned long *addr) 11static inline void set_bit(int nr, unsigned long *addr)
13{ 12{
@@ -20,10 +19,9 @@ static __always_inline int test_bit(unsigned int nr, const unsigned long *addr)
20 (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0; 19 (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0;
21} 20}
22 21
23unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned 22static inline unsigned long hweight_long(unsigned long w)
24 long size, unsigned long offset); 23{
25 24 return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
26unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned 25}
27 long size, unsigned long offset);
28 26
29#endif 27#endif
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
index dfb0713ed47..791f9dd27eb 100644
--- a/tools/perf/util/include/linux/compiler.h
+++ b/tools/perf/util/include/linux/compiler.h
@@ -7,4 +7,6 @@
7#define __user 7#define __user
8#define __attribute_const__ 8#define __attribute_const__
9 9
10#define __used __attribute__((__unused__))
11
10#endif 12#endif
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index f2611655ab5..1eb804fd3fb 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -28,6 +28,8 @@
28 (type *)((char *)__mptr - offsetof(type, member)); }) 28 (type *)((char *)__mptr - offsetof(type, member)); })
29#endif 29#endif
30 30
31#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
32
31#ifndef max 33#ifndef max
32#define max(x, y) ({ \ 34#define max(x, y) ({ \
33 typeof(x) _max1 = (x); \ 35 typeof(x) _max1 = (x); \
@@ -85,16 +87,19 @@ simple_strtoul(const char *nptr, char **endptr, int base)
85 return strtoul(nptr, endptr, base); 87 return strtoul(nptr, endptr, base);
86} 88}
87 89
90int eprintf(int level,
91 const char *fmt, ...) __attribute__((format(printf, 2, 3)));
92
88#ifndef pr_fmt 93#ifndef pr_fmt
89#define pr_fmt(fmt) fmt 94#define pr_fmt(fmt) fmt
90#endif 95#endif
91 96
92#define pr_err(fmt, ...) \ 97#define pr_err(fmt, ...) \
93 do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0) 98 eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
94#define pr_warning(fmt, ...) \ 99#define pr_warning(fmt, ...) \
95 do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0) 100 eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
96#define pr_info(fmt, ...) \ 101#define pr_info(fmt, ...) \
97 do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0) 102 eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
98#define pr_debug(fmt, ...) \ 103#define pr_debug(fmt, ...) \
99 eprintf(1, pr_fmt(fmt), ##__VA_ARGS__) 104 eprintf(1, pr_fmt(fmt), ##__VA_ARGS__)
100#define pr_debugN(n, fmt, ...) \ 105#define pr_debugN(n, fmt, ...) \
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index e509cd59c67..e672f2fef65 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -1,9 +1,11 @@
1#include "event.h"
2#include "symbol.h" 1#include "symbol.h"
2#include <errno.h>
3#include <limits.h>
3#include <stdlib.h> 4#include <stdlib.h>
4#include <string.h> 5#include <string.h>
5#include <stdio.h> 6#include <stdio.h>
6#include "debug.h" 7#include <unistd.h>
8#include "map.h"
7 9
8const char *map_type__name[MAP__NR_TYPES] = { 10const char *map_type__name[MAP__NR_TYPES] = {
9 [MAP__FUNCTION] = "Functions", 11 [MAP__FUNCTION] = "Functions",
@@ -36,15 +38,16 @@ void map__init(struct map *self, enum map_type type,
36 self->map_ip = map__map_ip; 38 self->map_ip = map__map_ip;
37 self->unmap_ip = map__unmap_ip; 39 self->unmap_ip = map__unmap_ip;
38 RB_CLEAR_NODE(&self->rb_node); 40 RB_CLEAR_NODE(&self->rb_node);
41 self->groups = NULL;
39} 42}
40 43
41struct map *map__new(struct mmap_event *event, enum map_type type, 44struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
42 char *cwd, int cwdlen) 45 u64 pgoff, u32 pid, char *filename,
46 enum map_type type, char *cwd, int cwdlen)
43{ 47{
44 struct map *self = malloc(sizeof(*self)); 48 struct map *self = malloc(sizeof(*self));
45 49
46 if (self != NULL) { 50 if (self != NULL) {
47 const char *filename = event->filename;
48 char newfilename[PATH_MAX]; 51 char newfilename[PATH_MAX];
49 struct dso *dso; 52 struct dso *dso;
50 int anon; 53 int anon;
@@ -62,16 +65,15 @@ struct map *map__new(struct mmap_event *event, enum map_type type,
62 anon = is_anon_memory(filename); 65 anon = is_anon_memory(filename);
63 66
64 if (anon) { 67 if (anon) {
65 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid); 68 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
66 filename = newfilename; 69 filename = newfilename;
67 } 70 }
68 71
69 dso = dsos__findnew(filename); 72 dso = __dsos__findnew(dsos__list, filename);
70 if (dso == NULL) 73 if (dso == NULL)
71 goto out_delete; 74 goto out_delete;
72 75
73 map__init(self, type, event->start, event->start + event->len, 76 map__init(self, type, start, start + len, pgoff, dso);
74 event->pgoff, dso);
75 77
76 if (anon) { 78 if (anon) {
77set_identity: 79set_identity:
@@ -235,3 +237,392 @@ u64 map__objdump_2ip(struct map *map, u64 addr)
235 map->unmap_ip(map, addr); /* RIP -> IP */ 237 map->unmap_ip(map, addr); /* RIP -> IP */
236 return ip; 238 return ip;
237} 239}
240
241void map_groups__init(struct map_groups *self)
242{
243 int i;
244 for (i = 0; i < MAP__NR_TYPES; ++i) {
245 self->maps[i] = RB_ROOT;
246 INIT_LIST_HEAD(&self->removed_maps[i]);
247 }
248 self->machine = NULL;
249}
250
251void map_groups__flush(struct map_groups *self)
252{
253 int type;
254
255 for (type = 0; type < MAP__NR_TYPES; type++) {
256 struct rb_root *root = &self->maps[type];
257 struct rb_node *next = rb_first(root);
258
259 while (next) {
260 struct map *pos = rb_entry(next, struct map, rb_node);
261 next = rb_next(&pos->rb_node);
262 rb_erase(&pos->rb_node, root);
263 /*
264 * We may have references to this map, for
265 * instance in some hist_entry instances, so
266 * just move them to a separate list.
267 */
268 list_add_tail(&pos->node, &self->removed_maps[pos->type]);
269 }
270 }
271}
272
273struct symbol *map_groups__find_symbol(struct map_groups *self,
274 enum map_type type, u64 addr,
275 struct map **mapp,
276 symbol_filter_t filter)
277{
278 struct map *map = map_groups__find(self, type, addr);
279
280 if (map != NULL) {
281 if (mapp != NULL)
282 *mapp = map;
283 return map__find_symbol(map, map->map_ip(map, addr), filter);
284 }
285
286 return NULL;
287}
288
289struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
290 enum map_type type,
291 const char *name,
292 struct map **mapp,
293 symbol_filter_t filter)
294{
295 struct rb_node *nd;
296
297 for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
298 struct map *pos = rb_entry(nd, struct map, rb_node);
299 struct symbol *sym = map__find_symbol_by_name(pos, name, filter);
300
301 if (sym == NULL)
302 continue;
303 if (mapp != NULL)
304 *mapp = pos;
305 return sym;
306 }
307
308 return NULL;
309}
310
311size_t __map_groups__fprintf_maps(struct map_groups *self,
312 enum map_type type, int verbose, FILE *fp)
313{
314 size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
315 struct rb_node *nd;
316
317 for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
318 struct map *pos = rb_entry(nd, struct map, rb_node);
319 printed += fprintf(fp, "Map:");
320 printed += map__fprintf(pos, fp);
321 if (verbose > 2) {
322 printed += dso__fprintf(pos->dso, type, fp);
323 printed += fprintf(fp, "--\n");
324 }
325 }
326
327 return printed;
328}
329
330size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp)
331{
332 size_t printed = 0, i;
333 for (i = 0; i < MAP__NR_TYPES; ++i)
334 printed += __map_groups__fprintf_maps(self, i, verbose, fp);
335 return printed;
336}
337
338static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
339 enum map_type type,
340 int verbose, FILE *fp)
341{
342 struct map *pos;
343 size_t printed = 0;
344
345 list_for_each_entry(pos, &self->removed_maps[type], node) {
346 printed += fprintf(fp, "Map:");
347 printed += map__fprintf(pos, fp);
348 if (verbose > 1) {
349 printed += dso__fprintf(pos->dso, type, fp);
350 printed += fprintf(fp, "--\n");
351 }
352 }
353 return printed;
354}
355
356static size_t map_groups__fprintf_removed_maps(struct map_groups *self,
357 int verbose, FILE *fp)
358{
359 size_t printed = 0, i;
360 for (i = 0; i < MAP__NR_TYPES; ++i)
361 printed += __map_groups__fprintf_removed_maps(self, i, verbose, fp);
362 return printed;
363}
364
365size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp)
366{
367 size_t printed = map_groups__fprintf_maps(self, verbose, fp);
368 printed += fprintf(fp, "Removed maps:\n");
369 return printed + map_groups__fprintf_removed_maps(self, verbose, fp);
370}
371
372int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
373 int verbose, FILE *fp)
374{
375 struct rb_root *root = &self->maps[map->type];
376 struct rb_node *next = rb_first(root);
377
378 while (next) {
379 struct map *pos = rb_entry(next, struct map, rb_node);
380 next = rb_next(&pos->rb_node);
381
382 if (!map__overlap(pos, map))
383 continue;
384
385 if (verbose >= 2) {
386 fputs("overlapping maps:\n", fp);
387 map__fprintf(map, fp);
388 map__fprintf(pos, fp);
389 }
390
391 rb_erase(&pos->rb_node, root);
392 /*
393 * We may have references to this map, for instance in some
394 * hist_entry instances, so just move them to a separate
395 * list.
396 */
397 list_add_tail(&pos->node, &self->removed_maps[map->type]);
398 /*
399 * Now check if we need to create new maps for areas not
400 * overlapped by the new map:
401 */
402 if (map->start > pos->start) {
403 struct map *before = map__clone(pos);
404
405 if (before == NULL)
406 return -ENOMEM;
407
408 before->end = map->start - 1;
409 map_groups__insert(self, before);
410 if (verbose >= 2)
411 map__fprintf(before, fp);
412 }
413
414 if (map->end < pos->end) {
415 struct map *after = map__clone(pos);
416
417 if (after == NULL)
418 return -ENOMEM;
419
420 after->start = map->end + 1;
421 map_groups__insert(self, after);
422 if (verbose >= 2)
423 map__fprintf(after, fp);
424 }
425 }
426
427 return 0;
428}
429
430/*
431 * XXX This should not really _copy_ te maps, but refcount them.
432 */
433int map_groups__clone(struct map_groups *self,
434 struct map_groups *parent, enum map_type type)
435{
436 struct rb_node *nd;
437 for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
438 struct map *map = rb_entry(nd, struct map, rb_node);
439 struct map *new = map__clone(map);
440 if (new == NULL)
441 return -ENOMEM;
442 map_groups__insert(self, new);
443 }
444 return 0;
445}
446
447static u64 map__reloc_map_ip(struct map *map, u64 ip)
448{
449 return ip + (s64)map->pgoff;
450}
451
452static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
453{
454 return ip - (s64)map->pgoff;
455}
456
457void map__reloc_vmlinux(struct map *self)
458{
459 struct kmap *kmap = map__kmap(self);
460 s64 reloc;
461
462 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
463 return;
464
465 reloc = (kmap->ref_reloc_sym->unrelocated_addr -
466 kmap->ref_reloc_sym->addr);
467
468 if (!reloc)
469 return;
470
471 self->map_ip = map__reloc_map_ip;
472 self->unmap_ip = map__reloc_unmap_ip;
473 self->pgoff = reloc;
474}
475
476void maps__insert(struct rb_root *maps, struct map *map)
477{
478 struct rb_node **p = &maps->rb_node;
479 struct rb_node *parent = NULL;
480 const u64 ip = map->start;
481 struct map *m;
482
483 while (*p != NULL) {
484 parent = *p;
485 m = rb_entry(parent, struct map, rb_node);
486 if (ip < m->start)
487 p = &(*p)->rb_left;
488 else
489 p = &(*p)->rb_right;
490 }
491
492 rb_link_node(&map->rb_node, parent, p);
493 rb_insert_color(&map->rb_node, maps);
494}
495
496struct map *maps__find(struct rb_root *maps, u64 ip)
497{
498 struct rb_node **p = &maps->rb_node;
499 struct rb_node *parent = NULL;
500 struct map *m;
501
502 while (*p != NULL) {
503 parent = *p;
504 m = rb_entry(parent, struct map, rb_node);
505 if (ip < m->start)
506 p = &(*p)->rb_left;
507 else if (ip > m->end)
508 p = &(*p)->rb_right;
509 else
510 return m;
511 }
512
513 return NULL;
514}
515
516int machine__init(struct machine *self, const char *root_dir, pid_t pid)
517{
518 map_groups__init(&self->kmaps);
519 RB_CLEAR_NODE(&self->rb_node);
520 INIT_LIST_HEAD(&self->user_dsos);
521 INIT_LIST_HEAD(&self->kernel_dsos);
522
523 self->kmaps.machine = self;
524 self->pid = pid;
525 self->root_dir = strdup(root_dir);
526 return self->root_dir == NULL ? -ENOMEM : 0;
527}
528
529struct machine *machines__add(struct rb_root *self, pid_t pid,
530 const char *root_dir)
531{
532 struct rb_node **p = &self->rb_node;
533 struct rb_node *parent = NULL;
534 struct machine *pos, *machine = malloc(sizeof(*machine));
535
536 if (!machine)
537 return NULL;
538
539 if (machine__init(machine, root_dir, pid) != 0) {
540 free(machine);
541 return NULL;
542 }
543
544 while (*p != NULL) {
545 parent = *p;
546 pos = rb_entry(parent, struct machine, rb_node);
547 if (pid < pos->pid)
548 p = &(*p)->rb_left;
549 else
550 p = &(*p)->rb_right;
551 }
552
553 rb_link_node(&machine->rb_node, parent, p);
554 rb_insert_color(&machine->rb_node, self);
555
556 return machine;
557}
558
559struct machine *machines__find(struct rb_root *self, pid_t pid)
560{
561 struct rb_node **p = &self->rb_node;
562 struct rb_node *parent = NULL;
563 struct machine *machine;
564 struct machine *default_machine = NULL;
565
566 while (*p != NULL) {
567 parent = *p;
568 machine = rb_entry(parent, struct machine, rb_node);
569 if (pid < machine->pid)
570 p = &(*p)->rb_left;
571 else if (pid > machine->pid)
572 p = &(*p)->rb_right;
573 else
574 return machine;
575 if (!machine->pid)
576 default_machine = machine;
577 }
578
579 return default_machine;
580}
581
582struct machine *machines__findnew(struct rb_root *self, pid_t pid)
583{
584 char path[PATH_MAX];
585 const char *root_dir;
586 struct machine *machine = machines__find(self, pid);
587
588 if (!machine || machine->pid != pid) {
589 if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID)
590 root_dir = "";
591 else {
592 if (!symbol_conf.guestmount)
593 goto out;
594 sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
595 if (access(path, R_OK)) {
596 pr_err("Can't access file %s\n", path);
597 goto out;
598 }
599 root_dir = path;
600 }
601 machine = machines__add(self, pid, root_dir);
602 }
603
604out:
605 return machine;
606}
607
608void machines__process(struct rb_root *self, machine__process_t process, void *data)
609{
610 struct rb_node *nd;
611
612 for (nd = rb_first(self); nd; nd = rb_next(nd)) {
613 struct machine *pos = rb_entry(nd, struct machine, rb_node);
614 process(pos, data);
615 }
616}
617
618char *machine__mmap_name(struct machine *self, char *bf, size_t size)
619{
620 if (machine__is_host(self))
621 snprintf(bf, size, "[%s]", "kernel.kallsyms");
622 else if (machine__is_default_guest(self))
623 snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
624 else
625 snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms", self->pid);
626
627 return bf;
628}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index b756368076c..f3913451282 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -4,7 +4,9 @@
4#include <linux/compiler.h> 4#include <linux/compiler.h>
5#include <linux/list.h> 5#include <linux/list.h>
6#include <linux/rbtree.h> 6#include <linux/rbtree.h>
7#include <linux/types.h> 7#include <stdio.h>
8#include <stdbool.h>
9#include "types.h"
8 10
9enum map_type { 11enum map_type {
10 MAP__FUNCTION = 0, 12 MAP__FUNCTION = 0,
@@ -18,6 +20,7 @@ extern const char *map_type__name[MAP__NR_TYPES];
18struct dso; 20struct dso;
19struct ref_reloc_sym; 21struct ref_reloc_sym;
20struct map_groups; 22struct map_groups;
23struct machine;
21 24
22struct map { 25struct map {
23 union { 26 union {
@@ -27,6 +30,7 @@ struct map {
27 u64 start; 30 u64 start;
28 u64 end; 31 u64 end;
29 enum map_type type; 32 enum map_type type;
33 u32 priv;
30 u64 pgoff; 34 u64 pgoff;
31 35
32 /* ip -> dso rip */ 36 /* ip -> dso rip */
@@ -35,6 +39,7 @@ struct map {
35 u64 (*unmap_ip)(struct map *, u64); 39 u64 (*unmap_ip)(struct map *, u64);
36 40
37 struct dso *dso; 41 struct dso *dso;
42 struct map_groups *groups;
38}; 43};
39 44
40struct kmap { 45struct kmap {
@@ -42,6 +47,32 @@ struct kmap {
42 struct map_groups *kmaps; 47 struct map_groups *kmaps;
43}; 48};
44 49
50struct map_groups {
51 struct rb_root maps[MAP__NR_TYPES];
52 struct list_head removed_maps[MAP__NR_TYPES];
53 struct machine *machine;
54};
55
56/* Native host kernel uses -1 as pid index in machine */
57#define HOST_KERNEL_ID (-1)
58#define DEFAULT_GUEST_KERNEL_ID (0)
59
60struct machine {
61 struct rb_node rb_node;
62 pid_t pid;
63 char *root_dir;
64 struct list_head user_dsos;
65 struct list_head kernel_dsos;
66 struct map_groups kmaps;
67 struct map *vmlinux_maps[MAP__NR_TYPES];
68};
69
70static inline
71struct map *machine__kernel_map(struct machine *self, enum map_type type)
72{
73 return self->vmlinux_maps[type];
74}
75
45static inline struct kmap *map__kmap(struct map *self) 76static inline struct kmap *map__kmap(struct map *self)
46{ 77{
47 return (struct kmap *)(self + 1); 78 return (struct kmap *)(self + 1);
@@ -68,14 +99,14 @@ u64 map__rip_2objdump(struct map *map, u64 rip);
68u64 map__objdump_2ip(struct map *map, u64 addr); 99u64 map__objdump_2ip(struct map *map, u64 addr);
69 100
70struct symbol; 101struct symbol;
71struct mmap_event;
72 102
73typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym); 103typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
74 104
75void map__init(struct map *self, enum map_type type, 105void map__init(struct map *self, enum map_type type,
76 u64 start, u64 end, u64 pgoff, struct dso *dso); 106 u64 start, u64 end, u64 pgoff, struct dso *dso);
77struct map *map__new(struct mmap_event *event, enum map_type, 107struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
78 char *cwd, int cwdlen); 108 u64 pgoff, u32 pid, char *filename,
109 enum map_type type, char *cwd, int cwdlen);
79void map__delete(struct map *self); 110void map__delete(struct map *self);
80struct map *map__clone(struct map *self); 111struct map *map__clone(struct map *self);
81int map__overlap(struct map *l, struct map *r); 112int map__overlap(struct map *l, struct map *r);
@@ -91,4 +122,96 @@ void map__fixup_end(struct map *self);
91 122
92void map__reloc_vmlinux(struct map *self); 123void map__reloc_vmlinux(struct map *self);
93 124
125size_t __map_groups__fprintf_maps(struct map_groups *self,
126 enum map_type type, int verbose, FILE *fp);
127void maps__insert(struct rb_root *maps, struct map *map);
128struct map *maps__find(struct rb_root *maps, u64 addr);
129void map_groups__init(struct map_groups *self);
130int map_groups__clone(struct map_groups *self,
131 struct map_groups *parent, enum map_type type);
132size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
133size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp);
134
135typedef void (*machine__process_t)(struct machine *self, void *data);
136
137void machines__process(struct rb_root *self, machine__process_t process, void *data);
138struct machine *machines__add(struct rb_root *self, pid_t pid,
139 const char *root_dir);
140struct machine *machines__find_host(struct rb_root *self);
141struct machine *machines__find(struct rb_root *self, pid_t pid);
142struct machine *machines__findnew(struct rb_root *self, pid_t pid);
143char *machine__mmap_name(struct machine *self, char *bf, size_t size);
144int machine__init(struct machine *self, const char *root_dir, pid_t pid);
145
146/*
147 * Default guest kernel is defined by parameter --guestkallsyms
148 * and --guestmodules
149 */
150static inline bool machine__is_default_guest(struct machine *self)
151{
152 return self ? self->pid == DEFAULT_GUEST_KERNEL_ID : false;
153}
154
155static inline bool machine__is_host(struct machine *self)
156{
157 return self ? self->pid == HOST_KERNEL_ID : false;
158}
159
160static inline void map_groups__insert(struct map_groups *self, struct map *map)
161{
162 maps__insert(&self->maps[map->type], map);
163 map->groups = self;
164}
165
166static inline struct map *map_groups__find(struct map_groups *self,
167 enum map_type type, u64 addr)
168{
169 return maps__find(&self->maps[type], addr);
170}
171
172struct symbol *map_groups__find_symbol(struct map_groups *self,
173 enum map_type type, u64 addr,
174 struct map **mapp,
175 symbol_filter_t filter);
176
177struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
178 enum map_type type,
179 const char *name,
180 struct map **mapp,
181 symbol_filter_t filter);
182
183static inline
184struct symbol *machine__find_kernel_symbol(struct machine *self,
185 enum map_type type, u64 addr,
186 struct map **mapp,
187 symbol_filter_t filter)
188{
189 return map_groups__find_symbol(&self->kmaps, type, addr, mapp, filter);
190}
191
192static inline
193struct symbol *machine__find_kernel_function(struct machine *self, u64 addr,
194 struct map **mapp,
195 symbol_filter_t filter)
196{
197 return machine__find_kernel_symbol(self, MAP__FUNCTION, addr, mapp, filter);
198}
199
200static inline
201struct symbol *map_groups__find_function_by_name(struct map_groups *self,
202 const char *name, struct map **mapp,
203 symbol_filter_t filter)
204{
205 return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter);
206}
207
208int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
209 int verbose, FILE *fp);
210
211struct map *map_groups__find_by_name(struct map_groups *self,
212 enum map_type type, const char *name);
213struct map *machine__new_module(struct machine *self, u64 start, const char *filename);
214
215void map_groups__flush(struct map_groups *self);
216
94#endif /* __PERF_MAP_H */ 217#endif /* __PERF_MAP_H */
diff --git a/tools/perf/util/newt.c b/tools/perf/util/newt.c
new file mode 100644
index 00000000000..7537ca15900
--- /dev/null
+++ b/tools/perf/util/newt.c
@@ -0,0 +1,1178 @@
1#define _GNU_SOURCE
2#include <stdio.h>
3#undef _GNU_SOURCE
4/*
5 * slang versions <= 2.0.6 have a "#if HAVE_LONG_LONG" that breaks
6 * the build if it isn't defined. Use the equivalent one that glibc
7 * has on features.h.
8 */
9#include <features.h>
10#ifndef HAVE_LONG_LONG
11#define HAVE_LONG_LONG __GLIBC_HAVE_LONG_LONG
12#endif
13#include <slang.h>
14#include <stdlib.h>
15#include <newt.h>
16#include <sys/ttydefaults.h>
17
18#include "cache.h"
19#include "hist.h"
20#include "pstack.h"
21#include "session.h"
22#include "sort.h"
23#include "symbol.h"
24
25#if SLANG_VERSION < 20104
26#define slsmg_printf(msg, args...) SLsmg_printf((char *)msg, ##args)
27#define slsmg_write_nstring(msg, len) SLsmg_write_nstring((char *)msg, len)
28#define sltt_set_color(obj, name, fg, bg) SLtt_set_color(obj,(char *)name,\
29 (char *)fg, (char *)bg)
30#else
31#define slsmg_printf SLsmg_printf
32#define slsmg_write_nstring SLsmg_write_nstring
33#define sltt_set_color SLtt_set_color
34#endif
35
36struct ui_progress {
37 newtComponent form, scale;
38};
39
40struct ui_progress *ui_progress__new(const char *title, u64 total)
41{
42 struct ui_progress *self = malloc(sizeof(*self));
43
44 if (self != NULL) {
45 int cols;
46
47 if (use_browser <= 0)
48 return self;
49 newtGetScreenSize(&cols, NULL);
50 cols -= 4;
51 newtCenteredWindow(cols, 1, title);
52 self->form = newtForm(NULL, NULL, 0);
53 if (self->form == NULL)
54 goto out_free_self;
55 self->scale = newtScale(0, 0, cols, total);
56 if (self->scale == NULL)
57 goto out_free_form;
58 newtFormAddComponent(self->form, self->scale);
59 newtRefresh();
60 }
61
62 return self;
63
64out_free_form:
65 newtFormDestroy(self->form);
66out_free_self:
67 free(self);
68 return NULL;
69}
70
71void ui_progress__update(struct ui_progress *self, u64 curr)
72{
73 /*
74 * FIXME: We should have a per UI backend way of showing progress,
75 * stdio will just show a percentage as NN%, etc.
76 */
77 if (use_browser <= 0)
78 return;
79 newtScaleSet(self->scale, curr);
80 newtRefresh();
81}
82
83void ui_progress__delete(struct ui_progress *self)
84{
85 if (use_browser > 0) {
86 newtFormDestroy(self->form);
87 newtPopWindow();
88 }
89 free(self);
90}
91
92static void ui_helpline__pop(void)
93{
94 newtPopHelpLine();
95}
96
97static void ui_helpline__push(const char *msg)
98{
99 newtPushHelpLine(msg);
100}
101
102static void ui_helpline__vpush(const char *fmt, va_list ap)
103{
104 char *s;
105
106 if (vasprintf(&s, fmt, ap) < 0)
107 vfprintf(stderr, fmt, ap);
108 else {
109 ui_helpline__push(s);
110 free(s);
111 }
112}
113
114static void ui_helpline__fpush(const char *fmt, ...)
115{
116 va_list ap;
117
118 va_start(ap, fmt);
119 ui_helpline__vpush(fmt, ap);
120 va_end(ap);
121}
122
123static void ui_helpline__puts(const char *msg)
124{
125 ui_helpline__pop();
126 ui_helpline__push(msg);
127}
128
129static char browser__last_msg[1024];
130
131int browser__show_help(const char *format, va_list ap)
132{
133 int ret;
134 static int backlog;
135
136 ret = vsnprintf(browser__last_msg + backlog,
137 sizeof(browser__last_msg) - backlog, format, ap);
138 backlog += ret;
139
140 if (browser__last_msg[backlog - 1] == '\n') {
141 ui_helpline__puts(browser__last_msg);
142 newtRefresh();
143 backlog = 0;
144 }
145
146 return ret;
147}
148
149static void newt_form__set_exit_keys(newtComponent self)
150{
151 newtFormAddHotKey(self, NEWT_KEY_LEFT);
152 newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
153 newtFormAddHotKey(self, 'Q');
154 newtFormAddHotKey(self, 'q');
155 newtFormAddHotKey(self, CTRL('c'));
156}
157
158static newtComponent newt_form__new(void)
159{
160 newtComponent self = newtForm(NULL, NULL, 0);
161 if (self)
162 newt_form__set_exit_keys(self);
163 return self;
164}
165
166static int popup_menu(int argc, char * const argv[])
167{
168 struct newtExitStruct es;
169 int i, rc = -1, max_len = 5;
170 newtComponent listbox, form = newt_form__new();
171
172 if (form == NULL)
173 return -1;
174
175 listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
176 if (listbox == NULL)
177 goto out_destroy_form;
178
179 newtFormAddComponent(form, listbox);
180
181 for (i = 0; i < argc; ++i) {
182 int len = strlen(argv[i]);
183 if (len > max_len)
184 max_len = len;
185 if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
186 goto out_destroy_form;
187 }
188
189 newtCenteredWindow(max_len, argc, NULL);
190 newtFormRun(form, &es);
191 rc = newtListboxGetCurrent(listbox) - NULL;
192 if (es.reason == NEWT_EXIT_HOTKEY)
193 rc = -1;
194 newtPopWindow();
195out_destroy_form:
196 newtFormDestroy(form);
197 return rc;
198}
199
200static int ui__help_window(const char *text)
201{
202 struct newtExitStruct es;
203 newtComponent tb, form = newt_form__new();
204 int rc = -1;
205 int max_len = 0, nr_lines = 0;
206 const char *t;
207
208 if (form == NULL)
209 return -1;
210
211 t = text;
212 while (1) {
213 const char *sep = strchr(t, '\n');
214 int len;
215
216 if (sep == NULL)
217 sep = strchr(t, '\0');
218 len = sep - t;
219 if (max_len < len)
220 max_len = len;
221 ++nr_lines;
222 if (*sep == '\0')
223 break;
224 t = sep + 1;
225 }
226
227 tb = newtTextbox(0, 0, max_len, nr_lines, 0);
228 if (tb == NULL)
229 goto out_destroy_form;
230
231 newtTextboxSetText(tb, text);
232 newtFormAddComponent(form, tb);
233 newtCenteredWindow(max_len, nr_lines, NULL);
234 newtFormRun(form, &es);
235 newtPopWindow();
236 rc = 0;
237out_destroy_form:
238 newtFormDestroy(form);
239 return rc;
240}
241
242static bool dialog_yesno(const char *msg)
243{
244 /* newtWinChoice should really be accepting const char pointers... */
245 char yes[] = "Yes", no[] = "No";
246 return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
247}
248
249static void ui__error_window(const char *fmt, ...)
250{
251 va_list ap;
252
253 va_start(ap, fmt);
254 newtWinMessagev((char *)"Error", (char *)"Ok", (char *)fmt, ap);
255 va_end(ap);
256}
257
258#define HE_COLORSET_TOP 50
259#define HE_COLORSET_MEDIUM 51
260#define HE_COLORSET_NORMAL 52
261#define HE_COLORSET_SELECTED 53
262#define HE_COLORSET_CODE 54
263
264static int ui_browser__percent_color(double percent, bool current)
265{
266 if (current)
267 return HE_COLORSET_SELECTED;
268 if (percent >= MIN_RED)
269 return HE_COLORSET_TOP;
270 if (percent >= MIN_GREEN)
271 return HE_COLORSET_MEDIUM;
272 return HE_COLORSET_NORMAL;
273}
274
275struct ui_browser {
276 newtComponent form, sb;
277 u64 index, first_visible_entry_idx;
278 void *first_visible_entry, *entries;
279 u16 top, left, width, height;
280 void *priv;
281 u32 nr_entries;
282};
283
284static void ui_browser__refresh_dimensions(struct ui_browser *self)
285{
286 int cols, rows;
287 newtGetScreenSize(&cols, &rows);
288
289 if (self->width > cols - 4)
290 self->width = cols - 4;
291 self->height = rows - 5;
292 if (self->height > self->nr_entries)
293 self->height = self->nr_entries;
294 self->top = (rows - self->height) / 2;
295 self->left = (cols - self->width) / 2;
296}
297
298static void ui_browser__reset_index(struct ui_browser *self)
299{
300 self->index = self->first_visible_entry_idx = 0;
301 self->first_visible_entry = NULL;
302}
303
304static int objdump_line__show(struct objdump_line *self, struct list_head *head,
305 int width, struct hist_entry *he, int len,
306 bool current_entry)
307{
308 if (self->offset != -1) {
309 struct symbol *sym = he->ms.sym;
310 unsigned int hits = 0;
311 double percent = 0.0;
312 int color;
313 struct sym_priv *priv = symbol__priv(sym);
314 struct sym_ext *sym_ext = priv->ext;
315 struct sym_hist *h = priv->hist;
316 s64 offset = self->offset;
317 struct objdump_line *next = objdump__get_next_ip_line(head, self);
318
319 while (offset < (s64)len &&
320 (next == NULL || offset < next->offset)) {
321 if (sym_ext) {
322 percent += sym_ext[offset].percent;
323 } else
324 hits += h->ip[offset];
325
326 ++offset;
327 }
328
329 if (sym_ext == NULL && h->sum)
330 percent = 100.0 * hits / h->sum;
331
332 color = ui_browser__percent_color(percent, current_entry);
333 SLsmg_set_color(color);
334 slsmg_printf(" %7.2f ", percent);
335 if (!current_entry)
336 SLsmg_set_color(HE_COLORSET_CODE);
337 } else {
338 int color = ui_browser__percent_color(0, current_entry);
339 SLsmg_set_color(color);
340 slsmg_write_nstring(" ", 9);
341 }
342
343 SLsmg_write_char(':');
344 slsmg_write_nstring(" ", 8);
345 if (!*self->line)
346 slsmg_write_nstring(" ", width - 18);
347 else
348 slsmg_write_nstring(self->line, width - 18);
349
350 return 0;
351}
352
353static int ui_browser__refresh_entries(struct ui_browser *self)
354{
355 struct objdump_line *pos;
356 struct list_head *head = self->entries;
357 struct hist_entry *he = self->priv;
358 int row = 0;
359 int len = he->ms.sym->end - he->ms.sym->start;
360
361 if (self->first_visible_entry == NULL || self->first_visible_entry == self->entries)
362 self->first_visible_entry = head->next;
363
364 pos = list_entry(self->first_visible_entry, struct objdump_line, node);
365
366 list_for_each_entry_from(pos, head, node) {
367 bool current_entry = (self->first_visible_entry_idx + row) == self->index;
368 SLsmg_gotorc(self->top + row, self->left);
369 objdump_line__show(pos, head, self->width,
370 he, len, current_entry);
371 if (++row == self->height)
372 break;
373 }
374
375 SLsmg_set_color(HE_COLORSET_NORMAL);
376 SLsmg_fill_region(self->top + row, self->left,
377 self->height - row, self->width, ' ');
378
379 return 0;
380}
381
382static int ui_browser__run(struct ui_browser *self, const char *title,
383 struct newtExitStruct *es)
384{
385 if (self->form) {
386 newtFormDestroy(self->form);
387 newtPopWindow();
388 }
389
390 ui_browser__refresh_dimensions(self);
391 newtCenteredWindow(self->width + 2, self->height, title);
392 self->form = newt_form__new();
393 if (self->form == NULL)
394 return -1;
395
396 self->sb = newtVerticalScrollbar(self->width + 1, 0, self->height,
397 HE_COLORSET_NORMAL,
398 HE_COLORSET_SELECTED);
399 if (self->sb == NULL)
400 return -1;
401
402 newtFormAddHotKey(self->form, NEWT_KEY_UP);
403 newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
404 newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
405 newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
406 newtFormAddHotKey(self->form, ' ');
407 newtFormAddHotKey(self->form, NEWT_KEY_HOME);
408 newtFormAddHotKey(self->form, NEWT_KEY_END);
409 newtFormAddHotKey(self->form, NEWT_KEY_TAB);
410 newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
411
412 if (ui_browser__refresh_entries(self) < 0)
413 return -1;
414 newtFormAddComponent(self->form, self->sb);
415
416 while (1) {
417 unsigned int offset;
418
419 newtFormRun(self->form, es);
420
421 if (es->reason != NEWT_EXIT_HOTKEY)
422 break;
423 if (is_exit_key(es->u.key))
424 return es->u.key;
425 switch (es->u.key) {
426 case NEWT_KEY_DOWN:
427 if (self->index == self->nr_entries - 1)
428 break;
429 ++self->index;
430 if (self->index == self->first_visible_entry_idx + self->height) {
431 struct list_head *pos = self->first_visible_entry;
432 ++self->first_visible_entry_idx;
433 self->first_visible_entry = pos->next;
434 }
435 break;
436 case NEWT_KEY_UP:
437 if (self->index == 0)
438 break;
439 --self->index;
440 if (self->index < self->first_visible_entry_idx) {
441 struct list_head *pos = self->first_visible_entry;
442 --self->first_visible_entry_idx;
443 self->first_visible_entry = pos->prev;
444 }
445 break;
446 case NEWT_KEY_PGDN:
447 case ' ':
448 if (self->first_visible_entry_idx + self->height > self->nr_entries - 1)
449 break;
450
451 offset = self->height;
452 if (self->index + offset > self->nr_entries - 1)
453 offset = self->nr_entries - 1 - self->index;
454 self->index += offset;
455 self->first_visible_entry_idx += offset;
456
457 while (offset--) {
458 struct list_head *pos = self->first_visible_entry;
459 self->first_visible_entry = pos->next;
460 }
461
462 break;
463 case NEWT_KEY_PGUP:
464 if (self->first_visible_entry_idx == 0)
465 break;
466
467 if (self->first_visible_entry_idx < self->height)
468 offset = self->first_visible_entry_idx;
469 else
470 offset = self->height;
471
472 self->index -= offset;
473 self->first_visible_entry_idx -= offset;
474
475 while (offset--) {
476 struct list_head *pos = self->first_visible_entry;
477 self->first_visible_entry = pos->prev;
478 }
479 break;
480 case NEWT_KEY_HOME:
481 ui_browser__reset_index(self);
482 break;
483 case NEWT_KEY_END: {
484 struct list_head *head = self->entries;
485 offset = self->height - 1;
486
487 if (offset > self->nr_entries)
488 offset = self->nr_entries;
489
490 self->index = self->first_visible_entry_idx = self->nr_entries - 1 - offset;
491 self->first_visible_entry = head->prev;
492 while (offset-- != 0) {
493 struct list_head *pos = self->first_visible_entry;
494 self->first_visible_entry = pos->prev;
495 }
496 }
497 break;
498 case NEWT_KEY_RIGHT:
499 case NEWT_KEY_LEFT:
500 case NEWT_KEY_TAB:
501 return es->u.key;
502 default:
503 continue;
504 }
505 if (ui_browser__refresh_entries(self) < 0)
506 return -1;
507 }
508 return 0;
509}
510
511/*
512 * When debugging newt problems it was useful to be able to "unroll"
513 * the calls to newtCheckBoxTreeAdd{Array,Item}, so that we can generate
514 * a source file with the sequence of calls to these methods, to then
515 * tweak the arrays to get the intended results, so I'm keeping this code
516 * here, may be useful again in the future.
517 */
518#undef NEWT_DEBUG
519
520static void newt_checkbox_tree__add(newtComponent tree, const char *str,
521 void *priv, int *indexes)
522{
523#ifdef NEWT_DEBUG
524 /* Print the newtCheckboxTreeAddArray to tinker with its index arrays */
525 int i = 0, len = 40 - strlen(str);
526
527 fprintf(stderr,
528 "\tnewtCheckboxTreeAddItem(tree, %*.*s\"%s\", (void *)%p, 0, ",
529 len, len, " ", str, priv);
530 while (indexes[i] != NEWT_ARG_LAST) {
531 if (indexes[i] != NEWT_ARG_APPEND)
532 fprintf(stderr, " %d,", indexes[i]);
533 else
534 fprintf(stderr, " %s,", "NEWT_ARG_APPEND");
535 ++i;
536 }
537 fprintf(stderr, " %s", " NEWT_ARG_LAST);\n");
538 fflush(stderr);
539#endif
540 newtCheckboxTreeAddArray(tree, str, priv, 0, indexes);
541}
542
543static char *callchain_list__sym_name(struct callchain_list *self,
544 char *bf, size_t bfsize)
545{
546 if (self->ms.sym)
547 return self->ms.sym->name;
548
549 snprintf(bf, bfsize, "%#Lx", self->ip);
550 return bf;
551}
552
553static void __callchain__append_graph_browser(struct callchain_node *self,
554 newtComponent tree, u64 total,
555 int *indexes, int depth)
556{
557 struct rb_node *node;
558 u64 new_total, remaining;
559 int idx = 0;
560
561 if (callchain_param.mode == CHAIN_GRAPH_REL)
562 new_total = self->children_hit;
563 else
564 new_total = total;
565
566 remaining = new_total;
567 node = rb_first(&self->rb_root);
568 while (node) {
569 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
570 struct rb_node *next = rb_next(node);
571 u64 cumul = cumul_hits(child);
572 struct callchain_list *chain;
573 int first = true, printed = 0;
574 int chain_idx = -1;
575 remaining -= cumul;
576
577 indexes[depth] = NEWT_ARG_APPEND;
578 indexes[depth + 1] = NEWT_ARG_LAST;
579
580 list_for_each_entry(chain, &child->val, list) {
581 char ipstr[BITS_PER_LONG / 4 + 1],
582 *alloc_str = NULL;
583 const char *str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
584
585 if (first) {
586 double percent = cumul * 100.0 / new_total;
587
588 first = false;
589 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
590 str = "Not enough memory!";
591 else
592 str = alloc_str;
593 } else {
594 indexes[depth] = idx;
595 indexes[depth + 1] = NEWT_ARG_APPEND;
596 indexes[depth + 2] = NEWT_ARG_LAST;
597 ++chain_idx;
598 }
599 newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
600 free(alloc_str);
601 ++printed;
602 }
603
604 indexes[depth] = idx;
605 if (chain_idx != -1)
606 indexes[depth + 1] = chain_idx;
607 if (printed != 0)
608 ++idx;
609 __callchain__append_graph_browser(child, tree, new_total, indexes,
610 depth + (chain_idx != -1 ? 2 : 1));
611 node = next;
612 }
613}
614
615static void callchain__append_graph_browser(struct callchain_node *self,
616 newtComponent tree, u64 total,
617 int *indexes, int parent_idx)
618{
619 struct callchain_list *chain;
620 int i = 0;
621
622 indexes[1] = NEWT_ARG_APPEND;
623 indexes[2] = NEWT_ARG_LAST;
624
625 list_for_each_entry(chain, &self->val, list) {
626 char ipstr[BITS_PER_LONG / 4 + 1], *str;
627
628 if (chain->ip >= PERF_CONTEXT_MAX)
629 continue;
630
631 if (!i++ && sort__first_dimension == SORT_SYM)
632 continue;
633
634 str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
635 newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
636 }
637
638 indexes[1] = parent_idx;
639 indexes[2] = NEWT_ARG_APPEND;
640 indexes[3] = NEWT_ARG_LAST;
641 __callchain__append_graph_browser(self, tree, total, indexes, 2);
642}
643
644static void hist_entry__append_callchain_browser(struct hist_entry *self,
645 newtComponent tree, u64 total, int parent_idx)
646{
647 struct rb_node *rb_node;
648 int indexes[1024] = { [0] = parent_idx, };
649 int idx = 0;
650 struct callchain_node *chain;
651
652 rb_node = rb_first(&self->sorted_chain);
653 while (rb_node) {
654 chain = rb_entry(rb_node, struct callchain_node, rb_node);
655 switch (callchain_param.mode) {
656 case CHAIN_FLAT:
657 break;
658 case CHAIN_GRAPH_ABS: /* falldown */
659 case CHAIN_GRAPH_REL:
660 callchain__append_graph_browser(chain, tree, total, indexes, idx++);
661 break;
662 case CHAIN_NONE:
663 default:
664 break;
665 }
666 rb_node = rb_next(rb_node);
667 }
668}
669
670static size_t hist_entry__append_browser(struct hist_entry *self,
671 newtComponent tree, u64 total)
672{
673 char s[256];
674 size_t ret;
675
676 if (symbol_conf.exclude_other && !self->parent)
677 return 0;
678
679 ret = hist_entry__snprintf(self, s, sizeof(s), NULL,
680 false, 0, false, total);
681 if (symbol_conf.use_callchain) {
682 int indexes[2];
683
684 indexes[0] = NEWT_ARG_APPEND;
685 indexes[1] = NEWT_ARG_LAST;
686 newt_checkbox_tree__add(tree, s, &self->ms, indexes);
687 } else
688 newtListboxAppendEntry(tree, s, &self->ms);
689
690 return ret;
691}
692
693int hist_entry__tui_annotate(struct hist_entry *self)
694{
695 struct ui_browser browser;
696 struct newtExitStruct es;
697 struct objdump_line *pos, *n;
698 LIST_HEAD(head);
699 int ret;
700
701 if (self->ms.sym == NULL)
702 return -1;
703
704 if (self->ms.map->dso->annotate_warned)
705 return -1;
706
707 if (hist_entry__annotate(self, &head) < 0) {
708 ui__error_window(browser__last_msg);
709 return -1;
710 }
711
712 ui_helpline__push("Press <- or ESC to exit");
713
714 memset(&browser, 0, sizeof(browser));
715 browser.entries = &head;
716 browser.priv = self;
717 list_for_each_entry(pos, &head, node) {
718 size_t line_len = strlen(pos->line);
719 if (browser.width < line_len)
720 browser.width = line_len;
721 ++browser.nr_entries;
722 }
723
724 browser.width += 18; /* Percentage */
725 ret = ui_browser__run(&browser, self->ms.sym->name, &es);
726 newtFormDestroy(browser.form);
727 newtPopWindow();
728 list_for_each_entry_safe(pos, n, &head, node) {
729 list_del(&pos->node);
730 objdump_line__free(pos);
731 }
732 ui_helpline__pop();
733 return ret;
734}
735
736static const void *newt__symbol_tree_get_current(newtComponent self)
737{
738 if (symbol_conf.use_callchain)
739 return newtCheckboxTreeGetCurrent(self);
740 return newtListboxGetCurrent(self);
741}
742
743static void hist_browser__selection(newtComponent self, void *data)
744{
745 const struct map_symbol **symbol_ptr = data;
746 *symbol_ptr = newt__symbol_tree_get_current(self);
747}
748
749struct hist_browser {
750 newtComponent form, tree;
751 const struct map_symbol *selection;
752};
753
754static struct hist_browser *hist_browser__new(void)
755{
756 struct hist_browser *self = malloc(sizeof(*self));
757
758 if (self != NULL)
759 self->form = NULL;
760
761 return self;
762}
763
764static void hist_browser__delete(struct hist_browser *self)
765{
766 newtFormDestroy(self->form);
767 newtPopWindow();
768 free(self);
769}
770
771static int hist_browser__populate(struct hist_browser *self, struct hists *hists,
772 const char *title)
773{
774 int max_len = 0, idx, cols, rows;
775 struct ui_progress *progress;
776 struct rb_node *nd;
777 u64 curr_hist = 0;
778 char seq[] = ".", unit;
779 char str[256];
780 unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
781
782 if (self->form) {
783 newtFormDestroy(self->form);
784 newtPopWindow();
785 }
786
787 nr_events = convert_unit(nr_events, &unit);
788 snprintf(str, sizeof(str), "Events: %lu%c ",
789 nr_events, unit);
790 newtDrawRootText(0, 0, str);
791
792 newtGetScreenSize(NULL, &rows);
793
794 if (symbol_conf.use_callchain)
795 self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
796 NEWT_FLAG_SCROLL);
797 else
798 self->tree = newtListbox(0, 0, rows - 5,
799 (NEWT_FLAG_SCROLL |
800 NEWT_FLAG_RETURNEXIT));
801
802 newtComponentAddCallback(self->tree, hist_browser__selection,
803 &self->selection);
804
805 progress = ui_progress__new("Adding entries to the browser...",
806 hists->nr_entries);
807 if (progress == NULL)
808 return -1;
809
810 idx = 0;
811 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
812 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
813 int len;
814
815 if (h->filtered)
816 continue;
817
818 len = hist_entry__append_browser(h, self->tree, hists->stats.total_period);
819 if (len > max_len)
820 max_len = len;
821 if (symbol_conf.use_callchain)
822 hist_entry__append_callchain_browser(h, self->tree,
823 hists->stats.total_period, idx++);
824 ++curr_hist;
825 if (curr_hist % 5)
826 ui_progress__update(progress, curr_hist);
827 }
828
829 ui_progress__delete(progress);
830
831 newtGetScreenSize(&cols, &rows);
832
833 if (max_len > cols)
834 max_len = cols - 3;
835
836 if (!symbol_conf.use_callchain)
837 newtListboxSetWidth(self->tree, max_len);
838
839 newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
840 rows - 5, title);
841 self->form = newt_form__new();
842 if (self->form == NULL)
843 return -1;
844
845 newtFormAddHotKey(self->form, 'A');
846 newtFormAddHotKey(self->form, 'a');
847 newtFormAddHotKey(self->form, 'D');
848 newtFormAddHotKey(self->form, 'd');
849 newtFormAddHotKey(self->form, 'T');
850 newtFormAddHotKey(self->form, 't');
851 newtFormAddHotKey(self->form, '?');
852 newtFormAddHotKey(self->form, 'H');
853 newtFormAddHotKey(self->form, 'h');
854 newtFormAddHotKey(self->form, NEWT_KEY_F1);
855 newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
856 newtFormAddHotKey(self->form, NEWT_KEY_TAB);
857 newtFormAddHotKey(self->form, NEWT_KEY_UNTAB);
858 newtFormAddComponents(self->form, self->tree, NULL);
859 self->selection = newt__symbol_tree_get_current(self->tree);
860
861 return 0;
862}
863
864static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
865{
866 int *indexes;
867
868 if (!symbol_conf.use_callchain)
869 goto out;
870
871 indexes = newtCheckboxTreeFindItem(self->tree, (void *)self->selection);
872 if (indexes) {
873 bool is_hist_entry = indexes[1] == NEWT_ARG_LAST;
874 free(indexes);
875 if (is_hist_entry)
876 goto out;
877 }
878 return NULL;
879out:
880 return container_of(self->selection, struct hist_entry, ms);
881}
882
883static struct thread *hist_browser__selected_thread(struct hist_browser *self)
884{
885 struct hist_entry *he = hist_browser__selected_entry(self);
886 return he ? he->thread : NULL;
887}
888
889static int hist_browser__title(char *bf, size_t size, const char *ev_name,
890 const struct dso *dso, const struct thread *thread)
891{
892 int printed = 0;
893
894 if (thread)
895 printed += snprintf(bf + printed, size - printed,
896 "Thread: %s(%d)",
897 (thread->comm_set ? thread->comm : ""),
898 thread->pid);
899 if (dso)
900 printed += snprintf(bf + printed, size - printed,
901 "%sDSO: %s", thread ? " " : "",
902 dso->short_name);
903 return printed ?: snprintf(bf, size, "Event: %s", ev_name);
904}
905
906int hists__browse(struct hists *self, const char *helpline, const char *ev_name)
907{
908 struct hist_browser *browser = hist_browser__new();
909 struct pstack *fstack;
910 const struct thread *thread_filter = NULL;
911 const struct dso *dso_filter = NULL;
912 struct newtExitStruct es;
913 char msg[160];
914 int key = -1;
915
916 if (browser == NULL)
917 return -1;
918
919 fstack = pstack__new(2);
920 if (fstack == NULL)
921 goto out;
922
923 ui_helpline__push(helpline);
924
925 hist_browser__title(msg, sizeof(msg), ev_name,
926 dso_filter, thread_filter);
927 if (hist_browser__populate(browser, self, msg) < 0)
928 goto out_free_stack;
929
930 while (1) {
931 const struct thread *thread;
932 const struct dso *dso;
933 char *options[16];
934 int nr_options = 0, choice = 0, i,
935 annotate = -2, zoom_dso = -2, zoom_thread = -2;
936
937 newtFormRun(browser->form, &es);
938
939 thread = hist_browser__selected_thread(browser);
940 dso = browser->selection->map ? browser->selection->map->dso : NULL;
941
942 if (es.reason == NEWT_EXIT_HOTKEY) {
943 key = es.u.key;
944
945 switch (key) {
946 case NEWT_KEY_F1:
947 goto do_help;
948 case NEWT_KEY_TAB:
949 case NEWT_KEY_UNTAB:
950 /*
951 * Exit the browser, let hists__browser_tree
952 * go to the next or previous
953 */
954 goto out_free_stack;
955 default:;
956 }
957
958 key = toupper(key);
959 switch (key) {
960 case 'A':
961 if (browser->selection->map == NULL &&
962 browser->selection->map->dso->annotate_warned)
963 continue;
964 goto do_annotate;
965 case 'D':
966 goto zoom_dso;
967 case 'T':
968 goto zoom_thread;
969 case 'H':
970 case '?':
971do_help:
972 ui__help_window("-> Zoom into DSO/Threads & Annotate current symbol\n"
973 "<- Zoom out\n"
974 "a Annotate current symbol\n"
975 "h/?/F1 Show this window\n"
976 "d Zoom into current DSO\n"
977 "t Zoom into current Thread\n"
978 "q/CTRL+C Exit browser");
979 continue;
980 default:;
981 }
982 if (is_exit_key(key)) {
983 if (key == NEWT_KEY_ESCAPE) {
984 if (dialog_yesno("Do you really want to exit?"))
985 break;
986 else
987 continue;
988 } else
989 break;
990 }
991
992 if (es.u.key == NEWT_KEY_LEFT) {
993 const void *top;
994
995 if (pstack__empty(fstack))
996 continue;
997 top = pstack__pop(fstack);
998 if (top == &dso_filter)
999 goto zoom_out_dso;
1000 if (top == &thread_filter)
1001 goto zoom_out_thread;
1002 continue;
1003 }
1004 }
1005
1006 if (browser->selection->sym != NULL &&
1007 !browser->selection->map->dso->annotate_warned &&
1008 asprintf(&options[nr_options], "Annotate %s",
1009 browser->selection->sym->name) > 0)
1010 annotate = nr_options++;
1011
1012 if (thread != NULL &&
1013 asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
1014 (thread_filter ? "out of" : "into"),
1015 (thread->comm_set ? thread->comm : ""),
1016 thread->pid) > 0)
1017 zoom_thread = nr_options++;
1018
1019 if (dso != NULL &&
1020 asprintf(&options[nr_options], "Zoom %s %s DSO",
1021 (dso_filter ? "out of" : "into"),
1022 (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
1023 zoom_dso = nr_options++;
1024
1025 options[nr_options++] = (char *)"Exit";
1026
1027 choice = popup_menu(nr_options, options);
1028
1029 for (i = 0; i < nr_options - 1; ++i)
1030 free(options[i]);
1031
1032 if (choice == nr_options - 1)
1033 break;
1034
1035 if (choice == -1)
1036 continue;
1037
1038 if (choice == annotate) {
1039 struct hist_entry *he;
1040do_annotate:
1041 if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
1042 browser->selection->map->dso->annotate_warned = 1;
1043 ui_helpline__puts("No vmlinux file found, can't "
1044 "annotate with just a "
1045 "kallsyms file");
1046 continue;
1047 }
1048
1049 he = hist_browser__selected_entry(browser);
1050 if (he == NULL)
1051 continue;
1052
1053 hist_entry__tui_annotate(he);
1054 } else if (choice == zoom_dso) {
1055zoom_dso:
1056 if (dso_filter) {
1057 pstack__remove(fstack, &dso_filter);
1058zoom_out_dso:
1059 ui_helpline__pop();
1060 dso_filter = NULL;
1061 } else {
1062 if (dso == NULL)
1063 continue;
1064 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1065 dso->kernel ? "the Kernel" : dso->short_name);
1066 dso_filter = dso;
1067 pstack__push(fstack, &dso_filter);
1068 }
1069 hists__filter_by_dso(self, dso_filter);
1070 hist_browser__title(msg, sizeof(msg), ev_name,
1071 dso_filter, thread_filter);
1072 if (hist_browser__populate(browser, self, msg) < 0)
1073 goto out;
1074 } else if (choice == zoom_thread) {
1075zoom_thread:
1076 if (thread_filter) {
1077 pstack__remove(fstack, &thread_filter);
1078zoom_out_thread:
1079 ui_helpline__pop();
1080 thread_filter = NULL;
1081 } else {
1082 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1083 thread->comm_set ? thread->comm : "",
1084 thread->pid);
1085 thread_filter = thread;
1086 pstack__push(fstack, &thread_filter);
1087 }
1088 hists__filter_by_thread(self, thread_filter);
1089 hist_browser__title(msg, sizeof(msg), ev_name,
1090 dso_filter, thread_filter);
1091 if (hist_browser__populate(browser, self, msg) < 0)
1092 goto out;
1093 }
1094 }
1095out_free_stack:
1096 pstack__delete(fstack);
1097out:
1098 hist_browser__delete(browser);
1099 return key;
1100}
1101
1102int hists__tui_browse_tree(struct rb_root *self, const char *help)
1103{
1104 struct rb_node *first = rb_first(self), *nd = first, *next;
1105 int key = 0;
1106
1107 while (nd) {
1108 struct hists *hists = rb_entry(nd, struct hists, rb_node);
1109 const char *ev_name = __event_name(hists->type, hists->config);
1110
1111 key = hists__browse(hists, help, ev_name);
1112
1113 if (is_exit_key(key))
1114 break;
1115
1116 switch (key) {
1117 case NEWT_KEY_TAB:
1118 next = rb_next(nd);
1119 if (next)
1120 nd = next;
1121 break;
1122 case NEWT_KEY_UNTAB:
1123 if (nd == first)
1124 continue;
1125 nd = rb_prev(nd);
1126 default:
1127 break;
1128 }
1129 }
1130
1131 return key;
1132}
1133
1134static struct newtPercentTreeColors {
1135 const char *topColorFg, *topColorBg;
1136 const char *mediumColorFg, *mediumColorBg;
1137 const char *normalColorFg, *normalColorBg;
1138 const char *selColorFg, *selColorBg;
1139 const char *codeColorFg, *codeColorBg;
1140} defaultPercentTreeColors = {
1141 "red", "lightgray",
1142 "green", "lightgray",
1143 "black", "lightgray",
1144 "lightgray", "magenta",
1145 "blue", "lightgray",
1146};
1147
1148void setup_browser(void)
1149{
1150 struct newtPercentTreeColors *c = &defaultPercentTreeColors;
1151
1152 if (!isatty(1) || !use_browser || dump_trace) {
1153 use_browser = 0;
1154 setup_pager();
1155 return;
1156 }
1157
1158 use_browser = 1;
1159 newtInit();
1160 newtCls();
1161 ui_helpline__puts(" ");
1162 sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
1163 sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
1164 sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
1165 sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
1166 sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
1167}
1168
1169void exit_browser(bool wait_for_ok)
1170{
1171 if (use_browser > 0) {
1172 if (wait_for_ok) {
1173 char title[] = "Fatal Error", ok[] = "Ok";
1174 newtWinMessage(title, ok, browser__last_msg);
1175 }
1176 newtFinished();
1177 }
1178}
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 05d0c5c2030..9bf0f402ca7 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -5,6 +5,7 @@
5#include "parse-events.h" 5#include "parse-events.h"
6#include "exec_cmd.h" 6#include "exec_cmd.h"
7#include "string.h" 7#include "string.h"
8#include "symbol.h"
8#include "cache.h" 9#include "cache.h"
9#include "header.h" 10#include "header.h"
10#include "debugfs.h" 11#include "debugfs.h"
@@ -409,7 +410,6 @@ static enum event_result
409parse_single_tracepoint_event(char *sys_name, 410parse_single_tracepoint_event(char *sys_name,
410 const char *evt_name, 411 const char *evt_name,
411 unsigned int evt_length, 412 unsigned int evt_length,
412 char *flags,
413 struct perf_event_attr *attr, 413 struct perf_event_attr *attr,
414 const char **strp) 414 const char **strp)
415{ 415{
@@ -418,14 +418,6 @@ parse_single_tracepoint_event(char *sys_name,
418 u64 id; 418 u64 id;
419 int fd; 419 int fd;
420 420
421 if (flags) {
422 if (!strncmp(flags, "record", strlen(flags))) {
423 attr->sample_type |= PERF_SAMPLE_RAW;
424 attr->sample_type |= PERF_SAMPLE_TIME;
425 attr->sample_type |= PERF_SAMPLE_CPU;
426 }
427 }
428
429 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path, 421 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
430 sys_name, evt_name); 422 sys_name, evt_name);
431 423
@@ -444,6 +436,13 @@ parse_single_tracepoint_event(char *sys_name,
444 attr->type = PERF_TYPE_TRACEPOINT; 436 attr->type = PERF_TYPE_TRACEPOINT;
445 *strp = evt_name + evt_length; 437 *strp = evt_name + evt_length;
446 438
439 attr->sample_type |= PERF_SAMPLE_RAW;
440 attr->sample_type |= PERF_SAMPLE_TIME;
441 attr->sample_type |= PERF_SAMPLE_CPU;
442
443 attr->sample_period = 1;
444
445
447 return EVT_HANDLED; 446 return EVT_HANDLED;
448} 447}
449 448
@@ -532,8 +531,7 @@ static enum event_result parse_tracepoint_event(const char **strp,
532 flags); 531 flags);
533 } else 532 } else
534 return parse_single_tracepoint_event(sys_name, evt_name, 533 return parse_single_tracepoint_event(sys_name, evt_name,
535 evt_length, flags, 534 evt_length, attr, strp);
536 attr, strp);
537} 535}
538 536
539static enum event_result 537static enum event_result
@@ -690,19 +688,29 @@ static enum event_result
690parse_event_modifier(const char **strp, struct perf_event_attr *attr) 688parse_event_modifier(const char **strp, struct perf_event_attr *attr)
691{ 689{
692 const char *str = *strp; 690 const char *str = *strp;
693 int eu = 1, ek = 1, eh = 1; 691 int exclude = 0;
692 int eu = 0, ek = 0, eh = 0, precise = 0;
694 693
695 if (*str++ != ':') 694 if (*str++ != ':')
696 return 0; 695 return 0;
697 while (*str) { 696 while (*str) {
698 if (*str == 'u') 697 if (*str == 'u') {
698 if (!exclude)
699 exclude = eu = ek = eh = 1;
699 eu = 0; 700 eu = 0;
700 else if (*str == 'k') 701 } else if (*str == 'k') {
702 if (!exclude)
703 exclude = eu = ek = eh = 1;
701 ek = 0; 704 ek = 0;
702 else if (*str == 'h') 705 } else if (*str == 'h') {
706 if (!exclude)
707 exclude = eu = ek = eh = 1;
703 eh = 0; 708 eh = 0;
704 else 709 } else if (*str == 'p') {
710 precise++;
711 } else
705 break; 712 break;
713
706 ++str; 714 ++str;
707 } 715 }
708 if (str >= *strp + 2) { 716 if (str >= *strp + 2) {
@@ -710,6 +718,7 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
710 attr->exclude_user = eu; 718 attr->exclude_user = eu;
711 attr->exclude_kernel = ek; 719 attr->exclude_kernel = ek;
712 attr->exclude_hv = eh; 720 attr->exclude_hv = eh;
721 attr->precise_ip = precise;
713 return 1; 722 return 1;
714 } 723 }
715 return 0; 724 return 0;
@@ -934,7 +943,8 @@ void print_events(void)
934 943
935 printf("\n"); 944 printf("\n");
936 printf(" %-42s [%s]\n", 945 printf(" %-42s [%s]\n",
937 "rNNN", event_type_descriptors[PERF_TYPE_RAW]); 946 "rNNN (see 'perf list --help' on how to encode it)",
947 event_type_descriptors[PERF_TYPE_RAW]);
938 printf("\n"); 948 printf("\n");
939 949
940 printf(" %-42s [%s]\n", 950 printf(" %-42s [%s]\n",
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index b8c1f64bc93..fc4ab3fe877 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -13,6 +13,7 @@ struct tracepoint_path {
13}; 13};
14 14
15extern struct tracepoint_path *tracepoint_id_to_path(u64 config); 15extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
16extern bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events);
16 17
17extern int nr_counters; 18extern int nr_counters;
18 19
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index efebd5b476b..99d02aa57db 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -49,8 +49,9 @@ static int get_value(struct parse_opt_ctx_t *p,
49 break; 49 break;
50 /* FALLTHROUGH */ 50 /* FALLTHROUGH */
51 case OPTION_BOOLEAN: 51 case OPTION_BOOLEAN:
52 case OPTION_INCR:
52 case OPTION_BIT: 53 case OPTION_BIT:
53 case OPTION_SET_INT: 54 case OPTION_SET_UINT:
54 case OPTION_SET_PTR: 55 case OPTION_SET_PTR:
55 return opterror(opt, "takes no value", flags); 56 return opterror(opt, "takes no value", flags);
56 case OPTION_END: 57 case OPTION_END:
@@ -58,7 +59,9 @@ static int get_value(struct parse_opt_ctx_t *p,
58 case OPTION_GROUP: 59 case OPTION_GROUP:
59 case OPTION_STRING: 60 case OPTION_STRING:
60 case OPTION_INTEGER: 61 case OPTION_INTEGER:
62 case OPTION_UINTEGER:
61 case OPTION_LONG: 63 case OPTION_LONG:
64 case OPTION_U64:
62 default: 65 default:
63 break; 66 break;
64 } 67 }
@@ -73,11 +76,15 @@ static int get_value(struct parse_opt_ctx_t *p,
73 return 0; 76 return 0;
74 77
75 case OPTION_BOOLEAN: 78 case OPTION_BOOLEAN:
79 *(bool *)opt->value = unset ? false : true;
80 return 0;
81
82 case OPTION_INCR:
76 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1; 83 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
77 return 0; 84 return 0;
78 85
79 case OPTION_SET_INT: 86 case OPTION_SET_UINT:
80 *(int *)opt->value = unset ? 0 : opt->defval; 87 *(unsigned int *)opt->value = unset ? 0 : opt->defval;
81 return 0; 88 return 0;
82 89
83 case OPTION_SET_PTR: 90 case OPTION_SET_PTR:
@@ -120,6 +127,22 @@ static int get_value(struct parse_opt_ctx_t *p,
120 return opterror(opt, "expects a numerical value", flags); 127 return opterror(opt, "expects a numerical value", flags);
121 return 0; 128 return 0;
122 129
130 case OPTION_UINTEGER:
131 if (unset) {
132 *(unsigned int *)opt->value = 0;
133 return 0;
134 }
135 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
136 *(unsigned int *)opt->value = opt->defval;
137 return 0;
138 }
139 if (get_arg(p, opt, flags, &arg))
140 return -1;
141 *(unsigned int *)opt->value = strtol(arg, (char **)&s, 10);
142 if (*s)
143 return opterror(opt, "expects a numerical value", flags);
144 return 0;
145
123 case OPTION_LONG: 146 case OPTION_LONG:
124 if (unset) { 147 if (unset) {
125 *(long *)opt->value = 0; 148 *(long *)opt->value = 0;
@@ -136,6 +159,22 @@ static int get_value(struct parse_opt_ctx_t *p,
136 return opterror(opt, "expects a numerical value", flags); 159 return opterror(opt, "expects a numerical value", flags);
137 return 0; 160 return 0;
138 161
162 case OPTION_U64:
163 if (unset) {
164 *(u64 *)opt->value = 0;
165 return 0;
166 }
167 if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
168 *(u64 *)opt->value = opt->defval;
169 return 0;
170 }
171 if (get_arg(p, opt, flags, &arg))
172 return -1;
173 *(u64 *)opt->value = strtoull(arg, (char **)&s, 10);
174 if (*s)
175 return opterror(opt, "expects a numerical value", flags);
176 return 0;
177
139 case OPTION_END: 178 case OPTION_END:
140 case OPTION_ARGUMENT: 179 case OPTION_ARGUMENT:
141 case OPTION_GROUP: 180 case OPTION_GROUP:
@@ -441,7 +480,10 @@ int usage_with_options_internal(const char * const *usagestr,
441 switch (opts->type) { 480 switch (opts->type) {
442 case OPTION_ARGUMENT: 481 case OPTION_ARGUMENT:
443 break; 482 break;
483 case OPTION_LONG:
484 case OPTION_U64:
444 case OPTION_INTEGER: 485 case OPTION_INTEGER:
486 case OPTION_UINTEGER:
445 if (opts->flags & PARSE_OPT_OPTARG) 487 if (opts->flags & PARSE_OPT_OPTARG)
446 if (opts->long_name) 488 if (opts->long_name)
447 pos += fprintf(stderr, "[=<n>]"); 489 pos += fprintf(stderr, "[=<n>]");
@@ -473,14 +515,14 @@ int usage_with_options_internal(const char * const *usagestr,
473 pos += fprintf(stderr, " ..."); 515 pos += fprintf(stderr, " ...");
474 } 516 }
475 break; 517 break;
476 default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */ 518 default: /* OPTION_{BIT,BOOLEAN,SET_UINT,SET_PTR} */
477 case OPTION_END: 519 case OPTION_END:
478 case OPTION_GROUP: 520 case OPTION_GROUP:
479 case OPTION_BIT: 521 case OPTION_BIT:
480 case OPTION_BOOLEAN: 522 case OPTION_BOOLEAN:
481 case OPTION_SET_INT: 523 case OPTION_INCR:
524 case OPTION_SET_UINT:
482 case OPTION_SET_PTR: 525 case OPTION_SET_PTR:
483 case OPTION_LONG:
484 break; 526 break;
485 } 527 }
486 528
@@ -500,6 +542,7 @@ int usage_with_options_internal(const char * const *usagestr,
500void usage_with_options(const char * const *usagestr, 542void usage_with_options(const char * const *usagestr,
501 const struct option *opts) 543 const struct option *opts)
502{ 544{
545 exit_browser(false);
503 usage_with_options_internal(usagestr, opts, 0); 546 usage_with_options_internal(usagestr, opts, 0);
504 exit(129); 547 exit(129);
505} 548}
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 948805af43c..c7d72dce54b 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -1,6 +1,9 @@
1#ifndef __PERF_PARSE_OPTIONS_H 1#ifndef __PERF_PARSE_OPTIONS_H
2#define __PERF_PARSE_OPTIONS_H 2#define __PERF_PARSE_OPTIONS_H
3 3
4#include <linux/kernel.h>
5#include <stdbool.h>
6
4enum parse_opt_type { 7enum parse_opt_type {
5 /* special types */ 8 /* special types */
6 OPTION_END, 9 OPTION_END,
@@ -8,14 +11,17 @@ enum parse_opt_type {
8 OPTION_GROUP, 11 OPTION_GROUP,
9 /* options with no arguments */ 12 /* options with no arguments */
10 OPTION_BIT, 13 OPTION_BIT,
11 OPTION_BOOLEAN, /* _INCR would have been a better name */ 14 OPTION_BOOLEAN,
12 OPTION_SET_INT, 15 OPTION_INCR,
16 OPTION_SET_UINT,
13 OPTION_SET_PTR, 17 OPTION_SET_PTR,
14 /* options with arguments (usually) */ 18 /* options with arguments (usually) */
15 OPTION_STRING, 19 OPTION_STRING,
16 OPTION_INTEGER, 20 OPTION_INTEGER,
17 OPTION_LONG, 21 OPTION_LONG,
18 OPTION_CALLBACK, 22 OPTION_CALLBACK,
23 OPTION_U64,
24 OPTION_UINTEGER,
19}; 25};
20 26
21enum parse_opt_flags { 27enum parse_opt_flags {
@@ -73,7 +79,7 @@ typedef int parse_opt_cb(const struct option *, const char *arg, int unset);
73 * 79 *
74 * `defval`:: 80 * `defval`::
75 * default value to fill (*->value) with for PARSE_OPT_OPTARG. 81 * default value to fill (*->value) with for PARSE_OPT_OPTARG.
76 * OPTION_{BIT,SET_INT,SET_PTR} store the {mask,integer,pointer} to put in 82 * OPTION_{BIT,SET_UINT,SET_PTR} store the {mask,integer,pointer} to put in
77 * the value when met. 83 * the value when met.
78 * CALLBACKS can use it like they want. 84 * CALLBACKS can use it like they want.
79 */ 85 */
@@ -90,16 +96,21 @@ struct option {
90 intptr_t defval; 96 intptr_t defval;
91}; 97};
92 98
99#define check_vtype(v, type) ( BUILD_BUG_ON_ZERO(!__builtin_types_compatible_p(typeof(v), type)) + v )
100
93#define OPT_END() { .type = OPTION_END } 101#define OPT_END() { .type = OPTION_END }
94#define OPT_ARGUMENT(l, h) { .type = OPTION_ARGUMENT, .long_name = (l), .help = (h) } 102#define OPT_ARGUMENT(l, h) { .type = OPTION_ARGUMENT, .long_name = (l), .help = (h) }
95#define OPT_GROUP(h) { .type = OPTION_GROUP, .help = (h) } 103#define OPT_GROUP(h) { .type = OPTION_GROUP, .help = (h) }
96#define OPT_BIT(s, l, v, h, b) { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (b) } 104#define OPT_BIT(s, l, v, h, b) { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h), .defval = (b) }
97#define OPT_BOOLEAN(s, l, v, h) { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = (v), .help = (h) } 105#define OPT_BOOLEAN(s, l, v, h) { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = check_vtype(v, bool *), .help = (h) }
98#define OPT_SET_INT(s, l, v, h, i) { .type = OPTION_SET_INT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (i) } 106#define OPT_INCR(s, l, v, h) { .type = OPTION_INCR, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) }
107#define OPT_SET_UINT(s, l, v, h, i) { .type = OPTION_SET_UINT, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h), .defval = (i) }
99#define OPT_SET_PTR(s, l, v, h, p) { .type = OPTION_SET_PTR, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (p) } 108#define OPT_SET_PTR(s, l, v, h, p) { .type = OPTION_SET_PTR, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (p) }
100#define OPT_INTEGER(s, l, v, h) { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = (v), .help = (h) } 109#define OPT_INTEGER(s, l, v, h) { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) }
101#define OPT_LONG(s, l, v, h) { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = (v), .help = (h) } 110#define OPT_UINTEGER(s, l, v, h) { .type = OPTION_UINTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h) }
102#define OPT_STRING(s, l, v, a, h) { .type = OPTION_STRING, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h) } 111#define OPT_LONG(s, l, v, h) { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = check_vtype(v, long *), .help = (h) }
112#define OPT_U64(s, l, v, h) { .type = OPTION_U64, .short_name = (s), .long_name = (l), .value = check_vtype(v, u64 *), .help = (h) }
113#define OPT_STRING(s, l, v, a, h) { .type = OPTION_STRING, .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h) }
103#define OPT_DATE(s, l, v, h) \ 114#define OPT_DATE(s, l, v, h) \
104 { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb } 115 { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
105#define OPT_CALLBACK(s, l, v, a, h, f) \ 116#define OPT_CALLBACK(s, l, v, a, h, f) \
diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
index fd1f2faaade..58a470d036d 100644
--- a/tools/perf/util/path.c
+++ b/tools/perf/util/path.c
@@ -54,21 +54,6 @@ static char *cleanup_path(char *path)
54 return path; 54 return path;
55} 55}
56 56
57char *mksnpath(char *buf, size_t n, const char *fmt, ...)
58{
59 va_list args;
60 unsigned len;
61
62 va_start(args, fmt);
63 len = vsnprintf(buf, n, fmt, args);
64 va_end(args);
65 if (len >= n) {
66 strlcpy(buf, bad_path, n);
67 return buf;
68 }
69 return cleanup_path(buf);
70}
71
72static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args) 57static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args)
73{ 58{
74 const char *perf_dir = get_perf_dir(); 59 const char *perf_dir = get_perf_dir();
@@ -89,15 +74,6 @@ bad:
89 return buf; 74 return buf;
90} 75}
91 76
92char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
93{
94 va_list args;
95 va_start(args, fmt);
96 (void)perf_vsnpath(buf, n, fmt, args);
97 va_end(args);
98 return buf;
99}
100
101char *perf_pathdup(const char *fmt, ...) 77char *perf_pathdup(const char *fmt, ...)
102{ 78{
103 char path[PATH_MAX]; 79 char path[PATH_MAX];
@@ -143,184 +119,6 @@ char *perf_path(const char *fmt, ...)
143 return cleanup_path(pathname); 119 return cleanup_path(pathname);
144} 120}
145 121
146
147/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
148int perf_mkstemp(char *path, size_t len, const char *template)
149{
150 const char *tmp;
151 size_t n;
152
153 tmp = getenv("TMPDIR");
154 if (!tmp)
155 tmp = "/tmp";
156 n = snprintf(path, len, "%s/%s", tmp, template);
157 if (len <= n) {
158 errno = ENAMETOOLONG;
159 return -1;
160 }
161 return mkstemp(path);
162}
163
164
165const char *make_relative_path(const char *abs_path, const char *base)
166{
167 static char buf[PATH_MAX + 1];
168 int baselen;
169
170 if (!base)
171 return abs_path;
172
173 baselen = strlen(base);
174 if (prefixcmp(abs_path, base))
175 return abs_path;
176 if (abs_path[baselen] == '/')
177 baselen++;
178 else if (base[baselen - 1] != '/')
179 return abs_path;
180
181 strcpy(buf, abs_path + baselen);
182
183 return buf;
184}
185
186/*
187 * It is okay if dst == src, but they should not overlap otherwise.
188 *
189 * Performs the following normalizations on src, storing the result in dst:
190 * - Ensures that components are separated by '/' (Windows only)
191 * - Squashes sequences of '/'.
192 * - Removes "." components.
193 * - Removes ".." components, and the components the precede them.
194 * Returns failure (non-zero) if a ".." component appears as first path
195 * component anytime during the normalization. Otherwise, returns success (0).
196 *
197 * Note that this function is purely textual. It does not follow symlinks,
198 * verify the existence of the path, or make any system calls.
199 */
200int normalize_path_copy(char *dst, const char *src)
201{
202 char *dst0;
203
204 if (has_dos_drive_prefix(src)) {
205 *dst++ = *src++;
206 *dst++ = *src++;
207 }
208 dst0 = dst;
209
210 if (is_dir_sep(*src)) {
211 *dst++ = '/';
212 while (is_dir_sep(*src))
213 src++;
214 }
215
216 for (;;) {
217 char c = *src;
218
219 /*
220 * A path component that begins with . could be
221 * special:
222 * (1) "." and ends -- ignore and terminate.
223 * (2) "./" -- ignore them, eat slash and continue.
224 * (3) ".." and ends -- strip one and terminate.
225 * (4) "../" -- strip one, eat slash and continue.
226 */
227 if (c == '.') {
228 if (!src[1]) {
229 /* (1) */
230 src++;
231 } else if (is_dir_sep(src[1])) {
232 /* (2) */
233 src += 2;
234 while (is_dir_sep(*src))
235 src++;
236 continue;
237 } else if (src[1] == '.') {
238 if (!src[2]) {
239 /* (3) */
240 src += 2;
241 goto up_one;
242 } else if (is_dir_sep(src[2])) {
243 /* (4) */
244 src += 3;
245 while (is_dir_sep(*src))
246 src++;
247 goto up_one;
248 }
249 }
250 }
251
252 /* copy up to the next '/', and eat all '/' */
253 while ((c = *src++) != '\0' && !is_dir_sep(c))
254 *dst++ = c;
255 if (is_dir_sep(c)) {
256 *dst++ = '/';
257 while (is_dir_sep(c))
258 c = *src++;
259 src--;
260 } else if (!c)
261 break;
262 continue;
263
264 up_one:
265 /*
266 * dst0..dst is prefix portion, and dst[-1] is '/';
267 * go up one level.
268 */
269 dst--; /* go to trailing '/' */
270 if (dst <= dst0)
271 return -1;
272 /* Windows: dst[-1] cannot be backslash anymore */
273 while (dst0 < dst && dst[-1] != '/')
274 dst--;
275 }
276 *dst = '\0';
277 return 0;
278}
279
280/*
281 * path = Canonical absolute path
282 * prefix_list = Colon-separated list of absolute paths
283 *
284 * Determines, for each path in prefix_list, whether the "prefix" really
285 * is an ancestor directory of path. Returns the length of the longest
286 * ancestor directory, excluding any trailing slashes, or -1 if no prefix
287 * is an ancestor. (Note that this means 0 is returned if prefix_list is
288 * "/".) "/foo" is not considered an ancestor of "/foobar". Directories
289 * are not considered to be their own ancestors. path must be in a
290 * canonical form: empty components, or "." or ".." components are not
291 * allowed. prefix_list may be null, which is like "".
292 */
293int longest_ancestor_length(const char *path, const char *prefix_list)
294{
295 char buf[PATH_MAX+1];
296 const char *ceil, *colon;
297 int len, max_len = -1;
298
299 if (prefix_list == NULL || !strcmp(path, "/"))
300 return -1;
301
302 for (colon = ceil = prefix_list; *colon; ceil = colon+1) {
303 for (colon = ceil; *colon && *colon != PATH_SEP; colon++);
304 len = colon - ceil;
305 if (len == 0 || len > PATH_MAX || !is_absolute_path(ceil))
306 continue;
307 strlcpy(buf, ceil, len+1);
308 if (normalize_path_copy(buf, buf) < 0)
309 continue;
310 len = strlen(buf);
311 if (len > 0 && buf[len-1] == '/')
312 buf[--len] = '\0';
313
314 if (!strncmp(path, buf, len) &&
315 path[len] == '/' &&
316 len > max_len) {
317 max_len = len;
318 }
319 }
320
321 return max_len;
322}
323
324/* strip arbitrary amount of directory separators at end of path */ 122/* strip arbitrary amount of directory separators at end of path */
325static inline int chomp_trailing_dir_sep(const char *path, int len) 123static inline int chomp_trailing_dir_sep(const char *path, int len)
326{ 124{
@@ -354,5 +152,5 @@ char *strip_path_suffix(const char *path, const char *suffix)
354 152
355 if (path_len && !is_dir_sep(path[path_len - 1])) 153 if (path_len && !is_dir_sep(path[path_len - 1]))
356 return NULL; 154 return NULL;
357 return xstrndup(path, chomp_trailing_dir_sep(path, path_len)); 155 return strndup(path, chomp_trailing_dir_sep(path, path_len));
358} 156}
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 7c004b6ef24..914c67095d9 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -33,20 +33,27 @@
33#include <limits.h> 33#include <limits.h>
34 34
35#undef _GNU_SOURCE 35#undef _GNU_SOURCE
36#include "util.h"
36#include "event.h" 37#include "event.h"
37#include "string.h" 38#include "string.h"
38#include "strlist.h" 39#include "strlist.h"
39#include "debug.h" 40#include "debug.h"
40#include "cache.h" 41#include "cache.h"
41#include "color.h" 42#include "color.h"
42#include "parse-events.h" /* For debugfs_path */ 43#include "symbol.h"
44#include "thread.h"
45#include "debugfs.h"
46#include "trace-event.h" /* For __unused */
43#include "probe-event.h" 47#include "probe-event.h"
48#include "probe-finder.h"
44 49
45#define MAX_CMDLEN 256 50#define MAX_CMDLEN 256
46#define MAX_PROBE_ARGS 128 51#define MAX_PROBE_ARGS 128
47#define PERFPROBE_GROUP "probe" 52#define PERFPROBE_GROUP "probe"
48 53
49#define semantic_error(msg ...) die("Semantic error :" msg) 54bool probe_event_dry_run; /* Dry run flag */
55
56#define semantic_error(msg ...) pr_err("Semantic error :" msg)
50 57
51/* If there is no space to write, returns -E2BIG. */ 58/* If there is no space to write, returns -E2BIG. */
52static int e_snprintf(char *str, size_t size, const char *format, ...) 59static int e_snprintf(char *str, size_t size, const char *format, ...)
@@ -64,7 +71,275 @@ static int e_snprintf(char *str, size_t size, const char *format, ...)
64 return ret; 71 return ret;
65} 72}
66 73
67void parse_line_range_desc(const char *arg, struct line_range *lr) 74static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
75static struct machine machine;
76
77/* Initialize symbol maps and path of vmlinux */
78static int init_vmlinux(void)
79{
80 struct dso *kernel;
81 int ret;
82
83 symbol_conf.sort_by_name = true;
84 if (symbol_conf.vmlinux_name == NULL)
85 symbol_conf.try_vmlinux_path = true;
86 else
87 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
88 ret = symbol__init();
89 if (ret < 0) {
90 pr_debug("Failed to init symbol map.\n");
91 goto out;
92 }
93
94 ret = machine__init(&machine, "/", 0);
95 if (ret < 0)
96 goto out;
97
98 kernel = dso__new_kernel(symbol_conf.vmlinux_name);
99 if (kernel == NULL)
100 die("Failed to create kernel dso.");
101
102 ret = __machine__create_kernel_maps(&machine, kernel);
103 if (ret < 0)
104 pr_debug("Failed to create kernel maps.\n");
105
106out:
107 if (ret < 0)
108 pr_warning("Failed to init vmlinux path.\n");
109 return ret;
110}
111
112#ifdef DWARF_SUPPORT
113static int open_vmlinux(void)
114{
115 if (map__load(machine.vmlinux_maps[MAP__FUNCTION], NULL) < 0) {
116 pr_debug("Failed to load kernel map.\n");
117 return -EINVAL;
118 }
119 pr_debug("Try to open %s\n", machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name);
120 return open(machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name, O_RDONLY);
121}
122
123/* Convert trace point to probe point with debuginfo */
124static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
125 struct perf_probe_point *pp)
126{
127 struct symbol *sym;
128 int fd, ret = -ENOENT;
129
130 sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION],
131 tp->symbol, NULL);
132 if (sym) {
133 fd = open_vmlinux();
134 if (fd >= 0) {
135 ret = find_perf_probe_point(fd,
136 sym->start + tp->offset, pp);
137 close(fd);
138 }
139 }
140 if (ret <= 0) {
141 pr_debug("Failed to find corresponding probes from "
142 "debuginfo. Use kprobe event information.\n");
143 pp->function = strdup(tp->symbol);
144 if (pp->function == NULL)
145 return -ENOMEM;
146 pp->offset = tp->offset;
147 }
148 pp->retprobe = tp->retprobe;
149
150 return 0;
151}
152
153/* Try to find perf_probe_event with debuginfo */
154static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
155 struct kprobe_trace_event **tevs,
156 int max_tevs)
157{
158 bool need_dwarf = perf_probe_event_need_dwarf(pev);
159 int fd, ntevs;
160
161 fd = open_vmlinux();
162 if (fd < 0) {
163 if (need_dwarf) {
164 pr_warning("Failed to open debuginfo file.\n");
165 return fd;
166 }
167 pr_debug("Could not open vmlinux. Try to use symbols.\n");
168 return 0;
169 }
170
171 /* Searching trace events corresponding to probe event */
172 ntevs = find_kprobe_trace_events(fd, pev, tevs, max_tevs);
173 close(fd);
174
175 if (ntevs > 0) { /* Succeeded to find trace events */
176 pr_debug("find %d kprobe_trace_events.\n", ntevs);
177 return ntevs;
178 }
179
180 if (ntevs == 0) { /* No error but failed to find probe point. */
181 pr_warning("Probe point '%s' not found.\n",
182 synthesize_perf_probe_point(&pev->point));
183 return -ENOENT;
184 }
185 /* Error path : ntevs < 0 */
186 pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
187 if (ntevs == -EBADF) {
188 pr_warning("Warning: No dwarf info found in the vmlinux - "
189 "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
190 if (!need_dwarf) {
191 pr_debug("Trying to use symbols.\nn");
192 return 0;
193 }
194 }
195 return ntevs;
196}
197
198#define LINEBUF_SIZE 256
199#define NR_ADDITIONAL_LINES 2
200
201static int show_one_line(FILE *fp, int l, bool skip, bool show_num)
202{
203 char buf[LINEBUF_SIZE];
204 const char *color = PERF_COLOR_BLUE;
205
206 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
207 goto error;
208 if (!skip) {
209 if (show_num)
210 fprintf(stdout, "%7d %s", l, buf);
211 else
212 color_fprintf(stdout, color, " %s", buf);
213 }
214
215 while (strlen(buf) == LINEBUF_SIZE - 1 &&
216 buf[LINEBUF_SIZE - 2] != '\n') {
217 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
218 goto error;
219 if (!skip) {
220 if (show_num)
221 fprintf(stdout, "%s", buf);
222 else
223 color_fprintf(stdout, color, "%s", buf);
224 }
225 }
226
227 return 0;
228error:
229 if (feof(fp))
230 pr_warning("Source file is shorter than expected.\n");
231 else
232 pr_warning("File read error: %s\n", strerror(errno));
233
234 return -1;
235}
236
237/*
238 * Show line-range always requires debuginfo to find source file and
239 * line number.
240 */
241int show_line_range(struct line_range *lr)
242{
243 int l = 1;
244 struct line_node *ln;
245 FILE *fp;
246 int fd, ret;
247
248 /* Search a line range */
249 ret = init_vmlinux();
250 if (ret < 0)
251 return ret;
252
253 fd = open_vmlinux();
254 if (fd < 0) {
255 pr_warning("Failed to open debuginfo file.\n");
256 return fd;
257 }
258
259 ret = find_line_range(fd, lr);
260 close(fd);
261 if (ret == 0) {
262 pr_warning("Specified source line is not found.\n");
263 return -ENOENT;
264 } else if (ret < 0) {
265 pr_warning("Debuginfo analysis failed. (%d)\n", ret);
266 return ret;
267 }
268
269 setup_pager();
270
271 if (lr->function)
272 fprintf(stdout, "<%s:%d>\n", lr->function,
273 lr->start - lr->offset);
274 else
275 fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
276
277 fp = fopen(lr->path, "r");
278 if (fp == NULL) {
279 pr_warning("Failed to open %s: %s\n", lr->path,
280 strerror(errno));
281 return -errno;
282 }
283 /* Skip to starting line number */
284 while (l < lr->start && ret >= 0)
285 ret = show_one_line(fp, l++, true, false);
286 if (ret < 0)
287 goto end;
288
289 list_for_each_entry(ln, &lr->line_list, list) {
290 while (ln->line > l && ret >= 0)
291 ret = show_one_line(fp, (l++) - lr->offset,
292 false, false);
293 if (ret >= 0)
294 ret = show_one_line(fp, (l++) - lr->offset,
295 false, true);
296 if (ret < 0)
297 goto end;
298 }
299
300 if (lr->end == INT_MAX)
301 lr->end = l + NR_ADDITIONAL_LINES;
302 while (l <= lr->end && !feof(fp) && ret >= 0)
303 ret = show_one_line(fp, (l++) - lr->offset, false, false);
304end:
305 fclose(fp);
306 return ret;
307}
308
309#else /* !DWARF_SUPPORT */
310
311static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
312 struct perf_probe_point *pp)
313{
314 pp->function = strdup(tp->symbol);
315 if (pp->function == NULL)
316 return -ENOMEM;
317 pp->offset = tp->offset;
318 pp->retprobe = tp->retprobe;
319
320 return 0;
321}
322
323static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
324 struct kprobe_trace_event **tevs __unused,
325 int max_tevs __unused)
326{
327 if (perf_probe_event_need_dwarf(pev)) {
328 pr_warning("Debuginfo-analysis is not supported.\n");
329 return -ENOSYS;
330 }
331 return 0;
332}
333
334int show_line_range(struct line_range *lr __unused)
335{
336 pr_warning("Debuginfo-analysis is not supported.\n");
337 return -ENOSYS;
338}
339
340#endif
341
342int parse_line_range_desc(const char *arg, struct line_range *lr)
68{ 343{
69 const char *ptr; 344 const char *ptr;
70 char *tmp; 345 char *tmp;
@@ -75,29 +350,45 @@ void parse_line_range_desc(const char *arg, struct line_range *lr)
75 */ 350 */
76 ptr = strchr(arg, ':'); 351 ptr = strchr(arg, ':');
77 if (ptr) { 352 if (ptr) {
78 lr->start = (unsigned int)strtoul(ptr + 1, &tmp, 0); 353 lr->start = (int)strtoul(ptr + 1, &tmp, 0);
79 if (*tmp == '+') 354 if (*tmp == '+') {
80 lr->end = lr->start + (unsigned int)strtoul(tmp + 1, 355 lr->end = lr->start + (int)strtoul(tmp + 1, &tmp, 0);
81 &tmp, 0); 356 lr->end--; /*
82 else if (*tmp == '-') 357 * Adjust the number of lines here.
83 lr->end = (unsigned int)strtoul(tmp + 1, &tmp, 0); 358 * If the number of lines == 1, the
359 * the end of line should be equal to
360 * the start of line.
361 */
362 } else if (*tmp == '-')
363 lr->end = (int)strtoul(tmp + 1, &tmp, 0);
84 else 364 else
85 lr->end = 0; 365 lr->end = INT_MAX;
86 pr_debug("Line range is %u to %u\n", lr->start, lr->end); 366 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
87 if (lr->end && lr->start > lr->end) 367 if (lr->start > lr->end) {
88 semantic_error("Start line must be smaller" 368 semantic_error("Start line must be smaller"
89 " than end line."); 369 " than end line.\n");
90 if (*tmp != '\0') 370 return -EINVAL;
91 semantic_error("Tailing with invalid character '%d'.", 371 }
372 if (*tmp != '\0') {
373 semantic_error("Tailing with invalid character '%d'.\n",
92 *tmp); 374 *tmp);
375 return -EINVAL;
376 }
93 tmp = strndup(arg, (ptr - arg)); 377 tmp = strndup(arg, (ptr - arg));
94 } else 378 } else {
95 tmp = strdup(arg); 379 tmp = strdup(arg);
380 lr->end = INT_MAX;
381 }
382
383 if (tmp == NULL)
384 return -ENOMEM;
96 385
97 if (strchr(tmp, '.')) 386 if (strchr(tmp, '.'))
98 lr->file = tmp; 387 lr->file = tmp;
99 else 388 else
100 lr->function = tmp; 389 lr->function = tmp;
390
391 return 0;
101} 392}
102 393
103/* Check the name is good for event/group */ 394/* Check the name is good for event/group */
@@ -113,8 +404,9 @@ static bool check_event_name(const char *name)
113} 404}
114 405
115/* Parse probepoint definition. */ 406/* Parse probepoint definition. */
116static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp) 407static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
117{ 408{
409 struct perf_probe_point *pp = &pev->point;
118 char *ptr, *tmp; 410 char *ptr, *tmp;
119 char c, nc = 0; 411 char c, nc = 0;
120 /* 412 /*
@@ -129,13 +421,19 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
129 if (ptr && *ptr == '=') { /* Event name */ 421 if (ptr && *ptr == '=') { /* Event name */
130 *ptr = '\0'; 422 *ptr = '\0';
131 tmp = ptr + 1; 423 tmp = ptr + 1;
132 ptr = strchr(arg, ':'); 424 if (strchr(arg, ':')) {
133 if (ptr) /* Group name is not supported yet. */ 425 semantic_error("Group name is not supported yet.\n");
134 semantic_error("Group name is not supported yet."); 426 return -ENOTSUP;
135 if (!check_event_name(arg)) 427 }
428 if (!check_event_name(arg)) {
136 semantic_error("%s is bad for event name -it must " 429 semantic_error("%s is bad for event name -it must "
137 "follow C symbol-naming rule.", arg); 430 "follow C symbol-naming rule.\n", arg);
138 pp->event = strdup(arg); 431 return -EINVAL;
432 }
433 pev->event = strdup(arg);
434 if (pev->event == NULL)
435 return -ENOMEM;
436 pev->group = NULL;
139 arg = tmp; 437 arg = tmp;
140 } 438 }
141 439
@@ -145,12 +443,15 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
145 *ptr++ = '\0'; 443 *ptr++ = '\0';
146 } 444 }
147 445
446 tmp = strdup(arg);
447 if (tmp == NULL)
448 return -ENOMEM;
449
148 /* Check arg is function or file and copy it */ 450 /* Check arg is function or file and copy it */
149 if (strchr(arg, '.')) /* File */ 451 if (strchr(tmp, '.')) /* File */
150 pp->file = strdup(arg); 452 pp->file = tmp;
151 else /* Function */ 453 else /* Function */
152 pp->function = strdup(arg); 454 pp->function = tmp;
153 DIE_IF(pp->file == NULL && pp->function == NULL);
154 455
155 /* Parse other options */ 456 /* Parse other options */
156 while (ptr) { 457 while (ptr) {
@@ -158,6 +459,8 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
158 c = nc; 459 c = nc;
159 if (c == ';') { /* Lazy pattern must be the last part */ 460 if (c == ';') { /* Lazy pattern must be the last part */
160 pp->lazy_line = strdup(arg); 461 pp->lazy_line = strdup(arg);
462 if (pp->lazy_line == NULL)
463 return -ENOMEM;
161 break; 464 break;
162 } 465 }
163 ptr = strpbrk(arg, ";:+@%"); 466 ptr = strpbrk(arg, ";:+@%");
@@ -168,266 +471,658 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
168 switch (c) { 471 switch (c) {
169 case ':': /* Line number */ 472 case ':': /* Line number */
170 pp->line = strtoul(arg, &tmp, 0); 473 pp->line = strtoul(arg, &tmp, 0);
171 if (*tmp != '\0') 474 if (*tmp != '\0') {
172 semantic_error("There is non-digit char" 475 semantic_error("There is non-digit char"
173 " in line number."); 476 " in line number.\n");
477 return -EINVAL;
478 }
174 break; 479 break;
175 case '+': /* Byte offset from a symbol */ 480 case '+': /* Byte offset from a symbol */
176 pp->offset = strtoul(arg, &tmp, 0); 481 pp->offset = strtoul(arg, &tmp, 0);
177 if (*tmp != '\0') 482 if (*tmp != '\0') {
178 semantic_error("There is non-digit character" 483 semantic_error("There is non-digit character"
179 " in offset."); 484 " in offset.\n");
485 return -EINVAL;
486 }
180 break; 487 break;
181 case '@': /* File name */ 488 case '@': /* File name */
182 if (pp->file) 489 if (pp->file) {
183 semantic_error("SRC@SRC is not allowed."); 490 semantic_error("SRC@SRC is not allowed.\n");
491 return -EINVAL;
492 }
184 pp->file = strdup(arg); 493 pp->file = strdup(arg);
185 DIE_IF(pp->file == NULL); 494 if (pp->file == NULL)
495 return -ENOMEM;
186 break; 496 break;
187 case '%': /* Probe places */ 497 case '%': /* Probe places */
188 if (strcmp(arg, "return") == 0) { 498 if (strcmp(arg, "return") == 0) {
189 pp->retprobe = 1; 499 pp->retprobe = 1;
190 } else /* Others not supported yet */ 500 } else { /* Others not supported yet */
191 semantic_error("%%%s is not supported.", arg); 501 semantic_error("%%%s is not supported.\n", arg);
502 return -ENOTSUP;
503 }
192 break; 504 break;
193 default: 505 default: /* Buggy case */
194 DIE_IF("Program has a bug."); 506 pr_err("This program has a bug at %s:%d.\n",
507 __FILE__, __LINE__);
508 return -ENOTSUP;
195 break; 509 break;
196 } 510 }
197 } 511 }
198 512
199 /* Exclusion check */ 513 /* Exclusion check */
200 if (pp->lazy_line && pp->line) 514 if (pp->lazy_line && pp->line) {
201 semantic_error("Lazy pattern can't be used with line number."); 515 semantic_error("Lazy pattern can't be used with line number.");
516 return -EINVAL;
517 }
202 518
203 if (pp->lazy_line && pp->offset) 519 if (pp->lazy_line && pp->offset) {
204 semantic_error("Lazy pattern can't be used with offset."); 520 semantic_error("Lazy pattern can't be used with offset.");
521 return -EINVAL;
522 }
205 523
206 if (pp->line && pp->offset) 524 if (pp->line && pp->offset) {
207 semantic_error("Offset can't be used with line number."); 525 semantic_error("Offset can't be used with line number.");
526 return -EINVAL;
527 }
208 528
209 if (!pp->line && !pp->lazy_line && pp->file && !pp->function) 529 if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
210 semantic_error("File always requires line number or " 530 semantic_error("File always requires line number or "
211 "lazy pattern."); 531 "lazy pattern.");
532 return -EINVAL;
533 }
212 534
213 if (pp->offset && !pp->function) 535 if (pp->offset && !pp->function) {
214 semantic_error("Offset requires an entry function."); 536 semantic_error("Offset requires an entry function.");
537 return -EINVAL;
538 }
215 539
216 if (pp->retprobe && !pp->function) 540 if (pp->retprobe && !pp->function) {
217 semantic_error("Return probe requires an entry function."); 541 semantic_error("Return probe requires an entry function.");
542 return -EINVAL;
543 }
218 544
219 if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) 545 if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
220 semantic_error("Offset/Line/Lazy pattern can't be used with " 546 semantic_error("Offset/Line/Lazy pattern can't be used with "
221 "return probe."); 547 "return probe.");
548 return -EINVAL;
549 }
222 550
223 pr_debug("symbol:%s file:%s line:%d offset:%d return:%d lazy:%s\n", 551 pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
224 pp->function, pp->file, pp->line, pp->offset, pp->retprobe, 552 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
225 pp->lazy_line); 553 pp->lazy_line);
554 return 0;
226} 555}
227 556
228/* Parse perf-probe event definition */ 557/* Parse perf-probe event argument */
229void parse_perf_probe_event(const char *str, struct probe_point *pp, 558static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
230 bool *need_dwarf)
231{ 559{
232 char **argv; 560 char *tmp;
233 int argc, i; 561 struct perf_probe_arg_field **fieldp;
562
563 pr_debug("parsing arg: %s into ", str);
234 564
235 *need_dwarf = false; 565 tmp = strchr(str, '=');
566 if (tmp) {
567 arg->name = strndup(str, tmp - str);
568 if (arg->name == NULL)
569 return -ENOMEM;
570 pr_debug("name:%s ", arg->name);
571 str = tmp + 1;
572 }
236 573
237 argv = argv_split(str, &argc); 574 tmp = strchr(str, ':');
238 if (!argv) 575 if (tmp) { /* Type setting */
239 die("argv_split failed."); 576 *tmp = '\0';
240 if (argc > MAX_PROBE_ARGS + 1) 577 arg->type = strdup(tmp + 1);
241 semantic_error("Too many arguments"); 578 if (arg->type == NULL)
579 return -ENOMEM;
580 pr_debug("type:%s ", arg->type);
581 }
242 582
583 tmp = strpbrk(str, "-.");
584 if (!is_c_varname(str) || !tmp) {
585 /* A variable, register, symbol or special value */
586 arg->var = strdup(str);
587 if (arg->var == NULL)
588 return -ENOMEM;
589 pr_debug("%s\n", arg->var);
590 return 0;
591 }
592
593 /* Structure fields */
594 arg->var = strndup(str, tmp - str);
595 if (arg->var == NULL)
596 return -ENOMEM;
597 pr_debug("%s, ", arg->var);
598 fieldp = &arg->field;
599
600 do {
601 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
602 if (*fieldp == NULL)
603 return -ENOMEM;
604 if (*tmp == '.') {
605 str = tmp + 1;
606 (*fieldp)->ref = false;
607 } else if (tmp[1] == '>') {
608 str = tmp + 2;
609 (*fieldp)->ref = true;
610 } else {
611 semantic_error("Argument parse error: %s\n", str);
612 return -EINVAL;
613 }
614
615 tmp = strpbrk(str, "-.");
616 if (tmp) {
617 (*fieldp)->name = strndup(str, tmp - str);
618 if ((*fieldp)->name == NULL)
619 return -ENOMEM;
620 pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
621 fieldp = &(*fieldp)->next;
622 }
623 } while (tmp);
624 (*fieldp)->name = strdup(str);
625 if ((*fieldp)->name == NULL)
626 return -ENOMEM;
627 pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
628
629 /* If no name is specified, set the last field name */
630 if (!arg->name) {
631 arg->name = strdup((*fieldp)->name);
632 if (arg->name == NULL)
633 return -ENOMEM;
634 }
635 return 0;
636}
637
638/* Parse perf-probe event command */
639int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
640{
641 char **argv;
642 int argc, i, ret = 0;
643
644 argv = argv_split(cmd, &argc);
645 if (!argv) {
646 pr_debug("Failed to split arguments.\n");
647 return -ENOMEM;
648 }
649 if (argc - 1 > MAX_PROBE_ARGS) {
650 semantic_error("Too many probe arguments (%d).\n", argc - 1);
651 ret = -ERANGE;
652 goto out;
653 }
243 /* Parse probe point */ 654 /* Parse probe point */
244 parse_perf_probe_probepoint(argv[0], pp); 655 ret = parse_perf_probe_point(argv[0], pev);
245 if (pp->file || pp->line || pp->lazy_line) 656 if (ret < 0)
246 *need_dwarf = true; 657 goto out;
247 658
248 /* Copy arguments and ensure return probe has no C argument */ 659 /* Copy arguments and ensure return probe has no C argument */
249 pp->nr_args = argc - 1; 660 pev->nargs = argc - 1;
250 pp->args = zalloc(sizeof(char *) * pp->nr_args); 661 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
251 for (i = 0; i < pp->nr_args; i++) { 662 if (pev->args == NULL) {
252 pp->args[i] = strdup(argv[i + 1]); 663 ret = -ENOMEM;
253 if (!pp->args[i]) 664 goto out;
254 die("Failed to copy argument."); 665 }
255 if (is_c_varname(pp->args[i])) { 666 for (i = 0; i < pev->nargs && ret >= 0; i++) {
256 if (pp->retprobe) 667 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
257 semantic_error("You can't specify local" 668 if (ret >= 0 &&
258 " variable for kretprobe"); 669 is_c_varname(pev->args[i].var) && pev->point.retprobe) {
259 *need_dwarf = true; 670 semantic_error("You can't specify local variable for"
671 " kretprobe.\n");
672 ret = -EINVAL;
260 } 673 }
261 } 674 }
262 675out:
263 argv_free(argv); 676 argv_free(argv);
677
678 return ret;
679}
680
681/* Return true if this perf_probe_event requires debuginfo */
682bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
683{
684 int i;
685
686 if (pev->point.file || pev->point.line || pev->point.lazy_line)
687 return true;
688
689 for (i = 0; i < pev->nargs; i++)
690 if (is_c_varname(pev->args[i].var))
691 return true;
692
693 return false;
264} 694}
265 695
266/* Parse kprobe_events event into struct probe_point */ 696/* Parse kprobe_events event into struct probe_point */
267void parse_trace_kprobe_event(const char *str, struct probe_point *pp) 697int parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev)
268{ 698{
699 struct kprobe_trace_point *tp = &tev->point;
269 char pr; 700 char pr;
270 char *p; 701 char *p;
271 int ret, i, argc; 702 int ret, i, argc;
272 char **argv; 703 char **argv;
273 704
274 pr_debug("Parsing kprobe_events: %s\n", str); 705 pr_debug("Parsing kprobe_events: %s\n", cmd);
275 argv = argv_split(str, &argc); 706 argv = argv_split(cmd, &argc);
276 if (!argv) 707 if (!argv) {
277 die("argv_split failed."); 708 pr_debug("Failed to split arguments.\n");
278 if (argc < 2) 709 return -ENOMEM;
279 semantic_error("Too less arguments."); 710 }
711 if (argc < 2) {
712 semantic_error("Too few probe arguments.\n");
713 ret = -ERANGE;
714 goto out;
715 }
280 716
281 /* Scan event and group name. */ 717 /* Scan event and group name. */
282 ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]", 718 ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
283 &pr, (float *)(void *)&pp->group, 719 &pr, (float *)(void *)&tev->group,
284 (float *)(void *)&pp->event); 720 (float *)(void *)&tev->event);
285 if (ret != 3) 721 if (ret != 3) {
286 semantic_error("Failed to parse event name: %s", argv[0]); 722 semantic_error("Failed to parse event name: %s\n", argv[0]);
287 pr_debug("Group:%s Event:%s probe:%c\n", pp->group, pp->event, pr); 723 ret = -EINVAL;
724 goto out;
725 }
726 pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
288 727
289 pp->retprobe = (pr == 'r'); 728 tp->retprobe = (pr == 'r');
290 729
291 /* Scan function name and offset */ 730 /* Scan function name and offset */
292 ret = sscanf(argv[1], "%a[^+]+%d", (float *)(void *)&pp->function, 731 ret = sscanf(argv[1], "%a[^+]+%lu", (float *)(void *)&tp->symbol,
293 &pp->offset); 732 &tp->offset);
294 if (ret == 1) 733 if (ret == 1)
295 pp->offset = 0; 734 tp->offset = 0;
296
297 /* kprobe_events doesn't have this information */
298 pp->line = 0;
299 pp->file = NULL;
300 735
301 pp->nr_args = argc - 2; 736 tev->nargs = argc - 2;
302 pp->args = zalloc(sizeof(char *) * pp->nr_args); 737 tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
303 for (i = 0; i < pp->nr_args; i++) { 738 if (tev->args == NULL) {
739 ret = -ENOMEM;
740 goto out;
741 }
742 for (i = 0; i < tev->nargs; i++) {
304 p = strchr(argv[i + 2], '='); 743 p = strchr(argv[i + 2], '=');
305 if (p) /* We don't need which register is assigned. */ 744 if (p) /* We don't need which register is assigned. */
306 *p = '\0'; 745 *p++ = '\0';
307 pp->args[i] = strdup(argv[i + 2]); 746 else
308 if (!pp->args[i]) 747 p = argv[i + 2];
309 die("Failed to copy argument."); 748 tev->args[i].name = strdup(argv[i + 2]);
749 /* TODO: parse regs and offset */
750 tev->args[i].value = strdup(p);
751 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
752 ret = -ENOMEM;
753 goto out;
754 }
310 } 755 }
311 756 ret = 0;
757out:
312 argv_free(argv); 758 argv_free(argv);
759 return ret;
313} 760}
314 761
315/* Synthesize only probe point (not argument) */ 762/* Compose only probe arg */
316int synthesize_perf_probe_point(struct probe_point *pp) 763int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
317{ 764{
318 char *buf; 765 struct perf_probe_arg_field *field = pa->field;
319 char offs[64] = "", line[64] = "";
320 int ret; 766 int ret;
767 char *tmp = buf;
321 768
322 pp->probes[0] = buf = zalloc(MAX_CMDLEN); 769 if (pa->name && pa->var)
323 pp->found = 1; 770 ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
324 if (!buf) 771 else
325 die("Failed to allocate memory by zalloc."); 772 ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
773 if (ret <= 0)
774 goto error;
775 tmp += ret;
776 len -= ret;
777
778 while (field) {
779 ret = e_snprintf(tmp, len, "%s%s", field->ref ? "->" : ".",
780 field->name);
781 if (ret <= 0)
782 goto error;
783 tmp += ret;
784 len -= ret;
785 field = field->next;
786 }
787
788 if (pa->type) {
789 ret = e_snprintf(tmp, len, ":%s", pa->type);
790 if (ret <= 0)
791 goto error;
792 tmp += ret;
793 len -= ret;
794 }
795
796 return tmp - buf;
797error:
798 pr_debug("Failed to synthesize perf probe argument: %s",
799 strerror(-ret));
800 return ret;
801}
802
803/* Compose only probe point (not argument) */
804static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
805{
806 char *buf, *tmp;
807 char offs[32] = "", line[32] = "", file[32] = "";
808 int ret, len;
809
810 buf = zalloc(MAX_CMDLEN);
811 if (buf == NULL) {
812 ret = -ENOMEM;
813 goto error;
814 }
326 if (pp->offset) { 815 if (pp->offset) {
327 ret = e_snprintf(offs, 64, "+%d", pp->offset); 816 ret = e_snprintf(offs, 32, "+%lu", pp->offset);
328 if (ret <= 0) 817 if (ret <= 0)
329 goto error; 818 goto error;
330 } 819 }
331 if (pp->line) { 820 if (pp->line) {
332 ret = e_snprintf(line, 64, ":%d", pp->line); 821 ret = e_snprintf(line, 32, ":%d", pp->line);
822 if (ret <= 0)
823 goto error;
824 }
825 if (pp->file) {
826 len = strlen(pp->file) - 31;
827 if (len < 0)
828 len = 0;
829 tmp = strchr(pp->file + len, '/');
830 if (!tmp)
831 tmp = pp->file + len;
832 ret = e_snprintf(file, 32, "@%s", tmp + 1);
333 if (ret <= 0) 833 if (ret <= 0)
334 goto error; 834 goto error;
335 } 835 }
336 836
337 if (pp->function) 837 if (pp->function)
338 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s", pp->function, 838 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
339 offs, pp->retprobe ? "%return" : "", line); 839 offs, pp->retprobe ? "%return" : "", line,
840 file);
340 else 841 else
341 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", pp->file, line); 842 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
342 if (ret <= 0) { 843 if (ret <= 0)
844 goto error;
845
846 return buf;
343error: 847error:
344 free(pp->probes[0]); 848 pr_debug("Failed to synthesize perf probe point: %s",
345 pp->probes[0] = NULL; 849 strerror(-ret));
346 pp->found = 0; 850 if (buf)
347 } 851 free(buf);
348 return ret; 852 return NULL;
349} 853}
350 854
351int synthesize_perf_probe_event(struct probe_point *pp) 855#if 0
856char *synthesize_perf_probe_command(struct perf_probe_event *pev)
352{ 857{
353 char *buf; 858 char *buf;
354 int i, len, ret; 859 int i, len, ret;
355 860
356 len = synthesize_perf_probe_point(pp); 861 buf = synthesize_perf_probe_point(&pev->point);
357 if (len < 0) 862 if (!buf)
358 return 0; 863 return NULL;
359 864
360 buf = pp->probes[0]; 865 len = strlen(buf);
361 for (i = 0; i < pp->nr_args; i++) { 866 for (i = 0; i < pev->nargs; i++) {
362 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s", 867 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
363 pp->args[i]); 868 pev->args[i].name);
364 if (ret <= 0) 869 if (ret <= 0) {
365 goto error; 870 free(buf);
871 return NULL;
872 }
366 len += ret; 873 len += ret;
367 } 874 }
368 pp->found = 1;
369 875
370 return pp->found; 876 return buf;
371error: 877}
372 free(pp->probes[0]); 878#endif
373 pp->probes[0] = NULL; 879
880static int __synthesize_kprobe_trace_arg_ref(struct kprobe_trace_arg_ref *ref,
881 char **buf, size_t *buflen,
882 int depth)
883{
884 int ret;
885 if (ref->next) {
886 depth = __synthesize_kprobe_trace_arg_ref(ref->next, buf,
887 buflen, depth + 1);
888 if (depth < 0)
889 goto out;
890 }
891
892 ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
893 if (ret < 0)
894 depth = ret;
895 else {
896 *buf += ret;
897 *buflen -= ret;
898 }
899out:
900 return depth;
374 901
375 return ret;
376} 902}
377 903
378int synthesize_trace_kprobe_event(struct probe_point *pp) 904static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg,
905 char *buf, size_t buflen)
379{ 906{
907 int ret, depth = 0;
908 char *tmp = buf;
909
910 /* Argument name or separator */
911 if (arg->name)
912 ret = e_snprintf(buf, buflen, " %s=", arg->name);
913 else
914 ret = e_snprintf(buf, buflen, " ");
915 if (ret < 0)
916 return ret;
917 buf += ret;
918 buflen -= ret;
919
920 /* Dereferencing arguments */
921 if (arg->ref) {
922 depth = __synthesize_kprobe_trace_arg_ref(arg->ref, &buf,
923 &buflen, 1);
924 if (depth < 0)
925 return depth;
926 }
927
928 /* Print argument value */
929 ret = e_snprintf(buf, buflen, "%s", arg->value);
930 if (ret < 0)
931 return ret;
932 buf += ret;
933 buflen -= ret;
934
935 /* Closing */
936 while (depth--) {
937 ret = e_snprintf(buf, buflen, ")");
938 if (ret < 0)
939 return ret;
940 buf += ret;
941 buflen -= ret;
942 }
943 /* Print argument type */
944 if (arg->type) {
945 ret = e_snprintf(buf, buflen, ":%s", arg->type);
946 if (ret <= 0)
947 return ret;
948 buf += ret;
949 }
950
951 return buf - tmp;
952}
953
954char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev)
955{
956 struct kprobe_trace_point *tp = &tev->point;
380 char *buf; 957 char *buf;
381 int i, len, ret; 958 int i, len, ret;
382 959
383 pp->probes[0] = buf = zalloc(MAX_CMDLEN); 960 buf = zalloc(MAX_CMDLEN);
384 if (!buf) 961 if (buf == NULL)
385 die("Failed to allocate memory by zalloc."); 962 return NULL;
386 ret = e_snprintf(buf, MAX_CMDLEN, "%s+%d", pp->function, pp->offset); 963
387 if (ret <= 0) 964 len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s+%lu",
965 tp->retprobe ? 'r' : 'p',
966 tev->group, tev->event,
967 tp->symbol, tp->offset);
968 if (len <= 0)
388 goto error; 969 goto error;
389 len = ret;
390 970
391 for (i = 0; i < pp->nr_args; i++) { 971 for (i = 0; i < tev->nargs; i++) {
392 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s", 972 ret = synthesize_kprobe_trace_arg(&tev->args[i], buf + len,
393 pp->args[i]); 973 MAX_CMDLEN - len);
394 if (ret <= 0) 974 if (ret <= 0)
395 goto error; 975 goto error;
396 len += ret; 976 len += ret;
397 } 977 }
398 pp->found = 1;
399 978
400 return pp->found; 979 return buf;
401error: 980error:
402 free(pp->probes[0]); 981 free(buf);
403 pp->probes[0] = NULL; 982 return NULL;
983}
984
985int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
986 struct perf_probe_event *pev)
987{
988 char buf[64] = "";
989 int i, ret;
990
991 /* Convert event/group name */
992 pev->event = strdup(tev->event);
993 pev->group = strdup(tev->group);
994 if (pev->event == NULL || pev->group == NULL)
995 return -ENOMEM;
996
997 /* Convert trace_point to probe_point */
998 ret = convert_to_perf_probe_point(&tev->point, &pev->point);
999 if (ret < 0)
1000 return ret;
1001
1002 /* Convert trace_arg to probe_arg */
1003 pev->nargs = tev->nargs;
1004 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1005 if (pev->args == NULL)
1006 return -ENOMEM;
1007 for (i = 0; i < tev->nargs && ret >= 0; i++) {
1008 if (tev->args[i].name)
1009 pev->args[i].name = strdup(tev->args[i].name);
1010 else {
1011 ret = synthesize_kprobe_trace_arg(&tev->args[i],
1012 buf, 64);
1013 pev->args[i].name = strdup(buf);
1014 }
1015 if (pev->args[i].name == NULL && ret >= 0)
1016 ret = -ENOMEM;
1017 }
1018
1019 if (ret < 0)
1020 clear_perf_probe_event(pev);
404 1021
405 return ret; 1022 return ret;
406} 1023}
407 1024
408static int open_kprobe_events(int flags, int mode) 1025void clear_perf_probe_event(struct perf_probe_event *pev)
1026{
1027 struct perf_probe_point *pp = &pev->point;
1028 struct perf_probe_arg_field *field, *next;
1029 int i;
1030
1031 if (pev->event)
1032 free(pev->event);
1033 if (pev->group)
1034 free(pev->group);
1035 if (pp->file)
1036 free(pp->file);
1037 if (pp->function)
1038 free(pp->function);
1039 if (pp->lazy_line)
1040 free(pp->lazy_line);
1041 for (i = 0; i < pev->nargs; i++) {
1042 if (pev->args[i].name)
1043 free(pev->args[i].name);
1044 if (pev->args[i].var)
1045 free(pev->args[i].var);
1046 if (pev->args[i].type)
1047 free(pev->args[i].type);
1048 field = pev->args[i].field;
1049 while (field) {
1050 next = field->next;
1051 if (field->name)
1052 free(field->name);
1053 free(field);
1054 field = next;
1055 }
1056 }
1057 if (pev->args)
1058 free(pev->args);
1059 memset(pev, 0, sizeof(*pev));
1060}
1061
1062void clear_kprobe_trace_event(struct kprobe_trace_event *tev)
1063{
1064 struct kprobe_trace_arg_ref *ref, *next;
1065 int i;
1066
1067 if (tev->event)
1068 free(tev->event);
1069 if (tev->group)
1070 free(tev->group);
1071 if (tev->point.symbol)
1072 free(tev->point.symbol);
1073 for (i = 0; i < tev->nargs; i++) {
1074 if (tev->args[i].name)
1075 free(tev->args[i].name);
1076 if (tev->args[i].value)
1077 free(tev->args[i].value);
1078 if (tev->args[i].type)
1079 free(tev->args[i].type);
1080 ref = tev->args[i].ref;
1081 while (ref) {
1082 next = ref->next;
1083 free(ref);
1084 ref = next;
1085 }
1086 }
1087 if (tev->args)
1088 free(tev->args);
1089 memset(tev, 0, sizeof(*tev));
1090}
1091
1092static int open_kprobe_events(bool readwrite)
409{ 1093{
410 char buf[PATH_MAX]; 1094 char buf[PATH_MAX];
1095 const char *__debugfs;
411 int ret; 1096 int ret;
412 1097
413 ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path); 1098 __debugfs = debugfs_find_mountpoint();
414 if (ret < 0) 1099 if (__debugfs == NULL) {
415 die("Failed to make kprobe_events path."); 1100 pr_warning("Debugfs is not mounted.\n");
1101 return -ENOENT;
1102 }
1103
1104 ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
1105 if (ret >= 0) {
1106 pr_debug("Opening %s write=%d\n", buf, readwrite);
1107 if (readwrite && !probe_event_dry_run)
1108 ret = open(buf, O_RDWR, O_APPEND);
1109 else
1110 ret = open(buf, O_RDONLY, 0);
1111 }
416 1112
417 ret = open(buf, flags, mode);
418 if (ret < 0) { 1113 if (ret < 0) {
419 if (errno == ENOENT) 1114 if (errno == ENOENT)
420 die("kprobe_events file does not exist -" 1115 pr_warning("kprobe_events file does not exist - please"
421 " please rebuild with CONFIG_KPROBE_EVENT."); 1116 " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
422 else 1117 else
423 die("Could not open kprobe_events file: %s", 1118 pr_warning("Failed to open kprobe_events file: %s\n",
424 strerror(errno)); 1119 strerror(errno));
425 } 1120 }
426 return ret; 1121 return ret;
427} 1122}
428 1123
429/* Get raw string list of current kprobe_events */ 1124/* Get raw string list of current kprobe_events */
430static struct strlist *get_trace_kprobe_event_rawlist(int fd) 1125static struct strlist *get_kprobe_trace_command_rawlist(int fd)
431{ 1126{
432 int ret, idx; 1127 int ret, idx;
433 FILE *fp; 1128 FILE *fp;
@@ -447,271 +1142,486 @@ static struct strlist *get_trace_kprobe_event_rawlist(int fd)
447 if (p[idx] == '\n') 1142 if (p[idx] == '\n')
448 p[idx] = '\0'; 1143 p[idx] = '\0';
449 ret = strlist__add(sl, buf); 1144 ret = strlist__add(sl, buf);
450 if (ret < 0) 1145 if (ret < 0) {
451 die("strlist__add failed: %s", strerror(-ret)); 1146 pr_debug("strlist__add failed: %s\n", strerror(-ret));
1147 strlist__delete(sl);
1148 return NULL;
1149 }
452 } 1150 }
453 fclose(fp); 1151 fclose(fp);
454 1152
455 return sl; 1153 return sl;
456} 1154}
457 1155
458/* Free and zero clear probe_point */
459static void clear_probe_point(struct probe_point *pp)
460{
461 int i;
462
463 if (pp->event)
464 free(pp->event);
465 if (pp->group)
466 free(pp->group);
467 if (pp->function)
468 free(pp->function);
469 if (pp->file)
470 free(pp->file);
471 if (pp->lazy_line)
472 free(pp->lazy_line);
473 for (i = 0; i < pp->nr_args; i++)
474 free(pp->args[i]);
475 if (pp->args)
476 free(pp->args);
477 for (i = 0; i < pp->found; i++)
478 free(pp->probes[i]);
479 memset(pp, 0, sizeof(*pp));
480}
481
482/* Show an event */ 1156/* Show an event */
483static void show_perf_probe_event(const char *event, const char *place, 1157static int show_perf_probe_event(struct perf_probe_event *pev)
484 struct probe_point *pp)
485{ 1158{
486 int i, ret; 1159 int i, ret;
487 char buf[128]; 1160 char buf[128];
1161 char *place;
1162
1163 /* Synthesize only event probe point */
1164 place = synthesize_perf_probe_point(&pev->point);
1165 if (!place)
1166 return -EINVAL;
488 1167
489 ret = e_snprintf(buf, 128, "%s:%s", pp->group, event); 1168 ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
490 if (ret < 0) 1169 if (ret < 0)
491 die("Failed to copy event: %s", strerror(-ret)); 1170 return ret;
492 printf(" %-40s (on %s", buf, place); 1171
1172 printf(" %-20s (on %s", buf, place);
493 1173
494 if (pp->nr_args > 0) { 1174 if (pev->nargs > 0) {
495 printf(" with"); 1175 printf(" with");
496 for (i = 0; i < pp->nr_args; i++) 1176 for (i = 0; i < pev->nargs; i++) {
497 printf(" %s", pp->args[i]); 1177 ret = synthesize_perf_probe_arg(&pev->args[i],
1178 buf, 128);
1179 if (ret < 0)
1180 break;
1181 printf(" %s", buf);
1182 }
498 } 1183 }
499 printf(")\n"); 1184 printf(")\n");
1185 free(place);
1186 return ret;
500} 1187}
501 1188
502/* List up current perf-probe events */ 1189/* List up current perf-probe events */
503void show_perf_probe_events(void) 1190int show_perf_probe_events(void)
504{ 1191{
505 int fd; 1192 int fd, ret;
506 struct probe_point pp; 1193 struct kprobe_trace_event tev;
1194 struct perf_probe_event pev;
507 struct strlist *rawlist; 1195 struct strlist *rawlist;
508 struct str_node *ent; 1196 struct str_node *ent;
509 1197
510 setup_pager(); 1198 setup_pager();
511 memset(&pp, 0, sizeof(pp)); 1199 ret = init_vmlinux();
1200 if (ret < 0)
1201 return ret;
1202
1203 memset(&tev, 0, sizeof(tev));
1204 memset(&pev, 0, sizeof(pev));
512 1205
513 fd = open_kprobe_events(O_RDONLY, 0); 1206 fd = open_kprobe_events(false);
514 rawlist = get_trace_kprobe_event_rawlist(fd); 1207 if (fd < 0)
1208 return fd;
1209
1210 rawlist = get_kprobe_trace_command_rawlist(fd);
515 close(fd); 1211 close(fd);
1212 if (!rawlist)
1213 return -ENOENT;
516 1214
517 strlist__for_each(ent, rawlist) { 1215 strlist__for_each(ent, rawlist) {
518 parse_trace_kprobe_event(ent->s, &pp); 1216 ret = parse_kprobe_trace_command(ent->s, &tev);
519 /* Synthesize only event probe point */ 1217 if (ret >= 0) {
520 synthesize_perf_probe_point(&pp); 1218 ret = convert_to_perf_probe_event(&tev, &pev);
521 /* Show an event */ 1219 if (ret >= 0)
522 show_perf_probe_event(pp.event, pp.probes[0], &pp); 1220 ret = show_perf_probe_event(&pev);
523 clear_probe_point(&pp); 1221 }
1222 clear_perf_probe_event(&pev);
1223 clear_kprobe_trace_event(&tev);
1224 if (ret < 0)
1225 break;
524 } 1226 }
525
526 strlist__delete(rawlist); 1227 strlist__delete(rawlist);
1228
1229 return ret;
527} 1230}
528 1231
529/* Get current perf-probe event names */ 1232/* Get current perf-probe event names */
530static struct strlist *get_perf_event_names(int fd, bool include_group) 1233static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group)
531{ 1234{
532 char buf[128]; 1235 char buf[128];
533 struct strlist *sl, *rawlist; 1236 struct strlist *sl, *rawlist;
534 struct str_node *ent; 1237 struct str_node *ent;
535 struct probe_point pp; 1238 struct kprobe_trace_event tev;
1239 int ret = 0;
536 1240
537 memset(&pp, 0, sizeof(pp)); 1241 memset(&tev, 0, sizeof(tev));
538 rawlist = get_trace_kprobe_event_rawlist(fd);
539 1242
1243 rawlist = get_kprobe_trace_command_rawlist(fd);
540 sl = strlist__new(true, NULL); 1244 sl = strlist__new(true, NULL);
541 strlist__for_each(ent, rawlist) { 1245 strlist__for_each(ent, rawlist) {
542 parse_trace_kprobe_event(ent->s, &pp); 1246 ret = parse_kprobe_trace_command(ent->s, &tev);
1247 if (ret < 0)
1248 break;
543 if (include_group) { 1249 if (include_group) {
544 if (e_snprintf(buf, 128, "%s:%s", pp.group, 1250 ret = e_snprintf(buf, 128, "%s:%s", tev.group,
545 pp.event) < 0) 1251 tev.event);
546 die("Failed to copy group:event name."); 1252 if (ret >= 0)
547 strlist__add(sl, buf); 1253 ret = strlist__add(sl, buf);
548 } else 1254 } else
549 strlist__add(sl, pp.event); 1255 ret = strlist__add(sl, tev.event);
550 clear_probe_point(&pp); 1256 clear_kprobe_trace_event(&tev);
1257 if (ret < 0)
1258 break;
551 } 1259 }
552
553 strlist__delete(rawlist); 1260 strlist__delete(rawlist);
554 1261
1262 if (ret < 0) {
1263 strlist__delete(sl);
1264 return NULL;
1265 }
555 return sl; 1266 return sl;
556} 1267}
557 1268
558static void write_trace_kprobe_event(int fd, const char *buf) 1269static int write_kprobe_trace_event(int fd, struct kprobe_trace_event *tev)
559{ 1270{
560 int ret; 1271 int ret = 0;
1272 char *buf = synthesize_kprobe_trace_command(tev);
1273
1274 if (!buf) {
1275 pr_debug("Failed to synthesize kprobe trace event.\n");
1276 return -EINVAL;
1277 }
561 1278
562 pr_debug("Writing event: %s\n", buf); 1279 pr_debug("Writing event: %s\n", buf);
563 ret = write(fd, buf, strlen(buf)); 1280 if (!probe_event_dry_run) {
564 if (ret <= 0) 1281 ret = write(fd, buf, strlen(buf));
565 die("Failed to write event: %s", strerror(errno)); 1282 if (ret <= 0)
1283 pr_warning("Failed to write event: %s\n",
1284 strerror(errno));
1285 }
1286 free(buf);
1287 return ret;
566} 1288}
567 1289
568static void get_new_event_name(char *buf, size_t len, const char *base, 1290static int get_new_event_name(char *buf, size_t len, const char *base,
569 struct strlist *namelist, bool allow_suffix) 1291 struct strlist *namelist, bool allow_suffix)
570{ 1292{
571 int i, ret; 1293 int i, ret;
572 1294
573 /* Try no suffix */ 1295 /* Try no suffix */
574 ret = e_snprintf(buf, len, "%s", base); 1296 ret = e_snprintf(buf, len, "%s", base);
575 if (ret < 0) 1297 if (ret < 0) {
576 die("snprintf() failed: %s", strerror(-ret)); 1298 pr_debug("snprintf() failed: %s\n", strerror(-ret));
1299 return ret;
1300 }
577 if (!strlist__has_entry(namelist, buf)) 1301 if (!strlist__has_entry(namelist, buf))
578 return; 1302 return 0;
579 1303
580 if (!allow_suffix) { 1304 if (!allow_suffix) {
581 pr_warning("Error: event \"%s\" already exists. " 1305 pr_warning("Error: event \"%s\" already exists. "
582 "(Use -f to force duplicates.)\n", base); 1306 "(Use -f to force duplicates.)\n", base);
583 die("Can't add new event."); 1307 return -EEXIST;
584 } 1308 }
585 1309
586 /* Try to add suffix */ 1310 /* Try to add suffix */
587 for (i = 1; i < MAX_EVENT_INDEX; i++) { 1311 for (i = 1; i < MAX_EVENT_INDEX; i++) {
588 ret = e_snprintf(buf, len, "%s_%d", base, i); 1312 ret = e_snprintf(buf, len, "%s_%d", base, i);
589 if (ret < 0) 1313 if (ret < 0) {
590 die("snprintf() failed: %s", strerror(-ret)); 1314 pr_debug("snprintf() failed: %s\n", strerror(-ret));
1315 return ret;
1316 }
591 if (!strlist__has_entry(namelist, buf)) 1317 if (!strlist__has_entry(namelist, buf))
592 break; 1318 break;
593 } 1319 }
594 if (i == MAX_EVENT_INDEX) 1320 if (i == MAX_EVENT_INDEX) {
595 die("Too many events are on the same function."); 1321 pr_warning("Too many events are on the same function.\n");
1322 ret = -ERANGE;
1323 }
1324
1325 return ret;
596} 1326}
597 1327
598void add_trace_kprobe_events(struct probe_point *probes, int nr_probes, 1328static int __add_kprobe_trace_events(struct perf_probe_event *pev,
599 bool force_add) 1329 struct kprobe_trace_event *tevs,
1330 int ntevs, bool allow_suffix)
600{ 1331{
601 int i, j, fd; 1332 int i, fd, ret;
602 struct probe_point *pp; 1333 struct kprobe_trace_event *tev = NULL;
603 char buf[MAX_CMDLEN]; 1334 char buf[64];
604 char event[64]; 1335 const char *event, *group;
605 struct strlist *namelist; 1336 struct strlist *namelist;
606 bool allow_suffix;
607 1337
608 fd = open_kprobe_events(O_RDWR, O_APPEND); 1338 fd = open_kprobe_events(true);
1339 if (fd < 0)
1340 return fd;
609 /* Get current event names */ 1341 /* Get current event names */
610 namelist = get_perf_event_names(fd, false); 1342 namelist = get_kprobe_trace_event_names(fd, false);
611 1343 if (!namelist) {
612 for (j = 0; j < nr_probes; j++) { 1344 pr_debug("Failed to get current event list.\n");
613 pp = probes + j; 1345 return -EIO;
614 if (!pp->event) 1346 }
615 pp->event = strdup(pp->function); 1347
616 if (!pp->group) 1348 ret = 0;
617 pp->group = strdup(PERFPROBE_GROUP); 1349 printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
618 DIE_IF(!pp->event || !pp->group); 1350 for (i = 0; i < ntevs; i++) {
619 /* If force_add is true, suffix search is allowed */ 1351 tev = &tevs[i];
620 allow_suffix = force_add; 1352 if (pev->event)
621 for (i = 0; i < pp->found; i++) { 1353 event = pev->event;
622 /* Get an unused new event name */ 1354 else
623 get_new_event_name(event, 64, pp->event, namelist, 1355 if (pev->point.function)
624 allow_suffix); 1356 event = pev->point.function;
625 snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s\n", 1357 else
626 pp->retprobe ? 'r' : 'p', 1358 event = tev->point.symbol;
627 pp->group, event, 1359 if (pev->group)
628 pp->probes[i]); 1360 group = pev->group;
629 write_trace_kprobe_event(fd, buf); 1361 else
630 printf("Added new event:\n"); 1362 group = PERFPROBE_GROUP;
631 /* Get the first parameter (probe-point) */ 1363
632 sscanf(pp->probes[i], "%s", buf); 1364 /* Get an unused new event name */
633 show_perf_probe_event(event, buf, pp); 1365 ret = get_new_event_name(buf, 64, event,
634 /* Add added event name to namelist */ 1366 namelist, allow_suffix);
635 strlist__add(namelist, event); 1367 if (ret < 0)
636 /* 1368 break;
637 * Probes after the first probe which comes from same 1369 event = buf;
638 * user input are always allowed to add suffix, because 1370
639 * there might be several addresses corresponding to 1371 tev->event = strdup(event);
640 * one code line. 1372 tev->group = strdup(group);
641 */ 1373 if (tev->event == NULL || tev->group == NULL) {
642 allow_suffix = true; 1374 ret = -ENOMEM;
1375 break;
643 } 1376 }
1377 ret = write_kprobe_trace_event(fd, tev);
1378 if (ret < 0)
1379 break;
1380 /* Add added event name to namelist */
1381 strlist__add(namelist, event);
1382
1383 /* Trick here - save current event/group */
1384 event = pev->event;
1385 group = pev->group;
1386 pev->event = tev->event;
1387 pev->group = tev->group;
1388 show_perf_probe_event(pev);
1389 /* Trick here - restore current event/group */
1390 pev->event = (char *)event;
1391 pev->group = (char *)group;
1392
1393 /*
1394 * Probes after the first probe which comes from same
1395 * user input are always allowed to add suffix, because
1396 * there might be several addresses corresponding to
1397 * one code line.
1398 */
1399 allow_suffix = true;
1400 }
1401
1402 if (ret >= 0) {
1403 /* Show how to use the event. */
1404 printf("\nYou can now use it on all perf tools, such as:\n\n");
1405 printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
1406 tev->event);
644 } 1407 }
645 /* Show how to use the event. */
646 printf("\nYou can now use it on all perf tools, such as:\n\n");
647 printf("\tperf record -e %s:%s -a sleep 1\n\n", PERFPROBE_GROUP, event);
648 1408
649 strlist__delete(namelist); 1409 strlist__delete(namelist);
650 close(fd); 1410 close(fd);
1411 return ret;
1412}
1413
1414static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
1415 struct kprobe_trace_event **tevs,
1416 int max_tevs)
1417{
1418 struct symbol *sym;
1419 int ret = 0, i;
1420 struct kprobe_trace_event *tev;
1421
1422 /* Convert perf_probe_event with debuginfo */
1423 ret = try_to_find_kprobe_trace_events(pev, tevs, max_tevs);
1424 if (ret != 0)
1425 return ret;
1426
1427 /* Allocate trace event buffer */
1428 tev = *tevs = zalloc(sizeof(struct kprobe_trace_event));
1429 if (tev == NULL)
1430 return -ENOMEM;
1431
1432 /* Copy parameters */
1433 tev->point.symbol = strdup(pev->point.function);
1434 if (tev->point.symbol == NULL) {
1435 ret = -ENOMEM;
1436 goto error;
1437 }
1438 tev->point.offset = pev->point.offset;
1439 tev->nargs = pev->nargs;
1440 if (tev->nargs) {
1441 tev->args = zalloc(sizeof(struct kprobe_trace_arg)
1442 * tev->nargs);
1443 if (tev->args == NULL) {
1444 ret = -ENOMEM;
1445 goto error;
1446 }
1447 for (i = 0; i < tev->nargs; i++) {
1448 if (pev->args[i].name) {
1449 tev->args[i].name = strdup(pev->args[i].name);
1450 if (tev->args[i].name == NULL) {
1451 ret = -ENOMEM;
1452 goto error;
1453 }
1454 }
1455 tev->args[i].value = strdup(pev->args[i].var);
1456 if (tev->args[i].value == NULL) {
1457 ret = -ENOMEM;
1458 goto error;
1459 }
1460 if (pev->args[i].type) {
1461 tev->args[i].type = strdup(pev->args[i].type);
1462 if (tev->args[i].type == NULL) {
1463 ret = -ENOMEM;
1464 goto error;
1465 }
1466 }
1467 }
1468 }
1469
1470 /* Currently just checking function name from symbol map */
1471 sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION],
1472 tev->point.symbol, NULL);
1473 if (!sym) {
1474 pr_warning("Kernel symbol \'%s\' not found.\n",
1475 tev->point.symbol);
1476 ret = -ENOENT;
1477 goto error;
1478 }
1479
1480 return 1;
1481error:
1482 clear_kprobe_trace_event(tev);
1483 free(tev);
1484 *tevs = NULL;
1485 return ret;
1486}
1487
1488struct __event_package {
1489 struct perf_probe_event *pev;
1490 struct kprobe_trace_event *tevs;
1491 int ntevs;
1492};
1493
1494int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
1495 bool force_add, int max_tevs)
1496{
1497 int i, j, ret;
1498 struct __event_package *pkgs;
1499
1500 pkgs = zalloc(sizeof(struct __event_package) * npevs);
1501 if (pkgs == NULL)
1502 return -ENOMEM;
1503
1504 /* Init vmlinux path */
1505 ret = init_vmlinux();
1506 if (ret < 0)
1507 return ret;
1508
1509 /* Loop 1: convert all events */
1510 for (i = 0; i < npevs; i++) {
1511 pkgs[i].pev = &pevs[i];
1512 /* Convert with or without debuginfo */
1513 ret = convert_to_kprobe_trace_events(pkgs[i].pev,
1514 &pkgs[i].tevs, max_tevs);
1515 if (ret < 0)
1516 goto end;
1517 pkgs[i].ntevs = ret;
1518 }
1519
1520 /* Loop 2: add all events */
1521 for (i = 0; i < npevs && ret >= 0; i++)
1522 ret = __add_kprobe_trace_events(pkgs[i].pev, pkgs[i].tevs,
1523 pkgs[i].ntevs, force_add);
1524end:
1525 /* Loop 3: cleanup trace events */
1526 for (i = 0; i < npevs; i++)
1527 for (j = 0; j < pkgs[i].ntevs; j++)
1528 clear_kprobe_trace_event(&pkgs[i].tevs[j]);
1529
1530 return ret;
651} 1531}
652 1532
653static void __del_trace_kprobe_event(int fd, struct str_node *ent) 1533static int __del_trace_kprobe_event(int fd, struct str_node *ent)
654{ 1534{
655 char *p; 1535 char *p;
656 char buf[128]; 1536 char buf[128];
1537 int ret;
657 1538
658 /* Convert from perf-probe event to trace-kprobe event */ 1539 /* Convert from perf-probe event to trace-kprobe event */
659 if (e_snprintf(buf, 128, "-:%s", ent->s) < 0) 1540 ret = e_snprintf(buf, 128, "-:%s", ent->s);
660 die("Failed to copy event."); 1541 if (ret < 0)
1542 goto error;
1543
661 p = strchr(buf + 2, ':'); 1544 p = strchr(buf + 2, ':');
662 if (!p) 1545 if (!p) {
663 die("Internal error: %s should have ':' but not.", ent->s); 1546 pr_debug("Internal error: %s should have ':' but not.\n",
1547 ent->s);
1548 ret = -ENOTSUP;
1549 goto error;
1550 }
664 *p = '/'; 1551 *p = '/';
665 1552
666 write_trace_kprobe_event(fd, buf); 1553 pr_debug("Writing event: %s\n", buf);
1554 ret = write(fd, buf, strlen(buf));
1555 if (ret < 0)
1556 goto error;
1557
667 printf("Remove event: %s\n", ent->s); 1558 printf("Remove event: %s\n", ent->s);
1559 return 0;
1560error:
1561 pr_warning("Failed to delete event: %s\n", strerror(-ret));
1562 return ret;
668} 1563}
669 1564
670static void del_trace_kprobe_event(int fd, const char *group, 1565static int del_trace_kprobe_event(int fd, const char *group,
671 const char *event, struct strlist *namelist) 1566 const char *event, struct strlist *namelist)
672{ 1567{
673 char buf[128]; 1568 char buf[128];
674 struct str_node *ent, *n; 1569 struct str_node *ent, *n;
675 int found = 0; 1570 int found = 0, ret = 0;
676 1571
677 if (e_snprintf(buf, 128, "%s:%s", group, event) < 0) 1572 ret = e_snprintf(buf, 128, "%s:%s", group, event);
678 die("Failed to copy event."); 1573 if (ret < 0) {
1574 pr_err("Failed to copy event.");
1575 return ret;
1576 }
679 1577
680 if (strpbrk(buf, "*?")) { /* Glob-exp */ 1578 if (strpbrk(buf, "*?")) { /* Glob-exp */
681 strlist__for_each_safe(ent, n, namelist) 1579 strlist__for_each_safe(ent, n, namelist)
682 if (strglobmatch(ent->s, buf)) { 1580 if (strglobmatch(ent->s, buf)) {
683 found++; 1581 found++;
684 __del_trace_kprobe_event(fd, ent); 1582 ret = __del_trace_kprobe_event(fd, ent);
1583 if (ret < 0)
1584 break;
685 strlist__remove(namelist, ent); 1585 strlist__remove(namelist, ent);
686 } 1586 }
687 } else { 1587 } else {
688 ent = strlist__find(namelist, buf); 1588 ent = strlist__find(namelist, buf);
689 if (ent) { 1589 if (ent) {
690 found++; 1590 found++;
691 __del_trace_kprobe_event(fd, ent); 1591 ret = __del_trace_kprobe_event(fd, ent);
692 strlist__remove(namelist, ent); 1592 if (ret >= 0)
1593 strlist__remove(namelist, ent);
693 } 1594 }
694 } 1595 }
695 if (found == 0) 1596 if (found == 0 && ret >= 0)
696 pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf); 1597 pr_info("Info: Event \"%s\" does not exist.\n", buf);
1598
1599 return ret;
697} 1600}
698 1601
699void del_trace_kprobe_events(struct strlist *dellist) 1602int del_perf_probe_events(struct strlist *dellist)
700{ 1603{
701 int fd; 1604 int fd, ret = 0;
702 const char *group, *event; 1605 const char *group, *event;
703 char *p, *str; 1606 char *p, *str;
704 struct str_node *ent; 1607 struct str_node *ent;
705 struct strlist *namelist; 1608 struct strlist *namelist;
706 1609
707 fd = open_kprobe_events(O_RDWR, O_APPEND); 1610 fd = open_kprobe_events(true);
1611 if (fd < 0)
1612 return fd;
1613
708 /* Get current event names */ 1614 /* Get current event names */
709 namelist = get_perf_event_names(fd, true); 1615 namelist = get_kprobe_trace_event_names(fd, true);
1616 if (namelist == NULL)
1617 return -EINVAL;
710 1618
711 strlist__for_each(ent, dellist) { 1619 strlist__for_each(ent, dellist) {
712 str = strdup(ent->s); 1620 str = strdup(ent->s);
713 if (!str) 1621 if (str == NULL) {
714 die("Failed to copy event."); 1622 ret = -ENOMEM;
1623 break;
1624 }
715 pr_debug("Parsing: %s\n", str); 1625 pr_debug("Parsing: %s\n", str);
716 p = strchr(str, ':'); 1626 p = strchr(str, ':');
717 if (p) { 1627 if (p) {
@@ -723,80 +1633,14 @@ void del_trace_kprobe_events(struct strlist *dellist)
723 event = str; 1633 event = str;
724 } 1634 }
725 pr_debug("Group: %s, Event: %s\n", group, event); 1635 pr_debug("Group: %s, Event: %s\n", group, event);
726 del_trace_kprobe_event(fd, group, event, namelist); 1636 ret = del_trace_kprobe_event(fd, group, event, namelist);
727 free(str); 1637 free(str);
1638 if (ret < 0)
1639 break;
728 } 1640 }
729 strlist__delete(namelist); 1641 strlist__delete(namelist);
730 close(fd); 1642 close(fd);
731}
732 1643
733#define LINEBUF_SIZE 256 1644 return ret;
734#define NR_ADDITIONAL_LINES 2
735
736static void show_one_line(FILE *fp, unsigned int l, bool skip, bool show_num)
737{
738 char buf[LINEBUF_SIZE];
739 const char *color = PERF_COLOR_BLUE;
740
741 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
742 goto error;
743 if (!skip) {
744 if (show_num)
745 fprintf(stdout, "%7u %s", l, buf);
746 else
747 color_fprintf(stdout, color, " %s", buf);
748 }
749
750 while (strlen(buf) == LINEBUF_SIZE - 1 &&
751 buf[LINEBUF_SIZE - 2] != '\n') {
752 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
753 goto error;
754 if (!skip) {
755 if (show_num)
756 fprintf(stdout, "%s", buf);
757 else
758 color_fprintf(stdout, color, "%s", buf);
759 }
760 }
761 return;
762error:
763 if (feof(fp))
764 die("Source file is shorter than expected.");
765 else
766 die("File read error: %s", strerror(errno));
767} 1645}
768 1646
769void show_line_range(struct line_range *lr)
770{
771 unsigned int l = 1;
772 struct line_node *ln;
773 FILE *fp;
774
775 setup_pager();
776
777 if (lr->function)
778 fprintf(stdout, "<%s:%d>\n", lr->function,
779 lr->start - lr->offset);
780 else
781 fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
782
783 fp = fopen(lr->path, "r");
784 if (fp == NULL)
785 die("Failed to open %s: %s", lr->path, strerror(errno));
786 /* Skip to starting line number */
787 while (l < lr->start)
788 show_one_line(fp, l++, true, false);
789
790 list_for_each_entry(ln, &lr->line_list, list) {
791 while (ln->line > l)
792 show_one_line(fp, (l++) - lr->offset, false, false);
793 show_one_line(fp, (l++) - lr->offset, false, true);
794 }
795
796 if (lr->end == INT_MAX)
797 lr->end = l + NR_ADDITIONAL_LINES;
798 while (l < lr->end && !feof(fp))
799 show_one_line(fp, (l++) - lr->offset, false, false);
800
801 fclose(fp);
802}
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 711287d4bae..e9db1a214ca 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -2,21 +2,125 @@
2#define _PROBE_EVENT_H 2#define _PROBE_EVENT_H
3 3
4#include <stdbool.h> 4#include <stdbool.h>
5#include "probe-finder.h"
6#include "strlist.h" 5#include "strlist.h"
7 6
8extern void parse_line_range_desc(const char *arg, struct line_range *lr); 7extern bool probe_event_dry_run;
9extern void parse_perf_probe_event(const char *str, struct probe_point *pp, 8
10 bool *need_dwarf); 9/* kprobe-tracer tracing point */
11extern int synthesize_perf_probe_point(struct probe_point *pp); 10struct kprobe_trace_point {
12extern int synthesize_perf_probe_event(struct probe_point *pp); 11 char *symbol; /* Base symbol */
13extern void parse_trace_kprobe_event(const char *str, struct probe_point *pp); 12 unsigned long offset; /* Offset from symbol */
14extern int synthesize_trace_kprobe_event(struct probe_point *pp); 13 bool retprobe; /* Return probe flag */
15extern void add_trace_kprobe_events(struct probe_point *probes, int nr_probes, 14};
16 bool force_add); 15
17extern void del_trace_kprobe_events(struct strlist *dellist); 16/* kprobe-tracer tracing argument referencing offset */
18extern void show_perf_probe_events(void); 17struct kprobe_trace_arg_ref {
19extern void show_line_range(struct line_range *lr); 18 struct kprobe_trace_arg_ref *next; /* Next reference */
19 long offset; /* Offset value */
20};
21
22/* kprobe-tracer tracing argument */
23struct kprobe_trace_arg {
24 char *name; /* Argument name */
25 char *value; /* Base value */
26 char *type; /* Type name */
27 struct kprobe_trace_arg_ref *ref; /* Referencing offset */
28};
29
30/* kprobe-tracer tracing event (point + arg) */
31struct kprobe_trace_event {
32 char *event; /* Event name */
33 char *group; /* Group name */
34 struct kprobe_trace_point point; /* Trace point */
35 int nargs; /* Number of args */
36 struct kprobe_trace_arg *args; /* Arguments */
37};
38
39/* Perf probe probing point */
40struct perf_probe_point {
41 char *file; /* File path */
42 char *function; /* Function name */
43 int line; /* Line number */
44 bool retprobe; /* Return probe flag */
45 char *lazy_line; /* Lazy matching pattern */
46 unsigned long offset; /* Offset from function entry */
47};
48
49/* Perf probe probing argument field chain */
50struct perf_probe_arg_field {
51 struct perf_probe_arg_field *next; /* Next field */
52 char *name; /* Name of the field */
53 bool ref; /* Referencing flag */
54};
55
56/* Perf probe probing argument */
57struct perf_probe_arg {
58 char *name; /* Argument name */
59 char *var; /* Variable name */
60 char *type; /* Type name */
61 struct perf_probe_arg_field *field; /* Structure fields */
62};
63
64/* Perf probe probing event (point + arg) */
65struct perf_probe_event {
66 char *event; /* Event name */
67 char *group; /* Group name */
68 struct perf_probe_point point; /* Probe point */
69 int nargs; /* Number of arguments */
70 struct perf_probe_arg *args; /* Arguments */
71};
72
73
74/* Line number container */
75struct line_node {
76 struct list_head list;
77 int line;
78};
79
80/* Line range */
81struct line_range {
82 char *file; /* File name */
83 char *function; /* Function name */
84 int start; /* Start line number */
85 int end; /* End line number */
86 int offset; /* Start line offset */
87 char *path; /* Real path name */
88 struct list_head line_list; /* Visible lines */
89};
90
91/* Command string to events */
92extern int parse_perf_probe_command(const char *cmd,
93 struct perf_probe_event *pev);
94extern int parse_kprobe_trace_command(const char *cmd,
95 struct kprobe_trace_event *tev);
96
97/* Events to command string */
98extern char *synthesize_perf_probe_command(struct perf_probe_event *pev);
99extern char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev);
100extern int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf,
101 size_t len);
102
103/* Check the perf_probe_event needs debuginfo */
104extern bool perf_probe_event_need_dwarf(struct perf_probe_event *pev);
105
106/* Convert from kprobe_trace_event to perf_probe_event */
107extern int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
108 struct perf_probe_event *pev);
109
110/* Release event contents */
111extern void clear_perf_probe_event(struct perf_probe_event *pev);
112extern void clear_kprobe_trace_event(struct kprobe_trace_event *tev);
113
114/* Command string to line-range */
115extern int parse_line_range_desc(const char *cmd, struct line_range *lr);
116
117
118extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
119 bool force_add, int max_probe_points);
120extern int del_perf_probe_events(struct strlist *dellist);
121extern int show_perf_probe_events(void);
122extern int show_line_range(struct line_range *lr);
123
20 124
21/* Maximum index number of event-name postfix */ 125/* Maximum index number of event-name postfix */
22#define MAX_EVENT_INDEX 1024 126#define MAX_EVENT_INDEX 1024
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index c171a243d05..d964cb199c6 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -31,6 +31,7 @@
31#include <string.h> 31#include <string.h>
32#include <stdarg.h> 32#include <stdarg.h>
33#include <ctype.h> 33#include <ctype.h>
34#include <dwarf-regs.h>
34 35
35#include "string.h" 36#include "string.h"
36#include "event.h" 37#include "event.h"
@@ -38,57 +39,8 @@
38#include "util.h" 39#include "util.h"
39#include "probe-finder.h" 40#include "probe-finder.h"
40 41
41 42/* Kprobe tracer basic type is up to u64 */
42/* 43#define MAX_BASIC_TYPE_BITS 64
43 * Generic dwarf analysis helpers
44 */
45
46#define X86_32_MAX_REGS 8
47const char *x86_32_regs_table[X86_32_MAX_REGS] = {
48 "%ax",
49 "%cx",
50 "%dx",
51 "%bx",
52 "$stack", /* Stack address instead of %sp */
53 "%bp",
54 "%si",
55 "%di",
56};
57
58#define X86_64_MAX_REGS 16
59const char *x86_64_regs_table[X86_64_MAX_REGS] = {
60 "%ax",
61 "%dx",
62 "%cx",
63 "%bx",
64 "%si",
65 "%di",
66 "%bp",
67 "%sp",
68 "%r8",
69 "%r9",
70 "%r10",
71 "%r11",
72 "%r12",
73 "%r13",
74 "%r14",
75 "%r15",
76};
77
78/* TODO: switching by dwarf address size */
79#ifdef __x86_64__
80#define ARCH_MAX_REGS X86_64_MAX_REGS
81#define arch_regs_table x86_64_regs_table
82#else
83#define ARCH_MAX_REGS X86_32_MAX_REGS
84#define arch_regs_table x86_32_regs_table
85#endif
86
87/* Return architecture dependent register string (for kprobe-tracer) */
88static const char *get_arch_regstr(unsigned int n)
89{
90 return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
91}
92 44
93/* 45/*
94 * Compare the tail of two strings. 46 * Compare the tail of two strings.
@@ -108,7 +60,7 @@ static int strtailcmp(const char *s1, const char *s2)
108/* Line number list operations */ 60/* Line number list operations */
109 61
110/* Add a line to line number list */ 62/* Add a line to line number list */
111static void line_list__add_line(struct list_head *head, unsigned int line) 63static int line_list__add_line(struct list_head *head, int line)
112{ 64{
113 struct line_node *ln; 65 struct line_node *ln;
114 struct list_head *p; 66 struct list_head *p;
@@ -119,21 +71,23 @@ static void line_list__add_line(struct list_head *head, unsigned int line)
119 p = &ln->list; 71 p = &ln->list;
120 goto found; 72 goto found;
121 } else if (ln->line == line) /* Already exist */ 73 } else if (ln->line == line) /* Already exist */
122 return ; 74 return 1;
123 } 75 }
124 /* List is empty, or the smallest entry */ 76 /* List is empty, or the smallest entry */
125 p = head; 77 p = head;
126found: 78found:
127 pr_debug("line list: add a line %u\n", line); 79 pr_debug("line list: add a line %u\n", line);
128 ln = zalloc(sizeof(struct line_node)); 80 ln = zalloc(sizeof(struct line_node));
129 DIE_IF(ln == NULL); 81 if (ln == NULL)
82 return -ENOMEM;
130 ln->line = line; 83 ln->line = line;
131 INIT_LIST_HEAD(&ln->list); 84 INIT_LIST_HEAD(&ln->list);
132 list_add(&ln->list, p); 85 list_add(&ln->list, p);
86 return 0;
133} 87}
134 88
135/* Check if the line in line number list */ 89/* Check if the line in line number list */
136static int line_list__has_line(struct list_head *head, unsigned int line) 90static int line_list__has_line(struct list_head *head, int line)
137{ 91{
138 struct line_node *ln; 92 struct line_node *ln;
139 93
@@ -184,9 +138,129 @@ static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
184 if (strtailcmp(src, fname) == 0) 138 if (strtailcmp(src, fname) == 0)
185 break; 139 break;
186 } 140 }
141 if (i == nfiles)
142 return NULL;
187 return src; 143 return src;
188} 144}
189 145
146/* Compare diename and tname */
147static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
148{
149 const char *name;
150 name = dwarf_diename(dw_die);
151 return name ? strcmp(tname, name) : -1;
152}
153
154/* Get type die, but skip qualifiers and typedef */
155static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
156{
157 Dwarf_Attribute attr;
158 int tag;
159
160 do {
161 if (dwarf_attr(vr_die, DW_AT_type, &attr) == NULL ||
162 dwarf_formref_die(&attr, die_mem) == NULL)
163 return NULL;
164
165 tag = dwarf_tag(die_mem);
166 vr_die = die_mem;
167 } while (tag == DW_TAG_const_type ||
168 tag == DW_TAG_restrict_type ||
169 tag == DW_TAG_volatile_type ||
170 tag == DW_TAG_shared_type ||
171 tag == DW_TAG_typedef);
172
173 return die_mem;
174}
175
176static bool die_is_signed_type(Dwarf_Die *tp_die)
177{
178 Dwarf_Attribute attr;
179 Dwarf_Word ret;
180
181 if (dwarf_attr(tp_die, DW_AT_encoding, &attr) == NULL ||
182 dwarf_formudata(&attr, &ret) != 0)
183 return false;
184
185 return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
186 ret == DW_ATE_signed_fixed);
187}
188
189static int die_get_byte_size(Dwarf_Die *tp_die)
190{
191 Dwarf_Attribute attr;
192 Dwarf_Word ret;
193
194 if (dwarf_attr(tp_die, DW_AT_byte_size, &attr) == NULL ||
195 dwarf_formudata(&attr, &ret) != 0)
196 return 0;
197
198 return (int)ret;
199}
200
201/* Get data_member_location offset */
202static int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
203{
204 Dwarf_Attribute attr;
205 Dwarf_Op *expr;
206 size_t nexpr;
207 int ret;
208
209 if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
210 return -ENOENT;
211
212 if (dwarf_formudata(&attr, offs) != 0) {
213 /* DW_AT_data_member_location should be DW_OP_plus_uconst */
214 ret = dwarf_getlocation(&attr, &expr, &nexpr);
215 if (ret < 0 || nexpr == 0)
216 return -ENOENT;
217
218 if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
219 pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
220 expr[0].atom, nexpr);
221 return -ENOTSUP;
222 }
223 *offs = (Dwarf_Word)expr[0].number;
224 }
225 return 0;
226}
227
228/* Return values for die_find callbacks */
229enum {
230 DIE_FIND_CB_FOUND = 0, /* End of Search */
231 DIE_FIND_CB_CHILD = 1, /* Search only children */
232 DIE_FIND_CB_SIBLING = 2, /* Search only siblings */
233 DIE_FIND_CB_CONTINUE = 3, /* Search children and siblings */
234};
235
236/* Search a child die */
237static Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
238 int (*callback)(Dwarf_Die *, void *),
239 void *data, Dwarf_Die *die_mem)
240{
241 Dwarf_Die child_die;
242 int ret;
243
244 ret = dwarf_child(rt_die, die_mem);
245 if (ret != 0)
246 return NULL;
247
248 do {
249 ret = callback(die_mem, data);
250 if (ret == DIE_FIND_CB_FOUND)
251 return die_mem;
252
253 if ((ret & DIE_FIND_CB_CHILD) &&
254 die_find_child(die_mem, callback, data, &child_die)) {
255 memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
256 return die_mem;
257 }
258 } while ((ret & DIE_FIND_CB_SIBLING) &&
259 dwarf_siblingof(die_mem, die_mem) == 0);
260
261 return NULL;
262}
263
190struct __addr_die_search_param { 264struct __addr_die_search_param {
191 Dwarf_Addr addr; 265 Dwarf_Addr addr;
192 Dwarf_Die *die_mem; 266 Dwarf_Die *die_mem;
@@ -205,8 +279,8 @@ static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
205} 279}
206 280
207/* Search a real subprogram including this line, */ 281/* Search a real subprogram including this line, */
208static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr, 282static Dwarf_Die *die_find_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
209 Dwarf_Die *die_mem) 283 Dwarf_Die *die_mem)
210{ 284{
211 struct __addr_die_search_param ad; 285 struct __addr_die_search_param ad;
212 ad.addr = addr; 286 ad.addr = addr;
@@ -218,77 +292,64 @@ static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
218 return die_mem; 292 return die_mem;
219} 293}
220 294
221/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */ 295/* die_find callback for inline function search */
222static Dwarf_Die *die_get_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr, 296static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
223 Dwarf_Die *die_mem)
224{ 297{
225 Dwarf_Die child_die; 298 Dwarf_Addr *addr = data;
226 int ret;
227 299
228 ret = dwarf_child(sp_die, die_mem); 300 if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
229 if (ret != 0) 301 dwarf_haspc(die_mem, *addr))
230 return NULL; 302 return DIE_FIND_CB_FOUND;
231
232 do {
233 if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
234 dwarf_haspc(die_mem, addr))
235 return die_mem;
236
237 if (die_get_inlinefunc(die_mem, addr, &child_die)) {
238 memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
239 return die_mem;
240 }
241 } while (dwarf_siblingof(die_mem, die_mem) == 0);
242 303
243 return NULL; 304 return DIE_FIND_CB_CONTINUE;
244} 305}
245 306
246/* Compare diename and tname */ 307/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
247static bool die_compare_name(Dwarf_Die *dw_die, const char *tname) 308static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
309 Dwarf_Die *die_mem)
248{ 310{
249 const char *name; 311 return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
250 name = dwarf_diename(dw_die);
251 DIE_IF(name == NULL);
252 return strcmp(tname, name);
253} 312}
254 313
255/* Get entry pc(or low pc, 1st entry of ranges) of the die */ 314static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
256static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
257{ 315{
258 Dwarf_Addr epc; 316 const char *name = data;
259 int ret; 317 int tag;
318
319 tag = dwarf_tag(die_mem);
320 if ((tag == DW_TAG_formal_parameter ||
321 tag == DW_TAG_variable) &&
322 (die_compare_name(die_mem, name) == 0))
323 return DIE_FIND_CB_FOUND;
260 324
261 ret = dwarf_entrypc(dw_die, &epc); 325 return DIE_FIND_CB_CONTINUE;
262 DIE_IF(ret == -1);
263 return epc;
264} 326}
265 327
266/* Get a variable die */ 328/* Find a variable called 'name' */
267static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name, 329static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
268 Dwarf_Die *die_mem) 330 Dwarf_Die *die_mem)
269{ 331{
270 Dwarf_Die child_die; 332 return die_find_child(sp_die, __die_find_variable_cb, (void *)name,
271 int tag; 333 die_mem);
272 int ret; 334}
273 335
274 ret = dwarf_child(sp_die, die_mem); 336static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
275 if (ret != 0) 337{
276 return NULL; 338 const char *name = data;
277 339
278 do { 340 if ((dwarf_tag(die_mem) == DW_TAG_member) &&
279 tag = dwarf_tag(die_mem); 341 (die_compare_name(die_mem, name) == 0))
280 if ((tag == DW_TAG_formal_parameter || 342 return DIE_FIND_CB_FOUND;
281 tag == DW_TAG_variable) &&
282 (die_compare_name(die_mem, name) == 0))
283 return die_mem;
284 343
285 if (die_find_variable(die_mem, name, &child_die)) { 344 return DIE_FIND_CB_SIBLING;
286 memcpy(die_mem, &child_die, sizeof(Dwarf_Die)); 345}
287 return die_mem;
288 }
289 } while (dwarf_siblingof(die_mem, die_mem) == 0);
290 346
291 return NULL; 347/* Find a member called 'name' */
348static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
349 Dwarf_Die *die_mem)
350{
351 return die_find_child(st_die, __die_find_member_cb, (void *)name,
352 die_mem);
292} 353}
293 354
294/* 355/*
@@ -296,19 +357,22 @@ static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
296 */ 357 */
297 358
298/* Show a location */ 359/* Show a location */
299static void show_location(Dwarf_Op *op, struct probe_finder *pf) 360static int convert_location(Dwarf_Op *op, struct probe_finder *pf)
300{ 361{
301 unsigned int regn; 362 unsigned int regn;
302 Dwarf_Word offs = 0; 363 Dwarf_Word offs = 0;
303 int deref = 0, ret; 364 bool ref = false;
304 const char *regs; 365 const char *regs;
366 struct kprobe_trace_arg *tvar = pf->tvar;
305 367
306 /* TODO: support CFA */
307 /* If this is based on frame buffer, set the offset */ 368 /* If this is based on frame buffer, set the offset */
308 if (op->atom == DW_OP_fbreg) { 369 if (op->atom == DW_OP_fbreg) {
309 if (pf->fb_ops == NULL) 370 if (pf->fb_ops == NULL) {
310 die("The attribute of frame base is not supported.\n"); 371 pr_warning("The attribute of frame base is not "
311 deref = 1; 372 "supported.\n");
373 return -ENOTSUP;
374 }
375 ref = true;
312 offs = op->number; 376 offs = op->number;
313 op = &pf->fb_ops[0]; 377 op = &pf->fb_ops[0];
314 } 378 }
@@ -316,35 +380,164 @@ static void show_location(Dwarf_Op *op, struct probe_finder *pf)
316 if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) { 380 if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
317 regn = op->atom - DW_OP_breg0; 381 regn = op->atom - DW_OP_breg0;
318 offs += op->number; 382 offs += op->number;
319 deref = 1; 383 ref = true;
320 } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) { 384 } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
321 regn = op->atom - DW_OP_reg0; 385 regn = op->atom - DW_OP_reg0;
322 } else if (op->atom == DW_OP_bregx) { 386 } else if (op->atom == DW_OP_bregx) {
323 regn = op->number; 387 regn = op->number;
324 offs += op->number2; 388 offs += op->number2;
325 deref = 1; 389 ref = true;
326 } else if (op->atom == DW_OP_regx) { 390 } else if (op->atom == DW_OP_regx) {
327 regn = op->number; 391 regn = op->number;
328 } else 392 } else {
329 die("DW_OP %d is not supported.", op->atom); 393 pr_warning("DW_OP %x is not supported.\n", op->atom);
394 return -ENOTSUP;
395 }
330 396
331 regs = get_arch_regstr(regn); 397 regs = get_arch_regstr(regn);
332 if (!regs) 398 if (!regs) {
333 die("%u exceeds max register number.", regn); 399 pr_warning("Mapping for DWARF register number %u missing on this architecture.", regn);
400 return -ERANGE;
401 }
402
403 tvar->value = strdup(regs);
404 if (tvar->value == NULL)
405 return -ENOMEM;
406
407 if (ref) {
408 tvar->ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
409 if (tvar->ref == NULL)
410 return -ENOMEM;
411 tvar->ref->offset = (long)offs;
412 }
413 return 0;
414}
415
416static int convert_variable_type(Dwarf_Die *vr_die,
417 struct kprobe_trace_arg *targ)
418{
419 Dwarf_Die type;
420 char buf[16];
421 int ret;
422
423 if (die_get_real_type(vr_die, &type) == NULL) {
424 pr_warning("Failed to get a type information of %s.\n",
425 dwarf_diename(vr_die));
426 return -ENOENT;
427 }
428
429 ret = die_get_byte_size(&type) * 8;
430 if (ret) {
431 /* Check the bitwidth */
432 if (ret > MAX_BASIC_TYPE_BITS) {
433 pr_info("%s exceeds max-bitwidth."
434 " Cut down to %d bits.\n",
435 dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
436 ret = MAX_BASIC_TYPE_BITS;
437 }
438
439 ret = snprintf(buf, 16, "%c%d",
440 die_is_signed_type(&type) ? 's' : 'u', ret);
441 if (ret < 0 || ret >= 16) {
442 if (ret >= 16)
443 ret = -E2BIG;
444 pr_warning("Failed to convert variable type: %s\n",
445 strerror(-ret));
446 return ret;
447 }
448 targ->type = strdup(buf);
449 if (targ->type == NULL)
450 return -ENOMEM;
451 }
452 return 0;
453}
454
455static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
456 struct perf_probe_arg_field *field,
457 struct kprobe_trace_arg_ref **ref_ptr,
458 Dwarf_Die *die_mem)
459{
460 struct kprobe_trace_arg_ref *ref = *ref_ptr;
461 Dwarf_Die type;
462 Dwarf_Word offs;
463 int ret;
334 464
335 if (deref) 465 pr_debug("converting %s in %s\n", field->name, varname);
336 ret = snprintf(pf->buf, pf->len, " %s=%+jd(%s)", 466 if (die_get_real_type(vr_die, &type) == NULL) {
337 pf->var, (intmax_t)offs, regs); 467 pr_warning("Failed to get the type of %s.\n", varname);
468 return -ENOENT;
469 }
470
471 /* Check the pointer and dereference */
472 if (dwarf_tag(&type) == DW_TAG_pointer_type) {
473 if (!field->ref) {
474 pr_err("Semantic error: %s must be referred by '->'\n",
475 field->name);
476 return -EINVAL;
477 }
478 /* Get the type pointed by this pointer */
479 if (die_get_real_type(&type, &type) == NULL) {
480 pr_warning("Failed to get the type of %s.\n", varname);
481 return -ENOENT;
482 }
483 /* Verify it is a data structure */
484 if (dwarf_tag(&type) != DW_TAG_structure_type) {
485 pr_warning("%s is not a data structure.\n", varname);
486 return -EINVAL;
487 }
488
489 ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
490 if (ref == NULL)
491 return -ENOMEM;
492 if (*ref_ptr)
493 (*ref_ptr)->next = ref;
494 else
495 *ref_ptr = ref;
496 } else {
497 /* Verify it is a data structure */
498 if (dwarf_tag(&type) != DW_TAG_structure_type) {
499 pr_warning("%s is not a data structure.\n", varname);
500 return -EINVAL;
501 }
502 if (field->ref) {
503 pr_err("Semantic error: %s must be referred by '.'\n",
504 field->name);
505 return -EINVAL;
506 }
507 if (!ref) {
508 pr_warning("Structure on a register is not "
509 "supported yet.\n");
510 return -ENOTSUP;
511 }
512 }
513
514 if (die_find_member(&type, field->name, die_mem) == NULL) {
515 pr_warning("%s(tyep:%s) has no member %s.\n", varname,
516 dwarf_diename(&type), field->name);
517 return -EINVAL;
518 }
519
520 /* Get the offset of the field */
521 ret = die_get_data_member_location(die_mem, &offs);
522 if (ret < 0) {
523 pr_warning("Failed to get the offset of %s.\n", field->name);
524 return ret;
525 }
526 ref->offset += (long)offs;
527
528 /* Converting next field */
529 if (field->next)
530 return convert_variable_fields(die_mem, field->name,
531 field->next, &ref, die_mem);
338 else 532 else
339 ret = snprintf(pf->buf, pf->len, " %s=%s", pf->var, regs); 533 return 0;
340 DIE_IF(ret < 0);
341 DIE_IF(ret >= pf->len);
342} 534}
343 535
344/* Show a variables in kprobe event format */ 536/* Show a variables in kprobe event format */
345static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf) 537static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
346{ 538{
347 Dwarf_Attribute attr; 539 Dwarf_Attribute attr;
540 Dwarf_Die die_mem;
348 Dwarf_Op *expr; 541 Dwarf_Op *expr;
349 size_t nexpr; 542 size_t nexpr;
350 int ret; 543 int ret;
@@ -356,142 +549,193 @@ static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
356 if (ret <= 0 || nexpr == 0) 549 if (ret <= 0 || nexpr == 0)
357 goto error; 550 goto error;
358 551
359 show_location(expr, pf); 552 ret = convert_location(expr, pf);
553 if (ret == 0 && pf->pvar->field) {
554 ret = convert_variable_fields(vr_die, pf->pvar->var,
555 pf->pvar->field, &pf->tvar->ref,
556 &die_mem);
557 vr_die = &die_mem;
558 }
559 if (ret == 0) {
560 if (pf->pvar->type) {
561 pf->tvar->type = strdup(pf->pvar->type);
562 if (pf->tvar->type == NULL)
563 ret = -ENOMEM;
564 } else
565 ret = convert_variable_type(vr_die, pf->tvar);
566 }
360 /* *expr will be cached in libdw. Don't free it. */ 567 /* *expr will be cached in libdw. Don't free it. */
361 return ; 568 return ret;
362error: 569error:
363 /* TODO: Support const_value */ 570 /* TODO: Support const_value */
364 die("Failed to find the location of %s at this address.\n" 571 pr_err("Failed to find the location of %s at this address.\n"
365 " Perhaps, it has been optimized out.", pf->var); 572 " Perhaps, it has been optimized out.\n", pf->pvar->var);
573 return -ENOENT;
366} 574}
367 575
368/* Find a variable in a subprogram die */ 576/* Find a variable in a subprogram die */
369static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf) 577static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
370{ 578{
371 int ret;
372 Dwarf_Die vr_die; 579 Dwarf_Die vr_die;
580 char buf[32], *ptr;
581 int ret;
373 582
374 /* TODO: Support struct members and arrays */ 583 /* TODO: Support arrays */
375 if (!is_c_varname(pf->var)) { 584 if (pf->pvar->name)
376 /* Output raw parameters */ 585 pf->tvar->name = strdup(pf->pvar->name);
377 ret = snprintf(pf->buf, pf->len, " %s", pf->var); 586 else {
378 DIE_IF(ret < 0); 587 ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
379 DIE_IF(ret >= pf->len); 588 if (ret < 0)
380 return ; 589 return ret;
590 ptr = strchr(buf, ':'); /* Change type separator to _ */
591 if (ptr)
592 *ptr = '_';
593 pf->tvar->name = strdup(buf);
594 }
595 if (pf->tvar->name == NULL)
596 return -ENOMEM;
597
598 if (!is_c_varname(pf->pvar->var)) {
599 /* Copy raw parameters */
600 pf->tvar->value = strdup(pf->pvar->var);
601 if (pf->tvar->value == NULL)
602 return -ENOMEM;
603 else
604 return 0;
381 } 605 }
382 606
383 pr_debug("Searching '%s' variable in context.\n", pf->var); 607 pr_debug("Searching '%s' variable in context.\n",
608 pf->pvar->var);
384 /* Search child die for local variables and parameters. */ 609 /* Search child die for local variables and parameters. */
385 if (!die_find_variable(sp_die, pf->var, &vr_die)) 610 if (!die_find_variable(sp_die, pf->pvar->var, &vr_die)) {
386 die("Failed to find '%s' in this function.", pf->var); 611 pr_warning("Failed to find '%s' in this function.\n",
387 612 pf->pvar->var);
388 show_variable(&vr_die, pf); 613 return -ENOENT;
614 }
615 return convert_variable(&vr_die, pf);
389} 616}
390 617
391/* Show a probe point to output buffer */ 618/* Show a probe point to output buffer */
392static void show_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf) 619static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
393{ 620{
394 struct probe_point *pp = pf->pp; 621 struct kprobe_trace_event *tev;
395 Dwarf_Addr eaddr; 622 Dwarf_Addr eaddr;
396 Dwarf_Die die_mem; 623 Dwarf_Die die_mem;
397 const char *name; 624 const char *name;
398 char tmp[MAX_PROBE_BUFFER]; 625 int ret, i;
399 int ret, i, len;
400 Dwarf_Attribute fb_attr; 626 Dwarf_Attribute fb_attr;
401 size_t nops; 627 size_t nops;
402 628
629 if (pf->ntevs == pf->max_tevs) {
630 pr_warning("Too many( > %d) probe point found.\n",
631 pf->max_tevs);
632 return -ERANGE;
633 }
634 tev = &pf->tevs[pf->ntevs++];
635
403 /* If no real subprogram, find a real one */ 636 /* If no real subprogram, find a real one */
404 if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) { 637 if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
405 sp_die = die_get_real_subprogram(&pf->cu_die, 638 sp_die = die_find_real_subprogram(&pf->cu_die,
406 pf->addr, &die_mem); 639 pf->addr, &die_mem);
407 if (!sp_die) 640 if (!sp_die) {
408 die("Probe point is not found in subprograms."); 641 pr_warning("Failed to find probe point in any "
642 "functions.\n");
643 return -ENOENT;
644 }
409 } 645 }
410 646
411 /* Output name of probe point */ 647 /* Copy the name of probe point */
412 name = dwarf_diename(sp_die); 648 name = dwarf_diename(sp_die);
413 if (name) { 649 if (name) {
414 dwarf_entrypc(sp_die, &eaddr); 650 if (dwarf_entrypc(sp_die, &eaddr) != 0) {
415 ret = snprintf(tmp, MAX_PROBE_BUFFER, "%s+%lu", name, 651 pr_warning("Failed to get entry pc of %s\n",
416 (unsigned long)(pf->addr - eaddr)); 652 dwarf_diename(sp_die));
417 /* Copy the function name if possible */ 653 return -ENOENT;
418 if (!pp->function) {
419 pp->function = strdup(name);
420 pp->offset = (size_t)(pf->addr - eaddr);
421 } 654 }
422 } else { 655 tev->point.symbol = strdup(name);
656 if (tev->point.symbol == NULL)
657 return -ENOMEM;
658 tev->point.offset = (unsigned long)(pf->addr - eaddr);
659 } else
423 /* This function has no name. */ 660 /* This function has no name. */
424 ret = snprintf(tmp, MAX_PROBE_BUFFER, "0x%jx", 661 tev->point.offset = (unsigned long)pf->addr;
425 (uintmax_t)pf->addr); 662
426 if (!pp->function) { 663 pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
427 /* TODO: Use _stext */ 664 tev->point.offset);
428 pp->function = strdup("");
429 pp->offset = (size_t)pf->addr;
430 }
431 }
432 DIE_IF(ret < 0);
433 DIE_IF(ret >= MAX_PROBE_BUFFER);
434 len = ret;
435 pr_debug("Probe point found: %s\n", tmp);
436 665
437 /* Get the frame base attribute/ops */ 666 /* Get the frame base attribute/ops */
438 dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr); 667 dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
439 ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1); 668 ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
440 if (ret <= 0 || nops == 0) 669 if (ret <= 0 || nops == 0) {
441 pf->fb_ops = NULL; 670 pf->fb_ops = NULL;
671#if _ELFUTILS_PREREQ(0, 142)
672 } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
673 pf->cfi != NULL) {
674 Dwarf_Frame *frame;
675 if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
676 dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
677 pr_warning("Failed to get CFA on 0x%jx\n",
678 (uintmax_t)pf->addr);
679 return -ENOENT;
680 }
681#endif
682 }
442 683
443 /* Find each argument */ 684 /* Find each argument */
444 /* TODO: use dwarf_cfi_addrframe */ 685 tev->nargs = pf->pev->nargs;
445 for (i = 0; i < pp->nr_args; i++) { 686 tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
446 pf->var = pp->args[i]; 687 if (tev->args == NULL)
447 pf->buf = &tmp[len]; 688 return -ENOMEM;
448 pf->len = MAX_PROBE_BUFFER - len; 689 for (i = 0; i < pf->pev->nargs; i++) {
449 find_variable(sp_die, pf); 690 pf->pvar = &pf->pev->args[i];
450 len += strlen(pf->buf); 691 pf->tvar = &tev->args[i];
692 ret = find_variable(sp_die, pf);
693 if (ret != 0)
694 return ret;
451 } 695 }
452 696
453 /* *pf->fb_ops will be cached in libdw. Don't free it. */ 697 /* *pf->fb_ops will be cached in libdw. Don't free it. */
454 pf->fb_ops = NULL; 698 pf->fb_ops = NULL;
455 699 return 0;
456 if (pp->found == MAX_PROBES)
457 die("Too many( > %d) probe point found.\n", MAX_PROBES);
458
459 pp->probes[pp->found] = strdup(tmp);
460 pp->found++;
461} 700}
462 701
463/* Find probe point from its line number */ 702/* Find probe point from its line number */
464static void find_probe_point_by_line(struct probe_finder *pf) 703static int find_probe_point_by_line(struct probe_finder *pf)
465{ 704{
466 Dwarf_Lines *lines; 705 Dwarf_Lines *lines;
467 Dwarf_Line *line; 706 Dwarf_Line *line;
468 size_t nlines, i; 707 size_t nlines, i;
469 Dwarf_Addr addr; 708 Dwarf_Addr addr;
470 int lineno; 709 int lineno;
471 int ret; 710 int ret = 0;
472 711
473 ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines); 712 if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
474 DIE_IF(ret != 0); 713 pr_warning("No source lines found in this CU.\n");
714 return -ENOENT;
715 }
475 716
476 for (i = 0; i < nlines; i++) { 717 for (i = 0; i < nlines && ret == 0; i++) {
477 line = dwarf_onesrcline(lines, i); 718 line = dwarf_onesrcline(lines, i);
478 dwarf_lineno(line, &lineno); 719 if (dwarf_lineno(line, &lineno) != 0 ||
479 if (lineno != pf->lno) 720 lineno != pf->lno)
480 continue; 721 continue;
481 722
482 /* TODO: Get fileno from line, but how? */ 723 /* TODO: Get fileno from line, but how? */
483 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0) 724 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
484 continue; 725 continue;
485 726
486 ret = dwarf_lineaddr(line, &addr); 727 if (dwarf_lineaddr(line, &addr) != 0) {
487 DIE_IF(ret != 0); 728 pr_warning("Failed to get the address of the line.\n");
729 return -ENOENT;
730 }
488 pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n", 731 pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
489 (int)i, lineno, (uintmax_t)addr); 732 (int)i, lineno, (uintmax_t)addr);
490 pf->addr = addr; 733 pf->addr = addr;
491 734
492 show_probe_point(NULL, pf); 735 ret = convert_probe_point(NULL, pf);
493 /* Continuing, because target line might be inlined. */ 736 /* Continuing, because target line might be inlined. */
494 } 737 }
738 return ret;
495} 739}
496 740
497/* Find lines which match lazy pattern */ 741/* Find lines which match lazy pattern */
@@ -499,21 +743,36 @@ static int find_lazy_match_lines(struct list_head *head,
499 const char *fname, const char *pat) 743 const char *fname, const char *pat)
500{ 744{
501 char *fbuf, *p1, *p2; 745 char *fbuf, *p1, *p2;
502 int fd, line, nlines = 0; 746 int fd, line, nlines = -1;
503 struct stat st; 747 struct stat st;
504 748
505 fd = open(fname, O_RDONLY); 749 fd = open(fname, O_RDONLY);
506 if (fd < 0) 750 if (fd < 0) {
507 die("failed to open %s", fname); 751 pr_warning("Failed to open %s: %s\n", fname, strerror(-fd));
508 DIE_IF(fstat(fd, &st) < 0); 752 return -errno;
753 }
754
755 if (fstat(fd, &st) < 0) {
756 pr_warning("Failed to get the size of %s: %s\n",
757 fname, strerror(errno));
758 nlines = -errno;
759 goto out_close;
760 }
761
762 nlines = -ENOMEM;
509 fbuf = malloc(st.st_size + 2); 763 fbuf = malloc(st.st_size + 2);
510 DIE_IF(fbuf == NULL); 764 if (fbuf == NULL)
511 DIE_IF(read(fd, fbuf, st.st_size) < 0); 765 goto out_close;
512 close(fd); 766 if (read(fd, fbuf, st.st_size) < 0) {
767 pr_warning("Failed to read %s: %s\n", fname, strerror(errno));
768 nlines = -errno;
769 goto out_free_fbuf;
770 }
513 fbuf[st.st_size] = '\n'; /* Dummy line */ 771 fbuf[st.st_size] = '\n'; /* Dummy line */
514 fbuf[st.st_size + 1] = '\0'; 772 fbuf[st.st_size + 1] = '\0';
515 p1 = fbuf; 773 p1 = fbuf;
516 line = 1; 774 line = 1;
775 nlines = 0;
517 while ((p2 = strchr(p1, '\n')) != NULL) { 776 while ((p2 = strchr(p1, '\n')) != NULL) {
518 *p2 = '\0'; 777 *p2 = '\0';
519 if (strlazymatch(p1, pat)) { 778 if (strlazymatch(p1, pat)) {
@@ -523,12 +782,15 @@ static int find_lazy_match_lines(struct list_head *head,
523 line++; 782 line++;
524 p1 = p2 + 1; 783 p1 = p2 + 1;
525 } 784 }
785out_free_fbuf:
526 free(fbuf); 786 free(fbuf);
787out_close:
788 close(fd);
527 return nlines; 789 return nlines;
528} 790}
529 791
530/* Find probe points from lazy pattern */ 792/* Find probe points from lazy pattern */
531static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf) 793static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
532{ 794{
533 Dwarf_Lines *lines; 795 Dwarf_Lines *lines;
534 Dwarf_Line *line; 796 Dwarf_Line *line;
@@ -536,37 +798,46 @@ static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
536 Dwarf_Addr addr; 798 Dwarf_Addr addr;
537 Dwarf_Die die_mem; 799 Dwarf_Die die_mem;
538 int lineno; 800 int lineno;
539 int ret; 801 int ret = 0;
540 802
541 if (list_empty(&pf->lcache)) { 803 if (list_empty(&pf->lcache)) {
542 /* Matching lazy line pattern */ 804 /* Matching lazy line pattern */
543 ret = find_lazy_match_lines(&pf->lcache, pf->fname, 805 ret = find_lazy_match_lines(&pf->lcache, pf->fname,
544 pf->pp->lazy_line); 806 pf->pev->point.lazy_line);
545 if (ret <= 0) 807 if (ret == 0) {
546 die("No matched lines found in %s.", pf->fname); 808 pr_debug("No matched lines found in %s.\n", pf->fname);
809 return 0;
810 } else if (ret < 0)
811 return ret;
547 } 812 }
548 813
549 ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines); 814 if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
550 DIE_IF(ret != 0); 815 pr_warning("No source lines found in this CU.\n");
551 for (i = 0; i < nlines; i++) { 816 return -ENOENT;
817 }
818
819 for (i = 0; i < nlines && ret >= 0; i++) {
552 line = dwarf_onesrcline(lines, i); 820 line = dwarf_onesrcline(lines, i);
553 821
554 dwarf_lineno(line, &lineno); 822 if (dwarf_lineno(line, &lineno) != 0 ||
555 if (!line_list__has_line(&pf->lcache, lineno)) 823 !line_list__has_line(&pf->lcache, lineno))
556 continue; 824 continue;
557 825
558 /* TODO: Get fileno from line, but how? */ 826 /* TODO: Get fileno from line, but how? */
559 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0) 827 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
560 continue; 828 continue;
561 829
562 ret = dwarf_lineaddr(line, &addr); 830 if (dwarf_lineaddr(line, &addr) != 0) {
563 DIE_IF(ret != 0); 831 pr_debug("Failed to get the address of line %d.\n",
832 lineno);
833 continue;
834 }
564 if (sp_die) { 835 if (sp_die) {
565 /* Address filtering 1: does sp_die include addr? */ 836 /* Address filtering 1: does sp_die include addr? */
566 if (!dwarf_haspc(sp_die, addr)) 837 if (!dwarf_haspc(sp_die, addr))
567 continue; 838 continue;
568 /* Address filtering 2: No child include addr? */ 839 /* Address filtering 2: No child include addr? */
569 if (die_get_inlinefunc(sp_die, addr, &die_mem)) 840 if (die_find_inlinefunc(sp_die, addr, &die_mem))
570 continue; 841 continue;
571 } 842 }
572 843
@@ -574,27 +845,44 @@ static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
574 (int)i, lineno, (unsigned long long)addr); 845 (int)i, lineno, (unsigned long long)addr);
575 pf->addr = addr; 846 pf->addr = addr;
576 847
577 show_probe_point(sp_die, pf); 848 ret = convert_probe_point(sp_die, pf);
578 /* Continuing, because target line might be inlined. */ 849 /* Continuing, because target line might be inlined. */
579 } 850 }
580 /* TODO: deallocate lines, but how? */ 851 /* TODO: deallocate lines, but how? */
852 return ret;
581} 853}
582 854
855/* Callback parameter with return value */
856struct dwarf_callback_param {
857 void *data;
858 int retval;
859};
860
583static int probe_point_inline_cb(Dwarf_Die *in_die, void *data) 861static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
584{ 862{
585 struct probe_finder *pf = (struct probe_finder *)data; 863 struct dwarf_callback_param *param = data;
586 struct probe_point *pp = pf->pp; 864 struct probe_finder *pf = param->data;
865 struct perf_probe_point *pp = &pf->pev->point;
866 Dwarf_Addr addr;
587 867
588 if (pp->lazy_line) 868 if (pp->lazy_line)
589 find_probe_point_lazy(in_die, pf); 869 param->retval = find_probe_point_lazy(in_die, pf);
590 else { 870 else {
591 /* Get probe address */ 871 /* Get probe address */
592 pf->addr = die_get_entrypc(in_die); 872 if (dwarf_entrypc(in_die, &addr) != 0) {
873 pr_warning("Failed to get entry pc of %s.\n",
874 dwarf_diename(in_die));
875 param->retval = -ENOENT;
876 return DWARF_CB_ABORT;
877 }
878 pf->addr = addr;
593 pf->addr += pp->offset; 879 pf->addr += pp->offset;
594 pr_debug("found inline addr: 0x%jx\n", 880 pr_debug("found inline addr: 0x%jx\n",
595 (uintmax_t)pf->addr); 881 (uintmax_t)pf->addr);
596 882
597 show_probe_point(in_die, pf); 883 param->retval = convert_probe_point(in_die, pf);
884 if (param->retval < 0)
885 return DWARF_CB_ABORT;
598 } 886 }
599 887
600 return DWARF_CB_OK; 888 return DWARF_CB_OK;
@@ -603,59 +891,92 @@ static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
603/* Search function from function name */ 891/* Search function from function name */
604static int probe_point_search_cb(Dwarf_Die *sp_die, void *data) 892static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
605{ 893{
606 struct probe_finder *pf = (struct probe_finder *)data; 894 struct dwarf_callback_param *param = data;
607 struct probe_point *pp = pf->pp; 895 struct probe_finder *pf = param->data;
896 struct perf_probe_point *pp = &pf->pev->point;
608 897
609 /* Check tag and diename */ 898 /* Check tag and diename */
610 if (dwarf_tag(sp_die) != DW_TAG_subprogram || 899 if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
611 die_compare_name(sp_die, pp->function) != 0) 900 die_compare_name(sp_die, pp->function) != 0)
612 return 0; 901 return DWARF_CB_OK;
613 902
614 pf->fname = dwarf_decl_file(sp_die); 903 pf->fname = dwarf_decl_file(sp_die);
615 if (pp->line) { /* Function relative line */ 904 if (pp->line) { /* Function relative line */
616 dwarf_decl_line(sp_die, &pf->lno); 905 dwarf_decl_line(sp_die, &pf->lno);
617 pf->lno += pp->line; 906 pf->lno += pp->line;
618 find_probe_point_by_line(pf); 907 param->retval = find_probe_point_by_line(pf);
619 } else if (!dwarf_func_inline(sp_die)) { 908 } else if (!dwarf_func_inline(sp_die)) {
620 /* Real function */ 909 /* Real function */
621 if (pp->lazy_line) 910 if (pp->lazy_line)
622 find_probe_point_lazy(sp_die, pf); 911 param->retval = find_probe_point_lazy(sp_die, pf);
623 else { 912 else {
624 pf->addr = die_get_entrypc(sp_die); 913 if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
914 pr_warning("Failed to get entry pc of %s.\n",
915 dwarf_diename(sp_die));
916 param->retval = -ENOENT;
917 return DWARF_CB_ABORT;
918 }
625 pf->addr += pp->offset; 919 pf->addr += pp->offset;
626 /* TODO: Check the address in this function */ 920 /* TODO: Check the address in this function */
627 show_probe_point(sp_die, pf); 921 param->retval = convert_probe_point(sp_die, pf);
628 } 922 }
629 } else 923 } else {
924 struct dwarf_callback_param _param = {.data = (void *)pf,
925 .retval = 0};
630 /* Inlined function: search instances */ 926 /* Inlined function: search instances */
631 dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf); 927 dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
928 &_param);
929 param->retval = _param.retval;
930 }
632 931
633 return 1; /* Exit; no same symbol in this CU. */ 932 return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
634} 933}
635 934
636static void find_probe_point_by_func(struct probe_finder *pf) 935static int find_probe_point_by_func(struct probe_finder *pf)
637{ 936{
638 dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0); 937 struct dwarf_callback_param _param = {.data = (void *)pf,
938 .retval = 0};
939 dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
940 return _param.retval;
639} 941}
640 942
641/* Find a probe point */ 943/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
642int find_probe_point(int fd, struct probe_point *pp) 944int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
945 struct kprobe_trace_event **tevs, int max_tevs)
643{ 946{
644 struct probe_finder pf = {.pp = pp}; 947 struct probe_finder pf = {.pev = pev, .max_tevs = max_tevs};
948 struct perf_probe_point *pp = &pev->point;
645 Dwarf_Off off, noff; 949 Dwarf_Off off, noff;
646 size_t cuhl; 950 size_t cuhl;
647 Dwarf_Die *diep; 951 Dwarf_Die *diep;
648 Dwarf *dbg; 952 Dwarf *dbg;
953 int ret = 0;
954
955 pf.tevs = zalloc(sizeof(struct kprobe_trace_event) * max_tevs);
956 if (pf.tevs == NULL)
957 return -ENOMEM;
958 *tevs = pf.tevs;
959 pf.ntevs = 0;
649 960
650 dbg = dwarf_begin(fd, DWARF_C_READ); 961 dbg = dwarf_begin(fd, DWARF_C_READ);
651 if (!dbg) 962 if (!dbg) {
652 return -ENOENT; 963 pr_warning("No dwarf info found in the vmlinux - "
964 "please rebuild with CONFIG_DEBUG_INFO=y.\n");
965 free(pf.tevs);
966 *tevs = NULL;
967 return -EBADF;
968 }
969
970#if _ELFUTILS_PREREQ(0, 142)
971 /* Get the call frame information from this dwarf */
972 pf.cfi = dwarf_getcfi(dbg);
973#endif
653 974
654 pp->found = 0;
655 off = 0; 975 off = 0;
656 line_list__init(&pf.lcache); 976 line_list__init(&pf.lcache);
657 /* Loop on CUs (Compilation Unit) */ 977 /* Loop on CUs (Compilation Unit) */
658 while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) { 978 while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) &&
979 ret >= 0) {
659 /* Get the DIE(Debugging Information Entry) of this CU */ 980 /* Get the DIE(Debugging Information Entry) of this CU */
660 diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die); 981 diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
661 if (!diep) 982 if (!diep)
@@ -669,12 +990,12 @@ int find_probe_point(int fd, struct probe_point *pp)
669 990
670 if (!pp->file || pf.fname) { 991 if (!pp->file || pf.fname) {
671 if (pp->function) 992 if (pp->function)
672 find_probe_point_by_func(&pf); 993 ret = find_probe_point_by_func(&pf);
673 else if (pp->lazy_line) 994 else if (pp->lazy_line)
674 find_probe_point_lazy(NULL, &pf); 995 ret = find_probe_point_lazy(NULL, &pf);
675 else { 996 else {
676 pf.lno = pp->line; 997 pf.lno = pp->line;
677 find_probe_point_by_line(&pf); 998 ret = find_probe_point_by_line(&pf);
678 } 999 }
679 } 1000 }
680 off = noff; 1001 off = noff;
@@ -682,41 +1003,169 @@ int find_probe_point(int fd, struct probe_point *pp)
682 line_list__free(&pf.lcache); 1003 line_list__free(&pf.lcache);
683 dwarf_end(dbg); 1004 dwarf_end(dbg);
684 1005
685 return pp->found; 1006 return (ret < 0) ? ret : pf.ntevs;
1007}
1008
1009/* Reverse search */
1010int find_perf_probe_point(int fd, unsigned long addr,
1011 struct perf_probe_point *ppt)
1012{
1013 Dwarf_Die cudie, spdie, indie;
1014 Dwarf *dbg;
1015 Dwarf_Line *line;
1016 Dwarf_Addr laddr, eaddr;
1017 const char *tmp;
1018 int lineno, ret = 0;
1019 bool found = false;
1020
1021 dbg = dwarf_begin(fd, DWARF_C_READ);
1022 if (!dbg)
1023 return -EBADF;
1024
1025 /* Find cu die */
1026 if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie)) {
1027 ret = -EINVAL;
1028 goto end;
1029 }
1030
1031 /* Find a corresponding line */
1032 line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
1033 if (line) {
1034 if (dwarf_lineaddr(line, &laddr) == 0 &&
1035 (Dwarf_Addr)addr == laddr &&
1036 dwarf_lineno(line, &lineno) == 0) {
1037 tmp = dwarf_linesrc(line, NULL, NULL);
1038 if (tmp) {
1039 ppt->line = lineno;
1040 ppt->file = strdup(tmp);
1041 if (ppt->file == NULL) {
1042 ret = -ENOMEM;
1043 goto end;
1044 }
1045 found = true;
1046 }
1047 }
1048 }
1049
1050 /* Find a corresponding function */
1051 if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
1052 tmp = dwarf_diename(&spdie);
1053 if (!tmp || dwarf_entrypc(&spdie, &eaddr) != 0)
1054 goto end;
1055
1056 if (ppt->line) {
1057 if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
1058 &indie)) {
1059 /* addr in an inline function */
1060 tmp = dwarf_diename(&indie);
1061 if (!tmp)
1062 goto end;
1063 ret = dwarf_decl_line(&indie, &lineno);
1064 } else {
1065 if (eaddr == addr) { /* Function entry */
1066 lineno = ppt->line;
1067 ret = 0;
1068 } else
1069 ret = dwarf_decl_line(&spdie, &lineno);
1070 }
1071 if (ret == 0) {
1072 /* Make a relative line number */
1073 ppt->line -= lineno;
1074 goto found;
1075 }
1076 }
1077 /* We don't have a line number, let's use offset */
1078 ppt->offset = addr - (unsigned long)eaddr;
1079found:
1080 ppt->function = strdup(tmp);
1081 if (ppt->function == NULL) {
1082 ret = -ENOMEM;
1083 goto end;
1084 }
1085 found = true;
1086 }
1087
1088end:
1089 dwarf_end(dbg);
1090 if (ret >= 0)
1091 ret = found ? 1 : 0;
1092 return ret;
1093}
1094
1095/* Add a line and store the src path */
1096static int line_range_add_line(const char *src, unsigned int lineno,
1097 struct line_range *lr)
1098{
1099 /* Copy real path */
1100 if (!lr->path) {
1101 lr->path = strdup(src);
1102 if (lr->path == NULL)
1103 return -ENOMEM;
1104 }
1105 return line_list__add_line(&lr->line_list, lineno);
1106}
1107
1108/* Search function declaration lines */
1109static int line_range_funcdecl_cb(Dwarf_Die *sp_die, void *data)
1110{
1111 struct dwarf_callback_param *param = data;
1112 struct line_finder *lf = param->data;
1113 const char *src;
1114 int lineno;
1115
1116 src = dwarf_decl_file(sp_die);
1117 if (src && strtailcmp(src, lf->fname) != 0)
1118 return DWARF_CB_OK;
1119
1120 if (dwarf_decl_line(sp_die, &lineno) != 0 ||
1121 (lf->lno_s > lineno || lf->lno_e < lineno))
1122 return DWARF_CB_OK;
1123
1124 param->retval = line_range_add_line(src, lineno, lf->lr);
1125 if (param->retval < 0)
1126 return DWARF_CB_ABORT;
1127 return DWARF_CB_OK;
1128}
1129
1130static int find_line_range_func_decl_lines(struct line_finder *lf)
1131{
1132 struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1133 dwarf_getfuncs(&lf->cu_die, line_range_funcdecl_cb, &param, 0);
1134 return param.retval;
686} 1135}
687 1136
688/* Find line range from its line number */ 1137/* Find line range from its line number */
689static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf) 1138static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
690{ 1139{
691 Dwarf_Lines *lines; 1140 Dwarf_Lines *lines;
692 Dwarf_Line *line; 1141 Dwarf_Line *line;
693 size_t nlines, i; 1142 size_t nlines, i;
694 Dwarf_Addr addr; 1143 Dwarf_Addr addr;
695 int lineno; 1144 int lineno, ret = 0;
696 int ret;
697 const char *src; 1145 const char *src;
698 Dwarf_Die die_mem; 1146 Dwarf_Die die_mem;
699 1147
700 line_list__init(&lf->lr->line_list); 1148 line_list__init(&lf->lr->line_list);
701 ret = dwarf_getsrclines(&lf->cu_die, &lines, &nlines); 1149 if (dwarf_getsrclines(&lf->cu_die, &lines, &nlines) != 0) {
702 DIE_IF(ret != 0); 1150 pr_warning("No source lines found in this CU.\n");
1151 return -ENOENT;
1152 }
703 1153
1154 /* Search probable lines on lines list */
704 for (i = 0; i < nlines; i++) { 1155 for (i = 0; i < nlines; i++) {
705 line = dwarf_onesrcline(lines, i); 1156 line = dwarf_onesrcline(lines, i);
706 ret = dwarf_lineno(line, &lineno); 1157 if (dwarf_lineno(line, &lineno) != 0 ||
707 DIE_IF(ret != 0); 1158 (lf->lno_s > lineno || lf->lno_e < lineno))
708 if (lf->lno_s > lineno || lf->lno_e < lineno)
709 continue; 1159 continue;
710 1160
711 if (sp_die) { 1161 if (sp_die) {
712 /* Address filtering 1: does sp_die include addr? */ 1162 /* Address filtering 1: does sp_die include addr? */
713 ret = dwarf_lineaddr(line, &addr); 1163 if (dwarf_lineaddr(line, &addr) != 0 ||
714 DIE_IF(ret != 0); 1164 !dwarf_haspc(sp_die, addr))
715 if (!dwarf_haspc(sp_die, addr))
716 continue; 1165 continue;
717 1166
718 /* Address filtering 2: No child include addr? */ 1167 /* Address filtering 2: No child include addr? */
719 if (die_get_inlinefunc(sp_die, addr, &die_mem)) 1168 if (die_find_inlinefunc(sp_die, addr, &die_mem))
720 continue; 1169 continue;
721 } 1170 }
722 1171
@@ -725,30 +1174,49 @@ static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
725 if (strtailcmp(src, lf->fname) != 0) 1174 if (strtailcmp(src, lf->fname) != 0)
726 continue; 1175 continue;
727 1176
728 /* Copy real path */ 1177 ret = line_range_add_line(src, lineno, lf->lr);
729 if (!lf->lr->path) 1178 if (ret < 0)
730 lf->lr->path = strdup(src); 1179 return ret;
731 line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
732 } 1180 }
1181
1182 /*
1183 * Dwarf lines doesn't include function declarations. We have to
1184 * check functions list or given function.
1185 */
1186 if (sp_die) {
1187 src = dwarf_decl_file(sp_die);
1188 if (src && dwarf_decl_line(sp_die, &lineno) == 0 &&
1189 (lf->lno_s <= lineno && lf->lno_e >= lineno))
1190 ret = line_range_add_line(src, lineno, lf->lr);
1191 } else
1192 ret = find_line_range_func_decl_lines(lf);
1193
733 /* Update status */ 1194 /* Update status */
734 if (!list_empty(&lf->lr->line_list)) 1195 if (ret >= 0)
735 lf->found = 1; 1196 if (!list_empty(&lf->lr->line_list))
1197 ret = lf->found = 1;
1198 else
1199 ret = 0; /* Lines are not found */
736 else { 1200 else {
737 free(lf->lr->path); 1201 free(lf->lr->path);
738 lf->lr->path = NULL; 1202 lf->lr->path = NULL;
739 } 1203 }
1204 return ret;
740} 1205}
741 1206
742static int line_range_inline_cb(Dwarf_Die *in_die, void *data) 1207static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
743{ 1208{
744 find_line_range_by_line(in_die, (struct line_finder *)data); 1209 struct dwarf_callback_param *param = data;
1210
1211 param->retval = find_line_range_by_line(in_die, param->data);
745 return DWARF_CB_ABORT; /* No need to find other instances */ 1212 return DWARF_CB_ABORT; /* No need to find other instances */
746} 1213}
747 1214
748/* Search function from function name */ 1215/* Search function from function name */
749static int line_range_search_cb(Dwarf_Die *sp_die, void *data) 1216static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
750{ 1217{
751 struct line_finder *lf = (struct line_finder *)data; 1218 struct dwarf_callback_param *param = data;
1219 struct line_finder *lf = param->data;
752 struct line_range *lr = lf->lr; 1220 struct line_range *lr = lf->lr;
753 1221
754 if (dwarf_tag(sp_die) == DW_TAG_subprogram && 1222 if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
@@ -757,44 +1225,55 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
757 dwarf_decl_line(sp_die, &lr->offset); 1225 dwarf_decl_line(sp_die, &lr->offset);
758 pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset); 1226 pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
759 lf->lno_s = lr->offset + lr->start; 1227 lf->lno_s = lr->offset + lr->start;
760 if (!lr->end) 1228 if (lf->lno_s < 0) /* Overflow */
1229 lf->lno_s = INT_MAX;
1230 lf->lno_e = lr->offset + lr->end;
1231 if (lf->lno_e < 0) /* Overflow */
761 lf->lno_e = INT_MAX; 1232 lf->lno_e = INT_MAX;
762 else 1233 pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
763 lf->lno_e = lr->offset + lr->end;
764 lr->start = lf->lno_s; 1234 lr->start = lf->lno_s;
765 lr->end = lf->lno_e; 1235 lr->end = lf->lno_e;
766 if (dwarf_func_inline(sp_die)) 1236 if (dwarf_func_inline(sp_die)) {
1237 struct dwarf_callback_param _param;
1238 _param.data = (void *)lf;
1239 _param.retval = 0;
767 dwarf_func_inline_instances(sp_die, 1240 dwarf_func_inline_instances(sp_die,
768 line_range_inline_cb, lf); 1241 line_range_inline_cb,
769 else 1242 &_param);
770 find_line_range_by_line(sp_die, lf); 1243 param->retval = _param.retval;
771 return 1; 1244 } else
1245 param->retval = find_line_range_by_line(sp_die, lf);
1246 return DWARF_CB_ABORT;
772 } 1247 }
773 return 0; 1248 return DWARF_CB_OK;
774} 1249}
775 1250
776static void find_line_range_by_func(struct line_finder *lf) 1251static int find_line_range_by_func(struct line_finder *lf)
777{ 1252{
778 dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0); 1253 struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1254 dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
1255 return param.retval;
779} 1256}
780 1257
781int find_line_range(int fd, struct line_range *lr) 1258int find_line_range(int fd, struct line_range *lr)
782{ 1259{
783 struct line_finder lf = {.lr = lr, .found = 0}; 1260 struct line_finder lf = {.lr = lr, .found = 0};
784 int ret; 1261 int ret = 0;
785 Dwarf_Off off = 0, noff; 1262 Dwarf_Off off = 0, noff;
786 size_t cuhl; 1263 size_t cuhl;
787 Dwarf_Die *diep; 1264 Dwarf_Die *diep;
788 Dwarf *dbg; 1265 Dwarf *dbg;
789 1266
790 dbg = dwarf_begin(fd, DWARF_C_READ); 1267 dbg = dwarf_begin(fd, DWARF_C_READ);
791 if (!dbg) 1268 if (!dbg) {
792 return -ENOENT; 1269 pr_warning("No dwarf info found in the vmlinux - "
1270 "please rebuild with CONFIG_DEBUG_INFO=y.\n");
1271 return -EBADF;
1272 }
793 1273
794 /* Loop on CUs (Compilation Unit) */ 1274 /* Loop on CUs (Compilation Unit) */
795 while (!lf.found) { 1275 while (!lf.found && ret >= 0) {
796 ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL); 1276 if (dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) != 0)
797 if (ret != 0)
798 break; 1277 break;
799 1278
800 /* Get the DIE(Debugging Information Entry) of this CU */ 1279 /* Get the DIE(Debugging Information Entry) of this CU */
@@ -810,20 +1289,18 @@ int find_line_range(int fd, struct line_range *lr)
810 1289
811 if (!lr->file || lf.fname) { 1290 if (!lr->file || lf.fname) {
812 if (lr->function) 1291 if (lr->function)
813 find_line_range_by_func(&lf); 1292 ret = find_line_range_by_func(&lf);
814 else { 1293 else {
815 lf.lno_s = lr->start; 1294 lf.lno_s = lr->start;
816 if (!lr->end) 1295 lf.lno_e = lr->end;
817 lf.lno_e = INT_MAX; 1296 ret = find_line_range_by_line(NULL, &lf);
818 else
819 lf.lno_e = lr->end;
820 find_line_range_by_line(NULL, &lf);
821 } 1297 }
822 } 1298 }
823 off = noff; 1299 off = noff;
824 } 1300 }
825 pr_debug("path: %lx\n", (unsigned long)lr->path); 1301 pr_debug("path: %lx\n", (unsigned long)lr->path);
826 dwarf_end(dbg); 1302 dwarf_end(dbg);
827 return lf.found; 1303
1304 return (ret < 0) ? ret : lf.found;
828} 1305}
829 1306
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 21f7354397b..e1f61dcd18f 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -3,6 +3,7 @@
3 3
4#include <stdbool.h> 4#include <stdbool.h>
5#include "util.h" 5#include "util.h"
6#include "probe-event.h"
6 7
7#define MAX_PATH_LEN 256 8#define MAX_PATH_LEN 256
8#define MAX_PROBE_BUFFER 1024 9#define MAX_PROBE_BUFFER 1024
@@ -14,67 +15,42 @@ static inline int is_c_varname(const char *name)
14 return isalpha(name[0]) || name[0] == '_'; 15 return isalpha(name[0]) || name[0] == '_';
15} 16}
16 17
17struct probe_point { 18#ifdef DWARF_SUPPORT
18 char *event; /* Event name */ 19/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
19 char *group; /* Event group */ 20extern int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
21 struct kprobe_trace_event **tevs,
22 int max_tevs);
20 23
21 /* Inputs */ 24/* Find a perf_probe_point from debuginfo */
22 char *file; /* File name */ 25extern int find_perf_probe_point(int fd, unsigned long addr,
23 int line; /* Line number */ 26 struct perf_probe_point *ppt);
24 char *lazy_line; /* Lazy line pattern */
25 27
26 char *function; /* Function name */
27 int offset; /* Offset bytes */
28
29 int nr_args; /* Number of arguments */
30 char **args; /* Arguments */
31
32 int retprobe; /* Return probe */
33
34 /* Output */
35 int found; /* Number of found probe points */
36 char *probes[MAX_PROBES]; /* Output buffers (will be allocated)*/
37};
38
39/* Line number container */
40struct line_node {
41 struct list_head list;
42 unsigned int line;
43};
44
45/* Line range */
46struct line_range {
47 char *file; /* File name */
48 char *function; /* Function name */
49 unsigned int start; /* Start line number */
50 unsigned int end; /* End line number */
51 int offset; /* Start line offset */
52 char *path; /* Real path name */
53 struct list_head line_list; /* Visible lines */
54};
55
56#ifndef NO_DWARF_SUPPORT
57extern int find_probe_point(int fd, struct probe_point *pp);
58extern int find_line_range(int fd, struct line_range *lr); 28extern int find_line_range(int fd, struct line_range *lr);
59 29
60#include <dwarf.h> 30#include <dwarf.h>
61#include <libdw.h> 31#include <libdw.h>
32#include <version.h>
62 33
63struct probe_finder { 34struct probe_finder {
64 struct probe_point *pp; /* Target probe point */ 35 struct perf_probe_event *pev; /* Target probe event */
36 struct kprobe_trace_event *tevs; /* Result trace events */
37 int ntevs; /* Number of trace events */
38 int max_tevs; /* Max number of trace events */
65 39
66 /* For function searching */ 40 /* For function searching */
67 Dwarf_Addr addr; /* Address */
68 const char *fname; /* File name */
69 int lno; /* Line number */ 41 int lno; /* Line number */
42 Dwarf_Addr addr; /* Address */
43 const char *fname; /* Real file name */
70 Dwarf_Die cu_die; /* Current CU */ 44 Dwarf_Die cu_die; /* Current CU */
45 struct list_head lcache; /* Line cache for lazy match */
71 46
72 /* For variable searching */ 47 /* For variable searching */
48#if _ELFUTILS_PREREQ(0, 142)
49 Dwarf_CFI *cfi; /* Call Frame Information */
50#endif
73 Dwarf_Op *fb_ops; /* Frame base attribute */ 51 Dwarf_Op *fb_ops; /* Frame base attribute */
74 const char *var; /* Current variable name */ 52 struct perf_probe_arg *pvar; /* Current target variable */
75 char *buf; /* Current output buffer */ 53 struct kprobe_trace_arg *tvar; /* Current result variable */
76 int len; /* Length of output buffer */
77 struct list_head lcache; /* Line cache for lazy match */
78}; 54};
79 55
80struct line_finder { 56struct line_finder {
@@ -87,6 +63,6 @@ struct line_finder {
87 int found; 63 int found;
88}; 64};
89 65
90#endif /* NO_DWARF_SUPPORT */ 66#endif /* DWARF_SUPPORT */
91 67
92#endif /*_PROBE_FINDER_H */ 68#endif /*_PROBE_FINDER_H */
diff --git a/tools/perf/util/pstack.c b/tools/perf/util/pstack.c
new file mode 100644
index 00000000000..13d36faf64e
--- /dev/null
+++ b/tools/perf/util/pstack.c
@@ -0,0 +1,75 @@
1/*
2 * Simple pointer stack
3 *
4 * (c) 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
5 */
6
7#include "util.h"
8#include "pstack.h"
9#include <linux/kernel.h>
10#include <stdlib.h>
11
12struct pstack {
13 unsigned short top;
14 unsigned short max_nr_entries;
15 void *entries[0];
16};
17
18struct pstack *pstack__new(unsigned short max_nr_entries)
19{
20 struct pstack *self = zalloc((sizeof(*self) +
21 max_nr_entries * sizeof(void *)));
22 if (self != NULL)
23 self->max_nr_entries = max_nr_entries;
24 return self;
25}
26
27void pstack__delete(struct pstack *self)
28{
29 free(self);
30}
31
32bool pstack__empty(const struct pstack *self)
33{
34 return self->top == 0;
35}
36
37void pstack__remove(struct pstack *self, void *key)
38{
39 unsigned short i = self->top, last_index = self->top - 1;
40
41 while (i-- != 0) {
42 if (self->entries[i] == key) {
43 if (i < last_index)
44 memmove(self->entries + i,
45 self->entries + i + 1,
46 (last_index - i) * sizeof(void *));
47 --self->top;
48 return;
49 }
50 }
51 pr_err("%s: %p not on the pstack!\n", __func__, key);
52}
53
54void pstack__push(struct pstack *self, void *key)
55{
56 if (self->top == self->max_nr_entries) {
57 pr_err("%s: top=%d, overflow!\n", __func__, self->top);
58 return;
59 }
60 self->entries[self->top++] = key;
61}
62
63void *pstack__pop(struct pstack *self)
64{
65 void *ret;
66
67 if (self->top == 0) {
68 pr_err("%s: underflow!\n", __func__);
69 return NULL;
70 }
71
72 ret = self->entries[--self->top];
73 self->entries[self->top] = NULL;
74 return ret;
75}
diff --git a/tools/perf/util/pstack.h b/tools/perf/util/pstack.h
new file mode 100644
index 00000000000..5ad07023504
--- /dev/null
+++ b/tools/perf/util/pstack.h
@@ -0,0 +1,12 @@
1#ifndef _PERF_PSTACK_
2#define _PERF_PSTACK_
3
4struct pstack;
5struct pstack *pstack__new(unsigned short max_nr_entries);
6void pstack__delete(struct pstack *self);
7bool pstack__empty(const struct pstack *self);
8void pstack__remove(struct pstack *self, void *key);
9void pstack__push(struct pstack *self, void *key);
10void *pstack__pop(struct pstack *self);
11
12#endif /* _PERF_PSTACK_ */
diff --git a/tools/perf/util/quote.c b/tools/perf/util/quote.c
index 2726fe40eb5..01f03242b86 100644
--- a/tools/perf/util/quote.c
+++ b/tools/perf/util/quote.c
@@ -1,8 +1,6 @@
1#include "cache.h" 1#include "cache.h"
2#include "quote.h" 2#include "quote.h"
3 3
4int quote_path_fully = 1;
5
6/* Help to copy the thing properly quoted for the shell safety. 4/* Help to copy the thing properly quoted for the shell safety.
7 * any single quote is replaced with '\'', any exclamation point 5 * any single quote is replaced with '\'', any exclamation point
8 * is replaced with '\!', and the whole thing is enclosed in a 6 * is replaced with '\!', and the whole thing is enclosed in a
@@ -19,7 +17,7 @@ static inline int need_bs_quote(char c)
19 return (c == '\'' || c == '!'); 17 return (c == '\'' || c == '!');
20} 18}
21 19
22void sq_quote_buf(struct strbuf *dst, const char *src) 20static void sq_quote_buf(struct strbuf *dst, const char *src)
23{ 21{
24 char *to_free = NULL; 22 char *to_free = NULL;
25 23
@@ -41,23 +39,6 @@ void sq_quote_buf(struct strbuf *dst, const char *src)
41 free(to_free); 39 free(to_free);
42} 40}
43 41
44void sq_quote_print(FILE *stream, const char *src)
45{
46 char c;
47
48 fputc('\'', stream);
49 while ((c = *src++)) {
50 if (need_bs_quote(c)) {
51 fputs("'\\", stream);
52 fputc(c, stream);
53 fputc('\'', stream);
54 } else {
55 fputc(c, stream);
56 }
57 }
58 fputc('\'', stream);
59}
60
61void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen) 42void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
62{ 43{
63 int i; 44 int i;
@@ -71,415 +52,3 @@ void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
71 die("Too many or long arguments"); 52 die("Too many or long arguments");
72 } 53 }
73} 54}
74
75char *sq_dequote_step(char *arg, char **next)
76{
77 char *dst = arg;
78 char *src = arg;
79 char c;
80
81 if (*src != '\'')
82 return NULL;
83 for (;;) {
84 c = *++src;
85 if (!c)
86 return NULL;
87 if (c != '\'') {
88 *dst++ = c;
89 continue;
90 }
91 /* We stepped out of sq */
92 switch (*++src) {
93 case '\0':
94 *dst = 0;
95 if (next)
96 *next = NULL;
97 return arg;
98 case '\\':
99 c = *++src;
100 if (need_bs_quote(c) && *++src == '\'') {
101 *dst++ = c;
102 continue;
103 }
104 /* Fallthrough */
105 default:
106 if (!next || !isspace(*src))
107 return NULL;
108 do {
109 c = *++src;
110 } while (isspace(c));
111 *dst = 0;
112 *next = src;
113 return arg;
114 }
115 }
116}
117
118char *sq_dequote(char *arg)
119{
120 return sq_dequote_step(arg, NULL);
121}
122
123int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc)
124{
125 char *next = arg;
126
127 if (!*arg)
128 return 0;
129 do {
130 char *dequoted = sq_dequote_step(next, &next);
131 if (!dequoted)
132 return -1;
133 ALLOC_GROW(*argv, *nr + 1, *alloc);
134 (*argv)[(*nr)++] = dequoted;
135 } while (next);
136
137 return 0;
138}
139
140/* 1 means: quote as octal
141 * 0 means: quote as octal if (quote_path_fully)
142 * -1 means: never quote
143 * c: quote as "\\c"
144 */
145#define X8(x) x, x, x, x, x, x, x, x
146#define X16(x) X8(x), X8(x)
147static signed char const sq_lookup[256] = {
148 /* 0 1 2 3 4 5 6 7 */
149 /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 'a',
150 /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r', 1, 1,
151 /* 0x10 */ X16(1),
152 /* 0x20 */ -1, -1, '"', -1, -1, -1, -1, -1,
153 /* 0x28 */ X16(-1), X16(-1), X16(-1),
154 /* 0x58 */ -1, -1, -1, -1,'\\', -1, -1, -1,
155 /* 0x60 */ X16(-1), X8(-1),
156 /* 0x78 */ -1, -1, -1, -1, -1, -1, -1, 1,
157 /* 0x80 */ /* set to 0 */
158};
159
160static inline int sq_must_quote(char c)
161{
162 return sq_lookup[(unsigned char)c] + quote_path_fully > 0;
163}
164
165/*
166 * Returns the longest prefix not needing a quote up to maxlen if
167 * positive.
168 * This stops at the first \0 because it's marked as a character
169 * needing an escape.
170 */
171static ssize_t next_quote_pos(const char *s, ssize_t maxlen)
172{
173 ssize_t len;
174
175 if (maxlen < 0) {
176 for (len = 0; !sq_must_quote(s[len]); len++);
177 } else {
178 for (len = 0; len < maxlen && !sq_must_quote(s[len]); len++);
179 }
180 return len;
181}
182
183/*
184 * C-style name quoting.
185 *
186 * (1) if sb and fp are both NULL, inspect the input name and counts the
187 * number of bytes that are needed to hold c_style quoted version of name,
188 * counting the double quotes around it but not terminating NUL, and
189 * returns it.
190 * However, if name does not need c_style quoting, it returns 0.
191 *
192 * (2) if sb or fp are not NULL, it emits the c_style quoted version
193 * of name, enclosed with double quotes if asked and needed only.
194 * Return value is the same as in (1).
195 */
196static size_t quote_c_style_counted(const char *name, ssize_t maxlen,
197 struct strbuf *sb, FILE *fp, int no_dq)
198{
199#define EMIT(c) \
200 do { \
201 if (sb) strbuf_addch(sb, (c)); \
202 if (fp) fputc((c), fp); \
203 count++; \
204 } while (0)
205
206#define EMITBUF(s, l) \
207 do { \
208 int __ret; \
209 if (sb) strbuf_add(sb, (s), (l)); \
210 if (fp) __ret = fwrite((s), (l), 1, fp); \
211 count += (l); \
212 } while (0)
213
214 ssize_t len, count = 0;
215 const char *p = name;
216
217 for (;;) {
218 int ch;
219
220 len = next_quote_pos(p, maxlen);
221 if (len == maxlen || !p[len])
222 break;
223
224 if (!no_dq && p == name)
225 EMIT('"');
226
227 EMITBUF(p, len);
228 EMIT('\\');
229 p += len;
230 ch = (unsigned char)*p++;
231 if (sq_lookup[ch] >= ' ') {
232 EMIT(sq_lookup[ch]);
233 } else {
234 EMIT(((ch >> 6) & 03) + '0');
235 EMIT(((ch >> 3) & 07) + '0');
236 EMIT(((ch >> 0) & 07) + '0');
237 }
238 }
239
240 EMITBUF(p, len);
241 if (p == name) /* no ending quote needed */
242 return 0;
243
244 if (!no_dq)
245 EMIT('"');
246 return count;
247}
248
249size_t quote_c_style(const char *name, struct strbuf *sb, FILE *fp, int nodq)
250{
251 return quote_c_style_counted(name, -1, sb, fp, nodq);
252}
253
254void quote_two_c_style(struct strbuf *sb, const char *prefix, const char *path, int nodq)
255{
256 if (quote_c_style(prefix, NULL, NULL, 0) ||
257 quote_c_style(path, NULL, NULL, 0)) {
258 if (!nodq)
259 strbuf_addch(sb, '"');
260 quote_c_style(prefix, sb, NULL, 1);
261 quote_c_style(path, sb, NULL, 1);
262 if (!nodq)
263 strbuf_addch(sb, '"');
264 } else {
265 strbuf_addstr(sb, prefix);
266 strbuf_addstr(sb, path);
267 }
268}
269
270void write_name_quoted(const char *name, FILE *fp, int terminator)
271{
272 if (terminator) {
273 quote_c_style(name, NULL, fp, 0);
274 } else {
275 fputs(name, fp);
276 }
277 fputc(terminator, fp);
278}
279
280void write_name_quotedpfx(const char *pfx, ssize_t pfxlen,
281 const char *name, FILE *fp, int terminator)
282{
283 int needquote = 0;
284
285 if (terminator) {
286 needquote = next_quote_pos(pfx, pfxlen) < pfxlen
287 || name[next_quote_pos(name, -1)];
288 }
289 if (needquote) {
290 fputc('"', fp);
291 quote_c_style_counted(pfx, pfxlen, NULL, fp, 1);
292 quote_c_style(name, NULL, fp, 1);
293 fputc('"', fp);
294 } else {
295 int ret;
296
297 ret = fwrite(pfx, pfxlen, 1, fp);
298 fputs(name, fp);
299 }
300 fputc(terminator, fp);
301}
302
303/* quote path as relative to the given prefix */
304char *quote_path_relative(const char *in, int len,
305 struct strbuf *out, const char *prefix)
306{
307 int needquote;
308
309 if (len < 0)
310 len = strlen(in);
311
312 /* "../" prefix itself does not need quoting, but "in" might. */
313 needquote = (next_quote_pos(in, len) < len);
314 strbuf_setlen(out, 0);
315 strbuf_grow(out, len);
316
317 if (needquote)
318 strbuf_addch(out, '"');
319 if (prefix) {
320 int off = 0;
321 while (off < len && prefix[off] && prefix[off] == in[off])
322 if (prefix[off] == '/') {
323 prefix += off + 1;
324 in += off + 1;
325 len -= off + 1;
326 off = 0;
327 } else
328 off++;
329
330 for (; *prefix; prefix++)
331 if (*prefix == '/')
332 strbuf_addstr(out, "../");
333 }
334
335 quote_c_style_counted (in, len, out, NULL, 1);
336
337 if (needquote)
338 strbuf_addch(out, '"');
339 if (!out->len)
340 strbuf_addstr(out, "./");
341
342 return out->buf;
343}
344
345/*
346 * C-style name unquoting.
347 *
348 * Quoted should point at the opening double quote.
349 * + Returns 0 if it was able to unquote the string properly, and appends the
350 * result in the strbuf `sb'.
351 * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
352 * that this function will allocate memory in the strbuf, so calling
353 * strbuf_release is mandatory whichever result unquote_c_style returns.
354 *
355 * Updates endp pointer to point at one past the ending double quote if given.
356 */
357int unquote_c_style(struct strbuf *sb, const char *quoted, const char **endp)
358{
359 size_t oldlen = sb->len, len;
360 int ch, ac;
361
362 if (*quoted++ != '"')
363 return -1;
364
365 for (;;) {
366 len = strcspn(quoted, "\"\\");
367 strbuf_add(sb, quoted, len);
368 quoted += len;
369
370 switch (*quoted++) {
371 case '"':
372 if (endp)
373 *endp = quoted;
374 return 0;
375 case '\\':
376 break;
377 default:
378 goto error;
379 }
380
381 switch ((ch = *quoted++)) {
382 case 'a': ch = '\a'; break;
383 case 'b': ch = '\b'; break;
384 case 'f': ch = '\f'; break;
385 case 'n': ch = '\n'; break;
386 case 'r': ch = '\r'; break;
387 case 't': ch = '\t'; break;
388 case 'v': ch = '\v'; break;
389
390 case '\\': case '"':
391 break; /* verbatim */
392
393 /* octal values with first digit over 4 overflow */
394 case '0': case '1': case '2': case '3':
395 ac = ((ch - '0') << 6);
396 if ((ch = *quoted++) < '0' || '7' < ch)
397 goto error;
398 ac |= ((ch - '0') << 3);
399 if ((ch = *quoted++) < '0' || '7' < ch)
400 goto error;
401 ac |= (ch - '0');
402 ch = ac;
403 break;
404 default:
405 goto error;
406 }
407 strbuf_addch(sb, ch);
408 }
409
410 error:
411 strbuf_setlen(sb, oldlen);
412 return -1;
413}
414
415/* quoting as a string literal for other languages */
416
417void perl_quote_print(FILE *stream, const char *src)
418{
419 const char sq = '\'';
420 const char bq = '\\';
421 char c;
422
423 fputc(sq, stream);
424 while ((c = *src++)) {
425 if (c == sq || c == bq)
426 fputc(bq, stream);
427 fputc(c, stream);
428 }
429 fputc(sq, stream);
430}
431
432void python_quote_print(FILE *stream, const char *src)
433{
434 const char sq = '\'';
435 const char bq = '\\';
436 const char nl = '\n';
437 char c;
438
439 fputc(sq, stream);
440 while ((c = *src++)) {
441 if (c == nl) {
442 fputc(bq, stream);
443 fputc('n', stream);
444 continue;
445 }
446 if (c == sq || c == bq)
447 fputc(bq, stream);
448 fputc(c, stream);
449 }
450 fputc(sq, stream);
451}
452
453void tcl_quote_print(FILE *stream, const char *src)
454{
455 char c;
456
457 fputc('"', stream);
458 while ((c = *src++)) {
459 switch (c) {
460 case '[': case ']':
461 case '{': case '}':
462 case '$': case '\\': case '"':
463 fputc('\\', stream);
464 default:
465 fputc(c, stream);
466 break;
467 case '\f':
468 fputs("\\f", stream);
469 break;
470 case '\r':
471 fputs("\\r", stream);
472 break;
473 case '\n':
474 fputs("\\n", stream);
475 break;
476 case '\t':
477 fputs("\\t", stream);
478 break;
479 case '\v':
480 fputs("\\v", stream);
481 break;
482 }
483 }
484 fputc('"', stream);
485}
diff --git a/tools/perf/util/quote.h b/tools/perf/util/quote.h
index b6a01973391..172889ea234 100644
--- a/tools/perf/util/quote.h
+++ b/tools/perf/util/quote.h
@@ -22,47 +22,8 @@
22 * 22 *
23 * Note that the above examples leak memory! Remember to free result from 23 * Note that the above examples leak memory! Remember to free result from
24 * sq_quote() in a real application. 24 * sq_quote() in a real application.
25 *
26 * sq_quote_buf() writes to an existing buffer of specified size; it
27 * will return the number of characters that would have been written
28 * excluding the final null regardless of the buffer size.
29 */ 25 */
30 26
31extern void sq_quote_print(FILE *stream, const char *src);
32
33extern void sq_quote_buf(struct strbuf *, const char *src);
34extern void sq_quote_argv(struct strbuf *, const char **argv, size_t maxlen); 27extern void sq_quote_argv(struct strbuf *, const char **argv, size_t maxlen);
35 28
36/* This unwraps what sq_quote() produces in place, but returns
37 * NULL if the input does not look like what sq_quote would have
38 * produced.
39 */
40extern char *sq_dequote(char *);
41
42/*
43 * Same as the above, but can be used to unwrap many arguments in the
44 * same string separated by space. "next" is changed to point to the
45 * next argument that should be passed as first parameter. When there
46 * is no more argument to be dequoted, "next" is updated to point to NULL.
47 */
48extern char *sq_dequote_step(char *arg, char **next);
49extern int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc);
50
51extern int unquote_c_style(struct strbuf *, const char *quoted, const char **endp);
52extern size_t quote_c_style(const char *name, struct strbuf *, FILE *, int no_dq);
53extern void quote_two_c_style(struct strbuf *, const char *, const char *, int);
54
55extern void write_name_quoted(const char *name, FILE *, int terminator);
56extern void write_name_quotedpfx(const char *pfx, ssize_t pfxlen,
57 const char *name, FILE *, int terminator);
58
59/* quote path as relative to the given prefix */
60char *quote_path_relative(const char *in, int len,
61 struct strbuf *out, const char *prefix);
62
63/* quoting as a string literal for other languages */
64extern void perl_quote_print(FILE *stream, const char *src);
65extern void python_quote_print(FILE *stream, const char *src);
66extern void tcl_quote_print(FILE *stream, const char *src);
67
68#endif /* __PERF_QUOTE_H */ 29#endif /* __PERF_QUOTE_H */
diff --git a/tools/perf/util/run-command.c b/tools/perf/util/run-command.c
index 2b615acf94d..da8e9b285f5 100644
--- a/tools/perf/util/run-command.c
+++ b/tools/perf/util/run-command.c
@@ -212,93 +212,3 @@ int run_command_v_opt(const char **argv, int opt)
212 prepare_run_command_v_opt(&cmd, argv, opt); 212 prepare_run_command_v_opt(&cmd, argv, opt);
213 return run_command(&cmd); 213 return run_command(&cmd);
214} 214}
215
216int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
217{
218 struct child_process cmd;
219 prepare_run_command_v_opt(&cmd, argv, opt);
220 cmd.dir = dir;
221 cmd.env = env;
222 return run_command(&cmd);
223}
224
225int start_async(struct async *async)
226{
227 int pipe_out[2];
228
229 if (pipe(pipe_out) < 0)
230 return error("cannot create pipe: %s", strerror(errno));
231 async->out = pipe_out[0];
232
233 /* Flush stdio before fork() to avoid cloning buffers */
234 fflush(NULL);
235
236 async->pid = fork();
237 if (async->pid < 0) {
238 error("fork (async) failed: %s", strerror(errno));
239 close_pair(pipe_out);
240 return -1;
241 }
242 if (!async->pid) {
243 close(pipe_out[0]);
244 exit(!!async->proc(pipe_out[1], async->data));
245 }
246 close(pipe_out[1]);
247
248 return 0;
249}
250
251int finish_async(struct async *async)
252{
253 int ret = 0;
254
255 if (wait_or_whine(async->pid))
256 ret = error("waitpid (async) failed");
257
258 return ret;
259}
260
261int run_hook(const char *index_file, const char *name, ...)
262{
263 struct child_process hook;
264 const char **argv = NULL, *env[2];
265 char idx[PATH_MAX];
266 va_list args;
267 int ret;
268 size_t i = 0, alloc = 0;
269
270 if (access(perf_path("hooks/%s", name), X_OK) < 0)
271 return 0;
272
273 va_start(args, name);
274 ALLOC_GROW(argv, i + 1, alloc);
275 argv[i++] = perf_path("hooks/%s", name);
276 while (argv[i-1]) {
277 ALLOC_GROW(argv, i + 1, alloc);
278 argv[i++] = va_arg(args, const char *);
279 }
280 va_end(args);
281
282 memset(&hook, 0, sizeof(hook));
283 hook.argv = argv;
284 hook.no_stdin = 1;
285 hook.stdout_to_stderr = 1;
286 if (index_file) {
287 snprintf(idx, sizeof(idx), "PERF_INDEX_FILE=%s", index_file);
288 env[0] = idx;
289 env[1] = NULL;
290 hook.env = env;
291 }
292
293 ret = start_command(&hook);
294 free(argv);
295 if (ret) {
296 warning("Could not spawn %s", argv[0]);
297 return ret;
298 }
299 ret = finish_command(&hook);
300 if (ret == -ERR_RUN_COMMAND_WAITPID_SIGNAL)
301 warning("%s exited due to uncaught signal", argv[0]);
302
303 return ret;
304}
diff --git a/tools/perf/util/run-command.h b/tools/perf/util/run-command.h
index d79028727ce..1ef264d5069 100644
--- a/tools/perf/util/run-command.h
+++ b/tools/perf/util/run-command.h
@@ -50,39 +50,9 @@ int start_command(struct child_process *);
50int finish_command(struct child_process *); 50int finish_command(struct child_process *);
51int run_command(struct child_process *); 51int run_command(struct child_process *);
52 52
53extern int run_hook(const char *index_file, const char *name, ...);
54
55#define RUN_COMMAND_NO_STDIN 1 53#define RUN_COMMAND_NO_STDIN 1
56#define RUN_PERF_CMD 2 /*If this is to be perf sub-command */ 54#define RUN_PERF_CMD 2 /*If this is to be perf sub-command */
57#define RUN_COMMAND_STDOUT_TO_STDERR 4 55#define RUN_COMMAND_STDOUT_TO_STDERR 4
58int run_command_v_opt(const char **argv, int opt); 56int run_command_v_opt(const char **argv, int opt);
59 57
60/*
61 * env (the environment) is to be formatted like environ: "VAR=VALUE".
62 * To unset an environment variable use just "VAR".
63 */
64int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env);
65
66/*
67 * The purpose of the following functions is to feed a pipe by running
68 * a function asynchronously and providing output that the caller reads.
69 *
70 * It is expected that no synchronization and mutual exclusion between
71 * the caller and the feed function is necessary so that the function
72 * can run in a thread without interfering with the caller.
73 */
74struct async {
75 /*
76 * proc writes to fd and closes it;
77 * returns 0 on success, non-zero on failure
78 */
79 int (*proc)(int fd, void *data);
80 void *data;
81 int out; /* caller reads from here and closes it */
82 pid_t pid;
83};
84
85int start_async(struct async *async);
86int finish_async(struct async *async);
87
88#endif /* __PERF_RUN_COMMAND_H */ 58#endif /* __PERF_RUN_COMMAND_H */
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 5376378e0cf..b059dc50cc2 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -371,7 +371,6 @@ static int perl_start_script(const char *script, int argc, const char **argv)
371 run_start_sub(); 371 run_start_sub();
372 372
373 free(command_line); 373 free(command_line);
374 fprintf(stderr, "perf trace started with Perl script %s\n\n", script);
375 return 0; 374 return 0;
376error: 375error:
377 perl_free(my_perl); 376 perl_free(my_perl);
@@ -394,8 +393,6 @@ static int perl_stop_script(void)
394 perl_destruct(my_perl); 393 perl_destruct(my_perl);
395 perl_free(my_perl); 394 perl_free(my_perl);
396 395
397 fprintf(stderr, "\nperf trace Perl script stopped\n");
398
399 return 0; 396 return 0;
400} 397}
401 398
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 6a72f14c598..33a63252374 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -208,7 +208,7 @@ static void python_process_event(int cpu, void *data,
208 int size __unused, 208 int size __unused,
209 unsigned long long nsecs, char *comm) 209 unsigned long long nsecs, char *comm)
210{ 210{
211 PyObject *handler, *retval, *context, *t, *obj; 211 PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
212 static char handler_name[256]; 212 static char handler_name[256];
213 struct format_field *field; 213 struct format_field *field;
214 unsigned long long val; 214 unsigned long long val;
@@ -232,6 +232,14 @@ static void python_process_event(int cpu, void *data,
232 232
233 sprintf(handler_name, "%s__%s", event->system, event->name); 233 sprintf(handler_name, "%s__%s", event->system, event->name);
234 234
235 handler = PyDict_GetItemString(main_dict, handler_name);
236 if (handler && !PyCallable_Check(handler))
237 handler = NULL;
238 if (!handler) {
239 dict = PyDict_New();
240 if (!dict)
241 Py_FatalError("couldn't create Python dict");
242 }
235 s = nsecs / NSECS_PER_SEC; 243 s = nsecs / NSECS_PER_SEC;
236 ns = nsecs - s * NSECS_PER_SEC; 244 ns = nsecs - s * NSECS_PER_SEC;
237 245
@@ -242,12 +250,20 @@ static void python_process_event(int cpu, void *data,
242 PyTuple_SetItem(t, n++, PyString_FromString(handler_name)); 250 PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
243 PyTuple_SetItem(t, n++, 251 PyTuple_SetItem(t, n++,
244 PyCObject_FromVoidPtr(scripting_context, NULL)); 252 PyCObject_FromVoidPtr(scripting_context, NULL));
245 PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
246 PyTuple_SetItem(t, n++, PyInt_FromLong(s));
247 PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
248 PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
249 PyTuple_SetItem(t, n++, PyString_FromString(comm));
250 253
254 if (handler) {
255 PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
256 PyTuple_SetItem(t, n++, PyInt_FromLong(s));
257 PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
258 PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
259 PyTuple_SetItem(t, n++, PyString_FromString(comm));
260 } else {
261 PyDict_SetItemString(dict, "common_cpu", PyInt_FromLong(cpu));
262 PyDict_SetItemString(dict, "common_s", PyInt_FromLong(s));
263 PyDict_SetItemString(dict, "common_ns", PyInt_FromLong(ns));
264 PyDict_SetItemString(dict, "common_pid", PyInt_FromLong(pid));
265 PyDict_SetItemString(dict, "common_comm", PyString_FromString(comm));
266 }
251 for (field = event->format.fields; field; field = field->next) { 267 for (field = event->format.fields; field; field = field->next) {
252 if (field->flags & FIELD_IS_STRING) { 268 if (field->flags & FIELD_IS_STRING) {
253 int offset; 269 int offset;
@@ -272,27 +288,31 @@ static void python_process_event(int cpu, void *data,
272 obj = PyLong_FromUnsignedLongLong(val); 288 obj = PyLong_FromUnsignedLongLong(val);
273 } 289 }
274 } 290 }
275 PyTuple_SetItem(t, n++, obj); 291 if (handler)
292 PyTuple_SetItem(t, n++, obj);
293 else
294 PyDict_SetItemString(dict, field->name, obj);
295
276 } 296 }
297 if (!handler)
298 PyTuple_SetItem(t, n++, dict);
277 299
278 if (_PyTuple_Resize(&t, n) == -1) 300 if (_PyTuple_Resize(&t, n) == -1)
279 Py_FatalError("error resizing Python tuple"); 301 Py_FatalError("error resizing Python tuple");
280 302
281 handler = PyDict_GetItemString(main_dict, handler_name); 303 if (handler) {
282 if (handler && PyCallable_Check(handler)) {
283 retval = PyObject_CallObject(handler, t); 304 retval = PyObject_CallObject(handler, t);
284 if (retval == NULL) 305 if (retval == NULL)
285 handler_call_die(handler_name); 306 handler_call_die(handler_name);
286 } else { 307 } else {
287 handler = PyDict_GetItemString(main_dict, "trace_unhandled"); 308 handler = PyDict_GetItemString(main_dict, "trace_unhandled");
288 if (handler && PyCallable_Check(handler)) { 309 if (handler && PyCallable_Check(handler)) {
289 if (_PyTuple_Resize(&t, N_COMMON_FIELDS) == -1)
290 Py_FatalError("error resizing Python tuple");
291 310
292 retval = PyObject_CallObject(handler, t); 311 retval = PyObject_CallObject(handler, t);
293 if (retval == NULL) 312 if (retval == NULL)
294 handler_call_die("trace_unhandled"); 313 handler_call_die("trace_unhandled");
295 } 314 }
315 Py_DECREF(dict);
296 } 316 }
297 317
298 Py_DECREF(t); 318 Py_DECREF(t);
@@ -374,8 +394,6 @@ static int python_start_script(const char *script, int argc, const char **argv)
374 } 394 }
375 395
376 free(command_line); 396 free(command_line);
377 fprintf(stderr, "perf trace started with Python script %s\n\n",
378 script);
379 397
380 return err; 398 return err;
381error: 399error:
@@ -407,8 +425,6 @@ out:
407 Py_XDECREF(main_module); 425 Py_XDECREF(main_module);
408 Py_Finalize(); 426 Py_Finalize();
409 427
410 fprintf(stderr, "\nperf trace Python script stopped\n");
411
412 return err; 428 return err;
413} 429}
414 430
@@ -552,12 +568,10 @@ static int python_generate_script(const char *outfile)
552 } 568 }
553 569
554 fprintf(ofp, "def trace_unhandled(event_name, context, " 570 fprintf(ofp, "def trace_unhandled(event_name, context, "
555 "common_cpu, common_secs, common_nsecs,\n\t\t" 571 "event_fields_dict):\n");
556 "common_pid, common_comm):\n");
557 572
558 fprintf(ofp, "\t\tprint_header(event_name, common_cpu, " 573 fprintf(ofp, "\t\tprint ' '.join(['%%s=%%s'%%(k,str(v))"
559 "common_secs, common_nsecs,\n\t\tcommon_pid, " 574 "for k,v in sorted(event_fields_dict.items())])\n\n");
560 "common_comm)\n\n");
561 575
562 fprintf(ofp, "def print_header(" 576 fprintf(ofp, "def print_header("
563 "event_name, cpu, secs, nsecs, pid, comm):\n" 577 "event_name, cpu, secs, nsecs, pid, comm):\n"
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index eed1cb88900..c422cd67631 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -5,6 +5,7 @@
5#include <byteswap.h> 5#include <byteswap.h>
6#include <unistd.h> 6#include <unistd.h>
7#include <sys/types.h> 7#include <sys/types.h>
8#include <sys/mman.h>
8 9
9#include "session.h" 10#include "session.h"
10#include "sort.h" 11#include "sort.h"
@@ -14,6 +15,16 @@ static int perf_session__open(struct perf_session *self, bool force)
14{ 15{
15 struct stat input_stat; 16 struct stat input_stat;
16 17
18 if (!strcmp(self->filename, "-")) {
19 self->fd_pipe = true;
20 self->fd = STDIN_FILENO;
21
22 if (perf_header__read(self, self->fd) < 0)
23 pr_err("incompatible file format");
24
25 return 0;
26 }
27
17 self->fd = open(self->filename, O_RDONLY); 28 self->fd = open(self->filename, O_RDONLY);
18 if (self->fd < 0) { 29 if (self->fd < 0) {
19 pr_err("failed to open file: %s", self->filename); 30 pr_err("failed to open file: %s", self->filename);
@@ -38,7 +49,7 @@ static int perf_session__open(struct perf_session *self, bool force)
38 goto out_close; 49 goto out_close;
39 } 50 }
40 51
41 if (perf_header__read(&self->header, self->fd) < 0) { 52 if (perf_header__read(self, self->fd) < 0) {
42 pr_err("incompatible file format"); 53 pr_err("incompatible file format");
43 goto out_close; 54 goto out_close;
44 } 55 }
@@ -52,12 +63,21 @@ out_close:
52 return -1; 63 return -1;
53} 64}
54 65
55static inline int perf_session__create_kernel_maps(struct perf_session *self) 66void perf_session__update_sample_type(struct perf_session *self)
67{
68 self->sample_type = perf_header__sample_type(&self->header);
69}
70
71int perf_session__create_kernel_maps(struct perf_session *self)
56{ 72{
57 return map_groups__create_kernel_maps(&self->kmaps, self->vmlinux_maps); 73 int ret = machine__create_kernel_maps(&self->host_machine);
74
75 if (ret >= 0)
76 ret = machines__create_guest_kernel_maps(&self->machines);
77 return ret;
58} 78}
59 79
60struct perf_session *perf_session__new(const char *filename, int mode, bool force) 80struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe)
61{ 81{
62 size_t len = filename ? strlen(filename) + 1 : 0; 82 size_t len = filename ? strlen(filename) + 1 : 0;
63 struct perf_session *self = zalloc(sizeof(*self) + len); 83 struct perf_session *self = zalloc(sizeof(*self) + len);
@@ -70,13 +90,16 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
70 90
71 memcpy(self->filename, filename, len); 91 memcpy(self->filename, filename, len);
72 self->threads = RB_ROOT; 92 self->threads = RB_ROOT;
73 self->stats_by_id = RB_ROOT; 93 INIT_LIST_HEAD(&self->dead_threads);
94 self->hists_tree = RB_ROOT;
74 self->last_match = NULL; 95 self->last_match = NULL;
75 self->mmap_window = 32; 96 self->mmap_window = 32;
76 self->cwd = NULL; 97 self->cwd = NULL;
77 self->cwdlen = 0; 98 self->cwdlen = 0;
78 self->unknown_events = 0; 99 self->machines = RB_ROOT;
79 map_groups__init(&self->kmaps); 100 self->repipe = repipe;
101 INIT_LIST_HEAD(&self->ordered_samples.samples_head);
102 machine__init(&self->host_machine, "", HOST_KERNEL_ID);
80 103
81 if (mode == O_RDONLY) { 104 if (mode == O_RDONLY) {
82 if (perf_session__open(self, force) < 0) 105 if (perf_session__open(self, force) < 0)
@@ -90,7 +113,7 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
90 goto out_delete; 113 goto out_delete;
91 } 114 }
92 115
93 self->sample_type = perf_header__sample_type(&self->header); 116 perf_session__update_sample_type(self);
94out: 117out:
95 return self; 118 return self;
96out_free: 119out_free:
@@ -109,6 +132,16 @@ void perf_session__delete(struct perf_session *self)
109 free(self); 132 free(self);
110} 133}
111 134
135void perf_session__remove_thread(struct perf_session *self, struct thread *th)
136{
137 rb_erase(&th->rb_node, &self->threads);
138 /*
139 * We may have references to this thread, for instance in some hist_entry
140 * instances, so just move them to a separate list.
141 */
142 list_add_tail(&th->node, &self->dead_threads);
143}
144
112static bool symbol__match_parent_regex(struct symbol *sym) 145static bool symbol__match_parent_regex(struct symbol *sym)
113{ 146{
114 if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0)) 147 if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
@@ -117,22 +150,17 @@ static bool symbol__match_parent_regex(struct symbol *sym)
117 return 0; 150 return 0;
118} 151}
119 152
120struct symbol **perf_session__resolve_callchain(struct perf_session *self, 153struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
121 struct thread *thread, 154 struct thread *thread,
122 struct ip_callchain *chain, 155 struct ip_callchain *chain,
123 struct symbol **parent) 156 struct symbol **parent)
124{ 157{
125 u8 cpumode = PERF_RECORD_MISC_USER; 158 u8 cpumode = PERF_RECORD_MISC_USER;
126 struct symbol **syms = NULL;
127 unsigned int i; 159 unsigned int i;
160 struct map_symbol *syms = calloc(chain->nr, sizeof(*syms));
128 161
129 if (symbol_conf.use_callchain) { 162 if (!syms)
130 syms = calloc(chain->nr, sizeof(*syms)); 163 return NULL;
131 if (!syms) {
132 fprintf(stderr, "Can't allocate memory for symbols\n");
133 exit(-1);
134 }
135 }
136 164
137 for (i = 0; i < chain->nr; i++) { 165 for (i = 0; i < chain->nr; i++) {
138 u64 ip = chain->ips[i]; 166 u64 ip = chain->ips[i];
@@ -152,15 +180,17 @@ struct symbol **perf_session__resolve_callchain(struct perf_session *self,
152 continue; 180 continue;
153 } 181 }
154 182
183 al.filtered = false;
155 thread__find_addr_location(thread, self, cpumode, 184 thread__find_addr_location(thread, self, cpumode,
156 MAP__FUNCTION, ip, &al, NULL); 185 MAP__FUNCTION, thread->pid, ip, &al, NULL);
157 if (al.sym != NULL) { 186 if (al.sym != NULL) {
158 if (sort__has_parent && !*parent && 187 if (sort__has_parent && !*parent &&
159 symbol__match_parent_regex(al.sym)) 188 symbol__match_parent_regex(al.sym))
160 *parent = al.sym; 189 *parent = al.sym;
161 if (!symbol_conf.use_callchain) 190 if (!symbol_conf.use_callchain)
162 break; 191 break;
163 syms[i] = al.sym; 192 syms[i].map = al.map;
193 syms[i].sym = al.sym;
164 } 194 }
165 } 195 }
166 196
@@ -174,6 +204,18 @@ static int process_event_stub(event_t *event __used,
174 return 0; 204 return 0;
175} 205}
176 206
207static int process_finished_round_stub(event_t *event __used,
208 struct perf_session *session __used,
209 struct perf_event_ops *ops __used)
210{
211 dump_printf(": unhandled!\n");
212 return 0;
213}
214
215static int process_finished_round(event_t *event,
216 struct perf_session *session,
217 struct perf_event_ops *ops);
218
177static void perf_event_ops__fill_defaults(struct perf_event_ops *handler) 219static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
178{ 220{
179 if (handler->sample == NULL) 221 if (handler->sample == NULL)
@@ -194,29 +236,20 @@ static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
194 handler->throttle = process_event_stub; 236 handler->throttle = process_event_stub;
195 if (handler->unthrottle == NULL) 237 if (handler->unthrottle == NULL)
196 handler->unthrottle = process_event_stub; 238 handler->unthrottle = process_event_stub;
197} 239 if (handler->attr == NULL)
198 240 handler->attr = process_event_stub;
199static const char *event__name[] = { 241 if (handler->event_type == NULL)
200 [0] = "TOTAL", 242 handler->event_type = process_event_stub;
201 [PERF_RECORD_MMAP] = "MMAP", 243 if (handler->tracing_data == NULL)
202 [PERF_RECORD_LOST] = "LOST", 244 handler->tracing_data = process_event_stub;
203 [PERF_RECORD_COMM] = "COMM", 245 if (handler->build_id == NULL)
204 [PERF_RECORD_EXIT] = "EXIT", 246 handler->build_id = process_event_stub;
205 [PERF_RECORD_THROTTLE] = "THROTTLE", 247 if (handler->finished_round == NULL) {
206 [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE", 248 if (handler->ordered_samples)
207 [PERF_RECORD_FORK] = "FORK", 249 handler->finished_round = process_finished_round;
208 [PERF_RECORD_READ] = "READ", 250 else
209 [PERF_RECORD_SAMPLE] = "SAMPLE", 251 handler->finished_round = process_finished_round_stub;
210}; 252 }
211
212unsigned long event__total[PERF_RECORD_MAX];
213
214void event__print_totals(void)
215{
216 int i;
217 for (i = 0; i < PERF_RECORD_MAX; ++i)
218 pr_info("%10s events: %10ld\n",
219 event__name[i], event__total[i]);
220} 253}
221 254
222void mem_bswap_64(void *src, int byte_size) 255void mem_bswap_64(void *src, int byte_size)
@@ -270,6 +303,37 @@ static void event__read_swap(event_t *self)
270 self->read.id = bswap_64(self->read.id); 303 self->read.id = bswap_64(self->read.id);
271} 304}
272 305
306static void event__attr_swap(event_t *self)
307{
308 size_t size;
309
310 self->attr.attr.type = bswap_32(self->attr.attr.type);
311 self->attr.attr.size = bswap_32(self->attr.attr.size);
312 self->attr.attr.config = bswap_64(self->attr.attr.config);
313 self->attr.attr.sample_period = bswap_64(self->attr.attr.sample_period);
314 self->attr.attr.sample_type = bswap_64(self->attr.attr.sample_type);
315 self->attr.attr.read_format = bswap_64(self->attr.attr.read_format);
316 self->attr.attr.wakeup_events = bswap_32(self->attr.attr.wakeup_events);
317 self->attr.attr.bp_type = bswap_32(self->attr.attr.bp_type);
318 self->attr.attr.bp_addr = bswap_64(self->attr.attr.bp_addr);
319 self->attr.attr.bp_len = bswap_64(self->attr.attr.bp_len);
320
321 size = self->header.size;
322 size -= (void *)&self->attr.id - (void *)self;
323 mem_bswap_64(self->attr.id, size);
324}
325
326static void event__event_type_swap(event_t *self)
327{
328 self->event_type.event_type.event_id =
329 bswap_64(self->event_type.event_type.event_id);
330}
331
332static void event__tracing_data_swap(event_t *self)
333{
334 self->tracing_data.size = bswap_32(self->tracing_data.size);
335}
336
273typedef void (*event__swap_op)(event_t *self); 337typedef void (*event__swap_op)(event_t *self);
274 338
275static event__swap_op event__swap_ops[] = { 339static event__swap_op event__swap_ops[] = {
@@ -280,9 +344,212 @@ static event__swap_op event__swap_ops[] = {
280 [PERF_RECORD_LOST] = event__all64_swap, 344 [PERF_RECORD_LOST] = event__all64_swap,
281 [PERF_RECORD_READ] = event__read_swap, 345 [PERF_RECORD_READ] = event__read_swap,
282 [PERF_RECORD_SAMPLE] = event__all64_swap, 346 [PERF_RECORD_SAMPLE] = event__all64_swap,
283 [PERF_RECORD_MAX] = NULL, 347 [PERF_RECORD_HEADER_ATTR] = event__attr_swap,
348 [PERF_RECORD_HEADER_EVENT_TYPE] = event__event_type_swap,
349 [PERF_RECORD_HEADER_TRACING_DATA] = event__tracing_data_swap,
350 [PERF_RECORD_HEADER_BUILD_ID] = NULL,
351 [PERF_RECORD_HEADER_MAX] = NULL,
352};
353
354struct sample_queue {
355 u64 timestamp;
356 struct sample_event *event;
357 struct list_head list;
284}; 358};
285 359
360static void flush_sample_queue(struct perf_session *s,
361 struct perf_event_ops *ops)
362{
363 struct list_head *head = &s->ordered_samples.samples_head;
364 u64 limit = s->ordered_samples.next_flush;
365 struct sample_queue *tmp, *iter;
366
367 if (!ops->ordered_samples || !limit)
368 return;
369
370 list_for_each_entry_safe(iter, tmp, head, list) {
371 if (iter->timestamp > limit)
372 return;
373
374 if (iter == s->ordered_samples.last_inserted)
375 s->ordered_samples.last_inserted = NULL;
376
377 ops->sample((event_t *)iter->event, s);
378
379 s->ordered_samples.last_flush = iter->timestamp;
380 list_del(&iter->list);
381 free(iter->event);
382 free(iter);
383 }
384}
385
386/*
387 * When perf record finishes a pass on every buffers, it records this pseudo
388 * event.
389 * We record the max timestamp t found in the pass n.
390 * Assuming these timestamps are monotonic across cpus, we know that if
391 * a buffer still has events with timestamps below t, they will be all
392 * available and then read in the pass n + 1.
393 * Hence when we start to read the pass n + 2, we can safely flush every
394 * events with timestamps below t.
395 *
396 * ============ PASS n =================
397 * CPU 0 | CPU 1
398 * |
399 * cnt1 timestamps | cnt2 timestamps
400 * 1 | 2
401 * 2 | 3
402 * - | 4 <--- max recorded
403 *
404 * ============ PASS n + 1 ==============
405 * CPU 0 | CPU 1
406 * |
407 * cnt1 timestamps | cnt2 timestamps
408 * 3 | 5
409 * 4 | 6
410 * 5 | 7 <---- max recorded
411 *
412 * Flush every events below timestamp 4
413 *
414 * ============ PASS n + 2 ==============
415 * CPU 0 | CPU 1
416 * |
417 * cnt1 timestamps | cnt2 timestamps
418 * 6 | 8
419 * 7 | 9
420 * - | 10
421 *
422 * Flush every events below timestamp 7
423 * etc...
424 */
425static int process_finished_round(event_t *event __used,
426 struct perf_session *session,
427 struct perf_event_ops *ops)
428{
429 flush_sample_queue(session, ops);
430 session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
431
432 return 0;
433}
434
435static void __queue_sample_end(struct sample_queue *new, struct list_head *head)
436{
437 struct sample_queue *iter;
438
439 list_for_each_entry_reverse(iter, head, list) {
440 if (iter->timestamp < new->timestamp) {
441 list_add(&new->list, &iter->list);
442 return;
443 }
444 }
445
446 list_add(&new->list, head);
447}
448
449static void __queue_sample_before(struct sample_queue *new,
450 struct sample_queue *iter,
451 struct list_head *head)
452{
453 list_for_each_entry_continue_reverse(iter, head, list) {
454 if (iter->timestamp < new->timestamp) {
455 list_add(&new->list, &iter->list);
456 return;
457 }
458 }
459
460 list_add(&new->list, head);
461}
462
463static void __queue_sample_after(struct sample_queue *new,
464 struct sample_queue *iter,
465 struct list_head *head)
466{
467 list_for_each_entry_continue(iter, head, list) {
468 if (iter->timestamp > new->timestamp) {
469 list_add_tail(&new->list, &iter->list);
470 return;
471 }
472 }
473 list_add_tail(&new->list, head);
474}
475
476/* The queue is ordered by time */
477static void __queue_sample_event(struct sample_queue *new,
478 struct perf_session *s)
479{
480 struct sample_queue *last_inserted = s->ordered_samples.last_inserted;
481 struct list_head *head = &s->ordered_samples.samples_head;
482
483
484 if (!last_inserted) {
485 __queue_sample_end(new, head);
486 return;
487 }
488
489 /*
490 * Most of the time the current event has a timestamp
491 * very close to the last event inserted, unless we just switched
492 * to another event buffer. Having a sorting based on a list and
493 * on the last inserted event that is close to the current one is
494 * probably more efficient than an rbtree based sorting.
495 */
496 if (last_inserted->timestamp >= new->timestamp)
497 __queue_sample_before(new, last_inserted, head);
498 else
499 __queue_sample_after(new, last_inserted, head);
500}
501
502static int queue_sample_event(event_t *event, struct sample_data *data,
503 struct perf_session *s)
504{
505 u64 timestamp = data->time;
506 struct sample_queue *new;
507
508
509 if (timestamp < s->ordered_samples.last_flush) {
510 printf("Warning: Timestamp below last timeslice flush\n");
511 return -EINVAL;
512 }
513
514 new = malloc(sizeof(*new));
515 if (!new)
516 return -ENOMEM;
517
518 new->timestamp = timestamp;
519
520 new->event = malloc(event->header.size);
521 if (!new->event) {
522 free(new);
523 return -ENOMEM;
524 }
525
526 memcpy(new->event, event, event->header.size);
527
528 __queue_sample_event(new, s);
529 s->ordered_samples.last_inserted = new;
530
531 if (new->timestamp > s->ordered_samples.max_timestamp)
532 s->ordered_samples.max_timestamp = new->timestamp;
533
534 return 0;
535}
536
537static int perf_session__process_sample(event_t *event, struct perf_session *s,
538 struct perf_event_ops *ops)
539{
540 struct sample_data data;
541
542 if (!ops->ordered_samples)
543 return ops->sample(event, s);
544
545 bzero(&data, sizeof(struct sample_data));
546 event__parse_sample(event, s->sample_type, &data);
547
548 queue_sample_event(event, &data, s);
549
550 return 0;
551}
552
286static int perf_session__process_event(struct perf_session *self, 553static int perf_session__process_event(struct perf_session *self,
287 event_t *event, 554 event_t *event,
288 struct perf_event_ops *ops, 555 struct perf_event_ops *ops,
@@ -290,12 +557,11 @@ static int perf_session__process_event(struct perf_session *self,
290{ 557{
291 trace_event(event); 558 trace_event(event);
292 559
293 if (event->header.type < PERF_RECORD_MAX) { 560 if (event->header.type < PERF_RECORD_HEADER_MAX) {
294 dump_printf("%#Lx [%#x]: PERF_RECORD_%s", 561 dump_printf("%#Lx [%#x]: PERF_RECORD_%s",
295 offset + head, event->header.size, 562 offset + head, event->header.size,
296 event__name[event->header.type]); 563 event__name[event->header.type]);
297 ++event__total[0]; 564 hists__inc_nr_events(&self->hists, event->header.type);
298 ++event__total[event->header.type];
299 } 565 }
300 566
301 if (self->header.needs_swap && event__swap_ops[event->header.type]) 567 if (self->header.needs_swap && event__swap_ops[event->header.type])
@@ -303,7 +569,7 @@ static int perf_session__process_event(struct perf_session *self,
303 569
304 switch (event->header.type) { 570 switch (event->header.type) {
305 case PERF_RECORD_SAMPLE: 571 case PERF_RECORD_SAMPLE:
306 return ops->sample(event, self); 572 return perf_session__process_sample(event, self, ops);
307 case PERF_RECORD_MMAP: 573 case PERF_RECORD_MMAP:
308 return ops->mmap(event, self); 574 return ops->mmap(event, self);
309 case PERF_RECORD_COMM: 575 case PERF_RECORD_COMM:
@@ -320,8 +586,20 @@ static int perf_session__process_event(struct perf_session *self,
320 return ops->throttle(event, self); 586 return ops->throttle(event, self);
321 case PERF_RECORD_UNTHROTTLE: 587 case PERF_RECORD_UNTHROTTLE:
322 return ops->unthrottle(event, self); 588 return ops->unthrottle(event, self);
589 case PERF_RECORD_HEADER_ATTR:
590 return ops->attr(event, self);
591 case PERF_RECORD_HEADER_EVENT_TYPE:
592 return ops->event_type(event, self);
593 case PERF_RECORD_HEADER_TRACING_DATA:
594 /* setup for reading amidst mmap */
595 lseek(self->fd, offset + head, SEEK_SET);
596 return ops->tracing_data(event, self);
597 case PERF_RECORD_HEADER_BUILD_ID:
598 return ops->build_id(event, self);
599 case PERF_RECORD_FINISHED_ROUND:
600 return ops->finished_round(event, self, ops);
323 default: 601 default:
324 self->unknown_events++; 602 ++self->hists.stats.nr_unknown_events;
325 return -1; 603 return -1;
326 } 604 }
327} 605}
@@ -333,56 +611,114 @@ void perf_event_header__bswap(struct perf_event_header *self)
333 self->size = bswap_16(self->size); 611 self->size = bswap_16(self->size);
334} 612}
335 613
336int perf_header__read_build_ids(struct perf_header *self, 614static struct thread *perf_session__register_idle_thread(struct perf_session *self)
337 int input, u64 offset, u64 size)
338{ 615{
339 struct build_id_event bev; 616 struct thread *thread = perf_session__findnew(self, 0);
340 char filename[PATH_MAX];
341 u64 limit = offset + size;
342 int err = -1;
343
344 while (offset < limit) {
345 struct dso *dso;
346 ssize_t len;
347 struct list_head *head = &dsos__user;
348 617
349 if (read(input, &bev, sizeof(bev)) != sizeof(bev)) 618 if (thread == NULL || thread__set_comm(thread, "swapper")) {
350 goto out; 619 pr_err("problem inserting idle task.\n");
620 thread = NULL;
621 }
351 622
352 if (self->needs_swap) 623 return thread;
353 perf_event_header__bswap(&bev.header); 624}
354 625
355 len = bev.header.size - sizeof(bev); 626int do_read(int fd, void *buf, size_t size)
356 if (read(input, filename, len) != len) 627{
357 goto out; 628 void *buf_start = buf;
358 629
359 if (bev.header.misc & PERF_RECORD_MISC_KERNEL) 630 while (size) {
360 head = &dsos__kernel; 631 int ret = read(fd, buf, size);
361 632
362 dso = __dsos__findnew(head, filename); 633 if (ret <= 0)
363 if (dso != NULL) { 634 return ret;
364 dso__set_build_id(dso, &bev.build_id);
365 if (head == &dsos__kernel && filename[0] == '[')
366 dso->kernel = 1;
367 }
368 635
369 offset += bev.header.size; 636 size -= ret;
637 buf += ret;
370 } 638 }
371 err = 0; 639
372out: 640 return buf - buf_start;
373 return err;
374} 641}
375 642
376static struct thread *perf_session__register_idle_thread(struct perf_session *self) 643#define session_done() (*(volatile int *)(&session_done))
644volatile int session_done;
645
646static int __perf_session__process_pipe_events(struct perf_session *self,
647 struct perf_event_ops *ops)
377{ 648{
378 struct thread *thread = perf_session__findnew(self, 0); 649 event_t event;
650 uint32_t size;
651 int skip = 0;
652 u64 head;
653 int err;
654 void *p;
379 655
380 if (thread == NULL || thread__set_comm(thread, "swapper")) { 656 perf_event_ops__fill_defaults(ops);
381 pr_err("problem inserting idle task.\n"); 657
382 thread = NULL; 658 head = 0;
659more:
660 err = do_read(self->fd, &event, sizeof(struct perf_event_header));
661 if (err <= 0) {
662 if (err == 0)
663 goto done;
664
665 pr_err("failed to read event header\n");
666 goto out_err;
383 } 667 }
384 668
385 return thread; 669 if (self->header.needs_swap)
670 perf_event_header__bswap(&event.header);
671
672 size = event.header.size;
673 if (size == 0)
674 size = 8;
675
676 p = &event;
677 p += sizeof(struct perf_event_header);
678
679 if (size - sizeof(struct perf_event_header)) {
680 err = do_read(self->fd, p,
681 size - sizeof(struct perf_event_header));
682 if (err <= 0) {
683 if (err == 0) {
684 pr_err("unexpected end of event stream\n");
685 goto done;
686 }
687
688 pr_err("failed to read event data\n");
689 goto out_err;
690 }
691 }
692
693 if (size == 0 ||
694 (skip = perf_session__process_event(self, &event, ops,
695 0, head)) < 0) {
696 dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
697 head, event.header.size, event.header.type);
698 /*
699 * assume we lost track of the stream, check alignment, and
700 * increment a single u64 in the hope to catch on again 'soon'.
701 */
702 if (unlikely(head & 7))
703 head &= ~7ULL;
704
705 size = 8;
706 }
707
708 head += size;
709
710 dump_printf("\n%#Lx [%#x]: event: %d\n",
711 head, event.header.size, event.header.type);
712
713 if (skip > 0)
714 head += skip;
715
716 if (!session_done())
717 goto more;
718done:
719 err = 0;
720out_err:
721 return err;
386} 722}
387 723
388int __perf_session__process_events(struct perf_session *self, 724int __perf_session__process_events(struct perf_session *self,
@@ -396,6 +732,10 @@ int __perf_session__process_events(struct perf_session *self,
396 event_t *event; 732 event_t *event;
397 uint32_t size; 733 uint32_t size;
398 char *buf; 734 char *buf;
735 struct ui_progress *progress = ui_progress__new("Processing events...",
736 self->size);
737 if (progress == NULL)
738 return -1;
399 739
400 perf_event_ops__fill_defaults(ops); 740 perf_event_ops__fill_defaults(ops);
401 741
@@ -424,6 +764,7 @@ remap:
424 764
425more: 765more:
426 event = (event_t *)(buf + head); 766 event = (event_t *)(buf + head);
767 ui_progress__update(progress, offset);
427 768
428 if (self->header.needs_swap) 769 if (self->header.needs_swap)
429 perf_event_header__bswap(&event->header); 770 perf_event_header__bswap(&event->header);
@@ -473,7 +814,11 @@ more:
473 goto more; 814 goto more;
474done: 815done:
475 err = 0; 816 err = 0;
817 /* do the final flush for ordered samples */
818 self->ordered_samples.next_flush = ULLONG_MAX;
819 flush_sample_queue(self, ops);
476out_err: 820out_err:
821 ui_progress__delete(progress);
477 return err; 822 return err;
478} 823}
479 824
@@ -502,9 +847,13 @@ out_getcwd_err:
502 self->cwdlen = strlen(self->cwd); 847 self->cwdlen = strlen(self->cwd);
503 } 848 }
504 849
505 err = __perf_session__process_events(self, self->header.data_offset, 850 if (!self->fd_pipe)
506 self->header.data_size, 851 err = __perf_session__process_events(self,
507 self->size, ops); 852 self->header.data_offset,
853 self->header.data_size,
854 self->size, ops);
855 else
856 err = __perf_session__process_pipe_events(self, ops);
508out_err: 857out_err:
509 return err; 858 return err;
510} 859}
@@ -519,56 +868,48 @@ bool perf_session__has_traces(struct perf_session *self, const char *msg)
519 return true; 868 return true;
520} 869}
521 870
522int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self, 871int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
523 const char *symbol_name, 872 const char *symbol_name,
524 u64 addr) 873 u64 addr)
525{ 874{
526 char *bracket; 875 char *bracket;
527 enum map_type i; 876 enum map_type i;
877 struct ref_reloc_sym *ref;
878
879 ref = zalloc(sizeof(struct ref_reloc_sym));
880 if (ref == NULL)
881 return -ENOMEM;
528 882
529 self->ref_reloc_sym.name = strdup(symbol_name); 883 ref->name = strdup(symbol_name);
530 if (self->ref_reloc_sym.name == NULL) 884 if (ref->name == NULL) {
885 free(ref);
531 return -ENOMEM; 886 return -ENOMEM;
887 }
532 888
533 bracket = strchr(self->ref_reloc_sym.name, ']'); 889 bracket = strchr(ref->name, ']');
534 if (bracket) 890 if (bracket)
535 *bracket = '\0'; 891 *bracket = '\0';
536 892
537 self->ref_reloc_sym.addr = addr; 893 ref->addr = addr;
538 894
539 for (i = 0; i < MAP__NR_TYPES; ++i) { 895 for (i = 0; i < MAP__NR_TYPES; ++i) {
540 struct kmap *kmap = map__kmap(self->vmlinux_maps[i]); 896 struct kmap *kmap = map__kmap(maps[i]);
541 kmap->ref_reloc_sym = &self->ref_reloc_sym; 897 kmap->ref_reloc_sym = ref;
542 } 898 }
543 899
544 return 0; 900 return 0;
545} 901}
546 902
547static u64 map__reloc_map_ip(struct map *map, u64 ip) 903size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
548{
549 return ip + (s64)map->pgoff;
550}
551
552static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
553{ 904{
554 return ip - (s64)map->pgoff; 905 return __dsos__fprintf(&self->host_machine.kernel_dsos, fp) +
906 __dsos__fprintf(&self->host_machine.user_dsos, fp) +
907 machines__fprintf_dsos(&self->machines, fp);
555} 908}
556 909
557void map__reloc_vmlinux(struct map *self) 910size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
911 bool with_hits)
558{ 912{
559 struct kmap *kmap = map__kmap(self); 913 size_t ret = machine__fprintf_dsos_buildid(&self->host_machine, fp, with_hits);
560 s64 reloc; 914 return ret + machines__fprintf_dsos_buildid(&self->machines, fp, with_hits);
561
562 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
563 return;
564
565 reloc = (kmap->ref_reloc_sym->unrelocated_addr -
566 kmap->ref_reloc_sym->addr);
567
568 if (!reloc)
569 return;
570
571 self->map_ip = map__reloc_map_ip;
572 self->unmap_ip = map__reloc_unmap_ip;
573 self->pgoff = reloc;
574} 915}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 5c33417eebb..9fa0fc2a863 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -1,6 +1,7 @@
1#ifndef __PERF_SESSION_H 1#ifndef __PERF_SESSION_H
2#define __PERF_SESSION_H 2#define __PERF_SESSION_H
3 3
4#include "hist.h"
4#include "event.h" 5#include "event.h"
5#include "header.h" 6#include "header.h"
6#include "symbol.h" 7#include "symbol.h"
@@ -8,45 +9,70 @@
8#include <linux/rbtree.h> 9#include <linux/rbtree.h>
9#include "../../../include/linux/perf_event.h" 10#include "../../../include/linux/perf_event.h"
10 11
12struct sample_queue;
11struct ip_callchain; 13struct ip_callchain;
12struct thread; 14struct thread;
13 15
16struct ordered_samples {
17 u64 last_flush;
18 u64 next_flush;
19 u64 max_timestamp;
20 struct list_head samples_head;
21 struct sample_queue *last_inserted;
22};
23
14struct perf_session { 24struct perf_session {
15 struct perf_header header; 25 struct perf_header header;
16 unsigned long size; 26 unsigned long size;
17 unsigned long mmap_window; 27 unsigned long mmap_window;
18 struct map_groups kmaps;
19 struct rb_root threads; 28 struct rb_root threads;
29 struct list_head dead_threads;
20 struct thread *last_match; 30 struct thread *last_match;
21 struct map *vmlinux_maps[MAP__NR_TYPES]; 31 struct machine host_machine;
22 struct events_stats events_stats; 32 struct rb_root machines;
23 struct rb_root stats_by_id; 33 struct rb_root hists_tree;
24 unsigned long event_total[PERF_RECORD_MAX]; 34 /*
25 unsigned long unknown_events; 35 * FIXME: should point to the first entry in hists_tree and
26 struct rb_root hists; 36 * be a hists instance. Right now its only 'report'
37 * that is using ->hists_tree while all the rest use
38 * ->hists.
39 */
40 struct hists hists;
27 u64 sample_type; 41 u64 sample_type;
28 struct ref_reloc_sym ref_reloc_sym;
29 int fd; 42 int fd;
43 bool fd_pipe;
44 bool repipe;
30 int cwdlen; 45 int cwdlen;
31 char *cwd; 46 char *cwd;
47 struct ordered_samples ordered_samples;
32 char filename[0]; 48 char filename[0];
33}; 49};
34 50
51struct perf_event_ops;
52
35typedef int (*event_op)(event_t *self, struct perf_session *session); 53typedef int (*event_op)(event_t *self, struct perf_session *session);
54typedef int (*event_op2)(event_t *self, struct perf_session *session,
55 struct perf_event_ops *ops);
36 56
37struct perf_event_ops { 57struct perf_event_ops {
38 event_op sample, 58 event_op sample,
39 mmap, 59 mmap,
40 comm, 60 comm,
41 fork, 61 fork,
42 exit, 62 exit,
43 lost, 63 lost,
44 read, 64 read,
45 throttle, 65 throttle,
46 unthrottle; 66 unthrottle,
67 attr,
68 event_type,
69 tracing_data,
70 build_id;
71 event_op2 finished_round;
72 bool ordered_samples;
47}; 73};
48 74
49struct perf_session *perf_session__new(const char *filename, int mode, bool force); 75struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe);
50void perf_session__delete(struct perf_session *self); 76void perf_session__delete(struct perf_session *self);
51 77
52void perf_event_header__bswap(struct perf_event_header *self); 78void perf_event_header__bswap(struct perf_event_header *self);
@@ -57,33 +83,63 @@ int __perf_session__process_events(struct perf_session *self,
57int perf_session__process_events(struct perf_session *self, 83int perf_session__process_events(struct perf_session *self,
58 struct perf_event_ops *event_ops); 84 struct perf_event_ops *event_ops);
59 85
60struct symbol **perf_session__resolve_callchain(struct perf_session *self, 86struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
61 struct thread *thread, 87 struct thread *thread,
62 struct ip_callchain *chain, 88 struct ip_callchain *chain,
63 struct symbol **parent); 89 struct symbol **parent);
64 90
65bool perf_session__has_traces(struct perf_session *self, const char *msg); 91bool perf_session__has_traces(struct perf_session *self, const char *msg);
66 92
67int perf_header__read_build_ids(struct perf_header *self, int input, 93int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
68 u64 offset, u64 file_size);
69
70int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
71 const char *symbol_name, 94 const char *symbol_name,
72 u64 addr); 95 u64 addr);
73 96
74void mem_bswap_64(void *src, int byte_size); 97void mem_bswap_64(void *src, int byte_size);
75 98
76static inline int __perf_session__create_kernel_maps(struct perf_session *self, 99int perf_session__create_kernel_maps(struct perf_session *self);
77 struct dso *kernel) 100
101int do_read(int fd, void *buf, size_t size);
102void perf_session__update_sample_type(struct perf_session *self);
103void perf_session__remove_thread(struct perf_session *self, struct thread *th);
104
105static inline
106struct machine *perf_session__find_host_machine(struct perf_session *self)
107{
108 return &self->host_machine;
109}
110
111static inline
112struct machine *perf_session__find_machine(struct perf_session *self, pid_t pid)
78{ 113{
79 return __map_groups__create_kernel_maps(&self->kmaps, 114 if (pid == HOST_KERNEL_ID)
80 self->vmlinux_maps, kernel); 115 return &self->host_machine;
116 return machines__find(&self->machines, pid);
81} 117}
82 118
83static inline struct map * 119static inline
84 perf_session__new_module_map(struct perf_session *self, 120struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t pid)
85 u64 start, const char *filename) 121{
122 if (pid == HOST_KERNEL_ID)
123 return &self->host_machine;
124 return machines__findnew(&self->machines, pid);
125}
126
127static inline
128void perf_session__process_machines(struct perf_session *self,
129 machine__process_t process)
130{
131 process(&self->host_machine, self);
132 return machines__process(&self->machines, process, self);
133}
134
135size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp);
136
137size_t perf_session__fprintf_dsos_buildid(struct perf_session *self,
138 FILE *fp, bool with_hits);
139
140static inline
141size_t perf_session__fprintf_nr_events(struct perf_session *self, FILE *fp)
86{ 142{
87 return map_groups__new_module(&self->kmaps, start, filename); 143 return hists__fprintf_nr_events(&self->hists, fp);
88} 144}
89#endif /* __PERF_SESSION_H */ 145#endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sigchain.c b/tools/perf/util/sigchain.c
index 1118b99e57d..ba785e9b184 100644
--- a/tools/perf/util/sigchain.c
+++ b/tools/perf/util/sigchain.c
@@ -16,7 +16,7 @@ static void check_signum(int sig)
16 die("BUG: signal out of range: %d", sig); 16 die("BUG: signal out of range: %d", sig);
17} 17}
18 18
19int sigchain_push(int sig, sigchain_fun f) 19static int sigchain_push(int sig, sigchain_fun f)
20{ 20{
21 struct sigchain_signal *s = signals + sig; 21 struct sigchain_signal *s = signals + sig;
22 check_signum(sig); 22 check_signum(sig);
diff --git a/tools/perf/util/sigchain.h b/tools/perf/util/sigchain.h
index 1a53c11265f..959d64eb555 100644
--- a/tools/perf/util/sigchain.h
+++ b/tools/perf/util/sigchain.h
@@ -3,7 +3,6 @@
3 3
4typedef void (*sigchain_fun)(int); 4typedef void (*sigchain_fun)(int);
5 5
6int sigchain_push(int sig, sigchain_fun f);
7int sigchain_pop(int sig); 6int sigchain_pop(int sig);
8 7
9void sigchain_push_common(sigchain_fun f); 8void sigchain_push_common(sigchain_fun f);
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index cb0f327de9e..2316cb5a411 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,10 +1,10 @@
1#include "sort.h" 1#include "sort.h"
2 2
3regex_t parent_regex; 3regex_t parent_regex;
4char default_parent_pattern[] = "^sys_|^do_page_fault"; 4const char default_parent_pattern[] = "^sys_|^do_page_fault";
5char *parent_pattern = default_parent_pattern; 5const char *parent_pattern = default_parent_pattern;
6char default_sort_order[] = "comm,dso,symbol"; 6const char default_sort_order[] = "comm,dso,symbol";
7char *sort_order = default_sort_order; 7const char *sort_order = default_sort_order;
8int sort__need_collapse = 0; 8int sort__need_collapse = 0;
9int sort__has_parent = 0; 9int sort__has_parent = 0;
10 10
@@ -18,39 +18,50 @@ char * field_sep;
18 18
19LIST_HEAD(hist_entry__sort_list); 19LIST_HEAD(hist_entry__sort_list);
20 20
21static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
22 size_t size, unsigned int width);
23static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
24 size_t size, unsigned int width);
25static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
26 size_t size, unsigned int width);
27static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
28 size_t size, unsigned int width);
29static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
30 size_t size, unsigned int width);
31
21struct sort_entry sort_thread = { 32struct sort_entry sort_thread = {
22 .header = "Command: Pid", 33 .se_header = "Command: Pid",
23 .cmp = sort__thread_cmp, 34 .se_cmp = sort__thread_cmp,
24 .print = sort__thread_print, 35 .se_snprintf = hist_entry__thread_snprintf,
25 .width = &threads__col_width, 36 .se_width = &threads__col_width,
26}; 37};
27 38
28struct sort_entry sort_comm = { 39struct sort_entry sort_comm = {
29 .header = "Command", 40 .se_header = "Command",
30 .cmp = sort__comm_cmp, 41 .se_cmp = sort__comm_cmp,
31 .collapse = sort__comm_collapse, 42 .se_collapse = sort__comm_collapse,
32 .print = sort__comm_print, 43 .se_snprintf = hist_entry__comm_snprintf,
33 .width = &comms__col_width, 44 .se_width = &comms__col_width,
34}; 45};
35 46
36struct sort_entry sort_dso = { 47struct sort_entry sort_dso = {
37 .header = "Shared Object", 48 .se_header = "Shared Object",
38 .cmp = sort__dso_cmp, 49 .se_cmp = sort__dso_cmp,
39 .print = sort__dso_print, 50 .se_snprintf = hist_entry__dso_snprintf,
40 .width = &dsos__col_width, 51 .se_width = &dsos__col_width,
41}; 52};
42 53
43struct sort_entry sort_sym = { 54struct sort_entry sort_sym = {
44 .header = "Symbol", 55 .se_header = "Symbol",
45 .cmp = sort__sym_cmp, 56 .se_cmp = sort__sym_cmp,
46 .print = sort__sym_print, 57 .se_snprintf = hist_entry__sym_snprintf,
47}; 58};
48 59
49struct sort_entry sort_parent = { 60struct sort_entry sort_parent = {
50 .header = "Parent symbol", 61 .se_header = "Parent symbol",
51 .cmp = sort__parent_cmp, 62 .se_cmp = sort__parent_cmp,
52 .print = sort__parent_print, 63 .se_snprintf = hist_entry__parent_snprintf,
53 .width = &parent_symbol__col_width, 64 .se_width = &parent_symbol__col_width,
54}; 65};
55 66
56struct sort_dimension { 67struct sort_dimension {
@@ -85,45 +96,38 @@ sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
85 return right->thread->pid - left->thread->pid; 96 return right->thread->pid - left->thread->pid;
86} 97}
87 98
88int repsep_fprintf(FILE *fp, const char *fmt, ...) 99static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
89{ 100{
90 int n; 101 int n;
91 va_list ap; 102 va_list ap;
92 103
93 va_start(ap, fmt); 104 va_start(ap, fmt);
94 if (!field_sep) 105 n = vsnprintf(bf, size, fmt, ap);
95 n = vfprintf(fp, fmt, ap); 106 if (field_sep && n > 0) {
96 else { 107 char *sep = bf;
97 char *bf = NULL; 108
98 n = vasprintf(&bf, fmt, ap); 109 while (1) {
99 if (n > 0) { 110 sep = strchr(sep, *field_sep);
100 char *sep = bf; 111 if (sep == NULL)
101 112 break;
102 while (1) { 113 *sep = '.';
103 sep = strchr(sep, *field_sep);
104 if (sep == NULL)
105 break;
106 *sep = '.';
107 }
108 } 114 }
109 fputs(bf, fp);
110 free(bf);
111 } 115 }
112 va_end(ap); 116 va_end(ap);
113 return n; 117 return n;
114} 118}
115 119
116size_t 120static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
117sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width) 121 size_t size, unsigned int width)
118{ 122{
119 return repsep_fprintf(fp, "%*s:%5d", width - 6, 123 return repsep_snprintf(bf, size, "%*s:%5d", width,
120 self->thread->comm ?: "", self->thread->pid); 124 self->thread->comm ?: "", self->thread->pid);
121} 125}
122 126
123size_t 127static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
124sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width) 128 size_t size, unsigned int width)
125{ 129{
126 return repsep_fprintf(fp, "%*s", width, self->thread->comm); 130 return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
127} 131}
128 132
129/* --sort dso */ 133/* --sort dso */
@@ -131,8 +135,8 @@ sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
131int64_t 135int64_t
132sort__dso_cmp(struct hist_entry *left, struct hist_entry *right) 136sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
133{ 137{
134 struct dso *dso_l = left->map ? left->map->dso : NULL; 138 struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
135 struct dso *dso_r = right->map ? right->map->dso : NULL; 139 struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
136 const char *dso_name_l, *dso_name_r; 140 const char *dso_name_l, *dso_name_r;
137 141
138 if (!dso_l || !dso_r) 142 if (!dso_l || !dso_r)
@@ -149,16 +153,16 @@ sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
149 return strcmp(dso_name_l, dso_name_r); 153 return strcmp(dso_name_l, dso_name_r);
150} 154}
151 155
152size_t 156static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
153sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width) 157 size_t size, unsigned int width)
154{ 158{
155 if (self->map && self->map->dso) { 159 if (self->ms.map && self->ms.map->dso) {
156 const char *dso_name = !verbose ? self->map->dso->short_name : 160 const char *dso_name = !verbose ? self->ms.map->dso->short_name :
157 self->map->dso->long_name; 161 self->ms.map->dso->long_name;
158 return repsep_fprintf(fp, "%-*s", width, dso_name); 162 return repsep_snprintf(bf, size, "%-*s", width, dso_name);
159 } 163 }
160 164
161 return repsep_fprintf(fp, "%*llx", width, (u64)self->ip); 165 return repsep_snprintf(bf, size, "%*Lx", width, self->ip);
162} 166}
163 167
164/* --sort symbol */ 168/* --sort symbol */
@@ -168,31 +172,31 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
168{ 172{
169 u64 ip_l, ip_r; 173 u64 ip_l, ip_r;
170 174
171 if (left->sym == right->sym) 175 if (left->ms.sym == right->ms.sym)
172 return 0; 176 return 0;
173 177
174 ip_l = left->sym ? left->sym->start : left->ip; 178 ip_l = left->ms.sym ? left->ms.sym->start : left->ip;
175 ip_r = right->sym ? right->sym->start : right->ip; 179 ip_r = right->ms.sym ? right->ms.sym->start : right->ip;
176 180
177 return (int64_t)(ip_r - ip_l); 181 return (int64_t)(ip_r - ip_l);
178} 182}
179 183
180 184static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
181size_t 185 size_t size, unsigned int width __used)
182sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
183{ 186{
184 size_t ret = 0; 187 size_t ret = 0;
185 188
186 if (verbose) { 189 if (verbose) {
187 char o = self->map ? dso__symtab_origin(self->map->dso) : '!'; 190 char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
188 ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip, o); 191 ret += repsep_snprintf(bf, size, "%#018llx %c ", self->ip, o);
189 } 192 }
190 193
191 ret += repsep_fprintf(fp, "[%c] ", self->level); 194 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
192 if (self->sym) 195 if (self->ms.sym)
193 ret += repsep_fprintf(fp, "%s", self->sym->name); 196 ret += repsep_snprintf(bf + ret, size - ret, "%s",
197 self->ms.sym->name);
194 else 198 else
195 ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip); 199 ret += repsep_snprintf(bf + ret, size - ret, "%#016llx", self->ip);
196 200
197 return ret; 201 return ret;
198} 202}
@@ -231,10 +235,10 @@ sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
231 return strcmp(sym_l->name, sym_r->name); 235 return strcmp(sym_l->name, sym_r->name);
232} 236}
233 237
234size_t 238static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
235sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width) 239 size_t size, unsigned int width)
236{ 240{
237 return repsep_fprintf(fp, "%-*s", width, 241 return repsep_snprintf(bf, size, "%-*s", width,
238 self->parent ? self->parent->name : "[other]"); 242 self->parent ? self->parent->name : "[other]");
239} 243}
240 244
@@ -251,7 +255,7 @@ int sort_dimension__add(const char *tok)
251 if (strncasecmp(tok, sd->name, strlen(tok))) 255 if (strncasecmp(tok, sd->name, strlen(tok)))
252 continue; 256 continue;
253 257
254 if (sd->entry->collapse) 258 if (sd->entry->se_collapse)
255 sort__need_collapse = 1; 259 sort__need_collapse = 1;
256 260
257 if (sd->entry == &sort_parent) { 261 if (sd->entry == &sort_parent) {
@@ -260,9 +264,8 @@ int sort_dimension__add(const char *tok)
260 char err[BUFSIZ]; 264 char err[BUFSIZ];
261 265
262 regerror(ret, &parent_regex, err, sizeof(err)); 266 regerror(ret, &parent_regex, err, sizeof(err));
263 fprintf(stderr, "Invalid regex: %s\n%s", 267 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
264 parent_pattern, err); 268 return -EINVAL;
265 exit(-1);
266 } 269 }
267 sort__has_parent = 1; 270 sort__has_parent = 1;
268 } 271 }
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 753f9ea99fb..0d61c4082f4 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -25,10 +25,10 @@
25#include "sort.h" 25#include "sort.h"
26 26
27extern regex_t parent_regex; 27extern regex_t parent_regex;
28extern char *sort_order; 28extern const char *sort_order;
29extern char default_parent_pattern[]; 29extern const char default_parent_pattern[];
30extern char *parent_pattern; 30extern const char *parent_pattern;
31extern char default_sort_order[]; 31extern const char default_sort_order[];
32extern int sort__need_collapse; 32extern int sort__need_collapse;
33extern int sort__has_parent; 33extern int sort__has_parent;
34extern char *field_sep; 34extern char *field_sep;
@@ -43,19 +43,24 @@ extern enum sort_type sort__first_dimension;
43 43
44struct hist_entry { 44struct hist_entry {
45 struct rb_node rb_node; 45 struct rb_node rb_node;
46 u64 count; 46 u64 period;
47 u64 period_sys;
48 u64 period_us;
49 u64 period_guest_sys;
50 u64 period_guest_us;
51 struct map_symbol ms;
47 struct thread *thread; 52 struct thread *thread;
48 struct map *map;
49 struct symbol *sym;
50 u64 ip; 53 u64 ip;
54 u32 nr_events;
51 char level; 55 char level;
52 struct symbol *parent; 56 u8 filtered;
53 struct callchain_node callchain; 57 struct symbol *parent;
54 union { 58 union {
55 unsigned long position; 59 unsigned long position;
56 struct hist_entry *pair; 60 struct hist_entry *pair;
57 struct rb_root sorted_chain; 61 struct rb_root sorted_chain;
58 }; 62 };
63 struct callchain_node callchain[0];
59}; 64};
60 65
61enum sort_type { 66enum sort_type {
@@ -73,12 +78,13 @@ enum sort_type {
73struct sort_entry { 78struct sort_entry {
74 struct list_head list; 79 struct list_head list;
75 80
76 const char *header; 81 const char *se_header;
77 82
78 int64_t (*cmp)(struct hist_entry *, struct hist_entry *); 83 int64_t (*se_cmp)(struct hist_entry *, struct hist_entry *);
79 int64_t (*collapse)(struct hist_entry *, struct hist_entry *); 84 int64_t (*se_collapse)(struct hist_entry *, struct hist_entry *);
80 size_t (*print)(FILE *fp, struct hist_entry *, unsigned int width); 85 int (*se_snprintf)(struct hist_entry *self, char *bf, size_t size,
81 unsigned int *width; 86 unsigned int width);
87 unsigned int *se_width;
82 bool elide; 88 bool elide;
83}; 89};
84 90
@@ -87,7 +93,6 @@ extern struct list_head hist_entry__sort_list;
87 93
88void setup_sorting(const char * const usagestr[], const struct option *opts); 94void setup_sorting(const char * const usagestr[], const struct option *opts);
89 95
90extern int repsep_fprintf(FILE *fp, const char *fmt, ...);
91extern size_t sort__thread_print(FILE *, struct hist_entry *, unsigned int); 96extern size_t sort__thread_print(FILE *, struct hist_entry *, unsigned int);
92extern size_t sort__comm_print(FILE *, struct hist_entry *, unsigned int); 97extern size_t sort__comm_print(FILE *, struct hist_entry *, unsigned int);
93extern size_t sort__dso_print(FILE *, struct hist_entry *, unsigned int); 98extern size_t sort__dso_print(FILE *, struct hist_entry *, unsigned int);
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 5249d5a1b0c..92e068517c1 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -41,16 +41,6 @@ char *strbuf_detach(struct strbuf *sb, size_t *sz)
41 return res; 41 return res;
42} 42}
43 43
44void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
45{
46 strbuf_release(sb);
47 sb->buf = buf;
48 sb->len = len;
49 sb->alloc = alloc;
50 strbuf_grow(sb, 0);
51 sb->buf[sb->len] = '\0';
52}
53
54void strbuf_grow(struct strbuf *sb, size_t extra) 44void strbuf_grow(struct strbuf *sb, size_t extra)
55{ 45{
56 if (sb->len + extra + 1 <= sb->len) 46 if (sb->len + extra + 1 <= sb->len)
@@ -60,94 +50,7 @@ void strbuf_grow(struct strbuf *sb, size_t extra)
60 ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc); 50 ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
61} 51}
62 52
63void strbuf_trim(struct strbuf *sb) 53static void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
64{
65 char *b = sb->buf;
66 while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
67 sb->len--;
68 while (sb->len > 0 && isspace(*b)) {
69 b++;
70 sb->len--;
71 }
72 memmove(sb->buf, b, sb->len);
73 sb->buf[sb->len] = '\0';
74}
75void strbuf_rtrim(struct strbuf *sb)
76{
77 while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
78 sb->len--;
79 sb->buf[sb->len] = '\0';
80}
81
82void strbuf_ltrim(struct strbuf *sb)
83{
84 char *b = sb->buf;
85 while (sb->len > 0 && isspace(*b)) {
86 b++;
87 sb->len--;
88 }
89 memmove(sb->buf, b, sb->len);
90 sb->buf[sb->len] = '\0';
91}
92
93void strbuf_tolower(struct strbuf *sb)
94{
95 unsigned int i;
96
97 for (i = 0; i < sb->len; i++)
98 sb->buf[i] = tolower(sb->buf[i]);
99}
100
101struct strbuf **strbuf_split(const struct strbuf *sb, int delim)
102{
103 int alloc = 2, pos = 0;
104 char *n, *p;
105 struct strbuf **ret;
106 struct strbuf *t;
107
108 ret = calloc(alloc, sizeof(struct strbuf *));
109 p = n = sb->buf;
110 while (n < sb->buf + sb->len) {
111 int len;
112 n = memchr(n, delim, sb->len - (n - sb->buf));
113 if (pos + 1 >= alloc) {
114 alloc = alloc * 2;
115 ret = realloc(ret, sizeof(struct strbuf *) * alloc);
116 }
117 if (!n)
118 n = sb->buf + sb->len - 1;
119 len = n - p + 1;
120 t = malloc(sizeof(struct strbuf));
121 strbuf_init(t, len);
122 strbuf_add(t, p, len);
123 ret[pos] = t;
124 ret[++pos] = NULL;
125 p = ++n;
126 }
127 return ret;
128}
129
130void strbuf_list_free(struct strbuf **sbs)
131{
132 struct strbuf **s = sbs;
133
134 while (*s) {
135 strbuf_release(*s);
136 free(*s++);
137 }
138 free(sbs);
139}
140
141int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
142{
143 int len = a->len < b->len ? a->len: b->len;
144 int cmp = memcmp(a->buf, b->buf, len);
145 if (cmp)
146 return cmp;
147 return a->len < b->len ? -1: a->len != b->len;
148}
149
150void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
151 const void *data, size_t dlen) 54 const void *data, size_t dlen)
152{ 55{
153 if (pos + len < pos) 56 if (pos + len < pos)
@@ -166,11 +69,6 @@ void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
166 strbuf_setlen(sb, sb->len + dlen - len); 69 strbuf_setlen(sb, sb->len + dlen - len);
167} 70}
168 71
169void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
170{
171 strbuf_splice(sb, pos, 0, data, len);
172}
173
174void strbuf_remove(struct strbuf *sb, size_t pos, size_t len) 72void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
175{ 73{
176 strbuf_splice(sb, pos, len, NULL, 0); 74 strbuf_splice(sb, pos, len, NULL, 0);
@@ -183,13 +81,6 @@ void strbuf_add(struct strbuf *sb, const void *data, size_t len)
183 strbuf_setlen(sb, sb->len + len); 81 strbuf_setlen(sb, sb->len + len);
184} 82}
185 83
186void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len)
187{
188 strbuf_grow(sb, len);
189 memcpy(sb->buf + sb->len, sb->buf + pos, len);
190 strbuf_setlen(sb, sb->len + len);
191}
192
193void strbuf_addf(struct strbuf *sb, const char *fmt, ...) 84void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
194{ 85{
195 int len; 86 int len;
@@ -214,57 +105,6 @@ void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
214 strbuf_setlen(sb, sb->len + len); 105 strbuf_setlen(sb, sb->len + len);
215} 106}
216 107
217void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn,
218 void *context)
219{
220 for (;;) {
221 const char *percent;
222 size_t consumed;
223
224 percent = strchrnul(format, '%');
225 strbuf_add(sb, format, percent - format);
226 if (!*percent)
227 break;
228 format = percent + 1;
229
230 consumed = fn(sb, format, context);
231 if (consumed)
232 format += consumed;
233 else
234 strbuf_addch(sb, '%');
235 }
236}
237
238size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder,
239 void *context)
240{
241 struct strbuf_expand_dict_entry *e = context;
242 size_t len;
243
244 for (; e->placeholder && (len = strlen(e->placeholder)); e++) {
245 if (!strncmp(placeholder, e->placeholder, len)) {
246 if (e->value)
247 strbuf_addstr(sb, e->value);
248 return len;
249 }
250 }
251 return 0;
252}
253
254size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
255{
256 size_t res;
257 size_t oldalloc = sb->alloc;
258
259 strbuf_grow(sb, size);
260 res = fread(sb->buf + sb->len, 1, size, f);
261 if (res > 0)
262 strbuf_setlen(sb, sb->len + res);
263 else if (oldalloc == 0)
264 strbuf_release(sb);
265 return res;
266}
267
268ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint) 108ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
269{ 109{
270 size_t oldlen = sb->len; 110 size_t oldlen = sb->len;
@@ -291,70 +131,3 @@ ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
291 sb->buf[sb->len] = '\0'; 131 sb->buf[sb->len] = '\0';
292 return sb->len - oldlen; 132 return sb->len - oldlen;
293} 133}
294
295#define STRBUF_MAXLINK (2*PATH_MAX)
296
297int strbuf_readlink(struct strbuf *sb, const char *path, ssize_t hint)
298{
299 size_t oldalloc = sb->alloc;
300
301 if (hint < 32)
302 hint = 32;
303
304 while (hint < STRBUF_MAXLINK) {
305 ssize_t len;
306
307 strbuf_grow(sb, hint);
308 len = readlink(path, sb->buf, hint);
309 if (len < 0) {
310 if (errno != ERANGE)
311 break;
312 } else if (len < hint) {
313 strbuf_setlen(sb, len);
314 return 0;
315 }
316
317 /* .. the buffer was too small - try again */
318 hint *= 2;
319 }
320 if (oldalloc == 0)
321 strbuf_release(sb);
322 return -1;
323}
324
325int strbuf_getline(struct strbuf *sb, FILE *fp, int term)
326{
327 int ch;
328
329 strbuf_grow(sb, 0);
330 if (feof(fp))
331 return EOF;
332
333 strbuf_reset(sb);
334 while ((ch = fgetc(fp)) != EOF) {
335 if (ch == term)
336 break;
337 strbuf_grow(sb, 1);
338 sb->buf[sb->len++] = ch;
339 }
340 if (ch == EOF && sb->len == 0)
341 return EOF;
342
343 sb->buf[sb->len] = '\0';
344 return 0;
345}
346
347int strbuf_read_file(struct strbuf *sb, const char *path, ssize_t hint)
348{
349 int fd, len;
350
351 fd = open(path, O_RDONLY);
352 if (fd < 0)
353 return -1;
354 len = strbuf_read(sb, fd, hint);
355 close(fd);
356 if (len < 0)
357 return -1;
358
359 return len;
360}
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
index a3d121d6c83..436ac319f6c 100644
--- a/tools/perf/util/strbuf.h
+++ b/tools/perf/util/strbuf.h
@@ -53,12 +53,6 @@ struct strbuf {
53extern void strbuf_init(struct strbuf *buf, ssize_t hint); 53extern void strbuf_init(struct strbuf *buf, ssize_t hint);
54extern void strbuf_release(struct strbuf *); 54extern void strbuf_release(struct strbuf *);
55extern char *strbuf_detach(struct strbuf *, size_t *); 55extern char *strbuf_detach(struct strbuf *, size_t *);
56extern void strbuf_attach(struct strbuf *, void *, size_t, size_t);
57static inline void strbuf_swap(struct strbuf *a, struct strbuf *b) {
58 struct strbuf tmp = *a;
59 *a = *b;
60 *b = tmp;
61}
62 56
63/*----- strbuf size related -----*/ 57/*----- strbuf size related -----*/
64static inline ssize_t strbuf_avail(const struct strbuf *sb) { 58static inline ssize_t strbuf_avail(const struct strbuf *sb) {
@@ -74,17 +68,6 @@ static inline void strbuf_setlen(struct strbuf *sb, size_t len) {
74 sb->len = len; 68 sb->len = len;
75 sb->buf[len] = '\0'; 69 sb->buf[len] = '\0';
76} 70}
77#define strbuf_reset(sb) strbuf_setlen(sb, 0)
78
79/*----- content related -----*/
80extern void strbuf_trim(struct strbuf *);
81extern void strbuf_rtrim(struct strbuf *);
82extern void strbuf_ltrim(struct strbuf *);
83extern int strbuf_cmp(const struct strbuf *, const struct strbuf *);
84extern void strbuf_tolower(struct strbuf *);
85
86extern struct strbuf **strbuf_split(const struct strbuf *, int delim);
87extern void strbuf_list_free(struct strbuf **);
88 71
89/*----- add data in your buffer -----*/ 72/*----- add data in your buffer -----*/
90static inline void strbuf_addch(struct strbuf *sb, int c) { 73static inline void strbuf_addch(struct strbuf *sb, int c) {
@@ -93,45 +76,17 @@ static inline void strbuf_addch(struct strbuf *sb, int c) {
93 sb->buf[sb->len] = '\0'; 76 sb->buf[sb->len] = '\0';
94} 77}
95 78
96extern void strbuf_insert(struct strbuf *, size_t pos, const void *, size_t);
97extern void strbuf_remove(struct strbuf *, size_t pos, size_t len); 79extern void strbuf_remove(struct strbuf *, size_t pos, size_t len);
98 80
99/* splice pos..pos+len with given data */
100extern void strbuf_splice(struct strbuf *, size_t pos, size_t len,
101 const void *, size_t);
102
103extern void strbuf_add(struct strbuf *, const void *, size_t); 81extern void strbuf_add(struct strbuf *, const void *, size_t);
104static inline void strbuf_addstr(struct strbuf *sb, const char *s) { 82static inline void strbuf_addstr(struct strbuf *sb, const char *s) {
105 strbuf_add(sb, s, strlen(s)); 83 strbuf_add(sb, s, strlen(s));
106} 84}
107static inline void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2) {
108 strbuf_add(sb, sb2->buf, sb2->len);
109}
110extern void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len);
111
112typedef size_t (*expand_fn_t) (struct strbuf *sb, const char *placeholder, void *context);
113extern void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn, void *context);
114struct strbuf_expand_dict_entry {
115 const char *placeholder;
116 const char *value;
117};
118extern size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder, void *context);
119 85
120__attribute__((format(printf,2,3))) 86__attribute__((format(printf,2,3)))
121extern void strbuf_addf(struct strbuf *sb, const char *fmt, ...); 87extern void strbuf_addf(struct strbuf *sb, const char *fmt, ...);
122 88
123extern size_t strbuf_fread(struct strbuf *, size_t, FILE *);
124/* XXX: if read fails, any partial read is undone */ 89/* XXX: if read fails, any partial read is undone */
125extern ssize_t strbuf_read(struct strbuf *, int fd, ssize_t hint); 90extern ssize_t strbuf_read(struct strbuf *, int fd, ssize_t hint);
126extern int strbuf_read_file(struct strbuf *sb, const char *path, ssize_t hint);
127extern int strbuf_readlink(struct strbuf *sb, const char *path, ssize_t hint);
128
129extern int strbuf_getline(struct strbuf *, FILE *, int);
130
131extern void stripspace(struct strbuf *buf, int skip_comments);
132extern int launch_editor(const char *path, struct strbuf *buffer, const char *const *env);
133
134extern int strbuf_branchname(struct strbuf *sb, const char *name);
135extern int strbuf_check_branch_ref(struct strbuf *sb, const char *name);
136 91
137#endif /* __PERF_STRBUF_H */ 92#endif /* __PERF_STRBUF_H */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index a175949ed21..0409fc7c005 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,48 +1,5 @@
1#include "string.h"
2#include "util.h" 1#include "util.h"
3 2#include "string.h"
4static int hex(char ch)
5{
6 if ((ch >= '0') && (ch <= '9'))
7 return ch - '0';
8 if ((ch >= 'a') && (ch <= 'f'))
9 return ch - 'a' + 10;
10 if ((ch >= 'A') && (ch <= 'F'))
11 return ch - 'A' + 10;
12 return -1;
13}
14
15/*
16 * While we find nice hex chars, build a long_val.
17 * Return number of chars processed.
18 */
19int hex2u64(const char *ptr, u64 *long_val)
20{
21 const char *p = ptr;
22 *long_val = 0;
23
24 while (*p) {
25 const int hex_val = hex(*p);
26
27 if (hex_val < 0)
28 break;
29
30 *long_val = (*long_val << 4) | hex_val;
31 p++;
32 }
33
34 return p - ptr;
35}
36
37char *strxfrchar(char *s, char from, char to)
38{
39 char *p = s;
40
41 while ((p = strchr(p, from)) != NULL)
42 *p++ = to;
43
44 return s;
45}
46 3
47#define K 1024LL 4#define K 1024LL
48/* 5/*
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
deleted file mode 100644
index 542e44de371..00000000000
--- a/tools/perf/util/string.h
+++ /dev/null
@@ -1,18 +0,0 @@
1#ifndef __PERF_STRING_H_
2#define __PERF_STRING_H_
3
4#include <stdbool.h>
5#include "types.h"
6
7int hex2u64(const char *ptr, u64 *val);
8char *strxfrchar(char *s, char from, char to);
9s64 perf_atoll(const char *str);
10char **argv_split(const char *str, int *argcp);
11void argv_free(char **argv);
12bool strglobmatch(const char *str, const char *pat);
13bool strlazymatch(const char *str, const char *pat);
14
15#define _STR(x) #x
16#define STR(x) _STR(x)
17
18#endif /* __PERF_STRING_H */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index c458c4a371d..5b276833e2b 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,13 +1,20 @@
1#include "util.h" 1#define _GNU_SOURCE
2#include "../perf.h" 2#include <ctype.h>
3#include "sort.h" 3#include <dirent.h>
4#include "string.h" 4#include <errno.h>
5#include <libgen.h>
6#include <stdlib.h>
7#include <stdio.h>
8#include <string.h>
9#include <sys/types.h>
10#include <sys/stat.h>
11#include <sys/param.h>
12#include <fcntl.h>
13#include <unistd.h>
14#include "build-id.h"
5#include "symbol.h" 15#include "symbol.h"
6#include "thread.h" 16#include "strlist.h"
7 17
8#include "debug.h"
9
10#include <asm/bug.h>
11#include <libelf.h> 18#include <libelf.h>
12#include <gelf.h> 19#include <gelf.h>
13#include <elf.h> 20#include <elf.h>
@@ -18,22 +25,12 @@
18#define NT_GNU_BUILD_ID 3 25#define NT_GNU_BUILD_ID 3
19#endif 26#endif
20 27
21enum dso_origin {
22 DSO__ORIG_KERNEL = 0,
23 DSO__ORIG_JAVA_JIT,
24 DSO__ORIG_BUILD_ID_CACHE,
25 DSO__ORIG_FEDORA,
26 DSO__ORIG_UBUNTU,
27 DSO__ORIG_BUILDID,
28 DSO__ORIG_DSO,
29 DSO__ORIG_KMODULE,
30 DSO__ORIG_NOT_FOUND,
31};
32
33static void dsos__add(struct list_head *head, struct dso *dso); 28static void dsos__add(struct list_head *head, struct dso *dso);
34static struct map *map__new2(u64 start, struct dso *dso, enum map_type type); 29static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
35static int dso__load_kernel_sym(struct dso *self, struct map *map, 30static int dso__load_kernel_sym(struct dso *self, struct map *map,
36 symbol_filter_t filter); 31 symbol_filter_t filter);
32static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
33 symbol_filter_t filter);
37static int vmlinux_path__nr_entries; 34static int vmlinux_path__nr_entries;
38static char **vmlinux_path; 35static char **vmlinux_path;
39 36
@@ -126,16 +123,17 @@ static void map_groups__fixup_end(struct map_groups *self)
126static struct symbol *symbol__new(u64 start, u64 len, const char *name) 123static struct symbol *symbol__new(u64 start, u64 len, const char *name)
127{ 124{
128 size_t namelen = strlen(name) + 1; 125 size_t namelen = strlen(name) + 1;
129 struct symbol *self = zalloc(symbol_conf.priv_size + 126 struct symbol *self = calloc(1, (symbol_conf.priv_size +
130 sizeof(*self) + namelen); 127 sizeof(*self) + namelen));
131 if (self == NULL) 128 if (self == NULL)
132 return NULL; 129 return NULL;
133 130
134 if (symbol_conf.priv_size) 131 if (symbol_conf.priv_size)
135 self = ((void *)self) + symbol_conf.priv_size; 132 self = ((void *)self) + symbol_conf.priv_size;
136 133
137 self->start = start; 134 self->start = start;
138 self->end = len ? start + len - 1 : start; 135 self->end = len ? start + len - 1 : start;
136 self->namelen = namelen - 1;
139 137
140 pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end); 138 pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
141 139
@@ -178,7 +176,7 @@ static void dso__set_basename(struct dso *self)
178 176
179struct dso *dso__new(const char *name) 177struct dso *dso__new(const char *name)
180{ 178{
181 struct dso *self = zalloc(sizeof(*self) + strlen(name) + 1); 179 struct dso *self = calloc(1, sizeof(*self) + strlen(name) + 1);
182 180
183 if (self != NULL) { 181 if (self != NULL) {
184 int i; 182 int i;
@@ -192,6 +190,8 @@ struct dso *dso__new(const char *name)
192 self->loaded = 0; 190 self->loaded = 0;
193 self->sorted_by_name = 0; 191 self->sorted_by_name = 0;
194 self->has_build_id = 0; 192 self->has_build_id = 0;
193 self->kernel = DSO_TYPE_USER;
194 INIT_LIST_HEAD(&self->node);
195 } 195 }
196 196
197 return self; 197 return self;
@@ -408,12 +408,9 @@ int kallsyms__parse(const char *filename, void *arg,
408 char *symbol_name; 408 char *symbol_name;
409 409
410 line_len = getline(&line, &n, file); 410 line_len = getline(&line, &n, file);
411 if (line_len < 0) 411 if (line_len < 0 || !line)
412 break; 412 break;
413 413
414 if (!line)
415 goto out_failure;
416
417 line[--line_len] = '\0'; /* \n */ 414 line[--line_len] = '\0'; /* \n */
418 415
419 len = hex2u64(line, &start); 416 len = hex2u64(line, &start);
@@ -465,6 +462,7 @@ static int map__process_kallsym_symbol(void *arg, const char *name,
465 * map__split_kallsyms, when we have split the maps per module 462 * map__split_kallsyms, when we have split the maps per module
466 */ 463 */
467 symbols__insert(root, sym); 464 symbols__insert(root, sym);
465
468 return 0; 466 return 0;
469} 467}
470 468
@@ -489,6 +487,7 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
489 symbol_filter_t filter) 487 symbol_filter_t filter)
490{ 488{
491 struct map_groups *kmaps = map__kmap(map)->kmaps; 489 struct map_groups *kmaps = map__kmap(map)->kmaps;
490 struct machine *machine = kmaps->machine;
492 struct map *curr_map = map; 491 struct map *curr_map = map;
493 struct symbol *pos; 492 struct symbol *pos;
494 int count = 0; 493 int count = 0;
@@ -510,15 +509,33 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
510 *module++ = '\0'; 509 *module++ = '\0';
511 510
512 if (strcmp(curr_map->dso->short_name, module)) { 511 if (strcmp(curr_map->dso->short_name, module)) {
513 curr_map = map_groups__find_by_name(kmaps, map->type, module); 512 if (curr_map != map &&
513 self->kernel == DSO_TYPE_GUEST_KERNEL &&
514 machine__is_default_guest(machine)) {
515 /*
516 * We assume all symbols of a module are
517 * continuous in * kallsyms, so curr_map
518 * points to a module and all its
519 * symbols are in its kmap. Mark it as
520 * loaded.
521 */
522 dso__set_loaded(curr_map->dso,
523 curr_map->type);
524 }
525
526 curr_map = map_groups__find_by_name(kmaps,
527 map->type, module);
514 if (curr_map == NULL) { 528 if (curr_map == NULL) {
515 pr_debug("/proc/{kallsyms,modules} " 529 pr_debug("%s/proc/{kallsyms,modules} "
516 "inconsistency while looking " 530 "inconsistency while looking "
517 "for \"%s\" module!\n", module); 531 "for \"%s\" module!\n",
518 return -1; 532 machine->root_dir, module);
533 curr_map = map;
534 goto discard_symbol;
519 } 535 }
520 536
521 if (curr_map->dso->loaded) 537 if (curr_map->dso->loaded &&
538 !machine__is_default_guest(machine))
522 goto discard_symbol; 539 goto discard_symbol;
523 } 540 }
524 /* 541 /*
@@ -531,13 +548,21 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
531 char dso_name[PATH_MAX]; 548 char dso_name[PATH_MAX];
532 struct dso *dso; 549 struct dso *dso;
533 550
534 snprintf(dso_name, sizeof(dso_name), "[kernel].%d", 551 if (self->kernel == DSO_TYPE_GUEST_KERNEL)
535 kernel_range++); 552 snprintf(dso_name, sizeof(dso_name),
553 "[guest.kernel].%d",
554 kernel_range++);
555 else
556 snprintf(dso_name, sizeof(dso_name),
557 "[kernel].%d",
558 kernel_range++);
536 559
537 dso = dso__new(dso_name); 560 dso = dso__new(dso_name);
538 if (dso == NULL) 561 if (dso == NULL)
539 return -1; 562 return -1;
540 563
564 dso->kernel = self->kernel;
565
541 curr_map = map__new2(pos->start, dso, map->type); 566 curr_map = map__new2(pos->start, dso, map->type);
542 if (curr_map == NULL) { 567 if (curr_map == NULL) {
543 dso__delete(dso); 568 dso__delete(dso);
@@ -561,6 +586,12 @@ discard_symbol: rb_erase(&pos->rb_node, root);
561 } 586 }
562 } 587 }
563 588
589 if (curr_map != map &&
590 self->kernel == DSO_TYPE_GUEST_KERNEL &&
591 machine__is_default_guest(kmaps->machine)) {
592 dso__set_loaded(curr_map->dso, curr_map->type);
593 }
594
564 return count; 595 return count;
565} 596}
566 597
@@ -571,7 +602,10 @@ int dso__load_kallsyms(struct dso *self, const char *filename,
571 return -1; 602 return -1;
572 603
573 symbols__fixup_end(&self->symbols[map->type]); 604 symbols__fixup_end(&self->symbols[map->type]);
574 self->origin = DSO__ORIG_KERNEL; 605 if (self->kernel == DSO_TYPE_GUEST_KERNEL)
606 self->origin = DSO__ORIG_GUEST_KERNEL;
607 else
608 self->origin = DSO__ORIG_KERNEL;
575 609
576 return dso__split_kallsyms(self, map, filter); 610 return dso__split_kallsyms(self, map, filter);
577} 611}
@@ -870,8 +904,8 @@ out_close:
870 if (err == 0) 904 if (err == 0)
871 return nr; 905 return nr;
872out: 906out:
873 pr_warning("%s: problems reading %s PLT info.\n", 907 pr_debug("%s: problems reading %s PLT info.\n",
874 __func__, self->long_name); 908 __func__, self->long_name);
875 return 0; 909 return 0;
876} 910}
877 911
@@ -958,7 +992,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
958 nr_syms = shdr.sh_size / shdr.sh_entsize; 992 nr_syms = shdr.sh_size / shdr.sh_entsize;
959 993
960 memset(&sym, 0, sizeof(sym)); 994 memset(&sym, 0, sizeof(sym));
961 if (!self->kernel) { 995 if (self->kernel == DSO_TYPE_USER) {
962 self->adjust_symbols = (ehdr.e_type == ET_EXEC || 996 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
963 elf_section_by_name(elf, &ehdr, &shdr, 997 elf_section_by_name(elf, &ehdr, &shdr,
964 ".gnu.prelink_undo", 998 ".gnu.prelink_undo",
@@ -990,7 +1024,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
990 1024
991 section_name = elf_sec__name(&shdr, secstrs); 1025 section_name = elf_sec__name(&shdr, secstrs);
992 1026
993 if (self->kernel || kmodule) { 1027 if (self->kernel != DSO_TYPE_USER || kmodule) {
994 char dso_name[PATH_MAX]; 1028 char dso_name[PATH_MAX];
995 1029
996 if (strcmp(section_name, 1030 if (strcmp(section_name,
@@ -1017,6 +1051,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
1017 curr_dso = dso__new(dso_name); 1051 curr_dso = dso__new(dso_name);
1018 if (curr_dso == NULL) 1052 if (curr_dso == NULL)
1019 goto out_elf_end; 1053 goto out_elf_end;
1054 curr_dso->kernel = self->kernel;
1020 curr_map = map__new2(start, curr_dso, 1055 curr_map = map__new2(start, curr_dso,
1021 map->type); 1056 map->type);
1022 if (curr_map == NULL) { 1057 if (curr_map == NULL) {
@@ -1025,9 +1060,9 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
1025 } 1060 }
1026 curr_map->map_ip = identity__map_ip; 1061 curr_map->map_ip = identity__map_ip;
1027 curr_map->unmap_ip = identity__map_ip; 1062 curr_map->unmap_ip = identity__map_ip;
1028 curr_dso->origin = DSO__ORIG_KERNEL; 1063 curr_dso->origin = self->origin;
1029 map_groups__insert(kmap->kmaps, curr_map); 1064 map_groups__insert(kmap->kmaps, curr_map);
1030 dsos__add(&dsos__kernel, curr_dso); 1065 dsos__add(&self->node, curr_dso);
1031 dso__set_loaded(curr_dso, map->type); 1066 dso__set_loaded(curr_dso, map->type);
1032 } else 1067 } else
1033 curr_dso = curr_map->dso; 1068 curr_dso = curr_map->dso;
@@ -1089,7 +1124,7 @@ static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
1089 return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0; 1124 return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
1090} 1125}
1091 1126
1092static bool __dsos__read_build_ids(struct list_head *head, bool with_hits) 1127bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1093{ 1128{
1094 bool have_build_id = false; 1129 bool have_build_id = false;
1095 struct dso *pos; 1130 struct dso *pos;
@@ -1097,6 +1132,10 @@ static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1097 list_for_each_entry(pos, head, node) { 1132 list_for_each_entry(pos, head, node) {
1098 if (with_hits && !pos->hit) 1133 if (with_hits && !pos->hit)
1099 continue; 1134 continue;
1135 if (pos->has_build_id) {
1136 have_build_id = true;
1137 continue;
1138 }
1100 if (filename__read_build_id(pos->long_name, pos->build_id, 1139 if (filename__read_build_id(pos->long_name, pos->build_id,
1101 sizeof(pos->build_id)) > 0) { 1140 sizeof(pos->build_id)) > 0) {
1102 have_build_id = true; 1141 have_build_id = true;
@@ -1107,13 +1146,6 @@ static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1107 return have_build_id; 1146 return have_build_id;
1108} 1147}
1109 1148
1110bool dsos__read_build_ids(bool with_hits)
1111{
1112 bool kbuildids = __dsos__read_build_ids(&dsos__kernel, with_hits),
1113 ubuildids = __dsos__read_build_ids(&dsos__user, with_hits);
1114 return kbuildids || ubuildids;
1115}
1116
1117/* 1149/*
1118 * Align offset to 4 bytes as needed for note name and descriptor data. 1150 * Align offset to 4 bytes as needed for note name and descriptor data.
1119 */ 1151 */
@@ -1248,6 +1280,8 @@ char dso__symtab_origin(const struct dso *self)
1248 [DSO__ORIG_BUILDID] = 'b', 1280 [DSO__ORIG_BUILDID] = 'b',
1249 [DSO__ORIG_DSO] = 'd', 1281 [DSO__ORIG_DSO] = 'd',
1250 [DSO__ORIG_KMODULE] = 'K', 1282 [DSO__ORIG_KMODULE] = 'K',
1283 [DSO__ORIG_GUEST_KERNEL] = 'g',
1284 [DSO__ORIG_GUEST_KMODULE] = 'G',
1251 }; 1285 };
1252 1286
1253 if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND) 1287 if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
@@ -1260,14 +1294,22 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1260 int size = PATH_MAX; 1294 int size = PATH_MAX;
1261 char *name; 1295 char *name;
1262 u8 build_id[BUILD_ID_SIZE]; 1296 u8 build_id[BUILD_ID_SIZE];
1263 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1264 int ret = -1; 1297 int ret = -1;
1265 int fd; 1298 int fd;
1299 struct machine *machine;
1300 const char *root_dir;
1266 1301
1267 dso__set_loaded(self, map->type); 1302 dso__set_loaded(self, map->type);
1268 1303
1269 if (self->kernel) 1304 if (self->kernel == DSO_TYPE_KERNEL)
1270 return dso__load_kernel_sym(self, map, filter); 1305 return dso__load_kernel_sym(self, map, filter);
1306 else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
1307 return dso__load_guest_kernel_sym(self, map, filter);
1308
1309 if (map->groups && map->groups->machine)
1310 machine = map->groups->machine;
1311 else
1312 machine = NULL;
1271 1313
1272 name = malloc(size); 1314 name = malloc(size);
1273 if (!name) 1315 if (!name)
@@ -1283,15 +1325,8 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1283 } 1325 }
1284 1326
1285 self->origin = DSO__ORIG_BUILD_ID_CACHE; 1327 self->origin = DSO__ORIG_BUILD_ID_CACHE;
1286 1328 if (dso__build_id_filename(self, name, size) != NULL)
1287 if (self->has_build_id) {
1288 build_id__sprintf(self->build_id, sizeof(self->build_id),
1289 build_id_hex);
1290 snprintf(name, size, "%s/%s/.build-id/%.2s/%s",
1291 getenv("HOME"), DEBUG_CACHE_DIR,
1292 build_id_hex, build_id_hex + 2);
1293 goto open_file; 1329 goto open_file;
1294 }
1295more: 1330more:
1296 do { 1331 do {
1297 self->origin++; 1332 self->origin++;
@@ -1307,6 +1342,7 @@ more:
1307 case DSO__ORIG_BUILDID: 1342 case DSO__ORIG_BUILDID:
1308 if (filename__read_build_id(self->long_name, build_id, 1343 if (filename__read_build_id(self->long_name, build_id,
1309 sizeof(build_id))) { 1344 sizeof(build_id))) {
1345 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1310 build_id__sprintf(build_id, sizeof(build_id), 1346 build_id__sprintf(build_id, sizeof(build_id),
1311 build_id_hex); 1347 build_id_hex);
1312 snprintf(name, size, 1348 snprintf(name, size,
@@ -1321,6 +1357,13 @@ more:
1321 case DSO__ORIG_DSO: 1357 case DSO__ORIG_DSO:
1322 snprintf(name, size, "%s", self->long_name); 1358 snprintf(name, size, "%s", self->long_name);
1323 break; 1359 break;
1360 case DSO__ORIG_GUEST_KMODULE:
1361 if (map->groups && map->groups->machine)
1362 root_dir = map->groups->machine->root_dir;
1363 else
1364 root_dir = "";
1365 snprintf(name, size, "%s%s", root_dir, self->long_name);
1366 break;
1324 1367
1325 default: 1368 default:
1326 goto out; 1369 goto out;
@@ -1374,7 +1417,8 @@ struct map *map_groups__find_by_name(struct map_groups *self,
1374 return NULL; 1417 return NULL;
1375} 1418}
1376 1419
1377static int dso__kernel_module_get_build_id(struct dso *self) 1420static int dso__kernel_module_get_build_id(struct dso *self,
1421 const char *root_dir)
1378{ 1422{
1379 char filename[PATH_MAX]; 1423 char filename[PATH_MAX];
1380 /* 1424 /*
@@ -1384,8 +1428,8 @@ static int dso__kernel_module_get_build_id(struct dso *self)
1384 const char *name = self->short_name + 1; 1428 const char *name = self->short_name + 1;
1385 1429
1386 snprintf(filename, sizeof(filename), 1430 snprintf(filename, sizeof(filename),
1387 "/sys/module/%.*s/notes/.note.gnu.build-id", 1431 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1388 (int)strlen(name - 1), name); 1432 root_dir, (int)strlen(name) - 1, name);
1389 1433
1390 if (sysfs__read_build_id(filename, self->build_id, 1434 if (sysfs__read_build_id(filename, self->build_id,
1391 sizeof(self->build_id)) == 0) 1435 sizeof(self->build_id)) == 0)
@@ -1394,28 +1438,37 @@ static int dso__kernel_module_get_build_id(struct dso *self)
1394 return 0; 1438 return 0;
1395} 1439}
1396 1440
1397static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirname) 1441static int map_groups__set_modules_path_dir(struct map_groups *self,
1442 const char *dir_name)
1398{ 1443{
1399 struct dirent *dent; 1444 struct dirent *dent;
1400 DIR *dir = opendir(dirname); 1445 DIR *dir = opendir(dir_name);
1446 int ret = 0;
1401 1447
1402 if (!dir) { 1448 if (!dir) {
1403 pr_debug("%s: cannot open %s dir\n", __func__, dirname); 1449 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1404 return -1; 1450 return -1;
1405 } 1451 }
1406 1452
1407 while ((dent = readdir(dir)) != NULL) { 1453 while ((dent = readdir(dir)) != NULL) {
1408 char path[PATH_MAX]; 1454 char path[PATH_MAX];
1455 struct stat st;
1409 1456
1410 if (dent->d_type == DT_DIR) { 1457 /*sshfs might return bad dent->d_type, so we have to stat*/
1458 sprintf(path, "%s/%s", dir_name, dent->d_name);
1459 if (stat(path, &st))
1460 continue;
1461
1462 if (S_ISDIR(st.st_mode)) {
1411 if (!strcmp(dent->d_name, ".") || 1463 if (!strcmp(dent->d_name, ".") ||
1412 !strcmp(dent->d_name, "..")) 1464 !strcmp(dent->d_name, ".."))
1413 continue; 1465 continue;
1414 1466
1415 snprintf(path, sizeof(path), "%s/%s", 1467 snprintf(path, sizeof(path), "%s/%s",
1416 dirname, dent->d_name); 1468 dir_name, dent->d_name);
1417 if (map_groups__set_modules_path_dir(self, path) < 0) 1469 ret = map_groups__set_modules_path_dir(self, path);
1418 goto failure; 1470 if (ret < 0)
1471 goto out;
1419 } else { 1472 } else {
1420 char *dot = strrchr(dent->d_name, '.'), 1473 char *dot = strrchr(dent->d_name, '.'),
1421 dso_name[PATH_MAX]; 1474 dso_name[PATH_MAX];
@@ -1433,34 +1486,64 @@ static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirna
1433 continue; 1486 continue;
1434 1487
1435 snprintf(path, sizeof(path), "%s/%s", 1488 snprintf(path, sizeof(path), "%s/%s",
1436 dirname, dent->d_name); 1489 dir_name, dent->d_name);
1437 1490
1438 long_name = strdup(path); 1491 long_name = strdup(path);
1439 if (long_name == NULL) 1492 if (long_name == NULL) {
1440 goto failure; 1493 ret = -1;
1494 goto out;
1495 }
1441 dso__set_long_name(map->dso, long_name); 1496 dso__set_long_name(map->dso, long_name);
1442 dso__kernel_module_get_build_id(map->dso); 1497 dso__kernel_module_get_build_id(map->dso, "");
1443 } 1498 }
1444 } 1499 }
1445 1500
1446 return 0; 1501out:
1447failure:
1448 closedir(dir); 1502 closedir(dir);
1449 return -1; 1503 return ret;
1450} 1504}
1451 1505
1452static int map_groups__set_modules_path(struct map_groups *self) 1506static char *get_kernel_version(const char *root_dir)
1453{ 1507{
1454 struct utsname uts; 1508 char version[PATH_MAX];
1509 FILE *file;
1510 char *name, *tmp;
1511 const char *prefix = "Linux version ";
1512
1513 sprintf(version, "%s/proc/version", root_dir);
1514 file = fopen(version, "r");
1515 if (!file)
1516 return NULL;
1517
1518 version[0] = '\0';
1519 tmp = fgets(version, sizeof(version), file);
1520 fclose(file);
1521
1522 name = strstr(version, prefix);
1523 if (!name)
1524 return NULL;
1525 name += strlen(prefix);
1526 tmp = strchr(name, ' ');
1527 if (tmp)
1528 *tmp = '\0';
1529
1530 return strdup(name);
1531}
1532
1533static int machine__set_modules_path(struct machine *self)
1534{
1535 char *version;
1455 char modules_path[PATH_MAX]; 1536 char modules_path[PATH_MAX];
1456 1537
1457 if (uname(&uts) < 0) 1538 version = get_kernel_version(self->root_dir);
1539 if (!version)
1458 return -1; 1540 return -1;
1459 1541
1460 snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel", 1542 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1461 uts.release); 1543 self->root_dir, version);
1544 free(version);
1462 1545
1463 return map_groups__set_modules_path_dir(self, modules_path); 1546 return map_groups__set_modules_path_dir(&self->kmaps, modules_path);
1464} 1547}
1465 1548
1466/* 1549/*
@@ -1470,8 +1553,8 @@ static int map_groups__set_modules_path(struct map_groups *self)
1470 */ 1553 */
1471static struct map *map__new2(u64 start, struct dso *dso, enum map_type type) 1554static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1472{ 1555{
1473 struct map *self = zalloc(sizeof(*self) + 1556 struct map *self = calloc(1, (sizeof(*self) +
1474 (dso->kernel ? sizeof(struct kmap) : 0)); 1557 (dso->kernel ? sizeof(struct kmap) : 0)));
1475 if (self != NULL) { 1558 if (self != NULL) {
1476 /* 1559 /*
1477 * ->end will be filled after we load all the symbols 1560 * ->end will be filled after we load all the symbols
@@ -1482,11 +1565,11 @@ static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1482 return self; 1565 return self;
1483} 1566}
1484 1567
1485struct map *map_groups__new_module(struct map_groups *self, u64 start, 1568struct map *machine__new_module(struct machine *self, u64 start,
1486 const char *filename) 1569 const char *filename)
1487{ 1570{
1488 struct map *map; 1571 struct map *map;
1489 struct dso *dso = __dsos__findnew(&dsos__kernel, filename); 1572 struct dso *dso = __dsos__findnew(&self->kernel_dsos, filename);
1490 1573
1491 if (dso == NULL) 1574 if (dso == NULL)
1492 return NULL; 1575 return NULL;
@@ -1495,18 +1578,31 @@ struct map *map_groups__new_module(struct map_groups *self, u64 start,
1495 if (map == NULL) 1578 if (map == NULL)
1496 return NULL; 1579 return NULL;
1497 1580
1498 dso->origin = DSO__ORIG_KMODULE; 1581 if (machine__is_host(self))
1499 map_groups__insert(self, map); 1582 dso->origin = DSO__ORIG_KMODULE;
1583 else
1584 dso->origin = DSO__ORIG_GUEST_KMODULE;
1585 map_groups__insert(&self->kmaps, map);
1500 return map; 1586 return map;
1501} 1587}
1502 1588
1503static int map_groups__create_modules(struct map_groups *self) 1589static int machine__create_modules(struct machine *self)
1504{ 1590{
1505 char *line = NULL; 1591 char *line = NULL;
1506 size_t n; 1592 size_t n;
1507 FILE *file = fopen("/proc/modules", "r"); 1593 FILE *file;
1508 struct map *map; 1594 struct map *map;
1595 const char *modules;
1596 char path[PATH_MAX];
1597
1598 if (machine__is_default_guest(self))
1599 modules = symbol_conf.default_guest_modules;
1600 else {
1601 sprintf(path, "%s/proc/modules", self->root_dir);
1602 modules = path;
1603 }
1509 1604
1605 file = fopen(modules, "r");
1510 if (file == NULL) 1606 if (file == NULL)
1511 return -1; 1607 return -1;
1512 1608
@@ -1538,16 +1634,16 @@ static int map_groups__create_modules(struct map_groups *self)
1538 *sep = '\0'; 1634 *sep = '\0';
1539 1635
1540 snprintf(name, sizeof(name), "[%s]", line); 1636 snprintf(name, sizeof(name), "[%s]", line);
1541 map = map_groups__new_module(self, start, name); 1637 map = machine__new_module(self, start, name);
1542 if (map == NULL) 1638 if (map == NULL)
1543 goto out_delete_line; 1639 goto out_delete_line;
1544 dso__kernel_module_get_build_id(map->dso); 1640 dso__kernel_module_get_build_id(map->dso, self->root_dir);
1545 } 1641 }
1546 1642
1547 free(line); 1643 free(line);
1548 fclose(file); 1644 fclose(file);
1549 1645
1550 return map_groups__set_modules_path(self); 1646 return machine__set_modules_path(self);
1551 1647
1552out_delete_line: 1648out_delete_line:
1553 free(line); 1649 free(line);
@@ -1602,9 +1698,20 @@ int dso__load_vmlinux_path(struct dso *self, struct map *map,
1602 symbol_filter_t filter) 1698 symbol_filter_t filter)
1603{ 1699{
1604 int i, err = 0; 1700 int i, err = 0;
1701 char *filename;
1605 1702
1606 pr_debug("Looking at the vmlinux_path (%d entries long)\n", 1703 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1607 vmlinux_path__nr_entries); 1704 vmlinux_path__nr_entries + 1);
1705
1706 filename = dso__build_id_filename(self, NULL, 0);
1707 if (filename != NULL) {
1708 err = dso__load_vmlinux(self, map, filename, filter);
1709 if (err > 0) {
1710 dso__set_long_name(self, filename);
1711 goto out;
1712 }
1713 free(filename);
1714 }
1608 1715
1609 for (i = 0; i < vmlinux_path__nr_entries; ++i) { 1716 for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1610 err = dso__load_vmlinux(self, map, vmlinux_path[i], filter); 1717 err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
@@ -1613,7 +1720,7 @@ int dso__load_vmlinux_path(struct dso *self, struct map *map,
1613 break; 1720 break;
1614 } 1721 }
1615 } 1722 }
1616 1723out:
1617 return err; 1724 return err;
1618} 1725}
1619 1726
@@ -1641,7 +1748,12 @@ static int dso__load_kernel_sym(struct dso *self, struct map *map,
1641 if (symbol_conf.vmlinux_name != NULL) { 1748 if (symbol_conf.vmlinux_name != NULL) {
1642 err = dso__load_vmlinux(self, map, 1749 err = dso__load_vmlinux(self, map,
1643 symbol_conf.vmlinux_name, filter); 1750 symbol_conf.vmlinux_name, filter);
1644 goto out_try_fixup; 1751 if (err > 0) {
1752 dso__set_long_name(self,
1753 strdup(symbol_conf.vmlinux_name));
1754 goto out_fixup;
1755 }
1756 return err;
1645 } 1757 }
1646 1758
1647 if (vmlinux_path != NULL) { 1759 if (vmlinux_path != NULL) {
@@ -1702,7 +1814,6 @@ do_kallsyms:
1702 pr_debug("Using %s for symbols\n", kallsyms_filename); 1814 pr_debug("Using %s for symbols\n", kallsyms_filename);
1703 free(kallsyms_allocated_filename); 1815 free(kallsyms_allocated_filename);
1704 1816
1705out_try_fixup:
1706 if (err > 0) { 1817 if (err > 0) {
1707out_fixup: 1818out_fixup:
1708 if (kallsyms_filename != NULL) 1819 if (kallsyms_filename != NULL)
@@ -1714,8 +1825,56 @@ out_fixup:
1714 return err; 1825 return err;
1715} 1826}
1716 1827
1717LIST_HEAD(dsos__user); 1828static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1718LIST_HEAD(dsos__kernel); 1829 symbol_filter_t filter)
1830{
1831 int err;
1832 const char *kallsyms_filename = NULL;
1833 struct machine *machine;
1834 char path[PATH_MAX];
1835
1836 if (!map->groups) {
1837 pr_debug("Guest kernel map hasn't the point to groups\n");
1838 return -1;
1839 }
1840 machine = map->groups->machine;
1841
1842 if (machine__is_default_guest(machine)) {
1843 /*
1844 * if the user specified a vmlinux filename, use it and only
1845 * it, reporting errors to the user if it cannot be used.
1846 * Or use file guest_kallsyms inputted by user on commandline
1847 */
1848 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1849 err = dso__load_vmlinux(self, map,
1850 symbol_conf.default_guest_vmlinux_name, filter);
1851 goto out_try_fixup;
1852 }
1853
1854 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1855 if (!kallsyms_filename)
1856 return -1;
1857 } else {
1858 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1859 kallsyms_filename = path;
1860 }
1861
1862 err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1863 if (err > 0)
1864 pr_debug("Using %s for symbols\n", kallsyms_filename);
1865
1866out_try_fixup:
1867 if (err > 0) {
1868 if (kallsyms_filename != NULL) {
1869 machine__mmap_name(machine, path, sizeof(path));
1870 dso__set_long_name(self, strdup(path));
1871 }
1872 map__fixup_start(map);
1873 map__fixup_end(map);
1874 }
1875
1876 return err;
1877}
1719 1878
1720static void dsos__add(struct list_head *head, struct dso *dso) 1879static void dsos__add(struct list_head *head, struct dso *dso)
1721{ 1880{
@@ -1747,21 +1906,32 @@ struct dso *__dsos__findnew(struct list_head *head, const char *name)
1747 return dso; 1906 return dso;
1748} 1907}
1749 1908
1750static void __dsos__fprintf(struct list_head *head, FILE *fp) 1909size_t __dsos__fprintf(struct list_head *head, FILE *fp)
1751{ 1910{
1752 struct dso *pos; 1911 struct dso *pos;
1912 size_t ret = 0;
1753 1913
1754 list_for_each_entry(pos, head, node) { 1914 list_for_each_entry(pos, head, node) {
1755 int i; 1915 int i;
1756 for (i = 0; i < MAP__NR_TYPES; ++i) 1916 for (i = 0; i < MAP__NR_TYPES; ++i)
1757 dso__fprintf(pos, i, fp); 1917 ret += dso__fprintf(pos, i, fp);
1758 } 1918 }
1919
1920 return ret;
1759} 1921}
1760 1922
1761void dsos__fprintf(FILE *fp) 1923size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
1762{ 1924{
1763 __dsos__fprintf(&dsos__kernel, fp); 1925 struct rb_node *nd;
1764 __dsos__fprintf(&dsos__user, fp); 1926 size_t ret = 0;
1927
1928 for (nd = rb_first(self); nd; nd = rb_next(nd)) {
1929 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1930 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
1931 ret += __dsos__fprintf(&pos->user_dsos, fp);
1932 }
1933
1934 return ret;
1765} 1935}
1766 1936
1767static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp, 1937static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
@@ -1779,10 +1949,22 @@ static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
1779 return ret; 1949 return ret;
1780} 1950}
1781 1951
1782size_t dsos__fprintf_buildid(FILE *fp, bool with_hits) 1952size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits)
1783{ 1953{
1784 return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) + 1954 return __dsos__fprintf_buildid(&self->kernel_dsos, fp, with_hits) +
1785 __dsos__fprintf_buildid(&dsos__user, fp, with_hits)); 1955 __dsos__fprintf_buildid(&self->user_dsos, fp, with_hits);
1956}
1957
1958size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
1959{
1960 struct rb_node *nd;
1961 size_t ret = 0;
1962
1963 for (nd = rb_first(self); nd; nd = rb_next(nd)) {
1964 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1965 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
1966 }
1967 return ret;
1786} 1968}
1787 1969
1788struct dso *dso__new_kernel(const char *name) 1970struct dso *dso__new_kernel(const char *name)
@@ -1791,55 +1973,98 @@ struct dso *dso__new_kernel(const char *name)
1791 1973
1792 if (self != NULL) { 1974 if (self != NULL) {
1793 dso__set_short_name(self, "[kernel]"); 1975 dso__set_short_name(self, "[kernel]");
1794 self->kernel = 1; 1976 self->kernel = DSO_TYPE_KERNEL;
1977 }
1978
1979 return self;
1980}
1981
1982static struct dso *dso__new_guest_kernel(struct machine *machine,
1983 const char *name)
1984{
1985 char bf[PATH_MAX];
1986 struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
1987
1988 if (self != NULL) {
1989 dso__set_short_name(self, "[guest.kernel]");
1990 self->kernel = DSO_TYPE_GUEST_KERNEL;
1795 } 1991 }
1796 1992
1797 return self; 1993 return self;
1798} 1994}
1799 1995
1800void dso__read_running_kernel_build_id(struct dso *self) 1996void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
1801{ 1997{
1802 if (sysfs__read_build_id("/sys/kernel/notes", self->build_id, 1998 char path[PATH_MAX];
1999
2000 if (machine__is_default_guest(machine))
2001 return;
2002 sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2003 if (sysfs__read_build_id(path, self->build_id,
1803 sizeof(self->build_id)) == 0) 2004 sizeof(self->build_id)) == 0)
1804 self->has_build_id = true; 2005 self->has_build_id = true;
1805} 2006}
1806 2007
1807static struct dso *dsos__create_kernel(const char *vmlinux) 2008static struct dso *machine__create_kernel(struct machine *self)
1808{ 2009{
1809 struct dso *kernel = dso__new_kernel(vmlinux); 2010 const char *vmlinux_name = NULL;
2011 struct dso *kernel;
1810 2012
1811 if (kernel != NULL) { 2013 if (machine__is_host(self)) {
1812 dso__read_running_kernel_build_id(kernel); 2014 vmlinux_name = symbol_conf.vmlinux_name;
1813 dsos__add(&dsos__kernel, kernel); 2015 kernel = dso__new_kernel(vmlinux_name);
2016 } else {
2017 if (machine__is_default_guest(self))
2018 vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2019 kernel = dso__new_guest_kernel(self, vmlinux_name);
1814 } 2020 }
1815 2021
2022 if (kernel != NULL) {
2023 dso__read_running_kernel_build_id(kernel, self);
2024 dsos__add(&self->kernel_dsos, kernel);
2025 }
1816 return kernel; 2026 return kernel;
1817} 2027}
1818 2028
1819int __map_groups__create_kernel_maps(struct map_groups *self, 2029int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
1820 struct map *vmlinux_maps[MAP__NR_TYPES],
1821 struct dso *kernel)
1822{ 2030{
1823 enum map_type type; 2031 enum map_type type;
1824 2032
1825 for (type = 0; type < MAP__NR_TYPES; ++type) { 2033 for (type = 0; type < MAP__NR_TYPES; ++type) {
1826 struct kmap *kmap; 2034 struct kmap *kmap;
1827 2035
1828 vmlinux_maps[type] = map__new2(0, kernel, type); 2036 self->vmlinux_maps[type] = map__new2(0, kernel, type);
1829 if (vmlinux_maps[type] == NULL) 2037 if (self->vmlinux_maps[type] == NULL)
1830 return -1; 2038 return -1;
1831 2039
1832 vmlinux_maps[type]->map_ip = 2040 self->vmlinux_maps[type]->map_ip =
1833 vmlinux_maps[type]->unmap_ip = identity__map_ip; 2041 self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
1834 2042
1835 kmap = map__kmap(vmlinux_maps[type]); 2043 kmap = map__kmap(self->vmlinux_maps[type]);
1836 kmap->kmaps = self; 2044 kmap->kmaps = &self->kmaps;
1837 map_groups__insert(self, vmlinux_maps[type]); 2045 map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
1838 } 2046 }
1839 2047
1840 return 0; 2048 return 0;
1841} 2049}
1842 2050
2051int machine__create_kernel_maps(struct machine *self)
2052{
2053 struct dso *kernel = machine__create_kernel(self);
2054
2055 if (kernel == NULL ||
2056 __machine__create_kernel_maps(self, kernel) < 0)
2057 return -1;
2058
2059 if (symbol_conf.use_modules && machine__create_modules(self) < 0)
2060 pr_debug("Problems creating module maps, continuing anyway...\n");
2061 /*
2062 * Now that we have all the maps created, just set the ->end of them:
2063 */
2064 map_groups__fixup_end(&self->kmaps);
2065 return 0;
2066}
2067
1843static void vmlinux_path__exit(void) 2068static void vmlinux_path__exit(void)
1844{ 2069{
1845 while (--vmlinux_path__nr_entries >= 0) { 2070 while (--vmlinux_path__nr_entries >= 0) {
@@ -1895,6 +2120,25 @@ out_fail:
1895 return -1; 2120 return -1;
1896} 2121}
1897 2122
2123size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp)
2124{
2125 int i;
2126 size_t printed = 0;
2127 struct dso *kdso = self->vmlinux_maps[MAP__FUNCTION]->dso;
2128
2129 if (kdso->has_build_id) {
2130 char filename[PATH_MAX];
2131 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2132 printed += fprintf(fp, "[0] %s\n", filename);
2133 }
2134
2135 for (i = 0; i < vmlinux_path__nr_entries; ++i)
2136 printed += fprintf(fp, "[%d] %s\n",
2137 i + kdso->has_build_id, vmlinux_path[i]);
2138
2139 return printed;
2140}
2141
1898static int setup_list(struct strlist **list, const char *list_str, 2142static int setup_list(struct strlist **list, const char *list_str,
1899 const char *list_name) 2143 const char *list_name)
1900{ 2144{
@@ -1945,22 +2189,129 @@ out_free_comm_list:
1945 return -1; 2189 return -1;
1946} 2190}
1947 2191
1948int map_groups__create_kernel_maps(struct map_groups *self, 2192int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
1949 struct map *vmlinux_maps[MAP__NR_TYPES])
1950{ 2193{
1951 struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name); 2194 struct machine *machine = machines__findnew(self, pid);
1952 2195
1953 if (kernel == NULL) 2196 if (machine == NULL)
1954 return -1; 2197 return -1;
1955 2198
1956 if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0) 2199 return machine__create_kernel_maps(machine);
1957 return -1; 2200}
1958 2201
1959 if (symbol_conf.use_modules && map_groups__create_modules(self) < 0) 2202static int hex(char ch)
1960 pr_debug("Problems creating module maps, continuing anyway...\n"); 2203{
1961 /* 2204 if ((ch >= '0') && (ch <= '9'))
1962 * Now that we have all the maps created, just set the ->end of them: 2205 return ch - '0';
1963 */ 2206 if ((ch >= 'a') && (ch <= 'f'))
1964 map_groups__fixup_end(self); 2207 return ch - 'a' + 10;
1965 return 0; 2208 if ((ch >= 'A') && (ch <= 'F'))
2209 return ch - 'A' + 10;
2210 return -1;
2211}
2212
2213/*
2214 * While we find nice hex chars, build a long_val.
2215 * Return number of chars processed.
2216 */
2217int hex2u64(const char *ptr, u64 *long_val)
2218{
2219 const char *p = ptr;
2220 *long_val = 0;
2221
2222 while (*p) {
2223 const int hex_val = hex(*p);
2224
2225 if (hex_val < 0)
2226 break;
2227
2228 *long_val = (*long_val << 4) | hex_val;
2229 p++;
2230 }
2231
2232 return p - ptr;
2233}
2234
2235char *strxfrchar(char *s, char from, char to)
2236{
2237 char *p = s;
2238
2239 while ((p = strchr(p, from)) != NULL)
2240 *p++ = to;
2241
2242 return s;
2243}
2244
2245int machines__create_guest_kernel_maps(struct rb_root *self)
2246{
2247 int ret = 0;
2248 struct dirent **namelist = NULL;
2249 int i, items = 0;
2250 char path[PATH_MAX];
2251 pid_t pid;
2252
2253 if (symbol_conf.default_guest_vmlinux_name ||
2254 symbol_conf.default_guest_modules ||
2255 symbol_conf.default_guest_kallsyms) {
2256 machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
2257 }
2258
2259 if (symbol_conf.guestmount) {
2260 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2261 if (items <= 0)
2262 return -ENOENT;
2263 for (i = 0; i < items; i++) {
2264 if (!isdigit(namelist[i]->d_name[0])) {
2265 /* Filter out . and .. */
2266 continue;
2267 }
2268 pid = atoi(namelist[i]->d_name);
2269 sprintf(path, "%s/%s/proc/kallsyms",
2270 symbol_conf.guestmount,
2271 namelist[i]->d_name);
2272 ret = access(path, R_OK);
2273 if (ret) {
2274 pr_debug("Can't access file %s\n", path);
2275 goto failure;
2276 }
2277 machines__create_kernel_maps(self, pid);
2278 }
2279failure:
2280 free(namelist);
2281 }
2282
2283 return ret;
2284}
2285
2286int machine__load_kallsyms(struct machine *self, const char *filename,
2287 enum map_type type, symbol_filter_t filter)
2288{
2289 struct map *map = self->vmlinux_maps[type];
2290 int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2291
2292 if (ret > 0) {
2293 dso__set_loaded(map->dso, type);
2294 /*
2295 * Since /proc/kallsyms will have multiple sessions for the
2296 * kernel, with modules between them, fixup the end of all
2297 * sections.
2298 */
2299 __map_groups__fixup_end(&self->kmaps, type);
2300 }
2301
2302 return ret;
2303}
2304
2305int machine__load_vmlinux_path(struct machine *self, enum map_type type,
2306 symbol_filter_t filter)
2307{
2308 struct map *map = self->vmlinux_maps[type];
2309 int ret = dso__load_vmlinux_path(map->dso, map, filter);
2310
2311 if (ret > 0) {
2312 dso__set_loaded(map->dso, type);
2313 map__reloc_vmlinux(map);
2314 }
2315
2316 return ret;
1966} 2317}
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index f30a3742891..5e02d2c1715 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -3,10 +3,11 @@
3 3
4#include <linux/types.h> 4#include <linux/types.h>
5#include <stdbool.h> 5#include <stdbool.h>
6#include "types.h" 6#include <stdint.h>
7#include "map.h"
7#include <linux/list.h> 8#include <linux/list.h>
8#include <linux/rbtree.h> 9#include <linux/rbtree.h>
9#include "event.h" 10#include <stdio.h>
10 11
11#define DEBUG_CACHE_DIR ".debug" 12#define DEBUG_CACHE_DIR ".debug"
12 13
@@ -29,6 +30,9 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
29#endif 30#endif
30#endif 31#endif
31 32
33int hex2u64(const char *ptr, u64 *val);
34char *strxfrchar(char *s, char from, char to);
35
32/* 36/*
33 * libelf 0.8.x and earlier do not support ELF_C_READ_MMAP; 37 * libelf 0.8.x and earlier do not support ELF_C_READ_MMAP;
34 * for newer versions we can use mmap to reduce memory usage: 38 * for newer versions we can use mmap to reduce memory usage:
@@ -44,10 +48,13 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
44#define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */ 48#define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */
45#endif 49#endif
46 50
51#define BUILD_ID_SIZE 20
52
47struct symbol { 53struct symbol {
48 struct rb_node rb_node; 54 struct rb_node rb_node;
49 u64 start; 55 u64 start;
50 u64 end; 56 u64 end;
57 u16 namelen;
51 char name[0]; 58 char name[0];
52}; 59};
53 60
@@ -63,10 +70,15 @@ struct symbol_conf {
63 show_nr_samples, 70 show_nr_samples,
64 use_callchain, 71 use_callchain,
65 exclude_other, 72 exclude_other,
66 full_paths; 73 full_paths,
74 show_cpu_utilization;
67 const char *vmlinux_name, 75 const char *vmlinux_name,
68 *field_sep; 76 *field_sep;
69 char *dso_list_str, 77 const char *default_guest_vmlinux_name,
78 *default_guest_kallsyms,
79 *default_guest_modules;
80 const char *guestmount;
81 const char *dso_list_str,
70 *comm_list_str, 82 *comm_list_str,
71 *sym_list_str, 83 *sym_list_str,
72 *col_width_list_str; 84 *col_width_list_str;
@@ -88,6 +100,11 @@ struct ref_reloc_sym {
88 u64 unrelocated_addr; 100 u64 unrelocated_addr;
89}; 101};
90 102
103struct map_symbol {
104 struct map *map;
105 struct symbol *sym;
106};
107
91struct addr_location { 108struct addr_location {
92 struct thread *thread; 109 struct thread *thread;
93 struct map *map; 110 struct map *map;
@@ -95,6 +112,13 @@ struct addr_location {
95 u64 addr; 112 u64 addr;
96 char level; 113 char level;
97 bool filtered; 114 bool filtered;
115 unsigned int cpumode;
116};
117
118enum dso_kernel_type {
119 DSO_TYPE_USER = 0,
120 DSO_TYPE_KERNEL,
121 DSO_TYPE_GUEST_KERNEL
98}; 122};
99 123
100struct dso { 124struct dso {
@@ -104,8 +128,9 @@ struct dso {
104 u8 adjust_symbols:1; 128 u8 adjust_symbols:1;
105 u8 slen_calculated:1; 129 u8 slen_calculated:1;
106 u8 has_build_id:1; 130 u8 has_build_id:1;
107 u8 kernel:1; 131 enum dso_kernel_type kernel;
108 u8 hit:1; 132 u8 hit:1;
133 u8 annotate_warned:1;
109 unsigned char origin; 134 unsigned char origin;
110 u8 sorted_by_name; 135 u8 sorted_by_name;
111 u8 loaded; 136 u8 loaded;
@@ -131,42 +156,66 @@ static inline void dso__set_loaded(struct dso *self, enum map_type type)
131 156
132void dso__sort_by_name(struct dso *self, enum map_type type); 157void dso__sort_by_name(struct dso *self, enum map_type type);
133 158
134extern struct list_head dsos__user, dsos__kernel;
135
136struct dso *__dsos__findnew(struct list_head *head, const char *name); 159struct dso *__dsos__findnew(struct list_head *head, const char *name);
137 160
138static inline struct dso *dsos__findnew(const char *name)
139{
140 return __dsos__findnew(&dsos__user, name);
141}
142
143int dso__load(struct dso *self, struct map *map, symbol_filter_t filter); 161int dso__load(struct dso *self, struct map *map, symbol_filter_t filter);
144int dso__load_vmlinux_path(struct dso *self, struct map *map, 162int dso__load_vmlinux_path(struct dso *self, struct map *map,
145 symbol_filter_t filter); 163 symbol_filter_t filter);
146int dso__load_kallsyms(struct dso *self, const char *filename, struct map *map, 164int dso__load_kallsyms(struct dso *self, const char *filename, struct map *map,
147 symbol_filter_t filter); 165 symbol_filter_t filter);
148void dsos__fprintf(FILE *fp); 166int machine__load_kallsyms(struct machine *self, const char *filename,
149size_t dsos__fprintf_buildid(FILE *fp, bool with_hits); 167 enum map_type type, symbol_filter_t filter);
168int machine__load_vmlinux_path(struct machine *self, enum map_type type,
169 symbol_filter_t filter);
170
171size_t __dsos__fprintf(struct list_head *head, FILE *fp);
172
173size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits);
174size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp);
175size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits);
150 176
151size_t dso__fprintf_buildid(struct dso *self, FILE *fp); 177size_t dso__fprintf_buildid(struct dso *self, FILE *fp);
152size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp); 178size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp);
179
180enum dso_origin {
181 DSO__ORIG_KERNEL = 0,
182 DSO__ORIG_GUEST_KERNEL,
183 DSO__ORIG_JAVA_JIT,
184 DSO__ORIG_BUILD_ID_CACHE,
185 DSO__ORIG_FEDORA,
186 DSO__ORIG_UBUNTU,
187 DSO__ORIG_BUILDID,
188 DSO__ORIG_DSO,
189 DSO__ORIG_GUEST_KMODULE,
190 DSO__ORIG_KMODULE,
191 DSO__ORIG_NOT_FOUND,
192};
193
153char dso__symtab_origin(const struct dso *self); 194char dso__symtab_origin(const struct dso *self);
154void dso__set_long_name(struct dso *self, char *name); 195void dso__set_long_name(struct dso *self, char *name);
155void dso__set_build_id(struct dso *self, void *build_id); 196void dso__set_build_id(struct dso *self, void *build_id);
156void dso__read_running_kernel_build_id(struct dso *self); 197void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine);
157struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr); 198struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
158struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type, 199struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
159 const char *name); 200 const char *name);
160 201
161int filename__read_build_id(const char *filename, void *bf, size_t size); 202int filename__read_build_id(const char *filename, void *bf, size_t size);
162int sysfs__read_build_id(const char *filename, void *bf, size_t size); 203int sysfs__read_build_id(const char *filename, void *bf, size_t size);
163bool dsos__read_build_ids(bool with_hits); 204bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
164int build_id__sprintf(const u8 *self, int len, char *bf); 205int build_id__sprintf(const u8 *self, int len, char *bf);
165int kallsyms__parse(const char *filename, void *arg, 206int kallsyms__parse(const char *filename, void *arg,
166 int (*process_symbol)(void *arg, const char *name, 207 int (*process_symbol)(void *arg, const char *name,
167 char type, u64 start)); 208 char type, u64 start));
168 209
210int __machine__create_kernel_maps(struct machine *self, struct dso *kernel);
211int machine__create_kernel_maps(struct machine *self);
212
213int machines__create_kernel_maps(struct rb_root *self, pid_t pid);
214int machines__create_guest_kernel_maps(struct rb_root *self);
215
169int symbol__init(void); 216int symbol__init(void);
170bool symbol_type__is_a(char symbol_type, enum map_type map_type); 217bool symbol_type__is_a(char symbol_type, enum map_type map_type);
171 218
219size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp);
220
172#endif /* __PERF_SYMBOL */ 221#endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index fa968312ee7..9a448b47400 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -7,13 +7,44 @@
7#include "util.h" 7#include "util.h"
8#include "debug.h" 8#include "debug.h"
9 9
10void map_groups__init(struct map_groups *self) 10/* Skip "." and ".." directories */
11static int filter(const struct dirent *dir)
11{ 12{
13 if (dir->d_name[0] == '.')
14 return 0;
15 else
16 return 1;
17}
18
19int find_all_tid(int pid, pid_t ** all_tid)
20{
21 char name[256];
22 int items;
23 struct dirent **namelist = NULL;
24 int ret = 0;
12 int i; 25 int i;
13 for (i = 0; i < MAP__NR_TYPES; ++i) { 26
14 self->maps[i] = RB_ROOT; 27 sprintf(name, "/proc/%d/task", pid);
15 INIT_LIST_HEAD(&self->removed_maps[i]); 28 items = scandir(name, &namelist, filter, NULL);
29 if (items <= 0)
30 return -ENOENT;
31 *all_tid = malloc(sizeof(pid_t) * items);
32 if (!*all_tid) {
33 ret = -ENOMEM;
34 goto failure;
16 } 35 }
36
37 for (i = 0; i < items; i++)
38 (*all_tid)[i] = atoi(namelist[i]->d_name);
39
40 ret = items;
41
42failure:
43 for (i=0; i<items; i++)
44 free(namelist[i]);
45 free(namelist);
46
47 return ret;
17} 48}
18 49
19static struct thread *thread__new(pid_t pid) 50static struct thread *thread__new(pid_t pid)
@@ -31,28 +62,6 @@ static struct thread *thread__new(pid_t pid)
31 return self; 62 return self;
32} 63}
33 64
34static void map_groups__flush(struct map_groups *self)
35{
36 int type;
37
38 for (type = 0; type < MAP__NR_TYPES; type++) {
39 struct rb_root *root = &self->maps[type];
40 struct rb_node *next = rb_first(root);
41
42 while (next) {
43 struct map *pos = rb_entry(next, struct map, rb_node);
44 next = rb_next(&pos->rb_node);
45 rb_erase(&pos->rb_node, root);
46 /*
47 * We may have references to this map, for
48 * instance in some hist_entry instances, so
49 * just move them to a separate list.
50 */
51 list_add_tail(&pos->node, &self->removed_maps[pos->type]);
52 }
53 }
54}
55
56int thread__set_comm(struct thread *self, const char *comm) 65int thread__set_comm(struct thread *self, const char *comm)
57{ 66{
58 int err; 67 int err;
@@ -79,69 +88,10 @@ int thread__comm_len(struct thread *self)
79 return self->comm_len; 88 return self->comm_len;
80} 89}
81 90
82size_t __map_groups__fprintf_maps(struct map_groups *self,
83 enum map_type type, FILE *fp)
84{
85 size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
86 struct rb_node *nd;
87
88 for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
89 struct map *pos = rb_entry(nd, struct map, rb_node);
90 printed += fprintf(fp, "Map:");
91 printed += map__fprintf(pos, fp);
92 if (verbose > 2) {
93 printed += dso__fprintf(pos->dso, type, fp);
94 printed += fprintf(fp, "--\n");
95 }
96 }
97
98 return printed;
99}
100
101size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp)
102{
103 size_t printed = 0, i;
104 for (i = 0; i < MAP__NR_TYPES; ++i)
105 printed += __map_groups__fprintf_maps(self, i, fp);
106 return printed;
107}
108
109static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
110 enum map_type type, FILE *fp)
111{
112 struct map *pos;
113 size_t printed = 0;
114
115 list_for_each_entry(pos, &self->removed_maps[type], node) {
116 printed += fprintf(fp, "Map:");
117 printed += map__fprintf(pos, fp);
118 if (verbose > 1) {
119 printed += dso__fprintf(pos->dso, type, fp);
120 printed += fprintf(fp, "--\n");
121 }
122 }
123 return printed;
124}
125
126static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp)
127{
128 size_t printed = 0, i;
129 for (i = 0; i < MAP__NR_TYPES; ++i)
130 printed += __map_groups__fprintf_removed_maps(self, i, fp);
131 return printed;
132}
133
134static size_t map_groups__fprintf(struct map_groups *self, FILE *fp)
135{
136 size_t printed = map_groups__fprintf_maps(self, fp);
137 printed += fprintf(fp, "Removed maps:\n");
138 return printed + map_groups__fprintf_removed_maps(self, fp);
139}
140
141static size_t thread__fprintf(struct thread *self, FILE *fp) 91static size_t thread__fprintf(struct thread *self, FILE *fp)
142{ 92{
143 return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) + 93 return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
144 map_groups__fprintf(&self->mg, fp); 94 map_groups__fprintf(&self->mg, verbose, fp);
145} 95}
146 96
147struct thread *perf_session__findnew(struct perf_session *self, pid_t pid) 97struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
@@ -183,127 +133,12 @@ struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
183 return th; 133 return th;
184} 134}
185 135
186static int map_groups__fixup_overlappings(struct map_groups *self,
187 struct map *map)
188{
189 struct rb_root *root = &self->maps[map->type];
190 struct rb_node *next = rb_first(root);
191
192 while (next) {
193 struct map *pos = rb_entry(next, struct map, rb_node);
194 next = rb_next(&pos->rb_node);
195
196 if (!map__overlap(pos, map))
197 continue;
198
199 if (verbose >= 2) {
200 fputs("overlapping maps:\n", stderr);
201 map__fprintf(map, stderr);
202 map__fprintf(pos, stderr);
203 }
204
205 rb_erase(&pos->rb_node, root);
206 /*
207 * We may have references to this map, for instance in some
208 * hist_entry instances, so just move them to a separate
209 * list.
210 */
211 list_add_tail(&pos->node, &self->removed_maps[map->type]);
212 /*
213 * Now check if we need to create new maps for areas not
214 * overlapped by the new map:
215 */
216 if (map->start > pos->start) {
217 struct map *before = map__clone(pos);
218
219 if (before == NULL)
220 return -ENOMEM;
221
222 before->end = map->start - 1;
223 map_groups__insert(self, before);
224 if (verbose >= 2)
225 map__fprintf(before, stderr);
226 }
227
228 if (map->end < pos->end) {
229 struct map *after = map__clone(pos);
230
231 if (after == NULL)
232 return -ENOMEM;
233
234 after->start = map->end + 1;
235 map_groups__insert(self, after);
236 if (verbose >= 2)
237 map__fprintf(after, stderr);
238 }
239 }
240
241 return 0;
242}
243
244void maps__insert(struct rb_root *maps, struct map *map)
245{
246 struct rb_node **p = &maps->rb_node;
247 struct rb_node *parent = NULL;
248 const u64 ip = map->start;
249 struct map *m;
250
251 while (*p != NULL) {
252 parent = *p;
253 m = rb_entry(parent, struct map, rb_node);
254 if (ip < m->start)
255 p = &(*p)->rb_left;
256 else
257 p = &(*p)->rb_right;
258 }
259
260 rb_link_node(&map->rb_node, parent, p);
261 rb_insert_color(&map->rb_node, maps);
262}
263
264struct map *maps__find(struct rb_root *maps, u64 ip)
265{
266 struct rb_node **p = &maps->rb_node;
267 struct rb_node *parent = NULL;
268 struct map *m;
269
270 while (*p != NULL) {
271 parent = *p;
272 m = rb_entry(parent, struct map, rb_node);
273 if (ip < m->start)
274 p = &(*p)->rb_left;
275 else if (ip > m->end)
276 p = &(*p)->rb_right;
277 else
278 return m;
279 }
280
281 return NULL;
282}
283
284void thread__insert_map(struct thread *self, struct map *map) 136void thread__insert_map(struct thread *self, struct map *map)
285{ 137{
286 map_groups__fixup_overlappings(&self->mg, map); 138 map_groups__fixup_overlappings(&self->mg, map, verbose, stderr);
287 map_groups__insert(&self->mg, map); 139 map_groups__insert(&self->mg, map);
288} 140}
289 141
290/*
291 * XXX This should not really _copy_ te maps, but refcount them.
292 */
293static int map_groups__clone(struct map_groups *self,
294 struct map_groups *parent, enum map_type type)
295{
296 struct rb_node *nd;
297 for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
298 struct map *map = rb_entry(nd, struct map, rb_node);
299 struct map *new = map__clone(map);
300 if (new == NULL)
301 return -ENOMEM;
302 map_groups__insert(self, new);
303 }
304 return 0;
305}
306
307int thread__fork(struct thread *self, struct thread *parent) 142int thread__fork(struct thread *self, struct thread *parent)
308{ 143{
309 int i; 144 int i;
@@ -336,15 +171,3 @@ size_t perf_session__fprintf(struct perf_session *self, FILE *fp)
336 171
337 return ret; 172 return ret;
338} 173}
339
340struct symbol *map_groups__find_symbol(struct map_groups *self,
341 enum map_type type, u64 addr,
342 symbol_filter_t filter)
343{
344 struct map *map = map_groups__find(self, type, addr);
345
346 if (map != NULL)
347 return map__find_symbol(map, map->map_ip(map, addr), filter);
348
349 return NULL;
350}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index dcf70303e58..ee6bbcf277c 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -5,16 +5,11 @@
5#include <unistd.h> 5#include <unistd.h>
6#include "symbol.h" 6#include "symbol.h"
7 7
8struct map_groups {
9 struct rb_root maps[MAP__NR_TYPES];
10 struct list_head removed_maps[MAP__NR_TYPES];
11};
12
13size_t __map_groups__fprintf_maps(struct map_groups *self,
14 enum map_type type, FILE *fp);
15
16struct thread { 8struct thread {
17 struct rb_node rb_node; 9 union {
10 struct rb_node rb_node;
11 struct list_head node;
12 };
18 struct map_groups mg; 13 struct map_groups mg;
19 pid_t pid; 14 pid_t pid;
20 char shortname[3]; 15 char shortname[3];
@@ -23,29 +18,16 @@ struct thread {
23 int comm_len; 18 int comm_len;
24}; 19};
25 20
26void map_groups__init(struct map_groups *self); 21struct perf_session;
22
23int find_all_tid(int pid, pid_t ** all_tid);
27int thread__set_comm(struct thread *self, const char *comm); 24int thread__set_comm(struct thread *self, const char *comm);
28int thread__comm_len(struct thread *self); 25int thread__comm_len(struct thread *self);
29struct thread *perf_session__findnew(struct perf_session *self, pid_t pid); 26struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
30void thread__insert_map(struct thread *self, struct map *map); 27void thread__insert_map(struct thread *self, struct map *map);
31int thread__fork(struct thread *self, struct thread *parent); 28int thread__fork(struct thread *self, struct thread *parent);
32size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp);
33size_t perf_session__fprintf(struct perf_session *self, FILE *fp); 29size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
34 30
35void maps__insert(struct rb_root *maps, struct map *map);
36struct map *maps__find(struct rb_root *maps, u64 addr);
37
38static inline void map_groups__insert(struct map_groups *self, struct map *map)
39{
40 maps__insert(&self->maps[map->type], map);
41}
42
43static inline struct map *map_groups__find(struct map_groups *self,
44 enum map_type type, u64 addr)
45{
46 return maps__find(&self->maps[type], addr);
47}
48
49static inline struct map *thread__find_map(struct thread *self, 31static inline struct map *thread__find_map(struct thread *self,
50 enum map_type type, u64 addr) 32 enum map_type type, u64 addr)
51{ 33{
@@ -54,34 +36,12 @@ static inline struct map *thread__find_map(struct thread *self,
54 36
55void thread__find_addr_map(struct thread *self, 37void thread__find_addr_map(struct thread *self,
56 struct perf_session *session, u8 cpumode, 38 struct perf_session *session, u8 cpumode,
57 enum map_type type, u64 addr, 39 enum map_type type, pid_t pid, u64 addr,
58 struct addr_location *al); 40 struct addr_location *al);
59 41
60void thread__find_addr_location(struct thread *self, 42void thread__find_addr_location(struct thread *self,
61 struct perf_session *session, u8 cpumode, 43 struct perf_session *session, u8 cpumode,
62 enum map_type type, u64 addr, 44 enum map_type type, pid_t pid, u64 addr,
63 struct addr_location *al, 45 struct addr_location *al,
64 symbol_filter_t filter); 46 symbol_filter_t filter);
65struct symbol *map_groups__find_symbol(struct map_groups *self,
66 enum map_type type, u64 addr,
67 symbol_filter_t filter);
68
69static inline struct symbol *map_groups__find_function(struct map_groups *self,
70 u64 addr,
71 symbol_filter_t filter)
72{
73 return map_groups__find_symbol(self, MAP__FUNCTION, addr, filter);
74}
75
76struct map *map_groups__find_by_name(struct map_groups *self,
77 enum map_type type, const char *name);
78
79int __map_groups__create_kernel_maps(struct map_groups *self,
80 struct map *vmlinux_maps[MAP__NR_TYPES],
81 struct dso *kernel);
82int map_groups__create_kernel_maps(struct map_groups *self,
83 struct map *vmlinux_maps[MAP__NR_TYPES]);
84
85struct map *map_groups__new_module(struct map_groups *self, u64 start,
86 const char *filename);
87#endif /* __PERF_THREAD_H */ 47#endif /* __PERF_THREAD_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 5ea8973ad33..b1572601286 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -154,10 +154,17 @@ static void put_tracing_file(char *file)
154 free(file); 154 free(file);
155} 155}
156 156
157static ssize_t calc_data_size;
158
157static ssize_t write_or_die(const void *buf, size_t len) 159static ssize_t write_or_die(const void *buf, size_t len)
158{ 160{
159 int ret; 161 int ret;
160 162
163 if (calc_data_size) {
164 calc_data_size += len;
165 return len;
166 }
167
161 ret = write(output_fd, buf, len); 168 ret = write(output_fd, buf, len);
162 if (ret < 0) 169 if (ret < 0)
163 die("writing to '%s'", output_file); 170 die("writing to '%s'", output_file);
@@ -480,6 +487,17 @@ get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
480 return nr_tracepoints > 0 ? path.next : NULL; 487 return nr_tracepoints > 0 ? path.next : NULL;
481} 488}
482 489
490bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
491{
492 int i;
493
494 for (i = 0; i < nb_events; i++)
495 if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
496 return true;
497
498 return false;
499}
500
483int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events) 501int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
484{ 502{
485 char buf[BUFSIZ]; 503 char buf[BUFSIZ];
@@ -526,3 +544,20 @@ int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
526 544
527 return 0; 545 return 0;
528} 546}
547
548ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
549 int nb_events)
550{
551 ssize_t size;
552 int err = 0;
553
554 calc_data_size = 1;
555 err = read_tracing_data(fd, pattrs, nb_events);
556 size = calc_data_size - 1;
557 calc_data_size = 0;
558
559 if (err < 0)
560 return err;
561
562 return size;
563}
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 613c9cc9057..73a02223c62 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -37,10 +37,12 @@ int header_page_ts_offset;
37int header_page_ts_size; 37int header_page_ts_size;
38int header_page_size_offset; 38int header_page_size_offset;
39int header_page_size_size; 39int header_page_size_size;
40int header_page_overwrite_offset;
41int header_page_overwrite_size;
40int header_page_data_offset; 42int header_page_data_offset;
41int header_page_data_size; 43int header_page_data_size;
42 44
43int latency_format; 45bool latency_format;
44 46
45static char *input_buf; 47static char *input_buf;
46static unsigned long long input_buf_ptr; 48static unsigned long long input_buf_ptr;
@@ -628,23 +630,32 @@ static int test_type(enum event_type type, enum event_type expect)
628 return 0; 630 return 0;
629} 631}
630 632
631static int test_type_token(enum event_type type, char *token, 633static int __test_type_token(enum event_type type, char *token,
632 enum event_type expect, const char *expect_tok) 634 enum event_type expect, const char *expect_tok,
635 bool warn)
633{ 636{
634 if (type != expect) { 637 if (type != expect) {
635 warning("Error: expected type %d but read %d", 638 if (warn)
636 expect, type); 639 warning("Error: expected type %d but read %d",
640 expect, type);
637 return -1; 641 return -1;
638 } 642 }
639 643
640 if (strcmp(token, expect_tok) != 0) { 644 if (strcmp(token, expect_tok) != 0) {
641 warning("Error: expected '%s' but read '%s'", 645 if (warn)
642 expect_tok, token); 646 warning("Error: expected '%s' but read '%s'",
647 expect_tok, token);
643 return -1; 648 return -1;
644 } 649 }
645 return 0; 650 return 0;
646} 651}
647 652
653static int test_type_token(enum event_type type, char *token,
654 enum event_type expect, const char *expect_tok)
655{
656 return __test_type_token(type, token, expect, expect_tok, true);
657}
658
648static int __read_expect_type(enum event_type expect, char **tok, int newline_ok) 659static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
649{ 660{
650 enum event_type type; 661 enum event_type type;
@@ -661,7 +672,8 @@ static int read_expect_type(enum event_type expect, char **tok)
661 return __read_expect_type(expect, tok, 1); 672 return __read_expect_type(expect, tok, 1);
662} 673}
663 674
664static int __read_expected(enum event_type expect, const char *str, int newline_ok) 675static int __read_expected(enum event_type expect, const char *str,
676 int newline_ok, bool warn)
665{ 677{
666 enum event_type type; 678 enum event_type type;
667 char *token; 679 char *token;
@@ -672,7 +684,7 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
672 else 684 else
673 type = read_token_item(&token); 685 type = read_token_item(&token);
674 686
675 ret = test_type_token(type, token, expect, str); 687 ret = __test_type_token(type, token, expect, str, warn);
676 688
677 free_token(token); 689 free_token(token);
678 690
@@ -681,12 +693,12 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
681 693
682static int read_expected(enum event_type expect, const char *str) 694static int read_expected(enum event_type expect, const char *str)
683{ 695{
684 return __read_expected(expect, str, 1); 696 return __read_expected(expect, str, 1, true);
685} 697}
686 698
687static int read_expected_item(enum event_type expect, const char *str) 699static int read_expected_item(enum event_type expect, const char *str)
688{ 700{
689 return __read_expected(expect, str, 0); 701 return __read_expected(expect, str, 0, true);
690} 702}
691 703
692static char *event_read_name(void) 704static char *event_read_name(void)
@@ -744,7 +756,7 @@ static int field_is_string(struct format_field *field)
744 756
745static int field_is_dynamic(struct format_field *field) 757static int field_is_dynamic(struct format_field *field)
746{ 758{
747 if (!strcmp(field->type, "__data_loc")) 759 if (!strncmp(field->type, "__data_loc", 10))
748 return 1; 760 return 1;
749 761
750 return 0; 762 return 0;
@@ -3087,88 +3099,6 @@ static void print_args(struct print_arg *args)
3087 } 3099 }
3088} 3100}
3089 3101
3090static void parse_header_field(const char *field,
3091 int *offset, int *size)
3092{
3093 char *token;
3094 int type;
3095
3096 if (read_expected(EVENT_ITEM, "field") < 0)
3097 return;
3098 if (read_expected(EVENT_OP, ":") < 0)
3099 return;
3100
3101 /* type */
3102 if (read_expect_type(EVENT_ITEM, &token) < 0)
3103 goto fail;
3104 free_token(token);
3105
3106 if (read_expected(EVENT_ITEM, field) < 0)
3107 return;
3108 if (read_expected(EVENT_OP, ";") < 0)
3109 return;
3110 if (read_expected(EVENT_ITEM, "offset") < 0)
3111 return;
3112 if (read_expected(EVENT_OP, ":") < 0)
3113 return;
3114 if (read_expect_type(EVENT_ITEM, &token) < 0)
3115 goto fail;
3116 *offset = atoi(token);
3117 free_token(token);
3118 if (read_expected(EVENT_OP, ";") < 0)
3119 return;
3120 if (read_expected(EVENT_ITEM, "size") < 0)
3121 return;
3122 if (read_expected(EVENT_OP, ":") < 0)
3123 return;
3124 if (read_expect_type(EVENT_ITEM, &token) < 0)
3125 goto fail;
3126 *size = atoi(token);
3127 free_token(token);
3128 if (read_expected(EVENT_OP, ";") < 0)
3129 return;
3130 type = read_token(&token);
3131 if (type != EVENT_NEWLINE) {
3132 /* newer versions of the kernel have a "signed" type */
3133 if (type != EVENT_ITEM)
3134 goto fail;
3135
3136 if (strcmp(token, "signed") != 0)
3137 goto fail;
3138
3139 free_token(token);
3140
3141 if (read_expected(EVENT_OP, ":") < 0)
3142 return;
3143
3144 if (read_expect_type(EVENT_ITEM, &token))
3145 goto fail;
3146
3147 free_token(token);
3148 if (read_expected(EVENT_OP, ";") < 0)
3149 return;
3150
3151 if (read_expect_type(EVENT_NEWLINE, &token))
3152 goto fail;
3153 }
3154 fail:
3155 free_token(token);
3156}
3157
3158int parse_header_page(char *buf, unsigned long size)
3159{
3160 init_input_buf(buf, size);
3161
3162 parse_header_field("timestamp", &header_page_ts_offset,
3163 &header_page_ts_size);
3164 parse_header_field("commit", &header_page_size_offset,
3165 &header_page_size_size);
3166 parse_header_field("data", &header_page_data_offset,
3167 &header_page_data_size);
3168
3169 return 0;
3170}
3171
3172int parse_ftrace_file(char *buf, unsigned long size) 3102int parse_ftrace_file(char *buf, unsigned long size)
3173{ 3103{
3174 struct format_field *field; 3104 struct format_field *field;
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 7cd1193918c..f55cc3a765a 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -50,17 +50,61 @@ static int long_size;
50 50
51static unsigned long page_size; 51static unsigned long page_size;
52 52
53static ssize_t calc_data_size;
54static bool repipe;
55
56static int do_read(int fd, void *buf, int size)
57{
58 int rsize = size;
59
60 while (size) {
61 int ret = read(fd, buf, size);
62
63 if (ret <= 0)
64 return -1;
65
66 if (repipe) {
67 int retw = write(STDOUT_FILENO, buf, ret);
68
69 if (retw <= 0 || retw != ret)
70 die("repiping input file");
71 }
72
73 size -= ret;
74 buf += ret;
75 }
76
77 return rsize;
78}
79
53static int read_or_die(void *data, int size) 80static int read_or_die(void *data, int size)
54{ 81{
55 int r; 82 int r;
56 83
57 r = read(input_fd, data, size); 84 r = do_read(input_fd, data, size);
58 if (r != size) 85 if (r <= 0)
59 die("reading input file (size expected=%d received=%d)", 86 die("reading input file (size expected=%d received=%d)",
60 size, r); 87 size, r);
88
89 if (calc_data_size)
90 calc_data_size += r;
91
61 return r; 92 return r;
62} 93}
63 94
95/* If it fails, the next read will report it */
96static void skip(int size)
97{
98 char buf[BUFSIZ];
99 int r;
100
101 while (size) {
102 r = size > BUFSIZ ? BUFSIZ : size;
103 read_or_die(buf, r);
104 size -= r;
105 };
106}
107
64static unsigned int read4(void) 108static unsigned int read4(void)
65{ 109{
66 unsigned int data; 110 unsigned int data;
@@ -82,57 +126,36 @@ static char *read_string(void)
82 char buf[BUFSIZ]; 126 char buf[BUFSIZ];
83 char *str = NULL; 127 char *str = NULL;
84 int size = 0; 128 int size = 0;
85 int i;
86 off_t r; 129 off_t r;
130 char c;
87 131
88 for (;;) { 132 for (;;) {
89 r = read(input_fd, buf, BUFSIZ); 133 r = read(input_fd, &c, 1);
90 if (r < 0) 134 if (r < 0)
91 die("reading input file"); 135 die("reading input file");
92 136
93 if (!r) 137 if (!r)
94 die("no data"); 138 die("no data");
95 139
96 for (i = 0; i < r; i++) { 140 if (repipe) {
97 if (!buf[i]) 141 int retw = write(STDOUT_FILENO, &c, 1);
98 break;
99 }
100 if (i < r)
101 break;
102 142
103 if (str) { 143 if (retw <= 0 || retw != r)
104 size += BUFSIZ; 144 die("repiping input file string");
105 str = realloc(str, size);
106 if (!str)
107 die("malloc of size %d", size);
108 memcpy(str + (size - BUFSIZ), buf, BUFSIZ);
109 } else {
110 size = BUFSIZ;
111 str = malloc_or_die(size);
112 memcpy(str, buf, size);
113 } 145 }
114 }
115 146
116 /* trailing \0: */ 147 buf[size++] = c;
117 i++; 148
118 149 if (!c)
119 /* move the file descriptor to the end of the string */ 150 break;
120 r = lseek(input_fd, -(r - i), SEEK_CUR);
121 if (r == (off_t)-1)
122 die("lseek");
123
124 if (str) {
125 size += i;
126 str = realloc(str, size);
127 if (!str)
128 die("malloc of size %d", size);
129 memcpy(str + (size - i), buf, i);
130 } else {
131 size = i;
132 str = malloc_or_die(i);
133 memcpy(str, buf, i);
134 } 151 }
135 152
153 if (calc_data_size)
154 calc_data_size += size;
155
156 str = malloc_or_die(size);
157 memcpy(str, buf, size);
158
136 return str; 159 return str;
137} 160}
138 161
@@ -174,7 +197,6 @@ static void read_ftrace_printk(void)
174static void read_header_files(void) 197static void read_header_files(void)
175{ 198{
176 unsigned long long size; 199 unsigned long long size;
177 char *header_page;
178 char *header_event; 200 char *header_event;
179 char buf[BUFSIZ]; 201 char buf[BUFSIZ];
180 202
@@ -184,10 +206,7 @@ static void read_header_files(void)
184 die("did not read header page"); 206 die("did not read header page");
185 207
186 size = read8(); 208 size = read8();
187 header_page = malloc_or_die(size); 209 skip(size);
188 read_or_die(header_page, size);
189 parse_header_page(header_page, size);
190 free(header_page);
191 210
192 /* 211 /*
193 * The size field in the page is of type long, 212 * The size field in the page is of type long,
@@ -459,7 +478,7 @@ struct record *trace_read_data(int cpu)
459 return data; 478 return data;
460} 479}
461 480
462void trace_report(int fd) 481ssize_t trace_report(int fd, bool __repipe)
463{ 482{
464 char buf[BUFSIZ]; 483 char buf[BUFSIZ];
465 char test[] = { 23, 8, 68 }; 484 char test[] = { 23, 8, 68 };
@@ -467,6 +486,10 @@ void trace_report(int fd)
467 int show_version = 0; 486 int show_version = 0;
468 int show_funcs = 0; 487 int show_funcs = 0;
469 int show_printk = 0; 488 int show_printk = 0;
489 ssize_t size;
490
491 calc_data_size = 1;
492 repipe = __repipe;
470 493
471 input_fd = fd; 494 input_fd = fd;
472 495
@@ -499,14 +522,18 @@ void trace_report(int fd)
499 read_proc_kallsyms(); 522 read_proc_kallsyms();
500 read_ftrace_printk(); 523 read_ftrace_printk();
501 524
525 size = calc_data_size - 1;
526 calc_data_size = 0;
527 repipe = false;
528
502 if (show_funcs) { 529 if (show_funcs) {
503 print_funcs(); 530 print_funcs();
504 return; 531 return size;
505 } 532 }
506 if (show_printk) { 533 if (show_printk) {
507 print_printk(); 534 print_printk();
508 return; 535 return size;
509 } 536 }
510 537
511 return; 538 return size;
512} 539}
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index c3269b937db..b3e86b1e444 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,6 +1,7 @@
1#ifndef __PERF_TRACE_EVENTS_H 1#ifndef __PERF_TRACE_EVENTS_H
2#define __PERF_TRACE_EVENTS_H 2#define __PERF_TRACE_EVENTS_H
3 3
4#include <stdbool.h>
4#include "parse-events.h" 5#include "parse-events.h"
5 6
6#define __unused __attribute__((unused)) 7#define __unused __attribute__((unused))
@@ -162,7 +163,7 @@ struct record *trace_read_data(int cpu);
162 163
163void parse_set_info(int nr_cpus, int long_sz); 164void parse_set_info(int nr_cpus, int long_sz);
164 165
165void trace_report(int fd); 166ssize_t trace_report(int fd, bool repipe);
166 167
167void *malloc_or_die(unsigned int size); 168void *malloc_or_die(unsigned int size);
168 169
@@ -232,7 +233,12 @@ static inline unsigned long long __data2host8(unsigned long long data)
232 233
233#define data2host2(ptr) __data2host2(*(unsigned short *)ptr) 234#define data2host2(ptr) __data2host2(*(unsigned short *)ptr)
234#define data2host4(ptr) __data2host4(*(unsigned int *)ptr) 235#define data2host4(ptr) __data2host4(*(unsigned int *)ptr)
235#define data2host8(ptr) __data2host8(*(unsigned long long *)ptr) 236#define data2host8(ptr) ({ \
237 unsigned long long __val; \
238 \
239 memcpy(&__val, (ptr), sizeof(unsigned long long)); \
240 __data2host8(__val); \
241})
236 242
237extern int header_page_ts_offset; 243extern int header_page_ts_offset;
238extern int header_page_ts_size; 244extern int header_page_ts_size;
@@ -241,9 +247,8 @@ extern int header_page_size_size;
241extern int header_page_data_offset; 247extern int header_page_data_offset;
242extern int header_page_data_size; 248extern int header_page_data_size;
243 249
244extern int latency_format; 250extern bool latency_format;
245 251
246int parse_header_page(char *buf, unsigned long size);
247int trace_parse_common_type(void *data); 252int trace_parse_common_type(void *data);
248int trace_parse_common_pid(void *data); 253int trace_parse_common_pid(void *data);
249int parse_common_pc(void *data); 254int parse_common_pc(void *data);
@@ -258,6 +263,8 @@ void *raw_field_ptr(struct event *event, const char *name, void *data);
258unsigned long long eval_flag(const char *flag); 263unsigned long long eval_flag(const char *flag);
259 264
260int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events); 265int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events);
266ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
267 int nb_events);
261 268
262/* taken from kernel/trace/trace.h */ 269/* taken from kernel/trace/trace.h */
263enum trace_flag_type { 270enum trace_flag_type {
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index f9b890fde68..214265674dd 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -92,3 +92,25 @@ out_close_from:
92out: 92out:
93 return err; 93 return err;
94} 94}
95
96unsigned long convert_unit(unsigned long value, char *unit)
97{
98 *unit = ' ';
99
100 if (value > 1000) {
101 value /= 1000;
102 *unit = 'K';
103 }
104
105 if (value > 1000) {
106 value /= 1000;
107 *unit = 'M';
108 }
109
110 if (value > 1000) {
111 value /= 1000;
112 *unit = 'G';
113 }
114
115 return value;
116}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 0f5b2a6f108..4e8b6b0c551 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -42,12 +42,14 @@
42#define _ALL_SOURCE 1 42#define _ALL_SOURCE 1
43#define _GNU_SOURCE 1 43#define _GNU_SOURCE 1
44#define _BSD_SOURCE 1 44#define _BSD_SOURCE 1
45#define HAS_BOOL
45 46
46#include <unistd.h> 47#include <unistd.h>
47#include <stdio.h> 48#include <stdio.h>
48#include <sys/stat.h> 49#include <sys/stat.h>
49#include <sys/statfs.h> 50#include <sys/statfs.h>
50#include <fcntl.h> 51#include <fcntl.h>
52#include <stdbool.h>
51#include <stddef.h> 53#include <stddef.h>
52#include <stdlib.h> 54#include <stdlib.h>
53#include <stdarg.h> 55#include <stdarg.h>
@@ -78,7 +80,8 @@
78#include <pwd.h> 80#include <pwd.h>
79#include <inttypes.h> 81#include <inttypes.h>
80#include "../../../include/linux/magic.h" 82#include "../../../include/linux/magic.h"
81 83#include "types.h"
84#include <sys/ttydefaults.h>
82 85
83#ifndef NO_ICONV 86#ifndef NO_ICONV
84#include <iconv.h> 87#include <iconv.h>
@@ -149,7 +152,6 @@ extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)))
149extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN); 152extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
150 153
151extern int prefixcmp(const char *str, const char *prefix); 154extern int prefixcmp(const char *str, const char *prefix);
152extern time_t tm_to_time_t(const struct tm *tm);
153 155
154static inline const char *skip_prefix(const char *str, const char *prefix) 156static inline const char *skip_prefix(const char *str, const char *prefix)
155{ 157{
@@ -157,119 +159,6 @@ static inline const char *skip_prefix(const char *str, const char *prefix)
157 return strncmp(str, prefix, len) ? NULL : str + len; 159 return strncmp(str, prefix, len) ? NULL : str + len;
158} 160}
159 161
160#if defined(NO_MMAP) || defined(USE_WIN32_MMAP)
161
162#ifndef PROT_READ
163#define PROT_READ 1
164#define PROT_WRITE 2
165#define MAP_PRIVATE 1
166#define MAP_FAILED ((void*)-1)
167#endif
168
169#define mmap git_mmap
170#define munmap git_munmap
171extern void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
172extern int git_munmap(void *start, size_t length);
173
174#else /* NO_MMAP || USE_WIN32_MMAP */
175
176#include <sys/mman.h>
177
178#endif /* NO_MMAP || USE_WIN32_MMAP */
179
180#ifdef NO_MMAP
181
182/* This value must be multiple of (pagesize * 2) */
183#define DEFAULT_PACKED_GIT_WINDOW_SIZE (1 * 1024 * 1024)
184
185#else /* NO_MMAP */
186
187/* This value must be multiple of (pagesize * 2) */
188#define DEFAULT_PACKED_GIT_WINDOW_SIZE \
189 (sizeof(void*) >= 8 \
190 ? 1 * 1024 * 1024 * 1024 \
191 : 32 * 1024 * 1024)
192
193#endif /* NO_MMAP */
194
195#ifdef NO_ST_BLOCKS_IN_STRUCT_STAT
196#define on_disk_bytes(st) ((st).st_size)
197#else
198#define on_disk_bytes(st) ((st).st_blocks * 512)
199#endif
200
201#define DEFAULT_PACKED_GIT_LIMIT \
202 ((1024L * 1024L) * (sizeof(void*) >= 8 ? 8192 : 256))
203
204#ifdef NO_PREAD
205#define pread git_pread
206extern ssize_t git_pread(int fd, void *buf, size_t count, off_t offset);
207#endif
208/*
209 * Forward decl that will remind us if its twin in cache.h changes.
210 * This function is used in compat/pread.c. But we can't include
211 * cache.h there.
212 */
213extern ssize_t read_in_full(int fd, void *buf, size_t count);
214
215#ifdef NO_SETENV
216#define setenv gitsetenv
217extern int gitsetenv(const char *, const char *, int);
218#endif
219
220#ifdef NO_MKDTEMP
221#define mkdtemp gitmkdtemp
222extern char *gitmkdtemp(char *);
223#endif
224
225#ifdef NO_UNSETENV
226#define unsetenv gitunsetenv
227extern void gitunsetenv(const char *);
228#endif
229
230#ifdef NO_STRCASESTR
231#define strcasestr gitstrcasestr
232extern char *gitstrcasestr(const char *haystack, const char *needle);
233#endif
234
235#ifdef NO_STRLCPY
236#define strlcpy gitstrlcpy
237extern size_t gitstrlcpy(char *, const char *, size_t);
238#endif
239
240#ifdef NO_STRTOUMAX
241#define strtoumax gitstrtoumax
242extern uintmax_t gitstrtoumax(const char *, char **, int);
243#endif
244
245#ifdef NO_HSTRERROR
246#define hstrerror githstrerror
247extern const char *githstrerror(int herror);
248#endif
249
250#ifdef NO_MEMMEM
251#define memmem gitmemmem
252void *gitmemmem(const void *haystack, size_t haystacklen,
253 const void *needle, size_t needlelen);
254#endif
255
256#ifdef FREAD_READS_DIRECTORIES
257#ifdef fopen
258#undef fopen
259#endif
260#define fopen(a,b) git_fopen(a,b)
261extern FILE *git_fopen(const char*, const char*);
262#endif
263
264#ifdef SNPRINTF_RETURNS_BOGUS
265#define snprintf git_snprintf
266extern int git_snprintf(char *str, size_t maxsize,
267 const char *format, ...);
268#define vsnprintf git_vsnprintf
269extern int git_vsnprintf(char *str, size_t maxsize,
270 const char *format, va_list ap);
271#endif
272
273#ifdef __GLIBC_PREREQ 162#ifdef __GLIBC_PREREQ
274#if __GLIBC_PREREQ(2, 1) 163#if __GLIBC_PREREQ(2, 1)
275#define HAVE_STRCHRNUL 164#define HAVE_STRCHRNUL
@@ -290,25 +179,19 @@ static inline char *gitstrchrnul(const char *s, int c)
290 * Wrappers: 179 * Wrappers:
291 */ 180 */
292extern char *xstrdup(const char *str); 181extern char *xstrdup(const char *str);
293extern void *xmalloc(size_t size) __attribute__((weak));
294extern void *xmemdupz(const void *data, size_t len);
295extern char *xstrndup(const char *str, size_t len);
296extern void *xrealloc(void *ptr, size_t size) __attribute__((weak)); 182extern void *xrealloc(void *ptr, size_t size) __attribute__((weak));
297 183
184
298static inline void *zalloc(size_t size) 185static inline void *zalloc(size_t size)
299{ 186{
300 return calloc(1, size); 187 return calloc(1, size);
301} 188}
302 189
303static inline size_t xsize_t(off_t len)
304{
305 return (size_t)len;
306}
307
308static inline int has_extension(const char *filename, const char *ext) 190static inline int has_extension(const char *filename, const char *ext)
309{ 191{
310 size_t len = strlen(filename); 192 size_t len = strlen(filename);
311 size_t extlen = strlen(ext); 193 size_t extlen = strlen(ext);
194
312 return len > extlen && !memcmp(filename + len - extlen, ext, extlen); 195 return len > extlen && !memcmp(filename + len - extlen, ext, extlen);
313} 196}
314 197
@@ -322,6 +205,7 @@ static inline int has_extension(const char *filename, const char *ext)
322#undef isalnum 205#undef isalnum
323#undef tolower 206#undef tolower
324#undef toupper 207#undef toupper
208
325extern unsigned char sane_ctype[256]; 209extern unsigned char sane_ctype[256];
326#define GIT_SPACE 0x01 210#define GIT_SPACE 0x01
327#define GIT_DIGIT 0x02 211#define GIT_DIGIT 0x02
@@ -339,8 +223,6 @@ extern unsigned char sane_ctype[256];
339#define isalpha(x) sane_istest(x,GIT_ALPHA) 223#define isalpha(x) sane_istest(x,GIT_ALPHA)
340#define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT) 224#define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
341#define isprint(x) sane_istest(x,GIT_PRINT) 225#define isprint(x) sane_istest(x,GIT_PRINT)
342#define is_glob_special(x) sane_istest(x,GIT_GLOB_SPECIAL)
343#define is_regex_special(x) sane_istest(x,GIT_GLOB_SPECIAL | GIT_REGEX_SPECIAL)
344#define tolower(x) sane_case((unsigned char)(x), 0x20) 226#define tolower(x) sane_case((unsigned char)(x), 0x20)
345#define toupper(x) sane_case((unsigned char)(x), 0) 227#define toupper(x) sane_case((unsigned char)(x), 0)
346 228
@@ -351,38 +233,6 @@ static inline int sane_case(int x, int high)
351 return x; 233 return x;
352} 234}
353 235
354static inline int strtoul_ui(char const *s, int base, unsigned int *result)
355{
356 unsigned long ul;
357 char *p;
358
359 errno = 0;
360 ul = strtoul(s, &p, base);
361 if (errno || *p || p == s || (unsigned int) ul != ul)
362 return -1;
363 *result = ul;
364 return 0;
365}
366
367static inline int strtol_i(char const *s, int base, int *result)
368{
369 long ul;
370 char *p;
371
372 errno = 0;
373 ul = strtol(s, &p, base);
374 if (errno || *p || p == s || (int) ul != ul)
375 return -1;
376 *result = ul;
377 return 0;
378}
379
380#ifdef INTERNAL_QSORT
381void git_qsort(void *base, size_t nmemb, size_t size,
382 int(*compar)(const void *, const void *));
383#define qsort git_qsort
384#endif
385
386#ifndef DIR_HAS_BSD_GROUP_SEMANTICS 236#ifndef DIR_HAS_BSD_GROUP_SEMANTICS
387# define FORCE_DIR_SET_GID S_ISGID 237# define FORCE_DIR_SET_GID S_ISGID
388#else 238#else
@@ -406,4 +256,27 @@ void git_qsort(void *base, size_t nmemb, size_t size,
406int mkdir_p(char *path, mode_t mode); 256int mkdir_p(char *path, mode_t mode);
407int copyfile(const char *from, const char *to); 257int copyfile(const char *from, const char *to);
408 258
259s64 perf_atoll(const char *str);
260char **argv_split(const char *str, int *argcp);
261void argv_free(char **argv);
262bool strglobmatch(const char *str, const char *pat);
263bool strlazymatch(const char *str, const char *pat);
264unsigned long convert_unit(unsigned long value, char *unit);
265
266#ifndef ESC
267#define ESC 27
268#endif
269
270static inline bool is_exit_key(int key)
271{
272 char up;
273 if (key == CTRL('c') || key == ESC)
274 return true;
275 up = toupper(key);
276 return up == 'Q';
277}
278
279#define _STR(x) #x
280#define STR(x) _STR(x)
281
409#endif 282#endif
diff --git a/tools/perf/util/wrapper.c b/tools/perf/util/wrapper.c
index bf44ca85d23..73e900edb5a 100644
--- a/tools/perf/util/wrapper.c
+++ b/tools/perf/util/wrapper.c
@@ -23,46 +23,6 @@ char *xstrdup(const char *str)
23 return ret; 23 return ret;
24} 24}
25 25
26void *xmalloc(size_t size)
27{
28 void *ret = malloc(size);
29 if (!ret && !size)
30 ret = malloc(1);
31 if (!ret) {
32 release_pack_memory(size, -1);
33 ret = malloc(size);
34 if (!ret && !size)
35 ret = malloc(1);
36 if (!ret)
37 die("Out of memory, malloc failed");
38 }
39#ifdef XMALLOC_POISON
40 memset(ret, 0xA5, size);
41#endif
42 return ret;
43}
44
45/*
46 * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
47 * "data" to the allocated memory, zero terminates the allocated memory,
48 * and returns a pointer to the allocated memory. If the allocation fails,
49 * the program dies.
50 */
51void *xmemdupz(const void *data, size_t len)
52{
53 char *p = xmalloc(len + 1);
54 memcpy(p, data, len);
55 p[len] = '\0';
56 return p;
57}
58
59char *xstrndup(const char *str, size_t len)
60{
61 char *p = memchr(str, '\0', len);
62
63 return xmemdupz(str, p ? (size_t)(p - str) : len);
64}
65
66void *xrealloc(void *ptr, size_t size) 26void *xrealloc(void *ptr, size_t size)
67{ 27{
68 void *ret = realloc(ptr, size); 28 void *ret = realloc(ptr, size);
@@ -78,73 +38,3 @@ void *xrealloc(void *ptr, size_t size)
78 } 38 }
79 return ret; 39 return ret;
80} 40}
81
82/*
83 * xread() is the same a read(), but it automatically restarts read()
84 * operations with a recoverable error (EAGAIN and EINTR). xread()
85 * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
86 */
87static ssize_t xread(int fd, void *buf, size_t len)
88{
89 ssize_t nr;
90 while (1) {
91 nr = read(fd, buf, len);
92 if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
93 continue;
94 return nr;
95 }
96}
97
98/*
99 * xwrite() is the same a write(), but it automatically restarts write()
100 * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
101 * GUARANTEE that "len" bytes is written even if the operation is successful.
102 */
103static ssize_t xwrite(int fd, const void *buf, size_t len)
104{
105 ssize_t nr;
106 while (1) {
107 nr = write(fd, buf, len);
108 if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
109 continue;
110 return nr;
111 }
112}
113
114ssize_t read_in_full(int fd, void *buf, size_t count)
115{
116 char *p = buf;
117 ssize_t total = 0;
118
119 while (count > 0) {
120 ssize_t loaded = xread(fd, p, count);
121 if (loaded <= 0)
122 return total ? total : loaded;
123 count -= loaded;
124 p += loaded;
125 total += loaded;
126 }
127
128 return total;
129}
130
131ssize_t write_in_full(int fd, const void *buf, size_t count)
132{
133 const char *p = buf;
134 ssize_t total = 0;
135
136 while (count > 0) {
137 ssize_t written = xwrite(fd, p, count);
138 if (written < 0)
139 return -1;
140 if (!written) {
141 errno = ENOSPC;
142 return -1;
143 }
144 count -= written;
145 p += written;
146 total += written;
147 }
148
149 return total;
150}
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-26 11:59:26 -0500