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