Can wait on async library calls
[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 256 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 typedef struct printbuf {
20         int idx;        // current buffer index
21         int cnt;        // total bytes printed so far
22         char buf[256];
23 } printbuf_t;
24
25
26 static void
27 putch(int ch, printbuf_t *b)
28 {
29         b->buf[b->idx++] = ch;
30         if (b->idx == 256-1) {
31                 sys_cputs(b->buf, b->idx);
32                 b->idx = 0;
33         }
34         b->cnt++;
35 }
36
37 int
38 vcprintf(const char *fmt, va_list ap)
39 {
40         printbuf_t b;
41
42         b.idx = 0;
43         b.cnt = 0;
44         vprintfmt((void*)putch, &b, fmt, ap);
45         sys_cputs(b.buf, b.idx);
46
47         return b.cnt;
48 }
49
50 int
51 cprintf(const char *fmt, ...)
52 {
53         va_list ap;
54         int cnt;
55
56         va_start(ap, fmt);
57         cnt = vcprintf(fmt, ap);
58         va_end(ap);
59
60         return cnt;
61 }
62
63 // Temp async varieties
64 #define MAX_BUFFERS 10
65 POOL_TYPE_DEFINE(printbuf_t, print_buf_pool, MAX_BUFFERS);
66 print_buf_pool_t print_buf_pool;
67
68 static error_t init_printf(void)
69 {
70         POOL_INIT(&print_buf_pool, MAX_BUFFERS);
71         return 0;
72 }
73
74 static printbuf_t* get_free_buffer(void)
75 {
76         return POOL_GET(&print_buf_pool);
77         //cprintf("Out of buffers!!!\n");
78 }
79
80 // this buffering is a minor pain in the ass....
81 // TODO - it will be a pain in the ass to put the buffers back after we waited.
82 static void putch_async(int ch, printbuf_t *b)
83 {
84         b->buf[b->idx++] = ch;
85         if (b->idx == 256-1) {
86                 // will need some way to track the result of the syscall
87                 sys_cputs_async(b->buf, b->idx, get_sys_desc(current_async_desc));
88                 // TODO - this isn't getting passed back properly
89                 b = get_free_buffer();
90                 b->idx = 0;
91         }
92         b->cnt++; // supposed to be overall number, not just in one buffer
93 }
94
95 static int vcprintf_async(const char *fmt, va_list ap)
96 {
97         // start with an available buffer
98         printbuf_t* b = get_free_buffer();
99
100         b->idx = 0;
101         b->cnt = 0;
102         vprintfmt((void*)putch_async, b, fmt, ap);
103         sys_cputs_async(b->buf, b->idx, get_sys_desc(current_async_desc));
104
105         return b->cnt; // this is lying if we used more than one buffer
106 }
107
108 int cprintf_async(async_desc_t** desc, const char *fmt, ...)
109 {
110         va_list ap;
111         int cnt;
112         static bool initialized = 0;
113         if (!initialized) {
114                 init_printf();
115         initialized = TRUE;
116         }
117         current_async_desc = get_async_desc();
118         *desc = current_async_desc;
119
120         va_start(ap, fmt);
121         cnt = vcprintf_async(fmt, ap);
122         va_end(ap);
123
124         return cnt;
125 }
126