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/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  free:
124 	kfree(buf);
125 	return ret;
126  delete:
127 	/* We got an error after creating the event, delete it */
128 	synth_event_delete("gen_synth_test");
129 	goto free;
130 }
131 
132 /*
133  * Test to make sure we can create an initially empty synthetic event,
134  * then add all the fields.
135  */
136 static int __init test_empty_synth_event(void)
137 {
138 	struct dynevent_cmd cmd;
139 	u64 vals[7];
140 	char *buf;
141 	int ret;
142 
143 	/* Create a buffer to hold the generated command */
144 	buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
145 	if (!buf)
146 		return -ENOMEM;
147 
148 	/* Before generating the command, initialize the cmd object */
149 	synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
150 
151 	/*
152 	 * Create the empty_synth_test synthetic event with no fields.
153 	 */
154 	ret = synth_event_gen_cmd_start(&cmd, "empty_synth_test", THIS_MODULE);
155 	if (ret)
156 		goto free;
157 
158 	/* Use synth_event_add_field to add all of the fields */
159 
160 	ret = synth_event_add_field(&cmd, "pid_t", "next_pid_field");
161 	if (ret)
162 		goto free;
163 
164 	ret = synth_event_add_field(&cmd, "char[16]", "next_comm_field");
165 	if (ret)
166 		goto free;
167 
168 	ret = synth_event_add_field(&cmd, "u64", "ts_ns");
169 	if (ret)
170 		goto free;
171 
172 	ret = synth_event_add_field(&cmd, "u64", "ts_ms");
173 	if (ret)
174 		goto free;
175 
176 	ret = synth_event_add_field(&cmd, "unsigned int", "cpu");
177 	if (ret)
178 		goto free;
179 
180 	ret = synth_event_add_field(&cmd, "char[64]", "my_string_field");
181 	if (ret)
182 		goto free;
183 
184 	ret = synth_event_add_field(&cmd, "int", "my_int_field");
185 	if (ret)
186 		goto free;
187 
188 	/* All fields have been added, close and register the synth event */
189 
190 	ret = synth_event_gen_cmd_end(&cmd);
191 	if (ret)
192 		goto free;
193 
194 	/*
195 	 * Now get the empty_synth_test event file.  We need to
196 	 * prevent the instance and event from disappearing from
197 	 * underneath us, which trace_get_event_file() does (though in
198 	 * this case we're using the top-level instance which never
199 	 * goes away).
200 	 */
201 	empty_synth_test = trace_get_event_file(NULL, "synthetic",
202 						"empty_synth_test");
203 	if (IS_ERR(empty_synth_test)) {
204 		ret = PTR_ERR(empty_synth_test);
205 		goto delete;
206 	}
207 
208 	/* Enable the event or you won't see anything */
209 	ret = trace_array_set_clr_event(empty_synth_test->tr,
210 					"synthetic", "empty_synth_test", true);
211 	if (ret) {
212 		trace_put_event_file(empty_synth_test);
213 		goto delete;
214 	}
215 
216 	/* Create some bogus values just for testing */
217 
218 	vals[0] = 777;			/* next_pid_field */
219 	vals[1] = (u64)(long)"tiddlywinks";	/* next_comm_field */
220 	vals[2] = 1000000;		/* ts_ns */
221 	vals[3] = 1000;			/* ts_ms */
222 	vals[4] = raw_smp_processor_id(); /* cpu */
223 	vals[5] = (u64)(long)"thneed_2.0";	/* my_string_field */
224 	vals[6] = 399;			/* my_int_field */
225 
226 	/* Now trace an empty_synth_test event */
227 	ret = synth_event_trace_array(empty_synth_test, vals, ARRAY_SIZE(vals));
228  free:
229 	kfree(buf);
230 	return ret;
231  delete:
232 	/* We got an error after creating the event, delete it */
233 	synth_event_delete("empty_synth_test");
234 	goto free;
235 }
236 
237 static struct synth_field_desc create_synth_test_fields[] = {
238 	{ .type = "pid_t",		.name = "next_pid_field" },
239 	{ .type = "char[16]",		.name = "next_comm_field" },
240 	{ .type = "u64",		.name = "ts_ns" },
241 	{ .type = "char[]",		.name = "dynstring_field_1" },
242 	{ .type = "u64",		.name = "ts_ms" },
243 	{ .type = "unsigned int",	.name = "cpu" },
244 	{ .type = "char[64]",		.name = "my_string_field" },
245 	{ .type = "char[]",		.name = "dynstring_field_2" },
246 	{ .type = "int",		.name = "my_int_field" },
247 };
248 
249 /*
250  * Test synthetic event creation all at once from array of field
251  * descriptors.
252  */
253 static int __init test_create_synth_event(void)
254 {
255 	u64 vals[9];
256 	int ret;
257 
258 	/* Create the create_synth_test event with the fields above */
259 	ret = synth_event_create("create_synth_test",
260 				 create_synth_test_fields,
261 				 ARRAY_SIZE(create_synth_test_fields),
262 				 THIS_MODULE);
263 	if (ret)
264 		goto out;
265 
266 	/*
267 	 * Now get the create_synth_test event file.  We need to
268 	 * prevent the instance and event from disappearing from
269 	 * underneath us, which trace_get_event_file() does (though in
270 	 * this case we're using the top-level instance which never
271 	 * goes away).
272 	 */
273 	create_synth_test = trace_get_event_file(NULL, "synthetic",
274 						 "create_synth_test");
275 	if (IS_ERR(create_synth_test)) {
276 		ret = PTR_ERR(create_synth_test);
277 		goto delete;
278 	}
279 
280 	/* Enable the event or you won't see anything */
281 	ret = trace_array_set_clr_event(create_synth_test->tr,
282 					"synthetic", "create_synth_test", true);
283 	if (ret) {
284 		trace_put_event_file(create_synth_test);
285 		goto delete;
286 	}
287 
288 	/* Create some bogus values just for testing */
289 
290 	vals[0] = 777;			/* next_pid_field */
291 	vals[1] = (u64)(long)"tiddlywinks";	/* next_comm_field */
292 	vals[2] = 1000000;		/* ts_ns */
293 	vals[3] = (u64)(long)"xrayspecs";	/* dynstring_field_1 */
294 	vals[4] = 1000;			/* ts_ms */
295 	vals[5] = raw_smp_processor_id(); /* cpu */
296 	vals[6] = (u64)(long)"thneed";	/* my_string_field */
297 	vals[7] = (u64)(long)"kerplunk";	/* dynstring_field_2 */
298 	vals[8] = 398;			/* my_int_field */
299 
300 	/* Now generate a create_synth_test event */
301 	ret = synth_event_trace_array(create_synth_test, vals, ARRAY_SIZE(vals));
302  out:
303 	return ret;
304  delete:
305 	/* We got an error after creating the event, delete it */
306 	synth_event_delete("create_synth_test");
307 
308 	goto out;
309 }
310 
311 /*
312  * Test tracing a synthetic event by reserving trace buffer space,
313  * then filling in fields one after another.
314  */
315 static int __init test_add_next_synth_val(void)
316 {
317 	struct synth_event_trace_state trace_state;
318 	int ret;
319 
320 	/* Start by reserving space in the trace buffer */
321 	ret = synth_event_trace_start(gen_synth_test, &trace_state);
322 	if (ret)
323 		return ret;
324 
325 	/* Write some bogus values into the trace buffer, one after another */
326 
327 	/* next_pid_field */
328 	ret = synth_event_add_next_val(777, &trace_state);
329 	if (ret)
330 		goto out;
331 
332 	/* next_comm_field */
333 	ret = synth_event_add_next_val((u64)(long)"slinky", &trace_state);
334 	if (ret)
335 		goto out;
336 
337 	/* ts_ns */
338 	ret = synth_event_add_next_val(1000000, &trace_state);
339 	if (ret)
340 		goto out;
341 
342 	/* ts_ms */
343 	ret = synth_event_add_next_val(1000, &trace_state);
344 	if (ret)
345 		goto out;
346 
347 	/* cpu */
348 	ret = synth_event_add_next_val(raw_smp_processor_id(), &trace_state);
349 	if (ret)
350 		goto out;
351 
352 	/* my_string_field */
353 	ret = synth_event_add_next_val((u64)(long)"thneed_2.01", &trace_state);
354 	if (ret)
355 		goto out;
356 
357 	/* my_int_field */
358 	ret = synth_event_add_next_val(395, &trace_state);
359  out:
360 	/* Finally, commit the event */
361 	ret = synth_event_trace_end(&trace_state);
362 
363 	return ret;
364 }
365 
366 /*
367  * Test tracing a synthetic event by reserving trace buffer space,
368  * then filling in fields using field names, which can be done in any
369  * order.
370  */
371 static int __init test_add_synth_val(void)
372 {
373 	struct synth_event_trace_state trace_state;
374 	int ret;
375 
376 	/* Start by reserving space in the trace buffer */
377 	ret = synth_event_trace_start(gen_synth_test, &trace_state);
378 	if (ret)
379 		return ret;
380 
381 	/* Write some bogus values into the trace buffer, using field names */
382 
383 	ret = synth_event_add_val("ts_ns", 1000000, &trace_state);
384 	if (ret)
385 		goto out;
386 
387 	ret = synth_event_add_val("ts_ms", 1000, &trace_state);
388 	if (ret)
389 		goto out;
390 
391 	ret = synth_event_add_val("cpu", raw_smp_processor_id(), &trace_state);
392 	if (ret)
393 		goto out;
394 
395 	ret = synth_event_add_val("next_pid_field", 777, &trace_state);
396 	if (ret)
397 		goto out;
398 
399 	ret = synth_event_add_val("next_comm_field", (u64)(long)"silly putty",
400 				  &trace_state);
401 	if (ret)
402 		goto out;
403 
404 	ret = synth_event_add_val("my_string_field", (u64)(long)"thneed_9",
405 				  &trace_state);
406 	if (ret)
407 		goto out;
408 
409 	ret = synth_event_add_val("my_int_field", 3999, &trace_state);
410  out:
411 	/* Finally, commit the event */
412 	ret = synth_event_trace_end(&trace_state);
413 
414 	return ret;
415 }
416 
417 /*
418  * Test tracing a synthetic event all at once from array of values.
419  */
420 static int __init test_trace_synth_event(void)
421 {
422 	int ret;
423 
424 	/* Trace some bogus values just for testing */
425 	ret = synth_event_trace(create_synth_test, 9,	/* number of values */
426 				(u64)444,		/* next_pid_field */
427 				(u64)(long)"clackers",	/* next_comm_field */
428 				(u64)1000000,		/* ts_ns */
429 				(u64)(long)"viewmaster",/* dynstring_field_1 */
430 				(u64)1000,		/* ts_ms */
431 				(u64)raw_smp_processor_id(), /* cpu */
432 				(u64)(long)"Thneed",	/* my_string_field */
433 				(u64)(long)"yoyos",	/* dynstring_field_2 */
434 				(u64)999);		/* my_int_field */
435 	return ret;
436 }
437 
438 static int __init synth_event_gen_test_init(void)
439 {
440 	int ret;
441 
442 	ret = test_gen_synth_cmd();
443 	if (ret)
444 		return ret;
445 
446 	ret = test_empty_synth_event();
447 	if (ret) {
448 		WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
449 						  "synthetic",
450 						  "gen_synth_test", false));
451 		trace_put_event_file(gen_synth_test);
452 		WARN_ON(synth_event_delete("gen_synth_test"));
453 		goto out;
454 	}
455 
456 	ret = test_create_synth_event();
457 	if (ret) {
458 		WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
459 						  "synthetic",
460 						  "gen_synth_test", false));
461 		trace_put_event_file(gen_synth_test);
462 		WARN_ON(synth_event_delete("gen_synth_test"));
463 
464 		WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
465 						  "synthetic",
466 						  "empty_synth_test", false));
467 		trace_put_event_file(empty_synth_test);
468 		WARN_ON(synth_event_delete("empty_synth_test"));
469 		goto out;
470 	}
471 
472 	ret = test_add_next_synth_val();
473 	WARN_ON(ret);
474 
475 	ret = test_add_synth_val();
476 	WARN_ON(ret);
477 
478 	ret = test_trace_synth_event();
479 	WARN_ON(ret);
480  out:
481 	return ret;
482 }
483 
484 static void __exit synth_event_gen_test_exit(void)
485 {
486 	/* Disable the event or you can't remove it */
487 	WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
488 					  "synthetic",
489 					  "gen_synth_test", false));
490 
491 	/* Now give the file and instance back */
492 	trace_put_event_file(gen_synth_test);
493 
494 	/* Now unregister and free the synthetic event */
495 	WARN_ON(synth_event_delete("gen_synth_test"));
496 
497 	/* Disable the event or you can't remove it */
498 	WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
499 					  "synthetic",
500 					  "empty_synth_test", false));
501 
502 	/* Now give the file and instance back */
503 	trace_put_event_file(empty_synth_test);
504 
505 	/* Now unregister and free the synthetic event */
506 	WARN_ON(synth_event_delete("empty_synth_test"));
507 
508 	/* Disable the event or you can't remove it */
509 	WARN_ON(trace_array_set_clr_event(create_synth_test->tr,
510 					  "synthetic",
511 					  "create_synth_test", false));
512 
513 	/* Now give the file and instance back */
514 	trace_put_event_file(create_synth_test);
515 
516 	/* Now unregister and free the synthetic event */
517 	WARN_ON(synth_event_delete("create_synth_test"));
518 }
519 
520 module_init(synth_event_gen_test_init)
521 module_exit(synth_event_gen_test_exit)
522 
523 MODULE_AUTHOR("Tom Zanussi");
524 MODULE_DESCRIPTION("synthetic event generation test");
525 MODULE_LICENSE("GPL v2");
526