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 event_read_fields(struct tep_event *event, struct tep_format_field **fields)
1429{
1430	struct tep_format_field *field = NULL;
1431	enum tep_event_type type;
1432	char *token;
1433	char *last_token;
1434	int count = 0;
1435
1436	do {
1437		unsigned int size_dynamic = 0;
1438
1439		type = read_token(&token);
1440		if (type == TEP_EVENT_NEWLINE) {
1441			free_token(token);
1442			return count;
1443		}
1444
1445		count++;
1446
1447		if (test_type_token(type, token, TEP_EVENT_ITEM, "field"))
1448			goto fail;
1449		free_token(token);
1450
1451		type = read_token(&token);
1452		/*
1453		 * The ftrace fields may still use the "special" name.
1454		 * Just ignore it.
1455		 */
1456		if (event->flags & TEP_EVENT_FL_ISFTRACE &&
1457		    type == TEP_EVENT_ITEM && strcmp(token, "special") == 0) {
1458			free_token(token);
1459			type = read_token(&token);
1460		}
1461
1462		if (test_type_token(type, token, TEP_EVENT_OP, ":") < 0)
1463			goto fail;
1464
1465		free_token(token);
1466		if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1467			goto fail;
1468
1469		last_token = token;
1470
1471		field = calloc(1, sizeof(*field));
1472		if (!field)
1473			goto fail;
1474
1475		field->event = event;
1476
1477		/* read the rest of the type */
1478		for (;;) {
1479			type = read_token(&token);
1480			if (type == TEP_EVENT_ITEM ||
1481			    (type == TEP_EVENT_OP && strcmp(token, "*") == 0) ||
1482			    /*
1483			     * Some of the ftrace fields are broken and have
1484			     * an illegal "." in them.
1485			     */
1486			    (event->flags & TEP_EVENT_FL_ISFTRACE &&
1487			     type == TEP_EVENT_OP && strcmp(token, ".") == 0)) {
1488
1489				if (strcmp(token, "*") == 0)
1490					field->flags |= TEP_FIELD_IS_POINTER;
1491
1492				if (field->type) {
1493					char *new_type;
1494					new_type = realloc(field->type,
1495							   strlen(field->type) +
1496							   strlen(last_token) + 2);
1497					if (!new_type) {
1498						free(last_token);
1499						goto fail;
1500					}
1501					field->type = new_type;
1502					strcat(field->type, " ");
1503					strcat(field->type, last_token);
1504					free(last_token);
1505				} else
1506					field->type = last_token;
1507				last_token = token;
1508				continue;
1509			}
1510
1511			break;
1512		}
1513
1514		if (!field->type) {
1515			do_warning_event(event, "%s: no type found", __func__);
1516			goto fail;
1517		}
1518		field->name = field->alias = last_token;
1519
1520		if (test_type(type, TEP_EVENT_OP))
1521			goto fail;
1522
1523		if (strcmp(token, "[") == 0) {
1524			enum tep_event_type last_type = type;
1525			char *brackets = token;
1526			char *new_brackets;
1527			int len;
1528
1529			field->flags |= TEP_FIELD_IS_ARRAY;
1530
1531			type = read_token(&token);
1532
1533			if (type == TEP_EVENT_ITEM)
1534				field->arraylen = strtoul(token, NULL, 0);
1535			else
1536				field->arraylen = 0;
1537
1538		        while (strcmp(token, "]") != 0) {
1539				if (last_type == TEP_EVENT_ITEM &&
1540				    type == TEP_EVENT_ITEM)
1541					len = 2;
1542				else
1543					len = 1;
1544				last_type = type;
1545
1546				new_brackets = realloc(brackets,
1547						       strlen(brackets) +
1548						       strlen(token) + len);
1549				if (!new_brackets) {
1550					free(brackets);
1551					goto fail;
1552				}
1553				brackets = new_brackets;
1554				if (len == 2)
1555					strcat(brackets, " ");
1556				strcat(brackets, token);
1557				/* We only care about the last token */
1558				field->arraylen = strtoul(token, NULL, 0);
1559				free_token(token);
1560				type = read_token(&token);
1561				if (type == TEP_EVENT_NONE) {
1562					do_warning_event(event, "failed to find token");
1563					goto fail;
1564				}
1565			}
1566
1567			free_token(token);
1568
1569			new_brackets = realloc(brackets, strlen(brackets) + 2);
1570			if (!new_brackets) {
1571				free(brackets);
1572				goto fail;
1573			}
1574			brackets = new_brackets;
1575			strcat(brackets, "]");
1576
1577			/* add brackets to type */
1578
1579			type = read_token(&token);
1580			/*
1581			 * If the next token is not an OP, then it is of
1582			 * the format: type [] item;
1583			 */
1584			if (type == TEP_EVENT_ITEM) {
1585				char *new_type;
1586				new_type = realloc(field->type,
1587						   strlen(field->type) +
1588						   strlen(field->name) +
1589						   strlen(brackets) + 2);
1590				if (!new_type) {
1591					free(brackets);
1592					goto fail;
1593				}
1594				field->type = new_type;
1595				strcat(field->type, " ");
1596				strcat(field->type, field->name);
1597				size_dynamic = type_size(field->name);
1598				free_token(field->name);
1599				strcat(field->type, brackets);
1600				field->name = field->alias = token;
1601				type = read_token(&token);
1602			} else {
1603				char *new_type;
1604				new_type = realloc(field->type,
1605						   strlen(field->type) +
1606						   strlen(brackets) + 1);
1607				if (!new_type) {
1608					free(brackets);
1609					goto fail;
1610				}
1611				field->type = new_type;
1612				strcat(field->type, brackets);
1613			}
1614			free(brackets);
1615		}
1616
1617		if (field_is_string(field))
1618			field->flags |= TEP_FIELD_IS_STRING;
1619		if (field_is_dynamic(field))
1620			field->flags |= TEP_FIELD_IS_DYNAMIC;
1621		if (field_is_long(field))
1622			field->flags |= TEP_FIELD_IS_LONG;
1623
1624		if (test_type_token(type, token,  TEP_EVENT_OP, ";"))
1625			goto fail;
1626		free_token(token);
1627
1628		if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
1629			goto fail_expect;
1630
1631		if (read_expected(TEP_EVENT_OP, ":") < 0)
1632			goto fail_expect;
1633
1634		if (read_expect_type(TEP_EVENT_ITEM, &token))
1635			goto fail;
1636		field->offset = strtoul(token, NULL, 0);
1637		free_token(token);
1638
1639		if (read_expected(TEP_EVENT_OP, ";") < 0)
1640			goto fail_expect;
1641
1642		if (read_expected(TEP_EVENT_ITEM, "size") < 0)
1643			goto fail_expect;
1644
1645		if (read_expected(TEP_EVENT_OP, ":") < 0)
1646			goto fail_expect;
1647
1648		if (read_expect_type(TEP_EVENT_ITEM, &token))
1649			goto fail;
1650		field->size = strtoul(token, NULL, 0);
1651		free_token(token);
1652
1653		if (read_expected(TEP_EVENT_OP, ";") < 0)
1654			goto fail_expect;
1655
1656		type = read_token(&token);
1657		if (type != TEP_EVENT_NEWLINE) {
1658			/* newer versions of the kernel have a "signed" type */
1659			if (test_type_token(type, token, TEP_EVENT_ITEM, "signed"))
1660				goto fail;
1661
1662			free_token(token);
1663
1664			if (read_expected(TEP_EVENT_OP, ":") < 0)
1665				goto fail_expect;
1666
1667			if (read_expect_type(TEP_EVENT_ITEM, &token))
1668				goto fail;
1669
1670			if (strtoul(token, NULL, 0))
1671				field->flags |= TEP_FIELD_IS_SIGNED;
1672
1673			free_token(token);
1674			if (read_expected(TEP_EVENT_OP, ";") < 0)
1675				goto fail_expect;
1676
1677			if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1678				goto fail;
1679		}
1680
1681		free_token(token);
1682
1683		if (field->flags & TEP_FIELD_IS_ARRAY) {
1684			if (field->arraylen)
1685				field->elementsize = field->size / field->arraylen;
1686			else if (field->flags & TEP_FIELD_IS_DYNAMIC)
1687				field->elementsize = size_dynamic;
1688			else if (field->flags & TEP_FIELD_IS_STRING)
1689				field->elementsize = 1;
1690			else if (field->flags & TEP_FIELD_IS_LONG)
1691				field->elementsize = event->tep ?
1692						     event->tep->long_size :
1693						     sizeof(long);
1694		} else
1695			field->elementsize = field->size;
1696
1697		*fields = field;
1698		fields = &field->next;
1699
1700	} while (1);
1701
1702	return 0;
1703
1704fail:
1705	free_token(token);
1706fail_expect:
1707	if (field) {
1708		free(field->type);
1709		free(field->name);
1710		free(field);
1711	}
1712	return -1;
1713}
1714
1715static int event_read_format(struct tep_event *event)
1716{
1717	char *token;
1718	int ret;
1719
1720	if (read_expected_item(TEP_EVENT_ITEM, "format") < 0)
1721		return -1;
1722
1723	if (read_expected(TEP_EVENT_OP, ":") < 0)
1724		return -1;
1725
1726	if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1727		goto fail;
1728	free_token(token);
1729
1730	ret = event_read_fields(event, &event->format.common_fields);
1731	if (ret < 0)
1732		return ret;
1733	event->format.nr_common = ret;
1734
1735	ret = event_read_fields(event, &event->format.fields);
1736	if (ret < 0)
1737		return ret;
1738	event->format.nr_fields = ret;
1739
1740	return 0;
1741
1742 fail:
1743	free_token(token);
1744	return -1;
1745}
1746
1747static enum tep_event_type
1748process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
1749		  char **tok, enum tep_event_type type);
1750
1751static enum tep_event_type
1752process_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1753{
1754	enum tep_event_type type;
1755	char *token;
1756
1757	type = read_token(&token);
1758	*tok = token;
1759
1760	return process_arg_token(event, arg, tok, type);
1761}
1762
1763static enum tep_event_type
1764process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok);
1765
1766/*
1767 * For __print_symbolic() and __print_flags, we need to completely
1768 * evaluate the first argument, which defines what to print next.
1769 */
1770static enum tep_event_type
1771process_field_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1772{
1773	enum tep_event_type type;
1774
1775	type = process_arg(event, arg, tok);
1776
1777	while (type == TEP_EVENT_OP) {
1778		type = process_op(event, arg, tok);
1779	}
1780
1781	return type;
1782}
1783
1784static enum tep_event_type
1785process_cond(struct tep_event *event, struct tep_print_arg *top, char **tok)
1786{
1787	struct tep_print_arg *arg, *left, *right;
1788	enum tep_event_type type;
1789	char *token = NULL;
1790
1791	arg = alloc_arg();
1792	left = alloc_arg();
1793	right = alloc_arg();
1794
1795	if (!arg || !left || !right) {
1796		do_warning_event(event, "%s: not enough memory!", __func__);
1797		/* arg will be freed at out_free */
1798		free_arg(left);
1799		free_arg(right);
1800		goto out_free;
1801	}
1802
1803	arg->type = TEP_PRINT_OP;
1804	arg->op.left = left;
1805	arg->op.right = right;
1806
1807	*tok = NULL;
1808	type = process_arg(event, left, &token);
1809
1810 again:
1811	if (type == TEP_EVENT_ERROR)
1812		goto out_free;
1813
1814	/* Handle other operations in the arguments */
1815	if (type == TEP_EVENT_OP && strcmp(token, ":") != 0) {
1816		type = process_op(event, left, &token);
1817		goto again;
1818	}
1819
1820	if (test_type_token(type, token, TEP_EVENT_OP, ":"))
1821		goto out_free;
1822
1823	arg->op.op = token;
1824
1825	type = process_arg(event, right, &token);
1826
1827	top->op.right = arg;
1828
1829	*tok = token;
1830	return type;
1831
1832out_free:
1833	/* Top may point to itself */
1834	top->op.right = NULL;
1835	free_token(token);
1836	free_arg(arg);
1837	return TEP_EVENT_ERROR;
1838}
1839
1840static enum tep_event_type
1841process_array(struct tep_event *event, struct tep_print_arg *top, char **tok)
1842{
1843	struct tep_print_arg *arg;
1844	enum tep_event_type type;
1845	char *token = NULL;
1846
1847	arg = alloc_arg();
1848	if (!arg) {
1849		do_warning_event(event, "%s: not enough memory!", __func__);
1850		/* '*tok' is set to top->op.op.  No need to free. */
1851		*tok = NULL;
1852		return TEP_EVENT_ERROR;
1853	}
1854
1855	*tok = NULL;
1856	type = process_arg(event, arg, &token);
1857	if (test_type_token(type, token, TEP_EVENT_OP, "]"))
1858		goto out_free;
1859
1860	top->op.right = arg;
1861
1862	free_token(token);
1863	type = read_token_item(&token);
1864	*tok = token;
1865
1866	return type;
1867
1868out_free:
1869	free_token(token);
1870	free_arg(arg);
1871	return TEP_EVENT_ERROR;
1872}
1873
1874static int get_op_prio(char *op)
1875{
1876	if (!op[1]) {
1877		switch (op[0]) {
1878		case '~':
1879		case '!':
1880			return 4;
1881		case '*':
1882		case '/':
1883		case '%':
1884			return 6;
1885		case '+':
1886		case '-':
1887			return 7;
1888			/* '>>' and '<<' are 8 */
1889		case '<':
1890		case '>':
1891			return 9;
1892			/* '==' and '!=' are 10 */
1893		case '&':
1894			return 11;
1895		case '^':
1896			return 12;
1897		case '|':
1898			return 13;
1899		case '?':
1900			return 16;
1901		default:
1902			do_warning("unknown op '%c'", op[0]);
1903			return -1;
1904		}
1905	} else {
1906		if (strcmp(op, "++") == 0 ||
1907		    strcmp(op, "--") == 0) {
1908			return 3;
1909		} else if (strcmp(op, ">>") == 0 ||
1910			   strcmp(op, "<<") == 0) {
1911			return 8;
1912		} else if (strcmp(op, ">=") == 0 ||
1913			   strcmp(op, "<=") == 0) {
1914			return 9;
1915		} else if (strcmp(op, "==") == 0 ||
1916			   strcmp(op, "!=") == 0) {
1917			return 10;
1918		} else if (strcmp(op, "&&") == 0) {
1919			return 14;
1920		} else if (strcmp(op, "||") == 0) {
1921			return 15;
1922		} else {
1923			do_warning("unknown op '%s'", op);
1924			return -1;
1925		}
1926	}
1927}
1928
1929static int set_op_prio(struct tep_print_arg *arg)
1930{
1931
1932	/* single ops are the greatest */
1933	if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
1934		arg->op.prio = 0;
1935	else
1936		arg->op.prio = get_op_prio(arg->op.op);
1937
1938	return arg->op.prio;
1939}
1940
1941/* Note, *tok does not get freed, but will most likely be saved */
1942static enum tep_event_type
1943process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1944{
1945	struct tep_print_arg *left, *right = NULL;
1946	enum tep_event_type type;
1947	char *token;
1948
1949	/* the op is passed in via tok */
1950	token = *tok;
1951
1952	if (arg->type == TEP_PRINT_OP && !arg->op.left) {
1953		/* handle single op */
1954		if (token[1]) {
1955			do_warning_event(event, "bad op token %s", token);
1956			goto out_free;
1957		}
1958		switch (token[0]) {
1959		case '~':
1960		case '!':
1961		case '+':
1962		case '-':
1963			break;
1964		default:
1965			do_warning_event(event, "bad op token %s", token);
1966			goto out_free;
1967
1968		}
1969
1970		/* make an empty left */
1971		left = alloc_arg();
1972		if (!left)
1973			goto out_warn_free;
1974
1975		left->type = TEP_PRINT_NULL;
1976		arg->op.left = left;
1977
1978		right = alloc_arg();
1979		if (!right)
1980			goto out_warn_free;
1981
1982		arg->op.right = right;
1983
1984		/* do not free the token, it belongs to an op */
1985		*tok = NULL;
1986		type = process_arg(event, right, tok);
1987
1988	} else if (strcmp(token, "?") == 0) {
1989
1990		left = alloc_arg();
1991		if (!left)
1992			goto out_warn_free;
1993
1994		/* copy the top arg to the left */
1995		*left = *arg;
1996
1997		arg->type = TEP_PRINT_OP;
1998		arg->op.op = token;
1999		arg->op.left = left;
2000		arg->op.prio = 0;
2001
2002		/* it will set arg->op.right */
2003		type = process_cond(event, arg, tok);
2004
2005	} else if (strcmp(token, ">>") == 0 ||
2006		   strcmp(token, "<<") == 0 ||
2007		   strcmp(token, "&") == 0 ||
2008		   strcmp(token, "|") == 0 ||
2009		   strcmp(token, "&&") == 0 ||
2010		   strcmp(token, "||") == 0 ||
2011		   strcmp(token, "-") == 0 ||
2012		   strcmp(token, "+") == 0 ||
2013		   strcmp(token, "*") == 0 ||
2014		   strcmp(token, "^") == 0 ||
2015		   strcmp(token, "/") == 0 ||
2016		   strcmp(token, "%") == 0 ||
2017		   strcmp(token, "<") == 0 ||
2018		   strcmp(token, ">") == 0 ||
2019		   strcmp(token, "<=") == 0 ||
2020		   strcmp(token, ">=") == 0 ||
2021		   strcmp(token, "==") == 0 ||
2022		   strcmp(token, "!=") == 0) {
2023
2024		left = alloc_arg();
2025		if (!left)
2026			goto out_warn_free;
2027
2028		/* copy the top arg to the left */
2029		*left = *arg;
2030
2031		arg->type = TEP_PRINT_OP;
2032		arg->op.op = token;
2033		arg->op.left = left;
2034		arg->op.right = NULL;
2035
2036		if (set_op_prio(arg) == -1) {
2037			event->flags |= TEP_EVENT_FL_FAILED;
2038			/* arg->op.op (= token) will be freed at out_free */
2039			arg->op.op = NULL;
2040			goto out_free;
2041		}
2042
2043		type = read_token_item(&token);
2044		*tok = token;
2045
2046		/* could just be a type pointer */
2047		if ((strcmp(arg->op.op, "*") == 0) &&
2048		    type == TEP_EVENT_DELIM && (strcmp(token, ")") == 0)) {
2049			char *new_atom;
2050
2051			if (left->type != TEP_PRINT_ATOM) {
2052				do_warning_event(event, "bad pointer type");
2053				goto out_free;
2054			}
2055			new_atom = realloc(left->atom.atom,
2056					    strlen(left->atom.atom) + 3);
2057			if (!new_atom)
2058				goto out_warn_free;
2059
2060			left->atom.atom = new_atom;
2061			strcat(left->atom.atom, " *");
2062			free(arg->op.op);
2063			*arg = *left;
2064			free(left);
2065
2066			return type;
2067		}
2068
2069		right = alloc_arg();
2070		if (!right)
2071			goto out_warn_free;
2072
2073		type = process_arg_token(event, right, tok, type);
2074		if (type == TEP_EVENT_ERROR) {
2075			free_arg(right);
2076			/* token was freed in process_arg_token() via *tok */
2077			token = NULL;
2078			goto out_free;
2079		}
2080
2081		if (right->type == TEP_PRINT_OP &&
2082		    get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
2083			struct tep_print_arg tmp;
2084
2085			/* rotate ops according to the priority */
2086			arg->op.right = right->op.left;
2087
2088			tmp = *arg;
2089			*arg = *right;
2090			*right = tmp;
2091
2092			arg->op.left = right;
2093		} else {
2094			arg->op.right = right;
2095		}
2096
2097	} else if (strcmp(token, "[") == 0) {
2098
2099		left = alloc_arg();
2100		if (!left)
2101			goto out_warn_free;
2102
2103		*left = *arg;
2104
2105		arg->type = TEP_PRINT_OP;
2106		arg->op.op = token;
2107		arg->op.left = left;
2108
2109		arg->op.prio = 0;
2110
2111		/* it will set arg->op.right */
2112		type = process_array(event, arg, tok);
2113
2114	} else {
2115		do_warning_event(event, "unknown op '%s'", token);
2116		event->flags |= TEP_EVENT_FL_FAILED;
2117		/* the arg is now the left side */
2118		goto out_free;
2119	}
2120
2121	if (type == TEP_EVENT_OP && strcmp(*tok, ":") != 0) {
2122		int prio;
2123
2124		/* higher prios need to be closer to the root */
2125		prio = get_op_prio(*tok);
2126
2127		if (prio > arg->op.prio)
2128			return process_op(event, arg, tok);
2129
2130		return process_op(event, right, tok);
2131	}
2132
2133	return type;
2134
2135out_warn_free:
2136	do_warning_event(event, "%s: not enough memory!", __func__);
2137out_free:
2138	free_token(token);
2139	*tok = NULL;
2140	return TEP_EVENT_ERROR;
2141}
2142
2143static enum tep_event_type
2144process_entry(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2145	      char **tok)
2146{
2147	enum tep_event_type type;
2148	char *field;
2149	char *token;
2150
2151	if (read_expected(TEP_EVENT_OP, "->") < 0)
2152		goto out_err;
2153
2154	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2155		goto out_free;
2156	field = token;
2157
2158	arg->type = TEP_PRINT_FIELD;
2159	arg->field.name = field;
2160
2161	if (is_flag_field) {
2162		arg->field.field = tep_find_any_field(event, arg->field.name);
2163		arg->field.field->flags |= TEP_FIELD_IS_FLAG;
2164		is_flag_field = 0;
2165	} else if (is_symbolic_field) {
2166		arg->field.field = tep_find_any_field(event, arg->field.name);
2167		arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
2168		is_symbolic_field = 0;
2169	}
2170
2171	type = read_token(&token);
2172	*tok = token;
2173
2174	return type;
2175
2176 out_free:
2177	free_token(token);
2178 out_err:
2179	*tok = NULL;
2180	return TEP_EVENT_ERROR;
2181}
2182
2183static int alloc_and_process_delim(struct tep_event *event, char *next_token,
2184				   struct tep_print_arg **print_arg)
2185{
2186	struct tep_print_arg *field;
2187	enum tep_event_type type;
2188	char *token;
2189	int ret = 0;
2190
2191	field = alloc_arg();
2192	if (!field) {
2193		do_warning_event(event, "%s: not enough memory!", __func__);
2194		errno = ENOMEM;
2195		return -1;
2196	}
2197
2198	type = process_arg(event, field, &token);
2199
2200	if (test_type_token(type, token, TEP_EVENT_DELIM, next_token)) {
2201		errno = EINVAL;
2202		ret = -1;
2203		free_arg(field);
2204		goto out_free_token;
2205	}
2206
2207	*print_arg = field;
2208
2209out_free_token:
2210	free_token(token);
2211
2212	return ret;
2213}
2214
2215static char *arg_eval (struct tep_print_arg *arg);
2216
2217static unsigned long long
2218eval_type_str(unsigned long long val, const char *type, int pointer)
2219{
2220	int sign = 0;
2221	char *ref;
2222	int len;
2223
2224	len = strlen(type);
2225
2226	if (pointer) {
2227
2228		if (type[len-1] != '*') {
2229			do_warning("pointer expected with non pointer type");
2230			return val;
2231		}
2232
2233		ref = malloc(len);
2234		if (!ref) {
2235			do_warning("%s: not enough memory!", __func__);
2236			return val;
2237		}
2238		memcpy(ref, type, len);
2239
2240		/* chop off the " *" */
2241		ref[len - 2] = 0;
2242
2243		val = eval_type_str(val, ref, 0);
2244		free(ref);
2245		return val;
2246	}
2247
2248	/* check if this is a pointer */
2249	if (type[len - 1] == '*')
2250		return val;
2251
2252	/* Try to figure out the arg size*/
2253	if (strncmp(type, "struct", 6) == 0)
2254		/* all bets off */
2255		return val;
2256
2257	if (strcmp(type, "u8") == 0)
2258		return val & 0xff;
2259
2260	if (strcmp(type, "u16") == 0)
2261		return val & 0xffff;
2262
2263	if (strcmp(type, "u32") == 0)
2264		return val & 0xffffffff;
2265
2266	if (strcmp(type, "u64") == 0 ||
2267	    strcmp(type, "s64") == 0)
2268		return val;
2269
2270	if (strcmp(type, "s8") == 0)
2271		return (unsigned long long)(char)val & 0xff;
2272
2273	if (strcmp(type, "s16") == 0)
2274		return (unsigned long long)(short)val & 0xffff;
2275
2276	if (strcmp(type, "s32") == 0)
2277		return (unsigned long long)(int)val & 0xffffffff;
2278
2279	if (strncmp(type, "unsigned ", 9) == 0) {
2280		sign = 0;
2281		type += 9;
2282	}
2283
2284	if (strcmp(type, "char") == 0) {
2285		if (sign)
2286			return (unsigned long long)(char)val & 0xff;
2287		else
2288			return val & 0xff;
2289	}
2290
2291	if (strcmp(type, "short") == 0) {
2292		if (sign)
2293			return (unsigned long long)(short)val & 0xffff;
2294		else
2295			return val & 0xffff;
2296	}
2297
2298	if (strcmp(type, "int") == 0) {
2299		if (sign)
2300			return (unsigned long long)(int)val & 0xffffffff;
2301		else
2302			return val & 0xffffffff;
2303	}
2304
2305	return val;
2306}
2307
2308/*
2309 * Try to figure out the type.
2310 */
2311static unsigned long long
2312eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
2313{
2314	if (arg->type != TEP_PRINT_TYPE) {
2315		do_warning("expected type argument");
2316		return 0;
2317	}
2318
2319	return eval_type_str(val, arg->typecast.type, pointer);
2320}
2321
2322static int arg_num_eval(struct tep_print_arg *arg, long long *val)
2323{
2324	long long left, right;
2325	int ret = 1;
2326
2327	switch (arg->type) {
2328	case TEP_PRINT_ATOM:
2329		*val = strtoll(arg->atom.atom, NULL, 0);
2330		break;
2331	case TEP_PRINT_TYPE:
2332		ret = arg_num_eval(arg->typecast.item, val);
2333		if (!ret)
2334			break;
2335		*val = eval_type(*val, arg, 0);
2336		break;
2337	case TEP_PRINT_OP:
2338		switch (arg->op.op[0]) {
2339		case '|':
2340			ret = arg_num_eval(arg->op.left, &left);
2341			if (!ret)
2342				break;
2343			ret = arg_num_eval(arg->op.right, &right);
2344			if (!ret)
2345				break;
2346			if (arg->op.op[1])
2347				*val = left || right;
2348			else
2349				*val = left | right;
2350			break;
2351		case '&':
2352			ret = arg_num_eval(arg->op.left, &left);
2353			if (!ret)
2354				break;
2355			ret = arg_num_eval(arg->op.right, &right);
2356			if (!ret)
2357				break;
2358			if (arg->op.op[1])
2359				*val = left && right;
2360			else
2361				*val = left & right;
2362			break;
2363		case '<':
2364			ret = arg_num_eval(arg->op.left, &left);
2365			if (!ret)
2366				break;
2367			ret = arg_num_eval(arg->op.right, &right);
2368			if (!ret)
2369				break;
2370			switch (arg->op.op[1]) {
2371			case 0:
2372				*val = left < right;
2373				break;
2374			case '<':
2375				*val = left << right;
2376				break;
2377			case '=':
2378				*val = left <= right;
2379				break;
2380			default:
2381				do_warning("unknown op '%s'", arg->op.op);
2382				ret = 0;
2383			}
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
2415			if (arg->op.op[1] != '=') {
2416				do_warning("unknown op '%s'", arg->op.op);
2417				ret = 0;
2418			} else
2419				*val = left == right;
2420			break;
2421		case '!':
2422			ret = arg_num_eval(arg->op.left, &left);
2423			if (!ret)
2424				break;
2425			ret = arg_num_eval(arg->op.right, &right);
2426			if (!ret)
2427				break;
2428
2429			switch (arg->op.op[1]) {
2430			case '=':
2431				*val = left != right;
2432				break;
2433			default:
2434				do_warning("unknown op '%s'", arg->op.op);
2435				ret = 0;
2436			}
2437			break;
2438		case '-':
2439			/* check for negative */
2440			if (arg->op.left->type == TEP_PRINT_NULL)
2441				left = 0;
2442			else
2443				ret = arg_num_eval(arg->op.left, &left);
2444			if (!ret)
2445				break;
2446			ret = arg_num_eval(arg->op.right, &right);
2447			if (!ret)
2448				break;
2449			*val = left - right;
2450			break;
2451		case '+':
2452			if (arg->op.left->type == TEP_PRINT_NULL)
2453				left = 0;
2454			else
2455				ret = arg_num_eval(arg->op.left, &left);
2456			if (!ret)
2457				break;
2458			ret = arg_num_eval(arg->op.right, &right);
2459			if (!ret)
2460				break;
2461			*val = left + right;
2462			break;
2463		case '~':
2464			ret = arg_num_eval(arg->op.right, &right);
2465			if (!ret)
2466				break;
2467			*val = ~right;
2468			break;
2469		default:
2470			do_warning("unknown op '%s'", arg->op.op);
2471			ret = 0;
2472		}
2473		break;
2474
2475	case TEP_PRINT_NULL:
2476	case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2477	case TEP_PRINT_STRING:
2478	case TEP_PRINT_BSTRING:
2479	case TEP_PRINT_BITMASK:
2480	default:
2481		do_warning("invalid eval type %d", arg->type);
2482		ret = 0;
2483
2484	}
2485	return ret;
2486}
2487
2488static char *arg_eval (struct tep_print_arg *arg)
2489{
2490	long long val;
2491	static char buf[24];
2492
2493	switch (arg->type) {
2494	case TEP_PRINT_ATOM:
2495		return arg->atom.atom;
2496	case TEP_PRINT_TYPE:
2497		return arg_eval(arg->typecast.item);
2498	case TEP_PRINT_OP:
2499		if (!arg_num_eval(arg, &val))
2500			break;
2501		sprintf(buf, "%lld", val);
2502		return buf;
2503
2504	case TEP_PRINT_NULL:
2505	case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2506	case TEP_PRINT_STRING:
2507	case TEP_PRINT_BSTRING:
2508	case TEP_PRINT_BITMASK:
2509	default:
2510		do_warning("invalid eval type %d", arg->type);
2511		break;
2512	}
2513
2514	return NULL;
2515}
2516
2517static enum tep_event_type
2518process_fields(struct tep_event *event, struct tep_print_flag_sym **list, char **tok)
2519{
2520	enum tep_event_type type;
2521	struct tep_print_arg *arg = NULL;
2522	struct tep_print_flag_sym *field;
2523	char *token = *tok;
2524	char *value;
2525
2526	do {
2527		free_token(token);
2528		type = read_token_item(&token);
2529		if (test_type_token(type, token, TEP_EVENT_OP, "{"))
2530			break;
2531
2532		arg = alloc_arg();
2533		if (!arg)
2534			goto out_free;
2535
2536		free_token(token);
2537		type = process_arg(event, arg, &token);
2538
2539		if (type == TEP_EVENT_OP)
2540			type = process_op(event, arg, &token);
2541
2542		if (type == TEP_EVENT_ERROR)
2543			goto out_free;
2544
2545		if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2546			goto out_free;
2547
2548		field = calloc(1, sizeof(*field));
2549		if (!field)
2550			goto out_free;
2551
2552		value = arg_eval(arg);
2553		if (value == NULL)
2554			goto out_free_field;
2555		field->value = strdup(value);
2556		if (field->value == NULL)
2557			goto out_free_field;
2558
2559		free_arg(arg);
2560		arg = alloc_arg();
2561		if (!arg)
2562			goto out_free;
2563
2564		free_token(token);
2565		type = process_arg(event, arg, &token);
2566		if (test_type_token(type, token, TEP_EVENT_OP, "}"))
2567			goto out_free_field;
2568
2569		value = arg_eval(arg);
2570		if (value == NULL)
2571			goto out_free_field;
2572		field->str = strdup(value);
2573		if (field->str == NULL)
2574			goto out_free_field;
2575		free_arg(arg);
2576		arg = NULL;
2577
2578		*list = field;
2579		list = &field->next;
2580
2581		free_token(token);
2582		type = read_token_item(&token);
2583	} while (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0);
2584
2585	*tok = token;
2586	return type;
2587
2588out_free_field:
2589	free_flag_sym(field);
2590out_free:
2591	free_arg(arg);
2592	free_token(token);
2593	*tok = NULL;
2594
2595	return TEP_EVENT_ERROR;
2596}
2597
2598static enum tep_event_type
2599process_flags(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2600{
2601	struct tep_print_arg *field;
2602	enum tep_event_type type;
2603	char *token = NULL;
2604
2605	memset(arg, 0, sizeof(*arg));
2606	arg->type = TEP_PRINT_FLAGS;
2607
2608	field = alloc_arg();
2609	if (!field) {
2610		do_warning_event(event, "%s: not enough memory!", __func__);
2611		goto out_free;
2612	}
2613
2614	type = process_field_arg(event, field, &token);
2615
2616	/* Handle operations in the first argument */
2617	while (type == TEP_EVENT_OP)
2618		type = process_op(event, field, &token);
2619
2620	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2621		goto out_free_field;
2622	free_token(token);
2623
2624	arg->flags.field = field;
2625
2626	type = read_token_item(&token);
2627	if (event_item_type(type)) {
2628		arg->flags.delim = token;
2629		type = read_token_item(&token);
2630	}
2631
2632	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2633		goto out_free;
2634
2635	type = process_fields(event, &arg->flags.flags, &token);
2636	if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2637		goto out_free;
2638
2639	free_token(token);
2640	type = read_token_item(tok);
2641	return type;
2642
2643out_free_field:
2644	free_arg(field);
2645out_free:
2646	free_token(token);
2647	*tok = NULL;
2648	return TEP_EVENT_ERROR;
2649}
2650
2651static enum tep_event_type
2652process_symbols(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2653{
2654	struct tep_print_arg *field;
2655	enum tep_event_type type;
2656	char *token = NULL;
2657
2658	memset(arg, 0, sizeof(*arg));
2659	arg->type = TEP_PRINT_SYMBOL;
2660
2661	field = alloc_arg();
2662	if (!field) {
2663		do_warning_event(event, "%s: not enough memory!", __func__);
2664		goto out_free;
2665	}
2666
2667	type = process_field_arg(event, field, &token);
2668
2669	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2670		goto out_free_field;
2671
2672	arg->symbol.field = field;
2673
2674	type = process_fields(event, &arg->symbol.symbols, &token);
2675	if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2676		goto out_free;
2677
2678	free_token(token);
2679	type = read_token_item(tok);
2680	return type;
2681
2682out_free_field:
2683	free_arg(field);
2684out_free:
2685	free_token(token);
2686	*tok = NULL;
2687	return TEP_EVENT_ERROR;
2688}
2689
2690static enum tep_event_type
2691process_hex_common(struct tep_event *event, struct tep_print_arg *arg,
2692		   char **tok, enum tep_print_arg_type type)
2693{
2694	memset(arg, 0, sizeof(*arg));
2695	arg->type = type;
2696
2697	if (alloc_and_process_delim(event, ",", &arg->hex.field))
2698		goto out;
2699
2700	if (alloc_and_process_delim(event, ")", &arg->hex.size))
2701		goto free_field;
2702
2703	return read_token_item(tok);
2704
2705free_field:
2706	free_arg(arg->hex.field);
2707	arg->hex.field = NULL;
2708out:
2709	*tok = NULL;
2710	return TEP_EVENT_ERROR;
2711}
2712
2713static enum tep_event_type
2714process_hex(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2715{
2716	return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
2717}
2718
2719static enum tep_event_type
2720process_hex_str(struct tep_event *event, struct tep_print_arg *arg,
2721		char **tok)
2722{
2723	return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
2724}
2725
2726static enum tep_event_type
2727process_int_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2728{
2729	memset(arg, 0, sizeof(*arg));
2730	arg->type = TEP_PRINT_INT_ARRAY;
2731
2732	if (alloc_and_process_delim(event, ",", &arg->int_array.field))
2733		goto out;
2734
2735	if (alloc_and_process_delim(event, ",", &arg->int_array.count))
2736		goto free_field;
2737
2738	if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
2739		goto free_size;
2740
2741	return read_token_item(tok);
2742
2743free_size:
2744	free_arg(arg->int_array.count);
2745	arg->int_array.count = NULL;
2746free_field:
2747	free_arg(arg->int_array.field);
2748	arg->int_array.field = NULL;
2749out:
2750	*tok = NULL;
2751	return TEP_EVENT_ERROR;
2752}
2753
2754static enum tep_event_type
2755process_dynamic_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2756{
2757	struct tep_format_field *field;
2758	enum tep_event_type type;
2759	char *token;
2760
2761	memset(arg, 0, sizeof(*arg));
2762	arg->type = TEP_PRINT_DYNAMIC_ARRAY;
2763
2764	/*
2765	 * The item within the parenthesis is another field that holds
2766	 * the index into where the array starts.
2767	 */
2768	type = read_token(&token);
2769	*tok = token;
2770	if (type != TEP_EVENT_ITEM)
2771		goto out_free;
2772
2773	/* Find the field */
2774
2775	field = tep_find_field(event, token);
2776	if (!field)
2777		goto out_free;
2778
2779	arg->dynarray.field = field;
2780	arg->dynarray.index = 0;
2781
2782	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2783		goto out_free;
2784
2785	free_token(token);
2786	type = read_token_item(&token);
2787	*tok = token;
2788	if (type != TEP_EVENT_OP || strcmp(token, "[") != 0)
2789		return type;
2790
2791	free_token(token);
2792	arg = alloc_arg();
2793	if (!arg) {
2794		do_warning_event(event, "%s: not enough memory!", __func__);
2795		*tok = NULL;
2796		return TEP_EVENT_ERROR;
2797	}
2798
2799	type = process_arg(event, arg, &token);
2800	if (type == TEP_EVENT_ERROR)
2801		goto out_free_arg;
2802
2803	if (!test_type_token(type, token, TEP_EVENT_OP, "]"))
2804		goto out_free_arg;
2805
2806	free_token(token);
2807	type = read_token_item(tok);
2808	return type;
2809
2810 out_free_arg:
2811	free_arg(arg);
2812 out_free:
2813	free_token(token);
2814	*tok = NULL;
2815	return TEP_EVENT_ERROR;
2816}
2817
2818static enum tep_event_type
2819process_dynamic_array_len(struct tep_event *event, struct tep_print_arg *arg,
2820			  char **tok)
2821{
2822	struct tep_format_field *field;
2823	enum tep_event_type type;
2824	char *token;
2825
2826	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2827		goto out_free;
2828
2829	arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
2830
2831	/* Find the field */
2832	field = tep_find_field(event, token);
2833	if (!field)
2834		goto out_free;
2835
2836	arg->dynarray.field = field;
2837	arg->dynarray.index = 0;
2838
2839	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2840		goto out_err;
2841
2842	type = read_token(&token);
2843	*tok = token;
2844
2845	return type;
2846
2847 out_free:
2848	free_token(token);
2849 out_err:
2850	*tok = NULL;
2851	return TEP_EVENT_ERROR;
2852}
2853
2854static enum tep_event_type
2855process_paren(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2856{
2857	struct tep_print_arg *item_arg;
2858	enum tep_event_type type;
2859	char *token;
2860
2861	type = process_arg(event, arg, &token);
2862
2863	if (type == TEP_EVENT_ERROR)
2864		goto out_free;
2865
2866	if (type == TEP_EVENT_OP)
2867		type = process_op(event, arg, &token);
2868
2869	if (type == TEP_EVENT_ERROR)
2870		goto out_free;
2871
2872	if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2873		goto out_free;
2874
2875	free_token(token);
2876	type = read_token_item(&token);
2877
2878	/*
2879	 * If the next token is an item or another open paren, then
2880	 * this was a typecast.
2881	 */
2882	if (event_item_type(type) ||
2883	    (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0)) {
2884
2885		/* make this a typecast and contine */
2886
2887		/* prevous must be an atom */
2888		if (arg->type != TEP_PRINT_ATOM) {
2889			do_warning_event(event, "previous needed to be TEP_PRINT_ATOM");
2890			goto out_free;
2891		}
2892
2893		item_arg = alloc_arg();
2894		if (!item_arg) {
2895			do_warning_event(event, "%s: not enough memory!",
2896					 __func__);
2897			goto out_free;
2898		}
2899
2900		arg->type = TEP_PRINT_TYPE;
2901		arg->typecast.type = arg->atom.atom;
2902		arg->typecast.item = item_arg;
2903		type = process_arg_token(event, item_arg, &token, type);
2904
2905	}
2906
2907	*tok = token;
2908	return type;
2909
2910 out_free:
2911	free_token(token);
2912	*tok = NULL;
2913	return TEP_EVENT_ERROR;
2914}
2915
2916
2917static enum tep_event_type
2918process_str(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2919	    char **tok)
2920{
2921	enum tep_event_type type;
2922	char *token;
2923
2924	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2925		goto out_free;
2926
2927	arg->type = TEP_PRINT_STRING;
2928	arg->string.string = token;
2929	arg->string.offset = -1;
2930
2931	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2932		goto out_err;
2933
2934	type = read_token(&token);
2935	*tok = token;
2936
2937	return type;
2938
2939 out_free:
2940	free_token(token);
2941 out_err:
2942	*tok = NULL;
2943	return TEP_EVENT_ERROR;
2944}
2945
2946static enum tep_event_type
2947process_bitmask(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2948		char **tok)
2949{
2950	enum tep_event_type type;
2951	char *token;
2952
2953	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2954		goto out_free;
2955
2956	arg->type = TEP_PRINT_BITMASK;
2957	arg->bitmask.bitmask = token;
2958	arg->bitmask.offset = -1;
2959
2960	if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2961		goto out_err;
2962
2963	type = read_token(&token);
2964	*tok = token;
2965
2966	return type;
2967
2968 out_free:
2969	free_token(token);
2970 out_err:
2971	*tok = NULL;
2972	return TEP_EVENT_ERROR;
2973}
2974
2975static struct tep_function_handler *
2976find_func_handler(struct tep_handle *tep, char *func_name)
2977{
2978	struct tep_function_handler *func;
2979
2980	if (!tep)
2981		return NULL;
2982
2983	for (func = tep->func_handlers; func; func = func->next) {
2984		if (strcmp(func->name, func_name) == 0)
2985			break;
2986	}
2987
2988	return func;
2989}
2990
2991static void remove_func_handler(struct tep_handle *tep, char *func_name)
2992{
2993	struct tep_function_handler *func;
2994	struct tep_function_handler **next;
2995
2996	next = &tep->func_handlers;
2997	while ((func = *next)) {
2998		if (strcmp(func->name, func_name) == 0) {
2999			*next = func->next;
3000			free_func_handle(func);
3001			break;
3002		}
3003		next = &func->next;
3004	}
3005}
3006
3007static enum tep_event_type
3008process_func_handler(struct tep_event *event, struct tep_function_handler *func,
3009		     struct tep_print_arg *arg, char **tok)
3010{
3011	struct tep_print_arg **next_arg;
3012	struct tep_print_arg *farg;
3013	enum tep_event_type type;
3014	char *token;
3015	int i;
3016
3017	arg->type = TEP_PRINT_FUNC;
3018	arg->func.func = func;
3019
3020	*tok = NULL;
3021
3022	next_arg = &(arg->func.args);
3023	for (i = 0; i < func->nr_args; i++) {
3024		farg = alloc_arg();
3025		if (!farg) {
3026			do_warning_event(event, "%s: not enough memory!",
3027					 __func__);
3028			return TEP_EVENT_ERROR;
3029		}
3030
3031		type = process_arg(event, farg, &token);
3032		if (i < (func->nr_args - 1)) {
3033			if (type != TEP_EVENT_DELIM || strcmp(token, ",") != 0) {
3034				do_warning_event(event,
3035					"Error: function '%s()' expects %d arguments but event %s only uses %d",
3036					func->name, func->nr_args,
3037					event->name, i + 1);
3038				goto err;
3039			}
3040		} else {
3041			if (type != TEP_EVENT_DELIM || strcmp(token, ")") != 0) {
3042				do_warning_event(event,
3043					"Error: function '%s()' only expects %d arguments but event %s has more",
3044					func->name, func->nr_args, event->name);
3045				goto err;
3046			}
3047		}
3048
3049		*next_arg = farg;
3050		next_arg = &(farg->next);
3051		free_token(token);
3052	}
3053
3054	type = read_token(&token);
3055	*tok = token;
3056
3057	return type;
3058
3059err:
3060	free_arg(farg);
3061	free_token(token);
3062	return TEP_EVENT_ERROR;
3063}
3064
3065static enum tep_event_type
3066process_function(struct tep_event *event, struct tep_print_arg *arg,
3067		 char *token, char **tok)
3068{
3069	struct tep_function_handler *func;
3070
3071	if (strcmp(token, "__print_flags") == 0) {
3072		free_token(token);
3073		is_flag_field = 1;
3074		return process_flags(event, arg, tok);
3075	}
3076	if (strcmp(token, "__print_symbolic") == 0) {
3077		free_token(token);
3078		is_symbolic_field = 1;
3079		return process_symbols(event, arg, tok);
3080	}
3081	if (strcmp(token, "__print_hex") == 0) {
3082		free_token(token);
3083		return process_hex(event, arg, tok);
3084	}
3085	if (strcmp(token, "__print_hex_str") == 0) {
3086		free_token(token);
3087		return process_hex_str(event, arg, tok);
3088	}
3089	if (strcmp(token, "__print_array") == 0) {
3090		free_token(token);
3091		return process_int_array(event, arg, tok);
3092	}
3093	if (strcmp(token, "__get_str") == 0) {
3094		free_token(token);
3095		return process_str(event, arg, tok);
3096	}
3097	if (strcmp(token, "__get_bitmask") == 0) {
3098		free_token(token);
3099		return process_bitmask(event, arg, tok);
3100	}
3101	if (strcmp(token, "__get_dynamic_array") == 0) {
3102		free_token(token);
3103		return process_dynamic_array(event, arg, tok);
3104	}
3105	if (strcmp(token, "__get_dynamic_array_len") == 0) {
3106		free_token(token);
3107		return process_dynamic_array_len(event, arg, tok);
3108	}
3109
3110	func = find_func_handler(event->tep, token);
3111	if (func) {
3112		free_token(token);
3113		return process_func_handler(event, func, arg, tok);
3114	}
3115
3116	do_warning_event(event, "function %s not defined", token);
3117	free_token(token);
3118	return TEP_EVENT_ERROR;
3119}
3120
3121static enum tep_event_type
3122process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
3123		  char **tok, enum tep_event_type type)
3124{
3125	char *token;
3126	char *atom;
3127
3128	token = *tok;
3129
3130	switch (type) {
3131	case TEP_EVENT_ITEM:
3132		if (strcmp(token, "REC") == 0) {
3133			free_token(token);
3134			type = process_entry(event, arg, &token);
3135			break;
3136		}
3137		atom = token;
3138		/* test the next token */
3139		type = read_token_item(&token);
3140
3141		/*
3142		 * If the next token is a parenthesis, then this
3143		 * is a function.
3144		 */
3145		if (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0) {
3146			free_token(token);
3147			token = NULL;
3148			/* this will free atom. */
3149			type = process_function(event, arg, atom, &token);
3150			break;
3151		}
3152		/* atoms can be more than one token long */
3153		while (type == TEP_EVENT_ITEM) {
3154			char *new_atom;
3155			new_atom = realloc(atom,
3156					   strlen(atom) + strlen(token) + 2);
3157			if (!new_atom) {
3158				free(atom);
3159				*tok = NULL;
3160				free_token(token);
3161				return TEP_EVENT_ERROR;
3162			}
3163			atom = new_atom;
3164			strcat(atom, " ");
3165			strcat(atom, token);
3166			free_token(token);
3167			type = read_token_item(&token);
3168		}
3169
3170		arg->type = TEP_PRINT_ATOM;
3171		arg->atom.atom = atom;
3172		break;
3173
3174	case TEP_EVENT_DQUOTE:
3175	case TEP_EVENT_SQUOTE:
3176		arg->type = TEP_PRINT_ATOM;
3177		arg->atom.atom = token;
3178		type = read_token_item(&token);
3179		break;
3180	case TEP_EVENT_DELIM:
3181		if (strcmp(token, "(") == 0) {
3182			free_token(token);
3183			type = process_paren(event, arg, &token);
3184			break;
3185		}
3186	case TEP_EVENT_OP:
3187		/* handle single ops */
3188		arg->type = TEP_PRINT_OP;
3189		arg->op.op = token;
3190		arg->op.left = NULL;
3191		type = process_op(event, arg, &token);
3192
3193		/* On error, the op is freed */
3194		if (type == TEP_EVENT_ERROR)
3195			arg->op.op = NULL;
3196
3197		/* return error type if errored */
3198		break;
3199
3200	case TEP_EVENT_ERROR ... TEP_EVENT_NEWLINE:
3201	default:
3202		do_warning_event(event, "unexpected type %d", type);
3203		return TEP_EVENT_ERROR;
3204	}
3205	*tok = token;
3206
3207	return type;
3208}
3209
3210static int event_read_print_args(struct tep_event *event, struct tep_print_arg **list)
3211{
3212	enum tep_event_type type = TEP_EVENT_ERROR;
3213	struct tep_print_arg *arg;
3214	char *token;
3215	int args = 0;
3216
3217	do {
3218		if (type == TEP_EVENT_NEWLINE) {
3219			type = read_token_item(&token);
3220			continue;
3221		}
3222
3223		arg = alloc_arg();
3224		if (!arg) {
3225			do_warning_event(event, "%s: not enough memory!",
3226					 __func__);
3227			return -1;
3228		}
3229
3230		type = process_arg(event, arg, &token);
3231
3232		if (type == TEP_EVENT_ERROR) {
3233			free_token(token);
3234			free_arg(arg);
3235			return -1;
3236		}
3237
3238		*list = arg;
3239		args++;
3240
3241		if (type == TEP_EVENT_OP) {
3242			type = process_op(event, arg, &token);
3243			free_token(token);
3244			if (type == TEP_EVENT_ERROR) {
3245				*list = NULL;
3246				free_arg(arg);
3247				return -1;
3248			}
3249			list = &arg->next;
3250			continue;
3251		}
3252
3253		if (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0) {
3254			free_token(token);
3255			*list = arg;
3256			list = &arg->next;
3257			continue;
3258		}
3259		break;
3260	} while (type != TEP_EVENT_NONE);
3261
3262	if (type != TEP_EVENT_NONE && type != TEP_EVENT_ERROR)
3263		free_token(token);
3264
3265	return args;
3266}
3267
3268static int event_read_print(struct tep_event *event)
3269{
3270	enum tep_event_type type;
3271	char *token;
3272	int ret;
3273
3274	if (read_expected_item(TEP_EVENT_ITEM, "print") < 0)
3275		return -1;
3276
3277	if (read_expected(TEP_EVENT_ITEM, "fmt") < 0)
3278		return -1;
3279
3280	if (read_expected(TEP_EVENT_OP, ":") < 0)
3281		return -1;
3282
3283	if (read_expect_type(TEP_EVENT_DQUOTE, &token) < 0)
3284		goto fail;
3285
3286 concat:
3287	event->print_fmt.format = token;
3288	event->print_fmt.args = NULL;
3289
3290	/* ok to have no arg */
3291	type = read_token_item(&token);
3292
3293	if (type == TEP_EVENT_NONE)
3294		return 0;
3295
3296	/* Handle concatenation of print lines */
3297	if (type == TEP_EVENT_DQUOTE) {
3298		char *cat;
3299
3300		if (asprintf(&cat, "%s%s", event->print_fmt.format, token) < 0)
3301			goto fail;
3302		free_token(token);
3303		free_token(event->print_fmt.format);
3304		event->print_fmt.format = NULL;
3305		token = cat;
3306		goto concat;
3307	}
3308			     
3309	if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
3310		goto fail;
3311
3312	free_token(token);
3313
3314	ret = event_read_print_args(event, &event->print_fmt.args);
3315	if (ret < 0)
3316		return -1;
3317
3318	return ret;
3319
3320 fail:
3321	free_token(token);
3322	return -1;
3323}
3324
3325/**
3326 * tep_find_common_field - return a common field by event
3327 * @event: handle for the event
3328 * @name: the name of the common field to return
3329 *
3330 * Returns a common field from the event by the given @name.
3331 * This only searches the common fields and not all field.
3332 */
3333struct tep_format_field *
3334tep_find_common_field(struct tep_event *event, const char *name)
3335{
3336	struct tep_format_field *format;
3337
3338	for (format = event->format.common_fields;
3339	     format; format = format->next) {
3340		if (strcmp(format->name, name) == 0)
3341			break;
3342	}
3343
3344	return format;
3345}
3346
3347/**
3348 * tep_find_field - find a non-common field
3349 * @event: handle for the event
3350 * @name: the name of the non-common field
3351 *
3352 * Returns a non-common field by the given @name.
3353 * This does not search common fields.
3354 */
3355struct tep_format_field *
3356tep_find_field(struct tep_event *event, const char *name)
3357{
3358	struct tep_format_field *format;
3359
3360	for (format = event->format.fields;
3361	     format; format = format->next) {
3362		if (strcmp(format->name, name) == 0)
3363			break;
3364	}
3365
3366	return format;
3367}
3368
3369/**
3370 * tep_find_any_field - find any field by name
3371 * @event: handle for the event
3372 * @name: the name of the field
3373 *
3374 * Returns a field by the given @name.
3375 * This searches the common field names first, then
3376 * the non-common ones if a common one was not found.
3377 */
3378struct tep_format_field *
3379tep_find_any_field(struct tep_event *event, const char *name)
3380{
3381	struct tep_format_field *format;
3382
3383	format = tep_find_common_field(event, name);
3384	if (format)
3385		return format;
3386	return tep_find_field(event, name);
3387}
3388
3389/**
3390 * tep_read_number - read a number from data
3391 * @tep: a handle to the trace event parser context
3392 * @ptr: the raw data
3393 * @size: the size of the data that holds the number
3394 *
3395 * Returns the number (converted to host) from the
3396 * raw data.
3397 */
3398unsigned long long tep_read_number(struct tep_handle *tep,
3399				   const void *ptr, int size)
3400{
3401	unsigned long long val;
3402
3403	switch (size) {
3404	case 1:
3405		return *(unsigned char *)ptr;
3406	case 2:
3407		return tep_data2host2(tep, *(unsigned short *)ptr);
3408	case 4:
3409		return tep_data2host4(tep, *(unsigned int *)ptr);
3410	case 8:
3411		memcpy(&val, (ptr), sizeof(unsigned long long));
3412		return tep_data2host8(tep, val);
3413	default:
3414		/* BUG! */
3415		return 0;
3416	}
3417}
3418
3419/**
3420 * tep_read_number_field - read a number from data
3421 * @field: a handle to the field
3422 * @data: the raw data to read
3423 * @value: the value to place the number in
3424 *
3425 * Reads raw data according to a field offset and size,
3426 * and translates it into @value.
3427 *
3428 * Returns 0 on success, -1 otherwise.
3429 */
3430int tep_read_number_field(struct tep_format_field *field, const void *data,
3431			  unsigned long long *value)
3432{
3433	if (!field)
3434		return -1;
3435	switch (field->size) {
3436	case 1:
3437	case 2:
3438	case 4:
3439	case 8:
3440		*value = tep_read_number(field->event->tep,
3441					 data + field->offset, field->size);
3442		return 0;
3443	default:
3444		return -1;
3445	}
3446}
3447
3448static int get_common_info(struct tep_handle *tep,
3449			   const char *type, int *offset, int *size)
3450{
3451	struct tep_event *event;
3452	struct tep_format_field *field;
3453
3454	/*
3455	 * All events should have the same common elements.
3456	 * Pick any event to find where the type is;
3457	 */
3458	if (!tep->events) {
3459		do_warning("no event_list!");
3460		return -1;
3461	}
3462
3463	event = tep->events[0];
3464	field = tep_find_common_field(event, type);
3465	if (!field)
3466		return -1;
3467
3468	*offset = field->offset;
3469	*size = field->size;
3470
3471	return 0;
3472}
3473
3474static int __parse_common(struct tep_handle *tep, void *data,
3475			  int *size, int *offset, const char *name)
3476{
3477	int ret;
3478
3479	if (!*size) {
3480		ret = get_common_info(tep, name, offset, size);
3481		if (ret < 0)
3482			return ret;
3483	}
3484	return tep_read_number(tep, data + *offset, *size);
3485}
3486
3487static int trace_parse_common_type(struct tep_handle *tep, void *data)
3488{
3489	return __parse_common(tep, data,
3490			      &tep->type_size, &tep->type_offset,
3491			      "common_type");
3492}
3493
3494static int parse_common_pid(struct tep_handle *tep, void *data)
3495{
3496	return __parse_common(tep, data,
3497			      &tep->pid_size, &tep->pid_offset,
3498			      "common_pid");
3499}
3500
3501static int parse_common_pc(struct tep_handle *tep, void *data)
3502{
3503	return __parse_common(tep, data,
3504			      &tep->pc_size, &tep->pc_offset,
3505			      "common_preempt_count");
3506}
3507
3508static int parse_common_flags(struct tep_handle *tep, void *data)
3509{
3510	return __parse_common(tep, data,
3511			      &tep->flags_size, &tep->flags_offset,
3512			      "common_flags");
3513}
3514
3515static int parse_common_lock_depth(struct tep_handle *tep, void *data)
3516{
3517	return __parse_common(tep, data,
3518			      &tep->ld_size, &tep->ld_offset,
3519			      "common_lock_depth");
3520}
3521
3522static int parse_common_migrate_disable(struct tep_handle *tep, void *data)
3523{
3524	return __parse_common(tep, data,
3525			      &tep->ld_size, &tep->ld_offset,
3526			      "common_migrate_disable");
3527}
3528
3529static int events_id_cmp(const void *a, const void *b);
3530
3531/**
3532 * tep_find_event - find an event by given id
3533 * @tep: a handle to the trace event parser context
3534 * @id: the id of the event
3535 *
3536 * Returns an event that has a given @id.
3537 */
3538struct tep_event *tep_find_event(struct tep_handle *tep, int id)
3539{
3540	struct tep_event **eventptr;
3541	struct tep_event key;
3542	struct tep_event *pkey = &key;
3543
3544	/* Check cache first */
3545	if (tep->last_event && tep->last_event->id == id)
3546		return tep->last_event;
3547
3548	key.id = id;
3549
3550	eventptr = bsearch(&pkey, tep->events, tep->nr_events,
3551			   sizeof(*tep->events), events_id_cmp);
3552
3553	if (eventptr) {
3554		tep->last_event = *eventptr;
3555		return *eventptr;
3556	}
3557
3558	return NULL;
3559}
3560
3561/**
3562 * tep_find_event_by_name - find an event by given name
3563 * @tep: a handle to the trace event parser context
3564 * @sys: the system name to search for
3565 * @name: the name of the event to search for
3566 *
3567 * This returns an event with a given @name and under the system
3568 * @sys. If @sys is NULL the first event with @name is returned.
3569 */
3570struct tep_event *
3571tep_find_event_by_name(struct tep_handle *tep,
3572		       const char *sys, const char *name)
3573{
3574	struct tep_event *event = NULL;
3575	int i;
3576
3577	if (tep->last_event &&
3578	    strcmp(tep->last_event->name, name) == 0 &&
3579	    (!sys || strcmp(tep->last_event->system, sys) == 0))
3580		return tep->last_event;
3581
3582	for (i = 0; i < tep->nr_events; i++) {
3583		event = tep->events[i];
3584		if (strcmp(event->name, name) == 0) {
3585			if (!sys)
3586				break;
3587			if (strcmp(event->system, sys) == 0)
3588				break;
3589		}
3590	}
3591	if (i == tep->nr_events)
3592		event = NULL;
3593
3594	tep->last_event = event;
3595	return event;
3596}
3597
3598static unsigned long long
3599eval_num_arg(void *data, int size, struct tep_event *event, struct tep_print_arg *arg)
3600{
3601	struct tep_handle *tep = event->tep;
3602	unsigned long long val = 0;
3603	unsigned long long left, right;
3604	struct tep_print_arg *typearg = NULL;
3605	struct tep_print_arg *larg;
3606	unsigned long offset;
3607	unsigned int field_size;
3608
3609	switch (arg->type) {
3610	case TEP_PRINT_NULL:
3611		/* ?? */
3612		return 0;
3613	case TEP_PRINT_ATOM:
3614		return strtoull(arg->atom.atom, NULL, 0);
3615	case TEP_PRINT_FIELD:
3616		if (!arg->field.field) {
3617			arg->field.field = tep_find_any_field(event, arg->field.name);
3618			if (!arg->field.field)
3619				goto out_warning_field;
3620			
3621		}
3622		/* must be a number */
3623		val = tep_read_number(tep, data + arg->field.field->offset,
3624				      arg->field.field->size);
3625		break;
3626	case TEP_PRINT_FLAGS:
3627	case TEP_PRINT_SYMBOL:
3628	case TEP_PRINT_INT_ARRAY:
3629	case TEP_PRINT_HEX:
3630	case TEP_PRINT_HEX_STR:
3631		break;
3632	case TEP_PRINT_TYPE:
3633		val = eval_num_arg(data, size, event, arg->typecast.item);
3634		return eval_type(val, arg, 0);
3635	case TEP_PRINT_STRING:
3636	case TEP_PRINT_BSTRING:
3637	case TEP_PRINT_BITMASK:
3638		return 0;
3639	case TEP_PRINT_FUNC: {
3640		struct trace_seq s;
3641		trace_seq_init(&s);
3642		val = process_defined_func(&s, data, size, event, arg);
3643		trace_seq_destroy(&s);
3644		return val;
3645	}
3646	case TEP_PRINT_OP:
3647		if (strcmp(arg->op.op, "[") == 0) {
3648			/*
3649			 * Arrays are special, since we don't want
3650			 * to read the arg as is.
3651			 */
3652			right = eval_num_arg(data, size, event, arg->op.right);
3653
3654			/* handle typecasts */
3655			larg = arg->op.left;
3656			while (larg->type == TEP_PRINT_TYPE) {
3657				if (!typearg)
3658					typearg = larg;
3659				larg = larg->typecast.item;
3660			}
3661
3662			/* Default to long size */
3663			field_size = tep->long_size;
3664
3665			switch (larg->type) {
3666			case TEP_PRINT_DYNAMIC_ARRAY:
3667				offset = tep_read_number(tep,
3668						   data + larg->dynarray.field->offset,
3669						   larg->dynarray.field->size);
3670				if (larg->dynarray.field->elementsize)
3671					field_size = larg->dynarray.field->elementsize;
3672				/*
3673				 * The actual length of the dynamic array is stored
3674				 * in the top half of the field, and the offset
3675				 * is in the bottom half of the 32 bit field.
3676				 */
3677				offset &= 0xffff;
3678				offset += right;
3679				break;
3680			case TEP_PRINT_FIELD:
3681				if (!larg->field.field) {
3682					larg->field.field =
3683						tep_find_any_field(event, larg->field.name);
3684					if (!larg->field.field) {
3685						arg = larg;
3686						goto out_warning_field;
3687					}
3688				}
3689				field_size = larg->field.field->elementsize;
3690				offset = larg->field.field->offset +
3691					right * larg->field.field->elementsize;
3692				break;
3693			default:
3694				goto default_op; /* oops, all bets off */
3695			}
3696			val = tep_read_number(tep,
3697					      data + offset, field_size);
3698			if (typearg)
3699				val = eval_type(val, typearg, 1);
3700			break;
3701		} else if (strcmp(arg->op.op, "?") == 0) {
3702			left = eval_num_arg(data, size, event, arg->op.left);
3703			arg = arg->op.right;
3704			if (left)
3705				val = eval_num_arg(data, size, event, arg->op.left);
3706			else
3707				val = eval_num_arg(data, size, event, arg->op.right);
3708			break;
3709		}
3710 default_op:
3711		left = eval_num_arg(data, size, event, arg->op.left);
3712		right = eval_num_arg(data, size, event, arg->op.right);
3713		switch (arg->op.op[0]) {
3714		case '!':
3715			switch (arg->op.op[1]) {
3716			case 0:
3717				val = !right;
3718				break;
3719			case '=':
3720				val = left != right;
3721				break;
3722			default:
3723				goto out_warning_op;
3724			}
3725			break;
3726		case '~':
3727			val = ~right;
3728			break;
3729		case '|':
3730			if (arg->op.op[1])
3731				val = left || right;
3732			else
3733				val = left | right;
3734			break;
3735		case '&':
3736			if (arg->op.op[1])
3737				val = left && right;
3738			else
3739				val = left & right;
3740			break;
3741		case '<':
3742			switch (arg->op.op[1]) {
3743			case 0:
3744				val = left < right;
3745				break;
3746			case '<':
3747				val = left << right;
3748				break;
3749			case '=':
3750				val = left <= right;
3751				break;
3752			default:
3753				goto out_warning_op;
3754			}
3755			break;
3756		case '>':
3757			switch (arg->op.op[1]) {
3758			case 0:
3759				val = left > right;
3760				break;
3761			case '>':
3762				val = left >> right;
3763				break;
3764			case '=':
3765				val = left >= right;
3766				break;
3767			default:
3768				goto out_warning_op;
3769			}
3770			break;
3771		case '=':
3772			if (arg->op.op[1] != '=')
3773				goto out_warning_op;
3774
3775			val = left == right;
3776			break;
3777		case '-':
3778			val = left - right;
3779			break;
3780		case '+':
3781			val = left + right;
3782			break;
3783		case '/':
3784			val = left / right;
3785			break;
3786		case '%':
3787			val = left % right;
3788			break;
3789		case '*':
3790			val = left * right;
3791			break;
3792		default:
3793			goto out_warning_op;
3794		}
3795		break;
3796	case TEP_PRINT_DYNAMIC_ARRAY_LEN:
3797		offset = tep_read_number(tep,
3798					 data + arg->dynarray.field->offset,
3799					 arg->dynarray.field->size);
3800		/*
3801		 * The total allocated length of the dynamic array is
3802		 * stored in the top half of the field, and the offset
3803		 * is in the bottom half of the 32 bit field.
3804		 */
3805		val = (unsigned long long)(offset >> 16);
3806		break;
3807	case TEP_PRINT_DYNAMIC_ARRAY:
3808		/* Without [], we pass the address to the dynamic data */
3809		offset = tep_read_number(tep,
3810					 data + arg->dynarray.field->offset,
3811					 arg->dynarray.field->size);
3812		/*
3813		 * The total allocated length of the dynamic array is
3814		 * stored in the top half of the field, and the offset
3815		 * is in the bottom half of the 32 bit field.
3816		 */
3817		offset &= 0xffff;
3818		val = (unsigned long long)((unsigned long)data + offset);
3819		break;
3820	default: /* not sure what to do there */
3821		return 0;
3822	}
3823	return val;
3824
3825out_warning_op:
3826	do_warning_event(event, "%s: unknown op '%s'", __func__, arg->op.op);
3827	return 0;
3828
3829out_warning_field:
3830	do_warning_event(event, "%s: field %s not found",
3831			 __func__, arg->field.name);
3832	return 0;
3833}
3834
3835struct flag {
3836	const char *name;
3837	unsigned long long value;
3838};
3839
3840static const struct flag flags[] = {
3841	{ "HI_SOFTIRQ", 0 },
3842	{ "TIMER_SOFTIRQ", 1 },
3843	{ "NET_TX_SOFTIRQ", 2 },
3844	{ "NET_RX_SOFTIRQ", 3 },
3845	{ "BLOCK_SOFTIRQ", 4 },
3846	{ "IRQ_POLL_SOFTIRQ", 5 },
3847	{ "TASKLET_SOFTIRQ", 6 },
3848	{ "SCHED_SOFTIRQ", 7 },
3849	{ "HRTIMER_SOFTIRQ", 8 },
3850	{ "RCU_SOFTIRQ", 9 },
3851
3852	{ "HRTIMER_NORESTART", 0 },
3853	{ "HRTIMER_RESTART", 1 },
3854};
3855
3856static long long eval_flag(const char *flag)
3857{
3858	int i;
3859
3860	/*
3861	 * Some flags in the format files do not get converted.
3862	 * If the flag is not numeric, see if it is something that
3863	 * we already know about.
3864	 */
3865	if (isdigit(flag[0]))
3866		return strtoull(flag, NULL, 0);
3867
3868	for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
3869		if (strcmp(flags[i].name, flag) == 0)
3870			return flags[i].value;
3871
3872	return -1LL;
3873}
3874
3875static void print_str_to_seq(struct trace_seq *s, const char *format,
3876			     int len_arg, const char *str)
3877{
3878	if (len_arg >= 0)
3879		trace_seq_printf(s, format, len_arg, str);
3880	else
3881		trace_seq_printf(s, format, str);
3882}
3883
3884static void print_bitmask_to_seq(struct tep_handle *tep,
3885				 struct trace_seq *s, const char *format,
3886				 int len_arg, const void *data, int size)
3887{
3888	int nr_bits = size * 8;
3889	int str_size = (nr_bits + 3) / 4;
3890	int len = 0;
3891	char buf[3];
3892	char *str;
3893	int index;
3894	int i;
3895
3896	/*
3897	 * The kernel likes to put in commas every 32 bits, we
3898	 * can do the same.
3899	 */
3900	str_size += (nr_bits - 1) / 32;
3901
3902	str = malloc(str_size + 1);
3903	if (!str) {
3904		do_warning("%s: not enough memory!", __func__);
3905		return;
3906	}
3907	str[str_size] = 0;
3908
3909	/* Start out with -2 for the two chars per byte */
3910	for (i = str_size - 2; i >= 0; i -= 2) {
3911		/*
3912		 * data points to a bit mask of size bytes.
3913		 * In the kernel, this is an array of long words, thus
3914		 * endianness is very important.
3915		 */
3916		if (tep->file_bigendian)
3917			index = size - (len + 1);
3918		else
3919			index = len;
3920
3921		snprintf(buf, 3, "%02x", *((unsigned char *)data + index));
3922		memcpy(str + i, buf, 2);
3923		len++;
3924		if (!(len & 3) && i > 0) {
3925			i--;
3926			str[i] = ',';
3927		}
3928	}
3929
3930	if (len_arg >= 0)
3931		trace_seq_printf(s, format, len_arg, str);
3932	else
3933		trace_seq_printf(s, format, str);
3934
3935	free(str);
3936}
3937
3938static void print_str_arg(struct trace_seq *s, void *data, int size,
3939			  struct tep_event *event, const char *format,
3940			  int len_arg, struct tep_print_arg *arg)
3941{
3942	struct tep_handle *tep = event->tep;
3943	struct tep_print_flag_sym *flag;
3944	struct tep_format_field *field;
3945	struct printk_map *printk;
3946	long long val, fval;
3947	unsigned long long addr;
3948	char *str;
3949	unsigned char *hex;
3950	int print;
3951	int i, len;
3952
3953	switch (arg->type) {
3954	case TEP_PRINT_NULL:
3955		/* ?? */
3956		return;
3957	case TEP_PRINT_ATOM:
3958		print_str_to_seq(s, format, len_arg, arg->atom.atom);
3959		return;
3960	case TEP_PRINT_FIELD:
3961		field = arg->field.field;
3962		if (!field) {
3963			field = tep_find_any_field(event, arg->field.name);
3964			if (!field) {
3965				str = arg->field.name;
3966				goto out_warning_field;
3967			}
3968			arg->field.field = field;
3969		}
3970		/* Zero sized fields, mean the rest of the data */
3971		len = field->size ? : size - field->offset;
3972
3973		/*
3974		 * Some events pass in pointers. If this is not an array
3975		 * and the size is the same as long_size, assume that it
3976		 * is a pointer.
3977		 */
3978		if (!(field->flags & TEP_FIELD_IS_ARRAY) &&
3979		    field->size == tep->long_size) {
3980
3981			/* Handle heterogeneous recording and processing
3982			 * architectures
3983			 *
3984			 * CASE I:
3985			 * Traces recorded on 32-bit devices (32-bit
3986			 * addressing) and processed on 64-bit devices:
3987			 * In this case, only 32 bits should be read.
3988			 *
3989			 * CASE II:
3990			 * Traces recorded on 64 bit devices and processed
3991			 * on 32-bit devices:
3992			 * In this case, 64 bits must be read.
3993			 */
3994			addr = (tep->long_size == 8) ?
3995				*(unsigned long long *)(data + field->offset) :
3996				(unsigned long long)*(unsigned int *)(data + field->offset);
3997
3998			/* Check if it matches a print format */
3999			printk = find_printk(tep, addr);
4000			if (printk)
4001				trace_seq_puts(s, printk->printk);
4002			else
4003				trace_seq_printf(s, "%llx", addr);
4004			break;
4005		}
4006		str = malloc(len + 1);
4007		if (!str) {
4008			do_warning_event(event, "%s: not enough memory!",
4009					 __func__);
4010			return;
4011		}
4012		memcpy(str, data + field->offset, len);
4013		str[len] = 0;
4014		print_str_to_seq(s, format, len_arg, str);
4015		free(str);
4016		break;
4017	case TEP_PRINT_FLAGS:
4018		val = eval_num_arg(data, size, event, arg->flags.field);
4019		print = 0;
4020		for (flag = arg->flags.flags; flag; flag = flag->next) {
4021			fval = eval_flag(flag->value);
4022			if (!val && fval < 0) {
4023				print_str_to_seq(s, format, len_arg, flag->str);
4024				break;
4025			}
4026			if (fval > 0 && (val & fval) == fval) {
4027				if (print && arg->flags.delim)
4028					trace_seq_puts(s, arg->flags.delim);
4029				print_str_to_seq(s, format, len_arg, flag->str);
4030				print = 1;
4031				val &= ~fval;
4032			}
4033		}
4034		if (val) {
4035			if (print && arg->flags.delim)
4036				trace_seq_puts(s, arg->flags.delim);
4037			trace_seq_printf(s, "0x%llx", val);
4038		}
4039		break;
4040	case TEP_PRINT_SYMBOL:
4041		val = eval_num_arg(data, size, event, arg->symbol.field);
4042		for (flag = arg->symbol.symbols; flag; flag = flag->next) {
4043			fval = eval_flag(flag->value);
4044			if (val == fval) {
4045				print_str_to_seq(s, format, len_arg, flag->str);
4046				break;
4047			}
4048		}
4049		if (!flag)
4050			trace_seq_printf(s, "0x%llx", val);
4051		break;
4052	case TEP_PRINT_HEX:
4053	case TEP_PRINT_HEX_STR:
4054		if (arg->hex.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4055			unsigned long offset;
4056			offset = tep_read_number(tep,
4057				data + arg->hex.field->dynarray.field->offset,
4058				arg->hex.field->dynarray.field->size);
4059			hex = data + (offset & 0xffff);
4060		} else {
4061			field = arg->hex.field->field.field;
4062			if (!field) {
4063				str = arg->hex.field->field.name;
4064				field = tep_find_any_field(event, str);
4065				if (!field)
4066					goto out_warning_field;
4067				arg->hex.field->field.field = field;
4068			}
4069			hex = data + field->offset;
4070		}
4071		len = eval_num_arg(data, size, event, arg->hex.size);
4072		for (i = 0; i < len; i++) {
4073			if (i && arg->type == TEP_PRINT_HEX)
4074				trace_seq_putc(s, ' ');
4075			trace_seq_printf(s, "%02x", hex[i]);
4076		}
4077		break;
4078
4079	case TEP_PRINT_INT_ARRAY: {
4080		void *num;
4081		int el_size;
4082
4083		if (arg->int_array.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4084			unsigned long offset;
4085			struct tep_format_field *field =
4086				arg->int_array.field->dynarray.field;
4087			offset = tep_read_number(tep,
4088						 data + field->offset,
4089						 field->size);
4090			num = data + (offset & 0xffff);
4091		} else {
4092			field = arg->int_array.field->field.field;
4093			if (!field) {
4094				str = arg->int_array.field->field.name;
4095				field = tep_find_any_field(event, str);
4096				if (!field)
4097					goto out_warning_field;
4098				arg->int_array.field->field.field = field;
4099			}
4100			num = data + field->offset;
4101		}
4102		len = eval_num_arg(data, size, event, arg->int_array.count);
4103		el_size = eval_num_arg(data, size, event,
4104				       arg->int_array.el_size);
4105		for (i = 0; i < len; i++) {
4106			if (i)
4107				trace_seq_putc(s, ' ');
4108
4109			if (el_size == 1) {
4110				trace_seq_printf(s, "%u", *(uint8_t *)num);
4111			} else if (el_size == 2) {
4112				trace_seq_printf(s, "%u", *(uint16_t *)num);
4113			} else if (el_size == 4) {
4114				trace_seq_printf(s, "%u", *(uint32_t *)num);
4115			} else if (el_size == 8) {
4116				trace_seq_printf(s, "%"PRIu64, *(uint64_t *)num);
4117			} else {
4118				trace_seq_printf(s, "BAD SIZE:%d 0x%x",
4119						 el_size, *(uint8_t *)num);
4120				el_size = 1;
4121			}
4122
4123			num += el_size;
4124		}
4125		break;
4126	}
4127	case TEP_PRINT_TYPE:
4128		break;
4129	case TEP_PRINT_STRING: {
4130		int str_offset;
4131
4132		if (arg->string.offset == -1) {
4133			struct tep_format_field *f;
4134
4135			f = tep_find_any_field(event, arg->string.string);
4136			arg->string.offset = f->offset;
4137		}
4138		str_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->string.offset));
4139		str_offset &= 0xffff;
4140		print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
4141		break;
4142	}
4143	case TEP_PRINT_BSTRING:
4144		print_str_to_seq(s, format, len_arg, arg->string.string);
4145		break;
4146	case TEP_PRINT_BITMASK: {
4147		int bitmask_offset;
4148		int bitmask_size;
4149
4150		if (arg->bitmask.offset == -1) {
4151			struct tep_format_field *f;
4152
4153			f = tep_find_any_field(event, arg->bitmask.bitmask);
4154			arg->bitmask.offset = f->offset;
4155		}
4156		bitmask_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->bitmask.offset));
4157		bitmask_size = bitmask_offset >> 16;
4158		bitmask_offset &= 0xffff;
4159		print_bitmask_to_seq(tep, s, format, len_arg,
4160				     data + bitmask_offset, bitmask_size);
4161		break;
4162	}
4163	case TEP_PRINT_OP:
4164		/*
4165		 * The only op for string should be ? :
4166		 */
4167		if (arg->op.op[0] != '?')
4168			return;
4169		val = eval_num_arg(data, size, event, arg->op.left);
4170		if (val)
4171			print_str_arg(s, data, size, event,
4172				      format, len_arg, arg->op.right->op.left);
4173		else
4174			print_str_arg(s, data, size, event,
4175				      format, len_arg, arg->op.right->op.right);
4176		break;
4177	case TEP_PRINT_FUNC:
4178		process_defined_func(s, data, size, event, arg);
4179		break;
4180	default:
4181		/* well... */
4182		break;
4183	}
4184
4185	return;
4186
4187out_warning_field:
4188	do_warning_event(event, "%s: field %s not found",
4189			 __func__, arg->field.name);
4190}
4191
4192static unsigned long long
4193process_defined_func(struct trace_seq *s, void *data, int size,
4194		     struct tep_event *event, struct tep_print_arg *arg)
4195{
4196	struct tep_function_handler *func_handle = arg->func.func;
4197	struct func_params *param;
4198	unsigned long long *args;
4199	unsigned long long ret;
4200	struct tep_print_arg *farg;
4201	struct trace_seq str;
4202	struct save_str {
4203		struct save_str *next;
4204		char *str;
4205	} *strings = NULL, *string;
4206	int i;
4207
4208	if (!func_handle->nr_args) {
4209		ret = (*func_handle->func)(s, NULL);
4210		goto out;
4211	}
4212
4213	farg = arg->func.args;
4214	param = func_handle->params;
4215
4216	ret = ULLONG_MAX;
4217	args = malloc(sizeof(*args) * func_handle->nr_args);
4218	if (!args)
4219		goto out;
4220
4221	for (i = 0; i < func_handle->nr_args; i++) {
4222		switch (param->type) {
4223		case TEP_FUNC_ARG_INT:
4224		case TEP_FUNC_ARG_LONG:
4225		case TEP_FUNC_ARG_PTR:
4226			args[i] = eval_num_arg(data, size, event, farg);
4227			break;
4228		case TEP_FUNC_ARG_STRING:
4229			trace_seq_init(&str);
4230			print_str_arg(&str, data, size, event, "%s", -1, farg);
4231			trace_seq_terminate(&str);
4232			string = malloc(sizeof(*string));
4233			if (!string) {
4234				do_warning_event(event, "%s(%d): malloc str",
4235						 __func__, __LINE__);
4236				goto out_free;
4237			}
4238			string->next = strings;
4239			string->str = strdup(str.buffer);
4240			if (!string->str) {
4241				free(string);
4242				do_warning_event(event, "%s(%d): malloc str",
4243						 __func__, __LINE__);
4244				goto out_free;
4245			}
4246			args[i] = (uintptr_t)string->str;
4247			strings = string;
4248			trace_seq_destroy(&str);
4249			break;
4250		default:
4251			/*
4252			 * Something went totally wrong, this is not
4253			 * an input error, something in this code broke.
4254			 */
4255			do_warning_event(event, "Unexpected end of arguments\n");
4256			goto out_free;
4257		}
4258		farg = farg->next;
4259		param = param->next;
4260	}
4261
4262	ret = (*func_handle->func)(s, args);
4263out_free:
4264	free(args);
4265	while (strings) {
4266		string = strings;
4267		strings = string->next;
4268		free(string->str);
4269		free(string);
4270	}
4271
4272 out:
4273	/* TBD : handle return type here */
4274	return ret;
4275}
4276
4277static void free_args(struct tep_print_arg *args)
4278{
4279	struct tep_print_arg *next;
4280
4281	while (args) {
4282		next = args->next;
4283
4284		free_arg(args);
4285		args = next;
4286	}
4287}
4288
4289static struct tep_print_arg *make_bprint_args(char *fmt, void *data, int size, struct tep_event *event)
4290{
4291	struct tep_handle *tep = event->tep;
4292	struct tep_format_field *field, *ip_field;
4293	struct tep_print_arg *args, *arg, **next;
4294	unsigned long long ip, val;
4295	char *ptr;
4296	void *bptr;
4297	int vsize = 0;
4298
4299	field = tep->bprint_buf_field;
4300	ip_field = tep->bprint_ip_field;
4301
4302	if (!field) {
4303		field = tep_find_field(event, "buf");
4304		if (!field) {
4305			do_warning_event(event, "can't find buffer field for binary printk");
4306			return NULL;
4307		}
4308		ip_field = tep_find_field(event, "ip");
4309		if (!ip_field) {
4310			do_warning_event(event, "can't find ip field for binary printk");
4311			return NULL;
4312		}
4313		tep->bprint_buf_field = field;
4314		tep->bprint_ip_field = ip_field;
4315	}
4316
4317	ip = tep_read_number(tep, data + ip_field->offset, ip_field->size);
4318
4319	/*
4320	 * The first arg is the IP pointer.
4321	 */
4322	args = alloc_arg();
4323	if (!args) {
4324		do_warning_event(event, "%s(%d): not enough memory!",
4325				 __func__, __LINE__);
4326		return NULL;
4327	}
4328	arg = args;
4329	arg->next = NULL;
4330	next = &arg->next;
4331
4332	arg->type = TEP_PRINT_ATOM;
4333		
4334	if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
4335		goto out_free;
4336
4337	/* skip the first "%ps: " */
4338	for (ptr = fmt + 5, bptr = data + field->offset;
4339	     bptr < data + size && *ptr; ptr++) {
4340		int ls = 0;
4341
4342		if (*ptr == '%') {
4343 process_again:
4344			ptr++;
4345			switch (*ptr) {
4346			case '%':
4347				break;
4348			case 'l':
4349				ls++;
4350				goto process_again;
4351			case 'L':
4352				ls = 2;
4353				goto process_again;
4354			case '0' ... '9':
4355				goto process_again;
4356			case '.':
4357				goto process_again;
4358			case 'z':
4359			case 'Z':
4360				ls = 1;
4361				goto process_again;
4362			case 'p':
4363				ls = 1;
4364				if (isalnum(ptr[1])) {
4365					ptr++;
4366					/* Check for special pointers */
4367					switch (*ptr) {
4368					case 's':
4369					case 'S':
4370					case 'x':
4371						break;
4372					case 'f':
4373					case 'F':
4374						/*
4375						 * Pre-5.5 kernels use %pf and
4376						 * %pF for printing symbols
4377						 * while kernels since 5.5 use
4378						 * %pfw for fwnodes. So check
4379						 * %p[fF] isn't followed by 'w'.
4380						 */
4381						if (ptr[1] != 'w')
4382							break;
4383						/* fall through */
4384					default:
4385						/*
4386						 * Older kernels do not process
4387						 * dereferenced pointers.
4388						 * Only process if the pointer
4389						 * value is a printable.
4390						 */
4391						if (isprint(*(char *)bptr))
4392							goto process_string;
4393					}
4394				}
4395				/* fall through */
4396			case 'd':
4397			case 'u':
4398			case 'x':
4399			case 'i':
4400				switch (ls) {
4401				case 0:
4402					vsize = 4;
4403					break;
4404				case 1:
4405					vsize = tep->long_size;
4406					break;
4407				case 2:
4408					vsize = 8;
4409					break;
4410				default:
4411					vsize = ls; /* ? */
4412					break;
4413				}
4414			/* fall through */
4415			case '*':
4416				if (*ptr == '*')
4417					vsize = 4;
4418
4419				/* the pointers are always 4 bytes aligned */
4420				bptr = (void *)(((unsigned long)bptr + 3) &
4421						~3);
4422				val = tep_read_number(tep, bptr, vsize);
4423				bptr += vsize;
4424				arg = alloc_arg();
4425				if (!arg) {
4426					do_warning_event(event, "%s(%d): not enough memory!",
4427						   __func__, __LINE__);
4428					goto out_free;
4429				}
4430				arg->next = NULL;
4431				arg->type = TEP_PRINT_ATOM;
4432				if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4433					free(arg);
4434					goto out_free;
4435				}
4436				*next = arg;
4437				next = &arg->next;
4438				/*
4439				 * The '*' case means that an arg is used as the length.
4440				 * We need to continue to figure out for what.
4441				 */
4442				if (*ptr == '*')
4443					goto process_again;
4444
4445				break;
4446			case 's':
4447 process_string:
4448				arg = alloc_arg();
4449				if (!arg) {
4450					do_warning_event(event, "%s(%d): not enough memory!",
4451						   __func__, __LINE__);
4452					goto out_free;
4453				}
4454				arg->next = NULL;
4455				arg->type = TEP_PRINT_BSTRING;
4456				arg->string.string = strdup(bptr);
4457				if (!arg->string.string)
4458					goto out_free;
4459				bptr += strlen(bptr) + 1;
4460				*next = arg;
4461				next = &arg->next;
4462			default:
4463				break;
4464			}
4465		}
4466	}
4467
4468	return args;
4469
4470out_free:
4471	free_args(args);
4472	return NULL;
4473}
4474
4475static char *
4476get_bprint_format(void *data, int size __maybe_unused,
4477		  struct tep_event *event)
4478{
4479	struct tep_handle *tep = event->tep;
4480	unsigned long long addr;
4481	struct tep_format_field *field;
4482	struct printk_map *printk;
4483	char *format;
4484
4485	field = tep->bprint_fmt_field;
4486
4487	if (!field) {
4488		field = tep_find_field(event, "fmt");
4489		if (!field) {
4490			do_warning_event(event, "can't find format field for binary printk");
4491			return NULL;
4492		}
4493		tep->bprint_fmt_field = field;
4494	}
4495
4496	addr = tep_read_number(tep, data + field->offset, field->size);
4497
4498	printk = find_printk(tep, addr);
4499	if (!printk) {
4500		if (asprintf(&format, "%%ps: (NO FORMAT FOUND at %llx)\n", addr) < 0)
4501			return NULL;
4502		return format;
4503	}
4504
4505	if (asprintf(&format, "%s: %s", "%ps", printk->printk) < 0)
4506		return NULL;
4507
4508	return format;
4509}
4510
4511static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
4512			  struct tep_event *event, struct tep_print_arg *arg)
4513{
4514	unsigned char *buf;
4515	const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
4516
4517	if (arg->type == TEP_PRINT_FUNC) {
4518		process_defined_func(s, data, size, event, arg);
4519		return;
4520	}
4521
4522	if (arg->type != TEP_PRINT_FIELD) {
4523		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
4524				 arg->type);
4525		return;
4526	}
4527
4528	if (mac == 'm')
4529		fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
4530	if (!arg->field.field) {
4531		arg->field.field =
4532			tep_find_any_field(event, arg->field.name);
4533		if (!arg->field.field) {
4534			do_warning_event(event, "%s: field %s not found",
4535					 __func__, arg->field.name);
4536			return;
4537		}
4538	}
4539	if (arg->field.field->size != 6) {
4540		trace_seq_printf(s, "INVALIDMAC");
4541		return;
4542	}
4543	buf = data + arg->field.field->offset;
4544	trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
4545}
4546
4547static void print_ip4_addr(struct trace_seq *s, char i, unsigned char *buf)
4548{
4549	const char *fmt;
4550
4551	if (i == 'i')
4552		fmt = "%03d.%03d.%03d.%03d";
4553	else
4554		fmt = "%d.%d.%d.%d";
4555
4556	trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
4557}
4558
4559static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
4560{
4561	return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
4562		(unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
4563}
4564
4565static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
4566{
4567	return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
4568}
4569
4570static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
4571{
4572	int i, j, range;
4573	unsigned char zerolength[8];
4574	int longest = 1;
4575	int colonpos = -1;
4576	uint16_t word;
4577	uint8_t hi, lo;
4578	bool needcolon = false;
4579	bool useIPv4;
4580	struct in6_addr in6;
4581
4582	memcpy(&in6, addr, sizeof(struct in6_addr));
4583
4584	useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
4585
4586	memset(zerolength, 0, sizeof(zerolength));
4587
4588	if (useIPv4)
4589		range = 6;
4590	else
4591		range = 8;
4592
4593	/* find position of longest 0 run */
4594	for (i = 0; i < range; i++) {
4595		for (j = i; j < range; j++) {
4596			if (in6.s6_addr16[j] != 0)
4597				break;
4598			zerolength[i]++;
4599		}
4600	}
4601	for (i = 0; i < range; i++) {
4602		if (zerolength[i] > longest) {
4603			longest = zerolength[i];
4604			colonpos = i;
4605		}
4606	}
4607	if (longest == 1)		/* don't compress a single 0 */
4608		colonpos = -1;
4609
4610	/* emit address */
4611	for (i = 0; i < range; i++) {
4612		if (i == colonpos) {
4613			if (needcolon || i == 0)
4614				trace_seq_printf(s, ":");
4615			trace_seq_printf(s, ":");
4616			needcolon = false;
4617			i += longest - 1;
4618			continue;
4619		}
4620		if (needcolon) {
4621			trace_seq_printf(s, ":");
4622			needcolon = false;
4623		}
4624		/* hex u16 without leading 0s */
4625		word = ntohs(in6.s6_addr16[i]);
4626		hi = word >> 8;
4627		lo = word & 0xff;
4628		if (hi)
4629			trace_seq_printf(s, "%x%02x", hi, lo);
4630		else
4631			trace_seq_printf(s, "%x", lo);
4632
4633		needcolon = true;
4634	}
4635
4636	if (useIPv4) {
4637		if (needcolon)
4638			trace_seq_printf(s, ":");
4639		print_ip4_addr(s, 'I', &in6.s6_addr[12]);
4640	}
4641
4642	return;
4643}
4644
4645static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
4646{
4647	int j;
4648
4649	for (j = 0; j < 16; j += 2) {
4650		trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
4651		if (i == 'I' && j < 14)
4652			trace_seq_printf(s, ":");
4653	}
4654}
4655
4656/*
4657 * %pi4   print an IPv4 address with leading zeros
4658 * %pI4   print an IPv4 address without leading zeros
4659 * %pi6   print an IPv6 address without colons
4660 * %pI6   print an IPv6 address with colons
4661 * %pI6c  print an IPv6 address in compressed form with colons
4662 * %pISpc print an IP address based on sockaddr; p adds port.
4663 */
4664static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
4665			  void *data, int size, struct tep_event *event,
4666			  struct tep_print_arg *arg)
4667{
4668	unsigned char *buf;
4669
4670	if (arg->type == TEP_PRINT_FUNC) {
4671		process_defined_func(s, data, size, event, arg);
4672		return 0;
4673	}
4674
4675	if (arg->type != TEP_PRINT_FIELD) {
4676		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4677		return 0;
4678	}
4679
4680	if (!arg->field.field) {
4681		arg->field.field =
4682			tep_find_any_field(event, arg->field.name);
4683		if (!arg->field.field) {
4684			do_warning("%s: field %s not found",
4685				   __func__, arg->field.name);
4686			return 0;
4687		}
4688	}
4689
4690	buf = data + arg->field.field->offset;
4691
4692	if (arg->field.field->size != 4) {
4693		trace_seq_printf(s, "INVALIDIPv4");
4694		return 0;
4695	}
4696	print_ip4_addr(s, i, buf);
4697
4698	return 0;
4699}
4700
4701static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
4702			  void *data, int size, struct tep_event *event,
4703			  struct tep_print_arg *arg)
4704{
4705	char have_c = 0;
4706	unsigned char *buf;
4707	int rc = 0;
4708
4709	/* pI6c */
4710	if (i == 'I' && *ptr == 'c') {
4711		have_c = 1;
4712		ptr++;
4713		rc++;
4714	}
4715
4716	if (arg->type == TEP_PRINT_FUNC) {
4717		process_defined_func(s, data, size, event, arg);
4718		return rc;
4719	}
4720
4721	if (arg->type != TEP_PRINT_FIELD) {
4722		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4723		return rc;
4724	}
4725
4726	if (!arg->field.field) {
4727		arg->field.field =
4728			tep_find_any_field(event, arg->field.name);
4729		if (!arg->field.field) {
4730			do_warning("%s: field %s not found",
4731				   __func__, arg->field.name);
4732			return rc;
4733		}
4734	}
4735
4736	buf = data + arg->field.field->offset;
4737
4738	if (arg->field.field->size != 16) {
4739		trace_seq_printf(s, "INVALIDIPv6");
4740		return rc;
4741	}
4742
4743	if (have_c)
4744		print_ip6c_addr(s, buf);
4745	else
4746		print_ip6_addr(s, i, buf);
4747
4748	return rc;
4749}
4750
4751static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
4752			  void *data, int size, struct tep_event *event,
4753			  struct tep_print_arg *arg)
4754{
4755	char have_c = 0, have_p = 0;
4756	unsigned char *buf;
4757	struct sockaddr_storage *sa;
4758	int rc = 0;
4759
4760	/* pISpc */
4761	if (i == 'I') {
4762		if (*ptr == 'p') {
4763			have_p = 1;
4764			ptr++;
4765			rc++;
4766		}
4767		if (*ptr == 'c') {
4768			have_c = 1;
4769			ptr++;
4770			rc++;
4771		}
4772	}
4773
4774	if (arg->type == TEP_PRINT_FUNC) {
4775		process_defined_func(s, data, size, event, arg);
4776		return rc;
4777	}
4778
4779	if (arg->type != TEP_PRINT_FIELD) {
4780		trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4781		return rc;
4782	}
4783
4784	if (!arg->field.field) {
4785		arg->field.field =
4786			tep_find_any_field(event, arg->field.name);
4787		if (!arg->field.field) {
4788			do_warning("%s: field %s not found",
4789				   __func__, arg->field.name);
4790			return rc;
4791		}
4792	}
4793
4794	sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4795
4796	if (sa->ss_family == AF_INET) {
4797		struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
4798
4799		if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4800			trace_seq_printf(s, "INVALIDIPv4");
4801			return rc;
4802		}
4803
4804		print_ip4_addr(s, i, (unsigned char *) &sa4->sin_addr);
4805		if (have_p)
4806			trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
4807
4808
4809	} else if (sa->ss_family == AF_INET6) {
4810		struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
4811
4812		if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4813			trace_seq_printf(s, "INVALIDIPv6");
4814			return rc;
4815		}
4816
4817		if (have_p)
4818			trace_seq_printf(s, "[");
4819
4820		buf = (unsigned char *) &sa6->sin6_addr;
4821		if (have_c)
4822			print_ip6c_addr(s, buf);
4823		else
4824			print_ip6_addr(s, i, buf);
4825
4826		if (have_p)
4827			trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
4828	}
4829
4830	return rc;
4831}
4832
4833static int print_ip_arg(struct trace_seq *s, const char *ptr,
4834			void *data, int size, struct tep_event *event,
4835			struct tep_print_arg *arg)
4836{
4837	char i = *ptr;  /* 'i' or 'I' */
4838	char ver;
4839	int rc = 0;
4840
4841	ptr++;
4842	rc++;
4843
4844	ver = *ptr;
4845	ptr++;
4846	rc++;
4847
4848	switch (ver) {
4849	case '4':
4850		rc += print_ipv4_arg(s, ptr, i, data, size, event, arg);
4851		break;
4852	case '6':
4853		rc += print_ipv6_arg(s, ptr, i, data, size, event, arg);
4854		break;
4855	case 'S':
4856		rc += print_ipsa_arg(s, ptr, i, data, size, event, arg);
4857		break;
4858	default:
4859		return 0;
4860	}
4861
4862	return rc;
4863}
4864
4865static int is_printable_array(char *p, unsigned int len)
4866{
4867	unsigned int i;
4868
4869	for (i = 0; i < len && p[i]; i++)
4870		if (!isprint(p[i]) && !isspace(p[i]))
4871		    return 0;
4872	return 1;
4873}
4874
4875void tep_print_field(struct trace_seq *s, void *data,
4876		     struct tep_format_field *field)
4877{
4878	unsigned long long val;
4879	unsigned int offset, len, i;
4880	struct tep_handle *tep = field->event->tep;
4881
4882	if (field->flags & TEP_FIELD_IS_ARRAY) {
4883		offset = field->offset;
4884		len = field->size;
4885		if (field->flags & TEP_FIELD_IS_DYNAMIC) {
4886			val = tep_read_number(tep, data + offset, len);
4887			offset = val;
4888			len = offset >> 16;
4889			offset &= 0xffff;
4890		}
4891		if (field->flags & TEP_FIELD_IS_STRING &&
4892		    is_printable_array(data + offset, len)) {
4893			trace_seq_printf(s, "%s", (char *)data + offset);
4894		} else {
4895			trace_seq_puts(s, "ARRAY[");
4896			for (i = 0; i < len; i++) {
4897				if (i)
4898					trace_seq_puts(s, ", ");
4899				trace_seq_printf(s, "%02x",
4900						 *((unsigned char *)data + offset + i));
4901			}
4902			trace_seq_putc(s, ']');
4903			field->flags &= ~TEP_FIELD_IS_STRING;
4904		}
4905	} else {
4906		val = tep_read_number(tep, data + field->offset,
4907				      field->size);
4908		if (field->flags & TEP_FIELD_IS_POINTER) {
4909			trace_seq_printf(s, "0x%llx", val);
4910		} else if (field->flags & TEP_FIELD_IS_SIGNED) {
4911			switch (field->size) {
4912			case 4:
4913				/*
4914				 * If field is long then print it in hex.
4915				 * A long usually stores pointers.
4916				 */
4917				if (field->flags & TEP_FIELD_IS_LONG)
4918					trace_seq_printf(s, "0x%x", (int)val);
4919				else
4920					trace_seq_printf(s, "%d", (int)val);
4921				break;
4922			case 2:
4923				trace_seq_printf(s, "%2d", (short)val);
4924				break;
4925			case 1:
4926				trace_seq_printf(s, "%1d", (char)val);
4927				break;
4928			default:
4929				trace_seq_printf(s, "%lld", val);
4930			}
4931		} else {
4932			if (field->flags & TEP_FIELD_IS_LONG)
4933				trace_seq_printf(s, "0x%llx", val);
4934			else
4935				trace_seq_printf(s, "%llu", val);
4936		}
4937	}
4938}
4939
4940void tep_print_fields(struct trace_seq *s, void *data,
4941		      int size __maybe_unused, struct tep_event *event)
4942{
4943	struct tep_format_field *field;
4944
4945	field = event->format.fields;
4946	while (field) {
4947		trace_seq_printf(s, " %s=", field->name);
4948		tep_print_field(s, data, field);
4949		field = field->next;
4950	}
4951}
4952
4953static void pretty_print(struct trace_seq *s, void *data, int size, struct tep_event *event)
4954{
4955	struct tep_handle *tep = event->tep;
4956	struct tep_print_fmt *print_fmt = &event->print_fmt;
4957	struct tep_print_arg *arg = print_fmt->args;
4958	struct tep_print_arg *args = NULL;
4959	const char *ptr = print_fmt->format;
4960	unsigned long long val;
4961	struct func_map *func;
4962	const char *saveptr;
4963	struct trace_seq p;
4964	char *bprint_fmt = NULL;
4965	char format[32];
4966	int show_func;
4967	int len_as_arg;
4968	int len_arg = 0;
4969	int len;
4970	int ls;
4971
4972	if (event->flags & TEP_EVENT_FL_FAILED) {
4973		trace_seq_printf(s, "[FAILED TO PARSE]");
4974		tep_print_fields(s, data, size, event);
4975		return;
4976	}
4977
4978	if (event->flags & TEP_EVENT_FL_ISBPRINT) {
4979		bprint_fmt = get_bprint_format(data, size, event);
4980		args = make_bprint_args(bprint_fmt, data, size, event);
4981		arg = args;
4982		ptr = bprint_fmt;
4983	}
4984
4985	for (; *ptr; ptr++) {
4986		ls = 0;
4987		if (*ptr == '\\') {
4988			ptr++;
4989			switch (*ptr) {
4990			case 'n':
4991				trace_seq_putc(s, '\n');
4992				break;
4993			case 't':
4994				trace_seq_putc(s, '\t');
4995				break;
4996			case 'r':
4997				trace_seq_putc(s, '\r');
4998				break;
4999			case '\\':
5000				trace_seq_putc(s, '\\');
5001				break;
5002			default:
5003				trace_seq_putc(s, *ptr);
5004				break;
5005			}
5006
5007		} else if (*ptr == '%') {
5008			saveptr = ptr;
5009			show_func = 0;
5010			len_as_arg = 0;
5011 cont_process:
5012			ptr++;
5013			switch (*ptr) {
5014			case '%':
5015				trace_seq_putc(s, '%');
5016				break;
5017			case '#':
5018				/* FIXME: need to handle properly */
5019				goto cont_process;
5020			case 'h':
5021				ls--;
5022				goto cont_process;
5023			case 'l':
5024				ls++;
5025				goto cont_process;
5026			case 'L':
5027				ls = 2;
5028				goto cont_process;
5029			case '*':
5030				/* The argument is the length. */
5031				if (!arg) {
5032					do_warning_event(event, "no argument match");
5033					event->flags |= TEP_EVENT_FL_FAILED;
5034					goto out_failed;
5035				}
5036				len_arg = eval_num_arg(data, size, event, arg);
5037				len_as_arg = 1;
5038				arg = arg->next;
5039				goto cont_process;
5040			case '.':
5041			case 'z':
5042			case 'Z':
5043			case '0' ... '9':
5044			case '-':
5045				goto cont_process;
5046			case 'p':
5047				if (tep->long_size == 4)
5048					ls = 1;
5049				else
5050					ls = 2;
5051
5052				if (isalnum(ptr[1]))
5053					ptr++;
5054
5055				if (arg->type == TEP_PRINT_BSTRING) {
5056					trace_seq_puts(s, arg->string.string);
5057					arg = arg->next;
5058					break;
5059				}
5060
5061				if (*ptr == 'F' || *ptr == 'f' ||
5062				    *ptr == 'S' || *ptr == 's') {
5063					show_func = *ptr;
5064				} else if (*ptr == 'M' || *ptr == 'm') {
5065					print_mac_arg(s, *ptr, data, size, event, arg);
5066					arg = arg->next;
5067					break;
5068				} else if (*ptr == 'I' || *ptr == 'i') {
5069					int n;
5070
5071					n = print_ip_arg(s, ptr, data, size, event, arg);
5072					if (n > 0) {
5073						ptr += n - 1;
5074						arg = arg->next;
5075						break;
5076					}
5077				}
5078
5079				/* fall through */
5080			case 'd':
5081			case 'i':
5082			case 'x':
5083			case 'X':
5084			case 'u':
5085				if (!arg) {
5086					do_warning_event(event, "no argument match");
5087					event->flags |= TEP_EVENT_FL_FAILED;
5088					goto out_failed;
5089				}
5090
5091				len = ((unsigned long)ptr + 1) -
5092					(unsigned long)saveptr;
5093
5094				/* should never happen */
5095				if (len > 31) {
5096					do_warning_event(event, "bad format!");
5097					event->flags |= TEP_EVENT_FL_FAILED;
5098					len = 31;
5099				}
5100
5101				memcpy(format, saveptr, len);
5102				format[len] = 0;
5103
5104				val = eval_num_arg(data, size, event, arg);
5105				arg = arg->next;
5106
5107				if (show_func) {
5108					func = find_func(tep, val);
5109					if (func) {
5110						trace_seq_puts(s, func->func);
5111						if (show_func == 'F')
5112							trace_seq_printf(s,
5113							       "+0x%llx",
5114							       val - func->addr);
5115						break;
5116					}
5117				}
5118				if (tep->long_size == 8 && ls == 1 &&
5119				    sizeof(long) != 8) {
5120					char *p;
5121
5122					/* make %l into %ll */
5123					if (ls == 1 && (p = strchr(format, 'l')))
5124						memmove(p+1, p, strlen(p)+1);
5125					else if (strcmp(format, "%p") == 0)
5126						strcpy(format, "0x%llx");
5127					ls = 2;
5128				}
5129				switch (ls) {
5130				case -2:
5131					if (len_as_arg)
5132						trace_seq_printf(s, format, len_arg, (char)val);
5133					else
5134						trace_seq_printf(s, format, (char)val);
5135					break;
5136				case -1:
5137					if (len_as_arg)
5138						trace_seq_printf(s, format, len_arg, (short)val);
5139					else
5140						trace_seq_printf(s, format, (short)val);
5141					break;
5142				case 0:
5143					if (len_as_arg)
5144						trace_seq_printf(s, format, len_arg, (int)val);
5145					else
5146						trace_seq_printf(s, format, (int)val);
5147					break;
5148				case 1:
5149					if (len_as_arg)
5150						trace_seq_printf(s, format, len_arg, (long)val);
5151					else
5152						trace_seq_printf(s, format, (long)val);
5153					break;
5154				case 2:
5155					if (len_as_arg)
5156						trace_seq_printf(s, format, len_arg,
5157								 (long long)val);
5158					else
5159						trace_seq_printf(s, format, (long long)val);
5160					break;
5161				default:
5162					do_warning_event(event, "bad count (%d)", ls);
5163					event->flags |= TEP_EVENT_FL_FAILED;
5164				}
5165				break;
5166			case 's':
5167				if (!arg) {
5168					do_warning_event(event, "no matching argument");
5169					event->flags |= TEP_EVENT_FL_FAILED;
5170					goto out_failed;
5171				}
5172
5173				len = ((unsigned long)ptr + 1) -
5174					(unsigned long)saveptr;
5175
5176				/* should never happen */
5177				if (len > 31) {
5178					do_warning_event(event, "bad format!");
5179					event->flags |= TEP_EVENT_FL_FAILED;
5180					len = 31;
5181				}
5182
5183				memcpy(format, saveptr, len);
5184				format[len] = 0;
5185				if (!len_as_arg)
5186					len_arg = -1;
5187				/* Use helper trace_seq */
5188				trace_seq_init(&p);
5189				print_str_arg(&p, data, size, event,
5190					      format, len_arg, arg);
5191				trace_seq_terminate(&p);
5192				trace_seq_puts(s, p.buffer);
5193				trace_seq_destroy(&p);
5194				arg = arg->next;
5195				break;
5196			default:
5197				trace_seq_printf(s, ">%c<", *ptr);
5198
5199			}
5200		} else
5201			trace_seq_putc(s, *ptr);
5202	}
5203
5204	if (event->flags & TEP_EVENT_FL_FAILED) {
5205out_failed:
5206		trace_seq_printf(s, "[FAILED TO PARSE]");
5207	}
5208
5209	if (args) {
5210		free_args(args);
5211		free(bprint_fmt);
5212	}
5213}
5214
5215/*
5216 * This parses out the Latency format (interrupts disabled,
5217 * need rescheduling, in hard/soft interrupt, preempt count
5218 * and lock depth) and places it into the trace_seq.
5219 */
5220static void data_latency_format(struct tep_handle *tep, struct trace_seq *s,
5221				char *format, struct tep_record *record)
5222{
5223	static int check_lock_depth = 1;
5224	static int check_migrate_disable = 1;
5225	static int lock_depth_exists;
5226	static int migrate_disable_exists;
5227	unsigned int lat_flags;
5228	struct trace_seq sq;
5229	unsigned int pc;
5230	int lock_depth = 0;
5231	int migrate_disable = 0;
5232	int hardirq;
5233	int softirq;
5234	void *data = record->data;
5235
5236	trace_seq_init(&sq);
5237	lat_flags = parse_common_flags(tep, data);
5238	pc = parse_common_pc(tep, data);
5239	/* lock_depth may not always exist */
5240	if (lock_depth_exists)
5241		lock_depth = parse_common_lock_depth(tep, data);
5242	else if (check_lock_depth) {
5243		lock_depth = parse_common_lock_depth(tep, data);
5244		if (lock_depth < 0)
5245			check_lock_depth = 0;
5246		else
5247			lock_depth_exists = 1;
5248	}
5249
5250	/* migrate_disable may not always exist */
5251	if (migrate_disable_exists)
5252		migrate_disable = parse_common_migrate_disable(tep, data);
5253	else if (check_migrate_disable) {
5254		migrate_disable = parse_common_migrate_disable(tep, data);
5255		if (migrate_disable < 0)
5256			check_migrate_disable = 0;
5257		else
5258			migrate_disable_exists = 1;
5259	}
5260
5261	hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
5262	softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
5263
5264	trace_seq_printf(&sq, "%c%c%c",
5265	       (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
5266	       (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
5267	       'X' : '.',
5268	       (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
5269	       'N' : '.',
5270	       (hardirq && softirq) ? 'H' :
5271	       hardirq ? 'h' : softirq ? 's' : '.');
5272
5273	if (pc)
5274		trace_seq_printf(&sq, "%x", pc);
5275	else
5276		trace_seq_printf(&sq, ".");
5277
5278	if (migrate_disable_exists) {
5279		if (migrate_disable < 0)
5280			trace_seq_printf(&sq, ".");
5281		else
5282			trace_seq_printf(&sq, "%d", migrate_disable);
5283	}
5284
5285	if (lock_depth_exists) {
5286		if (lock_depth < 0)
5287			trace_seq_printf(&sq, ".");
5288		else
5289			trace_seq_printf(&sq, "%d", lock_depth);
5290	}
5291
5292	if (sq.state == TRACE_SEQ__MEM_ALLOC_FAILED) {
5293		s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
5294		return;
5295	}
5296
5297	trace_seq_terminate(&sq);
5298	trace_seq_puts(s, sq.buffer);
5299	trace_seq_destroy(&sq);
5300	trace_seq_terminate(s);
5301}
5302
5303/**
5304 * tep_data_type - parse out the given event type
5305 * @tep: a handle to the trace event parser context
5306 * @rec: the record to read from
5307 *
5308 * This returns the event id from the @rec.
5309 */
5310int tep_data_type(struct tep_handle *tep, struct tep_record *rec)
5311{
5312	return trace_parse_common_type(tep, rec->data);
5313}
5314
5315/**
5316 * tep_data_pid - parse the PID from record
5317 * @tep: a handle to the trace event parser context
5318 * @rec: the record to parse
5319 *
5320 * This returns the PID from a record.
5321 */
5322int tep_data_pid(struct tep_handle *tep, struct tep_record *rec)
5323{
5324	return parse_common_pid(tep, rec->data);
5325}
5326
5327/**
5328 * tep_data_preempt_count - parse the preempt count from the record
5329 * @tep: a handle to the trace event parser context
5330 * @rec: the record to parse
5331 *
5332 * This returns the preempt count from a record.
5333 */
5334int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec)
5335{
5336	return parse_common_pc(tep, rec->data);
5337}
5338
5339/**
5340 * tep_data_flags - parse the latency flags from the record
5341 * @tep: a handle to the trace event parser context
5342 * @rec: the record to parse
5343 *
5344 * This returns the latency flags from a record.
5345 *
5346 *  Use trace_flag_type enum for the flags (see event-parse.h).
5347 */
5348int tep_data_flags(struct tep_handle *tep, struct tep_record *rec)
5349{
5350	return parse_common_flags(tep, rec->data);
5351}
5352
5353/**
5354 * tep_data_comm_from_pid - return the command line from PID
5355 * @tep: a handle to the trace event parser context
5356 * @pid: the PID of the task to search for
5357 *
5358 * This returns a pointer to the command line that has the given
5359 * @pid.
5360 */
5361const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid)
5362{
5363	const char *comm;
5364
5365	comm = find_cmdline(tep, pid);
5366	return comm;
5367}
5368
5369static struct tep_cmdline *
5370pid_from_cmdlist(struct tep_handle *tep, const char *comm, struct tep_cmdline *next)
5371{
5372	struct cmdline_list *cmdlist = (struct cmdline_list *)next;
5373
5374	if (cmdlist)
5375		cmdlist = cmdlist->next;
5376	else
5377		cmdlist = tep->cmdlist;
5378
5379	while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
5380		cmdlist = cmdlist->next;
5381
5382	return (struct tep_cmdline *)cmdlist;
5383}
5384
5385/**
5386 * tep_data_pid_from_comm - return the pid from a given comm
5387 * @tep: a handle to the trace event parser context
5388 * @comm: the cmdline to find the pid from
5389 * @next: the cmdline structure to find the next comm
5390 *
5391 * This returns the cmdline structure that holds a pid for a given
5392 * comm, or NULL if none found. As there may be more than one pid for
5393 * a given comm, the result of this call can be passed back into
5394 * a recurring call in the @next parameter, and then it will find the
5395 * next pid.
5396 * Also, it does a linear search, so it may be slow.
5397 */
5398struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm,
5399					   struct tep_cmdline *next)
5400{
5401	struct tep_cmdline *cmdline;
5402
5403	/*
5404	 * If the cmdlines have not been converted yet, then use
5405	 * the list.
5406	 */
5407	if (!tep->cmdlines)
5408		return pid_from_cmdlist(tep, comm, next);
5409
5410	if (next) {
5411		/*
5412		 * The next pointer could have been still from
5413		 * a previous call before cmdlines were created
5414		 */
5415		if (next < tep->cmdlines ||
5416		    next >= tep->cmdlines + tep->cmdline_count)
5417			next = NULL;
5418		else
5419			cmdline  = next++;
5420	}
5421
5422	if (!next)
5423		cmdline = tep->cmdlines;
5424
5425	while (cmdline < tep->cmdlines + tep->cmdline_count) {
5426		if (strcmp(cmdline->comm, comm) == 0)
5427			return cmdline;
5428		cmdline++;
5429	}
5430	return NULL;
5431}
5432
5433/**
5434 * tep_cmdline_pid - return the pid associated to a given cmdline
5435 * @tep: a handle to the trace event parser context
5436 * @cmdline: The cmdline structure to get the pid from
5437 *
5438 * Returns the pid for a give cmdline. If @cmdline is NULL, then
5439 * -1 is returned.
5440 */
5441int tep_cmdline_pid(struct tep_handle *tep, struct tep_cmdline *cmdline)
5442{
5443	struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
5444
5445	if (!cmdline)
5446		return -1;
5447
5448	/*
5449	 * If cmdlines have not been created yet, or cmdline is
5450	 * not part of the array, then treat it as a cmdlist instead.
5451	 */
5452	if (!tep->cmdlines ||
5453	    cmdline < tep->cmdlines ||
5454	    cmdline >= tep->cmdlines + tep->cmdline_count)
5455		return cmdlist->pid;
5456
5457	return cmdline->pid;
5458}
5459
5460/*
5461 * This parses the raw @data using the given @event information and
5462 * writes the print format into the trace_seq.
5463 */
5464static void print_event_info(struct trace_seq *s, char *format, bool raw,
5465			     struct tep_event *event, struct tep_record *record)
5466{
5467	int print_pretty = 1;
5468
5469	if (raw || (event->flags & TEP_EVENT_FL_PRINTRAW))
5470		tep_print_fields(s, record->data, record->size, event);
5471	else {
5472
5473		if (event->handler && !(event->flags & TEP_EVENT_FL_NOHANDLE))
5474			print_pretty = event->handler(s, record, event,
5475						      event->context);
5476
5477		if (print_pretty)
5478			pretty_print(s, record->data, record->size, event);
5479	}
5480
5481	trace_seq_terminate(s);
5482}
5483
5484/**
5485 * tep_find_event_by_record - return the event from a given record
5486 * @tep: a handle to the trace event parser context
5487 * @record: The record to get the event from
5488 *
5489 * Returns the associated event for a given record, or NULL if non is
5490 * is found.
5491 */
5492struct tep_event *
5493tep_find_event_by_record(struct tep_handle *tep, struct tep_record *record)
5494{
5495	int type;
5496
5497	if (record->size < 0) {
5498		do_warning("ug! negative record size %d", record->size);
5499		return NULL;
5500	}
5501
5502	type = trace_parse_common_type(tep, record->data);
5503
5504	return tep_find_event(tep, type);
5505}
5506
5507/*
5508 * Writes the timestamp of the record into @s. Time divisor and precision can be
5509 * specified as part of printf @format string. Example:
5510 *	"%3.1000d" - divide the time by 1000 and print the first 3 digits
5511 *	before the dot. Thus, the timestamp "123456000" will be printed as
5512 *	"123.456"
5513 */
5514static void print_event_time(struct tep_handle *tep, struct trace_seq *s,
5515				 char *format, struct tep_event *event,
5516				 struct tep_record *record)
5517{
5518	unsigned long long time;
5519	char *divstr;
5520	int prec = 0, pr;
5521	int div = 0;
5522	int p10 = 1;
5523
5524	if (isdigit(*(format + 1)))
5525		prec = atoi(format + 1);
5526	divstr = strchr(format, '.');
5527	if (divstr && isdigit(*(divstr + 1)))
5528		div = atoi(divstr + 1);
5529	time = record->ts;
5530	if (div) {
5531		time += div / 2;
5532		time /= div;
5533	}
5534	pr = prec;
5535	while (pr--)
5536		p10 *= 10;
5537
5538	if (p10 > 1 && p10 < time)
5539		trace_seq_printf(s, "%5llu.%0*llu", time / p10, prec, time % p10);
5540	else
5541		trace_seq_printf(s, "%12llu\n", time);
5542}
5543
5544struct print_event_type {
5545	enum {
5546		EVENT_TYPE_INT = 1,
5547		EVENT_TYPE_STRING,
5548		EVENT_TYPE_UNKNOWN,
5549	} type;
5550	char format[32];
5551};
5552
5553static void print_string(struct tep_handle *tep, struct trace_seq *s,
5554			 struct tep_record *record, struct tep_event *event,
5555			 const char *arg, struct print_event_type *type)
5556{
5557	const char *comm;
5558	int pid;
5559
5560	if (strncmp(arg, TEP_PRINT_LATENCY, strlen(TEP_PRINT_LATENCY)) == 0) {
5561		data_latency_format(tep, s, type->format, record);
5562	} else if (strncmp(arg, TEP_PRINT_COMM, strlen(TEP_PRINT_COMM)) == 0) {
5563		pid = parse_common_pid(tep, record->data);
5564		comm = find_cmdline(tep, pid);
5565		trace_seq_printf(s, type->format, comm);
5566	} else if (strncmp(arg, TEP_PRINT_INFO_RAW, strlen(TEP_PRINT_INFO_RAW)) == 0) {
5567		print_event_info(s, type->format, true, event, record);
5568	} else if (strncmp(arg, TEP_PRINT_INFO, strlen(TEP_PRINT_INFO)) == 0) {
5569		print_event_info(s, type->format, false, event, record);
5570	} else if  (strncmp(arg, TEP_PRINT_NAME, strlen(TEP_PRINT_NAME)) == 0) {
5571		trace_seq_printf(s, type->format, event->name);
5572	} else {
5573		trace_seq_printf(s, "[UNKNOWN TEP TYPE %s]", arg);
5574	}
5575
5576}
5577
5578static void print_int(struct tep_handle *tep, struct trace_seq *s,
5579		      struct tep_record *record, struct tep_event *event,
5580		      int arg, struct print_event_type *type)
5581{
5582	int param;
5583
5584	switch (arg) {
5585	case TEP_PRINT_CPU:
5586		param = record->cpu;
5587		break;
5588	case TEP_PRINT_PID:
5589		param = parse_common_pid(tep, record->data);
5590		break;
5591	case TEP_PRINT_TIME:
5592		return print_event_time(tep, s, type->format, event, record);
5593	default:
5594		return;
5595	}
5596	trace_seq_printf(s, type->format, param);
5597}
5598
5599static int tep_print_event_param_type(char *format,
5600				      struct print_event_type *type)
5601{
5602	char *str = format + 1;
5603	int i = 1;
5604
5605	type->type = EVENT_TYPE_UNKNOWN;
5606	while (*str) {
5607		switch (*str) {
5608		case 'd':
5609		case 'u':
5610		case 'i':
5611		case 'x':
5612		case 'X':
5613		case 'o':
5614			type->type = EVENT_TYPE_INT;
5615			break;
5616		case 's':
5617			type->type = EVENT_TYPE_STRING;
5618			break;
5619		}
5620		str++;
5621		i++;
5622		if (type->type != EVENT_TYPE_UNKNOWN)
5623			break;
5624	}
5625	memset(type->format, 0, 32);
5626	memcpy(type->format, format, i < 32 ? i : 31);
5627	return i;
5628}
5629
5630/**
5631 * tep_print_event - Write various event information
5632 * @tep: a handle to the trace event parser context
5633 * @s: the trace_seq to write to
5634 * @record: The record to get the event from
5635 * @format: a printf format string. Supported event fileds:
5636 *	TEP_PRINT_PID, "%d" - event PID
5637 *	TEP_PRINT_CPU, "%d" - event CPU
5638 *	TEP_PRINT_COMM, "%s" - event command string
5639 *	TEP_PRINT_NAME, "%s" - event name
5640 *	TEP_PRINT_LATENCY, "%s" - event latency
5641 *	TEP_PRINT_TIME, %d - event time stamp. A divisor and precision
5642 *			can be specified as part of this format string:
5643 *			"%precision.divisord". Example:
5644 *			"%3.1000d" - divide the time by 1000 and print the first
5645 *			3 digits before the dot. Thus, the time stamp
5646 *			"123456000" will be printed as "123.456"
5647 *	TEP_PRINT_INFO, "%s" - event information. If any width is specified in
5648 *			the format string, the event information will be printed
5649 *			in raw format.
5650 * Writes the specified event information into @s.
5651 */
5652void tep_print_event(struct tep_handle *tep, struct trace_seq *s,
5653		     struct tep_record *record, const char *fmt, ...)
5654{
5655	struct print_event_type type;
5656	char *format = strdup(fmt);
5657	char *current = format;
5658	char *str = format;
5659	int offset;
5660	va_list args;
5661	struct tep_event *event;
5662
5663	if (!format)
5664		return;
5665
5666	event = tep_find_event_by_record(tep, record);
5667	va_start(args, fmt);
5668	while (*current) {
5669		current = strchr(str, '%');
5670		if (!current) {
5671			trace_seq_puts(s, str);
5672			break;
5673		}
5674		memset(&type, 0, sizeof(type));
5675		offset = tep_print_event_param_type(current, &type);
5676		*current = '\0';
5677		trace_seq_puts(s, str);
5678		current += offset;
5679		switch (type.type) {
5680		case EVENT_TYPE_STRING:
5681			print_string(tep, s, record, event,
5682				     va_arg(args, char*), &type);
5683			break;
5684		case EVENT_TYPE_INT:
5685			print_int(tep, s, record, event,
5686				  va_arg(args, int), &type);
5687			break;
5688		case EVENT_TYPE_UNKNOWN:
5689		default:
5690			trace_seq_printf(s, "[UNKNOWN TYPE]");
5691			break;
5692		}
5693		str = current;
5694
5695	}
5696	va_end(args);
5697	free(format);
5698}
5699
5700static int events_id_cmp(const void *a, const void *b)
5701{
5702	struct tep_event * const * ea = a;
5703	struct tep_event * const * eb = b;
5704
5705	if ((*ea)->id < (*eb)->id)
5706		return -1;
5707
5708	if ((*ea)->id > (*eb)->id)
5709		return 1;
5710
5711	return 0;
5712}
5713
5714static int events_name_cmp(const void *a, const void *b)
5715{
5716	struct tep_event * const * ea = a;
5717	struct tep_event * const * eb = b;
5718	int res;
5719
5720	res = strcmp((*ea)->name, (*eb)->name);
5721	if (res)
5722		return res;
5723
5724	res = strcmp((*ea)->system, (*eb)->system);
5725	if (res)
5726		return res;
5727
5728	return events_id_cmp(a, b);
5729}
5730
5731static int events_system_cmp(const void *a, const void *b)
5732{
5733	struct tep_event * const * ea = a;
5734	struct tep_event * const * eb = b;
5735	int res;
5736
5737	res = strcmp((*ea)->system, (*eb)->system);
5738	if (res)
5739		return res;
5740
5741	res = strcmp((*ea)->name, (*eb)->name);
5742	if (res)
5743		return res;
5744
5745	return events_id_cmp(a, b);
5746}
5747
5748static struct tep_event **list_events_copy(struct tep_handle *tep)
5749{
5750	struct tep_event **events;
5751
5752	if (!tep)
5753		return NULL;
5754
5755	events = malloc(sizeof(*events) * (tep->nr_events + 1));
5756	if (!events)
5757		return NULL;
5758
5759	memcpy(events, tep->events, sizeof(*events) * tep->nr_events);
5760	events[tep->nr_events] = NULL;
5761	return events;
5762}
5763
5764static void list_events_sort(struct tep_event **events, int nr_events,
5765			     enum tep_event_sort_type sort_type)
5766{
5767	int (*sort)(const void *a, const void *b);
5768
5769	switch (sort_type) {
5770	case TEP_EVENT_SORT_ID:
5771		sort = events_id_cmp;
5772		break;
5773	case TEP_EVENT_SORT_NAME:
5774		sort = events_name_cmp;
5775		break;
5776	case TEP_EVENT_SORT_SYSTEM:
5777		sort = events_system_cmp;
5778		break;
5779	default:
5780		sort = NULL;
5781	}
5782
5783	if (sort)
5784		qsort(events, nr_events, sizeof(*events), sort);
5785}
5786
5787/**
5788 * tep_list_events - Get events, sorted by given criteria.
5789 * @tep: a handle to the tep context
5790 * @sort_type: desired sort order of the events in the array
5791 *
5792 * Returns an array of pointers to all events, sorted by the given
5793 * @sort_type criteria. The last element of the array is NULL. The returned
5794 * memory must not be freed, it is managed by the library.
5795 * The function is not thread safe.
5796 */
5797struct tep_event **tep_list_events(struct tep_handle *tep,
5798				   enum tep_event_sort_type sort_type)
5799{
5800	struct tep_event **events;
5801
5802	if (!tep)
5803		return NULL;
5804
5805	events = tep->sort_events;
5806	if (events && tep->last_type == sort_type)
5807		return events;
5808
5809	if (!events) {
5810		events = list_events_copy(tep);
5811		if (!events)
5812			return NULL;
5813
5814		tep->sort_events = events;
5815
5816		/* the internal events are sorted by id */
5817		if (sort_type == TEP_EVENT_SORT_ID) {
5818			tep->last_type = sort_type;
5819			return events;
5820		}
5821	}
5822
5823	list_events_sort(events, tep->nr_events, sort_type);
5824	tep->last_type = sort_type;
5825
5826	return events;
5827}
5828
5829
5830/**
5831 * tep_list_events_copy - Thread safe version of tep_list_events()
5832 * @tep: a handle to the tep context
5833 * @sort_type: desired sort order of the events in the array
5834 *
5835 * Returns an array of pointers to all events, sorted by the given
5836 * @sort_type criteria. The last element of the array is NULL. The returned
5837 * array is newly allocated inside the function and must be freed by the caller
5838 */
5839struct tep_event **tep_list_events_copy(struct tep_handle *tep,
5840					enum tep_event_sort_type sort_type)
5841{
5842	struct tep_event **events;
5843
5844	if (!tep)
5845		return NULL;
5846
5847	events = list_events_copy(tep);
5848	if (!events)
5849		return NULL;
5850
5851	/* the internal events are sorted by id */
5852	if (sort_type == TEP_EVENT_SORT_ID)
5853		return events;
5854
5855	list_events_sort(events, tep->nr_events, sort_type);
5856
5857	return events;
5858}
5859
5860static struct tep_format_field **
5861get_event_fields(const char *type, const char *name,
5862		 int count, struct tep_format_field *list)
5863{
5864	struct tep_format_field **fields;
5865	struct tep_format_field *field;
5866	int i = 0;
5867
5868	fields = malloc(sizeof(*fields) * (count + 1));
5869	if (!fields)
5870		return NULL;
5871
5872	for (field = list; field; field = field->next) {
5873		fields[i++] = field;
5874		if (i == count + 1) {
5875			do_warning("event %s has more %s fields than specified",
5876				name, type);
5877			i--;
5878			break;
5879		}
5880	}
5881
5882	if (i != count)
5883		do_warning("event %s has less %s fields than specified",
5884			name, type);
5885
5886	fields[i] = NULL;
5887
5888	return fields;
5889}
5890
5891/**
5892 * tep_event_common_fields - return a list of common fields for an event
5893 * @event: the event to return the common fields of.
5894 *
5895 * Returns an allocated array of fields. The last item in the array is NULL.
5896 * The array must be freed with free().
5897 */
5898struct tep_format_field **tep_event_common_fields(struct tep_event *event)
5899{
5900	return get_event_fields("common", event->name,
5901				event->format.nr_common,
5902				event->format.common_fields);
5903}
5904
5905/**
5906 * tep_event_fields - return a list of event specific fields for an event
5907 * @event: the event to return the fields of.
5908 *
5909 * Returns an allocated array of fields. The last item in the array is NULL.
5910 * The array must be freed with free().
5911 */
5912struct tep_format_field **tep_event_fields(struct tep_event *event)
5913{
5914	return get_event_fields("event", event->name,
5915				event->format.nr_fields,
5916				event->format.fields);
5917}
5918
5919static void print_fields(struct trace_seq *s, struct tep_print_flag_sym *field)
5920{
5921	trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
5922	if (field->next) {
5923		trace_seq_puts(s, ", ");
5924		print_fields(s, field->next);
5925	}
5926}
5927
5928/* for debugging */
5929static void print_args(struct tep_print_arg *args)
5930{
5931	int print_paren = 1;
5932	struct trace_seq s;
5933
5934	switch (args->type) {
5935	case TEP_PRINT_NULL:
5936		printf("null");
5937		break;
5938	case TEP_PRINT_ATOM:
5939		printf("%s", args->atom.atom);
5940		break;
5941	case TEP_PRINT_FIELD:
5942		printf("REC->%s", args->field.name);
5943		break;
5944	case TEP_PRINT_FLAGS:
5945		printf("__print_flags(");
5946		print_args(args->flags.field);
5947		printf(", %s, ", args->flags.delim);
5948		trace_seq_init(&s);
5949		print_fields(&s, args->flags.flags);
5950		trace_seq_do_printf(&s);
5951		trace_seq_destroy(&s);
5952		printf(")");
5953		break;
5954	case TEP_PRINT_SYMBOL:
5955		printf("__print_symbolic(");
5956		print_args(args->symbol.field);
5957		printf(", ");
5958		trace_seq_init(&s);
5959		print_fields(&s, args->symbol.symbols);
5960		trace_seq_do_printf(&s);
5961		trace_seq_destroy(&s);
5962		printf(")");
5963		break;
5964	case TEP_PRINT_HEX:
5965		printf("__print_hex(");
5966		print_args(args->hex.field);
5967		printf(", ");
5968		print_args(args->hex.size);
5969		printf(")");
5970		break;
5971	case TEP_PRINT_HEX_STR:
5972		printf("__print_hex_str(");
5973		print_args(args->hex.field);
5974		printf(", ");
5975		print_args(args->hex.size);
5976		printf(")");
5977		break;
5978	case TEP_PRINT_INT_ARRAY:
5979		printf("__print_array(");
5980		print_args(args->int_array.field);
5981		printf(", ");
5982		print_args(args->int_array.count);
5983		printf(", ");
5984		print_args(args->int_array.el_size);
5985		printf(")");
5986		break;
5987	case TEP_PRINT_STRING:
5988	case TEP_PRINT_BSTRING:
5989		printf("__get_str(%s)", args->string.string);
5990		break;
5991	case TEP_PRINT_BITMASK:
5992		printf("__get_bitmask(%s)", args->bitmask.bitmask);
5993		break;
5994	case TEP_PRINT_TYPE:
5995		printf("(%s)", args->typecast.type);
5996		print_args(args->typecast.item);
5997		break;
5998	case TEP_PRINT_OP:
5999		if (strcmp(args->op.op, ":") == 0)
6000			print_paren = 0;
6001		if (print_paren)
6002			printf("(");
6003		print_args(args->op.left);
6004		printf(" %s ", args->op.op);
6005		print_args(args->op.right);
6006		if (print_paren)
6007			printf(")");
6008		break;
6009	default:
6010		/* we should warn... */
6011		return;
6012	}
6013	if (args->next) {
6014		printf("\n");
6015		print_args(args->next);
6016	}
6017}
6018
6019static void parse_header_field(const char *field,
6020			       int *offset, int *size, int mandatory)
6021{
6022	unsigned long long save_input_buf_ptr;
6023	unsigned long long save_input_buf_siz;
6024	char *token;
6025	int type;
6026
6027	save_input_buf_ptr = input_buf_ptr;
6028	save_input_buf_siz = input_buf_siz;
6029
6030	if (read_expected(TEP_EVENT_ITEM, "field") < 0)
6031		return;
6032	if (read_expected(TEP_EVENT_OP, ":") < 0)
6033		return;
6034
6035	/* type */
6036	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6037		goto fail;
6038	free_token(token);
6039
6040	/*
6041	 * If this is not a mandatory field, then test it first.
6042	 */
6043	if (mandatory) {
6044		if (read_expected(TEP_EVENT_ITEM, field) < 0)
6045			return;
6046	} else {
6047		if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6048			goto fail;
6049		if (strcmp(token, field) != 0)
6050			goto discard;
6051		free_token(token);
6052	}
6053
6054	if (read_expected(TEP_EVENT_OP, ";") < 0)
6055		return;
6056	if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
6057		return;
6058	if (read_expected(TEP_EVENT_OP, ":") < 0)
6059		return;
6060	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6061		goto fail;
6062	*offset = atoi(token);
6063	free_token(token);
6064	if (read_expected(TEP_EVENT_OP, ";") < 0)
6065		return;
6066	if (read_expected(TEP_EVENT_ITEM, "size") < 0)
6067		return;
6068	if (read_expected(TEP_EVENT_OP, ":") < 0)
6069		return;
6070	if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6071		goto fail;
6072	*size = atoi(token);
6073	free_token(token);
6074	if (read_expected(TEP_EVENT_OP, ";") < 0)
6075		return;
6076	type = read_token(&token);
6077	if (type != TEP_EVENT_NEWLINE) {
6078		/* newer versions of the kernel have a "signed" type */
6079		if (type != TEP_EVENT_ITEM)
6080			goto fail;
6081
6082		if (strcmp(token, "signed") != 0)
6083			goto fail;
6084
6085		free_token(token);
6086
6087		if (read_expected(TEP_EVENT_OP, ":") < 0)
6088			return;
6089
6090		if (read_expect_type(TEP_EVENT_ITEM, &token))
6091			goto fail;
6092
6093		free_token(token);
6094		if (read_expected(TEP_EVENT_OP, ";") < 0)
6095			return;
6096
6097		if (read_expect_type(TEP_EVENT_NEWLINE, &token))
6098			goto fail;
6099	}
6100 fail:
6101	free_token(token);
6102	return;
6103
6104 discard:
6105	input_buf_ptr = save_input_buf_ptr;
6106	input_buf_siz = save_input_buf_siz;
6107	*offset = 0;
6108	*size = 0;
6109	free_token(token);
6110}
6111
6112/**
6113 * tep_parse_header_page - parse the data stored in the header page
6114 * @tep: a handle to the trace event parser context
6115 * @buf: the buffer storing the header page format string
6116 * @size: the size of @buf
6117 * @long_size: the long size to use if there is no header
6118 *
6119 * This parses the header page format for information on the
6120 * ring buffer used. The @buf should be copied from
6121 *
6122 * /sys/kernel/debug/tracing/events/header_page
6123 */
6124int tep_parse_header_page(struct tep_handle *tep, char *buf, unsigned long size,
6125			  int long_size)
6126{
6127	int ignore;
6128
6129	if (!size) {
6130		/*
6131		 * Old kernels did not have header page info.
6132		 * Sorry but we just use what we find here in user space.
6133		 */
6134		tep->header_page_ts_size = sizeof(long long);
6135		tep->header_page_size_size = long_size;
6136		tep->header_page_data_offset = sizeof(long long) + long_size;
6137		tep->old_format = 1;
6138		return -1;
6139	}
6140	init_input_buf(buf, size);
6141
6142	parse_header_field("timestamp", &tep->header_page_ts_offset,
6143			   &tep->header_page_ts_size, 1);
6144	parse_header_field("commit", &tep->header_page_size_offset,
6145			   &tep->header_page_size_size, 1);
6146	parse_header_field("overwrite", &tep->header_page_overwrite,
6147			   &ignore, 0);
6148	parse_header_field("data", &tep->header_page_data_offset,
6149			   &tep->header_page_data_size, 1);
6150
6151	return 0;
6152}
6153
6154static int event_matches(struct tep_event *event,
6155			 int id, const char *sys_name,
6156			 const char *event_name)
6157{
6158	if (id >= 0 && id != event->id)
6159		return 0;
6160
6161	if (event_name && (strcmp(event_name, event->name) != 0))
6162		return 0;
6163
6164	if (sys_name && (strcmp(sys_name, event->system) != 0))
6165		return 0;
6166
6167	return 1;
6168}
6169
6170static void free_handler(struct event_handler *handle)
6171{
6172	free((void *)handle->sys_name);
6173	free((void *)handle->event_name);
6174	free(handle);
6175}
6176
6177static int find_event_handle(struct tep_handle *tep, struct tep_event *event)
6178{
6179	struct event_handler *handle, **next;
6180
6181	for (next = &tep->handlers; *next;
6182	     next = &(*next)->next) {
6183		handle = *next;
6184		if (event_matches(event, handle->id,
6185				  handle->sys_name,
6186				  handle->event_name))
6187			break;
6188	}
6189
6190	if (!(*next))
6191		return 0;
6192
6193	pr_stat("overriding event (%d) %s:%s with new print handler",
6194		event->id, event->system, event->name);
6195
6196	event->handler = handle->func;
6197	event->context = handle->context;
6198
6199	*next = handle->next;
6200	free_handler(handle);
6201
6202	return 1;
6203}
6204
6205/**
6206 * __tep_parse_format - parse the event format
6207 * @buf: the buffer storing the event format string
6208 * @size: the size of @buf
6209 * @sys: the system the event belongs to
6210 *
6211 * This parses the event format and creates an event structure
6212 * to quickly parse raw data for a given event.
6213 *
6214 * These files currently come from:
6215 *
6216 * /sys/kernel/debug/tracing/events/.../.../format
6217 */
6218enum tep_errno __tep_parse_format(struct tep_event **eventp,
6219				  struct tep_handle *tep, const char *buf,
6220				  unsigned long size, const char *sys)
6221{
6222	struct tep_event *event;
6223	int ret;
6224
6225	init_input_buf(buf, size);
6226
6227	*eventp = event = alloc_event();
6228	if (!event)
6229		return TEP_ERRNO__MEM_ALLOC_FAILED;
6230
6231	event->name = event_read_name();
6232	if (!event->name) {
6233		/* Bad event? */
6234		ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6235		goto event_alloc_failed;
6236	}
6237
6238	if (strcmp(sys, "ftrace") == 0) {
6239		event->flags |= TEP_EVENT_FL_ISFTRACE;
6240
6241		if (strcmp(event->name, "bprint") == 0)
6242			event->flags |= TEP_EVENT_FL_ISBPRINT;
6243	}
6244		
6245	event->id = event_read_id();
6246	if (event->id < 0) {
6247		ret = TEP_ERRNO__READ_ID_FAILED;
6248		/*
6249		 * This isn't an allocation error actually.
6250		 * But as the ID is critical, just bail out.
6251		 */
6252		goto event_alloc_failed;
6253	}
6254
6255	event->system = strdup(sys);
6256	if (!event->system) {
6257		ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6258		goto event_alloc_failed;
6259	}
6260
6261	/* Add tep to event so that it can be referenced */
6262	event->tep = tep;
6263
6264	ret = event_read_format(event);
6265	if (ret < 0) {
6266		ret = TEP_ERRNO__READ_FORMAT_FAILED;
6267		goto event_parse_failed;
6268	}
6269
6270	/*
6271	 * If the event has an override, don't print warnings if the event
6272	 * print format fails to parse.
6273	 */
6274	if (tep && find_event_handle(tep, event))
6275		show_warning = 0;
6276
6277	ret = event_read_print(event);
6278	show_warning = 1;
6279
6280	if (ret < 0) {
6281		ret = TEP_ERRNO__READ_PRINT_FAILED;
6282		goto event_parse_failed;
6283	}
6284
6285	if (!ret && (event->flags & TEP_EVENT_FL_ISFTRACE)) {
6286		struct tep_format_field *field;
6287		struct tep_print_arg *arg, **list;
6288
6289		/* old ftrace had no args */
6290		list = &event->print_fmt.args;
6291		for (field = event->format.fields; field; field = field->next) {
6292			arg = alloc_arg();
6293			if (!arg) {
6294				event->flags |= TEP_EVENT_FL_FAILED;
6295				return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6296			}
6297			arg->type = TEP_PRINT_FIELD;
6298			arg->field.name = strdup(field->name);
6299			if (!arg->field.name) {
6300				event->flags |= TEP_EVENT_FL_FAILED;
6301				free_arg(arg);
6302				return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6303			}
6304			arg->field.field = field;
6305			*list = arg;
6306			list = &arg->next;
6307		}
6308		return 0;
6309	}
6310
6311	return 0;
6312
6313 event_parse_failed:
6314	event->flags |= TEP_EVENT_FL_FAILED;
6315	return ret;
6316
6317 event_alloc_failed:
6318	free(event->system);
6319	free(event->name);
6320	free(event);
6321	*eventp = NULL;
6322	return ret;
6323}
6324
6325static enum tep_errno
6326__parse_event(struct tep_handle *tep,
6327	      struct tep_event **eventp,
6328	      const char *buf, unsigned long size,
6329	      const char *sys)
6330{
6331	int ret = __tep_parse_format(eventp, tep, buf, size, sys);
6332	struct tep_event *event = *eventp;
6333
6334	if (event == NULL)
6335		return ret;
6336
6337	if (tep && add_event(tep, event)) {
6338		ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6339		goto event_add_failed;
6340	}
6341
6342#define PRINT_ARGS 0
6343	if (PRINT_ARGS && event->print_fmt.args)
6344		print_args(event->print_fmt.args);
6345
6346	return 0;
6347
6348event_add_failed:
6349	tep_free_event(event);
6350	return ret;
6351}
6352
6353/**
6354 * tep_parse_format - parse the event format
6355 * @tep: a handle to the trace event parser context
6356 * @eventp: returned format
6357 * @buf: the buffer storing the event format string
6358 * @size: the size of @buf
6359 * @sys: the system the event belongs to
6360 *
6361 * This parses the event format and creates an event structure
6362 * to quickly parse raw data for a given event.
6363 *
6364 * These files currently come from:
6365 *
6366 * /sys/kernel/debug/tracing/events/.../.../format
6367 */
6368enum tep_errno tep_parse_format(struct tep_handle *tep,
6369				struct tep_event **eventp,
6370				const char *buf,
6371				unsigned long size, const char *sys)
6372{
6373	return __parse_event(tep, eventp, buf, size, sys);
6374}
6375
6376/**
6377 * tep_parse_event - parse the event format
6378 * @tep: a handle to the trace event parser context
6379 * @buf: the buffer storing the event format string
6380 * @size: the size of @buf
6381 * @sys: the system the event belongs to
6382 *
6383 * This parses the event format and creates an event structure
6384 * to quickly parse raw data for a given event.
6385 *
6386 * These files currently come from:
6387 *
6388 * /sys/kernel/debug/tracing/events/.../.../format
6389 */
6390enum tep_errno tep_parse_event(struct tep_handle *tep, const char *buf,
6391			       unsigned long size, const char *sys)
6392{
6393	struct tep_event *event = NULL;
6394	return __parse_event(tep, &event, buf, size, sys);
6395}
6396
6397int get_field_val(struct trace_seq *s, struct tep_format_field *field,
6398		  const char *name, struct tep_record *record,
6399		  unsigned long long *val, int err)
6400{
6401	if (!field) {
6402		if (err)
6403			trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6404		return -1;
6405	}
6406
6407	if (tep_read_number_field(field, record->data, val)) {
6408		if (err)
6409			trace_seq_printf(s, " %s=INVALID", name);
6410		return -1;
6411	}
6412
6413	return 0;
6414}
6415
6416/**
6417 * tep_get_field_raw - return the raw pointer into the data field
6418 * @s: The seq to print to on error
6419 * @event: the event that the field is for
6420 * @name: The name of the field
6421 * @record: The record with the field name.
6422 * @len: place to store the field length.
6423 * @err: print default error if failed.
6424 *
6425 * Returns a pointer into record->data of the field and places
6426 * the length of the field in @len.
6427 *
6428 * On failure, it returns NULL.
6429 */
6430void *tep_get_field_raw(struct trace_seq *s, struct tep_event *event,
6431			const char *name, struct tep_record *record,
6432			int *len, int err)
6433{
6434	struct tep_format_field *field;
6435	void *data = record->data;
6436	unsigned offset;
6437	int dummy;
6438
6439	if (!event)
6440		return NULL;
6441
6442	field = tep_find_field(event, name);
6443
6444	if (!field) {
6445		if (err)
6446			trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6447		return NULL;
6448	}
6449
6450	/* Allow @len to be NULL */
6451	if (!len)
6452		len = &dummy;
6453
6454	offset = field->offset;
6455	if (field->flags & TEP_FIELD_IS_DYNAMIC) {
6456		offset = tep_read_number(event->tep,
6457					 data + offset, field->size);
6458		*len = offset >> 16;
6459		offset &= 0xffff;
6460	} else
6461		*len = field->size;
6462
6463	return data + offset;
6464}
6465
6466/**
6467 * tep_get_field_val - find a field and return its value
6468 * @s: The seq to print to on error
6469 * @event: the event that the field is for
6470 * @name: The name of the field
6471 * @record: The record with the field name.
6472 * @val: place to store the value of the field.
6473 * @err: print default error if failed.
6474 *
6475 * Returns 0 on success -1 on field not found.
6476 */
6477int tep_get_field_val(struct trace_seq *s, struct tep_event *event,
6478		      const char *name, struct tep_record *record,
6479		      unsigned long long *val, int err)
6480{
6481	struct tep_format_field *field;
6482
6483	if (!event)
6484		return -1;
6485
6486	field = tep_find_field(event, name);
6487
6488	return get_field_val(s, field, name, record, val, err);
6489}
6490
6491/**
6492 * tep_get_common_field_val - find a common field and return its value
6493 * @s: The seq to print to on error
6494 * @event: the event that the field is for
6495 * @name: The name of the field
6496 * @record: The record with the field name.
6497 * @val: place to store the value of the field.
6498 * @err: print default error if failed.
6499 *
6500 * Returns 0 on success -1 on field not found.
6501 */
6502int tep_get_common_field_val(struct trace_seq *s, struct tep_event *event,
6503			     const char *name, struct tep_record *record,
6504			     unsigned long long *val, int err)
6505{
6506	struct tep_format_field *field;
6507
6508	if (!event)
6509		return -1;
6510
6511	field = tep_find_common_field(event, name);
6512
6513	return get_field_val(s, field, name, record, val, err);
6514}
6515
6516/**
6517 * tep_get_any_field_val - find a any field and return its value
6518 * @s: The seq to print to on error
6519 * @event: the event that the field is for
6520 * @name: The name of the field
6521 * @record: The record with the field name.
6522 * @val: place to store the value of the field.
6523 * @err: print default error if failed.
6524 *
6525 * Returns 0 on success -1 on field not found.
6526 */
6527int tep_get_any_field_val(struct trace_seq *s, struct tep_event *event,
6528			  const char *name, struct tep_record *record,
6529			  unsigned long long *val, int err)
6530{
6531	struct tep_format_field *field;
6532
6533	if (!event)
6534		return -1;
6535
6536	field = tep_find_any_field(event, name);
6537
6538	return get_field_val(s, field, name, record, val, err);
6539}
6540
6541/**
6542 * tep_print_num_field - print a field and a format
6543 * @s: The seq to print to
6544 * @fmt: The printf format to print the field with.
6545 * @event: the event that the field is for
6546 * @name: The name of the field
6547 * @record: The record with the field name.
6548 * @err: print default error if failed.
6549 *
6550 * Returns positive value on success, negative in case of an error,
6551 * or 0 if buffer is full.
6552 */
6553int tep_print_num_field(struct trace_seq *s, const char *fmt,
6554			struct tep_event *event, const char *name,
6555			struct tep_record *record, int err)
6556{
6557	struct tep_format_field *field = tep_find_field(event, name);
6558	unsigned long long val;
6559
6560	if (!field)
6561		goto failed;
6562
6563	if (tep_read_number_field(field, record->data, &val))
6564		goto failed;
6565
6566	return trace_seq_printf(s, fmt, val);
6567
6568 failed:
6569	if (err)
6570		trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6571	return -1;
6572}
6573
6574/**
6575 * tep_print_func_field - print a field and a format for function pointers
6576 * @s: The seq to print to
6577 * @fmt: The printf format to print the field with.
6578 * @event: the event that the field is for
6579 * @name: The name of the field
6580 * @record: The record with the field name.
6581 * @err: print default error if failed.
6582 *
6583 * Returns positive value on success, negative in case of an error,
6584 * or 0 if buffer is full.
6585 */
6586int tep_print_func_field(struct trace_seq *s, const char *fmt,
6587			 struct tep_event *event, const char *name,
6588			 struct tep_record *record, int err)
6589{
6590	struct tep_format_field *field = tep_find_field(event, name);
6591	struct tep_handle *tep = event->tep;
6592	unsigned long long val;
6593	struct func_map *func;
6594	char tmp[128];
6595
6596	if (!field)
6597		goto failed;
6598
6599	if (tep_read_number_field(field, record->data, &val))
6600		goto failed;
6601
6602	func = find_func(tep, val);
6603
6604	if (func)
6605		snprintf(tmp, 128, "%s/0x%llx", func->func, func->addr - val);
6606	else
6607		sprintf(tmp, "0x%08llx", val);
6608
6609	return trace_seq_printf(s, fmt, tmp);
6610
6611 failed:
6612	if (err)
6613		trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6614	return -1;
6615}
6616
6617static void free_func_handle(struct tep_function_handler *func)
6618{
6619	struct func_params *params;
6620
6621	free(func->name);
6622
6623	while (func->params) {
6624		params = func->params;
6625		func->params = params->next;
6626		free(params);
6627	}
6628
6629	free(func);
6630}
6631
6632/**
6633 * tep_register_print_function - register a helper function
6634 * @tep: a handle to the trace event parser context
6635 * @func: the function to process the helper function
6636 * @ret_type: the return type of the helper function
6637 * @name: the name of the helper function
6638 * @parameters: A list of enum tep_func_arg_type
6639 *
6640 * Some events may have helper functions in the print format arguments.
6641 * This allows a plugin to dynamically create a way to process one
6642 * of these functions.
6643 *
6644 * The @parameters is a variable list of tep_func_arg_type enums that
6645 * must end with TEP_FUNC_ARG_VOID.
6646 */
6647int tep_register_print_function(struct tep_handle *tep,
6648				tep_func_handler func,
6649				enum tep_func_arg_type ret_type,
6650				char *name, ...)
6651{
6652	struct tep_function_handler *func_handle;
6653	struct func_params **next_param;
6654	struct func_params *param;
6655	enum tep_func_arg_type type;
6656	va_list ap;
6657	int ret;
6658
6659	func_handle = find_func_handler(tep, name);
6660	if (func_handle) {
6661		/*
6662		 * This is most like caused by the users own
6663		 * plugins updating the function. This overrides the
6664		 * system defaults.
6665		 */
6666		pr_stat("override of function helper '%s'", name);
6667		remove_func_handler(tep, name);
6668	}
6669
6670	func_handle = calloc(1, sizeof(*func_handle));
6671	if (!func_handle) {
6672		do_warning("Failed to allocate function handler");
6673		return TEP_ERRNO__MEM_ALLOC_FAILED;
6674	}
6675
6676	func_handle->ret_type = ret_type;
6677	func_handle->name = strdup(name);
6678	func_handle->func = func;
6679	if (!func_handle->name) {
6680		do_warning("Failed to allocate function name");
6681		free(func_handle);
6682		return TEP_ERRNO__MEM_ALLOC_FAILED;
6683	}
6684
6685	next_param = &(func_handle->params);
6686	va_start(ap, name);
6687	for (;;) {
6688		type = va_arg(ap, enum tep_func_arg_type);
6689		if (type == TEP_FUNC_ARG_VOID)
6690			break;
6691
6692		if (type >= TEP_FUNC_ARG_MAX_TYPES) {
6693			do_warning("Invalid argument type %d", type);
6694			ret = TEP_ERRNO__INVALID_ARG_TYPE;
6695			goto out_free;
6696		}
6697
6698		param = malloc(sizeof(*param));
6699		if (!param) {
6700			do_warning("Failed to allocate function param");
6701			ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6702			goto out_free;
6703		}
6704		param->type = type;
6705		param->next = NULL;
6706
6707		*next_param = param;
6708		next_param = &(param->next);
6709
6710		func_handle->nr_args++;
6711	}
6712	va_end(ap);
6713
6714	func_handle->next = tep->func_handlers;
6715	tep->func_handlers = func_handle;
6716
6717	return 0;
6718 out_free:
6719	va_end(ap);
6720	free_func_handle(func_handle);
6721	return ret;
6722}
6723
6724/**
6725 * tep_unregister_print_function - unregister a helper function
6726 * @tep: a handle to the trace event parser context
6727 * @func: the function to process the helper function
6728 * @name: the name of the helper function
6729 *
6730 * This function removes existing print handler for function @name.
6731 *
6732 * Returns 0 if the handler was removed successully, -1 otherwise.
6733 */
6734int tep_unregister_print_function(struct tep_handle *tep,
6735				  tep_func_handler func, char *name)
6736{
6737	struct tep_function_handler *func_handle;
6738
6739	func_handle = find_func_handler(tep, name);
6740	if (func_handle && func_handle->func == func) {
6741		remove_func_handler(tep, name);
6742		return 0;
6743	}
6744	return -1;
6745}
6746
6747static struct tep_event *search_event(struct tep_handle *tep, int id,
6748				      const char *sys_name,
6749				      const char *event_name)
6750{
6751	struct tep_event *event;
6752
6753	if (id >= 0) {
6754		/* search by id */
6755		event = tep_find_event(tep, id);
6756		if (!event)
6757			return NULL;
6758		if (event_name && (strcmp(event_name, event->name) != 0))
6759			return NULL;
6760		if (sys_name && (strcmp(sys_name, event->system) != 0))
6761			return NULL;
6762	} else {
6763		event = tep_find_event_by_name(tep, sys_name, event_name);
6764		if (!event)
6765			return NULL;
6766	}
6767	return event;
6768}
6769
6770/**
6771 * tep_register_event_handler - register a way to parse an event
6772 * @tep: a handle to the trace event parser context
6773 * @id: the id of the event to register
6774 * @sys_name: the system name the event belongs to
6775 * @event_name: the name of the event
6776 * @func: the function to call to parse the event information
6777 * @context: the data to be passed to @func
6778 *
6779 * This function allows a developer to override the parsing of
6780 * a given event. If for some reason the default print format
6781 * is not sufficient, this function will register a function
6782 * for an event to be used to parse the data instead.
6783 *
6784 * If @id is >= 0, then it is used to find the event.
6785 * else @sys_name and @event_name are used.
6786 *
6787 * Returns:
6788 *  TEP_REGISTER_SUCCESS_OVERWRITE if an existing handler is overwritten
6789 *  TEP_REGISTER_SUCCESS if a new handler is registered successfully
6790 *  negative TEP_ERRNO_... in case of an error
6791 *
6792 */
6793int tep_register_event_handler(struct tep_handle *tep, int id,
6794			       const char *sys_name, const char *event_name,
6795			       tep_event_handler_func func, void *context)
6796{
6797	struct tep_event *event;
6798	struct event_handler *handle;
6799
6800	event = search_event(tep, id, sys_name, event_name);
6801	if (event == NULL)
6802		goto not_found;
6803
6804	pr_stat("overriding event (%d) %s:%s with new print handler",
6805		event->id, event->system, event->name);
6806
6807	event->handler = func;
6808	event->context = context;
6809	return TEP_REGISTER_SUCCESS_OVERWRITE;
6810
6811 not_found:
6812	/* Save for later use. */
6813	handle = calloc(1, sizeof(*handle));
6814	if (!handle) {
6815		do_warning("Failed to allocate event handler");
6816		return TEP_ERRNO__MEM_ALLOC_FAILED;
6817	}
6818
6819	handle->id = id;
6820	if (event_name)
6821		handle->event_name = strdup(event_name);
6822	if (sys_name)
6823		handle->sys_name = strdup(sys_name);
6824
6825	if ((event_name && !handle->event_name) ||
6826	    (sys_name && !handle->sys_name)) {
6827		do_warning("Failed to allocate event/sys name");
6828		free((void *)handle->event_name);
6829		free((void *)handle->sys_name);
6830		free(handle);
6831		return TEP_ERRNO__MEM_ALLOC_FAILED;
6832	}
6833
6834	handle->func = func;
6835	handle->next = tep->handlers;
6836	tep->handlers = handle;
6837	handle->context = context;
6838
6839	return TEP_REGISTER_SUCCESS;
6840}
6841
6842static int handle_matches(struct event_handler *handler, int id,
6843			  const char *sys_name, const char *event_name,
6844			  tep_event_handler_func func, void *context)
6845{
6846	if (id >= 0 && id != handler->id)
6847		return 0;
6848
6849	if (event_name && (strcmp(event_name, handler->event_name) != 0))
6850		return 0;
6851
6852	if (sys_name && (strcmp(sys_name, handler->sys_name) != 0))
6853		return 0;
6854
6855	if (func != handler->func || context != handler->context)
6856		return 0;
6857
6858	return 1;
6859}
6860
6861/**
6862 * tep_unregister_event_handler - unregister an existing event handler
6863 * @tep: a handle to the trace event parser context
6864 * @id: the id of the event to unregister
6865 * @sys_name: the system name the handler belongs to
6866 * @event_name: the name of the event handler
6867 * @func: the function to call to parse the event information
6868 * @context: the data to be passed to @func
6869 *
6870 * This function removes existing event handler (parser).
6871 *
6872 * If @id is >= 0, then it is used to find the event.
6873 * else @sys_name and @event_name are used.
6874 *
6875 * Returns 0 if handler was removed successfully, -1 if event was not found.
6876 */
6877int tep_unregister_event_handler(struct tep_handle *tep, int id,
6878				 const char *sys_name, const char *event_name,
6879				 tep_event_handler_func func, void *context)
6880{
6881	struct tep_event *event;
6882	struct event_handler *handle;
6883	struct event_handler **next;
6884
6885	event = search_event(tep, id, sys_name, event_name);
6886	if (event == NULL)
6887		goto not_found;
6888
6889	if (event->handler == func && event->context == context) {
6890		pr_stat("removing override handler for event (%d) %s:%s. Going back to default handler.",
6891			event->id, event->system, event->name);
6892
6893		event->handler = NULL;
6894		event->context = NULL;
6895		return 0;
6896	}
6897
6898not_found:
6899	for (next = &tep->handlers; *next; next = &(*next)->next) {
6900		handle = *next;
6901		if (handle_matches(handle, id, sys_name, event_name,
6902				   func, context))
6903			break;
6904	}
6905
6906	if (!(*next))
6907		return -1;
6908
6909	*next = handle->next;
6910	free_handler(handle);
6911
6912	return 0;
6913}
6914
6915/**
6916 * tep_alloc - create a tep handle
6917 */
6918struct tep_handle *tep_alloc(void)
6919{
6920	struct tep_handle *tep = calloc(1, sizeof(*tep));
6921
6922	if (tep) {
6923		tep->ref_count = 1;
6924		tep->host_bigendian = tep_is_bigendian();
6925	}
6926
6927	return tep;
6928}
6929
6930void tep_ref(struct tep_handle *tep)
6931{
6932	tep->ref_count++;
6933}
6934
6935int tep_get_ref(struct tep_handle *tep)
6936{
6937	if (tep)
6938		return tep->ref_count;
6939	return 0;
6940}
6941
6942void tep_free_format_field(struct tep_format_field *field)
6943{
6944	free(field->type);
6945	if (field->alias != field->name)
6946		free(field->alias);
6947	free(field->name);
6948	free(field);
6949}
6950
6951static void free_format_fields(struct tep_format_field *field)
6952{
6953	struct tep_format_field *next;
6954
6955	while (field) {
6956		next = field->next;
6957		tep_free_format_field(field);
6958		field = next;
6959	}
6960}
6961
6962static void free_formats(struct tep_format *format)
6963{
6964	free_format_fields(format->common_fields);
6965	free_format_fields(format->fields);
6966}
6967
6968void tep_free_event(struct tep_event *event)
6969{
6970	free(event->name);
6971	free(event->system);
6972
6973	free_formats(&event->format);
6974
6975	free(event->print_fmt.format);
6976	free_args(event->print_fmt.args);
6977
6978	free(event);
6979}
6980
6981/**
6982 * tep_free - free a tep handle
6983 * @tep: the tep handle to free
6984 */
6985void tep_free(struct tep_handle *tep)
6986{
6987	struct cmdline_list *cmdlist, *cmdnext;
6988	struct func_list *funclist, *funcnext;
6989	struct printk_list *printklist, *printknext;
6990	struct tep_function_handler *func_handler;
6991	struct event_handler *handle;
6992	int i;
6993
6994	if (!tep)
6995		return;
6996
6997	cmdlist = tep->cmdlist;
6998	funclist = tep->funclist;
6999	printklist = tep->printklist;
7000
7001	tep->ref_count--;
7002	if (tep->ref_count)
7003		return;
7004
7005	if (tep->cmdlines) {
7006		for (i = 0; i < tep->cmdline_count; i++)
7007			free(tep->cmdlines[i].comm);
7008		free(tep->cmdlines);
7009	}
7010
7011	while (cmdlist) {
7012		cmdnext = cmdlist->next;
7013		free(cmdlist->comm);
7014		free(cmdlist);
7015		cmdlist = cmdnext;
7016	}
7017
7018	if (tep->func_map) {
7019		for (i = 0; i < (int)tep->func_count; i++) {
7020			free(tep->func_map[i].func);
7021			free(tep->func_map[i].mod);
7022		}
7023		free(tep->func_map);
7024	}
7025
7026	while (funclist) {
7027		funcnext = funclist->next;
7028		free(funclist->func);
7029		free(funclist->mod);
7030		free(funclist);
7031		funclist = funcnext;
7032	}
7033
7034	while (tep->func_handlers) {
7035		func_handler = tep->func_handlers;
7036		tep->func_handlers = func_handler->next;
7037		free_func_handle(func_handler);
7038	}
7039
7040	if (tep->printk_map) {
7041		for (i = 0; i < (int)tep->printk_count; i++)
7042			free(tep->printk_map[i].printk);
7043		free(tep->printk_map);
7044	}
7045
7046	while (printklist) {
7047		printknext = printklist->next;
7048		free(printklist->printk);
7049		free(printklist);
7050		printklist = printknext;
7051	}
7052
7053	for (i = 0; i < tep->nr_events; i++)
7054		tep_free_event(tep->events[i]);
7055
7056	while (tep->handlers) {
7057		handle = tep->handlers;
7058		tep->handlers = handle->next;
7059		free_handler(handle);
7060	}
7061
7062	free(tep->events);
7063	free(tep->sort_events);
7064	free(tep->func_resolver);
7065
7066	free(tep);
7067}
7068
7069void tep_unref(struct tep_handle *tep)
7070{
7071	tep_free(tep);
7072}