Remove the old console input code; use qio
[akaros.git] / kern / src / err.c
1 /*
2  * Copyright 2013 Google Inc.
3  */
4 //#define DEBUG
5 #include <setjmp.h>
6 #include <vfs.h>
7 #include <kfs.h>
8 #include <slab.h>
9 #include <kmalloc.h>
10 #include <kref.h>
11 #include <string.h>
12 #include <stdio.h>
13 #include <assert.h>
14 #include <error.h>
15 #include <cpio.h>
16 #include <pmap.h>
17 #include <smp.h>
18 #include <err.h>
19
20 /* General idea: if we're at the base for this func (base of ERRSTACK in the
21  * scope where ERRSTACK and waserror are used), we need to find and save the
22  * previous errbuf, so we know how to pop back.
23  *
24  * The main goal of this is to track and advertise (via pcpui) the errbuf that
25  * should be jumped to next (when we call error()).  Note that the caller of
26  * this (waserror()) will fill the jumpbuf shortly with its context.
27  *
28  * When we enter, curindex points to the slot we should use.  First time, it is
29  * 0, and we'll set cur_eb to slot 0.  When we leave, curindex is set to the
30  * next free slot. */
31 struct errbuf *errpush(struct errbuf *errstack, int stacksize, int *curindex,
32                                            struct errbuf **prev_errbuf)
33 {
34         struct errbuf *cbuf;
35
36         printd("pushe %p %d %dp\n", errstack, stacksize, *curindex);
37         if (*curindex == 0)
38                 *prev_errbuf = get_cur_errbuf();
39
40         if (*curindex >= stacksize)
41                 panic("Error stack overflow");
42
43         cbuf = &errstack[*curindex];
44         set_cur_errbuf(cbuf);
45         (*curindex)++;
46
47         return cbuf;
48 }
49
50 /* Undo the work of errpush, and advertise the new errbuf used by error() calls.
51  * We only need to be tricky when we reached the beginning of the stack and need
52  * to check the prev_errbuf from a previous ERRSTACK/function.
53  *
54  * When we enter, curindex is the slot of the next *free* errstack (the one we'd
55  * push into if we were pushing.  When we leave, it will be decreased by one,
56  * and will still point to the next free errstack (the one we are popping).
57  * */
58 struct errbuf *errpop(struct errbuf *errstack, int stacksize, int *curindex,
59                                           struct errbuf *prev_errbuf)
60 {
61         struct errbuf *cbuf;
62
63         printd("pope %p %d %d\n", errstack, stacksize, *curindex);
64         /* curindex now points to the slot we are popping*/
65         *curindex = *curindex - 1;
66         /* We still need to advertise the previous slot, which is one back from
67          * curindex.  If curindex is 0, that means the next free slot is the first
68          * of our errstack.  In this case, we need to advertise the prev. */
69         if (*curindex < 0)
70                 panic("Error stack underflow");
71
72         cbuf = (*curindex == 0) ? prev_errbuf: &errstack[*curindex - 1];
73         set_cur_errbuf(cbuf);
74
75         return cbuf;
76 }