1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2017, 2018, 2019, 2021 BMW Car IT GmbH
4  * Author: Viktor Rosendahl (viktor.rosendahl@bmw.de)
5  */
6 
7 #define _GNU_SOURCE
8 #define _POSIX_C_SOURCE 200809L
9 
10 #include <ctype.h>
11 #include <stdbool.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 
16 #include <err.h>
17 #include <errno.h>
18 #include <fcntl.h>
19 #include <getopt.h>
20 #include <sched.h>
21 #include <linux/unistd.h>
22 #include <signal.h>
23 #include <sys/inotify.h>
24 #include <unistd.h>
25 #include <pthread.h>
26 #include <tracefs.h>
27 
28 static const char *prg_name;
29 static const char *prg_unknown = "unknown program name";
30 
31 static int fd_stdout;
32 
33 static int sched_policy;
34 static bool sched_policy_set;
35 
36 static int sched_pri;
37 static bool sched_pri_set;
38 
39 static bool trace_enable = true;
40 static bool setup_ftrace = true;
41 static bool use_random_sleep;
42 
43 #define TRACE_OPTS				\
44 	C(FUNC_TR, "function-trace"),		\
45 	C(DISP_GR, "display-graph"),		\
46 	C(NR,       NULL)
47 
48 #undef C
49 #define C(a, b) OPTIDX_##a
50 
51 enum traceopt {
52 	TRACE_OPTS
53 };
54 
55 #undef C
56 #define C(a, b)  b
57 
58 static const char *const optstr[] = {
59 	TRACE_OPTS
60 };
61 
62 enum errhandling {
63 	ERR_EXIT = 0,
64 	ERR_WARN,
65 	ERR_CLEANUP,
66 };
67 
68 static bool use_options[OPTIDX_NR];
69 
70 static char inotify_buffer[655360];
71 
72 #define likely(x)      __builtin_expect(!!(x), 1)
73 #define unlikely(x)    __builtin_expect(!!(x), 0)
74 #define bool2str(x)    (x ? "true":"false")
75 
76 #define DEFAULT_NR_PRINTER_THREADS (3)
77 static unsigned int nr_threads = DEFAULT_NR_PRINTER_THREADS;
78 
79 #define DEFAULT_TABLE_SIZE (2)
80 static unsigned int table_startsize = DEFAULT_TABLE_SIZE;
81 
82 static int verbosity;
83 
84 #define verbose_sizechange() (verbosity >= 1)
85 #define verbose_lostevent()  (verbosity >= 2)
86 #define verbose_ftrace()     (verbosity >= 1)
87 
88 #define was_changed(ORIG, CUR) (strcmp(ORIG, CUR) != 0)
89 #define needs_change(CUR, WANTED) (strcmp(CUR, WANTED) != 0)
90 
91 static const char *debug_tracefile;
92 static const char *debug_tracefile_dflt;
93 static const char *debug_maxlat;
94 static const char *debug_maxlat_dflt;
95 static const char * const DEBUG_NOFILE = "[file not found]";
96 
97 static const char * const TR_MAXLAT  = "tracing_max_latency";
98 static const char * const TR_THRESH  = "tracing_thresh";
99 static const char * const TR_CURRENT = "current_tracer";
100 static const char * const TR_OPTIONS = "trace_options";
101 
102 static const char * const NOP_TRACER = "nop";
103 
104 static const char * const OPT_NO_PREFIX = "no";
105 
106 #define DFLT_THRESHOLD_US "0"
107 static const char *threshold = DFLT_THRESHOLD_US;
108 
109 #define DEV_URANDOM     "/dev/urandom"
110 #define RT_DEFAULT_PRI (99)
111 #define DEFAULT_PRI    (0)
112 
113 #define USEC_PER_MSEC (1000L)
114 #define NSEC_PER_USEC (1000L)
115 #define NSEC_PER_MSEC (USEC_PER_MSEC * NSEC_PER_USEC)
116 
117 #define MSEC_PER_SEC (1000L)
118 #define USEC_PER_SEC (USEC_PER_MSEC * MSEC_PER_SEC)
119 #define NSEC_PER_SEC (NSEC_PER_MSEC * MSEC_PER_SEC)
120 
121 #define SLEEP_TIME_MS_DEFAULT (1000L)
122 #define TRY_PRINTMUTEX_MS (1000)
123 
124 static long sleep_time = (USEC_PER_MSEC * SLEEP_TIME_MS_DEFAULT);
125 
126 static const char * const queue_full_warning =
127 "Could not queue trace for printing. It is likely that events happen faster\n"
128 "than what they can be printed. Probably partly because of random sleeping\n";
129 
130 static const char * const no_tracer_msg =
131 "Could not find any tracers! Running this program as root may help!\n";
132 
133 static const char * const no_latency_tr_msg =
134 "No latency tracers are supported by your kernel!\n";
135 
136 struct policy {
137 	const char *name;
138 	int policy;
139 	int default_pri;
140 };
141 
142 static const struct policy policies[] = {
143 	{ "other", SCHED_OTHER, DEFAULT_PRI    },
144 	{ "batch", SCHED_BATCH, DEFAULT_PRI    },
145 	{ "idle",  SCHED_IDLE,  DEFAULT_PRI    },
146 	{ "rr",    SCHED_RR,    RT_DEFAULT_PRI },
147 	{ "fifo",  SCHED_FIFO,  RT_DEFAULT_PRI },
148 	{ NULL,    0,           DEFAULT_PRI    }
149 };
150 
151 /*
152  * The default tracer will be the first on this list that is supported by the
153  * currently running Linux kernel.
154  */
155 static const char * const relevant_tracers[] = {
156 	"preemptirqsoff",
157 	"preemptoff",
158 	"irqsoff",
159 	"wakeup",
160 	"wakeup_rt",
161 	"wakeup_dl",
162 	NULL
163 };
164 
165 /* This is the list of tracers for which random sleep makes sense */
166 static const char * const random_tracers[] = {
167 	"preemptirqsoff",
168 	"preemptoff",
169 	"irqsoff",
170 	NULL
171 };
172 
173 static const char *current_tracer;
174 static bool force_tracer;
175 
176 struct ftrace_state {
177 	char *tracer;
178 	char *thresh;
179 	bool opt[OPTIDX_NR];
180 	bool opt_valid[OPTIDX_NR];
181 	pthread_mutex_t mutex;
182 };
183 
184 struct entry {
185 	int ticket;
186 	int ticket_completed_ref;
187 };
188 
189 struct print_state {
190 	int ticket_counter;
191 	int ticket_completed;
192 	pthread_mutex_t mutex;
193 	pthread_cond_t cond;
194 	int cnt;
195 	pthread_mutex_t cnt_mutex;
196 };
197 
198 struct short_msg {
199 	char buf[160];
200 	int len;
201 };
202 
203 static struct print_state printstate;
204 static struct ftrace_state save_state;
205 volatile sig_atomic_t signal_flag;
206 
207 #define PROB_TABLE_MAX_SIZE (1000)
208 
209 int probabilities[PROB_TABLE_MAX_SIZE];
210 
211 struct sleep_table {
212 	int *table;
213 	int size;
214 	pthread_mutex_t mutex;
215 };
216 
217 static struct sleep_table sleeptable;
218 
219 #define QUEUE_SIZE (10)
220 
221 struct queue {
222 	struct entry entries[QUEUE_SIZE];
223 	int next_prod_idx;
224 	int next_cons_idx;
225 	pthread_mutex_t mutex;
226 	pthread_cond_t cond;
227 };
228 
229 #define MAX_THREADS (40)
230 
231 struct queue printqueue;
232 pthread_t printthread[MAX_THREADS];
233 pthread_mutex_t print_mtx;
234 #define PRINT_BUFFER_SIZE (16 * 1024 * 1024)
235 
236 static void cleanup_exit(int status);
237 static int set_trace_opt(const char *opt, bool value);
238 
239 static __always_inline void *malloc_or_die(size_t size)
240 {
241 	void *ptr = malloc(size);
242 
243 	if (unlikely(ptr == NULL)) {
244 		warn("malloc() failed");
245 		cleanup_exit(EXIT_FAILURE);
246 	}
247 	return ptr;
248 }
249 
250 static __always_inline void *malloc_or_die_nocleanup(size_t size)
251 {
252 	void *ptr = malloc(size);
253 
254 	if (unlikely(ptr == NULL))
255 		err(0, "malloc() failed");
256 	return ptr;
257 }
258 
259 static __always_inline void write_or_die(int fd, const char *buf, size_t count)
260 {
261 	ssize_t r;
262 
263 	do {
264 		r = write(fd, buf, count);
265 		if (unlikely(r < 0)) {
266 			if (errno == EINTR)
267 				continue;
268 			warn("write() failed");
269 			cleanup_exit(EXIT_FAILURE);
270 		}
271 		count -= r;
272 		buf += r;
273 	} while (count > 0);
274 }
275 
276 static __always_inline void clock_gettime_or_die(clockid_t clk_id,
277 						 struct timespec *tp)
278 {
279 	int r = clock_gettime(clk_id, tp);
280 
281 	if (unlikely(r != 0))
282 		err(EXIT_FAILURE, "clock_gettime() failed");
283 }
284 
285 static __always_inline void sigemptyset_or_die(sigset_t *s)
286 {
287 	if (unlikely(sigemptyset(s) != 0)) {
288 		warn("sigemptyset() failed");
289 		cleanup_exit(EXIT_FAILURE);
290 	}
291 }
292 
293 static __always_inline void sigaddset_or_die(sigset_t *s, int signum)
294 {
295 	if (unlikely(sigaddset(s, signum) != 0)) {
296 		warn("sigemptyset() failed");
297 		cleanup_exit(EXIT_FAILURE);
298 	}
299 }
300 
301 static __always_inline void sigaction_or_die(int signum,
302 					     const struct sigaction *act,
303 					     struct sigaction *oldact)
304 {
305 	if (unlikely(sigaction(signum, act, oldact) != 0)) {
306 		warn("sigaction() failed");
307 		cleanup_exit(EXIT_FAILURE);
308 	}
309 }
310 
311 static void open_stdout(void)
312 {
313 	if (setvbuf(stdout, NULL, _IONBF, 0) != 0)
314 		err(EXIT_FAILURE, "setvbuf() failed");
315 	fd_stdout = fileno(stdout);
316 	if (fd_stdout < 0)
317 		err(EXIT_FAILURE, "fileno() failed");
318 }
319 
320 /*
321  * It's not worth it to call cleanup_exit() from mutex functions because
322  * cleanup_exit() uses mutexes.
323  */
324 static __always_inline void mutex_lock(pthread_mutex_t *mtx)
325 {
326 	errno = pthread_mutex_lock(mtx);
327 	if (unlikely(errno))
328 		err(EXIT_FAILURE, "pthread_mutex_lock() failed");
329 }
330 
331 
332 static __always_inline void mutex_unlock(pthread_mutex_t *mtx)
333 {
334 	errno = pthread_mutex_unlock(mtx);
335 	if (unlikely(errno))
336 		err(EXIT_FAILURE, "pthread_mutex_unlock() failed");
337 }
338 
339 static __always_inline void cond_signal(pthread_cond_t *cond)
340 {
341 	errno = pthread_cond_signal(cond);
342 	if (unlikely(errno))
343 		err(EXIT_FAILURE, "pthread_cond_signal() failed");
344 }
345 
346 static __always_inline void cond_wait(pthread_cond_t *restrict cond,
347 				      pthread_mutex_t *restrict mutex)
348 {
349 	errno = pthread_cond_wait(cond, mutex);
350 	if (unlikely(errno))
351 		err(EXIT_FAILURE, "pthread_cond_wait() failed");
352 }
353 
354 static __always_inline void cond_broadcast(pthread_cond_t *cond)
355 {
356 	errno = pthread_cond_broadcast(cond);
357 	if (unlikely(errno))
358 		err(EXIT_FAILURE, "pthread_cond_broadcast() failed");
359 }
360 
361 static __always_inline void
362 mutex_init(pthread_mutex_t *mutex,
363 	   const pthread_mutexattr_t *attr)
364 {
365 	errno = pthread_mutex_init(mutex, attr);
366 	if (errno)
367 		err(EXIT_FAILURE, "pthread_mutex_init() failed");
368 }
369 
370 static __always_inline void mutexattr_init(pthread_mutexattr_t *attr)
371 {
372 	errno = pthread_mutexattr_init(attr);
373 	if (errno)
374 		err(EXIT_FAILURE, "pthread_mutexattr_init() failed");
375 }
376 
377 static __always_inline void mutexattr_destroy(pthread_mutexattr_t *attr)
378 {
379 	errno = pthread_mutexattr_destroy(attr);
380 	if (errno)
381 		err(EXIT_FAILURE, "pthread_mutexattr_destroy() failed");
382 }
383 
384 static __always_inline void mutexattr_settype(pthread_mutexattr_t *attr,
385 					      int type)
386 {
387 	errno = pthread_mutexattr_settype(attr, type);
388 	if (errno)
389 		err(EXIT_FAILURE, "pthread_mutexattr_settype() failed");
390 }
391 
392 static __always_inline void condattr_init(pthread_condattr_t *attr)
393 {
394 	errno = pthread_condattr_init(attr);
395 	if (errno)
396 		err(EXIT_FAILURE, "pthread_condattr_init() failed");
397 }
398 
399 static __always_inline void condattr_destroy(pthread_condattr_t *attr)
400 {
401 	errno = pthread_condattr_destroy(attr);
402 	if (errno)
403 		err(EXIT_FAILURE, "pthread_condattr_destroy() failed");
404 }
405 
406 static __always_inline void condattr_setclock(pthread_condattr_t *attr,
407 					      clockid_t clock_id)
408 {
409 	errno = pthread_condattr_setclock(attr, clock_id);
410 	if (unlikely(errno))
411 		err(EXIT_FAILURE, "pthread_condattr_setclock() failed");
412 }
413 
414 static __always_inline void cond_init(pthread_cond_t *cond,
415 				      const pthread_condattr_t *attr)
416 {
417 	errno = pthread_cond_init(cond, attr);
418 	if (errno)
419 		err(EXIT_FAILURE, "pthread_cond_init() failed");
420 }
421 
422 static __always_inline int
423 cond_timedwait(pthread_cond_t *restrict cond,
424 	       pthread_mutex_t *restrict mutex,
425 	       const struct timespec *restrict abstime)
426 {
427 	errno = pthread_cond_timedwait(cond, mutex, abstime);
428 	if (errno && errno != ETIMEDOUT)
429 		err(EXIT_FAILURE, "pthread_cond_timedwait() failed");
430 	return errno;
431 }
432 
433 static void init_printstate(void)
434 {
435 	pthread_condattr_t cattr;
436 
437 	printstate.ticket_counter = 0;
438 	printstate.ticket_completed = 0;
439 	printstate.cnt = 0;
440 
441 	mutex_init(&printstate.mutex, NULL);
442 
443 	condattr_init(&cattr);
444 	condattr_setclock(&cattr, CLOCK_MONOTONIC);
445 	cond_init(&printstate.cond, &cattr);
446 	condattr_destroy(&cattr);
447 }
448 
449 static void init_print_mtx(void)
450 {
451 	pthread_mutexattr_t mattr;
452 
453 	mutexattr_init(&mattr);
454 	mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
455 	mutex_init(&print_mtx, &mattr);
456 	mutexattr_destroy(&mattr);
457 
458 }
459 
460 static void signal_blocking(int how)
461 {
462 	sigset_t s;
463 
464 	sigemptyset_or_die(&s);
465 	sigaddset_or_die(&s, SIGHUP);
466 	sigaddset_or_die(&s, SIGTERM);
467 	sigaddset_or_die(&s, SIGINT);
468 
469 	errno = pthread_sigmask(how, &s, NULL);
470 	if (unlikely(errno)) {
471 		warn("pthread_sigmask() failed");
472 		cleanup_exit(EXIT_FAILURE);
473 	}
474 }
475 
476 static void signal_handler(int num)
477 {
478 	signal_flag = num;
479 }
480 
481 static void setup_sig_handler(void)
482 {
483 	struct sigaction sa;
484 
485 	memset(&sa, 0, sizeof(sa));
486 	sa.sa_handler = signal_handler;
487 
488 	sigaction_or_die(SIGHUP, &sa, NULL);
489 	sigaction_or_die(SIGTERM, &sa, NULL);
490 	sigaction_or_die(SIGINT, &sa, NULL);
491 }
492 
493 static void process_signal(int signal)
494 {
495 	char *name;
496 
497 	name = strsignal(signal);
498 	if (name == NULL)
499 		printf("Received signal %d\n", signal);
500 	else
501 		printf("Received signal %d (%s)\n", signal, name);
502 	cleanup_exit(EXIT_SUCCESS);
503 }
504 
505 static __always_inline void check_signals(void)
506 {
507 	int signal = signal_flag;
508 
509 	if (unlikely(signal))
510 		process_signal(signal);
511 }
512 
513 static __always_inline void get_time_in_future(struct timespec *future,
514 					       long time_us)
515 {
516 	long nsec;
517 
518 	clock_gettime_or_die(CLOCK_MONOTONIC, future);
519 	future->tv_sec += time_us / USEC_PER_SEC;
520 	nsec = future->tv_nsec + (time_us * NSEC_PER_USEC) % NSEC_PER_SEC;
521 	if (nsec >= NSEC_PER_SEC) {
522 		future->tv_nsec = nsec % NSEC_PER_SEC;
523 		future->tv_sec += 1;
524 	}
525 }
526 
527 static __always_inline bool time_has_passed(const struct timespec *time)
528 {
529 	struct timespec now;
530 
531 	clock_gettime_or_die(CLOCK_MONOTONIC, &now);
532 	if (now.tv_sec > time->tv_sec)
533 		return true;
534 	if (now.tv_sec < time->tv_sec)
535 		return false;
536 	return (now.tv_nsec >= time->tv_nsec);
537 }
538 
539 static bool mutex_trylock_limit(pthread_mutex_t *mutex, int time_ms)
540 {
541 	long time_us = time_ms * USEC_PER_MSEC;
542 	struct timespec limit;
543 
544 	get_time_in_future(&limit, time_us);
545 	do {
546 		errno =  pthread_mutex_trylock(mutex);
547 		if (errno && errno != EBUSY)
548 			err(EXIT_FAILURE, "pthread_mutex_trylock() failed");
549 	} while (errno && !time_has_passed(&limit));
550 	return errno == 0;
551 }
552 
553 static void restore_trace_opts(const struct ftrace_state *state,
554 				const bool *cur)
555 {
556 	int i;
557 	int r;
558 
559 	for (i = 0; i < OPTIDX_NR; i++)
560 		if (state->opt_valid[i] && state->opt[i] != cur[i]) {
561 			r = set_trace_opt(optstr[i], state->opt[i]);
562 			if (r < 0)
563 				warnx("Failed to restore the %s option to %s",
564 				      optstr[i], bool2str(state->opt[i]));
565 			else if (verbose_ftrace())
566 				printf("Restored the %s option in %s to %s\n",
567 				       optstr[i], TR_OPTIONS,
568 				       bool2str(state->opt[i]));
569 		}
570 }
571 
572 static char *read_file(const char *file, enum errhandling h)
573 {
574 	int psize;
575 	char *r;
576 	static const char *emsg = "Failed to read the %s file";
577 
578 	r = tracefs_instance_file_read(NULL, file, &psize);
579 	if (!r) {
580 		if (h) {
581 			warn(emsg, file);
582 			if (h == ERR_CLEANUP)
583 				cleanup_exit(EXIT_FAILURE);
584 		} else
585 			errx(EXIT_FAILURE, emsg, file);
586 	}
587 
588 	if (r && r[psize - 1] == '\n')
589 		r[psize - 1] = '\0';
590 	return r;
591 }
592 
593 static void restore_file(const char *file, char **saved, const char *cur)
594 {
595 	if (*saved && was_changed(*saved, cur)) {
596 		if (tracefs_instance_file_write(NULL, file, *saved) < 0)
597 			warnx("Failed to restore %s to %s!", file, *saved);
598 		else if (verbose_ftrace())
599 			printf("Restored %s to %s\n", file, *saved);
600 		free(*saved);
601 		*saved = NULL;
602 	}
603 }
604 
605 static void restore_ftrace(void)
606 {
607 	mutex_lock(&save_state.mutex);
608 
609 	restore_file(TR_CURRENT, &save_state.tracer, current_tracer);
610 	restore_file(TR_THRESH, &save_state.thresh, threshold);
611 	restore_trace_opts(&save_state, use_options);
612 
613 	mutex_unlock(&save_state.mutex);
614 }
615 
616 static void cleanup_exit(int status)
617 {
618 	char *maxlat;
619 
620 	if (!setup_ftrace)
621 		exit(status);
622 
623 	/*
624 	 * We try the print_mtx for 1 sec in order to avoid garbled
625 	 * output if possible, but if it cannot be obtained we proceed anyway.
626 	 */
627 	mutex_trylock_limit(&print_mtx, TRY_PRINTMUTEX_MS);
628 
629 	maxlat = read_file(TR_MAXLAT, ERR_WARN);
630 	if (maxlat) {
631 		printf("The maximum detected latency was: %sus\n", maxlat);
632 		free(maxlat);
633 	}
634 
635 	restore_ftrace();
636 	/*
637 	 * We do not need to unlock the print_mtx here because we will exit at
638 	 * the end of this function. Unlocking print_mtx causes problems if a
639 	 * print thread happens to be waiting for the mutex because we have
640 	 * just changed the ftrace settings to the original and thus the
641 	 * print thread would output incorrect data from ftrace.
642 	 */
643 	exit(status);
644 }
645 
646 static void init_save_state(void)
647 {
648 	pthread_mutexattr_t mattr;
649 
650 	mutexattr_init(&mattr);
651 	mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
652 	mutex_init(&save_state.mutex, &mattr);
653 	mutexattr_destroy(&mattr);
654 
655 	save_state.tracer = NULL;
656 	save_state.thresh = NULL;
657 	save_state.opt_valid[OPTIDX_FUNC_TR] = false;
658 	save_state.opt_valid[OPTIDX_DISP_GR] = false;
659 }
660 
661 static int printstate_next_ticket(struct entry *req)
662 {
663 	int r;
664 
665 	r = ++(printstate.ticket_counter);
666 	req->ticket = r;
667 	req->ticket_completed_ref = printstate.ticket_completed;
668 	cond_broadcast(&printstate.cond);
669 	return r;
670 }
671 
672 static __always_inline
673 void printstate_mark_req_completed(const struct entry *req)
674 {
675 	if (req->ticket > printstate.ticket_completed)
676 		printstate.ticket_completed = req->ticket;
677 }
678 
679 static __always_inline
680 bool printstate_has_new_req_arrived(const struct entry *req)
681 {
682 	return (printstate.ticket_counter != req->ticket);
683 }
684 
685 static __always_inline int printstate_cnt_inc(void)
686 {
687 	int value;
688 
689 	mutex_lock(&printstate.cnt_mutex);
690 	value = ++printstate.cnt;
691 	mutex_unlock(&printstate.cnt_mutex);
692 	return value;
693 }
694 
695 static __always_inline int printstate_cnt_dec(void)
696 {
697 	int value;
698 
699 	mutex_lock(&printstate.cnt_mutex);
700 	value = --printstate.cnt;
701 	mutex_unlock(&printstate.cnt_mutex);
702 	return value;
703 }
704 
705 static __always_inline int printstate_cnt_read(void)
706 {
707 	int value;
708 
709 	mutex_lock(&printstate.cnt_mutex);
710 	value = printstate.cnt;
711 	mutex_unlock(&printstate.cnt_mutex);
712 	return value;
713 }
714 
715 static __always_inline
716 bool prev_req_won_race(const struct entry *req)
717 {
718 	return (printstate.ticket_completed != req->ticket_completed_ref);
719 }
720 
721 static void sleeptable_resize(int size, bool printout, struct short_msg *msg)
722 {
723 	int bytes;
724 
725 	if (printout) {
726 		msg->len = 0;
727 		if (unlikely(size > PROB_TABLE_MAX_SIZE))
728 			bytes = snprintf(msg->buf, sizeof(msg->buf),
729 "Cannot increase probability table to %d (maximum size reached)\n", size);
730 		else
731 			bytes = snprintf(msg->buf, sizeof(msg->buf),
732 "Increasing probability table to %d\n", size);
733 		if (bytes < 0)
734 			warn("snprintf() failed");
735 		else
736 			msg->len = bytes;
737 	}
738 
739 	if (unlikely(size < 0)) {
740 		/* Should never happen */
741 		warnx("Bad program state at %s:%d", __FILE__, __LINE__);
742 		cleanup_exit(EXIT_FAILURE);
743 		return;
744 	}
745 	sleeptable.size = size;
746 	sleeptable.table = &probabilities[PROB_TABLE_MAX_SIZE - size];
747 }
748 
749 static void init_probabilities(void)
750 {
751 	int i;
752 	int j = 1000;
753 
754 	for (i = 0; i < PROB_TABLE_MAX_SIZE; i++) {
755 		probabilities[i] = 1000 / j;
756 		j--;
757 	}
758 	mutex_init(&sleeptable.mutex, NULL);
759 }
760 
761 static int table_get_probability(const struct entry *req,
762 				 struct short_msg *msg)
763 {
764 	int diff = req->ticket - req->ticket_completed_ref;
765 	int rval = 0;
766 
767 	msg->len = 0;
768 	diff--;
769 	/* Should never happen...*/
770 	if (unlikely(diff < 0)) {
771 		warnx("Programmer assumption error at %s:%d\n", __FILE__,
772 		      __LINE__);
773 		cleanup_exit(EXIT_FAILURE);
774 	}
775 	mutex_lock(&sleeptable.mutex);
776 	if (diff >= (sleeptable.size - 1)) {
777 		rval = sleeptable.table[sleeptable.size - 1];
778 		sleeptable_resize(sleeptable.size + 1, verbose_sizechange(),
779 				  msg);
780 	} else {
781 		rval = sleeptable.table[diff];
782 	}
783 	mutex_unlock(&sleeptable.mutex);
784 	return rval;
785 }
786 
787 static void init_queue(struct queue *q)
788 {
789 	q->next_prod_idx = 0;
790 	q->next_cons_idx = 0;
791 	mutex_init(&q->mutex, NULL);
792 	errno = pthread_cond_init(&q->cond, NULL);
793 	if (errno)
794 		err(EXIT_FAILURE, "pthread_cond_init() failed");
795 }
796 
797 static __always_inline int queue_len(const struct queue *q)
798 {
799 	if (q->next_prod_idx >= q->next_cons_idx)
800 		return q->next_prod_idx - q->next_cons_idx;
801 	else
802 		return QUEUE_SIZE - q->next_cons_idx + q->next_prod_idx;
803 }
804 
805 static __always_inline int queue_nr_free(const struct queue *q)
806 {
807 	int nr_free = QUEUE_SIZE - queue_len(q);
808 
809 	/*
810 	 * If there is only one slot left we will anyway lie and claim that the
811 	 * queue is full because adding an element will make it appear empty
812 	 */
813 	if (nr_free == 1)
814 		nr_free = 0;
815 	return nr_free;
816 }
817 
818 static __always_inline void queue_idx_inc(int *idx)
819 {
820 	*idx = (*idx + 1) % QUEUE_SIZE;
821 }
822 
823 static __always_inline void queue_push_to_back(struct queue *q,
824 					      const struct entry *e)
825 {
826 	q->entries[q->next_prod_idx] = *e;
827 	queue_idx_inc(&q->next_prod_idx);
828 }
829 
830 static __always_inline struct entry queue_pop_from_front(struct queue *q)
831 {
832 	struct entry e = q->entries[q->next_cons_idx];
833 
834 	queue_idx_inc(&q->next_cons_idx);
835 	return e;
836 }
837 
838 static __always_inline void queue_cond_signal(struct queue *q)
839 {
840 	cond_signal(&q->cond);
841 }
842 
843 static __always_inline void queue_cond_wait(struct queue *q)
844 {
845 	cond_wait(&q->cond, &q->mutex);
846 }
847 
848 static __always_inline int queue_try_to_add_entry(struct queue *q,
849 						  const struct entry *e)
850 {
851 	int r = 0;
852 
853 	mutex_lock(&q->mutex);
854 	if (queue_nr_free(q) > 0) {
855 		queue_push_to_back(q, e);
856 		cond_signal(&q->cond);
857 	} else
858 		r = -1;
859 	mutex_unlock(&q->mutex);
860 	return r;
861 }
862 
863 static struct entry queue_wait_for_entry(struct queue *q)
864 {
865 	struct entry e;
866 
867 	mutex_lock(&q->mutex);
868 	while (true) {
869 		if (queue_len(&printqueue) > 0) {
870 			e = queue_pop_from_front(q);
871 			break;
872 		}
873 		queue_cond_wait(q);
874 	}
875 	mutex_unlock(&q->mutex);
876 
877 	return e;
878 }
879 
880 static const struct policy *policy_from_name(const char *name)
881 {
882 	const struct policy *p = &policies[0];
883 
884 	while (p->name != NULL) {
885 		if (!strcmp(name, p->name))
886 			return p;
887 		p++;
888 	}
889 	return NULL;
890 }
891 
892 static const char *policy_name(int policy)
893 {
894 	const struct policy *p = &policies[0];
895 	static const char *rval = "unknown";
896 
897 	while (p->name != NULL) {
898 		if (p->policy == policy)
899 			return p->name;
900 		p++;
901 	}
902 	return rval;
903 }
904 
905 static bool is_relevant_tracer(const char *name)
906 {
907 	unsigned int i;
908 
909 	for (i = 0; relevant_tracers[i]; i++)
910 		if (!strcmp(name, relevant_tracers[i]))
911 			return true;
912 	return false;
913 }
914 
915 static bool random_makes_sense(const char *name)
916 {
917 	unsigned int i;
918 
919 	for (i = 0; random_tracers[i]; i++)
920 		if (!strcmp(name, random_tracers[i]))
921 			return true;
922 	return false;
923 }
924 
925 static void show_available(void)
926 {
927 	char **tracers;
928 	int found = 0;
929 	int i;
930 
931 	tracers = tracefs_tracers(NULL);
932 	for (i = 0; tracers && tracers[i]; i++) {
933 		if (is_relevant_tracer(tracers[i]))
934 			found++;
935 	}
936 
937 	if (!tracers) {
938 		warnx("%s", no_tracer_msg);
939 		return;
940 	}
941 
942 	if (!found) {
943 		warnx("%s", no_latency_tr_msg);
944 		tracefs_list_free(tracers);
945 		return;
946 	}
947 
948 	printf("The following latency tracers are available on your system:\n");
949 	for (i = 0; tracers[i]; i++) {
950 		if (is_relevant_tracer(tracers[i]))
951 			printf("%s\n", tracers[i]);
952 	}
953 	tracefs_list_free(tracers);
954 }
955 
956 static bool tracer_valid(const char *name, bool *notracer)
957 {
958 	char **tracers;
959 	int i;
960 	bool rval = false;
961 
962 	*notracer = false;
963 	tracers = tracefs_tracers(NULL);
964 	if (!tracers) {
965 		*notracer = true;
966 		return false;
967 	}
968 	for (i = 0; tracers[i]; i++)
969 		if (!strcmp(tracers[i], name)) {
970 			rval = true;
971 			break;
972 		}
973 	tracefs_list_free(tracers);
974 	return rval;
975 }
976 
977 static const char *find_default_tracer(void)
978 {
979 	int i;
980 	bool notracer;
981 	bool valid;
982 
983 	for (i = 0; relevant_tracers[i]; i++) {
984 		valid = tracer_valid(relevant_tracers[i], &notracer);
985 		if (notracer)
986 			errx(EXIT_FAILURE, "%s", no_tracer_msg);
987 		if (valid)
988 			return relevant_tracers[i];
989 	}
990 	return NULL;
991 }
992 
993 static bool toss_coin(struct drand48_data *buffer, unsigned int prob)
994 {
995 	long r;
996 
997 	if (unlikely(lrand48_r(buffer, &r))) {
998 		warnx("lrand48_r() failed");
999 		cleanup_exit(EXIT_FAILURE);
1000 	}
1001 	r = r % 1000L;
1002 	if (r < prob)
1003 		return true;
1004 	else
1005 		return false;
1006 }
1007 
1008 
1009 static long go_to_sleep(const struct entry *req)
1010 {
1011 	struct timespec future;
1012 	long delay = sleep_time;
1013 
1014 	get_time_in_future(&future, delay);
1015 
1016 	mutex_lock(&printstate.mutex);
1017 	while (!printstate_has_new_req_arrived(req)) {
1018 		cond_timedwait(&printstate.cond, &printstate.mutex, &future);
1019 		if (time_has_passed(&future))
1020 			break;
1021 	}
1022 
1023 	if (printstate_has_new_req_arrived(req))
1024 		delay = -1;
1025 	mutex_unlock(&printstate.mutex);
1026 
1027 	return delay;
1028 }
1029 
1030 
1031 static void set_priority(void)
1032 {
1033 	int r;
1034 	pid_t pid;
1035 	struct sched_param param;
1036 
1037 	memset(&param, 0, sizeof(param));
1038 	param.sched_priority = sched_pri;
1039 
1040 	pid = getpid();
1041 	r = sched_setscheduler(pid, sched_policy, &param);
1042 
1043 	if (r != 0)
1044 		err(EXIT_FAILURE, "sched_setscheduler() failed");
1045 }
1046 
1047 pid_t latency_collector_gettid(void)
1048 {
1049 	return (pid_t) syscall(__NR_gettid);
1050 }
1051 
1052 static void print_priority(void)
1053 {
1054 	pid_t tid;
1055 	int policy;
1056 	int r;
1057 	struct sched_param param;
1058 
1059 	tid = latency_collector_gettid();
1060 	r = pthread_getschedparam(pthread_self(), &policy, &param);
1061 	if (r != 0) {
1062 		warn("pthread_getschedparam() failed");
1063 		cleanup_exit(EXIT_FAILURE);
1064 	}
1065 	mutex_lock(&print_mtx);
1066 	printf("Thread %d runs with scheduling policy %s and priority %d\n",
1067 	       tid, policy_name(policy), param.sched_priority);
1068 	mutex_unlock(&print_mtx);
1069 }
1070 
1071 static __always_inline
1072 void __print_skipmessage(const struct short_msg *resize_msg,
1073 			 const struct timespec *timestamp, char *buffer,
1074 			 size_t bufspace, const struct entry *req, bool excuse,
1075 			 const char *str)
1076 {
1077 	ssize_t bytes = 0;
1078 	char *p = &buffer[0];
1079 	long us, sec;
1080 	int r;
1081 
1082 	sec = timestamp->tv_sec;
1083 	us = timestamp->tv_nsec / 1000;
1084 
1085 	if (resize_msg != NULL && resize_msg->len > 0) {
1086 		strncpy(p, resize_msg->buf, resize_msg->len);
1087 		bytes += resize_msg->len;
1088 		p += resize_msg->len;
1089 		bufspace -= resize_msg->len;
1090 	}
1091 
1092 	if (excuse)
1093 		r = snprintf(p, bufspace,
1094 "%ld.%06ld Latency %d printout skipped due to %s\n",
1095 			     sec, us, req->ticket, str);
1096 	else
1097 		r = snprintf(p, bufspace, "%ld.%06ld Latency %d detected\n",
1098 			    sec, us, req->ticket);
1099 
1100 	if (r < 0)
1101 		warn("snprintf() failed");
1102 	else
1103 		bytes += r;
1104 
1105 	/* These prints could happen concurrently */
1106 	mutex_lock(&print_mtx);
1107 	write_or_die(fd_stdout, buffer, bytes);
1108 	mutex_unlock(&print_mtx);
1109 }
1110 
1111 static void print_skipmessage(const struct short_msg *resize_msg,
1112 			      const struct timespec *timestamp, char *buffer,
1113 			      size_t bufspace, const struct entry *req,
1114 			      bool excuse)
1115 {
1116 	__print_skipmessage(resize_msg, timestamp, buffer, bufspace, req,
1117 			    excuse, "random delay");
1118 }
1119 
1120 static void print_lostmessage(const struct timespec *timestamp, char *buffer,
1121 			      size_t bufspace, const struct entry *req,
1122 			      const char *reason)
1123 {
1124 	__print_skipmessage(NULL, timestamp, buffer, bufspace, req, true,
1125 			    reason);
1126 }
1127 
1128 static void print_tracefile(const struct short_msg *resize_msg,
1129 			    const struct timespec *timestamp, char *buffer,
1130 			    size_t bufspace, long slept,
1131 			    const struct entry *req)
1132 {
1133 	static const int reserve = 256;
1134 	char *p = &buffer[0];
1135 	ssize_t bytes = 0;
1136 	ssize_t bytes_tot = 0;
1137 	long us, sec;
1138 	long slept_ms;
1139 	int trace_fd;
1140 
1141 	/* Save some space for the final string and final null char */
1142 	bufspace = bufspace - reserve - 1;
1143 
1144 	if (resize_msg != NULL && resize_msg->len > 0) {
1145 		bytes = resize_msg->len;
1146 		strncpy(p, resize_msg->buf, bytes);
1147 		bytes_tot += bytes;
1148 		p += bytes;
1149 		bufspace -= bytes;
1150 	}
1151 
1152 	trace_fd = open(debug_tracefile, O_RDONLY);
1153 
1154 	if (trace_fd < 0) {
1155 		warn("open() failed on %s", debug_tracefile);
1156 		return;
1157 	}
1158 
1159 	sec = timestamp->tv_sec;
1160 	us = timestamp->tv_nsec / 1000;
1161 
1162 	if (slept != 0) {
1163 		slept_ms = slept / 1000;
1164 		bytes = snprintf(p, bufspace,
1165 "%ld.%06ld Latency %d randomly sleep for %ld ms before print\n",
1166 				 sec, us, req->ticket, slept_ms);
1167 	} else {
1168 		bytes = snprintf(p, bufspace,
1169 				 "%ld.%06ld Latency %d immediate print\n", sec,
1170 				 us, req->ticket);
1171 	}
1172 
1173 	if (bytes < 0) {
1174 		warn("snprintf() failed");
1175 		return;
1176 	}
1177 	p += bytes;
1178 	bufspace -= bytes;
1179 	bytes_tot += bytes;
1180 
1181 	bytes = snprintf(p, bufspace,
1182 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BEGIN <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
1183 		);
1184 
1185 	if (bytes < 0) {
1186 		warn("snprintf() failed");
1187 		return;
1188 	}
1189 
1190 	p += bytes;
1191 	bufspace -= bytes;
1192 	bytes_tot += bytes;
1193 
1194 	do {
1195 		bytes = read(trace_fd, p, bufspace);
1196 		if (bytes < 0) {
1197 			if (errno == EINTR)
1198 				continue;
1199 			warn("read() failed on %s", debug_tracefile);
1200 			if (unlikely(close(trace_fd) != 0))
1201 				warn("close() failed on %s", debug_tracefile);
1202 			return;
1203 		}
1204 		if (bytes == 0)
1205 			break;
1206 		p += bytes;
1207 		bufspace -= bytes;
1208 		bytes_tot += bytes;
1209 	} while (true);
1210 
1211 	if (unlikely(close(trace_fd) != 0))
1212 		warn("close() failed on %s", debug_tracefile);
1213 
1214 	printstate_cnt_dec();
1215 	/* Add the reserve space back to the budget for the final string */
1216 	bufspace += reserve;
1217 
1218 	bytes = snprintf(p, bufspace,
1219 			 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> END <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n");
1220 
1221 	if (bytes < 0) {
1222 		warn("snprintf() failed");
1223 		return;
1224 	}
1225 
1226 	bytes_tot += bytes;
1227 
1228 	/* These prints could happen concurrently */
1229 	mutex_lock(&print_mtx);
1230 	write_or_die(fd_stdout, buffer, bytes_tot);
1231 	mutex_unlock(&print_mtx);
1232 }
1233 
1234 static char *get_no_opt(const char *opt)
1235 {
1236 	char *no_opt;
1237 	int s;
1238 
1239 	s = strlen(opt) + strlen(OPT_NO_PREFIX) + 1;
1240 	/* We may be called from cleanup_exit() via set_trace_opt() */
1241 	no_opt = malloc_or_die_nocleanup(s);
1242 	strcpy(no_opt, OPT_NO_PREFIX);
1243 	strcat(no_opt, opt);
1244 	return no_opt;
1245 }
1246 
1247 static char *find_next_optstr(const char *allopt, const char **next)
1248 {
1249 	const char *begin;
1250 	const char *end;
1251 	char *r;
1252 	int s = 0;
1253 
1254 	if (allopt == NULL)
1255 		return NULL;
1256 
1257 	for (begin = allopt; *begin != '\0'; begin++) {
1258 		if (isgraph(*begin))
1259 			break;
1260 	}
1261 
1262 	if (*begin == '\0')
1263 		return NULL;
1264 
1265 	for (end = begin; *end != '\0' && isgraph(*end); end++)
1266 		s++;
1267 
1268 	r = malloc_or_die_nocleanup(s + 1);
1269 	strncpy(r, begin, s);
1270 	r[s] = '\0';
1271 	*next = begin + s;
1272 	return r;
1273 }
1274 
1275 static bool get_trace_opt(const char *allopt, const char *opt, bool *found)
1276 {
1277 	*found = false;
1278 	char *no_opt;
1279 	char *str;
1280 	const char *next = allopt;
1281 	bool rval = false;
1282 
1283 	no_opt = get_no_opt(opt);
1284 
1285 	do {
1286 		str = find_next_optstr(next, &next);
1287 		if (str == NULL)
1288 			break;
1289 		if (!strcmp(str, opt)) {
1290 			*found = true;
1291 			rval = true;
1292 			free(str);
1293 			break;
1294 		}
1295 		if (!strcmp(str, no_opt)) {
1296 			*found = true;
1297 			rval = false;
1298 			free(str);
1299 			break;
1300 		}
1301 		free(str);
1302 	} while (true);
1303 	free(no_opt);
1304 
1305 	return rval;
1306 }
1307 
1308 static int set_trace_opt(const char *opt, bool value)
1309 {
1310 	char *str;
1311 	int r;
1312 
1313 	if (value)
1314 		str = strdup(opt);
1315 	else
1316 		str = get_no_opt(opt);
1317 
1318 	r = tracefs_instance_file_write(NULL, TR_OPTIONS, str);
1319 	free(str);
1320 	return r;
1321 }
1322 
1323 void save_trace_opts(struct ftrace_state *state)
1324 {
1325 	char *allopt;
1326 	int psize;
1327 	int i;
1328 
1329 	allopt = tracefs_instance_file_read(NULL, TR_OPTIONS, &psize);
1330 	if (!allopt)
1331 		errx(EXIT_FAILURE, "Failed to read the %s file\n", TR_OPTIONS);
1332 
1333 	for (i = 0; i < OPTIDX_NR; i++)
1334 		state->opt[i] = get_trace_opt(allopt, optstr[i],
1335 					      &state->opt_valid[i]);
1336 
1337 	free(allopt);
1338 }
1339 
1340 static void write_file(const char *file, const char *cur, const char *new,
1341 		       enum errhandling h)
1342 {
1343 	int r;
1344 	static const char *emsg = "Failed to write to the %s file!";
1345 
1346 	/* Do nothing if we now that the current and new value are equal */
1347 	if (cur && !needs_change(cur, new))
1348 		return;
1349 
1350 	r = tracefs_instance_file_write(NULL, file, new);
1351 	if (r < 0) {
1352 		if (h) {
1353 			warnx(emsg, file);
1354 			if (h == ERR_CLEANUP)
1355 				cleanup_exit(EXIT_FAILURE);
1356 		} else
1357 			errx(EXIT_FAILURE, emsg, file);
1358 	}
1359 	if (verbose_ftrace()) {
1360 		mutex_lock(&print_mtx);
1361 		printf("%s was set to %s\n", file, new);
1362 		mutex_unlock(&print_mtx);
1363 	}
1364 }
1365 
1366 static void reset_max_latency(void)
1367 {
1368 	write_file(TR_MAXLAT, NULL, "0", ERR_CLEANUP);
1369 }
1370 
1371 static void save_and_disable_tracer(void)
1372 {
1373 	char *orig_th;
1374 	char *tracer;
1375 	bool need_nop = false;
1376 
1377 	mutex_lock(&save_state.mutex);
1378 
1379 	save_trace_opts(&save_state);
1380 	tracer = read_file(TR_CURRENT, ERR_EXIT);
1381 	orig_th = read_file(TR_THRESH, ERR_EXIT);
1382 
1383 	if (needs_change(tracer, NOP_TRACER)) {
1384 		mutex_lock(&print_mtx);
1385 		if (force_tracer) {
1386 			printf(
1387 				"The %s tracer is already in use but proceeding anyway!\n",
1388 				tracer);
1389 		} else {
1390 			printf(
1391 				"The %s tracer is already in use, cowardly bailing out!\n"
1392 				"This could indicate that another program or instance is tracing.\n"
1393 				"Use the -F [--force] option to disregard the current tracer.\n", tracer);
1394 			exit(0);
1395 		}
1396 		mutex_unlock(&print_mtx);
1397 		need_nop = true;
1398 	}
1399 
1400 	save_state.tracer =  tracer;
1401 	save_state.thresh = orig_th;
1402 
1403 	if (need_nop)
1404 		write_file(TR_CURRENT, NULL, NOP_TRACER, ERR_EXIT);
1405 
1406 	mutex_unlock(&save_state.mutex);
1407 }
1408 
1409 void set_trace_opts(struct ftrace_state *state, bool *new)
1410 {
1411 	int i;
1412 	int r;
1413 
1414 	/*
1415 	 * We only set options if we earlier detected that the option exists in
1416 	 * the trace_options file and that the wanted setting is different from
1417 	 * the one we saw in save_and_disable_tracer()
1418 	 */
1419 	for (i = 0; i < OPTIDX_NR; i++)
1420 		if (state->opt_valid[i] &&
1421 		    state->opt[i] != new[i]) {
1422 			r = set_trace_opt(optstr[i], new[i]);
1423 			if (r < 0) {
1424 				warnx("Failed to set the %s option to %s",
1425 				      optstr[i], bool2str(new[i]));
1426 				cleanup_exit(EXIT_FAILURE);
1427 			}
1428 			if (verbose_ftrace()) {
1429 				mutex_lock(&print_mtx);
1430 				printf("%s in %s was set to %s\n", optstr[i],
1431 				       TR_OPTIONS, bool2str(new[i]));
1432 				mutex_unlock(&print_mtx);
1433 			}
1434 		}
1435 }
1436 
1437 static void enable_tracer(void)
1438 {
1439 	mutex_lock(&save_state.mutex);
1440 	set_trace_opts(&save_state, use_options);
1441 
1442 	write_file(TR_THRESH, save_state.thresh, threshold, ERR_CLEANUP);
1443 	write_file(TR_CURRENT, NOP_TRACER, current_tracer, ERR_CLEANUP);
1444 
1445 	mutex_unlock(&save_state.mutex);
1446 }
1447 
1448 static void tracing_loop(void)
1449 {
1450 	int ifd = inotify_init();
1451 	int wd;
1452 	const ssize_t bufsize = sizeof(inotify_buffer);
1453 	const ssize_t istructsize = sizeof(struct inotify_event);
1454 	char *buf = &inotify_buffer[0];
1455 	ssize_t nr_read;
1456 	char *p;
1457 	int modified;
1458 	struct inotify_event *event;
1459 	struct entry req;
1460 	char *buffer;
1461 	const size_t bufspace = PRINT_BUFFER_SIZE;
1462 	struct timespec timestamp;
1463 
1464 	print_priority();
1465 
1466 	buffer = malloc_or_die(bufspace);
1467 
1468 	if (ifd < 0)
1469 		err(EXIT_FAILURE, "inotify_init() failed!");
1470 
1471 
1472 	if (setup_ftrace) {
1473 		/*
1474 		 * We must disable the tracer before resetting the max_latency
1475 		 */
1476 		save_and_disable_tracer();
1477 		/*
1478 		 * We must reset the max_latency before the inotify_add_watch()
1479 		 * call.
1480 		 */
1481 		reset_max_latency();
1482 	}
1483 
1484 	wd = inotify_add_watch(ifd, debug_maxlat, IN_MODIFY);
1485 	if (wd < 0)
1486 		err(EXIT_FAILURE, "inotify_add_watch() failed!");
1487 
1488 	if (setup_ftrace)
1489 		enable_tracer();
1490 
1491 	signal_blocking(SIG_UNBLOCK);
1492 
1493 	while (true) {
1494 		modified = 0;
1495 		check_signals();
1496 		nr_read = read(ifd, buf, bufsize);
1497 		check_signals();
1498 		if (nr_read < 0) {
1499 			if (errno == EINTR)
1500 				continue;
1501 			warn("read() failed on inotify fd!");
1502 			cleanup_exit(EXIT_FAILURE);
1503 		}
1504 		if (nr_read == bufsize)
1505 			warnx("inotify() buffer filled, skipping events");
1506 		if (nr_read < istructsize) {
1507 			warnx("read() returned too few bytes on inotify fd");
1508 			cleanup_exit(EXIT_FAILURE);
1509 		}
1510 
1511 		for (p = buf; p < buf + nr_read;) {
1512 			event = (struct inotify_event *) p;
1513 			if ((event->mask & IN_MODIFY) != 0)
1514 				modified++;
1515 			p += istructsize + event->len;
1516 		}
1517 		while (modified > 0) {
1518 			check_signals();
1519 			mutex_lock(&printstate.mutex);
1520 			check_signals();
1521 			printstate_next_ticket(&req);
1522 			if (printstate_cnt_read() > 0) {
1523 				printstate_mark_req_completed(&req);
1524 				mutex_unlock(&printstate.mutex);
1525 				if (verbose_lostevent()) {
1526 					clock_gettime_or_die(CLOCK_MONOTONIC,
1527 							     &timestamp);
1528 					print_lostmessage(&timestamp, buffer,
1529 							  bufspace, &req,
1530 							  "inotify loop");
1531 				}
1532 				break;
1533 			}
1534 			mutex_unlock(&printstate.mutex);
1535 			if (queue_try_to_add_entry(&printqueue, &req) != 0) {
1536 				/* These prints could happen concurrently */
1537 				check_signals();
1538 				mutex_lock(&print_mtx);
1539 				check_signals();
1540 				write_or_die(fd_stdout, queue_full_warning,
1541 					     strlen(queue_full_warning));
1542 				mutex_unlock(&print_mtx);
1543 			}
1544 			modified--;
1545 		}
1546 	}
1547 }
1548 
1549 static void *do_printloop(void *arg)
1550 {
1551 	const size_t bufspace = PRINT_BUFFER_SIZE;
1552 	char *buffer;
1553 	long *rseed = (long *) arg;
1554 	struct drand48_data drandbuf;
1555 	long slept = 0;
1556 	struct entry req;
1557 	int prob = 0;
1558 	struct timespec timestamp;
1559 	struct short_msg resize_msg;
1560 
1561 	print_priority();
1562 
1563 	if (srand48_r(*rseed, &drandbuf) != 0) {
1564 		warn("srand48_r() failed!\n");
1565 		cleanup_exit(EXIT_FAILURE);
1566 	}
1567 
1568 	buffer = malloc_or_die(bufspace);
1569 
1570 	while (true) {
1571 		req = queue_wait_for_entry(&printqueue);
1572 		clock_gettime_or_die(CLOCK_MONOTONIC, &timestamp);
1573 		mutex_lock(&printstate.mutex);
1574 		if (prev_req_won_race(&req)) {
1575 			printstate_mark_req_completed(&req);
1576 			mutex_unlock(&printstate.mutex);
1577 			if (verbose_lostevent())
1578 				print_lostmessage(&timestamp, buffer, bufspace,
1579 						  &req, "print loop");
1580 			continue;
1581 		}
1582 		mutex_unlock(&printstate.mutex);
1583 
1584 		/*
1585 		 * Toss a coin to decide if we want to sleep before printing
1586 		 * out the backtrace. The reason for this is that opening
1587 		 * /sys/kernel/tracing/trace will cause a blackout of
1588 		 * hundreds of ms, where no latencies will be noted by the
1589 		 * latency tracer. Thus by randomly sleeping we try to avoid
1590 		 * missing traces systematically due to this. With this option
1591 		 * we will sometimes get the first latency, some other times
1592 		 * some of the later ones, in case of closely spaced traces.
1593 		 */
1594 		if (trace_enable && use_random_sleep) {
1595 			slept = 0;
1596 			prob = table_get_probability(&req, &resize_msg);
1597 			if (!toss_coin(&drandbuf, prob))
1598 				slept = go_to_sleep(&req);
1599 			if (slept >= 0) {
1600 				/* A print is ongoing */
1601 				printstate_cnt_inc();
1602 				/*
1603 				 * We will do the printout below so we have to
1604 				 * mark it as completed while we still have the
1605 				 * mutex.
1606 				 */
1607 				mutex_lock(&printstate.mutex);
1608 				printstate_mark_req_completed(&req);
1609 				mutex_unlock(&printstate.mutex);
1610 			}
1611 		}
1612 		if (trace_enable) {
1613 			/*
1614 			 * slept < 0  means that we detected another
1615 			 * notification in go_to_sleep() above
1616 			 */
1617 			if (slept >= 0)
1618 				/*
1619 				 * N.B. printstate_cnt_dec(); will be called
1620 				 * inside print_tracefile()
1621 				 */
1622 				print_tracefile(&resize_msg, &timestamp, buffer,
1623 						bufspace, slept, &req);
1624 			else
1625 				print_skipmessage(&resize_msg, &timestamp,
1626 						  buffer, bufspace, &req, true);
1627 		} else {
1628 			print_skipmessage(&resize_msg, &timestamp, buffer,
1629 					  bufspace, &req, false);
1630 		}
1631 	}
1632 	return NULL;
1633 }
1634 
1635 static void start_printthread(void)
1636 {
1637 	unsigned int i;
1638 	long *seed;
1639 	int ufd;
1640 
1641 	ufd = open(DEV_URANDOM, O_RDONLY);
1642 	if (nr_threads > MAX_THREADS) {
1643 		warnx(
1644 "Number of requested print threads was %d, max number is %d\n",
1645 		      nr_threads, MAX_THREADS);
1646 		nr_threads = MAX_THREADS;
1647 	}
1648 	for (i = 0; i < nr_threads; i++) {
1649 		seed = malloc_or_die(sizeof(*seed));
1650 		if (ufd <  0 ||
1651 		    read(ufd, seed, sizeof(*seed)) != sizeof(*seed)) {
1652 			printf(
1653 "Warning! Using trivial random number seed, since %s not available\n",
1654 			DEV_URANDOM);
1655 			fflush(stdout);
1656 			*seed = i;
1657 		}
1658 		errno = pthread_create(&printthread[i], NULL, do_printloop,
1659 				       seed);
1660 		if (errno)
1661 			err(EXIT_FAILURE, "pthread_create()");
1662 	}
1663 	if (ufd > 0 && close(ufd) != 0)
1664 		warn("close() failed");
1665 }
1666 
1667 static void show_usage(void)
1668 {
1669 	printf(
1670 "Usage: %s [OPTION]...\n\n"
1671 "Collect closely occurring latencies from %s\n"
1672 "with any of the following tracers: preemptirqsoff, preemptoff, irqsoff, "
1673 "wakeup,\nwakeup_dl, or wakeup_rt.\n\n"
1674 
1675 "The occurrence of a latency is detected by monitoring the file\n"
1676 "%s with inotify.\n\n"
1677 
1678 "The following options are supported:\n\n"
1679 
1680 "-l, --list\t\tList the latency tracers that are supported by the\n"
1681 "\t\t\tcurrently running Linux kernel. If you don't see the\n"
1682 "\t\t\ttracer that you want, you will probably need to\n"
1683 "\t\t\tchange your kernel config and build a new kernel.\n\n"
1684 
1685 "-t, --tracer TR\t\tUse the tracer TR. The default is to use the first\n"
1686 "\t\t\ttracer that is supported by the kernel in the following\n"
1687 "\t\t\torder of precedence:\n\n"
1688 "\t\t\tpreemptirqsoff\n"
1689 "\t\t\tpreemptoff\n"
1690 "\t\t\tirqsoff\n"
1691 "\t\t\twakeup\n"
1692 "\t\t\twakeup_rt\n"
1693 "\t\t\twakeup_dl\n"
1694 "\n"
1695 "\t\t\tIf TR is not on the list above, then a warning will be\n"
1696 "\t\t\tprinted.\n\n"
1697 
1698 "-F, --force\t\tProceed even if another ftrace tracer is active. Without\n"
1699 "\t\t\tthis option, the program will refuse to start tracing if\n"
1700 "\t\t\tany other tracer than the nop tracer is active.\n\n"
1701 
1702 "-s, --threshold TH\tConfigure ftrace to use a threshold of TH microseconds\n"
1703 "\t\t\tfor the tracer. The default is 0, which means that\n"
1704 "\t\t\ttracing_max_latency will be used. tracing_max_latency is\n"
1705 "\t\t\tset to 0 when the program is started and contains the\n"
1706 "\t\t\tmaximum of the latencies that have been encountered.\n\n"
1707 
1708 "-f, --function\t\tEnable the function-trace option in trace_options. With\n"
1709 "\t\t\tthis option, ftrace will trace the functions that are\n"
1710 "\t\t\texecuted during a latency, without it we only get the\n"
1711 "\t\t\tbeginning, end, and backtrace.\n\n"
1712 
1713 "-g, --graph\t\tEnable the display-graph option in trace_option. This\n"
1714 "\t\t\toption causes ftrace to show the graph of how functions\n"
1715 "\t\t\tare calling other functions.\n\n"
1716 
1717 "-c, --policy POL\tRun the program with scheduling policy POL. POL can be\n"
1718 "\t\t\tother, batch, idle, rr or fifo. The default is rr. When\n"
1719 "\t\t\tusing rr or fifo, remember that these policies may cause\n"
1720 "\t\t\tother tasks to experience latencies.\n\n"
1721 
1722 "-p, --priority PRI\tRun the program with priority PRI. The acceptable range\n"
1723 "\t\t\tof PRI depends on the scheduling policy.\n\n"
1724 
1725 "-n, --notrace\t\tIf latency is detected, do not print out the content of\n"
1726 "\t\t\tthe trace file to standard output\n\n"
1727 
1728 "-t, --threads NRTHR\tRun NRTHR threads for printing. Default is %d.\n\n"
1729 
1730 "-r, --random\t\tArbitrarily sleep a certain amount of time, default\n"
1731 "\t\t\t%ld ms, before reading the trace file. The\n"
1732 "\t\t\tprobabilities for sleep are chosen so that the\n"
1733 "\t\t\tprobability of obtaining any of a cluster of closely\n"
1734 "\t\t\toccurring latencies are equal, i.e. we will randomly\n"
1735 "\t\t\tchoose which one we collect from the trace file.\n\n"
1736 "\t\t\tThis option is probably only useful with the irqsoff,\n"
1737 "\t\t\tpreemptoff, and preemptirqsoff tracers.\n\n"
1738 
1739 "-a, --nrlat NRLAT\tFor the purpose of arbitrary delay, assume that there\n"
1740 "\t\t\tare no more than NRLAT clustered latencies. If NRLAT\n"
1741 "\t\t\tlatencies are detected during a run, this value will\n"
1742 "\t\t\tautomatically be increased to NRLAT + 1 and then to\n"
1743 "\t\t\tNRLAT + 2 and so on. The default is %d. This option\n"
1744 "\t\t\timplies -r. We need to know this number in order to\n"
1745 "\t\t\tbe able to calculate the probabilities of sleeping.\n"
1746 "\t\t\tSpecifically, the probabilities of not sleeping, i.e. to\n"
1747 "\t\t\tdo an immediate printout will be:\n\n"
1748 "\t\t\t1/NRLAT  1/(NRLAT - 1) ... 1/3  1/2  1\n\n"
1749 "\t\t\tThe probability of sleeping will be:\n\n"
1750 "\t\t\t1 - P, where P is from the series above\n\n"
1751 "\t\t\tThis descending probability will cause us to choose\n"
1752 "\t\t\tan occurrence at random. Observe that the final\n"
1753 "\t\t\tprobability is 0, it is when we reach this probability\n"
1754 "\t\t\tthat we increase NRLAT automatically. As an example,\n"
1755 "\t\t\twith the default value of 2, the probabilities will be:\n\n"
1756 "\t\t\t1/2  0\n\n"
1757 "\t\t\tThis means, when a latency is detected we will sleep\n"
1758 "\t\t\twith 50%% probability. If we ever detect another latency\n"
1759 "\t\t\tduring the sleep period, then the probability of sleep\n"
1760 "\t\t\twill be 0%% and the table will be expanded to:\n\n"
1761 "\t\t\t1/3  1/2  0\n\n"
1762 
1763 "-v, --verbose\t\tIncrease the verbosity. If this option is given once,\n"
1764 "\t\t\tthen print a message every time that the NRLAT value\n"
1765 "\t\t\tis automatically increased. It also causes a message to\n"
1766 "\t\t\tbe printed when the ftrace settings are changed. If this\n"
1767 "\t\t\toption is given at least twice, then also print a\n"
1768 "\t\t\twarning for lost events.\n\n"
1769 
1770 "-u, --time TIME\t\tArbitrarily sleep for a specified time TIME ms before\n"
1771 "\t\t\tprinting out the trace from the trace file. The default\n"
1772 "\t\t\tis %ld ms. This option implies -r.\n\n"
1773 
1774 "-x, --no-ftrace\t\tDo not configure ftrace. This assume that the user\n"
1775 "\t\t\tconfigures the ftrace files in sysfs such as\n"
1776 "\t\t\t/sys/kernel/tracing/current_tracer or equivalent.\n\n"
1777 
1778 "-i, --tracefile FILE\tUse FILE as trace file. The default is\n"
1779 "\t\t\t%s.\n"
1780 "\t\t\tThis options implies -x\n\n"
1781 
1782 "-m, --max-lat FILE\tUse FILE as tracing_max_latency file. The default is\n"
1783 "\t\t\t%s.\n"
1784 "\t\t\tThis options implies -x\n\n"
1785 ,
1786 prg_name, debug_tracefile_dflt, debug_maxlat_dflt, DEFAULT_NR_PRINTER_THREADS,
1787 SLEEP_TIME_MS_DEFAULT, DEFAULT_TABLE_SIZE, SLEEP_TIME_MS_DEFAULT,
1788 debug_tracefile_dflt, debug_maxlat_dflt);
1789 }
1790 
1791 static void find_tracefiles(void)
1792 {
1793 	debug_tracefile_dflt = tracefs_get_tracing_file("trace");
1794 	if (debug_tracefile_dflt == NULL) {
1795 		/* This is needed in show_usage() */
1796 		debug_tracefile_dflt = DEBUG_NOFILE;
1797 	}
1798 
1799 	debug_maxlat_dflt = tracefs_get_tracing_file("tracing_max_latency");
1800 	if (debug_maxlat_dflt == NULL) {
1801 		/* This is needed in show_usage() */
1802 		debug_maxlat_dflt = DEBUG_NOFILE;
1803 	}
1804 
1805 	debug_tracefile = debug_tracefile_dflt;
1806 	debug_maxlat = debug_maxlat_dflt;
1807 }
1808 
1809 bool alldigits(const char *s)
1810 {
1811 	for (; *s != '\0'; s++)
1812 		if (!isdigit(*s))
1813 			return false;
1814 	return true;
1815 }
1816 
1817 void check_alldigits(const char *optarg, const char *argname)
1818 {
1819 	if (!alldigits(optarg))
1820 		errx(EXIT_FAILURE,
1821 		     "The %s parameter expects a decimal argument\n", argname);
1822 }
1823 
1824 static void scan_arguments(int argc, char *argv[])
1825 {
1826 	int c;
1827 	int i;
1828 	int option_idx = 0;
1829 
1830 	static struct option long_options[] = {
1831 		{ "list",       no_argument,            0, 'l' },
1832 		{ "tracer",	required_argument,	0, 't' },
1833 		{ "force",      no_argument,            0, 'F' },
1834 		{ "threshold",  required_argument,      0, 's' },
1835 		{ "function",   no_argument,            0, 'f' },
1836 		{ "graph",      no_argument,            0, 'g' },
1837 		{ "policy",	required_argument,	0, 'c' },
1838 		{ "priority",	required_argument,	0, 'p' },
1839 		{ "help",	no_argument,		0, 'h' },
1840 		{ "notrace",	no_argument,		0, 'n' },
1841 		{ "random",	no_argument,		0, 'r' },
1842 		{ "nrlat",	required_argument,	0, 'a' },
1843 		{ "threads",	required_argument,	0, 'e' },
1844 		{ "time",	required_argument,	0, 'u' },
1845 		{ "verbose",	no_argument,		0, 'v' },
1846 		{ "no-ftrace",  no_argument,            0, 'x' },
1847 		{ "tracefile",	required_argument,	0, 'i' },
1848 		{ "max-lat",	required_argument,	0, 'm' },
1849 		{ 0,		0,			0,  0  }
1850 	};
1851 	const struct policy *p;
1852 	int max, min;
1853 	int value;
1854 	bool notracer, valid;
1855 
1856 	/*
1857 	 * We must do this before parsing the arguments because show_usage()
1858 	 * needs to display these.
1859 	 */
1860 	find_tracefiles();
1861 
1862 	while (true) {
1863 		c = getopt_long(argc, argv, "lt:Fs:fgc:p:hnra:e:u:vxi:m:",
1864 				long_options, &option_idx);
1865 		if (c == -1)
1866 			break;
1867 
1868 		switch (c) {
1869 		case 'l':
1870 			show_available();
1871 			exit(0);
1872 			break;
1873 		case 't':
1874 			current_tracer = strdup(optarg);
1875 			if (!is_relevant_tracer(current_tracer)) {
1876 				warnx("%s is not a known latency tracer!\n",
1877 				      current_tracer);
1878 			}
1879 			valid = tracer_valid(current_tracer, &notracer);
1880 			if (notracer)
1881 				errx(EXIT_FAILURE, "%s", no_tracer_msg);
1882 			if (!valid)
1883 				errx(EXIT_FAILURE,
1884 "The tracer %s is not supported by your kernel!\n", current_tracer);
1885 			break;
1886 		case 'F':
1887 			force_tracer = true;
1888 			break;
1889 		case 's':
1890 			check_alldigits(optarg, "-s [--threshold]");
1891 			threshold = strdup(optarg);
1892 			break;
1893 		case 'f':
1894 			use_options[OPTIDX_FUNC_TR] = true;
1895 			break;
1896 		case 'g':
1897 			use_options[OPTIDX_DISP_GR] = true;
1898 			break;
1899 		case 'c':
1900 			p = policy_from_name(optarg);
1901 			if (p != NULL) {
1902 				sched_policy = p->policy;
1903 				sched_policy_set = true;
1904 				if (!sched_pri_set) {
1905 					sched_pri = p->default_pri;
1906 					sched_pri_set = true;
1907 				}
1908 			} else {
1909 				warnx("Unknown scheduling %s\n", optarg);
1910 				show_usage();
1911 				exit(0);
1912 			}
1913 			break;
1914 		case 'p':
1915 			check_alldigits(optarg, "-p [--priority]");
1916 			sched_pri = atoi(optarg);
1917 			sched_pri_set = true;
1918 			break;
1919 		case 'h':
1920 			show_usage();
1921 			exit(0);
1922 			break;
1923 		case 'n':
1924 			trace_enable = false;
1925 			use_random_sleep = false;
1926 			break;
1927 		case 'e':
1928 			check_alldigits(optarg, "-e [--threads]");
1929 			value = atoi(optarg);
1930 			if (value > 0)
1931 				nr_threads = value;
1932 			else {
1933 				warnx("NRTHR must be > 0\n");
1934 				show_usage();
1935 				exit(0);
1936 			}
1937 			break;
1938 		case 'u':
1939 			check_alldigits(optarg, "-u [--time]");
1940 			value = atoi(optarg);
1941 			if (value < 0) {
1942 				warnx("TIME must be >= 0\n");
1943 				show_usage();
1944 				exit(0);
1945 			}
1946 			trace_enable = true;
1947 			use_random_sleep = true;
1948 			sleep_time = value * USEC_PER_MSEC;
1949 			break;
1950 		case 'v':
1951 			verbosity++;
1952 			break;
1953 		case 'r':
1954 			trace_enable = true;
1955 			use_random_sleep = true;
1956 			break;
1957 		case 'a':
1958 			check_alldigits(optarg, "-a [--nrlat]");
1959 			value = atoi(optarg);
1960 			if (value <= 0) {
1961 				warnx("NRLAT must be > 0\n");
1962 				show_usage();
1963 				exit(0);
1964 			}
1965 			trace_enable = true;
1966 			use_random_sleep = true;
1967 			table_startsize = value;
1968 			break;
1969 		case 'x':
1970 			setup_ftrace = false;
1971 			break;
1972 		case 'i':
1973 			setup_ftrace = false;
1974 			debug_tracefile = strdup(optarg);
1975 			break;
1976 		case 'm':
1977 			setup_ftrace = false;
1978 			debug_maxlat = strdup(optarg);
1979 			break;
1980 		default:
1981 			show_usage();
1982 			exit(0);
1983 			break;
1984 		}
1985 	}
1986 
1987 	if (setup_ftrace) {
1988 		if (!current_tracer) {
1989 			current_tracer = find_default_tracer();
1990 			if (!current_tracer)
1991 				errx(EXIT_FAILURE,
1992 "No default tracer found and tracer not specified\n");
1993 		}
1994 
1995 		if (use_random_sleep && !random_makes_sense(current_tracer)) {
1996 			warnx("WARNING: The tracer is %s and random sleep has",
1997 			      current_tracer);
1998 			fprintf(stderr,
1999 "been enabled. Random sleep is intended for the following tracers:\n");
2000 			for (i = 0; random_tracers[i]; i++)
2001 				fprintf(stderr, "%s\n", random_tracers[i]);
2002 			fprintf(stderr, "\n");
2003 		}
2004 	}
2005 
2006 	if (debug_tracefile == DEBUG_NOFILE ||
2007 	    debug_maxlat == DEBUG_NOFILE)
2008 		errx(EXIT_FAILURE,
2009 "Could not find tracing directory e.g. /sys/kernel/tracing\n");
2010 
2011 	if (!sched_policy_set) {
2012 		sched_policy = SCHED_RR;
2013 		sched_policy_set = true;
2014 		if (!sched_pri_set) {
2015 			sched_pri = RT_DEFAULT_PRI;
2016 			sched_pri_set = true;
2017 		}
2018 	}
2019 
2020 	max = sched_get_priority_max(sched_policy);
2021 	min = sched_get_priority_min(sched_policy);
2022 
2023 	if (sched_pri < min) {
2024 		printf(
2025 "ATTENTION: Increasing priority to minimum, which is %d\n", min);
2026 		sched_pri = min;
2027 	}
2028 	if (sched_pri > max) {
2029 		printf(
2030 "ATTENTION: Reducing priority to maximum, which is %d\n", max);
2031 		sched_pri = max;
2032 	}
2033 }
2034 
2035 static void show_params(void)
2036 {
2037 	printf(
2038 "\n"
2039 "Running with scheduling policy %s and priority %d. Using %d print threads.\n",
2040 		policy_name(sched_policy), sched_pri, nr_threads);
2041 	if (trace_enable) {
2042 		if (use_random_sleep) {
2043 			printf(
2044 "%s will be printed with random delay\n"
2045 "Start size of the probability table:\t\t\t%d\n"
2046 "Print a message when the prob. table changes size:\t%s\n"
2047 "Print a warning when an event has been lost:\t\t%s\n"
2048 "Sleep time is:\t\t\t\t\t\t%ld ms\n",
2049 debug_tracefile,
2050 table_startsize,
2051 bool2str(verbose_sizechange()),
2052 bool2str(verbose_lostevent()),
2053 sleep_time / USEC_PER_MSEC);
2054 		} else {
2055 			printf("%s will be printed immediately\n",
2056 			       debug_tracefile);
2057 		}
2058 	} else {
2059 		printf("%s will not be printed\n",
2060 		       debug_tracefile);
2061 	}
2062 	if (setup_ftrace) {
2063 		printf("Tracer:\t\t\t\t\t\t\t%s\n"
2064 		       "%s option:\t\t\t\t\t%s\n"
2065 		       "%s option:\t\t\t\t\t%s\n",
2066 		       current_tracer,
2067 		       optstr[OPTIDX_FUNC_TR],
2068 		       bool2str(use_options[OPTIDX_FUNC_TR]),
2069 		       optstr[OPTIDX_DISP_GR],
2070 		       bool2str(use_options[OPTIDX_DISP_GR]));
2071 		if (!strcmp(threshold, "0"))
2072 			printf("Threshold:\t\t\t\t\t\ttracing_max_latency\n");
2073 		else
2074 			printf("Threshold:\t\t\t\t\t\t%s\n", threshold);
2075 	}
2076 	printf("\n");
2077 }
2078 
2079 int main(int argc, char *argv[])
2080 {
2081 	init_save_state();
2082 	signal_blocking(SIG_BLOCK);
2083 	setup_sig_handler();
2084 	open_stdout();
2085 
2086 	if (argc >= 1)
2087 		prg_name = argv[0];
2088 	else
2089 		prg_name = prg_unknown;
2090 
2091 	scan_arguments(argc, argv);
2092 	show_params();
2093 
2094 	init_printstate();
2095 	init_print_mtx();
2096 	if (use_random_sleep) {
2097 		init_probabilities();
2098 		if (verbose_sizechange())
2099 			printf("Initializing probability table to %d\n",
2100 			       table_startsize);
2101 		sleeptable_resize(table_startsize, false, NULL);
2102 	}
2103 	set_priority();
2104 	init_queue(&printqueue);
2105 	start_printthread();
2106 	tracing_loop();
2107 	return 0;
2108 }
2109