cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

trace-event-python.c (58087B)


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