Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 1 | #ifndef __PERF_CALLCHAIN_H |
| 2 | #define __PERF_CALLCHAIN_H |
| 3 | |
| 4 | #include "../perf.h" |
Arnaldo Carvalho de Melo | 5da5025 | 2009-07-01 14:46:08 -0300 | [diff] [blame] | 5 | #include <linux/list.h> |
Arnaldo Carvalho de Melo | 43cbcd8 | 2009-07-01 12:28:37 -0300 | [diff] [blame] | 6 | #include <linux/rbtree.h> |
Arnaldo Carvalho de Melo | 139633c | 2010-05-09 11:47:13 -0300 | [diff] [blame] | 7 | #include "event.h" |
Frederic Weisbecker | 4424961 | 2009-07-01 05:35:14 +0200 | [diff] [blame] | 8 | #include "symbol.h" |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 9 | |
Namhyung Kim | 76a2654 | 2015-10-22 23:28:32 +0900 | [diff] [blame] | 10 | #define HELP_PAD "\t\t\t\t" |
| 11 | |
| 12 | #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace):\n\n" |
Namhyung Kim | 21cf628 | 2015-10-22 15:28:48 +0900 | [diff] [blame] | 13 | |
| 14 | #ifdef HAVE_DWARF_UNWIND_SUPPORT |
Namhyung Kim | 76a2654 | 2015-10-22 23:28:32 +0900 | [diff] [blame] | 15 | # define RECORD_MODE_HELP HELP_PAD "record_mode:\tcall graph recording mode (fp|dwarf|lbr)\n" |
Namhyung Kim | 21cf628 | 2015-10-22 15:28:48 +0900 | [diff] [blame] | 16 | #else |
Namhyung Kim | 76a2654 | 2015-10-22 23:28:32 +0900 | [diff] [blame] | 17 | # define RECORD_MODE_HELP HELP_PAD "record_mode:\tcall graph recording mode (fp|lbr)\n" |
Namhyung Kim | 21cf628 | 2015-10-22 15:28:48 +0900 | [diff] [blame] | 18 | #endif |
| 19 | |
Namhyung Kim | 76a2654 | 2015-10-22 23:28:32 +0900 | [diff] [blame] | 20 | #define RECORD_SIZE_HELP \ |
| 21 | HELP_PAD "record_size:\tif record_mode is 'dwarf', max size of stack recording (<bytes>)\n" \ |
| 22 | HELP_PAD "\t\tdefault: 8192 (bytes)\n" |
| 23 | |
| 24 | #define CALLCHAIN_RECORD_HELP CALLCHAIN_HELP RECORD_MODE_HELP RECORD_SIZE_HELP |
| 25 | |
| 26 | #define CALLCHAIN_REPORT_HELP \ |
Namhyung Kim | 26e7792 | 2015-11-09 14:45:37 +0900 | [diff] [blame] | 27 | HELP_PAD "print_type:\tcall graph printing style (graph|flat|fractal|folded|none)\n" \ |
Namhyung Kim | 76a2654 | 2015-10-22 23:28:32 +0900 | [diff] [blame] | 28 | HELP_PAD "threshold:\tminimum call graph inclusion threshold (<percent>)\n" \ |
| 29 | HELP_PAD "print_limit:\tmaximum number of call graph entry (<number>)\n" \ |
| 30 | HELP_PAD "order:\t\tcall graph order (caller|callee)\n" \ |
| 31 | HELP_PAD "sort_key:\tcall graph sort key (function|address)\n" \ |
Namhyung Kim | f2af008 | 2015-11-09 14:45:41 +0900 | [diff] [blame] | 32 | HELP_PAD "branch:\t\tinclude last branch info to call graph (branch)\n" \ |
| 33 | HELP_PAD "value:\t\tcall graph value (percent|period|count)\n" |
Namhyung Kim | 21cf628 | 2015-10-22 15:28:48 +0900 | [diff] [blame] | 34 | |
Jiri Olsa | 2c83bc0 | 2014-05-05 12:46:17 +0200 | [diff] [blame] | 35 | enum perf_call_graph_mode { |
| 36 | CALLCHAIN_NONE, |
| 37 | CALLCHAIN_FP, |
| 38 | CALLCHAIN_DWARF, |
Kan Liang | aad2b21 | 2015-01-05 13:23:04 -0500 | [diff] [blame] | 39 | CALLCHAIN_LBR, |
Jiri Olsa | 2c83bc0 | 2014-05-05 12:46:17 +0200 | [diff] [blame] | 40 | CALLCHAIN_MAX |
| 41 | }; |
| 42 | |
Frederic Weisbecker | 4eb3e47 | 2009-07-02 17:58:21 +0200 | [diff] [blame] | 43 | enum chain_mode { |
Frederic Weisbecker | b1a8834 | 2009-08-08 02:16:24 +0200 | [diff] [blame] | 44 | CHAIN_NONE, |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 45 | CHAIN_FLAT, |
| 46 | CHAIN_GRAPH_ABS, |
Namhyung Kim | 26e7792 | 2015-11-09 14:45:37 +0900 | [diff] [blame] | 47 | CHAIN_GRAPH_REL, |
| 48 | CHAIN_FOLDED, |
Frederic Weisbecker | 4eb3e47 | 2009-07-02 17:58:21 +0200 | [diff] [blame] | 49 | }; |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 50 | |
Sam Liao | d797fdc | 2011-06-07 23:49:46 +0800 | [diff] [blame] | 51 | enum chain_order { |
| 52 | ORDER_CALLER, |
| 53 | ORDER_CALLEE |
| 54 | }; |
| 55 | |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 56 | struct callchain_node { |
| 57 | struct callchain_node *parent; |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 58 | struct list_head val; |
Namhyung Kim | 4b3a321 | 2015-11-09 14:45:43 +0900 | [diff] [blame] | 59 | struct list_head parent_val; |
Namhyung Kim | e369517 | 2013-10-11 14:15:36 +0900 | [diff] [blame] | 60 | struct rb_node rb_node_in; /* to insert nodes in an rbtree */ |
| 61 | struct rb_node rb_node; /* to sort nodes in an output tree */ |
| 62 | struct rb_root rb_root_in; /* input tree of children */ |
| 63 | struct rb_root rb_root; /* sorted output tree of children */ |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 64 | unsigned int val_nr; |
Namhyung Kim | 5e47f8f | 2015-11-09 14:45:40 +0900 | [diff] [blame] | 65 | unsigned int count; |
| 66 | unsigned int children_count; |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 67 | u64 hit; |
Frederic Weisbecker | 1953287 | 2009-08-07 07:11:05 +0200 | [diff] [blame] | 68 | u64 children_hit; |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 69 | }; |
| 70 | |
Frederic Weisbecker | d2009c5 | 2010-08-22 20:05:22 +0200 | [diff] [blame] | 71 | struct callchain_root { |
| 72 | u64 max_depth; |
| 73 | struct callchain_node node; |
| 74 | }; |
| 75 | |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 76 | struct callchain_param; |
| 77 | |
Frederic Weisbecker | d2009c5 | 2010-08-22 20:05:22 +0200 | [diff] [blame] | 78 | typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_root *, |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 79 | u64, struct callchain_param *); |
| 80 | |
Andi Kleen | 99571ab | 2013-07-18 15:33:57 -0700 | [diff] [blame] | 81 | enum chain_key { |
| 82 | CCKEY_FUNCTION, |
| 83 | CCKEY_ADDRESS |
| 84 | }; |
| 85 | |
Namhyung Kim | f2af008 | 2015-11-09 14:45:41 +0900 | [diff] [blame] | 86 | enum chain_value { |
| 87 | CCVAL_PERCENT, |
| 88 | CCVAL_PERIOD, |
| 89 | CCVAL_COUNT, |
| 90 | }; |
| 91 | |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 92 | struct callchain_param { |
Namhyung Kim | 72a128a | 2014-09-23 10:01:41 +0900 | [diff] [blame] | 93 | bool enabled; |
| 94 | enum perf_call_graph_mode record_mode; |
| 95 | u32 dump_size; |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 96 | enum chain_mode mode; |
Arnaldo Carvalho de Melo | 792d48b | 2016-04-28 19:03:42 -0300 | [diff] [blame] | 97 | u16 max_stack; |
Arnaldo Carvalho de Melo | 232a5c9 | 2010-05-09 20:28:10 -0300 | [diff] [blame] | 98 | u32 print_limit; |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 99 | double min_percent; |
| 100 | sort_chain_func_t sort; |
Sam Liao | d797fdc | 2011-06-07 23:49:46 +0800 | [diff] [blame] | 101 | enum chain_order order; |
Namhyung Kim | 792aeaf | 2015-10-22 16:45:46 +0900 | [diff] [blame] | 102 | bool order_set; |
Andi Kleen | 99571ab | 2013-07-18 15:33:57 -0700 | [diff] [blame] | 103 | enum chain_key key; |
Andi Kleen | 8b7bad5 | 2014-11-12 18:05:20 -0800 | [diff] [blame] | 104 | bool branch_callstack; |
Namhyung Kim | f2af008 | 2015-11-09 14:45:41 +0900 | [diff] [blame] | 105 | enum chain_value value; |
Frederic Weisbecker | 805d127 | 2009-07-05 07:39:21 +0200 | [diff] [blame] | 106 | }; |
| 107 | |
Arnaldo Carvalho de Melo | 8f651ea | 2014-10-09 16:12:24 -0300 | [diff] [blame] | 108 | extern struct callchain_param callchain_param; |
Jiri Olsa | 347ca87 | 2016-07-04 14:16:21 +0200 | [diff] [blame] | 109 | extern struct callchain_param callchain_param_default; |
Arnaldo Carvalho de Melo | 8f651ea | 2014-10-09 16:12:24 -0300 | [diff] [blame] | 110 | |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 111 | struct callchain_list { |
Ingo Molnar | f37a291 | 2009-07-01 12:37:06 +0200 | [diff] [blame] | 112 | u64 ip; |
Arnaldo Carvalho de Melo | b3c9ac0 | 2010-03-24 16:40:18 -0300 | [diff] [blame] | 113 | struct map_symbol ms; |
Namhyung Kim | 3698dab | 2015-05-05 23:55:46 +0900 | [diff] [blame] | 114 | struct /* for TUI */ { |
| 115 | bool unfolded; |
| 116 | bool has_children; |
| 117 | }; |
Andi Kleen | 23f0981 | 2014-11-12 18:05:24 -0800 | [diff] [blame] | 118 | char *srcline; |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 119 | struct list_head list; |
| 120 | }; |
| 121 | |
Frederic Weisbecker | 1b3a0e9 | 2011-01-14 04:51:58 +0100 | [diff] [blame] | 122 | /* |
| 123 | * A callchain cursor is a single linked list that |
| 124 | * let one feed a callchain progressively. |
Masanari Iida | 3fd44cd | 2012-07-18 01:20:59 +0900 | [diff] [blame] | 125 | * It keeps persistent allocated entries to minimize |
Frederic Weisbecker | 1b3a0e9 | 2011-01-14 04:51:58 +0100 | [diff] [blame] | 126 | * allocations. |
| 127 | */ |
| 128 | struct callchain_cursor_node { |
| 129 | u64 ip; |
| 130 | struct map *map; |
| 131 | struct symbol *sym; |
| 132 | struct callchain_cursor_node *next; |
| 133 | }; |
| 134 | |
| 135 | struct callchain_cursor { |
| 136 | u64 nr; |
| 137 | struct callchain_cursor_node *first; |
| 138 | struct callchain_cursor_node **last; |
| 139 | u64 pos; |
| 140 | struct callchain_cursor_node *curr; |
| 141 | }; |
| 142 | |
Namhyung Kim | 4726064 | 2012-05-31 14:43:26 +0900 | [diff] [blame] | 143 | extern __thread struct callchain_cursor callchain_cursor; |
| 144 | |
Frederic Weisbecker | d2009c5 | 2010-08-22 20:05:22 +0200 | [diff] [blame] | 145 | static inline void callchain_init(struct callchain_root *root) |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 146 | { |
Frederic Weisbecker | d2009c5 | 2010-08-22 20:05:22 +0200 | [diff] [blame] | 147 | INIT_LIST_HEAD(&root->node.val); |
Jiri Olsa | 646a6e8 | 2015-11-21 11:23:55 +0100 | [diff] [blame] | 148 | INIT_LIST_HEAD(&root->node.parent_val); |
Frederic Weisbecker | 97aa105 | 2010-07-08 06:06:17 +0200 | [diff] [blame] | 149 | |
Frederic Weisbecker | d2009c5 | 2010-08-22 20:05:22 +0200 | [diff] [blame] | 150 | root->node.parent = NULL; |
| 151 | root->node.hit = 0; |
Frederic Weisbecker | 98ee74a | 2010-08-27 02:28:40 +0200 | [diff] [blame] | 152 | root->node.children_hit = 0; |
Namhyung Kim | e369517 | 2013-10-11 14:15:36 +0900 | [diff] [blame] | 153 | root->node.rb_root_in = RB_ROOT; |
Frederic Weisbecker | d2009c5 | 2010-08-22 20:05:22 +0200 | [diff] [blame] | 154 | root->max_depth = 0; |
Frederic Weisbecker | 8cb76d9 | 2009-06-26 16:28:00 +0200 | [diff] [blame] | 155 | } |
| 156 | |
Frederic Weisbecker | f08c315 | 2011-01-14 04:51:59 +0100 | [diff] [blame] | 157 | static inline u64 callchain_cumul_hits(struct callchain_node *node) |
Frederic Weisbecker | 1953287 | 2009-08-07 07:11:05 +0200 | [diff] [blame] | 158 | { |
| 159 | return node->hit + node->children_hit; |
| 160 | } |
| 161 | |
Namhyung Kim | 5e47f8f | 2015-11-09 14:45:40 +0900 | [diff] [blame] | 162 | static inline unsigned callchain_cumul_counts(struct callchain_node *node) |
| 163 | { |
| 164 | return node->count + node->children_count; |
| 165 | } |
| 166 | |
Frederic Weisbecker | 16537f1 | 2011-01-14 04:52:00 +0100 | [diff] [blame] | 167 | int callchain_register_param(struct callchain_param *param); |
Frederic Weisbecker | 1b3a0e9 | 2011-01-14 04:51:58 +0100 | [diff] [blame] | 168 | int callchain_append(struct callchain_root *root, |
| 169 | struct callchain_cursor *cursor, |
| 170 | u64 period); |
| 171 | |
| 172 | int callchain_merge(struct callchain_cursor *cursor, |
| 173 | struct callchain_root *dst, struct callchain_root *src); |
Arnaldo Carvalho de Melo | 139633c | 2010-05-09 11:47:13 -0300 | [diff] [blame] | 174 | |
Frederic Weisbecker | 1b3a0e9 | 2011-01-14 04:51:58 +0100 | [diff] [blame] | 175 | /* |
| 176 | * Initialize a cursor before adding entries inside, but keep |
| 177 | * the previously allocated entries as a cache. |
| 178 | */ |
| 179 | static inline void callchain_cursor_reset(struct callchain_cursor *cursor) |
| 180 | { |
| 181 | cursor->nr = 0; |
| 182 | cursor->last = &cursor->first; |
| 183 | } |
| 184 | |
| 185 | int callchain_cursor_append(struct callchain_cursor *cursor, u64 ip, |
| 186 | struct map *map, struct symbol *sym); |
| 187 | |
| 188 | /* Close a cursor writing session. Initialize for the reader */ |
| 189 | static inline void callchain_cursor_commit(struct callchain_cursor *cursor) |
| 190 | { |
| 191 | cursor->curr = cursor->first; |
| 192 | cursor->pos = 0; |
| 193 | } |
| 194 | |
| 195 | /* Cursor reading iteration helpers */ |
| 196 | static inline struct callchain_cursor_node * |
| 197 | callchain_cursor_current(struct callchain_cursor *cursor) |
| 198 | { |
| 199 | if (cursor->pos == cursor->nr) |
| 200 | return NULL; |
| 201 | |
| 202 | return cursor->curr; |
| 203 | } |
| 204 | |
| 205 | static inline void callchain_cursor_advance(struct callchain_cursor *cursor) |
| 206 | { |
| 207 | cursor->curr = cursor->curr->next; |
| 208 | cursor->pos++; |
| 209 | } |
Arnaldo Carvalho de Melo | 75d9a108 | 2012-12-11 16:46:05 -0300 | [diff] [blame] | 210 | |
| 211 | struct option; |
Namhyung Kim | 2dc9fb1 | 2014-01-14 14:25:35 +0900 | [diff] [blame] | 212 | struct hist_entry; |
Arnaldo Carvalho de Melo | 75d9a108 | 2012-12-11 16:46:05 -0300 | [diff] [blame] | 213 | |
| 214 | int record_parse_callchain_opt(const struct option *opt, const char *arg, int unset); |
Jiri Olsa | 09b0fd4 | 2013-10-26 16:25:33 +0200 | [diff] [blame] | 215 | int record_callchain_opt(const struct option *opt, const char *arg, int unset); |
| 216 | |
Arnaldo Carvalho de Melo | 0883e82 | 2016-04-15 16:37:17 -0300 | [diff] [blame] | 217 | struct record_opts; |
| 218 | |
| 219 | int record_opts__parse_callchain(struct record_opts *record, |
| 220 | struct callchain_param *callchain, |
| 221 | const char *arg, bool unset); |
| 222 | |
Arnaldo Carvalho de Melo | 91d7b2d | 2016-04-14 14:48:07 -0300 | [diff] [blame] | 223 | int sample__resolve_callchain(struct perf_sample *sample, |
| 224 | struct callchain_cursor *cursor, struct symbol **parent, |
Namhyung Kim | 2dc9fb1 | 2014-01-14 14:25:35 +0900 | [diff] [blame] | 225 | struct perf_evsel *evsel, struct addr_location *al, |
| 226 | int max_stack); |
| 227 | int hist_entry__append_callchain(struct hist_entry *he, struct perf_sample *sample); |
Namhyung Kim | c7405d8 | 2013-10-31 13:58:30 +0900 | [diff] [blame] | 228 | int fill_callchain_info(struct addr_location *al, struct callchain_cursor_node *node, |
| 229 | bool hide_unresolved); |
Namhyung Kim | 2dc9fb1 | 2014-01-14 14:25:35 +0900 | [diff] [blame] | 230 | |
Arnaldo Carvalho de Melo | 75d9a108 | 2012-12-11 16:46:05 -0300 | [diff] [blame] | 231 | extern const char record_callchain_help[]; |
Arnaldo Carvalho de Melo | 3938bad | 2016-03-23 15:06:35 -0300 | [diff] [blame] | 232 | int parse_callchain_record(const char *arg, struct callchain_param *param); |
Kan Liang | c3a6a8c | 2015-08-04 04:30:20 -0400 | [diff] [blame] | 233 | int parse_callchain_record_opt(const char *arg, struct callchain_param *param); |
Don Zickus | cff6bb4 | 2014-04-07 14:55:24 -0400 | [diff] [blame] | 234 | int parse_callchain_report_opt(const char *arg); |
Namhyung Kim | a2c10d3 | 2015-10-22 15:28:49 +0900 | [diff] [blame] | 235 | int parse_callchain_top_opt(const char *arg); |
Namhyung Kim | 2b9240c | 2014-09-23 10:01:43 +0900 | [diff] [blame] | 236 | int perf_callchain_config(const char *var, const char *value); |
Namhyung Kim | be1f13e | 2012-09-10 13:38:00 +0900 | [diff] [blame] | 237 | |
| 238 | static inline void callchain_cursor_snapshot(struct callchain_cursor *dest, |
| 239 | struct callchain_cursor *src) |
| 240 | { |
| 241 | *dest = *src; |
| 242 | |
| 243 | dest->first = src->curr; |
| 244 | dest->nr -= src->pos; |
| 245 | } |
Sukadev Bhattiprolu | a60335b | 2014-06-25 08:49:03 -0700 | [diff] [blame] | 246 | |
| 247 | #ifdef HAVE_SKIP_CALLCHAIN_IDX |
Arnaldo Carvalho de Melo | 3938bad | 2016-03-23 15:06:35 -0300 | [diff] [blame] | 248 | int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain); |
Sukadev Bhattiprolu | a60335b | 2014-06-25 08:49:03 -0700 | [diff] [blame] | 249 | #else |
Arnaldo Carvalho de Melo | bb871a9 | 2014-10-23 12:50:25 -0300 | [diff] [blame] | 250 | static inline int arch_skip_callchain_idx(struct thread *thread __maybe_unused, |
Sukadev Bhattiprolu | a60335b | 2014-06-25 08:49:03 -0700 | [diff] [blame] | 251 | struct ip_callchain *chain __maybe_unused) |
| 252 | { |
| 253 | return -1; |
| 254 | } |
| 255 | #endif |
| 256 | |
Andi Kleen | 2989cca | 2014-11-12 18:05:23 -0800 | [diff] [blame] | 257 | char *callchain_list__sym_name(struct callchain_list *cl, |
| 258 | char *bf, size_t bfsize, bool show_dso); |
Namhyung Kim | 5ab250c | 2015-11-09 14:45:39 +0900 | [diff] [blame] | 259 | char *callchain_node__scnprintf_value(struct callchain_node *node, |
| 260 | char *bf, size_t bfsize, u64 total); |
| 261 | int callchain_node__fprintf_value(struct callchain_node *node, |
| 262 | FILE *fp, u64 total); |
Andi Kleen | 2989cca | 2014-11-12 18:05:23 -0800 | [diff] [blame] | 263 | |
Namhyung Kim | d114960 | 2014-12-30 14:38:13 +0900 | [diff] [blame] | 264 | void free_callchain(struct callchain_root *root); |
Namhyung Kim | 42b276a | 2016-01-05 12:06:00 +0900 | [diff] [blame] | 265 | void decay_callchain(struct callchain_root *root); |
Namhyung Kim | 4b3a321 | 2015-11-09 14:45:43 +0900 | [diff] [blame] | 266 | int callchain_node__make_parent_list(struct callchain_node *node); |
Namhyung Kim | d114960 | 2014-12-30 14:38:13 +0900 | [diff] [blame] | 267 | |
John Kacur | 8b40f52 | 2009-09-24 18:02:18 +0200 | [diff] [blame] | 268 | #endif /* __PERF_CALLCHAIN_H */ |