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