parlib: Add __uth_sync_swap and __uth_sync_is_empty
[akaros.git] / user / parlib / debug.c
1 #include <parlib/common.h>
2 #include <parlib/assert.h>
3 #include <parlib/stdio.h>
4 #include <parlib/parlib.h>
5 #include <stdio.h>
6 #include <unistd.h>
7 #include <parlib/spinlock.h>
8 #include <ros/common.h>
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <fcntl.h>
12
13 int akaros_printf(const char *format, ...)
14 {
15         va_list ap;
16         int ret;
17
18         va_start(ap, format);
19         ret = vprintf(format, ap);
20         va_end(ap);
21         return ret;
22 }
23
24 /* Poor man's Ftrace, won't work well with concurrency. */
25 static const char *blacklist[] = {
26         "whatever",
27 };
28
29 static bool is_blacklisted(const char *s)
30 {
31         for (int i = 0; i < COUNT_OF(blacklist); i++) {
32                 if (!strcmp(blacklist[i], s))
33                         return TRUE;
34         }
35         return FALSE;
36 }
37
38 static int tab_depth = 0;
39 static bool print = TRUE;
40
41 void reset_print_func_depth(void)
42 {
43         tab_depth = 0;
44 }
45
46 void toggle_print_func(void)
47 {
48         print = !print;
49         printf("Func entry/exit printing is now %sabled\n", print ? "en" : "dis");
50 }
51
52 static spinlock_t lock = {0};
53
54 void __print_func_entry(const char *func, const char *file)
55 {
56         if (!print)
57                 return;
58         if (is_blacklisted(func))
59                 return;
60         spinlock_lock(&lock);
61         printd("Vcore %2d", vcore_id());        /* helps with multicore output */
62         for (int i = 0; i < tab_depth; i++)
63                 printf("\t");
64         printf("%s() in %s\n", func, file);
65         spinlock_unlock(&lock);
66         tab_depth++;
67 }
68
69 void __print_func_exit(const char *func, const char *file)
70 {
71         if (!print)
72                 return;
73         if (is_blacklisted(func))
74                 return;
75         tab_depth--;
76         spinlock_lock(&lock);
77         printd("Vcore %2d", vcore_id());
78         for (int i = 0; i < tab_depth; i++)
79                 printf("\t");
80         printf("---- %s()\n", func);
81         spinlock_unlock(&lock);
82 }
83
84 static int kptrace;
85
86 static void trace_init(void *arg)
87 {
88         kptrace = open("#kprof/kptrace", O_WRITE);
89         if (kptrace < 0)
90                 perror("Unable to open kptrace!\n");
91 }
92
93 void trace_printf(const char *fmt, ...)
94 {
95         va_list args;
96         char buf[128];
97         int amt;
98         static parlib_once_t once = PARLIB_ONCE_INIT;
99
100         parlib_run_once(&once, trace_init, NULL);
101         if (kptrace < 0)
102                 return;
103         amt = snprintf(buf, sizeof(buf), "PID %d: ", getpid());
104         /* amt could be > sizeof, if we truncated. */
105         amt = MIN(amt, sizeof(buf));
106         va_start(args, fmt);
107         /* amt == sizeof is OK here */
108         amt += vsnprintf(buf + amt, sizeof(buf) - amt, fmt, args);
109         va_end(args);
110         write(kptrace, buf, MIN(amt, sizeof(buf)));
111 }