BNX2X: spatch signed typedefs
[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 int errpush(struct errbuf *errstack, int stacksize, int *curindex,
32             struct errbuf **prev_errbuf)
33 {
34         printd("pushe %p %d %dp\n", errstack, stacksize, *curindex);
35         if (*curindex == 0)
36                 *prev_errbuf = get_cur_errbuf();
37
38         if (*curindex >= stacksize)
39                 panic("Error stack overflow");
40         set_cur_errbuf(&errstack[*curindex]);
41         *curindex = *curindex + 1;
42         return 0;
43 }
44
45 /* Undo the work of errpush, and advertise the new errbuf used by error() calls.
46  * We only need to be tricky when we reached the beginning of the stack and need
47  * to check the prev_errbuf from a previous ERRSTACK/function.
48  *
49  * When we enter, curindex is the slot of the next *free* errstack (the one we'd
50  * push into if we were pushing.  When we leave, it will be decreased by one,
51  * and will still point to the next free errstack (the one we are popping).
52  * */
53 void errpop(struct errbuf *errstack, int stacksize, int *curindex,
54             struct errbuf *prev_errbuf)
55 {
56         printd("pope %p %d %d\n", errstack, stacksize, *curindex);
57         /* curindex now points to the slot we are popping*/
58         *curindex = *curindex - 1;
59         /* We still need to advertise the previous slot, which is one back from
60          * curindex.  If curindex is 0, that means the next free slot is the first
61          * of our errstack.  In this case, we need to advertise the prev. */
62         if (*curindex < 0)
63                 panic("Error stack underflow");
64
65         if (*curindex == 0)
66                 set_cur_errbuf(prev_errbuf);
67         else
68                 set_cur_errbuf(&errstack[*curindex - 1]);       /* use the prior slot */
69 }