1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * trace_events_synth - synthetic trace events
   4 *
   5 * Copyright (C) 2015, 2020 Tom Zanussi <tom.zanussi@linux.intel.com>
   6 */
   7
   8#include <linux/module.h>
   9#include <linux/kallsyms.h>
  10#include <linux/security.h>
  11#include <linux/mutex.h>
  12#include <linux/slab.h>
  13#include <linux/stacktrace.h>
  14#include <linux/rculist.h>
  15#include <linux/tracefs.h>
  16
  17/* for gfp flag names */
  18#include <linux/trace_events.h>
  19#include <trace/events/mmflags.h>
  20#include "trace_probe.h"
  21#include "trace_probe_kernel.h"
  22
  23#include "trace_synth.h"
  24
  25#undef ERRORS
  26#define ERRORS	\
  27	C(BAD_NAME,		"Illegal name"),		\
  28	C(INVALID_CMD,		"Command must be of the form: <name> field[;field] ..."),\
  29	C(INVALID_DYN_CMD,	"Command must be of the form: s or -:[synthetic/]<name> field[;field] ..."),\
  30	C(EVENT_EXISTS,		"Event already exists"),	\
  31	C(TOO_MANY_FIELDS,	"Too many fields"),		\
  32	C(INCOMPLETE_TYPE,	"Incomplete type"),		\
  33	C(INVALID_TYPE,		"Invalid type"),		\
  34	C(INVALID_FIELD,        "Invalid field"),		\
  35	C(INVALID_ARRAY_SPEC,	"Invalid array specification"),
  36
  37#undef C
  38#define C(a, b)		SYNTH_ERR_##a
  39
  40enum { ERRORS };
  41
  42#undef C
  43#define C(a, b)		b
  44
  45static const char *err_text[] = { ERRORS };
  46
  47static char *last_cmd;
  48
  49static int errpos(const char *str)
  50{
  51	if (!str || !last_cmd)
  52		return 0;
  53
  54	return err_pos(last_cmd, str);
  55}
  56
  57static void last_cmd_set(const char *str)
  58{
  59	if (!str)
  60		return;
  61
  62	kfree(last_cmd);
  63
  64	last_cmd = kstrdup(str, GFP_KERNEL);
  65}
  66
  67static void synth_err(u8 err_type, u16 err_pos)
  68{
  69	if (!last_cmd)
  70		return;
  71
  72	tracing_log_err(NULL, "synthetic_events", last_cmd, err_text,
  73			err_type, err_pos);
  74}
  75
  76static int create_synth_event(const char *raw_command);
  77static int synth_event_show(struct seq_file *m, struct dyn_event *ev);
  78static int synth_event_release(struct dyn_event *ev);
  79static bool synth_event_is_busy(struct dyn_event *ev);
  80static bool synth_event_match(const char *system, const char *event,
  81			int argc, const char **argv, struct dyn_event *ev);
  82
  83static struct dyn_event_operations synth_event_ops = {
  84	.create = create_synth_event,
  85	.show = synth_event_show,
  86	.is_busy = synth_event_is_busy,
  87	.free = synth_event_release,
  88	.match = synth_event_match,
  89};
  90
  91static bool is_synth_event(struct dyn_event *ev)
  92{
  93	return ev->ops == &synth_event_ops;
  94}
  95
  96static struct synth_event *to_synth_event(struct dyn_event *ev)
  97{
  98	return container_of(ev, struct synth_event, devent);
  99}
 100
 101static bool synth_event_is_busy(struct dyn_event *ev)
 102{
 103	struct synth_event *event = to_synth_event(ev);
 104
 105	return event->ref != 0;
 106}
 107
 108static bool synth_event_match(const char *system, const char *event,
 109			int argc, const char **argv, struct dyn_event *ev)
 110{
 111	struct synth_event *sev = to_synth_event(ev);
 112
 113	return strcmp(sev->name, event) == 0 &&
 114		(!system || strcmp(system, SYNTH_SYSTEM) == 0);
 115}
 116
 117struct synth_trace_event {
 118	struct trace_entry	ent;
 119	u64			fields[];
 120};
 121
 122static int synth_event_define_fields(struct trace_event_call *call)
 123{
 124	struct synth_trace_event trace;
 125	int offset = offsetof(typeof(trace), fields);
 126	struct synth_event *event = call->data;
 127	unsigned int i, size, n_u64;
 128	char *name, *type;
 129	bool is_signed;
 130	int ret = 0;
 131
 132	for (i = 0, n_u64 = 0; i < event->n_fields; i++) {
 133		size = event->fields[i]->size;
 134		is_signed = event->fields[i]->is_signed;
 135		type = event->fields[i]->type;
 136		name = event->fields[i]->name;
 137		ret = trace_define_field(call, type, name, offset, size,
 138					 is_signed, FILTER_OTHER);
 139		if (ret)
 140			break;
 141
 142		event->fields[i]->offset = n_u64;
 143
 144		if (event->fields[i]->is_string && !event->fields[i]->is_dynamic) {
 145			offset += STR_VAR_LEN_MAX;
 146			n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
 147		} else {
 148			offset += sizeof(u64);
 149			n_u64++;
 150		}
 151	}
 152
 153	event->n_u64 = n_u64;
 154
 155	return ret;
 156}
 157
 158static bool synth_field_signed(char *type)
 159{
 160	if (str_has_prefix(type, "u"))
 161		return false;
 162	if (strcmp(type, "gfp_t") == 0)
 163		return false;
 164
 165	return true;
 166}
 167
 168static int synth_field_is_string(char *type)
 169{
 170	if (strstr(type, "char[") != NULL)
 171		return true;
 172
 173	return false;
 174}
 175
 176static int synth_field_string_size(char *type)
 177{
 178	char buf[4], *end, *start;
 179	unsigned int len;
 180	int size, err;
 181
 182	start = strstr(type, "char[");
 183	if (start == NULL)
 184		return -EINVAL;
 185	start += sizeof("char[") - 1;
 186
 187	end = strchr(type, ']');
 188	if (!end || end < start || type + strlen(type) > end + 1)
 189		return -EINVAL;
 190
 191	len = end - start;
 192	if (len > 3)
 193		return -EINVAL;
 194
 195	if (len == 0)
 196		return 0; /* variable-length string */
 197
 198	strncpy(buf, start, len);
 199	buf[len] = '\0';
 200
 201	err = kstrtouint(buf, 0, &size);
 202	if (err)
 203		return err;
 204
 205	if (size > STR_VAR_LEN_MAX)
 206		return -EINVAL;
 207
 208	return size;
 209}
 210
 211static int synth_field_size(char *type)
 212{
 213	int size = 0;
 214
 215	if (strcmp(type, "s64") == 0)
 216		size = sizeof(s64);
 217	else if (strcmp(type, "u64") == 0)
 218		size = sizeof(u64);
 219	else if (strcmp(type, "s32") == 0)
 220		size = sizeof(s32);
 221	else if (strcmp(type, "u32") == 0)
 222		size = sizeof(u32);
 223	else if (strcmp(type, "s16") == 0)
 224		size = sizeof(s16);
 225	else if (strcmp(type, "u16") == 0)
 226		size = sizeof(u16);
 227	else if (strcmp(type, "s8") == 0)
 228		size = sizeof(s8);
 229	else if (strcmp(type, "u8") == 0)
 230		size = sizeof(u8);
 231	else if (strcmp(type, "char") == 0)
 232		size = sizeof(char);
 233	else if (strcmp(type, "unsigned char") == 0)
 234		size = sizeof(unsigned char);
 235	else if (strcmp(type, "int") == 0)
 236		size = sizeof(int);
 237	else if (strcmp(type, "unsigned int") == 0)
 238		size = sizeof(unsigned int);
 239	else if (strcmp(type, "long") == 0)
 240		size = sizeof(long);
 241	else if (strcmp(type, "unsigned long") == 0)
 242		size = sizeof(unsigned long);
 243	else if (strcmp(type, "bool") == 0)
 244		size = sizeof(bool);
 245	else if (strcmp(type, "pid_t") == 0)
 246		size = sizeof(pid_t);
 247	else if (strcmp(type, "gfp_t") == 0)
 248		size = sizeof(gfp_t);
 249	else if (synth_field_is_string(type))
 250		size = synth_field_string_size(type);
 251
 252	return size;
 253}
 254
 255static const char *synth_field_fmt(char *type)
 256{
 257	const char *fmt = "%llu";
 258
 259	if (strcmp(type, "s64") == 0)
 260		fmt = "%lld";
 261	else if (strcmp(type, "u64") == 0)
 262		fmt = "%llu";
 263	else if (strcmp(type, "s32") == 0)
 264		fmt = "%d";
 265	else if (strcmp(type, "u32") == 0)
 266		fmt = "%u";
 267	else if (strcmp(type, "s16") == 0)
 268		fmt = "%d";
 269	else if (strcmp(type, "u16") == 0)
 270		fmt = "%u";
 271	else if (strcmp(type, "s8") == 0)
 272		fmt = "%d";
 273	else if (strcmp(type, "u8") == 0)
 274		fmt = "%u";
 275	else if (strcmp(type, "char") == 0)
 276		fmt = "%d";
 277	else if (strcmp(type, "unsigned char") == 0)
 278		fmt = "%u";
 279	else if (strcmp(type, "int") == 0)
 280		fmt = "%d";
 281	else if (strcmp(type, "unsigned int") == 0)
 282		fmt = "%u";
 283	else if (strcmp(type, "long") == 0)
 284		fmt = "%ld";
 285	else if (strcmp(type, "unsigned long") == 0)
 286		fmt = "%lu";
 287	else if (strcmp(type, "bool") == 0)
 288		fmt = "%d";
 289	else if (strcmp(type, "pid_t") == 0)
 290		fmt = "%d";
 291	else if (strcmp(type, "gfp_t") == 0)
 292		fmt = "%x";
 293	else if (synth_field_is_string(type))
 294		fmt = "%.*s";
 295
 296	return fmt;
 297}
 298
 299static void print_synth_event_num_val(struct trace_seq *s,
 300				      char *print_fmt, char *name,
 301				      int size, u64 val, char *space)
 302{
 303	switch (size) {
 304	case 1:
 305		trace_seq_printf(s, print_fmt, name, (u8)val, space);
 306		break;
 307
 308	case 2:
 309		trace_seq_printf(s, print_fmt, name, (u16)val, space);
 310		break;
 311
 312	case 4:
 313		trace_seq_printf(s, print_fmt, name, (u32)val, space);
 314		break;
 315
 316	default:
 317		trace_seq_printf(s, print_fmt, name, val, space);
 318		break;
 319	}
 320}
 321
 322static enum print_line_t print_synth_event(struct trace_iterator *iter,
 323					   int flags,
 324					   struct trace_event *event)
 325{
 326	struct trace_array *tr = iter->tr;
 327	struct trace_seq *s = &iter->seq;
 328	struct synth_trace_event *entry;
 329	struct synth_event *se;
 330	unsigned int i, n_u64;
 331	char print_fmt[32];
 332	const char *fmt;
 333
 334	entry = (struct synth_trace_event *)iter->ent;
 335	se = container_of(event, struct synth_event, call.event);
 336
 337	trace_seq_printf(s, "%s: ", se->name);
 338
 339	for (i = 0, n_u64 = 0; i < se->n_fields; i++) {
 340		if (trace_seq_has_overflowed(s))
 341			goto end;
 342
 343		fmt = synth_field_fmt(se->fields[i]->type);
 344
 345		/* parameter types */
 346		if (tr && tr->trace_flags & TRACE_ITER_VERBOSE)
 347			trace_seq_printf(s, "%s ", fmt);
 348
 349		snprintf(print_fmt, sizeof(print_fmt), "%%s=%s%%s", fmt);
 350
 351		/* parameter values */
 352		if (se->fields[i]->is_string) {
 353			if (se->fields[i]->is_dynamic) {
 354				u32 offset, data_offset;
 355				char *str_field;
 356
 357				offset = (u32)entry->fields[n_u64];
 358				data_offset = offset & 0xffff;
 359
 360				str_field = (char *)entry + data_offset;
 361
 362				trace_seq_printf(s, print_fmt, se->fields[i]->name,
 363						 STR_VAR_LEN_MAX,
 364						 str_field,
 365						 i == se->n_fields - 1 ? "" : " ");
 366				n_u64++;
 367			} else {
 368				trace_seq_printf(s, print_fmt, se->fields[i]->name,
 369						 STR_VAR_LEN_MAX,
 370						 (char *)&entry->fields[n_u64],
 371						 i == se->n_fields - 1 ? "" : " ");
 372				n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
 373			}
 374		} else {
 375			struct trace_print_flags __flags[] = {
 376			    __def_gfpflag_names, {-1, NULL} };
 377			char *space = (i == se->n_fields - 1 ? "" : " ");
 378
 379			print_synth_event_num_val(s, print_fmt,
 380						  se->fields[i]->name,
 381						  se->fields[i]->size,
 382						  entry->fields[n_u64],
 383						  space);
 384
 385			if (strcmp(se->fields[i]->type, "gfp_t") == 0) {
 386				trace_seq_puts(s, " (");
 387				trace_print_flags_seq(s, "|",
 388						      entry->fields[n_u64],
 389						      __flags);
 390				trace_seq_putc(s, ')');
 391			}
 392			n_u64++;
 393		}
 394	}
 395end:
 396	trace_seq_putc(s, '\n');
 397
 398	return trace_handle_return(s);
 399}
 400
 401static struct trace_event_functions synth_event_funcs = {
 402	.trace		= print_synth_event
 403};
 404
 405static unsigned int trace_string(struct synth_trace_event *entry,
 406				 struct synth_event *event,
 407				 char *str_val,
 408				 bool is_dynamic,
 409				 unsigned int data_size,
 410				 unsigned int *n_u64)
 411{
 412	unsigned int len = 0;
 413	char *str_field;
 414	int ret;
 415
 416	if (is_dynamic) {
 417		u32 data_offset;
 418
 419		data_offset = offsetof(typeof(*entry), fields);
 420		data_offset += event->n_u64 * sizeof(u64);
 421		data_offset += data_size;
 422
 423		len = kern_fetch_store_strlen((unsigned long)str_val);
 424
 425		data_offset |= len << 16;
 426		*(u32 *)&entry->fields[*n_u64] = data_offset;
 427
 428		ret = kern_fetch_store_string((unsigned long)str_val, &entry->fields[*n_u64], entry);
 429
 430		(*n_u64)++;
 431	} else {
 432		str_field = (char *)&entry->fields[*n_u64];
 433
 434#ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE
 435		if ((unsigned long)str_val < TASK_SIZE)
 436			ret = strncpy_from_user_nofault(str_field, str_val, STR_VAR_LEN_MAX);
 437		else
 438#endif
 439			ret = strncpy_from_kernel_nofault(str_field, str_val, STR_VAR_LEN_MAX);
 440
 441		if (ret < 0)
 442			strcpy(str_field, FAULT_STRING);
 443
 444		(*n_u64) += STR_VAR_LEN_MAX / sizeof(u64);
 445	}
 446
 447	return len;
 448}
 449
 450static notrace void trace_event_raw_event_synth(void *__data,
 451						u64 *var_ref_vals,
 452						unsigned int *var_ref_idx)
 453{
 454	unsigned int i, n_u64, val_idx, len, data_size = 0;
 455	struct trace_event_file *trace_file = __data;
 456	struct synth_trace_event *entry;
 457	struct trace_event_buffer fbuffer;
 458	struct trace_buffer *buffer;
 459	struct synth_event *event;
 
 460	int fields_size = 0;
 461
 462	event = trace_file->event_call->data;
 463
 464	if (trace_trigger_soft_disabled(trace_file))
 465		return;
 466
 467	fields_size = event->n_u64 * sizeof(u64);
 468
 469	for (i = 0; i < event->n_dynamic_fields; i++) {
 470		unsigned int field_pos = event->dynamic_fields[i]->field_pos;
 471		char *str_val;
 472
 473		val_idx = var_ref_idx[field_pos];
 474		str_val = (char *)(long)var_ref_vals[val_idx];
 475
 476		len = kern_fetch_store_strlen((unsigned long)str_val);
 477
 478		fields_size += len;
 479	}
 480
 481	/*
 482	 * Avoid ring buffer recursion detection, as this event
 483	 * is being performed within another event.
 484	 */
 485	buffer = trace_file->tr->array_buffer.buffer;
 486	ring_buffer_nest_start(buffer);
 487
 488	entry = trace_event_buffer_reserve(&fbuffer, trace_file,
 489					   sizeof(*entry) + fields_size);
 490	if (!entry)
 491		goto out;
 492
 493	for (i = 0, n_u64 = 0; i < event->n_fields; i++) {
 494		val_idx = var_ref_idx[i];
 495		if (event->fields[i]->is_string) {
 496			char *str_val = (char *)(long)var_ref_vals[val_idx];
 
 497
 498			len = trace_string(entry, event, str_val,
 499					   event->fields[i]->is_dynamic,
 500					   data_size, &n_u64);
 501			data_size += len; /* only dynamic string increments */
 502		} else {
 503			struct synth_field *field = event->fields[i];
 504			u64 val = var_ref_vals[val_idx];
 505
 506			switch (field->size) {
 507			case 1:
 508				*(u8 *)&entry->fields[n_u64] = (u8)val;
 509				break;
 510
 511			case 2:
 512				*(u16 *)&entry->fields[n_u64] = (u16)val;
 513				break;
 514
 515			case 4:
 516				*(u32 *)&entry->fields[n_u64] = (u32)val;
 517				break;
 518
 519			default:
 520				entry->fields[n_u64] = val;
 521				break;
 522			}
 523			n_u64++;
 524		}
 525	}
 526
 527	trace_event_buffer_commit(&fbuffer);
 528out:
 529	ring_buffer_nest_end(buffer);
 530}
 531
 532static void free_synth_event_print_fmt(struct trace_event_call *call)
 533{
 534	if (call) {
 535		kfree(call->print_fmt);
 536		call->print_fmt = NULL;
 537	}
 538}
 539
 540static int __set_synth_event_print_fmt(struct synth_event *event,
 541				       char *buf, int len)
 542{
 543	const char *fmt;
 544	int pos = 0;
 545	int i;
 546
 547	/* When len=0, we just calculate the needed length */
 548#define LEN_OR_ZERO (len ? len - pos : 0)
 549
 550	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
 551	for (i = 0; i < event->n_fields; i++) {
 552		fmt = synth_field_fmt(event->fields[i]->type);
 553		pos += snprintf(buf + pos, LEN_OR_ZERO, "%s=%s%s",
 554				event->fields[i]->name, fmt,
 555				i == event->n_fields - 1 ? "" : ", ");
 556	}
 557	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
 558
 559	for (i = 0; i < event->n_fields; i++) {
 560		if (event->fields[i]->is_string &&
 561		    event->fields[i]->is_dynamic)
 562			pos += snprintf(buf + pos, LEN_OR_ZERO,
 563				", __get_str(%s)", event->fields[i]->name);
 564		else
 565			pos += snprintf(buf + pos, LEN_OR_ZERO,
 566					", REC->%s", event->fields[i]->name);
 567	}
 568
 569#undef LEN_OR_ZERO
 570
 571	/* return the length of print_fmt */
 572	return pos;
 573}
 574
 575static int set_synth_event_print_fmt(struct trace_event_call *call)
 576{
 577	struct synth_event *event = call->data;
 578	char *print_fmt;
 579	int len;
 580
 581	/* First: called with 0 length to calculate the needed length */
 582	len = __set_synth_event_print_fmt(event, NULL, 0);
 583
 584	print_fmt = kmalloc(len + 1, GFP_KERNEL);
 585	if (!print_fmt)
 586		return -ENOMEM;
 587
 588	/* Second: actually write the @print_fmt */
 589	__set_synth_event_print_fmt(event, print_fmt, len + 1);
 590	call->print_fmt = print_fmt;
 591
 592	return 0;
 593}
 594
 595static void free_synth_field(struct synth_field *field)
 596{
 597	kfree(field->type);
 598	kfree(field->name);
 599	kfree(field);
 600}
 601
 602static int check_field_version(const char *prefix, const char *field_type,
 603			       const char *field_name)
 604{
 605	/*
 606	 * For backward compatibility, the old synthetic event command
 607	 * format did not require semicolons, and in order to not
 608	 * break user space, that old format must still work. If a new
 609	 * feature is added, then the format that uses the new feature
 610	 * will be required to have semicolons, as nothing that uses
 611	 * the old format would be using the new, yet to be created,
 612	 * feature. When a new feature is added, this will detect it,
 613	 * and return a number greater than 1, and require the format
 614	 * to use semicolons.
 615	 */
 616	return 1;
 617}
 618
 619static struct synth_field *parse_synth_field(int argc, char **argv,
 620					     int *consumed, int *field_version)
 621{
 622	const char *prefix = NULL, *field_type = argv[0], *field_name, *array;
 623	struct synth_field *field;
 624	int len, ret = -ENOMEM;
 625	struct seq_buf s;
 626	ssize_t size;
 
 
 627
 628	if (!strcmp(field_type, "unsigned")) {
 629		if (argc < 3) {
 630			synth_err(SYNTH_ERR_INCOMPLETE_TYPE, errpos(field_type));
 631			return ERR_PTR(-EINVAL);
 632		}
 633		prefix = "unsigned ";
 634		field_type = argv[1];
 635		field_name = argv[2];
 636		*consumed += 3;
 637	} else {
 638		field_name = argv[1];
 639		*consumed += 2;
 640	}
 641
 642	if (!field_name) {
 643		synth_err(SYNTH_ERR_INVALID_FIELD, errpos(field_type));
 644		return ERR_PTR(-EINVAL);
 645	}
 646
 647	*field_version = check_field_version(prefix, field_type, field_name);
 648
 649	field = kzalloc(sizeof(*field), GFP_KERNEL);
 650	if (!field)
 651		return ERR_PTR(-ENOMEM);
 652
 653	len = strlen(field_name);
 654	array = strchr(field_name, '[');
 655	if (array)
 656		len -= strlen(array);
 
 
 657
 658	field->name = kmemdup_nul(field_name, len, GFP_KERNEL);
 659	if (!field->name)
 660		goto free;
 661
 662	if (!is_good_name(field->name)) {
 663		synth_err(SYNTH_ERR_BAD_NAME, errpos(field_name));
 664		ret = -EINVAL;
 665		goto free;
 666	}
 667
 
 
 668	len = strlen(field_type) + 1;
 669
 670	if (array)
 671		len += strlen(array);
 672
 673	if (prefix)
 674		len += strlen(prefix);
 675
 676	field->type = kzalloc(len, GFP_KERNEL);
 677	if (!field->type)
 
 678		goto free;
 679
 680	seq_buf_init(&s, field->type, len);
 681	if (prefix)
 682		seq_buf_puts(&s, prefix);
 683	seq_buf_puts(&s, field_type);
 684	if (array)
 685		seq_buf_puts(&s, array);
 686	if (WARN_ON_ONCE(!seq_buf_buffer_left(&s)))
 687		goto free;
 688
 689	s.buffer[s.len] = '\0';
 690
 691	size = synth_field_size(field->type);
 692	if (size < 0) {
 693		if (array)
 694			synth_err(SYNTH_ERR_INVALID_ARRAY_SPEC, errpos(field_name));
 695		else
 696			synth_err(SYNTH_ERR_INVALID_TYPE, errpos(field_type));
 697		ret = -EINVAL;
 698		goto free;
 699	} else if (size == 0) {
 700		if (synth_field_is_string(field->type)) {
 701			char *type;
 702
 703			len = sizeof("__data_loc ") + strlen(field->type) + 1;
 704			type = kzalloc(len, GFP_KERNEL);
 705			if (!type)
 706				goto free;
 707
 708			seq_buf_init(&s, type, len);
 709			seq_buf_puts(&s, "__data_loc ");
 710			seq_buf_puts(&s, field->type);
 711
 712			if (WARN_ON_ONCE(!seq_buf_buffer_left(&s)))
 713				goto free;
 714			s.buffer[s.len] = '\0';
 715
 716			kfree(field->type);
 717			field->type = type;
 718
 719			field->is_dynamic = true;
 720			size = sizeof(u64);
 721		} else {
 722			synth_err(SYNTH_ERR_INVALID_TYPE, errpos(field_type));
 723			ret = -EINVAL;
 724			goto free;
 725		}
 726	}
 727	field->size = size;
 728
 729	if (synth_field_is_string(field->type))
 730		field->is_string = true;
 731
 732	field->is_signed = synth_field_signed(field->type);
 
 733 out:
 734	return field;
 735 free:
 736	free_synth_field(field);
 737	field = ERR_PTR(ret);
 738	goto out;
 739}
 740
 741static void free_synth_tracepoint(struct tracepoint *tp)
 742{
 743	if (!tp)
 744		return;
 745
 746	kfree(tp->name);
 747	kfree(tp);
 748}
 749
 750static struct tracepoint *alloc_synth_tracepoint(char *name)
 751{
 752	struct tracepoint *tp;
 753
 754	tp = kzalloc(sizeof(*tp), GFP_KERNEL);
 755	if (!tp)
 756		return ERR_PTR(-ENOMEM);
 757
 758	tp->name = kstrdup(name, GFP_KERNEL);
 759	if (!tp->name) {
 760		kfree(tp);
 761		return ERR_PTR(-ENOMEM);
 762	}
 763
 764	return tp;
 765}
 766
 767struct synth_event *find_synth_event(const char *name)
 768{
 769	struct dyn_event *pos;
 770	struct synth_event *event;
 771
 772	for_each_dyn_event(pos) {
 773		if (!is_synth_event(pos))
 774			continue;
 775		event = to_synth_event(pos);
 776		if (strcmp(event->name, name) == 0)
 777			return event;
 778	}
 779
 780	return NULL;
 781}
 782
 783static struct trace_event_fields synth_event_fields_array[] = {
 784	{ .type = TRACE_FUNCTION_TYPE,
 785	  .define_fields = synth_event_define_fields },
 786	{}
 787};
 788
 789static int register_synth_event(struct synth_event *event)
 790{
 791	struct trace_event_call *call = &event->call;
 792	int ret = 0;
 793
 794	event->call.class = &event->class;
 795	event->class.system = kstrdup(SYNTH_SYSTEM, GFP_KERNEL);
 796	if (!event->class.system) {
 797		ret = -ENOMEM;
 798		goto out;
 799	}
 800
 801	event->tp = alloc_synth_tracepoint(event->name);
 802	if (IS_ERR(event->tp)) {
 803		ret = PTR_ERR(event->tp);
 804		event->tp = NULL;
 805		goto out;
 806	}
 807
 808	INIT_LIST_HEAD(&call->class->fields);
 809	call->event.funcs = &synth_event_funcs;
 810	call->class->fields_array = synth_event_fields_array;
 811
 812	ret = register_trace_event(&call->event);
 813	if (!ret) {
 814		ret = -ENODEV;
 815		goto out;
 816	}
 817	call->flags = TRACE_EVENT_FL_TRACEPOINT;
 818	call->class->reg = trace_event_reg;
 819	call->class->probe = trace_event_raw_event_synth;
 820	call->data = event;
 821	call->tp = event->tp;
 822
 823	ret = trace_add_event_call(call);
 824	if (ret) {
 825		pr_warn("Failed to register synthetic event: %s\n",
 826			trace_event_name(call));
 827		goto err;
 828	}
 829
 830	ret = set_synth_event_print_fmt(call);
 831	/* unregister_trace_event() will be called inside */
 832	if (ret < 0)
 833		trace_remove_event_call(call);
 
 
 834 out:
 835	return ret;
 836 err:
 837	unregister_trace_event(&call->event);
 838	goto out;
 839}
 840
 841static int unregister_synth_event(struct synth_event *event)
 842{
 843	struct trace_event_call *call = &event->call;
 844	int ret;
 845
 846	ret = trace_remove_event_call(call);
 847
 848	return ret;
 849}
 850
 851static void free_synth_event(struct synth_event *event)
 852{
 853	unsigned int i;
 854
 855	if (!event)
 856		return;
 857
 858	for (i = 0; i < event->n_fields; i++)
 859		free_synth_field(event->fields[i]);
 860
 861	kfree(event->fields);
 862	kfree(event->dynamic_fields);
 863	kfree(event->name);
 864	kfree(event->class.system);
 865	free_synth_tracepoint(event->tp);
 866	free_synth_event_print_fmt(&event->call);
 867	kfree(event);
 868}
 869
 870static struct synth_event *alloc_synth_event(const char *name, int n_fields,
 871					     struct synth_field **fields)
 872{
 873	unsigned int i, j, n_dynamic_fields = 0;
 874	struct synth_event *event;
 
 875
 876	event = kzalloc(sizeof(*event), GFP_KERNEL);
 877	if (!event) {
 878		event = ERR_PTR(-ENOMEM);
 879		goto out;
 880	}
 881
 882	event->name = kstrdup(name, GFP_KERNEL);
 883	if (!event->name) {
 884		kfree(event);
 885		event = ERR_PTR(-ENOMEM);
 886		goto out;
 887	}
 888
 889	event->fields = kcalloc(n_fields, sizeof(*event->fields), GFP_KERNEL);
 890	if (!event->fields) {
 891		free_synth_event(event);
 892		event = ERR_PTR(-ENOMEM);
 893		goto out;
 894	}
 895
 896	for (i = 0; i < n_fields; i++)
 897		if (fields[i]->is_dynamic)
 898			n_dynamic_fields++;
 899
 900	if (n_dynamic_fields) {
 901		event->dynamic_fields = kcalloc(n_dynamic_fields,
 902						sizeof(*event->dynamic_fields),
 903						GFP_KERNEL);
 904		if (!event->dynamic_fields) {
 905			free_synth_event(event);
 906			event = ERR_PTR(-ENOMEM);
 907			goto out;
 908		}
 909	}
 910
 911	dyn_event_init(&event->devent, &synth_event_ops);
 912
 913	for (i = 0, j = 0; i < n_fields; i++) {
 914		fields[i]->field_pos = i;
 915		event->fields[i] = fields[i];
 916
 917		if (fields[i]->is_dynamic)
 918			event->dynamic_fields[j++] = fields[i];
 919	}
 920	event->n_dynamic_fields = j;
 921	event->n_fields = n_fields;
 922 out:
 923	return event;
 924}
 925
 926static int synth_event_check_arg_fn(void *data)
 927{
 928	struct dynevent_arg_pair *arg_pair = data;
 929	int size;
 930
 931	size = synth_field_size((char *)arg_pair->lhs);
 932	if (size == 0) {
 933		if (strstr((char *)arg_pair->lhs, "["))
 934			return 0;
 935	}
 936
 937	return size ? 0 : -EINVAL;
 938}
 939
 940/**
 941 * synth_event_add_field - Add a new field to a synthetic event cmd
 942 * @cmd: A pointer to the dynevent_cmd struct representing the new event
 943 * @type: The type of the new field to add
 944 * @name: The name of the new field to add
 945 *
 946 * Add a new field to a synthetic event cmd object.  Field ordering is in
 947 * the same order the fields are added.
 948 *
 949 * See synth_field_size() for available types. If field_name contains
 950 * [n] the field is considered to be an array.
 951 *
 952 * Return: 0 if successful, error otherwise.
 953 */
 954int synth_event_add_field(struct dynevent_cmd *cmd, const char *type,
 955			  const char *name)
 956{
 957	struct dynevent_arg_pair arg_pair;
 958	int ret;
 959
 960	if (cmd->type != DYNEVENT_TYPE_SYNTH)
 961		return -EINVAL;
 962
 963	if (!type || !name)
 964		return -EINVAL;
 965
 966	dynevent_arg_pair_init(&arg_pair, 0, ';');
 967
 968	arg_pair.lhs = type;
 969	arg_pair.rhs = name;
 970
 971	ret = dynevent_arg_pair_add(cmd, &arg_pair, synth_event_check_arg_fn);
 972	if (ret)
 973		return ret;
 974
 975	if (++cmd->n_fields > SYNTH_FIELDS_MAX)
 976		ret = -EINVAL;
 977
 978	return ret;
 979}
 980EXPORT_SYMBOL_GPL(synth_event_add_field);
 981
 982/**
 983 * synth_event_add_field_str - Add a new field to a synthetic event cmd
 984 * @cmd: A pointer to the dynevent_cmd struct representing the new event
 985 * @type_name: The type and name of the new field to add, as a single string
 986 *
 987 * Add a new field to a synthetic event cmd object, as a single
 988 * string.  The @type_name string is expected to be of the form 'type
 989 * name', which will be appended by ';'.  No sanity checking is done -
 990 * what's passed in is assumed to already be well-formed.  Field
 991 * ordering is in the same order the fields are added.
 992 *
 993 * See synth_field_size() for available types. If field_name contains
 994 * [n] the field is considered to be an array.
 995 *
 996 * Return: 0 if successful, error otherwise.
 997 */
 998int synth_event_add_field_str(struct dynevent_cmd *cmd, const char *type_name)
 999{
1000	struct dynevent_arg arg;
1001	int ret;
1002
1003	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1004		return -EINVAL;
1005
1006	if (!type_name)
1007		return -EINVAL;
1008
1009	dynevent_arg_init(&arg, ';');
1010
1011	arg.str = type_name;
1012
1013	ret = dynevent_arg_add(cmd, &arg, NULL);
1014	if (ret)
1015		return ret;
1016
1017	if (++cmd->n_fields > SYNTH_FIELDS_MAX)
1018		ret = -EINVAL;
1019
1020	return ret;
1021}
1022EXPORT_SYMBOL_GPL(synth_event_add_field_str);
1023
1024/**
1025 * synth_event_add_fields - Add multiple fields to a synthetic event cmd
1026 * @cmd: A pointer to the dynevent_cmd struct representing the new event
1027 * @fields: An array of type/name field descriptions
1028 * @n_fields: The number of field descriptions contained in the fields array
1029 *
1030 * Add a new set of fields to a synthetic event cmd object.  The event
1031 * fields that will be defined for the event should be passed in as an
1032 * array of struct synth_field_desc, and the number of elements in the
1033 * array passed in as n_fields.  Field ordering will retain the
1034 * ordering given in the fields array.
1035 *
1036 * See synth_field_size() for available types. If field_name contains
1037 * [n] the field is considered to be an array.
1038 *
1039 * Return: 0 if successful, error otherwise.
1040 */
1041int synth_event_add_fields(struct dynevent_cmd *cmd,
1042			   struct synth_field_desc *fields,
1043			   unsigned int n_fields)
1044{
1045	unsigned int i;
1046	int ret = 0;
1047
1048	for (i = 0; i < n_fields; i++) {
1049		if (fields[i].type == NULL || fields[i].name == NULL) {
1050			ret = -EINVAL;
1051			break;
1052		}
1053
1054		ret = synth_event_add_field(cmd, fields[i].type, fields[i].name);
1055		if (ret)
1056			break;
1057	}
1058
1059	return ret;
1060}
1061EXPORT_SYMBOL_GPL(synth_event_add_fields);
1062
1063/**
1064 * __synth_event_gen_cmd_start - Start a synthetic event command from arg list
1065 * @cmd: A pointer to the dynevent_cmd struct representing the new event
1066 * @name: The name of the synthetic event
1067 * @mod: The module creating the event, NULL if not created from a module
1068 * @args: Variable number of arg (pairs), one pair for each field
1069 *
1070 * NOTE: Users normally won't want to call this function directly, but
1071 * rather use the synth_event_gen_cmd_start() wrapper, which
1072 * automatically adds a NULL to the end of the arg list.  If this
1073 * function is used directly, make sure the last arg in the variable
1074 * arg list is NULL.
1075 *
1076 * Generate a synthetic event command to be executed by
1077 * synth_event_gen_cmd_end().  This function can be used to generate
1078 * the complete command or only the first part of it; in the latter
1079 * case, synth_event_add_field(), synth_event_add_field_str(), or
1080 * synth_event_add_fields() can be used to add more fields following
1081 * this.
1082 *
1083 * There should be an even number variable args, each pair consisting
1084 * of a type followed by a field name.
1085 *
1086 * See synth_field_size() for available types. If field_name contains
1087 * [n] the field is considered to be an array.
1088 *
1089 * Return: 0 if successful, error otherwise.
1090 */
1091int __synth_event_gen_cmd_start(struct dynevent_cmd *cmd, const char *name,
1092				struct module *mod, ...)
1093{
1094	struct dynevent_arg arg;
1095	va_list args;
1096	int ret;
1097
1098	cmd->event_name = name;
1099	cmd->private_data = mod;
1100
1101	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1102		return -EINVAL;
1103
1104	dynevent_arg_init(&arg, 0);
1105	arg.str = name;
1106	ret = dynevent_arg_add(cmd, &arg, NULL);
1107	if (ret)
1108		return ret;
1109
1110	va_start(args, mod);
1111	for (;;) {
1112		const char *type, *name;
1113
1114		type = va_arg(args, const char *);
1115		if (!type)
1116			break;
1117		name = va_arg(args, const char *);
1118		if (!name)
1119			break;
1120
1121		if (++cmd->n_fields > SYNTH_FIELDS_MAX) {
1122			ret = -EINVAL;
1123			break;
1124		}
1125
1126		ret = synth_event_add_field(cmd, type, name);
1127		if (ret)
1128			break;
1129	}
1130	va_end(args);
1131
1132	return ret;
1133}
1134EXPORT_SYMBOL_GPL(__synth_event_gen_cmd_start);
1135
1136/**
1137 * synth_event_gen_cmd_array_start - Start synthetic event command from an array
1138 * @cmd: A pointer to the dynevent_cmd struct representing the new event
1139 * @name: The name of the synthetic event
1140 * @fields: An array of type/name field descriptions
1141 * @n_fields: The number of field descriptions contained in the fields array
1142 *
1143 * Generate a synthetic event command to be executed by
1144 * synth_event_gen_cmd_end().  This function can be used to generate
1145 * the complete command or only the first part of it; in the latter
1146 * case, synth_event_add_field(), synth_event_add_field_str(), or
1147 * synth_event_add_fields() can be used to add more fields following
1148 * this.
1149 *
1150 * The event fields that will be defined for the event should be
1151 * passed in as an array of struct synth_field_desc, and the number of
1152 * elements in the array passed in as n_fields.  Field ordering will
1153 * retain the ordering given in the fields array.
1154 *
1155 * See synth_field_size() for available types. If field_name contains
1156 * [n] the field is considered to be an array.
1157 *
1158 * Return: 0 if successful, error otherwise.
1159 */
1160int synth_event_gen_cmd_array_start(struct dynevent_cmd *cmd, const char *name,
1161				    struct module *mod,
1162				    struct synth_field_desc *fields,
1163				    unsigned int n_fields)
1164{
1165	struct dynevent_arg arg;
1166	unsigned int i;
1167	int ret = 0;
1168
1169	cmd->event_name = name;
1170	cmd->private_data = mod;
1171
1172	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1173		return -EINVAL;
1174
1175	if (n_fields > SYNTH_FIELDS_MAX)
1176		return -EINVAL;
1177
1178	dynevent_arg_init(&arg, 0);
1179	arg.str = name;
1180	ret = dynevent_arg_add(cmd, &arg, NULL);
1181	if (ret)
1182		return ret;
1183
1184	for (i = 0; i < n_fields; i++) {
1185		if (fields[i].type == NULL || fields[i].name == NULL)
1186			return -EINVAL;
1187
1188		ret = synth_event_add_field(cmd, fields[i].type, fields[i].name);
1189		if (ret)
1190			break;
1191	}
1192
1193	return ret;
1194}
1195EXPORT_SYMBOL_GPL(synth_event_gen_cmd_array_start);
1196
1197static int __create_synth_event(const char *name, const char *raw_fields)
1198{
1199	char **argv, *field_str, *tmp_fields, *saved_fields = NULL;
1200	struct synth_field *field, *fields[SYNTH_FIELDS_MAX];
1201	int consumed, cmd_version = 1, n_fields_this_loop;
1202	int i, argc, n_fields = 0, ret = 0;
1203	struct synth_event *event = NULL;
 
1204
1205	/*
1206	 * Argument syntax:
1207	 *  - Add synthetic event: <event_name> field[;field] ...
1208	 *  - Remove synthetic event: !<event_name> field[;field] ...
1209	 *      where 'field' = type field_name
1210	 */
1211
1212	if (name[0] == '\0') {
1213		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1214		return -EINVAL;
1215	}
1216
1217	if (!is_good_name(name)) {
1218		synth_err(SYNTH_ERR_BAD_NAME, errpos(name));
1219		return -EINVAL;
1220	}
1221
1222	mutex_lock(&event_mutex);
1223
1224	event = find_synth_event(name);
1225	if (event) {
1226		synth_err(SYNTH_ERR_EVENT_EXISTS, errpos(name));
1227		ret = -EEXIST;
1228		goto err;
1229	}
1230
1231	tmp_fields = saved_fields = kstrdup(raw_fields, GFP_KERNEL);
1232	if (!tmp_fields) {
1233		ret = -ENOMEM;
1234		goto err;
1235	}
1236
1237	while ((field_str = strsep(&tmp_fields, ";")) != NULL) {
1238		argv = argv_split(GFP_KERNEL, field_str, &argc);
1239		if (!argv) {
1240			ret = -ENOMEM;
1241			goto err;
1242		}
1243
1244		if (!argc) {
1245			argv_free(argv);
1246			continue;
1247		}
1248
1249		n_fields_this_loop = 0;
1250		consumed = 0;
1251		while (argc > consumed) {
1252			int field_version;
1253
1254			field = parse_synth_field(argc - consumed,
1255						  argv + consumed, &consumed,
1256						  &field_version);
1257			if (IS_ERR(field)) {
1258				ret = PTR_ERR(field);
1259				goto err_free_arg;
1260			}
1261
1262			/*
1263			 * Track the highest version of any field we
1264			 * found in the command.
1265			 */
1266			if (field_version > cmd_version)
1267				cmd_version = field_version;
1268
1269			/*
1270			 * Now sort out what is and isn't valid for
1271			 * each supported version.
1272			 *
1273			 * If we see more than 1 field per loop, it
1274			 * means we have multiple fields between
1275			 * semicolons, and that's something we no
1276			 * longer support in a version 2 or greater
1277			 * command.
1278			 */
1279			if (cmd_version > 1 && n_fields_this_loop >= 1) {
1280				synth_err(SYNTH_ERR_INVALID_CMD, errpos(field_str));
1281				ret = -EINVAL;
1282				goto err_free_arg;
1283			}
1284
1285			if (n_fields == SYNTH_FIELDS_MAX) {
1286				synth_err(SYNTH_ERR_TOO_MANY_FIELDS, 0);
1287				ret = -EINVAL;
1288				goto err_free_arg;
1289			}
1290			fields[n_fields++] = field;
1291
1292			n_fields_this_loop++;
1293		}
1294		argv_free(argv);
1295
1296		if (consumed < argc) {
1297			synth_err(SYNTH_ERR_INVALID_CMD, 0);
1298			ret = -EINVAL;
1299			goto err;
1300		}
1301
 
 
 
 
 
 
 
1302	}
1303
1304	if (n_fields == 0) {
1305		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1306		ret = -EINVAL;
1307		goto err;
1308	}
1309
1310	event = alloc_synth_event(name, n_fields, fields);
1311	if (IS_ERR(event)) {
1312		ret = PTR_ERR(event);
1313		event = NULL;
1314		goto err;
1315	}
1316	ret = register_synth_event(event);
1317	if (!ret)
1318		dyn_event_add(&event->devent, &event->call);
1319	else
1320		free_synth_event(event);
1321 out:
1322	mutex_unlock(&event_mutex);
1323
1324	kfree(saved_fields);
1325
1326	return ret;
1327 err_free_arg:
1328	argv_free(argv);
1329 err:
1330	for (i = 0; i < n_fields; i++)
1331		free_synth_field(fields[i]);
1332
1333	goto out;
1334}
1335
1336/**
1337 * synth_event_create - Create a new synthetic event
1338 * @name: The name of the new synthetic event
1339 * @fields: An array of type/name field descriptions
1340 * @n_fields: The number of field descriptions contained in the fields array
1341 * @mod: The module creating the event, NULL if not created from a module
1342 *
1343 * Create a new synthetic event with the given name under the
1344 * trace/events/synthetic/ directory.  The event fields that will be
1345 * defined for the event should be passed in as an array of struct
1346 * synth_field_desc, and the number elements in the array passed in as
1347 * n_fields. Field ordering will retain the ordering given in the
1348 * fields array.
1349 *
1350 * If the new synthetic event is being created from a module, the mod
1351 * param must be non-NULL.  This will ensure that the trace buffer
1352 * won't contain unreadable events.
1353 *
1354 * The new synth event should be deleted using synth_event_delete()
1355 * function.  The new synthetic event can be generated from modules or
1356 * other kernel code using trace_synth_event() and related functions.
1357 *
1358 * Return: 0 if successful, error otherwise.
1359 */
1360int synth_event_create(const char *name, struct synth_field_desc *fields,
1361		       unsigned int n_fields, struct module *mod)
1362{
1363	struct dynevent_cmd cmd;
1364	char *buf;
1365	int ret;
1366
1367	buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
1368	if (!buf)
1369		return -ENOMEM;
1370
1371	synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
1372
1373	ret = synth_event_gen_cmd_array_start(&cmd, name, mod,
1374					      fields, n_fields);
1375	if (ret)
1376		goto out;
1377
1378	ret = synth_event_gen_cmd_end(&cmd);
1379 out:
1380	kfree(buf);
1381
1382	return ret;
1383}
1384EXPORT_SYMBOL_GPL(synth_event_create);
1385
1386static int destroy_synth_event(struct synth_event *se)
1387{
1388	int ret;
1389
1390	if (se->ref)
1391		return -EBUSY;
1392
1393	if (trace_event_dyn_busy(&se->call))
1394		return -EBUSY;
1395
1396	ret = unregister_synth_event(se);
1397	if (!ret) {
1398		dyn_event_remove(&se->devent);
1399		free_synth_event(se);
1400	}
1401
1402	return ret;
1403}
1404
1405/**
1406 * synth_event_delete - Delete a synthetic event
1407 * @event_name: The name of the new synthetic event
1408 *
1409 * Delete a synthetic event that was created with synth_event_create().
1410 *
1411 * Return: 0 if successful, error otherwise.
1412 */
1413int synth_event_delete(const char *event_name)
1414{
1415	struct synth_event *se = NULL;
1416	struct module *mod = NULL;
1417	int ret = -ENOENT;
1418
1419	mutex_lock(&event_mutex);
1420	se = find_synth_event(event_name);
1421	if (se) {
1422		mod = se->mod;
1423		ret = destroy_synth_event(se);
1424	}
1425	mutex_unlock(&event_mutex);
1426
1427	if (mod) {
 
1428		/*
1429		 * It is safest to reset the ring buffer if the module
1430		 * being unloaded registered any events that were
1431		 * used. The only worry is if a new module gets
1432		 * loaded, and takes on the same id as the events of
1433		 * this module. When printing out the buffer, traced
1434		 * events left over from this module may be passed to
1435		 * the new module events and unexpected results may
1436		 * occur.
1437		 */
1438		tracing_reset_all_online_cpus();
 
1439	}
1440
1441	return ret;
1442}
1443EXPORT_SYMBOL_GPL(synth_event_delete);
1444
1445static int check_command(const char *raw_command)
1446{
1447	char **argv = NULL, *cmd, *saved_cmd, *name_and_field;
1448	int argc, ret = 0;
1449
1450	cmd = saved_cmd = kstrdup(raw_command, GFP_KERNEL);
1451	if (!cmd)
1452		return -ENOMEM;
1453
1454	name_and_field = strsep(&cmd, ";");
1455	if (!name_and_field) {
1456		ret = -EINVAL;
1457		goto free;
1458	}
1459
1460	if (name_and_field[0] == '!')
1461		goto free;
1462
1463	argv = argv_split(GFP_KERNEL, name_and_field, &argc);
1464	if (!argv) {
1465		ret = -ENOMEM;
1466		goto free;
1467	}
1468	argv_free(argv);
1469
1470	if (argc < 3)
1471		ret = -EINVAL;
1472free:
1473	kfree(saved_cmd);
1474
1475	return ret;
1476}
1477
1478static int create_or_delete_synth_event(const char *raw_command)
1479{
1480	char *name = NULL, *fields, *p;
1481	int ret = 0;
1482
1483	raw_command = skip_spaces(raw_command);
1484	if (raw_command[0] == '\0')
1485		return ret;
1486
1487	last_cmd_set(raw_command);
1488
1489	ret = check_command(raw_command);
1490	if (ret) {
1491		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1492		return ret;
1493	}
1494
1495	p = strpbrk(raw_command, " \t");
1496	if (!p && raw_command[0] != '!') {
1497		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1498		ret = -EINVAL;
1499		goto free;
1500	}
1501
1502	name = kmemdup_nul(raw_command, p ? p - raw_command : strlen(raw_command), GFP_KERNEL);
1503	if (!name)
1504		return -ENOMEM;
1505
 
1506	if (name[0] == '!') {
1507		ret = synth_event_delete(name + 1);
1508		goto free;
1509	}
1510
1511	fields = skip_spaces(p);
1512
1513	ret = __create_synth_event(name, fields);
1514free:
1515	kfree(name);
1516
1517	return ret;
1518}
1519
1520static int synth_event_run_command(struct dynevent_cmd *cmd)
1521{
1522	struct synth_event *se;
1523	int ret;
1524
1525	ret = create_or_delete_synth_event(cmd->seq.buffer);
1526	if (ret)
1527		return ret;
1528
1529	se = find_synth_event(cmd->event_name);
1530	if (WARN_ON(!se))
1531		return -ENOENT;
1532
1533	se->mod = cmd->private_data;
1534
1535	return ret;
1536}
1537
1538/**
1539 * synth_event_cmd_init - Initialize a synthetic event command object
1540 * @cmd: A pointer to the dynevent_cmd struct representing the new event
1541 * @buf: A pointer to the buffer used to build the command
1542 * @maxlen: The length of the buffer passed in @buf
1543 *
1544 * Initialize a synthetic event command object.  Use this before
1545 * calling any of the other dyenvent_cmd functions.
1546 */
1547void synth_event_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen)
1548{
1549	dynevent_cmd_init(cmd, buf, maxlen, DYNEVENT_TYPE_SYNTH,
1550			  synth_event_run_command);
1551}
1552EXPORT_SYMBOL_GPL(synth_event_cmd_init);
1553
1554static inline int
1555__synth_event_trace_init(struct trace_event_file *file,
1556			 struct synth_event_trace_state *trace_state)
1557{
 
1558	int ret = 0;
1559
1560	memset(trace_state, '\0', sizeof(*trace_state));
1561
1562	/*
1563	 * Normal event tracing doesn't get called at all unless the
1564	 * ENABLED bit is set (which attaches the probe thus allowing
1565	 * this code to be called, etc).  Because this is called
1566	 * directly by the user, we don't have that but we still need
1567	 * to honor not logging when disabled.  For the iterated
1568	 * trace case, we save the enabled state upon start and just
1569	 * ignore the following data calls.
1570	 */
1571	if (!(file->flags & EVENT_FILE_FL_ENABLED) ||
1572	    trace_trigger_soft_disabled(file)) {
1573		trace_state->disabled = true;
1574		ret = -ENOENT;
1575		goto out;
1576	}
1577
1578	trace_state->event = file->event_call->data;
1579out:
1580	return ret;
1581}
1582
1583static inline int
1584__synth_event_trace_start(struct trace_event_file *file,
1585			  struct synth_event_trace_state *trace_state,
1586			  int dynamic_fields_size)
1587{
1588	int entry_size, fields_size = 0;
1589	int ret = 0;
1590
1591	fields_size = trace_state->event->n_u64 * sizeof(u64);
1592	fields_size += dynamic_fields_size;
1593
1594	/*
1595	 * Avoid ring buffer recursion detection, as this event
1596	 * is being performed within another event.
1597	 */
1598	trace_state->buffer = file->tr->array_buffer.buffer;
1599	ring_buffer_nest_start(trace_state->buffer);
1600
1601	entry_size = sizeof(*trace_state->entry) + fields_size;
1602	trace_state->entry = trace_event_buffer_reserve(&trace_state->fbuffer,
1603							file,
1604							entry_size);
1605	if (!trace_state->entry) {
1606		ring_buffer_nest_end(trace_state->buffer);
1607		ret = -EINVAL;
1608	}
1609
1610	return ret;
1611}
1612
1613static inline void
1614__synth_event_trace_end(struct synth_event_trace_state *trace_state)
1615{
1616	trace_event_buffer_commit(&trace_state->fbuffer);
1617
1618	ring_buffer_nest_end(trace_state->buffer);
1619}
1620
1621/**
1622 * synth_event_trace - Trace a synthetic event
1623 * @file: The trace_event_file representing the synthetic event
1624 * @n_vals: The number of values in vals
1625 * @args: Variable number of args containing the event values
1626 *
1627 * Trace a synthetic event using the values passed in the variable
1628 * argument list.
1629 *
1630 * The argument list should be a list 'n_vals' u64 values.  The number
1631 * of vals must match the number of field in the synthetic event, and
1632 * must be in the same order as the synthetic event fields.
1633 *
1634 * All vals should be cast to u64, and string vals are just pointers
1635 * to strings, cast to u64.  Strings will be copied into space
1636 * reserved in the event for the string, using these pointers.
1637 *
1638 * Return: 0 on success, err otherwise.
1639 */
1640int synth_event_trace(struct trace_event_file *file, unsigned int n_vals, ...)
1641{
1642	unsigned int i, n_u64, len, data_size = 0;
1643	struct synth_event_trace_state state;
 
1644	va_list args;
1645	int ret;
1646
1647	ret = __synth_event_trace_init(file, &state);
1648	if (ret) {
1649		if (ret == -ENOENT)
1650			ret = 0; /* just disabled, not really an error */
1651		return ret;
1652	}
1653
1654	if (state.event->n_dynamic_fields) {
1655		va_start(args, n_vals);
1656
1657		for (i = 0; i < state.event->n_fields; i++) {
1658			u64 val = va_arg(args, u64);
1659
1660			if (state.event->fields[i]->is_string &&
1661			    state.event->fields[i]->is_dynamic) {
1662				char *str_val = (char *)(long)val;
1663
1664				data_size += strlen(str_val) + 1;
1665			}
1666		}
1667
1668		va_end(args);
1669	}
1670
1671	ret = __synth_event_trace_start(file, &state, data_size);
1672	if (ret)
1673		return ret;
1674
1675	if (n_vals != state.event->n_fields) {
1676		ret = -EINVAL;
1677		goto out;
1678	}
1679
1680	data_size = 0;
1681
1682	va_start(args, n_vals);
1683	for (i = 0, n_u64 = 0; i < state.event->n_fields; i++) {
1684		u64 val;
1685
1686		val = va_arg(args, u64);
1687
1688		if (state.event->fields[i]->is_string) {
1689			char *str_val = (char *)(long)val;
 
1690
1691			len = trace_string(state.entry, state.event, str_val,
1692					   state.event->fields[i]->is_dynamic,
1693					   data_size, &n_u64);
1694			data_size += len; /* only dynamic string increments */
1695		} else {
1696			struct synth_field *field = state.event->fields[i];
1697
1698			switch (field->size) {
1699			case 1:
1700				*(u8 *)&state.entry->fields[n_u64] = (u8)val;
1701				break;
1702
1703			case 2:
1704				*(u16 *)&state.entry->fields[n_u64] = (u16)val;
1705				break;
1706
1707			case 4:
1708				*(u32 *)&state.entry->fields[n_u64] = (u32)val;
1709				break;
1710
1711			default:
1712				state.entry->fields[n_u64] = val;
1713				break;
1714			}
1715			n_u64++;
1716		}
1717	}
1718	va_end(args);
1719out:
1720	__synth_event_trace_end(&state);
1721
1722	return ret;
1723}
1724EXPORT_SYMBOL_GPL(synth_event_trace);
1725
1726/**
1727 * synth_event_trace_array - Trace a synthetic event from an array
1728 * @file: The trace_event_file representing the synthetic event
1729 * @vals: Array of values
1730 * @n_vals: The number of values in vals
1731 *
1732 * Trace a synthetic event using the values passed in as 'vals'.
1733 *
1734 * The 'vals' array is just an array of 'n_vals' u64.  The number of
1735 * vals must match the number of field in the synthetic event, and
1736 * must be in the same order as the synthetic event fields.
1737 *
1738 * All vals should be cast to u64, and string vals are just pointers
1739 * to strings, cast to u64.  Strings will be copied into space
1740 * reserved in the event for the string, using these pointers.
1741 *
1742 * Return: 0 on success, err otherwise.
1743 */
1744int synth_event_trace_array(struct trace_event_file *file, u64 *vals,
1745			    unsigned int n_vals)
1746{
1747	unsigned int i, n_u64, field_pos, len, data_size = 0;
1748	struct synth_event_trace_state state;
1749	char *str_val;
1750	int ret;
1751
1752	ret = __synth_event_trace_init(file, &state);
1753	if (ret) {
1754		if (ret == -ENOENT)
1755			ret = 0; /* just disabled, not really an error */
1756		return ret;
1757	}
1758
1759	if (state.event->n_dynamic_fields) {
1760		for (i = 0; i < state.event->n_dynamic_fields; i++) {
1761			field_pos = state.event->dynamic_fields[i]->field_pos;
1762			str_val = (char *)(long)vals[field_pos];
1763			len = strlen(str_val) + 1;
1764			data_size += len;
1765		}
1766	}
1767
1768	ret = __synth_event_trace_start(file, &state, data_size);
1769	if (ret)
1770		return ret;
1771
1772	if (n_vals != state.event->n_fields) {
1773		ret = -EINVAL;
1774		goto out;
1775	}
1776
1777	data_size = 0;
1778
1779	for (i = 0, n_u64 = 0; i < state.event->n_fields; i++) {
1780		if (state.event->fields[i]->is_string) {
1781			char *str_val = (char *)(long)vals[i];
 
1782
1783			len = trace_string(state.entry, state.event, str_val,
1784					   state.event->fields[i]->is_dynamic,
1785					   data_size, &n_u64);
1786			data_size += len; /* only dynamic string increments */
1787		} else {
1788			struct synth_field *field = state.event->fields[i];
1789			u64 val = vals[i];
1790
1791			switch (field->size) {
1792			case 1:
1793				*(u8 *)&state.entry->fields[n_u64] = (u8)val;
1794				break;
1795
1796			case 2:
1797				*(u16 *)&state.entry->fields[n_u64] = (u16)val;
1798				break;
1799
1800			case 4:
1801				*(u32 *)&state.entry->fields[n_u64] = (u32)val;
1802				break;
1803
1804			default:
1805				state.entry->fields[n_u64] = val;
1806				break;
1807			}
1808			n_u64++;
1809		}
1810	}
1811out:
1812	__synth_event_trace_end(&state);
1813
1814	return ret;
1815}
1816EXPORT_SYMBOL_GPL(synth_event_trace_array);
1817
1818/**
1819 * synth_event_trace_start - Start piecewise synthetic event trace
1820 * @file: The trace_event_file representing the synthetic event
1821 * @trace_state: A pointer to object tracking the piecewise trace state
1822 *
1823 * Start the trace of a synthetic event field-by-field rather than all
1824 * at once.
1825 *
1826 * This function 'opens' an event trace, which means space is reserved
1827 * for the event in the trace buffer, after which the event's
1828 * individual field values can be set through either
1829 * synth_event_add_next_val() or synth_event_add_val().
1830 *
1831 * A pointer to a trace_state object is passed in, which will keep
1832 * track of the current event trace state until the event trace is
1833 * closed (and the event finally traced) using
1834 * synth_event_trace_end().
1835 *
1836 * Note that synth_event_trace_end() must be called after all values
1837 * have been added for each event trace, regardless of whether adding
1838 * all field values succeeded or not.
1839 *
1840 * Note also that for a given event trace, all fields must be added
1841 * using either synth_event_add_next_val() or synth_event_add_val()
1842 * but not both together or interleaved.
1843 *
1844 * Return: 0 on success, err otherwise.
1845 */
1846int synth_event_trace_start(struct trace_event_file *file,
1847			    struct synth_event_trace_state *trace_state)
1848{
1849	int ret;
1850
1851	if (!trace_state)
1852		return -EINVAL;
1853
1854	ret = __synth_event_trace_init(file, trace_state);
1855	if (ret) {
1856		if (ret == -ENOENT)
1857			ret = 0; /* just disabled, not really an error */
1858		return ret;
1859	}
1860
1861	if (trace_state->event->n_dynamic_fields)
1862		return -ENOTSUPP;
1863
1864	ret = __synth_event_trace_start(file, trace_state, 0);
1865
1866	return ret;
1867}
1868EXPORT_SYMBOL_GPL(synth_event_trace_start);
1869
1870static int __synth_event_add_val(const char *field_name, u64 val,
1871				 struct synth_event_trace_state *trace_state)
1872{
1873	struct synth_field *field = NULL;
1874	struct synth_trace_event *entry;
1875	struct synth_event *event;
1876	int i, ret = 0;
1877
1878	if (!trace_state) {
1879		ret = -EINVAL;
1880		goto out;
1881	}
1882
1883	/* can't mix add_next_synth_val() with add_synth_val() */
1884	if (field_name) {
1885		if (trace_state->add_next) {
1886			ret = -EINVAL;
1887			goto out;
1888		}
1889		trace_state->add_name = true;
1890	} else {
1891		if (trace_state->add_name) {
1892			ret = -EINVAL;
1893			goto out;
1894		}
1895		trace_state->add_next = true;
1896	}
1897
1898	if (trace_state->disabled)
1899		goto out;
1900
1901	event = trace_state->event;
1902	if (trace_state->add_name) {
1903		for (i = 0; i < event->n_fields; i++) {
1904			field = event->fields[i];
1905			if (strcmp(field->name, field_name) == 0)
1906				break;
1907		}
1908		if (!field) {
1909			ret = -EINVAL;
1910			goto out;
1911		}
1912	} else {
1913		if (trace_state->cur_field >= event->n_fields) {
1914			ret = -EINVAL;
1915			goto out;
1916		}
1917		field = event->fields[trace_state->cur_field++];
1918	}
1919
1920	entry = trace_state->entry;
1921	if (field->is_string) {
1922		char *str_val = (char *)(long)val;
1923		char *str_field;
1924
1925		if (field->is_dynamic) { /* add_val can't do dynamic strings */
1926			ret = -EINVAL;
1927			goto out;
1928		}
1929
1930		if (!str_val) {
1931			ret = -EINVAL;
1932			goto out;
1933		}
1934
1935		str_field = (char *)&entry->fields[field->offset];
1936		strscpy(str_field, str_val, STR_VAR_LEN_MAX);
1937	} else {
1938		switch (field->size) {
1939		case 1:
1940			*(u8 *)&trace_state->entry->fields[field->offset] = (u8)val;
1941			break;
1942
1943		case 2:
1944			*(u16 *)&trace_state->entry->fields[field->offset] = (u16)val;
1945			break;
1946
1947		case 4:
1948			*(u32 *)&trace_state->entry->fields[field->offset] = (u32)val;
1949			break;
1950
1951		default:
1952			trace_state->entry->fields[field->offset] = val;
1953			break;
1954		}
1955	}
1956 out:
1957	return ret;
1958}
1959
1960/**
1961 * synth_event_add_next_val - Add the next field's value to an open synth trace
1962 * @val: The value to set the next field to
1963 * @trace_state: A pointer to object tracking the piecewise trace state
1964 *
1965 * Set the value of the next field in an event that's been opened by
1966 * synth_event_trace_start().
1967 *
1968 * The val param should be the value cast to u64.  If the value points
1969 * to a string, the val param should be a char * cast to u64.
1970 *
1971 * This function assumes all the fields in an event are to be set one
1972 * after another - successive calls to this function are made, one for
1973 * each field, in the order of the fields in the event, until all
1974 * fields have been set.  If you'd rather set each field individually
1975 * without regard to ordering, synth_event_add_val() can be used
1976 * instead.
1977 *
1978 * Note however that synth_event_add_next_val() and
1979 * synth_event_add_val() can't be intermixed for a given event trace -
1980 * one or the other but not both can be used at the same time.
1981 *
1982 * Note also that synth_event_trace_end() must be called after all
1983 * values have been added for each event trace, regardless of whether
1984 * adding all field values succeeded or not.
1985 *
1986 * Return: 0 on success, err otherwise.
1987 */
1988int synth_event_add_next_val(u64 val,
1989			     struct synth_event_trace_state *trace_state)
1990{
1991	return __synth_event_add_val(NULL, val, trace_state);
1992}
1993EXPORT_SYMBOL_GPL(synth_event_add_next_val);
1994
1995/**
1996 * synth_event_add_val - Add a named field's value to an open synth trace
1997 * @field_name: The name of the synthetic event field value to set
1998 * @val: The value to set the named field to
1999 * @trace_state: A pointer to object tracking the piecewise trace state
2000 *
2001 * Set the value of the named field in an event that's been opened by
2002 * synth_event_trace_start().
2003 *
2004 * The val param should be the value cast to u64.  If the value points
2005 * to a string, the val param should be a char * cast to u64.
2006 *
2007 * This function looks up the field name, and if found, sets the field
2008 * to the specified value.  This lookup makes this function more
2009 * expensive than synth_event_add_next_val(), so use that or the
2010 * none-piecewise synth_event_trace() instead if efficiency is more
2011 * important.
2012 *
2013 * Note however that synth_event_add_next_val() and
2014 * synth_event_add_val() can't be intermixed for a given event trace -
2015 * one or the other but not both can be used at the same time.
2016 *
2017 * Note also that synth_event_trace_end() must be called after all
2018 * values have been added for each event trace, regardless of whether
2019 * adding all field values succeeded or not.
2020 *
2021 * Return: 0 on success, err otherwise.
2022 */
2023int synth_event_add_val(const char *field_name, u64 val,
2024			struct synth_event_trace_state *trace_state)
2025{
2026	return __synth_event_add_val(field_name, val, trace_state);
2027}
2028EXPORT_SYMBOL_GPL(synth_event_add_val);
2029
2030/**
2031 * synth_event_trace_end - End piecewise synthetic event trace
2032 * @trace_state: A pointer to object tracking the piecewise trace state
2033 *
2034 * End the trace of a synthetic event opened by
2035 * synth_event_trace__start().
2036 *
2037 * This function 'closes' an event trace, which basically means that
2038 * it commits the reserved event and cleans up other loose ends.
2039 *
2040 * A pointer to a trace_state object is passed in, which will keep
2041 * track of the current event trace state opened with
2042 * synth_event_trace_start().
2043 *
2044 * Note that this function must be called after all values have been
2045 * added for each event trace, regardless of whether adding all field
2046 * values succeeded or not.
2047 *
2048 * Return: 0 on success, err otherwise.
2049 */
2050int synth_event_trace_end(struct synth_event_trace_state *trace_state)
2051{
2052	if (!trace_state)
2053		return -EINVAL;
2054
2055	__synth_event_trace_end(trace_state);
2056
2057	return 0;
2058}
2059EXPORT_SYMBOL_GPL(synth_event_trace_end);
2060
2061static int create_synth_event(const char *raw_command)
2062{
2063	char *fields, *p;
2064	const char *name;
2065	int len, ret = 0;
2066
2067	raw_command = skip_spaces(raw_command);
2068	if (raw_command[0] == '\0')
2069		return ret;
2070
2071	last_cmd_set(raw_command);
2072
2073	name = raw_command;
2074
2075	/* Don't try to process if not our system */
2076	if (name[0] != 's' || name[1] != ':')
2077		return -ECANCELED;
2078	name += 2;
2079
2080	p = strpbrk(raw_command, " \t");
2081	if (!p) {
2082		synth_err(SYNTH_ERR_INVALID_CMD, 0);
2083		return -EINVAL;
2084	}
2085
2086	fields = skip_spaces(p);
2087
2088	/* This interface accepts group name prefix */
2089	if (strchr(name, '/')) {
2090		len = str_has_prefix(name, SYNTH_SYSTEM "/");
2091		if (len == 0) {
2092			synth_err(SYNTH_ERR_INVALID_DYN_CMD, 0);
2093			return -EINVAL;
2094		}
2095		name += len;
2096	}
2097
2098	len = name - raw_command;
2099
2100	ret = check_command(raw_command + len);
2101	if (ret) {
2102		synth_err(SYNTH_ERR_INVALID_CMD, 0);
2103		return ret;
2104	}
2105
2106	name = kmemdup_nul(raw_command + len, p - raw_command - len, GFP_KERNEL);
2107	if (!name)
2108		return -ENOMEM;
2109
2110	ret = __create_synth_event(name, fields);
2111
2112	kfree(name);
2113
2114	return ret;
2115}
2116
2117static int synth_event_release(struct dyn_event *ev)
2118{
2119	struct synth_event *event = to_synth_event(ev);
2120	int ret;
2121
2122	if (event->ref)
2123		return -EBUSY;
2124
2125	if (trace_event_dyn_busy(&event->call))
2126		return -EBUSY;
2127
2128	ret = unregister_synth_event(event);
2129	if (ret)
2130		return ret;
2131
2132	dyn_event_remove(ev);
2133	free_synth_event(event);
2134	return 0;
2135}
2136
2137static int __synth_event_show(struct seq_file *m, struct synth_event *event)
2138{
2139	struct synth_field *field;
2140	unsigned int i;
2141	char *type, *t;
2142
2143	seq_printf(m, "%s\t", event->name);
2144
2145	for (i = 0; i < event->n_fields; i++) {
2146		field = event->fields[i];
2147
2148		type = field->type;
2149		t = strstr(type, "__data_loc");
2150		if (t) { /* __data_loc belongs in format but not event desc */
2151			t += sizeof("__data_loc");
2152			type = t;
2153		}
2154
2155		/* parameter values */
2156		seq_printf(m, "%s %s%s", type, field->name,
2157			   i == event->n_fields - 1 ? "" : "; ");
2158	}
2159
2160	seq_putc(m, '\n');
2161
2162	return 0;
2163}
2164
2165static int synth_event_show(struct seq_file *m, struct dyn_event *ev)
2166{
2167	struct synth_event *event = to_synth_event(ev);
2168
2169	seq_printf(m, "s:%s/", event->class.system);
2170
2171	return __synth_event_show(m, event);
2172}
2173
2174static int synth_events_seq_show(struct seq_file *m, void *v)
2175{
2176	struct dyn_event *ev = v;
2177
2178	if (!is_synth_event(ev))
2179		return 0;
2180
2181	return __synth_event_show(m, to_synth_event(ev));
2182}
2183
2184static const struct seq_operations synth_events_seq_op = {
2185	.start	= dyn_event_seq_start,
2186	.next	= dyn_event_seq_next,
2187	.stop	= dyn_event_seq_stop,
2188	.show	= synth_events_seq_show,
2189};
2190
2191static int synth_events_open(struct inode *inode, struct file *file)
2192{
2193	int ret;
2194
2195	ret = security_locked_down(LOCKDOWN_TRACEFS);
2196	if (ret)
2197		return ret;
2198
2199	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
2200		ret = dyn_events_release_all(&synth_event_ops);
2201		if (ret < 0)
2202			return ret;
2203	}
2204
2205	return seq_open(file, &synth_events_seq_op);
2206}
2207
2208static ssize_t synth_events_write(struct file *file,
2209				  const char __user *buffer,
2210				  size_t count, loff_t *ppos)
2211{
2212	return trace_parse_run_command(file, buffer, count, ppos,
2213				       create_or_delete_synth_event);
2214}
2215
2216static const struct file_operations synth_events_fops = {
2217	.open           = synth_events_open,
2218	.write		= synth_events_write,
2219	.read           = seq_read,
2220	.llseek         = seq_lseek,
2221	.release        = seq_release,
2222};
2223
2224/*
2225 * Register dynevent at core_initcall. This allows kernel to setup kprobe
2226 * events in postcore_initcall without tracefs.
2227 */
2228static __init int trace_events_synth_init_early(void)
2229{
 
 
2230	int err = 0;
2231
2232	err = dyn_event_register(&synth_event_ops);
2233	if (err)
2234		pr_warn("Could not register synth_event_ops\n");
 
 
2235
2236	return err;
2237}
2238core_initcall(trace_events_synth_init_early);
2239
2240static __init int trace_events_synth_init(void)
2241{
2242	struct dentry *entry = NULL;
2243	int err = 0;
2244	err = tracing_init_dentry();
2245	if (err)
2246		goto err;
 
2247
2248	entry = tracefs_create_file("synthetic_events", TRACE_MODE_WRITE,
2249				    NULL, NULL, &synth_events_fops);
2250	if (!entry) {
2251		err = -ENODEV;
2252		goto err;
2253	}
2254
2255	return err;
2256 err:
2257	pr_warn("Could not create tracefs 'synthetic_events' entry\n");
2258
2259	return err;
2260}
2261
2262fs_initcall(trace_events_synth_init);