LXR linux/tools/perf/util/callchain.h

   1#ifndef __PERF_CALLCHAIN_H
   2#define __PERF_CALLCHAIN_H
   3
   4#include "../perf.h"
   5#include <linux/list.h>
   6#include <linux/rbtree.h>
   7#include "event.h"
   8#include "symbol.h"
   9
  10enum chain_mode {
  11        CHAIN_NONE,
  12        CHAIN_FLAT,
  13        CHAIN_GRAPH_ABS,
  14        CHAIN_GRAPH_REL
  15};
  16
  17enum chain_order {
  18        ORDER_CALLER,
  19        ORDER_CALLEE
  20};
  21
  22struct callchain_node {
  23        struct callchain_node   *parent;
  24        struct list_head        siblings;
  25        struct list_head        children;
  26        struct list_head        val;
  27        struct rb_node          rb_node; /* to sort nodes in an rbtree */
  28        struct rb_root          rb_root; /* sorted tree of children */
  29        unsigned int            val_nr;
  30        u64                     hit;
  31        u64                     children_hit;
  32};
  33
  34struct callchain_root {
  35        u64                     max_depth;
  36        struct callchain_node   node;
  37};
  38
  39struct callchain_param;
  40
  41typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_root *,
  42                                 u64, struct callchain_param *);
  43
  44struct callchain_param {
  45        enum chain_mode         mode;
  46        u32                     print_limit;
  47        double                  min_percent;
  48        sort_chain_func_t       sort;
  49        enum chain_order        order;
  50};
  51
  52struct callchain_list {
  53        u64                     ip;
  54        struct map_symbol       ms;
  55        struct list_head        list;
  56};
  57
  58/*
  59 * A callchain cursor is a single linked list that
  60 * let one feed a callchain progressively.
  61 * It keeps persitent allocated entries to minimize
  62 * allocations.
  63 */
  64struct callchain_cursor_node {
  65        u64                             ip;
  66        struct map                      *map;
  67        struct symbol                   *sym;
  68        struct callchain_cursor_node    *next;
  69};
  70
  71struct callchain_cursor {
  72        u64                             nr;
  73        struct callchain_cursor_node    *first;
  74        struct callchain_cursor_node    **last;
  75        u64                             pos;
  76        struct callchain_cursor_node    *curr;
  77};
  78
  79static inline void callchain_init(struct callchain_root *root)
  80{
  81        INIT_LIST_HEAD(&root->node.siblings);
  82        INIT_LIST_HEAD(&root->node.children);
  83        INIT_LIST_HEAD(&root->node.val);
  84
  85        root->node.parent = NULL;
  86        root->node.hit = 0;
  87        root->node.children_hit = 0;
  88        root->max_depth = 0;
  89}
  90
  91static inline u64 callchain_cumul_hits(struct callchain_node *node)
  92{
  93        return node->hit + node->children_hit;
  94}
  95
  96int callchain_register_param(struct callchain_param *param);
  97int callchain_append(struct callchain_root *root,
  98                     struct callchain_cursor *cursor,
  99                     u64 period);
 100
 101int callchain_merge(struct callchain_cursor *cursor,
 102                    struct callchain_root *dst, struct callchain_root *src);
 103
 104struct ip_callchain;
 105union perf_event;
 106
 107bool ip_callchain__valid(struct ip_callchain *chain,
 108                         const union perf_event *event);
 109/*
 110 * Initialize a cursor before adding entries inside, but keep
 111 * the previously allocated entries as a cache.
 112 */
 113static inline void callchain_cursor_reset(struct callchain_cursor *cursor)
 114{
 115        cursor->nr = 0;
 116        cursor->last = &cursor->first;
 117}
 118
 119int callchain_cursor_append(struct callchain_cursor *cursor, u64 ip,
 120                            struct map *map, struct symbol *sym);
 121
 122/* Close a cursor writing session. Initialize for the reader */
 123static inline void callchain_cursor_commit(struct callchain_cursor *cursor)
 124{
 125        cursor->curr = cursor->first;
 126        cursor->pos = 0;
 127}
 128
 129/* Cursor reading iteration helpers */
 130static inline struct callchain_cursor_node *
 131callchain_cursor_current(struct callchain_cursor *cursor)
 132{
 133        if (cursor->pos == cursor->nr)
 134                return NULL;
 135
 136        return cursor->curr;
 137}
 138
 139static inline void callchain_cursor_advance(struct callchain_cursor *cursor)
 140{
 141        cursor->curr = cursor->curr->next;
 142        cursor->pos++;
 143}
 144#endif  /* __PERF_CALLCHAIN_H */
 145