Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * trace-event-python.  Feed trace events to an embedded Python interpreter.
0003  *
0004  * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com>
0005  *
0006  *  This program is free software; you can redistribute it and/or modify
0007  *  it under the terms of the GNU General Public License as published by
0008  *  the Free Software Foundation; either version 2 of the License, or
0009  *  (at your option) any later version.
0010  *
0011  *  This program is distributed in the hope that it will be useful,
0012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
0013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0014  *  GNU General Public License for more details.
0015  *
0016  *  You should have received a copy of the GNU General Public License
0017  *  along with this program; if not, write to the Free Software
0018  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
0019  *
0020  */
0021 
0022 #include <Python.h>
0023 
0024 #include <inttypes.h>
0025 #include <stdio.h>
0026 #include <stdlib.h>
0027 #include <string.h>
0028 #include <stdbool.h>
0029 #include <errno.h>
0030 #include <linux/bitmap.h>
0031 #include <linux/compiler.h>
0032 #include <linux/time64.h>
0033 
0034 #include "../build-id.h"
0035 #include "../counts.h"
0036 #include "../debug.h"
0037 #include "../dso.h"
0038 #include "../callchain.h"
0039 #include "../env.h"
0040 #include "../evsel.h"
0041 #include "../event.h"
0042 #include "../thread.h"
0043 #include "../comm.h"
0044 #include "../machine.h"
0045 #include "../db-export.h"
0046 #include "../thread-stack.h"
0047 #include "../trace-event.h"
0048 #include "../call-path.h"
0049 #include "map.h"
0050 #include "symbol.h"
0051 #include "thread_map.h"
0052 #include "print_binary.h"
0053 #include "stat.h"
0054 #include "mem-events.h"
0055 
0056 #if PY_MAJOR_VERSION < 3
0057 #define _PyUnicode_FromString(arg) \
0058   PyString_FromString(arg)
0059 #define _PyUnicode_FromStringAndSize(arg1, arg2) \
0060   PyString_FromStringAndSize((arg1), (arg2))
0061 #define _PyBytes_FromStringAndSize(arg1, arg2) \
0062   PyString_FromStringAndSize((arg1), (arg2))
0063 #define _PyLong_FromLong(arg) \
0064   PyInt_FromLong(arg)
0065 #define _PyLong_AsLong(arg) \
0066   PyInt_AsLong(arg)
0067 #define _PyCapsule_New(arg1, arg2, arg3) \
0068   PyCObject_FromVoidPtr((arg1), (arg2))
0069 
0070 PyMODINIT_FUNC initperf_trace_context(void);
0071 #else
0072 #define _PyUnicode_FromString(arg) \
0073   PyUnicode_FromString(arg)
0074 #define _PyUnicode_FromStringAndSize(arg1, arg2) \
0075   PyUnicode_FromStringAndSize((arg1), (arg2))
0076 #define _PyBytes_FromStringAndSize(arg1, arg2) \
0077   PyBytes_FromStringAndSize((arg1), (arg2))
0078 #define _PyLong_FromLong(arg) \
0079   PyLong_FromLong(arg)
0080 #define _PyLong_AsLong(arg) \
0081   PyLong_AsLong(arg)
0082 #define _PyCapsule_New(arg1, arg2, arg3) \
0083   PyCapsule_New((arg1), (arg2), (arg3))
0084 
0085 PyMODINIT_FUNC PyInit_perf_trace_context(void);
0086 #endif
0087 
0088 #define TRACE_EVENT_TYPE_MAX                \
0089     ((1 << (sizeof(unsigned short) * 8)) - 1)
0090 
0091 static DECLARE_BITMAP(events_defined, TRACE_EVENT_TYPE_MAX);
0092 
0093 #define MAX_FIELDS  64
0094 #define N_COMMON_FIELDS 7
0095 
0096 extern struct scripting_context *scripting_context;
0097 
0098 static char *cur_field_name;
0099 static int zero_flag_atom;
0100 
0101 static PyObject *main_module, *main_dict;
0102 
0103 struct tables {
0104     struct db_export    dbe;
0105     PyObject        *evsel_handler;
0106     PyObject        *machine_handler;
0107     PyObject        *thread_handler;
0108     PyObject        *comm_handler;
0109     PyObject        *comm_thread_handler;
0110     PyObject        *dso_handler;
0111     PyObject        *symbol_handler;
0112     PyObject        *branch_type_handler;
0113     PyObject        *sample_handler;
0114     PyObject        *call_path_handler;
0115     PyObject        *call_return_handler;
0116     PyObject        *synth_handler;
0117     PyObject        *context_switch_handler;
0118     bool            db_export_mode;
0119 };
0120 
0121 static struct tables tables_global;
0122 
0123 static void handler_call_die(const char *handler_name) __noreturn;
0124 static void handler_call_die(const char *handler_name)
0125 {
0126     PyErr_Print();
0127     Py_FatalError("problem in Python trace event handler");
0128     // Py_FatalError does not return
0129     // but we have to make the compiler happy
0130     abort();
0131 }
0132 
0133 /*
0134  * Insert val into the dictionary and decrement the reference counter.
0135  * This is necessary for dictionaries since PyDict_SetItemString() does not
0136  * steal a reference, as opposed to PyTuple_SetItem().
0137  */
0138 static void pydict_set_item_string_decref(PyObject *dict, const char *key, PyObject *val)
0139 {
0140     PyDict_SetItemString(dict, key, val);
0141     Py_DECREF(val);
0142 }
0143 
0144 static PyObject *get_handler(const char *handler_name)
0145 {
0146     PyObject *handler;
0147 
0148     handler = PyDict_GetItemString(main_dict, handler_name);
0149     if (handler && !PyCallable_Check(handler))
0150         return NULL;
0151     return handler;
0152 }
0153 
0154 static int get_argument_count(PyObject *handler)
0155 {
0156     int arg_count = 0;
0157 
0158     /*
0159      * The attribute for the code object is func_code in Python 2,
0160      * whereas it is __code__ in Python 3.0+.
0161      */
0162     PyObject *code_obj = PyObject_GetAttrString(handler,
0163         "func_code");
0164     if (PyErr_Occurred()) {
0165         PyErr_Clear();
0166         code_obj = PyObject_GetAttrString(handler,
0167             "__code__");
0168     }
0169     PyErr_Clear();
0170     if (code_obj) {
0171         PyObject *arg_count_obj = PyObject_GetAttrString(code_obj,
0172             "co_argcount");
0173         if (arg_count_obj) {
0174             arg_count = (int) _PyLong_AsLong(arg_count_obj);
0175             Py_DECREF(arg_count_obj);
0176         }
0177         Py_DECREF(code_obj);
0178     }
0179     return arg_count;
0180 }
0181 
0182 static void call_object(PyObject *handler, PyObject *args, const char *die_msg)
0183 {
0184     PyObject *retval;
0185 
0186     retval = PyObject_CallObject(handler, args);
0187     if (retval == NULL)
0188         handler_call_die(die_msg);
0189     Py_DECREF(retval);
0190 }
0191 
0192 static void try_call_object(const char *handler_name, PyObject *args)
0193 {
0194     PyObject *handler;
0195 
0196     handler = get_handler(handler_name);
0197     if (handler)
0198         call_object(handler, args, handler_name);
0199 }
0200 
0201 static void define_value(enum tep_print_arg_type field_type,
0202              const char *ev_name,
0203              const char *field_name,
0204              const char *field_value,
0205              const char *field_str)
0206 {
0207     const char *handler_name = "define_flag_value";
0208     PyObject *t;
0209     unsigned long long value;
0210     unsigned n = 0;
0211 
0212     if (field_type == TEP_PRINT_SYMBOL)
0213         handler_name = "define_symbolic_value";
0214 
0215     t = PyTuple_New(4);
0216     if (!t)
0217         Py_FatalError("couldn't create Python tuple");
0218 
0219     value = eval_flag(field_value);
0220 
0221     PyTuple_SetItem(t, n++, _PyUnicode_FromString(ev_name));
0222     PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_name));
0223     PyTuple_SetItem(t, n++, _PyLong_FromLong(value));
0224     PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_str));
0225 
0226     try_call_object(handler_name, t);
0227 
0228     Py_DECREF(t);
0229 }
0230 
0231 static void define_values(enum tep_print_arg_type field_type,
0232               struct tep_print_flag_sym *field,
0233               const char *ev_name,
0234               const char *field_name)
0235 {
0236     define_value(field_type, ev_name, field_name, field->value,
0237              field->str);
0238 
0239     if (field->next)
0240         define_values(field_type, field->next, ev_name, field_name);
0241 }
0242 
0243 static void define_field(enum tep_print_arg_type field_type,
0244              const char *ev_name,
0245              const char *field_name,
0246              const char *delim)
0247 {
0248     const char *handler_name = "define_flag_field";
0249     PyObject *t;
0250     unsigned n = 0;
0251 
0252     if (field_type == TEP_PRINT_SYMBOL)
0253         handler_name = "define_symbolic_field";
0254 
0255     if (field_type == TEP_PRINT_FLAGS)
0256         t = PyTuple_New(3);
0257     else
0258         t = PyTuple_New(2);
0259     if (!t)
0260         Py_FatalError("couldn't create Python tuple");
0261 
0262     PyTuple_SetItem(t, n++, _PyUnicode_FromString(ev_name));
0263     PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_name));
0264     if (field_type == TEP_PRINT_FLAGS)
0265         PyTuple_SetItem(t, n++, _PyUnicode_FromString(delim));
0266 
0267     try_call_object(handler_name, t);
0268 
0269     Py_DECREF(t);
0270 }
0271 
0272 static void define_event_symbols(struct tep_event *event,
0273                  const char *ev_name,
0274                  struct tep_print_arg *args)
0275 {
0276     if (args == NULL)
0277         return;
0278 
0279     switch (args->type) {
0280     case TEP_PRINT_NULL:
0281         break;
0282     case TEP_PRINT_ATOM:
0283         define_value(TEP_PRINT_FLAGS, ev_name, cur_field_name, "0",
0284                  args->atom.atom);
0285         zero_flag_atom = 0;
0286         break;
0287     case TEP_PRINT_FIELD:
0288         free(cur_field_name);
0289         cur_field_name = strdup(args->field.name);
0290         break;
0291     case TEP_PRINT_FLAGS:
0292         define_event_symbols(event, ev_name, args->flags.field);
0293         define_field(TEP_PRINT_FLAGS, ev_name, cur_field_name,
0294                  args->flags.delim);
0295         define_values(TEP_PRINT_FLAGS, args->flags.flags, ev_name,
0296                   cur_field_name);
0297         break;
0298     case TEP_PRINT_SYMBOL:
0299         define_event_symbols(event, ev_name, args->symbol.field);
0300         define_field(TEP_PRINT_SYMBOL, ev_name, cur_field_name, NULL);
0301         define_values(TEP_PRINT_SYMBOL, args->symbol.symbols, ev_name,
0302                   cur_field_name);
0303         break;
0304     case TEP_PRINT_HEX:
0305     case TEP_PRINT_HEX_STR:
0306         define_event_symbols(event, ev_name, args->hex.field);
0307         define_event_symbols(event, ev_name, args->hex.size);
0308         break;
0309     case TEP_PRINT_INT_ARRAY:
0310         define_event_symbols(event, ev_name, args->int_array.field);
0311         define_event_symbols(event, ev_name, args->int_array.count);
0312         define_event_symbols(event, ev_name, args->int_array.el_size);
0313         break;
0314     case TEP_PRINT_STRING:
0315         break;
0316     case TEP_PRINT_TYPE:
0317         define_event_symbols(event, ev_name, args->typecast.item);
0318         break;
0319     case TEP_PRINT_OP:
0320         if (strcmp(args->op.op, ":") == 0)
0321             zero_flag_atom = 1;
0322         define_event_symbols(event, ev_name, args->op.left);
0323         define_event_symbols(event, ev_name, args->op.right);
0324         break;
0325     default:
0326         /* gcc warns for these? */
0327     case TEP_PRINT_BSTRING:
0328     case TEP_PRINT_DYNAMIC_ARRAY:
0329     case TEP_PRINT_DYNAMIC_ARRAY_LEN:
0330     case TEP_PRINT_FUNC:
0331     case TEP_PRINT_BITMASK:
0332         /* we should warn... */
0333         return;
0334     }
0335 
0336     if (args->next)
0337         define_event_symbols(event, ev_name, args->next);
0338 }
0339 
0340 static PyObject *get_field_numeric_entry(struct tep_event *event,
0341         struct tep_format_field *field, void *data)
0342 {
0343     bool is_array = field->flags & TEP_FIELD_IS_ARRAY;
0344     PyObject *obj = NULL, *list = NULL;
0345     unsigned long long val;
0346     unsigned int item_size, n_items, i;
0347 
0348     if (is_array) {
0349         list = PyList_New(field->arraylen);
0350         item_size = field->size / field->arraylen;
0351         n_items = field->arraylen;
0352     } else {
0353         item_size = field->size;
0354         n_items = 1;
0355     }
0356 
0357     for (i = 0; i < n_items; i++) {
0358 
0359         val = read_size(event, data + field->offset + i * item_size,
0360                 item_size);
0361         if (field->flags & TEP_FIELD_IS_SIGNED) {
0362             if ((long long)val >= LONG_MIN &&
0363                     (long long)val <= LONG_MAX)
0364                 obj = _PyLong_FromLong(val);
0365             else
0366                 obj = PyLong_FromLongLong(val);
0367         } else {
0368             if (val <= LONG_MAX)
0369                 obj = _PyLong_FromLong(val);
0370             else
0371                 obj = PyLong_FromUnsignedLongLong(val);
0372         }
0373         if (is_array)
0374             PyList_SET_ITEM(list, i, obj);
0375     }
0376     if (is_array)
0377         obj = list;
0378     return obj;
0379 }
0380 
0381 static const char *get_dsoname(struct map *map)
0382 {
0383     const char *dsoname = "[unknown]";
0384 
0385     if (map && map->dso) {
0386         if (symbol_conf.show_kernel_path && map->dso->long_name)
0387             dsoname = map->dso->long_name;
0388         else
0389             dsoname = map->dso->name;
0390     }
0391 
0392     return dsoname;
0393 }
0394 
0395 static unsigned long get_offset(struct symbol *sym, struct addr_location *al)
0396 {
0397     unsigned long offset;
0398 
0399     if (al->addr < sym->end)
0400         offset = al->addr - sym->start;
0401     else
0402         offset = al->addr - al->map->start - sym->start;
0403 
0404     return offset;
0405 }
0406 
0407 static PyObject *python_process_callchain(struct perf_sample *sample,
0408                      struct evsel *evsel,
0409                      struct addr_location *al)
0410 {
0411     PyObject *pylist;
0412 
0413     pylist = PyList_New(0);
0414     if (!pylist)
0415         Py_FatalError("couldn't create Python list");
0416 
0417     if (!symbol_conf.use_callchain || !sample->callchain)
0418         goto exit;
0419 
0420     if (thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
0421                       sample, NULL, NULL,
0422                       scripting_max_stack) != 0) {
0423         pr_err("Failed to resolve callchain. Skipping\n");
0424         goto exit;
0425     }
0426     callchain_cursor_commit(&callchain_cursor);
0427 
0428 
0429     while (1) {
0430         PyObject *pyelem;
0431         struct callchain_cursor_node *node;
0432         node = callchain_cursor_current(&callchain_cursor);
0433         if (!node)
0434             break;
0435 
0436         pyelem = PyDict_New();
0437         if (!pyelem)
0438             Py_FatalError("couldn't create Python dictionary");
0439 
0440 
0441         pydict_set_item_string_decref(pyelem, "ip",
0442                 PyLong_FromUnsignedLongLong(node->ip));
0443 
0444         if (node->ms.sym) {
0445             PyObject *pysym  = PyDict_New();
0446             if (!pysym)
0447                 Py_FatalError("couldn't create Python dictionary");
0448             pydict_set_item_string_decref(pysym, "start",
0449                     PyLong_FromUnsignedLongLong(node->ms.sym->start));
0450             pydict_set_item_string_decref(pysym, "end",
0451                     PyLong_FromUnsignedLongLong(node->ms.sym->end));
0452             pydict_set_item_string_decref(pysym, "binding",
0453                     _PyLong_FromLong(node->ms.sym->binding));
0454             pydict_set_item_string_decref(pysym, "name",
0455                     _PyUnicode_FromStringAndSize(node->ms.sym->name,
0456                             node->ms.sym->namelen));
0457             pydict_set_item_string_decref(pyelem, "sym", pysym);
0458 
0459             if (node->ms.map) {
0460                 struct map *map = node->ms.map;
0461                 struct addr_location node_al;
0462                 unsigned long offset;
0463 
0464                 node_al.addr = map->map_ip(map, node->ip);
0465                 node_al.map  = map;
0466                 offset = get_offset(node->ms.sym, &node_al);
0467 
0468                 pydict_set_item_string_decref(
0469                     pyelem, "sym_off",
0470                     PyLong_FromUnsignedLongLong(offset));
0471             }
0472             if (node->srcline && strcmp(":0", node->srcline)) {
0473                 pydict_set_item_string_decref(
0474                     pyelem, "sym_srcline",
0475                     _PyUnicode_FromString(node->srcline));
0476             }
0477         }
0478 
0479         if (node->ms.map) {
0480             const char *dsoname = get_dsoname(node->ms.map);
0481 
0482             pydict_set_item_string_decref(pyelem, "dso",
0483                     _PyUnicode_FromString(dsoname));
0484         }
0485 
0486         callchain_cursor_advance(&callchain_cursor);
0487         PyList_Append(pylist, pyelem);
0488         Py_DECREF(pyelem);
0489     }
0490 
0491 exit:
0492     return pylist;
0493 }
0494 
0495 static PyObject *python_process_brstack(struct perf_sample *sample,
0496                     struct thread *thread)
0497 {
0498     struct branch_stack *br = sample->branch_stack;
0499     struct branch_entry *entries = perf_sample__branch_entries(sample);
0500     PyObject *pylist;
0501     u64 i;
0502 
0503     pylist = PyList_New(0);
0504     if (!pylist)
0505         Py_FatalError("couldn't create Python list");
0506 
0507     if (!(br && br->nr))
0508         goto exit;
0509 
0510     for (i = 0; i < br->nr; i++) {
0511         PyObject *pyelem;
0512         struct addr_location al;
0513         const char *dsoname;
0514 
0515         pyelem = PyDict_New();
0516         if (!pyelem)
0517             Py_FatalError("couldn't create Python dictionary");
0518 
0519         pydict_set_item_string_decref(pyelem, "from",
0520             PyLong_FromUnsignedLongLong(entries[i].from));
0521         pydict_set_item_string_decref(pyelem, "to",
0522             PyLong_FromUnsignedLongLong(entries[i].to));
0523         pydict_set_item_string_decref(pyelem, "mispred",
0524             PyBool_FromLong(entries[i].flags.mispred));
0525         pydict_set_item_string_decref(pyelem, "predicted",
0526             PyBool_FromLong(entries[i].flags.predicted));
0527         pydict_set_item_string_decref(pyelem, "in_tx",
0528             PyBool_FromLong(entries[i].flags.in_tx));
0529         pydict_set_item_string_decref(pyelem, "abort",
0530             PyBool_FromLong(entries[i].flags.abort));
0531         pydict_set_item_string_decref(pyelem, "cycles",
0532             PyLong_FromUnsignedLongLong(entries[i].flags.cycles));
0533 
0534         thread__find_map_fb(thread, sample->cpumode,
0535                     entries[i].from, &al);
0536         dsoname = get_dsoname(al.map);
0537         pydict_set_item_string_decref(pyelem, "from_dsoname",
0538                           _PyUnicode_FromString(dsoname));
0539 
0540         thread__find_map_fb(thread, sample->cpumode,
0541                     entries[i].to, &al);
0542         dsoname = get_dsoname(al.map);
0543         pydict_set_item_string_decref(pyelem, "to_dsoname",
0544                           _PyUnicode_FromString(dsoname));
0545 
0546         PyList_Append(pylist, pyelem);
0547         Py_DECREF(pyelem);
0548     }
0549 
0550 exit:
0551     return pylist;
0552 }
0553 
0554 static int get_symoff(struct symbol *sym, struct addr_location *al,
0555               bool print_off, char *bf, int size)
0556 {
0557     unsigned long offset;
0558 
0559     if (!sym || !sym->name[0])
0560         return scnprintf(bf, size, "%s", "[unknown]");
0561 
0562     if (!print_off)
0563         return scnprintf(bf, size, "%s", sym->name);
0564 
0565     offset = get_offset(sym, al);
0566 
0567     return scnprintf(bf, size, "%s+0x%x", sym->name, offset);
0568 }
0569 
0570 static int get_br_mspred(struct branch_flags *flags, char *bf, int size)
0571 {
0572     if (!flags->mispred  && !flags->predicted)
0573         return scnprintf(bf, size, "%s", "-");
0574 
0575     if (flags->mispred)
0576         return scnprintf(bf, size, "%s", "M");
0577 
0578     return scnprintf(bf, size, "%s", "P");
0579 }
0580 
0581 static PyObject *python_process_brstacksym(struct perf_sample *sample,
0582                        struct thread *thread)
0583 {
0584     struct branch_stack *br = sample->branch_stack;
0585     struct branch_entry *entries = perf_sample__branch_entries(sample);
0586     PyObject *pylist;
0587     u64 i;
0588     char bf[512];
0589     struct addr_location al;
0590 
0591     pylist = PyList_New(0);
0592     if (!pylist)
0593         Py_FatalError("couldn't create Python list");
0594 
0595     if (!(br && br->nr))
0596         goto exit;
0597 
0598     for (i = 0; i < br->nr; i++) {
0599         PyObject *pyelem;
0600 
0601         pyelem = PyDict_New();
0602         if (!pyelem)
0603             Py_FatalError("couldn't create Python dictionary");
0604 
0605         thread__find_symbol_fb(thread, sample->cpumode,
0606                        entries[i].from, &al);
0607         get_symoff(al.sym, &al, true, bf, sizeof(bf));
0608         pydict_set_item_string_decref(pyelem, "from",
0609                           _PyUnicode_FromString(bf));
0610 
0611         thread__find_symbol_fb(thread, sample->cpumode,
0612                        entries[i].to, &al);
0613         get_symoff(al.sym, &al, true, bf, sizeof(bf));
0614         pydict_set_item_string_decref(pyelem, "to",
0615                           _PyUnicode_FromString(bf));
0616 
0617         get_br_mspred(&entries[i].flags, bf, sizeof(bf));
0618         pydict_set_item_string_decref(pyelem, "pred",
0619                           _PyUnicode_FromString(bf));
0620 
0621         if (entries[i].flags.in_tx) {
0622             pydict_set_item_string_decref(pyelem, "in_tx",
0623                           _PyUnicode_FromString("X"));
0624         } else {
0625             pydict_set_item_string_decref(pyelem, "in_tx",
0626                           _PyUnicode_FromString("-"));
0627         }
0628 
0629         if (entries[i].flags.abort) {
0630             pydict_set_item_string_decref(pyelem, "abort",
0631                           _PyUnicode_FromString("A"));
0632         } else {
0633             pydict_set_item_string_decref(pyelem, "abort",
0634                           _PyUnicode_FromString("-"));
0635         }
0636 
0637         PyList_Append(pylist, pyelem);
0638         Py_DECREF(pyelem);
0639     }
0640 
0641 exit:
0642     return pylist;
0643 }
0644 
0645 static PyObject *get_sample_value_as_tuple(struct sample_read_value *value,
0646                        u64 read_format)
0647 {
0648     PyObject *t;
0649 
0650     t = PyTuple_New(3);
0651     if (!t)
0652         Py_FatalError("couldn't create Python tuple");
0653     PyTuple_SetItem(t, 0, PyLong_FromUnsignedLongLong(value->id));
0654     PyTuple_SetItem(t, 1, PyLong_FromUnsignedLongLong(value->value));
0655     if (read_format & PERF_FORMAT_LOST)
0656         PyTuple_SetItem(t, 2, PyLong_FromUnsignedLongLong(value->lost));
0657 
0658     return t;
0659 }
0660 
0661 static void set_sample_read_in_dict(PyObject *dict_sample,
0662                      struct perf_sample *sample,
0663                      struct evsel *evsel)
0664 {
0665     u64 read_format = evsel->core.attr.read_format;
0666     PyObject *values;
0667     unsigned int i;
0668 
0669     if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
0670         pydict_set_item_string_decref(dict_sample, "time_enabled",
0671             PyLong_FromUnsignedLongLong(sample->read.time_enabled));
0672     }
0673 
0674     if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
0675         pydict_set_item_string_decref(dict_sample, "time_running",
0676             PyLong_FromUnsignedLongLong(sample->read.time_running));
0677     }
0678 
0679     if (read_format & PERF_FORMAT_GROUP)
0680         values = PyList_New(sample->read.group.nr);
0681     else
0682         values = PyList_New(1);
0683 
0684     if (!values)
0685         Py_FatalError("couldn't create Python list");
0686 
0687     if (read_format & PERF_FORMAT_GROUP) {
0688         struct sample_read_value *v = sample->read.group.values;
0689 
0690         i = 0;
0691         sample_read_group__for_each(v, sample->read.group.nr, read_format) {
0692             PyObject *t = get_sample_value_as_tuple(v, read_format);
0693             PyList_SET_ITEM(values, i, t);
0694             i++;
0695         }
0696     } else {
0697         PyObject *t = get_sample_value_as_tuple(&sample->read.one,
0698                             read_format);
0699         PyList_SET_ITEM(values, 0, t);
0700     }
0701     pydict_set_item_string_decref(dict_sample, "values", values);
0702 }
0703 
0704 static void set_sample_datasrc_in_dict(PyObject *dict,
0705                        struct perf_sample *sample)
0706 {
0707     struct mem_info mi = { .data_src.val = sample->data_src };
0708     char decode[100];
0709 
0710     pydict_set_item_string_decref(dict, "datasrc",
0711             PyLong_FromUnsignedLongLong(sample->data_src));
0712 
0713     perf_script__meminfo_scnprintf(decode, 100, &mi);
0714 
0715     pydict_set_item_string_decref(dict, "datasrc_decode",
0716             _PyUnicode_FromString(decode));
0717 }
0718 
0719 static void regs_map(struct regs_dump *regs, uint64_t mask, const char *arch, char *bf, int size)
0720 {
0721     unsigned int i = 0, r;
0722     int printed = 0;
0723 
0724     bf[0] = 0;
0725 
0726     if (!regs || !regs->regs)
0727         return;
0728 
0729     for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) {
0730         u64 val = regs->regs[i++];
0731 
0732         printed += scnprintf(bf + printed, size - printed,
0733                      "%5s:0x%" PRIx64 " ",
0734                      perf_reg_name(r, arch), val);
0735     }
0736 }
0737 
0738 static void set_regs_in_dict(PyObject *dict,
0739                  struct perf_sample *sample,
0740                  struct evsel *evsel)
0741 {
0742     struct perf_event_attr *attr = &evsel->core.attr;
0743     const char *arch = perf_env__arch(evsel__env(evsel));
0744 
0745     /*
0746      * Here value 28 is a constant size which can be used to print
0747      * one register value and its corresponds to:
0748      * 16 chars is to specify 64 bit register in hexadecimal.
0749      * 2 chars is for appending "0x" to the hexadecimal value and
0750      * 10 chars is for register name.
0751      */
0752     int size = __sw_hweight64(attr->sample_regs_intr) * 28;
0753     char bf[size];
0754 
0755     regs_map(&sample->intr_regs, attr->sample_regs_intr, arch, bf, sizeof(bf));
0756 
0757     pydict_set_item_string_decref(dict, "iregs",
0758             _PyUnicode_FromString(bf));
0759 
0760     regs_map(&sample->user_regs, attr->sample_regs_user, arch, bf, sizeof(bf));
0761 
0762     pydict_set_item_string_decref(dict, "uregs",
0763             _PyUnicode_FromString(bf));
0764 }
0765 
0766 static void set_sym_in_dict(PyObject *dict, struct addr_location *al,
0767                 const char *dso_field, const char *dso_bid_field,
0768                 const char *dso_map_start, const char *dso_map_end,
0769                 const char *sym_field, const char *symoff_field)
0770 {
0771     char sbuild_id[SBUILD_ID_SIZE];
0772 
0773     if (al->map) {
0774         pydict_set_item_string_decref(dict, dso_field,
0775             _PyUnicode_FromString(al->map->dso->name));
0776         build_id__sprintf(&al->map->dso->bid, sbuild_id);
0777         pydict_set_item_string_decref(dict, dso_bid_field,
0778             _PyUnicode_FromString(sbuild_id));
0779         pydict_set_item_string_decref(dict, dso_map_start,
0780             PyLong_FromUnsignedLong(al->map->start));
0781         pydict_set_item_string_decref(dict, dso_map_end,
0782             PyLong_FromUnsignedLong(al->map->end));
0783     }
0784     if (al->sym) {
0785         pydict_set_item_string_decref(dict, sym_field,
0786             _PyUnicode_FromString(al->sym->name));
0787         pydict_set_item_string_decref(dict, symoff_field,
0788             PyLong_FromUnsignedLong(get_offset(al->sym, al)));
0789     }
0790 }
0791 
0792 static void set_sample_flags(PyObject *dict, u32 flags)
0793 {
0794     const char *ch = PERF_IP_FLAG_CHARS;
0795     char *p, str[33];
0796 
0797     for (p = str; *ch; ch++, flags >>= 1) {
0798         if (flags & 1)
0799             *p++ = *ch;
0800     }
0801     *p = 0;
0802     pydict_set_item_string_decref(dict, "flags", _PyUnicode_FromString(str));
0803 }
0804 
0805 static void python_process_sample_flags(struct perf_sample *sample, PyObject *dict_sample)
0806 {
0807     char flags_disp[SAMPLE_FLAGS_BUF_SIZE];
0808 
0809     set_sample_flags(dict_sample, sample->flags);
0810     perf_sample__sprintf_flags(sample->flags, flags_disp, sizeof(flags_disp));
0811     pydict_set_item_string_decref(dict_sample, "flags_disp",
0812         _PyUnicode_FromString(flags_disp));
0813 }
0814 
0815 static PyObject *get_perf_sample_dict(struct perf_sample *sample,
0816                      struct evsel *evsel,
0817                      struct addr_location *al,
0818                      struct addr_location *addr_al,
0819                      PyObject *callchain)
0820 {
0821     PyObject *dict, *dict_sample, *brstack, *brstacksym;
0822 
0823     dict = PyDict_New();
0824     if (!dict)
0825         Py_FatalError("couldn't create Python dictionary");
0826 
0827     dict_sample = PyDict_New();
0828     if (!dict_sample)
0829         Py_FatalError("couldn't create Python dictionary");
0830 
0831     pydict_set_item_string_decref(dict, "ev_name", _PyUnicode_FromString(evsel__name(evsel)));
0832     pydict_set_item_string_decref(dict, "attr", _PyBytes_FromStringAndSize((const char *)&evsel->core.attr, sizeof(evsel->core.attr)));
0833 
0834     pydict_set_item_string_decref(dict_sample, "pid",
0835             _PyLong_FromLong(sample->pid));
0836     pydict_set_item_string_decref(dict_sample, "tid",
0837             _PyLong_FromLong(sample->tid));
0838     pydict_set_item_string_decref(dict_sample, "cpu",
0839             _PyLong_FromLong(sample->cpu));
0840     pydict_set_item_string_decref(dict_sample, "ip",
0841             PyLong_FromUnsignedLongLong(sample->ip));
0842     pydict_set_item_string_decref(dict_sample, "time",
0843             PyLong_FromUnsignedLongLong(sample->time));
0844     pydict_set_item_string_decref(dict_sample, "period",
0845             PyLong_FromUnsignedLongLong(sample->period));
0846     pydict_set_item_string_decref(dict_sample, "phys_addr",
0847             PyLong_FromUnsignedLongLong(sample->phys_addr));
0848     pydict_set_item_string_decref(dict_sample, "addr",
0849             PyLong_FromUnsignedLongLong(sample->addr));
0850     set_sample_read_in_dict(dict_sample, sample, evsel);
0851     pydict_set_item_string_decref(dict_sample, "weight",
0852             PyLong_FromUnsignedLongLong(sample->weight));
0853     pydict_set_item_string_decref(dict_sample, "transaction",
0854             PyLong_FromUnsignedLongLong(sample->transaction));
0855     set_sample_datasrc_in_dict(dict_sample, sample);
0856     pydict_set_item_string_decref(dict, "sample", dict_sample);
0857 
0858     pydict_set_item_string_decref(dict, "raw_buf", _PyBytes_FromStringAndSize(
0859             (const char *)sample->raw_data, sample->raw_size));
0860     pydict_set_item_string_decref(dict, "comm",
0861             _PyUnicode_FromString(thread__comm_str(al->thread)));
0862     set_sym_in_dict(dict, al, "dso", "dso_bid", "dso_map_start", "dso_map_end",
0863             "symbol", "symoff");
0864 
0865     pydict_set_item_string_decref(dict, "callchain", callchain);
0866 
0867     brstack = python_process_brstack(sample, al->thread);
0868     pydict_set_item_string_decref(dict, "brstack", brstack);
0869 
0870     brstacksym = python_process_brstacksym(sample, al->thread);
0871     pydict_set_item_string_decref(dict, "brstacksym", brstacksym);
0872 
0873     if (sample->machine_pid) {
0874         pydict_set_item_string_decref(dict_sample, "machine_pid",
0875                 _PyLong_FromLong(sample->machine_pid));
0876         pydict_set_item_string_decref(dict_sample, "vcpu",
0877                 _PyLong_FromLong(sample->vcpu));
0878     }
0879 
0880     pydict_set_item_string_decref(dict_sample, "cpumode",
0881             _PyLong_FromLong((unsigned long)sample->cpumode));
0882 
0883     if (addr_al) {
0884         pydict_set_item_string_decref(dict_sample, "addr_correlates_sym",
0885             PyBool_FromLong(1));
0886         set_sym_in_dict(dict_sample, addr_al, "addr_dso", "addr_dso_bid",
0887                 "addr_dso_map_start", "addr_dso_map_end",
0888                 "addr_symbol", "addr_symoff");
0889     }
0890 
0891     if (sample->flags)
0892         python_process_sample_flags(sample, dict_sample);
0893 
0894     /* Instructions per cycle (IPC) */
0895     if (sample->insn_cnt && sample->cyc_cnt) {
0896         pydict_set_item_string_decref(dict_sample, "insn_cnt",
0897             PyLong_FromUnsignedLongLong(sample->insn_cnt));
0898         pydict_set_item_string_decref(dict_sample, "cyc_cnt",
0899             PyLong_FromUnsignedLongLong(sample->cyc_cnt));
0900     }
0901 
0902     set_regs_in_dict(dict, sample, evsel);
0903 
0904     return dict;
0905 }
0906 
0907 static void python_process_tracepoint(struct perf_sample *sample,
0908                       struct evsel *evsel,
0909                       struct addr_location *al,
0910                       struct addr_location *addr_al)
0911 {
0912     struct tep_event *event = evsel->tp_format;
0913     PyObject *handler, *context, *t, *obj = NULL, *callchain;
0914     PyObject *dict = NULL, *all_entries_dict = NULL;
0915     static char handler_name[256];
0916     struct tep_format_field *field;
0917     unsigned long s, ns;
0918     unsigned n = 0;
0919     int pid;
0920     int cpu = sample->cpu;
0921     void *data = sample->raw_data;
0922     unsigned long long nsecs = sample->time;
0923     const char *comm = thread__comm_str(al->thread);
0924     const char *default_handler_name = "trace_unhandled";
0925 
0926     if (!event) {
0927         snprintf(handler_name, sizeof(handler_name),
0928              "ug! no event found for type %" PRIu64, (u64)evsel->core.attr.config);
0929         Py_FatalError(handler_name);
0930     }
0931 
0932     pid = raw_field_value(event, "common_pid", data);
0933 
0934     sprintf(handler_name, "%s__%s", event->system, event->name);
0935 
0936     if (!test_and_set_bit(event->id, events_defined))
0937         define_event_symbols(event, handler_name, event->print_fmt.args);
0938 
0939     handler = get_handler(handler_name);
0940     if (!handler) {
0941         handler = get_handler(default_handler_name);
0942         if (!handler)
0943             return;
0944         dict = PyDict_New();
0945         if (!dict)
0946             Py_FatalError("couldn't create Python dict");
0947     }
0948 
0949     t = PyTuple_New(MAX_FIELDS);
0950     if (!t)
0951         Py_FatalError("couldn't create Python tuple");
0952 
0953 
0954     s = nsecs / NSEC_PER_SEC;
0955     ns = nsecs - s * NSEC_PER_SEC;
0956 
0957     context = _PyCapsule_New(scripting_context, NULL, NULL);
0958 
0959     PyTuple_SetItem(t, n++, _PyUnicode_FromString(handler_name));
0960     PyTuple_SetItem(t, n++, context);
0961 
0962     /* ip unwinding */
0963     callchain = python_process_callchain(sample, evsel, al);
0964     /* Need an additional reference for the perf_sample dict */
0965     Py_INCREF(callchain);
0966 
0967     if (!dict) {
0968         PyTuple_SetItem(t, n++, _PyLong_FromLong(cpu));
0969         PyTuple_SetItem(t, n++, _PyLong_FromLong(s));
0970         PyTuple_SetItem(t, n++, _PyLong_FromLong(ns));
0971         PyTuple_SetItem(t, n++, _PyLong_FromLong(pid));
0972         PyTuple_SetItem(t, n++, _PyUnicode_FromString(comm));
0973         PyTuple_SetItem(t, n++, callchain);
0974     } else {
0975         pydict_set_item_string_decref(dict, "common_cpu", _PyLong_FromLong(cpu));
0976         pydict_set_item_string_decref(dict, "common_s", _PyLong_FromLong(s));
0977         pydict_set_item_string_decref(dict, "common_ns", _PyLong_FromLong(ns));
0978         pydict_set_item_string_decref(dict, "common_pid", _PyLong_FromLong(pid));
0979         pydict_set_item_string_decref(dict, "common_comm", _PyUnicode_FromString(comm));
0980         pydict_set_item_string_decref(dict, "common_callchain", callchain);
0981     }
0982     for (field = event->format.fields; field; field = field->next) {
0983         unsigned int offset, len;
0984         unsigned long long val;
0985 
0986         if (field->flags & TEP_FIELD_IS_ARRAY) {
0987             offset = field->offset;
0988             len    = field->size;
0989             if (field->flags & TEP_FIELD_IS_DYNAMIC) {
0990                 val     = tep_read_number(scripting_context->pevent,
0991                               data + offset, len);
0992                 offset  = val;
0993                 len     = offset >> 16;
0994                 offset &= 0xffff;
0995                 if (field->flags & TEP_FIELD_IS_RELATIVE)
0996                     offset += field->offset + field->size;
0997             }
0998             if (field->flags & TEP_FIELD_IS_STRING &&
0999                 is_printable_array(data + offset, len)) {
1000                 obj = _PyUnicode_FromString((char *) data + offset);
1001             } else {
1002                 obj = PyByteArray_FromStringAndSize((const char *) data + offset, len);
1003                 field->flags &= ~TEP_FIELD_IS_STRING;
1004             }
1005         } else { /* FIELD_IS_NUMERIC */
1006             obj = get_field_numeric_entry(event, field, data);
1007         }
1008         if (!dict)
1009             PyTuple_SetItem(t, n++, obj);
1010         else
1011             pydict_set_item_string_decref(dict, field->name, obj);
1012 
1013     }
1014 
1015     if (dict)
1016         PyTuple_SetItem(t, n++, dict);
1017 
1018     if (get_argument_count(handler) == (int) n + 1) {
1019         all_entries_dict = get_perf_sample_dict(sample, evsel, al, addr_al,
1020             callchain);
1021         PyTuple_SetItem(t, n++, all_entries_dict);
1022     } else {
1023         Py_DECREF(callchain);
1024     }
1025 
1026     if (_PyTuple_Resize(&t, n) == -1)
1027         Py_FatalError("error resizing Python tuple");
1028 
1029     if (!dict)
1030         call_object(handler, t, handler_name);
1031     else
1032         call_object(handler, t, default_handler_name);
1033 
1034     Py_DECREF(t);
1035 }
1036 
1037 static PyObject *tuple_new(unsigned int sz)
1038 {
1039     PyObject *t;
1040 
1041     t = PyTuple_New(sz);
1042     if (!t)
1043         Py_FatalError("couldn't create Python tuple");
1044     return t;
1045 }
1046 
1047 static int tuple_set_s64(PyObject *t, unsigned int pos, s64 val)
1048 {
1049 #if BITS_PER_LONG == 64
1050     return PyTuple_SetItem(t, pos, _PyLong_FromLong(val));
1051 #endif
1052 #if BITS_PER_LONG == 32
1053     return PyTuple_SetItem(t, pos, PyLong_FromLongLong(val));
1054 #endif
1055 }
1056 
1057 /*
1058  * Databases support only signed 64-bit numbers, so even though we are
1059  * exporting a u64, it must be as s64.
1060  */
1061 #define tuple_set_d64 tuple_set_s64
1062 
1063 static int tuple_set_u64(PyObject *t, unsigned int pos, u64 val)
1064 {
1065 #if BITS_PER_LONG == 64
1066     return PyTuple_SetItem(t, pos, PyLong_FromUnsignedLong(val));
1067 #endif
1068 #if BITS_PER_LONG == 32
1069     return PyTuple_SetItem(t, pos, PyLong_FromUnsignedLongLong(val));
1070 #endif
1071 }
1072 
1073 static int tuple_set_u32(PyObject *t, unsigned int pos, u32 val)
1074 {
1075     return PyTuple_SetItem(t, pos, PyLong_FromUnsignedLong(val));
1076 }
1077 
1078 static int tuple_set_s32(PyObject *t, unsigned int pos, s32 val)
1079 {
1080     return PyTuple_SetItem(t, pos, _PyLong_FromLong(val));
1081 }
1082 
1083 static int tuple_set_bool(PyObject *t, unsigned int pos, bool val)
1084 {
1085     return PyTuple_SetItem(t, pos, PyBool_FromLong(val));
1086 }
1087 
1088 static int tuple_set_string(PyObject *t, unsigned int pos, const char *s)
1089 {
1090     return PyTuple_SetItem(t, pos, _PyUnicode_FromString(s));
1091 }
1092 
1093 static int tuple_set_bytes(PyObject *t, unsigned int pos, void *bytes,
1094                unsigned int sz)
1095 {
1096     return PyTuple_SetItem(t, pos, _PyBytes_FromStringAndSize(bytes, sz));
1097 }
1098 
1099 static int python_export_evsel(struct db_export *dbe, struct evsel *evsel)
1100 {
1101     struct tables *tables = container_of(dbe, struct tables, dbe);
1102     PyObject *t;
1103 
1104     t = tuple_new(2);
1105 
1106     tuple_set_d64(t, 0, evsel->db_id);
1107     tuple_set_string(t, 1, evsel__name(evsel));
1108 
1109     call_object(tables->evsel_handler, t, "evsel_table");
1110 
1111     Py_DECREF(t);
1112 
1113     return 0;
1114 }
1115 
1116 static int python_export_machine(struct db_export *dbe,
1117                  struct machine *machine)
1118 {
1119     struct tables *tables = container_of(dbe, struct tables, dbe);
1120     PyObject *t;
1121 
1122     t = tuple_new(3);
1123 
1124     tuple_set_d64(t, 0, machine->db_id);
1125     tuple_set_s32(t, 1, machine->pid);
1126     tuple_set_string(t, 2, machine->root_dir ? machine->root_dir : "");
1127 
1128     call_object(tables->machine_handler, t, "machine_table");
1129 
1130     Py_DECREF(t);
1131 
1132     return 0;
1133 }
1134 
1135 static int python_export_thread(struct db_export *dbe, struct thread *thread,
1136                 u64 main_thread_db_id, struct machine *machine)
1137 {
1138     struct tables *tables = container_of(dbe, struct tables, dbe);
1139     PyObject *t;
1140 
1141     t = tuple_new(5);
1142 
1143     tuple_set_d64(t, 0, thread->db_id);
1144     tuple_set_d64(t, 1, machine->db_id);
1145     tuple_set_d64(t, 2, main_thread_db_id);
1146     tuple_set_s32(t, 3, thread->pid_);
1147     tuple_set_s32(t, 4, thread->tid);
1148 
1149     call_object(tables->thread_handler, t, "thread_table");
1150 
1151     Py_DECREF(t);
1152 
1153     return 0;
1154 }
1155 
1156 static int python_export_comm(struct db_export *dbe, struct comm *comm,
1157                   struct thread *thread)
1158 {
1159     struct tables *tables = container_of(dbe, struct tables, dbe);
1160     PyObject *t;
1161 
1162     t = tuple_new(5);
1163 
1164     tuple_set_d64(t, 0, comm->db_id);
1165     tuple_set_string(t, 1, comm__str(comm));
1166     tuple_set_d64(t, 2, thread->db_id);
1167     tuple_set_d64(t, 3, comm->start);
1168     tuple_set_s32(t, 4, comm->exec);
1169 
1170     call_object(tables->comm_handler, t, "comm_table");
1171 
1172     Py_DECREF(t);
1173 
1174     return 0;
1175 }
1176 
1177 static int python_export_comm_thread(struct db_export *dbe, u64 db_id,
1178                      struct comm *comm, struct thread *thread)
1179 {
1180     struct tables *tables = container_of(dbe, struct tables, dbe);
1181     PyObject *t;
1182 
1183     t = tuple_new(3);
1184 
1185     tuple_set_d64(t, 0, db_id);
1186     tuple_set_d64(t, 1, comm->db_id);
1187     tuple_set_d64(t, 2, thread->db_id);
1188 
1189     call_object(tables->comm_thread_handler, t, "comm_thread_table");
1190 
1191     Py_DECREF(t);
1192 
1193     return 0;
1194 }
1195 
1196 static int python_export_dso(struct db_export *dbe, struct dso *dso,
1197                  struct machine *machine)
1198 {
1199     struct tables *tables = container_of(dbe, struct tables, dbe);
1200     char sbuild_id[SBUILD_ID_SIZE];
1201     PyObject *t;
1202 
1203     build_id__sprintf(&dso->bid, sbuild_id);
1204 
1205     t = tuple_new(5);
1206 
1207     tuple_set_d64(t, 0, dso->db_id);
1208     tuple_set_d64(t, 1, machine->db_id);
1209     tuple_set_string(t, 2, dso->short_name);
1210     tuple_set_string(t, 3, dso->long_name);
1211     tuple_set_string(t, 4, sbuild_id);
1212 
1213     call_object(tables->dso_handler, t, "dso_table");
1214 
1215     Py_DECREF(t);
1216 
1217     return 0;
1218 }
1219 
1220 static int python_export_symbol(struct db_export *dbe, struct symbol *sym,
1221                 struct dso *dso)
1222 {
1223     struct tables *tables = container_of(dbe, struct tables, dbe);
1224     u64 *sym_db_id = symbol__priv(sym);
1225     PyObject *t;
1226 
1227     t = tuple_new(6);
1228 
1229     tuple_set_d64(t, 0, *sym_db_id);
1230     tuple_set_d64(t, 1, dso->db_id);
1231     tuple_set_d64(t, 2, sym->start);
1232     tuple_set_d64(t, 3, sym->end);
1233     tuple_set_s32(t, 4, sym->binding);
1234     tuple_set_string(t, 5, sym->name);
1235 
1236     call_object(tables->symbol_handler, t, "symbol_table");
1237 
1238     Py_DECREF(t);
1239 
1240     return 0;
1241 }
1242 
1243 static int python_export_branch_type(struct db_export *dbe, u32 branch_type,
1244                      const char *name)
1245 {
1246     struct tables *tables = container_of(dbe, struct tables, dbe);
1247     PyObject *t;
1248 
1249     t = tuple_new(2);
1250 
1251     tuple_set_s32(t, 0, branch_type);
1252     tuple_set_string(t, 1, name);
1253 
1254     call_object(tables->branch_type_handler, t, "branch_type_table");
1255 
1256     Py_DECREF(t);
1257 
1258     return 0;
1259 }
1260 
1261 static void python_export_sample_table(struct db_export *dbe,
1262                        struct export_sample *es)
1263 {
1264     struct tables *tables = container_of(dbe, struct tables, dbe);
1265     PyObject *t;
1266 
1267     t = tuple_new(25);
1268 
1269     tuple_set_d64(t, 0, es->db_id);
1270     tuple_set_d64(t, 1, es->evsel->db_id);
1271     tuple_set_d64(t, 2, es->al->maps->machine->db_id);
1272     tuple_set_d64(t, 3, es->al->thread->db_id);
1273     tuple_set_d64(t, 4, es->comm_db_id);
1274     tuple_set_d64(t, 5, es->dso_db_id);
1275     tuple_set_d64(t, 6, es->sym_db_id);
1276     tuple_set_d64(t, 7, es->offset);
1277     tuple_set_d64(t, 8, es->sample->ip);
1278     tuple_set_d64(t, 9, es->sample->time);
1279     tuple_set_s32(t, 10, es->sample->cpu);
1280     tuple_set_d64(t, 11, es->addr_dso_db_id);
1281     tuple_set_d64(t, 12, es->addr_sym_db_id);
1282     tuple_set_d64(t, 13, es->addr_offset);
1283     tuple_set_d64(t, 14, es->sample->addr);
1284     tuple_set_d64(t, 15, es->sample->period);
1285     tuple_set_d64(t, 16, es->sample->weight);
1286     tuple_set_d64(t, 17, es->sample->transaction);
1287     tuple_set_d64(t, 18, es->sample->data_src);
1288     tuple_set_s32(t, 19, es->sample->flags & PERF_BRANCH_MASK);
1289     tuple_set_s32(t, 20, !!(es->sample->flags & PERF_IP_FLAG_IN_TX));
1290     tuple_set_d64(t, 21, es->call_path_id);
1291     tuple_set_d64(t, 22, es->sample->insn_cnt);
1292     tuple_set_d64(t, 23, es->sample->cyc_cnt);
1293     tuple_set_s32(t, 24, es->sample->flags);
1294 
1295     call_object(tables->sample_handler, t, "sample_table");
1296 
1297     Py_DECREF(t);
1298 }
1299 
1300 static void python_export_synth(struct db_export *dbe, struct export_sample *es)
1301 {
1302     struct tables *tables = container_of(dbe, struct tables, dbe);
1303     PyObject *t;
1304 
1305     t = tuple_new(3);
1306 
1307     tuple_set_d64(t, 0, es->db_id);
1308     tuple_set_d64(t, 1, es->evsel->core.attr.config);
1309     tuple_set_bytes(t, 2, es->sample->raw_data, es->sample->raw_size);
1310 
1311     call_object(tables->synth_handler, t, "synth_data");
1312 
1313     Py_DECREF(t);
1314 }
1315 
1316 static int python_export_sample(struct db_export *dbe,
1317                 struct export_sample *es)
1318 {
1319     struct tables *tables = container_of(dbe, struct tables, dbe);
1320 
1321     python_export_sample_table(dbe, es);
1322 
1323     if (es->evsel->core.attr.type == PERF_TYPE_SYNTH && tables->synth_handler)
1324         python_export_synth(dbe, es);
1325 
1326     return 0;
1327 }
1328 
1329 static int python_export_call_path(struct db_export *dbe, struct call_path *cp)
1330 {
1331     struct tables *tables = container_of(dbe, struct tables, dbe);
1332     PyObject *t;
1333     u64 parent_db_id, sym_db_id;
1334 
1335     parent_db_id = cp->parent ? cp->parent->db_id : 0;
1336     sym_db_id = cp->sym ? *(u64 *)symbol__priv(cp->sym) : 0;
1337 
1338     t = tuple_new(4);
1339 
1340     tuple_set_d64(t, 0, cp->db_id);
1341     tuple_set_d64(t, 1, parent_db_id);
1342     tuple_set_d64(t, 2, sym_db_id);
1343     tuple_set_d64(t, 3, cp->ip);
1344 
1345     call_object(tables->call_path_handler, t, "call_path_table");
1346 
1347     Py_DECREF(t);
1348 
1349     return 0;
1350 }
1351 
1352 static int python_export_call_return(struct db_export *dbe,
1353                      struct call_return *cr)
1354 {
1355     struct tables *tables = container_of(dbe, struct tables, dbe);
1356     u64 comm_db_id = cr->comm ? cr->comm->db_id : 0;
1357     PyObject *t;
1358 
1359     t = tuple_new(14);
1360 
1361     tuple_set_d64(t, 0, cr->db_id);
1362     tuple_set_d64(t, 1, cr->thread->db_id);
1363     tuple_set_d64(t, 2, comm_db_id);
1364     tuple_set_d64(t, 3, cr->cp->db_id);
1365     tuple_set_d64(t, 4, cr->call_time);
1366     tuple_set_d64(t, 5, cr->return_time);
1367     tuple_set_d64(t, 6, cr->branch_count);
1368     tuple_set_d64(t, 7, cr->call_ref);
1369     tuple_set_d64(t, 8, cr->return_ref);
1370     tuple_set_d64(t, 9, cr->cp->parent->db_id);
1371     tuple_set_s32(t, 10, cr->flags);
1372     tuple_set_d64(t, 11, cr->parent_db_id);
1373     tuple_set_d64(t, 12, cr->insn_count);
1374     tuple_set_d64(t, 13, cr->cyc_count);
1375 
1376     call_object(tables->call_return_handler, t, "call_return_table");
1377 
1378     Py_DECREF(t);
1379 
1380     return 0;
1381 }
1382 
1383 static int python_export_context_switch(struct db_export *dbe, u64 db_id,
1384                     struct machine *machine,
1385                     struct perf_sample *sample,
1386                     u64 th_out_id, u64 comm_out_id,
1387                     u64 th_in_id, u64 comm_in_id, int flags)
1388 {
1389     struct tables *tables = container_of(dbe, struct tables, dbe);
1390     PyObject *t;
1391 
1392     t = tuple_new(9);
1393 
1394     tuple_set_d64(t, 0, db_id);
1395     tuple_set_d64(t, 1, machine->db_id);
1396     tuple_set_d64(t, 2, sample->time);
1397     tuple_set_s32(t, 3, sample->cpu);
1398     tuple_set_d64(t, 4, th_out_id);
1399     tuple_set_d64(t, 5, comm_out_id);
1400     tuple_set_d64(t, 6, th_in_id);
1401     tuple_set_d64(t, 7, comm_in_id);
1402     tuple_set_s32(t, 8, flags);
1403 
1404     call_object(tables->context_switch_handler, t, "context_switch");
1405 
1406     Py_DECREF(t);
1407 
1408     return 0;
1409 }
1410 
1411 static int python_process_call_return(struct call_return *cr, u64 *parent_db_id,
1412                       void *data)
1413 {
1414     struct db_export *dbe = data;
1415 
1416     return db_export__call_return(dbe, cr, parent_db_id);
1417 }
1418 
1419 static void python_process_general_event(struct perf_sample *sample,
1420                      struct evsel *evsel,
1421                      struct addr_location *al,
1422                      struct addr_location *addr_al)
1423 {
1424     PyObject *handler, *t, *dict, *callchain;
1425     static char handler_name[64];
1426     unsigned n = 0;
1427 
1428     snprintf(handler_name, sizeof(handler_name), "%s", "process_event");
1429 
1430     handler = get_handler(handler_name);
1431     if (!handler)
1432         return;
1433 
1434     /*
1435      * Use the MAX_FIELDS to make the function expandable, though
1436      * currently there is only one item for the tuple.
1437      */
1438     t = PyTuple_New(MAX_FIELDS);
1439     if (!t)
1440         Py_FatalError("couldn't create Python tuple");
1441 
1442     /* ip unwinding */
1443     callchain = python_process_callchain(sample, evsel, al);
1444     dict = get_perf_sample_dict(sample, evsel, al, addr_al, callchain);
1445 
1446     PyTuple_SetItem(t, n++, dict);
1447     if (_PyTuple_Resize(&t, n) == -1)
1448         Py_FatalError("error resizing Python tuple");
1449 
1450     call_object(handler, t, handler_name);
1451 
1452     Py_DECREF(t);
1453 }
1454 
1455 static void python_process_event(union perf_event *event,
1456                  struct perf_sample *sample,
1457                  struct evsel *evsel,
1458                  struct addr_location *al,
1459                  struct addr_location *addr_al)
1460 {
1461     struct tables *tables = &tables_global;
1462 
1463     scripting_context__update(scripting_context, event, sample, evsel, al, addr_al);
1464 
1465     switch (evsel->core.attr.type) {
1466     case PERF_TYPE_TRACEPOINT:
1467         python_process_tracepoint(sample, evsel, al, addr_al);
1468         break;
1469     /* Reserve for future process_hw/sw/raw APIs */
1470     default:
1471         if (tables->db_export_mode)
1472             db_export__sample(&tables->dbe, event, sample, evsel, al, addr_al);
1473         else
1474             python_process_general_event(sample, evsel, al, addr_al);
1475     }
1476 }
1477 
1478 static void python_process_throttle(union perf_event *event,
1479                     struct perf_sample *sample,
1480                     struct machine *machine)
1481 {
1482     const char *handler_name;
1483     PyObject *handler, *t;
1484 
1485     if (event->header.type == PERF_RECORD_THROTTLE)
1486         handler_name = "throttle";
1487     else
1488         handler_name = "unthrottle";
1489     handler = get_handler(handler_name);
1490     if (!handler)
1491         return;
1492 
1493     t = tuple_new(6);
1494     if (!t)
1495         return;
1496 
1497     tuple_set_u64(t, 0, event->throttle.time);
1498     tuple_set_u64(t, 1, event->throttle.id);
1499     tuple_set_u64(t, 2, event->throttle.stream_id);
1500     tuple_set_s32(t, 3, sample->cpu);
1501     tuple_set_s32(t, 4, sample->pid);
1502     tuple_set_s32(t, 5, sample->tid);
1503 
1504     call_object(handler, t, handler_name);
1505 
1506     Py_DECREF(t);
1507 }
1508 
1509 static void python_do_process_switch(union perf_event *event,
1510                      struct perf_sample *sample,
1511                      struct machine *machine)
1512 {
1513     const char *handler_name = "context_switch";
1514     bool out = event->header.misc & PERF_RECORD_MISC_SWITCH_OUT;
1515     bool out_preempt = out && (event->header.misc & PERF_RECORD_MISC_SWITCH_OUT_PREEMPT);
1516     pid_t np_pid = -1, np_tid = -1;
1517     PyObject *handler, *t;
1518 
1519     handler = get_handler(handler_name);
1520     if (!handler)
1521         return;
1522 
1523     if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) {
1524         np_pid = event->context_switch.next_prev_pid;
1525         np_tid = event->context_switch.next_prev_tid;
1526     }
1527 
1528     t = tuple_new(11);
1529     if (!t)
1530         return;
1531 
1532     tuple_set_u64(t, 0, sample->time);
1533     tuple_set_s32(t, 1, sample->cpu);
1534     tuple_set_s32(t, 2, sample->pid);
1535     tuple_set_s32(t, 3, sample->tid);
1536     tuple_set_s32(t, 4, np_pid);
1537     tuple_set_s32(t, 5, np_tid);
1538     tuple_set_s32(t, 6, machine->pid);
1539     tuple_set_bool(t, 7, out);
1540     tuple_set_bool(t, 8, out_preempt);
1541     tuple_set_s32(t, 9, sample->machine_pid);
1542     tuple_set_s32(t, 10, sample->vcpu);
1543 
1544     call_object(handler, t, handler_name);
1545 
1546     Py_DECREF(t);
1547 }
1548 
1549 static void python_process_switch(union perf_event *event,
1550                   struct perf_sample *sample,
1551                   struct machine *machine)
1552 {
1553     struct tables *tables = &tables_global;
1554 
1555     if (tables->db_export_mode)
1556         db_export__switch(&tables->dbe, event, sample, machine);
1557     else
1558         python_do_process_switch(event, sample, machine);
1559 }
1560 
1561 static void python_process_auxtrace_error(struct perf_session *session __maybe_unused,
1562                       union perf_event *event)
1563 {
1564     struct perf_record_auxtrace_error *e = &event->auxtrace_error;
1565     u8 cpumode = e->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1566     const char *handler_name = "auxtrace_error";
1567     unsigned long long tm = e->time;
1568     const char *msg = e->msg;
1569     PyObject *handler, *t;
1570 
1571     handler = get_handler(handler_name);
1572     if (!handler)
1573         return;
1574 
1575     if (!e->fmt) {
1576         tm = 0;
1577         msg = (const char *)&e->time;
1578     }
1579 
1580     t = tuple_new(11);
1581 
1582     tuple_set_u32(t, 0, e->type);
1583     tuple_set_u32(t, 1, e->code);
1584     tuple_set_s32(t, 2, e->cpu);
1585     tuple_set_s32(t, 3, e->pid);
1586     tuple_set_s32(t, 4, e->tid);
1587     tuple_set_u64(t, 5, e->ip);
1588     tuple_set_u64(t, 6, tm);
1589     tuple_set_string(t, 7, msg);
1590     tuple_set_u32(t, 8, cpumode);
1591     tuple_set_s32(t, 9, e->machine_pid);
1592     tuple_set_s32(t, 10, e->vcpu);
1593 
1594     call_object(handler, t, handler_name);
1595 
1596     Py_DECREF(t);
1597 }
1598 
1599 static void get_handler_name(char *str, size_t size,
1600                  struct evsel *evsel)
1601 {
1602     char *p = str;
1603 
1604     scnprintf(str, size, "stat__%s", evsel__name(evsel));
1605 
1606     while ((p = strchr(p, ':'))) {
1607         *p = '_';
1608         p++;
1609     }
1610 }
1611 
1612 static void
1613 process_stat(struct evsel *counter, struct perf_cpu cpu, int thread, u64 tstamp,
1614          struct perf_counts_values *count)
1615 {
1616     PyObject *handler, *t;
1617     static char handler_name[256];
1618     int n = 0;
1619 
1620     t = PyTuple_New(MAX_FIELDS);
1621     if (!t)
1622         Py_FatalError("couldn't create Python tuple");
1623 
1624     get_handler_name(handler_name, sizeof(handler_name),
1625              counter);
1626 
1627     handler = get_handler(handler_name);
1628     if (!handler) {
1629         pr_debug("can't find python handler %s\n", handler_name);
1630         return;
1631     }
1632 
1633     PyTuple_SetItem(t, n++, _PyLong_FromLong(cpu.cpu));
1634     PyTuple_SetItem(t, n++, _PyLong_FromLong(thread));
1635 
1636     tuple_set_u64(t, n++, tstamp);
1637     tuple_set_u64(t, n++, count->val);
1638     tuple_set_u64(t, n++, count->ena);
1639     tuple_set_u64(t, n++, count->run);
1640 
1641     if (_PyTuple_Resize(&t, n) == -1)
1642         Py_FatalError("error resizing Python tuple");
1643 
1644     call_object(handler, t, handler_name);
1645 
1646     Py_DECREF(t);
1647 }
1648 
1649 static void python_process_stat(struct perf_stat_config *config,
1650                 struct evsel *counter, u64 tstamp)
1651 {
1652     struct perf_thread_map *threads = counter->core.threads;
1653     struct perf_cpu_map *cpus = counter->core.cpus;
1654     int cpu, thread;
1655 
1656     if (config->aggr_mode == AGGR_GLOBAL) {
1657         process_stat(counter, (struct perf_cpu){ .cpu = -1 }, -1, tstamp,
1658                  &counter->counts->aggr);
1659         return;
1660     }
1661 
1662     for (thread = 0; thread < threads->nr; thread++) {
1663         for (cpu = 0; cpu < perf_cpu_map__nr(cpus); cpu++) {
1664             process_stat(counter, perf_cpu_map__cpu(cpus, cpu),
1665                      perf_thread_map__pid(threads, thread), tstamp,
1666                      perf_counts(counter->counts, cpu, thread));
1667         }
1668     }
1669 }
1670 
1671 static void python_process_stat_interval(u64 tstamp)
1672 {
1673     PyObject *handler, *t;
1674     static const char handler_name[] = "stat__interval";
1675     int n = 0;
1676 
1677     t = PyTuple_New(MAX_FIELDS);
1678     if (!t)
1679         Py_FatalError("couldn't create Python tuple");
1680 
1681     handler = get_handler(handler_name);
1682     if (!handler) {
1683         pr_debug("can't find python handler %s\n", handler_name);
1684         return;
1685     }
1686 
1687     tuple_set_u64(t, n++, tstamp);
1688 
1689     if (_PyTuple_Resize(&t, n) == -1)
1690         Py_FatalError("error resizing Python tuple");
1691 
1692     call_object(handler, t, handler_name);
1693 
1694     Py_DECREF(t);
1695 }
1696 
1697 static int perf_script_context_init(void)
1698 {
1699     PyObject *perf_script_context;
1700     PyObject *perf_trace_context;
1701     PyObject *dict;
1702     int ret;
1703 
1704     perf_trace_context = PyImport_AddModule("perf_trace_context");
1705     if (!perf_trace_context)
1706         return -1;
1707     dict = PyModule_GetDict(perf_trace_context);
1708     if (!dict)
1709         return -1;
1710 
1711     perf_script_context = _PyCapsule_New(scripting_context, NULL, NULL);
1712     if (!perf_script_context)
1713         return -1;
1714 
1715     ret = PyDict_SetItemString(dict, "perf_script_context", perf_script_context);
1716     if (!ret)
1717         ret = PyDict_SetItemString(main_dict, "perf_script_context", perf_script_context);
1718     Py_DECREF(perf_script_context);
1719     return ret;
1720 }
1721 
1722 static int run_start_sub(void)
1723 {
1724     main_module = PyImport_AddModule("__main__");
1725     if (main_module == NULL)
1726         return -1;
1727     Py_INCREF(main_module);
1728 
1729     main_dict = PyModule_GetDict(main_module);
1730     if (main_dict == NULL)
1731         goto error;
1732     Py_INCREF(main_dict);
1733 
1734     if (perf_script_context_init())
1735         goto error;
1736 
1737     try_call_object("trace_begin", NULL);
1738 
1739     return 0;
1740 
1741 error:
1742     Py_XDECREF(main_dict);
1743     Py_XDECREF(main_module);
1744     return -1;
1745 }
1746 
1747 #define SET_TABLE_HANDLER_(name, handler_name, table_name) do {     \
1748     tables->handler_name = get_handler(#table_name);        \
1749     if (tables->handler_name)                   \
1750         tables->dbe.export_ ## name = python_export_ ## name;   \
1751 } while (0)
1752 
1753 #define SET_TABLE_HANDLER(name) \
1754     SET_TABLE_HANDLER_(name, name ## _handler, name ## _table)
1755 
1756 static void set_table_handlers(struct tables *tables)
1757 {
1758     const char *perf_db_export_mode = "perf_db_export_mode";
1759     const char *perf_db_export_calls = "perf_db_export_calls";
1760     const char *perf_db_export_callchains = "perf_db_export_callchains";
1761     PyObject *db_export_mode, *db_export_calls, *db_export_callchains;
1762     bool export_calls = false;
1763     bool export_callchains = false;
1764     int ret;
1765 
1766     memset(tables, 0, sizeof(struct tables));
1767     if (db_export__init(&tables->dbe))
1768         Py_FatalError("failed to initialize export");
1769 
1770     db_export_mode = PyDict_GetItemString(main_dict, perf_db_export_mode);
1771     if (!db_export_mode)
1772         return;
1773 
1774     ret = PyObject_IsTrue(db_export_mode);
1775     if (ret == -1)
1776         handler_call_die(perf_db_export_mode);
1777     if (!ret)
1778         return;
1779 
1780     /* handle export calls */
1781     tables->dbe.crp = NULL;
1782     db_export_calls = PyDict_GetItemString(main_dict, perf_db_export_calls);
1783     if (db_export_calls) {
1784         ret = PyObject_IsTrue(db_export_calls);
1785         if (ret == -1)
1786             handler_call_die(perf_db_export_calls);
1787         export_calls = !!ret;
1788     }
1789 
1790     if (export_calls) {
1791         tables->dbe.crp =
1792             call_return_processor__new(python_process_call_return,
1793                            &tables->dbe);
1794         if (!tables->dbe.crp)
1795             Py_FatalError("failed to create calls processor");
1796     }
1797 
1798     /* handle export callchains */
1799     tables->dbe.cpr = NULL;
1800     db_export_callchains = PyDict_GetItemString(main_dict,
1801                             perf_db_export_callchains);
1802     if (db_export_callchains) {
1803         ret = PyObject_IsTrue(db_export_callchains);
1804         if (ret == -1)
1805             handler_call_die(perf_db_export_callchains);
1806         export_callchains = !!ret;
1807     }
1808 
1809     if (export_callchains) {
1810         /*
1811          * Attempt to use the call path root from the call return
1812          * processor, if the call return processor is in use. Otherwise,
1813          * we allocate a new call path root. This prevents exporting
1814          * duplicate call path ids when both are in use simultaneously.
1815          */
1816         if (tables->dbe.crp)
1817             tables->dbe.cpr = tables->dbe.crp->cpr;
1818         else
1819             tables->dbe.cpr = call_path_root__new();
1820 
1821         if (!tables->dbe.cpr)
1822             Py_FatalError("failed to create call path root");
1823     }
1824 
1825     tables->db_export_mode = true;
1826     /*
1827      * Reserve per symbol space for symbol->db_id via symbol__priv()
1828      */
1829     symbol_conf.priv_size = sizeof(u64);
1830 
1831     SET_TABLE_HANDLER(evsel);
1832     SET_TABLE_HANDLER(machine);
1833     SET_TABLE_HANDLER(thread);
1834     SET_TABLE_HANDLER(comm);
1835     SET_TABLE_HANDLER(comm_thread);
1836     SET_TABLE_HANDLER(dso);
1837     SET_TABLE_HANDLER(symbol);
1838     SET_TABLE_HANDLER(branch_type);
1839     SET_TABLE_HANDLER(sample);
1840     SET_TABLE_HANDLER(call_path);
1841     SET_TABLE_HANDLER(call_return);
1842     SET_TABLE_HANDLER(context_switch);
1843 
1844     /*
1845      * Synthesized events are samples but with architecture-specific data
1846      * stored in sample->raw_data. They are exported via
1847      * python_export_sample() and consequently do not need a separate export
1848      * callback.
1849      */
1850     tables->synth_handler = get_handler("synth_data");
1851 }
1852 
1853 #if PY_MAJOR_VERSION < 3
1854 static void _free_command_line(const char **command_line, int num)
1855 {
1856     free(command_line);
1857 }
1858 #else
1859 static void _free_command_line(wchar_t **command_line, int num)
1860 {
1861     int i;
1862     for (i = 0; i < num; i++)
1863         PyMem_RawFree(command_line[i]);
1864     free(command_line);
1865 }
1866 #endif
1867 
1868 
1869 /*
1870  * Start trace script
1871  */
1872 static int python_start_script(const char *script, int argc, const char **argv,
1873                    struct perf_session *session)
1874 {
1875     struct tables *tables = &tables_global;
1876 #if PY_MAJOR_VERSION < 3
1877     const char **command_line;
1878 #else
1879     wchar_t **command_line;
1880 #endif
1881     /*
1882      * Use a non-const name variable to cope with python 2.6's
1883      * PyImport_AppendInittab prototype
1884      */
1885     char buf[PATH_MAX], name[19] = "perf_trace_context";
1886     int i, err = 0;
1887     FILE *fp;
1888 
1889     scripting_context->session = session;
1890 #if PY_MAJOR_VERSION < 3
1891     command_line = malloc((argc + 1) * sizeof(const char *));
1892     command_line[0] = script;
1893     for (i = 1; i < argc + 1; i++)
1894         command_line[i] = argv[i - 1];
1895     PyImport_AppendInittab(name, initperf_trace_context);
1896 #else
1897     command_line = malloc((argc + 1) * sizeof(wchar_t *));
1898     command_line[0] = Py_DecodeLocale(script, NULL);
1899     for (i = 1; i < argc + 1; i++)
1900         command_line[i] = Py_DecodeLocale(argv[i - 1], NULL);
1901     PyImport_AppendInittab(name, PyInit_perf_trace_context);
1902 #endif
1903     Py_Initialize();
1904 
1905 #if PY_MAJOR_VERSION < 3
1906     PySys_SetArgv(argc + 1, (char **)command_line);
1907 #else
1908     PySys_SetArgv(argc + 1, command_line);
1909 #endif
1910 
1911     fp = fopen(script, "r");
1912     if (!fp) {
1913         sprintf(buf, "Can't open python script \"%s\"", script);
1914         perror(buf);
1915         err = -1;
1916         goto error;
1917     }
1918 
1919     err = PyRun_SimpleFile(fp, script);
1920     if (err) {
1921         fprintf(stderr, "Error running python script %s\n", script);
1922         goto error;
1923     }
1924 
1925     err = run_start_sub();
1926     if (err) {
1927         fprintf(stderr, "Error starting python script %s\n", script);
1928         goto error;
1929     }
1930 
1931     set_table_handlers(tables);
1932 
1933     if (tables->db_export_mode) {
1934         err = db_export__branch_types(&tables->dbe);
1935         if (err)
1936             goto error;
1937     }
1938 
1939     _free_command_line(command_line, argc + 1);
1940 
1941     return err;
1942 error:
1943     Py_Finalize();
1944     _free_command_line(command_line, argc + 1);
1945 
1946     return err;
1947 }
1948 
1949 static int python_flush_script(void)
1950 {
1951     return 0;
1952 }
1953 
1954 /*
1955  * Stop trace script
1956  */
1957 static int python_stop_script(void)
1958 {
1959     struct tables *tables = &tables_global;
1960 
1961     try_call_object("trace_end", NULL);
1962 
1963     db_export__exit(&tables->dbe);
1964 
1965     Py_XDECREF(main_dict);
1966     Py_XDECREF(main_module);
1967     Py_Finalize();
1968 
1969     return 0;
1970 }
1971 
1972 static int python_generate_script(struct tep_handle *pevent, const char *outfile)
1973 {
1974     int i, not_first, count, nr_events;
1975     struct tep_event **all_events;
1976     struct tep_event *event = NULL;
1977     struct tep_format_field *f;
1978     char fname[PATH_MAX];
1979     FILE *ofp;
1980 
1981     sprintf(fname, "%s.py", outfile);
1982     ofp = fopen(fname, "w");
1983     if (ofp == NULL) {
1984         fprintf(stderr, "couldn't open %s\n", fname);
1985         return -1;
1986     }
1987     fprintf(ofp, "# perf script event handlers, "
1988         "generated by perf script -g python\n");
1989 
1990     fprintf(ofp, "# Licensed under the terms of the GNU GPL"
1991         " License version 2\n\n");
1992 
1993     fprintf(ofp, "# The common_* event handler fields are the most useful "
1994         "fields common to\n");
1995 
1996     fprintf(ofp, "# all events.  They don't necessarily correspond to "
1997         "the 'common_*' fields\n");
1998 
1999     fprintf(ofp, "# in the format files.  Those fields not available as "
2000         "handler params can\n");
2001 
2002     fprintf(ofp, "# be retrieved using Python functions of the form "
2003         "common_*(context).\n");
2004 
2005     fprintf(ofp, "# See the perf-script-python Documentation for the list "
2006         "of available functions.\n\n");
2007 
2008     fprintf(ofp, "from __future__ import print_function\n\n");
2009     fprintf(ofp, "import os\n");
2010     fprintf(ofp, "import sys\n\n");
2011 
2012     fprintf(ofp, "sys.path.append(os.environ['PERF_EXEC_PATH'] + \\\n");
2013     fprintf(ofp, "\t'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')\n");
2014     fprintf(ofp, "\nfrom perf_trace_context import *\n");
2015     fprintf(ofp, "from Core import *\n\n\n");
2016 
2017     fprintf(ofp, "def trace_begin():\n");
2018     fprintf(ofp, "\tprint(\"in trace_begin\")\n\n");
2019 
2020     fprintf(ofp, "def trace_end():\n");
2021     fprintf(ofp, "\tprint(\"in trace_end\")\n\n");
2022 
2023     nr_events = tep_get_events_count(pevent);
2024     all_events = tep_list_events(pevent, TEP_EVENT_SORT_ID);
2025 
2026     for (i = 0; all_events && i < nr_events; i++) {
2027         event = all_events[i];
2028         fprintf(ofp, "def %s__%s(", event->system, event->name);
2029         fprintf(ofp, "event_name, ");
2030         fprintf(ofp, "context, ");
2031         fprintf(ofp, "common_cpu,\n");
2032         fprintf(ofp, "\tcommon_secs, ");
2033         fprintf(ofp, "common_nsecs, ");
2034         fprintf(ofp, "common_pid, ");
2035         fprintf(ofp, "common_comm,\n\t");
2036         fprintf(ofp, "common_callchain, ");
2037 
2038         not_first = 0;
2039         count = 0;
2040 
2041         for (f = event->format.fields; f; f = f->next) {
2042             if (not_first++)
2043                 fprintf(ofp, ", ");
2044             if (++count % 5 == 0)
2045                 fprintf(ofp, "\n\t");
2046 
2047             fprintf(ofp, "%s", f->name);
2048         }
2049         if (not_first++)
2050             fprintf(ofp, ", ");
2051         if (++count % 5 == 0)
2052             fprintf(ofp, "\n\t\t");
2053         fprintf(ofp, "perf_sample_dict");
2054 
2055         fprintf(ofp, "):\n");
2056 
2057         fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
2058             "common_secs, common_nsecs,\n\t\t\t"
2059             "common_pid, common_comm)\n\n");
2060 
2061         fprintf(ofp, "\t\tprint(\"");
2062 
2063         not_first = 0;
2064         count = 0;
2065 
2066         for (f = event->format.fields; f; f = f->next) {
2067             if (not_first++)
2068                 fprintf(ofp, ", ");
2069             if (count && count % 3 == 0) {
2070                 fprintf(ofp, "\" \\\n\t\t\"");
2071             }
2072             count++;
2073 
2074             fprintf(ofp, "%s=", f->name);
2075             if (f->flags & TEP_FIELD_IS_STRING ||
2076                 f->flags & TEP_FIELD_IS_FLAG ||
2077                 f->flags & TEP_FIELD_IS_ARRAY ||
2078                 f->flags & TEP_FIELD_IS_SYMBOLIC)
2079                 fprintf(ofp, "%%s");
2080             else if (f->flags & TEP_FIELD_IS_SIGNED)
2081                 fprintf(ofp, "%%d");
2082             else
2083                 fprintf(ofp, "%%u");
2084         }
2085 
2086         fprintf(ofp, "\" %% \\\n\t\t(");
2087 
2088         not_first = 0;
2089         count = 0;
2090 
2091         for (f = event->format.fields; f; f = f->next) {
2092             if (not_first++)
2093                 fprintf(ofp, ", ");
2094 
2095             if (++count % 5 == 0)
2096                 fprintf(ofp, "\n\t\t");
2097 
2098             if (f->flags & TEP_FIELD_IS_FLAG) {
2099                 if ((count - 1) % 5 != 0) {
2100                     fprintf(ofp, "\n\t\t");
2101                     count = 4;
2102                 }
2103                 fprintf(ofp, "flag_str(\"");
2104                 fprintf(ofp, "%s__%s\", ", event->system,
2105                     event->name);
2106                 fprintf(ofp, "\"%s\", %s)", f->name,
2107                     f->name);
2108             } else if (f->flags & TEP_FIELD_IS_SYMBOLIC) {
2109                 if ((count - 1) % 5 != 0) {
2110                     fprintf(ofp, "\n\t\t");
2111                     count = 4;
2112                 }
2113                 fprintf(ofp, "symbol_str(\"");
2114                 fprintf(ofp, "%s__%s\", ", event->system,
2115                     event->name);
2116                 fprintf(ofp, "\"%s\", %s)", f->name,
2117                     f->name);
2118             } else
2119                 fprintf(ofp, "%s", f->name);
2120         }
2121 
2122         fprintf(ofp, "))\n\n");
2123 
2124         fprintf(ofp, "\t\tprint('Sample: {'+"
2125             "get_dict_as_string(perf_sample_dict['sample'], ', ')+'}')\n\n");
2126 
2127         fprintf(ofp, "\t\tfor node in common_callchain:");
2128         fprintf(ofp, "\n\t\t\tif 'sym' in node:");
2129         fprintf(ofp, "\n\t\t\t\tprint(\"\t[%%x] %%s%%s%%s%%s\" %% (");
2130         fprintf(ofp, "\n\t\t\t\t\tnode['ip'], node['sym']['name'],");
2131         fprintf(ofp, "\n\t\t\t\t\t\"+0x{:x}\".format(node['sym_off']) if 'sym_off' in node else \"\",");
2132         fprintf(ofp, "\n\t\t\t\t\t\" ({})\".format(node['dso'])  if 'dso' in node else \"\",");
2133         fprintf(ofp, "\n\t\t\t\t\t\" \" + node['sym_srcline'] if 'sym_srcline' in node else \"\"))");
2134         fprintf(ofp, "\n\t\t\telse:");
2135         fprintf(ofp, "\n\t\t\t\tprint(\"\t[%%x]\" %% (node['ip']))\n\n");
2136         fprintf(ofp, "\t\tprint()\n\n");
2137 
2138     }
2139 
2140     fprintf(ofp, "def trace_unhandled(event_name, context, "
2141         "event_fields_dict, perf_sample_dict):\n");
2142 
2143     fprintf(ofp, "\t\tprint(get_dict_as_string(event_fields_dict))\n");
2144     fprintf(ofp, "\t\tprint('Sample: {'+"
2145         "get_dict_as_string(perf_sample_dict['sample'], ', ')+'}')\n\n");
2146 
2147     fprintf(ofp, "def print_header("
2148         "event_name, cpu, secs, nsecs, pid, comm):\n"
2149         "\tprint(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \" %% \\\n\t"
2150         "(event_name, cpu, secs, nsecs, pid, comm), end=\"\")\n\n");
2151 
2152     fprintf(ofp, "def get_dict_as_string(a_dict, delimiter=' '):\n"
2153         "\treturn delimiter.join"
2154         "(['%%s=%%s'%%(k,str(v))for k,v in sorted(a_dict.items())])\n");
2155 
2156     fclose(ofp);
2157 
2158     fprintf(stderr, "generated Python script: %s\n", fname);
2159 
2160     return 0;
2161 }
2162 
2163 struct scripting_ops python_scripting_ops = {
2164     .name           = "Python",
2165     .dirname        = "python",
2166     .start_script       = python_start_script,
2167     .flush_script       = python_flush_script,
2168     .stop_script        = python_stop_script,
2169     .process_event      = python_process_event,
2170     .process_switch     = python_process_switch,
2171     .process_auxtrace_error = python_process_auxtrace_error,
2172     .process_stat       = python_process_stat,
2173     .process_stat_interval  = python_process_stat_interval,
2174     .process_throttle   = python_process_throttle,
2175     .generate_script    = python_generate_script,
2176 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!