10f70d8e9SYang Jihong // SPDX-License-Identifier: GPL-2.0 20f70d8e9SYang Jihong /* 30f70d8e9SYang Jihong * builtin-kwork.c 40f70d8e9SYang Jihong * 50f70d8e9SYang Jihong * Copyright (c) 2022 Huawei Inc, Yang Jihong <yangjihong1@huawei.com> 60f70d8e9SYang Jihong */ 70f70d8e9SYang Jihong 80f70d8e9SYang Jihong #include "builtin.h" 90f70d8e9SYang Jihong 100f70d8e9SYang Jihong #include "util/data.h" 11628d6999SArnaldo Carvalho de Melo #include "util/evlist.h" 12628d6999SArnaldo Carvalho de Melo #include "util/evsel.h" 13628d6999SArnaldo Carvalho de Melo #include "util/header.h" 140f70d8e9SYang Jihong #include "util/kwork.h" 150f70d8e9SYang Jihong #include "util/debug.h" 16628d6999SArnaldo Carvalho de Melo #include "util/session.h" 170f70d8e9SYang Jihong #include "util/symbol.h" 180f70d8e9SYang Jihong #include "util/thread.h" 190f70d8e9SYang Jihong #include "util/string2.h" 200f70d8e9SYang Jihong #include "util/callchain.h" 210f70d8e9SYang Jihong #include "util/evsel_fprintf.h" 22f12ad272SIan Rogers #include "util/util.h" 230f70d8e9SYang Jihong 240f70d8e9SYang Jihong #include <subcmd/pager.h> 250f70d8e9SYang Jihong #include <subcmd/parse-options.h> 26378ef0f5SIan Rogers #include <traceevent/event-parse.h> 270f70d8e9SYang Jihong 280f70d8e9SYang Jihong #include <errno.h> 290f70d8e9SYang Jihong #include <inttypes.h> 30628d6999SArnaldo Carvalho de Melo #include <signal.h> 310f70d8e9SYang Jihong #include <linux/err.h> 320f70d8e9SYang Jihong #include <linux/time64.h> 330f70d8e9SYang Jihong #include <linux/zalloc.h> 340f70d8e9SYang Jihong 35f98919ecSYang Jihong /* 36f98919ecSYang Jihong * report header elements width 37f98919ecSYang Jihong */ 38f98919ecSYang Jihong #define PRINT_CPU_WIDTH 4 39f98919ecSYang Jihong #define PRINT_COUNT_WIDTH 9 40f98919ecSYang Jihong #define PRINT_RUNTIME_WIDTH 10 41ad3d9f7aSYang Jihong #define PRINT_LATENCY_WIDTH 10 42f98919ecSYang Jihong #define PRINT_TIMESTAMP_WIDTH 17 43f98919ecSYang Jihong #define PRINT_KWORK_NAME_WIDTH 30 44f98919ecSYang Jihong #define RPINT_DECIMAL_WIDTH 3 45bcc8b3e8SYang Jihong #define PRINT_BRACKETPAIR_WIDTH 2 46f98919ecSYang Jihong #define PRINT_TIME_UNIT_SEC_WIDTH 2 47f98919ecSYang Jihong #define PRINT_TIME_UNIT_MESC_WIDTH 3 48f98919ecSYang Jihong #define PRINT_RUNTIME_HEADER_WIDTH (PRINT_RUNTIME_WIDTH + PRINT_TIME_UNIT_MESC_WIDTH) 49ad3d9f7aSYang Jihong #define PRINT_LATENCY_HEADER_WIDTH (PRINT_LATENCY_WIDTH + PRINT_TIME_UNIT_MESC_WIDTH) 50bcc8b3e8SYang Jihong #define PRINT_TIMEHIST_CPU_WIDTH (PRINT_CPU_WIDTH + PRINT_BRACKETPAIR_WIDTH) 51f98919ecSYang Jihong #define PRINT_TIMESTAMP_HEADER_WIDTH (PRINT_TIMESTAMP_WIDTH + PRINT_TIME_UNIT_SEC_WIDTH) 52f98919ecSYang Jihong 53f98919ecSYang Jihong struct sort_dimension { 54f98919ecSYang Jihong const char *name; 55f98919ecSYang Jihong int (*cmp)(struct kwork_work *l, struct kwork_work *r); 56f98919ecSYang Jihong struct list_head list; 57f98919ecSYang Jihong }; 58f98919ecSYang Jihong 59f98919ecSYang Jihong static int id_cmp(struct kwork_work *l, struct kwork_work *r) 60f98919ecSYang Jihong { 61f98919ecSYang Jihong if (l->cpu > r->cpu) 62f98919ecSYang Jihong return 1; 63f98919ecSYang Jihong if (l->cpu < r->cpu) 64f98919ecSYang Jihong return -1; 65f98919ecSYang Jihong 66f98919ecSYang Jihong if (l->id > r->id) 67f98919ecSYang Jihong return 1; 68f98919ecSYang Jihong if (l->id < r->id) 69f98919ecSYang Jihong return -1; 70f98919ecSYang Jihong 71f98919ecSYang Jihong return 0; 72f98919ecSYang Jihong } 73f98919ecSYang Jihong 74f98919ecSYang Jihong static int count_cmp(struct kwork_work *l, struct kwork_work *r) 75f98919ecSYang Jihong { 76f98919ecSYang Jihong if (l->nr_atoms > r->nr_atoms) 77f98919ecSYang Jihong return 1; 78f98919ecSYang Jihong if (l->nr_atoms < r->nr_atoms) 79f98919ecSYang Jihong return -1; 80f98919ecSYang Jihong 81f98919ecSYang Jihong return 0; 82f98919ecSYang Jihong } 83f98919ecSYang Jihong 84f98919ecSYang Jihong static int runtime_cmp(struct kwork_work *l, struct kwork_work *r) 85f98919ecSYang Jihong { 86f98919ecSYang Jihong if (l->total_runtime > r->total_runtime) 87f98919ecSYang Jihong return 1; 88f98919ecSYang Jihong if (l->total_runtime < r->total_runtime) 89f98919ecSYang Jihong return -1; 90f98919ecSYang Jihong 91f98919ecSYang Jihong return 0; 92f98919ecSYang Jihong } 93f98919ecSYang Jihong 94f98919ecSYang Jihong static int max_runtime_cmp(struct kwork_work *l, struct kwork_work *r) 95f98919ecSYang Jihong { 96f98919ecSYang Jihong if (l->max_runtime > r->max_runtime) 97f98919ecSYang Jihong return 1; 98f98919ecSYang Jihong if (l->max_runtime < r->max_runtime) 99f98919ecSYang Jihong return -1; 100f98919ecSYang Jihong 101f98919ecSYang Jihong return 0; 102f98919ecSYang Jihong } 103f98919ecSYang Jihong 104ad3d9f7aSYang Jihong static int avg_latency_cmp(struct kwork_work *l, struct kwork_work *r) 105ad3d9f7aSYang Jihong { 106ad3d9f7aSYang Jihong u64 avgl, avgr; 107ad3d9f7aSYang Jihong 108ad3d9f7aSYang Jihong if (!r->nr_atoms) 109ad3d9f7aSYang Jihong return 1; 110ad3d9f7aSYang Jihong if (!l->nr_atoms) 111ad3d9f7aSYang Jihong return -1; 112ad3d9f7aSYang Jihong 113ad3d9f7aSYang Jihong avgl = l->total_latency / l->nr_atoms; 114ad3d9f7aSYang Jihong avgr = r->total_latency / r->nr_atoms; 115ad3d9f7aSYang Jihong 116ad3d9f7aSYang Jihong if (avgl > avgr) 117ad3d9f7aSYang Jihong return 1; 118ad3d9f7aSYang Jihong if (avgl < avgr) 119ad3d9f7aSYang Jihong return -1; 120ad3d9f7aSYang Jihong 121ad3d9f7aSYang Jihong return 0; 122ad3d9f7aSYang Jihong } 123ad3d9f7aSYang Jihong 124ad3d9f7aSYang Jihong static int max_latency_cmp(struct kwork_work *l, struct kwork_work *r) 125ad3d9f7aSYang Jihong { 126ad3d9f7aSYang Jihong if (l->max_latency > r->max_latency) 127ad3d9f7aSYang Jihong return 1; 128ad3d9f7aSYang Jihong if (l->max_latency < r->max_latency) 129ad3d9f7aSYang Jihong return -1; 130ad3d9f7aSYang Jihong 131ad3d9f7aSYang Jihong return 0; 132ad3d9f7aSYang Jihong } 133ad3d9f7aSYang Jihong 134f98919ecSYang Jihong static int sort_dimension__add(struct perf_kwork *kwork __maybe_unused, 135f98919ecSYang Jihong const char *tok, struct list_head *list) 136f98919ecSYang Jihong { 137f98919ecSYang Jihong size_t i; 138f98919ecSYang Jihong static struct sort_dimension max_sort_dimension = { 139f98919ecSYang Jihong .name = "max", 140f98919ecSYang Jihong .cmp = max_runtime_cmp, 141f98919ecSYang Jihong }; 142f98919ecSYang Jihong static struct sort_dimension id_sort_dimension = { 143f98919ecSYang Jihong .name = "id", 144f98919ecSYang Jihong .cmp = id_cmp, 145f98919ecSYang Jihong }; 146f98919ecSYang Jihong static struct sort_dimension runtime_sort_dimension = { 147f98919ecSYang Jihong .name = "runtime", 148f98919ecSYang Jihong .cmp = runtime_cmp, 149f98919ecSYang Jihong }; 150f98919ecSYang Jihong static struct sort_dimension count_sort_dimension = { 151f98919ecSYang Jihong .name = "count", 152f98919ecSYang Jihong .cmp = count_cmp, 153f98919ecSYang Jihong }; 154ad3d9f7aSYang Jihong static struct sort_dimension avg_sort_dimension = { 155ad3d9f7aSYang Jihong .name = "avg", 156ad3d9f7aSYang Jihong .cmp = avg_latency_cmp, 157ad3d9f7aSYang Jihong }; 158f98919ecSYang Jihong struct sort_dimension *available_sorts[] = { 159f98919ecSYang Jihong &id_sort_dimension, 160f98919ecSYang Jihong &max_sort_dimension, 161f98919ecSYang Jihong &count_sort_dimension, 162f98919ecSYang Jihong &runtime_sort_dimension, 163ad3d9f7aSYang Jihong &avg_sort_dimension, 164f98919ecSYang Jihong }; 165f98919ecSYang Jihong 166ad3d9f7aSYang Jihong if (kwork->report == KWORK_REPORT_LATENCY) 167ad3d9f7aSYang Jihong max_sort_dimension.cmp = max_latency_cmp; 168ad3d9f7aSYang Jihong 169f98919ecSYang Jihong for (i = 0; i < ARRAY_SIZE(available_sorts); i++) { 170f98919ecSYang Jihong if (!strcmp(available_sorts[i]->name, tok)) { 171f98919ecSYang Jihong list_add_tail(&available_sorts[i]->list, list); 172f98919ecSYang Jihong return 0; 173f98919ecSYang Jihong } 174f98919ecSYang Jihong } 175f98919ecSYang Jihong 176f98919ecSYang Jihong return -1; 177f98919ecSYang Jihong } 178f98919ecSYang Jihong 179f98919ecSYang Jihong static void setup_sorting(struct perf_kwork *kwork, 180f98919ecSYang Jihong const struct option *options, 181f98919ecSYang Jihong const char * const usage_msg[]) 182f98919ecSYang Jihong { 183f98919ecSYang Jihong char *tmp, *tok, *str = strdup(kwork->sort_order); 184f98919ecSYang Jihong 185f98919ecSYang Jihong for (tok = strtok_r(str, ", ", &tmp); 186f98919ecSYang Jihong tok; tok = strtok_r(NULL, ", ", &tmp)) { 187f98919ecSYang Jihong if (sort_dimension__add(kwork, tok, &kwork->sort_list) < 0) 188f98919ecSYang Jihong usage_with_options_msg(usage_msg, options, 189f98919ecSYang Jihong "Unknown --sort key: `%s'", tok); 190f98919ecSYang Jihong } 191f98919ecSYang Jihong 192f98919ecSYang Jihong pr_debug("Sort order: %s\n", kwork->sort_order); 193f98919ecSYang Jihong free(str); 194f98919ecSYang Jihong } 195f98919ecSYang Jihong 196f98919ecSYang Jihong static struct kwork_atom *atom_new(struct perf_kwork *kwork, 197f98919ecSYang Jihong struct perf_sample *sample) 198f98919ecSYang Jihong { 199f98919ecSYang Jihong unsigned long i; 200f98919ecSYang Jihong struct kwork_atom_page *page; 201f98919ecSYang Jihong struct kwork_atom *atom = NULL; 202f98919ecSYang Jihong 203f98919ecSYang Jihong list_for_each_entry(page, &kwork->atom_page_list, list) { 204f98919ecSYang Jihong if (!bitmap_full(page->bitmap, NR_ATOM_PER_PAGE)) { 205f98919ecSYang Jihong i = find_first_zero_bit(page->bitmap, NR_ATOM_PER_PAGE); 206f98919ecSYang Jihong BUG_ON(i >= NR_ATOM_PER_PAGE); 207f98919ecSYang Jihong atom = &page->atoms[i]; 208f98919ecSYang Jihong goto found_atom; 209f98919ecSYang Jihong } 210f98919ecSYang Jihong } 211f98919ecSYang Jihong 212f98919ecSYang Jihong /* 213f98919ecSYang Jihong * new page 214f98919ecSYang Jihong */ 215f98919ecSYang Jihong page = zalloc(sizeof(*page)); 216f98919ecSYang Jihong if (page == NULL) { 217f98919ecSYang Jihong pr_err("Failed to zalloc kwork atom page\n"); 218f98919ecSYang Jihong return NULL; 219f98919ecSYang Jihong } 220f98919ecSYang Jihong 221f98919ecSYang Jihong i = 0; 222f98919ecSYang Jihong atom = &page->atoms[0]; 223f98919ecSYang Jihong list_add_tail(&page->list, &kwork->atom_page_list); 224f98919ecSYang Jihong 225f98919ecSYang Jihong found_atom: 22649bd97c2SSean Christopherson __set_bit(i, page->bitmap); 227f98919ecSYang Jihong atom->time = sample->time; 228f98919ecSYang Jihong atom->prev = NULL; 229f98919ecSYang Jihong atom->page_addr = page; 230f98919ecSYang Jihong atom->bit_inpage = i; 231f98919ecSYang Jihong return atom; 232f98919ecSYang Jihong } 233f98919ecSYang Jihong 234f98919ecSYang Jihong static void atom_free(struct kwork_atom *atom) 235f98919ecSYang Jihong { 236f98919ecSYang Jihong if (atom->prev != NULL) 237f98919ecSYang Jihong atom_free(atom->prev); 238f98919ecSYang Jihong 23949bd97c2SSean Christopherson __clear_bit(atom->bit_inpage, 240f98919ecSYang Jihong ((struct kwork_atom_page *)atom->page_addr)->bitmap); 241f98919ecSYang Jihong } 242f98919ecSYang Jihong 243f98919ecSYang Jihong static void atom_del(struct kwork_atom *atom) 244f98919ecSYang Jihong { 245f98919ecSYang Jihong list_del(&atom->list); 246f98919ecSYang Jihong atom_free(atom); 247f98919ecSYang Jihong } 248f98919ecSYang Jihong 249f98919ecSYang Jihong static int work_cmp(struct list_head *list, 250f98919ecSYang Jihong struct kwork_work *l, struct kwork_work *r) 251f98919ecSYang Jihong { 252f98919ecSYang Jihong int ret = 0; 253f98919ecSYang Jihong struct sort_dimension *sort; 254f98919ecSYang Jihong 255f98919ecSYang Jihong BUG_ON(list_empty(list)); 256f98919ecSYang Jihong 257f98919ecSYang Jihong list_for_each_entry(sort, list, list) { 258f98919ecSYang Jihong ret = sort->cmp(l, r); 259f98919ecSYang Jihong if (ret) 260f98919ecSYang Jihong return ret; 261f98919ecSYang Jihong } 262f98919ecSYang Jihong 263f98919ecSYang Jihong return ret; 264f98919ecSYang Jihong } 265f98919ecSYang Jihong 266f98919ecSYang Jihong static struct kwork_work *work_search(struct rb_root_cached *root, 267f98919ecSYang Jihong struct kwork_work *key, 268f98919ecSYang Jihong struct list_head *sort_list) 269f98919ecSYang Jihong { 270f98919ecSYang Jihong int cmp; 271f98919ecSYang Jihong struct kwork_work *work; 272f98919ecSYang Jihong struct rb_node *node = root->rb_root.rb_node; 273f98919ecSYang Jihong 274f98919ecSYang Jihong while (node) { 275f98919ecSYang Jihong work = container_of(node, struct kwork_work, node); 276f98919ecSYang Jihong cmp = work_cmp(sort_list, key, work); 277f98919ecSYang Jihong if (cmp > 0) 278f98919ecSYang Jihong node = node->rb_left; 279f98919ecSYang Jihong else if (cmp < 0) 280f98919ecSYang Jihong node = node->rb_right; 281f98919ecSYang Jihong else { 282f98919ecSYang Jihong if (work->name == NULL) 283f98919ecSYang Jihong work->name = key->name; 284f98919ecSYang Jihong return work; 285f98919ecSYang Jihong } 286f98919ecSYang Jihong } 287f98919ecSYang Jihong return NULL; 288f98919ecSYang Jihong } 289f98919ecSYang Jihong 290f98919ecSYang Jihong static void work_insert(struct rb_root_cached *root, 291f98919ecSYang Jihong struct kwork_work *key, struct list_head *sort_list) 292f98919ecSYang Jihong { 293f98919ecSYang Jihong int cmp; 294f98919ecSYang Jihong bool leftmost = true; 295f98919ecSYang Jihong struct kwork_work *cur; 296f98919ecSYang Jihong struct rb_node **new = &(root->rb_root.rb_node), *parent = NULL; 297f98919ecSYang Jihong 298f98919ecSYang Jihong while (*new) { 299f98919ecSYang Jihong cur = container_of(*new, struct kwork_work, node); 300f98919ecSYang Jihong parent = *new; 301f98919ecSYang Jihong cmp = work_cmp(sort_list, key, cur); 302f98919ecSYang Jihong 303f98919ecSYang Jihong if (cmp > 0) 304f98919ecSYang Jihong new = &((*new)->rb_left); 305f98919ecSYang Jihong else { 306f98919ecSYang Jihong new = &((*new)->rb_right); 307f98919ecSYang Jihong leftmost = false; 308f98919ecSYang Jihong } 309f98919ecSYang Jihong } 310f98919ecSYang Jihong 311f98919ecSYang Jihong rb_link_node(&key->node, parent, new); 312f98919ecSYang Jihong rb_insert_color_cached(&key->node, root, leftmost); 313f98919ecSYang Jihong } 314f98919ecSYang Jihong 315f98919ecSYang Jihong static struct kwork_work *work_new(struct kwork_work *key) 316f98919ecSYang Jihong { 317f98919ecSYang Jihong int i; 318f98919ecSYang Jihong struct kwork_work *work = zalloc(sizeof(*work)); 319f98919ecSYang Jihong 320f98919ecSYang Jihong if (work == NULL) { 321f98919ecSYang Jihong pr_err("Failed to zalloc kwork work\n"); 322f98919ecSYang Jihong return NULL; 323f98919ecSYang Jihong } 324f98919ecSYang Jihong 325f98919ecSYang Jihong for (i = 0; i < KWORK_TRACE_MAX; i++) 326f98919ecSYang Jihong INIT_LIST_HEAD(&work->atom_list[i]); 327f98919ecSYang Jihong 328f98919ecSYang Jihong work->id = key->id; 329f98919ecSYang Jihong work->cpu = key->cpu; 330f98919ecSYang Jihong work->name = key->name; 331f98919ecSYang Jihong work->class = key->class; 332f98919ecSYang Jihong return work; 333f98919ecSYang Jihong } 334f98919ecSYang Jihong 335f98919ecSYang Jihong static struct kwork_work *work_findnew(struct rb_root_cached *root, 336f98919ecSYang Jihong struct kwork_work *key, 337f98919ecSYang Jihong struct list_head *sort_list) 338f98919ecSYang Jihong { 339daf07d22SYang Jihong struct kwork_work *work = work_search(root, key, sort_list); 340f98919ecSYang Jihong 341f98919ecSYang Jihong if (work != NULL) 342f98919ecSYang Jihong return work; 343f98919ecSYang Jihong 344f98919ecSYang Jihong work = work_new(key); 345daf07d22SYang Jihong if (work) 346f98919ecSYang Jihong work_insert(root, work, sort_list); 347daf07d22SYang Jihong 348f98919ecSYang Jihong return work; 349f98919ecSYang Jihong } 350f98919ecSYang Jihong 351f98919ecSYang Jihong static void profile_update_timespan(struct perf_kwork *kwork, 352f98919ecSYang Jihong struct perf_sample *sample) 353f98919ecSYang Jihong { 354f98919ecSYang Jihong if (!kwork->summary) 355f98919ecSYang Jihong return; 356f98919ecSYang Jihong 357f98919ecSYang Jihong if ((kwork->timestart == 0) || (kwork->timestart > sample->time)) 358f98919ecSYang Jihong kwork->timestart = sample->time; 359f98919ecSYang Jihong 360f98919ecSYang Jihong if (kwork->timeend < sample->time) 361f98919ecSYang Jihong kwork->timeend = sample->time; 362f98919ecSYang Jihong } 363f98919ecSYang Jihong 364f98919ecSYang Jihong static bool profile_event_match(struct perf_kwork *kwork, 365f98919ecSYang Jihong struct kwork_work *work, 366f98919ecSYang Jihong struct perf_sample *sample) 367f98919ecSYang Jihong { 368f98919ecSYang Jihong int cpu = work->cpu; 369f98919ecSYang Jihong u64 time = sample->time; 370f98919ecSYang Jihong struct perf_time_interval *ptime = &kwork->ptime; 371f98919ecSYang Jihong 372f98919ecSYang Jihong if ((kwork->cpu_list != NULL) && !test_bit(cpu, kwork->cpu_bitmap)) 373f98919ecSYang Jihong return false; 374f98919ecSYang Jihong 375f98919ecSYang Jihong if (((ptime->start != 0) && (ptime->start > time)) || 376f98919ecSYang Jihong ((ptime->end != 0) && (ptime->end < time))) 377f98919ecSYang Jihong return false; 378f98919ecSYang Jihong 379f98919ecSYang Jihong if ((kwork->profile_name != NULL) && 380f98919ecSYang Jihong (work->name != NULL) && 381f98919ecSYang Jihong (strcmp(work->name, kwork->profile_name) != 0)) 382f98919ecSYang Jihong return false; 383f98919ecSYang Jihong 384f98919ecSYang Jihong profile_update_timespan(kwork, sample); 385f98919ecSYang Jihong return true; 386f98919ecSYang Jihong } 387f98919ecSYang Jihong 388f98919ecSYang Jihong static int work_push_atom(struct perf_kwork *kwork, 389f98919ecSYang Jihong struct kwork_class *class, 390f98919ecSYang Jihong enum kwork_trace_type src_type, 391f98919ecSYang Jihong enum kwork_trace_type dst_type, 392f98919ecSYang Jihong struct evsel *evsel, 393f98919ecSYang Jihong struct perf_sample *sample, 394f98919ecSYang Jihong struct machine *machine, 395f98919ecSYang Jihong struct kwork_work **ret_work) 396f98919ecSYang Jihong { 397f98919ecSYang Jihong struct kwork_atom *atom, *dst_atom; 398f98919ecSYang Jihong struct kwork_work *work, key; 399f98919ecSYang Jihong 400f98919ecSYang Jihong BUG_ON(class->work_init == NULL); 401f98919ecSYang Jihong class->work_init(class, &key, evsel, sample, machine); 402f98919ecSYang Jihong 403f98919ecSYang Jihong atom = atom_new(kwork, sample); 404f98919ecSYang Jihong if (atom == NULL) 405f98919ecSYang Jihong return -1; 406f98919ecSYang Jihong 407f98919ecSYang Jihong work = work_findnew(&class->work_root, &key, &kwork->cmp_id); 408f98919ecSYang Jihong if (work == NULL) { 409f98919ecSYang Jihong free(atom); 410f98919ecSYang Jihong return -1; 411f98919ecSYang Jihong } 412f98919ecSYang Jihong 413f98919ecSYang Jihong if (!profile_event_match(kwork, work, sample)) 414f98919ecSYang Jihong return 0; 415f98919ecSYang Jihong 416f98919ecSYang Jihong if (dst_type < KWORK_TRACE_MAX) { 417f98919ecSYang Jihong dst_atom = list_last_entry_or_null(&work->atom_list[dst_type], 418f98919ecSYang Jihong struct kwork_atom, list); 419f98919ecSYang Jihong if (dst_atom != NULL) { 420f98919ecSYang Jihong atom->prev = dst_atom; 421f98919ecSYang Jihong list_del(&dst_atom->list); 422f98919ecSYang Jihong } 423f98919ecSYang Jihong } 424f98919ecSYang Jihong 425f98919ecSYang Jihong if (ret_work != NULL) 426f98919ecSYang Jihong *ret_work = work; 427f98919ecSYang Jihong 428f98919ecSYang Jihong list_add_tail(&atom->list, &work->atom_list[src_type]); 429f98919ecSYang Jihong 430f98919ecSYang Jihong return 0; 431f98919ecSYang Jihong } 432f98919ecSYang Jihong 433f98919ecSYang Jihong static struct kwork_atom *work_pop_atom(struct perf_kwork *kwork, 434f98919ecSYang Jihong struct kwork_class *class, 435f98919ecSYang Jihong enum kwork_trace_type src_type, 436f98919ecSYang Jihong enum kwork_trace_type dst_type, 437f98919ecSYang Jihong struct evsel *evsel, 438f98919ecSYang Jihong struct perf_sample *sample, 439f98919ecSYang Jihong struct machine *machine, 440f98919ecSYang Jihong struct kwork_work **ret_work) 441f98919ecSYang Jihong { 442f98919ecSYang Jihong struct kwork_atom *atom, *src_atom; 443f98919ecSYang Jihong struct kwork_work *work, key; 444f98919ecSYang Jihong 445f98919ecSYang Jihong BUG_ON(class->work_init == NULL); 446f98919ecSYang Jihong class->work_init(class, &key, evsel, sample, machine); 447f98919ecSYang Jihong 448f98919ecSYang Jihong work = work_findnew(&class->work_root, &key, &kwork->cmp_id); 449f98919ecSYang Jihong if (ret_work != NULL) 450f98919ecSYang Jihong *ret_work = work; 451f98919ecSYang Jihong 452f98919ecSYang Jihong if (work == NULL) 453f98919ecSYang Jihong return NULL; 454f98919ecSYang Jihong 455f98919ecSYang Jihong if (!profile_event_match(kwork, work, sample)) 456f98919ecSYang Jihong return NULL; 457f98919ecSYang Jihong 458f98919ecSYang Jihong atom = list_last_entry_or_null(&work->atom_list[dst_type], 459f98919ecSYang Jihong struct kwork_atom, list); 460f98919ecSYang Jihong if (atom != NULL) 461f98919ecSYang Jihong return atom; 462f98919ecSYang Jihong 463f98919ecSYang Jihong src_atom = atom_new(kwork, sample); 464f98919ecSYang Jihong if (src_atom != NULL) 465f98919ecSYang Jihong list_add_tail(&src_atom->list, &work->atom_list[src_type]); 466f98919ecSYang Jihong else { 467f98919ecSYang Jihong if (ret_work != NULL) 468f98919ecSYang Jihong *ret_work = NULL; 469f98919ecSYang Jihong } 470f98919ecSYang Jihong 471f98919ecSYang Jihong return NULL; 472f98919ecSYang Jihong } 473f98919ecSYang Jihong 474f98919ecSYang Jihong static void report_update_exit_event(struct kwork_work *work, 475f98919ecSYang Jihong struct kwork_atom *atom, 476f98919ecSYang Jihong struct perf_sample *sample) 477f98919ecSYang Jihong { 478f98919ecSYang Jihong u64 delta; 479f98919ecSYang Jihong u64 exit_time = sample->time; 480f98919ecSYang Jihong u64 entry_time = atom->time; 481f98919ecSYang Jihong 482f98919ecSYang Jihong if ((entry_time != 0) && (exit_time >= entry_time)) { 483f98919ecSYang Jihong delta = exit_time - entry_time; 484f98919ecSYang Jihong if ((delta > work->max_runtime) || 485f98919ecSYang Jihong (work->max_runtime == 0)) { 486f98919ecSYang Jihong work->max_runtime = delta; 487f98919ecSYang Jihong work->max_runtime_start = entry_time; 488f98919ecSYang Jihong work->max_runtime_end = exit_time; 489f98919ecSYang Jihong } 490f98919ecSYang Jihong work->total_runtime += delta; 491f98919ecSYang Jihong work->nr_atoms++; 492f98919ecSYang Jihong } 493f98919ecSYang Jihong } 494f98919ecSYang Jihong 495f98919ecSYang Jihong static int report_entry_event(struct perf_kwork *kwork, 496f98919ecSYang Jihong struct kwork_class *class, 497f98919ecSYang Jihong struct evsel *evsel, 498f98919ecSYang Jihong struct perf_sample *sample, 499f98919ecSYang Jihong struct machine *machine) 500f98919ecSYang Jihong { 501f98919ecSYang Jihong return work_push_atom(kwork, class, KWORK_TRACE_ENTRY, 502f98919ecSYang Jihong KWORK_TRACE_MAX, evsel, sample, 503f98919ecSYang Jihong machine, NULL); 504f98919ecSYang Jihong } 505f98919ecSYang Jihong 506f98919ecSYang Jihong static int report_exit_event(struct perf_kwork *kwork, 507f98919ecSYang Jihong struct kwork_class *class, 508f98919ecSYang Jihong struct evsel *evsel, 509f98919ecSYang Jihong struct perf_sample *sample, 510f98919ecSYang Jihong struct machine *machine) 511f98919ecSYang Jihong { 512f98919ecSYang Jihong struct kwork_atom *atom = NULL; 513f98919ecSYang Jihong struct kwork_work *work = NULL; 514f98919ecSYang Jihong 515f98919ecSYang Jihong atom = work_pop_atom(kwork, class, KWORK_TRACE_EXIT, 516f98919ecSYang Jihong KWORK_TRACE_ENTRY, evsel, sample, 517f98919ecSYang Jihong machine, &work); 518f98919ecSYang Jihong if (work == NULL) 519f98919ecSYang Jihong return -1; 520f98919ecSYang Jihong 521f98919ecSYang Jihong if (atom != NULL) { 522f98919ecSYang Jihong report_update_exit_event(work, atom, sample); 523f98919ecSYang Jihong atom_del(atom); 524f98919ecSYang Jihong } 525f98919ecSYang Jihong 526f98919ecSYang Jihong return 0; 527f98919ecSYang Jihong } 528f98919ecSYang Jihong 529ad3d9f7aSYang Jihong static void latency_update_entry_event(struct kwork_work *work, 530ad3d9f7aSYang Jihong struct kwork_atom *atom, 531ad3d9f7aSYang Jihong struct perf_sample *sample) 532ad3d9f7aSYang Jihong { 533ad3d9f7aSYang Jihong u64 delta; 534ad3d9f7aSYang Jihong u64 entry_time = sample->time; 535ad3d9f7aSYang Jihong u64 raise_time = atom->time; 536ad3d9f7aSYang Jihong 537ad3d9f7aSYang Jihong if ((raise_time != 0) && (entry_time >= raise_time)) { 538ad3d9f7aSYang Jihong delta = entry_time - raise_time; 539ad3d9f7aSYang Jihong if ((delta > work->max_latency) || 540ad3d9f7aSYang Jihong (work->max_latency == 0)) { 541ad3d9f7aSYang Jihong work->max_latency = delta; 542ad3d9f7aSYang Jihong work->max_latency_start = raise_time; 543ad3d9f7aSYang Jihong work->max_latency_end = entry_time; 544ad3d9f7aSYang Jihong } 545ad3d9f7aSYang Jihong work->total_latency += delta; 546ad3d9f7aSYang Jihong work->nr_atoms++; 547ad3d9f7aSYang Jihong } 548ad3d9f7aSYang Jihong } 549ad3d9f7aSYang Jihong 550ad3d9f7aSYang Jihong static int latency_raise_event(struct perf_kwork *kwork, 551ad3d9f7aSYang Jihong struct kwork_class *class, 552ad3d9f7aSYang Jihong struct evsel *evsel, 553ad3d9f7aSYang Jihong struct perf_sample *sample, 554ad3d9f7aSYang Jihong struct machine *machine) 555ad3d9f7aSYang Jihong { 556ad3d9f7aSYang Jihong return work_push_atom(kwork, class, KWORK_TRACE_RAISE, 557ad3d9f7aSYang Jihong KWORK_TRACE_MAX, evsel, sample, 558ad3d9f7aSYang Jihong machine, NULL); 559ad3d9f7aSYang Jihong } 560ad3d9f7aSYang Jihong 561ad3d9f7aSYang Jihong static int latency_entry_event(struct perf_kwork *kwork, 562ad3d9f7aSYang Jihong struct kwork_class *class, 563ad3d9f7aSYang Jihong struct evsel *evsel, 564ad3d9f7aSYang Jihong struct perf_sample *sample, 565ad3d9f7aSYang Jihong struct machine *machine) 566ad3d9f7aSYang Jihong { 567ad3d9f7aSYang Jihong struct kwork_atom *atom = NULL; 568ad3d9f7aSYang Jihong struct kwork_work *work = NULL; 569ad3d9f7aSYang Jihong 570ad3d9f7aSYang Jihong atom = work_pop_atom(kwork, class, KWORK_TRACE_ENTRY, 571ad3d9f7aSYang Jihong KWORK_TRACE_RAISE, evsel, sample, 572ad3d9f7aSYang Jihong machine, &work); 573ad3d9f7aSYang Jihong if (work == NULL) 574ad3d9f7aSYang Jihong return -1; 575ad3d9f7aSYang Jihong 576ad3d9f7aSYang Jihong if (atom != NULL) { 577ad3d9f7aSYang Jihong latency_update_entry_event(work, atom, sample); 578ad3d9f7aSYang Jihong atom_del(atom); 579ad3d9f7aSYang Jihong } 580ad3d9f7aSYang Jihong 581ad3d9f7aSYang Jihong return 0; 582ad3d9f7aSYang Jihong } 583ad3d9f7aSYang Jihong 584bcc8b3e8SYang Jihong static void timehist_save_callchain(struct perf_kwork *kwork, 585bcc8b3e8SYang Jihong struct perf_sample *sample, 586bcc8b3e8SYang Jihong struct evsel *evsel, 587bcc8b3e8SYang Jihong struct machine *machine) 588bcc8b3e8SYang Jihong { 589bcc8b3e8SYang Jihong struct symbol *sym; 590bcc8b3e8SYang Jihong struct thread *thread; 591bcc8b3e8SYang Jihong struct callchain_cursor_node *node; 592*8ab12a20SIan Rogers struct callchain_cursor *cursor; 593bcc8b3e8SYang Jihong 594bcc8b3e8SYang Jihong if (!kwork->show_callchain || sample->callchain == NULL) 595bcc8b3e8SYang Jihong return; 596bcc8b3e8SYang Jihong 597bcc8b3e8SYang Jihong /* want main thread for process - has maps */ 598bcc8b3e8SYang Jihong thread = machine__findnew_thread(machine, sample->pid, sample->pid); 599bcc8b3e8SYang Jihong if (thread == NULL) { 600bcc8b3e8SYang Jihong pr_debug("Failed to get thread for pid %d\n", sample->pid); 601bcc8b3e8SYang Jihong return; 602bcc8b3e8SYang Jihong } 603bcc8b3e8SYang Jihong 604*8ab12a20SIan Rogers cursor = get_tls_callchain_cursor(); 605*8ab12a20SIan Rogers 606bcc8b3e8SYang Jihong if (thread__resolve_callchain(thread, cursor, evsel, sample, 607bcc8b3e8SYang Jihong NULL, NULL, kwork->max_stack + 2) != 0) { 608bcc8b3e8SYang Jihong pr_debug("Failed to resolve callchain, skipping\n"); 609bcc8b3e8SYang Jihong goto out_put; 610bcc8b3e8SYang Jihong } 611bcc8b3e8SYang Jihong 612bcc8b3e8SYang Jihong callchain_cursor_commit(cursor); 613bcc8b3e8SYang Jihong 614bcc8b3e8SYang Jihong while (true) { 615bcc8b3e8SYang Jihong node = callchain_cursor_current(cursor); 616bcc8b3e8SYang Jihong if (node == NULL) 617bcc8b3e8SYang Jihong break; 618bcc8b3e8SYang Jihong 619bcc8b3e8SYang Jihong sym = node->ms.sym; 620bcc8b3e8SYang Jihong if (sym) { 621bcc8b3e8SYang Jihong if (!strcmp(sym->name, "__softirqentry_text_start") || 622bcc8b3e8SYang Jihong !strcmp(sym->name, "__do_softirq")) 623bcc8b3e8SYang Jihong sym->ignore = 1; 624bcc8b3e8SYang Jihong } 625bcc8b3e8SYang Jihong 626bcc8b3e8SYang Jihong callchain_cursor_advance(cursor); 627bcc8b3e8SYang Jihong } 628bcc8b3e8SYang Jihong 629bcc8b3e8SYang Jihong out_put: 630bcc8b3e8SYang Jihong thread__put(thread); 631bcc8b3e8SYang Jihong } 632bcc8b3e8SYang Jihong 633bcc8b3e8SYang Jihong static void timehist_print_event(struct perf_kwork *kwork, 634bcc8b3e8SYang Jihong struct kwork_work *work, 635bcc8b3e8SYang Jihong struct kwork_atom *atom, 636bcc8b3e8SYang Jihong struct perf_sample *sample, 637bcc8b3e8SYang Jihong struct addr_location *al) 638bcc8b3e8SYang Jihong { 639bcc8b3e8SYang Jihong char entrytime[32], exittime[32]; 640bcc8b3e8SYang Jihong char kwork_name[PRINT_KWORK_NAME_WIDTH]; 641bcc8b3e8SYang Jihong 642bcc8b3e8SYang Jihong /* 643bcc8b3e8SYang Jihong * runtime start 644bcc8b3e8SYang Jihong */ 645bcc8b3e8SYang Jihong timestamp__scnprintf_usec(atom->time, 646bcc8b3e8SYang Jihong entrytime, sizeof(entrytime)); 647bcc8b3e8SYang Jihong printf(" %*s ", PRINT_TIMESTAMP_WIDTH, entrytime); 648bcc8b3e8SYang Jihong 649bcc8b3e8SYang Jihong /* 650bcc8b3e8SYang Jihong * runtime end 651bcc8b3e8SYang Jihong */ 652bcc8b3e8SYang Jihong timestamp__scnprintf_usec(sample->time, 653bcc8b3e8SYang Jihong exittime, sizeof(exittime)); 654bcc8b3e8SYang Jihong printf(" %*s ", PRINT_TIMESTAMP_WIDTH, exittime); 655bcc8b3e8SYang Jihong 656bcc8b3e8SYang Jihong /* 657bcc8b3e8SYang Jihong * cpu 658bcc8b3e8SYang Jihong */ 659bcc8b3e8SYang Jihong printf(" [%0*d] ", PRINT_CPU_WIDTH, work->cpu); 660bcc8b3e8SYang Jihong 661bcc8b3e8SYang Jihong /* 662bcc8b3e8SYang Jihong * kwork name 663bcc8b3e8SYang Jihong */ 664bcc8b3e8SYang Jihong if (work->class && work->class->work_name) { 665bcc8b3e8SYang Jihong work->class->work_name(work, kwork_name, 666bcc8b3e8SYang Jihong PRINT_KWORK_NAME_WIDTH); 667bcc8b3e8SYang Jihong printf(" %-*s ", PRINT_KWORK_NAME_WIDTH, kwork_name); 668bcc8b3e8SYang Jihong } else 669bcc8b3e8SYang Jihong printf(" %-*s ", PRINT_KWORK_NAME_WIDTH, ""); 670bcc8b3e8SYang Jihong 671bcc8b3e8SYang Jihong /* 672bcc8b3e8SYang Jihong *runtime 673bcc8b3e8SYang Jihong */ 674bcc8b3e8SYang Jihong printf(" %*.*f ", 675bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, RPINT_DECIMAL_WIDTH, 676bcc8b3e8SYang Jihong (double)(sample->time - atom->time) / NSEC_PER_MSEC); 677bcc8b3e8SYang Jihong 678bcc8b3e8SYang Jihong /* 679bcc8b3e8SYang Jihong * delaytime 680bcc8b3e8SYang Jihong */ 681bcc8b3e8SYang Jihong if (atom->prev != NULL) 682bcc8b3e8SYang Jihong printf(" %*.*f ", PRINT_LATENCY_WIDTH, RPINT_DECIMAL_WIDTH, 683bcc8b3e8SYang Jihong (double)(atom->time - atom->prev->time) / NSEC_PER_MSEC); 684bcc8b3e8SYang Jihong else 685bcc8b3e8SYang Jihong printf(" %*s ", PRINT_LATENCY_WIDTH, " "); 686bcc8b3e8SYang Jihong 687bcc8b3e8SYang Jihong /* 688bcc8b3e8SYang Jihong * callchain 689bcc8b3e8SYang Jihong */ 690bcc8b3e8SYang Jihong if (kwork->show_callchain) { 691*8ab12a20SIan Rogers struct callchain_cursor *cursor = get_tls_callchain_cursor(); 692*8ab12a20SIan Rogers 693*8ab12a20SIan Rogers if (cursor == NULL) 694*8ab12a20SIan Rogers return; 695*8ab12a20SIan Rogers 696bcc8b3e8SYang Jihong printf(" "); 697*8ab12a20SIan Rogers 698bcc8b3e8SYang Jihong sample__fprintf_sym(sample, al, 0, 699bcc8b3e8SYang Jihong EVSEL__PRINT_SYM | EVSEL__PRINT_ONELINE | 700bcc8b3e8SYang Jihong EVSEL__PRINT_CALLCHAIN_ARROW | 701bcc8b3e8SYang Jihong EVSEL__PRINT_SKIP_IGNORED, 702*8ab12a20SIan Rogers cursor, symbol_conf.bt_stop_list, 703bcc8b3e8SYang Jihong stdout); 704bcc8b3e8SYang Jihong } 705bcc8b3e8SYang Jihong 706bcc8b3e8SYang Jihong printf("\n"); 707bcc8b3e8SYang Jihong } 708bcc8b3e8SYang Jihong 709bcc8b3e8SYang Jihong static int timehist_raise_event(struct perf_kwork *kwork, 710bcc8b3e8SYang Jihong struct kwork_class *class, 711bcc8b3e8SYang Jihong struct evsel *evsel, 712bcc8b3e8SYang Jihong struct perf_sample *sample, 713bcc8b3e8SYang Jihong struct machine *machine) 714bcc8b3e8SYang Jihong { 715bcc8b3e8SYang Jihong return work_push_atom(kwork, class, KWORK_TRACE_RAISE, 716bcc8b3e8SYang Jihong KWORK_TRACE_MAX, evsel, sample, 717bcc8b3e8SYang Jihong machine, NULL); 718bcc8b3e8SYang Jihong } 719bcc8b3e8SYang Jihong 720bcc8b3e8SYang Jihong static int timehist_entry_event(struct perf_kwork *kwork, 721bcc8b3e8SYang Jihong struct kwork_class *class, 722bcc8b3e8SYang Jihong struct evsel *evsel, 723bcc8b3e8SYang Jihong struct perf_sample *sample, 724bcc8b3e8SYang Jihong struct machine *machine) 725bcc8b3e8SYang Jihong { 726bcc8b3e8SYang Jihong int ret; 727bcc8b3e8SYang Jihong struct kwork_work *work = NULL; 728bcc8b3e8SYang Jihong 729bcc8b3e8SYang Jihong ret = work_push_atom(kwork, class, KWORK_TRACE_ENTRY, 730bcc8b3e8SYang Jihong KWORK_TRACE_RAISE, evsel, sample, 731bcc8b3e8SYang Jihong machine, &work); 732bcc8b3e8SYang Jihong if (ret) 733bcc8b3e8SYang Jihong return ret; 734bcc8b3e8SYang Jihong 735bcc8b3e8SYang Jihong if (work != NULL) 736bcc8b3e8SYang Jihong timehist_save_callchain(kwork, sample, evsel, machine); 737bcc8b3e8SYang Jihong 738bcc8b3e8SYang Jihong return 0; 739bcc8b3e8SYang Jihong } 740bcc8b3e8SYang Jihong 741bcc8b3e8SYang Jihong static int timehist_exit_event(struct perf_kwork *kwork, 742bcc8b3e8SYang Jihong struct kwork_class *class, 743bcc8b3e8SYang Jihong struct evsel *evsel, 744bcc8b3e8SYang Jihong struct perf_sample *sample, 745bcc8b3e8SYang Jihong struct machine *machine) 746bcc8b3e8SYang Jihong { 747bcc8b3e8SYang Jihong struct kwork_atom *atom = NULL; 748bcc8b3e8SYang Jihong struct kwork_work *work = NULL; 749bcc8b3e8SYang Jihong struct addr_location al; 7500dd5041cSIan Rogers int ret = 0; 751bcc8b3e8SYang Jihong 7520dd5041cSIan Rogers addr_location__init(&al); 753bcc8b3e8SYang Jihong if (machine__resolve(machine, &al, sample) < 0) { 754bcc8b3e8SYang Jihong pr_debug("Problem processing event, skipping it\n"); 7550dd5041cSIan Rogers ret = -1; 7560dd5041cSIan Rogers goto out; 757bcc8b3e8SYang Jihong } 758bcc8b3e8SYang Jihong 759bcc8b3e8SYang Jihong atom = work_pop_atom(kwork, class, KWORK_TRACE_EXIT, 760bcc8b3e8SYang Jihong KWORK_TRACE_ENTRY, evsel, sample, 761bcc8b3e8SYang Jihong machine, &work); 7620dd5041cSIan Rogers if (work == NULL) { 7630dd5041cSIan Rogers ret = -1; 7640dd5041cSIan Rogers goto out; 7650dd5041cSIan Rogers } 766bcc8b3e8SYang Jihong 767bcc8b3e8SYang Jihong if (atom != NULL) { 768bcc8b3e8SYang Jihong work->nr_atoms++; 769bcc8b3e8SYang Jihong timehist_print_event(kwork, work, atom, sample, &al); 770bcc8b3e8SYang Jihong atom_del(atom); 771bcc8b3e8SYang Jihong } 772bcc8b3e8SYang Jihong 7730dd5041cSIan Rogers out: 7740dd5041cSIan Rogers addr_location__exit(&al); 7750dd5041cSIan Rogers return ret; 776bcc8b3e8SYang Jihong } 777bcc8b3e8SYang Jihong 77894348520SYang Jihong static struct kwork_class kwork_irq; 77994348520SYang Jihong static int process_irq_handler_entry_event(struct perf_tool *tool, 78094348520SYang Jihong struct evsel *evsel, 78194348520SYang Jihong struct perf_sample *sample, 78294348520SYang Jihong struct machine *machine) 78394348520SYang Jihong { 78494348520SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 78594348520SYang Jihong 78694348520SYang Jihong if (kwork->tp_handler->entry_event) 78794348520SYang Jihong return kwork->tp_handler->entry_event(kwork, &kwork_irq, 78894348520SYang Jihong evsel, sample, machine); 78994348520SYang Jihong return 0; 79094348520SYang Jihong } 79194348520SYang Jihong 79294348520SYang Jihong static int process_irq_handler_exit_event(struct perf_tool *tool, 79394348520SYang Jihong struct evsel *evsel, 79494348520SYang Jihong struct perf_sample *sample, 79594348520SYang Jihong struct machine *machine) 79694348520SYang Jihong { 79794348520SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 79894348520SYang Jihong 79994348520SYang Jihong if (kwork->tp_handler->exit_event) 80094348520SYang Jihong return kwork->tp_handler->exit_event(kwork, &kwork_irq, 80194348520SYang Jihong evsel, sample, machine); 80294348520SYang Jihong return 0; 80394348520SYang Jihong } 80494348520SYang Jihong 8054f8ae962SYang Jihong const struct evsel_str_handler irq_tp_handlers[] = { 80694348520SYang Jihong { "irq:irq_handler_entry", process_irq_handler_entry_event, }, 80794348520SYang Jihong { "irq:irq_handler_exit", process_irq_handler_exit_event, }, 8084f8ae962SYang Jihong }; 8094f8ae962SYang Jihong 81094348520SYang Jihong static int irq_class_init(struct kwork_class *class, 81194348520SYang Jihong struct perf_session *session) 81294348520SYang Jihong { 81394348520SYang Jihong if (perf_session__set_tracepoints_handlers(session, irq_tp_handlers)) { 81494348520SYang Jihong pr_err("Failed to set irq tracepoints handlers\n"); 81594348520SYang Jihong return -1; 81694348520SYang Jihong } 81794348520SYang Jihong 81894348520SYang Jihong class->work_root = RB_ROOT_CACHED; 81994348520SYang Jihong return 0; 82094348520SYang Jihong } 82194348520SYang Jihong 82294348520SYang Jihong static void irq_work_init(struct kwork_class *class, 82394348520SYang Jihong struct kwork_work *work, 82494348520SYang Jihong struct evsel *evsel, 82594348520SYang Jihong struct perf_sample *sample, 82694348520SYang Jihong struct machine *machine __maybe_unused) 82794348520SYang Jihong { 82894348520SYang Jihong work->class = class; 82994348520SYang Jihong work->cpu = sample->cpu; 83094348520SYang Jihong work->id = evsel__intval(evsel, sample, "irq"); 83194348520SYang Jihong work->name = evsel__strval(evsel, sample, "name"); 83294348520SYang Jihong } 83394348520SYang Jihong 83494348520SYang Jihong static void irq_work_name(struct kwork_work *work, char *buf, int len) 83594348520SYang Jihong { 83694348520SYang Jihong snprintf(buf, len, "%s:%" PRIu64 "", work->name, work->id); 83794348520SYang Jihong } 83894348520SYang Jihong 8394f8ae962SYang Jihong static struct kwork_class kwork_irq = { 8404f8ae962SYang Jihong .name = "irq", 8414f8ae962SYang Jihong .type = KWORK_CLASS_IRQ, 8424f8ae962SYang Jihong .nr_tracepoints = 2, 8434f8ae962SYang Jihong .tp_handlers = irq_tp_handlers, 84494348520SYang Jihong .class_init = irq_class_init, 84594348520SYang Jihong .work_init = irq_work_init, 84694348520SYang Jihong .work_name = irq_work_name, 8474f8ae962SYang Jihong }; 8484f8ae962SYang Jihong 8494c148191SYang Jihong static struct kwork_class kwork_softirq; 85019807bbaSYang Jihong static int process_softirq_raise_event(struct perf_tool *tool, 85119807bbaSYang Jihong struct evsel *evsel, 85219807bbaSYang Jihong struct perf_sample *sample, 85319807bbaSYang Jihong struct machine *machine) 85419807bbaSYang Jihong { 85519807bbaSYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 85619807bbaSYang Jihong 85719807bbaSYang Jihong if (kwork->tp_handler->raise_event) 85819807bbaSYang Jihong return kwork->tp_handler->raise_event(kwork, &kwork_softirq, 85919807bbaSYang Jihong evsel, sample, machine); 86019807bbaSYang Jihong 86119807bbaSYang Jihong return 0; 86219807bbaSYang Jihong } 86319807bbaSYang Jihong 8644c148191SYang Jihong static int process_softirq_entry_event(struct perf_tool *tool, 8654c148191SYang Jihong struct evsel *evsel, 8664c148191SYang Jihong struct perf_sample *sample, 8674c148191SYang Jihong struct machine *machine) 8684c148191SYang Jihong { 8694c148191SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 8704c148191SYang Jihong 8714c148191SYang Jihong if (kwork->tp_handler->entry_event) 8724c148191SYang Jihong return kwork->tp_handler->entry_event(kwork, &kwork_softirq, 8734c148191SYang Jihong evsel, sample, machine); 8744c148191SYang Jihong 8754c148191SYang Jihong return 0; 8764c148191SYang Jihong } 8774c148191SYang Jihong 8784c148191SYang Jihong static int process_softirq_exit_event(struct perf_tool *tool, 8794c148191SYang Jihong struct evsel *evsel, 8804c148191SYang Jihong struct perf_sample *sample, 8814c148191SYang Jihong struct machine *machine) 8824c148191SYang Jihong { 8834c148191SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 8844c148191SYang Jihong 8854c148191SYang Jihong if (kwork->tp_handler->exit_event) 8864c148191SYang Jihong return kwork->tp_handler->exit_event(kwork, &kwork_softirq, 8874c148191SYang Jihong evsel, sample, machine); 8884c148191SYang Jihong 8894c148191SYang Jihong return 0; 8904c148191SYang Jihong } 8914c148191SYang Jihong 892e6439321SYang Jihong const struct evsel_str_handler softirq_tp_handlers[] = { 89319807bbaSYang Jihong { "irq:softirq_raise", process_softirq_raise_event, }, 8944c148191SYang Jihong { "irq:softirq_entry", process_softirq_entry_event, }, 8954c148191SYang Jihong { "irq:softirq_exit", process_softirq_exit_event, }, 896e6439321SYang Jihong }; 897e6439321SYang Jihong 8984c148191SYang Jihong static int softirq_class_init(struct kwork_class *class, 8994c148191SYang Jihong struct perf_session *session) 9004c148191SYang Jihong { 9014c148191SYang Jihong if (perf_session__set_tracepoints_handlers(session, 9024c148191SYang Jihong softirq_tp_handlers)) { 9034c148191SYang Jihong pr_err("Failed to set softirq tracepoints handlers\n"); 9044c148191SYang Jihong return -1; 9054c148191SYang Jihong } 9064c148191SYang Jihong 9074c148191SYang Jihong class->work_root = RB_ROOT_CACHED; 9084c148191SYang Jihong return 0; 9094c148191SYang Jihong } 9104c148191SYang Jihong 9114c148191SYang Jihong static char *evsel__softirq_name(struct evsel *evsel, u64 num) 9124c148191SYang Jihong { 9134c148191SYang Jihong char *name = NULL; 9144c148191SYang Jihong bool found = false; 9154c148191SYang Jihong struct tep_print_flag_sym *sym = NULL; 9164c148191SYang Jihong struct tep_print_arg *args = evsel->tp_format->print_fmt.args; 9174c148191SYang Jihong 9184c148191SYang Jihong if ((args == NULL) || (args->next == NULL)) 9194c148191SYang Jihong return NULL; 9204c148191SYang Jihong 9214c148191SYang Jihong /* skip softirq field: "REC->vec" */ 9224c148191SYang Jihong for (sym = args->next->symbol.symbols; sym != NULL; sym = sym->next) { 9234c148191SYang Jihong if ((eval_flag(sym->value) == (unsigned long long)num) && 9244c148191SYang Jihong (strlen(sym->str) != 0)) { 9254c148191SYang Jihong found = true; 9264c148191SYang Jihong break; 9274c148191SYang Jihong } 9284c148191SYang Jihong } 9294c148191SYang Jihong 9304c148191SYang Jihong if (!found) 9314c148191SYang Jihong return NULL; 9324c148191SYang Jihong 9334c148191SYang Jihong name = strdup(sym->str); 9344c148191SYang Jihong if (name == NULL) { 9354c148191SYang Jihong pr_err("Failed to copy symbol name\n"); 9364c148191SYang Jihong return NULL; 9374c148191SYang Jihong } 9384c148191SYang Jihong return name; 9394c148191SYang Jihong } 9404c148191SYang Jihong 9414c148191SYang Jihong static void softirq_work_init(struct kwork_class *class, 9424c148191SYang Jihong struct kwork_work *work, 9434c148191SYang Jihong struct evsel *evsel, 9444c148191SYang Jihong struct perf_sample *sample, 9454c148191SYang Jihong struct machine *machine __maybe_unused) 9464c148191SYang Jihong { 9474c148191SYang Jihong u64 num = evsel__intval(evsel, sample, "vec"); 9484c148191SYang Jihong 9494c148191SYang Jihong work->id = num; 9504c148191SYang Jihong work->class = class; 9514c148191SYang Jihong work->cpu = sample->cpu; 9524c148191SYang Jihong work->name = evsel__softirq_name(evsel, num); 9534c148191SYang Jihong } 9544c148191SYang Jihong 9554c148191SYang Jihong static void softirq_work_name(struct kwork_work *work, char *buf, int len) 9564c148191SYang Jihong { 9574c148191SYang Jihong snprintf(buf, len, "(s)%s:%" PRIu64 "", work->name, work->id); 9584c148191SYang Jihong } 9594c148191SYang Jihong 960e6439321SYang Jihong static struct kwork_class kwork_softirq = { 961e6439321SYang Jihong .name = "softirq", 962e6439321SYang Jihong .type = KWORK_CLASS_SOFTIRQ, 963e6439321SYang Jihong .nr_tracepoints = 3, 964e6439321SYang Jihong .tp_handlers = softirq_tp_handlers, 9654c148191SYang Jihong .class_init = softirq_class_init, 9664c148191SYang Jihong .work_init = softirq_work_init, 9674c148191SYang Jihong .work_name = softirq_work_name, 968e6439321SYang Jihong }; 969e6439321SYang Jihong 9708dbc3c86SYang Jihong static struct kwork_class kwork_workqueue; 97153e49e32SYang Jihong static int process_workqueue_activate_work_event(struct perf_tool *tool, 97253e49e32SYang Jihong struct evsel *evsel, 97353e49e32SYang Jihong struct perf_sample *sample, 97453e49e32SYang Jihong struct machine *machine) 97553e49e32SYang Jihong { 97653e49e32SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 97753e49e32SYang Jihong 97853e49e32SYang Jihong if (kwork->tp_handler->raise_event) 97953e49e32SYang Jihong return kwork->tp_handler->raise_event(kwork, &kwork_workqueue, 98053e49e32SYang Jihong evsel, sample, machine); 98153e49e32SYang Jihong 98253e49e32SYang Jihong return 0; 98353e49e32SYang Jihong } 98453e49e32SYang Jihong 9858dbc3c86SYang Jihong static int process_workqueue_execute_start_event(struct perf_tool *tool, 9868dbc3c86SYang Jihong struct evsel *evsel, 9878dbc3c86SYang Jihong struct perf_sample *sample, 9888dbc3c86SYang Jihong struct machine *machine) 9898dbc3c86SYang Jihong { 9908dbc3c86SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 9918dbc3c86SYang Jihong 9928dbc3c86SYang Jihong if (kwork->tp_handler->entry_event) 9938dbc3c86SYang Jihong return kwork->tp_handler->entry_event(kwork, &kwork_workqueue, 9948dbc3c86SYang Jihong evsel, sample, machine); 9958dbc3c86SYang Jihong 9968dbc3c86SYang Jihong return 0; 9978dbc3c86SYang Jihong } 9988dbc3c86SYang Jihong 9998dbc3c86SYang Jihong static int process_workqueue_execute_end_event(struct perf_tool *tool, 10008dbc3c86SYang Jihong struct evsel *evsel, 10018dbc3c86SYang Jihong struct perf_sample *sample, 10028dbc3c86SYang Jihong struct machine *machine) 10038dbc3c86SYang Jihong { 10048dbc3c86SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 10058dbc3c86SYang Jihong 10068dbc3c86SYang Jihong if (kwork->tp_handler->exit_event) 10078dbc3c86SYang Jihong return kwork->tp_handler->exit_event(kwork, &kwork_workqueue, 10088dbc3c86SYang Jihong evsel, sample, machine); 10098dbc3c86SYang Jihong 10108dbc3c86SYang Jihong return 0; 10118dbc3c86SYang Jihong } 10128dbc3c86SYang Jihong 101397179d9dSYang Jihong const struct evsel_str_handler workqueue_tp_handlers[] = { 101453e49e32SYang Jihong { "workqueue:workqueue_activate_work", process_workqueue_activate_work_event, }, 10158dbc3c86SYang Jihong { "workqueue:workqueue_execute_start", process_workqueue_execute_start_event, }, 10168dbc3c86SYang Jihong { "workqueue:workqueue_execute_end", process_workqueue_execute_end_event, }, 101797179d9dSYang Jihong }; 101897179d9dSYang Jihong 10198dbc3c86SYang Jihong static int workqueue_class_init(struct kwork_class *class, 10208dbc3c86SYang Jihong struct perf_session *session) 10218dbc3c86SYang Jihong { 10228dbc3c86SYang Jihong if (perf_session__set_tracepoints_handlers(session, 10238dbc3c86SYang Jihong workqueue_tp_handlers)) { 10248dbc3c86SYang Jihong pr_err("Failed to set workqueue tracepoints handlers\n"); 10258dbc3c86SYang Jihong return -1; 10268dbc3c86SYang Jihong } 10278dbc3c86SYang Jihong 10288dbc3c86SYang Jihong class->work_root = RB_ROOT_CACHED; 10298dbc3c86SYang Jihong return 0; 10308dbc3c86SYang Jihong } 10318dbc3c86SYang Jihong 10328dbc3c86SYang Jihong static void workqueue_work_init(struct kwork_class *class, 10338dbc3c86SYang Jihong struct kwork_work *work, 10348dbc3c86SYang Jihong struct evsel *evsel, 10358dbc3c86SYang Jihong struct perf_sample *sample, 10368dbc3c86SYang Jihong struct machine *machine) 10378dbc3c86SYang Jihong { 10388dbc3c86SYang Jihong char *modp = NULL; 10398dbc3c86SYang Jihong unsigned long long function_addr = evsel__intval(evsel, 10408dbc3c86SYang Jihong sample, "function"); 10418dbc3c86SYang Jihong 10428dbc3c86SYang Jihong work->class = class; 10438dbc3c86SYang Jihong work->cpu = sample->cpu; 10448dbc3c86SYang Jihong work->id = evsel__intval(evsel, sample, "work"); 10458dbc3c86SYang Jihong work->name = function_addr == 0 ? NULL : 10468dbc3c86SYang Jihong machine__resolve_kernel_addr(machine, &function_addr, &modp); 10478dbc3c86SYang Jihong } 10488dbc3c86SYang Jihong 10498dbc3c86SYang Jihong static void workqueue_work_name(struct kwork_work *work, char *buf, int len) 10508dbc3c86SYang Jihong { 10518dbc3c86SYang Jihong if (work->name != NULL) 10528dbc3c86SYang Jihong snprintf(buf, len, "(w)%s", work->name); 10538dbc3c86SYang Jihong else 10548dbc3c86SYang Jihong snprintf(buf, len, "(w)0x%" PRIx64, work->id); 10558dbc3c86SYang Jihong } 10568dbc3c86SYang Jihong 105797179d9dSYang Jihong static struct kwork_class kwork_workqueue = { 105897179d9dSYang Jihong .name = "workqueue", 105997179d9dSYang Jihong .type = KWORK_CLASS_WORKQUEUE, 106097179d9dSYang Jihong .nr_tracepoints = 3, 106197179d9dSYang Jihong .tp_handlers = workqueue_tp_handlers, 10628dbc3c86SYang Jihong .class_init = workqueue_class_init, 10638dbc3c86SYang Jihong .work_init = workqueue_work_init, 10648dbc3c86SYang Jihong .work_name = workqueue_work_name, 106597179d9dSYang Jihong }; 106697179d9dSYang Jihong 10670f70d8e9SYang Jihong static struct kwork_class *kwork_class_supported_list[KWORK_CLASS_MAX] = { 10684f8ae962SYang Jihong [KWORK_CLASS_IRQ] = &kwork_irq, 1069e6439321SYang Jihong [KWORK_CLASS_SOFTIRQ] = &kwork_softirq, 107097179d9dSYang Jihong [KWORK_CLASS_WORKQUEUE] = &kwork_workqueue, 10710f70d8e9SYang Jihong }; 10720f70d8e9SYang Jihong 1073f98919ecSYang Jihong static void print_separator(int len) 1074f98919ecSYang Jihong { 1075f98919ecSYang Jihong printf(" %.*s\n", len, graph_dotted_line); 1076f98919ecSYang Jihong } 1077f98919ecSYang Jihong 1078f98919ecSYang Jihong static int report_print_work(struct perf_kwork *kwork, struct kwork_work *work) 1079f98919ecSYang Jihong { 1080f98919ecSYang Jihong int ret = 0; 1081f98919ecSYang Jihong char kwork_name[PRINT_KWORK_NAME_WIDTH]; 1082f98919ecSYang Jihong char max_runtime_start[32], max_runtime_end[32]; 1083ad3d9f7aSYang Jihong char max_latency_start[32], max_latency_end[32]; 1084f98919ecSYang Jihong 1085f98919ecSYang Jihong printf(" "); 1086f98919ecSYang Jihong 1087f98919ecSYang Jihong /* 1088f98919ecSYang Jihong * kwork name 1089f98919ecSYang Jihong */ 1090f98919ecSYang Jihong if (work->class && work->class->work_name) { 1091f98919ecSYang Jihong work->class->work_name(work, kwork_name, 1092f98919ecSYang Jihong PRINT_KWORK_NAME_WIDTH); 1093f98919ecSYang Jihong ret += printf(" %-*s |", PRINT_KWORK_NAME_WIDTH, kwork_name); 1094f98919ecSYang Jihong } else { 1095f98919ecSYang Jihong ret += printf(" %-*s |", PRINT_KWORK_NAME_WIDTH, ""); 1096f98919ecSYang Jihong } 1097f98919ecSYang Jihong 1098f98919ecSYang Jihong /* 1099f98919ecSYang Jihong * cpu 1100f98919ecSYang Jihong */ 1101f98919ecSYang Jihong ret += printf(" %0*d |", PRINT_CPU_WIDTH, work->cpu); 1102f98919ecSYang Jihong 1103f98919ecSYang Jihong /* 1104f98919ecSYang Jihong * total runtime 1105f98919ecSYang Jihong */ 1106f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 1107f98919ecSYang Jihong ret += printf(" %*.*f ms |", 1108f98919ecSYang Jihong PRINT_RUNTIME_WIDTH, RPINT_DECIMAL_WIDTH, 1109f98919ecSYang Jihong (double)work->total_runtime / NSEC_PER_MSEC); 1110ad3d9f7aSYang Jihong } else if (kwork->report == KWORK_REPORT_LATENCY) { // avg delay 1111ad3d9f7aSYang Jihong ret += printf(" %*.*f ms |", 1112ad3d9f7aSYang Jihong PRINT_LATENCY_WIDTH, RPINT_DECIMAL_WIDTH, 1113ad3d9f7aSYang Jihong (double)work->total_latency / 1114ad3d9f7aSYang Jihong work->nr_atoms / NSEC_PER_MSEC); 1115f98919ecSYang Jihong } 1116f98919ecSYang Jihong 1117f98919ecSYang Jihong /* 1118f98919ecSYang Jihong * count 1119f98919ecSYang Jihong */ 1120f98919ecSYang Jihong ret += printf(" %*" PRIu64 " |", PRINT_COUNT_WIDTH, work->nr_atoms); 1121f98919ecSYang Jihong 1122f98919ecSYang Jihong /* 1123f98919ecSYang Jihong * max runtime, max runtime start, max runtime end 1124f98919ecSYang Jihong */ 1125f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 1126f98919ecSYang Jihong timestamp__scnprintf_usec(work->max_runtime_start, 1127f98919ecSYang Jihong max_runtime_start, 1128f98919ecSYang Jihong sizeof(max_runtime_start)); 1129f98919ecSYang Jihong timestamp__scnprintf_usec(work->max_runtime_end, 1130f98919ecSYang Jihong max_runtime_end, 1131f98919ecSYang Jihong sizeof(max_runtime_end)); 1132f98919ecSYang Jihong ret += printf(" %*.*f ms | %*s s | %*s s |", 1133f98919ecSYang Jihong PRINT_RUNTIME_WIDTH, RPINT_DECIMAL_WIDTH, 1134f98919ecSYang Jihong (double)work->max_runtime / NSEC_PER_MSEC, 1135f98919ecSYang Jihong PRINT_TIMESTAMP_WIDTH, max_runtime_start, 1136f98919ecSYang Jihong PRINT_TIMESTAMP_WIDTH, max_runtime_end); 1137f98919ecSYang Jihong } 1138ad3d9f7aSYang Jihong /* 1139ad3d9f7aSYang Jihong * max delay, max delay start, max delay end 1140ad3d9f7aSYang Jihong */ 1141ad3d9f7aSYang Jihong else if (kwork->report == KWORK_REPORT_LATENCY) { 1142ad3d9f7aSYang Jihong timestamp__scnprintf_usec(work->max_latency_start, 1143ad3d9f7aSYang Jihong max_latency_start, 1144ad3d9f7aSYang Jihong sizeof(max_latency_start)); 1145ad3d9f7aSYang Jihong timestamp__scnprintf_usec(work->max_latency_end, 1146ad3d9f7aSYang Jihong max_latency_end, 1147ad3d9f7aSYang Jihong sizeof(max_latency_end)); 1148ad3d9f7aSYang Jihong ret += printf(" %*.*f ms | %*s s | %*s s |", 1149ad3d9f7aSYang Jihong PRINT_LATENCY_WIDTH, RPINT_DECIMAL_WIDTH, 1150ad3d9f7aSYang Jihong (double)work->max_latency / NSEC_PER_MSEC, 1151ad3d9f7aSYang Jihong PRINT_TIMESTAMP_WIDTH, max_latency_start, 1152ad3d9f7aSYang Jihong PRINT_TIMESTAMP_WIDTH, max_latency_end); 1153ad3d9f7aSYang Jihong } 1154f98919ecSYang Jihong 1155f98919ecSYang Jihong printf("\n"); 1156f98919ecSYang Jihong return ret; 1157f98919ecSYang Jihong } 1158f98919ecSYang Jihong 1159f98919ecSYang Jihong static int report_print_header(struct perf_kwork *kwork) 1160f98919ecSYang Jihong { 1161f98919ecSYang Jihong int ret; 1162f98919ecSYang Jihong 1163f98919ecSYang Jihong printf("\n "); 1164f98919ecSYang Jihong ret = printf(" %-*s | %-*s |", 1165f98919ecSYang Jihong PRINT_KWORK_NAME_WIDTH, "Kwork Name", 1166f98919ecSYang Jihong PRINT_CPU_WIDTH, "Cpu"); 1167f98919ecSYang Jihong 1168f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 1169f98919ecSYang Jihong ret += printf(" %-*s |", 1170f98919ecSYang Jihong PRINT_RUNTIME_HEADER_WIDTH, "Total Runtime"); 1171ad3d9f7aSYang Jihong } else if (kwork->report == KWORK_REPORT_LATENCY) { 1172ad3d9f7aSYang Jihong ret += printf(" %-*s |", 1173ad3d9f7aSYang Jihong PRINT_LATENCY_HEADER_WIDTH, "Avg delay"); 1174f98919ecSYang Jihong } 1175f98919ecSYang Jihong 1176f98919ecSYang Jihong ret += printf(" %-*s |", PRINT_COUNT_WIDTH, "Count"); 1177f98919ecSYang Jihong 1178f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 1179f98919ecSYang Jihong ret += printf(" %-*s | %-*s | %-*s |", 1180f98919ecSYang Jihong PRINT_RUNTIME_HEADER_WIDTH, "Max runtime", 1181f98919ecSYang Jihong PRINT_TIMESTAMP_HEADER_WIDTH, "Max runtime start", 1182f98919ecSYang Jihong PRINT_TIMESTAMP_HEADER_WIDTH, "Max runtime end"); 1183ad3d9f7aSYang Jihong } else if (kwork->report == KWORK_REPORT_LATENCY) { 1184ad3d9f7aSYang Jihong ret += printf(" %-*s | %-*s | %-*s |", 1185ad3d9f7aSYang Jihong PRINT_LATENCY_HEADER_WIDTH, "Max delay", 1186ad3d9f7aSYang Jihong PRINT_TIMESTAMP_HEADER_WIDTH, "Max delay start", 1187ad3d9f7aSYang Jihong PRINT_TIMESTAMP_HEADER_WIDTH, "Max delay end"); 1188f98919ecSYang Jihong } 1189f98919ecSYang Jihong 1190f98919ecSYang Jihong printf("\n"); 1191f98919ecSYang Jihong print_separator(ret); 1192f98919ecSYang Jihong return ret; 1193f98919ecSYang Jihong } 1194f98919ecSYang Jihong 1195bcc8b3e8SYang Jihong static void timehist_print_header(void) 1196bcc8b3e8SYang Jihong { 1197bcc8b3e8SYang Jihong /* 1198bcc8b3e8SYang Jihong * header row 1199bcc8b3e8SYang Jihong */ 1200bcc8b3e8SYang Jihong printf(" %-*s %-*s %-*s %-*s %-*s %-*s\n", 1201bcc8b3e8SYang Jihong PRINT_TIMESTAMP_WIDTH, "Runtime start", 1202bcc8b3e8SYang Jihong PRINT_TIMESTAMP_WIDTH, "Runtime end", 1203bcc8b3e8SYang Jihong PRINT_TIMEHIST_CPU_WIDTH, "Cpu", 1204bcc8b3e8SYang Jihong PRINT_KWORK_NAME_WIDTH, "Kwork name", 1205bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, "Runtime", 1206bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, "Delaytime"); 1207bcc8b3e8SYang Jihong 1208bcc8b3e8SYang Jihong /* 1209bcc8b3e8SYang Jihong * units row 1210bcc8b3e8SYang Jihong */ 1211bcc8b3e8SYang Jihong printf(" %-*s %-*s %-*s %-*s %-*s %-*s\n", 1212bcc8b3e8SYang Jihong PRINT_TIMESTAMP_WIDTH, "", 1213bcc8b3e8SYang Jihong PRINT_TIMESTAMP_WIDTH, "", 1214bcc8b3e8SYang Jihong PRINT_TIMEHIST_CPU_WIDTH, "", 1215bcc8b3e8SYang Jihong PRINT_KWORK_NAME_WIDTH, "(TYPE)NAME:NUM", 1216bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, "(msec)", 1217bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, "(msec)"); 1218bcc8b3e8SYang Jihong 1219bcc8b3e8SYang Jihong /* 1220bcc8b3e8SYang Jihong * separator 1221bcc8b3e8SYang Jihong */ 1222bcc8b3e8SYang Jihong printf(" %.*s %.*s %.*s %.*s %.*s %.*s\n", 1223bcc8b3e8SYang Jihong PRINT_TIMESTAMP_WIDTH, graph_dotted_line, 1224bcc8b3e8SYang Jihong PRINT_TIMESTAMP_WIDTH, graph_dotted_line, 1225bcc8b3e8SYang Jihong PRINT_TIMEHIST_CPU_WIDTH, graph_dotted_line, 1226bcc8b3e8SYang Jihong PRINT_KWORK_NAME_WIDTH, graph_dotted_line, 1227bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, graph_dotted_line, 1228bcc8b3e8SYang Jihong PRINT_RUNTIME_WIDTH, graph_dotted_line); 1229bcc8b3e8SYang Jihong } 1230bcc8b3e8SYang Jihong 1231f98919ecSYang Jihong static void print_summary(struct perf_kwork *kwork) 1232f98919ecSYang Jihong { 1233f98919ecSYang Jihong u64 time = kwork->timeend - kwork->timestart; 1234f98919ecSYang Jihong 1235f98919ecSYang Jihong printf(" Total count : %9" PRIu64 "\n", kwork->all_count); 1236f98919ecSYang Jihong printf(" Total runtime (msec) : %9.3f (%.3f%% load average)\n", 1237f98919ecSYang Jihong (double)kwork->all_runtime / NSEC_PER_MSEC, 1238f98919ecSYang Jihong time == 0 ? 0 : (double)kwork->all_runtime / time); 1239f98919ecSYang Jihong printf(" Total time span (msec) : %9.3f\n", 1240f98919ecSYang Jihong (double)time / NSEC_PER_MSEC); 1241f98919ecSYang Jihong } 1242f98919ecSYang Jihong 1243f98919ecSYang Jihong static unsigned long long nr_list_entry(struct list_head *head) 1244f98919ecSYang Jihong { 1245f98919ecSYang Jihong struct list_head *pos; 1246f98919ecSYang Jihong unsigned long long n = 0; 1247f98919ecSYang Jihong 1248f98919ecSYang Jihong list_for_each(pos, head) 1249f98919ecSYang Jihong n++; 1250f98919ecSYang Jihong 1251f98919ecSYang Jihong return n; 1252f98919ecSYang Jihong } 1253f98919ecSYang Jihong 1254f98919ecSYang Jihong static void print_skipped_events(struct perf_kwork *kwork) 1255f98919ecSYang Jihong { 1256f98919ecSYang Jihong int i; 1257f98919ecSYang Jihong const char *const kwork_event_str[] = { 1258ad3d9f7aSYang Jihong [KWORK_TRACE_RAISE] = "raise", 1259f98919ecSYang Jihong [KWORK_TRACE_ENTRY] = "entry", 1260f98919ecSYang Jihong [KWORK_TRACE_EXIT] = "exit", 1261f98919ecSYang Jihong }; 1262f98919ecSYang Jihong 1263f98919ecSYang Jihong if ((kwork->nr_skipped_events[KWORK_TRACE_MAX] != 0) && 1264f98919ecSYang Jihong (kwork->nr_events != 0)) { 1265f98919ecSYang Jihong printf(" INFO: %.3f%% skipped events (%" PRIu64 " including ", 1266f98919ecSYang Jihong (double)kwork->nr_skipped_events[KWORK_TRACE_MAX] / 1267f98919ecSYang Jihong (double)kwork->nr_events * 100.0, 1268f98919ecSYang Jihong kwork->nr_skipped_events[KWORK_TRACE_MAX]); 1269f98919ecSYang Jihong 1270f98919ecSYang Jihong for (i = 0; i < KWORK_TRACE_MAX; i++) { 1271f98919ecSYang Jihong printf("%" PRIu64 " %s%s", 1272f98919ecSYang Jihong kwork->nr_skipped_events[i], 1273f98919ecSYang Jihong kwork_event_str[i], 1274f98919ecSYang Jihong (i == KWORK_TRACE_MAX - 1) ? ")\n" : ", "); 1275f98919ecSYang Jihong } 1276f98919ecSYang Jihong } 1277f98919ecSYang Jihong 1278f98919ecSYang Jihong if (verbose > 0) 1279f98919ecSYang Jihong printf(" INFO: use %lld atom pages\n", 1280f98919ecSYang Jihong nr_list_entry(&kwork->atom_page_list)); 1281f98919ecSYang Jihong } 1282f98919ecSYang Jihong 1283f98919ecSYang Jihong static void print_bad_events(struct perf_kwork *kwork) 1284f98919ecSYang Jihong { 1285f98919ecSYang Jihong if ((kwork->nr_lost_events != 0) && (kwork->nr_events != 0)) { 1286f98919ecSYang Jihong printf(" INFO: %.3f%% lost events (%ld out of %ld, in %ld chunks)\n", 1287f98919ecSYang Jihong (double)kwork->nr_lost_events / 1288f98919ecSYang Jihong (double)kwork->nr_events * 100.0, 1289f98919ecSYang Jihong kwork->nr_lost_events, kwork->nr_events, 1290f98919ecSYang Jihong kwork->nr_lost_chunks); 1291f98919ecSYang Jihong } 1292f98919ecSYang Jihong } 1293f98919ecSYang Jihong 1294f98919ecSYang Jihong static void work_sort(struct perf_kwork *kwork, struct kwork_class *class) 1295f98919ecSYang Jihong { 1296f98919ecSYang Jihong struct rb_node *node; 1297f98919ecSYang Jihong struct kwork_work *data; 1298f98919ecSYang Jihong struct rb_root_cached *root = &class->work_root; 1299f98919ecSYang Jihong 1300f98919ecSYang Jihong pr_debug("Sorting %s ...\n", class->name); 1301f98919ecSYang Jihong for (;;) { 1302f98919ecSYang Jihong node = rb_first_cached(root); 1303f98919ecSYang Jihong if (!node) 1304f98919ecSYang Jihong break; 1305f98919ecSYang Jihong 1306f98919ecSYang Jihong rb_erase_cached(node, root); 1307f98919ecSYang Jihong data = rb_entry(node, struct kwork_work, node); 1308f98919ecSYang Jihong work_insert(&kwork->sorted_work_root, 1309f98919ecSYang Jihong data, &kwork->sort_list); 1310f98919ecSYang Jihong } 1311f98919ecSYang Jihong } 1312f98919ecSYang Jihong 1313f98919ecSYang Jihong static void perf_kwork__sort(struct perf_kwork *kwork) 1314f98919ecSYang Jihong { 1315f98919ecSYang Jihong struct kwork_class *class; 1316f98919ecSYang Jihong 1317f98919ecSYang Jihong list_for_each_entry(class, &kwork->class_list, list) 1318f98919ecSYang Jihong work_sort(kwork, class); 1319f98919ecSYang Jihong } 1320f98919ecSYang Jihong 1321f98919ecSYang Jihong static int perf_kwork__check_config(struct perf_kwork *kwork, 1322f98919ecSYang Jihong struct perf_session *session) 1323f98919ecSYang Jihong { 1324f98919ecSYang Jihong int ret; 1325bcc8b3e8SYang Jihong struct evsel *evsel; 1326f98919ecSYang Jihong struct kwork_class *class; 1327f98919ecSYang Jihong 1328f98919ecSYang Jihong static struct trace_kwork_handler report_ops = { 1329f98919ecSYang Jihong .entry_event = report_entry_event, 1330f98919ecSYang Jihong .exit_event = report_exit_event, 1331f98919ecSYang Jihong }; 1332ad3d9f7aSYang Jihong static struct trace_kwork_handler latency_ops = { 1333ad3d9f7aSYang Jihong .raise_event = latency_raise_event, 1334ad3d9f7aSYang Jihong .entry_event = latency_entry_event, 1335ad3d9f7aSYang Jihong }; 1336bcc8b3e8SYang Jihong static struct trace_kwork_handler timehist_ops = { 1337bcc8b3e8SYang Jihong .raise_event = timehist_raise_event, 1338bcc8b3e8SYang Jihong .entry_event = timehist_entry_event, 1339bcc8b3e8SYang Jihong .exit_event = timehist_exit_event, 1340bcc8b3e8SYang Jihong }; 1341f98919ecSYang Jihong 1342f98919ecSYang Jihong switch (kwork->report) { 1343f98919ecSYang Jihong case KWORK_REPORT_RUNTIME: 1344f98919ecSYang Jihong kwork->tp_handler = &report_ops; 1345f98919ecSYang Jihong break; 1346ad3d9f7aSYang Jihong case KWORK_REPORT_LATENCY: 1347ad3d9f7aSYang Jihong kwork->tp_handler = &latency_ops; 1348ad3d9f7aSYang Jihong break; 1349bcc8b3e8SYang Jihong case KWORK_REPORT_TIMEHIST: 1350bcc8b3e8SYang Jihong kwork->tp_handler = &timehist_ops; 1351bcc8b3e8SYang Jihong break; 1352f98919ecSYang Jihong default: 1353f98919ecSYang Jihong pr_debug("Invalid report type %d\n", kwork->report); 1354f98919ecSYang Jihong return -1; 1355f98919ecSYang Jihong } 1356f98919ecSYang Jihong 1357f98919ecSYang Jihong list_for_each_entry(class, &kwork->class_list, list) 1358f98919ecSYang Jihong if ((class->class_init != NULL) && 1359f98919ecSYang Jihong (class->class_init(class, session) != 0)) 1360f98919ecSYang Jihong return -1; 1361f98919ecSYang Jihong 1362f98919ecSYang Jihong if (kwork->cpu_list != NULL) { 1363f98919ecSYang Jihong ret = perf_session__cpu_bitmap(session, 1364f98919ecSYang Jihong kwork->cpu_list, 1365f98919ecSYang Jihong kwork->cpu_bitmap); 1366f98919ecSYang Jihong if (ret < 0) { 1367f98919ecSYang Jihong pr_err("Invalid cpu bitmap\n"); 1368f98919ecSYang Jihong return -1; 1369f98919ecSYang Jihong } 1370f98919ecSYang Jihong } 1371f98919ecSYang Jihong 1372f98919ecSYang Jihong if (kwork->time_str != NULL) { 1373f98919ecSYang Jihong ret = perf_time__parse_str(&kwork->ptime, kwork->time_str); 1374f98919ecSYang Jihong if (ret != 0) { 1375f98919ecSYang Jihong pr_err("Invalid time span\n"); 1376f98919ecSYang Jihong return -1; 1377f98919ecSYang Jihong } 1378f98919ecSYang Jihong } 1379f98919ecSYang Jihong 1380bcc8b3e8SYang Jihong list_for_each_entry(evsel, &session->evlist->core.entries, core.node) { 1381bcc8b3e8SYang Jihong if (kwork->show_callchain && !evsel__has_callchain(evsel)) { 1382bcc8b3e8SYang Jihong pr_debug("Samples do not have callchains\n"); 1383bcc8b3e8SYang Jihong kwork->show_callchain = 0; 1384bcc8b3e8SYang Jihong symbol_conf.use_callchain = 0; 1385bcc8b3e8SYang Jihong } 1386bcc8b3e8SYang Jihong } 1387bcc8b3e8SYang Jihong 1388f98919ecSYang Jihong return 0; 1389f98919ecSYang Jihong } 1390f98919ecSYang Jihong 1391f98919ecSYang Jihong static int perf_kwork__read_events(struct perf_kwork *kwork) 1392f98919ecSYang Jihong { 1393f98919ecSYang Jihong int ret = -1; 1394f98919ecSYang Jihong struct perf_session *session = NULL; 1395f98919ecSYang Jihong 1396f98919ecSYang Jihong struct perf_data data = { 1397f98919ecSYang Jihong .path = input_name, 1398f98919ecSYang Jihong .mode = PERF_DATA_MODE_READ, 1399f98919ecSYang Jihong .force = kwork->force, 1400f98919ecSYang Jihong }; 1401f98919ecSYang Jihong 1402f98919ecSYang Jihong session = perf_session__new(&data, &kwork->tool); 1403f98919ecSYang Jihong if (IS_ERR(session)) { 1404f98919ecSYang Jihong pr_debug("Error creating perf session\n"); 1405f98919ecSYang Jihong return PTR_ERR(session); 1406f98919ecSYang Jihong } 1407f98919ecSYang Jihong 1408f98919ecSYang Jihong symbol__init(&session->header.env); 1409f98919ecSYang Jihong 1410f98919ecSYang Jihong if (perf_kwork__check_config(kwork, session) != 0) 1411f98919ecSYang Jihong goto out_delete; 1412f98919ecSYang Jihong 1413f98919ecSYang Jihong if (session->tevent.pevent && 1414f98919ecSYang Jihong tep_set_function_resolver(session->tevent.pevent, 1415f98919ecSYang Jihong machine__resolve_kernel_addr, 1416f98919ecSYang Jihong &session->machines.host) < 0) { 1417f98919ecSYang Jihong pr_err("Failed to set libtraceevent function resolver\n"); 1418f98919ecSYang Jihong goto out_delete; 1419f98919ecSYang Jihong } 1420f98919ecSYang Jihong 1421bcc8b3e8SYang Jihong if (kwork->report == KWORK_REPORT_TIMEHIST) 1422bcc8b3e8SYang Jihong timehist_print_header(); 1423bcc8b3e8SYang Jihong 1424f98919ecSYang Jihong ret = perf_session__process_events(session); 1425f98919ecSYang Jihong if (ret) { 1426f98919ecSYang Jihong pr_debug("Failed to process events, error %d\n", ret); 1427f98919ecSYang Jihong goto out_delete; 1428f98919ecSYang Jihong } 1429f98919ecSYang Jihong 1430f98919ecSYang Jihong kwork->nr_events = session->evlist->stats.nr_events[0]; 1431f98919ecSYang Jihong kwork->nr_lost_events = session->evlist->stats.total_lost; 1432f98919ecSYang Jihong kwork->nr_lost_chunks = session->evlist->stats.nr_events[PERF_RECORD_LOST]; 1433f98919ecSYang Jihong 1434f98919ecSYang Jihong out_delete: 1435f98919ecSYang Jihong perf_session__delete(session); 1436f98919ecSYang Jihong return ret; 1437f98919ecSYang Jihong } 1438f98919ecSYang Jihong 1439f98919ecSYang Jihong static void process_skipped_events(struct perf_kwork *kwork, 1440f98919ecSYang Jihong struct kwork_work *work) 1441f98919ecSYang Jihong { 1442f98919ecSYang Jihong int i; 1443f98919ecSYang Jihong unsigned long long count; 1444f98919ecSYang Jihong 1445f98919ecSYang Jihong for (i = 0; i < KWORK_TRACE_MAX; i++) { 1446f98919ecSYang Jihong count = nr_list_entry(&work->atom_list[i]); 1447f98919ecSYang Jihong kwork->nr_skipped_events[i] += count; 1448f98919ecSYang Jihong kwork->nr_skipped_events[KWORK_TRACE_MAX] += count; 1449f98919ecSYang Jihong } 1450f98919ecSYang Jihong } 1451f98919ecSYang Jihong 1452daf07d22SYang Jihong struct kwork_work *perf_kwork_add_work(struct perf_kwork *kwork, 1453daf07d22SYang Jihong struct kwork_class *class, 1454daf07d22SYang Jihong struct kwork_work *key) 1455daf07d22SYang Jihong { 1456daf07d22SYang Jihong struct kwork_work *work = NULL; 1457daf07d22SYang Jihong 1458daf07d22SYang Jihong work = work_new(key); 1459daf07d22SYang Jihong if (work == NULL) 1460daf07d22SYang Jihong return NULL; 1461daf07d22SYang Jihong 1462daf07d22SYang Jihong work_insert(&class->work_root, work, &kwork->cmp_id); 1463daf07d22SYang Jihong return work; 1464daf07d22SYang Jihong } 1465daf07d22SYang Jihong 1466daf07d22SYang Jihong static void sig_handler(int sig) 1467daf07d22SYang Jihong { 1468daf07d22SYang Jihong /* 1469daf07d22SYang Jihong * Simply capture termination signal so that 1470daf07d22SYang Jihong * the program can continue after pause returns 1471daf07d22SYang Jihong */ 1472daf07d22SYang Jihong pr_debug("Captuer signal %d\n", sig); 1473daf07d22SYang Jihong } 1474daf07d22SYang Jihong 1475daf07d22SYang Jihong static int perf_kwork__report_bpf(struct perf_kwork *kwork) 1476daf07d22SYang Jihong { 1477daf07d22SYang Jihong int ret; 1478daf07d22SYang Jihong 1479daf07d22SYang Jihong signal(SIGINT, sig_handler); 1480daf07d22SYang Jihong signal(SIGTERM, sig_handler); 1481daf07d22SYang Jihong 1482daf07d22SYang Jihong ret = perf_kwork__trace_prepare_bpf(kwork); 1483daf07d22SYang Jihong if (ret) 1484daf07d22SYang Jihong return -1; 1485daf07d22SYang Jihong 1486daf07d22SYang Jihong printf("Starting trace, Hit <Ctrl+C> to stop and report\n"); 1487daf07d22SYang Jihong 1488daf07d22SYang Jihong perf_kwork__trace_start(); 1489daf07d22SYang Jihong 1490daf07d22SYang Jihong /* 1491daf07d22SYang Jihong * a simple pause, wait here for stop signal 1492daf07d22SYang Jihong */ 1493daf07d22SYang Jihong pause(); 1494daf07d22SYang Jihong 1495daf07d22SYang Jihong perf_kwork__trace_finish(); 1496daf07d22SYang Jihong 1497daf07d22SYang Jihong perf_kwork__report_read_bpf(kwork); 1498daf07d22SYang Jihong 1499daf07d22SYang Jihong perf_kwork__report_cleanup_bpf(); 1500daf07d22SYang Jihong 1501daf07d22SYang Jihong return 0; 1502daf07d22SYang Jihong } 1503daf07d22SYang Jihong 1504f98919ecSYang Jihong static int perf_kwork__report(struct perf_kwork *kwork) 1505f98919ecSYang Jihong { 1506f98919ecSYang Jihong int ret; 1507f98919ecSYang Jihong struct rb_node *next; 1508f98919ecSYang Jihong struct kwork_work *work; 1509f98919ecSYang Jihong 1510daf07d22SYang Jihong if (kwork->use_bpf) 1511daf07d22SYang Jihong ret = perf_kwork__report_bpf(kwork); 1512daf07d22SYang Jihong else 1513f98919ecSYang Jihong ret = perf_kwork__read_events(kwork); 1514daf07d22SYang Jihong 1515f98919ecSYang Jihong if (ret != 0) 1516f98919ecSYang Jihong return -1; 1517f98919ecSYang Jihong 1518f98919ecSYang Jihong perf_kwork__sort(kwork); 1519f98919ecSYang Jihong 1520f98919ecSYang Jihong setup_pager(); 1521f98919ecSYang Jihong 1522f98919ecSYang Jihong ret = report_print_header(kwork); 1523f98919ecSYang Jihong next = rb_first_cached(&kwork->sorted_work_root); 1524f98919ecSYang Jihong while (next) { 1525f98919ecSYang Jihong work = rb_entry(next, struct kwork_work, node); 1526f98919ecSYang Jihong process_skipped_events(kwork, work); 1527f98919ecSYang Jihong 1528f98919ecSYang Jihong if (work->nr_atoms != 0) { 1529f98919ecSYang Jihong report_print_work(kwork, work); 1530f98919ecSYang Jihong if (kwork->summary) { 1531f98919ecSYang Jihong kwork->all_runtime += work->total_runtime; 1532f98919ecSYang Jihong kwork->all_count += work->nr_atoms; 1533f98919ecSYang Jihong } 1534f98919ecSYang Jihong } 1535f98919ecSYang Jihong next = rb_next(next); 1536f98919ecSYang Jihong } 1537f98919ecSYang Jihong print_separator(ret); 1538f98919ecSYang Jihong 1539f98919ecSYang Jihong if (kwork->summary) { 1540f98919ecSYang Jihong print_summary(kwork); 1541f98919ecSYang Jihong print_separator(ret); 1542f98919ecSYang Jihong } 1543f98919ecSYang Jihong 1544f98919ecSYang Jihong print_bad_events(kwork); 1545f98919ecSYang Jihong print_skipped_events(kwork); 1546f98919ecSYang Jihong printf("\n"); 1547f98919ecSYang Jihong 1548f98919ecSYang Jihong return 0; 1549f98919ecSYang Jihong } 1550f98919ecSYang Jihong 1551f98919ecSYang Jihong typedef int (*tracepoint_handler)(struct perf_tool *tool, 1552f98919ecSYang Jihong struct evsel *evsel, 1553f98919ecSYang Jihong struct perf_sample *sample, 1554f98919ecSYang Jihong struct machine *machine); 1555f98919ecSYang Jihong 1556f98919ecSYang Jihong static int perf_kwork__process_tracepoint_sample(struct perf_tool *tool, 1557f98919ecSYang Jihong union perf_event *event __maybe_unused, 1558f98919ecSYang Jihong struct perf_sample *sample, 1559f98919ecSYang Jihong struct evsel *evsel, 1560f98919ecSYang Jihong struct machine *machine) 1561f98919ecSYang Jihong { 1562f98919ecSYang Jihong int err = 0; 1563f98919ecSYang Jihong 1564f98919ecSYang Jihong if (evsel->handler != NULL) { 1565f98919ecSYang Jihong tracepoint_handler f = evsel->handler; 1566f98919ecSYang Jihong 1567f98919ecSYang Jihong err = f(tool, evsel, sample, machine); 1568f98919ecSYang Jihong } 1569f98919ecSYang Jihong 1570f98919ecSYang Jihong return err; 1571f98919ecSYang Jihong } 1572f98919ecSYang Jihong 1573bcc8b3e8SYang Jihong static int perf_kwork__timehist(struct perf_kwork *kwork) 1574bcc8b3e8SYang Jihong { 1575bcc8b3e8SYang Jihong /* 1576bcc8b3e8SYang Jihong * event handlers for timehist option 1577bcc8b3e8SYang Jihong */ 1578bcc8b3e8SYang Jihong kwork->tool.comm = perf_event__process_comm; 1579bcc8b3e8SYang Jihong kwork->tool.exit = perf_event__process_exit; 1580bcc8b3e8SYang Jihong kwork->tool.fork = perf_event__process_fork; 1581bcc8b3e8SYang Jihong kwork->tool.attr = perf_event__process_attr; 1582bcc8b3e8SYang Jihong kwork->tool.tracing_data = perf_event__process_tracing_data; 1583bcc8b3e8SYang Jihong kwork->tool.build_id = perf_event__process_build_id; 1584bcc8b3e8SYang Jihong kwork->tool.ordered_events = true; 1585bcc8b3e8SYang Jihong kwork->tool.ordering_requires_timestamps = true; 1586bcc8b3e8SYang Jihong symbol_conf.use_callchain = kwork->show_callchain; 1587bcc8b3e8SYang Jihong 1588bcc8b3e8SYang Jihong if (symbol__validate_sym_arguments()) { 1589bcc8b3e8SYang Jihong pr_err("Failed to validate sym arguments\n"); 1590bcc8b3e8SYang Jihong return -1; 1591bcc8b3e8SYang Jihong } 1592bcc8b3e8SYang Jihong 1593bcc8b3e8SYang Jihong setup_pager(); 1594bcc8b3e8SYang Jihong 1595bcc8b3e8SYang Jihong return perf_kwork__read_events(kwork); 1596bcc8b3e8SYang Jihong } 1597bcc8b3e8SYang Jihong 15980f70d8e9SYang Jihong static void setup_event_list(struct perf_kwork *kwork, 15990f70d8e9SYang Jihong const struct option *options, 16000f70d8e9SYang Jihong const char * const usage_msg[]) 16010f70d8e9SYang Jihong { 16020f70d8e9SYang Jihong int i; 16030f70d8e9SYang Jihong struct kwork_class *class; 16040f70d8e9SYang Jihong char *tmp, *tok, *str; 16050f70d8e9SYang Jihong 16060f70d8e9SYang Jihong if (kwork->event_list_str == NULL) 16070f70d8e9SYang Jihong goto null_event_list_str; 16080f70d8e9SYang Jihong 16090f70d8e9SYang Jihong str = strdup(kwork->event_list_str); 16100f70d8e9SYang Jihong for (tok = strtok_r(str, ", ", &tmp); 16110f70d8e9SYang Jihong tok; tok = strtok_r(NULL, ", ", &tmp)) { 16120f70d8e9SYang Jihong for (i = 0; i < KWORK_CLASS_MAX; i++) { 16130f70d8e9SYang Jihong class = kwork_class_supported_list[i]; 16140f70d8e9SYang Jihong if (strcmp(tok, class->name) == 0) { 16150f70d8e9SYang Jihong list_add_tail(&class->list, &kwork->class_list); 16160f70d8e9SYang Jihong break; 16170f70d8e9SYang Jihong } 16180f70d8e9SYang Jihong } 16190f70d8e9SYang Jihong if (i == KWORK_CLASS_MAX) { 16200f70d8e9SYang Jihong usage_with_options_msg(usage_msg, options, 16210f70d8e9SYang Jihong "Unknown --event key: `%s'", tok); 16220f70d8e9SYang Jihong } 16230f70d8e9SYang Jihong } 16240f70d8e9SYang Jihong free(str); 16250f70d8e9SYang Jihong 16260f70d8e9SYang Jihong null_event_list_str: 16270f70d8e9SYang Jihong /* 16280f70d8e9SYang Jihong * config all kwork events if not specified 16290f70d8e9SYang Jihong */ 16300f70d8e9SYang Jihong if (list_empty(&kwork->class_list)) { 16310f70d8e9SYang Jihong for (i = 0; i < KWORK_CLASS_MAX; i++) { 16320f70d8e9SYang Jihong list_add_tail(&kwork_class_supported_list[i]->list, 16330f70d8e9SYang Jihong &kwork->class_list); 16340f70d8e9SYang Jihong } 16350f70d8e9SYang Jihong } 16360f70d8e9SYang Jihong 16370f70d8e9SYang Jihong pr_debug("Config event list:"); 16380f70d8e9SYang Jihong list_for_each_entry(class, &kwork->class_list, list) 16390f70d8e9SYang Jihong pr_debug(" %s", class->name); 16400f70d8e9SYang Jihong pr_debug("\n"); 16410f70d8e9SYang Jihong } 16420f70d8e9SYang Jihong 16430f70d8e9SYang Jihong static int perf_kwork__record(struct perf_kwork *kwork, 16440f70d8e9SYang Jihong int argc, const char **argv) 16450f70d8e9SYang Jihong { 16460f70d8e9SYang Jihong const char **rec_argv; 16470f70d8e9SYang Jihong unsigned int rec_argc, i, j; 16480f70d8e9SYang Jihong struct kwork_class *class; 16490f70d8e9SYang Jihong 16500f70d8e9SYang Jihong const char *const record_args[] = { 16510f70d8e9SYang Jihong "record", 16520f70d8e9SYang Jihong "-a", 16530f70d8e9SYang Jihong "-R", 16540f70d8e9SYang Jihong "-m", "1024", 16550f70d8e9SYang Jihong "-c", "1", 16560f70d8e9SYang Jihong }; 16570f70d8e9SYang Jihong 16580f70d8e9SYang Jihong rec_argc = ARRAY_SIZE(record_args) + argc - 1; 16590f70d8e9SYang Jihong 16600f70d8e9SYang Jihong list_for_each_entry(class, &kwork->class_list, list) 16610f70d8e9SYang Jihong rec_argc += 2 * class->nr_tracepoints; 16620f70d8e9SYang Jihong 16630f70d8e9SYang Jihong rec_argv = calloc(rec_argc + 1, sizeof(char *)); 16640f70d8e9SYang Jihong if (rec_argv == NULL) 16650f70d8e9SYang Jihong return -ENOMEM; 16660f70d8e9SYang Jihong 16670f70d8e9SYang Jihong for (i = 0; i < ARRAY_SIZE(record_args); i++) 16680f70d8e9SYang Jihong rec_argv[i] = strdup(record_args[i]); 16690f70d8e9SYang Jihong 16700f70d8e9SYang Jihong list_for_each_entry(class, &kwork->class_list, list) { 16710f70d8e9SYang Jihong for (j = 0; j < class->nr_tracepoints; j++) { 16720f70d8e9SYang Jihong rec_argv[i++] = strdup("-e"); 16730f70d8e9SYang Jihong rec_argv[i++] = strdup(class->tp_handlers[j].name); 16740f70d8e9SYang Jihong } 16750f70d8e9SYang Jihong } 16760f70d8e9SYang Jihong 16770f70d8e9SYang Jihong for (j = 1; j < (unsigned int)argc; j++, i++) 16780f70d8e9SYang Jihong rec_argv[i] = argv[j]; 16790f70d8e9SYang Jihong 16800f70d8e9SYang Jihong BUG_ON(i != rec_argc); 16810f70d8e9SYang Jihong 16820f70d8e9SYang Jihong pr_debug("record comm: "); 16830f70d8e9SYang Jihong for (j = 0; j < rec_argc; j++) 16840f70d8e9SYang Jihong pr_debug("%s ", rec_argv[j]); 16850f70d8e9SYang Jihong pr_debug("\n"); 16860f70d8e9SYang Jihong 16870f70d8e9SYang Jihong return cmd_record(i, rec_argv); 16880f70d8e9SYang Jihong } 16890f70d8e9SYang Jihong 16900f70d8e9SYang Jihong int cmd_kwork(int argc, const char **argv) 16910f70d8e9SYang Jihong { 16920f70d8e9SYang Jihong static struct perf_kwork kwork = { 16930f70d8e9SYang Jihong .class_list = LIST_HEAD_INIT(kwork.class_list), 1694f98919ecSYang Jihong .tool = { 1695f98919ecSYang Jihong .mmap = perf_event__process_mmap, 1696f98919ecSYang Jihong .mmap2 = perf_event__process_mmap2, 1697f98919ecSYang Jihong .sample = perf_kwork__process_tracepoint_sample, 1698f98919ecSYang Jihong }, 1699f98919ecSYang Jihong .atom_page_list = LIST_HEAD_INIT(kwork.atom_page_list), 1700f98919ecSYang Jihong .sort_list = LIST_HEAD_INIT(kwork.sort_list), 1701f98919ecSYang Jihong .cmp_id = LIST_HEAD_INIT(kwork.cmp_id), 1702f98919ecSYang Jihong .sorted_work_root = RB_ROOT_CACHED, 1703f98919ecSYang Jihong .tp_handler = NULL, 1704f98919ecSYang Jihong .profile_name = NULL, 1705f98919ecSYang Jihong .cpu_list = NULL, 1706f98919ecSYang Jihong .time_str = NULL, 17070f70d8e9SYang Jihong .force = false, 17080f70d8e9SYang Jihong .event_list_str = NULL, 1709f98919ecSYang Jihong .summary = false, 1710f98919ecSYang Jihong .sort_order = NULL, 1711bcc8b3e8SYang Jihong .show_callchain = false, 1712bcc8b3e8SYang Jihong .max_stack = 5, 1713f98919ecSYang Jihong .timestart = 0, 1714f98919ecSYang Jihong .timeend = 0, 1715f98919ecSYang Jihong .nr_events = 0, 1716f98919ecSYang Jihong .nr_lost_chunks = 0, 1717f98919ecSYang Jihong .nr_lost_events = 0, 1718f98919ecSYang Jihong .all_runtime = 0, 1719f98919ecSYang Jihong .all_count = 0, 1720f98919ecSYang Jihong .nr_skipped_events = { 0 }, 17210f70d8e9SYang Jihong }; 1722f98919ecSYang Jihong static const char default_report_sort_order[] = "runtime, max, count"; 1723ad3d9f7aSYang Jihong static const char default_latency_sort_order[] = "avg, max, count"; 17240f70d8e9SYang Jihong const struct option kwork_options[] = { 17250f70d8e9SYang Jihong OPT_INCR('v', "verbose", &verbose, 17260f70d8e9SYang Jihong "be more verbose (show symbol address, etc)"), 17270f70d8e9SYang Jihong OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 17280f70d8e9SYang Jihong "dump raw trace in ASCII"), 17290f70d8e9SYang Jihong OPT_STRING('k', "kwork", &kwork.event_list_str, "kwork", 173097179d9dSYang Jihong "list of kwork to profile (irq, softirq, workqueue, etc)"), 17310f70d8e9SYang Jihong OPT_BOOLEAN('f', "force", &kwork.force, "don't complain, do it"), 17320f70d8e9SYang Jihong OPT_END() 17330f70d8e9SYang Jihong }; 1734f98919ecSYang Jihong const struct option report_options[] = { 1735f98919ecSYang Jihong OPT_STRING('s', "sort", &kwork.sort_order, "key[,key2...]", 1736f98919ecSYang Jihong "sort by key(s): runtime, max, count"), 1737f98919ecSYang Jihong OPT_STRING('C', "cpu", &kwork.cpu_list, "cpu", 1738f98919ecSYang Jihong "list of cpus to profile"), 1739f98919ecSYang Jihong OPT_STRING('n', "name", &kwork.profile_name, "name", 1740f98919ecSYang Jihong "event name to profile"), 1741f98919ecSYang Jihong OPT_STRING(0, "time", &kwork.time_str, "str", 1742f98919ecSYang Jihong "Time span for analysis (start,stop)"), 1743f98919ecSYang Jihong OPT_STRING('i', "input", &input_name, "file", 1744f98919ecSYang Jihong "input file name"), 1745f98919ecSYang Jihong OPT_BOOLEAN('S', "with-summary", &kwork.summary, 1746f98919ecSYang Jihong "Show summary with statistics"), 1747daf07d22SYang Jihong #ifdef HAVE_BPF_SKEL 1748daf07d22SYang Jihong OPT_BOOLEAN('b', "use-bpf", &kwork.use_bpf, 1749daf07d22SYang Jihong "Use BPF to measure kwork runtime"), 1750daf07d22SYang Jihong #endif 1751f98919ecSYang Jihong OPT_PARENT(kwork_options) 1752f98919ecSYang Jihong }; 1753ad3d9f7aSYang Jihong const struct option latency_options[] = { 1754ad3d9f7aSYang Jihong OPT_STRING('s', "sort", &kwork.sort_order, "key[,key2...]", 1755ad3d9f7aSYang Jihong "sort by key(s): avg, max, count"), 1756ad3d9f7aSYang Jihong OPT_STRING('C', "cpu", &kwork.cpu_list, "cpu", 1757ad3d9f7aSYang Jihong "list of cpus to profile"), 1758ad3d9f7aSYang Jihong OPT_STRING('n', "name", &kwork.profile_name, "name", 1759ad3d9f7aSYang Jihong "event name to profile"), 1760ad3d9f7aSYang Jihong OPT_STRING(0, "time", &kwork.time_str, "str", 1761ad3d9f7aSYang Jihong "Time span for analysis (start,stop)"), 1762ad3d9f7aSYang Jihong OPT_STRING('i', "input", &input_name, "file", 1763ad3d9f7aSYang Jihong "input file name"), 1764daf07d22SYang Jihong #ifdef HAVE_BPF_SKEL 1765daf07d22SYang Jihong OPT_BOOLEAN('b', "use-bpf", &kwork.use_bpf, 1766daf07d22SYang Jihong "Use BPF to measure kwork latency"), 1767daf07d22SYang Jihong #endif 1768ad3d9f7aSYang Jihong OPT_PARENT(kwork_options) 1769ad3d9f7aSYang Jihong }; 1770bcc8b3e8SYang Jihong const struct option timehist_options[] = { 1771bcc8b3e8SYang Jihong OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 1772bcc8b3e8SYang Jihong "file", "vmlinux pathname"), 1773bcc8b3e8SYang Jihong OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, 1774bcc8b3e8SYang Jihong "file", "kallsyms pathname"), 1775bcc8b3e8SYang Jihong OPT_BOOLEAN('g', "call-graph", &kwork.show_callchain, 1776bcc8b3e8SYang Jihong "Display call chains if present"), 1777bcc8b3e8SYang Jihong OPT_UINTEGER(0, "max-stack", &kwork.max_stack, 1778bcc8b3e8SYang Jihong "Maximum number of functions to display backtrace."), 1779bcc8b3e8SYang Jihong OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 1780bcc8b3e8SYang Jihong "Look for files with symbols relative to this directory"), 1781bcc8b3e8SYang Jihong OPT_STRING(0, "time", &kwork.time_str, "str", 1782bcc8b3e8SYang Jihong "Time span for analysis (start,stop)"), 1783bcc8b3e8SYang Jihong OPT_STRING('C', "cpu", &kwork.cpu_list, "cpu", 1784bcc8b3e8SYang Jihong "list of cpus to profile"), 1785bcc8b3e8SYang Jihong OPT_STRING('n', "name", &kwork.profile_name, "name", 1786bcc8b3e8SYang Jihong "event name to profile"), 1787bcc8b3e8SYang Jihong OPT_STRING('i', "input", &input_name, "file", 1788bcc8b3e8SYang Jihong "input file name"), 1789bcc8b3e8SYang Jihong OPT_PARENT(kwork_options) 1790bcc8b3e8SYang Jihong }; 17910f70d8e9SYang Jihong const char *kwork_usage[] = { 17920f70d8e9SYang Jihong NULL, 17930f70d8e9SYang Jihong NULL 17940f70d8e9SYang Jihong }; 1795f98919ecSYang Jihong const char * const report_usage[] = { 1796f98919ecSYang Jihong "perf kwork report [<options>]", 1797f98919ecSYang Jihong NULL 1798f98919ecSYang Jihong }; 1799ad3d9f7aSYang Jihong const char * const latency_usage[] = { 1800ad3d9f7aSYang Jihong "perf kwork latency [<options>]", 1801ad3d9f7aSYang Jihong NULL 1802ad3d9f7aSYang Jihong }; 1803bcc8b3e8SYang Jihong const char * const timehist_usage[] = { 1804bcc8b3e8SYang Jihong "perf kwork timehist [<options>]", 1805bcc8b3e8SYang Jihong NULL 1806bcc8b3e8SYang Jihong }; 18070f70d8e9SYang Jihong const char *const kwork_subcommands[] = { 1808bcc8b3e8SYang Jihong "record", "report", "latency", "timehist", NULL 18090f70d8e9SYang Jihong }; 18100f70d8e9SYang Jihong 18110f70d8e9SYang Jihong argc = parse_options_subcommand(argc, argv, kwork_options, 18120f70d8e9SYang Jihong kwork_subcommands, kwork_usage, 18130f70d8e9SYang Jihong PARSE_OPT_STOP_AT_NON_OPTION); 18140f70d8e9SYang Jihong if (!argc) 18150f70d8e9SYang Jihong usage_with_options(kwork_usage, kwork_options); 18160f70d8e9SYang Jihong 18170f70d8e9SYang Jihong setup_event_list(&kwork, kwork_options, kwork_usage); 1818f98919ecSYang Jihong sort_dimension__add(&kwork, "id", &kwork.cmp_id); 18190f70d8e9SYang Jihong 18200f70d8e9SYang Jihong if (strlen(argv[0]) > 2 && strstarts("record", argv[0])) 18210f70d8e9SYang Jihong return perf_kwork__record(&kwork, argc, argv); 1822f98919ecSYang Jihong else if (strlen(argv[0]) > 2 && strstarts("report", argv[0])) { 1823f98919ecSYang Jihong kwork.sort_order = default_report_sort_order; 1824f98919ecSYang Jihong if (argc > 1) { 1825f98919ecSYang Jihong argc = parse_options(argc, argv, report_options, report_usage, 0); 1826f98919ecSYang Jihong if (argc) 1827f98919ecSYang Jihong usage_with_options(report_usage, report_options); 1828f98919ecSYang Jihong } 1829f98919ecSYang Jihong kwork.report = KWORK_REPORT_RUNTIME; 1830f98919ecSYang Jihong setup_sorting(&kwork, report_options, report_usage); 1831f98919ecSYang Jihong return perf_kwork__report(&kwork); 1832ad3d9f7aSYang Jihong } else if (strlen(argv[0]) > 2 && strstarts("latency", argv[0])) { 1833ad3d9f7aSYang Jihong kwork.sort_order = default_latency_sort_order; 1834ad3d9f7aSYang Jihong if (argc > 1) { 1835ad3d9f7aSYang Jihong argc = parse_options(argc, argv, latency_options, latency_usage, 0); 1836ad3d9f7aSYang Jihong if (argc) 1837ad3d9f7aSYang Jihong usage_with_options(latency_usage, latency_options); 1838ad3d9f7aSYang Jihong } 1839ad3d9f7aSYang Jihong kwork.report = KWORK_REPORT_LATENCY; 1840ad3d9f7aSYang Jihong setup_sorting(&kwork, latency_options, latency_usage); 1841ad3d9f7aSYang Jihong return perf_kwork__report(&kwork); 1842bcc8b3e8SYang Jihong } else if (strlen(argv[0]) > 2 && strstarts("timehist", argv[0])) { 1843bcc8b3e8SYang Jihong if (argc > 1) { 1844bcc8b3e8SYang Jihong argc = parse_options(argc, argv, timehist_options, timehist_usage, 0); 1845bcc8b3e8SYang Jihong if (argc) 1846bcc8b3e8SYang Jihong usage_with_options(timehist_usage, timehist_options); 1847bcc8b3e8SYang Jihong } 1848bcc8b3e8SYang Jihong kwork.report = KWORK_REPORT_TIMEHIST; 1849bcc8b3e8SYang Jihong return perf_kwork__timehist(&kwork); 1850f98919ecSYang Jihong } else 18510f70d8e9SYang Jihong usage_with_options(kwork_usage, kwork_options); 18520f70d8e9SYang Jihong 18530f70d8e9SYang Jihong return 0; 18540f70d8e9SYang Jihong } 1855