1 /* 2 * trace_events_hist - trace event hist triggers 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * Copyright (C) 2015 Tom Zanussi <tom.zanussi@linux.intel.com> 15 */ 16 17 #include <linux/module.h> 18 #include <linux/kallsyms.h> 19 #include <linux/mutex.h> 20 #include <linux/slab.h> 21 #include <linux/stacktrace.h> 22 #include <linux/rculist.h> 23 24 #include "tracing_map.h" 25 #include "trace.h" 26 27 struct hist_field; 28 29 typedef u64 (*hist_field_fn_t) (struct hist_field *field, void *event); 30 31 struct hist_field { 32 struct ftrace_event_field *field; 33 unsigned long flags; 34 hist_field_fn_t fn; 35 unsigned int size; 36 unsigned int offset; 37 }; 38 39 static u64 hist_field_none(struct hist_field *field, void *event) 40 { 41 return 0; 42 } 43 44 static u64 hist_field_counter(struct hist_field *field, void *event) 45 { 46 return 1; 47 } 48 49 static u64 hist_field_string(struct hist_field *hist_field, void *event) 50 { 51 char *addr = (char *)(event + hist_field->field->offset); 52 53 return (u64)(unsigned long)addr; 54 } 55 56 static u64 hist_field_dynstring(struct hist_field *hist_field, void *event) 57 { 58 u32 str_item = *(u32 *)(event + hist_field->field->offset); 59 int str_loc = str_item & 0xffff; 60 char *addr = (char *)(event + str_loc); 61 62 return (u64)(unsigned long)addr; 63 } 64 65 static u64 hist_field_pstring(struct hist_field *hist_field, void *event) 66 { 67 char **addr = (char **)(event + hist_field->field->offset); 68 69 return (u64)(unsigned long)*addr; 70 } 71 72 static u64 hist_field_log2(struct hist_field *hist_field, void *event) 73 { 74 u64 val = *(u64 *)(event + hist_field->field->offset); 75 76 return (u64) ilog2(roundup_pow_of_two(val)); 77 } 78 79 #define DEFINE_HIST_FIELD_FN(type) \ 80 static u64 hist_field_##type(struct hist_field *hist_field, void *event)\ 81 { \ 82 type *addr = (type *)(event + hist_field->field->offset); \ 83 \ 84 return (u64)(unsigned long)*addr; \ 85 } 86 87 DEFINE_HIST_FIELD_FN(s64); 88 DEFINE_HIST_FIELD_FN(u64); 89 DEFINE_HIST_FIELD_FN(s32); 90 DEFINE_HIST_FIELD_FN(u32); 91 DEFINE_HIST_FIELD_FN(s16); 92 DEFINE_HIST_FIELD_FN(u16); 93 DEFINE_HIST_FIELD_FN(s8); 94 DEFINE_HIST_FIELD_FN(u8); 95 96 #define for_each_hist_field(i, hist_data) \ 97 for ((i) = 0; (i) < (hist_data)->n_fields; (i)++) 98 99 #define for_each_hist_val_field(i, hist_data) \ 100 for ((i) = 0; (i) < (hist_data)->n_vals; (i)++) 101 102 #define for_each_hist_key_field(i, hist_data) \ 103 for ((i) = (hist_data)->n_vals; (i) < (hist_data)->n_fields; (i)++) 104 105 #define HIST_STACKTRACE_DEPTH 16 106 #define HIST_STACKTRACE_SIZE (HIST_STACKTRACE_DEPTH * sizeof(unsigned long)) 107 #define HIST_STACKTRACE_SKIP 5 108 109 #define HITCOUNT_IDX 0 110 #define HIST_KEY_SIZE_MAX (MAX_FILTER_STR_VAL + HIST_STACKTRACE_SIZE) 111 112 enum hist_field_flags { 113 HIST_FIELD_FL_HITCOUNT = 1, 114 HIST_FIELD_FL_KEY = 2, 115 HIST_FIELD_FL_STRING = 4, 116 HIST_FIELD_FL_HEX = 8, 117 HIST_FIELD_FL_SYM = 16, 118 HIST_FIELD_FL_SYM_OFFSET = 32, 119 HIST_FIELD_FL_EXECNAME = 64, 120 HIST_FIELD_FL_SYSCALL = 128, 121 HIST_FIELD_FL_STACKTRACE = 256, 122 HIST_FIELD_FL_LOG2 = 512, 123 }; 124 125 struct hist_trigger_attrs { 126 char *keys_str; 127 char *vals_str; 128 char *sort_key_str; 129 char *name; 130 bool pause; 131 bool cont; 132 bool clear; 133 unsigned int map_bits; 134 }; 135 136 struct hist_trigger_data { 137 struct hist_field *fields[TRACING_MAP_FIELDS_MAX]; 138 unsigned int n_vals; 139 unsigned int n_keys; 140 unsigned int n_fields; 141 unsigned int key_size; 142 struct tracing_map_sort_key sort_keys[TRACING_MAP_SORT_KEYS_MAX]; 143 unsigned int n_sort_keys; 144 struct trace_event_file *event_file; 145 struct hist_trigger_attrs *attrs; 146 struct tracing_map *map; 147 }; 148 149 static hist_field_fn_t select_value_fn(int field_size, int field_is_signed) 150 { 151 hist_field_fn_t fn = NULL; 152 153 switch (field_size) { 154 case 8: 155 if (field_is_signed) 156 fn = hist_field_s64; 157 else 158 fn = hist_field_u64; 159 break; 160 case 4: 161 if (field_is_signed) 162 fn = hist_field_s32; 163 else 164 fn = hist_field_u32; 165 break; 166 case 2: 167 if (field_is_signed) 168 fn = hist_field_s16; 169 else 170 fn = hist_field_u16; 171 break; 172 case 1: 173 if (field_is_signed) 174 fn = hist_field_s8; 175 else 176 fn = hist_field_u8; 177 break; 178 } 179 180 return fn; 181 } 182 183 static int parse_map_size(char *str) 184 { 185 unsigned long size, map_bits; 186 int ret; 187 188 strsep(&str, "="); 189 if (!str) { 190 ret = -EINVAL; 191 goto out; 192 } 193 194 ret = kstrtoul(str, 0, &size); 195 if (ret) 196 goto out; 197 198 map_bits = ilog2(roundup_pow_of_two(size)); 199 if (map_bits < TRACING_MAP_BITS_MIN || 200 map_bits > TRACING_MAP_BITS_MAX) 201 ret = -EINVAL; 202 else 203 ret = map_bits; 204 out: 205 return ret; 206 } 207 208 static void destroy_hist_trigger_attrs(struct hist_trigger_attrs *attrs) 209 { 210 if (!attrs) 211 return; 212 213 kfree(attrs->name); 214 kfree(attrs->sort_key_str); 215 kfree(attrs->keys_str); 216 kfree(attrs->vals_str); 217 kfree(attrs); 218 } 219 220 static struct hist_trigger_attrs *parse_hist_trigger_attrs(char *trigger_str) 221 { 222 struct hist_trigger_attrs *attrs; 223 int ret = 0; 224 225 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL); 226 if (!attrs) 227 return ERR_PTR(-ENOMEM); 228 229 while (trigger_str) { 230 char *str = strsep(&trigger_str, ":"); 231 232 if ((strncmp(str, "key=", strlen("key=")) == 0) || 233 (strncmp(str, "keys=", strlen("keys=")) == 0)) 234 attrs->keys_str = kstrdup(str, GFP_KERNEL); 235 else if ((strncmp(str, "val=", strlen("val=")) == 0) || 236 (strncmp(str, "vals=", strlen("vals=")) == 0) || 237 (strncmp(str, "values=", strlen("values=")) == 0)) 238 attrs->vals_str = kstrdup(str, GFP_KERNEL); 239 else if (strncmp(str, "sort=", strlen("sort=")) == 0) 240 attrs->sort_key_str = kstrdup(str, GFP_KERNEL); 241 else if (strncmp(str, "name=", strlen("name=")) == 0) 242 attrs->name = kstrdup(str, GFP_KERNEL); 243 else if (strcmp(str, "pause") == 0) 244 attrs->pause = true; 245 else if ((strcmp(str, "cont") == 0) || 246 (strcmp(str, "continue") == 0)) 247 attrs->cont = true; 248 else if (strcmp(str, "clear") == 0) 249 attrs->clear = true; 250 else if (strncmp(str, "size=", strlen("size=")) == 0) { 251 int map_bits = parse_map_size(str); 252 253 if (map_bits < 0) { 254 ret = map_bits; 255 goto free; 256 } 257 attrs->map_bits = map_bits; 258 } else { 259 ret = -EINVAL; 260 goto free; 261 } 262 } 263 264 if (!attrs->keys_str) { 265 ret = -EINVAL; 266 goto free; 267 } 268 269 return attrs; 270 free: 271 destroy_hist_trigger_attrs(attrs); 272 273 return ERR_PTR(ret); 274 } 275 276 static inline void save_comm(char *comm, struct task_struct *task) 277 { 278 if (!task->pid) { 279 strcpy(comm, "<idle>"); 280 return; 281 } 282 283 if (WARN_ON_ONCE(task->pid < 0)) { 284 strcpy(comm, "<XXX>"); 285 return; 286 } 287 288 memcpy(comm, task->comm, TASK_COMM_LEN); 289 } 290 291 static void hist_trigger_elt_comm_free(struct tracing_map_elt *elt) 292 { 293 kfree((char *)elt->private_data); 294 } 295 296 static int hist_trigger_elt_comm_alloc(struct tracing_map_elt *elt) 297 { 298 struct hist_trigger_data *hist_data = elt->map->private_data; 299 struct hist_field *key_field; 300 unsigned int i; 301 302 for_each_hist_key_field(i, hist_data) { 303 key_field = hist_data->fields[i]; 304 305 if (key_field->flags & HIST_FIELD_FL_EXECNAME) { 306 unsigned int size = TASK_COMM_LEN + 1; 307 308 elt->private_data = kzalloc(size, GFP_KERNEL); 309 if (!elt->private_data) 310 return -ENOMEM; 311 break; 312 } 313 } 314 315 return 0; 316 } 317 318 static void hist_trigger_elt_comm_copy(struct tracing_map_elt *to, 319 struct tracing_map_elt *from) 320 { 321 char *comm_from = from->private_data; 322 char *comm_to = to->private_data; 323 324 if (comm_from) 325 memcpy(comm_to, comm_from, TASK_COMM_LEN + 1); 326 } 327 328 static void hist_trigger_elt_comm_init(struct tracing_map_elt *elt) 329 { 330 char *comm = elt->private_data; 331 332 if (comm) 333 save_comm(comm, current); 334 } 335 336 static const struct tracing_map_ops hist_trigger_elt_comm_ops = { 337 .elt_alloc = hist_trigger_elt_comm_alloc, 338 .elt_copy = hist_trigger_elt_comm_copy, 339 .elt_free = hist_trigger_elt_comm_free, 340 .elt_init = hist_trigger_elt_comm_init, 341 }; 342 343 static void destroy_hist_field(struct hist_field *hist_field) 344 { 345 kfree(hist_field); 346 } 347 348 static struct hist_field *create_hist_field(struct ftrace_event_field *field, 349 unsigned long flags) 350 { 351 struct hist_field *hist_field; 352 353 if (field && is_function_field(field)) 354 return NULL; 355 356 hist_field = kzalloc(sizeof(struct hist_field), GFP_KERNEL); 357 if (!hist_field) 358 return NULL; 359 360 if (flags & HIST_FIELD_FL_HITCOUNT) { 361 hist_field->fn = hist_field_counter; 362 goto out; 363 } 364 365 if (flags & HIST_FIELD_FL_STACKTRACE) { 366 hist_field->fn = hist_field_none; 367 goto out; 368 } 369 370 if (flags & HIST_FIELD_FL_LOG2) { 371 hist_field->fn = hist_field_log2; 372 goto out; 373 } 374 375 if (WARN_ON_ONCE(!field)) 376 goto out; 377 378 if (is_string_field(field)) { 379 flags |= HIST_FIELD_FL_STRING; 380 381 if (field->filter_type == FILTER_STATIC_STRING) 382 hist_field->fn = hist_field_string; 383 else if (field->filter_type == FILTER_DYN_STRING) 384 hist_field->fn = hist_field_dynstring; 385 else 386 hist_field->fn = hist_field_pstring; 387 } else { 388 hist_field->fn = select_value_fn(field->size, 389 field->is_signed); 390 if (!hist_field->fn) { 391 destroy_hist_field(hist_field); 392 return NULL; 393 } 394 } 395 out: 396 hist_field->field = field; 397 hist_field->flags = flags; 398 399 return hist_field; 400 } 401 402 static void destroy_hist_fields(struct hist_trigger_data *hist_data) 403 { 404 unsigned int i; 405 406 for (i = 0; i < TRACING_MAP_FIELDS_MAX; i++) { 407 if (hist_data->fields[i]) { 408 destroy_hist_field(hist_data->fields[i]); 409 hist_data->fields[i] = NULL; 410 } 411 } 412 } 413 414 static int create_hitcount_val(struct hist_trigger_data *hist_data) 415 { 416 hist_data->fields[HITCOUNT_IDX] = 417 create_hist_field(NULL, HIST_FIELD_FL_HITCOUNT); 418 if (!hist_data->fields[HITCOUNT_IDX]) 419 return -ENOMEM; 420 421 hist_data->n_vals++; 422 423 if (WARN_ON(hist_data->n_vals > TRACING_MAP_VALS_MAX)) 424 return -EINVAL; 425 426 return 0; 427 } 428 429 static int create_val_field(struct hist_trigger_data *hist_data, 430 unsigned int val_idx, 431 struct trace_event_file *file, 432 char *field_str) 433 { 434 struct ftrace_event_field *field = NULL; 435 unsigned long flags = 0; 436 char *field_name; 437 int ret = 0; 438 439 if (WARN_ON(val_idx >= TRACING_MAP_VALS_MAX)) 440 return -EINVAL; 441 442 field_name = strsep(&field_str, "."); 443 if (field_str) { 444 if (strcmp(field_str, "hex") == 0) 445 flags |= HIST_FIELD_FL_HEX; 446 else { 447 ret = -EINVAL; 448 goto out; 449 } 450 } 451 452 field = trace_find_event_field(file->event_call, field_name); 453 if (!field) { 454 ret = -EINVAL; 455 goto out; 456 } 457 458 hist_data->fields[val_idx] = create_hist_field(field, flags); 459 if (!hist_data->fields[val_idx]) { 460 ret = -ENOMEM; 461 goto out; 462 } 463 464 ++hist_data->n_vals; 465 466 if (WARN_ON(hist_data->n_vals > TRACING_MAP_VALS_MAX)) 467 ret = -EINVAL; 468 out: 469 return ret; 470 } 471 472 static int create_val_fields(struct hist_trigger_data *hist_data, 473 struct trace_event_file *file) 474 { 475 char *fields_str, *field_str; 476 unsigned int i, j; 477 int ret; 478 479 ret = create_hitcount_val(hist_data); 480 if (ret) 481 goto out; 482 483 fields_str = hist_data->attrs->vals_str; 484 if (!fields_str) 485 goto out; 486 487 strsep(&fields_str, "="); 488 if (!fields_str) 489 goto out; 490 491 for (i = 0, j = 1; i < TRACING_MAP_VALS_MAX && 492 j < TRACING_MAP_VALS_MAX; i++) { 493 field_str = strsep(&fields_str, ","); 494 if (!field_str) 495 break; 496 if (strcmp(field_str, "hitcount") == 0) 497 continue; 498 ret = create_val_field(hist_data, j++, file, field_str); 499 if (ret) 500 goto out; 501 } 502 if (fields_str && (strcmp(fields_str, "hitcount") != 0)) 503 ret = -EINVAL; 504 out: 505 return ret; 506 } 507 508 static int create_key_field(struct hist_trigger_data *hist_data, 509 unsigned int key_idx, 510 unsigned int key_offset, 511 struct trace_event_file *file, 512 char *field_str) 513 { 514 struct ftrace_event_field *field = NULL; 515 unsigned long flags = 0; 516 unsigned int key_size; 517 int ret = 0; 518 519 if (WARN_ON(key_idx >= TRACING_MAP_FIELDS_MAX)) 520 return -EINVAL; 521 522 flags |= HIST_FIELD_FL_KEY; 523 524 if (strcmp(field_str, "stacktrace") == 0) { 525 flags |= HIST_FIELD_FL_STACKTRACE; 526 key_size = sizeof(unsigned long) * HIST_STACKTRACE_DEPTH; 527 } else { 528 char *field_name = strsep(&field_str, "."); 529 530 if (field_str) { 531 if (strcmp(field_str, "hex") == 0) 532 flags |= HIST_FIELD_FL_HEX; 533 else if (strcmp(field_str, "sym") == 0) 534 flags |= HIST_FIELD_FL_SYM; 535 else if (strcmp(field_str, "sym-offset") == 0) 536 flags |= HIST_FIELD_FL_SYM_OFFSET; 537 else if ((strcmp(field_str, "execname") == 0) && 538 (strcmp(field_name, "common_pid") == 0)) 539 flags |= HIST_FIELD_FL_EXECNAME; 540 else if (strcmp(field_str, "syscall") == 0) 541 flags |= HIST_FIELD_FL_SYSCALL; 542 else if (strcmp(field_str, "log2") == 0) 543 flags |= HIST_FIELD_FL_LOG2; 544 else { 545 ret = -EINVAL; 546 goto out; 547 } 548 } 549 550 field = trace_find_event_field(file->event_call, field_name); 551 if (!field) { 552 ret = -EINVAL; 553 goto out; 554 } 555 556 if (is_string_field(field)) 557 key_size = MAX_FILTER_STR_VAL; 558 else 559 key_size = field->size; 560 } 561 562 hist_data->fields[key_idx] = create_hist_field(field, flags); 563 if (!hist_data->fields[key_idx]) { 564 ret = -ENOMEM; 565 goto out; 566 } 567 568 key_size = ALIGN(key_size, sizeof(u64)); 569 hist_data->fields[key_idx]->size = key_size; 570 hist_data->fields[key_idx]->offset = key_offset; 571 hist_data->key_size += key_size; 572 if (hist_data->key_size > HIST_KEY_SIZE_MAX) { 573 ret = -EINVAL; 574 goto out; 575 } 576 577 hist_data->n_keys++; 578 579 if (WARN_ON(hist_data->n_keys > TRACING_MAP_KEYS_MAX)) 580 return -EINVAL; 581 582 ret = key_size; 583 out: 584 return ret; 585 } 586 587 static int create_key_fields(struct hist_trigger_data *hist_data, 588 struct trace_event_file *file) 589 { 590 unsigned int i, key_offset = 0, n_vals = hist_data->n_vals; 591 char *fields_str, *field_str; 592 int ret = -EINVAL; 593 594 fields_str = hist_data->attrs->keys_str; 595 if (!fields_str) 596 goto out; 597 598 strsep(&fields_str, "="); 599 if (!fields_str) 600 goto out; 601 602 for (i = n_vals; i < n_vals + TRACING_MAP_KEYS_MAX; i++) { 603 field_str = strsep(&fields_str, ","); 604 if (!field_str) 605 break; 606 ret = create_key_field(hist_data, i, key_offset, 607 file, field_str); 608 if (ret < 0) 609 goto out; 610 key_offset += ret; 611 } 612 if (fields_str) { 613 ret = -EINVAL; 614 goto out; 615 } 616 ret = 0; 617 out: 618 return ret; 619 } 620 621 static int create_hist_fields(struct hist_trigger_data *hist_data, 622 struct trace_event_file *file) 623 { 624 int ret; 625 626 ret = create_val_fields(hist_data, file); 627 if (ret) 628 goto out; 629 630 ret = create_key_fields(hist_data, file); 631 if (ret) 632 goto out; 633 634 hist_data->n_fields = hist_data->n_vals + hist_data->n_keys; 635 out: 636 return ret; 637 } 638 639 static int is_descending(const char *str) 640 { 641 if (!str) 642 return 0; 643 644 if (strcmp(str, "descending") == 0) 645 return 1; 646 647 if (strcmp(str, "ascending") == 0) 648 return 0; 649 650 return -EINVAL; 651 } 652 653 static int create_sort_keys(struct hist_trigger_data *hist_data) 654 { 655 char *fields_str = hist_data->attrs->sort_key_str; 656 struct ftrace_event_field *field = NULL; 657 struct tracing_map_sort_key *sort_key; 658 int descending, ret = 0; 659 unsigned int i, j; 660 661 hist_data->n_sort_keys = 1; /* we always have at least one, hitcount */ 662 663 if (!fields_str) 664 goto out; 665 666 strsep(&fields_str, "="); 667 if (!fields_str) { 668 ret = -EINVAL; 669 goto out; 670 } 671 672 for (i = 0; i < TRACING_MAP_SORT_KEYS_MAX; i++) { 673 char *field_str, *field_name; 674 675 sort_key = &hist_data->sort_keys[i]; 676 677 field_str = strsep(&fields_str, ","); 678 if (!field_str) { 679 if (i == 0) 680 ret = -EINVAL; 681 break; 682 } 683 684 if ((i == TRACING_MAP_SORT_KEYS_MAX - 1) && fields_str) { 685 ret = -EINVAL; 686 break; 687 } 688 689 field_name = strsep(&field_str, "."); 690 if (!field_name) { 691 ret = -EINVAL; 692 break; 693 } 694 695 if (strcmp(field_name, "hitcount") == 0) { 696 descending = is_descending(field_str); 697 if (descending < 0) { 698 ret = descending; 699 break; 700 } 701 sort_key->descending = descending; 702 continue; 703 } 704 705 for (j = 1; j < hist_data->n_fields; j++) { 706 field = hist_data->fields[j]->field; 707 if (field && (strcmp(field_name, field->name) == 0)) { 708 sort_key->field_idx = j; 709 descending = is_descending(field_str); 710 if (descending < 0) { 711 ret = descending; 712 goto out; 713 } 714 sort_key->descending = descending; 715 break; 716 } 717 } 718 if (j == hist_data->n_fields) { 719 ret = -EINVAL; 720 break; 721 } 722 } 723 hist_data->n_sort_keys = i; 724 out: 725 return ret; 726 } 727 728 static void destroy_hist_data(struct hist_trigger_data *hist_data) 729 { 730 destroy_hist_trigger_attrs(hist_data->attrs); 731 destroy_hist_fields(hist_data); 732 tracing_map_destroy(hist_data->map); 733 kfree(hist_data); 734 } 735 736 static int create_tracing_map_fields(struct hist_trigger_data *hist_data) 737 { 738 struct tracing_map *map = hist_data->map; 739 struct ftrace_event_field *field; 740 struct hist_field *hist_field; 741 int i, idx; 742 743 for_each_hist_field(i, hist_data) { 744 hist_field = hist_data->fields[i]; 745 if (hist_field->flags & HIST_FIELD_FL_KEY) { 746 tracing_map_cmp_fn_t cmp_fn; 747 748 field = hist_field->field; 749 750 if (hist_field->flags & HIST_FIELD_FL_STACKTRACE) 751 cmp_fn = tracing_map_cmp_none; 752 else if (is_string_field(field)) 753 cmp_fn = tracing_map_cmp_string; 754 else 755 cmp_fn = tracing_map_cmp_num(field->size, 756 field->is_signed); 757 idx = tracing_map_add_key_field(map, 758 hist_field->offset, 759 cmp_fn); 760 761 } else 762 idx = tracing_map_add_sum_field(map); 763 764 if (idx < 0) 765 return idx; 766 } 767 768 return 0; 769 } 770 771 static bool need_tracing_map_ops(struct hist_trigger_data *hist_data) 772 { 773 struct hist_field *key_field; 774 unsigned int i; 775 776 for_each_hist_key_field(i, hist_data) { 777 key_field = hist_data->fields[i]; 778 779 if (key_field->flags & HIST_FIELD_FL_EXECNAME) 780 return true; 781 } 782 783 return false; 784 } 785 786 static struct hist_trigger_data * 787 create_hist_data(unsigned int map_bits, 788 struct hist_trigger_attrs *attrs, 789 struct trace_event_file *file) 790 { 791 const struct tracing_map_ops *map_ops = NULL; 792 struct hist_trigger_data *hist_data; 793 int ret = 0; 794 795 hist_data = kzalloc(sizeof(*hist_data), GFP_KERNEL); 796 if (!hist_data) 797 return ERR_PTR(-ENOMEM); 798 799 hist_data->attrs = attrs; 800 801 ret = create_hist_fields(hist_data, file); 802 if (ret) 803 goto free; 804 805 ret = create_sort_keys(hist_data); 806 if (ret) 807 goto free; 808 809 if (need_tracing_map_ops(hist_data)) 810 map_ops = &hist_trigger_elt_comm_ops; 811 812 hist_data->map = tracing_map_create(map_bits, hist_data->key_size, 813 map_ops, hist_data); 814 if (IS_ERR(hist_data->map)) { 815 ret = PTR_ERR(hist_data->map); 816 hist_data->map = NULL; 817 goto free; 818 } 819 820 ret = create_tracing_map_fields(hist_data); 821 if (ret) 822 goto free; 823 824 ret = tracing_map_init(hist_data->map); 825 if (ret) 826 goto free; 827 828 hist_data->event_file = file; 829 out: 830 return hist_data; 831 free: 832 hist_data->attrs = NULL; 833 834 destroy_hist_data(hist_data); 835 836 hist_data = ERR_PTR(ret); 837 838 goto out; 839 } 840 841 static void hist_trigger_elt_update(struct hist_trigger_data *hist_data, 842 struct tracing_map_elt *elt, 843 void *rec) 844 { 845 struct hist_field *hist_field; 846 unsigned int i; 847 u64 hist_val; 848 849 for_each_hist_val_field(i, hist_data) { 850 hist_field = hist_data->fields[i]; 851 hist_val = hist_field->fn(hist_field, rec); 852 tracing_map_update_sum(elt, i, hist_val); 853 } 854 } 855 856 static inline void add_to_key(char *compound_key, void *key, 857 struct hist_field *key_field, void *rec) 858 { 859 size_t size = key_field->size; 860 861 if (key_field->flags & HIST_FIELD_FL_STRING) { 862 struct ftrace_event_field *field; 863 864 field = key_field->field; 865 if (field->filter_type == FILTER_DYN_STRING) 866 size = *(u32 *)(rec + field->offset) >> 16; 867 else if (field->filter_type == FILTER_PTR_STRING) 868 size = strlen(key); 869 else if (field->filter_type == FILTER_STATIC_STRING) 870 size = field->size; 871 872 /* ensure NULL-termination */ 873 if (size > key_field->size - 1) 874 size = key_field->size - 1; 875 } 876 877 memcpy(compound_key + key_field->offset, key, size); 878 } 879 880 static void event_hist_trigger(struct event_trigger_data *data, void *rec) 881 { 882 struct hist_trigger_data *hist_data = data->private_data; 883 bool use_compound_key = (hist_data->n_keys > 1); 884 unsigned long entries[HIST_STACKTRACE_DEPTH]; 885 char compound_key[HIST_KEY_SIZE_MAX]; 886 struct stack_trace stacktrace; 887 struct hist_field *key_field; 888 struct tracing_map_elt *elt; 889 u64 field_contents; 890 void *key = NULL; 891 unsigned int i; 892 893 memset(compound_key, 0, hist_data->key_size); 894 895 for_each_hist_key_field(i, hist_data) { 896 key_field = hist_data->fields[i]; 897 898 if (key_field->flags & HIST_FIELD_FL_STACKTRACE) { 899 stacktrace.max_entries = HIST_STACKTRACE_DEPTH; 900 stacktrace.entries = entries; 901 stacktrace.nr_entries = 0; 902 stacktrace.skip = HIST_STACKTRACE_SKIP; 903 904 memset(stacktrace.entries, 0, HIST_STACKTRACE_SIZE); 905 save_stack_trace(&stacktrace); 906 907 key = entries; 908 } else { 909 field_contents = key_field->fn(key_field, rec); 910 if (key_field->flags & HIST_FIELD_FL_STRING) { 911 key = (void *)(unsigned long)field_contents; 912 use_compound_key = true; 913 } else 914 key = (void *)&field_contents; 915 } 916 917 if (use_compound_key) 918 add_to_key(compound_key, key, key_field, rec); 919 } 920 921 if (use_compound_key) 922 key = compound_key; 923 924 elt = tracing_map_insert(hist_data->map, key); 925 if (elt) 926 hist_trigger_elt_update(hist_data, elt, rec); 927 } 928 929 static void hist_trigger_stacktrace_print(struct seq_file *m, 930 unsigned long *stacktrace_entries, 931 unsigned int max_entries) 932 { 933 char str[KSYM_SYMBOL_LEN]; 934 unsigned int spaces = 8; 935 unsigned int i; 936 937 for (i = 0; i < max_entries; i++) { 938 if (stacktrace_entries[i] == ULONG_MAX) 939 return; 940 941 seq_printf(m, "%*c", 1 + spaces, ' '); 942 sprint_symbol(str, stacktrace_entries[i]); 943 seq_printf(m, "%s\n", str); 944 } 945 } 946 947 static void 948 hist_trigger_entry_print(struct seq_file *m, 949 struct hist_trigger_data *hist_data, void *key, 950 struct tracing_map_elt *elt) 951 { 952 struct hist_field *key_field; 953 char str[KSYM_SYMBOL_LEN]; 954 bool multiline = false; 955 unsigned int i; 956 u64 uval; 957 958 seq_puts(m, "{ "); 959 960 for_each_hist_key_field(i, hist_data) { 961 key_field = hist_data->fields[i]; 962 963 if (i > hist_data->n_vals) 964 seq_puts(m, ", "); 965 966 if (key_field->flags & HIST_FIELD_FL_HEX) { 967 uval = *(u64 *)(key + key_field->offset); 968 seq_printf(m, "%s: %llx", 969 key_field->field->name, uval); 970 } else if (key_field->flags & HIST_FIELD_FL_SYM) { 971 uval = *(u64 *)(key + key_field->offset); 972 sprint_symbol_no_offset(str, uval); 973 seq_printf(m, "%s: [%llx] %-45s", 974 key_field->field->name, uval, str); 975 } else if (key_field->flags & HIST_FIELD_FL_SYM_OFFSET) { 976 uval = *(u64 *)(key + key_field->offset); 977 sprint_symbol(str, uval); 978 seq_printf(m, "%s: [%llx] %-55s", 979 key_field->field->name, uval, str); 980 } else if (key_field->flags & HIST_FIELD_FL_EXECNAME) { 981 char *comm = elt->private_data; 982 983 uval = *(u64 *)(key + key_field->offset); 984 seq_printf(m, "%s: %-16s[%10llu]", 985 key_field->field->name, comm, uval); 986 } else if (key_field->flags & HIST_FIELD_FL_SYSCALL) { 987 const char *syscall_name; 988 989 uval = *(u64 *)(key + key_field->offset); 990 syscall_name = get_syscall_name(uval); 991 if (!syscall_name) 992 syscall_name = "unknown_syscall"; 993 994 seq_printf(m, "%s: %-30s[%3llu]", 995 key_field->field->name, syscall_name, uval); 996 } else if (key_field->flags & HIST_FIELD_FL_STACKTRACE) { 997 seq_puts(m, "stacktrace:\n"); 998 hist_trigger_stacktrace_print(m, 999 key + key_field->offset, 1000 HIST_STACKTRACE_DEPTH); 1001 multiline = true; 1002 } else if (key_field->flags & HIST_FIELD_FL_LOG2) { 1003 seq_printf(m, "%s: ~ 2^%-2llu", key_field->field->name, 1004 *(u64 *)(key + key_field->offset)); 1005 } else if (key_field->flags & HIST_FIELD_FL_STRING) { 1006 seq_printf(m, "%s: %-50s", key_field->field->name, 1007 (char *)(key + key_field->offset)); 1008 } else { 1009 uval = *(u64 *)(key + key_field->offset); 1010 seq_printf(m, "%s: %10llu", key_field->field->name, 1011 uval); 1012 } 1013 } 1014 1015 if (!multiline) 1016 seq_puts(m, " "); 1017 1018 seq_puts(m, "}"); 1019 1020 seq_printf(m, " hitcount: %10llu", 1021 tracing_map_read_sum(elt, HITCOUNT_IDX)); 1022 1023 for (i = 1; i < hist_data->n_vals; i++) { 1024 if (hist_data->fields[i]->flags & HIST_FIELD_FL_HEX) { 1025 seq_printf(m, " %s: %10llx", 1026 hist_data->fields[i]->field->name, 1027 tracing_map_read_sum(elt, i)); 1028 } else { 1029 seq_printf(m, " %s: %10llu", 1030 hist_data->fields[i]->field->name, 1031 tracing_map_read_sum(elt, i)); 1032 } 1033 } 1034 1035 seq_puts(m, "\n"); 1036 } 1037 1038 static int print_entries(struct seq_file *m, 1039 struct hist_trigger_data *hist_data) 1040 { 1041 struct tracing_map_sort_entry **sort_entries = NULL; 1042 struct tracing_map *map = hist_data->map; 1043 int i, n_entries; 1044 1045 n_entries = tracing_map_sort_entries(map, hist_data->sort_keys, 1046 hist_data->n_sort_keys, 1047 &sort_entries); 1048 if (n_entries < 0) 1049 return n_entries; 1050 1051 for (i = 0; i < n_entries; i++) 1052 hist_trigger_entry_print(m, hist_data, 1053 sort_entries[i]->key, 1054 sort_entries[i]->elt); 1055 1056 tracing_map_destroy_sort_entries(sort_entries, n_entries); 1057 1058 return n_entries; 1059 } 1060 1061 static void hist_trigger_show(struct seq_file *m, 1062 struct event_trigger_data *data, int n) 1063 { 1064 struct hist_trigger_data *hist_data; 1065 int n_entries, ret = 0; 1066 1067 if (n > 0) 1068 seq_puts(m, "\n\n"); 1069 1070 seq_puts(m, "# event histogram\n#\n# trigger info: "); 1071 data->ops->print(m, data->ops, data); 1072 seq_puts(m, "#\n\n"); 1073 1074 hist_data = data->private_data; 1075 n_entries = print_entries(m, hist_data); 1076 if (n_entries < 0) { 1077 ret = n_entries; 1078 n_entries = 0; 1079 } 1080 1081 seq_printf(m, "\nTotals:\n Hits: %llu\n Entries: %u\n Dropped: %llu\n", 1082 (u64)atomic64_read(&hist_data->map->hits), 1083 n_entries, (u64)atomic64_read(&hist_data->map->drops)); 1084 } 1085 1086 static int hist_show(struct seq_file *m, void *v) 1087 { 1088 struct event_trigger_data *data; 1089 struct trace_event_file *event_file; 1090 int n = 0, ret = 0; 1091 1092 mutex_lock(&event_mutex); 1093 1094 event_file = event_file_data(m->private); 1095 if (unlikely(!event_file)) { 1096 ret = -ENODEV; 1097 goto out_unlock; 1098 } 1099 1100 list_for_each_entry_rcu(data, &event_file->triggers, list) { 1101 if (data->cmd_ops->trigger_type == ETT_EVENT_HIST) 1102 hist_trigger_show(m, data, n++); 1103 } 1104 1105 out_unlock: 1106 mutex_unlock(&event_mutex); 1107 1108 return ret; 1109 } 1110 1111 static int event_hist_open(struct inode *inode, struct file *file) 1112 { 1113 return single_open(file, hist_show, file); 1114 } 1115 1116 const struct file_operations event_hist_fops = { 1117 .open = event_hist_open, 1118 .read = seq_read, 1119 .llseek = seq_lseek, 1120 .release = single_release, 1121 }; 1122 1123 static const char *get_hist_field_flags(struct hist_field *hist_field) 1124 { 1125 const char *flags_str = NULL; 1126 1127 if (hist_field->flags & HIST_FIELD_FL_HEX) 1128 flags_str = "hex"; 1129 else if (hist_field->flags & HIST_FIELD_FL_SYM) 1130 flags_str = "sym"; 1131 else if (hist_field->flags & HIST_FIELD_FL_SYM_OFFSET) 1132 flags_str = "sym-offset"; 1133 else if (hist_field->flags & HIST_FIELD_FL_EXECNAME) 1134 flags_str = "execname"; 1135 else if (hist_field->flags & HIST_FIELD_FL_SYSCALL) 1136 flags_str = "syscall"; 1137 else if (hist_field->flags & HIST_FIELD_FL_LOG2) 1138 flags_str = "log2"; 1139 1140 return flags_str; 1141 } 1142 1143 static void hist_field_print(struct seq_file *m, struct hist_field *hist_field) 1144 { 1145 seq_printf(m, "%s", hist_field->field->name); 1146 if (hist_field->flags) { 1147 const char *flags_str = get_hist_field_flags(hist_field); 1148 1149 if (flags_str) 1150 seq_printf(m, ".%s", flags_str); 1151 } 1152 } 1153 1154 static int event_hist_trigger_print(struct seq_file *m, 1155 struct event_trigger_ops *ops, 1156 struct event_trigger_data *data) 1157 { 1158 struct hist_trigger_data *hist_data = data->private_data; 1159 struct hist_field *key_field; 1160 unsigned int i; 1161 1162 seq_puts(m, "hist:"); 1163 1164 if (data->name) 1165 seq_printf(m, "%s:", data->name); 1166 1167 seq_puts(m, "keys="); 1168 1169 for_each_hist_key_field(i, hist_data) { 1170 key_field = hist_data->fields[i]; 1171 1172 if (i > hist_data->n_vals) 1173 seq_puts(m, ","); 1174 1175 if (key_field->flags & HIST_FIELD_FL_STACKTRACE) 1176 seq_puts(m, "stacktrace"); 1177 else 1178 hist_field_print(m, key_field); 1179 } 1180 1181 seq_puts(m, ":vals="); 1182 1183 for_each_hist_val_field(i, hist_data) { 1184 if (i == HITCOUNT_IDX) 1185 seq_puts(m, "hitcount"); 1186 else { 1187 seq_puts(m, ","); 1188 hist_field_print(m, hist_data->fields[i]); 1189 } 1190 } 1191 1192 seq_puts(m, ":sort="); 1193 1194 for (i = 0; i < hist_data->n_sort_keys; i++) { 1195 struct tracing_map_sort_key *sort_key; 1196 1197 sort_key = &hist_data->sort_keys[i]; 1198 1199 if (i > 0) 1200 seq_puts(m, ","); 1201 1202 if (sort_key->field_idx == HITCOUNT_IDX) 1203 seq_puts(m, "hitcount"); 1204 else { 1205 unsigned int idx = sort_key->field_idx; 1206 1207 if (WARN_ON(idx >= TRACING_MAP_FIELDS_MAX)) 1208 return -EINVAL; 1209 1210 hist_field_print(m, hist_data->fields[idx]); 1211 } 1212 1213 if (sort_key->descending) 1214 seq_puts(m, ".descending"); 1215 } 1216 1217 seq_printf(m, ":size=%u", (1 << hist_data->map->map_bits)); 1218 1219 if (data->filter_str) 1220 seq_printf(m, " if %s", data->filter_str); 1221 1222 if (data->paused) 1223 seq_puts(m, " [paused]"); 1224 else 1225 seq_puts(m, " [active]"); 1226 1227 seq_putc(m, '\n'); 1228 1229 return 0; 1230 } 1231 1232 static int event_hist_trigger_init(struct event_trigger_ops *ops, 1233 struct event_trigger_data *data) 1234 { 1235 struct hist_trigger_data *hist_data = data->private_data; 1236 1237 if (!data->ref && hist_data->attrs->name) 1238 save_named_trigger(hist_data->attrs->name, data); 1239 1240 data->ref++; 1241 1242 return 0; 1243 } 1244 1245 static void event_hist_trigger_free(struct event_trigger_ops *ops, 1246 struct event_trigger_data *data) 1247 { 1248 struct hist_trigger_data *hist_data = data->private_data; 1249 1250 if (WARN_ON_ONCE(data->ref <= 0)) 1251 return; 1252 1253 data->ref--; 1254 if (!data->ref) { 1255 if (data->name) 1256 del_named_trigger(data); 1257 trigger_data_free(data); 1258 destroy_hist_data(hist_data); 1259 } 1260 } 1261 1262 static struct event_trigger_ops event_hist_trigger_ops = { 1263 .func = event_hist_trigger, 1264 .print = event_hist_trigger_print, 1265 .init = event_hist_trigger_init, 1266 .free = event_hist_trigger_free, 1267 }; 1268 1269 static int event_hist_trigger_named_init(struct event_trigger_ops *ops, 1270 struct event_trigger_data *data) 1271 { 1272 data->ref++; 1273 1274 save_named_trigger(data->named_data->name, data); 1275 1276 event_hist_trigger_init(ops, data->named_data); 1277 1278 return 0; 1279 } 1280 1281 static void event_hist_trigger_named_free(struct event_trigger_ops *ops, 1282 struct event_trigger_data *data) 1283 { 1284 if (WARN_ON_ONCE(data->ref <= 0)) 1285 return; 1286 1287 event_hist_trigger_free(ops, data->named_data); 1288 1289 data->ref--; 1290 if (!data->ref) { 1291 del_named_trigger(data); 1292 trigger_data_free(data); 1293 } 1294 } 1295 1296 static struct event_trigger_ops event_hist_trigger_named_ops = { 1297 .func = event_hist_trigger, 1298 .print = event_hist_trigger_print, 1299 .init = event_hist_trigger_named_init, 1300 .free = event_hist_trigger_named_free, 1301 }; 1302 1303 static struct event_trigger_ops *event_hist_get_trigger_ops(char *cmd, 1304 char *param) 1305 { 1306 return &event_hist_trigger_ops; 1307 } 1308 1309 static void hist_clear(struct event_trigger_data *data) 1310 { 1311 struct hist_trigger_data *hist_data = data->private_data; 1312 1313 if (data->name) 1314 pause_named_trigger(data); 1315 1316 synchronize_sched(); 1317 1318 tracing_map_clear(hist_data->map); 1319 1320 if (data->name) 1321 unpause_named_trigger(data); 1322 } 1323 1324 static bool compatible_field(struct ftrace_event_field *field, 1325 struct ftrace_event_field *test_field) 1326 { 1327 if (field == test_field) 1328 return true; 1329 if (field == NULL || test_field == NULL) 1330 return false; 1331 if (strcmp(field->name, test_field->name) != 0) 1332 return false; 1333 if (strcmp(field->type, test_field->type) != 0) 1334 return false; 1335 if (field->size != test_field->size) 1336 return false; 1337 if (field->is_signed != test_field->is_signed) 1338 return false; 1339 1340 return true; 1341 } 1342 1343 static bool hist_trigger_match(struct event_trigger_data *data, 1344 struct event_trigger_data *data_test, 1345 struct event_trigger_data *named_data, 1346 bool ignore_filter) 1347 { 1348 struct tracing_map_sort_key *sort_key, *sort_key_test; 1349 struct hist_trigger_data *hist_data, *hist_data_test; 1350 struct hist_field *key_field, *key_field_test; 1351 unsigned int i; 1352 1353 if (named_data && (named_data != data_test) && 1354 (named_data != data_test->named_data)) 1355 return false; 1356 1357 if (!named_data && is_named_trigger(data_test)) 1358 return false; 1359 1360 hist_data = data->private_data; 1361 hist_data_test = data_test->private_data; 1362 1363 if (hist_data->n_vals != hist_data_test->n_vals || 1364 hist_data->n_fields != hist_data_test->n_fields || 1365 hist_data->n_sort_keys != hist_data_test->n_sort_keys) 1366 return false; 1367 1368 if (!ignore_filter) { 1369 if ((data->filter_str && !data_test->filter_str) || 1370 (!data->filter_str && data_test->filter_str)) 1371 return false; 1372 } 1373 1374 for_each_hist_field(i, hist_data) { 1375 key_field = hist_data->fields[i]; 1376 key_field_test = hist_data_test->fields[i]; 1377 1378 if (key_field->flags != key_field_test->flags) 1379 return false; 1380 if (!compatible_field(key_field->field, key_field_test->field)) 1381 return false; 1382 if (key_field->offset != key_field_test->offset) 1383 return false; 1384 } 1385 1386 for (i = 0; i < hist_data->n_sort_keys; i++) { 1387 sort_key = &hist_data->sort_keys[i]; 1388 sort_key_test = &hist_data_test->sort_keys[i]; 1389 1390 if (sort_key->field_idx != sort_key_test->field_idx || 1391 sort_key->descending != sort_key_test->descending) 1392 return false; 1393 } 1394 1395 if (!ignore_filter && data->filter_str && 1396 (strcmp(data->filter_str, data_test->filter_str) != 0)) 1397 return false; 1398 1399 return true; 1400 } 1401 1402 static int hist_register_trigger(char *glob, struct event_trigger_ops *ops, 1403 struct event_trigger_data *data, 1404 struct trace_event_file *file) 1405 { 1406 struct hist_trigger_data *hist_data = data->private_data; 1407 struct event_trigger_data *test, *named_data = NULL; 1408 int ret = 0; 1409 1410 if (hist_data->attrs->name) { 1411 named_data = find_named_trigger(hist_data->attrs->name); 1412 if (named_data) { 1413 if (!hist_trigger_match(data, named_data, named_data, 1414 true)) { 1415 ret = -EINVAL; 1416 goto out; 1417 } 1418 } 1419 } 1420 1421 if (hist_data->attrs->name && !named_data) 1422 goto new; 1423 1424 list_for_each_entry_rcu(test, &file->triggers, list) { 1425 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) { 1426 if (!hist_trigger_match(data, test, named_data, false)) 1427 continue; 1428 if (hist_data->attrs->pause) 1429 test->paused = true; 1430 else if (hist_data->attrs->cont) 1431 test->paused = false; 1432 else if (hist_data->attrs->clear) 1433 hist_clear(test); 1434 else 1435 ret = -EEXIST; 1436 goto out; 1437 } 1438 } 1439 new: 1440 if (hist_data->attrs->cont || hist_data->attrs->clear) { 1441 ret = -ENOENT; 1442 goto out; 1443 } 1444 1445 if (hist_data->attrs->pause) 1446 data->paused = true; 1447 1448 if (named_data) { 1449 destroy_hist_data(data->private_data); 1450 data->private_data = named_data->private_data; 1451 set_named_trigger_data(data, named_data); 1452 data->ops = &event_hist_trigger_named_ops; 1453 } 1454 1455 if (data->ops->init) { 1456 ret = data->ops->init(data->ops, data); 1457 if (ret < 0) 1458 goto out; 1459 } 1460 1461 list_add_rcu(&data->list, &file->triggers); 1462 ret++; 1463 1464 update_cond_flag(file); 1465 1466 if (trace_event_trigger_enable_disable(file, 1) < 0) { 1467 list_del_rcu(&data->list); 1468 update_cond_flag(file); 1469 ret--; 1470 } 1471 out: 1472 return ret; 1473 } 1474 1475 static void hist_unregister_trigger(char *glob, struct event_trigger_ops *ops, 1476 struct event_trigger_data *data, 1477 struct trace_event_file *file) 1478 { 1479 struct hist_trigger_data *hist_data = data->private_data; 1480 struct event_trigger_data *test, *named_data = NULL; 1481 bool unregistered = false; 1482 1483 if (hist_data->attrs->name) 1484 named_data = find_named_trigger(hist_data->attrs->name); 1485 1486 list_for_each_entry_rcu(test, &file->triggers, list) { 1487 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) { 1488 if (!hist_trigger_match(data, test, named_data, false)) 1489 continue; 1490 unregistered = true; 1491 list_del_rcu(&test->list); 1492 trace_event_trigger_enable_disable(file, 0); 1493 update_cond_flag(file); 1494 break; 1495 } 1496 } 1497 1498 if (unregistered && test->ops->free) 1499 test->ops->free(test->ops, test); 1500 } 1501 1502 static void hist_unreg_all(struct trace_event_file *file) 1503 { 1504 struct event_trigger_data *test, *n; 1505 1506 list_for_each_entry_safe(test, n, &file->triggers, list) { 1507 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) { 1508 list_del_rcu(&test->list); 1509 trace_event_trigger_enable_disable(file, 0); 1510 update_cond_flag(file); 1511 if (test->ops->free) 1512 test->ops->free(test->ops, test); 1513 } 1514 } 1515 } 1516 1517 static int event_hist_trigger_func(struct event_command *cmd_ops, 1518 struct trace_event_file *file, 1519 char *glob, char *cmd, char *param) 1520 { 1521 unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT; 1522 struct event_trigger_data *trigger_data; 1523 struct hist_trigger_attrs *attrs; 1524 struct event_trigger_ops *trigger_ops; 1525 struct hist_trigger_data *hist_data; 1526 char *trigger; 1527 int ret = 0; 1528 1529 if (!param) 1530 return -EINVAL; 1531 1532 /* separate the trigger from the filter (k:v [if filter]) */ 1533 trigger = strsep(¶m, " \t"); 1534 if (!trigger) 1535 return -EINVAL; 1536 1537 attrs = parse_hist_trigger_attrs(trigger); 1538 if (IS_ERR(attrs)) 1539 return PTR_ERR(attrs); 1540 1541 if (attrs->map_bits) 1542 hist_trigger_bits = attrs->map_bits; 1543 1544 hist_data = create_hist_data(hist_trigger_bits, attrs, file); 1545 if (IS_ERR(hist_data)) { 1546 destroy_hist_trigger_attrs(attrs); 1547 return PTR_ERR(hist_data); 1548 } 1549 1550 trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger); 1551 1552 ret = -ENOMEM; 1553 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL); 1554 if (!trigger_data) 1555 goto out_free; 1556 1557 trigger_data->count = -1; 1558 trigger_data->ops = trigger_ops; 1559 trigger_data->cmd_ops = cmd_ops; 1560 1561 INIT_LIST_HEAD(&trigger_data->list); 1562 RCU_INIT_POINTER(trigger_data->filter, NULL); 1563 1564 trigger_data->private_data = hist_data; 1565 1566 /* if param is non-empty, it's supposed to be a filter */ 1567 if (param && cmd_ops->set_filter) { 1568 ret = cmd_ops->set_filter(param, trigger_data, file); 1569 if (ret < 0) 1570 goto out_free; 1571 } 1572 1573 if (glob[0] == '!') { 1574 cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); 1575 ret = 0; 1576 goto out_free; 1577 } 1578 1579 ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file); 1580 /* 1581 * The above returns on success the # of triggers registered, 1582 * but if it didn't register any it returns zero. Consider no 1583 * triggers registered a failure too. 1584 */ 1585 if (!ret) { 1586 if (!(attrs->pause || attrs->cont || attrs->clear)) 1587 ret = -ENOENT; 1588 goto out_free; 1589 } else if (ret < 0) 1590 goto out_free; 1591 /* Just return zero, not the number of registered triggers */ 1592 ret = 0; 1593 out: 1594 return ret; 1595 out_free: 1596 if (cmd_ops->set_filter) 1597 cmd_ops->set_filter(NULL, trigger_data, NULL); 1598 1599 kfree(trigger_data); 1600 1601 destroy_hist_data(hist_data); 1602 goto out; 1603 } 1604 1605 static struct event_command trigger_hist_cmd = { 1606 .name = "hist", 1607 .trigger_type = ETT_EVENT_HIST, 1608 .flags = EVENT_CMD_FL_NEEDS_REC, 1609 .func = event_hist_trigger_func, 1610 .reg = hist_register_trigger, 1611 .unreg = hist_unregister_trigger, 1612 .unreg_all = hist_unreg_all, 1613 .get_trigger_ops = event_hist_get_trigger_ops, 1614 .set_filter = set_trigger_filter, 1615 }; 1616 1617 __init int register_trigger_hist_cmd(void) 1618 { 1619 int ret; 1620 1621 ret = register_event_command(&trigger_hist_cmd); 1622 WARN_ON(ret < 0); 1623 1624 return ret; 1625 } 1626 1627 static void 1628 hist_enable_trigger(struct event_trigger_data *data, void *rec) 1629 { 1630 struct enable_trigger_data *enable_data = data->private_data; 1631 struct event_trigger_data *test; 1632 1633 list_for_each_entry_rcu(test, &enable_data->file->triggers, list) { 1634 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) { 1635 if (enable_data->enable) 1636 test->paused = false; 1637 else 1638 test->paused = true; 1639 } 1640 } 1641 } 1642 1643 static void 1644 hist_enable_count_trigger(struct event_trigger_data *data, void *rec) 1645 { 1646 if (!data->count) 1647 return; 1648 1649 if (data->count != -1) 1650 (data->count)--; 1651 1652 hist_enable_trigger(data, rec); 1653 } 1654 1655 static struct event_trigger_ops hist_enable_trigger_ops = { 1656 .func = hist_enable_trigger, 1657 .print = event_enable_trigger_print, 1658 .init = event_trigger_init, 1659 .free = event_enable_trigger_free, 1660 }; 1661 1662 static struct event_trigger_ops hist_enable_count_trigger_ops = { 1663 .func = hist_enable_count_trigger, 1664 .print = event_enable_trigger_print, 1665 .init = event_trigger_init, 1666 .free = event_enable_trigger_free, 1667 }; 1668 1669 static struct event_trigger_ops hist_disable_trigger_ops = { 1670 .func = hist_enable_trigger, 1671 .print = event_enable_trigger_print, 1672 .init = event_trigger_init, 1673 .free = event_enable_trigger_free, 1674 }; 1675 1676 static struct event_trigger_ops hist_disable_count_trigger_ops = { 1677 .func = hist_enable_count_trigger, 1678 .print = event_enable_trigger_print, 1679 .init = event_trigger_init, 1680 .free = event_enable_trigger_free, 1681 }; 1682 1683 static struct event_trigger_ops * 1684 hist_enable_get_trigger_ops(char *cmd, char *param) 1685 { 1686 struct event_trigger_ops *ops; 1687 bool enable; 1688 1689 enable = (strcmp(cmd, ENABLE_HIST_STR) == 0); 1690 1691 if (enable) 1692 ops = param ? &hist_enable_count_trigger_ops : 1693 &hist_enable_trigger_ops; 1694 else 1695 ops = param ? &hist_disable_count_trigger_ops : 1696 &hist_disable_trigger_ops; 1697 1698 return ops; 1699 } 1700 1701 static void hist_enable_unreg_all(struct trace_event_file *file) 1702 { 1703 struct event_trigger_data *test, *n; 1704 1705 list_for_each_entry_safe(test, n, &file->triggers, list) { 1706 if (test->cmd_ops->trigger_type == ETT_HIST_ENABLE) { 1707 list_del_rcu(&test->list); 1708 update_cond_flag(file); 1709 trace_event_trigger_enable_disable(file, 0); 1710 if (test->ops->free) 1711 test->ops->free(test->ops, test); 1712 } 1713 } 1714 } 1715 1716 static struct event_command trigger_hist_enable_cmd = { 1717 .name = ENABLE_HIST_STR, 1718 .trigger_type = ETT_HIST_ENABLE, 1719 .func = event_enable_trigger_func, 1720 .reg = event_enable_register_trigger, 1721 .unreg = event_enable_unregister_trigger, 1722 .unreg_all = hist_enable_unreg_all, 1723 .get_trigger_ops = hist_enable_get_trigger_ops, 1724 .set_filter = set_trigger_filter, 1725 }; 1726 1727 static struct event_command trigger_hist_disable_cmd = { 1728 .name = DISABLE_HIST_STR, 1729 .trigger_type = ETT_HIST_ENABLE, 1730 .func = event_enable_trigger_func, 1731 .reg = event_enable_register_trigger, 1732 .unreg = event_enable_unregister_trigger, 1733 .unreg_all = hist_enable_unreg_all, 1734 .get_trigger_ops = hist_enable_get_trigger_ops, 1735 .set_filter = set_trigger_filter, 1736 }; 1737 1738 static __init void unregister_trigger_hist_enable_disable_cmds(void) 1739 { 1740 unregister_event_command(&trigger_hist_enable_cmd); 1741 unregister_event_command(&trigger_hist_disable_cmd); 1742 } 1743 1744 __init int register_trigger_hist_enable_disable_cmds(void) 1745 { 1746 int ret; 1747 1748 ret = register_event_command(&trigger_hist_enable_cmd); 1749 if (WARN_ON(ret < 0)) 1750 return ret; 1751 ret = register_event_command(&trigger_hist_disable_cmd); 1752 if (WARN_ON(ret < 0)) 1753 unregister_trigger_hist_enable_disable_cmds(); 1754 1755 return ret; 1756 } 1757