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" 110f70d8e9SYang Jihong #include "util/kwork.h" 120f70d8e9SYang Jihong #include "util/debug.h" 130f70d8e9SYang Jihong #include "util/symbol.h" 140f70d8e9SYang Jihong #include "util/thread.h" 150f70d8e9SYang Jihong #include "util/string2.h" 160f70d8e9SYang Jihong #include "util/callchain.h" 170f70d8e9SYang Jihong #include "util/evsel_fprintf.h" 180f70d8e9SYang Jihong 190f70d8e9SYang Jihong #include <subcmd/pager.h> 200f70d8e9SYang Jihong #include <subcmd/parse-options.h> 210f70d8e9SYang Jihong 220f70d8e9SYang Jihong #include <errno.h> 230f70d8e9SYang Jihong #include <inttypes.h> 240f70d8e9SYang Jihong #include <linux/err.h> 250f70d8e9SYang Jihong #include <linux/time64.h> 260f70d8e9SYang Jihong #include <linux/zalloc.h> 270f70d8e9SYang Jihong 28f98919ecSYang Jihong /* 29f98919ecSYang Jihong * report header elements width 30f98919ecSYang Jihong */ 31f98919ecSYang Jihong #define PRINT_CPU_WIDTH 4 32f98919ecSYang Jihong #define PRINT_COUNT_WIDTH 9 33f98919ecSYang Jihong #define PRINT_RUNTIME_WIDTH 10 34f98919ecSYang Jihong #define PRINT_TIMESTAMP_WIDTH 17 35f98919ecSYang Jihong #define PRINT_KWORK_NAME_WIDTH 30 36f98919ecSYang Jihong #define RPINT_DECIMAL_WIDTH 3 37f98919ecSYang Jihong #define PRINT_TIME_UNIT_SEC_WIDTH 2 38f98919ecSYang Jihong #define PRINT_TIME_UNIT_MESC_WIDTH 3 39f98919ecSYang Jihong #define PRINT_RUNTIME_HEADER_WIDTH (PRINT_RUNTIME_WIDTH + PRINT_TIME_UNIT_MESC_WIDTH) 40f98919ecSYang Jihong #define PRINT_TIMESTAMP_HEADER_WIDTH (PRINT_TIMESTAMP_WIDTH + PRINT_TIME_UNIT_SEC_WIDTH) 41f98919ecSYang Jihong 42f98919ecSYang Jihong struct sort_dimension { 43f98919ecSYang Jihong const char *name; 44f98919ecSYang Jihong int (*cmp)(struct kwork_work *l, struct kwork_work *r); 45f98919ecSYang Jihong struct list_head list; 46f98919ecSYang Jihong }; 47f98919ecSYang Jihong 48f98919ecSYang Jihong static int id_cmp(struct kwork_work *l, struct kwork_work *r) 49f98919ecSYang Jihong { 50f98919ecSYang Jihong if (l->cpu > r->cpu) 51f98919ecSYang Jihong return 1; 52f98919ecSYang Jihong if (l->cpu < r->cpu) 53f98919ecSYang Jihong return -1; 54f98919ecSYang Jihong 55f98919ecSYang Jihong if (l->id > r->id) 56f98919ecSYang Jihong return 1; 57f98919ecSYang Jihong if (l->id < r->id) 58f98919ecSYang Jihong return -1; 59f98919ecSYang Jihong 60f98919ecSYang Jihong return 0; 61f98919ecSYang Jihong } 62f98919ecSYang Jihong 63f98919ecSYang Jihong static int count_cmp(struct kwork_work *l, struct kwork_work *r) 64f98919ecSYang Jihong { 65f98919ecSYang Jihong if (l->nr_atoms > r->nr_atoms) 66f98919ecSYang Jihong return 1; 67f98919ecSYang Jihong if (l->nr_atoms < r->nr_atoms) 68f98919ecSYang Jihong return -1; 69f98919ecSYang Jihong 70f98919ecSYang Jihong return 0; 71f98919ecSYang Jihong } 72f98919ecSYang Jihong 73f98919ecSYang Jihong static int runtime_cmp(struct kwork_work *l, struct kwork_work *r) 74f98919ecSYang Jihong { 75f98919ecSYang Jihong if (l->total_runtime > r->total_runtime) 76f98919ecSYang Jihong return 1; 77f98919ecSYang Jihong if (l->total_runtime < r->total_runtime) 78f98919ecSYang Jihong return -1; 79f98919ecSYang Jihong 80f98919ecSYang Jihong return 0; 81f98919ecSYang Jihong } 82f98919ecSYang Jihong 83f98919ecSYang Jihong static int max_runtime_cmp(struct kwork_work *l, struct kwork_work *r) 84f98919ecSYang Jihong { 85f98919ecSYang Jihong if (l->max_runtime > r->max_runtime) 86f98919ecSYang Jihong return 1; 87f98919ecSYang Jihong if (l->max_runtime < r->max_runtime) 88f98919ecSYang Jihong return -1; 89f98919ecSYang Jihong 90f98919ecSYang Jihong return 0; 91f98919ecSYang Jihong } 92f98919ecSYang Jihong 93f98919ecSYang Jihong static int sort_dimension__add(struct perf_kwork *kwork __maybe_unused, 94f98919ecSYang Jihong const char *tok, struct list_head *list) 95f98919ecSYang Jihong { 96f98919ecSYang Jihong size_t i; 97f98919ecSYang Jihong static struct sort_dimension max_sort_dimension = { 98f98919ecSYang Jihong .name = "max", 99f98919ecSYang Jihong .cmp = max_runtime_cmp, 100f98919ecSYang Jihong }; 101f98919ecSYang Jihong static struct sort_dimension id_sort_dimension = { 102f98919ecSYang Jihong .name = "id", 103f98919ecSYang Jihong .cmp = id_cmp, 104f98919ecSYang Jihong }; 105f98919ecSYang Jihong static struct sort_dimension runtime_sort_dimension = { 106f98919ecSYang Jihong .name = "runtime", 107f98919ecSYang Jihong .cmp = runtime_cmp, 108f98919ecSYang Jihong }; 109f98919ecSYang Jihong static struct sort_dimension count_sort_dimension = { 110f98919ecSYang Jihong .name = "count", 111f98919ecSYang Jihong .cmp = count_cmp, 112f98919ecSYang Jihong }; 113f98919ecSYang Jihong struct sort_dimension *available_sorts[] = { 114f98919ecSYang Jihong &id_sort_dimension, 115f98919ecSYang Jihong &max_sort_dimension, 116f98919ecSYang Jihong &count_sort_dimension, 117f98919ecSYang Jihong &runtime_sort_dimension, 118f98919ecSYang Jihong }; 119f98919ecSYang Jihong 120f98919ecSYang Jihong for (i = 0; i < ARRAY_SIZE(available_sorts); i++) { 121f98919ecSYang Jihong if (!strcmp(available_sorts[i]->name, tok)) { 122f98919ecSYang Jihong list_add_tail(&available_sorts[i]->list, list); 123f98919ecSYang Jihong return 0; 124f98919ecSYang Jihong } 125f98919ecSYang Jihong } 126f98919ecSYang Jihong 127f98919ecSYang Jihong return -1; 128f98919ecSYang Jihong } 129f98919ecSYang Jihong 130f98919ecSYang Jihong static void setup_sorting(struct perf_kwork *kwork, 131f98919ecSYang Jihong const struct option *options, 132f98919ecSYang Jihong const char * const usage_msg[]) 133f98919ecSYang Jihong { 134f98919ecSYang Jihong char *tmp, *tok, *str = strdup(kwork->sort_order); 135f98919ecSYang Jihong 136f98919ecSYang Jihong for (tok = strtok_r(str, ", ", &tmp); 137f98919ecSYang Jihong tok; tok = strtok_r(NULL, ", ", &tmp)) { 138f98919ecSYang Jihong if (sort_dimension__add(kwork, tok, &kwork->sort_list) < 0) 139f98919ecSYang Jihong usage_with_options_msg(usage_msg, options, 140f98919ecSYang Jihong "Unknown --sort key: `%s'", tok); 141f98919ecSYang Jihong } 142f98919ecSYang Jihong 143f98919ecSYang Jihong pr_debug("Sort order: %s\n", kwork->sort_order); 144f98919ecSYang Jihong free(str); 145f98919ecSYang Jihong } 146f98919ecSYang Jihong 147f98919ecSYang Jihong static struct kwork_atom *atom_new(struct perf_kwork *kwork, 148f98919ecSYang Jihong struct perf_sample *sample) 149f98919ecSYang Jihong { 150f98919ecSYang Jihong unsigned long i; 151f98919ecSYang Jihong struct kwork_atom_page *page; 152f98919ecSYang Jihong struct kwork_atom *atom = NULL; 153f98919ecSYang Jihong 154f98919ecSYang Jihong list_for_each_entry(page, &kwork->atom_page_list, list) { 155f98919ecSYang Jihong if (!bitmap_full(page->bitmap, NR_ATOM_PER_PAGE)) { 156f98919ecSYang Jihong i = find_first_zero_bit(page->bitmap, NR_ATOM_PER_PAGE); 157f98919ecSYang Jihong BUG_ON(i >= NR_ATOM_PER_PAGE); 158f98919ecSYang Jihong atom = &page->atoms[i]; 159f98919ecSYang Jihong goto found_atom; 160f98919ecSYang Jihong } 161f98919ecSYang Jihong } 162f98919ecSYang Jihong 163f98919ecSYang Jihong /* 164f98919ecSYang Jihong * new page 165f98919ecSYang Jihong */ 166f98919ecSYang Jihong page = zalloc(sizeof(*page)); 167f98919ecSYang Jihong if (page == NULL) { 168f98919ecSYang Jihong pr_err("Failed to zalloc kwork atom page\n"); 169f98919ecSYang Jihong return NULL; 170f98919ecSYang Jihong } 171f98919ecSYang Jihong 172f98919ecSYang Jihong i = 0; 173f98919ecSYang Jihong atom = &page->atoms[0]; 174f98919ecSYang Jihong list_add_tail(&page->list, &kwork->atom_page_list); 175f98919ecSYang Jihong 176f98919ecSYang Jihong found_atom: 177f98919ecSYang Jihong set_bit(i, page->bitmap); 178f98919ecSYang Jihong atom->time = sample->time; 179f98919ecSYang Jihong atom->prev = NULL; 180f98919ecSYang Jihong atom->page_addr = page; 181f98919ecSYang Jihong atom->bit_inpage = i; 182f98919ecSYang Jihong return atom; 183f98919ecSYang Jihong } 184f98919ecSYang Jihong 185f98919ecSYang Jihong static void atom_free(struct kwork_atom *atom) 186f98919ecSYang Jihong { 187f98919ecSYang Jihong if (atom->prev != NULL) 188f98919ecSYang Jihong atom_free(atom->prev); 189f98919ecSYang Jihong 190f98919ecSYang Jihong clear_bit(atom->bit_inpage, 191f98919ecSYang Jihong ((struct kwork_atom_page *)atom->page_addr)->bitmap); 192f98919ecSYang Jihong } 193f98919ecSYang Jihong 194f98919ecSYang Jihong static void atom_del(struct kwork_atom *atom) 195f98919ecSYang Jihong { 196f98919ecSYang Jihong list_del(&atom->list); 197f98919ecSYang Jihong atom_free(atom); 198f98919ecSYang Jihong } 199f98919ecSYang Jihong 200f98919ecSYang Jihong static int work_cmp(struct list_head *list, 201f98919ecSYang Jihong struct kwork_work *l, struct kwork_work *r) 202f98919ecSYang Jihong { 203f98919ecSYang Jihong int ret = 0; 204f98919ecSYang Jihong struct sort_dimension *sort; 205f98919ecSYang Jihong 206f98919ecSYang Jihong BUG_ON(list_empty(list)); 207f98919ecSYang Jihong 208f98919ecSYang Jihong list_for_each_entry(sort, list, list) { 209f98919ecSYang Jihong ret = sort->cmp(l, r); 210f98919ecSYang Jihong if (ret) 211f98919ecSYang Jihong return ret; 212f98919ecSYang Jihong } 213f98919ecSYang Jihong 214f98919ecSYang Jihong return ret; 215f98919ecSYang Jihong } 216f98919ecSYang Jihong 217f98919ecSYang Jihong static struct kwork_work *work_search(struct rb_root_cached *root, 218f98919ecSYang Jihong struct kwork_work *key, 219f98919ecSYang Jihong struct list_head *sort_list) 220f98919ecSYang Jihong { 221f98919ecSYang Jihong int cmp; 222f98919ecSYang Jihong struct kwork_work *work; 223f98919ecSYang Jihong struct rb_node *node = root->rb_root.rb_node; 224f98919ecSYang Jihong 225f98919ecSYang Jihong while (node) { 226f98919ecSYang Jihong work = container_of(node, struct kwork_work, node); 227f98919ecSYang Jihong cmp = work_cmp(sort_list, key, work); 228f98919ecSYang Jihong if (cmp > 0) 229f98919ecSYang Jihong node = node->rb_left; 230f98919ecSYang Jihong else if (cmp < 0) 231f98919ecSYang Jihong node = node->rb_right; 232f98919ecSYang Jihong else { 233f98919ecSYang Jihong if (work->name == NULL) 234f98919ecSYang Jihong work->name = key->name; 235f98919ecSYang Jihong return work; 236f98919ecSYang Jihong } 237f98919ecSYang Jihong } 238f98919ecSYang Jihong return NULL; 239f98919ecSYang Jihong } 240f98919ecSYang Jihong 241f98919ecSYang Jihong static void work_insert(struct rb_root_cached *root, 242f98919ecSYang Jihong struct kwork_work *key, struct list_head *sort_list) 243f98919ecSYang Jihong { 244f98919ecSYang Jihong int cmp; 245f98919ecSYang Jihong bool leftmost = true; 246f98919ecSYang Jihong struct kwork_work *cur; 247f98919ecSYang Jihong struct rb_node **new = &(root->rb_root.rb_node), *parent = NULL; 248f98919ecSYang Jihong 249f98919ecSYang Jihong while (*new) { 250f98919ecSYang Jihong cur = container_of(*new, struct kwork_work, node); 251f98919ecSYang Jihong parent = *new; 252f98919ecSYang Jihong cmp = work_cmp(sort_list, key, cur); 253f98919ecSYang Jihong 254f98919ecSYang Jihong if (cmp > 0) 255f98919ecSYang Jihong new = &((*new)->rb_left); 256f98919ecSYang Jihong else { 257f98919ecSYang Jihong new = &((*new)->rb_right); 258f98919ecSYang Jihong leftmost = false; 259f98919ecSYang Jihong } 260f98919ecSYang Jihong } 261f98919ecSYang Jihong 262f98919ecSYang Jihong rb_link_node(&key->node, parent, new); 263f98919ecSYang Jihong rb_insert_color_cached(&key->node, root, leftmost); 264f98919ecSYang Jihong } 265f98919ecSYang Jihong 266f98919ecSYang Jihong static struct kwork_work *work_new(struct kwork_work *key) 267f98919ecSYang Jihong { 268f98919ecSYang Jihong int i; 269f98919ecSYang Jihong struct kwork_work *work = zalloc(sizeof(*work)); 270f98919ecSYang Jihong 271f98919ecSYang Jihong if (work == NULL) { 272f98919ecSYang Jihong pr_err("Failed to zalloc kwork work\n"); 273f98919ecSYang Jihong return NULL; 274f98919ecSYang Jihong } 275f98919ecSYang Jihong 276f98919ecSYang Jihong for (i = 0; i < KWORK_TRACE_MAX; i++) 277f98919ecSYang Jihong INIT_LIST_HEAD(&work->atom_list[i]); 278f98919ecSYang Jihong 279f98919ecSYang Jihong work->id = key->id; 280f98919ecSYang Jihong work->cpu = key->cpu; 281f98919ecSYang Jihong work->name = key->name; 282f98919ecSYang Jihong work->class = key->class; 283f98919ecSYang Jihong return work; 284f98919ecSYang Jihong } 285f98919ecSYang Jihong 286f98919ecSYang Jihong static struct kwork_work *work_findnew(struct rb_root_cached *root, 287f98919ecSYang Jihong struct kwork_work *key, 288f98919ecSYang Jihong struct list_head *sort_list) 289f98919ecSYang Jihong { 290f98919ecSYang Jihong struct kwork_work *work = NULL; 291f98919ecSYang Jihong 292f98919ecSYang Jihong work = work_search(root, key, sort_list); 293f98919ecSYang Jihong if (work != NULL) 294f98919ecSYang Jihong return work; 295f98919ecSYang Jihong 296f98919ecSYang Jihong work = work_new(key); 297f98919ecSYang Jihong if (work == NULL) 298f98919ecSYang Jihong return NULL; 299f98919ecSYang Jihong 300f98919ecSYang Jihong work_insert(root, work, sort_list); 301f98919ecSYang Jihong return work; 302f98919ecSYang Jihong } 303f98919ecSYang Jihong 304f98919ecSYang Jihong static void profile_update_timespan(struct perf_kwork *kwork, 305f98919ecSYang Jihong struct perf_sample *sample) 306f98919ecSYang Jihong { 307f98919ecSYang Jihong if (!kwork->summary) 308f98919ecSYang Jihong return; 309f98919ecSYang Jihong 310f98919ecSYang Jihong if ((kwork->timestart == 0) || (kwork->timestart > sample->time)) 311f98919ecSYang Jihong kwork->timestart = sample->time; 312f98919ecSYang Jihong 313f98919ecSYang Jihong if (kwork->timeend < sample->time) 314f98919ecSYang Jihong kwork->timeend = sample->time; 315f98919ecSYang Jihong } 316f98919ecSYang Jihong 317f98919ecSYang Jihong static bool profile_event_match(struct perf_kwork *kwork, 318f98919ecSYang Jihong struct kwork_work *work, 319f98919ecSYang Jihong struct perf_sample *sample) 320f98919ecSYang Jihong { 321f98919ecSYang Jihong int cpu = work->cpu; 322f98919ecSYang Jihong u64 time = sample->time; 323f98919ecSYang Jihong struct perf_time_interval *ptime = &kwork->ptime; 324f98919ecSYang Jihong 325f98919ecSYang Jihong if ((kwork->cpu_list != NULL) && !test_bit(cpu, kwork->cpu_bitmap)) 326f98919ecSYang Jihong return false; 327f98919ecSYang Jihong 328f98919ecSYang Jihong if (((ptime->start != 0) && (ptime->start > time)) || 329f98919ecSYang Jihong ((ptime->end != 0) && (ptime->end < time))) 330f98919ecSYang Jihong return false; 331f98919ecSYang Jihong 332f98919ecSYang Jihong if ((kwork->profile_name != NULL) && 333f98919ecSYang Jihong (work->name != NULL) && 334f98919ecSYang Jihong (strcmp(work->name, kwork->profile_name) != 0)) 335f98919ecSYang Jihong return false; 336f98919ecSYang Jihong 337f98919ecSYang Jihong profile_update_timespan(kwork, sample); 338f98919ecSYang Jihong return true; 339f98919ecSYang Jihong } 340f98919ecSYang Jihong 341f98919ecSYang Jihong static int work_push_atom(struct perf_kwork *kwork, 342f98919ecSYang Jihong struct kwork_class *class, 343f98919ecSYang Jihong enum kwork_trace_type src_type, 344f98919ecSYang Jihong enum kwork_trace_type dst_type, 345f98919ecSYang Jihong struct evsel *evsel, 346f98919ecSYang Jihong struct perf_sample *sample, 347f98919ecSYang Jihong struct machine *machine, 348f98919ecSYang Jihong struct kwork_work **ret_work) 349f98919ecSYang Jihong { 350f98919ecSYang Jihong struct kwork_atom *atom, *dst_atom; 351f98919ecSYang Jihong struct kwork_work *work, key; 352f98919ecSYang Jihong 353f98919ecSYang Jihong BUG_ON(class->work_init == NULL); 354f98919ecSYang Jihong class->work_init(class, &key, evsel, sample, machine); 355f98919ecSYang Jihong 356f98919ecSYang Jihong atom = atom_new(kwork, sample); 357f98919ecSYang Jihong if (atom == NULL) 358f98919ecSYang Jihong return -1; 359f98919ecSYang Jihong 360f98919ecSYang Jihong work = work_findnew(&class->work_root, &key, &kwork->cmp_id); 361f98919ecSYang Jihong if (work == NULL) { 362f98919ecSYang Jihong free(atom); 363f98919ecSYang Jihong return -1; 364f98919ecSYang Jihong } 365f98919ecSYang Jihong 366f98919ecSYang Jihong if (!profile_event_match(kwork, work, sample)) 367f98919ecSYang Jihong return 0; 368f98919ecSYang Jihong 369f98919ecSYang Jihong if (dst_type < KWORK_TRACE_MAX) { 370f98919ecSYang Jihong dst_atom = list_last_entry_or_null(&work->atom_list[dst_type], 371f98919ecSYang Jihong struct kwork_atom, list); 372f98919ecSYang Jihong if (dst_atom != NULL) { 373f98919ecSYang Jihong atom->prev = dst_atom; 374f98919ecSYang Jihong list_del(&dst_atom->list); 375f98919ecSYang Jihong } 376f98919ecSYang Jihong } 377f98919ecSYang Jihong 378f98919ecSYang Jihong if (ret_work != NULL) 379f98919ecSYang Jihong *ret_work = work; 380f98919ecSYang Jihong 381f98919ecSYang Jihong list_add_tail(&atom->list, &work->atom_list[src_type]); 382f98919ecSYang Jihong 383f98919ecSYang Jihong return 0; 384f98919ecSYang Jihong } 385f98919ecSYang Jihong 386f98919ecSYang Jihong static struct kwork_atom *work_pop_atom(struct perf_kwork *kwork, 387f98919ecSYang Jihong struct kwork_class *class, 388f98919ecSYang Jihong enum kwork_trace_type src_type, 389f98919ecSYang Jihong enum kwork_trace_type dst_type, 390f98919ecSYang Jihong struct evsel *evsel, 391f98919ecSYang Jihong struct perf_sample *sample, 392f98919ecSYang Jihong struct machine *machine, 393f98919ecSYang Jihong struct kwork_work **ret_work) 394f98919ecSYang Jihong { 395f98919ecSYang Jihong struct kwork_atom *atom, *src_atom; 396f98919ecSYang Jihong struct kwork_work *work, key; 397f98919ecSYang Jihong 398f98919ecSYang Jihong BUG_ON(class->work_init == NULL); 399f98919ecSYang Jihong class->work_init(class, &key, evsel, sample, machine); 400f98919ecSYang Jihong 401f98919ecSYang Jihong work = work_findnew(&class->work_root, &key, &kwork->cmp_id); 402f98919ecSYang Jihong if (ret_work != NULL) 403f98919ecSYang Jihong *ret_work = work; 404f98919ecSYang Jihong 405f98919ecSYang Jihong if (work == NULL) 406f98919ecSYang Jihong return NULL; 407f98919ecSYang Jihong 408f98919ecSYang Jihong if (!profile_event_match(kwork, work, sample)) 409f98919ecSYang Jihong return NULL; 410f98919ecSYang Jihong 411f98919ecSYang Jihong atom = list_last_entry_or_null(&work->atom_list[dst_type], 412f98919ecSYang Jihong struct kwork_atom, list); 413f98919ecSYang Jihong if (atom != NULL) 414f98919ecSYang Jihong return atom; 415f98919ecSYang Jihong 416f98919ecSYang Jihong src_atom = atom_new(kwork, sample); 417f98919ecSYang Jihong if (src_atom != NULL) 418f98919ecSYang Jihong list_add_tail(&src_atom->list, &work->atom_list[src_type]); 419f98919ecSYang Jihong else { 420f98919ecSYang Jihong if (ret_work != NULL) 421f98919ecSYang Jihong *ret_work = NULL; 422f98919ecSYang Jihong } 423f98919ecSYang Jihong 424f98919ecSYang Jihong return NULL; 425f98919ecSYang Jihong } 426f98919ecSYang Jihong 427f98919ecSYang Jihong static void report_update_exit_event(struct kwork_work *work, 428f98919ecSYang Jihong struct kwork_atom *atom, 429f98919ecSYang Jihong struct perf_sample *sample) 430f98919ecSYang Jihong { 431f98919ecSYang Jihong u64 delta; 432f98919ecSYang Jihong u64 exit_time = sample->time; 433f98919ecSYang Jihong u64 entry_time = atom->time; 434f98919ecSYang Jihong 435f98919ecSYang Jihong if ((entry_time != 0) && (exit_time >= entry_time)) { 436f98919ecSYang Jihong delta = exit_time - entry_time; 437f98919ecSYang Jihong if ((delta > work->max_runtime) || 438f98919ecSYang Jihong (work->max_runtime == 0)) { 439f98919ecSYang Jihong work->max_runtime = delta; 440f98919ecSYang Jihong work->max_runtime_start = entry_time; 441f98919ecSYang Jihong work->max_runtime_end = exit_time; 442f98919ecSYang Jihong } 443f98919ecSYang Jihong work->total_runtime += delta; 444f98919ecSYang Jihong work->nr_atoms++; 445f98919ecSYang Jihong } 446f98919ecSYang Jihong } 447f98919ecSYang Jihong 448f98919ecSYang Jihong static int report_entry_event(struct perf_kwork *kwork, 449f98919ecSYang Jihong struct kwork_class *class, 450f98919ecSYang Jihong struct evsel *evsel, 451f98919ecSYang Jihong struct perf_sample *sample, 452f98919ecSYang Jihong struct machine *machine) 453f98919ecSYang Jihong { 454f98919ecSYang Jihong return work_push_atom(kwork, class, KWORK_TRACE_ENTRY, 455f98919ecSYang Jihong KWORK_TRACE_MAX, evsel, sample, 456f98919ecSYang Jihong machine, NULL); 457f98919ecSYang Jihong } 458f98919ecSYang Jihong 459f98919ecSYang Jihong static int report_exit_event(struct perf_kwork *kwork, 460f98919ecSYang Jihong struct kwork_class *class, 461f98919ecSYang Jihong struct evsel *evsel, 462f98919ecSYang Jihong struct perf_sample *sample, 463f98919ecSYang Jihong struct machine *machine) 464f98919ecSYang Jihong { 465f98919ecSYang Jihong struct kwork_atom *atom = NULL; 466f98919ecSYang Jihong struct kwork_work *work = NULL; 467f98919ecSYang Jihong 468f98919ecSYang Jihong atom = work_pop_atom(kwork, class, KWORK_TRACE_EXIT, 469f98919ecSYang Jihong KWORK_TRACE_ENTRY, evsel, sample, 470f98919ecSYang Jihong machine, &work); 471f98919ecSYang Jihong if (work == NULL) 472f98919ecSYang Jihong return -1; 473f98919ecSYang Jihong 474f98919ecSYang Jihong if (atom != NULL) { 475f98919ecSYang Jihong report_update_exit_event(work, atom, sample); 476f98919ecSYang Jihong atom_del(atom); 477f98919ecSYang Jihong } 478f98919ecSYang Jihong 479f98919ecSYang Jihong return 0; 480f98919ecSYang Jihong } 481f98919ecSYang Jihong 48294348520SYang Jihong static struct kwork_class kwork_irq; 48394348520SYang Jihong static int process_irq_handler_entry_event(struct perf_tool *tool, 48494348520SYang Jihong struct evsel *evsel, 48594348520SYang Jihong struct perf_sample *sample, 48694348520SYang Jihong struct machine *machine) 48794348520SYang Jihong { 48894348520SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 48994348520SYang Jihong 49094348520SYang Jihong if (kwork->tp_handler->entry_event) 49194348520SYang Jihong return kwork->tp_handler->entry_event(kwork, &kwork_irq, 49294348520SYang Jihong evsel, sample, machine); 49394348520SYang Jihong return 0; 49494348520SYang Jihong } 49594348520SYang Jihong 49694348520SYang Jihong static int process_irq_handler_exit_event(struct perf_tool *tool, 49794348520SYang Jihong struct evsel *evsel, 49894348520SYang Jihong struct perf_sample *sample, 49994348520SYang Jihong struct machine *machine) 50094348520SYang Jihong { 50194348520SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 50294348520SYang Jihong 50394348520SYang Jihong if (kwork->tp_handler->exit_event) 50494348520SYang Jihong return kwork->tp_handler->exit_event(kwork, &kwork_irq, 50594348520SYang Jihong evsel, sample, machine); 50694348520SYang Jihong return 0; 50794348520SYang Jihong } 50894348520SYang Jihong 5094f8ae962SYang Jihong const struct evsel_str_handler irq_tp_handlers[] = { 51094348520SYang Jihong { "irq:irq_handler_entry", process_irq_handler_entry_event, }, 51194348520SYang Jihong { "irq:irq_handler_exit", process_irq_handler_exit_event, }, 5124f8ae962SYang Jihong }; 5134f8ae962SYang Jihong 51494348520SYang Jihong static int irq_class_init(struct kwork_class *class, 51594348520SYang Jihong struct perf_session *session) 51694348520SYang Jihong { 51794348520SYang Jihong if (perf_session__set_tracepoints_handlers(session, irq_tp_handlers)) { 51894348520SYang Jihong pr_err("Failed to set irq tracepoints handlers\n"); 51994348520SYang Jihong return -1; 52094348520SYang Jihong } 52194348520SYang Jihong 52294348520SYang Jihong class->work_root = RB_ROOT_CACHED; 52394348520SYang Jihong return 0; 52494348520SYang Jihong } 52594348520SYang Jihong 52694348520SYang Jihong static void irq_work_init(struct kwork_class *class, 52794348520SYang Jihong struct kwork_work *work, 52894348520SYang Jihong struct evsel *evsel, 52994348520SYang Jihong struct perf_sample *sample, 53094348520SYang Jihong struct machine *machine __maybe_unused) 53194348520SYang Jihong { 53294348520SYang Jihong work->class = class; 53394348520SYang Jihong work->cpu = sample->cpu; 53494348520SYang Jihong work->id = evsel__intval(evsel, sample, "irq"); 53594348520SYang Jihong work->name = evsel__strval(evsel, sample, "name"); 53694348520SYang Jihong } 53794348520SYang Jihong 53894348520SYang Jihong static void irq_work_name(struct kwork_work *work, char *buf, int len) 53994348520SYang Jihong { 54094348520SYang Jihong snprintf(buf, len, "%s:%" PRIu64 "", work->name, work->id); 54194348520SYang Jihong } 54294348520SYang Jihong 5434f8ae962SYang Jihong static struct kwork_class kwork_irq = { 5444f8ae962SYang Jihong .name = "irq", 5454f8ae962SYang Jihong .type = KWORK_CLASS_IRQ, 5464f8ae962SYang Jihong .nr_tracepoints = 2, 5474f8ae962SYang Jihong .tp_handlers = irq_tp_handlers, 54894348520SYang Jihong .class_init = irq_class_init, 54994348520SYang Jihong .work_init = irq_work_init, 55094348520SYang Jihong .work_name = irq_work_name, 5514f8ae962SYang Jihong }; 5524f8ae962SYang Jihong 553*4c148191SYang Jihong static struct kwork_class kwork_softirq; 554*4c148191SYang Jihong static int process_softirq_entry_event(struct perf_tool *tool, 555*4c148191SYang Jihong struct evsel *evsel, 556*4c148191SYang Jihong struct perf_sample *sample, 557*4c148191SYang Jihong struct machine *machine) 558*4c148191SYang Jihong { 559*4c148191SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 560*4c148191SYang Jihong 561*4c148191SYang Jihong if (kwork->tp_handler->entry_event) 562*4c148191SYang Jihong return kwork->tp_handler->entry_event(kwork, &kwork_softirq, 563*4c148191SYang Jihong evsel, sample, machine); 564*4c148191SYang Jihong 565*4c148191SYang Jihong return 0; 566*4c148191SYang Jihong } 567*4c148191SYang Jihong 568*4c148191SYang Jihong static int process_softirq_exit_event(struct perf_tool *tool, 569*4c148191SYang Jihong struct evsel *evsel, 570*4c148191SYang Jihong struct perf_sample *sample, 571*4c148191SYang Jihong struct machine *machine) 572*4c148191SYang Jihong { 573*4c148191SYang Jihong struct perf_kwork *kwork = container_of(tool, struct perf_kwork, tool); 574*4c148191SYang Jihong 575*4c148191SYang Jihong if (kwork->tp_handler->exit_event) 576*4c148191SYang Jihong return kwork->tp_handler->exit_event(kwork, &kwork_softirq, 577*4c148191SYang Jihong evsel, sample, machine); 578*4c148191SYang Jihong 579*4c148191SYang Jihong return 0; 580*4c148191SYang Jihong } 581*4c148191SYang Jihong 582e6439321SYang Jihong const struct evsel_str_handler softirq_tp_handlers[] = { 583e6439321SYang Jihong { "irq:softirq_raise", NULL, }, 584*4c148191SYang Jihong { "irq:softirq_entry", process_softirq_entry_event, }, 585*4c148191SYang Jihong { "irq:softirq_exit", process_softirq_exit_event, }, 586e6439321SYang Jihong }; 587e6439321SYang Jihong 588*4c148191SYang Jihong static int softirq_class_init(struct kwork_class *class, 589*4c148191SYang Jihong struct perf_session *session) 590*4c148191SYang Jihong { 591*4c148191SYang Jihong if (perf_session__set_tracepoints_handlers(session, 592*4c148191SYang Jihong softirq_tp_handlers)) { 593*4c148191SYang Jihong pr_err("Failed to set softirq tracepoints handlers\n"); 594*4c148191SYang Jihong return -1; 595*4c148191SYang Jihong } 596*4c148191SYang Jihong 597*4c148191SYang Jihong class->work_root = RB_ROOT_CACHED; 598*4c148191SYang Jihong return 0; 599*4c148191SYang Jihong } 600*4c148191SYang Jihong 601*4c148191SYang Jihong static char *evsel__softirq_name(struct evsel *evsel, u64 num) 602*4c148191SYang Jihong { 603*4c148191SYang Jihong char *name = NULL; 604*4c148191SYang Jihong bool found = false; 605*4c148191SYang Jihong struct tep_print_flag_sym *sym = NULL; 606*4c148191SYang Jihong struct tep_print_arg *args = evsel->tp_format->print_fmt.args; 607*4c148191SYang Jihong 608*4c148191SYang Jihong if ((args == NULL) || (args->next == NULL)) 609*4c148191SYang Jihong return NULL; 610*4c148191SYang Jihong 611*4c148191SYang Jihong /* skip softirq field: "REC->vec" */ 612*4c148191SYang Jihong for (sym = args->next->symbol.symbols; sym != NULL; sym = sym->next) { 613*4c148191SYang Jihong if ((eval_flag(sym->value) == (unsigned long long)num) && 614*4c148191SYang Jihong (strlen(sym->str) != 0)) { 615*4c148191SYang Jihong found = true; 616*4c148191SYang Jihong break; 617*4c148191SYang Jihong } 618*4c148191SYang Jihong } 619*4c148191SYang Jihong 620*4c148191SYang Jihong if (!found) 621*4c148191SYang Jihong return NULL; 622*4c148191SYang Jihong 623*4c148191SYang Jihong name = strdup(sym->str); 624*4c148191SYang Jihong if (name == NULL) { 625*4c148191SYang Jihong pr_err("Failed to copy symbol name\n"); 626*4c148191SYang Jihong return NULL; 627*4c148191SYang Jihong } 628*4c148191SYang Jihong return name; 629*4c148191SYang Jihong } 630*4c148191SYang Jihong 631*4c148191SYang Jihong static void softirq_work_init(struct kwork_class *class, 632*4c148191SYang Jihong struct kwork_work *work, 633*4c148191SYang Jihong struct evsel *evsel, 634*4c148191SYang Jihong struct perf_sample *sample, 635*4c148191SYang Jihong struct machine *machine __maybe_unused) 636*4c148191SYang Jihong { 637*4c148191SYang Jihong u64 num = evsel__intval(evsel, sample, "vec"); 638*4c148191SYang Jihong 639*4c148191SYang Jihong work->id = num; 640*4c148191SYang Jihong work->class = class; 641*4c148191SYang Jihong work->cpu = sample->cpu; 642*4c148191SYang Jihong work->name = evsel__softirq_name(evsel, num); 643*4c148191SYang Jihong } 644*4c148191SYang Jihong 645*4c148191SYang Jihong static void softirq_work_name(struct kwork_work *work, char *buf, int len) 646*4c148191SYang Jihong { 647*4c148191SYang Jihong snprintf(buf, len, "(s)%s:%" PRIu64 "", work->name, work->id); 648*4c148191SYang Jihong } 649*4c148191SYang Jihong 650e6439321SYang Jihong static struct kwork_class kwork_softirq = { 651e6439321SYang Jihong .name = "softirq", 652e6439321SYang Jihong .type = KWORK_CLASS_SOFTIRQ, 653e6439321SYang Jihong .nr_tracepoints = 3, 654e6439321SYang Jihong .tp_handlers = softirq_tp_handlers, 655*4c148191SYang Jihong .class_init = softirq_class_init, 656*4c148191SYang Jihong .work_init = softirq_work_init, 657*4c148191SYang Jihong .work_name = softirq_work_name, 658e6439321SYang Jihong }; 659e6439321SYang Jihong 66097179d9dSYang Jihong const struct evsel_str_handler workqueue_tp_handlers[] = { 66197179d9dSYang Jihong { "workqueue:workqueue_activate_work", NULL, }, 66297179d9dSYang Jihong { "workqueue:workqueue_execute_start", NULL, }, 66397179d9dSYang Jihong { "workqueue:workqueue_execute_end", NULL, }, 66497179d9dSYang Jihong }; 66597179d9dSYang Jihong 66697179d9dSYang Jihong static struct kwork_class kwork_workqueue = { 66797179d9dSYang Jihong .name = "workqueue", 66897179d9dSYang Jihong .type = KWORK_CLASS_WORKQUEUE, 66997179d9dSYang Jihong .nr_tracepoints = 3, 67097179d9dSYang Jihong .tp_handlers = workqueue_tp_handlers, 67197179d9dSYang Jihong }; 67297179d9dSYang Jihong 6730f70d8e9SYang Jihong static struct kwork_class *kwork_class_supported_list[KWORK_CLASS_MAX] = { 6744f8ae962SYang Jihong [KWORK_CLASS_IRQ] = &kwork_irq, 675e6439321SYang Jihong [KWORK_CLASS_SOFTIRQ] = &kwork_softirq, 67697179d9dSYang Jihong [KWORK_CLASS_WORKQUEUE] = &kwork_workqueue, 6770f70d8e9SYang Jihong }; 6780f70d8e9SYang Jihong 679f98919ecSYang Jihong static void print_separator(int len) 680f98919ecSYang Jihong { 681f98919ecSYang Jihong printf(" %.*s\n", len, graph_dotted_line); 682f98919ecSYang Jihong } 683f98919ecSYang Jihong 684f98919ecSYang Jihong static int report_print_work(struct perf_kwork *kwork, struct kwork_work *work) 685f98919ecSYang Jihong { 686f98919ecSYang Jihong int ret = 0; 687f98919ecSYang Jihong char kwork_name[PRINT_KWORK_NAME_WIDTH]; 688f98919ecSYang Jihong char max_runtime_start[32], max_runtime_end[32]; 689f98919ecSYang Jihong 690f98919ecSYang Jihong printf(" "); 691f98919ecSYang Jihong 692f98919ecSYang Jihong /* 693f98919ecSYang Jihong * kwork name 694f98919ecSYang Jihong */ 695f98919ecSYang Jihong if (work->class && work->class->work_name) { 696f98919ecSYang Jihong work->class->work_name(work, kwork_name, 697f98919ecSYang Jihong PRINT_KWORK_NAME_WIDTH); 698f98919ecSYang Jihong ret += printf(" %-*s |", PRINT_KWORK_NAME_WIDTH, kwork_name); 699f98919ecSYang Jihong } else { 700f98919ecSYang Jihong ret += printf(" %-*s |", PRINT_KWORK_NAME_WIDTH, ""); 701f98919ecSYang Jihong } 702f98919ecSYang Jihong 703f98919ecSYang Jihong /* 704f98919ecSYang Jihong * cpu 705f98919ecSYang Jihong */ 706f98919ecSYang Jihong ret += printf(" %0*d |", PRINT_CPU_WIDTH, work->cpu); 707f98919ecSYang Jihong 708f98919ecSYang Jihong /* 709f98919ecSYang Jihong * total runtime 710f98919ecSYang Jihong */ 711f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 712f98919ecSYang Jihong ret += printf(" %*.*f ms |", 713f98919ecSYang Jihong PRINT_RUNTIME_WIDTH, RPINT_DECIMAL_WIDTH, 714f98919ecSYang Jihong (double)work->total_runtime / NSEC_PER_MSEC); 715f98919ecSYang Jihong } 716f98919ecSYang Jihong 717f98919ecSYang Jihong /* 718f98919ecSYang Jihong * count 719f98919ecSYang Jihong */ 720f98919ecSYang Jihong ret += printf(" %*" PRIu64 " |", PRINT_COUNT_WIDTH, work->nr_atoms); 721f98919ecSYang Jihong 722f98919ecSYang Jihong /* 723f98919ecSYang Jihong * max runtime, max runtime start, max runtime end 724f98919ecSYang Jihong */ 725f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 726f98919ecSYang Jihong timestamp__scnprintf_usec(work->max_runtime_start, 727f98919ecSYang Jihong max_runtime_start, 728f98919ecSYang Jihong sizeof(max_runtime_start)); 729f98919ecSYang Jihong timestamp__scnprintf_usec(work->max_runtime_end, 730f98919ecSYang Jihong max_runtime_end, 731f98919ecSYang Jihong sizeof(max_runtime_end)); 732f98919ecSYang Jihong ret += printf(" %*.*f ms | %*s s | %*s s |", 733f98919ecSYang Jihong PRINT_RUNTIME_WIDTH, RPINT_DECIMAL_WIDTH, 734f98919ecSYang Jihong (double)work->max_runtime / NSEC_PER_MSEC, 735f98919ecSYang Jihong PRINT_TIMESTAMP_WIDTH, max_runtime_start, 736f98919ecSYang Jihong PRINT_TIMESTAMP_WIDTH, max_runtime_end); 737f98919ecSYang Jihong } 738f98919ecSYang Jihong 739f98919ecSYang Jihong printf("\n"); 740f98919ecSYang Jihong return ret; 741f98919ecSYang Jihong } 742f98919ecSYang Jihong 743f98919ecSYang Jihong static int report_print_header(struct perf_kwork *kwork) 744f98919ecSYang Jihong { 745f98919ecSYang Jihong int ret; 746f98919ecSYang Jihong 747f98919ecSYang Jihong printf("\n "); 748f98919ecSYang Jihong ret = printf(" %-*s | %-*s |", 749f98919ecSYang Jihong PRINT_KWORK_NAME_WIDTH, "Kwork Name", 750f98919ecSYang Jihong PRINT_CPU_WIDTH, "Cpu"); 751f98919ecSYang Jihong 752f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 753f98919ecSYang Jihong ret += printf(" %-*s |", 754f98919ecSYang Jihong PRINT_RUNTIME_HEADER_WIDTH, "Total Runtime"); 755f98919ecSYang Jihong } 756f98919ecSYang Jihong 757f98919ecSYang Jihong ret += printf(" %-*s |", PRINT_COUNT_WIDTH, "Count"); 758f98919ecSYang Jihong 759f98919ecSYang Jihong if (kwork->report == KWORK_REPORT_RUNTIME) { 760f98919ecSYang Jihong ret += printf(" %-*s | %-*s | %-*s |", 761f98919ecSYang Jihong PRINT_RUNTIME_HEADER_WIDTH, "Max runtime", 762f98919ecSYang Jihong PRINT_TIMESTAMP_HEADER_WIDTH, "Max runtime start", 763f98919ecSYang Jihong PRINT_TIMESTAMP_HEADER_WIDTH, "Max runtime end"); 764f98919ecSYang Jihong } 765f98919ecSYang Jihong 766f98919ecSYang Jihong printf("\n"); 767f98919ecSYang Jihong print_separator(ret); 768f98919ecSYang Jihong return ret; 769f98919ecSYang Jihong } 770f98919ecSYang Jihong 771f98919ecSYang Jihong static void print_summary(struct perf_kwork *kwork) 772f98919ecSYang Jihong { 773f98919ecSYang Jihong u64 time = kwork->timeend - kwork->timestart; 774f98919ecSYang Jihong 775f98919ecSYang Jihong printf(" Total count : %9" PRIu64 "\n", kwork->all_count); 776f98919ecSYang Jihong printf(" Total runtime (msec) : %9.3f (%.3f%% load average)\n", 777f98919ecSYang Jihong (double)kwork->all_runtime / NSEC_PER_MSEC, 778f98919ecSYang Jihong time == 0 ? 0 : (double)kwork->all_runtime / time); 779f98919ecSYang Jihong printf(" Total time span (msec) : %9.3f\n", 780f98919ecSYang Jihong (double)time / NSEC_PER_MSEC); 781f98919ecSYang Jihong } 782f98919ecSYang Jihong 783f98919ecSYang Jihong static unsigned long long nr_list_entry(struct list_head *head) 784f98919ecSYang Jihong { 785f98919ecSYang Jihong struct list_head *pos; 786f98919ecSYang Jihong unsigned long long n = 0; 787f98919ecSYang Jihong 788f98919ecSYang Jihong list_for_each(pos, head) 789f98919ecSYang Jihong n++; 790f98919ecSYang Jihong 791f98919ecSYang Jihong return n; 792f98919ecSYang Jihong } 793f98919ecSYang Jihong 794f98919ecSYang Jihong static void print_skipped_events(struct perf_kwork *kwork) 795f98919ecSYang Jihong { 796f98919ecSYang Jihong int i; 797f98919ecSYang Jihong const char *const kwork_event_str[] = { 798f98919ecSYang Jihong [KWORK_TRACE_ENTRY] = "entry", 799f98919ecSYang Jihong [KWORK_TRACE_EXIT] = "exit", 800f98919ecSYang Jihong }; 801f98919ecSYang Jihong 802f98919ecSYang Jihong if ((kwork->nr_skipped_events[KWORK_TRACE_MAX] != 0) && 803f98919ecSYang Jihong (kwork->nr_events != 0)) { 804f98919ecSYang Jihong printf(" INFO: %.3f%% skipped events (%" PRIu64 " including ", 805f98919ecSYang Jihong (double)kwork->nr_skipped_events[KWORK_TRACE_MAX] / 806f98919ecSYang Jihong (double)kwork->nr_events * 100.0, 807f98919ecSYang Jihong kwork->nr_skipped_events[KWORK_TRACE_MAX]); 808f98919ecSYang Jihong 809f98919ecSYang Jihong for (i = 0; i < KWORK_TRACE_MAX; i++) { 810f98919ecSYang Jihong printf("%" PRIu64 " %s%s", 811f98919ecSYang Jihong kwork->nr_skipped_events[i], 812f98919ecSYang Jihong kwork_event_str[i], 813f98919ecSYang Jihong (i == KWORK_TRACE_MAX - 1) ? ")\n" : ", "); 814f98919ecSYang Jihong } 815f98919ecSYang Jihong } 816f98919ecSYang Jihong 817f98919ecSYang Jihong if (verbose > 0) 818f98919ecSYang Jihong printf(" INFO: use %lld atom pages\n", 819f98919ecSYang Jihong nr_list_entry(&kwork->atom_page_list)); 820f98919ecSYang Jihong } 821f98919ecSYang Jihong 822f98919ecSYang Jihong static void print_bad_events(struct perf_kwork *kwork) 823f98919ecSYang Jihong { 824f98919ecSYang Jihong if ((kwork->nr_lost_events != 0) && (kwork->nr_events != 0)) { 825f98919ecSYang Jihong printf(" INFO: %.3f%% lost events (%ld out of %ld, in %ld chunks)\n", 826f98919ecSYang Jihong (double)kwork->nr_lost_events / 827f98919ecSYang Jihong (double)kwork->nr_events * 100.0, 828f98919ecSYang Jihong kwork->nr_lost_events, kwork->nr_events, 829f98919ecSYang Jihong kwork->nr_lost_chunks); 830f98919ecSYang Jihong } 831f98919ecSYang Jihong } 832f98919ecSYang Jihong 833f98919ecSYang Jihong static void work_sort(struct perf_kwork *kwork, struct kwork_class *class) 834f98919ecSYang Jihong { 835f98919ecSYang Jihong struct rb_node *node; 836f98919ecSYang Jihong struct kwork_work *data; 837f98919ecSYang Jihong struct rb_root_cached *root = &class->work_root; 838f98919ecSYang Jihong 839f98919ecSYang Jihong pr_debug("Sorting %s ...\n", class->name); 840f98919ecSYang Jihong for (;;) { 841f98919ecSYang Jihong node = rb_first_cached(root); 842f98919ecSYang Jihong if (!node) 843f98919ecSYang Jihong break; 844f98919ecSYang Jihong 845f98919ecSYang Jihong rb_erase_cached(node, root); 846f98919ecSYang Jihong data = rb_entry(node, struct kwork_work, node); 847f98919ecSYang Jihong work_insert(&kwork->sorted_work_root, 848f98919ecSYang Jihong data, &kwork->sort_list); 849f98919ecSYang Jihong } 850f98919ecSYang Jihong } 851f98919ecSYang Jihong 852f98919ecSYang Jihong static void perf_kwork__sort(struct perf_kwork *kwork) 853f98919ecSYang Jihong { 854f98919ecSYang Jihong struct kwork_class *class; 855f98919ecSYang Jihong 856f98919ecSYang Jihong list_for_each_entry(class, &kwork->class_list, list) 857f98919ecSYang Jihong work_sort(kwork, class); 858f98919ecSYang Jihong } 859f98919ecSYang Jihong 860f98919ecSYang Jihong static int perf_kwork__check_config(struct perf_kwork *kwork, 861f98919ecSYang Jihong struct perf_session *session) 862f98919ecSYang Jihong { 863f98919ecSYang Jihong int ret; 864f98919ecSYang Jihong struct kwork_class *class; 865f98919ecSYang Jihong 866f98919ecSYang Jihong static struct trace_kwork_handler report_ops = { 867f98919ecSYang Jihong .entry_event = report_entry_event, 868f98919ecSYang Jihong .exit_event = report_exit_event, 869f98919ecSYang Jihong }; 870f98919ecSYang Jihong 871f98919ecSYang Jihong switch (kwork->report) { 872f98919ecSYang Jihong case KWORK_REPORT_RUNTIME: 873f98919ecSYang Jihong kwork->tp_handler = &report_ops; 874f98919ecSYang Jihong break; 875f98919ecSYang Jihong default: 876f98919ecSYang Jihong pr_debug("Invalid report type %d\n", kwork->report); 877f98919ecSYang Jihong return -1; 878f98919ecSYang Jihong } 879f98919ecSYang Jihong 880f98919ecSYang Jihong list_for_each_entry(class, &kwork->class_list, list) 881f98919ecSYang Jihong if ((class->class_init != NULL) && 882f98919ecSYang Jihong (class->class_init(class, session) != 0)) 883f98919ecSYang Jihong return -1; 884f98919ecSYang Jihong 885f98919ecSYang Jihong if (kwork->cpu_list != NULL) { 886f98919ecSYang Jihong ret = perf_session__cpu_bitmap(session, 887f98919ecSYang Jihong kwork->cpu_list, 888f98919ecSYang Jihong kwork->cpu_bitmap); 889f98919ecSYang Jihong if (ret < 0) { 890f98919ecSYang Jihong pr_err("Invalid cpu bitmap\n"); 891f98919ecSYang Jihong return -1; 892f98919ecSYang Jihong } 893f98919ecSYang Jihong } 894f98919ecSYang Jihong 895f98919ecSYang Jihong if (kwork->time_str != NULL) { 896f98919ecSYang Jihong ret = perf_time__parse_str(&kwork->ptime, kwork->time_str); 897f98919ecSYang Jihong if (ret != 0) { 898f98919ecSYang Jihong pr_err("Invalid time span\n"); 899f98919ecSYang Jihong return -1; 900f98919ecSYang Jihong } 901f98919ecSYang Jihong } 902f98919ecSYang Jihong 903f98919ecSYang Jihong return 0; 904f98919ecSYang Jihong } 905f98919ecSYang Jihong 906f98919ecSYang Jihong static int perf_kwork__read_events(struct perf_kwork *kwork) 907f98919ecSYang Jihong { 908f98919ecSYang Jihong int ret = -1; 909f98919ecSYang Jihong struct perf_session *session = NULL; 910f98919ecSYang Jihong 911f98919ecSYang Jihong struct perf_data data = { 912f98919ecSYang Jihong .path = input_name, 913f98919ecSYang Jihong .mode = PERF_DATA_MODE_READ, 914f98919ecSYang Jihong .force = kwork->force, 915f98919ecSYang Jihong }; 916f98919ecSYang Jihong 917f98919ecSYang Jihong session = perf_session__new(&data, &kwork->tool); 918f98919ecSYang Jihong if (IS_ERR(session)) { 919f98919ecSYang Jihong pr_debug("Error creating perf session\n"); 920f98919ecSYang Jihong return PTR_ERR(session); 921f98919ecSYang Jihong } 922f98919ecSYang Jihong 923f98919ecSYang Jihong symbol__init(&session->header.env); 924f98919ecSYang Jihong 925f98919ecSYang Jihong if (perf_kwork__check_config(kwork, session) != 0) 926f98919ecSYang Jihong goto out_delete; 927f98919ecSYang Jihong 928f98919ecSYang Jihong if (session->tevent.pevent && 929f98919ecSYang Jihong tep_set_function_resolver(session->tevent.pevent, 930f98919ecSYang Jihong machine__resolve_kernel_addr, 931f98919ecSYang Jihong &session->machines.host) < 0) { 932f98919ecSYang Jihong pr_err("Failed to set libtraceevent function resolver\n"); 933f98919ecSYang Jihong goto out_delete; 934f98919ecSYang Jihong } 935f98919ecSYang Jihong 936f98919ecSYang Jihong ret = perf_session__process_events(session); 937f98919ecSYang Jihong if (ret) { 938f98919ecSYang Jihong pr_debug("Failed to process events, error %d\n", ret); 939f98919ecSYang Jihong goto out_delete; 940f98919ecSYang Jihong } 941f98919ecSYang Jihong 942f98919ecSYang Jihong kwork->nr_events = session->evlist->stats.nr_events[0]; 943f98919ecSYang Jihong kwork->nr_lost_events = session->evlist->stats.total_lost; 944f98919ecSYang Jihong kwork->nr_lost_chunks = session->evlist->stats.nr_events[PERF_RECORD_LOST]; 945f98919ecSYang Jihong 946f98919ecSYang Jihong out_delete: 947f98919ecSYang Jihong perf_session__delete(session); 948f98919ecSYang Jihong return ret; 949f98919ecSYang Jihong } 950f98919ecSYang Jihong 951f98919ecSYang Jihong static void process_skipped_events(struct perf_kwork *kwork, 952f98919ecSYang Jihong struct kwork_work *work) 953f98919ecSYang Jihong { 954f98919ecSYang Jihong int i; 955f98919ecSYang Jihong unsigned long long count; 956f98919ecSYang Jihong 957f98919ecSYang Jihong for (i = 0; i < KWORK_TRACE_MAX; i++) { 958f98919ecSYang Jihong count = nr_list_entry(&work->atom_list[i]); 959f98919ecSYang Jihong kwork->nr_skipped_events[i] += count; 960f98919ecSYang Jihong kwork->nr_skipped_events[KWORK_TRACE_MAX] += count; 961f98919ecSYang Jihong } 962f98919ecSYang Jihong } 963f98919ecSYang Jihong 964f98919ecSYang Jihong static int perf_kwork__report(struct perf_kwork *kwork) 965f98919ecSYang Jihong { 966f98919ecSYang Jihong int ret; 967f98919ecSYang Jihong struct rb_node *next; 968f98919ecSYang Jihong struct kwork_work *work; 969f98919ecSYang Jihong 970f98919ecSYang Jihong ret = perf_kwork__read_events(kwork); 971f98919ecSYang Jihong if (ret != 0) 972f98919ecSYang Jihong return -1; 973f98919ecSYang Jihong 974f98919ecSYang Jihong perf_kwork__sort(kwork); 975f98919ecSYang Jihong 976f98919ecSYang Jihong setup_pager(); 977f98919ecSYang Jihong 978f98919ecSYang Jihong ret = report_print_header(kwork); 979f98919ecSYang Jihong next = rb_first_cached(&kwork->sorted_work_root); 980f98919ecSYang Jihong while (next) { 981f98919ecSYang Jihong work = rb_entry(next, struct kwork_work, node); 982f98919ecSYang Jihong process_skipped_events(kwork, work); 983f98919ecSYang Jihong 984f98919ecSYang Jihong if (work->nr_atoms != 0) { 985f98919ecSYang Jihong report_print_work(kwork, work); 986f98919ecSYang Jihong if (kwork->summary) { 987f98919ecSYang Jihong kwork->all_runtime += work->total_runtime; 988f98919ecSYang Jihong kwork->all_count += work->nr_atoms; 989f98919ecSYang Jihong } 990f98919ecSYang Jihong } 991f98919ecSYang Jihong next = rb_next(next); 992f98919ecSYang Jihong } 993f98919ecSYang Jihong print_separator(ret); 994f98919ecSYang Jihong 995f98919ecSYang Jihong if (kwork->summary) { 996f98919ecSYang Jihong print_summary(kwork); 997f98919ecSYang Jihong print_separator(ret); 998f98919ecSYang Jihong } 999f98919ecSYang Jihong 1000f98919ecSYang Jihong print_bad_events(kwork); 1001f98919ecSYang Jihong print_skipped_events(kwork); 1002f98919ecSYang Jihong printf("\n"); 1003f98919ecSYang Jihong 1004f98919ecSYang Jihong return 0; 1005f98919ecSYang Jihong } 1006f98919ecSYang Jihong 1007f98919ecSYang Jihong typedef int (*tracepoint_handler)(struct perf_tool *tool, 1008f98919ecSYang Jihong struct evsel *evsel, 1009f98919ecSYang Jihong struct perf_sample *sample, 1010f98919ecSYang Jihong struct machine *machine); 1011f98919ecSYang Jihong 1012f98919ecSYang Jihong static int perf_kwork__process_tracepoint_sample(struct perf_tool *tool, 1013f98919ecSYang Jihong union perf_event *event __maybe_unused, 1014f98919ecSYang Jihong struct perf_sample *sample, 1015f98919ecSYang Jihong struct evsel *evsel, 1016f98919ecSYang Jihong struct machine *machine) 1017f98919ecSYang Jihong { 1018f98919ecSYang Jihong int err = 0; 1019f98919ecSYang Jihong 1020f98919ecSYang Jihong if (evsel->handler != NULL) { 1021f98919ecSYang Jihong tracepoint_handler f = evsel->handler; 1022f98919ecSYang Jihong 1023f98919ecSYang Jihong err = f(tool, evsel, sample, machine); 1024f98919ecSYang Jihong } 1025f98919ecSYang Jihong 1026f98919ecSYang Jihong return err; 1027f98919ecSYang Jihong } 1028f98919ecSYang Jihong 10290f70d8e9SYang Jihong static void setup_event_list(struct perf_kwork *kwork, 10300f70d8e9SYang Jihong const struct option *options, 10310f70d8e9SYang Jihong const char * const usage_msg[]) 10320f70d8e9SYang Jihong { 10330f70d8e9SYang Jihong int i; 10340f70d8e9SYang Jihong struct kwork_class *class; 10350f70d8e9SYang Jihong char *tmp, *tok, *str; 10360f70d8e9SYang Jihong 10370f70d8e9SYang Jihong if (kwork->event_list_str == NULL) 10380f70d8e9SYang Jihong goto null_event_list_str; 10390f70d8e9SYang Jihong 10400f70d8e9SYang Jihong str = strdup(kwork->event_list_str); 10410f70d8e9SYang Jihong for (tok = strtok_r(str, ", ", &tmp); 10420f70d8e9SYang Jihong tok; tok = strtok_r(NULL, ", ", &tmp)) { 10430f70d8e9SYang Jihong for (i = 0; i < KWORK_CLASS_MAX; i++) { 10440f70d8e9SYang Jihong class = kwork_class_supported_list[i]; 10450f70d8e9SYang Jihong if (strcmp(tok, class->name) == 0) { 10460f70d8e9SYang Jihong list_add_tail(&class->list, &kwork->class_list); 10470f70d8e9SYang Jihong break; 10480f70d8e9SYang Jihong } 10490f70d8e9SYang Jihong } 10500f70d8e9SYang Jihong if (i == KWORK_CLASS_MAX) { 10510f70d8e9SYang Jihong usage_with_options_msg(usage_msg, options, 10520f70d8e9SYang Jihong "Unknown --event key: `%s'", tok); 10530f70d8e9SYang Jihong } 10540f70d8e9SYang Jihong } 10550f70d8e9SYang Jihong free(str); 10560f70d8e9SYang Jihong 10570f70d8e9SYang Jihong null_event_list_str: 10580f70d8e9SYang Jihong /* 10590f70d8e9SYang Jihong * config all kwork events if not specified 10600f70d8e9SYang Jihong */ 10610f70d8e9SYang Jihong if (list_empty(&kwork->class_list)) { 10620f70d8e9SYang Jihong for (i = 0; i < KWORK_CLASS_MAX; i++) { 10630f70d8e9SYang Jihong list_add_tail(&kwork_class_supported_list[i]->list, 10640f70d8e9SYang Jihong &kwork->class_list); 10650f70d8e9SYang Jihong } 10660f70d8e9SYang Jihong } 10670f70d8e9SYang Jihong 10680f70d8e9SYang Jihong pr_debug("Config event list:"); 10690f70d8e9SYang Jihong list_for_each_entry(class, &kwork->class_list, list) 10700f70d8e9SYang Jihong pr_debug(" %s", class->name); 10710f70d8e9SYang Jihong pr_debug("\n"); 10720f70d8e9SYang Jihong } 10730f70d8e9SYang Jihong 10740f70d8e9SYang Jihong static int perf_kwork__record(struct perf_kwork *kwork, 10750f70d8e9SYang Jihong int argc, const char **argv) 10760f70d8e9SYang Jihong { 10770f70d8e9SYang Jihong const char **rec_argv; 10780f70d8e9SYang Jihong unsigned int rec_argc, i, j; 10790f70d8e9SYang Jihong struct kwork_class *class; 10800f70d8e9SYang Jihong 10810f70d8e9SYang Jihong const char *const record_args[] = { 10820f70d8e9SYang Jihong "record", 10830f70d8e9SYang Jihong "-a", 10840f70d8e9SYang Jihong "-R", 10850f70d8e9SYang Jihong "-m", "1024", 10860f70d8e9SYang Jihong "-c", "1", 10870f70d8e9SYang Jihong }; 10880f70d8e9SYang Jihong 10890f70d8e9SYang Jihong rec_argc = ARRAY_SIZE(record_args) + argc - 1; 10900f70d8e9SYang Jihong 10910f70d8e9SYang Jihong list_for_each_entry(class, &kwork->class_list, list) 10920f70d8e9SYang Jihong rec_argc += 2 * class->nr_tracepoints; 10930f70d8e9SYang Jihong 10940f70d8e9SYang Jihong rec_argv = calloc(rec_argc + 1, sizeof(char *)); 10950f70d8e9SYang Jihong if (rec_argv == NULL) 10960f70d8e9SYang Jihong return -ENOMEM; 10970f70d8e9SYang Jihong 10980f70d8e9SYang Jihong for (i = 0; i < ARRAY_SIZE(record_args); i++) 10990f70d8e9SYang Jihong rec_argv[i] = strdup(record_args[i]); 11000f70d8e9SYang Jihong 11010f70d8e9SYang Jihong list_for_each_entry(class, &kwork->class_list, list) { 11020f70d8e9SYang Jihong for (j = 0; j < class->nr_tracepoints; j++) { 11030f70d8e9SYang Jihong rec_argv[i++] = strdup("-e"); 11040f70d8e9SYang Jihong rec_argv[i++] = strdup(class->tp_handlers[j].name); 11050f70d8e9SYang Jihong } 11060f70d8e9SYang Jihong } 11070f70d8e9SYang Jihong 11080f70d8e9SYang Jihong for (j = 1; j < (unsigned int)argc; j++, i++) 11090f70d8e9SYang Jihong rec_argv[i] = argv[j]; 11100f70d8e9SYang Jihong 11110f70d8e9SYang Jihong BUG_ON(i != rec_argc); 11120f70d8e9SYang Jihong 11130f70d8e9SYang Jihong pr_debug("record comm: "); 11140f70d8e9SYang Jihong for (j = 0; j < rec_argc; j++) 11150f70d8e9SYang Jihong pr_debug("%s ", rec_argv[j]); 11160f70d8e9SYang Jihong pr_debug("\n"); 11170f70d8e9SYang Jihong 11180f70d8e9SYang Jihong return cmd_record(i, rec_argv); 11190f70d8e9SYang Jihong } 11200f70d8e9SYang Jihong 11210f70d8e9SYang Jihong int cmd_kwork(int argc, const char **argv) 11220f70d8e9SYang Jihong { 11230f70d8e9SYang Jihong static struct perf_kwork kwork = { 11240f70d8e9SYang Jihong .class_list = LIST_HEAD_INIT(kwork.class_list), 1125f98919ecSYang Jihong .tool = { 1126f98919ecSYang Jihong .mmap = perf_event__process_mmap, 1127f98919ecSYang Jihong .mmap2 = perf_event__process_mmap2, 1128f98919ecSYang Jihong .sample = perf_kwork__process_tracepoint_sample, 1129f98919ecSYang Jihong }, 1130f98919ecSYang Jihong .atom_page_list = LIST_HEAD_INIT(kwork.atom_page_list), 1131f98919ecSYang Jihong .sort_list = LIST_HEAD_INIT(kwork.sort_list), 1132f98919ecSYang Jihong .cmp_id = LIST_HEAD_INIT(kwork.cmp_id), 1133f98919ecSYang Jihong .sorted_work_root = RB_ROOT_CACHED, 1134f98919ecSYang Jihong .tp_handler = NULL, 1135f98919ecSYang Jihong .profile_name = NULL, 1136f98919ecSYang Jihong .cpu_list = NULL, 1137f98919ecSYang Jihong .time_str = NULL, 11380f70d8e9SYang Jihong .force = false, 11390f70d8e9SYang Jihong .event_list_str = NULL, 1140f98919ecSYang Jihong .summary = false, 1141f98919ecSYang Jihong .sort_order = NULL, 1142f98919ecSYang Jihong .timestart = 0, 1143f98919ecSYang Jihong .timeend = 0, 1144f98919ecSYang Jihong .nr_events = 0, 1145f98919ecSYang Jihong .nr_lost_chunks = 0, 1146f98919ecSYang Jihong .nr_lost_events = 0, 1147f98919ecSYang Jihong .all_runtime = 0, 1148f98919ecSYang Jihong .all_count = 0, 1149f98919ecSYang Jihong .nr_skipped_events = { 0 }, 11500f70d8e9SYang Jihong }; 1151f98919ecSYang Jihong static const char default_report_sort_order[] = "runtime, max, count"; 11520f70d8e9SYang Jihong const struct option kwork_options[] = { 11530f70d8e9SYang Jihong OPT_INCR('v', "verbose", &verbose, 11540f70d8e9SYang Jihong "be more verbose (show symbol address, etc)"), 11550f70d8e9SYang Jihong OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 11560f70d8e9SYang Jihong "dump raw trace in ASCII"), 11570f70d8e9SYang Jihong OPT_STRING('k', "kwork", &kwork.event_list_str, "kwork", 115897179d9dSYang Jihong "list of kwork to profile (irq, softirq, workqueue, etc)"), 11590f70d8e9SYang Jihong OPT_BOOLEAN('f', "force", &kwork.force, "don't complain, do it"), 11600f70d8e9SYang Jihong OPT_END() 11610f70d8e9SYang Jihong }; 1162f98919ecSYang Jihong const struct option report_options[] = { 1163f98919ecSYang Jihong OPT_STRING('s', "sort", &kwork.sort_order, "key[,key2...]", 1164f98919ecSYang Jihong "sort by key(s): runtime, max, count"), 1165f98919ecSYang Jihong OPT_STRING('C', "cpu", &kwork.cpu_list, "cpu", 1166f98919ecSYang Jihong "list of cpus to profile"), 1167f98919ecSYang Jihong OPT_STRING('n', "name", &kwork.profile_name, "name", 1168f98919ecSYang Jihong "event name to profile"), 1169f98919ecSYang Jihong OPT_STRING(0, "time", &kwork.time_str, "str", 1170f98919ecSYang Jihong "Time span for analysis (start,stop)"), 1171f98919ecSYang Jihong OPT_STRING('i', "input", &input_name, "file", 1172f98919ecSYang Jihong "input file name"), 1173f98919ecSYang Jihong OPT_BOOLEAN('S', "with-summary", &kwork.summary, 1174f98919ecSYang Jihong "Show summary with statistics"), 1175f98919ecSYang Jihong OPT_PARENT(kwork_options) 1176f98919ecSYang Jihong }; 11770f70d8e9SYang Jihong const char *kwork_usage[] = { 11780f70d8e9SYang Jihong NULL, 11790f70d8e9SYang Jihong NULL 11800f70d8e9SYang Jihong }; 1181f98919ecSYang Jihong const char * const report_usage[] = { 1182f98919ecSYang Jihong "perf kwork report [<options>]", 1183f98919ecSYang Jihong NULL 1184f98919ecSYang Jihong }; 11850f70d8e9SYang Jihong const char *const kwork_subcommands[] = { 1186f98919ecSYang Jihong "record", "report", NULL 11870f70d8e9SYang Jihong }; 11880f70d8e9SYang Jihong 11890f70d8e9SYang Jihong argc = parse_options_subcommand(argc, argv, kwork_options, 11900f70d8e9SYang Jihong kwork_subcommands, kwork_usage, 11910f70d8e9SYang Jihong PARSE_OPT_STOP_AT_NON_OPTION); 11920f70d8e9SYang Jihong if (!argc) 11930f70d8e9SYang Jihong usage_with_options(kwork_usage, kwork_options); 11940f70d8e9SYang Jihong 11950f70d8e9SYang Jihong setup_event_list(&kwork, kwork_options, kwork_usage); 1196f98919ecSYang Jihong sort_dimension__add(&kwork, "id", &kwork.cmp_id); 11970f70d8e9SYang Jihong 11980f70d8e9SYang Jihong if (strlen(argv[0]) > 2 && strstarts("record", argv[0])) 11990f70d8e9SYang Jihong return perf_kwork__record(&kwork, argc, argv); 1200f98919ecSYang Jihong else if (strlen(argv[0]) > 2 && strstarts("report", argv[0])) { 1201f98919ecSYang Jihong kwork.sort_order = default_report_sort_order; 1202f98919ecSYang Jihong if (argc > 1) { 1203f98919ecSYang Jihong argc = parse_options(argc, argv, report_options, report_usage, 0); 1204f98919ecSYang Jihong if (argc) 1205f98919ecSYang Jihong usage_with_options(report_usage, report_options); 1206f98919ecSYang Jihong } 1207f98919ecSYang Jihong kwork.report = KWORK_REPORT_RUNTIME; 1208f98919ecSYang Jihong setup_sorting(&kwork, report_options, report_usage); 1209f98919ecSYang Jihong return perf_kwork__report(&kwork); 1210f98919ecSYang Jihong } else 12110f70d8e9SYang Jihong usage_with_options(kwork_usage, kwork_options); 12120f70d8e9SYang Jihong 12130f70d8e9SYang Jihong return 0; 12140f70d8e9SYang Jihong } 1215