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