1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Test module for in-kernel synthetic event creation and generation.
4  *
5  * Copyright (C) 2019 Tom Zanussi <zanussi@kernel.org>
6  */
7 
8 #include <linux/module.h>
9 #include <linux/trace_events.h>
10 
11 /*
12  * This module is a simple test of basic functionality for in-kernel
13  * synthetic event creation and generation, the first and second tests
14  * using synth_event_gen_cmd_start() and synth_event_add_field(), the
15  * third uses synth_event_create() to do it all at once with a static
16  * field array.
17  *
18  * Following that are a few examples using the created events to test
19  * various ways of tracing a synthetic event.
20  *
21  * To test, select CONFIG_SYNTH_EVENT_GEN_TEST and build the module.
22  * Then:
23  *
24  * # insmod kernel/trace/synth_event_gen_test.ko
25  * # cat /sys/kernel/debug/tracing/trace
26  *
27  * You should see several events in the trace buffer -
28  * "create_synth_test", "empty_synth_test", and several instances of
29  * "gen_synth_test".
30  *
31  * To remove the events, remove the module:
32  *
33  * # rmmod synth_event_gen_test
34  *
35  */
36 
37 static struct trace_event_file *create_synth_test;
38 static struct trace_event_file *empty_synth_test;
39 static struct trace_event_file *gen_synth_test;
40 
41 /*
42  * Test to make sure we can create a synthetic event, then add more
43  * fields.
44  */
45 static int __init test_gen_synth_cmd(void)
46 {
47 	struct dynevent_cmd cmd;
48 	u64 vals[7];
49 	char *buf;
50 	int ret;
51 
52 	/* Create a buffer to hold the generated command */
53 	buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
54 	if (!buf)
55 		return -ENOMEM;
56 
57 	/* Before generating the command, initialize the cmd object */
58 	synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
59 
60 	/*
61 	 * Create the empty gen_synth_test synthetic event with the
62 	 * first 4 fields.
63 	 */
64 	ret = synth_event_gen_cmd_start(&cmd, "gen_synth_test", THIS_MODULE,
65 					"pid_t", "next_pid_field",
66 					"char[16]", "next_comm_field",
67 					"u64", "ts_ns",
68 					"u64", "ts_ms");
69 	if (ret)
70 		goto free;
71 
72 	/* Use synth_event_add_field to add the rest of the fields */
73 
74 	ret = synth_event_add_field(&cmd, "unsigned int", "cpu");
75 	if (ret)
76 		goto free;
77 
78 	ret = synth_event_add_field(&cmd, "char[64]", "my_string_field");
79 	if (ret)
80 		goto free;
81 
82 	ret = synth_event_add_field(&cmd, "int", "my_int_field");
83 	if (ret)
84 		goto free;
85 
86 	ret = synth_event_gen_cmd_end(&cmd);
87 	if (ret)
88 		goto free;
89 
90 	/*
91 	 * Now get the gen_synth_test event file.  We need to prevent
92 	 * the instance and event from disappearing from underneath
93 	 * us, which trace_get_event_file() does (though in this case
94 	 * we're using the top-level instance which never goes away).
95 	 */
96 	gen_synth_test = trace_get_event_file(NULL, "synthetic",
97 					      "gen_synth_test");
98 	if (IS_ERR(gen_synth_test)) {
99 		ret = PTR_ERR(gen_synth_test);
100 		goto delete;
101 	}
102 
103 	/* Enable the event or you won't see anything */
104 	ret = trace_array_set_clr_event(gen_synth_test->tr,
105 					"synthetic", "gen_synth_test", true);
106 	if (ret) {
107 		trace_put_event_file(gen_synth_test);
108 		goto delete;
109 	}
110 
111 	/* Create some bogus values just for testing */
112 
113 	vals[0] = 777;			/* next_pid_field */
114 	vals[1] = (u64)(long)"hula hoops";	/* next_comm_field */
115 	vals[2] = 1000000;		/* ts_ns */
116 	vals[3] = 1000;			/* ts_ms */
117 	vals[4] = raw_smp_processor_id(); /* cpu */
118 	vals[5] = (u64)(long)"thneed";	/* my_string_field */
119 	vals[6] = 598;			/* my_int_field */
120 
121 	/* Now generate a gen_synth_test event */
122 	ret = synth_event_trace_array(gen_synth_test, vals, ARRAY_SIZE(vals));
123  out:
124 	return ret;
125  delete:
126 	/* We got an error after creating the event, delete it */
127 	synth_event_delete("gen_synth_test");
128  free:
129 	kfree(buf);
130 
131 	goto out;
132 }
133 
134 /*
135  * Test to make sure we can create an initially empty synthetic event,
136  * then add all the fields.
137  */
138 static int __init test_empty_synth_event(void)
139 {
140 	struct dynevent_cmd cmd;
141 	u64 vals[7];
142 	char *buf;
143 	int ret;
144 
145 	/* Create a buffer to hold the generated command */
146 	buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
147 	if (!buf)
148 		return -ENOMEM;
149 
150 	/* Before generating the command, initialize the cmd object */
151 	synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
152 
153 	/*
154 	 * Create the empty_synth_test synthetic event with no fields.
155 	 */
156 	ret = synth_event_gen_cmd_start(&cmd, "empty_synth_test", THIS_MODULE);
157 	if (ret)
158 		goto free;
159 
160 	/* Use synth_event_add_field to add all of the fields */
161 
162 	ret = synth_event_add_field(&cmd, "pid_t", "next_pid_field");
163 	if (ret)
164 		goto free;
165 
166 	ret = synth_event_add_field(&cmd, "char[16]", "next_comm_field");
167 	if (ret)
168 		goto free;
169 
170 	ret = synth_event_add_field(&cmd, "u64", "ts_ns");
171 	if (ret)
172 		goto free;
173 
174 	ret = synth_event_add_field(&cmd, "u64", "ts_ms");
175 	if (ret)
176 		goto free;
177 
178 	ret = synth_event_add_field(&cmd, "unsigned int", "cpu");
179 	if (ret)
180 		goto free;
181 
182 	ret = synth_event_add_field(&cmd, "char[64]", "my_string_field");
183 	if (ret)
184 		goto free;
185 
186 	ret = synth_event_add_field(&cmd, "int", "my_int_field");
187 	if (ret)
188 		goto free;
189 
190 	/* All fields have been added, close and register the synth event */
191 
192 	ret = synth_event_gen_cmd_end(&cmd);
193 	if (ret)
194 		goto free;
195 
196 	/*
197 	 * Now get the empty_synth_test event file.  We need to
198 	 * prevent the instance and event from disappearing from
199 	 * underneath us, which trace_get_event_file() does (though in
200 	 * this case we're using the top-level instance which never
201 	 * goes away).
202 	 */
203 	empty_synth_test = trace_get_event_file(NULL, "synthetic",
204 						"empty_synth_test");
205 	if (IS_ERR(empty_synth_test)) {
206 		ret = PTR_ERR(empty_synth_test);
207 		goto delete;
208 	}
209 
210 	/* Enable the event or you won't see anything */
211 	ret = trace_array_set_clr_event(empty_synth_test->tr,
212 					"synthetic", "empty_synth_test", true);
213 	if (ret) {
214 		trace_put_event_file(empty_synth_test);
215 		goto delete;
216 	}
217 
218 	/* Create some bogus values just for testing */
219 
220 	vals[0] = 777;			/* next_pid_field */
221 	vals[1] = (u64)(long)"tiddlywinks";	/* next_comm_field */
222 	vals[2] = 1000000;		/* ts_ns */
223 	vals[3] = 1000;			/* ts_ms */
224 	vals[4] = raw_smp_processor_id(); /* cpu */
225 	vals[5] = (u64)(long)"thneed_2.0";	/* my_string_field */
226 	vals[6] = 399;			/* my_int_field */
227 
228 	/* Now trace an empty_synth_test event */
229 	ret = synth_event_trace_array(empty_synth_test, vals, ARRAY_SIZE(vals));
230  out:
231 	return ret;
232  delete:
233 	/* We got an error after creating the event, delete it */
234 	synth_event_delete("empty_synth_test");
235  free:
236 	kfree(buf);
237 
238 	goto out;
239 }
240 
241 static struct synth_field_desc create_synth_test_fields[] = {
242 	{ .type = "pid_t",		.name = "next_pid_field" },
243 	{ .type = "char[16]",		.name = "next_comm_field" },
244 	{ .type = "u64",		.name = "ts_ns" },
245 	{ .type = "char[]",		.name = "dynstring_field_1" },
246 	{ .type = "u64",		.name = "ts_ms" },
247 	{ .type = "unsigned int",	.name = "cpu" },
248 	{ .type = "char[64]",		.name = "my_string_field" },
249 	{ .type = "char[]",		.name = "dynstring_field_2" },
250 	{ .type = "int",		.name = "my_int_field" },
251 };
252 
253 /*
254  * Test synthetic event creation all at once from array of field
255  * descriptors.
256  */
257 static int __init test_create_synth_event(void)
258 {
259 	u64 vals[9];
260 	int ret;
261 
262 	/* Create the create_synth_test event with the fields above */
263 	ret = synth_event_create("create_synth_test",
264 				 create_synth_test_fields,
265 				 ARRAY_SIZE(create_synth_test_fields),
266 				 THIS_MODULE);
267 	if (ret)
268 		goto out;
269 
270 	/*
271 	 * Now get the create_synth_test event file.  We need to
272 	 * prevent the instance and event from disappearing from
273 	 * underneath us, which trace_get_event_file() does (though in
274 	 * this case we're using the top-level instance which never
275 	 * goes away).
276 	 */
277 	create_synth_test = trace_get_event_file(NULL, "synthetic",
278 						 "create_synth_test");
279 	if (IS_ERR(create_synth_test)) {
280 		ret = PTR_ERR(create_synth_test);
281 		goto delete;
282 	}
283 
284 	/* Enable the event or you won't see anything */
285 	ret = trace_array_set_clr_event(create_synth_test->tr,
286 					"synthetic", "create_synth_test", true);
287 	if (ret) {
288 		trace_put_event_file(create_synth_test);
289 		goto delete;
290 	}
291 
292 	/* Create some bogus values just for testing */
293 
294 	vals[0] = 777;			/* next_pid_field */
295 	vals[1] = (u64)(long)"tiddlywinks";	/* next_comm_field */
296 	vals[2] = 1000000;		/* ts_ns */
297 	vals[3] = (u64)(long)"xrayspecs";	/* dynstring_field_1 */
298 	vals[4] = 1000;			/* ts_ms */
299 	vals[5] = raw_smp_processor_id(); /* cpu */
300 	vals[6] = (u64)(long)"thneed";	/* my_string_field */
301 	vals[7] = (u64)(long)"kerplunk";	/* dynstring_field_2 */
302 	vals[8] = 398;			/* my_int_field */
303 
304 	/* Now generate a create_synth_test event */
305 	ret = synth_event_trace_array(create_synth_test, vals, ARRAY_SIZE(vals));
306  out:
307 	return ret;
308  delete:
309 	/* We got an error after creating the event, delete it */
310 	synth_event_delete("create_synth_test");
311 
312 	goto out;
313 }
314 
315 /*
316  * Test tracing a synthetic event by reserving trace buffer space,
317  * then filling in fields one after another.
318  */
319 static int __init test_add_next_synth_val(void)
320 {
321 	struct synth_event_trace_state trace_state;
322 	int ret;
323 
324 	/* Start by reserving space in the trace buffer */
325 	ret = synth_event_trace_start(gen_synth_test, &trace_state);
326 	if (ret)
327 		return ret;
328 
329 	/* Write some bogus values into the trace buffer, one after another */
330 
331 	/* next_pid_field */
332 	ret = synth_event_add_next_val(777, &trace_state);
333 	if (ret)
334 		goto out;
335 
336 	/* next_comm_field */
337 	ret = synth_event_add_next_val((u64)(long)"slinky", &trace_state);
338 	if (ret)
339 		goto out;
340 
341 	/* ts_ns */
342 	ret = synth_event_add_next_val(1000000, &trace_state);
343 	if (ret)
344 		goto out;
345 
346 	/* ts_ms */
347 	ret = synth_event_add_next_val(1000, &trace_state);
348 	if (ret)
349 		goto out;
350 
351 	/* cpu */
352 	ret = synth_event_add_next_val(raw_smp_processor_id(), &trace_state);
353 	if (ret)
354 		goto out;
355 
356 	/* my_string_field */
357 	ret = synth_event_add_next_val((u64)(long)"thneed_2.01", &trace_state);
358 	if (ret)
359 		goto out;
360 
361 	/* my_int_field */
362 	ret = synth_event_add_next_val(395, &trace_state);
363  out:
364 	/* Finally, commit the event */
365 	ret = synth_event_trace_end(&trace_state);
366 
367 	return ret;
368 }
369 
370 /*
371  * Test tracing a synthetic event by reserving trace buffer space,
372  * then filling in fields using field names, which can be done in any
373  * order.
374  */
375 static int __init test_add_synth_val(void)
376 {
377 	struct synth_event_trace_state trace_state;
378 	int ret;
379 
380 	/* Start by reserving space in the trace buffer */
381 	ret = synth_event_trace_start(gen_synth_test, &trace_state);
382 	if (ret)
383 		return ret;
384 
385 	/* Write some bogus values into the trace buffer, using field names */
386 
387 	ret = synth_event_add_val("ts_ns", 1000000, &trace_state);
388 	if (ret)
389 		goto out;
390 
391 	ret = synth_event_add_val("ts_ms", 1000, &trace_state);
392 	if (ret)
393 		goto out;
394 
395 	ret = synth_event_add_val("cpu", raw_smp_processor_id(), &trace_state);
396 	if (ret)
397 		goto out;
398 
399 	ret = synth_event_add_val("next_pid_field", 777, &trace_state);
400 	if (ret)
401 		goto out;
402 
403 	ret = synth_event_add_val("next_comm_field", (u64)(long)"silly putty",
404 				  &trace_state);
405 	if (ret)
406 		goto out;
407 
408 	ret = synth_event_add_val("my_string_field", (u64)(long)"thneed_9",
409 				  &trace_state);
410 	if (ret)
411 		goto out;
412 
413 	ret = synth_event_add_val("my_int_field", 3999, &trace_state);
414  out:
415 	/* Finally, commit the event */
416 	ret = synth_event_trace_end(&trace_state);
417 
418 	return ret;
419 }
420 
421 /*
422  * Test tracing a synthetic event all at once from array of values.
423  */
424 static int __init test_trace_synth_event(void)
425 {
426 	int ret;
427 
428 	/* Trace some bogus values just for testing */
429 	ret = synth_event_trace(create_synth_test, 9,	/* number of values */
430 				(u64)444,		/* next_pid_field */
431 				(u64)(long)"clackers",	/* next_comm_field */
432 				(u64)1000000,		/* ts_ns */
433 				(u64)(long)"viewmaster",/* dynstring_field_1 */
434 				(u64)1000,		/* ts_ms */
435 				(u64)raw_smp_processor_id(), /* cpu */
436 				(u64)(long)"Thneed",	/* my_string_field */
437 				(u64)(long)"yoyos",	/* dynstring_field_2 */
438 				(u64)999);		/* my_int_field */
439 	return ret;
440 }
441 
442 static int __init synth_event_gen_test_init(void)
443 {
444 	int ret;
445 
446 	ret = test_gen_synth_cmd();
447 	if (ret)
448 		return ret;
449 
450 	ret = test_empty_synth_event();
451 	if (ret) {
452 		WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
453 						  "synthetic",
454 						  "gen_synth_test", false));
455 		trace_put_event_file(gen_synth_test);
456 		WARN_ON(synth_event_delete("gen_synth_test"));
457 		goto out;
458 	}
459 
460 	ret = test_create_synth_event();
461 	if (ret) {
462 		WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
463 						  "synthetic",
464 						  "gen_synth_test", false));
465 		trace_put_event_file(gen_synth_test);
466 		WARN_ON(synth_event_delete("gen_synth_test"));
467 
468 		WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
469 						  "synthetic",
470 						  "empty_synth_test", false));
471 		trace_put_event_file(empty_synth_test);
472 		WARN_ON(synth_event_delete("empty_synth_test"));
473 		goto out;
474 	}
475 
476 	ret = test_add_next_synth_val();
477 	WARN_ON(ret);
478 
479 	ret = test_add_synth_val();
480 	WARN_ON(ret);
481 
482 	ret = test_trace_synth_event();
483 	WARN_ON(ret);
484  out:
485 	return ret;
486 }
487 
488 static void __exit synth_event_gen_test_exit(void)
489 {
490 	/* Disable the event or you can't remove it */
491 	WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
492 					  "synthetic",
493 					  "gen_synth_test", false));
494 
495 	/* Now give the file and instance back */
496 	trace_put_event_file(gen_synth_test);
497 
498 	/* Now unregister and free the synthetic event */
499 	WARN_ON(synth_event_delete("gen_synth_test"));
500 
501 	/* Disable the event or you can't remove it */
502 	WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
503 					  "synthetic",
504 					  "empty_synth_test", false));
505 
506 	/* Now give the file and instance back */
507 	trace_put_event_file(empty_synth_test);
508 
509 	/* Now unregister and free the synthetic event */
510 	WARN_ON(synth_event_delete("empty_synth_test"));
511 
512 	/* Disable the event or you can't remove it */
513 	WARN_ON(trace_array_set_clr_event(create_synth_test->tr,
514 					  "synthetic",
515 					  "create_synth_test", false));
516 
517 	/* Now give the file and instance back */
518 	trace_put_event_file(create_synth_test);
519 
520 	/* Now unregister and free the synthetic event */
521 	WARN_ON(synth_event_delete("create_synth_test"));
522 }
523 
524 module_init(synth_event_gen_test_init)
525 module_exit(synth_event_gen_test_exit)
526 
527 MODULE_AUTHOR("Tom Zanussi");
528 MODULE_DESCRIPTION("synthetic event generation test");
529 MODULE_LICENSE("GPL v2");
530