Measurement for async syscalls
[akaros.git] / lib / printf.c
1 // Implementation of cprintf console output for user environments,
2 // based on printfmt() and the sys_cputs() system call.
3 //
4 // cprintf is a debugging statement, not a generic output statement.
5 // It is very important that it always go to the console, especially when
6 // debugging file descriptor code!
7
8 #include <inc/types.h>
9 #include <inc/stdio.h>
10 #include <inc/stdarg.h>
11 #include <inc/lib.h>
12
13
14 // Collect up to BUF_SIZE characters into a buffer
15 // and perform ONE system call to print all of them,
16 // in order to make the lines output to the console atomic
17 // and prevent interrupts from causing context switches
18 // in the middle of a console output line and such.
19 #define BUF_SIZE 256
20 typedef struct printbuf {
21         int idx;        // current buffer index
22         int cnt;        // total bytes printed so far
23         char buf[BUF_SIZE];
24 } printbuf_t;
25
26
27 static void putch(int ch, printbuf_t **b)
28 {
29         (*b)->buf[(*b)->idx++] = ch;
30         if ((*b)->idx == BUF_SIZE) {
31                 sys_cputs((*b)->buf, (*b)->idx);
32                 (*b)->idx = 0;
33         }
34         (*b)->cnt++;
35 }
36
37 int vcprintf(const char *fmt, va_list ap)
38 {
39         printbuf_t b;
40         printbuf_t *bp = &b;
41
42         b.idx = 0;
43         b.cnt = 0;
44         vprintfmt((void*)putch, (void**)&bp, fmt, ap);
45         sys_cputs(b.buf, b.idx);
46
47         return b.cnt;
48 }
49
50 int cprintf(const char *fmt, ...)
51 {
52         va_list ap;
53         int cnt;
54
55         va_start(ap, fmt);
56         cnt = vcprintf(fmt, ap);
57         va_end(ap);
58
59         return cnt;
60 }
61
62 // Temp async varieties
63 #define MAX_BUFFERS 100
64 POOL_TYPE_DEFINE(printbuf_t, print_buf_pool, MAX_BUFFERS);
65 print_buf_pool_t print_buf_pool;
66
67 static error_t init_printf(void)
68 {
69         POOL_INIT(&print_buf_pool, MAX_BUFFERS);
70         return 0;
71 }
72
73 static printbuf_t* get_free_buffer(void)
74 {
75         return POOL_GET(&print_buf_pool);
76 }
77
78 // This is called when the syscall is waited on
79 static void cputs_async_cleanup(void* data)
80 {
81         POOL_PUT(&print_buf_pool, (printbuf_t*)data);
82 }
83
84 static void putch_async(int ch, printbuf_t **b)
85 {
86         (*b)->buf[(*b)->idx++] = ch;
87         if ((*b)->idx == BUF_SIZE) {
88                 // will need some way to track the result of the syscall
89                 sys_cputs_async((*b)->buf, (*b)->idx, get_sys_desc(current_async_desc),
90                                 cputs_async_cleanup, *b);
91                 // TODO - this isn't getting passed back properly
92                 // TODO - should check for a return value
93                 *b = get_free_buffer();
94                 (*b)->idx = 0;
95         }
96         (*b)->cnt++; // supposed to be overall number, not just in one buffer
97 }
98
99 static int vcprintf_async(const char *fmt, va_list ap)
100 {
101         // start with an available buffer
102         printbuf_t* b = get_free_buffer();
103
104         b->idx = 0;
105         b->cnt = 0;
106         vprintfmt((void*)putch_async, (void**)&b, fmt, ap);
107         sys_cputs_async(b->buf, b->idx, get_sys_desc(current_async_desc),
108                         cputs_async_cleanup, b);
109
110         return b->cnt; // this is lying if we used more than one buffer
111 }
112
113 int cprintf_async(async_desc_t** desc, const char *fmt, ...)
114 {
115         va_list ap;
116         int cnt;
117
118         // This async call has some housekeeping it needs to do once, ever.
119         static bool initialized = 0;
120         if (!initialized) {
121                 init_printf();
122         initialized = TRUE;
123         }
124         // get a free async_desc for this async call, and save it in the per-thread
125         // tracking variable (current_async_desc).  then pass it back out.
126         current_async_desc = get_async_desc();
127         *desc = current_async_desc;
128         // This is the traditional (sync) cprintf code
129         va_start(ap, fmt);
130         cnt = vcprintf_async(fmt, ap);
131         va_end(ap);
132
133         return cnt;
134 }
135