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