1 /* 2 * trace-event-python. Feed trace events to an embedded Python interpreter. 3 * 4 * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 */ 21 22 #include <Python.h> 23 24 #include <inttypes.h> 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <stdbool.h> 29 #include <errno.h> 30 #include <linux/bitmap.h> 31 #include <linux/compiler.h> 32 #include <linux/time64.h> 33 34 #include "../build-id.h" 35 #include "../counts.h" 36 #include "../debug.h" 37 #include "../dso.h" 38 #include "../callchain.h" 39 #include "../env.h" 40 #include "../evsel.h" 41 #include "../event.h" 42 #include "../thread.h" 43 #include "../comm.h" 44 #include "../machine.h" 45 #include "../db-export.h" 46 #include "../thread-stack.h" 47 #include "../trace-event.h" 48 #include "../call-path.h" 49 #include "map.h" 50 #include "symbol.h" 51 #include "thread_map.h" 52 #include "print_binary.h" 53 #include "stat.h" 54 #include "mem-events.h" 55 #include "util/perf_regs.h" 56 57 #if PY_MAJOR_VERSION < 3 58 #define _PyUnicode_FromString(arg) \ 59 PyString_FromString(arg) 60 #define _PyUnicode_FromStringAndSize(arg1, arg2) \ 61 PyString_FromStringAndSize((arg1), (arg2)) 62 #define _PyBytes_FromStringAndSize(arg1, arg2) \ 63 PyString_FromStringAndSize((arg1), (arg2)) 64 #define _PyLong_FromLong(arg) \ 65 PyInt_FromLong(arg) 66 #define _PyLong_AsLong(arg) \ 67 PyInt_AsLong(arg) 68 #define _PyCapsule_New(arg1, arg2, arg3) \ 69 PyCObject_FromVoidPtr((arg1), (arg2)) 70 71 PyMODINIT_FUNC initperf_trace_context(void); 72 #else 73 #define _PyUnicode_FromString(arg) \ 74 PyUnicode_FromString(arg) 75 #define _PyUnicode_FromStringAndSize(arg1, arg2) \ 76 PyUnicode_FromStringAndSize((arg1), (arg2)) 77 #define _PyBytes_FromStringAndSize(arg1, arg2) \ 78 PyBytes_FromStringAndSize((arg1), (arg2)) 79 #define _PyLong_FromLong(arg) \ 80 PyLong_FromLong(arg) 81 #define _PyLong_AsLong(arg) \ 82 PyLong_AsLong(arg) 83 #define _PyCapsule_New(arg1, arg2, arg3) \ 84 PyCapsule_New((arg1), (arg2), (arg3)) 85 86 PyMODINIT_FUNC PyInit_perf_trace_context(void); 87 #endif 88 89 #define TRACE_EVENT_TYPE_MAX \ 90 ((1 << (sizeof(unsigned short) * 8)) - 1) 91 92 static DECLARE_BITMAP(events_defined, TRACE_EVENT_TYPE_MAX); 93 94 #define MAX_FIELDS 64 95 #define N_COMMON_FIELDS 7 96 97 extern struct scripting_context *scripting_context; 98 99 static char *cur_field_name; 100 static int zero_flag_atom; 101 102 static PyObject *main_module, *main_dict; 103 104 struct tables { 105 struct db_export dbe; 106 PyObject *evsel_handler; 107 PyObject *machine_handler; 108 PyObject *thread_handler; 109 PyObject *comm_handler; 110 PyObject *comm_thread_handler; 111 PyObject *dso_handler; 112 PyObject *symbol_handler; 113 PyObject *branch_type_handler; 114 PyObject *sample_handler; 115 PyObject *call_path_handler; 116 PyObject *call_return_handler; 117 PyObject *synth_handler; 118 PyObject *context_switch_handler; 119 bool db_export_mode; 120 }; 121 122 static struct tables tables_global; 123 124 static void handler_call_die(const char *handler_name) __noreturn; 125 static void handler_call_die(const char *handler_name) 126 { 127 PyErr_Print(); 128 Py_FatalError("problem in Python trace event handler"); 129 // Py_FatalError does not return 130 // but we have to make the compiler happy 131 abort(); 132 } 133 134 /* 135 * Insert val into the dictionary and decrement the reference counter. 136 * This is necessary for dictionaries since PyDict_SetItemString() does not 137 * steal a reference, as opposed to PyTuple_SetItem(). 138 */ 139 static void pydict_set_item_string_decref(PyObject *dict, const char *key, PyObject *val) 140 { 141 PyDict_SetItemString(dict, key, val); 142 Py_DECREF(val); 143 } 144 145 static PyObject *get_handler(const char *handler_name) 146 { 147 PyObject *handler; 148 149 handler = PyDict_GetItemString(main_dict, handler_name); 150 if (handler && !PyCallable_Check(handler)) 151 return NULL; 152 return handler; 153 } 154 155 static int get_argument_count(PyObject *handler) 156 { 157 int arg_count = 0; 158 159 /* 160 * The attribute for the code object is func_code in Python 2, 161 * whereas it is __code__ in Python 3.0+. 162 */ 163 PyObject *code_obj = PyObject_GetAttrString(handler, 164 "func_code"); 165 if (PyErr_Occurred()) { 166 PyErr_Clear(); 167 code_obj = PyObject_GetAttrString(handler, 168 "__code__"); 169 } 170 PyErr_Clear(); 171 if (code_obj) { 172 PyObject *arg_count_obj = PyObject_GetAttrString(code_obj, 173 "co_argcount"); 174 if (arg_count_obj) { 175 arg_count = (int) _PyLong_AsLong(arg_count_obj); 176 Py_DECREF(arg_count_obj); 177 } 178 Py_DECREF(code_obj); 179 } 180 return arg_count; 181 } 182 183 static void call_object(PyObject *handler, PyObject *args, const char *die_msg) 184 { 185 PyObject *retval; 186 187 retval = PyObject_CallObject(handler, args); 188 if (retval == NULL) 189 handler_call_die(die_msg); 190 Py_DECREF(retval); 191 } 192 193 static void try_call_object(const char *handler_name, PyObject *args) 194 { 195 PyObject *handler; 196 197 handler = get_handler(handler_name); 198 if (handler) 199 call_object(handler, args, handler_name); 200 } 201 202 static void define_value(enum tep_print_arg_type field_type, 203 const char *ev_name, 204 const char *field_name, 205 const char *field_value, 206 const char *field_str) 207 { 208 const char *handler_name = "define_flag_value"; 209 PyObject *t; 210 unsigned long long value; 211 unsigned n = 0; 212 213 if (field_type == TEP_PRINT_SYMBOL) 214 handler_name = "define_symbolic_value"; 215 216 t = PyTuple_New(4); 217 if (!t) 218 Py_FatalError("couldn't create Python tuple"); 219 220 value = eval_flag(field_value); 221 222 PyTuple_SetItem(t, n++, _PyUnicode_FromString(ev_name)); 223 PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_name)); 224 PyTuple_SetItem(t, n++, _PyLong_FromLong(value)); 225 PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_str)); 226 227 try_call_object(handler_name, t); 228 229 Py_DECREF(t); 230 } 231 232 static void define_values(enum tep_print_arg_type field_type, 233 struct tep_print_flag_sym *field, 234 const char *ev_name, 235 const char *field_name) 236 { 237 define_value(field_type, ev_name, field_name, field->value, 238 field->str); 239 240 if (field->next) 241 define_values(field_type, field->next, ev_name, field_name); 242 } 243 244 static void define_field(enum tep_print_arg_type field_type, 245 const char *ev_name, 246 const char *field_name, 247 const char *delim) 248 { 249 const char *handler_name = "define_flag_field"; 250 PyObject *t; 251 unsigned n = 0; 252 253 if (field_type == TEP_PRINT_SYMBOL) 254 handler_name = "define_symbolic_field"; 255 256 if (field_type == TEP_PRINT_FLAGS) 257 t = PyTuple_New(3); 258 else 259 t = PyTuple_New(2); 260 if (!t) 261 Py_FatalError("couldn't create Python tuple"); 262 263 PyTuple_SetItem(t, n++, _PyUnicode_FromString(ev_name)); 264 PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_name)); 265 if (field_type == TEP_PRINT_FLAGS) 266 PyTuple_SetItem(t, n++, _PyUnicode_FromString(delim)); 267 268 try_call_object(handler_name, t); 269 270 Py_DECREF(t); 271 } 272 273 static void define_event_symbols(struct tep_event *event, 274 const char *ev_name, 275 struct tep_print_arg *args) 276 { 277 if (args == NULL) 278 return; 279 280 switch (args->type) { 281 case TEP_PRINT_NULL: 282 break; 283 case TEP_PRINT_ATOM: 284 define_value(TEP_PRINT_FLAGS, ev_name, cur_field_name, "0", 285 args->atom.atom); 286 zero_flag_atom = 0; 287 break; 288 case TEP_PRINT_FIELD: 289 free(cur_field_name); 290 cur_field_name = strdup(args->field.name); 291 break; 292 case TEP_PRINT_FLAGS: 293 define_event_symbols(event, ev_name, args->flags.field); 294 define_field(TEP_PRINT_FLAGS, ev_name, cur_field_name, 295 args->flags.delim); 296 define_values(TEP_PRINT_FLAGS, args->flags.flags, ev_name, 297 cur_field_name); 298 break; 299 case TEP_PRINT_SYMBOL: 300 define_event_symbols(event, ev_name, args->symbol.field); 301 define_field(TEP_PRINT_SYMBOL, ev_name, cur_field_name, NULL); 302 define_values(TEP_PRINT_SYMBOL, args->symbol.symbols, ev_name, 303 cur_field_name); 304 break; 305 case TEP_PRINT_HEX: 306 case TEP_PRINT_HEX_STR: 307 define_event_symbols(event, ev_name, args->hex.field); 308 define_event_symbols(event, ev_name, args->hex.size); 309 break; 310 case TEP_PRINT_INT_ARRAY: 311 define_event_symbols(event, ev_name, args->int_array.field); 312 define_event_symbols(event, ev_name, args->int_array.count); 313 define_event_symbols(event, ev_name, args->int_array.el_size); 314 break; 315 case TEP_PRINT_STRING: 316 break; 317 case TEP_PRINT_TYPE: 318 define_event_symbols(event, ev_name, args->typecast.item); 319 break; 320 case TEP_PRINT_OP: 321 if (strcmp(args->op.op, ":") == 0) 322 zero_flag_atom = 1; 323 define_event_symbols(event, ev_name, args->op.left); 324 define_event_symbols(event, ev_name, args->op.right); 325 break; 326 default: 327 /* gcc warns for these? */ 328 case TEP_PRINT_BSTRING: 329 case TEP_PRINT_DYNAMIC_ARRAY: 330 case TEP_PRINT_DYNAMIC_ARRAY_LEN: 331 case TEP_PRINT_FUNC: 332 case TEP_PRINT_BITMASK: 333 /* we should warn... */ 334 return; 335 } 336 337 if (args->next) 338 define_event_symbols(event, ev_name, args->next); 339 } 340 341 static PyObject *get_field_numeric_entry(struct tep_event *event, 342 struct tep_format_field *field, void *data) 343 { 344 bool is_array = field->flags & TEP_FIELD_IS_ARRAY; 345 PyObject *obj = NULL, *list = NULL; 346 unsigned long long val; 347 unsigned int item_size, n_items, i; 348 349 if (is_array) { 350 list = PyList_New(field->arraylen); 351 item_size = field->size / field->arraylen; 352 n_items = field->arraylen; 353 } else { 354 item_size = field->size; 355 n_items = 1; 356 } 357 358 for (i = 0; i < n_items; i++) { 359 360 val = read_size(event, data + field->offset + i * item_size, 361 item_size); 362 if (field->flags & TEP_FIELD_IS_SIGNED) { 363 if ((long long)val >= LONG_MIN && 364 (long long)val <= LONG_MAX) 365 obj = _PyLong_FromLong(val); 366 else 367 obj = PyLong_FromLongLong(val); 368 } else { 369 if (val <= LONG_MAX) 370 obj = _PyLong_FromLong(val); 371 else 372 obj = PyLong_FromUnsignedLongLong(val); 373 } 374 if (is_array) 375 PyList_SET_ITEM(list, i, obj); 376 } 377 if (is_array) 378 obj = list; 379 return obj; 380 } 381 382 static const char *get_dsoname(struct map *map) 383 { 384 const char *dsoname = "[unknown]"; 385 386 if (map && map->dso) { 387 if (symbol_conf.show_kernel_path && map->dso->long_name) 388 dsoname = map->dso->long_name; 389 else 390 dsoname = map->dso->name; 391 } 392 393 return dsoname; 394 } 395 396 static unsigned long get_offset(struct symbol *sym, struct addr_location *al) 397 { 398 unsigned long offset; 399 400 if (al->addr < sym->end) 401 offset = al->addr - sym->start; 402 else 403 offset = al->addr - al->map->start - sym->start; 404 405 return offset; 406 } 407 408 static PyObject *python_process_callchain(struct perf_sample *sample, 409 struct evsel *evsel, 410 struct addr_location *al) 411 { 412 PyObject *pylist; 413 414 pylist = PyList_New(0); 415 if (!pylist) 416 Py_FatalError("couldn't create Python list"); 417 418 if (!symbol_conf.use_callchain || !sample->callchain) 419 goto exit; 420 421 if (thread__resolve_callchain(al->thread, &callchain_cursor, evsel, 422 sample, NULL, NULL, 423 scripting_max_stack) != 0) { 424 pr_err("Failed to resolve callchain. Skipping\n"); 425 goto exit; 426 } 427 callchain_cursor_commit(&callchain_cursor); 428 429 430 while (1) { 431 PyObject *pyelem; 432 struct callchain_cursor_node *node; 433 node = callchain_cursor_current(&callchain_cursor); 434 if (!node) 435 break; 436 437 pyelem = PyDict_New(); 438 if (!pyelem) 439 Py_FatalError("couldn't create Python dictionary"); 440 441 442 pydict_set_item_string_decref(pyelem, "ip", 443 PyLong_FromUnsignedLongLong(node->ip)); 444 445 if (node->ms.sym) { 446 PyObject *pysym = PyDict_New(); 447 if (!pysym) 448 Py_FatalError("couldn't create Python dictionary"); 449 pydict_set_item_string_decref(pysym, "start", 450 PyLong_FromUnsignedLongLong(node->ms.sym->start)); 451 pydict_set_item_string_decref(pysym, "end", 452 PyLong_FromUnsignedLongLong(node->ms.sym->end)); 453 pydict_set_item_string_decref(pysym, "binding", 454 _PyLong_FromLong(node->ms.sym->binding)); 455 pydict_set_item_string_decref(pysym, "name", 456 _PyUnicode_FromStringAndSize(node->ms.sym->name, 457 node->ms.sym->namelen)); 458 pydict_set_item_string_decref(pyelem, "sym", pysym); 459 460 if (node->ms.map) { 461 struct map *map = node->ms.map; 462 struct addr_location node_al; 463 unsigned long offset; 464 465 node_al.addr = map->map_ip(map, node->ip); 466 node_al.map = map; 467 offset = get_offset(node->ms.sym, &node_al); 468 469 pydict_set_item_string_decref( 470 pyelem, "sym_off", 471 PyLong_FromUnsignedLongLong(offset)); 472 } 473 if (node->srcline && strcmp(":0", node->srcline)) { 474 pydict_set_item_string_decref( 475 pyelem, "sym_srcline", 476 _PyUnicode_FromString(node->srcline)); 477 } 478 } 479 480 if (node->ms.map) { 481 const char *dsoname = get_dsoname(node->ms.map); 482 483 pydict_set_item_string_decref(pyelem, "dso", 484 _PyUnicode_FromString(dsoname)); 485 } 486 487 callchain_cursor_advance(&callchain_cursor); 488 PyList_Append(pylist, pyelem); 489 Py_DECREF(pyelem); 490 } 491 492 exit: 493 return pylist; 494 } 495 496 static PyObject *python_process_brstack(struct perf_sample *sample, 497 struct thread *thread) 498 { 499 struct branch_stack *br = sample->branch_stack; 500 struct branch_entry *entries = perf_sample__branch_entries(sample); 501 PyObject *pylist; 502 u64 i; 503 504 pylist = PyList_New(0); 505 if (!pylist) 506 Py_FatalError("couldn't create Python list"); 507 508 if (!(br && br->nr)) 509 goto exit; 510 511 for (i = 0; i < br->nr; i++) { 512 PyObject *pyelem; 513 struct addr_location al; 514 const char *dsoname; 515 516 pyelem = PyDict_New(); 517 if (!pyelem) 518 Py_FatalError("couldn't create Python dictionary"); 519 520 pydict_set_item_string_decref(pyelem, "from", 521 PyLong_FromUnsignedLongLong(entries[i].from)); 522 pydict_set_item_string_decref(pyelem, "to", 523 PyLong_FromUnsignedLongLong(entries[i].to)); 524 pydict_set_item_string_decref(pyelem, "mispred", 525 PyBool_FromLong(entries[i].flags.mispred)); 526 pydict_set_item_string_decref(pyelem, "predicted", 527 PyBool_FromLong(entries[i].flags.predicted)); 528 pydict_set_item_string_decref(pyelem, "in_tx", 529 PyBool_FromLong(entries[i].flags.in_tx)); 530 pydict_set_item_string_decref(pyelem, "abort", 531 PyBool_FromLong(entries[i].flags.abort)); 532 pydict_set_item_string_decref(pyelem, "cycles", 533 PyLong_FromUnsignedLongLong(entries[i].flags.cycles)); 534 535 thread__find_map_fb(thread, sample->cpumode, 536 entries[i].from, &al); 537 dsoname = get_dsoname(al.map); 538 pydict_set_item_string_decref(pyelem, "from_dsoname", 539 _PyUnicode_FromString(dsoname)); 540 541 thread__find_map_fb(thread, sample->cpumode, 542 entries[i].to, &al); 543 dsoname = get_dsoname(al.map); 544 pydict_set_item_string_decref(pyelem, "to_dsoname", 545 _PyUnicode_FromString(dsoname)); 546 547 PyList_Append(pylist, pyelem); 548 Py_DECREF(pyelem); 549 } 550 551 exit: 552 return pylist; 553 } 554 555 static int get_symoff(struct symbol *sym, struct addr_location *al, 556 bool print_off, char *bf, int size) 557 { 558 unsigned long offset; 559 560 if (!sym || !sym->name[0]) 561 return scnprintf(bf, size, "%s", "[unknown]"); 562 563 if (!print_off) 564 return scnprintf(bf, size, "%s", sym->name); 565 566 offset = get_offset(sym, al); 567 568 return scnprintf(bf, size, "%s+0x%x", sym->name, offset); 569 } 570 571 static int get_br_mspred(struct branch_flags *flags, char *bf, int size) 572 { 573 if (!flags->mispred && !flags->predicted) 574 return scnprintf(bf, size, "%s", "-"); 575 576 if (flags->mispred) 577 return scnprintf(bf, size, "%s", "M"); 578 579 return scnprintf(bf, size, "%s", "P"); 580 } 581 582 static PyObject *python_process_brstacksym(struct perf_sample *sample, 583 struct thread *thread) 584 { 585 struct branch_stack *br = sample->branch_stack; 586 struct branch_entry *entries = perf_sample__branch_entries(sample); 587 PyObject *pylist; 588 u64 i; 589 char bf[512]; 590 struct addr_location al; 591 592 pylist = PyList_New(0); 593 if (!pylist) 594 Py_FatalError("couldn't create Python list"); 595 596 if (!(br && br->nr)) 597 goto exit; 598 599 for (i = 0; i < br->nr; i++) { 600 PyObject *pyelem; 601 602 pyelem = PyDict_New(); 603 if (!pyelem) 604 Py_FatalError("couldn't create Python dictionary"); 605 606 thread__find_symbol_fb(thread, sample->cpumode, 607 entries[i].from, &al); 608 get_symoff(al.sym, &al, true, bf, sizeof(bf)); 609 pydict_set_item_string_decref(pyelem, "from", 610 _PyUnicode_FromString(bf)); 611 612 thread__find_symbol_fb(thread, sample->cpumode, 613 entries[i].to, &al); 614 get_symoff(al.sym, &al, true, bf, sizeof(bf)); 615 pydict_set_item_string_decref(pyelem, "to", 616 _PyUnicode_FromString(bf)); 617 618 get_br_mspred(&entries[i].flags, bf, sizeof(bf)); 619 pydict_set_item_string_decref(pyelem, "pred", 620 _PyUnicode_FromString(bf)); 621 622 if (entries[i].flags.in_tx) { 623 pydict_set_item_string_decref(pyelem, "in_tx", 624 _PyUnicode_FromString("X")); 625 } else { 626 pydict_set_item_string_decref(pyelem, "in_tx", 627 _PyUnicode_FromString("-")); 628 } 629 630 if (entries[i].flags.abort) { 631 pydict_set_item_string_decref(pyelem, "abort", 632 _PyUnicode_FromString("A")); 633 } else { 634 pydict_set_item_string_decref(pyelem, "abort", 635 _PyUnicode_FromString("-")); 636 } 637 638 PyList_Append(pylist, pyelem); 639 Py_DECREF(pyelem); 640 } 641 642 exit: 643 return pylist; 644 } 645 646 static PyObject *get_sample_value_as_tuple(struct sample_read_value *value, 647 u64 read_format) 648 { 649 PyObject *t; 650 651 t = PyTuple_New(3); 652 if (!t) 653 Py_FatalError("couldn't create Python tuple"); 654 PyTuple_SetItem(t, 0, PyLong_FromUnsignedLongLong(value->id)); 655 PyTuple_SetItem(t, 1, PyLong_FromUnsignedLongLong(value->value)); 656 if (read_format & PERF_FORMAT_LOST) 657 PyTuple_SetItem(t, 2, PyLong_FromUnsignedLongLong(value->lost)); 658 659 return t; 660 } 661 662 static void set_sample_read_in_dict(PyObject *dict_sample, 663 struct perf_sample *sample, 664 struct evsel *evsel) 665 { 666 u64 read_format = evsel->core.attr.read_format; 667 PyObject *values; 668 unsigned int i; 669 670 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) { 671 pydict_set_item_string_decref(dict_sample, "time_enabled", 672 PyLong_FromUnsignedLongLong(sample->read.time_enabled)); 673 } 674 675 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) { 676 pydict_set_item_string_decref(dict_sample, "time_running", 677 PyLong_FromUnsignedLongLong(sample->read.time_running)); 678 } 679 680 if (read_format & PERF_FORMAT_GROUP) 681 values = PyList_New(sample->read.group.nr); 682 else 683 values = PyList_New(1); 684 685 if (!values) 686 Py_FatalError("couldn't create Python list"); 687 688 if (read_format & PERF_FORMAT_GROUP) { 689 struct sample_read_value *v = sample->read.group.values; 690 691 i = 0; 692 sample_read_group__for_each(v, sample->read.group.nr, read_format) { 693 PyObject *t = get_sample_value_as_tuple(v, read_format); 694 PyList_SET_ITEM(values, i, t); 695 i++; 696 } 697 } else { 698 PyObject *t = get_sample_value_as_tuple(&sample->read.one, 699 read_format); 700 PyList_SET_ITEM(values, 0, t); 701 } 702 pydict_set_item_string_decref(dict_sample, "values", values); 703 } 704 705 static void set_sample_datasrc_in_dict(PyObject *dict, 706 struct perf_sample *sample) 707 { 708 struct mem_info mi = { .data_src.val = sample->data_src }; 709 char decode[100]; 710 711 pydict_set_item_string_decref(dict, "datasrc", 712 PyLong_FromUnsignedLongLong(sample->data_src)); 713 714 perf_script__meminfo_scnprintf(decode, 100, &mi); 715 716 pydict_set_item_string_decref(dict, "datasrc_decode", 717 _PyUnicode_FromString(decode)); 718 } 719 720 static void regs_map(struct regs_dump *regs, uint64_t mask, const char *arch, char *bf, int size) 721 { 722 unsigned int i = 0, r; 723 int printed = 0; 724 725 bf[0] = 0; 726 727 if (!regs || !regs->regs) 728 return; 729 730 for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) { 731 u64 val = regs->regs[i++]; 732 733 printed += scnprintf(bf + printed, size - printed, 734 "%5s:0x%" PRIx64 " ", 735 perf_reg_name(r, arch), val); 736 } 737 } 738 739 static void set_regs_in_dict(PyObject *dict, 740 struct perf_sample *sample, 741 struct evsel *evsel) 742 { 743 struct perf_event_attr *attr = &evsel->core.attr; 744 const char *arch = perf_env__arch(evsel__env(evsel)); 745 746 /* 747 * Here value 28 is a constant size which can be used to print 748 * one register value and its corresponds to: 749 * 16 chars is to specify 64 bit register in hexadecimal. 750 * 2 chars is for appending "0x" to the hexadecimal value and 751 * 10 chars is for register name. 752 */ 753 int size = __sw_hweight64(attr->sample_regs_intr) * 28; 754 char bf[size]; 755 756 regs_map(&sample->intr_regs, attr->sample_regs_intr, arch, bf, sizeof(bf)); 757 758 pydict_set_item_string_decref(dict, "iregs", 759 _PyUnicode_FromString(bf)); 760 761 regs_map(&sample->user_regs, attr->sample_regs_user, arch, bf, sizeof(bf)); 762 763 pydict_set_item_string_decref(dict, "uregs", 764 _PyUnicode_FromString(bf)); 765 } 766 767 static void set_sym_in_dict(PyObject *dict, struct addr_location *al, 768 const char *dso_field, const char *dso_bid_field, 769 const char *dso_map_start, const char *dso_map_end, 770 const char *sym_field, const char *symoff_field) 771 { 772 char sbuild_id[SBUILD_ID_SIZE]; 773 774 if (al->map) { 775 pydict_set_item_string_decref(dict, dso_field, 776 _PyUnicode_FromString(al->map->dso->name)); 777 build_id__sprintf(&al->map->dso->bid, sbuild_id); 778 pydict_set_item_string_decref(dict, dso_bid_field, 779 _PyUnicode_FromString(sbuild_id)); 780 pydict_set_item_string_decref(dict, dso_map_start, 781 PyLong_FromUnsignedLong(al->map->start)); 782 pydict_set_item_string_decref(dict, dso_map_end, 783 PyLong_FromUnsignedLong(al->map->end)); 784 } 785 if (al->sym) { 786 pydict_set_item_string_decref(dict, sym_field, 787 _PyUnicode_FromString(al->sym->name)); 788 pydict_set_item_string_decref(dict, symoff_field, 789 PyLong_FromUnsignedLong(get_offset(al->sym, al))); 790 } 791 } 792 793 static void set_sample_flags(PyObject *dict, u32 flags) 794 { 795 const char *ch = PERF_IP_FLAG_CHARS; 796 char *p, str[33]; 797 798 for (p = str; *ch; ch++, flags >>= 1) { 799 if (flags & 1) 800 *p++ = *ch; 801 } 802 *p = 0; 803 pydict_set_item_string_decref(dict, "flags", _PyUnicode_FromString(str)); 804 } 805 806 static void python_process_sample_flags(struct perf_sample *sample, PyObject *dict_sample) 807 { 808 char flags_disp[SAMPLE_FLAGS_BUF_SIZE]; 809 810 set_sample_flags(dict_sample, sample->flags); 811 perf_sample__sprintf_flags(sample->flags, flags_disp, sizeof(flags_disp)); 812 pydict_set_item_string_decref(dict_sample, "flags_disp", 813 _PyUnicode_FromString(flags_disp)); 814 } 815 816 static PyObject *get_perf_sample_dict(struct perf_sample *sample, 817 struct evsel *evsel, 818 struct addr_location *al, 819 struct addr_location *addr_al, 820 PyObject *callchain) 821 { 822 PyObject *dict, *dict_sample, *brstack, *brstacksym; 823 824 dict = PyDict_New(); 825 if (!dict) 826 Py_FatalError("couldn't create Python dictionary"); 827 828 dict_sample = PyDict_New(); 829 if (!dict_sample) 830 Py_FatalError("couldn't create Python dictionary"); 831 832 pydict_set_item_string_decref(dict, "ev_name", _PyUnicode_FromString(evsel__name(evsel))); 833 pydict_set_item_string_decref(dict, "attr", _PyBytes_FromStringAndSize((const char *)&evsel->core.attr, sizeof(evsel->core.attr))); 834 835 pydict_set_item_string_decref(dict_sample, "pid", 836 _PyLong_FromLong(sample->pid)); 837 pydict_set_item_string_decref(dict_sample, "tid", 838 _PyLong_FromLong(sample->tid)); 839 pydict_set_item_string_decref(dict_sample, "cpu", 840 _PyLong_FromLong(sample->cpu)); 841 pydict_set_item_string_decref(dict_sample, "ip", 842 PyLong_FromUnsignedLongLong(sample->ip)); 843 pydict_set_item_string_decref(dict_sample, "time", 844 PyLong_FromUnsignedLongLong(sample->time)); 845 pydict_set_item_string_decref(dict_sample, "period", 846 PyLong_FromUnsignedLongLong(sample->period)); 847 pydict_set_item_string_decref(dict_sample, "phys_addr", 848 PyLong_FromUnsignedLongLong(sample->phys_addr)); 849 pydict_set_item_string_decref(dict_sample, "addr", 850 PyLong_FromUnsignedLongLong(sample->addr)); 851 set_sample_read_in_dict(dict_sample, sample, evsel); 852 pydict_set_item_string_decref(dict_sample, "weight", 853 PyLong_FromUnsignedLongLong(sample->weight)); 854 pydict_set_item_string_decref(dict_sample, "transaction", 855 PyLong_FromUnsignedLongLong(sample->transaction)); 856 set_sample_datasrc_in_dict(dict_sample, sample); 857 pydict_set_item_string_decref(dict, "sample", dict_sample); 858 859 pydict_set_item_string_decref(dict, "raw_buf", _PyBytes_FromStringAndSize( 860 (const char *)sample->raw_data, sample->raw_size)); 861 pydict_set_item_string_decref(dict, "comm", 862 _PyUnicode_FromString(thread__comm_str(al->thread))); 863 set_sym_in_dict(dict, al, "dso", "dso_bid", "dso_map_start", "dso_map_end", 864 "symbol", "symoff"); 865 866 pydict_set_item_string_decref(dict, "callchain", callchain); 867 868 brstack = python_process_brstack(sample, al->thread); 869 pydict_set_item_string_decref(dict, "brstack", brstack); 870 871 brstacksym = python_process_brstacksym(sample, al->thread); 872 pydict_set_item_string_decref(dict, "brstacksym", brstacksym); 873 874 if (sample->machine_pid) { 875 pydict_set_item_string_decref(dict_sample, "machine_pid", 876 _PyLong_FromLong(sample->machine_pid)); 877 pydict_set_item_string_decref(dict_sample, "vcpu", 878 _PyLong_FromLong(sample->vcpu)); 879 } 880 881 pydict_set_item_string_decref(dict_sample, "cpumode", 882 _PyLong_FromLong((unsigned long)sample->cpumode)); 883 884 if (addr_al) { 885 pydict_set_item_string_decref(dict_sample, "addr_correlates_sym", 886 PyBool_FromLong(1)); 887 set_sym_in_dict(dict_sample, addr_al, "addr_dso", "addr_dso_bid", 888 "addr_dso_map_start", "addr_dso_map_end", 889 "addr_symbol", "addr_symoff"); 890 } 891 892 if (sample->flags) 893 python_process_sample_flags(sample, dict_sample); 894 895 /* Instructions per cycle (IPC) */ 896 if (sample->insn_cnt && sample->cyc_cnt) { 897 pydict_set_item_string_decref(dict_sample, "insn_cnt", 898 PyLong_FromUnsignedLongLong(sample->insn_cnt)); 899 pydict_set_item_string_decref(dict_sample, "cyc_cnt", 900 PyLong_FromUnsignedLongLong(sample->cyc_cnt)); 901 } 902 903 set_regs_in_dict(dict, sample, evsel); 904 905 return dict; 906 } 907 908 static void python_process_tracepoint(struct perf_sample *sample, 909 struct evsel *evsel, 910 struct addr_location *al, 911 struct addr_location *addr_al) 912 { 913 struct tep_event *event = evsel->tp_format; 914 PyObject *handler, *context, *t, *obj = NULL, *callchain; 915 PyObject *dict = NULL, *all_entries_dict = NULL; 916 static char handler_name[256]; 917 struct tep_format_field *field; 918 unsigned long s, ns; 919 unsigned n = 0; 920 int pid; 921 int cpu = sample->cpu; 922 void *data = sample->raw_data; 923 unsigned long long nsecs = sample->time; 924 const char *comm = thread__comm_str(al->thread); 925 const char *default_handler_name = "trace_unhandled"; 926 927 if (!event) { 928 snprintf(handler_name, sizeof(handler_name), 929 "ug! no event found for type %" PRIu64, (u64)evsel->core.attr.config); 930 Py_FatalError(handler_name); 931 } 932 933 pid = raw_field_value(event, "common_pid", data); 934 935 sprintf(handler_name, "%s__%s", event->system, event->name); 936 937 if (!test_and_set_bit(event->id, events_defined)) 938 define_event_symbols(event, handler_name, event->print_fmt.args); 939 940 handler = get_handler(handler_name); 941 if (!handler) { 942 handler = get_handler(default_handler_name); 943 if (!handler) 944 return; 945 dict = PyDict_New(); 946 if (!dict) 947 Py_FatalError("couldn't create Python dict"); 948 } 949 950 t = PyTuple_New(MAX_FIELDS); 951 if (!t) 952 Py_FatalError("couldn't create Python tuple"); 953 954 955 s = nsecs / NSEC_PER_SEC; 956 ns = nsecs - s * NSEC_PER_SEC; 957 958 context = _PyCapsule_New(scripting_context, NULL, NULL); 959 960 PyTuple_SetItem(t, n++, _PyUnicode_FromString(handler_name)); 961 PyTuple_SetItem(t, n++, context); 962 963 /* ip unwinding */ 964 callchain = python_process_callchain(sample, evsel, al); 965 /* Need an additional reference for the perf_sample dict */ 966 Py_INCREF(callchain); 967 968 if (!dict) { 969 PyTuple_SetItem(t, n++, _PyLong_FromLong(cpu)); 970 PyTuple_SetItem(t, n++, _PyLong_FromLong(s)); 971 PyTuple_SetItem(t, n++, _PyLong_FromLong(ns)); 972 PyTuple_SetItem(t, n++, _PyLong_FromLong(pid)); 973 PyTuple_SetItem(t, n++, _PyUnicode_FromString(comm)); 974 PyTuple_SetItem(t, n++, callchain); 975 } else { 976 pydict_set_item_string_decref(dict, "common_cpu", _PyLong_FromLong(cpu)); 977 pydict_set_item_string_decref(dict, "common_s", _PyLong_FromLong(s)); 978 pydict_set_item_string_decref(dict, "common_ns", _PyLong_FromLong(ns)); 979 pydict_set_item_string_decref(dict, "common_pid", _PyLong_FromLong(pid)); 980 pydict_set_item_string_decref(dict, "common_comm", _PyUnicode_FromString(comm)); 981 pydict_set_item_string_decref(dict, "common_callchain", callchain); 982 } 983 for (field = event->format.fields; field; field = field->next) { 984 unsigned int offset, len; 985 unsigned long long val; 986 987 if (field->flags & TEP_FIELD_IS_ARRAY) { 988 offset = field->offset; 989 len = field->size; 990 if (field->flags & TEP_FIELD_IS_DYNAMIC) { 991 val = tep_read_number(scripting_context->pevent, 992 data + offset, len); 993 offset = val; 994 len = offset >> 16; 995 offset &= 0xffff; 996 if (field->flags & TEP_FIELD_IS_RELATIVE) 997 offset += field->offset + field->size; 998 } 999 if (field->flags & TEP_FIELD_IS_STRING && 1000 is_printable_array(data + offset, len)) { 1001 obj = _PyUnicode_FromString((char *) data + offset); 1002 } else { 1003 obj = PyByteArray_FromStringAndSize((const char *) data + offset, len); 1004 field->flags &= ~TEP_FIELD_IS_STRING; 1005 } 1006 } else { /* FIELD_IS_NUMERIC */ 1007 obj = get_field_numeric_entry(event, field, data); 1008 } 1009 if (!dict) 1010 PyTuple_SetItem(t, n++, obj); 1011 else 1012 pydict_set_item_string_decref(dict, field->name, obj); 1013 1014 } 1015 1016 if (dict) 1017 PyTuple_SetItem(t, n++, dict); 1018 1019 if (get_argument_count(handler) == (int) n + 1) { 1020 all_entries_dict = get_perf_sample_dict(sample, evsel, al, addr_al, 1021 callchain); 1022 PyTuple_SetItem(t, n++, all_entries_dict); 1023 } else { 1024 Py_DECREF(callchain); 1025 } 1026 1027 if (_PyTuple_Resize(&t, n) == -1) 1028 Py_FatalError("error resizing Python tuple"); 1029 1030 if (!dict) 1031 call_object(handler, t, handler_name); 1032 else 1033 call_object(handler, t, default_handler_name); 1034 1035 Py_DECREF(t); 1036 } 1037 1038 static PyObject *tuple_new(unsigned int sz) 1039 { 1040 PyObject *t; 1041 1042 t = PyTuple_New(sz); 1043 if (!t) 1044 Py_FatalError("couldn't create Python tuple"); 1045 return t; 1046 } 1047 1048 static int tuple_set_s64(PyObject *t, unsigned int pos, s64 val) 1049 { 1050 #if BITS_PER_LONG == 64 1051 return PyTuple_SetItem(t, pos, _PyLong_FromLong(val)); 1052 #endif 1053 #if BITS_PER_LONG == 32 1054 return PyTuple_SetItem(t, pos, PyLong_FromLongLong(val)); 1055 #endif 1056 } 1057 1058 /* 1059 * Databases support only signed 64-bit numbers, so even though we are 1060 * exporting a u64, it must be as s64. 1061 */ 1062 #define tuple_set_d64 tuple_set_s64 1063 1064 static int tuple_set_u64(PyObject *t, unsigned int pos, u64 val) 1065 { 1066 #if BITS_PER_LONG == 64 1067 return PyTuple_SetItem(t, pos, PyLong_FromUnsignedLong(val)); 1068 #endif 1069 #if BITS_PER_LONG == 32 1070 return PyTuple_SetItem(t, pos, PyLong_FromUnsignedLongLong(val)); 1071 #endif 1072 } 1073 1074 static int tuple_set_u32(PyObject *t, unsigned int pos, u32 val) 1075 { 1076 return PyTuple_SetItem(t, pos, PyLong_FromUnsignedLong(val)); 1077 } 1078 1079 static int tuple_set_s32(PyObject *t, unsigned int pos, s32 val) 1080 { 1081 return PyTuple_SetItem(t, pos, _PyLong_FromLong(val)); 1082 } 1083 1084 static int tuple_set_bool(PyObject *t, unsigned int pos, bool val) 1085 { 1086 return PyTuple_SetItem(t, pos, PyBool_FromLong(val)); 1087 } 1088 1089 static int tuple_set_string(PyObject *t, unsigned int pos, const char *s) 1090 { 1091 return PyTuple_SetItem(t, pos, _PyUnicode_FromString(s)); 1092 } 1093 1094 static int tuple_set_bytes(PyObject *t, unsigned int pos, void *bytes, 1095 unsigned int sz) 1096 { 1097 return PyTuple_SetItem(t, pos, _PyBytes_FromStringAndSize(bytes, sz)); 1098 } 1099 1100 static int python_export_evsel(struct db_export *dbe, struct evsel *evsel) 1101 { 1102 struct tables *tables = container_of(dbe, struct tables, dbe); 1103 PyObject *t; 1104 1105 t = tuple_new(2); 1106 1107 tuple_set_d64(t, 0, evsel->db_id); 1108 tuple_set_string(t, 1, evsel__name(evsel)); 1109 1110 call_object(tables->evsel_handler, t, "evsel_table"); 1111 1112 Py_DECREF(t); 1113 1114 return 0; 1115 } 1116 1117 static int python_export_machine(struct db_export *dbe, 1118 struct machine *machine) 1119 { 1120 struct tables *tables = container_of(dbe, struct tables, dbe); 1121 PyObject *t; 1122 1123 t = tuple_new(3); 1124 1125 tuple_set_d64(t, 0, machine->db_id); 1126 tuple_set_s32(t, 1, machine->pid); 1127 tuple_set_string(t, 2, machine->root_dir ? machine->root_dir : ""); 1128 1129 call_object(tables->machine_handler, t, "machine_table"); 1130 1131 Py_DECREF(t); 1132 1133 return 0; 1134 } 1135 1136 static int python_export_thread(struct db_export *dbe, struct thread *thread, 1137 u64 main_thread_db_id, struct machine *machine) 1138 { 1139 struct tables *tables = container_of(dbe, struct tables, dbe); 1140 PyObject *t; 1141 1142 t = tuple_new(5); 1143 1144 tuple_set_d64(t, 0, thread->db_id); 1145 tuple_set_d64(t, 1, machine->db_id); 1146 tuple_set_d64(t, 2, main_thread_db_id); 1147 tuple_set_s32(t, 3, thread->pid_); 1148 tuple_set_s32(t, 4, thread->tid); 1149 1150 call_object(tables->thread_handler, t, "thread_table"); 1151 1152 Py_DECREF(t); 1153 1154 return 0; 1155 } 1156 1157 static int python_export_comm(struct db_export *dbe, struct comm *comm, 1158 struct thread *thread) 1159 { 1160 struct tables *tables = container_of(dbe, struct tables, dbe); 1161 PyObject *t; 1162 1163 t = tuple_new(5); 1164 1165 tuple_set_d64(t, 0, comm->db_id); 1166 tuple_set_string(t, 1, comm__str(comm)); 1167 tuple_set_d64(t, 2, thread->db_id); 1168 tuple_set_d64(t, 3, comm->start); 1169 tuple_set_s32(t, 4, comm->exec); 1170 1171 call_object(tables->comm_handler, t, "comm_table"); 1172 1173 Py_DECREF(t); 1174 1175 return 0; 1176 } 1177 1178 static int python_export_comm_thread(struct db_export *dbe, u64 db_id, 1179 struct comm *comm, struct thread *thread) 1180 { 1181 struct tables *tables = container_of(dbe, struct tables, dbe); 1182 PyObject *t; 1183 1184 t = tuple_new(3); 1185 1186 tuple_set_d64(t, 0, db_id); 1187 tuple_set_d64(t, 1, comm->db_id); 1188 tuple_set_d64(t, 2, thread->db_id); 1189 1190 call_object(tables->comm_thread_handler, t, "comm_thread_table"); 1191 1192 Py_DECREF(t); 1193 1194 return 0; 1195 } 1196 1197 static int python_export_dso(struct db_export *dbe, struct dso *dso, 1198 struct machine *machine) 1199 { 1200 struct tables *tables = container_of(dbe, struct tables, dbe); 1201 char sbuild_id[SBUILD_ID_SIZE]; 1202 PyObject *t; 1203 1204 build_id__sprintf(&dso->bid, sbuild_id); 1205 1206 t = tuple_new(5); 1207 1208 tuple_set_d64(t, 0, dso->db_id); 1209 tuple_set_d64(t, 1, machine->db_id); 1210 tuple_set_string(t, 2, dso->short_name); 1211 tuple_set_string(t, 3, dso->long_name); 1212 tuple_set_string(t, 4, sbuild_id); 1213 1214 call_object(tables->dso_handler, t, "dso_table"); 1215 1216 Py_DECREF(t); 1217 1218 return 0; 1219 } 1220 1221 static int python_export_symbol(struct db_export *dbe, struct symbol *sym, 1222 struct dso *dso) 1223 { 1224 struct tables *tables = container_of(dbe, struct tables, dbe); 1225 u64 *sym_db_id = symbol__priv(sym); 1226 PyObject *t; 1227 1228 t = tuple_new(6); 1229 1230 tuple_set_d64(t, 0, *sym_db_id); 1231 tuple_set_d64(t, 1, dso->db_id); 1232 tuple_set_d64(t, 2, sym->start); 1233 tuple_set_d64(t, 3, sym->end); 1234 tuple_set_s32(t, 4, sym->binding); 1235 tuple_set_string(t, 5, sym->name); 1236 1237 call_object(tables->symbol_handler, t, "symbol_table"); 1238 1239 Py_DECREF(t); 1240 1241 return 0; 1242 } 1243 1244 static int python_export_branch_type(struct db_export *dbe, u32 branch_type, 1245 const char *name) 1246 { 1247 struct tables *tables = container_of(dbe, struct tables, dbe); 1248 PyObject *t; 1249 1250 t = tuple_new(2); 1251 1252 tuple_set_s32(t, 0, branch_type); 1253 tuple_set_string(t, 1, name); 1254 1255 call_object(tables->branch_type_handler, t, "branch_type_table"); 1256 1257 Py_DECREF(t); 1258 1259 return 0; 1260 } 1261 1262 static void python_export_sample_table(struct db_export *dbe, 1263 struct export_sample *es) 1264 { 1265 struct tables *tables = container_of(dbe, struct tables, dbe); 1266 PyObject *t; 1267 1268 t = tuple_new(25); 1269 1270 tuple_set_d64(t, 0, es->db_id); 1271 tuple_set_d64(t, 1, es->evsel->db_id); 1272 tuple_set_d64(t, 2, es->al->maps->machine->db_id); 1273 tuple_set_d64(t, 3, es->al->thread->db_id); 1274 tuple_set_d64(t, 4, es->comm_db_id); 1275 tuple_set_d64(t, 5, es->dso_db_id); 1276 tuple_set_d64(t, 6, es->sym_db_id); 1277 tuple_set_d64(t, 7, es->offset); 1278 tuple_set_d64(t, 8, es->sample->ip); 1279 tuple_set_d64(t, 9, es->sample->time); 1280 tuple_set_s32(t, 10, es->sample->cpu); 1281 tuple_set_d64(t, 11, es->addr_dso_db_id); 1282 tuple_set_d64(t, 12, es->addr_sym_db_id); 1283 tuple_set_d64(t, 13, es->addr_offset); 1284 tuple_set_d64(t, 14, es->sample->addr); 1285 tuple_set_d64(t, 15, es->sample->period); 1286 tuple_set_d64(t, 16, es->sample->weight); 1287 tuple_set_d64(t, 17, es->sample->transaction); 1288 tuple_set_d64(t, 18, es->sample->data_src); 1289 tuple_set_s32(t, 19, es->sample->flags & PERF_BRANCH_MASK); 1290 tuple_set_s32(t, 20, !!(es->sample->flags & PERF_IP_FLAG_IN_TX)); 1291 tuple_set_d64(t, 21, es->call_path_id); 1292 tuple_set_d64(t, 22, es->sample->insn_cnt); 1293 tuple_set_d64(t, 23, es->sample->cyc_cnt); 1294 tuple_set_s32(t, 24, es->sample->flags); 1295 1296 call_object(tables->sample_handler, t, "sample_table"); 1297 1298 Py_DECREF(t); 1299 } 1300 1301 static void python_export_synth(struct db_export *dbe, struct export_sample *es) 1302 { 1303 struct tables *tables = container_of(dbe, struct tables, dbe); 1304 PyObject *t; 1305 1306 t = tuple_new(3); 1307 1308 tuple_set_d64(t, 0, es->db_id); 1309 tuple_set_d64(t, 1, es->evsel->core.attr.config); 1310 tuple_set_bytes(t, 2, es->sample->raw_data, es->sample->raw_size); 1311 1312 call_object(tables->synth_handler, t, "synth_data"); 1313 1314 Py_DECREF(t); 1315 } 1316 1317 static int python_export_sample(struct db_export *dbe, 1318 struct export_sample *es) 1319 { 1320 struct tables *tables = container_of(dbe, struct tables, dbe); 1321 1322 python_export_sample_table(dbe, es); 1323 1324 if (es->evsel->core.attr.type == PERF_TYPE_SYNTH && tables->synth_handler) 1325 python_export_synth(dbe, es); 1326 1327 return 0; 1328 } 1329 1330 static int python_export_call_path(struct db_export *dbe, struct call_path *cp) 1331 { 1332 struct tables *tables = container_of(dbe, struct tables, dbe); 1333 PyObject *t; 1334 u64 parent_db_id, sym_db_id; 1335 1336 parent_db_id = cp->parent ? cp->parent->db_id : 0; 1337 sym_db_id = cp->sym ? *(u64 *)symbol__priv(cp->sym) : 0; 1338 1339 t = tuple_new(4); 1340 1341 tuple_set_d64(t, 0, cp->db_id); 1342 tuple_set_d64(t, 1, parent_db_id); 1343 tuple_set_d64(t, 2, sym_db_id); 1344 tuple_set_d64(t, 3, cp->ip); 1345 1346 call_object(tables->call_path_handler, t, "call_path_table"); 1347 1348 Py_DECREF(t); 1349 1350 return 0; 1351 } 1352 1353 static int python_export_call_return(struct db_export *dbe, 1354 struct call_return *cr) 1355 { 1356 struct tables *tables = container_of(dbe, struct tables, dbe); 1357 u64 comm_db_id = cr->comm ? cr->comm->db_id : 0; 1358 PyObject *t; 1359 1360 t = tuple_new(14); 1361 1362 tuple_set_d64(t, 0, cr->db_id); 1363 tuple_set_d64(t, 1, cr->thread->db_id); 1364 tuple_set_d64(t, 2, comm_db_id); 1365 tuple_set_d64(t, 3, cr->cp->db_id); 1366 tuple_set_d64(t, 4, cr->call_time); 1367 tuple_set_d64(t, 5, cr->return_time); 1368 tuple_set_d64(t, 6, cr->branch_count); 1369 tuple_set_d64(t, 7, cr->call_ref); 1370 tuple_set_d64(t, 8, cr->return_ref); 1371 tuple_set_d64(t, 9, cr->cp->parent->db_id); 1372 tuple_set_s32(t, 10, cr->flags); 1373 tuple_set_d64(t, 11, cr->parent_db_id); 1374 tuple_set_d64(t, 12, cr->insn_count); 1375 tuple_set_d64(t, 13, cr->cyc_count); 1376 1377 call_object(tables->call_return_handler, t, "call_return_table"); 1378 1379 Py_DECREF(t); 1380 1381 return 0; 1382 } 1383 1384 static int python_export_context_switch(struct db_export *dbe, u64 db_id, 1385 struct machine *machine, 1386 struct perf_sample *sample, 1387 u64 th_out_id, u64 comm_out_id, 1388 u64 th_in_id, u64 comm_in_id, int flags) 1389 { 1390 struct tables *tables = container_of(dbe, struct tables, dbe); 1391 PyObject *t; 1392 1393 t = tuple_new(9); 1394 1395 tuple_set_d64(t, 0, db_id); 1396 tuple_set_d64(t, 1, machine->db_id); 1397 tuple_set_d64(t, 2, sample->time); 1398 tuple_set_s32(t, 3, sample->cpu); 1399 tuple_set_d64(t, 4, th_out_id); 1400 tuple_set_d64(t, 5, comm_out_id); 1401 tuple_set_d64(t, 6, th_in_id); 1402 tuple_set_d64(t, 7, comm_in_id); 1403 tuple_set_s32(t, 8, flags); 1404 1405 call_object(tables->context_switch_handler, t, "context_switch"); 1406 1407 Py_DECREF(t); 1408 1409 return 0; 1410 } 1411 1412 static int python_process_call_return(struct call_return *cr, u64 *parent_db_id, 1413 void *data) 1414 { 1415 struct db_export *dbe = data; 1416 1417 return db_export__call_return(dbe, cr, parent_db_id); 1418 } 1419 1420 static void python_process_general_event(struct perf_sample *sample, 1421 struct evsel *evsel, 1422 struct addr_location *al, 1423 struct addr_location *addr_al) 1424 { 1425 PyObject *handler, *t, *dict, *callchain; 1426 static char handler_name[64]; 1427 unsigned n = 0; 1428 1429 snprintf(handler_name, sizeof(handler_name), "%s", "process_event"); 1430 1431 handler = get_handler(handler_name); 1432 if (!handler) 1433 return; 1434 1435 /* 1436 * Use the MAX_FIELDS to make the function expandable, though 1437 * currently there is only one item for the tuple. 1438 */ 1439 t = PyTuple_New(MAX_FIELDS); 1440 if (!t) 1441 Py_FatalError("couldn't create Python tuple"); 1442 1443 /* ip unwinding */ 1444 callchain = python_process_callchain(sample, evsel, al); 1445 dict = get_perf_sample_dict(sample, evsel, al, addr_al, callchain); 1446 1447 PyTuple_SetItem(t, n++, dict); 1448 if (_PyTuple_Resize(&t, n) == -1) 1449 Py_FatalError("error resizing Python tuple"); 1450 1451 call_object(handler, t, handler_name); 1452 1453 Py_DECREF(t); 1454 } 1455 1456 static void python_process_event(union perf_event *event, 1457 struct perf_sample *sample, 1458 struct evsel *evsel, 1459 struct addr_location *al, 1460 struct addr_location *addr_al) 1461 { 1462 struct tables *tables = &tables_global; 1463 1464 scripting_context__update(scripting_context, event, sample, evsel, al, addr_al); 1465 1466 switch (evsel->core.attr.type) { 1467 case PERF_TYPE_TRACEPOINT: 1468 python_process_tracepoint(sample, evsel, al, addr_al); 1469 break; 1470 /* Reserve for future process_hw/sw/raw APIs */ 1471 default: 1472 if (tables->db_export_mode) 1473 db_export__sample(&tables->dbe, event, sample, evsel, al, addr_al); 1474 else 1475 python_process_general_event(sample, evsel, al, addr_al); 1476 } 1477 } 1478 1479 static void python_process_throttle(union perf_event *event, 1480 struct perf_sample *sample, 1481 struct machine *machine) 1482 { 1483 const char *handler_name; 1484 PyObject *handler, *t; 1485 1486 if (event->header.type == PERF_RECORD_THROTTLE) 1487 handler_name = "throttle"; 1488 else 1489 handler_name = "unthrottle"; 1490 handler = get_handler(handler_name); 1491 if (!handler) 1492 return; 1493 1494 t = tuple_new(6); 1495 if (!t) 1496 return; 1497 1498 tuple_set_u64(t, 0, event->throttle.time); 1499 tuple_set_u64(t, 1, event->throttle.id); 1500 tuple_set_u64(t, 2, event->throttle.stream_id); 1501 tuple_set_s32(t, 3, sample->cpu); 1502 tuple_set_s32(t, 4, sample->pid); 1503 tuple_set_s32(t, 5, sample->tid); 1504 1505 call_object(handler, t, handler_name); 1506 1507 Py_DECREF(t); 1508 } 1509 1510 static void python_do_process_switch(union perf_event *event, 1511 struct perf_sample *sample, 1512 struct machine *machine) 1513 { 1514 const char *handler_name = "context_switch"; 1515 bool out = event->header.misc & PERF_RECORD_MISC_SWITCH_OUT; 1516 bool out_preempt = out && (event->header.misc & PERF_RECORD_MISC_SWITCH_OUT_PREEMPT); 1517 pid_t np_pid = -1, np_tid = -1; 1518 PyObject *handler, *t; 1519 1520 handler = get_handler(handler_name); 1521 if (!handler) 1522 return; 1523 1524 if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) { 1525 np_pid = event->context_switch.next_prev_pid; 1526 np_tid = event->context_switch.next_prev_tid; 1527 } 1528 1529 t = tuple_new(11); 1530 if (!t) 1531 return; 1532 1533 tuple_set_u64(t, 0, sample->time); 1534 tuple_set_s32(t, 1, sample->cpu); 1535 tuple_set_s32(t, 2, sample->pid); 1536 tuple_set_s32(t, 3, sample->tid); 1537 tuple_set_s32(t, 4, np_pid); 1538 tuple_set_s32(t, 5, np_tid); 1539 tuple_set_s32(t, 6, machine->pid); 1540 tuple_set_bool(t, 7, out); 1541 tuple_set_bool(t, 8, out_preempt); 1542 tuple_set_s32(t, 9, sample->machine_pid); 1543 tuple_set_s32(t, 10, sample->vcpu); 1544 1545 call_object(handler, t, handler_name); 1546 1547 Py_DECREF(t); 1548 } 1549 1550 static void python_process_switch(union perf_event *event, 1551 struct perf_sample *sample, 1552 struct machine *machine) 1553 { 1554 struct tables *tables = &tables_global; 1555 1556 if (tables->db_export_mode) 1557 db_export__switch(&tables->dbe, event, sample, machine); 1558 else 1559 python_do_process_switch(event, sample, machine); 1560 } 1561 1562 static void python_process_auxtrace_error(struct perf_session *session __maybe_unused, 1563 union perf_event *event) 1564 { 1565 struct perf_record_auxtrace_error *e = &event->auxtrace_error; 1566 u8 cpumode = e->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 1567 const char *handler_name = "auxtrace_error"; 1568 unsigned long long tm = e->time; 1569 const char *msg = e->msg; 1570 PyObject *handler, *t; 1571 1572 handler = get_handler(handler_name); 1573 if (!handler) 1574 return; 1575 1576 if (!e->fmt) { 1577 tm = 0; 1578 msg = (const char *)&e->time; 1579 } 1580 1581 t = tuple_new(11); 1582 1583 tuple_set_u32(t, 0, e->type); 1584 tuple_set_u32(t, 1, e->code); 1585 tuple_set_s32(t, 2, e->cpu); 1586 tuple_set_s32(t, 3, e->pid); 1587 tuple_set_s32(t, 4, e->tid); 1588 tuple_set_u64(t, 5, e->ip); 1589 tuple_set_u64(t, 6, tm); 1590 tuple_set_string(t, 7, msg); 1591 tuple_set_u32(t, 8, cpumode); 1592 tuple_set_s32(t, 9, e->machine_pid); 1593 tuple_set_s32(t, 10, e->vcpu); 1594 1595 call_object(handler, t, handler_name); 1596 1597 Py_DECREF(t); 1598 } 1599 1600 static void get_handler_name(char *str, size_t size, 1601 struct evsel *evsel) 1602 { 1603 char *p = str; 1604 1605 scnprintf(str, size, "stat__%s", evsel__name(evsel)); 1606 1607 while ((p = strchr(p, ':'))) { 1608 *p = '_'; 1609 p++; 1610 } 1611 } 1612 1613 static void 1614 process_stat(struct evsel *counter, struct perf_cpu cpu, int thread, u64 tstamp, 1615 struct perf_counts_values *count) 1616 { 1617 PyObject *handler, *t; 1618 static char handler_name[256]; 1619 int n = 0; 1620 1621 t = PyTuple_New(MAX_FIELDS); 1622 if (!t) 1623 Py_FatalError("couldn't create Python tuple"); 1624 1625 get_handler_name(handler_name, sizeof(handler_name), 1626 counter); 1627 1628 handler = get_handler(handler_name); 1629 if (!handler) { 1630 pr_debug("can't find python handler %s\n", handler_name); 1631 return; 1632 } 1633 1634 PyTuple_SetItem(t, n++, _PyLong_FromLong(cpu.cpu)); 1635 PyTuple_SetItem(t, n++, _PyLong_FromLong(thread)); 1636 1637 tuple_set_u64(t, n++, tstamp); 1638 tuple_set_u64(t, n++, count->val); 1639 tuple_set_u64(t, n++, count->ena); 1640 tuple_set_u64(t, n++, count->run); 1641 1642 if (_PyTuple_Resize(&t, n) == -1) 1643 Py_FatalError("error resizing Python tuple"); 1644 1645 call_object(handler, t, handler_name); 1646 1647 Py_DECREF(t); 1648 } 1649 1650 static void python_process_stat(struct perf_stat_config *config, 1651 struct evsel *counter, u64 tstamp) 1652 { 1653 struct perf_thread_map *threads = counter->core.threads; 1654 struct perf_cpu_map *cpus = counter->core.cpus; 1655 int cpu, thread; 1656 1657 for (thread = 0; thread < threads->nr; thread++) { 1658 for (cpu = 0; cpu < perf_cpu_map__nr(cpus); cpu++) { 1659 process_stat(counter, perf_cpu_map__cpu(cpus, cpu), 1660 perf_thread_map__pid(threads, thread), tstamp, 1661 perf_counts(counter->counts, cpu, thread)); 1662 } 1663 } 1664 } 1665 1666 static void python_process_stat_interval(u64 tstamp) 1667 { 1668 PyObject *handler, *t; 1669 static const char handler_name[] = "stat__interval"; 1670 int n = 0; 1671 1672 t = PyTuple_New(MAX_FIELDS); 1673 if (!t) 1674 Py_FatalError("couldn't create Python tuple"); 1675 1676 handler = get_handler(handler_name); 1677 if (!handler) { 1678 pr_debug("can't find python handler %s\n", handler_name); 1679 return; 1680 } 1681 1682 tuple_set_u64(t, n++, tstamp); 1683 1684 if (_PyTuple_Resize(&t, n) == -1) 1685 Py_FatalError("error resizing Python tuple"); 1686 1687 call_object(handler, t, handler_name); 1688 1689 Py_DECREF(t); 1690 } 1691 1692 static int perf_script_context_init(void) 1693 { 1694 PyObject *perf_script_context; 1695 PyObject *perf_trace_context; 1696 PyObject *dict; 1697 int ret; 1698 1699 perf_trace_context = PyImport_AddModule("perf_trace_context"); 1700 if (!perf_trace_context) 1701 return -1; 1702 dict = PyModule_GetDict(perf_trace_context); 1703 if (!dict) 1704 return -1; 1705 1706 perf_script_context = _PyCapsule_New(scripting_context, NULL, NULL); 1707 if (!perf_script_context) 1708 return -1; 1709 1710 ret = PyDict_SetItemString(dict, "perf_script_context", perf_script_context); 1711 if (!ret) 1712 ret = PyDict_SetItemString(main_dict, "perf_script_context", perf_script_context); 1713 Py_DECREF(perf_script_context); 1714 return ret; 1715 } 1716 1717 static int run_start_sub(void) 1718 { 1719 main_module = PyImport_AddModule("__main__"); 1720 if (main_module == NULL) 1721 return -1; 1722 Py_INCREF(main_module); 1723 1724 main_dict = PyModule_GetDict(main_module); 1725 if (main_dict == NULL) 1726 goto error; 1727 Py_INCREF(main_dict); 1728 1729 if (perf_script_context_init()) 1730 goto error; 1731 1732 try_call_object("trace_begin", NULL); 1733 1734 return 0; 1735 1736 error: 1737 Py_XDECREF(main_dict); 1738 Py_XDECREF(main_module); 1739 return -1; 1740 } 1741 1742 #define SET_TABLE_HANDLER_(name, handler_name, table_name) do { \ 1743 tables->handler_name = get_handler(#table_name); \ 1744 if (tables->handler_name) \ 1745 tables->dbe.export_ ## name = python_export_ ## name; \ 1746 } while (0) 1747 1748 #define SET_TABLE_HANDLER(name) \ 1749 SET_TABLE_HANDLER_(name, name ## _handler, name ## _table) 1750 1751 static void set_table_handlers(struct tables *tables) 1752 { 1753 const char *perf_db_export_mode = "perf_db_export_mode"; 1754 const char *perf_db_export_calls = "perf_db_export_calls"; 1755 const char *perf_db_export_callchains = "perf_db_export_callchains"; 1756 PyObject *db_export_mode, *db_export_calls, *db_export_callchains; 1757 bool export_calls = false; 1758 bool export_callchains = false; 1759 int ret; 1760 1761 memset(tables, 0, sizeof(struct tables)); 1762 if (db_export__init(&tables->dbe)) 1763 Py_FatalError("failed to initialize export"); 1764 1765 db_export_mode = PyDict_GetItemString(main_dict, perf_db_export_mode); 1766 if (!db_export_mode) 1767 return; 1768 1769 ret = PyObject_IsTrue(db_export_mode); 1770 if (ret == -1) 1771 handler_call_die(perf_db_export_mode); 1772 if (!ret) 1773 return; 1774 1775 /* handle export calls */ 1776 tables->dbe.crp = NULL; 1777 db_export_calls = PyDict_GetItemString(main_dict, perf_db_export_calls); 1778 if (db_export_calls) { 1779 ret = PyObject_IsTrue(db_export_calls); 1780 if (ret == -1) 1781 handler_call_die(perf_db_export_calls); 1782 export_calls = !!ret; 1783 } 1784 1785 if (export_calls) { 1786 tables->dbe.crp = 1787 call_return_processor__new(python_process_call_return, 1788 &tables->dbe); 1789 if (!tables->dbe.crp) 1790 Py_FatalError("failed to create calls processor"); 1791 } 1792 1793 /* handle export callchains */ 1794 tables->dbe.cpr = NULL; 1795 db_export_callchains = PyDict_GetItemString(main_dict, 1796 perf_db_export_callchains); 1797 if (db_export_callchains) { 1798 ret = PyObject_IsTrue(db_export_callchains); 1799 if (ret == -1) 1800 handler_call_die(perf_db_export_callchains); 1801 export_callchains = !!ret; 1802 } 1803 1804 if (export_callchains) { 1805 /* 1806 * Attempt to use the call path root from the call return 1807 * processor, if the call return processor is in use. Otherwise, 1808 * we allocate a new call path root. This prevents exporting 1809 * duplicate call path ids when both are in use simultaneously. 1810 */ 1811 if (tables->dbe.crp) 1812 tables->dbe.cpr = tables->dbe.crp->cpr; 1813 else 1814 tables->dbe.cpr = call_path_root__new(); 1815 1816 if (!tables->dbe.cpr) 1817 Py_FatalError("failed to create call path root"); 1818 } 1819 1820 tables->db_export_mode = true; 1821 /* 1822 * Reserve per symbol space for symbol->db_id via symbol__priv() 1823 */ 1824 symbol_conf.priv_size = sizeof(u64); 1825 1826 SET_TABLE_HANDLER(evsel); 1827 SET_TABLE_HANDLER(machine); 1828 SET_TABLE_HANDLER(thread); 1829 SET_TABLE_HANDLER(comm); 1830 SET_TABLE_HANDLER(comm_thread); 1831 SET_TABLE_HANDLER(dso); 1832 SET_TABLE_HANDLER(symbol); 1833 SET_TABLE_HANDLER(branch_type); 1834 SET_TABLE_HANDLER(sample); 1835 SET_TABLE_HANDLER(call_path); 1836 SET_TABLE_HANDLER(call_return); 1837 SET_TABLE_HANDLER(context_switch); 1838 1839 /* 1840 * Synthesized events are samples but with architecture-specific data 1841 * stored in sample->raw_data. They are exported via 1842 * python_export_sample() and consequently do not need a separate export 1843 * callback. 1844 */ 1845 tables->synth_handler = get_handler("synth_data"); 1846 } 1847 1848 #if PY_MAJOR_VERSION < 3 1849 static void _free_command_line(const char **command_line, int num) 1850 { 1851 free(command_line); 1852 } 1853 #else 1854 static void _free_command_line(wchar_t **command_line, int num) 1855 { 1856 int i; 1857 for (i = 0; i < num; i++) 1858 PyMem_RawFree(command_line[i]); 1859 free(command_line); 1860 } 1861 #endif 1862 1863 1864 /* 1865 * Start trace script 1866 */ 1867 static int python_start_script(const char *script, int argc, const char **argv, 1868 struct perf_session *session) 1869 { 1870 struct tables *tables = &tables_global; 1871 #if PY_MAJOR_VERSION < 3 1872 const char **command_line; 1873 #else 1874 wchar_t **command_line; 1875 #endif 1876 /* 1877 * Use a non-const name variable to cope with python 2.6's 1878 * PyImport_AppendInittab prototype 1879 */ 1880 char buf[PATH_MAX], name[19] = "perf_trace_context"; 1881 int i, err = 0; 1882 FILE *fp; 1883 1884 scripting_context->session = session; 1885 #if PY_MAJOR_VERSION < 3 1886 command_line = malloc((argc + 1) * sizeof(const char *)); 1887 command_line[0] = script; 1888 for (i = 1; i < argc + 1; i++) 1889 command_line[i] = argv[i - 1]; 1890 PyImport_AppendInittab(name, initperf_trace_context); 1891 #else 1892 command_line = malloc((argc + 1) * sizeof(wchar_t *)); 1893 command_line[0] = Py_DecodeLocale(script, NULL); 1894 for (i = 1; i < argc + 1; i++) 1895 command_line[i] = Py_DecodeLocale(argv[i - 1], NULL); 1896 PyImport_AppendInittab(name, PyInit_perf_trace_context); 1897 #endif 1898 Py_Initialize(); 1899 1900 #if PY_MAJOR_VERSION < 3 1901 PySys_SetArgv(argc + 1, (char **)command_line); 1902 #else 1903 PySys_SetArgv(argc + 1, command_line); 1904 #endif 1905 1906 fp = fopen(script, "r"); 1907 if (!fp) { 1908 sprintf(buf, "Can't open python script \"%s\"", script); 1909 perror(buf); 1910 err = -1; 1911 goto error; 1912 } 1913 1914 err = PyRun_SimpleFile(fp, script); 1915 if (err) { 1916 fprintf(stderr, "Error running python script %s\n", script); 1917 goto error; 1918 } 1919 1920 err = run_start_sub(); 1921 if (err) { 1922 fprintf(stderr, "Error starting python script %s\n", script); 1923 goto error; 1924 } 1925 1926 set_table_handlers(tables); 1927 1928 if (tables->db_export_mode) { 1929 err = db_export__branch_types(&tables->dbe); 1930 if (err) 1931 goto error; 1932 } 1933 1934 _free_command_line(command_line, argc + 1); 1935 1936 return err; 1937 error: 1938 Py_Finalize(); 1939 _free_command_line(command_line, argc + 1); 1940 1941 return err; 1942 } 1943 1944 static int python_flush_script(void) 1945 { 1946 return 0; 1947 } 1948 1949 /* 1950 * Stop trace script 1951 */ 1952 static int python_stop_script(void) 1953 { 1954 struct tables *tables = &tables_global; 1955 1956 try_call_object("trace_end", NULL); 1957 1958 db_export__exit(&tables->dbe); 1959 1960 Py_XDECREF(main_dict); 1961 Py_XDECREF(main_module); 1962 Py_Finalize(); 1963 1964 return 0; 1965 } 1966 1967 static int python_generate_script(struct tep_handle *pevent, const char *outfile) 1968 { 1969 int i, not_first, count, nr_events; 1970 struct tep_event **all_events; 1971 struct tep_event *event = NULL; 1972 struct tep_format_field *f; 1973 char fname[PATH_MAX]; 1974 FILE *ofp; 1975 1976 sprintf(fname, "%s.py", outfile); 1977 ofp = fopen(fname, "w"); 1978 if (ofp == NULL) { 1979 fprintf(stderr, "couldn't open %s\n", fname); 1980 return -1; 1981 } 1982 fprintf(ofp, "# perf script event handlers, " 1983 "generated by perf script -g python\n"); 1984 1985 fprintf(ofp, "# Licensed under the terms of the GNU GPL" 1986 " License version 2\n\n"); 1987 1988 fprintf(ofp, "# The common_* event handler fields are the most useful " 1989 "fields common to\n"); 1990 1991 fprintf(ofp, "# all events. They don't necessarily correspond to " 1992 "the 'common_*' fields\n"); 1993 1994 fprintf(ofp, "# in the format files. Those fields not available as " 1995 "handler params can\n"); 1996 1997 fprintf(ofp, "# be retrieved using Python functions of the form " 1998 "common_*(context).\n"); 1999 2000 fprintf(ofp, "# See the perf-script-python Documentation for the list " 2001 "of available functions.\n\n"); 2002 2003 fprintf(ofp, "from __future__ import print_function\n\n"); 2004 fprintf(ofp, "import os\n"); 2005 fprintf(ofp, "import sys\n\n"); 2006 2007 fprintf(ofp, "sys.path.append(os.environ['PERF_EXEC_PATH'] + \\\n"); 2008 fprintf(ofp, "\t'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')\n"); 2009 fprintf(ofp, "\nfrom perf_trace_context import *\n"); 2010 fprintf(ofp, "from Core import *\n\n\n"); 2011 2012 fprintf(ofp, "def trace_begin():\n"); 2013 fprintf(ofp, "\tprint(\"in trace_begin\")\n\n"); 2014 2015 fprintf(ofp, "def trace_end():\n"); 2016 fprintf(ofp, "\tprint(\"in trace_end\")\n\n"); 2017 2018 nr_events = tep_get_events_count(pevent); 2019 all_events = tep_list_events(pevent, TEP_EVENT_SORT_ID); 2020 2021 for (i = 0; all_events && i < nr_events; i++) { 2022 event = all_events[i]; 2023 fprintf(ofp, "def %s__%s(", event->system, event->name); 2024 fprintf(ofp, "event_name, "); 2025 fprintf(ofp, "context, "); 2026 fprintf(ofp, "common_cpu,\n"); 2027 fprintf(ofp, "\tcommon_secs, "); 2028 fprintf(ofp, "common_nsecs, "); 2029 fprintf(ofp, "common_pid, "); 2030 fprintf(ofp, "common_comm,\n\t"); 2031 fprintf(ofp, "common_callchain, "); 2032 2033 not_first = 0; 2034 count = 0; 2035 2036 for (f = event->format.fields; f; f = f->next) { 2037 if (not_first++) 2038 fprintf(ofp, ", "); 2039 if (++count % 5 == 0) 2040 fprintf(ofp, "\n\t"); 2041 2042 fprintf(ofp, "%s", f->name); 2043 } 2044 if (not_first++) 2045 fprintf(ofp, ", "); 2046 if (++count % 5 == 0) 2047 fprintf(ofp, "\n\t\t"); 2048 fprintf(ofp, "perf_sample_dict"); 2049 2050 fprintf(ofp, "):\n"); 2051 2052 fprintf(ofp, "\t\tprint_header(event_name, common_cpu, " 2053 "common_secs, common_nsecs,\n\t\t\t" 2054 "common_pid, common_comm)\n\n"); 2055 2056 fprintf(ofp, "\t\tprint(\""); 2057 2058 not_first = 0; 2059 count = 0; 2060 2061 for (f = event->format.fields; f; f = f->next) { 2062 if (not_first++) 2063 fprintf(ofp, ", "); 2064 if (count && count % 3 == 0) { 2065 fprintf(ofp, "\" \\\n\t\t\""); 2066 } 2067 count++; 2068 2069 fprintf(ofp, "%s=", f->name); 2070 if (f->flags & TEP_FIELD_IS_STRING || 2071 f->flags & TEP_FIELD_IS_FLAG || 2072 f->flags & TEP_FIELD_IS_ARRAY || 2073 f->flags & TEP_FIELD_IS_SYMBOLIC) 2074 fprintf(ofp, "%%s"); 2075 else if (f->flags & TEP_FIELD_IS_SIGNED) 2076 fprintf(ofp, "%%d"); 2077 else 2078 fprintf(ofp, "%%u"); 2079 } 2080 2081 fprintf(ofp, "\" %% \\\n\t\t("); 2082 2083 not_first = 0; 2084 count = 0; 2085 2086 for (f = event->format.fields; f; f = f->next) { 2087 if (not_first++) 2088 fprintf(ofp, ", "); 2089 2090 if (++count % 5 == 0) 2091 fprintf(ofp, "\n\t\t"); 2092 2093 if (f->flags & TEP_FIELD_IS_FLAG) { 2094 if ((count - 1) % 5 != 0) { 2095 fprintf(ofp, "\n\t\t"); 2096 count = 4; 2097 } 2098 fprintf(ofp, "flag_str(\""); 2099 fprintf(ofp, "%s__%s\", ", event->system, 2100 event->name); 2101 fprintf(ofp, "\"%s\", %s)", f->name, 2102 f->name); 2103 } else if (f->flags & TEP_FIELD_IS_SYMBOLIC) { 2104 if ((count - 1) % 5 != 0) { 2105 fprintf(ofp, "\n\t\t"); 2106 count = 4; 2107 } 2108 fprintf(ofp, "symbol_str(\""); 2109 fprintf(ofp, "%s__%s\", ", event->system, 2110 event->name); 2111 fprintf(ofp, "\"%s\", %s)", f->name, 2112 f->name); 2113 } else 2114 fprintf(ofp, "%s", f->name); 2115 } 2116 2117 fprintf(ofp, "))\n\n"); 2118 2119 fprintf(ofp, "\t\tprint('Sample: {'+" 2120 "get_dict_as_string(perf_sample_dict['sample'], ', ')+'}')\n\n"); 2121 2122 fprintf(ofp, "\t\tfor node in common_callchain:"); 2123 fprintf(ofp, "\n\t\t\tif 'sym' in node:"); 2124 fprintf(ofp, "\n\t\t\t\tprint(\"\t[%%x] %%s%%s%%s%%s\" %% ("); 2125 fprintf(ofp, "\n\t\t\t\t\tnode['ip'], node['sym']['name'],"); 2126 fprintf(ofp, "\n\t\t\t\t\t\"+0x{:x}\".format(node['sym_off']) if 'sym_off' in node else \"\","); 2127 fprintf(ofp, "\n\t\t\t\t\t\" ({})\".format(node['dso']) if 'dso' in node else \"\","); 2128 fprintf(ofp, "\n\t\t\t\t\t\" \" + node['sym_srcline'] if 'sym_srcline' in node else \"\"))"); 2129 fprintf(ofp, "\n\t\t\telse:"); 2130 fprintf(ofp, "\n\t\t\t\tprint(\"\t[%%x]\" %% (node['ip']))\n\n"); 2131 fprintf(ofp, "\t\tprint()\n\n"); 2132 2133 } 2134 2135 fprintf(ofp, "def trace_unhandled(event_name, context, " 2136 "event_fields_dict, perf_sample_dict):\n"); 2137 2138 fprintf(ofp, "\t\tprint(get_dict_as_string(event_fields_dict))\n"); 2139 fprintf(ofp, "\t\tprint('Sample: {'+" 2140 "get_dict_as_string(perf_sample_dict['sample'], ', ')+'}')\n\n"); 2141 2142 fprintf(ofp, "def print_header(" 2143 "event_name, cpu, secs, nsecs, pid, comm):\n" 2144 "\tprint(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \" %% \\\n\t" 2145 "(event_name, cpu, secs, nsecs, pid, comm), end=\"\")\n\n"); 2146 2147 fprintf(ofp, "def get_dict_as_string(a_dict, delimiter=' '):\n" 2148 "\treturn delimiter.join" 2149 "(['%%s=%%s'%%(k,str(v))for k,v in sorted(a_dict.items())])\n"); 2150 2151 fclose(ofp); 2152 2153 fprintf(stderr, "generated Python script: %s\n", fname); 2154 2155 return 0; 2156 } 2157 2158 struct scripting_ops python_scripting_ops = { 2159 .name = "Python", 2160 .dirname = "python", 2161 .start_script = python_start_script, 2162 .flush_script = python_flush_script, 2163 .stop_script = python_stop_script, 2164 .process_event = python_process_event, 2165 .process_switch = python_process_switch, 2166 .process_auxtrace_error = python_process_auxtrace_error, 2167 .process_stat = python_process_stat, 2168 .process_stat_interval = python_process_stat_interval, 2169 .process_throttle = python_process_throttle, 2170 .generate_script = python_generate_script, 2171 }; 2172