1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3 * Copyright (C) 2020, VMware, Tzvetomir Stoyanov <[email protected]>
4 *
5 */
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <sys/stat.h>
9 #include <fcntl.h>
10 #include <unistd.h>
11 #include <time.h>
12 #include <dirent.h>
13 #include <ftw.h>
14 #include <libgen.h>
15 #include <kbuffer.h>
16 #include <pthread.h>
17
18 #include <sys/mount.h>
19
20 #include <CUnit/CUnit.h>
21 #include <CUnit/Basic.h>
22
23 #include "tracefs.h"
24
25 #define TRACEFS_SUITE "tracefs library"
26 #define TEST_INSTANCE_NAME "cunit_test_iter"
27 #define TEST_TRACE_DIR "/tmp/trace_utest.XXXXXX"
28 #define TEST_ARRAY_SIZE 5000
29
30 #define ALL_TRACERS "available_tracers"
31 #define CUR_TRACER "current_tracer"
32 #define PER_CPU "per_cpu"
33 #define TRACE_ON "tracing_on"
34 #define TRACE_CLOCK "trace_clock"
35
36 #define SQL_1_EVENT "wakeup_1"
37 #define SQL_1_SQL "select sched_switch.next_pid as woke_pid, sched_waking.common_pid as waking_pid from sched_waking join sched_switch on sched_switch.next_pid = sched_waking.pid"
38
39 #define SQL_2_EVENT "wakeup_2"
40 #define SQL_2_SQL "select woke.next_pid as woke_pid, wake.common_pid as waking_pid from sched_waking as wake join sched_switch as woke on woke.next_pid = wake.pid"
41
42 #define SQL_3_EVENT "wakeup_lat"
43 #define SQL_3_SQL "select sched_switch.next_prio as prio, end.prev_prio as pprio, (sched.sched_waking.common_timestamp.usecs - end.TIMESTAMP_USECS) as lat from sched_waking as start join sched_switch as end on start.pid = end.next_pid"
44
45 #define SQL_4_EVENT "wakeup_lat_2"
46 #define SQL_4_SQL "select start.pid, end.next_prio as prio, (end.TIMESTAMP_USECS - start.TIMESTAMP_USECS) as lat from sched_waking as start join sched_switch as end on start.pid = end.next_pid where (start.prio >= 1 && start.prio < 100) || !(start.pid >= 0 && start.pid <= 1) && end.prev_pid != 0"
47
48 #define SQL_5_EVENT "irq_lat"
49 #define SQL_5_SQL "select end.common_pid as pid, (end.common_timestamp.usecs - start.common_timestamp.usecs) as irq_lat from irq_disable as start join irq_enable as end on start.common_pid = end.common_pid, start.parent_offs == end.parent_offs where start.common_pid != 0"
50 #define SQL_5_START "irq_disable"
51
52 #define DEBUGFS_DEFAULT_PATH "/sys/kernel/debug"
53 #define TRACEFS_DEFAULT_PATH "/sys/kernel/tracing"
54 #define TRACEFS_DEFAULT2_PATH "/sys/kernel/debug/tracing"
55
56 static struct tracefs_instance *test_instance;
57 static struct tep_handle *test_tep;
58 struct test_sample {
59 int cpu;
60 int value;
61 };
62 static struct test_sample test_array[TEST_ARRAY_SIZE];
63 static int test_found;
64 static unsigned long long last_ts;
65
test_callback(struct tep_event * event,struct tep_record * record,int cpu,void * context)66 static int test_callback(struct tep_event *event, struct tep_record *record,
67 int cpu, void *context)
68 {
69 struct tep_format_field *field;
70 struct test_sample *sample;
71 int *cpu_test = (int *)context;
72 int i;
73
74 CU_TEST(last_ts <= record->ts);
75 last_ts = record->ts;
76
77 if (cpu_test && *cpu_test >= 0) {
78 CU_TEST(*cpu_test == cpu);
79 }
80 CU_TEST(cpu == record->cpu);
81
82 field = tep_find_field(event, "buf");
83 if (field) {
84 sample = ((struct test_sample *)(record->data + field->offset));
85 for (i = 0; i < TEST_ARRAY_SIZE; i++) {
86 if (test_array[i].value == sample->value &&
87 test_array[i].cpu == cpu) {
88 test_array[i].value = 0;
89 test_found++;
90 break;
91 }
92 }
93 }
94
95 return 0;
96 }
97
98 static cpu_set_t *cpuset_save;
99 static cpu_set_t *cpuset;
100 static int cpu_size;
101
save_affinity(void)102 static void save_affinity(void)
103 {
104 int cpus;
105
106 cpus = sysconf(_SC_NPROCESSORS_CONF);
107 cpuset_save = CPU_ALLOC(cpus);
108 cpuset = CPU_ALLOC(cpus);
109 cpu_size = CPU_ALLOC_SIZE(cpus);
110 CU_TEST(cpuset_save != NULL && cpuset != NULL);
111 CU_TEST(sched_getaffinity(0, cpu_size, cpuset_save) == 0);
112 }
113
thread_affinity(void)114 static void thread_affinity(void)
115 {
116 sched_setaffinity(0, cpu_size, cpuset_save);
117 }
118
reset_affinity(void)119 static void reset_affinity(void)
120 {
121 sched_setaffinity(0, cpu_size, cpuset_save);
122 CPU_FREE(cpuset_save);
123 CPU_FREE(cpuset);
124 }
125
set_affinity(int cpu)126 static void set_affinity(int cpu)
127 {
128 CPU_ZERO_S(cpu_size, cpuset);
129 CPU_SET_S(cpu, cpu_size, cpuset);
130 CU_TEST(sched_setaffinity(0, cpu_size, cpuset) == 0);
131 sched_yield(); /* Force schedule */
132 }
133
test_iter_write(struct tracefs_instance * instance)134 static void test_iter_write(struct tracefs_instance *instance)
135 {
136 char *path;
137 int i, fd;
138 int cpus;
139 int ret;
140
141 cpus = sysconf(_SC_NPROCESSORS_CONF);
142 save_affinity();
143
144 path = tracefs_instance_get_file(instance, "trace_marker");
145 CU_TEST(path != NULL);
146 fd = open(path, O_WRONLY);
147 tracefs_put_tracing_file(path);
148 CU_TEST(fd >= 0);
149
150 for (i = 0; i < TEST_ARRAY_SIZE; i++) {
151 test_array[i].cpu = rand() % cpus;
152 test_array[i].value = random();
153 if (!test_array[i].value)
154 test_array[i].value++;
155 CU_TEST(test_array[i].cpu < cpus);
156 set_affinity(test_array[i].cpu);
157 ret = write(fd, test_array + i, sizeof(struct test_sample));
158 CU_TEST(ret == sizeof(struct test_sample));
159 }
160
161 reset_affinity();
162 close(fd);
163 }
164
165
iter_raw_events_on_cpu(struct tracefs_instance * instance,int cpu)166 static void iter_raw_events_on_cpu(struct tracefs_instance *instance, int cpu)
167 {
168 int cpus = sysconf(_SC_NPROCESSORS_CONF);
169 cpu_set_t *cpuset = NULL;
170 int cpu_size = 0;
171 int check = 0;
172 int ret;
173 int i;
174
175 if (cpu >= 0) {
176 cpuset = CPU_ALLOC(cpus);
177 cpu_size = CPU_ALLOC_SIZE(cpus);
178 CPU_ZERO_S(cpu_size, cpuset);
179 CPU_SET(cpu, cpuset);
180 }
181 test_found = 0;
182 last_ts = 0;
183 test_iter_write(instance);
184 ret = tracefs_iterate_raw_events(test_tep, instance, cpuset, cpu_size,
185 test_callback, &cpu);
186 CU_TEST(ret == 0);
187 if (cpu < 0) {
188 CU_TEST(test_found == TEST_ARRAY_SIZE);
189 } else {
190 for (i = 0; i < TEST_ARRAY_SIZE; i++) {
191 if (test_array[i].cpu == cpu) {
192 check++;
193 CU_TEST(test_array[i].value == 0)
194 } else {
195 CU_TEST(test_array[i].value != 0)
196 }
197 }
198 CU_TEST(test_found == check);
199 }
200
201 if (cpuset)
202 CPU_FREE(cpuset);
203 }
204
test_instance_iter_raw_events(struct tracefs_instance * instance)205 static void test_instance_iter_raw_events(struct tracefs_instance *instance)
206 {
207 int cpus = sysconf(_SC_NPROCESSORS_CONF);
208 int ret;
209 int i;
210
211 ret = tracefs_iterate_raw_events(NULL, instance, NULL, 0, test_callback, NULL);
212 CU_TEST(ret < 0);
213 last_ts = 0;
214 ret = tracefs_iterate_raw_events(test_tep, NULL, NULL, 0, test_callback, NULL);
215 CU_TEST(ret == 0);
216 ret = tracefs_iterate_raw_events(test_tep, instance, NULL, 0, NULL, NULL);
217 CU_TEST(ret < 0);
218
219 iter_raw_events_on_cpu(instance, -1);
220 for (i = 0; i < cpus; i++)
221 iter_raw_events_on_cpu(instance, i);
222 }
223
test_iter_raw_events(void)224 static void test_iter_raw_events(void)
225 {
226 test_instance_iter_raw_events(test_instance);
227 }
228
229 #define RAND_STR_SIZE 20
230 #define RAND_ASCII "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
get_rand_str(void)231 static const char *get_rand_str(void)
232 {
233 static char str[RAND_STR_SIZE];
234 static char sym[] = RAND_ASCII;
235 struct timespec clk;
236 int i;
237
238 clock_gettime(CLOCK_REALTIME, &clk);
239 srand(clk.tv_nsec);
240 for (i = 0; i < RAND_STR_SIZE; i++)
241 str[i] = sym[rand() % (sizeof(sym) - 1)];
242
243 str[RAND_STR_SIZE - 1] = 0;
244 return str;
245 }
246
247 struct marker_find {
248 int data_offset;
249 int event_id;
250 int count;
251 int len;
252 void *data;
253 };
254
test_marker_callback(struct tep_event * event,struct tep_record * record,int cpu,void * context)255 static int test_marker_callback(struct tep_event *event, struct tep_record *record,
256 int cpu, void *context)
257 {
258 struct marker_find *walk = context;
259
260 if (!walk)
261 return -1;
262 if (event->id != walk->event_id)
263 return 0;
264 if (record->size < (walk->data_offset + walk->len))
265 return 0;
266
267 if (memcmp(walk->data, record->data + walk->data_offset, walk->len) == 0)
268 walk->count++;
269
270 return 0;
271 }
272
find_test_marker(struct tracefs_instance * instance,void * data,int len,int expected,bool raw)273 static bool find_test_marker(struct tracefs_instance *instance,
274 void *data, int len, int expected, bool raw)
275 {
276 struct tep_format_field *field;
277 struct tep_event *event;
278 struct marker_find walk;
279 int ret;
280
281 if (raw) {
282 event = tep_find_event_by_name(test_tep, "ftrace", "raw_data");
283 if (event)
284 field = tep_find_field(event, "id");
285
286 } else {
287 event = tep_find_event_by_name(test_tep, "ftrace", "print");
288 if (event)
289 field = tep_find_field(event, "buf");
290 }
291
292 if (!event || !field)
293 return false;
294
295 walk.data = data;
296 walk.len = len;
297 walk.count = 0;
298 walk.event_id = event->id;
299 walk.data_offset = field->offset;
300 ret = tracefs_iterate_raw_events(test_tep, instance, NULL, 0,
301 test_marker_callback, &walk);
302 CU_TEST(ret == 0);
303
304 return walk.count == expected;
305 }
306
marker_vprint(struct tracefs_instance * instance,char * fmt,...)307 static int marker_vprint(struct tracefs_instance *instance, char *fmt, ...)
308 {
309 va_list ap;
310 int ret;
311
312 va_start(ap, fmt);
313 ret = tracefs_vprintf(instance, fmt, ap);
314 va_end(ap);
315
316 return ret;
317 }
318
319 #define MARKERS_WRITE_COUNT 100
test_instance_ftrace_marker(struct tracefs_instance * instance)320 static void test_instance_ftrace_marker(struct tracefs_instance *instance)
321 {
322 const char *string = get_rand_str();
323 unsigned int data = 0xdeadbeef;
324 char *str;
325 int i;
326
327 CU_TEST(tracefs_print_init(instance) == 0);
328 tracefs_print_close(instance);
329
330 CU_TEST(tracefs_binary_init(instance) == 0);
331 tracefs_binary_close(instance);
332
333 for (i = 0; i < MARKERS_WRITE_COUNT; i++) {
334 CU_TEST(tracefs_binary_write(instance, &data, sizeof(data)) == 0);
335 }
336 CU_TEST(find_test_marker(instance, &data, sizeof(data), MARKERS_WRITE_COUNT, true));
337
338 for (i = 0; i < MARKERS_WRITE_COUNT; i++) {
339 CU_TEST(tracefs_printf(instance, "Test marker: %s 0x%X", string, data) == 0);
340 }
341 asprintf(&str, "Test marker: %s 0x%X", string, data);
342 CU_TEST(find_test_marker(instance, str, strlen(str), MARKERS_WRITE_COUNT, false));
343 free(str);
344
345 for (i = 0; i < MARKERS_WRITE_COUNT; i++) {
346 CU_TEST(marker_vprint(instance, "Test marker V: %s 0x%X", string, data) == 0);
347 }
348 asprintf(&str, "Test marker V: %s 0x%X", string, data);
349 CU_TEST(find_test_marker(instance, str, strlen(str), MARKERS_WRITE_COUNT, false));
350 free(str);
351
352 tracefs_print_close(instance);
353 tracefs_binary_close(instance);
354 }
355
test_ftrace_marker(void)356 static void test_ftrace_marker(void)
357 {
358 test_instance_ftrace_marker(test_instance);
359 }
360
test_instance_trace_sql(struct tracefs_instance * instance)361 static void test_instance_trace_sql(struct tracefs_instance *instance)
362 {
363 struct tracefs_synth *synth;
364 struct trace_seq seq;
365 struct tep_handle *tep;
366 struct tep_event *event;
367 int ret;
368
369 tep = tracefs_local_events(NULL);
370 CU_TEST(tep != NULL);
371
372 trace_seq_init(&seq);
373
374 synth = tracefs_sql(tep, SQL_1_EVENT, SQL_1_SQL, NULL);
375 CU_TEST(synth != NULL);
376 ret = tracefs_synth_echo_cmd(&seq, synth);
377 CU_TEST(ret == 0);
378 tracefs_synth_free(synth);
379 trace_seq_reset(&seq);
380
381 synth = tracefs_sql(tep, SQL_2_EVENT, SQL_2_SQL, NULL);
382 CU_TEST(synth != NULL);
383 ret = tracefs_synth_echo_cmd(&seq, synth);
384 CU_TEST(ret == 0);
385 tracefs_synth_free(synth);
386 trace_seq_reset(&seq);
387
388 synth = tracefs_sql(tep, SQL_3_EVENT, SQL_3_SQL, NULL);
389 CU_TEST(synth != NULL);
390 ret = tracefs_synth_echo_cmd(&seq, synth);
391 CU_TEST(ret == 0);
392 tracefs_synth_free(synth);
393 trace_seq_reset(&seq);
394
395 synth = tracefs_sql(tep, SQL_4_EVENT, SQL_4_SQL, NULL);
396 CU_TEST(synth != NULL);
397 ret = tracefs_synth_echo_cmd(&seq, synth);
398 CU_TEST(ret == 0);
399 tracefs_synth_free(synth);
400 trace_seq_reset(&seq);
401
402 event = tep_find_event_by_name(tep, NULL, SQL_5_START);
403 if (event) {
404 synth = tracefs_sql(tep, SQL_5_EVENT, SQL_5_SQL, NULL);
405 CU_TEST(synth != NULL);
406 ret = tracefs_synth_echo_cmd(&seq, synth);
407 CU_TEST(ret == 0);
408 tracefs_synth_free(synth);
409 trace_seq_reset(&seq);
410 }
411
412 tep_free(tep);
413 trace_seq_destroy(&seq);
414 }
415
test_trace_sql(void)416 static void test_trace_sql(void)
417 {
418 test_instance_trace_sql(test_instance);
419 }
420
421 struct test_cpu_data {
422 struct tracefs_instance *instance;
423 struct tracefs_cpu *tcpu;
424 struct kbuffer *kbuf;
425 struct tep_handle *tep;
426 unsigned long long missed_events;
427 void *buf;
428 int events_per_buf;
429 int bufsize;
430 int data_size;
431 int this_pid;
432 int fd;
433 bool done;
434 };
435
cleanup_trace_cpu(struct test_cpu_data * data)436 static void cleanup_trace_cpu(struct test_cpu_data *data)
437 {
438 close(data->fd);
439 tep_free(data->tep);
440 tracefs_cpu_close(data->tcpu);
441 free(data->buf);
442 kbuffer_free(data->kbuf);
443 }
444
445 #define EVENT_SYSTEM "syscalls"
446 #define EVENT_NAME "sys_enter_getppid"
447
setup_trace_cpu(struct tracefs_instance * instance,struct test_cpu_data * data)448 static int setup_trace_cpu(struct tracefs_instance *instance, struct test_cpu_data *data)
449 {
450 struct tep_format_field **fields;
451 struct tep_event *event;
452 char tmpfile[] = "/tmp/utest-libtracefsXXXXXX";
453 int max = 0;
454 int ret;
455 int i;
456
457 /* Make sure tracing is on */
458 tracefs_trace_on(instance);
459
460 memset (data, 0, sizeof(*data));
461
462 data->instance = instance;
463
464 data->fd = mkstemp(tmpfile);
465 CU_TEST(data->fd >= 0);
466 unlink(tmpfile);
467 if (data->fd < 0)
468 return -1;
469
470 data->tep = tracefs_local_events(NULL);
471 CU_TEST(data->tep != NULL);
472 if (!data->tep)
473 goto fail;
474
475 data->tcpu = tracefs_cpu_open(instance, 0, true);
476 CU_TEST(data->tcpu != NULL);
477 if (!data->tcpu)
478 goto fail;
479
480 data->bufsize = tracefs_cpu_read_size(data->tcpu);
481
482 data->buf = calloc(1, data->bufsize);
483 CU_TEST(data->buf != NULL);
484 if (!data->buf)
485 goto fail;
486
487 data->kbuf = kbuffer_alloc(sizeof(long) == 8, !tep_is_bigendian());
488 CU_TEST(data->kbuf != NULL);
489 if (!data->kbuf)
490 goto fail;
491
492 data->data_size = data->bufsize - kbuffer_start_of_data(data->kbuf);
493
494 tracefs_instance_file_clear(instance, "trace");
495
496 event = tep_find_event_by_name(data->tep, EVENT_SYSTEM, EVENT_NAME);
497 CU_TEST(event != NULL);
498 if (!event)
499 goto fail;
500
501 fields = tep_event_fields(event);
502 CU_TEST(fields != NULL);
503 if (!fields)
504 goto fail;
505
506 for (i = 0; fields[i]; i++) {
507 int end = fields[i]->offset + fields[i]->size;
508 if (end > max)
509 max = end;
510 }
511 free(fields);
512
513 CU_TEST(max != 0);
514 if (!max)
515 goto fail;
516
517 data->events_per_buf = data->data_size / max;
518
519 data->this_pid = getpid();
520 ret = tracefs_event_enable(instance, EVENT_SYSTEM, EVENT_NAME);
521 CU_TEST(ret == 0);
522 if (ret)
523 goto fail;
524
525
526 save_affinity();
527 set_affinity(0);
528
529 return 0;
530 fail:
531 cleanup_trace_cpu(data);
532 return -1;
533 }
534
shutdown_trace_cpu(struct test_cpu_data * data)535 static void shutdown_trace_cpu(struct test_cpu_data *data)
536 {
537 struct tracefs_instance *instance = data->instance;
538 int ret;
539
540 reset_affinity();
541
542 ret = tracefs_event_disable(instance, EVENT_SYSTEM, EVENT_NAME);
543 CU_TEST(ret == 0);
544
545 cleanup_trace_cpu(data);
546 }
547
call_getppid(int cnt)548 static void call_getppid(int cnt)
549 {
550 int i;
551
552 for (i = 0; i < cnt; i++)
553 getppid();
554 }
555
test_cpu_read(struct test_cpu_data * data,int expect)556 static void test_cpu_read(struct test_cpu_data *data, int expect)
557 {
558 struct tracefs_cpu *tcpu = data->tcpu;
559 struct kbuffer *kbuf = data->kbuf;
560 struct tep_record record;
561 void *buf = data->buf;
562 unsigned long long ts;
563 bool first = true;
564 int pid;
565 int ret;
566 int cnt = 0;
567
568 call_getppid(expect);
569
570 for (;;) {
571 ret = tracefs_cpu_read(tcpu, buf, false);
572 CU_TEST(ret > 0 || !first);
573 if (ret <= 0)
574 break;
575 first = false;
576 ret = kbuffer_load_subbuffer(kbuf, buf);
577 CU_TEST(ret == 0);
578 for (;;) {
579 record.data = kbuffer_read_event(kbuf, &ts);
580 if (!record.data)
581 break;
582 record.ts = ts;
583 pid = tep_data_pid(data->tep, &record);
584 if (pid == data->this_pid)
585 cnt++;
586 kbuffer_next_event(kbuf, NULL);
587 }
588 }
589 CU_TEST(cnt == expect);
590 }
591
test_instance_trace_cpu_read(struct tracefs_instance * instance)592 static void test_instance_trace_cpu_read(struct tracefs_instance *instance)
593 {
594 struct test_cpu_data data;
595
596 if (setup_trace_cpu(instance, &data))
597 return;
598
599 test_cpu_read(&data, 1);
600 test_cpu_read(&data, data.events_per_buf / 2);
601 test_cpu_read(&data, data.events_per_buf);
602 test_cpu_read(&data, data.events_per_buf + 1);
603 test_cpu_read(&data, data.events_per_buf * 50);
604
605 shutdown_trace_cpu(&data);
606 }
607
test_trace_cpu_read(void)608 static void test_trace_cpu_read(void)
609 {
610 test_instance_trace_cpu_read(NULL);
611 test_instance_trace_cpu_read(test_instance);
612 }
613
614 struct follow_data {
615 struct tep_event *sched_switch;
616 struct tep_event *sched_waking;
617 struct tep_event *function;
618 int missed;
619 };
620
switch_callback(struct tep_event * event,struct tep_record * record,int cpu,void * data)621 static int switch_callback(struct tep_event *event, struct tep_record *record,
622 int cpu, void *data)
623 {
624 struct follow_data *fdata = data;
625
626 CU_TEST(cpu == record->cpu);
627 CU_TEST(event->id == fdata->sched_switch->id);
628 return 0;
629 }
630
waking_callback(struct tep_event * event,struct tep_record * record,int cpu,void * data)631 static int waking_callback(struct tep_event *event, struct tep_record *record,
632 int cpu, void *data)
633 {
634 struct follow_data *fdata = data;
635
636 CU_TEST(cpu == record->cpu);
637 CU_TEST(event->id == fdata->sched_waking->id);
638 return 0;
639 }
640
function_callback(struct tep_event * event,struct tep_record * record,int cpu,void * data)641 static int function_callback(struct tep_event *event, struct tep_record *record,
642 int cpu, void *data)
643 {
644 struct follow_data *fdata = data;
645
646 CU_TEST(cpu == record->cpu);
647 CU_TEST(event->id == fdata->function->id);
648 return 0;
649 }
650
missed_callback(struct tep_event * event,struct tep_record * record,int cpu,void * data)651 static int missed_callback(struct tep_event *event, struct tep_record *record,
652 int cpu, void *data)
653 {
654 struct follow_data *fdata = data;
655
656 fdata->missed = record->missed_events;
657 return 0;
658 }
659
all_callback(struct tep_event * event,struct tep_record * record,int cpu,void * data)660 static int all_callback(struct tep_event *event, struct tep_record *record,
661 int cpu, void *data)
662 {
663 struct follow_data *fdata = data;
664
665 CU_TEST(fdata->missed == record->missed_events);
666 fdata->missed = 0;
667 return 0;
668 }
669
stop_thread(void * arg)670 static void *stop_thread(void *arg)
671 {
672 struct tracefs_instance *instance = arg;
673
674 sleep(1);
675 tracefs_iterate_stop(instance);
676 return NULL;
677 }
678
test_instance_follow_events(struct tracefs_instance * instance)679 static void test_instance_follow_events(struct tracefs_instance *instance)
680 {
681 struct follow_data fdata;
682 struct tep_handle *tep;
683 pthread_t thread;
684 int ret;
685
686 memset(&fdata, 0, sizeof(fdata));
687
688 tep = tracefs_local_events(NULL);
689 CU_TEST(tep != NULL);
690 if (!tep)
691 return;
692
693 fdata.sched_switch = tep_find_event_by_name(tep, "sched", "sched_switch");
694 CU_TEST(fdata.sched_switch != NULL);
695 if (!fdata.sched_switch)
696 return;
697
698 fdata.sched_waking = tep_find_event_by_name(tep, "sched", "sched_waking");
699 CU_TEST(fdata.sched_waking != NULL);
700 if (!fdata.sched_waking)
701 return;
702
703 fdata.function = tep_find_event_by_name(tep, "ftrace", "function");
704 CU_TEST(fdata.function != NULL);
705 if (!fdata.function)
706 return;
707
708 ret = tracefs_follow_event(tep, instance, "sched", "sched_switch",
709 switch_callback, &fdata);
710 CU_TEST(ret == 0);
711
712 ret = tracefs_follow_event(tep, instance, "sched", "sched_waking",
713 waking_callback, &fdata);
714 CU_TEST(ret == 0);
715
716 ret = tracefs_follow_event(tep, instance, "ftrace", "function",
717 function_callback, &fdata);
718 CU_TEST(ret == 0);
719
720 ret = tracefs_follow_missed_events(instance, missed_callback, &fdata);
721 CU_TEST(ret == 0);
722
723 ret = tracefs_event_enable(instance, "sched", "sched_switch");
724 CU_TEST(ret == 0);
725
726 ret = tracefs_event_enable(instance, "sched", "sched_waking");
727 CU_TEST(ret == 0);
728
729 ret = tracefs_tracer_set(instance, TRACEFS_TRACER_FUNCTION);
730 CU_TEST(ret == 0);
731
732 pthread_create(&thread, NULL, stop_thread, instance);
733
734 ret = tracefs_iterate_raw_events(tep, instance, NULL, 0, all_callback, &fdata);
735 CU_TEST(ret == 0);
736
737 pthread_join(thread, NULL);
738
739 tracefs_tracer_clear(instance);
740 tracefs_event_disable(instance, NULL, NULL);
741 }
742
test_follow_events(void)743 static void test_follow_events(void)
744 {
745 test_instance_follow_events(NULL);
746 test_instance_follow_events(test_instance);
747 }
748
749 extern char *find_tracing_dir(bool debugfs, bool mount);
test_mounting(void)750 static void test_mounting(void)
751 {
752 const char *tracing_dir;
753 const char *debug_dir;
754 struct stat st;
755 char *save_tracing = NULL;
756 char *save_debug = NULL;
757 char *path;
758 char *dir;
759 int ret;
760
761 /* First, unmount all instances of debugfs */
762 do {
763 dir = find_tracing_dir(true, false);
764 if (dir) {
765 ret = umount(dir);
766 CU_TEST(ret == 0);
767 if (ret < 0)
768 return;
769 /* Save the first instance that's not /sys/kernel/debug */
770 if (!save_debug && strcmp(dir, DEBUGFS_DEFAULT_PATH) != 0)
771 save_debug = dir;
772 else
773 free(dir);
774 }
775 } while (dir);
776
777 /* Next, unmount all instances of tracefs */
778 do {
779 dir = find_tracing_dir(false, false);
780 if (dir) {
781 ret = umount(dir);
782 CU_TEST(ret == 0);
783 if (ret < 0)
784 return;
785 /* Save the first instance that's not in /sys/kernel/ */
786 if (!save_tracing && strncmp(dir, "/sys/kernel/", 12) != 0)
787 save_tracing = dir;
788 else
789 free(dir);
790 }
791 } while (dir);
792
793 /* Mount first the tracing dir (which should mount at /sys/kernel/tracing */
794 tracing_dir = tracefs_tracing_dir();
795 CU_TEST(tracing_dir != NULL);
796 if (tracing_dir != NULL) {
797 CU_TEST(strcmp(tracing_dir, TRACEFS_DEFAULT_PATH) == 0 ||
798 strcmp(tracing_dir, TRACEFS_DEFAULT2_PATH) == 0);
799 if (strncmp(tracing_dir, "/sys/kernel/", 12) != 0)
800 printf("Tracing directory mounted at '%s'\n",
801 tracing_dir);
802
803 /* Make sure the directory has content.*/
804 asprintf(&path, "%s/trace", tracing_dir);
805 CU_TEST(stat(path, &st) == 0);
806 free(path);
807 }
808
809 /* Now mount debugfs dir, which should mount at /sys/kernel/debug */
810 debug_dir = tracefs_debug_dir();
811 CU_TEST(debug_dir != NULL);
812 if (debug_dir != NULL) {
813 CU_TEST(strcmp(debug_dir, DEBUGFS_DEFAULT_PATH) == 0);
814 if (strcmp(debug_dir, DEBUGFS_DEFAULT_PATH) != 0)
815 printf("debug directory mounted at '%s'\n",
816 debug_dir);
817
818 /* Make sure the directory has content.*/
819 asprintf(&path, "%s/tracing", debug_dir);
820 CU_TEST(stat(path, &st) == 0);
821 free(path);
822 }
823
824 if (save_debug)
825 mount("debugfs", save_debug, "debugfs", 0, NULL);
826
827 if (save_tracing &&
828 (!save_debug || strncmp(save_debug, save_tracing, strlen(save_debug)) != 0))
829 mount("tracefs", save_tracing, "tracefs", 0, NULL);
830
831 free(save_debug);
832 free(save_tracing);
833 }
834
read_trace_cpu_file(struct test_cpu_data * data)835 static int read_trace_cpu_file(struct test_cpu_data *data)
836 {
837 unsigned long long ts;
838 struct tep_record record;
839 struct kbuffer *kbuf = data->kbuf;
840 void *buf = data->buf;
841 bool first = true;
842 int bufsize = data->bufsize;
843 int fd = data->fd;
844 int missed;
845 int pid;
846 int ret;
847 int cnt = 0;
848
849 ret = lseek64(fd, 0, SEEK_SET);
850 CU_TEST(ret == 0);
851 if (ret)
852 return -1;
853
854 for (;;) {
855 ret = read(fd, buf, bufsize);
856 CU_TEST(ret > 0 || !first);
857 if (ret <= 0)
858 break;
859 first = false;
860
861 ret = kbuffer_load_subbuffer(kbuf, buf);
862 CU_TEST(ret == 0);
863 missed = kbuffer_missed_events(kbuf);
864 if (missed)
865 printf("missed events %d\n", missed);
866 for (;;) {
867 record.data = kbuffer_read_event(kbuf, &ts);
868 if (!record.data)
869 break;
870 record.ts = ts;
871 pid = tep_data_pid(data->tep, &record);
872 if (pid == data->this_pid)
873 cnt++;
874 kbuffer_next_event(kbuf, NULL);
875 }
876 }
877 return ret == 0 ? cnt : ret;
878 }
879
trace_cpu_thread(void * arg)880 static void *trace_cpu_thread(void *arg)
881 {
882 struct test_cpu_data *data = arg;
883 struct tracefs_cpu *tcpu = data->tcpu;
884 int fd = data->fd;
885 long ret = 0;
886
887 thread_affinity();
888
889 while (!data->done && ret >= 0) {
890 ret = tracefs_cpu_write(tcpu, fd, false);
891 if (ret < 0 && errno == EAGAIN)
892 ret = 0;
893 }
894 if (ret >= 0 || errno == EAGAIN) {
895 do {
896 ret = tracefs_cpu_flush_write(tcpu, fd);
897 } while (ret > 0);
898 }
899
900 return (void *)ret;
901 }
902
test_cpu_pipe(struct test_cpu_data * data,int expect)903 static void test_cpu_pipe(struct test_cpu_data *data, int expect)
904 {
905 pthread_t thread;
906 void *retval;
907 long ret;
908 int cnt;
909
910 tracefs_instance_file_clear(data->instance, "trace");
911 ftruncate(data->fd, 0);
912
913 data->done = false;
914
915 pthread_create(&thread, NULL, trace_cpu_thread, data);
916 sleep(1);
917
918 call_getppid(expect);
919
920 data->done = true;
921 tracefs_cpu_stop(data->tcpu);
922 pthread_join(thread, &retval);
923 ret = (long)retval;
924 CU_TEST(ret >= 0);
925
926 cnt = read_trace_cpu_file(data);
927
928 CU_TEST(cnt == expect);
929 }
930
test_instance_trace_cpu_pipe(struct tracefs_instance * instance)931 static void test_instance_trace_cpu_pipe(struct tracefs_instance *instance)
932 {
933 struct test_cpu_data data;
934
935 if (setup_trace_cpu(instance, &data))
936 return;
937
938 test_cpu_pipe(&data, 1);
939 test_cpu_pipe(&data, data.events_per_buf / 2);
940 test_cpu_pipe(&data, data.events_per_buf);
941 test_cpu_pipe(&data, data.events_per_buf + 1);
942 test_cpu_pipe(&data, data.events_per_buf * 1000);
943
944 shutdown_trace_cpu(&data);
945 }
946
test_trace_cpu_pipe(void)947 static void test_trace_cpu_pipe(void)
948 {
949 test_instance_trace_cpu_pipe(NULL);
950 test_instance_trace_cpu_pipe(test_instance);
951 }
952
get_dynevents_check(enum tracefs_dynevent_type types,int count)953 static struct tracefs_dynevent **get_dynevents_check(enum tracefs_dynevent_type types, int count)
954 {
955 struct tracefs_dynevent **devents;
956 int i;
957
958 devents = tracefs_dynevent_get_all(types, NULL);
959 if (count) {
960 CU_TEST(devents != NULL);
961 if (!devents)
962 return NULL;
963 i = 0;
964 while (devents[i])
965 i++;
966 CU_TEST(i == count);
967 } else {
968 CU_TEST(devents == NULL);
969 }
970
971 return devents;
972 }
973
974
975 struct test_synth {
976 char *name;
977 char *start_system;
978 char *start_event;
979 char *end_system;
980 char *end_event;
981 char *start_match_field;
982 char *end_match_field;
983 char *match_name;
984 };
985
test_synth_compare(struct test_synth * synth,struct tracefs_dynevent ** devents)986 static void test_synth_compare(struct test_synth *synth, struct tracefs_dynevent **devents)
987 {
988 enum tracefs_dynevent_type stype;
989 char *format;
990 char *event;
991 int i;
992
993 for (i = 0; devents && devents[i]; i++) {
994 stype = tracefs_dynevent_info(devents[i], NULL,
995 &event, NULL, NULL, &format);
996 CU_TEST(stype == TRACEFS_DYNEVENT_SYNTH);
997 CU_TEST(strcmp(event, synth[i].name) == 0);
998 if (synth[i].match_name) {
999 CU_TEST(strstr(format, synth[i].match_name) != NULL);
1000 }
1001 free(event);
1002 free(format);
1003 }
1004 CU_TEST(devents == NULL || devents[i] == NULL);
1005 }
1006
test_instance_synthetic(struct tracefs_instance * instance)1007 static void test_instance_synthetic(struct tracefs_instance *instance)
1008 {
1009 struct test_synth sevents[] = {
1010 {"synth_1", "sched", "sched_waking", "sched", "sched_switch", "pid", "next_pid", "pid_match"},
1011 {"synth_2", "syscalls", "sys_enter_openat2", "syscalls", "sys_exit_openat2", "__syscall_nr", "__syscall_nr", "nr_match"},
1012 };
1013 int sevents_count = sizeof(sevents) / sizeof((sevents)[0]);
1014 struct tracefs_dynevent **devents;
1015 struct tracefs_synth **synth;
1016 struct tep_handle *tep;
1017 int ret;
1018 int i;
1019
1020 synth = calloc(sevents_count + 1, sizeof(*synth));
1021
1022 tep = tracefs_local_events(NULL);
1023 CU_TEST(tep != NULL);
1024
1025 /* kprobes APIs */
1026 ret = tracefs_dynevent_destroy_all(TRACEFS_DYNEVENT_SYNTH, true);
1027 CU_TEST(ret == 0);
1028 get_dynevents_check(TRACEFS_DYNEVENT_SYNTH, 0);
1029
1030 for (i = 0; i < sevents_count; i++) {
1031 synth[i] = tracefs_synth_alloc(tep, sevents[i].name,
1032 sevents[i].start_system, sevents[i].start_event,
1033 sevents[i].end_system, sevents[i].end_event,
1034 sevents[i].start_match_field, sevents[i].end_match_field,
1035 sevents[i].match_name);
1036 CU_TEST(synth[i] != NULL);
1037 }
1038
1039 get_dynevents_check(TRACEFS_DYNEVENT_SYNTH, 0);
1040
1041 for (i = 0; i < sevents_count; i++) {
1042 ret = tracefs_synth_create(synth[i]);
1043 CU_TEST(ret == 0);
1044 }
1045
1046 devents = get_dynevents_check(TRACEFS_DYNEVENT_SYNTH, sevents_count);
1047 CU_TEST(devents != NULL);
1048 test_synth_compare(sevents, devents);
1049 tracefs_dynevent_list_free(devents);
1050
1051 for (i = 0; i < sevents_count; i++) {
1052 ret = tracefs_synth_destroy(synth[i]);
1053 CU_TEST(ret == 0);
1054 }
1055
1056 get_dynevents_check(TRACEFS_DYNEVENT_SYNTH, 0);
1057
1058 for (i = 0; i < sevents_count; i++)
1059 tracefs_synth_free(synth[i]);
1060
1061 tep_free(tep);
1062 free(synth);
1063 }
1064
test_synthetic(void)1065 static void test_synthetic(void)
1066 {
1067 test_instance_synthetic(test_instance);
1068 }
1069
test_trace_file(void)1070 static void test_trace_file(void)
1071 {
1072 const char *tmp = get_rand_str();
1073 const char *tdir;
1074 struct stat st;
1075 char *file;
1076
1077 tdir = tracefs_tracing_dir();
1078 CU_TEST(tdir != NULL);
1079 CU_TEST(stat(tdir, &st) == 0);
1080 CU_TEST(S_ISDIR(st.st_mode));
1081
1082 file = tracefs_get_tracing_file(NULL);
1083 CU_TEST(file == NULL);
1084 file = tracefs_get_tracing_file(tmp);
1085 CU_TEST(file != NULL);
1086 CU_TEST(stat(file, &st) != 0);
1087 tracefs_put_tracing_file(file);
1088
1089 file = tracefs_get_tracing_file("trace");
1090 CU_TEST(file != NULL);
1091 CU_TEST(stat(file, &st) == 0);
1092 tracefs_put_tracing_file(file);
1093 }
1094
test_instance_file_read(struct tracefs_instance * inst,const char * fname)1095 static void test_instance_file_read(struct tracefs_instance *inst, const char *fname)
1096 {
1097 const char *tdir = tracefs_tracing_dir();
1098 char buf[BUFSIZ];
1099 char *fpath;
1100 char *file;
1101 size_t fsize = 0;
1102 int size = 0;
1103 int fd;
1104
1105 if (inst) {
1106 CU_TEST(asprintf(&fpath, "%s/instances/%s/%s",
1107 tdir, tracefs_instance_get_name(inst), fname) > 0);
1108 } else {
1109 CU_TEST(asprintf(&fpath, "%s/%s", tdir, fname) > 0);
1110 }
1111
1112 memset(buf, 0, BUFSIZ);
1113 fd = open(fpath, O_RDONLY);
1114 CU_TEST(fd >= 0);
1115 fsize = read(fd, buf, BUFSIZ);
1116 CU_TEST(fsize >= 0);
1117 close(fd);
1118 buf[BUFSIZ - 1] = 0;
1119
1120 file = tracefs_instance_file_read(inst, fname, &size);
1121 CU_TEST(file != NULL);
1122 CU_TEST(size == fsize);
1123 CU_TEST(strcmp(file, buf) == 0);
1124
1125 free(fpath);
1126 free(file);
1127 }
1128
1129 struct probe_test {
1130 enum tracefs_dynevent_type type;
1131 char *prefix;
1132 char *system;
1133 char *event;
1134 char *address;
1135 char *format;
1136 };
1137
check_probes(struct probe_test * probes,int count,struct tracefs_dynevent ** devents,bool in_system,struct tracefs_instance * instance,struct tep_handle * tep)1138 static bool check_probes(struct probe_test *probes, int count,
1139 struct tracefs_dynevent **devents, bool in_system,
1140 struct tracefs_instance *instance, struct tep_handle *tep)
1141 {
1142 enum tracefs_dynevent_type type;
1143 struct tep_event *tevent;
1144 char *ename;
1145 char *address;
1146 char *event;
1147 char *system;
1148 char *format;
1149 char *prefix;
1150 int found = 0;
1151 int ret;
1152 int i, j;
1153
1154 for (i = 0; devents && devents[i]; i++) {
1155 type = tracefs_dynevent_info(devents[i], &system,
1156 &event, &prefix, &address, &format);
1157 for (j = 0; j < count; j++) {
1158 if (type != probes[j].type)
1159 continue;
1160 if (probes[j].event)
1161 ename = probes[j].event;
1162 else
1163 ename = probes[j].address;
1164 if (strcmp(ename, event))
1165 continue;
1166 if (probes[j].system) {
1167 CU_TEST(strcmp(probes[j].system, system) == 0);
1168 }
1169 CU_TEST(strcmp(probes[j].address, address) == 0);
1170 if (probes[j].format) {
1171 CU_TEST(strcmp(probes[j].format, format) == 0);
1172 }
1173 if (probes[j].prefix) {
1174 CU_TEST(strcmp(probes[j].prefix, prefix) == 0);
1175 }
1176 ret = tracefs_event_enable(instance, system, event);
1177 if (in_system) {
1178 CU_TEST(ret == 0);
1179 } else {
1180 CU_TEST(ret != 0);
1181 }
1182 ret = tracefs_event_disable(instance, system, event);
1183 if (in_system) {
1184 CU_TEST(ret == 0);
1185 } else {
1186 CU_TEST(ret != 0);
1187 }
1188
1189 tevent = tracefs_dynevent_get_event(tep, devents[i]);
1190 if (in_system) {
1191 CU_TEST(tevent != NULL);
1192 if (tevent) {
1193 CU_TEST(strcmp(tevent->name, event) == 0);
1194 CU_TEST(strcmp(tevent->system, system) == 0);
1195 }
1196 } else {
1197 CU_TEST(tevent == NULL);
1198 }
1199
1200 found++;
1201 break;
1202 }
1203 free(system);
1204 free(event);
1205 free(prefix);
1206 free(address);
1207 free(format);
1208 }
1209
1210 CU_TEST(found == count);
1211 if (found != count)
1212 return false;
1213
1214 return true;
1215 }
1216
test_kprobes_instance(struct tracefs_instance * instance)1217 static void test_kprobes_instance(struct tracefs_instance *instance)
1218 {
1219 struct probe_test ktests[] = {
1220 { TRACEFS_DYNEVENT_KPROBE, "p", NULL, "mkdir", "do_mkdirat", "path=+u0($arg2):ustring" },
1221 { TRACEFS_DYNEVENT_KPROBE, "p", NULL, "close", "close_fd", NULL },
1222 { TRACEFS_DYNEVENT_KPROBE, "p", "ptest", "open2", "do_sys_openat2",
1223 "file=+u0($arg2):ustring flags=+0($arg3):x64" },
1224 };
1225 struct probe_test kretests[] = {
1226 { TRACEFS_DYNEVENT_KRETPROBE, NULL, NULL, "retopen", "do_sys_openat2", "ret=$retval" },
1227 { TRACEFS_DYNEVENT_KRETPROBE, NULL, NULL, NULL, "do_sys_open", "ret=$retval" },
1228 };
1229 int kretprobe_count = sizeof(kretests) / sizeof((kretests)[0]);
1230 int kprobe_count = sizeof(ktests) / sizeof((ktests)[0]);
1231 struct tracefs_dynevent **dkretprobe;
1232 struct tracefs_dynevent **dkprobe;
1233 struct tracefs_dynevent **devents;
1234 struct tep_handle *tep;
1235 char *tmp;
1236 int ret;
1237 int i;
1238
1239 tep = tep_alloc();
1240 CU_TEST(tep != NULL);
1241
1242 dkprobe = calloc(kprobe_count + 1, sizeof(*dkprobe));
1243 dkretprobe = calloc(kretprobe_count + 1, sizeof(*dkretprobe));
1244
1245 /* Invalid parameters */
1246 CU_TEST(tracefs_kprobe_alloc("test", NULL, NULL, "test") == NULL);
1247 CU_TEST(tracefs_kretprobe_alloc("test", NULL, NULL, "test", 0) == NULL);
1248 CU_TEST(tracefs_dynevent_create(NULL) != 0);
1249 CU_TEST(tracefs_dynevent_info(NULL, &tmp, &tmp, &tmp, &tmp, &tmp) == TRACEFS_DYNEVENT_UNKNOWN);
1250 CU_TEST(tracefs_kprobe_raw("test", "test", NULL, "test") != 0);
1251 CU_TEST(tracefs_kretprobe_raw("test", "test", NULL, "test") != 0);
1252
1253 /* kprobes APIs */
1254 ret = tracefs_dynevent_destroy_all(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, true);
1255 CU_TEST(ret == 0);
1256 get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, 0);
1257
1258 for (i = 0; i < kprobe_count; i++) {
1259 dkprobe[i] = tracefs_kprobe_alloc(ktests[i].system, ktests[i].event,
1260 ktests[i].address, ktests[i].format);
1261 CU_TEST(dkprobe[i] != NULL);
1262 }
1263 dkprobe[i] = NULL;
1264 get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, 0);
1265 CU_TEST(check_probes(ktests, kprobe_count, dkprobe, false, instance, tep));
1266
1267 for (i = 0; i < kretprobe_count; i++) {
1268 dkretprobe[i] = tracefs_kretprobe_alloc(kretests[i].system, kretests[i].event,
1269 kretests[i].address, kretests[i].format, 0);
1270 CU_TEST(dkretprobe[i] != NULL);
1271 }
1272 dkretprobe[i] = NULL;
1273 get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, 0);
1274 CU_TEST(check_probes(kretests, kretprobe_count, dkretprobe, false, instance, tep));
1275
1276 for (i = 0; i < kprobe_count; i++) {
1277 CU_TEST(tracefs_dynevent_create(dkprobe[i]) == 0);
1278 }
1279 devents = get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE,
1280 kprobe_count);
1281 CU_TEST(check_probes(ktests, kprobe_count, devents, true, instance, tep));
1282 CU_TEST(check_probes(kretests, kretprobe_count, dkretprobe, false, instance, tep));
1283 tracefs_dynevent_list_free(devents);
1284 devents = NULL;
1285
1286 for (i = 0; i < kretprobe_count; i++) {
1287 CU_TEST(tracefs_dynevent_create(dkretprobe[i]) == 0);
1288 }
1289 devents = get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE,
1290 kprobe_count + kretprobe_count);
1291 CU_TEST(check_probes(ktests, kprobe_count, devents, true, instance, tep));
1292 CU_TEST(check_probes(kretests, kretprobe_count, devents, true, instance, tep));
1293 tracefs_dynevent_list_free(devents);
1294 devents = NULL;
1295
1296 for (i = 0; i < kretprobe_count; i++) {
1297 CU_TEST(tracefs_dynevent_destroy(dkretprobe[i], false) == 0);
1298 }
1299 devents = get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE,
1300 kprobe_count);
1301 CU_TEST(check_probes(ktests, kprobe_count, devents, true, instance, tep));
1302 CU_TEST(check_probes(kretests, kretprobe_count, dkretprobe, false, instance, tep));
1303 tracefs_dynevent_list_free(devents);
1304 devents = NULL;
1305
1306 for (i = 0; i < kprobe_count; i++) {
1307 CU_TEST(tracefs_dynevent_destroy(dkprobe[i], false) == 0);
1308 }
1309 get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, 0);
1310 CU_TEST(check_probes(ktests, kprobe_count, dkprobe, false, instance, tep));
1311 CU_TEST(check_probes(kretests, kretprobe_count, dkretprobe, false, instance, tep));
1312 tracefs_dynevent_list_free(devents);
1313 devents = NULL;
1314
1315 for (i = 0; i < kprobe_count; i++)
1316 tracefs_dynevent_free(dkprobe[i]);
1317 for (i = 0; i < kretprobe_count; i++)
1318 tracefs_dynevent_free(dkretprobe[i]);
1319
1320 /* kprobes raw APIs */
1321 ret = tracefs_dynevent_destroy_all(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, true);
1322 CU_TEST(ret == 0);
1323 get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, 0);
1324
1325 for (i = 0; i < kprobe_count; i++) {
1326 ret = tracefs_kprobe_raw(ktests[i].system, ktests[i].event,
1327 ktests[i].address, ktests[i].format);
1328 CU_TEST(ret == 0);
1329 }
1330
1331 devents = get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, kprobe_count);
1332 CU_TEST(check_probes(ktests, kprobe_count, devents, true, instance, tep));
1333 tracefs_dynevent_list_free(devents);
1334 devents = NULL;
1335
1336 for (i = 0; i < kretprobe_count; i++) {
1337 ret = tracefs_kretprobe_raw(kretests[i].system, kretests[i].event,
1338 kretests[i].address, kretests[i].format);
1339 CU_TEST(ret == 0);
1340 }
1341
1342 devents = get_dynevents_check(TRACEFS_DYNEVENT_KPROBE, kprobe_count);
1343 CU_TEST(check_probes(ktests, kprobe_count, devents, true, instance, tep));
1344 tracefs_dynevent_list_free(devents);
1345 devents = NULL;
1346
1347 devents = get_dynevents_check(TRACEFS_DYNEVENT_KRETPROBE, kretprobe_count);
1348 CU_TEST(check_probes(kretests, kretprobe_count, devents, true, instance, tep));
1349 tracefs_dynevent_list_free(devents);
1350 devents = NULL;
1351
1352 devents = get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE,
1353 kprobe_count + kretprobe_count);
1354 CU_TEST(check_probes(ktests, kprobe_count, devents, true, instance, tep));
1355 CU_TEST(check_probes(kretests, kretprobe_count, devents, true, instance, tep));
1356 tracefs_dynevent_list_free(devents);
1357 devents = NULL;
1358
1359 ret = tracefs_dynevent_destroy_all(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, true);
1360 CU_TEST(ret == 0);
1361 get_dynevents_check(TRACEFS_DYNEVENT_KPROBE | TRACEFS_DYNEVENT_KRETPROBE, 0);
1362 free(dkretprobe);
1363 free(dkprobe);
1364 tep_free(tep);
1365 }
1366
test_kprobes(void)1367 static void test_kprobes(void)
1368 {
1369 test_kprobes_instance(test_instance);
1370 }
1371
test_eprobes_instance(struct tracefs_instance * instance)1372 static void test_eprobes_instance(struct tracefs_instance *instance)
1373 {
1374 struct probe_test etests[] = {
1375 { TRACEFS_DYNEVENT_EPROBE, "e", NULL, "sopen_in", "syscalls.sys_enter_openat",
1376 "file=+0($filename):ustring" },
1377 { TRACEFS_DYNEVENT_EPROBE, "e", "etest", "sopen_out", "syscalls.sys_exit_openat",
1378 "res=$ret:u64" },
1379 };
1380 int count = sizeof(etests) / sizeof((etests)[0]);
1381 struct tracefs_dynevent **deprobes;
1382 struct tracefs_dynevent **devents;
1383 struct tep_handle *tep;
1384 char *tsys, *tevent;
1385 char *tmp, *sav;
1386 int ret;
1387 int i;
1388
1389 tep = tep_alloc();
1390 CU_TEST(tep != NULL);
1391
1392 deprobes = calloc(count + 1, sizeof(*deprobes));
1393
1394 /* Invalid parameters */
1395 CU_TEST(tracefs_eprobe_alloc("test", NULL, "test", "test", "test") == NULL);
1396 CU_TEST(tracefs_eprobe_alloc("test", "test", NULL, "test", "test") == NULL);
1397 CU_TEST(tracefs_eprobe_alloc("test", "test", "test", NULL, "test") == NULL);
1398
1399 ret = tracefs_dynevent_destroy_all(TRACEFS_DYNEVENT_EPROBE, true);
1400 CU_TEST(ret == 0);
1401 get_dynevents_check(TRACEFS_DYNEVENT_EPROBE, 0);
1402
1403 for (i = 0; i < count; i++) {
1404 tmp = strdup(etests[i].address);
1405 tsys = strtok_r(tmp, "./", &sav);
1406 tevent = strtok_r(NULL, "", &sav);
1407 deprobes[i] = tracefs_eprobe_alloc(etests[i].system, etests[i].event,
1408 tsys, tevent, etests[i].format);
1409 free(tmp);
1410 CU_TEST(deprobes[i] != NULL);
1411 }
1412 deprobes[i] = NULL;
1413
1414 get_dynevents_check(TRACEFS_DYNEVENT_EPROBE, 0);
1415 CU_TEST(check_probes(etests, count, deprobes, false, instance, tep));
1416
1417 for (i = 0; i < count; i++) {
1418 CU_TEST(tracefs_dynevent_create(deprobes[i]) == 0);
1419 }
1420
1421 devents = get_dynevents_check(TRACEFS_DYNEVENT_EPROBE, count);
1422 CU_TEST(check_probes(etests, count, devents, true, instance, tep));
1423 tracefs_dynevent_list_free(devents);
1424 devents = NULL;
1425
1426 for (i = 0; i < count; i++) {
1427 CU_TEST(tracefs_dynevent_destroy(deprobes[i], false) == 0);
1428 }
1429 get_dynevents_check(TRACEFS_DYNEVENT_EPROBE, 0);
1430 CU_TEST(check_probes(etests, count, deprobes, false, instance, tep));
1431
1432 for (i = 0; i < count; i++)
1433 tracefs_dynevent_free(deprobes[i]);
1434
1435 free(deprobes);
1436 tep_free(tep);
1437 }
1438
test_eprobes(void)1439 static void test_eprobes(void)
1440 {
1441 test_eprobes_instance(test_instance);
1442 }
1443
1444 #define FOFFSET 1000ll
test_uprobes_instance(struct tracefs_instance * instance)1445 static void test_uprobes_instance(struct tracefs_instance *instance)
1446 {
1447 struct probe_test utests[] = {
1448 { TRACEFS_DYNEVENT_UPROBE, "p", "utest", "utest_u", NULL, "arg1=$stack2" },
1449 { TRACEFS_DYNEVENT_URETPROBE, "r", "utest", "utest_r", NULL, "arg1=$retval" },
1450 };
1451 int count = sizeof(utests) / sizeof((utests)[0]);
1452 struct tracefs_dynevent **duprobes;
1453 struct tracefs_dynevent **duvents;
1454 char self[PATH_MAX] = { 0 };
1455 struct tep_handle *tep;
1456 char *target = NULL;
1457 int i;
1458
1459 tep = tep_alloc();
1460 CU_TEST(tep != NULL);
1461
1462 duprobes = calloc(count + 1, sizeof(*duvents));
1463 CU_TEST(duprobes != NULL);
1464 CU_TEST(readlink("/proc/self/exe", self, sizeof(self)) > 0);
1465 CU_TEST(asprintf(&target, "%s:0x%0*llx", self, (int)(sizeof(void *) * 2), FOFFSET) > 0);
1466
1467 for (i = 0; i < count; i++)
1468 utests[i].address = target;
1469
1470 /* Invalid parameters */
1471 CU_TEST(tracefs_uprobe_alloc(NULL, NULL, self, 0, NULL) == NULL);
1472 CU_TEST(tracefs_uprobe_alloc(NULL, "test", NULL, 0, NULL) == NULL);
1473 CU_TEST(tracefs_uretprobe_alloc(NULL, NULL, self, 0, NULL) == NULL);
1474 CU_TEST(tracefs_uretprobe_alloc(NULL, "test", NULL, 0, NULL) == NULL);
1475
1476 for (i = 0; i < count; i++) {
1477 if (utests[i].type == TRACEFS_DYNEVENT_UPROBE)
1478 duprobes[i] = tracefs_uprobe_alloc(utests[i].system, utests[i].event,
1479 self, FOFFSET, utests[i].format);
1480 else
1481 duprobes[i] = tracefs_uretprobe_alloc(utests[i].system, utests[i].event,
1482 self, FOFFSET, utests[i].format);
1483 CU_TEST(duprobes[i] != NULL);
1484 }
1485 duprobes[i] = NULL;
1486
1487 get_dynevents_check(TRACEFS_DYNEVENT_UPROBE | TRACEFS_DYNEVENT_URETPROBE, 0);
1488 CU_TEST(check_probes(utests, count, duprobes, false, instance, tep));
1489
1490 for (i = 0; i < count; i++) {
1491 CU_TEST(tracefs_dynevent_create(duprobes[i]) == 0);
1492 }
1493
1494 duvents = get_dynevents_check(TRACEFS_DYNEVENT_UPROBE | TRACEFS_DYNEVENT_URETPROBE, count);
1495 CU_TEST(check_probes(utests, count, duvents, true, instance, tep));
1496 tracefs_dynevent_list_free(duvents);
1497
1498 for (i = 0; i < count; i++) {
1499 CU_TEST(tracefs_dynevent_destroy(duprobes[i], false) == 0);
1500 }
1501 get_dynevents_check(TRACEFS_DYNEVENT_UPROBE | TRACEFS_DYNEVENT_URETPROBE, 0);
1502 CU_TEST(check_probes(utests, count, duprobes, false, instance, tep));
1503
1504 for (i = 0; i < count; i++)
1505 tracefs_dynevent_free(duprobes[i]);
1506
1507 free(duprobes);
1508 free(target);
1509 tep_free(tep);
1510 }
1511
test_uprobes(void)1512 static void test_uprobes(void)
1513 {
1514 test_uprobes_instance(test_instance);
1515 }
1516
test_instance_file(void)1517 static void test_instance_file(void)
1518 {
1519 struct tracefs_instance *instance = NULL;
1520 struct tracefs_instance *second = NULL;
1521 const char *name = get_rand_str();
1522 const char *inst_name = NULL;
1523 const char *tdir;
1524 char *inst_file;
1525 char *inst_dir;
1526 struct stat st;
1527 char *file1;
1528 char *file2;
1529 char *tracer;
1530 char *fname;
1531 int size;
1532 int ret;
1533
1534 tdir = tracefs_tracing_dir();
1535 CU_TEST(tdir != NULL);
1536 CU_TEST(asprintf(&inst_dir, "%s/instances/%s", tdir, name) > 0);
1537 CU_TEST(stat(inst_dir, &st) != 0);
1538
1539 CU_TEST(tracefs_instance_exists(name) == false);
1540 instance = tracefs_instance_create(name);
1541 CU_TEST(instance != NULL);
1542 CU_TEST(tracefs_instance_is_new(instance));
1543 second = tracefs_instance_create(name);
1544 CU_TEST(second != NULL);
1545 CU_TEST(!tracefs_instance_is_new(second));
1546 tracefs_instance_free(second);
1547 CU_TEST(tracefs_instance_exists(name) == true);
1548 CU_TEST(stat(inst_dir, &st) == 0);
1549 CU_TEST(S_ISDIR(st.st_mode));
1550 inst_name = tracefs_instance_get_name(instance);
1551 CU_TEST(inst_name != NULL);
1552 CU_TEST(strcmp(inst_name, name) == 0);
1553
1554 fname = tracefs_instance_get_dir(NULL);
1555 CU_TEST(fname != NULL);
1556 CU_TEST(strcmp(fname, tdir) == 0);
1557 free(fname);
1558
1559 fname = tracefs_instance_get_dir(instance);
1560 CU_TEST(fname != NULL);
1561 CU_TEST(strcmp(fname, inst_dir) == 0);
1562 free(fname);
1563
1564 CU_TEST(asprintf(&fname, "%s/"ALL_TRACERS, tdir) > 0);
1565 CU_TEST(fname != NULL);
1566 inst_file = tracefs_instance_get_file(NULL, ALL_TRACERS);
1567 CU_TEST(inst_file != NULL);
1568 CU_TEST(strcmp(fname, inst_file) == 0);
1569 tracefs_put_tracing_file(inst_file);
1570 free(fname);
1571
1572 CU_TEST(asprintf(&fname, "%s/instances/%s/"ALL_TRACERS, tdir, name) > 0);
1573 CU_TEST(fname != NULL);
1574 CU_TEST(stat(fname, &st) == 0);
1575 inst_file = tracefs_instance_get_file(instance, ALL_TRACERS);
1576 CU_TEST(inst_file != NULL);
1577 CU_TEST(strcmp(fname, inst_file) == 0);
1578
1579 test_instance_file_read(NULL, ALL_TRACERS);
1580 test_instance_file_read(instance, ALL_TRACERS);
1581
1582 file1 = tracefs_instance_file_read(instance, ALL_TRACERS, NULL);
1583 CU_TEST(file1 != NULL);
1584 tracer = strtok(file1, " ");
1585 CU_TEST(tracer != NULL);
1586 ret = tracefs_instance_file_write(instance, CUR_TRACER, tracer);
1587 CU_TEST(ret == strlen(tracer));
1588 file2 = tracefs_instance_file_read(instance, CUR_TRACER, &size);
1589 CU_TEST(file2 != NULL);
1590 CU_TEST(size >= strlen(tracer));
1591 CU_TEST(strncmp(file2, tracer, strlen(tracer)) == 0);
1592 free(file1);
1593 free(file2);
1594
1595 tracefs_put_tracing_file(inst_file);
1596 free(fname);
1597
1598 CU_TEST(tracefs_file_exists(NULL, (char *)name) == false);
1599 CU_TEST(tracefs_dir_exists(NULL, (char *)name) == false);
1600 CU_TEST(tracefs_file_exists(instance, (char *)name) == false);
1601 CU_TEST(tracefs_dir_exists(instance, (char *)name) == false);
1602
1603 CU_TEST(tracefs_file_exists(NULL, CUR_TRACER) == true);
1604 CU_TEST(tracefs_dir_exists(NULL, CUR_TRACER) == false);
1605 CU_TEST(tracefs_file_exists(instance, CUR_TRACER) == true);
1606 CU_TEST(tracefs_dir_exists(instance, CUR_TRACER) == false);
1607
1608 CU_TEST(tracefs_file_exists(NULL, PER_CPU) == false);
1609 CU_TEST(tracefs_dir_exists(NULL, PER_CPU) == true);
1610 CU_TEST(tracefs_file_exists(instance, PER_CPU) == false);
1611 CU_TEST(tracefs_dir_exists(instance, PER_CPU) == true);
1612
1613 CU_TEST(tracefs_instance_destroy(NULL) != 0);
1614 CU_TEST(tracefs_instance_destroy(instance) == 0);
1615 CU_TEST(tracefs_instance_destroy(instance) != 0);
1616 tracefs_instance_free(instance);
1617 CU_TEST(stat(inst_dir, &st) != 0);
1618 free(inst_dir);
1619 }
1620
check_fd_name(int fd,const char * dir,const char * name)1621 static bool check_fd_name(int fd, const char *dir, const char *name)
1622 {
1623 char link[PATH_MAX + 1];
1624 char path[PATH_MAX + 1];
1625 struct stat st;
1626 char *file;
1627 int ret;
1628
1629 snprintf(link, PATH_MAX, "/proc/self/fd/%d", fd);
1630 ret = lstat(link, &st);
1631 CU_TEST(ret == 0);
1632 if (ret < 0)
1633 return false;
1634 CU_TEST(S_ISLNK(st.st_mode));
1635 if (!S_ISLNK(st.st_mode))
1636 return false;
1637 ret = readlink(link, path, PATH_MAX);
1638 CU_TEST(ret > 0);
1639 if (ret > PATH_MAX || ret < 0)
1640 return false;
1641 path[ret] = 0;
1642 ret = strncmp(dir, path, strlen(dir));
1643 CU_TEST(ret == 0);
1644 if (ret)
1645 return false;
1646 file = basename(path);
1647 CU_TEST(file != NULL);
1648 if (!file)
1649 return false;
1650 ret = strcmp(file, name);
1651 CU_TEST(ret == 0);
1652 if (ret)
1653 return false;
1654 return true;
1655 }
1656
1657 #define FLAGS_STR "flags:"
check_fd_mode(int fd,int mode)1658 static bool check_fd_mode(int fd, int mode)
1659 {
1660 char path[PATH_MAX + 1];
1661 long fmode = -1;
1662 char *line = NULL;
1663 struct stat st;
1664 size_t len = 0;
1665 ssize_t size;
1666 FILE *file;
1667 int ret;
1668
1669 snprintf(path, PATH_MAX, "/proc/self/fdinfo/%d", fd);
1670 ret = stat(path, &st);
1671 CU_TEST(ret == 0);
1672 if (ret < 0)
1673 return false;
1674 file = fopen(path, "r");
1675 if (!file)
1676 return false;
1677 while ((size = getline(&line, &len, file)) > 0) {
1678 if (strncmp(line, FLAGS_STR, strlen(FLAGS_STR)))
1679 continue;
1680 fmode = strtol(line + strlen(FLAGS_STR), NULL, 8);
1681 break;
1682 }
1683 free(line);
1684 fclose(file);
1685 if (fmode < 0 ||
1686 (O_ACCMODE & fmode) != (O_ACCMODE & mode))
1687 return false;
1688 return true;
1689 }
1690
test_instance_file_fd(struct tracefs_instance * instance)1691 static void test_instance_file_fd(struct tracefs_instance *instance)
1692 {
1693 const char *name = get_rand_str();
1694 const char *tdir = tracefs_instance_get_trace_dir(instance);
1695 long long res = -1;
1696 char rd[2];
1697 int fd;
1698
1699 CU_TEST(tdir != NULL);
1700 fd = tracefs_instance_file_open(instance, name, -1);
1701 CU_TEST(fd == -1);
1702 fd = tracefs_instance_file_open(instance, TRACE_ON, O_RDONLY);
1703 CU_TEST(fd >= 0);
1704
1705 CU_TEST(check_fd_name(fd, tdir, TRACE_ON));
1706 CU_TEST(check_fd_mode(fd, O_RDONLY));
1707
1708 CU_TEST(tracefs_instance_file_read_number(instance, ALL_TRACERS, &res) != 0);
1709 CU_TEST(tracefs_instance_file_read_number(instance, name, &res) != 0);
1710 CU_TEST(tracefs_instance_file_read_number(instance, TRACE_ON, &res) == 0);
1711 CU_TEST((res == 0 || res == 1));
1712 CU_TEST(read(fd, &rd, 1) == 1);
1713 rd[1] = 0;
1714 CU_TEST(res == atoi(rd));
1715
1716 close(fd);
1717 }
1718
test_file_fd(void)1719 static void test_file_fd(void)
1720 {
1721 test_instance_file_fd(test_instance);
1722 }
1723
test_instance_tracing_onoff(struct tracefs_instance * instance)1724 static void test_instance_tracing_onoff(struct tracefs_instance *instance)
1725 {
1726 const char *tdir = tracefs_instance_get_trace_dir(instance);
1727 long long res = -1;
1728 int fd;
1729
1730 CU_TEST(tdir != NULL);
1731 fd = tracefs_trace_on_get_fd(instance);
1732 CU_TEST(fd >= 0);
1733 CU_TEST(check_fd_name(fd, tdir, TRACE_ON));
1734 CU_TEST(check_fd_mode(fd, O_RDWR));
1735 CU_TEST(tracefs_instance_file_read_number(instance, TRACE_ON, &res) == 0);
1736 if (res == 1) {
1737 CU_TEST(tracefs_trace_is_on(instance) == 1);
1738 CU_TEST(tracefs_trace_off(instance) == 0);
1739 CU_TEST(tracefs_trace_is_on(instance) == 0);
1740 CU_TEST(tracefs_trace_on(instance) == 0);
1741 CU_TEST(tracefs_trace_is_on(instance) == 1);
1742
1743 CU_TEST(tracefs_trace_off_fd(fd) == 0);
1744 CU_TEST(tracefs_trace_is_on(instance) == 0);
1745 CU_TEST(tracefs_trace_on_fd(fd) == 0);
1746 CU_TEST(tracefs_trace_is_on(instance) == 1);
1747 } else {
1748 CU_TEST(tracefs_trace_is_on(instance) == 0);
1749 CU_TEST(tracefs_trace_on(instance) == 0);
1750 CU_TEST(tracefs_trace_is_on(instance) == 1);
1751 CU_TEST(tracefs_trace_off(instance) == 0);
1752 CU_TEST(tracefs_trace_is_on(instance) == 0);
1753
1754 CU_TEST(tracefs_trace_on_fd(fd) == 0);
1755 CU_TEST(tracefs_trace_is_on(instance) == 1);
1756 CU_TEST(tracefs_trace_off_fd(fd) == 0);
1757 CU_TEST(tracefs_trace_is_on(instance) == 0);
1758 }
1759
1760 if (fd >= 0)
1761 close(fd);
1762 }
1763
test_tracing_onoff(void)1764 static void test_tracing_onoff(void)
1765 {
1766 test_instance_tracing_onoff(test_instance);
1767 }
1768
check_option(struct tracefs_instance * instance,enum tracefs_option_id id,bool exist,int enabled)1769 static bool check_option(struct tracefs_instance *instance,
1770 enum tracefs_option_id id, bool exist, int enabled)
1771 {
1772 const char *name = tracefs_option_name(id);
1773 char file[PATH_MAX];
1774 char *path = NULL;
1775 bool ret = false;
1776 bool supported;
1777 struct stat st;
1778 char buf[10];
1779 int fd = 0;
1780 int r;
1781 int rstat;
1782
1783 CU_TEST(name != NULL);
1784 supported = tracefs_option_is_supported(instance, id);
1785 CU_TEST(supported == exist);
1786 if (supported != exist)
1787 goto out;
1788 snprintf(file, PATH_MAX, "options/%s", name);
1789 path = tracefs_instance_get_file(instance, file);
1790 CU_TEST(path != NULL);
1791 rstat = stat(path, &st);
1792 if (exist) {
1793 CU_TEST(rstat == 0);
1794 if (rstat != 0)
1795 goto out;
1796 } else {
1797 CU_TEST(stat(path, &st) == -1);
1798 if (rstat != -1)
1799 goto out;
1800 }
1801
1802 fd = open(path, O_RDONLY);
1803 if (exist) {
1804 CU_TEST(fd >= 0);
1805 if (fd < 0)
1806 goto out;
1807 } else {
1808 CU_TEST(fd < 0);
1809 if (fd >= 0)
1810 goto out;
1811 }
1812
1813 if (exist && enabled >= 0) {
1814 int val = enabled ? '1' : '0';
1815
1816 r = read(fd, buf, 10);
1817 CU_TEST(r >= 1);
1818 CU_TEST(buf[0] == val);
1819 if (buf[0] != val)
1820 goto out;
1821 }
1822
1823 ret = true;
1824 out:
1825 tracefs_put_tracing_file(path);
1826 if (fd >= 0)
1827 close(fd);
1828 return ret;
1829 }
1830
test_instance_tracing_options(struct tracefs_instance * instance)1831 static void test_instance_tracing_options(struct tracefs_instance *instance)
1832 {
1833 const struct tracefs_options_mask *enabled;
1834 const struct tracefs_options_mask *all_copy;
1835 const struct tracefs_options_mask *all;
1836 enum tracefs_option_id i = 1;
1837 char file[PATH_MAX];
1838 const char *name;
1839
1840 all = tracefs_options_get_supported(instance);
1841 all_copy = tracefs_options_get_supported(instance);
1842 enabled = tracefs_options_get_enabled(instance);
1843 CU_TEST(all != NULL);
1844
1845 /* Invalid parameters test */
1846 CU_TEST(!tracefs_option_is_supported(instance, TRACEFS_OPTION_INVALID));
1847 CU_TEST(!tracefs_option_is_enabled(instance, TRACEFS_OPTION_INVALID));
1848 CU_TEST(tracefs_option_enable(instance, TRACEFS_OPTION_INVALID) == -1);
1849 CU_TEST(tracefs_option_disable(instance, TRACEFS_OPTION_INVALID) == -1);
1850 name = tracefs_option_name(TRACEFS_OPTION_INVALID);
1851 CU_TEST(!strcmp(name, "unknown"));
1852 /* Test all valid options */
1853 for (i = 1; i < TRACEFS_OPTION_MAX; i++) {
1854 name = tracefs_option_name(i);
1855 CU_TEST(name != NULL);
1856 CU_TEST(strcmp(name, "unknown"));
1857 snprintf(file, PATH_MAX, "options/%s", name);
1858
1859 if (tracefs_option_mask_is_set(all, i)) {
1860 CU_TEST(check_option(instance, i, true, -1));
1861 CU_TEST(tracefs_option_is_supported(instance, i));
1862 } else {
1863 CU_TEST(check_option(instance, i, false, -1));
1864 CU_TEST(!tracefs_option_is_supported(instance, i));
1865 }
1866
1867 if (tracefs_option_mask_is_set(enabled, i)) {
1868 CU_TEST(check_option(instance, i, true, 1));
1869 CU_TEST(tracefs_option_is_supported(instance, i));
1870 CU_TEST(tracefs_option_is_enabled(instance, i));
1871 CU_TEST(tracefs_option_disable(instance, i) == 0);
1872 CU_TEST(check_option(instance, i, true, 0));
1873 CU_TEST(tracefs_option_enable(instance, i) == 0);
1874 CU_TEST(check_option(instance, i, true, 1));
1875 } else if (tracefs_option_mask_is_set(all_copy, i)) {
1876 CU_TEST(check_option(instance, i, true, 0));
1877 CU_TEST(tracefs_option_is_supported(instance, i));
1878 CU_TEST(!tracefs_option_is_enabled(instance, i));
1879 CU_TEST(tracefs_option_enable(instance, i) == 0);
1880 CU_TEST(check_option(instance, i, true, 1));
1881 CU_TEST(tracefs_option_disable(instance, i) == 0);
1882 CU_TEST(check_option(instance, i, true, 0));
1883 }
1884 }
1885 }
1886
test_tracing_options(void)1887 static void test_tracing_options(void)
1888 {
1889 test_instance_tracing_options(test_instance);
1890 }
1891
exclude_string(char ** strings,char * name)1892 static void exclude_string(char **strings, char *name)
1893 {
1894 int i;
1895
1896 for (i = 0; strings[i]; i++) {
1897 if (strcmp(strings[i], name) == 0) {
1898 free(strings[i]);
1899 strings[i] = strdup("/");
1900 return;
1901 }
1902 }
1903 }
1904
test_check_files(const char * fdir,char ** files)1905 static void test_check_files(const char *fdir, char **files)
1906 {
1907 struct dirent *dent;
1908 DIR *dir;
1909 int i;
1910
1911 dir = opendir(fdir);
1912 CU_TEST(dir != NULL);
1913
1914 while ((dent = readdir(dir)))
1915 exclude_string(files, dent->d_name);
1916
1917 closedir(dir);
1918
1919 for (i = 0; files[i]; i++)
1920 CU_TEST(files[i][0] == '/');
1921 }
1922
system_event(const char * tdir)1923 static void system_event(const char *tdir)
1924 {
1925
1926 char **systems;
1927 char **events;
1928 char *sdir = NULL;
1929
1930 systems = tracefs_event_systems(tdir);
1931 CU_TEST(systems != NULL);
1932
1933 events = tracefs_system_events(tdir, systems[0]);
1934 CU_TEST(events != NULL);
1935
1936 asprintf(&sdir, "%s/events/%s", tdir, systems[0]);
1937 CU_TEST(sdir != NULL);
1938 test_check_files(sdir, events);
1939 free(sdir);
1940 sdir = NULL;
1941
1942 asprintf(&sdir, "%s/events", tdir);
1943 CU_TEST(sdir != NULL);
1944 test_check_files(sdir, systems);
1945
1946 tracefs_list_free(systems);
1947 tracefs_list_free(events);
1948
1949 free(sdir);
1950 }
1951
test_system_event(void)1952 static void test_system_event(void)
1953 {
1954 const char *tdir;
1955
1956 tdir = tracefs_tracing_dir();
1957 CU_TEST(tdir != NULL);
1958 system_event(tdir);
1959 }
1960
test_instance_tracers(struct tracefs_instance * instance)1961 static void test_instance_tracers(struct tracefs_instance *instance)
1962 {
1963 const char *tdir;
1964 char **tracers;
1965 char *tfile;
1966 char *tracer;
1967 int i;
1968
1969 tdir = tracefs_instance_get_trace_dir(instance);
1970 CU_TEST(tdir != NULL);
1971
1972 tracers = tracefs_tracers(tdir);
1973 CU_TEST(tracers != NULL);
1974
1975 for (i = 0; tracers[i]; i++)
1976 CU_TEST(tracefs_tracer_available(tdir, tracers[i]));
1977
1978 tfile = tracefs_instance_file_read(NULL, ALL_TRACERS, NULL);
1979
1980 tracer = strtok(tfile, " ");
1981 while (tracer) {
1982 exclude_string(tracers, tracer);
1983 tracer = strtok(NULL, " ");
1984 }
1985
1986 for (i = 0; tracers[i]; i++)
1987 CU_TEST(tracers[i][0] == '/');
1988
1989 tracefs_list_free(tracers);
1990 free(tfile);
1991 }
1992
test_tracers(void)1993 static void test_tracers(void)
1994 {
1995 test_instance_tracers(test_instance);
1996 }
1997
test_check_events(struct tep_handle * tep,char * system,bool exist)1998 static void test_check_events(struct tep_handle *tep, char *system, bool exist)
1999 {
2000 struct dirent *dent;
2001 char file[PATH_MAX];
2002 char buf[1024];
2003 char *edir = NULL;
2004 const char *tdir;
2005 DIR *dir;
2006 int fd;
2007
2008 tdir = tracefs_tracing_dir();
2009 CU_TEST(tdir != NULL);
2010
2011 asprintf(&edir, "%s/events/%s", tdir, system);
2012 dir = opendir(edir);
2013 CU_TEST(dir != NULL);
2014
2015 while ((dent = readdir(dir))) {
2016 if (dent->d_name[0] == '.')
2017 continue;
2018 sprintf(file, "%s/%s/id", edir, dent->d_name);
2019 fd = open(file, O_RDONLY);
2020 if (fd < 0)
2021 continue;
2022 CU_TEST(read(fd, buf, 1024) > 0);
2023 if (exist) {
2024 CU_TEST(tep_find_event(tep, atoi(buf)) != NULL);
2025 } else {
2026 CU_TEST(tep_find_event(tep, atoi(buf)) == NULL);
2027 }
2028
2029 close(fd);
2030 }
2031
2032 closedir(dir);
2033 free(edir);
2034
2035 }
2036
local_events(const char * tdir)2037 static void local_events(const char *tdir)
2038 {
2039 struct tep_handle *tep;
2040 char **systems;
2041 char *lsystems[3];
2042 int i;
2043
2044 tep = tracefs_local_events(tdir);
2045 CU_TEST(tep != NULL);
2046
2047 systems = tracefs_event_systems(tdir);
2048 CU_TEST(systems != NULL);
2049
2050 for (i = 0; systems[i]; i++)
2051 test_check_events(tep, systems[i], true);
2052 tep_free(tep);
2053
2054 memset(lsystems, 0, sizeof(lsystems));
2055 for (i = 0; systems[i]; i++) {
2056 if (!lsystems[0])
2057 lsystems[0] = systems[i];
2058 else if (!lsystems[2])
2059 lsystems[2] = systems[i];
2060 else
2061 break;
2062 }
2063
2064 if (lsystems[0] && lsystems[2]) {
2065 tep = tracefs_local_events_system(tdir,
2066 (const char * const *)lsystems);
2067 CU_TEST(tep != NULL);
2068 test_check_events(tep, lsystems[0], true);
2069 test_check_events(tep, lsystems[2], false);
2070 }
2071 tep_free(tep);
2072
2073 tep = tep_alloc();
2074 CU_TEST(tep != NULL);
2075 CU_TEST(tracefs_fill_local_events(tdir, tep, NULL) == 0);
2076 for (i = 0; systems[i]; i++)
2077 test_check_events(tep, systems[i], true);
2078
2079 tep_free(tep);
2080
2081 tracefs_list_free(systems);
2082 }
2083
test_local_events(void)2084 static void test_local_events(void)
2085 {
2086 const char *tdir;
2087
2088 tdir = tracefs_tracing_dir();
2089 CU_TEST(tdir != NULL);
2090 local_events(tdir);
2091 }
2092
2093 struct test_walk_instance {
2094 struct tracefs_instance *instance;
2095 bool found;
2096 };
2097 #define WALK_COUNT 10
test_instances_walk_cb(const char * name,void * data)2098 int test_instances_walk_cb(const char *name, void *data)
2099 {
2100 struct test_walk_instance *instances = (struct test_walk_instance *)data;
2101 int i;
2102
2103 CU_TEST(instances != NULL);
2104 CU_TEST(name != NULL);
2105
2106 for (i = 0; i < WALK_COUNT; i++) {
2107 if (!strcmp(name,
2108 tracefs_instance_get_name(instances[i].instance))) {
2109 instances[i].found = true;
2110 break;
2111 }
2112 }
2113
2114 return 0;
2115 }
2116
test_instances_walk(void)2117 static void test_instances_walk(void)
2118 {
2119 struct test_walk_instance instances[WALK_COUNT];
2120 int i;
2121
2122 memset(instances, 0, WALK_COUNT * sizeof(struct test_walk_instance));
2123 for (i = 0; i < WALK_COUNT; i++) {
2124 instances[i].instance = tracefs_instance_create(get_rand_str());
2125 CU_TEST(instances[i].instance != NULL);
2126 }
2127
2128 CU_TEST(tracefs_instances_walk(test_instances_walk_cb, instances) == 0);
2129 for (i = 0; i < WALK_COUNT; i++) {
2130 CU_TEST(instances[i].found);
2131 tracefs_instance_destroy(instances[i].instance);
2132 instances[i].found = false;
2133 }
2134
2135 CU_TEST(tracefs_instances_walk(test_instances_walk_cb, instances) == 0);
2136 for (i = 0; i < WALK_COUNT; i++) {
2137 CU_TEST(!instances[i].found);
2138 tracefs_instance_free(instances[i].instance);
2139 }
2140 }
2141
current_clock_check(struct tracefs_instance * instance,const char * clock)2142 static void current_clock_check(struct tracefs_instance *instance, const char *clock)
2143 {
2144 int size = 0;
2145 char *clocks;
2146 char *str;
2147
2148 clocks = tracefs_instance_file_read(instance, TRACE_CLOCK, &size);
2149 CU_TEST_FATAL(clocks != NULL);
2150 CU_TEST(size > strlen(clock));
2151 str = strstr(clocks, clock);
2152 CU_TEST(str != NULL);
2153 CU_TEST(str != clocks);
2154 CU_TEST(*(str - 1) == '[');
2155 CU_TEST(*(str + strlen(clock)) == ']');
2156 free(clocks);
2157 }
2158
test_instance_get_clock(struct tracefs_instance * instance)2159 static void test_instance_get_clock(struct tracefs_instance *instance)
2160 {
2161 const char *clock;
2162
2163 clock = tracefs_get_clock(instance);
2164 CU_TEST_FATAL(clock != NULL);
2165 current_clock_check(instance, clock);
2166 free((char *)clock);
2167 }
2168
test_get_clock(void)2169 static void test_get_clock(void)
2170 {
2171 test_instance_get_clock(test_instance);
2172 }
2173
copy_trace_file(const char * from,char * to)2174 static void copy_trace_file(const char *from, char *to)
2175 {
2176 int fd_from = -1;
2177 int fd_to = -1;
2178 char buf[512];
2179 int ret;
2180
2181 fd_from = open(from, O_RDONLY);
2182 if (fd_from < 0)
2183 goto out;
2184 fd_to = open(to, O_WRONLY | O_TRUNC | O_CREAT, S_IRWXU | S_IRWXG);
2185 if (fd_to < 0)
2186 goto out;
2187
2188 while ((ret = read(fd_from, buf, 512)) > 0) {
2189 if (write(fd_to, buf, ret) == -1)
2190 break;
2191 }
2192
2193 out:
2194 if (fd_to >= 0)
2195 close(fd_to);
2196 if (fd_from >= 0)
2197 close(fd_from);
2198 }
2199
2200 static int trace_dir_base;
2201 static char *trace_tmp_dir;
copy_trace_walk(const char * fpath,const struct stat * sb,int typeflag,struct FTW * ftwbuf)2202 static int copy_trace_walk(const char *fpath, const struct stat *sb,
2203 int typeflag, struct FTW *ftwbuf)
2204 {
2205 char path[PATH_MAX];
2206
2207 sprintf(path, "%s%s", trace_tmp_dir, fpath + trace_dir_base);
2208
2209 switch (typeflag) {
2210 case FTW_D:
2211 mkdir(path, 0750);
2212 break;
2213 case FTW_F:
2214 copy_trace_file(fpath, path);
2215 break;
2216 default:
2217 break;
2218 }
2219 return 0;
2220 }
2221
dup_trace_dir(char * to,char * dir)2222 static void dup_trace_dir(char *to, char *dir)
2223 {
2224 const char *trace_dir = tracefs_tracing_dir();
2225 char file_from[PATH_MAX];
2226 char file_to[PATH_MAX];
2227
2228 sprintf(file_from, "%s/%s", trace_dir, dir);
2229 sprintf(file_to, "%s/%s", to, dir);
2230 trace_tmp_dir = file_to;
2231 trace_dir_base = strlen(file_from);
2232 nftw(file_from, copy_trace_walk, 20, 0);
2233 }
2234
dup_trace_file(char * to,char * file)2235 static void dup_trace_file(char *to, char *file)
2236 {
2237 const char *trace_dir = tracefs_tracing_dir();
2238 char file_from[PATH_MAX];
2239 char file_to[PATH_MAX];
2240
2241 sprintf(file_from, "%s/%s", trace_dir, file);
2242 sprintf(file_to, "%s/%s", to, file);
2243 copy_trace_file(file_from, file_to);
2244 }
2245
copy_trace_dir(void)2246 static char *copy_trace_dir(void)
2247 {
2248 char template[] = TEST_TRACE_DIR;
2249 char *dname = mkdtemp(template);
2250
2251 dup_trace_dir(dname, "events");
2252 dup_trace_dir(dname, "options");
2253 dup_trace_file(dname, TRACE_ON);
2254 dup_trace_file(dname, CUR_TRACER);
2255 dup_trace_file(dname, TRACE_CLOCK);
2256 dup_trace_file(dname, ALL_TRACERS);
2257
2258 return strdup(dname);
2259 }
2260
del_trace_walk(const char * fpath,const struct stat * sb,int typeflag,struct FTW * ftwbuf)2261 static int del_trace_walk(const char *fpath, const struct stat *sb,
2262 int typeflag, struct FTW *ftwbuf)
2263 {
2264 remove(fpath);
2265 return 0;
2266 }
2267
del_trace_dir(char * dir)2268 void del_trace_dir(char *dir)
2269 {
2270 nftw(dir, del_trace_walk, 20, FTW_DEPTH);
2271 }
2272
test_custom_trace_dir(void)2273 static void test_custom_trace_dir(void)
2274 {
2275 char *tdir = "/tmp/custom_tracefs";
2276 struct tracefs_instance *instance;
2277 char *dname = copy_trace_dir();
2278 const char *trace_dir;
2279 char *tfile;
2280
2281 instance = tracefs_instance_alloc(dname, NULL);
2282 CU_TEST(instance != NULL);
2283
2284 system_event(dname);
2285 local_events(dname);
2286 test_instance_tracing_options(instance);
2287 test_instance_get_clock(instance);
2288 test_instance_file_fd(instance);
2289 test_instance_tracers(instance);
2290
2291 tracefs_instance_free(instance);
2292 del_trace_dir(dname);
2293 free(dname);
2294
2295 trace_dir = tracefs_tracing_dir();
2296 CU_TEST(trace_dir != NULL);
2297 CU_TEST(tracefs_set_tracing_dir(tdir) == 0);
2298 CU_TEST(strcmp(tdir, tracefs_tracing_dir()) == 0);
2299 tfile = tracefs_get_tracing_file("trace");
2300 CU_TEST(tfile != NULL);
2301 CU_TEST(strcmp(tdir, dirname(tfile)) == 0);
2302 free(tfile);
2303
2304 CU_TEST(tracefs_set_tracing_dir(NULL) == 0);
2305 CU_TEST(strcmp(trace_dir, tracefs_tracing_dir()) == 0);
2306 tfile = tracefs_get_tracing_file("trace");
2307 CU_TEST(tfile != NULL);
2308 CU_TEST(strcmp(trace_dir, dirname(tfile)) == 0);
2309 free(tfile);
2310 }
2311
test_suite_destroy(void)2312 static int test_suite_destroy(void)
2313 {
2314 tracefs_instance_destroy(test_instance);
2315 tracefs_instance_free(test_instance);
2316 tep_free(test_tep);
2317 return 0;
2318 }
2319
test_suite_init(void)2320 static int test_suite_init(void)
2321 {
2322 const char *systems[] = {"ftrace", NULL};
2323
2324 test_tep = tracefs_local_events_system(NULL, systems);
2325 if (test_tep == NULL)
2326 return 1;
2327 test_instance = tracefs_instance_create(TEST_INSTANCE_NAME);
2328 if (!test_instance)
2329 return 1;
2330
2331 return 0;
2332 }
2333
test_tracefs_lib(void)2334 void test_tracefs_lib(void)
2335 {
2336 CU_pSuite suite = NULL;
2337
2338 suite = CU_add_suite(TRACEFS_SUITE, test_suite_init, test_suite_destroy);
2339 if (suite == NULL) {
2340 fprintf(stderr, "Suite \"%s\" cannot be ceated\n", TRACEFS_SUITE);
2341 return;
2342 }
2343
2344 CU_add_test(suite, "Test tracefs/debugfs mounting", test_mounting);
2345 CU_add_test(suite, "trace cpu read",
2346 test_trace_cpu_read);
2347 CU_add_test(suite, "trace cpu pipe",
2348 test_trace_cpu_pipe);
2349 CU_add_test(suite, "trace sql",
2350 test_trace_sql);
2351 CU_add_test(suite, "tracing file / directory APIs",
2352 test_trace_file);
2353 CU_add_test(suite, "instance file / directory APIs",
2354 test_file_fd);
2355 CU_add_test(suite, "instance file descriptor",
2356 test_instance_file);
2357 CU_add_test(suite, "systems and events APIs",
2358 test_system_event);
2359 CU_add_test(suite, "tracefs_iterate_raw_events API",
2360 test_iter_raw_events);
2361
2362 /* Follow events test must be after the iterate raw events above */
2363 CU_add_test(suite, "Follow events", test_follow_events);
2364
2365 CU_add_test(suite, "tracefs_tracers API",
2366 test_tracers);
2367 CU_add_test(suite, "tracefs_local events API",
2368 test_local_events);
2369 CU_add_test(suite, "tracefs_instances_walk API",
2370 test_instances_walk);
2371 CU_add_test(suite, "tracefs_get_clock API",
2372 test_get_clock);
2373 CU_add_test(suite, "tracing on / off",
2374 test_tracing_onoff);
2375 CU_add_test(suite, "tracing options",
2376 test_tracing_options);
2377 CU_add_test(suite, "custom system directory",
2378 test_custom_trace_dir);
2379 CU_add_test(suite, "ftrace marker",
2380 test_ftrace_marker);
2381 CU_add_test(suite, "kprobes", test_kprobes);
2382 CU_add_test(suite, "synthetic events", test_synthetic);
2383 CU_add_test(suite, "eprobes", test_eprobes);
2384 CU_add_test(suite, "uprobes", test_uprobes);
2385 }
2386