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 int 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 0;
 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	return printed;
 709}
 710
 711static void set_regs_in_dict(PyObject *dict,
 712			     struct perf_sample *sample,
 713			     struct evsel *evsel)
 714{
 715	struct perf_event_attr *attr = &evsel->core.attr;
 716	char bf[512];
 
 
 
 
 
 
 
 
 
 
 
 
 717
 718	regs_map(&sample->intr_regs, attr->sample_regs_intr, bf, sizeof(bf));
 719
 720	pydict_set_item_string_decref(dict, "iregs",
 721			_PyUnicode_FromString(bf));
 722
 723	regs_map(&sample->user_regs, attr->sample_regs_user, bf, sizeof(bf));
 724
 725	pydict_set_item_string_decref(dict, "uregs",
 726			_PyUnicode_FromString(bf));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 727}
 728
 729static PyObject *get_perf_sample_dict(struct perf_sample *sample,
 730					 struct evsel *evsel,
 731					 struct addr_location *al,
 
 732					 PyObject *callchain)
 733{
 734	PyObject *dict, *dict_sample, *brstack, *brstacksym;
 735
 736	dict = PyDict_New();
 737	if (!dict)
 738		Py_FatalError("couldn't create Python dictionary");
 739
 740	dict_sample = PyDict_New();
 741	if (!dict_sample)
 742		Py_FatalError("couldn't create Python dictionary");
 743
 744	pydict_set_item_string_decref(dict, "ev_name", _PyUnicode_FromString(evsel__name(evsel)));
 745	pydict_set_item_string_decref(dict, "attr", _PyBytes_FromStringAndSize((const char *)&evsel->core.attr, sizeof(evsel->core.attr)));
 746
 747	pydict_set_item_string_decref(dict_sample, "pid",
 748			_PyLong_FromLong(sample->pid));
 749	pydict_set_item_string_decref(dict_sample, "tid",
 750			_PyLong_FromLong(sample->tid));
 751	pydict_set_item_string_decref(dict_sample, "cpu",
 752			_PyLong_FromLong(sample->cpu));
 753	pydict_set_item_string_decref(dict_sample, "ip",
 754			PyLong_FromUnsignedLongLong(sample->ip));
 755	pydict_set_item_string_decref(dict_sample, "time",
 756			PyLong_FromUnsignedLongLong(sample->time));
 757	pydict_set_item_string_decref(dict_sample, "period",
 758			PyLong_FromUnsignedLongLong(sample->period));
 759	pydict_set_item_string_decref(dict_sample, "phys_addr",
 760			PyLong_FromUnsignedLongLong(sample->phys_addr));
 761	pydict_set_item_string_decref(dict_sample, "addr",
 762			PyLong_FromUnsignedLongLong(sample->addr));
 763	set_sample_read_in_dict(dict_sample, sample, evsel);
 764	pydict_set_item_string_decref(dict_sample, "weight",
 765			PyLong_FromUnsignedLongLong(sample->weight));
 766	pydict_set_item_string_decref(dict_sample, "transaction",
 767			PyLong_FromUnsignedLongLong(sample->transaction));
 768	set_sample_datasrc_in_dict(dict_sample, sample);
 769	pydict_set_item_string_decref(dict, "sample", dict_sample);
 770
 771	pydict_set_item_string_decref(dict, "raw_buf", _PyBytes_FromStringAndSize(
 772			(const char *)sample->raw_data, sample->raw_size));
 773	pydict_set_item_string_decref(dict, "comm",
 774			_PyUnicode_FromString(thread__comm_str(al->thread)));
 775	if (al->map) {
 776		pydict_set_item_string_decref(dict, "dso",
 777			_PyUnicode_FromString(al->map->dso->name));
 778	}
 779	if (al->sym) {
 780		pydict_set_item_string_decref(dict, "symbol",
 781			_PyUnicode_FromString(al->sym->name));
 782	}
 783
 784	pydict_set_item_string_decref(dict, "callchain", callchain);
 785
 786	brstack = python_process_brstack(sample, al->thread);
 787	pydict_set_item_string_decref(dict, "brstack", brstack);
 788
 789	brstacksym = python_process_brstacksym(sample, al->thread);
 790	pydict_set_item_string_decref(dict, "brstacksym", brstacksym);
 791
 792	set_regs_in_dict(dict, sample, evsel);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 793
 794	return dict;
 795}
 796
 
 797static void python_process_tracepoint(struct perf_sample *sample,
 798				      struct evsel *evsel,
 799				      struct addr_location *al)
 
 800{
 801	struct tep_event *event = evsel->tp_format;
 802	PyObject *handler, *context, *t, *obj = NULL, *callchain;
 803	PyObject *dict = NULL, *all_entries_dict = NULL;
 804	static char handler_name[256];
 805	struct tep_format_field *field;
 806	unsigned long s, ns;
 807	unsigned n = 0;
 808	int pid;
 809	int cpu = sample->cpu;
 810	void *data = sample->raw_data;
 811	unsigned long long nsecs = sample->time;
 812	const char *comm = thread__comm_str(al->thread);
 813	const char *default_handler_name = "trace_unhandled";
 
 
 
 814
 815	if (!event) {
 816		snprintf(handler_name, sizeof(handler_name),
 817			 "ug! no event found for type %" PRIu64, (u64)evsel->core.attr.config);
 818		Py_FatalError(handler_name);
 819	}
 820
 821	pid = raw_field_value(event, "common_pid", data);
 822
 823	sprintf(handler_name, "%s__%s", event->system, event->name);
 824
 825	if (!test_and_set_bit(event->id, events_defined))
 826		define_event_symbols(event, handler_name, event->print_fmt.args);
 827
 828	handler = get_handler(handler_name);
 829	if (!handler) {
 830		handler = get_handler(default_handler_name);
 831		if (!handler)
 832			return;
 833		dict = PyDict_New();
 834		if (!dict)
 835			Py_FatalError("couldn't create Python dict");
 836	}
 837
 838	t = PyTuple_New(MAX_FIELDS);
 839	if (!t)
 840		Py_FatalError("couldn't create Python tuple");
 841
 842
 843	s = nsecs / NSEC_PER_SEC;
 844	ns = nsecs - s * NSEC_PER_SEC;
 845
 846	scripting_context->event_data = data;
 847	scripting_context->pevent = evsel->tp_format->tep;
 848
 849	context = _PyCapsule_New(scripting_context, NULL, NULL);
 850
 851	PyTuple_SetItem(t, n++, _PyUnicode_FromString(handler_name));
 852	PyTuple_SetItem(t, n++, context);
 853
 854	/* ip unwinding */
 855	callchain = python_process_callchain(sample, evsel, al);
 856	/* Need an additional reference for the perf_sample dict */
 857	Py_INCREF(callchain);
 858
 859	if (!dict) {
 860		PyTuple_SetItem(t, n++, _PyLong_FromLong(cpu));
 861		PyTuple_SetItem(t, n++, _PyLong_FromLong(s));
 862		PyTuple_SetItem(t, n++, _PyLong_FromLong(ns));
 863		PyTuple_SetItem(t, n++, _PyLong_FromLong(pid));
 864		PyTuple_SetItem(t, n++, _PyUnicode_FromString(comm));
 865		PyTuple_SetItem(t, n++, callchain);
 866	} else {
 867		pydict_set_item_string_decref(dict, "common_cpu", _PyLong_FromLong(cpu));
 868		pydict_set_item_string_decref(dict, "common_s", _PyLong_FromLong(s));
 869		pydict_set_item_string_decref(dict, "common_ns", _PyLong_FromLong(ns));
 870		pydict_set_item_string_decref(dict, "common_pid", _PyLong_FromLong(pid));
 871		pydict_set_item_string_decref(dict, "common_comm", _PyUnicode_FromString(comm));
 872		pydict_set_item_string_decref(dict, "common_callchain", callchain);
 873	}
 874	for (field = event->format.fields; field; field = field->next) {
 875		unsigned int offset, len;
 876		unsigned long long val;
 877
 878		if (field->flags & TEP_FIELD_IS_ARRAY) {
 879			offset = field->offset;
 880			len    = field->size;
 881			if (field->flags & TEP_FIELD_IS_DYNAMIC) {
 882				val     = tep_read_number(scripting_context->pevent,
 883							  data + offset, len);
 884				offset  = val;
 885				len     = offset >> 16;
 886				offset &= 0xffff;
 
 
 887			}
 888			if (field->flags & TEP_FIELD_IS_STRING &&
 889			    is_printable_array(data + offset, len)) {
 890				obj = _PyUnicode_FromString((char *) data + offset);
 891			} else {
 892				obj = PyByteArray_FromStringAndSize((const char *) data + offset, len);
 893				field->flags &= ~TEP_FIELD_IS_STRING;
 894			}
 895		} else { /* FIELD_IS_NUMERIC */
 896			obj = get_field_numeric_entry(event, field, data);
 897		}
 898		if (!dict)
 899			PyTuple_SetItem(t, n++, obj);
 900		else
 901			pydict_set_item_string_decref(dict, field->name, obj);
 902
 903	}
 904
 905	if (dict)
 906		PyTuple_SetItem(t, n++, dict);
 907
 908	if (get_argument_count(handler) == (int) n + 1) {
 909		all_entries_dict = get_perf_sample_dict(sample, evsel, al,
 910			callchain);
 911		PyTuple_SetItem(t, n++,	all_entries_dict);
 912	} else {
 913		Py_DECREF(callchain);
 914	}
 915
 916	if (_PyTuple_Resize(&t, n) == -1)
 917		Py_FatalError("error resizing Python tuple");
 918
 919	if (!dict)
 920		call_object(handler, t, handler_name);
 921	else
 922		call_object(handler, t, default_handler_name);
 923
 924	Py_DECREF(t);
 925}
 
 
 
 
 
 
 
 
 
 
 926
 927static PyObject *tuple_new(unsigned int sz)
 928{
 929	PyObject *t;
 930
 931	t = PyTuple_New(sz);
 932	if (!t)
 933		Py_FatalError("couldn't create Python tuple");
 934	return t;
 935}
 936
 937static int tuple_set_u64(PyObject *t, unsigned int pos, u64 val)
 938{
 939#if BITS_PER_LONG == 64
 940	return PyTuple_SetItem(t, pos, _PyLong_FromLong(val));
 941#endif
 942#if BITS_PER_LONG == 32
 943	return PyTuple_SetItem(t, pos, PyLong_FromLongLong(val));
 944#endif
 945}
 946
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 947static int tuple_set_s32(PyObject *t, unsigned int pos, s32 val)
 948{
 949	return PyTuple_SetItem(t, pos, _PyLong_FromLong(val));
 950}
 951
 
 
 
 
 
 952static int tuple_set_string(PyObject *t, unsigned int pos, const char *s)
 953{
 954	return PyTuple_SetItem(t, pos, _PyUnicode_FromString(s));
 955}
 956
 957static int tuple_set_bytes(PyObject *t, unsigned int pos, void *bytes,
 958			   unsigned int sz)
 959{
 960	return PyTuple_SetItem(t, pos, _PyBytes_FromStringAndSize(bytes, sz));
 961}
 962
 963static int python_export_evsel(struct db_export *dbe, struct evsel *evsel)
 964{
 965	struct tables *tables = container_of(dbe, struct tables, dbe);
 966	PyObject *t;
 967
 968	t = tuple_new(2);
 969
 970	tuple_set_u64(t, 0, evsel->db_id);
 971	tuple_set_string(t, 1, evsel__name(evsel));
 972
 973	call_object(tables->evsel_handler, t, "evsel_table");
 974
 975	Py_DECREF(t);
 976
 977	return 0;
 978}
 979
 980static int python_export_machine(struct db_export *dbe,
 981				 struct machine *machine)
 982{
 983	struct tables *tables = container_of(dbe, struct tables, dbe);
 984	PyObject *t;
 985
 986	t = tuple_new(3);
 987
 988	tuple_set_u64(t, 0, machine->db_id);
 989	tuple_set_s32(t, 1, machine->pid);
 990	tuple_set_string(t, 2, machine->root_dir ? machine->root_dir : "");
 991
 992	call_object(tables->machine_handler, t, "machine_table");
 993
 994	Py_DECREF(t);
 995
 996	return 0;
 997}
 998
 999static int python_export_thread(struct db_export *dbe, struct thread *thread,
1000				u64 main_thread_db_id, struct machine *machine)
1001{
1002	struct tables *tables = container_of(dbe, struct tables, dbe);
1003	PyObject *t;
1004
1005	t = tuple_new(5);
1006
1007	tuple_set_u64(t, 0, thread->db_id);
1008	tuple_set_u64(t, 1, machine->db_id);
1009	tuple_set_u64(t, 2, main_thread_db_id);
1010	tuple_set_s32(t, 3, thread->pid_);
1011	tuple_set_s32(t, 4, thread->tid);
1012
1013	call_object(tables->thread_handler, t, "thread_table");
1014
1015	Py_DECREF(t);
1016
1017	return 0;
1018}
1019
1020static int python_export_comm(struct db_export *dbe, struct comm *comm,
1021			      struct thread *thread)
1022{
1023	struct tables *tables = container_of(dbe, struct tables, dbe);
1024	PyObject *t;
1025
1026	t = tuple_new(5);
1027
1028	tuple_set_u64(t, 0, comm->db_id);
1029	tuple_set_string(t, 1, comm__str(comm));
1030	tuple_set_u64(t, 2, thread->db_id);
1031	tuple_set_u64(t, 3, comm->start);
1032	tuple_set_s32(t, 4, comm->exec);
1033
1034	call_object(tables->comm_handler, t, "comm_table");
1035
1036	Py_DECREF(t);
1037
1038	return 0;
1039}
1040
1041static int python_export_comm_thread(struct db_export *dbe, u64 db_id,
1042				     struct comm *comm, struct thread *thread)
1043{
1044	struct tables *tables = container_of(dbe, struct tables, dbe);
1045	PyObject *t;
1046
1047	t = tuple_new(3);
1048
1049	tuple_set_u64(t, 0, db_id);
1050	tuple_set_u64(t, 1, comm->db_id);
1051	tuple_set_u64(t, 2, thread->db_id);
1052
1053	call_object(tables->comm_thread_handler, t, "comm_thread_table");
1054
1055	Py_DECREF(t);
1056
1057	return 0;
1058}
1059
1060static int python_export_dso(struct db_export *dbe, struct dso *dso,
1061			     struct machine *machine)
1062{
1063	struct tables *tables = container_of(dbe, struct tables, dbe);
1064	char sbuild_id[SBUILD_ID_SIZE];
1065	PyObject *t;
1066
1067	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
1068
1069	t = tuple_new(5);
1070
1071	tuple_set_u64(t, 0, dso->db_id);
1072	tuple_set_u64(t, 1, machine->db_id);
1073	tuple_set_string(t, 2, dso->short_name);
1074	tuple_set_string(t, 3, dso->long_name);
1075	tuple_set_string(t, 4, sbuild_id);
1076
1077	call_object(tables->dso_handler, t, "dso_table");
1078
1079	Py_DECREF(t);
1080
1081	return 0;
1082}
1083
1084static int python_export_symbol(struct db_export *dbe, struct symbol *sym,
1085				struct dso *dso)
1086{
1087	struct tables *tables = container_of(dbe, struct tables, dbe);
1088	u64 *sym_db_id = symbol__priv(sym);
1089	PyObject *t;
1090
1091	t = tuple_new(6);
1092
1093	tuple_set_u64(t, 0, *sym_db_id);
1094	tuple_set_u64(t, 1, dso->db_id);
1095	tuple_set_u64(t, 2, sym->start);
1096	tuple_set_u64(t, 3, sym->end);
1097	tuple_set_s32(t, 4, sym->binding);
1098	tuple_set_string(t, 5, sym->name);
1099
1100	call_object(tables->symbol_handler, t, "symbol_table");
1101
1102	Py_DECREF(t);
1103
1104	return 0;
1105}
1106
1107static int python_export_branch_type(struct db_export *dbe, u32 branch_type,
1108				     const char *name)
1109{
1110	struct tables *tables = container_of(dbe, struct tables, dbe);
1111	PyObject *t;
1112
1113	t = tuple_new(2);
1114
1115	tuple_set_s32(t, 0, branch_type);
1116	tuple_set_string(t, 1, name);
1117
1118	call_object(tables->branch_type_handler, t, "branch_type_table");
1119
1120	Py_DECREF(t);
1121
1122	return 0;
1123}
1124
1125static void python_export_sample_table(struct db_export *dbe,
1126				       struct export_sample *es)
1127{
1128	struct tables *tables = container_of(dbe, struct tables, dbe);
1129	PyObject *t;
1130
1131	t = tuple_new(24);
1132
1133	tuple_set_u64(t, 0, es->db_id);
1134	tuple_set_u64(t, 1, es->evsel->db_id);
1135	tuple_set_u64(t, 2, es->al->maps->machine->db_id);
1136	tuple_set_u64(t, 3, es->al->thread->db_id);
1137	tuple_set_u64(t, 4, es->comm_db_id);
1138	tuple_set_u64(t, 5, es->dso_db_id);
1139	tuple_set_u64(t, 6, es->sym_db_id);
1140	tuple_set_u64(t, 7, es->offset);
1141	tuple_set_u64(t, 8, es->sample->ip);
1142	tuple_set_u64(t, 9, es->sample->time);
1143	tuple_set_s32(t, 10, es->sample->cpu);
1144	tuple_set_u64(t, 11, es->addr_dso_db_id);
1145	tuple_set_u64(t, 12, es->addr_sym_db_id);
1146	tuple_set_u64(t, 13, es->addr_offset);
1147	tuple_set_u64(t, 14, es->sample->addr);
1148	tuple_set_u64(t, 15, es->sample->period);
1149	tuple_set_u64(t, 16, es->sample->weight);
1150	tuple_set_u64(t, 17, es->sample->transaction);
1151	tuple_set_u64(t, 18, es->sample->data_src);
1152	tuple_set_s32(t, 19, es->sample->flags & PERF_BRANCH_MASK);
1153	tuple_set_s32(t, 20, !!(es->sample->flags & PERF_IP_FLAG_IN_TX));
1154	tuple_set_u64(t, 21, es->call_path_id);
1155	tuple_set_u64(t, 22, es->sample->insn_cnt);
1156	tuple_set_u64(t, 23, es->sample->cyc_cnt);
 
1157
1158	call_object(tables->sample_handler, t, "sample_table");
1159
1160	Py_DECREF(t);
1161}
1162
1163static void python_export_synth(struct db_export *dbe, struct export_sample *es)
1164{
1165	struct tables *tables = container_of(dbe, struct tables, dbe);
1166	PyObject *t;
1167
1168	t = tuple_new(3);
1169
1170	tuple_set_u64(t, 0, es->db_id);
1171	tuple_set_u64(t, 1, es->evsel->core.attr.config);
1172	tuple_set_bytes(t, 2, es->sample->raw_data, es->sample->raw_size);
1173
1174	call_object(tables->synth_handler, t, "synth_data");
1175
1176	Py_DECREF(t);
1177}
1178
1179static int python_export_sample(struct db_export *dbe,
1180				struct export_sample *es)
1181{
1182	struct tables *tables = container_of(dbe, struct tables, dbe);
1183
1184	python_export_sample_table(dbe, es);
1185
1186	if (es->evsel->core.attr.type == PERF_TYPE_SYNTH && tables->synth_handler)
1187		python_export_synth(dbe, es);
1188
1189	return 0;
1190}
1191
1192static int python_export_call_path(struct db_export *dbe, struct call_path *cp)
1193{
1194	struct tables *tables = container_of(dbe, struct tables, dbe);
1195	PyObject *t;
1196	u64 parent_db_id, sym_db_id;
1197
1198	parent_db_id = cp->parent ? cp->parent->db_id : 0;
1199	sym_db_id = cp->sym ? *(u64 *)symbol__priv(cp->sym) : 0;
1200
1201	t = tuple_new(4);
1202
1203	tuple_set_u64(t, 0, cp->db_id);
1204	tuple_set_u64(t, 1, parent_db_id);
1205	tuple_set_u64(t, 2, sym_db_id);
1206	tuple_set_u64(t, 3, cp->ip);
1207
1208	call_object(tables->call_path_handler, t, "call_path_table");
1209
1210	Py_DECREF(t);
1211
1212	return 0;
1213}
1214
1215static int python_export_call_return(struct db_export *dbe,
1216				     struct call_return *cr)
1217{
1218	struct tables *tables = container_of(dbe, struct tables, dbe);
1219	u64 comm_db_id = cr->comm ? cr->comm->db_id : 0;
1220	PyObject *t;
1221
1222	t = tuple_new(14);
1223
1224	tuple_set_u64(t, 0, cr->db_id);
1225	tuple_set_u64(t, 1, cr->thread->db_id);
1226	tuple_set_u64(t, 2, comm_db_id);
1227	tuple_set_u64(t, 3, cr->cp->db_id);
1228	tuple_set_u64(t, 4, cr->call_time);
1229	tuple_set_u64(t, 5, cr->return_time);
1230	tuple_set_u64(t, 6, cr->branch_count);
1231	tuple_set_u64(t, 7, cr->call_ref);
1232	tuple_set_u64(t, 8, cr->return_ref);
1233	tuple_set_u64(t, 9, cr->cp->parent->db_id);
1234	tuple_set_s32(t, 10, cr->flags);
1235	tuple_set_u64(t, 11, cr->parent_db_id);
1236	tuple_set_u64(t, 12, cr->insn_count);
1237	tuple_set_u64(t, 13, cr->cyc_count);
1238
1239	call_object(tables->call_return_handler, t, "call_return_table");
1240
1241	Py_DECREF(t);
1242
1243	return 0;
1244}
1245
1246static int python_export_context_switch(struct db_export *dbe, u64 db_id,
1247					struct machine *machine,
1248					struct perf_sample *sample,
1249					u64 th_out_id, u64 comm_out_id,
1250					u64 th_in_id, u64 comm_in_id, int flags)
1251{
1252	struct tables *tables = container_of(dbe, struct tables, dbe);
1253	PyObject *t;
1254
1255	t = tuple_new(9);
1256
1257	tuple_set_u64(t, 0, db_id);
1258	tuple_set_u64(t, 1, machine->db_id);
1259	tuple_set_u64(t, 2, sample->time);
1260	tuple_set_s32(t, 3, sample->cpu);
1261	tuple_set_u64(t, 4, th_out_id);
1262	tuple_set_u64(t, 5, comm_out_id);
1263	tuple_set_u64(t, 6, th_in_id);
1264	tuple_set_u64(t, 7, comm_in_id);
1265	tuple_set_s32(t, 8, flags);
1266
1267	call_object(tables->context_switch_handler, t, "context_switch");
1268
1269	Py_DECREF(t);
1270
1271	return 0;
1272}
1273
1274static int python_process_call_return(struct call_return *cr, u64 *parent_db_id,
1275				      void *data)
1276{
1277	struct db_export *dbe = data;
1278
1279	return db_export__call_return(dbe, cr, parent_db_id);
1280}
1281
1282static void python_process_general_event(struct perf_sample *sample,
1283					 struct evsel *evsel,
1284					 struct addr_location *al)
 
1285{
1286	PyObject *handler, *t, *dict, *callchain;
1287	static char handler_name[64];
1288	unsigned n = 0;
1289
1290	snprintf(handler_name, sizeof(handler_name), "%s", "process_event");
1291
1292	handler = get_handler(handler_name);
1293	if (!handler)
1294		return;
1295
1296	/*
1297	 * Use the MAX_FIELDS to make the function expandable, though
1298	 * currently there is only one item for the tuple.
1299	 */
1300	t = PyTuple_New(MAX_FIELDS);
1301	if (!t)
1302		Py_FatalError("couldn't create Python tuple");
1303
1304	/* ip unwinding */
1305	callchain = python_process_callchain(sample, evsel, al);
1306	dict = get_perf_sample_dict(sample, evsel, al, callchain);
1307
1308	PyTuple_SetItem(t, n++, dict);
1309	if (_PyTuple_Resize(&t, n) == -1)
1310		Py_FatalError("error resizing Python tuple");
1311
1312	call_object(handler, t, handler_name);
1313
1314	Py_DECREF(t);
1315}
1316
1317static void python_process_event(union perf_event *event,
1318				 struct perf_sample *sample,
1319				 struct evsel *evsel,
1320				 struct addr_location *al)
 
1321{
1322	struct tables *tables = &tables_global;
1323
 
 
1324	switch (evsel->core.attr.type) {
1325	case PERF_TYPE_TRACEPOINT:
1326		python_process_tracepoint(sample, evsel, al);
1327		break;
1328	/* Reserve for future process_hw/sw/raw APIs */
1329	default:
1330		if (tables->db_export_mode)
1331			db_export__sample(&tables->dbe, event, sample, evsel, al);
1332		else
1333			python_process_general_event(sample, evsel, al);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1334	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1335}
1336
1337static void python_process_switch(union perf_event *event,
1338				  struct perf_sample *sample,
1339				  struct machine *machine)
1340{
1341	struct tables *tables = &tables_global;
1342
1343	if (tables->db_export_mode)
1344		db_export__switch(&tables->dbe, event, sample, machine);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1345}
1346
1347static void get_handler_name(char *str, size_t size,
1348			     struct evsel *evsel)
1349{
1350	char *p = str;
1351
1352	scnprintf(str, size, "stat__%s", evsel__name(evsel));
1353
1354	while ((p = strchr(p, ':'))) {
1355		*p = '_';
1356		p++;
1357	}
1358}
1359
1360static void
1361process_stat(struct evsel *counter, int cpu, int thread, u64 tstamp,
1362	     struct perf_counts_values *count)
1363{
1364	PyObject *handler, *t;
1365	static char handler_name[256];
1366	int n = 0;
1367
1368	t = PyTuple_New(MAX_FIELDS);
1369	if (!t)
1370		Py_FatalError("couldn't create Python tuple");
1371
1372	get_handler_name(handler_name, sizeof(handler_name),
1373			 counter);
1374
1375	handler = get_handler(handler_name);
1376	if (!handler) {
1377		pr_debug("can't find python handler %s\n", handler_name);
1378		return;
1379	}
1380
1381	PyTuple_SetItem(t, n++, _PyLong_FromLong(cpu));
1382	PyTuple_SetItem(t, n++, _PyLong_FromLong(thread));
1383
1384	tuple_set_u64(t, n++, tstamp);
1385	tuple_set_u64(t, n++, count->val);
1386	tuple_set_u64(t, n++, count->ena);
1387	tuple_set_u64(t, n++, count->run);
1388
1389	if (_PyTuple_Resize(&t, n) == -1)
1390		Py_FatalError("error resizing Python tuple");
1391
1392	call_object(handler, t, handler_name);
1393
1394	Py_DECREF(t);
1395}
1396
1397static void python_process_stat(struct perf_stat_config *config,
1398				struct evsel *counter, u64 tstamp)
1399{
1400	struct perf_thread_map *threads = counter->core.threads;
1401	struct perf_cpu_map *cpus = counter->core.cpus;
1402	int cpu, thread;
1403
1404	if (config->aggr_mode == AGGR_GLOBAL) {
1405		process_stat(counter, -1, -1, tstamp,
1406			     &counter->counts->aggr);
1407		return;
1408	}
1409
1410	for (thread = 0; thread < threads->nr; thread++) {
1411		for (cpu = 0; cpu < cpus->nr; cpu++) {
1412			process_stat(counter, cpus->map[cpu],
1413				     perf_thread_map__pid(threads, thread), tstamp,
1414				     perf_counts(counter->counts, cpu, thread));
1415		}
1416	}
1417}
1418
1419static void python_process_stat_interval(u64 tstamp)
1420{
1421	PyObject *handler, *t;
1422	static const char handler_name[] = "stat__interval";
1423	int n = 0;
1424
1425	t = PyTuple_New(MAX_FIELDS);
1426	if (!t)
1427		Py_FatalError("couldn't create Python tuple");
1428
1429	handler = get_handler(handler_name);
1430	if (!handler) {
1431		pr_debug("can't find python handler %s\n", handler_name);
1432		return;
1433	}
1434
1435	tuple_set_u64(t, n++, tstamp);
1436
1437	if (_PyTuple_Resize(&t, n) == -1)
1438		Py_FatalError("error resizing Python tuple");
1439
1440	call_object(handler, t, handler_name);
1441
1442	Py_DECREF(t);
1443}
1444
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1445static int run_start_sub(void)
1446{
1447	main_module = PyImport_AddModule("__main__");
1448	if (main_module == NULL)
1449		return -1;
1450	Py_INCREF(main_module);
1451
1452	main_dict = PyModule_GetDict(main_module);
1453	if (main_dict == NULL)
1454		goto error;
1455	Py_INCREF(main_dict);
1456
 
 
 
1457	try_call_object("trace_begin", NULL);
1458
1459	return 0;
1460
1461error:
1462	Py_XDECREF(main_dict);
1463	Py_XDECREF(main_module);
1464	return -1;
1465}
1466
1467#define SET_TABLE_HANDLER_(name, handler_name, table_name) do {		\
1468	tables->handler_name = get_handler(#table_name);		\
1469	if (tables->handler_name)					\
1470		tables->dbe.export_ ## name = python_export_ ## name;	\
1471} while (0)
1472
1473#define SET_TABLE_HANDLER(name) \
1474	SET_TABLE_HANDLER_(name, name ## _handler, name ## _table)
1475
1476static void set_table_handlers(struct tables *tables)
1477{
1478	const char *perf_db_export_mode = "perf_db_export_mode";
1479	const char *perf_db_export_calls = "perf_db_export_calls";
1480	const char *perf_db_export_callchains = "perf_db_export_callchains";
1481	PyObject *db_export_mode, *db_export_calls, *db_export_callchains;
1482	bool export_calls = false;
1483	bool export_callchains = false;
1484	int ret;
1485
1486	memset(tables, 0, sizeof(struct tables));
1487	if (db_export__init(&tables->dbe))
1488		Py_FatalError("failed to initialize export");
1489
1490	db_export_mode = PyDict_GetItemString(main_dict, perf_db_export_mode);
1491	if (!db_export_mode)
1492		return;
1493
1494	ret = PyObject_IsTrue(db_export_mode);
1495	if (ret == -1)
1496		handler_call_die(perf_db_export_mode);
1497	if (!ret)
1498		return;
1499
1500	/* handle export calls */
1501	tables->dbe.crp = NULL;
1502	db_export_calls = PyDict_GetItemString(main_dict, perf_db_export_calls);
1503	if (db_export_calls) {
1504		ret = PyObject_IsTrue(db_export_calls);
1505		if (ret == -1)
1506			handler_call_die(perf_db_export_calls);
1507		export_calls = !!ret;
1508	}
1509
1510	if (export_calls) {
1511		tables->dbe.crp =
1512			call_return_processor__new(python_process_call_return,
1513						   &tables->dbe);
1514		if (!tables->dbe.crp)
1515			Py_FatalError("failed to create calls processor");
1516	}
1517
1518	/* handle export callchains */
1519	tables->dbe.cpr = NULL;
1520	db_export_callchains = PyDict_GetItemString(main_dict,
1521						    perf_db_export_callchains);
1522	if (db_export_callchains) {
1523		ret = PyObject_IsTrue(db_export_callchains);
1524		if (ret == -1)
1525			handler_call_die(perf_db_export_callchains);
1526		export_callchains = !!ret;
1527	}
1528
1529	if (export_callchains) {
1530		/*
1531		 * Attempt to use the call path root from the call return
1532		 * processor, if the call return processor is in use. Otherwise,
1533		 * we allocate a new call path root. This prevents exporting
1534		 * duplicate call path ids when both are in use simultaniously.
1535		 */
1536		if (tables->dbe.crp)
1537			tables->dbe.cpr = tables->dbe.crp->cpr;
1538		else
1539			tables->dbe.cpr = call_path_root__new();
1540
1541		if (!tables->dbe.cpr)
1542			Py_FatalError("failed to create call path root");
1543	}
1544
1545	tables->db_export_mode = true;
1546	/*
1547	 * Reserve per symbol space for symbol->db_id via symbol__priv()
1548	 */
1549	symbol_conf.priv_size = sizeof(u64);
1550
1551	SET_TABLE_HANDLER(evsel);
1552	SET_TABLE_HANDLER(machine);
1553	SET_TABLE_HANDLER(thread);
1554	SET_TABLE_HANDLER(comm);
1555	SET_TABLE_HANDLER(comm_thread);
1556	SET_TABLE_HANDLER(dso);
1557	SET_TABLE_HANDLER(symbol);
1558	SET_TABLE_HANDLER(branch_type);
1559	SET_TABLE_HANDLER(sample);
1560	SET_TABLE_HANDLER(call_path);
1561	SET_TABLE_HANDLER(call_return);
1562	SET_TABLE_HANDLER(context_switch);
1563
1564	/*
1565	 * Synthesized events are samples but with architecture-specific data
1566	 * stored in sample->raw_data. They are exported via
1567	 * python_export_sample() and consequently do not need a separate export
1568	 * callback.
1569	 */
1570	tables->synth_handler = get_handler("synth_data");
1571}
1572
1573#if PY_MAJOR_VERSION < 3
1574static void _free_command_line(const char **command_line, int num)
1575{
1576	free(command_line);
1577}
1578#else
1579static void _free_command_line(wchar_t **command_line, int num)
1580{
1581	int i;
1582	for (i = 0; i < num; i++)
1583		PyMem_RawFree(command_line[i]);
1584	free(command_line);
1585}
1586#endif
1587
1588
1589/*
1590 * Start trace script
1591 */
1592static int python_start_script(const char *script, int argc, const char **argv)
 
1593{
1594	struct tables *tables = &tables_global;
1595	PyMODINIT_FUNC (*initfunc)(void);
1596#if PY_MAJOR_VERSION < 3
1597	const char **command_line;
1598#else
1599	wchar_t **command_line;
1600#endif
1601	/*
1602	 * Use a non-const name variable to cope with python 2.6's
1603	 * PyImport_AppendInittab prototype
1604	 */
1605	char buf[PATH_MAX], name[19] = "perf_trace_context";
1606	int i, err = 0;
1607	FILE *fp;
1608
 
1609#if PY_MAJOR_VERSION < 3
1610	initfunc = initperf_trace_context;
1611	command_line = malloc((argc + 1) * sizeof(const char *));
 
 
 
1612	command_line[0] = script;
1613	for (i = 1; i < argc + 1; i++)
1614		command_line[i] = argv[i - 1];
 
1615#else
1616	initfunc = PyInit_perf_trace_context;
1617	command_line = malloc((argc + 1) * sizeof(wchar_t *));
 
 
 
1618	command_line[0] = Py_DecodeLocale(script, NULL);
1619	for (i = 1; i < argc + 1; i++)
1620		command_line[i] = Py_DecodeLocale(argv[i - 1], NULL);
 
1621#endif
1622
1623	PyImport_AppendInittab(name, initfunc);
1624	Py_Initialize();
1625
1626#if PY_MAJOR_VERSION < 3
1627	PySys_SetArgv(argc + 1, (char **)command_line);
1628#else
1629	PySys_SetArgv(argc + 1, command_line);
1630#endif
1631
1632	fp = fopen(script, "r");
1633	if (!fp) {
1634		sprintf(buf, "Can't open python script \"%s\"", script);
1635		perror(buf);
1636		err = -1;
1637		goto error;
1638	}
1639
1640	err = PyRun_SimpleFile(fp, script);
1641	if (err) {
1642		fprintf(stderr, "Error running python script %s\n", script);
1643		goto error;
1644	}
1645
1646	err = run_start_sub();
1647	if (err) {
1648		fprintf(stderr, "Error starting python script %s\n", script);
1649		goto error;
1650	}
1651
1652	set_table_handlers(tables);
1653
1654	if (tables->db_export_mode) {
1655		err = db_export__branch_types(&tables->dbe);
1656		if (err)
1657			goto error;
1658	}
1659
1660	_free_command_line(command_line, argc + 1);
1661
1662	return err;
1663error:
1664	Py_Finalize();
1665	_free_command_line(command_line, argc + 1);
1666
1667	return err;
1668}
1669
1670static int python_flush_script(void)
1671{
1672	return 0;
1673}
1674
1675/*
1676 * Stop trace script
1677 */
1678static int python_stop_script(void)
1679{
1680	struct tables *tables = &tables_global;
1681
1682	try_call_object("trace_end", NULL);
1683
1684	db_export__exit(&tables->dbe);
1685
1686	Py_XDECREF(main_dict);
1687	Py_XDECREF(main_module);
1688	Py_Finalize();
1689
1690	return 0;
1691}
1692
 
1693static int python_generate_script(struct tep_handle *pevent, const char *outfile)
1694{
1695	int i, not_first, count, nr_events;
1696	struct tep_event **all_events;
1697	struct tep_event *event = NULL;
1698	struct tep_format_field *f;
1699	char fname[PATH_MAX];
1700	FILE *ofp;
1701
1702	sprintf(fname, "%s.py", outfile);
1703	ofp = fopen(fname, "w");
1704	if (ofp == NULL) {
1705		fprintf(stderr, "couldn't open %s\n", fname);
1706		return -1;
1707	}
1708	fprintf(ofp, "# perf script event handlers, "
1709		"generated by perf script -g python\n");
1710
1711	fprintf(ofp, "# Licensed under the terms of the GNU GPL"
1712		" License version 2\n\n");
1713
1714	fprintf(ofp, "# The common_* event handler fields are the most useful "
1715		"fields common to\n");
1716
1717	fprintf(ofp, "# all events.  They don't necessarily correspond to "
1718		"the 'common_*' fields\n");
1719
1720	fprintf(ofp, "# in the format files.  Those fields not available as "
1721		"handler params can\n");
1722
1723	fprintf(ofp, "# be retrieved using Python functions of the form "
1724		"common_*(context).\n");
1725
1726	fprintf(ofp, "# See the perf-script-python Documentation for the list "
1727		"of available functions.\n\n");
1728
1729	fprintf(ofp, "from __future__ import print_function\n\n");
1730	fprintf(ofp, "import os\n");
1731	fprintf(ofp, "import sys\n\n");
1732
1733	fprintf(ofp, "sys.path.append(os.environ['PERF_EXEC_PATH'] + \\\n");
1734	fprintf(ofp, "\t'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')\n");
1735	fprintf(ofp, "\nfrom perf_trace_context import *\n");
1736	fprintf(ofp, "from Core import *\n\n\n");
1737
1738	fprintf(ofp, "def trace_begin():\n");
1739	fprintf(ofp, "\tprint(\"in trace_begin\")\n\n");
1740
1741	fprintf(ofp, "def trace_end():\n");
1742	fprintf(ofp, "\tprint(\"in trace_end\")\n\n");
1743
1744	nr_events = tep_get_events_count(pevent);
1745	all_events = tep_list_events(pevent, TEP_EVENT_SORT_ID);
1746
1747	for (i = 0; all_events && i < nr_events; i++) {
1748		event = all_events[i];
1749		fprintf(ofp, "def %s__%s(", event->system, event->name);
1750		fprintf(ofp, "event_name, ");
1751		fprintf(ofp, "context, ");
1752		fprintf(ofp, "common_cpu,\n");
1753		fprintf(ofp, "\tcommon_secs, ");
1754		fprintf(ofp, "common_nsecs, ");
1755		fprintf(ofp, "common_pid, ");
1756		fprintf(ofp, "common_comm,\n\t");
1757		fprintf(ofp, "common_callchain, ");
1758
1759		not_first = 0;
1760		count = 0;
1761
1762		for (f = event->format.fields; f; f = f->next) {
1763			if (not_first++)
1764				fprintf(ofp, ", ");
1765			if (++count % 5 == 0)
1766				fprintf(ofp, "\n\t");
1767
1768			fprintf(ofp, "%s", f->name);
1769		}
1770		if (not_first++)
1771			fprintf(ofp, ", ");
1772		if (++count % 5 == 0)
1773			fprintf(ofp, "\n\t\t");
1774		fprintf(ofp, "perf_sample_dict");
1775
1776		fprintf(ofp, "):\n");
1777
1778		fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
1779			"common_secs, common_nsecs,\n\t\t\t"
1780			"common_pid, common_comm)\n\n");
1781
1782		fprintf(ofp, "\t\tprint(\"");
1783
1784		not_first = 0;
1785		count = 0;
1786
1787		for (f = event->format.fields; f; f = f->next) {
1788			if (not_first++)
1789				fprintf(ofp, ", ");
1790			if (count && count % 3 == 0) {
1791				fprintf(ofp, "\" \\\n\t\t\"");
1792			}
1793			count++;
1794
1795			fprintf(ofp, "%s=", f->name);
1796			if (f->flags & TEP_FIELD_IS_STRING ||
1797			    f->flags & TEP_FIELD_IS_FLAG ||
1798			    f->flags & TEP_FIELD_IS_ARRAY ||
1799			    f->flags & TEP_FIELD_IS_SYMBOLIC)
1800				fprintf(ofp, "%%s");
1801			else if (f->flags & TEP_FIELD_IS_SIGNED)
1802				fprintf(ofp, "%%d");
1803			else
1804				fprintf(ofp, "%%u");
1805		}
1806
1807		fprintf(ofp, "\" %% \\\n\t\t(");
1808
1809		not_first = 0;
1810		count = 0;
1811
1812		for (f = event->format.fields; f; f = f->next) {
1813			if (not_first++)
1814				fprintf(ofp, ", ");
1815
1816			if (++count % 5 == 0)
1817				fprintf(ofp, "\n\t\t");
1818
1819			if (f->flags & TEP_FIELD_IS_FLAG) {
1820				if ((count - 1) % 5 != 0) {
1821					fprintf(ofp, "\n\t\t");
1822					count = 4;
1823				}
1824				fprintf(ofp, "flag_str(\"");
1825				fprintf(ofp, "%s__%s\", ", event->system,
1826					event->name);
1827				fprintf(ofp, "\"%s\", %s)", f->name,
1828					f->name);
1829			} else if (f->flags & TEP_FIELD_IS_SYMBOLIC) {
1830				if ((count - 1) % 5 != 0) {
1831					fprintf(ofp, "\n\t\t");
1832					count = 4;
1833				}
1834				fprintf(ofp, "symbol_str(\"");
1835				fprintf(ofp, "%s__%s\", ", event->system,
1836					event->name);
1837				fprintf(ofp, "\"%s\", %s)", f->name,
1838					f->name);
1839			} else
1840				fprintf(ofp, "%s", f->name);
1841		}
1842
1843		fprintf(ofp, "))\n\n");
1844
1845		fprintf(ofp, "\t\tprint('Sample: {'+"
1846			"get_dict_as_string(perf_sample_dict['sample'], ', ')+'}')\n\n");
1847
1848		fprintf(ofp, "\t\tfor node in common_callchain:");
1849		fprintf(ofp, "\n\t\t\tif 'sym' in node:");
1850		fprintf(ofp, "\n\t\t\t\tprint(\"\\t[%%x] %%s\" %% (node['ip'], node['sym']['name']))");
 
 
 
 
1851		fprintf(ofp, "\n\t\t\telse:");
1852		fprintf(ofp, "\n\t\t\t\tprint(\"\t[%%x]\" %% (node['ip']))\n\n");
1853		fprintf(ofp, "\t\tprint()\n\n");
1854
1855	}
1856
1857	fprintf(ofp, "def trace_unhandled(event_name, context, "
1858		"event_fields_dict, perf_sample_dict):\n");
1859
1860	fprintf(ofp, "\t\tprint(get_dict_as_string(event_fields_dict))\n");
1861	fprintf(ofp, "\t\tprint('Sample: {'+"
1862		"get_dict_as_string(perf_sample_dict['sample'], ', ')+'}')\n\n");
1863
1864	fprintf(ofp, "def print_header("
1865		"event_name, cpu, secs, nsecs, pid, comm):\n"
1866		"\tprint(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \" %% \\\n\t"
1867		"(event_name, cpu, secs, nsecs, pid, comm), end=\"\")\n\n");
1868
1869	fprintf(ofp, "def get_dict_as_string(a_dict, delimiter=' '):\n"
1870		"\treturn delimiter.join"
1871		"(['%%s=%%s'%%(k,str(v))for k,v in sorted(a_dict.items())])\n");
1872
1873	fclose(ofp);
1874
1875	fprintf(stderr, "generated Python script: %s\n", fname);
1876
1877	return 0;
1878}
 
 
 
 
 
 
 
 
 
 
 
 
1879
1880struct scripting_ops python_scripting_ops = {
1881	.name			= "Python",
 
1882	.start_script		= python_start_script,
1883	.flush_script		= python_flush_script,
1884	.stop_script		= python_stop_script,
1885	.process_event		= python_process_event,
1886	.process_switch		= python_process_switch,
 
1887	.process_stat		= python_process_stat,
1888	.process_stat_interval	= python_process_stat_interval,
 
1889	.generate_script	= python_generate_script,
1890};