1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <bristot@kernel.org>
4  */
5 
6 #include <getopt.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <signal.h>
10 #include <unistd.h>
11 #include <stdio.h>
12 #include <time.h>
13 
14 #include "utils.h"
15 #include "osnoise.h"
16 #include "timerlat.h"
17 
18 struct timerlat_hist_params {
19 	char			*cpus;
20 	char			*monitored_cpus;
21 	char			*trace_output;
22 	unsigned long long	runtime;
23 	long long		stop_us;
24 	long long		stop_total_us;
25 	long long		timerlat_period_us;
26 	long long		print_stack;
27 	int			sleep_time;
28 	int			output_divisor;
29 	int			duration;
30 	int			set_sched;
31 	int			dma_latency;
32 	struct sched_attr	sched_param;
33 	struct trace_events	*events;
34 
35 	char			no_irq;
36 	char			no_thread;
37 	char			no_header;
38 	char			no_summary;
39 	char			no_index;
40 	char			with_zeros;
41 	int			bucket_size;
42 	int			entries;
43 };
44 
45 struct timerlat_hist_cpu {
46 	int			*irq;
47 	int			*thread;
48 
49 	int			irq_count;
50 	int			thread_count;
51 
52 	unsigned long long	min_irq;
53 	unsigned long long	sum_irq;
54 	unsigned long long	max_irq;
55 
56 	unsigned long long	min_thread;
57 	unsigned long long	sum_thread;
58 	unsigned long long	max_thread;
59 };
60 
61 struct timerlat_hist_data {
62 	struct timerlat_hist_cpu	*hist;
63 	int				entries;
64 	int				bucket_size;
65 	int				nr_cpus;
66 };
67 
68 /*
69  * timerlat_free_histogram - free runtime data
70  */
71 static void
72 timerlat_free_histogram(struct timerlat_hist_data *data)
73 {
74 	int cpu;
75 
76 	/* one histogram for IRQ and one for thread, per CPU */
77 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
78 		if (data->hist[cpu].irq)
79 			free(data->hist[cpu].irq);
80 
81 		if (data->hist[cpu].thread)
82 			free(data->hist[cpu].thread);
83 	}
84 
85 	/* one set of histograms per CPU */
86 	if (data->hist)
87 		free(data->hist);
88 
89 	free(data);
90 }
91 
92 /*
93  * timerlat_alloc_histogram - alloc runtime data
94  */
95 static struct timerlat_hist_data
96 *timerlat_alloc_histogram(int nr_cpus, int entries, int bucket_size)
97 {
98 	struct timerlat_hist_data *data;
99 	int cpu;
100 
101 	data = calloc(1, sizeof(*data));
102 	if (!data)
103 		return NULL;
104 
105 	data->entries = entries;
106 	data->bucket_size = bucket_size;
107 	data->nr_cpus = nr_cpus;
108 
109 	/* one set of histograms per CPU */
110 	data->hist = calloc(1, sizeof(*data->hist) * nr_cpus);
111 	if (!data->hist)
112 		goto cleanup;
113 
114 	/* one histogram for IRQ and one for thread, per cpu */
115 	for (cpu = 0; cpu < nr_cpus; cpu++) {
116 		data->hist[cpu].irq = calloc(1, sizeof(*data->hist->irq) * (entries + 1));
117 		if (!data->hist[cpu].irq)
118 			goto cleanup;
119 		data->hist[cpu].thread = calloc(1, sizeof(*data->hist->thread) * (entries + 1));
120 		if (!data->hist[cpu].thread)
121 			goto cleanup;
122 	}
123 
124 	/* set the min to max */
125 	for (cpu = 0; cpu < nr_cpus; cpu++) {
126 		data->hist[cpu].min_irq = ~0;
127 		data->hist[cpu].min_thread = ~0;
128 	}
129 
130 	return data;
131 
132 cleanup:
133 	timerlat_free_histogram(data);
134 	return NULL;
135 }
136 
137 /*
138  * timerlat_hist_update - record a new timerlat occurent on cpu, updating data
139  */
140 static void
141 timerlat_hist_update(struct osnoise_tool *tool, int cpu,
142 		     unsigned long long thread,
143 		     unsigned long long latency)
144 {
145 	struct timerlat_hist_params *params = tool->params;
146 	struct timerlat_hist_data *data = tool->data;
147 	int entries = data->entries;
148 	int bucket;
149 	int *hist;
150 
151 	if (params->output_divisor)
152 		latency = latency / params->output_divisor;
153 
154 	if (data->bucket_size)
155 		bucket = latency / data->bucket_size;
156 
157 	if (!thread) {
158 		hist = data->hist[cpu].irq;
159 		data->hist[cpu].irq_count++;
160 		update_min(&data->hist[cpu].min_irq, &latency);
161 		update_sum(&data->hist[cpu].sum_irq, &latency);
162 		update_max(&data->hist[cpu].max_irq, &latency);
163 	} else {
164 		hist = data->hist[cpu].thread;
165 		data->hist[cpu].thread_count++;
166 		update_min(&data->hist[cpu].min_thread, &latency);
167 		update_sum(&data->hist[cpu].sum_thread, &latency);
168 		update_max(&data->hist[cpu].max_thread, &latency);
169 	}
170 
171 	if (bucket < entries)
172 		hist[bucket]++;
173 	else
174 		hist[entries]++;
175 }
176 
177 /*
178  * timerlat_hist_handler - this is the handler for timerlat tracer events
179  */
180 static int
181 timerlat_hist_handler(struct trace_seq *s, struct tep_record *record,
182 		     struct tep_event *event, void *data)
183 {
184 	struct trace_instance *trace = data;
185 	unsigned long long thread, latency;
186 	struct osnoise_tool *tool;
187 	int cpu = record->cpu;
188 
189 	tool = container_of(trace, struct osnoise_tool, trace);
190 
191 	tep_get_field_val(s, event, "context", record, &thread, 1);
192 	tep_get_field_val(s, event, "timer_latency", record, &latency, 1);
193 
194 	timerlat_hist_update(tool, cpu, thread, latency);
195 
196 	return 0;
197 }
198 
199 /*
200  * timerlat_hist_header - print the header of the tracer to the output
201  */
202 static void timerlat_hist_header(struct osnoise_tool *tool)
203 {
204 	struct timerlat_hist_params *params = tool->params;
205 	struct timerlat_hist_data *data = tool->data;
206 	struct trace_seq *s = tool->trace.seq;
207 	char duration[26];
208 	int cpu;
209 
210 	if (params->no_header)
211 		return;
212 
213 	get_duration(tool->start_time, duration, sizeof(duration));
214 	trace_seq_printf(s, "# RTLA timerlat histogram\n");
215 	trace_seq_printf(s, "# Time unit is %s (%s)\n",
216 			params->output_divisor == 1 ? "nanoseconds" : "microseconds",
217 			params->output_divisor == 1 ? "ns" : "us");
218 
219 	trace_seq_printf(s, "# Duration: %s\n", duration);
220 
221 	if (!params->no_index)
222 		trace_seq_printf(s, "Index");
223 
224 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
225 		if (params->cpus && !params->monitored_cpus[cpu])
226 			continue;
227 
228 		if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
229 			continue;
230 
231 		if (!params->no_irq)
232 			trace_seq_printf(s, "   IRQ-%03d", cpu);
233 
234 		if (!params->no_thread)
235 			trace_seq_printf(s, "   Thr-%03d", cpu);
236 	}
237 	trace_seq_printf(s, "\n");
238 
239 
240 	trace_seq_do_printf(s);
241 	trace_seq_reset(s);
242 }
243 
244 /*
245  * timerlat_print_summary - print the summary of the hist data to the output
246  */
247 static void
248 timerlat_print_summary(struct timerlat_hist_params *params,
249 		       struct trace_instance *trace,
250 		       struct timerlat_hist_data *data)
251 {
252 	int cpu;
253 
254 	if (params->no_summary)
255 		return;
256 
257 	if (!params->no_index)
258 		trace_seq_printf(trace->seq, "count:");
259 
260 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
261 		if (params->cpus && !params->monitored_cpus[cpu])
262 			continue;
263 
264 		if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
265 			continue;
266 
267 		if (!params->no_irq)
268 			trace_seq_printf(trace->seq, "%9d ",
269 					data->hist[cpu].irq_count);
270 
271 		if (!params->no_thread)
272 			trace_seq_printf(trace->seq, "%9d ",
273 					data->hist[cpu].thread_count);
274 	}
275 	trace_seq_printf(trace->seq, "\n");
276 
277 	if (!params->no_index)
278 		trace_seq_printf(trace->seq, "min:  ");
279 
280 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
281 		if (params->cpus && !params->monitored_cpus[cpu])
282 			continue;
283 
284 		if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
285 			continue;
286 
287 		if (!params->no_irq)
288 			trace_seq_printf(trace->seq, "%9llu ",
289 					data->hist[cpu].min_irq);
290 
291 		if (!params->no_thread)
292 			trace_seq_printf(trace->seq, "%9llu ",
293 					data->hist[cpu].min_thread);
294 	}
295 	trace_seq_printf(trace->seq, "\n");
296 
297 	if (!params->no_index)
298 		trace_seq_printf(trace->seq, "avg:  ");
299 
300 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
301 		if (params->cpus && !params->monitored_cpus[cpu])
302 			continue;
303 
304 		if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
305 			continue;
306 
307 		if (!params->no_irq) {
308 			if (data->hist[cpu].irq_count)
309 				trace_seq_printf(trace->seq, "%9llu ",
310 						 data->hist[cpu].sum_irq / data->hist[cpu].irq_count);
311 			else
312 				trace_seq_printf(trace->seq, "        - ");
313 		}
314 
315 		if (!params->no_thread) {
316 			if (data->hist[cpu].thread_count)
317 				trace_seq_printf(trace->seq, "%9llu ",
318 						data->hist[cpu].sum_thread / data->hist[cpu].thread_count);
319 			else
320 				trace_seq_printf(trace->seq, "        - ");
321 		}
322 	}
323 	trace_seq_printf(trace->seq, "\n");
324 
325 	if (!params->no_index)
326 		trace_seq_printf(trace->seq, "max:  ");
327 
328 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
329 		if (params->cpus && !params->monitored_cpus[cpu])
330 			continue;
331 
332 		if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
333 			continue;
334 
335 		if (!params->no_irq)
336 			trace_seq_printf(trace->seq, "%9llu ",
337 					data->hist[cpu].max_irq);
338 
339 		if (!params->no_thread)
340 			trace_seq_printf(trace->seq, "%9llu ",
341 					data->hist[cpu].max_thread);
342 	}
343 	trace_seq_printf(trace->seq, "\n");
344 	trace_seq_do_printf(trace->seq);
345 	trace_seq_reset(trace->seq);
346 }
347 
348 /*
349  * timerlat_print_stats - print data for all CPUs
350  */
351 static void
352 timerlat_print_stats(struct timerlat_hist_params *params, struct osnoise_tool *tool)
353 {
354 	struct timerlat_hist_data *data = tool->data;
355 	struct trace_instance *trace = &tool->trace;
356 	int bucket, cpu;
357 	int total;
358 
359 	timerlat_hist_header(tool);
360 
361 	for (bucket = 0; bucket < data->entries; bucket++) {
362 		total = 0;
363 
364 		if (!params->no_index)
365 			trace_seq_printf(trace->seq, "%-6d",
366 					 bucket * data->bucket_size);
367 
368 		for (cpu = 0; cpu < data->nr_cpus; cpu++) {
369 			if (params->cpus && !params->monitored_cpus[cpu])
370 				continue;
371 
372 			if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
373 				continue;
374 
375 			if (!params->no_irq) {
376 				total += data->hist[cpu].irq[bucket];
377 				trace_seq_printf(trace->seq, "%9d ",
378 						data->hist[cpu].irq[bucket]);
379 			}
380 
381 			if (!params->no_thread) {
382 				total += data->hist[cpu].thread[bucket];
383 				trace_seq_printf(trace->seq, "%9d ",
384 						data->hist[cpu].thread[bucket]);
385 			}
386 
387 		}
388 
389 		if (total == 0 && !params->with_zeros) {
390 			trace_seq_reset(trace->seq);
391 			continue;
392 		}
393 
394 		trace_seq_printf(trace->seq, "\n");
395 		trace_seq_do_printf(trace->seq);
396 		trace_seq_reset(trace->seq);
397 	}
398 
399 	if (!params->no_index)
400 		trace_seq_printf(trace->seq, "over: ");
401 
402 	for (cpu = 0; cpu < data->nr_cpus; cpu++) {
403 		if (params->cpus && !params->monitored_cpus[cpu])
404 			continue;
405 
406 		if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
407 			continue;
408 
409 		if (!params->no_irq)
410 			trace_seq_printf(trace->seq, "%9d ",
411 					 data->hist[cpu].irq[data->entries]);
412 
413 		if (!params->no_thread)
414 			trace_seq_printf(trace->seq, "%9d ",
415 					 data->hist[cpu].thread[data->entries]);
416 	}
417 	trace_seq_printf(trace->seq, "\n");
418 	trace_seq_do_printf(trace->seq);
419 	trace_seq_reset(trace->seq);
420 
421 	timerlat_print_summary(params, trace, data);
422 }
423 
424 /*
425  * timerlat_hist_usage - prints timerlat top usage message
426  */
427 static void timerlat_hist_usage(char *usage)
428 {
429 	int i;
430 
431 	char *msg[] = {
432 		"",
433 		"  usage: [rtla] timerlat hist [-h] [-q] [-d s] [-D] [-n] [-a us] [-p us] [-i us] [-T us] [-s us] \\",
434 		"         [-t[=file]] [-e sys[:event]] [--filter <filter>] [--trigger <trigger>] [-c cpu-list] \\",
435 		"	  [-P priority] [-E N] [-b N] [--no-irq] [--no-thread] [--no-header] [--no-summary] \\",
436 		"	  [--no-index] [--with-zeros] [--dma-latency us]",
437 		"",
438 		"	  -h/--help: print this menu",
439 		"	  -a/--auto: set automatic trace mode, stopping the session if argument in us latency is hit",
440 		"	  -p/--period us: timerlat period in us",
441 		"	  -i/--irq us: stop trace if the irq latency is higher than the argument in us",
442 		"	  -T/--thread us: stop trace if the thread latency is higher than the argument in us",
443 		"	  -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
444 		"	  -c/--cpus cpus: run the tracer only on the given cpus",
445 		"	  -d/--duration time[m|h|d]: duration of the session in seconds",
446 		"	  -D/--debug: print debug info",
447 		"	  -t/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
448 		"	  -e/--event <sys:event>: enable the <sys:event> in the trace instance, multiple -e are allowed",
449 		"	     --filter <filter>: enable a trace event filter to the previous -e event",
450 		"	     --trigger <trigger>: enable a trace event trigger to the previous -e event",
451 		"	  -n/--nano: display data in nanoseconds",
452 		"	  -b/--bucket-size N: set the histogram bucket size (default 1)",
453 		"	  -E/--entries N: set the number of entries of the histogram (default 256)",
454 		"	     --no-irq: ignore IRQ latencies",
455 		"	     --no-thread: ignore thread latencies",
456 		"	     --no-header: do not print header",
457 		"	     --no-summary: do not print summary",
458 		"	     --no-index: do not print index",
459 		"	     --with-zeros: print zero only entries",
460 		"	     --dma-latency us: set /dev/cpu_dma_latency latency <us> to reduce exit from idle latency",
461 		"	  -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
462 		"		o:prio - use SCHED_OTHER with prio",
463 		"		r:prio - use SCHED_RR with prio",
464 		"		f:prio - use SCHED_FIFO with prio",
465 		"		d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
466 		"						       in nanoseconds",
467 		NULL,
468 	};
469 
470 	if (usage)
471 		fprintf(stderr, "%s\n", usage);
472 
473 	fprintf(stderr, "rtla timerlat hist: a per-cpu histogram of the timer latency (version %s)\n",
474 			VERSION);
475 
476 	for (i = 0; msg[i]; i++)
477 		fprintf(stderr, "%s\n", msg[i]);
478 	exit(1);
479 }
480 
481 /*
482  * timerlat_hist_parse_args - allocs, parse and fill the cmd line parameters
483  */
484 static struct timerlat_hist_params
485 *timerlat_hist_parse_args(int argc, char *argv[])
486 {
487 	struct timerlat_hist_params *params;
488 	struct trace_events *tevent;
489 	int auto_thresh;
490 	int retval;
491 	int c;
492 
493 	params = calloc(1, sizeof(*params));
494 	if (!params)
495 		exit(1);
496 
497 	/* disabled by default */
498 	params->dma_latency = -1;
499 
500 	/* display data in microseconds */
501 	params->output_divisor = 1000;
502 	params->bucket_size = 1;
503 	params->entries = 256;
504 
505 	while (1) {
506 		static struct option long_options[] = {
507 			{"auto",		required_argument,	0, 'a'},
508 			{"cpus",		required_argument,	0, 'c'},
509 			{"bucket-size",		required_argument,	0, 'b'},
510 			{"debug",		no_argument,		0, 'D'},
511 			{"entries",		required_argument,	0, 'E'},
512 			{"duration",		required_argument,	0, 'd'},
513 			{"help",		no_argument,		0, 'h'},
514 			{"irq",			required_argument,	0, 'i'},
515 			{"nano",		no_argument,		0, 'n'},
516 			{"period",		required_argument,	0, 'p'},
517 			{"priority",		required_argument,	0, 'P'},
518 			{"stack",		required_argument,	0, 's'},
519 			{"thread",		required_argument,	0, 'T'},
520 			{"trace",		optional_argument,	0, 't'},
521 			{"event",		required_argument,	0, 'e'},
522 			{"no-irq",		no_argument,		0, '0'},
523 			{"no-thread",		no_argument,		0, '1'},
524 			{"no-header",		no_argument,		0, '2'},
525 			{"no-summary",		no_argument,		0, '3'},
526 			{"no-index",		no_argument,		0, '4'},
527 			{"with-zeros",		no_argument,		0, '5'},
528 			{"trigger",		required_argument,	0, '6'},
529 			{"filter",		required_argument,	0, '7'},
530 			{"dma-latency",		required_argument,	0, '8'},
531 			{0, 0, 0, 0}
532 		};
533 
534 		/* getopt_long stores the option index here. */
535 		int option_index = 0;
536 
537 		c = getopt_long(argc, argv, "a:c:b:d:e:E:Dhi:np:P:s:t::T:0123456:7:8:",
538 				 long_options, &option_index);
539 
540 		/* detect the end of the options. */
541 		if (c == -1)
542 			break;
543 
544 		switch (c) {
545 		case 'a':
546 			auto_thresh = get_llong_from_str(optarg);
547 
548 			/* set thread stop to auto_thresh */
549 			params->stop_total_us = auto_thresh;
550 
551 			/* get stack trace */
552 			params->print_stack = auto_thresh;
553 
554 			/* set trace */
555 			params->trace_output = "timerlat_trace.txt";
556 
557 			break;
558 		case 'c':
559 			retval = parse_cpu_list(optarg, &params->monitored_cpus);
560 			if (retval)
561 				timerlat_hist_usage("\nInvalid -c cpu list\n");
562 			params->cpus = optarg;
563 			break;
564 		case 'b':
565 			params->bucket_size = get_llong_from_str(optarg);
566 			if ((params->bucket_size == 0) || (params->bucket_size >= 1000000))
567 				timerlat_hist_usage("Bucket size needs to be > 0 and <= 1000000\n");
568 			break;
569 		case 'D':
570 			config_debug = 1;
571 			break;
572 		case 'd':
573 			params->duration = parse_seconds_duration(optarg);
574 			if (!params->duration)
575 				timerlat_hist_usage("Invalid -D duration\n");
576 			break;
577 		case 'e':
578 			tevent = trace_event_alloc(optarg);
579 			if (!tevent) {
580 				err_msg("Error alloc trace event");
581 				exit(EXIT_FAILURE);
582 			}
583 
584 			if (params->events)
585 				tevent->next = params->events;
586 
587 			params->events = tevent;
588 			break;
589 		case 'E':
590 			params->entries = get_llong_from_str(optarg);
591 			if ((params->entries < 10) || (params->entries > 9999999))
592 					timerlat_hist_usage("Entries must be > 10 and < 9999999\n");
593 			break;
594 		case 'h':
595 		case '?':
596 			timerlat_hist_usage(NULL);
597 			break;
598 		case 'i':
599 			params->stop_us = get_llong_from_str(optarg);
600 			break;
601 		case 'n':
602 			params->output_divisor = 1;
603 			break;
604 		case 'p':
605 			params->timerlat_period_us = get_llong_from_str(optarg);
606 			if (params->timerlat_period_us > 1000000)
607 				timerlat_hist_usage("Period longer than 1 s\n");
608 			break;
609 		case 'P':
610 			retval = parse_prio(optarg, &params->sched_param);
611 			if (retval == -1)
612 				timerlat_hist_usage("Invalid -P priority");
613 			params->set_sched = 1;
614 			break;
615 		case 's':
616 			params->print_stack = get_llong_from_str(optarg);
617 			break;
618 		case 'T':
619 			params->stop_total_us = get_llong_from_str(optarg);
620 			break;
621 		case 't':
622 			if (optarg)
623 				/* skip = */
624 				params->trace_output = &optarg[1];
625 			else
626 				params->trace_output = "timerlat_trace.txt";
627 			break;
628 		case '0': /* no irq */
629 			params->no_irq = 1;
630 			break;
631 		case '1': /* no thread */
632 			params->no_thread = 1;
633 			break;
634 		case '2': /* no header */
635 			params->no_header = 1;
636 			break;
637 		case '3': /* no summary */
638 			params->no_summary = 1;
639 			break;
640 		case '4': /* no index */
641 			params->no_index = 1;
642 			break;
643 		case '5': /* with zeros */
644 			params->with_zeros = 1;
645 			break;
646 		case '6': /* trigger */
647 			if (params->events) {
648 				retval = trace_event_add_trigger(params->events, optarg);
649 				if (retval) {
650 					err_msg("Error adding trigger %s\n", optarg);
651 					exit(EXIT_FAILURE);
652 				}
653 			} else {
654 				timerlat_hist_usage("--trigger requires a previous -e\n");
655 			}
656 			break;
657 		case '7': /* filter */
658 			if (params->events) {
659 				retval = trace_event_add_filter(params->events, optarg);
660 				if (retval) {
661 					err_msg("Error adding filter %s\n", optarg);
662 					exit(EXIT_FAILURE);
663 				}
664 			} else {
665 				timerlat_hist_usage("--filter requires a previous -e\n");
666 			}
667 			break;
668 		case '8':
669 			params->dma_latency = get_llong_from_str(optarg);
670 			if (params->dma_latency < 0 || params->dma_latency > 10000) {
671 				err_msg("--dma-latency needs to be >= 0 and < 10000");
672 				exit(EXIT_FAILURE);
673 			}
674 			break;
675 		default:
676 			timerlat_hist_usage("Invalid option");
677 		}
678 	}
679 
680 	if (geteuid()) {
681 		err_msg("rtla needs root permission\n");
682 		exit(EXIT_FAILURE);
683 	}
684 
685 	if (params->no_irq && params->no_thread)
686 		timerlat_hist_usage("no-irq and no-thread set, there is nothing to do here");
687 
688 	if (params->no_index && !params->with_zeros)
689 		timerlat_hist_usage("no-index set with with-zeros is not set - it does not make sense");
690 
691 	return params;
692 }
693 
694 /*
695  * timerlat_hist_apply_config - apply the hist configs to the initialized tool
696  */
697 static int
698 timerlat_hist_apply_config(struct osnoise_tool *tool, struct timerlat_hist_params *params)
699 {
700 	int retval;
701 
702 	if (!params->sleep_time)
703 		params->sleep_time = 1;
704 
705 	if (params->cpus) {
706 		retval = osnoise_set_cpus(tool->context, params->cpus);
707 		if (retval) {
708 			err_msg("Failed to apply CPUs config\n");
709 			goto out_err;
710 		}
711 	}
712 
713 	if (params->stop_us) {
714 		retval = osnoise_set_stop_us(tool->context, params->stop_us);
715 		if (retval) {
716 			err_msg("Failed to set stop us\n");
717 			goto out_err;
718 		}
719 	}
720 
721 	if (params->stop_total_us) {
722 		retval = osnoise_set_stop_total_us(tool->context, params->stop_total_us);
723 		if (retval) {
724 			err_msg("Failed to set stop total us\n");
725 			goto out_err;
726 		}
727 	}
728 
729 	if (params->timerlat_period_us) {
730 		retval = osnoise_set_timerlat_period_us(tool->context, params->timerlat_period_us);
731 		if (retval) {
732 			err_msg("Failed to set timerlat period\n");
733 			goto out_err;
734 		}
735 	}
736 
737 	if (params->print_stack) {
738 		retval = osnoise_set_print_stack(tool->context, params->print_stack);
739 		if (retval) {
740 			err_msg("Failed to set print stack\n");
741 			goto out_err;
742 		}
743 	}
744 
745 	return 0;
746 
747 out_err:
748 	return -1;
749 }
750 
751 /*
752  * timerlat_init_hist - initialize a timerlat hist tool with parameters
753  */
754 static struct osnoise_tool
755 *timerlat_init_hist(struct timerlat_hist_params *params)
756 {
757 	struct osnoise_tool *tool;
758 	int nr_cpus;
759 
760 	nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
761 
762 	tool = osnoise_init_tool("timerlat_hist");
763 	if (!tool)
764 		return NULL;
765 
766 	tool->data = timerlat_alloc_histogram(nr_cpus, params->entries, params->bucket_size);
767 	if (!tool->data)
768 		goto out_err;
769 
770 	tool->params = params;
771 
772 	tep_register_event_handler(tool->trace.tep, -1, "ftrace", "timerlat",
773 				   timerlat_hist_handler, tool);
774 
775 	return tool;
776 
777 out_err:
778 	osnoise_destroy_tool(tool);
779 	return NULL;
780 }
781 
782 static int stop_tracing;
783 static void stop_hist(int sig)
784 {
785 	stop_tracing = 1;
786 }
787 
788 /*
789  * timerlat_hist_set_signals - handles the signal to stop the tool
790  */
791 static void
792 timerlat_hist_set_signals(struct timerlat_hist_params *params)
793 {
794 	signal(SIGINT, stop_hist);
795 	if (params->duration) {
796 		signal(SIGALRM, stop_hist);
797 		alarm(params->duration);
798 	}
799 }
800 
801 int timerlat_hist_main(int argc, char *argv[])
802 {
803 	struct timerlat_hist_params *params;
804 	struct osnoise_tool *record = NULL;
805 	struct osnoise_tool *tool = NULL;
806 	struct trace_instance *trace;
807 	int dma_latency_fd = -1;
808 	int return_value = 1;
809 	int retval;
810 
811 	params = timerlat_hist_parse_args(argc, argv);
812 	if (!params)
813 		exit(1);
814 
815 	tool = timerlat_init_hist(params);
816 	if (!tool) {
817 		err_msg("Could not init osnoise hist\n");
818 		goto out_exit;
819 	}
820 
821 	retval = timerlat_hist_apply_config(tool, params);
822 	if (retval) {
823 		err_msg("Could not apply config\n");
824 		goto out_free;
825 	}
826 
827 	trace = &tool->trace;
828 
829 	retval = enable_timerlat(trace);
830 	if (retval) {
831 		err_msg("Failed to enable timerlat tracer\n");
832 		goto out_free;
833 	}
834 
835 	if (params->set_sched) {
836 		retval = set_comm_sched_attr("timerlat/", &params->sched_param);
837 		if (retval) {
838 			err_msg("Failed to set sched parameters\n");
839 			goto out_free;
840 		}
841 	}
842 
843 	if (params->dma_latency >= 0) {
844 		dma_latency_fd = set_cpu_dma_latency(params->dma_latency);
845 		if (dma_latency_fd < 0) {
846 			err_msg("Could not set /dev/cpu_dma_latency.\n");
847 			goto out_free;
848 		}
849 	}
850 
851 	trace_instance_start(trace);
852 
853 	if (params->trace_output) {
854 		record = osnoise_init_trace_tool("timerlat");
855 		if (!record) {
856 			err_msg("Failed to enable the trace instance\n");
857 			goto out_free;
858 		}
859 
860 		if (params->events) {
861 			retval = trace_events_enable(&record->trace, params->events);
862 			if (retval)
863 				goto out_hist;
864 		}
865 
866 		trace_instance_start(&record->trace);
867 	}
868 
869 	tool->start_time = time(NULL);
870 	timerlat_hist_set_signals(params);
871 
872 	while (!stop_tracing) {
873 		sleep(params->sleep_time);
874 
875 		retval = tracefs_iterate_raw_events(trace->tep,
876 						    trace->inst,
877 						    NULL,
878 						    0,
879 						    collect_registered_events,
880 						    trace);
881 		if (retval < 0) {
882 			err_msg("Error iterating on events\n");
883 			goto out_hist;
884 		}
885 
886 		if (trace_is_off(&tool->trace, &record->trace))
887 			break;
888 	}
889 
890 	timerlat_print_stats(params, tool);
891 
892 	return_value = 0;
893 
894 	if (trace_is_off(&tool->trace, &record->trace)) {
895 		printf("rtla timerlat hit stop tracing\n");
896 		if (params->trace_output) {
897 			printf("  Saving trace to %s\n", params->trace_output);
898 			save_trace_to_file(record->trace.inst, params->trace_output);
899 		}
900 	}
901 
902 out_hist:
903 	if (dma_latency_fd >= 0)
904 		close(dma_latency_fd);
905 	trace_events_destroy(&record->trace, params->events);
906 	params->events = NULL;
907 out_free:
908 	timerlat_free_histogram(tool->data);
909 	osnoise_destroy_tool(record);
910 	osnoise_destroy_tool(tool);
911 	free(params);
912 out_exit:
913 	exit(return_value);
914 }
915