1// SPDX-License-Identifier: LGPL-2.1
   2/*
   3 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   4 *
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   5 *
   6 *  The parts for function graph printing was taken and modified from the
   7 *  Linux Kernel that were written by
   8 *    - Copyright (C) 2009  Frederic Weisbecker,
   9 *  Frederic Weisbecker gave his permission to relicense the code to
  10 *  the Lesser General Public License.
  11 */
  12#include <inttypes.h>
  13#include <stdio.h>
  14#include <stdlib.h>
  15#include <string.h>
  16#include <stdarg.h>
  17#include <ctype.h>
  18#include <errno.h>
  19#include <stdint.h>
  20#include <limits.h>
 
  21#include <linux/time64.h>
  22
  23#include <netinet/in.h>
  24#include "event-parse.h"
  25
  26#include "event-parse-local.h"
  27#include "event-utils.h"
  28#include "trace-seq.h"
  29
  30static const char *input_buf;
  31static unsigned long long input_buf_ptr;
  32static unsigned long long input_buf_siz;
  33
  34static int is_flag_field;
  35static int is_symbolic_field;
  36
  37static int show_warning = 1;
  38
  39#define do_warning(fmt, ...)				\
  40	do {						\
  41		if (show_warning)			\
  42			warning(fmt, ##__VA_ARGS__);	\
  43	} while (0)
  44
  45#define do_warning_event(event, fmt, ...)			\
  46	do {							\
  47		if (!show_warning)				\
  48			continue;				\
  49								\
  50		if (event)					\
  51			warning("[%s:%s] " fmt, event->system,	\
  52				event->name, ##__VA_ARGS__);	\
  53		else						\
  54			warning(fmt, ##__VA_ARGS__);		\
  55	} while (0)
  56
  57static void init_input_buf(const char *buf, unsigned long long size)
  58{
  59	input_buf = buf;
  60	input_buf_siz = size;
  61	input_buf_ptr = 0;
  62}
  63
  64const char *tep_get_input_buf(void)
  65{
  66	return input_buf;
  67}
  68
  69unsigned long long tep_get_input_buf_ptr(void)
  70{
  71	return input_buf_ptr;
  72}
  73
  74struct event_handler {
  75	struct event_handler		*next;
  76	int				id;
  77	const char			*sys_name;
  78	const char			*event_name;
  79	tep_event_handler_func		func;
  80	void				*context;
  81};
  82
  83struct func_params {
  84	struct func_params	*next;
  85	enum tep_func_arg_type	type;
  86};
  87
  88struct tep_function_handler {
  89	struct tep_function_handler	*next;
  90	enum tep_func_arg_type		ret_type;
  91	char				*name;
  92	tep_func_handler		func;
  93	struct func_params		*params;
  94	int				nr_args;
  95};
  96
  97static unsigned long long
  98process_defined_func(struct trace_seq *s, void *data, int size,
  99		     struct tep_event *event, struct tep_print_arg *arg);
 100
 101static void free_func_handle(struct tep_function_handler *func);
 102
 103/**
 104 * tep_buffer_init - init buffer for parsing
 105 * @buf: buffer to parse
 106 * @size: the size of the buffer
 107 *
 108 * For use with tep_read_token(), this initializes the internal
 109 * buffer that tep_read_token() will parse.
 110 */
 111void tep_buffer_init(const char *buf, unsigned long long size)
 112{
 113	init_input_buf(buf, size);
 114}
 115
 116void breakpoint(void)
 117{
 118	static int x;
 119	x++;
 120}
 121
 122struct tep_print_arg *alloc_arg(void)
 123{
 124	return calloc(1, sizeof(struct tep_print_arg));
 125}
 126
 127struct tep_cmdline {
 128	char *comm;
 129	int pid;
 130};
 131
 132static int cmdline_cmp(const void *a, const void *b)
 133{
 134	const struct tep_cmdline *ca = a;
 135	const struct tep_cmdline *cb = b;
 136
 137	if (ca->pid < cb->pid)
 138		return -1;
 139	if (ca->pid > cb->pid)
 140		return 1;
 141
 142	return 0;
 143}
 144
 145/* Looking for where to place the key */
 146static int cmdline_slot_cmp(const void *a, const void *b)
 147{
 148	const struct tep_cmdline *ca = a;
 149	const struct tep_cmdline *cb = b;
 150	const struct tep_cmdline *cb1 = cb + 1;
 151
 152	if (ca->pid < cb->pid)
 153		return -1;
 154
 155	if (ca->pid > cb->pid) {
 156		if (ca->pid <= cb1->pid)
 157			return 0;
 158		return 1;
 159	}
 160
 161	return 0;
 162}
 163
 164struct cmdline_list {
 165	struct cmdline_list	*next;
 166	char			*comm;
 167	int			pid;
 168};
 169
 170static int cmdline_init(struct tep_handle *tep)
 171{
 172	struct cmdline_list *cmdlist = tep->cmdlist;
 173	struct cmdline_list *item;
 174	struct tep_cmdline *cmdlines;
 175	int i;
 176
 177	cmdlines = malloc(sizeof(*cmdlines) * tep->cmdline_count);
 178	if (!cmdlines)
 179		return -1;
 180
 181	i = 0;
 182	while (cmdlist) {
 183		cmdlines[i].pid = cmdlist->pid;
 184		cmdlines[i].comm = cmdlist->comm;
 185		i++;
 186		item = cmdlist;
 187		cmdlist = cmdlist->next;
 188		free(item);
 189	}
 190
 191	qsort(cmdlines, tep->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
 192
 193	tep->cmdlines = cmdlines;
 194	tep->cmdlist = NULL;
 195
 196	return 0;
 197}
 198
 199static const char *find_cmdline(struct tep_handle *tep, int pid)
 200{
 201	const struct tep_cmdline *comm;
 202	struct tep_cmdline key;
 203
 204	if (!pid)
 205		return "<idle>";
 206
 207	if (!tep->cmdlines && cmdline_init(tep))
 208		return "<not enough memory for cmdlines!>";
 209
 210	key.pid = pid;
 211
 212	comm = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 213		       sizeof(*tep->cmdlines), cmdline_cmp);
 214
 215	if (comm)
 216		return comm->comm;
 217	return "<...>";
 218}
 219
 220/**
 221 * tep_is_pid_registered - return if a pid has a cmdline registered
 222 * @tep: a handle to the trace event parser context
 223 * @pid: The pid to check if it has a cmdline registered with.
 224 *
 225 * Returns true if the pid has a cmdline mapped to it
 226 * false otherwise.
 227 */
 228bool tep_is_pid_registered(struct tep_handle *tep, int pid)
 229{
 230	const struct tep_cmdline *comm;
 231	struct tep_cmdline key;
 232
 233	if (!pid)
 234		return true;
 235
 236	if (!tep->cmdlines && cmdline_init(tep))
 237		return false;
 238
 239	key.pid = pid;
 240
 241	comm = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 242		       sizeof(*tep->cmdlines), cmdline_cmp);
 243
 244	if (comm)
 245		return true;
 246	return false;
 247}
 248
 249/*
 250 * If the command lines have been converted to an array, then
 251 * we must add this pid. This is much slower than when cmdlines
 252 * are added before the array is initialized.
 253 */
 254static int add_new_comm(struct tep_handle *tep,
 255			const char *comm, int pid, bool override)
 256{
 257	struct tep_cmdline *cmdlines = tep->cmdlines;
 258	struct tep_cmdline *cmdline;
 259	struct tep_cmdline key;
 260	char *new_comm;
 261	int cnt;
 262
 263	if (!pid)
 264		return 0;
 265
 266	/* avoid duplicates */
 267	key.pid = pid;
 268
 269	cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 270			  sizeof(*tep->cmdlines), cmdline_cmp);
 271	if (cmdline) {
 272		if (!override) {
 273			errno = EEXIST;
 274			return -1;
 275		}
 276		new_comm = strdup(comm);
 277		if (!new_comm) {
 278			errno = ENOMEM;
 279			return -1;
 280		}
 281		free(cmdline->comm);
 282		cmdline->comm = new_comm;
 283
 284		return 0;
 285	}
 286
 287	cmdlines = realloc(cmdlines, sizeof(*cmdlines) * (tep->cmdline_count + 1));
 288	if (!cmdlines) {
 289		errno = ENOMEM;
 290		return -1;
 291	}
 292	tep->cmdlines = cmdlines;
 293
 294	key.comm = strdup(comm);
 295	if (!key.comm) {
 
 296		errno = ENOMEM;
 297		return -1;
 298	}
 299
 300	if (!tep->cmdline_count) {
 301		/* no entries yet */
 302		tep->cmdlines[0] = key;
 303		tep->cmdline_count++;
 304		return 0;
 305	}
 306
 307	/* Now find where we want to store the new cmdline */
 308	cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count - 1,
 309			  sizeof(*tep->cmdlines), cmdline_slot_cmp);
 310
 311	cnt = tep->cmdline_count;
 312	if (cmdline) {
 313		/* cmdline points to the one before the spot we want */
 314		cmdline++;
 315		cnt -= cmdline - tep->cmdlines;
 316
 317	} else {
 318		/* The new entry is either before or after the list */
 319		if (key.pid > tep->cmdlines[tep->cmdline_count - 1].pid) {
 320			tep->cmdlines[tep->cmdline_count++] = key;
 321			return 0;
 322		}
 323		cmdline = &tep->cmdlines[0];
 324	}
 325	memmove(cmdline + 1, cmdline, (cnt * sizeof(*cmdline)));
 326	*cmdline = key;
 327
 328	tep->cmdline_count++;
 
 329
 330	return 0;
 331}
 332
 333static int _tep_register_comm(struct tep_handle *tep,
 334			      const char *comm, int pid, bool override)
 
 
 
 
 
 
 
 
 335{
 336	struct cmdline_list *item;
 337
 338	if (tep->cmdlines)
 339		return add_new_comm(tep, comm, pid, override);
 340
 341	item = malloc(sizeof(*item));
 342	if (!item)
 343		return -1;
 344
 345	if (comm)
 346		item->comm = strdup(comm);
 347	else
 348		item->comm = strdup("<...>");
 349	if (!item->comm) {
 350		free(item);
 351		return -1;
 352	}
 353	item->pid = pid;
 354	item->next = tep->cmdlist;
 355
 356	tep->cmdlist = item;
 357	tep->cmdline_count++;
 358
 359	return 0;
 360}
 361
 362/**
 363 * tep_register_comm - register a pid / comm mapping
 364 * @tep: a handle to the trace event parser context
 365 * @comm: the command line to register
 366 * @pid: the pid to map the command line to
 367 *
 368 * This adds a mapping to search for command line names with
 369 * a given pid. The comm is duplicated. If a command with the same pid
 370 * already exist, -1 is returned and errno is set to EEXIST
 371 */
 372int tep_register_comm(struct tep_handle *tep, const char *comm, int pid)
 373{
 374	return _tep_register_comm(tep, comm, pid, false);
 375}
 376
 377/**
 378 * tep_override_comm - register a pid / comm mapping
 379 * @tep: a handle to the trace event parser context
 380 * @comm: the command line to register
 381 * @pid: the pid to map the command line to
 382 *
 383 * This adds a mapping to search for command line names with
 384 * a given pid. The comm is duplicated. If a command with the same pid
 385 * already exist, the command string is udapted with the new one
 386 */
 387int tep_override_comm(struct tep_handle *tep, const char *comm, int pid)
 388{
 389	if (!tep->cmdlines && cmdline_init(tep)) {
 
 390		errno = ENOMEM;
 391		return -1;
 392	}
 393	return _tep_register_comm(tep, comm, pid, true);
 394}
 395
 396struct func_map {
 397	unsigned long long		addr;
 398	char				*func;
 399	char				*mod;
 400};
 401
 402struct func_list {
 403	struct func_list	*next;
 404	unsigned long long	addr;
 405	char			*func;
 406	char			*mod;
 407};
 408
 409static int func_cmp(const void *a, const void *b)
 410{
 411	const struct func_map *fa = a;
 412	const struct func_map *fb = b;
 413
 414	if (fa->addr < fb->addr)
 415		return -1;
 416	if (fa->addr > fb->addr)
 417		return 1;
 418
 419	return 0;
 420}
 421
 422/*
 423 * We are searching for a record in between, not an exact
 424 * match.
 425 */
 426static int func_bcmp(const void *a, const void *b)
 427{
 428	const struct func_map *fa = a;
 429	const struct func_map *fb = b;
 430
 431	if ((fa->addr == fb->addr) ||
 432
 433	    (fa->addr > fb->addr &&
 434	     fa->addr < (fb+1)->addr))
 435		return 0;
 436
 437	if (fa->addr < fb->addr)
 438		return -1;
 439
 440	return 1;
 441}
 442
 443static int func_map_init(struct tep_handle *tep)
 444{
 445	struct func_list *funclist;
 446	struct func_list *item;
 447	struct func_map *func_map;
 448	int i;
 449
 450	func_map = malloc(sizeof(*func_map) * (tep->func_count + 1));
 451	if (!func_map)
 452		return -1;
 453
 454	funclist = tep->funclist;
 455
 456	i = 0;
 457	while (funclist) {
 458		func_map[i].func = funclist->func;
 459		func_map[i].addr = funclist->addr;
 460		func_map[i].mod = funclist->mod;
 461		i++;
 462		item = funclist;
 463		funclist = funclist->next;
 464		free(item);
 465	}
 466
 467	qsort(func_map, tep->func_count, sizeof(*func_map), func_cmp);
 468
 469	/*
 470	 * Add a special record at the end.
 471	 */
 472	func_map[tep->func_count].func = NULL;
 473	func_map[tep->func_count].addr = 0;
 474	func_map[tep->func_count].mod = NULL;
 475
 476	tep->func_map = func_map;
 477	tep->funclist = NULL;
 478
 479	return 0;
 480}
 481
 482static struct func_map *
 483__find_func(struct tep_handle *tep, unsigned long long addr)
 484{
 485	struct func_map *func;
 486	struct func_map key;
 487
 488	if (!tep->func_map)
 489		func_map_init(tep);
 490
 491	key.addr = addr;
 492
 493	func = bsearch(&key, tep->func_map, tep->func_count,
 494		       sizeof(*tep->func_map), func_bcmp);
 495
 496	return func;
 497}
 498
 499struct func_resolver {
 500	tep_func_resolver_t	*func;
 501	void			*priv;
 502	struct func_map		map;
 503};
 504
 505/**
 506 * tep_set_function_resolver - set an alternative function resolver
 507 * @tep: a handle to the trace event parser context
 508 * @resolver: function to be used
 509 * @priv: resolver function private state.
 510 *
 511 * Some tools may have already a way to resolve kernel functions, allow them to
 512 * keep using it instead of duplicating all the entries inside tep->funclist.
 
 513 */
 514int tep_set_function_resolver(struct tep_handle *tep,
 515			      tep_func_resolver_t *func, void *priv)
 516{
 517	struct func_resolver *resolver = malloc(sizeof(*resolver));
 518
 519	if (resolver == NULL)
 520		return -1;
 521
 522	resolver->func = func;
 523	resolver->priv = priv;
 524
 525	free(tep->func_resolver);
 526	tep->func_resolver = resolver;
 527
 528	return 0;
 529}
 530
 531/**
 532 * tep_reset_function_resolver - reset alternative function resolver
 533 * @tep: a handle to the trace event parser context
 534 *
 535 * Stop using whatever alternative resolver was set, use the default
 536 * one instead.
 537 */
 538void tep_reset_function_resolver(struct tep_handle *tep)
 539{
 540	free(tep->func_resolver);
 541	tep->func_resolver = NULL;
 542}
 543
 544static struct func_map *
 545find_func(struct tep_handle *tep, unsigned long long addr)
 546{
 547	struct func_map *map;
 548
 549	if (!tep->func_resolver)
 550		return __find_func(tep, addr);
 551
 552	map = &tep->func_resolver->map;
 553	map->mod  = NULL;
 554	map->addr = addr;
 555	map->func = tep->func_resolver->func(tep->func_resolver->priv,
 556					     &map->addr, &map->mod);
 557	if (map->func == NULL)
 558		return NULL;
 559
 560	return map;
 561}
 562
 563/**
 564 * tep_find_function - find a function by a given address
 565 * @tep: a handle to the trace event parser context
 566 * @addr: the address to find the function with
 567 *
 568 * Returns a pointer to the function stored that has the given
 569 * address. Note, the address does not have to be exact, it
 570 * will select the function that would contain the address.
 571 */
 572const char *tep_find_function(struct tep_handle *tep, unsigned long long addr)
 573{
 574	struct func_map *map;
 575
 576	map = find_func(tep, addr);
 577	if (!map)
 578		return NULL;
 579
 580	return map->func;
 581}
 582
 583/**
 584 * tep_find_function_address - find a function address by a given address
 585 * @tep: a handle to the trace event parser context
 586 * @addr: the address to find the function with
 587 *
 588 * Returns the address the function starts at. This can be used in
 589 * conjunction with tep_find_function to print both the function
 590 * name and the function offset.
 591 */
 592unsigned long long
 593tep_find_function_address(struct tep_handle *tep, unsigned long long addr)
 594{
 595	struct func_map *map;
 596
 597	map = find_func(tep, addr);
 598	if (!map)
 599		return 0;
 600
 601	return map->addr;
 602}
 603
 604/**
 605 * tep_register_function - register a function with a given address
 606 * @tep: a handle to the trace event parser context
 607 * @function: the function name to register
 608 * @addr: the address the function starts at
 609 * @mod: the kernel module the function may be in (NULL for none)
 610 *
 611 * This registers a function name with an address and module.
 612 * The @func passed in is duplicated.
 613 */
 614int tep_register_function(struct tep_handle *tep, char *func,
 615			  unsigned long long addr, char *mod)
 616{
 617	struct func_list *item = malloc(sizeof(*item));
 618
 619	if (!item)
 620		return -1;
 621
 622	item->next = tep->funclist;
 623	item->func = strdup(func);
 624	if (!item->func)
 625		goto out_free;
 626
 627	if (mod) {
 628		item->mod = strdup(mod);
 629		if (!item->mod)
 630			goto out_free_func;
 631	} else
 632		item->mod = NULL;
 633	item->addr = addr;
 634
 635	tep->funclist = item;
 636	tep->func_count++;
 637
 638	return 0;
 639
 640out_free_func:
 641	free(item->func);
 642	item->func = NULL;
 643out_free:
 644	free(item);
 645	errno = ENOMEM;
 646	return -1;
 647}
 648
 649/**
 650 * tep_print_funcs - print out the stored functions
 651 * @tep: a handle to the trace event parser context
 652 *
 653 * This prints out the stored functions.
 654 */
 655void tep_print_funcs(struct tep_handle *tep)
 656{
 657	int i;
 658
 659	if (!tep->func_map)
 660		func_map_init(tep);
 661
 662	for (i = 0; i < (int)tep->func_count; i++) {
 663		printf("%016llx %s",
 664		       tep->func_map[i].addr,
 665		       tep->func_map[i].func);
 666		if (tep->func_map[i].mod)
 667			printf(" [%s]\n", tep->func_map[i].mod);
 668		else
 669			printf("\n");
 670	}
 671}
 672
 673struct printk_map {
 674	unsigned long long		addr;
 675	char				*printk;
 676};
 677
 678struct printk_list {
 679	struct printk_list	*next;
 680	unsigned long long	addr;
 681	char			*printk;
 682};
 683
 684static int printk_cmp(const void *a, const void *b)
 685{
 686	const struct printk_map *pa = a;
 687	const struct printk_map *pb = b;
 688
 689	if (pa->addr < pb->addr)
 690		return -1;
 691	if (pa->addr > pb->addr)
 692		return 1;
 693
 694	return 0;
 695}
 696
 697static int printk_map_init(struct tep_handle *tep)
 698{
 699	struct printk_list *printklist;
 700	struct printk_list *item;
 701	struct printk_map *printk_map;
 702	int i;
 703
 704	printk_map = malloc(sizeof(*printk_map) * (tep->printk_count + 1));
 705	if (!printk_map)
 706		return -1;
 707
 708	printklist = tep->printklist;
 709
 710	i = 0;
 711	while (printklist) {
 712		printk_map[i].printk = printklist->printk;
 713		printk_map[i].addr = printklist->addr;
 714		i++;
 715		item = printklist;
 716		printklist = printklist->next;
 717		free(item);
 718	}
 719
 720	qsort(printk_map, tep->printk_count, sizeof(*printk_map), printk_cmp);
 721
 722	tep->printk_map = printk_map;
 723	tep->printklist = NULL;
 724
 725	return 0;
 726}
 727
 728static struct printk_map *
 729find_printk(struct tep_handle *tep, unsigned long long addr)
 730{
 731	struct printk_map *printk;
 732	struct printk_map key;
 733
 734	if (!tep->printk_map && printk_map_init(tep))
 735		return NULL;
 736
 737	key.addr = addr;
 738
 739	printk = bsearch(&key, tep->printk_map, tep->printk_count,
 740			 sizeof(*tep->printk_map), printk_cmp);
 741
 742	return printk;
 743}
 744
 745/**
 746 * tep_register_print_string - register a string by its address
 747 * @tep: a handle to the trace event parser context
 748 * @fmt: the string format to register
 749 * @addr: the address the string was located at
 750 *
 751 * This registers a string by the address it was stored in the kernel.
 752 * The @fmt passed in is duplicated.
 753 */
 754int tep_register_print_string(struct tep_handle *tep, const char *fmt,
 755			      unsigned long long addr)
 756{
 757	struct printk_list *item = malloc(sizeof(*item));
 758	char *p;
 759
 760	if (!item)
 761		return -1;
 762
 763	item->next = tep->printklist;
 764	item->addr = addr;
 765
 766	/* Strip off quotes and '\n' from the end */
 767	if (fmt[0] == '"')
 768		fmt++;
 769	item->printk = strdup(fmt);
 770	if (!item->printk)
 771		goto out_free;
 772
 773	p = item->printk + strlen(item->printk) - 1;
 774	if (*p == '"')
 775		*p = 0;
 776
 777	p -= 2;
 778	if (strcmp(p, "\\n") == 0)
 779		*p = 0;
 780
 781	tep->printklist = item;
 782	tep->printk_count++;
 783
 784	return 0;
 785
 786out_free:
 787	free(item);
 788	errno = ENOMEM;
 789	return -1;
 790}
 791
 792/**
 793 * tep_print_printk - print out the stored strings
 794 * @tep: a handle to the trace event parser context
 795 *
 796 * This prints the string formats that were stored.
 797 */
 798void tep_print_printk(struct tep_handle *tep)
 799{
 800	int i;
 801
 802	if (!tep->printk_map)
 803		printk_map_init(tep);
 804
 805	for (i = 0; i < (int)tep->printk_count; i++) {
 806		printf("%016llx %s\n",
 807		       tep->printk_map[i].addr,
 808		       tep->printk_map[i].printk);
 809	}
 810}
 811
 812static struct tep_event *alloc_event(void)
 813{
 814	return calloc(1, sizeof(struct tep_event));
 815}
 816
 817static int add_event(struct tep_handle *tep, struct tep_event *event)
 818{
 819	int i;
 820	struct tep_event **events = realloc(tep->events, sizeof(event) *
 821					    (tep->nr_events + 1));
 822	if (!events)
 823		return -1;
 824
 825	tep->events = events;
 826
 827	for (i = 0; i < tep->nr_events; i++) {
 828		if (tep->events[i]->id > event->id)
 829			break;
 830	}
 831	if (i < tep->nr_events)
 832		memmove(&tep->events[i + 1],
 833			&tep->events[i],
 834			sizeof(event) * (tep->nr_events - i));
 835
 836	tep->events[i] = event;
 837	tep->nr_events++;
 838
 839	event->tep = tep;
 840
 841	return 0;
 842}
 843
 844static int event_item_type(enum tep_event_type type)
 845{
 846	switch (type) {
 847	case TEP_EVENT_ITEM ... TEP_EVENT_SQUOTE:
 848		return 1;
 849	case TEP_EVENT_ERROR ... TEP_EVENT_DELIM:
 850	default:
 851		return 0;
 852	}
 853}
 854
 855static void free_flag_sym(struct tep_print_flag_sym *fsym)
 856{
 857	struct tep_print_flag_sym *next;
 858
 859	while (fsym) {
 860		next = fsym->next;
 861		free(fsym->value);
 862		free(fsym->str);
 863		free(fsym);
 864		fsym = next;
 865	}
 866}
 867
 868static void free_arg(struct tep_print_arg *arg)
 869{
 870	struct tep_print_arg *farg;
 871
 872	if (!arg)
 873		return;
 874
 875	switch (arg->type) {
 876	case TEP_PRINT_ATOM:
 877		free(arg->atom.atom);
 878		break;
 879	case TEP_PRINT_FIELD:
 880		free(arg->field.name);
 881		break;
 882	case TEP_PRINT_FLAGS:
 883		free_arg(arg->flags.field);
 884		free(arg->flags.delim);
 885		free_flag_sym(arg->flags.flags);
 886		break;
 887	case TEP_PRINT_SYMBOL:
 888		free_arg(arg->symbol.field);
 889		free_flag_sym(arg->symbol.symbols);
 890		break;
 891	case TEP_PRINT_HEX:
 892	case TEP_PRINT_HEX_STR:
 893		free_arg(arg->hex.field);
 894		free_arg(arg->hex.size);
 895		break;
 896	case TEP_PRINT_INT_ARRAY:
 897		free_arg(arg->int_array.field);
 898		free_arg(arg->int_array.count);
 899		free_arg(arg->int_array.el_size);
 900		break;
 901	case TEP_PRINT_TYPE:
 902		free(arg->typecast.type);
 903		free_arg(arg->typecast.item);
 904		break;
 905	case TEP_PRINT_STRING:
 906	case TEP_PRINT_BSTRING:
 907		free(arg->string.string);
 908		break;
 909	case TEP_PRINT_BITMASK:
 910		free(arg->bitmask.bitmask);
 911		break;
 912	case TEP_PRINT_DYNAMIC_ARRAY:
 913	case TEP_PRINT_DYNAMIC_ARRAY_LEN:
 914		free(arg->dynarray.index);
 915		break;
 916	case TEP_PRINT_OP:
 917		free(arg->op.op);
 918		free_arg(arg->op.left);
 919		free_arg(arg->op.right);
 920		break;
 921	case TEP_PRINT_FUNC:
 922		while (arg->func.args) {
 923			farg = arg->func.args;
 924			arg->func.args = farg->next;
 925			free_arg(farg);
 926		}
 927		break;
 928
 929	case TEP_PRINT_NULL:
 930	default:
 931		break;
 932	}
 933
 934	free(arg);
 935}
 936
 937static enum tep_event_type get_type(int ch)
 938{
 939	if (ch == '\n')
 940		return TEP_EVENT_NEWLINE;
 941	if (isspace(ch))
 942		return TEP_EVENT_SPACE;
 943	if (isalnum(ch) || ch == '_')
 944		return TEP_EVENT_ITEM;
 945	if (ch == '\'')
 946		return TEP_EVENT_SQUOTE;
 947	if (ch == '"')
 948		return TEP_EVENT_DQUOTE;
 949	if (!isprint(ch))
 950		return TEP_EVENT_NONE;
 951	if (ch == '(' || ch == ')' || ch == ',')
 952		return TEP_EVENT_DELIM;
 953
 954	return TEP_EVENT_OP;
 955}
 956
 957static int __read_char(void)
 958{
 959	if (input_buf_ptr >= input_buf_siz)
 960		return -1;
 961
 962	return input_buf[input_buf_ptr++];
 963}
 964
 965static int __peek_char(void)
 966{
 967	if (input_buf_ptr >= input_buf_siz)
 968		return -1;
 969
 970	return input_buf[input_buf_ptr];
 971}
 972
 973/**
 974 * tep_peek_char - peek at the next character that will be read
 975 *
 976 * Returns the next character read, or -1 if end of buffer.
 977 */
 978int tep_peek_char(void)
 979{
 980	return __peek_char();
 981}
 982
 983static int extend_token(char **tok, char *buf, int size)
 984{
 985	char *newtok = realloc(*tok, size);
 986
 987	if (!newtok) {
 988		free(*tok);
 989		*tok = NULL;
 990		return -1;
 991	}
 992
 993	if (!*tok)
 994		strcpy(newtok, buf);
 995	else
 996		strcat(newtok, buf);
 997	*tok = newtok;
 998
 999	return 0;
1000}
1001
1002static enum tep_event_type force_token(const char *str, char **tok);
1003
1004static enum tep_event_type __read_token(char **tok)
1005{
1006	char buf[BUFSIZ];
1007	int ch, last_ch, quote_ch, next_ch;
1008	int i = 0;
1009	int tok_size = 0;
1010	enum tep_event_type type;
1011
1012	*tok = NULL;
1013
1014
1015	ch = __read_char();
1016	if (ch < 0)
1017		return TEP_EVENT_NONE;
1018
1019	type = get_type(ch);
1020	if (type == TEP_EVENT_NONE)
1021		return type;
1022
1023	buf[i++] = ch;
1024
1025	switch (type) {
1026	case TEP_EVENT_NEWLINE:
1027	case TEP_EVENT_DELIM:
1028		if (asprintf(tok, "%c", ch) < 0)
1029			return TEP_EVENT_ERROR;
1030
1031		return type;
1032
1033	case TEP_EVENT_OP:
1034		switch (ch) {
1035		case '-':
1036			next_ch = __peek_char();
1037			if (next_ch == '>') {
1038				buf[i++] = __read_char();
1039				break;
1040			}
1041			/* fall through */
1042		case '+':
1043		case '|':
1044		case '&':
1045		case '>':
1046		case '<':
1047			last_ch = ch;
1048			ch = __peek_char();
1049			if (ch != last_ch)
1050				goto test_equal;
1051			buf[i++] = __read_char();
1052			switch (last_ch) {
1053			case '>':
1054			case '<':
1055				goto test_equal;
1056			default:
1057				break;
1058			}
1059			break;
1060		case '!':
1061		case '=':
1062			goto test_equal;
1063		default: /* what should we do instead? */
1064			break;
1065		}
1066		buf[i] = 0;
1067		*tok = strdup(buf);
1068		return type;
1069
1070 test_equal:
1071		ch = __peek_char();
1072		if (ch == '=')
1073			buf[i++] = __read_char();
1074		goto out;
1075
1076	case TEP_EVENT_DQUOTE:
1077	case TEP_EVENT_SQUOTE:
1078		/* don't keep quotes */
1079		i--;
1080		quote_ch = ch;
1081		last_ch = 0;
1082 concat:
1083		do {
1084			if (i == (BUFSIZ - 1)) {
1085				buf[i] = 0;
1086				tok_size += BUFSIZ;
1087
1088				if (extend_token(tok, buf, tok_size) < 0)
1089					return TEP_EVENT_NONE;
1090				i = 0;
1091			}
1092			last_ch = ch;
1093			ch = __read_char();
1094			buf[i++] = ch;
1095			/* the '\' '\' will cancel itself */
1096			if (ch == '\\' && last_ch == '\\')
1097				last_ch = 0;
1098		} while (ch != quote_ch || last_ch == '\\');
1099		/* remove the last quote */
1100		i--;
1101
1102		/*
1103		 * For strings (double quotes) check the next token.
1104		 * If it is another string, concatinate the two.
1105		 */
1106		if (type == TEP_EVENT_DQUOTE) {
1107			unsigned long long save_input_buf_ptr = input_buf_ptr;
1108
1109			do {
1110				ch = __read_char();
1111			} while (isspace(ch));
1112			if (ch == '"')
1113				goto concat;
1114			input_buf_ptr = save_input_buf_ptr;
1115		}
1116
1117		goto out;
1118
1119	case TEP_EVENT_ERROR ... TEP_EVENT_SPACE:
1120	case TEP_EVENT_ITEM:
1121	default:
1122		break;
1123	}
1124
1125	while (get_type(__peek_char()) == type) {
1126		if (i == (BUFSIZ - 1)) {
1127			buf[i] = 0;
1128			tok_size += BUFSIZ;
1129
1130			if (extend_token(tok, buf, tok_size) < 0)
1131				return TEP_EVENT_NONE;
1132			i = 0;
1133		}
1134		ch = __read_char();
1135		buf[i++] = ch;
1136	}
1137
1138 out:
1139	buf[i] = 0;
1140	if (extend_token(tok, buf, tok_size + i + 1) < 0)
1141		return TEP_EVENT_NONE;
1142
1143	if (type == TEP_EVENT_ITEM) {
1144		/*
1145		 * Older versions of the kernel has a bug that
1146		 * creates invalid symbols and will break the mac80211
1147		 * parsing. This is a work around to that bug.
1148		 *
1149		 * See Linux kernel commit:
1150		 *  811cb50baf63461ce0bdb234927046131fc7fa8b
1151		 */
1152		if (strcmp(*tok, "LOCAL_PR_FMT") == 0) {
1153			free(*tok);
1154			*tok = NULL;
1155			return force_token("\"%s\" ", tok);
1156		} else if (strcmp(*tok, "STA_PR_FMT") == 0) {
1157			free(*tok);
1158			*tok = NULL;
1159			return force_token("\" sta:%pM\" ", tok);
1160		} else if (strcmp(*tok, "VIF_PR_FMT") == 0) {
1161			free(*tok);
1162			*tok = NULL;
1163			return force_token("\" vif:%p(%d)\" ", tok);
1164		}
1165	}
1166
1167	return type;
1168}
1169
1170static enum tep_event_type force_token(const char *str, char **tok)
1171{
1172	const char *save_input_buf;
1173	unsigned long long save_input_buf_ptr;
1174	unsigned long long save_input_buf_siz;
1175	enum tep_event_type type;
1176	
1177	/* save off the current input pointers */
1178	save_input_buf = input_buf;
1179	save_input_buf_ptr = input_buf_ptr;
1180	save_input_buf_siz = input_buf_siz;
1181
1182	init_input_buf(str, strlen(str));
1183
1184	type = __read_token(tok);
1185
1186	/* reset back to original token */
1187	input_buf = save_input_buf;
1188	input_buf_ptr = save_input_buf_ptr;
1189	input_buf_siz = save_input_buf_siz;
1190
1191	return type;
1192}
1193
1194static void free_token(char *tok)
1195{
1196	if (tok)
1197		free(tok);
1198}
1199
1200static enum tep_event_type read_token(char **tok)
1201{
1202	enum tep_event_type type;
1203
1204	for (;;) {
1205		type = __read_token(tok);
1206		if (type != TEP_EVENT_SPACE)
1207			return type;
1208
1209		free_token(*tok);
1210	}
1211
1212	/* not reached */
1213	*tok = NULL;
1214	return TEP_EVENT_NONE;
1215}
1216
1217/**
1218 * tep_read_token - access to utilities to use the tep parser
1219 * @tok: The token to return
1220 *
1221 * This will parse tokens from the string given by
1222 * tep_init_data().
1223 *
1224 * Returns the token type.
1225 */
1226enum tep_event_type tep_read_token(char **tok)
1227{
1228	return read_token(tok);
1229}
1230
1231/**
1232 * tep_free_token - free a token returned by tep_read_token
1233 * @token: the token to free
1234 */
1235void tep_free_token(char *token)
1236{
1237	free_token(token);
1238}
1239
1240/* no newline */
1241static enum tep_event_type read_token_item(char **tok)
1242{
1243	enum tep_event_type type;
1244
1245	for (;;) {
1246		type = __read_token(tok);
1247		if (type != TEP_EVENT_SPACE && type != TEP_EVENT_NEWLINE)
1248			return type;
1249		free_token(*tok);
1250		*tok = NULL;
1251	}
1252
1253	/* not reached */
1254	*tok = NULL;
1255	return TEP_EVENT_NONE;
1256}
1257
1258static int test_type(enum tep_event_type type, enum tep_event_type expect)
1259{
1260	if (type != expect) {
1261		do_warning("Error: expected type %d but read %d",
1262		    expect, type);
1263		return -1;
1264	}
1265	return 0;
1266}
1267
1268static int test_type_token(enum tep_event_type type, const char *token,
1269		    enum tep_event_type expect, const char *expect_tok)
1270{
1271	if (type != expect) {
1272		do_warning("Error: expected type %d but read %d",
1273		    expect, type);
1274		return -1;
1275	}
1276
1277	if (strcmp(token, expect_tok) != 0) {
1278		do_warning("Error: expected '%s' but read '%s'",
1279		    expect_tok, token);
1280		return -1;
1281	}
1282	return 0;
1283}
1284
1285static int __read_expect_type(enum tep_event_type expect, char **tok, int newline_ok)
1286{
1287	enum tep_event_type type;
1288
1289	if (newline_ok)
1290		type = read_token(tok);
1291	else
1292		type = read_token_item(tok);
1293	return test_type(type, expect);
1294}
1295
1296static int read_expect_type(enum tep_event_type expect, char **tok)
1297{
1298	return __read_expect_type(expect, tok, 1);
1299}
1300
1301static int __read_expected(enum tep_event_type expect, const char *str,
1302			   int newline_ok)
1303{
1304	enum tep_event_type type;
1305	char *token;
1306	int ret;
1307
1308	if (newline_ok)
1309		type = read_token(&token);
1310	else
1311		type = read_token_item(&token);
1312
1313	ret = test_type_token(type, token, expect, str);
1314
1315	free_token(token);
1316
1317	return ret;
1318}
1319
1320static int read_expected(enum tep_event_type expect, const char *str)
1321{
1322	return __read_expected(expect, str, 1);
1323}
1324
1325static int read_expected_item(enum tep_event_type expect, const char *str)
1326{
1327	return __read_expected(expect, str, 0);
1328}
1329
1330static char *event_read_name(void)
1331{
1332	char *token;
1333
1334	if (read_expected(TEP_EVENT_ITEM, "name") < 0)
1335		return NULL;
1336
1337	if (read_expected(TEP_EVENT_OP, ":") < 0)
1338		return NULL;
1339
1340	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1341		goto fail;
1342
1343	return token;
1344
1345 fail:
1346	free_token(token);
1347	return NULL;
1348}
1349
1350static int event_read_id(void)
1351{
1352	char *token;
1353	int id;
1354
1355	if (read_expected_item(TEP_EVENT_ITEM, "ID") < 0)
1356		return -1;
1357
1358	if (read_expected(TEP_EVENT_OP, ":") < 0)
1359		return -1;
1360
1361	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1362		goto fail;
1363
1364	id = strtoul(token, NULL, 0);
1365	free_token(token);
1366	return id;
1367
1368 fail:
1369	free_token(token);
1370	return -1;
1371}
1372
1373static int field_is_string(struct tep_format_field *field)
1374{
1375	if ((field->flags & TEP_FIELD_IS_ARRAY) &&
1376	    (strstr(field->type, "char") || strstr(field->type, "u8") ||
1377	     strstr(field->type, "s8")))
1378		return 1;
1379
1380	return 0;
1381}
1382
1383static int field_is_dynamic(struct tep_format_field *field)
1384{
1385	if (strncmp(field->type, "__data_loc", 10) == 0)
1386		return 1;
1387
1388	return 0;
1389}
1390
1391static int field_is_long(struct tep_format_field *field)
1392{
1393	/* includes long long */
1394	if (strstr(field->type, "long"))
1395		return 1;
1396
1397	return 0;
1398}
1399
1400static unsigned int type_size(const char *name)
1401{
1402	/* This covers all TEP_FIELD_IS_STRING types. */
1403	static struct {
1404		const char *type;
1405		unsigned int size;
1406	} table[] = {
1407		{ "u8",   1 },
1408		{ "u16",  2 },
1409		{ "u32",  4 },
1410		{ "u64",  8 },
1411		{ "s8",   1 },
1412		{ "s16",  2 },
1413		{ "s32",  4 },
1414		{ "s64",  8 },
1415		{ "char", 1 },
1416		{ },
1417	};
1418	int i;
1419
1420	for (i = 0; table[i].type; i++) {
1421		if (!strcmp(table[i].type, name))
1422			return table[i].size;
1423	}
1424
1425	return 0;
1426}
1427
1428static int append(char **buf, const char *delim, const char *str)
1429{
1430	char *new_buf;
1431
1432	new_buf = realloc(*buf, strlen(*buf) + strlen(delim) + strlen(str) + 1);
1433	if (!new_buf)
1434		return -1;
1435	strcat(new_buf, delim);
1436	strcat(new_buf, str);
1437	*buf = new_buf;
1438	return 0;
1439}
1440
1441static int event_read_fields(struct tep_event *event, struct tep_format_field **fields)
1442{
1443	struct tep_format_field *field = NULL;
1444	enum tep_event_type type;
1445	char *token;
1446	char *last_token;
1447	char *delim = " ";
1448	int count = 0;
1449	int ret;
1450
1451	do {
1452		unsigned int size_dynamic = 0;
1453
1454		type = read_token(&token);
1455		if (type == TEP_EVENT_NEWLINE) {
1456			free_token(token);
1457			return count;
1458		}
1459
1460		count++;
1461
1462		if (test_type_token(type, token, TEP_EVENT_ITEM, "field"))
1463			goto fail;
1464		free_token(token);
1465
1466		type = read_token(&token);
1467		/*
1468		 * The ftrace fields may still use the "special" name.
1469		 * Just ignore it.
1470		 */
1471		if (event->flags & TEP_EVENT_FL_ISFTRACE &&
1472		    type == TEP_EVENT_ITEM && strcmp(token, "special") == 0) {
1473			free_token(token);
1474			type = read_token(&token);
1475		}
1476
1477		if (test_type_token(type, token, TEP_EVENT_OP, ":") < 0)
1478			goto fail;
1479
1480		free_token(token);
1481		if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1482			goto fail;
1483
1484		last_token = token;
1485
1486		field = calloc(1, sizeof(*field));
1487		if (!field)
1488			goto fail;
1489
1490		field->event = event;
1491
1492		/* read the rest of the type */
1493		for (;;) {
1494			type = read_token(&token);
1495			if (type == TEP_EVENT_ITEM ||
1496			    (type == TEP_EVENT_OP && strcmp(token, "*") == 0) ||
1497			    /*
1498			     * Some of the ftrace fields are broken and have
1499			     * an illegal "." in them.
1500			     */
1501			    (event->flags & TEP_EVENT_FL_ISFTRACE &&
1502			     type == TEP_EVENT_OP && strcmp(token, ".") == 0)) {
1503
1504				if (strcmp(token, "*") == 0)
1505					field->flags |= TEP_FIELD_IS_POINTER;
1506
1507				if (field->type) {
1508					ret = append(&field->type, delim, last_token);
1509					free(last_token);
1510					if (ret < 0)
 
 
 
1511						goto fail;
 
 
 
 
 
1512				} else
1513					field->type = last_token;
1514				last_token = token;
1515				delim = " ";
1516				continue;
1517			}
1518
1519			/* Handle __attribute__((user)) */
1520			if ((type == TEP_EVENT_DELIM) &&
1521			    strcmp("__attribute__", last_token) == 0 &&
1522			    token[0] == '(') {
1523				int depth = 1;
1524				int ret;
1525
1526				ret = append(&field->type, " ", last_token);
1527				ret |= append(&field->type, "", "(");
1528				if (ret < 0)
1529					goto fail;
1530
1531				delim = " ";
1532				while ((type = read_token(&token)) != TEP_EVENT_NONE) {
1533					if (type == TEP_EVENT_DELIM) {
1534						if (token[0] == '(')
1535							depth++;
1536						else if (token[0] == ')')
1537							depth--;
1538						if (!depth)
1539							break;
1540						ret = append(&field->type, "", token);
1541						delim = "";
1542					} else {
1543						ret = append(&field->type, delim, token);
1544						delim = " ";
1545					}
1546					if (ret < 0)
1547						goto fail;
1548					free(last_token);
1549					last_token = token;
1550				}
1551				continue;
1552			}
1553			break;
1554		}
1555
1556		if (!field->type) {
1557			do_warning_event(event, "%s: no type found", __func__);
1558			goto fail;
1559		}
1560		field->name = field->alias = last_token;
1561
1562		if (test_type(type, TEP_EVENT_OP))
1563			goto fail;
1564
1565		if (strcmp(token, "[") == 0) {
1566			enum tep_event_type last_type = type;
1567			char *brackets = token;
 
 
1568
1569			field->flags |= TEP_FIELD_IS_ARRAY;
1570
1571			type = read_token(&token);
1572
1573			if (type == TEP_EVENT_ITEM)
1574				field->arraylen = strtoul(token, NULL, 0);
1575			else
1576				field->arraylen = 0;
1577
1578		        while (strcmp(token, "]") != 0) {
1579				const char *delim;
1580
1581				if (last_type == TEP_EVENT_ITEM &&
1582				    type == TEP_EVENT_ITEM)
1583					delim = " ";
1584				else
1585					delim = "";
1586
1587				last_type = type;
1588
1589				ret = append(&brackets, delim, token);
1590				if (ret < 0) {
 
 
1591					free(brackets);
1592					goto fail;
1593				}
 
 
 
 
1594				/* We only care about the last token */
1595				field->arraylen = strtoul(token, NULL, 0);
1596				free_token(token);
1597				type = read_token(&token);
1598				if (type == TEP_EVENT_NONE) {
1599					free(brackets);
1600					do_warning_event(event, "failed to find token");
1601					goto fail;
1602				}
1603			}
1604
1605			free_token(token);
1606
1607			ret = append(&brackets, "", "]");
1608			if (ret < 0) {
1609				free(brackets);
1610				goto fail;
1611			}
 
 
1612
1613			/* add brackets to type */
1614
1615			type = read_token(&token);
1616			/*
1617			 * If the next token is not an OP, then it is of
1618			 * the format: type [] item;
1619			 */
1620			if (type == TEP_EVENT_ITEM) {
1621				ret = append(&field->type, " ", field->name);
1622				if (ret < 0) {
 
 
 
 
1623					free(brackets);
1624					goto fail;
1625				}
1626				ret = append(&field->type, "", brackets);
1627
 
1628				size_dynamic = type_size(field->name);
1629				free_token(field->name);
 
1630				field->name = field->alias = token;
1631				type = read_token(&token);
1632			} else {
1633				ret = append(&field->type, "", brackets);
1634				if (ret < 0) {
 
 
 
1635					free(brackets);
1636					goto fail;
1637				}
 
 
1638			}
1639			free(brackets);
1640		}
1641
1642		if (field_is_string(field))
1643			field->flags |= TEP_FIELD_IS_STRING;
1644		if (field_is_dynamic(field))
1645			field->flags |= TEP_FIELD_IS_DYNAMIC;
1646		if (field_is_long(field))
1647			field->flags |= TEP_FIELD_IS_LONG;
1648
1649		if (test_type_token(type, token,  TEP_EVENT_OP, ";"))
1650			goto fail;
1651		free_token(token);
1652
1653		if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
1654			goto fail_expect;
1655
1656		if (read_expected(TEP_EVENT_OP, ":") < 0)
1657			goto fail_expect;
1658
1659		if (read_expect_type(TEP_EVENT_ITEM, &token))
1660			goto fail;
1661		field->offset = strtoul(token, NULL, 0);
1662		free_token(token);
1663
1664		if (read_expected(TEP_EVENT_OP, ";") < 0)
1665			goto fail_expect;
1666
1667		if (read_expected(TEP_EVENT_ITEM, "size") < 0)
1668			goto fail_expect;
1669
1670		if (read_expected(TEP_EVENT_OP, ":") < 0)
1671			goto fail_expect;
1672
1673		if (read_expect_type(TEP_EVENT_ITEM, &token))
1674			goto fail;
1675		field->size = strtoul(token, NULL, 0);
1676		free_token(token);
1677
1678		if (read_expected(TEP_EVENT_OP, ";") < 0)
1679			goto fail_expect;
1680
1681		type = read_token(&token);
1682		if (type != TEP_EVENT_NEWLINE) {
1683			/* newer versions of the kernel have a "signed" type */
1684			if (test_type_token(type, token, TEP_EVENT_ITEM, "signed"))
1685				goto fail;
1686
1687			free_token(token);
1688
1689			if (read_expected(TEP_EVENT_OP, ":") < 0)
1690				goto fail_expect;
1691
1692			if (read_expect_type(TEP_EVENT_ITEM, &token))
1693				goto fail;
1694
1695			if (strtoul(token, NULL, 0))
1696				field->flags |= TEP_FIELD_IS_SIGNED;
1697
1698			free_token(token);
1699			if (read_expected(TEP_EVENT_OP, ";") < 0)
1700				goto fail_expect;
1701
1702			if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1703				goto fail;
1704		}
1705
1706		free_token(token);
1707
1708		if (field->flags & TEP_FIELD_IS_ARRAY) {
1709			if (field->arraylen)
1710				field->elementsize = field->size / field->arraylen;
1711			else if (field->flags & TEP_FIELD_IS_DYNAMIC)
1712				field->elementsize = size_dynamic;
1713			else if (field->flags & TEP_FIELD_IS_STRING)
1714				field->elementsize = 1;
1715			else if (field->flags & TEP_FIELD_IS_LONG)
1716				field->elementsize = event->tep ?
1717						     event->tep->long_size :
1718						     sizeof(long);
1719		} else
1720			field->elementsize = field->size;
1721
1722		*fields = field;
1723		fields = &field->next;
1724
1725	} while (1);
1726
1727	return 0;
1728
1729fail:
1730	free_token(token);
1731fail_expect:
1732	if (field) {
1733		free(field->type);
1734		free(field->name);
1735		free(field);
1736	}
1737	return -1;
1738}
1739
1740static int event_read_format(struct tep_event *event)
1741{
1742	char *token;
1743	int ret;
1744
1745	if (read_expected_item(TEP_EVENT_ITEM, "format") < 0)
1746		return -1;
1747
1748	if (read_expected(TEP_EVENT_OP, ":") < 0)
1749		return -1;
1750
1751	if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1752		goto fail;
1753	free_token(token);
1754
1755	ret = event_read_fields(event, &event->format.common_fields);
1756	if (ret < 0)
1757		return ret;
1758	event->format.nr_common = ret;
1759
1760	ret = event_read_fields(event, &event->format.fields);
1761	if (ret < 0)
1762		return ret;
1763	event->format.nr_fields = ret;
1764
1765	return 0;
1766
1767 fail:
1768	free_token(token);
1769	return -1;
1770}
1771
1772static enum tep_event_type
1773process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
1774		  char **tok, enum tep_event_type type);
1775
1776static enum tep_event_type
1777process_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1778{
1779	enum tep_event_type type;
1780	char *token;
1781
1782	type = read_token(&token);
1783	*tok = token;
1784
1785	return process_arg_token(event, arg, tok, type);
1786}
1787
1788static enum tep_event_type
1789process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok);
1790
1791/*
1792 * For __print_symbolic() and __print_flags, we need to completely
1793 * evaluate the first argument, which defines what to print next.
1794 */
1795static enum tep_event_type
1796process_field_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1797{
1798	enum tep_event_type type;
1799
1800	type = process_arg(event, arg, tok);
1801
1802	while (type == TEP_EVENT_OP) {
1803		type = process_op(event, arg, tok);
1804	}
1805
1806	return type;
1807}
1808
1809static enum tep_event_type
1810process_cond(struct tep_event *event, struct tep_print_arg *top, char **tok)
1811{
1812	struct tep_print_arg *arg, *left, *right;
1813	enum tep_event_type type;
1814	char *token = NULL;
1815
1816	arg = alloc_arg();
1817	left = alloc_arg();
1818	right = alloc_arg();
1819
1820	if (!arg || !left || !right) {
1821		do_warning_event(event, "%s: not enough memory!", __func__);
1822		/* arg will be freed at out_free */
1823		free_arg(left);
1824		free_arg(right);
1825		goto out_free;
1826	}
1827
1828	arg->type = TEP_PRINT_OP;
1829	arg->op.left = left;
1830	arg->op.right = right;
1831
1832	*tok = NULL;
1833	type = process_arg(event, left, &token);
1834
1835 again:
1836	if (type == TEP_EVENT_ERROR)
1837		goto out_free;
1838
1839	/* Handle other operations in the arguments */
1840	if (type == TEP_EVENT_OP && strcmp(token, ":") != 0) {
1841		type = process_op(event, left, &token);
1842		goto again;
1843	}
1844
1845	if (test_type_token(type, token, TEP_EVENT_OP, ":"))
1846		goto out_free;
1847
1848	arg->op.op = token;
1849
1850	type = process_arg(event, right, &token);
1851
1852	top->op.right = arg;
1853
1854	*tok = token;
1855	return type;
1856
1857out_free:
1858	/* Top may point to itself */
1859	top->op.right = NULL;
1860	free_token(token);
1861	free_arg(arg);
1862	return TEP_EVENT_ERROR;
1863}
1864
1865static enum tep_event_type
1866process_array(struct tep_event *event, struct tep_print_arg *top, char **tok)
1867{
1868	struct tep_print_arg *arg;
1869	enum tep_event_type type;
1870	char *token = NULL;
1871
1872	arg = alloc_arg();
1873	if (!arg) {
1874		do_warning_event(event, "%s: not enough memory!", __func__);
1875		/* '*tok' is set to top->op.op.  No need to free. */
1876		*tok = NULL;
1877		return TEP_EVENT_ERROR;
1878	}
1879
1880	*tok = NULL;
1881	type = process_arg(event, arg, &token);
1882	if (test_type_token(type, token, TEP_EVENT_OP, "]"))
1883		goto out_free;
1884
1885	top->op.right = arg;
1886
1887	free_token(token);
1888	type = read_token_item(&token);
1889	*tok = token;
1890
1891	return type;
1892
1893out_free:
1894	free_token(token);
1895	free_arg(arg);
1896	return TEP_EVENT_ERROR;
1897}
1898
1899static int get_op_prio(char *op)
1900{
1901	if (!op[1]) {
1902		switch (op[0]) {
1903		case '~':
1904		case '!':
1905			return 4;
1906		case '*':
1907		case '/':
1908		case '%':
1909			return 6;
1910		case '+':
1911		case '-':
1912			return 7;
1913			/* '>>' and '<<' are 8 */
1914		case '<':
1915		case '>':
1916			return 9;
1917			/* '==' and '!=' are 10 */
1918		case '&':
1919			return 11;
1920		case '^':
1921			return 12;
1922		case '|':
1923			return 13;
1924		case '?':
1925			return 16;
1926		default:
1927			do_warning("unknown op '%c'", op[0]);
1928			return -1;
1929		}
1930	} else {
1931		if (strcmp(op, "++") == 0 ||
1932		    strcmp(op, "--") == 0) {
1933			return 3;
1934		} else if (strcmp(op, ">>") == 0 ||
1935			   strcmp(op, "<<") == 0) {
1936			return 8;
1937		} else if (strcmp(op, ">=") == 0 ||
1938			   strcmp(op, "<=") == 0) {
1939			return 9;
1940		} else if (strcmp(op, "==") == 0 ||
1941			   strcmp(op, "!=") == 0) {
1942			return 10;
1943		} else if (strcmp(op, "&&") == 0) {
1944			return 14;
1945		} else if (strcmp(op, "||") == 0) {
1946			return 15;
1947		} else {
1948			do_warning("unknown op '%s'", op);
1949			return -1;
1950		}
1951	}
1952}
1953
1954static int set_op_prio(struct tep_print_arg *arg)
1955{
1956
1957	/* single ops are the greatest */
1958	if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
1959		arg->op.prio = 0;
1960	else
1961		arg->op.prio = get_op_prio(arg->op.op);
1962
1963	return arg->op.prio;
1964}
1965
1966/* Note, *tok does not get freed, but will most likely be saved */
1967static enum tep_event_type
1968process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1969{
1970	struct tep_print_arg *left, *right = NULL;
1971	enum tep_event_type type;
1972	char *token;
1973
1974	/* the op is passed in via tok */
1975	token = *tok;
1976
1977	if (arg->type == TEP_PRINT_OP && !arg->op.left) {
1978		/* handle single op */
1979		if (token[1]) {
1980			do_warning_event(event, "bad op token %s", token);
1981			goto out_free;
1982		}
1983		switch (token[0]) {
1984		case '~':
1985		case '!':
1986		case '+':
1987		case '-':
1988			break;
1989		default:
1990			do_warning_event(event, "bad op token %s", token);
1991			goto out_free;
1992
1993		}
1994
1995		/* make an empty left */
1996		left = alloc_arg();
1997		if (!left)
1998			goto out_warn_free;
1999
2000		left->type = TEP_PRINT_NULL;
2001		arg->op.left = left;
2002
2003		right = alloc_arg();
2004		if (!right)
2005			goto out_warn_free;
2006
2007		arg->op.right = right;
2008
2009		/* do not free the token, it belongs to an op */
2010		*tok = NULL;
2011		type = process_arg(event, right, tok);
2012
2013	} else if (strcmp(token, "?") == 0) {
2014
2015		left = alloc_arg();
2016		if (!left)
2017			goto out_warn_free;
2018
2019		/* copy the top arg to the left */
2020		*left = *arg;
2021
2022		arg->type = TEP_PRINT_OP;
2023		arg->op.op = token;
2024		arg->op.left = left;
2025		arg->op.prio = 0;
2026
2027		/* it will set arg->op.right */
2028		type = process_cond(event, arg, tok);
2029
2030	} else if (strcmp(token, ">>") == 0 ||
2031		   strcmp(token, "<<") == 0 ||
2032		   strcmp(token, "&") == 0 ||
2033		   strcmp(token, "|") == 0 ||
2034		   strcmp(token, "&&") == 0 ||
2035		   strcmp(token, "||") == 0 ||
2036		   strcmp(token, "-") == 0 ||
2037		   strcmp(token, "+") == 0 ||
2038		   strcmp(token, "*") == 0 ||
2039		   strcmp(token, "^") == 0 ||
2040		   strcmp(token, "/") == 0 ||
2041		   strcmp(token, "%") == 0 ||
2042		   strcmp(token, "<") == 0 ||
2043		   strcmp(token, ">") == 0 ||
2044		   strcmp(token, "<=") == 0 ||
2045		   strcmp(token, ">=") == 0 ||
2046		   strcmp(token, "==") == 0 ||
2047		   strcmp(token, "!=") == 0) {
2048
2049		left = alloc_arg();
2050		if (!left)
2051			goto out_warn_free;
2052
2053		/* copy the top arg to the left */
2054		*left = *arg;
2055
2056		arg->type = TEP_PRINT_OP;
2057		arg->op.op = token;
2058		arg->op.left = left;
2059		arg->op.right = NULL;
2060
2061		if (set_op_prio(arg) == -1) {
2062			event->flags |= TEP_EVENT_FL_FAILED;
2063			/* arg->op.op (= token) will be freed at out_free */
2064			arg->op.op = NULL;
2065			goto out_free;
2066		}
2067
2068		type = read_token_item(&token);
2069		*tok = token;
2070
2071		/* could just be a type pointer */
2072		if ((strcmp(arg->op.op, "*") == 0) &&
2073		    type == TEP_EVENT_DELIM && (strcmp(token, ")") == 0)) {
2074			int ret;
2075
2076			if (left->type != TEP_PRINT_ATOM) {
2077				do_warning_event(event, "bad pointer type");
2078				goto out_free;
2079			}
2080			ret = append(&left->atom.atom, " ", "*");
2081			if (ret < 0)
 
2082				goto out_warn_free;
2083
 
 
2084			free(arg->op.op);
2085			*arg = *left;
2086			free(left);
2087
2088			return type;
2089		}
2090
2091		right = alloc_arg();
2092		if (!right)
2093			goto out_warn_free;
2094
2095		type = process_arg_token(event, right, tok, type);
2096		if (type == TEP_EVENT_ERROR) {
2097			free_arg(right);
2098			/* token was freed in process_arg_token() via *tok */
2099			token = NULL;
2100			goto out_free;
2101		}
2102
2103		if (right->type == TEP_PRINT_OP &&
2104		    get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
2105			struct tep_print_arg tmp;
2106
2107			/* rotate ops according to the priority */
2108			arg->op.right = right->op.left;
2109
2110			tmp = *arg;
2111			*arg = *right;
2112			*right = tmp;
2113
2114			arg->op.left = right;
2115		} else {
2116			arg->op.right = right;
2117		}
2118
2119	} else if (strcmp(token, "[") == 0) {
2120
2121		left = alloc_arg();
2122		if (!left)
2123			goto out_warn_free;
2124
2125		*left = *arg;
2126
2127		arg->type = TEP_PRINT_OP;
2128		arg->op.op = token;
2129		arg->op.left = left;
2130
2131		arg->op.prio = 0;
2132
2133		/* it will set arg->op.right */
2134		type = process_array(event, arg, tok);
2135
2136	} else {
2137		do_warning_event(event, "unknown op '%s'", token);
2138		event->flags |= TEP_EVENT_FL_FAILED;
2139		/* the arg is now the left side */
2140		goto out_free;
2141	}
2142
2143	if (type == TEP_EVENT_OP && strcmp(*tok, ":") != 0) {
2144		int prio;
2145
2146		/* higher prios need to be closer to the root */
2147		prio = get_op_prio(*tok);
2148
2149		if (prio > arg->op.prio)
2150			return process_op(event, arg, tok);
2151
2152		return process_op(event, right, tok);
2153	}
2154
2155	return type;
2156
2157out_warn_free:
2158	do_warning_event(event, "%s: not enough memory!", __func__);
2159out_free:
2160	free_token(token);
2161	*tok = NULL;
2162	return TEP_EVENT_ERROR;
2163}
2164
2165static enum tep_event_type
2166process_entry(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2167	      char **tok)
2168{
2169	enum tep_event_type type;
2170	char *field;
2171	char *token;
2172
2173	if (read_expected(TEP_EVENT_OP, "->") < 0)
2174		goto out_err;
2175
2176	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2177		goto out_free;
2178	field = token;
2179
2180	arg->type = TEP_PRINT_FIELD;
2181	arg->field.name = field;
2182
2183	if (is_flag_field) {
2184		arg->field.field = tep_find_any_field(event, arg->field.name);
2185		arg->field.field->flags |= TEP_FIELD_IS_FLAG;
2186		is_flag_field = 0;
2187	} else if (is_symbolic_field) {
2188		arg->field.field = tep_find_any_field(event, arg->field.name);
2189		arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
2190		is_symbolic_field = 0;
2191	}
2192
2193	type = read_token(&token);
2194	*tok = token;
2195
2196	return type;
2197
2198 out_free:
2199	free_token(token);
2200 out_err:
2201	*tok = NULL;
2202	return TEP_EVENT_ERROR;
2203}
2204
2205static int alloc_and_process_delim(struct tep_event *event, char *next_token,
2206				   struct tep_print_arg **print_arg)
2207{
2208	struct tep_print_arg *field;
2209	enum tep_event_type type;
2210	char *token;
2211	int ret = 0;
2212
2213	field = alloc_arg();
2214	if (!field) {
2215		do_warning_event(event, "%s: not enough memory!", __func__);
2216		errno = ENOMEM;
2217		return -1;
2218	}
2219
2220	type = process_arg(event, field, &token);
2221
2222	if (test_type_token(type, token, TEP_EVENT_DELIM, next_token)) {
2223		errno = EINVAL;
2224		ret = -1;
2225		free_arg(field);
2226		goto out_free_token;
2227	}
2228
2229	*print_arg = field;
2230
2231out_free_token:
2232	free_token(token);
2233
2234	return ret;
2235}
2236
2237static char *arg_eval (struct tep_print_arg *arg);
2238
2239static unsigned long long
2240eval_type_str(unsigned long long val, const char *type, int pointer)
2241{
2242	int sign = 0;
2243	char *ref;
2244	int len;
2245
2246	len = strlen(type);
2247
2248	if (pointer) {
2249
2250		if (type[len-1] != '*') {
2251			do_warning("pointer expected with non pointer type");
2252			return val;
2253		}
2254
2255		ref = malloc(len);
2256		if (!ref) {
2257			do_warning("%s: not enough memory!", __func__);
2258			return val;
2259		}
2260		memcpy(ref, type, len);
2261
2262		/* chop off the " *" */
2263		ref[len - 2] = 0;
2264
2265		val = eval_type_str(val, ref, 0);
2266		free(ref);
2267		return val;
2268	}
2269
2270	/* check if this is a pointer */
2271	if (type[len - 1] == '*')
2272		return val;
2273
2274	/* Try to figure out the arg size*/
2275	if (strncmp(type, "struct", 6) == 0)
2276		/* all bets off */
2277		return val;
2278
2279	if (strcmp(type, "u8") == 0)
2280		return val & 0xff;
2281
2282	if (strcmp(type, "u16") == 0)
2283		return val & 0xffff;
2284
2285	if (strcmp(type, "u32") == 0)
2286		return val & 0xffffffff;
2287
2288	if (strcmp(type, "u64") == 0 ||
2289	    strcmp(type, "s64") == 0)
2290		return val;
2291
2292	if (strcmp(type, "s8") == 0)
2293		return (unsigned long long)(char)val & 0xff;
2294
2295	if (strcmp(type, "s16") == 0)
2296		return (unsigned long long)(short)val & 0xffff;
2297
2298	if (strcmp(type, "s32") == 0)
2299		return (unsigned long long)(int)val & 0xffffffff;
2300
2301	if (strncmp(type, "unsigned ", 9) == 0) {
2302		sign = 0;
2303		type += 9;
2304	}
2305
2306	if (strcmp(type, "char") == 0) {
2307		if (sign)
2308			return (unsigned long long)(char)val & 0xff;
2309		else
2310			return val & 0xff;
2311	}
2312
2313	if (strcmp(type, "short") == 0) {
2314		if (sign)
2315			return (unsigned long long)(short)val & 0xffff;
2316		else
2317			return val & 0xffff;
2318	}
2319
2320	if (strcmp(type, "int") == 0) {
2321		if (sign)
2322			return (unsigned long long)(int)val & 0xffffffff;
2323		else
2324			return val & 0xffffffff;
2325	}
2326
2327	return val;
2328}
2329
2330/*
2331 * Try to figure out the type.
2332 */
2333static unsigned long long
2334eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
2335{
2336	if (arg->type != TEP_PRINT_TYPE) {
2337		do_warning("expected type argument");
2338		return 0;
2339	}
2340
2341	return eval_type_str(val, arg->typecast.type, pointer);
2342}
2343
2344static int arg_num_eval(struct tep_print_arg *arg, long long *val)
2345{
2346	long long left, right;
2347	int ret = 1;
2348
2349	switch (arg->type) {
2350	case TEP_PRINT_ATOM:
2351		*val = strtoll(arg->atom.atom, NULL, 0);
2352		break;
2353	case TEP_PRINT_TYPE:
2354		ret = arg_num_eval(arg->typecast.item, val);
2355		if (!ret)
2356			break;
2357		*val = eval_type(*val, arg, 0);
2358		break;
2359	case TEP_PRINT_OP:
2360		switch (arg->op.op[0]) {
2361		case '|':
2362			ret = arg_num_eval(arg->op.left, &left);
2363			if (!ret)
2364				break;
2365			ret = arg_num_eval(arg->op.right, &right);
2366			if (!ret)
2367				break;
2368			if (arg->op.op[1])
2369				*val = left || right;
2370			else
2371				*val = left | right;
2372			break;
2373		case '&':
2374			ret = arg_num_eval(arg->op.left, &left);
2375			if (!ret)
2376				break;
2377			ret = arg_num_eval(arg->op.right, &right);
2378			if (!ret)
2379				break;
2380			if (arg->op.op[1])
2381				*val = left && right;
2382			else
2383				*val = left & right;
2384			break;
2385		case '<':
2386			ret = arg_num_eval(arg->op.left, &left);
2387			if (!ret)
2388				break;
2389			ret = arg_num_eval(arg->op.right, &right);
2390			if (!ret)
2391				break;
2392			switch (arg->op.op[1]) {
2393			case 0:
2394				*val = left < right;
2395				break;
2396			case '<':
2397				*val = left << right;
2398				break;
2399			case '=':
2400				*val = left <= right;
2401				break;
2402			default:
2403				do_warning("unknown op '%s'", arg->op.op);
2404				ret = 0;
2405			}
2406			break;
2407		case '>':
2408			ret = arg_num_eval(arg->op.left, &left);
2409			if (!ret)
2410				break;
2411			ret = arg_num_eval(arg->op.right, &right);
2412			if (!ret)
2413				break;
2414			switch (arg->op.op[1]) {
2415			case 0:
2416				*val = left > right;
2417				break;
2418			case '>':
2419				*val = left >> right;
2420				break;
2421			case '=':
2422				*val = left >= right;
2423				break;
2424			default:
2425				do_warning("unknown op '%s'", arg->op.op);
2426				ret = 0;
2427			}
2428			break;
2429		case '=':
2430			ret = arg_num_eval(arg->op.left, &left);
2431			if (!ret)
2432				break;
2433			ret = arg_num_eval(arg->op.right, &right);
2434			if (!ret)
2435				break;
2436
2437			if (arg->op.op[1] != '=') {
2438				do_warning("unknown op '%s'", arg->op.op);
2439				ret = 0;
2440			} else
2441				*val = left == right;
2442			break;
2443		case '!':
2444			ret = arg_num_eval(arg->op.left, &left);
2445			if (!ret)
2446				break;
2447			ret = arg_num_eval(arg->op.right, &right);
2448			if (!ret)
2449				break;
2450
2451			switch (arg->op.op[1]) {
2452			case '=':
2453				*val = left != right;
2454				break;
2455			default:
2456				do_warning("unknown op '%s'", arg->op.op);
2457				ret = 0;
2458			}
2459			break;
2460		case '-':
2461			/* check for negative */
2462			if (arg->op.left->type == TEP_PRINT_NULL)
2463				left = 0;
2464			else
2465				ret = arg_num_eval(arg->op.left, &left);
2466			if (!ret)
2467				break;
2468			ret = arg_num_eval(arg->op.right, &right);
2469			if (!ret)
2470				break;
2471			*val = left - right;
2472			break;
2473		case '+':
2474			if (arg->op.left->type == TEP_PRINT_NULL)
2475				left = 0;
2476			else
2477				ret = arg_num_eval(arg->op.left, &left);
2478			if (!ret)
2479				break;
2480			ret = arg_num_eval(arg->op.right, &right);
2481			if (!ret)
2482				break;
2483			*val = left + right;
2484			break;
2485		case '~':
2486			ret = arg_num_eval(arg->op.right, &right);
2487			if (!ret)
2488				break;
2489			*val = ~right;
2490			break;
2491		default:
2492			do_warning("unknown op '%s'", arg->op.op);
2493			ret = 0;
2494		}
2495		break;
2496
2497	case TEP_PRINT_NULL:
2498	case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2499	case TEP_PRINT_STRING:
2500	case TEP_PRINT_BSTRING:
2501	case TEP_PRINT_BITMASK:
2502	default:
2503		do_warning("invalid eval type %d", arg->type);
2504		ret = 0;
2505
2506	}
2507	return ret;
2508}
2509
2510static char *arg_eval (struct tep_print_arg *arg)
2511{
2512	long long val;
2513	static char buf[24];
2514
2515	switch (arg->type) {
2516	case TEP_PRINT_ATOM:
2517		return arg->atom.atom;
2518	case TEP_PRINT_TYPE:
2519		return arg_eval(arg->typecast.item);
2520	case TEP_PRINT_OP:
2521		if (!arg_num_eval(arg, &val))
2522			break;
2523		sprintf(buf, "%lld", val);
2524		return buf;
2525
2526	case TEP_PRINT_NULL:
2527	case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2528	case TEP_PRINT_STRING:
2529	case TEP_PRINT_BSTRING:
2530	case TEP_PRINT_BITMASK:
2531	default:
2532		do_warning("invalid eval type %d", arg->type);
2533		break;
2534	}
2535
2536	return NULL;
2537}
2538
2539static enum tep_event_type
2540process_fields(struct tep_event *event, struct tep_print_flag_sym **list, char **tok)
2541{
2542	enum tep_event_type type;
2543	struct tep_print_arg *arg = NULL;
2544	struct tep_print_flag_sym *field;
2545	char *token = *tok;
2546	char *value;
2547
2548	do {
2549		free_token(token);
2550		type = read_token_item(&token);
2551		if (test_type_token(type, token, TEP_EVENT_OP, "{"))
2552			break;
2553
2554		arg = alloc_arg();
2555		if (!arg)
2556			goto out_free;
2557
2558		free_token(token);
2559		type = process_arg(event, arg, &token);
2560
2561		if (type == TEP_EVENT_OP)
2562			type = process_op(event, arg, &token);
2563
2564		if (type == TEP_EVENT_ERROR)
2565			goto out_free;
2566
2567		if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2568			goto out_free;
2569
2570		field = calloc(1, sizeof(*field));
2571		if (!field)
2572			goto out_free;
2573
2574		value = arg_eval(arg);
2575		if (value == NULL)
2576			goto out_free_field;
2577		field->value = strdup(value);
2578		if (field->value == NULL)
2579			goto out_free_field;
2580
2581		free_arg(arg);
2582		arg = alloc_arg();
2583		if (!arg)
2584			goto out_free;
2585
2586		free_token(token);
2587		type = process_arg(event, arg, &token);
2588		if (test_type_token(type, token, TEP_EVENT_OP, "}"))
2589			goto out_free_field;
2590
2591		value = arg_eval(arg);
2592		if (value == NULL)
2593			goto out_free_field;
2594		field->str = strdup(value);
2595		if (field->str == NULL)
2596			goto out_free_field;
2597		free_arg(arg);
2598		arg = NULL;
2599
2600		*list = field;
2601		list = &field->next;
2602
2603		free_token(token);
2604		type = read_token_item(&token);
2605	} while (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0);
2606
2607	*tok = token;
2608	return type;
2609
2610out_free_field:
2611	free_flag_sym(field);
2612out_free:
2613	free_arg(arg);
2614	free_token(token);
2615	*tok = NULL;
2616
2617	return TEP_EVENT_ERROR;
2618}
2619
2620static enum tep_event_type
2621process_flags(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2622{
2623	struct tep_print_arg *field;
2624	enum tep_event_type type;
2625	char *token = NULL;
2626
2627	memset(arg, 0, sizeof(*arg));
2628	arg->type = TEP_PRINT_FLAGS;
2629
2630	field = alloc_arg();
2631	if (!field) {
2632		do_warning_event(event, "%s: not enough memory!", __func__);
2633		goto out_free;
2634	}
2635
2636	type = process_field_arg(event, field, &token);
2637
2638	/* Handle operations in the first argument */
2639	while (type == TEP_EVENT_OP)
2640		type = process_op(event, field, &token);
2641
2642	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2643		goto out_free_field;
2644	free_token(token);
2645
2646	arg->flags.field = field;
2647
2648	type = read_token_item(&token);
2649	if (event_item_type(type)) {
2650		arg->flags.delim = token;
2651		type = read_token_item(&token);
2652	}
2653
2654	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2655		goto out_free;
2656
2657	type = process_fields(event, &arg->flags.flags, &token);
2658	if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2659		goto out_free;
2660
2661	free_token(token);
2662	type = read_token_item(tok);
2663	return type;
2664
2665out_free_field:
2666	free_arg(field);
2667out_free:
2668	free_token(token);
2669	*tok = NULL;
2670	return TEP_EVENT_ERROR;
2671}
2672
2673static enum tep_event_type
2674process_symbols(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2675{
2676	struct tep_print_arg *field;
2677	enum tep_event_type type;
2678	char *token = NULL;
2679
2680	memset(arg, 0, sizeof(*arg));
2681	arg->type = TEP_PRINT_SYMBOL;
2682
2683	field = alloc_arg();
2684	if (!field) {
2685		do_warning_event(event, "%s: not enough memory!", __func__);
2686		goto out_free;
2687	}
2688
2689	type = process_field_arg(event, field, &token);
2690
2691	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2692		goto out_free_field;
2693
2694	arg->symbol.field = field;
2695
2696	type = process_fields(event, &arg->symbol.symbols, &token);
2697	if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2698		goto out_free;
2699
2700	free_token(token);
2701	type = read_token_item(tok);
2702	return type;
2703
2704out_free_field:
2705	free_arg(field);
2706out_free:
2707	free_token(token);
2708	*tok = NULL;
2709	return TEP_EVENT_ERROR;
2710}
2711
2712static enum tep_event_type
2713process_hex_common(struct tep_event *event, struct tep_print_arg *arg,
2714		   char **tok, enum tep_print_arg_type type)
2715{
2716	memset(arg, 0, sizeof(*arg));
2717	arg->type = type;
2718
2719	if (alloc_and_process_delim(event, ",", &arg->hex.field))
2720		goto out;
2721
2722	if (alloc_and_process_delim(event, ")", &arg->hex.size))
2723		goto free_field;
2724
2725	return read_token_item(tok);
2726
2727free_field:
2728	free_arg(arg->hex.field);
2729	arg->hex.field = NULL;
2730out:
2731	*tok = NULL;
2732	return TEP_EVENT_ERROR;
2733}
2734
2735static enum tep_event_type
2736process_hex(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2737{
2738	return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
2739}
2740
2741static enum tep_event_type
2742process_hex_str(struct tep_event *event, struct tep_print_arg *arg,
2743		char **tok)
2744{
2745	return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
2746}
2747
2748static enum tep_event_type
2749process_int_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2750{
2751	memset(arg, 0, sizeof(*arg));
2752	arg->type = TEP_PRINT_INT_ARRAY;
2753
2754	if (alloc_and_process_delim(event, ",", &arg->int_array.field))
2755		goto out;
2756
2757	if (alloc_and_process_delim(event, ",", &arg->int_array.count))
2758		goto free_field;
2759
2760	if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
2761		goto free_size;
2762
2763	return read_token_item(tok);
2764
2765free_size:
2766	free_arg(arg->int_array.count);
2767	arg->int_array.count = NULL;
2768free_field:
2769	free_arg(arg->int_array.field);
2770	arg->int_array.field = NULL;
2771out:
2772	*tok = NULL;
2773	return TEP_EVENT_ERROR;
2774}
2775
2776static enum tep_event_type
2777process_dynamic_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2778{
2779	struct tep_format_field *field;
2780	enum tep_event_type type;
2781	char *token;
2782
2783	memset(arg, 0, sizeof(*arg));
2784	arg->type = TEP_PRINT_DYNAMIC_ARRAY;
2785
2786	/*
2787	 * The item within the parenthesis is another field that holds
2788	 * the index into where the array starts.
2789	 */
2790	type = read_token(&token);
2791	*tok = token;
2792	if (type != TEP_EVENT_ITEM)
2793		goto out_free;
2794
2795	/* Find the field */
2796
2797	field = tep_find_field(event, token);
2798	if (!field)
2799		goto out_free;
2800
2801	arg->dynarray.field = field;
2802	arg->dynarray.index = 0;
2803
2804	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2805		goto out_free;
2806
2807	free_token(token);
2808	type = read_token_item(&token);
2809	*tok = token;
2810	if (type != TEP_EVENT_OP || strcmp(token, "[") != 0)
2811		return type;
2812
2813	free_token(token);
2814	arg = alloc_arg();
2815	if (!arg) {
2816		do_warning_event(event, "%s: not enough memory!", __func__);
2817		*tok = NULL;
2818		return TEP_EVENT_ERROR;
2819	}
2820
2821	type = process_arg(event, arg, &token);
2822	if (type == TEP_EVENT_ERROR)
2823		goto out_free_arg;
2824
2825	if (!test_type_token(type, token, TEP_EVENT_OP, "]"))
2826		goto out_free_arg;
2827
2828	free_token(token);
2829	type = read_token_item(tok);
2830	return type;
2831
2832 out_free_arg:
2833	free_arg(arg);
2834 out_free:
2835	free_token(token);
2836	*tok = NULL;
2837	return TEP_EVENT_ERROR;
2838}
2839
2840static enum tep_event_type
2841process_dynamic_array_len(struct tep_event *event, struct tep_print_arg *arg,
2842			  char **tok)
2843{
2844	struct tep_format_field *field;
2845	enum tep_event_type type;
2846	char *token;
2847
2848	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2849		goto out_free;
2850
2851	arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
2852
2853	/* Find the field */
2854	field = tep_find_field(event, token);
2855	if (!field)
2856		goto out_free;
2857
2858	arg->dynarray.field = field;
2859	arg->dynarray.index = 0;
2860
2861	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2862		goto out_err;
2863
2864	free_token(token);
2865	type = read_token(&token);
2866	*tok = token;
2867
2868	return type;
2869
2870 out_free:
2871	free_token(token);
2872 out_err:
2873	*tok = NULL;
2874	return TEP_EVENT_ERROR;
2875}
2876
2877static enum tep_event_type
2878process_paren(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2879{
2880	struct tep_print_arg *item_arg;
2881	enum tep_event_type type;
2882	char *token;
2883
2884	type = process_arg(event, arg, &token);
2885
2886	if (type == TEP_EVENT_ERROR)
2887		goto out_free;
2888
2889	if (type == TEP_EVENT_OP)
2890		type = process_op(event, arg, &token);
2891
2892	if (type == TEP_EVENT_ERROR)
2893		goto out_free;
2894
2895	if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2896		goto out_free;
2897
2898	free_token(token);
2899	type = read_token_item(&token);
2900
2901	/*
2902	 * If the next token is an item or another open paren, then
2903	 * this was a typecast.
2904	 */
2905	if (event_item_type(type) ||
2906	    (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0)) {
2907
2908		/* make this a typecast and contine */
2909
2910		/* prevous must be an atom */
2911		if (arg->type != TEP_PRINT_ATOM) {
2912			do_warning_event(event, "previous needed to be TEP_PRINT_ATOM");
2913			goto out_free;
2914		}
2915
2916		item_arg = alloc_arg();
2917		if (!item_arg) {
2918			do_warning_event(event, "%s: not enough memory!",
2919					 __func__);
2920			goto out_free;
2921		}
2922
2923		arg->type = TEP_PRINT_TYPE;
2924		arg->typecast.type = arg->atom.atom;
2925		arg->typecast.item = item_arg;
2926		type = process_arg_token(event, item_arg, &token, type);
2927
2928	}
2929
2930	*tok = token;
2931	return type;
2932
2933 out_free:
2934	free_token(token);
2935	*tok = NULL;
2936	return TEP_EVENT_ERROR;
2937}
2938
2939
2940static enum tep_event_type
2941process_str(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2942	    char **tok)
2943{
2944	enum tep_event_type type;
2945	char *token;
2946
2947	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2948		goto out_free;
2949
2950	arg->type = TEP_PRINT_STRING;
2951	arg->string.string = token;
2952	arg->string.offset = -1;
2953
2954	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2955		goto out_err;
2956
2957	type = read_token(&token);
2958	*tok = token;
2959
2960	return type;
2961
2962 out_free:
2963	free_token(token);
2964 out_err:
2965	*tok = NULL;
2966	return TEP_EVENT_ERROR;
2967}
2968
2969static enum tep_event_type
2970process_bitmask(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2971		char **tok)
2972{
2973	enum tep_event_type type;
2974	char *token;
2975
2976	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2977		goto out_free;
2978
2979	arg->type = TEP_PRINT_BITMASK;
2980	arg->bitmask.bitmask = token;
2981	arg->bitmask.offset = -1;
2982
2983	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2984		goto out_err;
2985
2986	type = read_token(&token);
2987	*tok = token;
2988
2989	return type;
2990
2991 out_free:
2992	free_token(token);
2993 out_err:
2994	*tok = NULL;
2995	return TEP_EVENT_ERROR;
2996}
2997
2998static struct tep_function_handler *
2999find_func_handler(struct tep_handle *tep, char *func_name)
3000{
3001	struct tep_function_handler *func;
3002
3003	if (!tep)
3004		return NULL;
3005
3006	for (func = tep->func_handlers; func; func = func->next) {
3007		if (strcmp(func->name, func_name) == 0)
3008			break;
3009	}
3010
3011	return func;
3012}
3013
3014static void remove_func_handler(struct tep_handle *tep, char *func_name)
3015{
3016	struct tep_function_handler *func;
3017	struct tep_function_handler **next;
3018
3019	next = &tep->func_handlers;
3020	while ((func = *next)) {
3021		if (strcmp(func->name, func_name) == 0) {
3022			*next = func->next;
3023			free_func_handle(func);
3024			break;
3025		}
3026		next = &func->next;
3027	}
3028}
3029
3030static enum tep_event_type
3031process_func_handler(struct tep_event *event, struct tep_function_handler *func,
3032		     struct tep_print_arg *arg, char **tok)
3033{
3034	struct tep_print_arg **next_arg;
3035	struct tep_print_arg *farg;
3036	enum tep_event_type type;
3037	char *token;
3038	int i;
3039
3040	arg->type = TEP_PRINT_FUNC;
3041	arg->func.func = func;
3042
3043	*tok = NULL;
3044
3045	next_arg = &(arg->func.args);
3046	for (i = 0; i < func->nr_args; i++) {
3047		farg = alloc_arg();
3048		if (!farg) {
3049			do_warning_event(event, "%s: not enough memory!",
3050					 __func__);
3051			return TEP_EVENT_ERROR;
3052		}
3053
3054		type = process_arg(event, farg, &token);
3055		if (i < (func->nr_args - 1)) {
3056			if (type != TEP_EVENT_DELIM || strcmp(token, ",") != 0) {
3057				do_warning_event(event,
3058					"Error: function '%s()' expects %d arguments but event %s only uses %d",
3059					func->name, func->nr_args,
3060					event->name, i + 1);
3061				goto err;
3062			}
3063		} else {
3064			if (type != TEP_EVENT_DELIM || strcmp(token, ")") != 0) {
3065				do_warning_event(event,
3066					"Error: function '%s()' only expects %d arguments but event %s has more",
3067					func->name, func->nr_args, event->name);
3068				goto err;
3069			}
3070		}
3071
3072		*next_arg = farg;
3073		next_arg = &(farg->next);
3074		free_token(token);
3075	}
3076
3077	type = read_token(&token);
3078	*tok = token;
3079
3080	return type;
3081
3082err:
3083	free_arg(farg);
3084	free_token(token);
3085	return TEP_EVENT_ERROR;
3086}
3087
3088static enum tep_event_type
3089process_builtin_expect(struct tep_event *event, struct tep_print_arg *arg, char **tok)
3090{
3091	enum tep_event_type type;
3092	char *token = NULL;
3093
3094	/* Handle __builtin_expect( cond, #) */
3095	type = process_arg(event, arg, &token);
3096
3097	if (type != TEP_EVENT_DELIM || token[0] != ',')
3098		goto out_free;
3099
3100	free_token(token);
3101
3102	/* We don't care what the second parameter is of the __builtin_expect() */
3103	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
3104		goto out_free;
3105
3106	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
3107		goto out_free;
3108
3109	free_token(token);
3110	type = read_token_item(tok);
3111	return type;
3112
3113out_free:
3114	free_token(token);
3115	*tok = NULL;
3116	return TEP_EVENT_ERROR;
3117}
3118
3119static enum tep_event_type
3120process_function(struct tep_event *event, struct tep_print_arg *arg,
3121		 char *token, char **tok)
3122{
3123	struct tep_function_handler *func;
3124
3125	if (strcmp(token, "__print_flags") == 0) {
3126		free_token(token);
3127		is_flag_field = 1;
3128		return process_flags(event, arg, tok);
3129	}
3130	if (strcmp(token, "__print_symbolic") == 0) {
3131		free_token(token);
3132		is_symbolic_field = 1;
3133		return process_symbols(event, arg, tok);
3134	}
3135	if (strcmp(token, "__print_hex") == 0) {
3136		free_token(token);
3137		return process_hex(event, arg, tok);
3138	}
3139	if (strcmp(token, "__print_hex_str") == 0) {
3140		free_token(token);
3141		return process_hex_str(event, arg, tok);
3142	}
3143	if (strcmp(token, "__print_array") == 0) {
3144		free_token(token);
3145		return process_int_array(event, arg, tok);
3146	}
3147	if (strcmp(token, "__get_str") == 0) {
3148		free_token(token);
3149		return process_str(event, arg, tok);
3150	}
3151	if (strcmp(token, "__get_bitmask") == 0) {
3152		free_token(token);
3153		return process_bitmask(event, arg, tok);
3154	}
3155	if (strcmp(token, "__get_dynamic_array") == 0) {
3156		free_token(token);
3157		return process_dynamic_array(event, arg, tok);
3158	}
3159	if (strcmp(token, "__get_dynamic_array_len") == 0) {
3160		free_token(token);
3161		return process_dynamic_array_len(event, arg, tok);
3162	}
3163	if (strcmp(token, "__builtin_expect") == 0) {
3164		free_token(token);
3165		return process_builtin_expect(event, arg, tok);
3166	}
3167
3168	func = find_func_handler(event->tep, token);
3169	if (func) {
3170		free_token(token);
3171		return process_func_handler(event, func, arg, tok);
3172	}
3173
3174	do_warning_event(event, "function %s not defined", token);
3175	free_token(token);
3176	return TEP_EVENT_ERROR;
3177}
3178
3179static enum tep_event_type
3180process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
3181		  char **tok, enum tep_event_type type)
3182{
3183	char *token;
3184	char *atom;
3185
3186	token = *tok;
3187
3188	switch (type) {
3189	case TEP_EVENT_ITEM:
3190		if (strcmp(token, "REC") == 0) {
3191			free_token(token);
3192			type = process_entry(event, arg, &token);
3193			break;
3194		}
3195		atom = token;
3196		/* test the next token */
3197		type = read_token_item(&token);
3198
3199		/*
3200		 * If the next token is a parenthesis, then this
3201		 * is a function.
3202		 */
3203		if (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0) {
3204			free_token(token);
3205			token = NULL;
3206			/* this will free atom. */
3207			type = process_function(event, arg, atom, &token);
3208			break;
3209		}
3210		/* atoms can be more than one token long */
3211		while (type == TEP_EVENT_ITEM) {
3212			int ret;
3213
3214			ret = append(&atom, " ", token);
3215			if (ret < 0) {
3216				free(atom);
3217				*tok = NULL;
3218				free_token(token);
3219				return TEP_EVENT_ERROR;
3220			}
 
 
 
3221			free_token(token);
3222			type = read_token_item(&token);
3223		}
3224
3225		arg->type = TEP_PRINT_ATOM;
3226		arg->atom.atom = atom;
3227		break;
3228
3229	case TEP_EVENT_DQUOTE:
3230	case TEP_EVENT_SQUOTE:
3231		arg->type = TEP_PRINT_ATOM;
3232		arg->atom.atom = token;
3233		type = read_token_item(&token);
3234		break;
3235	case TEP_EVENT_DELIM:
3236		if (strcmp(token, "(") == 0) {
3237			free_token(token);
3238			type = process_paren(event, arg, &token);
3239			break;
3240		}
3241	case TEP_EVENT_OP:
3242		/* handle single ops */
3243		arg->type = TEP_PRINT_OP;
3244		arg->op.op = token;
3245		arg->op.left = NULL;
3246		type = process_op(event, arg, &token);
3247
3248		/* On error, the op is freed */
3249		if (type == TEP_EVENT_ERROR)
3250			arg->op.op = NULL;
3251
3252		/* return error type if errored */
3253		break;
3254
3255	case TEP_EVENT_ERROR ... TEP_EVENT_NEWLINE:
3256	default:
3257		do_warning_event(event, "unexpected type %d", type);
3258		return TEP_EVENT_ERROR;
3259	}
3260	*tok = token;
3261
3262	return type;
3263}
3264
3265static int event_read_print_args(struct tep_event *event, struct tep_print_arg **list)
3266{
3267	enum tep_event_type type = TEP_EVENT_ERROR;
3268	struct tep_print_arg *arg;
3269	char *token;
3270	int args = 0;
3271
3272	do {
3273		if (type == TEP_EVENT_NEWLINE) {
3274			type = read_token_item(&token);
3275			continue;
3276		}
3277
3278		arg = alloc_arg();
3279		if (!arg) {
3280			do_warning_event(event, "%s: not enough memory!",
3281					 __func__);
3282			return -1;
3283		}
3284
3285		type = process_arg(event, arg, &token);
3286
3287		if (type == TEP_EVENT_ERROR) {
3288			free_token(token);
3289			free_arg(arg);
3290			return -1;
3291		}
3292
3293		*list = arg;
3294		args++;
3295
3296		if (type == TEP_EVENT_OP) {
3297			type = process_op(event, arg, &token);
3298			free_token(token);
3299			if (type == TEP_EVENT_ERROR) {
3300				*list = NULL;
3301				free_arg(arg);
3302				return -1;
3303			}
3304			list = &arg->next;
3305			continue;
3306		}
3307
3308		if (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0) {
3309			free_token(token);
3310			*list = arg;
3311			list = &arg->next;
3312			continue;
3313		}
3314		break;
3315	} while (type != TEP_EVENT_NONE);
3316
3317	if (type != TEP_EVENT_NONE && type != TEP_EVENT_ERROR)
3318		free_token(token);
3319
3320	return args;
3321}
3322
3323static int event_read_print(struct tep_event *event)
3324{
3325	enum tep_event_type type;
3326	char *token;
3327	int ret;
3328
3329	if (read_expected_item(TEP_EVENT_ITEM, "print") < 0)
3330		return -1;
3331
3332	if (read_expected(TEP_EVENT_ITEM, "fmt") < 0)
3333		return -1;
3334
3335	if (read_expected(TEP_EVENT_OP, ":") < 0)
3336		return -1;
3337
3338	if (read_expect_type(TEP_EVENT_DQUOTE, &token) < 0)
3339		goto fail;
3340
3341 concat:
3342	event->print_fmt.format = token;
3343	event->print_fmt.args = NULL;
3344
3345	/* ok to have no arg */
3346	type = read_token_item(&token);
3347
3348	if (type == TEP_EVENT_NONE)
3349		return 0;
3350
3351	/* Handle concatenation of print lines */
3352	if (type == TEP_EVENT_DQUOTE) {
3353		char *cat;
3354
3355		if (asprintf(&cat, "%s%s", event->print_fmt.format, token) < 0)
3356			goto fail;
3357		free_token(token);
3358		free_token(event->print_fmt.format);
3359		event->print_fmt.format = NULL;
3360		token = cat;
3361		goto concat;
3362	}
3363			     
3364	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
3365		goto fail;
3366
3367	free_token(token);
3368
3369	ret = event_read_print_args(event, &event->print_fmt.args);
3370	if (ret < 0)
3371		return -1;
3372
3373	return ret;
3374
3375 fail:
3376	free_token(token);
3377	return -1;
3378}
3379
3380/**
3381 * tep_find_common_field - return a common field by event
3382 * @event: handle for the event
3383 * @name: the name of the common field to return
3384 *
3385 * Returns a common field from the event by the given @name.
3386 * This only searches the common fields and not all field.
3387 */
3388struct tep_format_field *
3389tep_find_common_field(struct tep_event *event, const char *name)
3390{
3391	struct tep_format_field *format;
3392
3393	for (format = event->format.common_fields;
3394	     format; format = format->next) {
3395		if (strcmp(format->name, name) == 0)
3396			break;
3397	}
3398
3399	return format;
3400}
3401
3402/**
3403 * tep_find_field - find a non-common field
3404 * @event: handle for the event
3405 * @name: the name of the non-common field
3406 *
3407 * Returns a non-common field by the given @name.
3408 * This does not search common fields.
3409 */
3410struct tep_format_field *
3411tep_find_field(struct tep_event *event, const char *name)
3412{
3413	struct tep_format_field *format;
3414
3415	for (format = event->format.fields;
3416	     format; format = format->next) {
3417		if (strcmp(format->name, name) == 0)
3418			break;
3419	}
3420
3421	return format;
3422}
3423
3424/**
3425 * tep_find_any_field - find any field by name
3426 * @event: handle for the event
3427 * @name: the name of the field
3428 *
3429 * Returns a field by the given @name.
3430 * This searches the common field names first, then
3431 * the non-common ones if a common one was not found.
3432 */
3433struct tep_format_field *
3434tep_find_any_field(struct tep_event *event, const char *name)
3435{
3436	struct tep_format_field *format;
3437
3438	format = tep_find_common_field(event, name);
3439	if (format)
3440		return format;
3441	return tep_find_field(event, name);
3442}
3443
3444/**
3445 * tep_read_number - read a number from data
3446 * @tep: a handle to the trace event parser context
3447 * @ptr: the raw data
3448 * @size: the size of the data that holds the number
3449 *
3450 * Returns the number (converted to host) from the
3451 * raw data.
3452 */
3453unsigned long long tep_read_number(struct tep_handle *tep,
3454				   const void *ptr, int size)
3455{
3456	unsigned long long val;
3457
3458	switch (size) {
3459	case 1:
3460		return *(unsigned char *)ptr;
3461	case 2:
3462		return tep_data2host2(tep, *(unsigned short *)ptr);
3463	case 4:
3464		return tep_data2host4(tep, *(unsigned int *)ptr);
3465	case 8:
3466		memcpy(&val, (ptr), sizeof(unsigned long long));
3467		return tep_data2host8(tep, val);
3468	default:
3469		/* BUG! */
3470		return 0;
3471	}
3472}
3473
3474/**
3475 * tep_read_number_field - read a number from data
3476 * @field: a handle to the field
3477 * @data: the raw data to read
3478 * @value: the value to place the number in
3479 *
3480 * Reads raw data according to a field offset and size,
3481 * and translates it into @value.
3482 *
3483 * Returns 0 on success, -1 otherwise.
3484 */
3485int tep_read_number_field(struct tep_format_field *field, const void *data,
3486			  unsigned long long *value)
3487{
3488	if (!field)
3489		return -1;
3490	switch (field->size) {
3491	case 1:
3492	case 2:
3493	case 4:
3494	case 8:
3495		*value = tep_read_number(field->event->tep,
3496					 data + field->offset, field->size);
3497		return 0;
3498	default:
3499		return -1;
3500	}
3501}
3502
3503static int get_common_info(struct tep_handle *tep,
3504			   const char *type, int *offset, int *size)
3505{
3506	struct tep_event *event;
3507	struct tep_format_field *field;
3508
3509	/*
3510	 * All events should have the same common elements.
3511	 * Pick any event to find where the type is;
3512	 */
3513	if (!tep->events) {
3514		do_warning("no event_list!");
3515		return -1;
3516	}
3517
3518	event = tep->events[0];
3519	field = tep_find_common_field(event, type);
3520	if (!field)
3521		return -1;
3522
3523	*offset = field->offset;
3524	*size = field->size;
3525
3526	return 0;
3527}
3528
3529static int __parse_common(struct tep_handle *tep, void *data,
3530			  int *size, int *offset, const char *name)
3531{
3532	int ret;
3533
3534	if (!*size) {
3535		ret = get_common_info(tep, name, offset, size);
3536		if (ret < 0)
3537			return ret;
3538	}
3539	return tep_read_number(tep, data + *offset, *size);
3540}
3541
3542static int trace_parse_common_type(struct tep_handle *tep, void *data)
3543{
3544	return __parse_common(tep, data,
3545			      &tep->type_size, &tep->type_offset,
3546			      "common_type");
3547}
3548
3549static int parse_common_pid(struct tep_handle *tep, void *data)
3550{
3551	return __parse_common(tep, data,
3552			      &tep->pid_size, &tep->pid_offset,
3553			      "common_pid");
3554}
3555
3556static int parse_common_pc(struct tep_handle *tep, void *data)
3557{
3558	return __parse_common(tep, data,
3559			      &tep->pc_size, &tep->pc_offset,
3560			      "common_preempt_count");
3561}
3562
3563static int parse_common_flags(struct tep_handle *tep, void *data)
3564{
3565	return __parse_common(tep, data,
3566			      &tep->flags_size, &tep->flags_offset,
3567			      "common_flags");
3568}
3569
3570static int parse_common_lock_depth(struct tep_handle *tep, void *data)
3571{
3572	return __parse_common(tep, data,
3573			      &tep->ld_size, &tep->ld_offset,
3574			      "common_lock_depth");
3575}
3576
3577static int parse_common_migrate_disable(struct tep_handle *tep, void *data)
3578{
3579	return __parse_common(tep, data,
3580			      &tep->ld_size, &tep->ld_offset,
3581			      "common_migrate_disable");
3582}
3583
3584static int events_id_cmp(const void *a, const void *b);
3585
3586/**
3587 * tep_find_event - find an event by given id
3588 * @tep: a handle to the trace event parser context
3589 * @id: the id of the event
3590 *
3591 * Returns an event that has a given @id.
3592 */
3593struct tep_event *tep_find_event(struct tep_handle *tep, int id)
3594{
3595	struct tep_event **eventptr;
3596	struct tep_event key;
3597	struct tep_event *pkey = &key;
3598
3599	/* Check cache first */
3600	if (tep->last_event && tep->last_event->id == id)
3601		return tep->last_event;
3602
3603	key.id = id;
3604
3605	eventptr = bsearch(&pkey, tep->events, tep->nr_events,
3606			   sizeof(*tep->events), events_id_cmp);
3607
3608	if (eventptr) {
3609		tep->last_event = *eventptr;
3610		return *eventptr;
3611	}
3612
3613	return NULL;
3614}
3615
3616/**
3617 * tep_find_event_by_name - find an event by given name
3618 * @tep: a handle to the trace event parser context
3619 * @sys: the system name to search for
3620 * @name: the name of the event to search for
3621 *
3622 * This returns an event with a given @name and under the system
3623 * @sys. If @sys is NULL the first event with @name is returned.
3624 */
3625struct tep_event *
3626tep_find_event_by_name(struct tep_handle *tep,
3627		       const char *sys, const char *name)
3628{
3629	struct tep_event *event = NULL;
3630	int i;
3631
3632	if (tep->last_event &&
3633	    strcmp(tep->last_event->name, name) == 0 &&
3634	    (!sys || strcmp(tep->last_event->system, sys) == 0))
3635		return tep->last_event;
3636
3637	for (i = 0; i < tep->nr_events; i++) {
3638		event = tep->events[i];
3639		if (strcmp(event->name, name) == 0) {
3640			if (!sys)
3641				break;
3642			if (strcmp(event->system, sys) == 0)
3643				break;
3644		}
3645	}
3646	if (i == tep->nr_events)
3647		event = NULL;
3648
3649	tep->last_event = event;
3650	return event;
3651}
3652
3653static unsigned long long
3654eval_num_arg(void *data, int size, struct tep_event *event, struct tep_print_arg *arg)
3655{
3656	struct tep_handle *tep = event->tep;
3657	unsigned long long val = 0;
3658	unsigned long long left, right;
3659	struct tep_print_arg *typearg = NULL;
3660	struct tep_print_arg *larg;
3661	unsigned long offset;
3662	unsigned int field_size;
3663
3664	switch (arg->type) {
3665	case TEP_PRINT_NULL:
3666		/* ?? */
3667		return 0;
3668	case TEP_PRINT_ATOM:
3669		return strtoull(arg->atom.atom, NULL, 0);
3670	case TEP_PRINT_FIELD:
3671		if (!arg->field.field) {
3672			arg->field.field = tep_find_any_field(event, arg->field.name);
3673			if (!arg->field.field)
3674				goto out_warning_field;
3675			
3676		}
3677		/* must be a number */
3678		val = tep_read_number(tep, data + arg->field.field->offset,
3679				      arg->field.field->size);
3680		break;
3681	case TEP_PRINT_FLAGS:
3682	case TEP_PRINT_SYMBOL:
3683	case TEP_PRINT_INT_ARRAY:
3684	case TEP_PRINT_HEX:
3685	case TEP_PRINT_HEX_STR:
3686		break;
3687	case TEP_PRINT_TYPE:
3688		val = eval_num_arg(data, size, event, arg->typecast.item);
3689		return eval_type(val, arg, 0);
3690	case TEP_PRINT_STRING:
3691	case TEP_PRINT_BSTRING:
3692	case TEP_PRINT_BITMASK:
3693		return 0;
3694	case TEP_PRINT_FUNC: {
3695		struct trace_seq s;
3696		trace_seq_init(&s);
3697		val = process_defined_func(&s, data, size, event, arg);
3698		trace_seq_destroy(&s);
3699		return val;
3700	}
3701	case TEP_PRINT_OP:
3702		if (strcmp(arg->op.op, "[") == 0) {
3703			/*
3704			 * Arrays are special, since we don't want
3705			 * to read the arg as is.
3706			 */
3707			right = eval_num_arg(data, size, event, arg->op.right);
3708
3709			/* handle typecasts */
3710			larg = arg->op.left;
3711			while (larg->type == TEP_PRINT_TYPE) {
3712				if (!typearg)
3713					typearg = larg;
3714				larg = larg->typecast.item;
3715			}
3716
3717			/* Default to long size */
3718			field_size = tep->long_size;
3719
3720			switch (larg->type) {
3721			case TEP_PRINT_DYNAMIC_ARRAY:
3722				offset = tep_read_number(tep,
3723						   data + larg->dynarray.field->offset,
3724						   larg->dynarray.field->size);
3725				if (larg->dynarray.field->elementsize)
3726					field_size = larg->dynarray.field->elementsize;
3727				/*
3728				 * The actual length of the dynamic array is stored
3729				 * in the top half of the field, and the offset
3730				 * is in the bottom half of the 32 bit field.
3731				 */
3732				offset &= 0xffff;
3733				offset += right;
3734				break;
3735			case TEP_PRINT_FIELD:
3736				if (!larg->field.field) {
3737					larg->field.field =
3738						tep_find_any_field(event, larg->field.name);
3739					if (!larg->field.field) {
3740						arg = larg;
3741						goto out_warning_field;
3742					}
3743				}
3744				field_size = larg->field.field->elementsize;
3745				offset = larg->field.field->offset +
3746					right * larg->field.field->elementsize;
3747				break;
3748			default:
3749				goto default_op; /* oops, all bets off */
3750			}
3751			val = tep_read_number(tep,
3752					      data + offset, field_size);
3753			if (typearg)
3754				val = eval_type(val, typearg, 1);
3755			break;
3756		} else if (strcmp(arg->op.op, "?") == 0) {
3757			left = eval_num_arg(data, size, event, arg->op.left);
3758			arg = arg->op.right;
3759			if (left)
3760				val = eval_num_arg(data, size, event, arg->op.left);
3761			else
3762				val = eval_num_arg(data, size, event, arg->op.right);
3763			break;
3764		}
3765 default_op:
3766		left = eval_num_arg(data, size, event, arg->op.left);
3767		right = eval_num_arg(data, size, event, arg->op.right);
3768		switch (arg->op.op[0]) {
3769		case '!':
3770			switch (arg->op.op[1]) {
3771			case 0:
3772				val = !right;
3773				break;
3774			case '=':
3775				val = left != right;
3776				break;
3777			default:
3778				goto out_warning_op;
3779			}
3780			break;
3781		case '~':
3782			val = ~right;
3783			break;
3784		case '|':
3785			if (arg->op.op[1])
3786				val = left || right;
3787			else
3788				val = left | right;
3789			break;
3790		case '&':
3791			if (arg->op.op[1])
3792				val = left && right;
3793			else
3794				val = left & right;
3795			break;
3796		case '<':
3797			switch (arg->op.op[1]) {
3798			case 0:
3799				val = left < right;
3800				break;
3801			case '<':
3802				val = left << right;
3803				break;
3804			case '=':
3805				val = left <= right;
3806				break;
3807			default:
3808				goto out_warning_op;
3809			}
3810			break;
3811		case '>':
3812			switch (arg->op.op[1]) {
3813			case 0:
3814				val = left > right;
3815				break;
3816			case '>':
3817				val = left >> right;
3818				break;
3819			case '=':
3820				val = left >= right;
3821				break;
3822			default:
3823				goto out_warning_op;
3824			}
3825			break;
3826		case '=':
3827			if (arg->op.op[1] != '=')
3828				goto out_warning_op;
3829
3830			val = left == right;
3831			break;
3832		case '-':
3833			val = left - right;
3834			break;
3835		case '+':
3836			val = left + right;
3837			break;
3838		case '/':
3839			val = left / right;
3840			break;
3841		case '%':
3842			val = left % right;
3843			break;
3844		case '*':
3845			val = left * right;
3846			break;
3847		default:
3848			goto out_warning_op;
3849		}
3850		break;
3851	case TEP_PRINT_DYNAMIC_ARRAY_LEN:
3852		offset = tep_read_number(tep,
3853					 data + arg->dynarray.field->offset,
3854					 arg->dynarray.field->size);
3855		/*
3856		 * The total allocated length of the dynamic array is
3857		 * stored in the top half of the field, and the offset
3858		 * is in the bottom half of the 32 bit field.
3859		 */
3860		val = (unsigned long long)(offset >> 16);
3861		break;
3862	case TEP_PRINT_DYNAMIC_ARRAY:
3863		/* Without [], we pass the address to the dynamic data */
3864		offset = tep_read_number(tep,
3865					 data + arg->dynarray.field->offset,
3866					 arg->dynarray.field->size);
3867		/*
3868		 * The total allocated length of the dynamic array is
3869		 * stored in the top half of the field, and the offset
3870		 * is in the bottom half of the 32 bit field.
3871		 */
3872		offset &= 0xffff;
3873		val = (unsigned long long)((unsigned long)data + offset);
3874		break;
3875	default: /* not sure what to do there */
3876		return 0;
3877	}
3878	return val;
3879
3880out_warning_op:
3881	do_warning_event(event, "%s: unknown op '%s'", __func__, arg->op.op);
3882	return 0;
3883
3884out_warning_field:
3885	do_warning_event(event, "%s: field %s not found",
3886			 __func__, arg->field.name);
3887	return 0;
3888}
3889
3890struct flag {
3891	const char *name;
3892	unsigned long long value;
3893};
3894
3895static const struct flag flags[] = {
3896	{ "HI_SOFTIRQ", 0 },
3897	{ "TIMER_SOFTIRQ", 1 },
3898	{ "NET_TX_SOFTIRQ", 2 },
3899	{ "NET_RX_SOFTIRQ", 3 },
3900	{ "BLOCK_SOFTIRQ", 4 },
3901	{ "IRQ_POLL_SOFTIRQ", 5 },
3902	{ "TASKLET_SOFTIRQ", 6 },
3903	{ "SCHED_SOFTIRQ", 7 },
3904	{ "HRTIMER_SOFTIRQ", 8 },
3905	{ "RCU_SOFTIRQ", 9 },
3906
3907	{ "HRTIMER_NORESTART", 0 },
3908	{ "HRTIMER_RESTART", 1 },
3909};
3910
3911static long long eval_flag(const char *flag)
3912{
3913	int i;
3914
3915	/*
3916	 * Some flags in the format files do not get converted.
3917	 * If the flag is not numeric, see if it is something that
3918	 * we already know about.
3919	 */
3920	if (isdigit(flag[0]))
3921		return strtoull(flag, NULL, 0);
3922
3923	for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
3924		if (strcmp(flags[i].name, flag) == 0)
3925			return flags[i].value;
3926
3927	return -1LL;
3928}
3929
3930static void print_str_to_seq(struct trace_seq *s, const char *format,
3931			     int len_arg, const char *str)
3932{
3933	if (len_arg >= 0)
3934		trace_seq_printf(s, format, len_arg, str);
3935	else
3936		trace_seq_printf(s, format, str);
3937}
3938
3939static void print_bitmask_to_seq(struct tep_handle *tep,
3940				 struct trace_seq *s, const char *format,
3941				 int len_arg, const void *data, int size)
3942{
3943	int nr_bits = size * 8;
3944	int str_size = (nr_bits + 3) / 4;
3945	int len = 0;
3946	char buf[3];
3947	char *str;
3948	int index;
3949	int i;
3950
3951	/*
3952	 * The kernel likes to put in commas every 32 bits, we
3953	 * can do the same.
3954	 */
3955	str_size += (nr_bits - 1) / 32;
3956
3957	str = malloc(str_size + 1);
3958	if (!str) {
3959		do_warning("%s: not enough memory!", __func__);
3960		return;
3961	}
3962	str[str_size] = 0;
3963
3964	/* Start out with -2 for the two chars per byte */
3965	for (i = str_size - 2; i >= 0; i -= 2) {
3966		/*
3967		 * data points to a bit mask of size bytes.
3968		 * In the kernel, this is an array of long words, thus
3969		 * endianness is very important.
3970		 */
3971		if (tep->file_bigendian)
3972			index = size - (len + 1);
3973		else
3974			index = len;
3975
3976		snprintf(buf, 3, "%02x", *((unsigned char *)data + index));
3977		memcpy(str + i, buf, 2);
3978		len++;
3979		if (!(len & 3) && i > 0) {
3980			i--;
3981			str[i] = ',';
3982		}
3983	}
3984
3985	if (len_arg >= 0)
3986		trace_seq_printf(s, format, len_arg, str);
3987	else
3988		trace_seq_printf(s, format, str);
3989
3990	free(str);
3991}
3992
3993static void print_str_arg(struct trace_seq *s, void *data, int size,
3994			  struct tep_event *event, const char *format,
3995			  int len_arg, struct tep_print_arg *arg)
3996{
3997	struct tep_handle *tep = event->tep;
3998	struct tep_print_flag_sym *flag;
3999	struct tep_format_field *field;
4000	struct printk_map *printk;
4001	long long val, fval;
4002	unsigned long long addr;
4003	char *str;
4004	unsigned char *hex;
4005	int print;
4006	int i, len;
4007
4008	switch (arg->type) {
4009	case TEP_PRINT_NULL:
4010		/* ?? */
4011		return;
4012	case TEP_PRINT_ATOM:
4013		print_str_to_seq(s, format, len_arg, arg->atom.atom);
4014		return;
4015	case TEP_PRINT_FIELD:
4016		field = arg->field.field;
4017		if (!field) {
4018			field = tep_find_any_field(event, arg->field.name);
4019			if (!field) {
4020				str = arg->field.name;
4021				goto out_warning_field;
4022			}
4023			arg->field.field = field;
4024		}
4025		/* Zero sized fields, mean the rest of the data */
4026		len = field->size ? : size - field->offset;
4027
4028		/*
4029		 * Some events pass in pointers. If this is not an array
4030		 * and the size is the same as long_size, assume that it
4031		 * is a pointer.
4032		 */
4033		if (!(field->flags & TEP_FIELD_IS_ARRAY) &&
4034		    field->size == tep->long_size) {
4035
4036			/* Handle heterogeneous recording and processing
4037			 * architectures
4038			 *
4039			 * CASE I:
4040			 * Traces recorded on 32-bit devices (32-bit
4041			 * addressing) and processed on 64-bit devices:
4042			 * In this case, only 32 bits should be read.
4043			 *
4044			 * CASE II:
4045			 * Traces recorded on 64 bit devices and processed
4046			 * on 32-bit devices:
4047			 * In this case, 64 bits must be read.
4048			 */
4049			addr = (tep->long_size == 8) ?
4050				*(unsigned long long *)(data + field->offset) :
4051				(unsigned long long)*(unsigned int *)(data + field->offset);
4052
4053			/* Check if it matches a print format */
4054			printk = find_printk(tep, addr);
4055			if (printk)
4056				trace_seq_puts(s, printk->printk);
4057			else
4058				trace_seq_printf(s, "%llx", addr);
4059			break;
4060		}
4061		str = malloc(len + 1);
4062		if (!str) {
4063			do_warning_event(event, "%s: not enough memory!",
4064					 __func__);
4065			return;
4066		}
4067		memcpy(str, data + field->offset, len);
4068		str[len] = 0;
4069		print_str_to_seq(s, format, len_arg, str);
4070		free(str);
4071		break;
4072	case TEP_PRINT_FLAGS:
4073		val = eval_num_arg(data, size, event, arg->flags.field);
4074		print = 0;
4075		for (flag = arg->flags.flags; flag; flag = flag->next) {
4076			fval = eval_flag(flag->value);
4077			if (!val && fval < 0) {
4078				print_str_to_seq(s, format, len_arg, flag->str);
4079				break;
4080			}
4081			if (fval > 0 && (val & fval) == fval) {
4082				if (print && arg->flags.delim)
4083					trace_seq_puts(s, arg->flags.delim);
4084				print_str_to_seq(s, format, len_arg, flag->str);
4085				print = 1;
4086				val &= ~fval;
4087			}
4088		}
4089		if (val) {
4090			if (print && arg->flags.delim)
4091				trace_seq_puts(s, arg->flags.delim);
4092			trace_seq_printf(s, "0x%llx", val);
4093		}
4094		break;
4095	case TEP_PRINT_SYMBOL:
4096		val = eval_num_arg(data, size, event, arg->symbol.field);
4097		for (flag = arg->symbol.symbols; flag; flag = flag->next) {
4098			fval = eval_flag(flag->value);
4099			if (val == fval) {
4100				print_str_to_seq(s, format, len_arg, flag->str);
4101				break;
4102			}
4103		}
4104		if (!flag)
4105			trace_seq_printf(s, "0x%llx", val);
4106		break;
4107	case TEP_PRINT_HEX:
4108	case TEP_PRINT_HEX_STR:
4109		if (arg->hex.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4110			unsigned long offset;
4111			offset = tep_read_number(tep,
4112				data + arg->hex.field->dynarray.field->offset,
4113				arg->hex.field->dynarray.field->size);
4114			hex = data + (offset & 0xffff);
4115		} else {
4116			field = arg->hex.field->field.field;
4117			if (!field) {
4118				str = arg->hex.field->field.name;
4119				field = tep_find_any_field(event, str);
4120				if (!field)
4121					goto out_warning_field;
4122				arg->hex.field->field.field = field;
4123			}
4124			hex = data + field->offset;
4125		}
4126		len = eval_num_arg(data, size, event, arg->hex.size);
4127		for (i = 0; i < len; i++) {
4128			if (i && arg->type == TEP_PRINT_HEX)
4129				trace_seq_putc(s, ' ');
4130			trace_seq_printf(s, "%02x", hex[i]);
4131		}
4132		break;
4133
4134	case TEP_PRINT_INT_ARRAY: {
4135		void *num;
4136		int el_size;
4137
4138		if (arg->int_array.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4139			unsigned long offset;
4140			struct tep_format_field *field =
4141				arg->int_array.field->dynarray.field;
4142			offset = tep_read_number(tep,
4143						 data + field->offset,
4144						 field->size);
4145			num = data + (offset & 0xffff);
4146		} else {
4147			field = arg->int_array.field->field.field;
4148			if (!field) {
4149				str = arg->int_array.field->field.name;
4150				field = tep_find_any_field(event, str);
4151				if (!field)
4152					goto out_warning_field;
4153				arg->int_array.field->field.field = field;
4154			}
4155			num = data + field->offset;
4156		}
4157		len = eval_num_arg(data, size, event, arg->int_array.count);
4158		el_size = eval_num_arg(data, size, event,
4159				       arg->int_array.el_size);
4160		for (i = 0; i < len; i++) {
4161			if (i)
4162				trace_seq_putc(s, ' ');
4163
4164			if (el_size == 1) {
4165				trace_seq_printf(s, "%u", *(uint8_t *)num);
4166			} else if (el_size == 2) {
4167				trace_seq_printf(s, "%u", *(uint16_t *)num);
4168			} else if (el_size == 4) {
4169				trace_seq_printf(s, "%u", *(uint32_t *)num);
4170			} else if (el_size == 8) {
4171				trace_seq_printf(s, "%"PRIu64, *(uint64_t *)num);
4172			} else {
4173				trace_seq_printf(s, "BAD SIZE:%d 0x%x",
4174						 el_size, *(uint8_t *)num);
4175				el_size = 1;
4176			}
4177
4178			num += el_size;
4179		}
4180		break;
4181	}
4182	case TEP_PRINT_TYPE:
4183		break;
4184	case TEP_PRINT_STRING: {
4185		int str_offset;
4186
4187		if (arg->string.offset == -1) {
4188			struct tep_format_field *f;
4189
4190			f = tep_find_any_field(event, arg->string.string);
4191			arg->string.offset = f->offset;
4192		}
4193		str_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->string.offset));
4194		str_offset &= 0xffff;
4195		print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
4196		break;
4197	}
4198	case TEP_PRINT_BSTRING:
4199		print_str_to_seq(s, format, len_arg, arg->string.string);
4200		break;
4201	case TEP_PRINT_BITMASK: {
4202		int bitmask_offset;
4203		int bitmask_size;
4204
4205		if (arg->bitmask.offset == -1) {
4206			struct tep_format_field *f;
4207
4208			f = tep_find_any_field(event, arg->bitmask.bitmask);
4209			arg->bitmask.offset = f->offset;
4210		}
4211		bitmask_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->bitmask.offset));
4212		bitmask_size = bitmask_offset >> 16;
4213		bitmask_offset &= 0xffff;
4214		print_bitmask_to_seq(tep, s, format, len_arg,
4215				     data + bitmask_offset, bitmask_size);
4216		break;
4217	}
4218	case TEP_PRINT_OP:
4219		/*
4220		 * The only op for string should be ? :
4221		 */
4222		if (arg->op.op[0] != '?')
4223			return;
4224		val = eval_num_arg(data, size, event, arg->op.left);
4225		if (val)
4226			print_str_arg(s, data, size, event,
4227				      format, len_arg, arg->op.right->op.left);
4228		else
4229			print_str_arg(s, data, size, event,
4230				      format, len_arg, arg->op.right->op.right);
4231		break;
4232	case TEP_PRINT_FUNC:
4233		process_defined_func(s, data, size, event, arg);
4234		break;
4235	default:
4236		/* well... */
4237		break;
4238	}
4239
4240	return;
4241
4242out_warning_field:
4243	do_warning_event(event, "%s: field %s not found",
4244			 __func__, arg->field.name);
4245}
4246
4247static unsigned long long
4248process_defined_func(struct trace_seq *s, void *data, int size,
4249		     struct tep_event *event, struct tep_print_arg *arg)
4250{
4251	struct tep_function_handler *func_handle = arg->func.func;
4252	struct func_params *param;
4253	unsigned long long *args;
4254	unsigned long long ret;
4255	struct tep_print_arg *farg;
4256	struct trace_seq str;
4257	struct save_str {
4258		struct save_str *next;
4259		char *str;
4260	} *strings = NULL, *string;
4261	int i;
4262
4263	if (!func_handle->nr_args) {
4264		ret = (*func_handle->func)(s, NULL);
4265		goto out;
4266	}
4267
4268	farg = arg->func.args;
4269	param = func_handle->params;
4270
4271	ret = ULLONG_MAX;
4272	args = malloc(sizeof(*args) * func_handle->nr_args);
4273	if (!args)
4274		goto out;
4275
4276	for (i = 0; i < func_handle->nr_args; i++) {
4277		switch (param->type) {
4278		case TEP_FUNC_ARG_INT:
4279		case TEP_FUNC_ARG_LONG:
4280		case TEP_FUNC_ARG_PTR:
4281			args[i] = eval_num_arg(data, size, event, farg);
4282			break;
4283		case TEP_FUNC_ARG_STRING:
4284			trace_seq_init(&str);
4285			print_str_arg(&str, data, size, event, "%s", -1, farg);
4286			trace_seq_terminate(&str);
4287			string = malloc(sizeof(*string));
4288			if (!string) {
4289				do_warning_event(event, "%s(%d): malloc str",
4290						 __func__, __LINE__);
4291				goto out_free;
4292			}
4293			string->next = strings;
4294			string->str = strdup(str.buffer);
4295			if (!string->str) {
4296				free(string);
4297				do_warning_event(event, "%s(%d): malloc str",
4298						 __func__, __LINE__);
4299				goto out_free;
4300			}
4301			args[i] = (uintptr_t)string->str;
4302			strings = string;
4303			trace_seq_destroy(&str);
4304			break;
4305		default:
4306			/*
4307			 * Something went totally wrong, this is not
4308			 * an input error, something in this code broke.
4309			 */
4310			do_warning_event(event, "Unexpected end of arguments\n");
4311			goto out_free;
4312		}
4313		farg = farg->next;
4314		param = param->next;
4315	}
4316
4317	ret = (*func_handle->func)(s, args);
4318out_free:
4319	free(args);
4320	while (strings) {
4321		string = strings;
4322		strings = string->next;
4323		free(string->str);
4324		free(string);
4325	}
4326
4327 out:
4328	/* TBD : handle return type here */
4329	return ret;
4330}
4331
4332static void free_args(struct tep_print_arg *args)
4333{
4334	struct tep_print_arg *next;
4335
4336	while (args) {
4337		next = args->next;
4338
4339		free_arg(args);
4340		args = next;
4341	}
4342}
4343
4344static struct tep_print_arg *make_bprint_args(char *fmt, void *data, int size, struct tep_event *event)
4345{
4346	struct tep_handle *tep = event->tep;
4347	struct tep_format_field *field, *ip_field;
4348	struct tep_print_arg *args, *arg, **next;
4349	unsigned long long ip, val;
4350	char *ptr;
4351	void *bptr;
4352	int vsize = 0;
4353
4354	field = tep->bprint_buf_field;
4355	ip_field = tep->bprint_ip_field;
4356
4357	if (!field) {
4358		field = tep_find_field(event, "buf");
4359		if (!field) {
4360			do_warning_event(event, "can't find buffer field for binary printk");
4361			return NULL;
4362		}
4363		ip_field = tep_find_field(event, "ip");
4364		if (!ip_field) {
4365			do_warning_event(event, "can't find ip field for binary printk");
4366			return NULL;
4367		}
4368		tep->bprint_buf_field = field;
4369		tep->bprint_ip_field = ip_field;
4370	}
4371
4372	ip = tep_read_number(tep, data + ip_field->offset, ip_field->size);
4373
4374	/*
4375	 * The first arg is the IP pointer.
4376	 */
4377	args = alloc_arg();
4378	if (!args) {
4379		do_warning_event(event, "%s(%d): not enough memory!",
4380				 __func__, __LINE__);
4381		return NULL;
4382	}
4383	arg = args;
4384	arg->next = NULL;
4385	next = &arg->next;
4386
4387	arg->type = TEP_PRINT_ATOM;
4388		
4389	if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
4390		goto out_free;
4391
4392	/* skip the first "%ps: " */
4393	for (ptr = fmt + 5, bptr = data + field->offset;
4394	     bptr < data + size && *ptr; ptr++) {
4395		int ls = 0;
4396
4397		if (*ptr == '%') {
4398 process_again:
4399			ptr++;
4400			switch (*ptr) {
4401			case '%':
4402				break;
4403			case 'l':
4404				ls++;
4405				goto process_again;
4406			case 'L':
4407				ls = 2;
4408				goto process_again;
4409			case '0' ... '9':
4410				goto process_again;
4411			case '.':
4412				goto process_again;
4413			case 'z':
4414			case 'Z':
4415				ls = 1;
4416				goto process_again;
4417			case 'p':
4418				ls = 1;
4419				if (isalnum(ptr[1])) {
4420					ptr++;
4421					/* Check for special pointers */
4422					switch (*ptr) {
4423					case 's':
4424					case 'S':
4425					case 'x':
4426						break;
4427					case 'f':
4428					case 'F':
4429						/*
4430						 * Pre-5.5 kernels use %pf and
4431						 * %pF for printing symbols
4432						 * while kernels since 5.5 use
4433						 * %pfw for fwnodes. So check
4434						 * %p[fF] isn't followed by 'w'.
4435						 */
4436						if (ptr[1] != 'w')
4437							break;
4438						/* fall through */
4439					default:
4440						/*
4441						 * Older kernels do not process
4442						 * dereferenced pointers.
4443						 * Only process if the pointer
4444						 * value is a printable.
4445						 */
4446						if (isprint(*(char *)bptr))
4447							goto process_string;
4448					}
4449				}
4450				/* fall through */
4451			case 'd':
4452			case 'u':
4453			case 'i':
4454			case 'x':
4455			case 'X':
4456			case 'o':
4457				switch (ls) {
4458				case 0:
4459					vsize = 4;
4460					break;
4461				case 1:
4462					vsize = tep->long_size;
4463					break;
4464				case 2:
4465					vsize = 8;
4466					break;
4467				default:
4468					vsize = ls; /* ? */
4469					break;
4470				}
4471			/* fall through */
4472			case '*':
4473				if (*ptr == '*')
4474					vsize = 4;
4475
4476				/* the pointers are always 4 bytes aligned */
4477				bptr = (void *)(((unsigned long)bptr + 3) &
4478						~3);
4479				val = tep_read_number(tep, bptr, vsize);
4480				bptr += vsize;
4481				arg = alloc_arg();
4482				if (!arg) {
4483					do_warning_event(event, "%s(%d): not enough memory!",
4484						   __func__, __LINE__);
4485					goto out_free;
4486				}
4487				arg->next = NULL;
4488				arg->type = TEP_PRINT_ATOM;
4489				if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4490					free(arg);
4491					goto out_free;
4492				}
4493				*next = arg;
4494				next = &arg->next;
4495				/*
4496				 * The '*' case means that an arg is used as the length.
4497				 * We need to continue to figure out for what.
4498				 */
4499				if (*ptr == '*')
4500					goto process_again;
4501
4502				break;
4503			case 's':
4504 process_string:
4505				arg = alloc_arg();
4506				if (!arg) {
4507					do_warning_event(event, "%s(%d): not enough memory!",
4508						   __func__, __LINE__);
4509					goto out_free;
4510				}
4511				arg->next = NULL;
4512				arg->type = TEP_PRINT_BSTRING;
4513				arg->string.string = strdup(bptr);
4514				if (!arg->string.string)
4515					goto out_free;
4516				bptr += strlen(bptr) + 1;
4517				*next = arg;
4518				next = &arg->next;
4519			default:
4520				break;
4521			}
4522		}
4523	}
4524
4525	return args;
4526
4527out_free:
4528	free_args(args);
4529	return NULL;
4530}
4531
4532static char *
4533get_bprint_format(void *data, int size __maybe_unused,
4534		  struct tep_event *event)
4535{
4536	struct tep_handle *tep = event->tep;
4537	unsigned long long addr;
4538	struct tep_format_field *field;
4539	struct printk_map *printk;
4540	char *format;
4541
4542	field = tep->bprint_fmt_field;
4543
4544	if (!field) {
4545		field = tep_find_field(event, "fmt");
4546		if (!field) {
4547			do_warning_event(event, "can't find format field for binary printk");
4548			return NULL;
4549		}
4550		tep->bprint_fmt_field = field;
4551	}
4552
4553	addr = tep_read_number(tep, data + field->offset, field->size);
4554
4555	printk = find_printk(tep, addr);
4556	if (!printk) {
4557		if (asprintf(&format, "%%ps: (NO FORMAT FOUND at %llx)\n", addr) < 0)
4558			return NULL;
4559		return format;
4560	}
4561
4562	if (asprintf(&format, "%s: %s", "%ps", printk->printk) < 0)
4563		return NULL;
4564
4565	return format;
4566}
4567
4568static int print_mac_arg(struct trace_seq *s, const char *format,
4569			 void *data, int size, struct tep_event *event,
4570			 struct tep_print_arg *arg)
4571{
4572	const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
4573	bool reverse = false;
4574	unsigned char *buf;
4575	int ret = 0;
4576
4577	if (arg->type == TEP_PRINT_FUNC) {
4578		process_defined_func(s, data, size, event, arg);
4579		return 0;
4580	}
4581
4582	if (arg->type != TEP_PRINT_FIELD) {
4583		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
4584				 arg->type);
4585		return 0;
4586	}
4587
4588	if (format[0] == 'm') {
4589		fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
4590	} else if (format[0] == 'M' && format[1] == 'F') {
4591		fmt = "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x";
4592		ret++;
4593	}
4594	if (format[1] == 'R') {
4595		reverse = true;
4596		ret++;
4597	}
4598
4599	if (!arg->field.field) {
4600		arg->field.field =
4601			tep_find_any_field(event, arg->field.name);
4602		if (!arg->field.field) {
4603			do_warning_event(event, "%s: field %s not found",
4604					 __func__, arg->field.name);
4605			return ret;
4606		}
4607	}
4608	if (arg->field.field->size != 6) {
4609		trace_seq_printf(s, "INVALIDMAC");
4610		return ret;
4611	}
4612
4613	buf = data + arg->field.field->offset;
4614	if (reverse)
4615		trace_seq_printf(s, fmt, buf[5], buf[4], buf[3], buf[2], buf[1], buf[0]);
4616	else
4617		trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
4618
4619	return ret;
4620}
4621
4622static int parse_ip4_print_args(struct tep_handle *tep,
4623				const char *ptr, bool *reverse)
4624{
4625	int ret = 0;
4626
4627	*reverse = false;
4628
4629	/* hnbl */
4630	switch (*ptr) {
4631	case 'h':
4632		if (tep->file_bigendian)
4633			*reverse = false;
4634		else
4635			*reverse = true;
4636		ret++;
4637		break;
4638	case 'l':
4639		*reverse = true;
4640		ret++;
4641		break;
4642	case 'n':
4643	case 'b':
4644		ret++;
4645		/* fall through */
4646	default:
4647		*reverse = false;
4648		break;
4649	}
4650
4651	return ret;
4652}
4653
4654static void print_ip4_addr(struct trace_seq *s, char i, bool reverse, unsigned char *buf)
4655{
4656	const char *fmt;
4657
4658	if (i == 'i')
4659		fmt = "%03d.%03d.%03d.%03d";
4660	else
4661		fmt = "%d.%d.%d.%d";
4662
4663	if (reverse)
4664		trace_seq_printf(s, fmt, buf[3], buf[2], buf[1], buf[0]);
4665	else
4666		trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
4667
4668}
4669
4670static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
4671{
4672	return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
4673		(unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
4674}
4675
4676static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
4677{
4678	return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
4679}
4680
4681static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
4682{
4683	int i, j, range;
4684	unsigned char zerolength[8];
4685	int longest = 1;
4686	int colonpos = -1;
4687	uint16_t word;
4688	uint8_t hi, lo;
4689	bool needcolon = false;
4690	bool useIPv4;
4691	struct in6_addr in6;
4692
4693	memcpy(&in6, addr, sizeof(struct in6_addr));
4694
4695	useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
4696
4697	memset(zerolength, 0, sizeof(zerolength));
4698
4699	if (useIPv4)
4700		range = 6;
4701	else
4702		range = 8;
4703
4704	/* find position of longest 0 run */
4705	for (i = 0; i < range; i++) {
4706		for (j = i; j < range; j++) {
4707			if (in6.s6_addr16[j] != 0)
4708				break;
4709			zerolength[i]++;
4710		}
4711	}
4712	for (i = 0; i < range; i++) {
4713		if (zerolength[i] > longest) {
4714			longest = zerolength[i];
4715			colonpos = i;
4716		}
4717	}
4718	if (longest == 1)		/* don't compress a single 0 */
4719		colonpos = -1;
4720
4721	/* emit address */
4722	for (i = 0; i < range; i++) {
4723		if (i == colonpos) {
4724			if (needcolon || i == 0)
4725				trace_seq_printf(s, ":");
4726			trace_seq_printf(s, ":");
4727			needcolon = false;
4728			i += longest - 1;
4729			continue;
4730		}
4731		if (needcolon) {
4732			trace_seq_printf(s, ":");
4733			needcolon = false;
4734		}
4735		/* hex u16 without leading 0s */
4736		word = ntohs(in6.s6_addr16[i]);
4737		hi = word >> 8;
4738		lo = word & 0xff;
4739		if (hi)
4740			trace_seq_printf(s, "%x%02x", hi, lo);
4741		else
4742			trace_seq_printf(s, "%x", lo);
4743
4744		needcolon = true;
4745	}
4746
4747	if (useIPv4) {
4748		if (needcolon)
4749			trace_seq_printf(s, ":");
4750		print_ip4_addr(s, 'I', false, &in6.s6_addr[12]);
4751	}
4752
4753	return;
4754}
4755
4756static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
4757{
4758	int j;
4759
4760	for (j = 0; j < 16; j += 2) {
4761		trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
4762		if (i == 'I' && j < 14)
4763			trace_seq_printf(s, ":");
4764	}
4765}
4766
4767/*
4768 * %pi4   print an IPv4 address with leading zeros
4769 * %pI4   print an IPv4 address without leading zeros
4770 * %pi6   print an IPv6 address without colons
4771 * %pI6   print an IPv6 address with colons
4772 * %pI6c  print an IPv6 address in compressed form with colons
4773 * %pISpc print an IP address based on sockaddr; p adds port.
4774 */
4775static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
4776			  void *data, int size, struct tep_event *event,
4777			  struct tep_print_arg *arg)
4778{
4779	bool reverse = false;
4780	unsigned char *buf;
4781	int ret;
4782
4783	ret = parse_ip4_print_args(event->tep, ptr, &reverse);
4784
4785	if (arg->type == TEP_PRINT_FUNC) {
4786		process_defined_func(s, data, size, event, arg);
4787		return ret;
4788	}
4789
4790	if (arg->type != TEP_PRINT_FIELD) {
4791		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4792		return ret;
4793	}
4794
4795	if (!arg->field.field) {
4796		arg->field.field =
4797			tep_find_any_field(event, arg->field.name);
4798		if (!arg->field.field) {
4799			do_warning("%s: field %s not found",
4800				   __func__, arg->field.name);
4801			return ret;
4802		}
4803	}
4804
4805	buf = data + arg->field.field->offset;
4806
4807	if (arg->field.field->size != 4) {
4808		trace_seq_printf(s, "INVALIDIPv4");
4809		return ret;
4810	}
 
4811
4812	print_ip4_addr(s, i, reverse, buf);
4813	return ret;
4814
4815}
4816
4817static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
4818			  void *data, int size, struct tep_event *event,
4819			  struct tep_print_arg *arg)
4820{
4821	char have_c = 0;
4822	unsigned char *buf;
4823	int rc = 0;
4824
4825	/* pI6c */
4826	if (i == 'I' && *ptr == 'c') {
4827		have_c = 1;
4828		ptr++;
4829		rc++;
4830	}
4831
4832	if (arg->type == TEP_PRINT_FUNC) {
4833		process_defined_func(s, data, size, event, arg);
4834		return rc;
4835	}
4836
4837	if (arg->type != TEP_PRINT_FIELD) {
4838		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4839		return rc;
4840	}
4841
4842	if (!arg->field.field) {
4843		arg->field.field =
4844			tep_find_any_field(event, arg->field.name);
4845		if (!arg->field.field) {
4846			do_warning("%s: field %s not found",
4847				   __func__, arg->field.name);
4848			return rc;
4849		}
4850	}
4851
4852	buf = data + arg->field.field->offset;
4853
4854	if (arg->field.field->size != 16) {
4855		trace_seq_printf(s, "INVALIDIPv6");
4856		return rc;
4857	}
4858
4859	if (have_c)
4860		print_ip6c_addr(s, buf);
4861	else
4862		print_ip6_addr(s, i, buf);
4863
4864	return rc;
4865}
4866
4867static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
4868			  void *data, int size, struct tep_event *event,
4869			  struct tep_print_arg *arg)
4870{
4871	char have_c = 0, have_p = 0;
4872	unsigned char *buf;
4873	struct sockaddr_storage *sa;
4874	bool reverse = false;
4875	int rc = 0;
4876	int ret;
4877
4878	/* pISpc */
4879	if (i == 'I') {
4880		if (*ptr == 'p') {
4881			have_p = 1;
4882			ptr++;
4883			rc++;
4884		}
4885		if (*ptr == 'c') {
4886			have_c = 1;
4887			ptr++;
4888			rc++;
4889		}
4890	}
4891	ret = parse_ip4_print_args(event->tep, ptr, &reverse);
4892	ptr += ret;
4893	rc += ret;
4894
4895	if (arg->type == TEP_PRINT_FUNC) {
4896		process_defined_func(s, data, size, event, arg);
4897		return rc;
4898	}
4899
4900	if (arg->type != TEP_PRINT_FIELD) {
4901		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4902		return rc;
4903	}
4904
4905	if (!arg->field.field) {
4906		arg->field.field =
4907			tep_find_any_field(event, arg->field.name);
4908		if (!arg->field.field) {
4909			do_warning("%s: field %s not found",
4910				   __func__, arg->field.name);
4911			return rc;
4912		}
4913	}
4914
4915	sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4916
4917	if (sa->ss_family == AF_INET) {
4918		struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
4919
4920		if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4921			trace_seq_printf(s, "INVALIDIPv4");
4922			return rc;
4923		}
4924
4925		print_ip4_addr(s, i, reverse, (unsigned char *) &sa4->sin_addr);
4926		if (have_p)
4927			trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
4928
4929
4930	} else if (sa->ss_family == AF_INET6) {
4931		struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
4932
4933		if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4934			trace_seq_printf(s, "INVALIDIPv6");
4935			return rc;
4936		}
4937
4938		if (have_p)
4939			trace_seq_printf(s, "[");
4940
4941		buf = (unsigned char *) &sa6->sin6_addr;
4942		if (have_c)
4943			print_ip6c_addr(s, buf);
4944		else
4945			print_ip6_addr(s, i, buf);
4946
4947		if (have_p)
4948			trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
4949	}
4950
4951	return rc;
4952}
4953
4954static int print_ip_arg(struct trace_seq *s, const char *ptr,
4955			void *data, int size, struct tep_event *event,
4956			struct tep_print_arg *arg)
4957{
4958	char i = *ptr;  /* 'i' or 'I' */
4959	int rc = 1;
 
 
 
 
4960
4961	/* IP version */
4962	ptr++;
 
4963
4964	switch (*ptr) {
4965	case '4':
4966		rc += print_ipv4_arg(s, ptr + 1, i, data, size, event, arg);
4967		break;
4968	case '6':
4969		rc += print_ipv6_arg(s, ptr + 1, i, data, size, event, arg);
4970		break;
4971	case 'S':
4972		rc += print_ipsa_arg(s, ptr + 1, i, data, size, event, arg);
4973		break;
4974	default:
4975		return 0;
4976	}
4977
4978	return rc;
4979}
4980
4981static const int guid_index[16] = {3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11, 12, 13, 14, 15};
4982static const int uuid_index[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
4983
4984static int print_uuid_arg(struct trace_seq *s, const char *ptr,
4985			void *data, int size, struct tep_event *event,
4986			struct tep_print_arg *arg)
4987{
4988	const int *index = uuid_index;
4989	char *format = "%02x";
4990	int ret = 0;
4991	char *buf;
4992	int i;
4993
4994	switch (*(ptr + 1)) {
4995	case 'L':
4996		format = "%02X";
4997		/* fall through */
4998	case 'l':
4999		index = guid_index;
5000		ret++;
5001		break;
5002	case 'B':
5003		format = "%02X";
5004		/* fall through */
5005	case 'b':
5006		ret++;
5007		break;
5008	}
5009
5010	if (arg->type == TEP_PRINT_FUNC) {
5011		process_defined_func(s, data, size, event, arg);
5012		return ret;
5013	}
5014
5015	if (arg->type != TEP_PRINT_FIELD) {
5016		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
5017		return ret;
5018	}
5019
5020	if (!arg->field.field) {
5021		arg->field.field =
5022			tep_find_any_field(event, arg->field.name);
5023		if (!arg->field.field) {
5024			do_warning("%s: field %s not found",
5025				   __func__, arg->field.name);
5026			return ret;
5027		}
5028	}
5029
5030	if (arg->field.field->size != 16) {
5031		trace_seq_printf(s, "INVALIDUUID");
5032		return ret;
5033	}
5034
5035	buf = data + arg->field.field->offset;
5036
5037	for (i = 0; i < 16; i++) {
5038		trace_seq_printf(s, format, buf[index[i]] & 0xff);
5039		switch (i) {
5040		case 3:
5041		case 5:
5042		case 7:
5043		case 9:
5044			trace_seq_printf(s, "-");
5045			break;
5046		}
5047	}
5048
5049	return ret;
5050}
5051
5052static int print_raw_buff_arg(struct trace_seq *s, const char *ptr,
5053			      void *data, int size, struct tep_event *event,
5054			      struct tep_print_arg *arg, int print_len)
5055{
5056	int plen = print_len;
5057	char *delim = " ";
5058	int ret = 0;
5059	char *buf;
5060	int i;
5061	unsigned long offset;
5062	int arr_len;
5063
5064	switch (*(ptr + 1)) {
5065	case 'C':
5066		delim = ":";
5067		ret++;
5068		break;
5069	case 'D':
5070		delim = "-";
5071		ret++;
5072		break;
5073	case 'N':
5074		delim = "";
5075		ret++;
5076		break;
5077	}
5078
5079	if (arg->type == TEP_PRINT_FUNC) {
5080		process_defined_func(s, data, size, event, arg);
5081		return ret;
5082	}
5083
5084	if (arg->type != TEP_PRINT_DYNAMIC_ARRAY) {
5085		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
5086		return ret;
5087	}
5088
5089	offset = tep_read_number(event->tep,
5090				 data + arg->dynarray.field->offset,
5091				 arg->dynarray.field->size);
5092	arr_len = (unsigned long long)(offset >> 16);
5093	buf = data + (offset & 0xffff);
5094
5095	if (arr_len < plen)
5096		plen = arr_len;
5097
5098	if (plen < 1)
5099		return ret;
5100
5101	trace_seq_printf(s, "%02x", buf[0] & 0xff);
5102	for (i = 1; i < plen; i++)
5103		trace_seq_printf(s, "%s%02x", delim, buf[i] & 0xff);
5104
5105	return ret;
5106}
5107
5108static int is_printable_array(char *p, unsigned int len)
5109{
5110	unsigned int i;
5111
5112	for (i = 0; i < len && p[i]; i++)
5113		if (!isprint(p[i]) && !isspace(p[i]))
5114		    return 0;
5115	return 1;
5116}
5117
5118void tep_print_field(struct trace_seq *s, void *data,
5119		     struct tep_format_field *field)
5120{
5121	unsigned long long val;
5122	unsigned int offset, len, i;
5123	struct tep_handle *tep = field->event->tep;
5124
5125	if (field->flags & TEP_FIELD_IS_ARRAY) {
5126		offset = field->offset;
5127		len = field->size;
5128		if (field->flags & TEP_FIELD_IS_DYNAMIC) {
5129			val = tep_read_number(tep, data + offset, len);
5130			offset = val;
5131			len = offset >> 16;
5132			offset &= 0xffff;
5133		}
5134		if (field->flags & TEP_FIELD_IS_STRING &&
5135		    is_printable_array(data + offset, len)) {
5136			trace_seq_printf(s, "%s", (char *)data + offset);
5137		} else {
5138			trace_seq_puts(s, "ARRAY[");
5139			for (i = 0; i < len; i++) {
5140				if (i)
5141					trace_seq_puts(s, ", ");
5142				trace_seq_printf(s, "%02x",
5143						 *((unsigned char *)data + offset + i));
5144			}
5145			trace_seq_putc(s, ']');
5146			field->flags &= ~TEP_FIELD_IS_STRING;
5147		}
5148	} else {
5149		val = tep_read_number(tep, data + field->offset,
5150				      field->size);
5151		if (field->flags & TEP_FIELD_IS_POINTER) {
5152			trace_seq_printf(s, "0x%llx", val);
5153		} else if (field->flags & TEP_FIELD_IS_SIGNED) {
5154			switch (field->size) {
5155			case 4:
5156				/*
5157				 * If field is long then print it in hex.
5158				 * A long usually stores pointers.
5159				 */
5160				if (field->flags & TEP_FIELD_IS_LONG)
5161					trace_seq_printf(s, "0x%x", (int)val);
5162				else
5163					trace_seq_printf(s, "%d", (int)val);
5164				break;
5165			case 2:
5166				trace_seq_printf(s, "%2d", (short)val);
5167				break;
5168			case 1:
5169				trace_seq_printf(s, "%1d", (char)val);
5170				break;
5171			default:
5172				trace_seq_printf(s, "%lld", val);
5173			}
5174		} else {
5175			if (field->flags & TEP_FIELD_IS_LONG)
5176				trace_seq_printf(s, "0x%llx", val);
5177			else
5178				trace_seq_printf(s, "%llu", val);
5179		}
5180	}
5181}
5182
5183void tep_print_fields(struct trace_seq *s, void *data,
5184		      int size __maybe_unused, struct tep_event *event)
5185{
5186	struct tep_format_field *field;
5187
5188	field = event->format.fields;
5189	while (field) {
5190		trace_seq_printf(s, " %s=", field->name);
5191		tep_print_field(s, data, field);
5192		field = field->next;
5193	}
5194}
5195
5196static int print_function(struct trace_seq *s, const char *format,
5197			  void *data, int size, struct tep_event *event,
5198			  struct tep_print_arg *arg)
5199{
5200	struct func_map *func;
5201	unsigned long long val;
5202
5203	val = eval_num_arg(data, size, event, arg);
5204	func = find_func(event->tep, val);
5205	if (func) {
5206		trace_seq_puts(s, func->func);
5207		if (*format == 'F' || *format == 'S')
5208			trace_seq_printf(s, "+0x%llx", val - func->addr);
5209	} else {
5210		if (event->tep->long_size == 4)
5211			trace_seq_printf(s, "0x%lx", (long)val);
5212		else
5213			trace_seq_printf(s, "0x%llx", (long long)val);
5214	}
5215
5216	return 0;
5217}
5218
5219static int print_arg_pointer(struct trace_seq *s, const char *format, int plen,
5220			     void *data, int size,
5221			     struct tep_event *event, struct tep_print_arg *arg)
5222{
 
 
 
 
 
5223	unsigned long long val;
5224	int ret = 1;
5225
5226	if (arg->type == TEP_PRINT_BSTRING) {
5227		trace_seq_puts(s, arg->string.string);
5228		return 0;
5229	}
5230	while (*format) {
5231		if (*format == 'p') {
5232			format++;
5233			break;
5234		}
5235		format++;
5236	}
5237
5238	switch (*format) {
5239	case 'F':
5240	case 'f':
5241	case 'S':
5242	case 's':
5243		ret += print_function(s, format, data, size, event, arg);
5244		break;
5245	case 'M':
5246	case 'm':
5247		ret += print_mac_arg(s, format, data, size, event, arg);
5248		break;
5249	case 'I':
5250	case 'i':
5251		ret += print_ip_arg(s, format, data, size, event, arg);
5252		break;
5253	case 'U':
5254		ret += print_uuid_arg(s, format, data, size, event, arg);
5255		break;
5256	case 'h':
5257		ret += print_raw_buff_arg(s, format, data, size, event, arg, plen);
5258		break;
5259	default:
5260		ret = 0;
5261		val = eval_num_arg(data, size, event, arg);
5262		trace_seq_printf(s, "%p", (void *)(intptr_t)val);
5263		break;
5264	}
5265
5266	return ret;
5267
5268}
5269
5270static int print_arg_number(struct trace_seq *s, const char *format, int plen,
5271			    void *data, int size, int ls,
5272			    struct tep_event *event, struct tep_print_arg *arg)
5273{
5274	unsigned long long val;
5275
5276	val = eval_num_arg(data, size, event, arg);
5277
5278	switch (ls) {
5279	case -2:
5280		if (plen >= 0)
5281			trace_seq_printf(s, format, plen, (char)val);
5282		else
5283			trace_seq_printf(s, format, (char)val);
5284		break;
5285	case -1:
5286		if (plen >= 0)
5287			trace_seq_printf(s, format, plen, (short)val);
5288		else
5289			trace_seq_printf(s, format, (short)val);
5290		break;
5291	case 0:
5292		if (plen >= 0)
5293			trace_seq_printf(s, format, plen, (int)val);
5294		else
5295			trace_seq_printf(s, format, (int)val);
5296		break;
5297	case 1:
5298		if (plen >= 0)
5299			trace_seq_printf(s, format, plen, (long)val);
5300		else
5301			trace_seq_printf(s, format, (long)val);
5302		break;
5303	case 2:
5304		if (plen >= 0)
5305			trace_seq_printf(s, format, plen, (long long)val);
5306		else
5307			trace_seq_printf(s, format, (long long)val);
5308		break;
5309	default:
5310		do_warning_event(event, "bad count (%d)", ls);
5311		event->flags |= TEP_EVENT_FL_FAILED;
5312	}
5313	return 0;
5314}
5315
5316
5317static void print_arg_string(struct trace_seq *s, const char *format, int plen,
5318			     void *data, int size,
5319			     struct tep_event *event, struct tep_print_arg *arg)
5320{
5321	struct trace_seq p;
5322
5323	/* Use helper trace_seq */
5324	trace_seq_init(&p);
5325	print_str_arg(&p, data, size, event,
5326		      format, plen, arg);
5327	trace_seq_terminate(&p);
5328	trace_seq_puts(s, p.buffer);
5329	trace_seq_destroy(&p);
5330}
5331
5332static int parse_arg_format_pointer(const char *format)
5333{
5334	int ret = 0;
5335	int index;
5336	int loop;
5337
5338	switch (*format) {
5339	case 'F':
5340	case 'S':
5341	case 'f':
5342	case 's':
5343		ret++;
5344		break;
5345	case 'M':
5346	case 'm':
5347		/* [mM]R , [mM]F */
5348		switch (format[1]) {
5349		case 'R':
5350		case 'F':
5351			ret++;
5352			break;
5353		}
5354		ret++;
5355		break;
5356	case 'I':
5357	case 'i':
5358		index = 2;
5359		loop = 1;
5360		switch (format[1]) {
5361		case 'S':
5362			/*[S][pfs]*/
5363			while (loop) {
5364				switch (format[index]) {
5365				case 'p':
5366				case 'f':
5367				case 's':
5368					ret++;
5369					index++;
5370					break;
5371				default:
5372					loop = 0;
5373					break;
5374				}
5375			}
5376			/* fall through */
5377		case '4':
5378			/* [4S][hnbl] */
5379			switch (format[index]) {
5380			case 'h':
5381			case 'n':
5382			case 'l':
5383			case 'b':
5384				ret++;
5385				index++;
5386				break;
5387			}
5388			if (format[1] == '4') {
5389				ret++;
 
 
 
 
 
 
 
 
5390				break;
5391			}
5392			/* fall through */
5393		case '6':
5394			/* [6S]c */
5395			if (format[index] == 'c')
5396				ret++;
5397			ret++;
5398			break;
5399		}
5400		ret++;
5401		break;
5402	case 'U':
5403		switch (format[1]) {
5404		case 'L':
5405		case 'l':
5406		case 'B':
5407		case 'b':
5408			ret++;
5409			break;
5410		}
5411		ret++;
5412		break;
5413	case 'h':
5414		switch (format[1]) {
5415		case 'C':
5416		case 'D':
5417		case 'N':
5418			ret++;
5419			break;
5420		}
5421		ret++;
5422		break;
5423	default:
5424		break;
5425	}
5426
5427	return ret;
5428}
5429
5430static void free_parse_args(struct tep_print_parse *arg)
5431{
5432	struct tep_print_parse *del;
5433
5434	while (arg) {
5435		del = arg;
5436		arg = del->next;
5437		free(del->format);
5438		free(del);
5439	}
5440}
5441
5442static int parse_arg_add(struct tep_print_parse **parse, char *format,
5443			 enum tep_print_parse_type type,
5444			 struct tep_print_arg *arg,
5445			 struct tep_print_arg *len_as_arg,
5446			 int ls)
5447{
5448	struct tep_print_parse *parg = NULL;
5449
5450	parg = calloc(1, sizeof(*parg));
5451	if (!parg)
5452		goto error;
5453	parg->format = strdup(format);
5454	if (!parg->format)
5455		goto error;
5456	parg->type = type;
5457	parg->arg = arg;
5458	parg->len_as_arg = len_as_arg;
5459	parg->ls = ls;
5460	*parse = parg;
5461	return 0;
5462error:
5463	if (parg) {
5464		free(parg->format);
5465		free(parg);
5466	}
5467	return -1;
5468}
5469
5470static int parse_arg_format(struct tep_print_parse **parse,
5471			    struct tep_event *event,
5472			    const char *format, struct tep_print_arg **arg)
5473{
5474	struct tep_print_arg *len_arg = NULL;
5475	char print_format[32];
5476	const char *start = format;
5477	int ret = 0;
5478	int ls = 0;
5479	int res;
5480	int len;
5481
5482	format++;
5483	ret++;
5484	for (; *format; format++) {
5485		switch (*format) {
5486		case '#':
5487			/* FIXME: need to handle properly */
5488			break;
5489		case 'h':
5490			ls--;
5491			break;
5492		case 'l':
5493			ls++;
5494			break;
5495		case 'L':
5496			ls = 2;
5497			break;
5498		case '.':
5499		case 'z':
5500		case 'Z':
5501		case '0' ... '9':
5502		case '-':
5503			break;
5504		case '*':
5505			/* The argument is the length. */
5506			if (!*arg) {
5507				do_warning_event(event, "no argument match");
5508				event->flags |= TEP_EVENT_FL_FAILED;
5509				goto out_failed;
5510			}
5511			if (len_arg) {
5512				do_warning_event(event, "argument already matched");
5513				event->flags |= TEP_EVENT_FL_FAILED;
5514				goto out_failed;
5515			}
5516			len_arg = *arg;
5517			*arg = (*arg)->next;
5518			break;
5519		case 'p':
5520			if (!*arg) {
5521				do_warning_event(event, "no argument match");
5522				event->flags |= TEP_EVENT_FL_FAILED;
5523				goto out_failed;
5524			}
5525			res = parse_arg_format_pointer(format + 1);
5526			if (res > 0) {
5527				format += res;
5528				ret += res;
5529			}
5530			len = ((unsigned long)format + 1) -
5531				(unsigned long)start;
5532			/* should never happen */
5533			if (len > 31) {
5534				do_warning_event(event, "bad format!");
5535				event->flags |= TEP_EVENT_FL_FAILED;
5536				len = 31;
5537			}
5538			memcpy(print_format, start, len);
5539			print_format[len] = 0;
5540
5541			parse_arg_add(parse, print_format,
5542				      PRINT_FMT_ARG_POINTER, *arg, len_arg, ls);
5543			*arg = (*arg)->next;
5544			ret++;
5545			return ret;
5546		case 'd':
5547		case 'u':
5548		case 'i':
5549		case 'x':
5550		case 'X':
5551		case 'o':
5552			if (!*arg) {
5553				do_warning_event(event, "no argument match");
5554				event->flags |= TEP_EVENT_FL_FAILED;
5555				goto out_failed;
5556			}
5557
5558			len = ((unsigned long)format + 1) -
5559				(unsigned long)start;
 
 
 
 
 
 
 
5560
5561			/* should never happen */
5562			if (len > 30) {
5563				do_warning_event(event, "bad format!");
5564				event->flags |= TEP_EVENT_FL_FAILED;
5565				len = 31;
5566			}
5567			memcpy(print_format, start, len);
5568			print_format[len] = 0;
5569
5570			if (event->tep->long_size == 8 && ls == 1 &&
5571			    sizeof(long) != 8) {
5572				char *p;
5573
5574				/* make %l into %ll */
5575				if (ls == 1 && (p = strchr(print_format, 'l')))
5576					memmove(p+1, p, strlen(p)+1);
5577				ls = 2;
5578			}
5579			if (ls < -2 || ls > 2) {
5580				do_warning_event(event, "bad count (%d)", ls);
5581				event->flags |= TEP_EVENT_FL_FAILED;
5582			}
5583			parse_arg_add(parse, print_format,
5584				      PRINT_FMT_ARG_DIGIT, *arg, len_arg, ls);
5585			*arg = (*arg)->next;
5586			ret++;
5587			return ret;
5588		case 's':
5589			if (!*arg) {
5590				do_warning_event(event, "no matching argument");
5591				event->flags |= TEP_EVENT_FL_FAILED;
5592				goto out_failed;
5593			}
5594
5595			len = ((unsigned long)format + 1) -
5596				(unsigned long)start;
5597
5598			/* should never happen */
5599			if (len > 31) {
5600				do_warning_event(event, "bad format!");
5601				event->flags |= TEP_EVENT_FL_FAILED;
5602				len = 31;
5603			}
5604
5605			memcpy(print_format, start, len);
5606			print_format[len] = 0;
5607
5608			parse_arg_add(parse, print_format,
5609					PRINT_FMT_ARG_STRING, *arg, len_arg, 0);
5610			*arg = (*arg)->next;
5611			ret++;
5612			return ret;
5613		default:
5614			snprintf(print_format, 32, ">%c<", *format);
5615			parse_arg_add(parse, print_format,
5616					PRINT_FMT_STRING, NULL, NULL, 0);
5617			ret++;
5618			return ret;
5619		}
5620		ret++;
5621	}
5622
5623out_failed:
5624	return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5625
5626}
 
5627
5628static int parse_arg_string(struct tep_print_parse **parse, const char *format)
5629{
5630	struct trace_seq s;
5631	int ret = 0;
 
 
5632
5633	trace_seq_init(&s);
5634	for (; *format; format++) {
5635		if (*format == '\\') {
5636			format++;
5637			ret++;
5638			switch (*format) {
5639			case 'n':
5640				trace_seq_putc(&s, '\n');
5641				break;
5642			case 't':
5643				trace_seq_putc(&s, '\t');
5644				break;
5645			case 'r':
5646				trace_seq_putc(&s, '\r');
5647				break;
5648			case '\\':
5649				trace_seq_putc(&s, '\\');
5650				break;
5651			default:
5652				trace_seq_putc(&s, *format);
5653				break;
5654			}
5655		} else if (*format == '%') {
5656			if (*(format + 1) == '%') {
5657				trace_seq_putc(&s, '%');
5658				format++;
5659				ret++;
5660			} else
5661				break;
5662		} else
5663			trace_seq_putc(&s, *format);
5664
5665		ret++;
5666	}
5667	trace_seq_terminate(&s);
5668	parse_arg_add(parse, s.buffer, PRINT_FMT_STRING, NULL, NULL, 0);
5669	trace_seq_destroy(&s);
5670
5671	return ret;
5672}
5673
5674static struct tep_print_parse *
5675parse_args(struct tep_event *event, const char *format, struct tep_print_arg *arg)
5676{
5677	struct tep_print_parse *parse_ret = NULL;
5678	struct tep_print_parse **parse = NULL;
5679	int ret;
5680	int len;
5681
5682	len = strlen(format);
5683	while (*format) {
5684		if (!parse_ret)
5685			parse = &parse_ret;
5686		if (*format == '%' && *(format + 1) != '%')
5687			ret = parse_arg_format(parse, event, format, &arg);
5688		else
5689			ret = parse_arg_string(parse, format);
5690		if (*parse)
5691			parse = &((*parse)->next);
5692
5693		len -= ret;
5694		if (len > 0)
5695			format += ret;
5696		else
5697			break;
5698	}
5699	return parse_ret;
5700}
5701
5702static void print_event_cache(struct tep_print_parse *parse, struct trace_seq *s,
5703			      void *data, int size, struct tep_event *event)
5704{
5705	int len_arg;
5706
5707	while (parse) {
5708		if (parse->len_as_arg)
5709			len_arg = eval_num_arg(data, size, event, parse->len_as_arg);
5710		switch (parse->type) {
5711		case PRINT_FMT_ARG_DIGIT:
5712			print_arg_number(s, parse->format,
5713					parse->len_as_arg ? len_arg : -1, data,
5714					 size, parse->ls, event, parse->arg);
5715			break;
5716		case PRINT_FMT_ARG_POINTER:
5717			print_arg_pointer(s, parse->format,
5718					  parse->len_as_arg ? len_arg : 1,
5719					  data, size, event, parse->arg);
5720			break;
5721		case PRINT_FMT_ARG_STRING:
5722			print_arg_string(s, parse->format,
5723					 parse->len_as_arg ? len_arg : -1,
5724					 data, size, event, parse->arg);
5725			break;
5726		case PRINT_FMT_STRING:
5727		default:
5728			trace_seq_printf(s, "%s", parse->format);
5729			break;
5730		}
5731		parse = parse->next;
5732	}
5733}
5734
5735static void pretty_print(struct trace_seq *s, void *data, int size, struct tep_event *event)
5736{
5737	struct tep_print_parse *parse = event->print_fmt.print_cache;
5738	struct tep_print_arg *args = NULL;
5739	char *bprint_fmt = NULL;
5740
5741	if (event->flags & TEP_EVENT_FL_FAILED) {
5742		trace_seq_printf(s, "[FAILED TO PARSE]");
5743		tep_print_fields(s, data, size, event);
5744		return;
5745	}
5746
5747	if (event->flags & TEP_EVENT_FL_ISBPRINT) {
5748		bprint_fmt = get_bprint_format(data, size, event);
5749		args = make_bprint_args(bprint_fmt, data, size, event);
5750		parse = parse_args(event, bprint_fmt, args);
5751	}
5752
5753	print_event_cache(parse, s, data, size, event);
5754
5755	if (event->flags & TEP_EVENT_FL_ISBPRINT) {
5756		free_parse_args(parse);
5757		free_args(args);
5758		free(bprint_fmt);
5759	}
5760}
5761
5762/*
 
 
 
 
 
5763 * This parses out the Latency format (interrupts disabled,
5764 * need rescheduling, in hard/soft interrupt, preempt count
5765 * and lock depth) and places it into the trace_seq.
5766 */
5767static void data_latency_format(struct tep_handle *tep, struct trace_seq *s,
5768				char *format, struct tep_record *record)
5769{
5770	static int check_lock_depth = 1;
5771	static int check_migrate_disable = 1;
5772	static int lock_depth_exists;
5773	static int migrate_disable_exists;
5774	unsigned int lat_flags;
5775	struct trace_seq sq;
5776	unsigned int pc;
5777	int lock_depth = 0;
5778	int migrate_disable = 0;
5779	int hardirq;
5780	int softirq;
5781	void *data = record->data;
5782
5783	trace_seq_init(&sq);
5784	lat_flags = parse_common_flags(tep, data);
5785	pc = parse_common_pc(tep, data);
5786	/* lock_depth may not always exist */
5787	if (lock_depth_exists)
5788		lock_depth = parse_common_lock_depth(tep, data);
5789	else if (check_lock_depth) {
5790		lock_depth = parse_common_lock_depth(tep, data);
5791		if (lock_depth < 0)
5792			check_lock_depth = 0;
5793		else
5794			lock_depth_exists = 1;
5795	}
5796
5797	/* migrate_disable may not always exist */
5798	if (migrate_disable_exists)
5799		migrate_disable = parse_common_migrate_disable(tep, data);
5800	else if (check_migrate_disable) {
5801		migrate_disable = parse_common_migrate_disable(tep, data);
5802		if (migrate_disable < 0)
5803			check_migrate_disable = 0;
5804		else
5805			migrate_disable_exists = 1;
5806	}
5807
5808	hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
5809	softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
5810
5811	trace_seq_printf(&sq, "%c%c%c",
5812	       (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
5813	       (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
5814	       'X' : '.',
5815	       (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
5816	       'N' : '.',
5817	       (hardirq && softirq) ? 'H' :
5818	       hardirq ? 'h' : softirq ? 's' : '.');
5819
5820	if (pc)
5821		trace_seq_printf(&sq, "%x", pc);
5822	else
5823		trace_seq_printf(&sq, ".");
5824
5825	if (migrate_disable_exists) {
5826		if (migrate_disable < 0)
5827			trace_seq_printf(&sq, ".");
5828		else
5829			trace_seq_printf(&sq, "%d", migrate_disable);
5830	}
5831
5832	if (lock_depth_exists) {
5833		if (lock_depth < 0)
5834			trace_seq_printf(&sq, ".");
5835		else
5836			trace_seq_printf(&sq, "%d", lock_depth);
5837	}
5838
5839	if (sq.state == TRACE_SEQ__MEM_ALLOC_FAILED) {
5840		s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
5841		return;
5842	}
5843
5844	trace_seq_terminate(&sq);
5845	trace_seq_puts(s, sq.buffer);
5846	trace_seq_destroy(&sq);
5847	trace_seq_terminate(s);
5848}
5849
5850/**
5851 * tep_data_type - parse out the given event type
5852 * @tep: a handle to the trace event parser context
5853 * @rec: the record to read from
5854 *
5855 * This returns the event id from the @rec.
5856 */
5857int tep_data_type(struct tep_handle *tep, struct tep_record *rec)
 
 
 
 
 
 
 
 
 
 
 
 
5858{
5859	return trace_parse_common_type(tep, rec->data);
5860}
5861
5862/**
5863 * tep_data_pid - parse the PID from record
5864 * @tep: a handle to the trace event parser context
5865 * @rec: the record to parse
5866 *
5867 * This returns the PID from a record.
5868 */
5869int tep_data_pid(struct tep_handle *tep, struct tep_record *rec)
5870{
5871	return parse_common_pid(tep, rec->data);
5872}
5873
5874/**
5875 * tep_data_preempt_count - parse the preempt count from the record
5876 * @tep: a handle to the trace event parser context
5877 * @rec: the record to parse
5878 *
5879 * This returns the preempt count from a record.
5880 */
5881int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec)
5882{
5883	return parse_common_pc(tep, rec->data);
5884}
5885
5886/**
5887 * tep_data_flags - parse the latency flags from the record
5888 * @tep: a handle to the trace event parser context
5889 * @rec: the record to parse
5890 *
5891 * This returns the latency flags from a record.
5892 *
5893 *  Use trace_flag_type enum for the flags (see event-parse.h).
5894 */
5895int tep_data_flags(struct tep_handle *tep, struct tep_record *rec)
5896{
5897	return parse_common_flags(tep, rec->data);
5898}
5899
5900/**
5901 * tep_data_comm_from_pid - return the command line from PID
5902 * @tep: a handle to the trace event parser context
5903 * @pid: the PID of the task to search for
5904 *
5905 * This returns a pointer to the command line that has the given
5906 * @pid.
5907 */
5908const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid)
5909{
5910	const char *comm;
5911
5912	comm = find_cmdline(tep, pid);
5913	return comm;
5914}
5915
5916static struct tep_cmdline *
5917pid_from_cmdlist(struct tep_handle *tep, const char *comm, struct tep_cmdline *next)
5918{
5919	struct cmdline_list *cmdlist = (struct cmdline_list *)next;
5920
5921	if (cmdlist)
5922		cmdlist = cmdlist->next;
5923	else
5924		cmdlist = tep->cmdlist;
5925
5926	while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
5927		cmdlist = cmdlist->next;
5928
5929	return (struct tep_cmdline *)cmdlist;
5930}
5931
5932/**
5933 * tep_data_pid_from_comm - return the pid from a given comm
5934 * @tep: a handle to the trace event parser context
5935 * @comm: the cmdline to find the pid from
5936 * @next: the cmdline structure to find the next comm
5937 *
5938 * This returns the cmdline structure that holds a pid for a given
5939 * comm, or NULL if none found. As there may be more than one pid for
5940 * a given comm, the result of this call can be passed back into
5941 * a recurring call in the @next parameter, and then it will find the
5942 * next pid.
5943 * Also, it does a linear search, so it may be slow.
5944 */
5945struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm,
5946					   struct tep_cmdline *next)
5947{
5948	struct tep_cmdline *cmdline;
5949
5950	/*
5951	 * If the cmdlines have not been converted yet, then use
5952	 * the list.
5953	 */
5954	if (!tep->cmdlines)
5955		return pid_from_cmdlist(tep, comm, next);
5956
5957	if (next) {
5958		/*
5959		 * The next pointer could have been still from
5960		 * a previous call before cmdlines were created
5961		 */
5962		if (next < tep->cmdlines ||
5963		    next >= tep->cmdlines + tep->cmdline_count)
5964			next = NULL;
5965		else
5966			cmdline  = next++;
5967	}
5968
5969	if (!next)
5970		cmdline = tep->cmdlines;
5971
5972	while (cmdline < tep->cmdlines + tep->cmdline_count) {
5973		if (strcmp(cmdline->comm, comm) == 0)
5974			return cmdline;
5975		cmdline++;
5976	}
5977	return NULL;
5978}
5979
5980/**
5981 * tep_cmdline_pid - return the pid associated to a given cmdline
5982 * @tep: a handle to the trace event parser context
5983 * @cmdline: The cmdline structure to get the pid from
5984 *
5985 * Returns the pid for a give cmdline. If @cmdline is NULL, then
5986 * -1 is returned.
5987 */
5988int tep_cmdline_pid(struct tep_handle *tep, struct tep_cmdline *cmdline)
5989{
5990	struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
5991
5992	if (!cmdline)
5993		return -1;
5994
5995	/*
5996	 * If cmdlines have not been created yet, or cmdline is
5997	 * not part of the array, then treat it as a cmdlist instead.
5998	 */
5999	if (!tep->cmdlines ||
6000	    cmdline < tep->cmdlines ||
6001	    cmdline >= tep->cmdlines + tep->cmdline_count)
6002		return cmdlist->pid;
6003
6004	return cmdline->pid;
6005}
6006
6007/*
 
 
 
 
 
6008 * This parses the raw @data using the given @event information and
6009 * writes the print format into the trace_seq.
6010 */
6011static void print_event_info(struct trace_seq *s, char *format, bool raw,
6012			     struct tep_event *event, struct tep_record *record)
6013{
6014	int print_pretty = 1;
6015
6016	if (raw || (event->flags & TEP_EVENT_FL_PRINTRAW))
6017		tep_print_fields(s, record->data, record->size, event);
6018	else {
6019
6020		if (event->handler && !(event->flags & TEP_EVENT_FL_NOHANDLE))
6021			print_pretty = event->handler(s, record, event,
6022						      event->context);
6023
6024		if (print_pretty)
6025			pretty_print(s, record->data, record->size, event);
6026	}
6027
6028	trace_seq_terminate(s);
6029}
6030
 
 
 
 
 
 
 
 
 
 
 
 
 
6031/**
6032 * tep_find_event_by_record - return the event from a given record
6033 * @tep: a handle to the trace event parser context
6034 * @record: The record to get the event from
6035 *
6036 * Returns the associated event for a given record, or NULL if non is
6037 * is found.
6038 */
6039struct tep_event *
6040tep_find_event_by_record(struct tep_handle *tep, struct tep_record *record)
6041{
6042	int type;
6043
6044	if (record->size < 0) {
6045		do_warning("ug! negative record size %d", record->size);
6046		return NULL;
6047	}
6048
6049	type = trace_parse_common_type(tep, record->data);
6050
6051	return tep_find_event(tep, type);
6052}
6053
6054/*
6055 * Writes the timestamp of the record into @s. Time divisor and precision can be
6056 * specified as part of printf @format string. Example:
6057 *	"%3.1000d" - divide the time by 1000 and print the first 3 digits
6058 *	before the dot. Thus, the timestamp "123456000" will be printed as
6059 *	"123.456"
6060 */
6061static void print_event_time(struct tep_handle *tep, struct trace_seq *s,
6062				 char *format, struct tep_event *event,
6063				 struct tep_record *record)
6064{
6065	unsigned long long time;
6066	char *divstr;
6067	int prec = 0, pr;
6068	int div = 0;
6069	int p10 = 1;
6070
6071	if (isdigit(*(format + 1)))
6072		prec = atoi(format + 1);
6073	divstr = strchr(format, '.');
6074	if (divstr && isdigit(*(divstr + 1)))
6075		div = atoi(divstr + 1);
6076	time = record->ts;
6077	if (div) {
6078		time += div / 2;
6079		time /= div;
6080	}
6081	pr = prec;
6082	while (pr--)
6083		p10 *= 10;
6084
6085	if (p10 > 1 && p10 < time)
6086		trace_seq_printf(s, "%5llu.%0*llu", time / p10, prec, time % p10);
6087	else
6088		trace_seq_printf(s, "%12llu", time);
6089}
6090
6091struct print_event_type {
6092	enum {
6093		EVENT_TYPE_INT = 1,
6094		EVENT_TYPE_STRING,
6095		EVENT_TYPE_UNKNOWN,
6096	} type;
6097	char format[32];
6098};
6099
6100static void print_string(struct tep_handle *tep, struct trace_seq *s,
6101			 struct tep_record *record, struct tep_event *event,
6102			 const char *arg, struct print_event_type *type)
6103{
 
6104	const char *comm;
6105	int pid;
6106
6107	if (strncmp(arg, TEP_PRINT_LATENCY, strlen(TEP_PRINT_LATENCY)) == 0) {
6108		data_latency_format(tep, s, type->format, record);
6109	} else if (strncmp(arg, TEP_PRINT_COMM, strlen(TEP_PRINT_COMM)) == 0) {
6110		pid = parse_common_pid(tep, record->data);
6111		comm = find_cmdline(tep, pid);
6112		trace_seq_printf(s, type->format, comm);
6113	} else if (strncmp(arg, TEP_PRINT_INFO_RAW, strlen(TEP_PRINT_INFO_RAW)) == 0) {
6114		print_event_info(s, type->format, true, event, record);
6115	} else if (strncmp(arg, TEP_PRINT_INFO, strlen(TEP_PRINT_INFO)) == 0) {
6116		print_event_info(s, type->format, false, event, record);
6117	} else if  (strncmp(arg, TEP_PRINT_NAME, strlen(TEP_PRINT_NAME)) == 0) {
6118		trace_seq_printf(s, type->format, event->name);
6119	} else {
6120		trace_seq_printf(s, "[UNKNOWN TEP TYPE %s]", arg);
6121	}
6122
 
 
 
 
 
6123}
6124
6125static void print_int(struct tep_handle *tep, struct trace_seq *s,
6126		      struct tep_record *record, struct tep_event *event,
6127		      int arg, struct print_event_type *type)
 
 
 
 
 
 
 
 
 
 
 
6128{
6129	int param;
 
 
 
 
6130
6131	switch (arg) {
6132	case TEP_PRINT_CPU:
6133		param = record->cpu;
6134		break;
6135	case TEP_PRINT_PID:
6136		param = parse_common_pid(tep, record->data);
6137		break;
6138	case TEP_PRINT_TIME:
6139		return print_event_time(tep, s, type->format, event, record);
6140	default:
6141		return;
6142	}
6143	trace_seq_printf(s, type->format, param);
6144}
6145
6146static int tep_print_event_param_type(char *format,
6147				      struct print_event_type *type)
6148{
6149	char *str = format + 1;
6150	int i = 1;
6151
6152	type->type = EVENT_TYPE_UNKNOWN;
6153	while (*str) {
6154		switch (*str) {
6155		case 'd':
6156		case 'u':
6157		case 'i':
6158		case 'x':
6159		case 'X':
6160		case 'o':
6161			type->type = EVENT_TYPE_INT;
6162			break;
6163		case 's':
6164			type->type = EVENT_TYPE_STRING;
6165			break;
6166		}
6167		str++;
6168		i++;
6169		if (type->type != EVENT_TYPE_UNKNOWN)
6170			break;
6171	}
6172	memset(type->format, 0, 32);
6173	memcpy(type->format, format, i < 32 ? i : 31);
6174	return i;
6175}
6176
6177/**
6178 * tep_print_event - Write various event information
6179 * @tep: a handle to the trace event parser context
6180 * @s: the trace_seq to write to
 
6181 * @record: The record to get the event from
6182 * @format: a printf format string. Supported event fileds:
6183 *	TEP_PRINT_PID, "%d" - event PID
6184 *	TEP_PRINT_CPU, "%d" - event CPU
6185 *	TEP_PRINT_COMM, "%s" - event command string
6186 *	TEP_PRINT_NAME, "%s" - event name
6187 *	TEP_PRINT_LATENCY, "%s" - event latency
6188 *	TEP_PRINT_TIME, %d - event time stamp. A divisor and precision
6189 *			can be specified as part of this format string:
6190 *			"%precision.divisord". Example:
6191 *			"%3.1000d" - divide the time by 1000 and print the first
6192 *			3 digits before the dot. Thus, the time stamp
6193 *			"123456000" will be printed as "123.456"
6194 *	TEP_PRINT_INFO, "%s" - event information. If any width is specified in
6195 *			the format string, the event information will be printed
6196 *			in raw format.
6197 * Writes the specified event information into @s.
6198 */
6199void tep_print_event(struct tep_handle *tep, struct trace_seq *s,
6200		     struct tep_record *record, const char *fmt, ...)
6201{
6202	struct print_event_type type;
6203	char *format = strdup(fmt);
6204	char *current = format;
6205	char *str = format;
6206	int offset;
6207	va_list args;
6208	struct tep_event *event;
6209
6210	if (!format)
6211		return;
6212
6213	event = tep_find_event_by_record(tep, record);
6214	va_start(args, fmt);
6215	while (*current) {
6216		current = strchr(str, '%');
6217		if (!current) {
6218			trace_seq_puts(s, str);
6219			break;
6220		}
6221		memset(&type, 0, sizeof(type));
6222		offset = tep_print_event_param_type(current, &type);
6223		*current = '\0';
6224		trace_seq_puts(s, str);
6225		current += offset;
6226		switch (type.type) {
6227		case EVENT_TYPE_STRING:
6228			print_string(tep, s, record, event,
6229				     va_arg(args, char*), &type);
6230			break;
6231		case EVENT_TYPE_INT:
6232			print_int(tep, s, record, event,
6233				  va_arg(args, int), &type);
6234			break;
6235		case EVENT_TYPE_UNKNOWN:
6236		default:
6237			trace_seq_printf(s, "[UNKNOWN TYPE]");
6238			break;
6239		}
6240		str = current;
6241
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6242	}
6243	va_end(args);
6244	free(format);
 
 
6245}
6246
6247static int events_id_cmp(const void *a, const void *b)
6248{
6249	struct tep_event * const * ea = a;
6250	struct tep_event * const * eb = b;
6251
6252	if ((*ea)->id < (*eb)->id)
6253		return -1;
6254
6255	if ((*ea)->id > (*eb)->id)
6256		return 1;
6257
6258	return 0;
6259}
6260
6261static int events_name_cmp(const void *a, const void *b)
6262{
6263	struct tep_event * const * ea = a;
6264	struct tep_event * const * eb = b;
6265	int res;
6266
6267	res = strcmp((*ea)->name, (*eb)->name);
6268	if (res)
6269		return res;
6270
6271	res = strcmp((*ea)->system, (*eb)->system);
6272	if (res)
6273		return res;
6274
6275	return events_id_cmp(a, b);
6276}
6277
6278static int events_system_cmp(const void *a, const void *b)
6279{
6280	struct tep_event * const * ea = a;
6281	struct tep_event * const * eb = b;
6282	int res;
6283
6284	res = strcmp((*ea)->system, (*eb)->system);
6285	if (res)
6286		return res;
6287
6288	res = strcmp((*ea)->name, (*eb)->name);
6289	if (res)
6290		return res;
6291
6292	return events_id_cmp(a, b);
6293}
6294
6295static struct tep_event **list_events_copy(struct tep_handle *tep)
6296{
6297	struct tep_event **events;
6298
6299	if (!tep)
6300		return NULL;
6301
6302	events = malloc(sizeof(*events) * (tep->nr_events + 1));
6303	if (!events)
6304		return NULL;
6305
6306	memcpy(events, tep->events, sizeof(*events) * tep->nr_events);
6307	events[tep->nr_events] = NULL;
6308	return events;
6309}
6310
6311static void list_events_sort(struct tep_event **events, int nr_events,
6312			     enum tep_event_sort_type sort_type)
6313{
 
6314	int (*sort)(const void *a, const void *b);
6315
6316	switch (sort_type) {
6317	case TEP_EVENT_SORT_ID:
6318		sort = events_id_cmp;
6319		break;
6320	case TEP_EVENT_SORT_NAME:
6321		sort = events_name_cmp;
6322		break;
6323	case TEP_EVENT_SORT_SYSTEM:
6324		sort = events_system_cmp;
6325		break;
6326	default:
6327		sort = NULL;
6328	}
6329
6330	if (sort)
6331		qsort(events, nr_events, sizeof(*events), sort);
6332}
6333
6334/**
6335 * tep_list_events - Get events, sorted by given criteria.
6336 * @tep: a handle to the tep context
6337 * @sort_type: desired sort order of the events in the array
6338 *
6339 * Returns an array of pointers to all events, sorted by the given
6340 * @sort_type criteria. The last element of the array is NULL. The returned
6341 * memory must not be freed, it is managed by the library.
6342 * The function is not thread safe.
6343 */
6344struct tep_event **tep_list_events(struct tep_handle *tep,
6345				   enum tep_event_sort_type sort_type)
6346{
6347	struct tep_event **events;
6348
6349	if (!tep)
6350		return NULL;
6351
6352	events = tep->sort_events;
6353	if (events && tep->last_type == sort_type)
6354		return events;
6355
6356	if (!events) {
6357		events = list_events_copy(tep);
6358		if (!events)
6359			return NULL;
6360
6361		tep->sort_events = events;
 
 
 
6362
6363		/* the internal events are sorted by id */
6364		if (sort_type == TEP_EVENT_SORT_ID) {
6365			tep->last_type = sort_type;
6366			return events;
6367		}
6368	}
6369
6370	list_events_sort(events, tep->nr_events, sort_type);
6371	tep->last_type = sort_type;
6372
6373	return events;
6374}
6375
6376
6377/**
6378 * tep_list_events_copy - Thread safe version of tep_list_events()
6379 * @tep: a handle to the tep context
6380 * @sort_type: desired sort order of the events in the array
6381 *
6382 * Returns an array of pointers to all events, sorted by the given
6383 * @sort_type criteria. The last element of the array is NULL. The returned
6384 * array is newly allocated inside the function and must be freed by the caller
6385 */
6386struct tep_event **tep_list_events_copy(struct tep_handle *tep,
6387					enum tep_event_sort_type sort_type)
6388{
6389	struct tep_event **events;
6390
6391	if (!tep)
6392		return NULL;
6393
6394	events = list_events_copy(tep);
6395	if (!events)
6396		return NULL;
6397
6398	/* the internal events are sorted by id */
6399	if (sort_type == TEP_EVENT_SORT_ID)
6400		return events;
 
6401
6402	list_events_sort(events, tep->nr_events, sort_type);
 
6403
6404	return events;
6405}
6406
6407static struct tep_format_field **
6408get_event_fields(const char *type, const char *name,
6409		 int count, struct tep_format_field *list)
6410{
6411	struct tep_format_field **fields;
6412	struct tep_format_field *field;
6413	int i = 0;
6414
6415	fields = malloc(sizeof(*fields) * (count + 1));
6416	if (!fields)
6417		return NULL;
6418
6419	for (field = list; field; field = field->next) {
6420		fields[i++] = field;
6421		if (i == count + 1) {
6422			do_warning("event %s has more %s fields than specified",
6423				name, type);
6424			i--;
6425			break;
6426		}
6427	}
6428
6429	if (i != count)
6430		do_warning("event %s has less %s fields than specified",
6431			name, type);
6432
6433	fields[i] = NULL;
6434
6435	return fields;
6436}
6437
6438/**
6439 * tep_event_common_fields - return a list of common fields for an event
6440 * @event: the event to return the common fields of.
6441 *
6442 * Returns an allocated array of fields. The last item in the array is NULL.
6443 * The array must be freed with free().
6444 */
6445struct tep_format_field **tep_event_common_fields(struct tep_event *event)
6446{
6447	return get_event_fields("common", event->name,
6448				event->format.nr_common,
6449				event->format.common_fields);
6450}
6451
6452/**
6453 * tep_event_fields - return a list of event specific fields for an event
6454 * @event: the event to return the fields of.
6455 *
6456 * Returns an allocated array of fields. The last item in the array is NULL.
6457 * The array must be freed with free().
6458 */
6459struct tep_format_field **tep_event_fields(struct tep_event *event)
6460{
6461	return get_event_fields("event", event->name,
6462				event->format.nr_fields,
6463				event->format.fields);
6464}
6465
6466static void print_fields(struct trace_seq *s, struct tep_print_flag_sym *field)
6467{
6468	trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
6469	if (field->next) {
6470		trace_seq_puts(s, ", ");
6471		print_fields(s, field->next);
6472	}
6473}
6474
6475/* for debugging */
6476static void print_args(struct tep_print_arg *args)
6477{
6478	int print_paren = 1;
6479	struct trace_seq s;
6480
6481	switch (args->type) {
6482	case TEP_PRINT_NULL:
6483		printf("null");
6484		break;
6485	case TEP_PRINT_ATOM:
6486		printf("%s", args->atom.atom);
6487		break;
6488	case TEP_PRINT_FIELD:
6489		printf("REC->%s", args->field.name);
6490		break;
6491	case TEP_PRINT_FLAGS:
6492		printf("__print_flags(");
6493		print_args(args->flags.field);
6494		printf(", %s, ", args->flags.delim);
6495		trace_seq_init(&s);
6496		print_fields(&s, args->flags.flags);
6497		trace_seq_do_printf(&s);
6498		trace_seq_destroy(&s);
6499		printf(")");
6500		break;
6501	case TEP_PRINT_SYMBOL:
6502		printf("__print_symbolic(");
6503		print_args(args->symbol.field);
6504		printf(", ");
6505		trace_seq_init(&s);
6506		print_fields(&s, args->symbol.symbols);
6507		trace_seq_do_printf(&s);
6508		trace_seq_destroy(&s);
6509		printf(")");
6510		break;
6511	case TEP_PRINT_HEX:
6512		printf("__print_hex(");
6513		print_args(args->hex.field);
6514		printf(", ");
6515		print_args(args->hex.size);
6516		printf(")");
6517		break;
6518	case TEP_PRINT_HEX_STR:
6519		printf("__print_hex_str(");
6520		print_args(args->hex.field);
6521		printf(", ");
6522		print_args(args->hex.size);
6523		printf(")");
6524		break;
6525	case TEP_PRINT_INT_ARRAY:
6526		printf("__print_array(");
6527		print_args(args->int_array.field);
6528		printf(", ");
6529		print_args(args->int_array.count);
6530		printf(", ");
6531		print_args(args->int_array.el_size);
6532		printf(")");
6533		break;
6534	case TEP_PRINT_STRING:
6535	case TEP_PRINT_BSTRING:
6536		printf("__get_str(%s)", args->string.string);
6537		break;
6538	case TEP_PRINT_BITMASK:
6539		printf("__get_bitmask(%s)", args->bitmask.bitmask);
6540		break;
6541	case TEP_PRINT_TYPE:
6542		printf("(%s)", args->typecast.type);
6543		print_args(args->typecast.item);
6544		break;
6545	case TEP_PRINT_OP:
6546		if (strcmp(args->op.op, ":") == 0)
6547			print_paren = 0;
6548		if (print_paren)
6549			printf("(");
6550		print_args(args->op.left);
6551		printf(" %s ", args->op.op);
6552		print_args(args->op.right);
6553		if (print_paren)
6554			printf(")");
6555		break;
6556	default:
6557		/* we should warn... */
6558		return;
6559	}
6560	if (args->next) {
6561		printf("\n");
6562		print_args(args->next);
6563	}
6564}
6565
6566static void parse_header_field(const char *field,
6567			       int *offset, int *size, int mandatory)
6568{
6569	unsigned long long save_input_buf_ptr;
6570	unsigned long long save_input_buf_siz;
6571	char *token;
6572	int type;
6573
6574	save_input_buf_ptr = input_buf_ptr;
6575	save_input_buf_siz = input_buf_siz;
6576
6577	if (read_expected(TEP_EVENT_ITEM, "field") < 0)
6578		return;
6579	if (read_expected(TEP_EVENT_OP, ":") < 0)
6580		return;
6581
6582	/* type */
6583	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6584		goto fail;
6585	free_token(token);
6586
6587	/*
6588	 * If this is not a mandatory field, then test it first.
6589	 */
6590	if (mandatory) {
6591		if (read_expected(TEP_EVENT_ITEM, field) < 0)
6592			return;
6593	} else {
6594		if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6595			goto fail;
6596		if (strcmp(token, field) != 0)
6597			goto discard;
6598		free_token(token);
6599	}
6600
6601	if (read_expected(TEP_EVENT_OP, ";") < 0)
6602		return;
6603	if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
6604		return;
6605	if (read_expected(TEP_EVENT_OP, ":") < 0)
6606		return;
6607	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6608		goto fail;
6609	*offset = atoi(token);
6610	free_token(token);
6611	if (read_expected(TEP_EVENT_OP, ";") < 0)
6612		return;
6613	if (read_expected(TEP_EVENT_ITEM, "size") < 0)
6614		return;
6615	if (read_expected(TEP_EVENT_OP, ":") < 0)
6616		return;
6617	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6618		goto fail;
6619	*size = atoi(token);
6620	free_token(token);
6621	if (read_expected(TEP_EVENT_OP, ";") < 0)
6622		return;
6623	type = read_token(&token);
6624	if (type != TEP_EVENT_NEWLINE) {
6625		/* newer versions of the kernel have a "signed" type */
6626		if (type != TEP_EVENT_ITEM)
6627			goto fail;
6628
6629		if (strcmp(token, "signed") != 0)
6630			goto fail;
6631
6632		free_token(token);
6633
6634		if (read_expected(TEP_EVENT_OP, ":") < 0)
6635			return;
6636
6637		if (read_expect_type(TEP_EVENT_ITEM, &token))
6638			goto fail;
6639
6640		free_token(token);
6641		if (read_expected(TEP_EVENT_OP, ";") < 0)
6642			return;
6643
6644		if (read_expect_type(TEP_EVENT_NEWLINE, &token))
6645			goto fail;
6646	}
6647 fail:
6648	free_token(token);
6649	return;
6650
6651 discard:
6652	input_buf_ptr = save_input_buf_ptr;
6653	input_buf_siz = save_input_buf_siz;
6654	*offset = 0;
6655	*size = 0;
6656	free_token(token);
6657}
6658
6659/**
6660 * tep_parse_header_page - parse the data stored in the header page
6661 * @tep: a handle to the trace event parser context
6662 * @buf: the buffer storing the header page format string
6663 * @size: the size of @buf
6664 * @long_size: the long size to use if there is no header
6665 *
6666 * This parses the header page format for information on the
6667 * ring buffer used. The @buf should be copied from
6668 *
6669 * /sys/kernel/debug/tracing/events/header_page
6670 */
6671int tep_parse_header_page(struct tep_handle *tep, char *buf, unsigned long size,
6672			  int long_size)
6673{
6674	int ignore;
6675
6676	if (!size) {
6677		/*
6678		 * Old kernels did not have header page info.
6679		 * Sorry but we just use what we find here in user space.
6680		 */
6681		tep->header_page_ts_size = sizeof(long long);
6682		tep->header_page_size_size = long_size;
6683		tep->header_page_data_offset = sizeof(long long) + long_size;
6684		tep->old_format = 1;
6685		return -1;
6686	}
6687	init_input_buf(buf, size);
6688
6689	parse_header_field("timestamp", &tep->header_page_ts_offset,
6690			   &tep->header_page_ts_size, 1);
6691	parse_header_field("commit", &tep->header_page_size_offset,
6692			   &tep->header_page_size_size, 1);
6693	parse_header_field("overwrite", &tep->header_page_overwrite,
6694			   &ignore, 0);
6695	parse_header_field("data", &tep->header_page_data_offset,
6696			   &tep->header_page_data_size, 1);
6697
6698	return 0;
6699}
6700
6701static int event_matches(struct tep_event *event,
6702			 int id, const char *sys_name,
6703			 const char *event_name)
6704{
6705	if (id >= 0 && id != event->id)
6706		return 0;
6707
6708	if (event_name && (strcmp(event_name, event->name) != 0))
6709		return 0;
6710
6711	if (sys_name && (strcmp(sys_name, event->system) != 0))
6712		return 0;
6713
6714	return 1;
6715}
6716
6717static void free_handler(struct event_handler *handle)
6718{
6719	free((void *)handle->sys_name);
6720	free((void *)handle->event_name);
6721	free(handle);
6722}
6723
6724static int find_event_handle(struct tep_handle *tep, struct tep_event *event)
6725{
6726	struct event_handler *handle, **next;
6727
6728	for (next = &tep->handlers; *next;
6729	     next = &(*next)->next) {
6730		handle = *next;
6731		if (event_matches(event, handle->id,
6732				  handle->sys_name,
6733				  handle->event_name))
6734			break;
6735	}
6736
6737	if (!(*next))
6738		return 0;
6739
6740	pr_stat("overriding event (%d) %s:%s with new print handler",
6741		event->id, event->system, event->name);
6742
6743	event->handler = handle->func;
6744	event->context = handle->context;
6745
6746	*next = handle->next;
6747	free_handler(handle);
6748
6749	return 1;
6750}
6751
6752/**
6753 * __tep_parse_format - parse the event format
6754 * @buf: the buffer storing the event format string
6755 * @size: the size of @buf
6756 * @sys: the system the event belongs to
6757 *
6758 * This parses the event format and creates an event structure
6759 * to quickly parse raw data for a given event.
6760 *
6761 * These files currently come from:
6762 *
6763 * /sys/kernel/debug/tracing/events/.../.../format
6764 */
6765enum tep_errno __tep_parse_format(struct tep_event **eventp,
6766				  struct tep_handle *tep, const char *buf,
6767				  unsigned long size, const char *sys)
6768{
6769	struct tep_event *event;
6770	int ret;
6771
6772	init_input_buf(buf, size);
6773
6774	*eventp = event = alloc_event();
6775	if (!event)
6776		return TEP_ERRNO__MEM_ALLOC_FAILED;
6777
6778	event->name = event_read_name();
6779	if (!event->name) {
6780		/* Bad event? */
6781		ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6782		goto event_alloc_failed;
6783	}
6784
6785	if (strcmp(sys, "ftrace") == 0) {
6786		event->flags |= TEP_EVENT_FL_ISFTRACE;
6787
6788		if (strcmp(event->name, "bprint") == 0)
6789			event->flags |= TEP_EVENT_FL_ISBPRINT;
6790	}
6791		
6792	event->id = event_read_id();
6793	if (event->id < 0) {
6794		ret = TEP_ERRNO__READ_ID_FAILED;
6795		/*
6796		 * This isn't an allocation error actually.
6797		 * But as the ID is critical, just bail out.
6798		 */
6799		goto event_alloc_failed;
6800	}
6801
6802	event->system = strdup(sys);
6803	if (!event->system) {
6804		ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6805		goto event_alloc_failed;
6806	}
6807
6808	/* Add tep to event so that it can be referenced */
6809	event->tep = tep;
6810
6811	ret = event_read_format(event);
6812	if (ret < 0) {
6813		ret = TEP_ERRNO__READ_FORMAT_FAILED;
6814		goto event_parse_failed;
6815	}
6816
6817	/*
6818	 * If the event has an override, don't print warnings if the event
6819	 * print format fails to parse.
6820	 */
6821	if (tep && find_event_handle(tep, event))
6822		show_warning = 0;
6823
6824	ret = event_read_print(event);
6825	show_warning = 1;
6826
6827	if (ret < 0) {
6828		ret = TEP_ERRNO__READ_PRINT_FAILED;
6829		goto event_parse_failed;
6830	}
6831
6832	if (!ret && (event->flags & TEP_EVENT_FL_ISFTRACE)) {
6833		struct tep_format_field *field;
6834		struct tep_print_arg *arg, **list;
6835
6836		/* old ftrace had no args */
6837		list = &event->print_fmt.args;
6838		for (field = event->format.fields; field; field = field->next) {
6839			arg = alloc_arg();
6840			if (!arg) {
6841				event->flags |= TEP_EVENT_FL_FAILED;
6842				return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6843			}
6844			arg->type = TEP_PRINT_FIELD;
6845			arg->field.name = strdup(field->name);
6846			if (!arg->field.name) {
6847				event->flags |= TEP_EVENT_FL_FAILED;
6848				free_arg(arg);
6849				return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6850			}
6851			arg->field.field = field;
6852			*list = arg;
6853			list = &arg->next;
6854		}
 
6855	}
6856
6857	if (!(event->flags & TEP_EVENT_FL_ISBPRINT))
6858		event->print_fmt.print_cache = parse_args(event,
6859							  event->print_fmt.format,
6860							  event->print_fmt.args);
6861
6862	return 0;
6863
6864 event_parse_failed:
6865	event->flags |= TEP_EVENT_FL_FAILED;
6866	return ret;
6867
6868 event_alloc_failed:
6869	free(event->system);
6870	free(event->name);
6871	free(event);
6872	*eventp = NULL;
6873	return ret;
6874}
6875
6876static enum tep_errno
6877__parse_event(struct tep_handle *tep,
6878	      struct tep_event **eventp,
6879	      const char *buf, unsigned long size,
6880	      const char *sys)
6881{
6882	int ret = __tep_parse_format(eventp, tep, buf, size, sys);
6883	struct tep_event *event = *eventp;
6884
6885	if (event == NULL)
6886		return ret;
6887
6888	if (tep && add_event(tep, event)) {
6889		ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6890		goto event_add_failed;
6891	}
6892
6893#define PRINT_ARGS 0
6894	if (PRINT_ARGS && event->print_fmt.args)
6895		print_args(event->print_fmt.args);
6896
6897	return 0;
6898
6899event_add_failed:
6900	tep_free_event(event);
6901	return ret;
6902}
6903
6904/**
6905 * tep_parse_format - parse the event format
6906 * @tep: a handle to the trace event parser context
6907 * @eventp: returned format
6908 * @buf: the buffer storing the event format string
6909 * @size: the size of @buf
6910 * @sys: the system the event belongs to
6911 *
6912 * This parses the event format and creates an event structure
6913 * to quickly parse raw data for a given event.
6914 *
6915 * These files currently come from:
6916 *
6917 * /sys/kernel/debug/tracing/events/.../.../format
6918 */
6919enum tep_errno tep_parse_format(struct tep_handle *tep,
6920				struct tep_event **eventp,
6921				const char *buf,
6922				unsigned long size, const char *sys)
6923{
6924	return __parse_event(tep, eventp, buf, size, sys);
6925}
6926
6927/**
6928 * tep_parse_event - parse the event format
6929 * @tep: a handle to the trace event parser context
6930 * @buf: the buffer storing the event format string
6931 * @size: the size of @buf
6932 * @sys: the system the event belongs to
6933 *
6934 * This parses the event format and creates an event structure
6935 * to quickly parse raw data for a given event.
6936 *
6937 * These files currently come from:
6938 *
6939 * /sys/kernel/debug/tracing/events/.../.../format
6940 */
6941enum tep_errno tep_parse_event(struct tep_handle *tep, const char *buf,
6942			       unsigned long size, const char *sys)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6943{
6944	struct tep_event *event = NULL;
6945	return __parse_event(tep, &event, buf, size, sys);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6946}
6947
6948int get_field_val(struct trace_seq *s, struct tep_format_field *field,
6949		  const char *name, struct tep_record *record,
6950		  unsigned long long *val, int err)
6951{
6952	if (!field) {
6953		if (err)
6954			trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6955		return -1;
6956	}
6957
6958	if (tep_read_number_field(field, record->data, val)) {
6959		if (err)
6960			trace_seq_printf(s, " %s=INVALID", name);
6961		return -1;
6962	}
6963
6964	return 0;
6965}
6966
6967/**
6968 * tep_get_field_raw - return the raw pointer into the data field
6969 * @s: The seq to print to on error
6970 * @event: the event that the field is for
6971 * @name: The name of the field
6972 * @record: The record with the field name.
6973 * @len: place to store the field length.
6974 * @err: print default error if failed.
6975 *
6976 * Returns a pointer into record->data of the field and places
6977 * the length of the field in @len.
6978 *
6979 * On failure, it returns NULL.
6980 */
6981void *tep_get_field_raw(struct trace_seq *s, struct tep_event *event,
6982			const char *name, struct tep_record *record,
6983			int *len, int err)
6984{
6985	struct tep_format_field *field;
6986	void *data = record->data;
6987	unsigned offset;
6988	int dummy;
6989
6990	if (!event)
6991		return NULL;
6992
6993	field = tep_find_field(event, name);
6994
6995	if (!field) {
6996		if (err)
6997			trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6998		return NULL;
6999	}
7000
7001	/* Allow @len to be NULL */
7002	if (!len)
7003		len = &dummy;
7004
7005	offset = field->offset;
7006	if (field->flags & TEP_FIELD_IS_DYNAMIC) {
7007		offset = tep_read_number(event->tep,
7008					 data + offset, field->size);
7009		*len = offset >> 16;
7010		offset &= 0xffff;
7011	} else
7012		*len = field->size;
7013
7014	return data + offset;
7015}
7016
7017/**
7018 * tep_get_field_val - find a field and return its value
7019 * @s: The seq to print to on error
7020 * @event: the event that the field is for
7021 * @name: The name of the field
7022 * @record: The record with the field name.
7023 * @val: place to store the value of the field.
7024 * @err: print default error if failed.
7025 *
7026 * Returns 0 on success -1 on field not found.
7027 */
7028int tep_get_field_val(struct trace_seq *s, struct tep_event *event,
7029		      const char *name, struct tep_record *record,
7030		      unsigned long long *val, int err)
7031{
7032	struct tep_format_field *field;
7033
7034	if (!event)
7035		return -1;
7036
7037	field = tep_find_field(event, name);
7038
7039	return get_field_val(s, field, name, record, val, err);
7040}
7041
7042/**
7043 * tep_get_common_field_val - find a common field and return its value
7044 * @s: The seq to print to on error
7045 * @event: the event that the field is for
7046 * @name: The name of the field
7047 * @record: The record with the field name.
7048 * @val: place to store the value of the field.
7049 * @err: print default error if failed.
7050 *
7051 * Returns 0 on success -1 on field not found.
7052 */
7053int tep_get_common_field_val(struct trace_seq *s, struct tep_event *event,
7054			     const char *name, struct tep_record *record,
7055			     unsigned long long *val, int err)
7056{
7057	struct tep_format_field *field;
7058
7059	if (!event)
7060		return -1;
7061
7062	field = tep_find_common_field(event, name);
7063
7064	return get_field_val(s, field, name, record, val, err);
7065}
7066
7067/**
7068 * tep_get_any_field_val - find a any field and return its value
7069 * @s: The seq to print to on error
7070 * @event: the event that the field is for
7071 * @name: The name of the field
7072 * @record: The record with the field name.
7073 * @val: place to store the value of the field.
7074 * @err: print default error if failed.
7075 *
7076 * Returns 0 on success -1 on field not found.
7077 */
7078int tep_get_any_field_val(struct trace_seq *s, struct tep_event *event,
7079			  const char *name, struct tep_record *record,
7080			  unsigned long long *val, int err)
7081{
7082	struct tep_format_field *field;
7083
7084	if (!event)
7085		return -1;
7086
7087	field = tep_find_any_field(event, name);
7088
7089	return get_field_val(s, field, name, record, val, err);
7090}
7091
7092/**
7093 * tep_print_num_field - print a field and a format
7094 * @s: The seq to print to
7095 * @fmt: The printf format to print the field with.
7096 * @event: the event that the field is for
7097 * @name: The name of the field
7098 * @record: The record with the field name.
7099 * @err: print default error if failed.
7100 *
7101 * Returns positive value on success, negative in case of an error,
7102 * or 0 if buffer is full.
7103 */
7104int tep_print_num_field(struct trace_seq *s, const char *fmt,
7105			struct tep_event *event, const char *name,
7106			struct tep_record *record, int err)
7107{
7108	struct tep_format_field *field = tep_find_field(event, name);
7109	unsigned long long val;
7110
7111	if (!field)
7112		goto failed;
7113
7114	if (tep_read_number_field(field, record->data, &val))
7115		goto failed;
7116
7117	return trace_seq_printf(s, fmt, val);
7118
7119 failed:
7120	if (err)
7121		trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
7122	return -1;
7123}
7124
7125/**
7126 * tep_print_func_field - print a field and a format for function pointers
7127 * @s: The seq to print to
7128 * @fmt: The printf format to print the field with.
7129 * @event: the event that the field is for
7130 * @name: The name of the field
7131 * @record: The record with the field name.
7132 * @err: print default error if failed.
7133 *
7134 * Returns positive value on success, negative in case of an error,
7135 * or 0 if buffer is full.
7136 */
7137int tep_print_func_field(struct trace_seq *s, const char *fmt,
7138			 struct tep_event *event, const char *name,
7139			 struct tep_record *record, int err)
7140{
7141	struct tep_format_field *field = tep_find_field(event, name);
7142	struct tep_handle *tep = event->tep;
7143	unsigned long long val;
7144	struct func_map *func;
7145	char tmp[128];
7146
7147	if (!field)
7148		goto failed;
7149
7150	if (tep_read_number_field(field, record->data, &val))
7151		goto failed;
7152
7153	func = find_func(tep, val);
7154
7155	if (func)
7156		snprintf(tmp, 128, "%s/0x%llx", func->func, func->addr - val);
7157	else
7158		sprintf(tmp, "0x%08llx", val);
7159
7160	return trace_seq_printf(s, fmt, tmp);
7161
7162 failed:
7163	if (err)
7164		trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
7165	return -1;
7166}
7167
7168static void free_func_handle(struct tep_function_handler *func)
7169{
7170	struct func_params *params;
7171
7172	free(func->name);
7173
7174	while (func->params) {
7175		params = func->params;
7176		func->params = params->next;
7177		free(params);
7178	}
7179
7180	free(func);
7181}
7182
7183/**
7184 * tep_register_print_function - register a helper function
7185 * @tep: a handle to the trace event parser context
7186 * @func: the function to process the helper function
7187 * @ret_type: the return type of the helper function
7188 * @name: the name of the helper function
7189 * @parameters: A list of enum tep_func_arg_type
7190 *
7191 * Some events may have helper functions in the print format arguments.
7192 * This allows a plugin to dynamically create a way to process one
7193 * of these functions.
7194 *
7195 * The @parameters is a variable list of tep_func_arg_type enums that
7196 * must end with TEP_FUNC_ARG_VOID.
7197 */
7198int tep_register_print_function(struct tep_handle *tep,
7199				tep_func_handler func,
7200				enum tep_func_arg_type ret_type,
7201				char *name, ...)
7202{
7203	struct tep_function_handler *func_handle;
7204	struct func_params **next_param;
7205	struct func_params *param;
7206	enum tep_func_arg_type type;
7207	va_list ap;
7208	int ret;
7209
7210	func_handle = find_func_handler(tep, name);
7211	if (func_handle) {
7212		/*
7213		 * This is most like caused by the users own
7214		 * plugins updating the function. This overrides the
7215		 * system defaults.
7216		 */
7217		pr_stat("override of function helper '%s'", name);
7218		remove_func_handler(tep, name);
7219	}
7220
7221	func_handle = calloc(1, sizeof(*func_handle));
7222	if (!func_handle) {
7223		do_warning("Failed to allocate function handler");
7224		return TEP_ERRNO__MEM_ALLOC_FAILED;
7225	}
7226
7227	func_handle->ret_type = ret_type;
7228	func_handle->name = strdup(name);
7229	func_handle->func = func;
7230	if (!func_handle->name) {
7231		do_warning("Failed to allocate function name");
7232		free(func_handle);
7233		return TEP_ERRNO__MEM_ALLOC_FAILED;
7234	}
7235
7236	next_param = &(func_handle->params);
7237	va_start(ap, name);
7238	for (;;) {
7239		type = va_arg(ap, enum tep_func_arg_type);
7240		if (type == TEP_FUNC_ARG_VOID)
7241			break;
7242
7243		if (type >= TEP_FUNC_ARG_MAX_TYPES) {
7244			do_warning("Invalid argument type %d", type);
7245			ret = TEP_ERRNO__INVALID_ARG_TYPE;
7246			goto out_free;
7247		}
7248
7249		param = malloc(sizeof(*param));
7250		if (!param) {
7251			do_warning("Failed to allocate function param");
7252			ret = TEP_ERRNO__MEM_ALLOC_FAILED;
7253			goto out_free;
7254		}
7255		param->type = type;
7256		param->next = NULL;
7257
7258		*next_param = param;
7259		next_param = &(param->next);
7260
7261		func_handle->nr_args++;
7262	}
7263	va_end(ap);
7264
7265	func_handle->next = tep->func_handlers;
7266	tep->func_handlers = func_handle;
7267
7268	return 0;
7269 out_free:
7270	va_end(ap);
7271	free_func_handle(func_handle);
7272	return ret;
7273}
7274
7275/**
7276 * tep_unregister_print_function - unregister a helper function
7277 * @tep: a handle to the trace event parser context
7278 * @func: the function to process the helper function
7279 * @name: the name of the helper function
7280 *
7281 * This function removes existing print handler for function @name.
7282 *
7283 * Returns 0 if the handler was removed successully, -1 otherwise.
7284 */
7285int tep_unregister_print_function(struct tep_handle *tep,
7286				  tep_func_handler func, char *name)
7287{
7288	struct tep_function_handler *func_handle;
7289
7290	func_handle = find_func_handler(tep, name);
7291	if (func_handle && func_handle->func == func) {
7292		remove_func_handler(tep, name);
7293		return 0;
7294	}
7295	return -1;
7296}
7297
7298static struct tep_event *search_event(struct tep_handle *tep, int id,
7299				      const char *sys_name,
7300				      const char *event_name)
7301{
7302	struct tep_event *event;
7303
7304	if (id >= 0) {
7305		/* search by id */
7306		event = tep_find_event(tep, id);
7307		if (!event)
7308			return NULL;
7309		if (event_name && (strcmp(event_name, event->name) != 0))
7310			return NULL;
7311		if (sys_name && (strcmp(sys_name, event->system) != 0))
7312			return NULL;
7313	} else {
7314		event = tep_find_event_by_name(tep, sys_name, event_name);
7315		if (!event)
7316			return NULL;
7317	}
7318	return event;
7319}
7320
7321/**
7322 * tep_register_event_handler - register a way to parse an event
7323 * @tep: a handle to the trace event parser context
7324 * @id: the id of the event to register
7325 * @sys_name: the system name the event belongs to
7326 * @event_name: the name of the event
7327 * @func: the function to call to parse the event information
7328 * @context: the data to be passed to @func
7329 *
7330 * This function allows a developer to override the parsing of
7331 * a given event. If for some reason the default print format
7332 * is not sufficient, this function will register a function
7333 * for an event to be used to parse the data instead.
7334 *
7335 * If @id is >= 0, then it is used to find the event.
7336 * else @sys_name and @event_name are used.
7337 *
7338 * Returns:
7339 *  TEP_REGISTER_SUCCESS_OVERWRITE if an existing handler is overwritten
7340 *  TEP_REGISTER_SUCCESS if a new handler is registered successfully
7341 *  negative TEP_ERRNO_... in case of an error
7342 *
7343 */
7344int tep_register_event_handler(struct tep_handle *tep, int id,
7345			       const char *sys_name, const char *event_name,
7346			       tep_event_handler_func func, void *context)
7347{
7348	struct tep_event *event;
7349	struct event_handler *handle;
7350
7351	event = search_event(tep, id, sys_name, event_name);
7352	if (event == NULL)
7353		goto not_found;
7354
7355	pr_stat("overriding event (%d) %s:%s with new print handler",
7356		event->id, event->system, event->name);
7357
7358	event->handler = func;
7359	event->context = context;
7360	return TEP_REGISTER_SUCCESS_OVERWRITE;
7361
7362 not_found:
7363	/* Save for later use. */
7364	handle = calloc(1, sizeof(*handle));
7365	if (!handle) {
7366		do_warning("Failed to allocate event handler");
7367		return TEP_ERRNO__MEM_ALLOC_FAILED;
7368	}
7369
7370	handle->id = id;
7371	if (event_name)
7372		handle->event_name = strdup(event_name);
7373	if (sys_name)
7374		handle->sys_name = strdup(sys_name);
7375
7376	if ((event_name && !handle->event_name) ||
7377	    (sys_name && !handle->sys_name)) {
7378		do_warning("Failed to allocate event/sys name");
7379		free((void *)handle->event_name);
7380		free((void *)handle->sys_name);
7381		free(handle);
7382		return TEP_ERRNO__MEM_ALLOC_FAILED;
7383	}
7384
7385	handle->func = func;
7386	handle->next = tep->handlers;
7387	tep->handlers = handle;
7388	handle->context = context;
7389
7390	return TEP_REGISTER_SUCCESS;
7391}
7392
7393static int handle_matches(struct event_handler *handler, int id,
7394			  const char *sys_name, const char *event_name,
7395			  tep_event_handler_func func, void *context)
7396{
7397	if (id >= 0 && id != handler->id)
7398		return 0;
7399
7400	if (event_name && (strcmp(event_name, handler->event_name) != 0))
7401		return 0;
7402
7403	if (sys_name && (strcmp(sys_name, handler->sys_name) != 0))
7404		return 0;
7405
7406	if (func != handler->func || context != handler->context)
7407		return 0;
7408
7409	return 1;
7410}
7411
7412/**
7413 * tep_unregister_event_handler - unregister an existing event handler
7414 * @tep: a handle to the trace event parser context
7415 * @id: the id of the event to unregister
7416 * @sys_name: the system name the handler belongs to
7417 * @event_name: the name of the event handler
7418 * @func: the function to call to parse the event information
7419 * @context: the data to be passed to @func
7420 *
7421 * This function removes existing event handler (parser).
7422 *
7423 * If @id is >= 0, then it is used to find the event.
7424 * else @sys_name and @event_name are used.
7425 *
7426 * Returns 0 if handler was removed successfully, -1 if event was not found.
7427 */
7428int tep_unregister_event_handler(struct tep_handle *tep, int id,
7429				 const char *sys_name, const char *event_name,
7430				 tep_event_handler_func func, void *context)
7431{
7432	struct tep_event *event;
7433	struct event_handler *handle;
7434	struct event_handler **next;
7435
7436	event = search_event(tep, id, sys_name, event_name);
7437	if (event == NULL)
7438		goto not_found;
7439
7440	if (event->handler == func && event->context == context) {
7441		pr_stat("removing override handler for event (%d) %s:%s. Going back to default handler.",
7442			event->id, event->system, event->name);
7443
7444		event->handler = NULL;
7445		event->context = NULL;
7446		return 0;
7447	}
7448
7449not_found:
7450	for (next = &tep->handlers; *next; next = &(*next)->next) {
7451		handle = *next;
7452		if (handle_matches(handle, id, sys_name, event_name,
7453				   func, context))
7454			break;
7455	}
7456
7457	if (!(*next))
7458		return -1;
7459
7460	*next = handle->next;
7461	free_handler(handle);
7462
7463	return 0;
7464}
7465
7466/**
7467 * tep_alloc - create a tep handle
7468 */
7469struct tep_handle *tep_alloc(void)
7470{
7471	struct tep_handle *tep = calloc(1, sizeof(*tep));
7472
7473	if (tep) {
7474		tep->ref_count = 1;
7475		tep->host_bigendian = tep_is_bigendian();
7476	}
7477
7478	return tep;
7479}
7480
7481void tep_ref(struct tep_handle *tep)
7482{
7483	tep->ref_count++;
7484}
7485
7486int tep_get_ref(struct tep_handle *tep)
7487{
7488	if (tep)
7489		return tep->ref_count;
7490	return 0;
7491}
7492
7493void tep_free_format_field(struct tep_format_field *field)
7494{
7495	free(field->type);
7496	if (field->alias != field->name)
7497		free(field->alias);
7498	free(field->name);
7499	free(field);
7500}
7501
7502static void free_format_fields(struct tep_format_field *field)
7503{
7504	struct tep_format_field *next;
7505
7506	while (field) {
7507		next = field->next;
7508		tep_free_format_field(field);
7509		field = next;
7510	}
7511}
7512
7513static void free_formats(struct tep_format *format)
7514{
7515	free_format_fields(format->common_fields);
7516	free_format_fields(format->fields);
7517}
7518
7519void tep_free_event(struct tep_event *event)
7520{
7521	free(event->name);
7522	free(event->system);
7523
7524	free_formats(&event->format);
7525
7526	free(event->print_fmt.format);
7527	free_args(event->print_fmt.args);
7528	free_parse_args(event->print_fmt.print_cache);
7529	free(event);
7530}
7531
7532/**
7533 * tep_free - free a tep handle
7534 * @tep: the tep handle to free
7535 */
7536void tep_free(struct tep_handle *tep)
7537{
7538	struct cmdline_list *cmdlist, *cmdnext;
7539	struct func_list *funclist, *funcnext;
7540	struct printk_list *printklist, *printknext;
7541	struct tep_function_handler *func_handler;
7542	struct event_handler *handle;
7543	int i;
7544
7545	if (!tep)
7546		return;
7547
7548	cmdlist = tep->cmdlist;
7549	funclist = tep->funclist;
7550	printklist = tep->printklist;
7551
7552	tep->ref_count--;
7553	if (tep->ref_count)
7554		return;
7555
7556	if (tep->cmdlines) {
7557		for (i = 0; i < tep->cmdline_count; i++)
7558			free(tep->cmdlines[i].comm);
7559		free(tep->cmdlines);
7560	}
7561
7562	while (cmdlist) {
7563		cmdnext = cmdlist->next;
7564		free(cmdlist->comm);
7565		free(cmdlist);
7566		cmdlist = cmdnext;
7567	}
7568
7569	if (tep->func_map) {
7570		for (i = 0; i < (int)tep->func_count; i++) {
7571			free(tep->func_map[i].func);
7572			free(tep->func_map[i].mod);
7573		}
7574		free(tep->func_map);
7575	}
7576
7577	while (funclist) {
7578		funcnext = funclist->next;
7579		free(funclist->func);
7580		free(funclist->mod);
7581		free(funclist);
7582		funclist = funcnext;
7583	}
7584
7585	while (tep->func_handlers) {
7586		func_handler = tep->func_handlers;
7587		tep->func_handlers = func_handler->next;
7588		free_func_handle(func_handler);
7589	}
7590
7591	if (tep->printk_map) {
7592		for (i = 0; i < (int)tep->printk_count; i++)
7593			free(tep->printk_map[i].printk);
7594		free(tep->printk_map);
7595	}
7596
7597	while (printklist) {
7598		printknext = printklist->next;
7599		free(printklist->printk);
7600		free(printklist);
7601		printklist = printknext;
7602	}
7603
7604	for (i = 0; i < tep->nr_events; i++)
7605		tep_free_event(tep->events[i]);
7606
7607	while (tep->handlers) {
7608		handle = tep->handlers;
7609		tep->handlers = handle->next;
7610		free_handler(handle);
7611	}
7612
7613	free(tep->events);
7614	free(tep->sort_events);
7615	free(tep->func_resolver);
7616	tep_free_plugin_paths(tep);
7617
7618	free(tep);
7619}
7620
7621void tep_unref(struct tep_handle *tep)
7622{
7623	tep_free(tep);
7624}