VMX sort of worked.
[akaros.git] / kern / drivers / dev / cons.c
index 2950a27..07b6b1d 100644 (file)
@@ -19,44 +19,41 @@ extern char *eve;
 extern int cflag;
 extern int keepbroken;
 
-void   (*serwrite)(char *, int);
+void (*serwrite) (char *, int);
 
-struct queue*  kscanq;                 /* keyboard raw scancodes (when needed) */
-char*  kscanid;                /* name of raw scan format (if defined) */
-struct queue*  kbdq;                   /* unprocessed console input */
-struct queue*  lineq;                  /* processed console input */
-struct queue*  printq;                 /* console output */
-struct queue*  klogq;                  /* kernel print (log) output */
-int    iprintscreenputs;
+struct queue *kscanq;                  /* keyboard raw scancodes (when needed) */
+char *kscanid;                                 /* name of raw scan format (if defined) */
+struct queue *kbdq;                            /* unprocessed console input */
+struct queue *lineq;                   /* processed console input */
+struct queue *printq;                  /* console output */
+struct queue *klogq;                   /* kernel print (log) output */
+int iprintscreenputs;
 
-static struct
-{
+static struct {
        rwlock_t rwlock;
-       Queue*  q;
+       Queue *q;
 } kprintq;
 
-static struct
-{
+static struct {
        qlock_t qlock;
 
-       int     raw;            /* true if we shouldn't process input */
-       int     ctl;            /* number of opens to the control file */
-       int     kbdr;           /* number of open reads to the keyboard */
-       int     scan;           /* true if reading raw scancodes */
-       int     x;              /* index into line */
-       char    line[1024];     /* current input line */
+       int raw;                                        /* true if we shouldn't process input */
+       int ctl;                                        /* number of opens to the control file */
+       int kbdr;                                       /* number of open reads to the keyboard */
+       int scan;                                       /* true if reading raw scancodes */
+       int x;                                          /* index into line */
+       char line[1024];                        /* current input line */
 
-       char    c;
-       int     count;
-       int     repeat;
+       char c;
+       int count;
+       int repeat;
 } kbd;
 
 #endif
-char*  sysname = "Your machine";
-char*  eve = "eve";
+char *sysname = "Your machine";
+char *eve = "eve";
 
-enum
-{
+enum {
        CMreboot,
        CMhalt,
        CMpanic,
@@ -65,22 +62,20 @@ enum
        CMconsole,
 };
 
-static struct cmdtab sysctlcmd[] =
-{
-       {CMreboot,      "reboot",       0},
-       {CMhalt,        "halt", 0},
-       {CMpanic,       "panic", 0},
-       {CMconsole,     "console", 1},
-       {CMbroken,      "broken", 0},
-       {CMnobroken,    "nobroken", 0},
+static struct cmdtab sysctlcmd[] = {
+       {CMreboot, "reboot", 0},
+       {CMhalt, "halt", 0},
+       {CMpanic, "panic", 0},
+       {CMconsole, "console", 1},
+       {CMbroken, "broken", 0},
+       {CMnobroken, "nobroken", 0},
 };
 
-void
-printinit(void)
+void printinit(void)
 {
 #if 0
-       lineq = qopen(2*1024, 0, NULL, NULL);
-       if(lineq == NULL)
+       lineq = qopen(2 * 1024, 0, NULL, NULL);
+       if (lineq == NULL)
                panic("printinit");
        qnoblock(lineq, 1);
 #endif
@@ -89,8 +84,7 @@ printinit(void)
 /*
  *  return true if current user is eve
  */
-int
-iseve(void)
+int iseve(void)
 {
 #if 0
        Osenv *o;
@@ -102,22 +96,20 @@ iseve(void)
 }
 
 #if 0
-static int
-consactive(void)
+static int consactive(void)
 {
-       if(printq)
+       if (printq)
                return qlen(printq) > 0;
        return 0;
 }
 
-static void
-prflush(void)
+static void prflush(void)
 {
        uint32_t now;
 
        now = m->ticks;
-       while(serwrite==NULL && consactive())
-               if(m->ticks - now >= HZ)
+       while (serwrite == NULL && consactive())
+               if (m->ticks - now >= HZ)
                        break;
 }
 
@@ -127,12 +119,11 @@ prflush(void)
  *   or uart code.  Multi-line messages to serial consoles may get
  *   interspersed with other messages.
  */
-static void
-putstrn0(char *str, int n, int usewrite)
+static void putstrn0(char *str, int n, int usewrite)
 {
        int m;
        char *t;
-       char buf[PRINTSIZE+2];
+       char buf[PRINTSIZE + 2];
        ERRSTACK(1);
 
        /*
@@ -141,13 +132,13 @@ putstrn0(char *str, int n, int usewrite)
         *  put the message there.
         */
        m = consoleprint;
-       if(canrlock(&(&kprintq)->rwlock)){
-               if(kprintq.q != NULL){
-                       if(waserror()){
+       if (canrlock(&(&kprintq)->rwlock)) {
+               if (kprintq.q != NULL) {
+                       if (waserror()) {
                                runlock(&(&kprintq)->rwlock);
                                nexterror();
                        }
-                       if(usewrite)
+                       if (usewrite)
                                qwrite(kprintq.q, str, n);
                        else
                                qiwrite(kprintq.q, str, n);
@@ -156,173 +147,50 @@ putstrn0(char *str, int n, int usewrite)
                }
                runlock(&(&kprintq)->rwlock);
        }
-       if(m && screenputs != NULL)
+       if (m && screenputs != NULL)
                screenputs(str, n);
 
        /*
         *  if there's a serial line being used as a console,
         *  put the message there.
         */
-       if(serwrite != NULL) {
+       if (serwrite != NULL) {
                serwrite(str, n);
                return;
        }
 
-       if(printq == 0)
+       if (printq == 0)
                return;
 
-       while(n > 0) {
+       while (n > 0) {
                t = memchr(str, '\n', n);
-               if(t && !kbd.raw) {
+               if (t && !kbd.raw) {
                        m = t - str;
-                       if(m > sizeof(buf)-2)
-                               m = sizeof(buf)-2;
+                       if (m > sizeof(buf) - 2)
+                               m = sizeof(buf) - 2;
                        memmove(buf, str, m);
                        buf[m] = '\r';
-                       buf[m+1] = '\n';
-                       if(usewrite)
-                               qwrite(printq, buf, m+2);
+                       buf[m + 1] = '\n';
+                       if (usewrite)
+                               qwrite(printq, buf, m + 2);
                        else
-                               qiwrite(printq, buf, m+2);
+                               qiwrite(printq, buf, m + 2);
                        str = t + 1;
                        n -= m + 1;
                } else {
-                       if(usewrite)
+                       if (usewrite)
                                qwrite(printq, str, n);
-                       else 
+                       else
                                qiwrite(printq, str, n);
                        break;
                }
        }
 }
 
-void
-putstrn(char *str, int n)
-{
-       putstrn0(str, n, 0);
-}
-
-int
-snprintf(char *s, int n, char *fmt, ...)
-{
-       va_list arg;
-
-       va_start(arg, fmt);
-       n = vseprintf(s, s+n, fmt, arg) - s;
-       va_end(arg);
-
-       return n;
-}
-
-int
-sprint(char *s, char *fmt, ...)
-{
-       int n;
-       va_list arg;
-
-       va_start(arg, fmt);
-       n = vseprintf(s, s+PRINTSIZE, fmt, arg) - s;
-       va_end(arg);
-
-       return n;
-}
-
-int
-print(char *fmt, ...)
-{
-       int n;
-       va_list arg;
-       char buf[PRINTSIZE];
-
-       va_start(arg, fmt);
-       n = vseprintf(buf, buf+sizeof(buf), fmt, arg) - buf;
-       va_end(arg);
-       putstrn(buf, n);
-
-       return n;
-}
-
-int
-fprint(int fd, char *fmt, ...)
-{
-       int n;
-       va_list arg;
-       char buf[PRINTSIZE];
-
-       va_start(arg, fmt);
-       n = vseprintf(buf, buf+sizeof(buf), fmt, arg) - buf;
-       va_end(arg);
-       putstrn(buf, n);
-
-       return n;
-}
-
-int
-kprint(char *fmt, ...)
-{
-       va_list arg;
-       char buf[PRINTSIZE];
-       int n;
-
-       va_start(arg, fmt);
-       n = vseprintf(buf, buf+sizeof(buf), fmt, arg) - buf;
-       va_end(arg);
-       if(qfull(klogq))
-               qflush(klogq);
-       return qproduce(klogq, buf, n);
-}
-
-int
-iprint(char *fmt, ...)
-{
-       int n, s;
-       va_list arg;
-       char buf[PRINTSIZE];
-
-       s = splhi();
-       va_start(arg, fmt);
-       n = vseprintf(buf, buf+sizeof(buf), fmt, arg) - buf;
-       va_end(arg);
-       if(screenputs != NULL && iprintscreenputs)
-               screenputs(buf, n);
-       uartputs(buf, n);
-       splx(s);
-
-       return n;
-}
-
-void
-panic(char *fmt, ...)
-{
-       int n;
-       va_list arg;
-       char buf[PRINTSIZE];
-
-       setpanic();
-       kprintq.q = NULL;
-       strncpy(buf,  "panic: ", sizeof(buf));
-       va_start(arg, fmt);
-       n = vseprintf(buf+strlen(buf), buf+sizeof(buf)-1, fmt, arg) - buf;
-       va_end(arg);
-       buf[n] = '\n';
-       putstrn(buf, n+1);
-       spllo();
-       dumpstack();
-
-       exit(1);
-}
-
-void
-_assert(char *fmt)
-{
-       panic("assert failed: %s", fmt);
-}
-
 /*
  * mainly for libmp
  */
-void
-sysfatal(char *fmt, ...)
+void sysfatal(char *fmt, ...)
 {
        va_list arg;
        char buf[64];
@@ -333,34 +201,33 @@ sysfatal(char *fmt, ...)
        error(buf);
 }
 
-int
-pprint(char *fmt, ...)
+int pprint(char *fmt, ...)
 {
        ERRSTACK(1);
        int n;
        struct chan *c;
        Osenv *o;
        va_list arg;
-       char buf[2*PRINTSIZE];
+       char buf[2 * PRINTSIZE];
 
        n = sprint(buf, "%s %ld: ", up->text, up->pid);
        va_start(arg, fmt);
-       n = vseprintf(buf+n, buf+sizeof(buf), fmt, arg) - buf;
+       n = vseprintf(buf + n, buf + sizeof(buf), fmt, arg) - buf;
        va_end(arg);
 
        o = up->env;
-       if(o->fgrp == 0) {
+       if (o->fgrp == 0) {
                printd("%s", buf);
                return 0;
        }
        /* TODO: this is probably wrong (VFS hack) */
        c = o->fgrp->fd[2];
-       if(c==0 || (c->mode!=OWRITE && c->mode!=ORDWR)) {
+       if (c == 0 || (c->mode != OWRITE && c->mode != ORDWR)) {
                printd("%s", buf);
                return 0;
        }
 
-       if(waserror()) {
+       if (waserror()) {
                printd("%s", buf);
                poperror();
                return 0;
@@ -375,22 +242,21 @@ pprint(char *fmt, ...)
        return n;
 }
 
-void
-echo(Rune r, char *buf, int n)
+void echo(Rune r, char *buf, int n)
 {
-       if(kbd.raw)
+       if (kbd.raw)
                return;
 
-       if(r == '\n'){
-               if(printq)
+       if (r == '\n') {
+               if (printq)
                        qiwrite(printq, "\r", 1);
-       } else if(r == 0x15){
+       } else if (r == 0x15) {
                buf = "^U\n";
                n = 3;
        }
-       if(consoleprint && screenputs != NULL)
+       if (consoleprint && screenputs != NULL)
                screenputs(buf, n);
-       if(printq)
+       if (printq)
                qiwrite(printq, buf, n);
 }
 #endif
@@ -402,65 +268,61 @@ echo(Rune r, char *buf, int n)
  *     splhi, which can choke some device drivers (eg softmodem).
  */
 typedef struct {
-       Rune    r;
-       char    *m;
-       void    (*f)(Rune);
-       int     i;      /* function called at interrupt time */
+       Rune r;
+       char *m;
+       void (*f) (Rune);
+       int i;                                          /* function called at interrupt time */
 } Dbgkey;
 
 static struct {
        Rendez;
-       Dbgkey  *work;
-       Dbgkey  keys[50];
-       int     nkeys;
-       int     on;
+       Dbgkey *work;
+       Dbgkey keys[50];
+       int nkeys;
+       int on;
 } dbg;
 
-static Dbgkey *
-finddbgkey(Rune r)
+static Dbgkey *finddbgkey(Rune r)
 {
        int i;
        Dbgkey *dp;
 
-       for(dp = dbg.keys, i = 0; i < dbg.nkeys; i++, dp++)
-               if(dp->r == r)
+       for (dp = dbg.keys, i = 0; i < dbg.nkeys; i++, dp++)
+               if (dp->r == r)
                        return dp;
        return NULL;
 }
 
-static int
-dbgwork(void *)
+static int dbgwork(void *)
 {
        return dbg.work != 0;
 }
 
-static void
-dbgproc(void *)
+static void dbgproc(void *)
 {
        Dbgkey *dp;
 
        setpri(PriRealtime);
-       for(;;) {
+       for (;;) {
                do {
                        rendez_sleep(&dbg, dbgwork, 0);
                        dp = dbg.work;
-               } while(dp == NULL);
+               } while (dp == NULL);
                dp->f(dp->r);
                dbg.work = NULL;
        }
 }
 
-void
-debugkey(Rune r, char *msg, void (*fcn)(), int iflag)
+void debugkey(Rune r, char *msg, void (*fcn) (), int iflag)
 {
        Dbgkey *dp;
 
-       if(dbg.nkeys >= ARRAY_SIZE(dbg.keys))
+       if (dbg.nkeys >= ARRAY_SIZE(dbg.keys))
                return;
-       if(finddbgkey(r) != NULL)
+       if (finddbgkey(r) != NULL)
                return;
-       for(dp = &dbg.keys[dbg.nkeys++] - 1; dp >= dbg.keys; dp--) {
-               if(strcmp(dp->m, msg) < 0)
+       for (dp = &dbg.keys[dbg.nkeys++] - 1; dp >= dbg.keys; dp--) {
+               if (strcmp(dp->m, msg) < 0)
                        break;
                dp[1] = dp[0];
        }
@@ -471,8 +333,7 @@ debugkey(Rune r, char *msg, void (*fcn)(), int iflag)
        dp->i = iflag;
 }
 
-static int
-isdbgkey(Rune r)
+static int isdbgkey(Rune r)
 {
        static int ctrlt;
        Dbgkey *dp;
@@ -481,13 +342,13 @@ isdbgkey(Rune r)
        /*
         * ^t hack BUG
         */
-       if(dbg.on || (ctrlt >= 2)) {
-               if(r == 0x14 || r == 0x05) {
+       if (dbg.on || (ctrlt >= 2)) {
+               if (r == 0x14 || r == 0x05) {
                        ctrlt++;
                        return 0;
                }
-               if(dp = finddbgkey(r)) {
-                       if(dp->i || ctrlt > 2)
+               if (dp = finddbgkey(r)) {
+                       if (dp->i || ctrlt > 2)
                                dp->f(r);
                        else {
                                dbg.work = dp;
@@ -497,18 +358,16 @@ isdbgkey(Rune r)
                        return 1;
                }
                ctrlt = 0;
-       }
-       else if(r == 0x14){
+       } else if (r == 0x14) {
                ctrlt++;
                return 1;
-       }
-       else
+       } else
                ctrlt = 0;
-       if(echoctrlt){
+       if (echoctrlt) {
                char buf[3];
 
                buf[0] = 0x14;
-               while(--echoctrlt >= 0){
+               while (--echoctrlt >= 0) {
                        echo(buf[0], buf, 1);
                        qproduce(kbdq, buf, 1);
                }
@@ -516,15 +375,13 @@ isdbgkey(Rune r)
        return 0;
 }
 
-static void
-dbgtoggle(Rune)
+static void dbgtoggle(Rune)
 {
        dbg.on = !dbg.on;
        printd("Debug keys %s\n", dbg.on ? "HOT" : "COLD");
 }
 
-static void
-dbghelp(void)
+static void dbghelp(void)
 {
        int i;
        Dbgkey *dp;
@@ -532,19 +389,18 @@ dbghelp(void)
        static char fmt[] = "%c: %-22s";
 
        dp = dbg.keys;
-       dp2 = dp + (dbg.nkeys + 1)/2;
-       for(i = dbg.nkeys; i > 1; i -= 2, dp++, dp2++) {
+       dp2 = dp + (dbg.nkeys + 1) / 2;
+       for (i = dbg.nkeys; i > 1; i -= 2, dp++, dp2++) {
                printd(fmt, dp->r, dp->m);
                printd(fmt, dp2->r, dp2->m);
                printd("\n");
        }
-       if(i)
+       if (i)
                printd(fmt, dp->r, dp->m);
        printd("\n");
 }
 
-static void
-debuginit(void)
+static void debuginit(void)
 {
        ktask("consdbg", dbgproc, NULL);
        debugkey('|', "HOT|COLD keys", dbgtoggle, 0);
@@ -557,10 +413,9 @@ debuginit(void)
  *
  *  turn '\r' into '\n' before putting it into the queue.
  */
-int
-kbdcr2nl(struct queue *q, int ch)
+int kbdcr2nl(struct queue *q, int ch)
 {
-       if(ch == '\r')
+       if (ch == '\r')
                ch = '\n';
        return kbdputc(q, ch);
 }
@@ -570,8 +425,7 @@ kbdcr2nl(struct queue *q, int ch)
  *  Performs translation for compose sequences
  *  Called at interrupt time to process a character.
  */
-int
-kbdputc(struct queue *q, int ch)
+int kbdputc(struct queue *q, int ch)
 {
        int n;
        char buf[3];
@@ -580,59 +434,57 @@ kbdputc(struct queue *q, int ch)
        static int nk, collecting = 0;
 
        r = ch;
-       if(r == Latin) {
+       if (r == Latin) {
                collecting = 1;
                nk = 0;
                return 0;
        }
-       if(collecting) {
+       if (collecting) {
                int c;
-               nk += runetochar(( char *unused_char_p_t)&kc[nk], &r);
+               nk += runetochar((char *unused_char_p_t)&kc[nk], &r);
                c = latin1(kc, nk);
-               if(c < -1)      /* need more keystrokes */
+               if (c < -1)     /* need more keystrokes */
                        return 0;
                collecting = 0;
-               if(c == -1) {   /* invalid sequence */
-                       echo(kc[0], ( char *unused_char_p_t)kc, nk);
+               if (c == -1) {  /* invalid sequence */
+                       echo(kc[0], (char *unused_char_p_t)kc, nk);
                        qproduce(q, kc, nk);
                        return 0;
                }
-               r = (Rune)c;
+               r = (Rune) c;
        }
        kbd.c = r;
        n = runetochar(buf, &r);
-       if(n == 0)
+       if (n == 0)
                return 0;
-       if(!isdbgkey(r)) {
+       if (!isdbgkey(r)) {
                echo(r, buf, n);
                qproduce(q, buf, n);
        }
        return 0;
 }
 
-void
-kbdrepeat(int rep)
+void kbdrepeat(int rep)
 {
        kbd.repeat = rep;
        kbd.count = 0;
 }
 
-void
-kbdclock(void)
+void kbdclock(void)
 {
-       if(kbd.repeat == 0)
+       if (kbd.repeat == 0)
                return;
-       if(kbd.repeat==1 && ++kbd.count>HZ){
+       if (kbd.repeat == 1 && ++kbd.count > HZ) {
                kbd.repeat = 2;
                kbd.count = 0;
                return;
        }
-       if(++kbd.count&1)
+       if (++kbd.count & 1)
                kbdputc(kbdq, kbd.c);
 }
 #endif
 
-enum{
+enum {
        Qdir,
        Qcons,
        Qsysctl,
@@ -654,34 +506,32 @@ enum{
        Qjit,
 };
 
-static struct dirtab consdir[]=
-{
-       {".",   {Qdir, 0, QTDIR},       0,              DMDIR|0555},
-       {"cons",                {Qcons},        0,              0660},
-       {"consctl",     {Qconsctl},     0,              0220},
-       {"sysctl",      {Qsysctl},      0,              0644},
-       {"drivers",     {Qdrivers},     0,              0444},
-       {"hostowner",   {Qhostowner},   0,      0644},
-       {"keyboard",    {Qkeyboard},    0,              0666},
-       {"klog",                {Qklog},        0,              0444},
-       {"kprint",              {Qkprint},      0,              0444},
-       {"scancode",    {Qscancode},    0,              0444},
-       {"memory",      {Qmemory},      0,              0444},
-       {"msec",                {Qmsec},        NUMSIZE,        0444},
-       {"null",                {Qnull},        0,              0666},
-       {"random",      {Qrandom},      0,              0444},
-       {"notquiterandom", {Qnotquiterandom}, 0,        0444},
-       {"sysname",     {Qsysname},     0,              0664},
-       {"time",                {Qtime},        0,              0664},
-       {"user",                {Quser},        0,      0644},
-       {"jit",         {Qjit}, 0,      0666},
+static struct dirtab consdir[] = {
+       {".", {Qdir, 0, QTDIR}, 0, DMDIR | 0555},
+       {"cons", {Qcons}, 0, 0660},
+       {"consctl", {Qconsctl}, 0, 0220},
+       {"sysctl", {Qsysctl}, 0, 0644},
+       {"drivers", {Qdrivers}, 0, 0444},
+       {"hostowner", {Qhostowner}, 0, 0644},
+       {"keyboard", {Qkeyboard}, 0, 0666},
+       {"klog", {Qklog}, 0, 0444},
+       {"kprint", {Qkprint}, 0, 0444},
+       {"scancode", {Qscancode}, 0, 0444},
+       {"memory", {Qmemory}, 0, 0444},
+       {"msec", {Qmsec}, NUMSIZE, 0444},
+       {"null", {Qnull}, 0, 0666},
+       {"random", {Qrandom}, 0, 0444},
+       {"notquiterandom", {Qnotquiterandom}, 0, 0444},
+       {"sysname", {Qsysname}, 0, 0664},
+       {"time", {Qtime}, 0, 0664},
+       {"user", {Quser}, 0, 0644},
+       {"jit", {Qjit}, 0, 0666},
 };
 
-uint32_t       boottime;               /* seconds since epoch at boot */
+uint32_t boottime;                             /* seconds since epoch at boot */
 
 #if 0
-void
-fddump()
+void fddump()
 {
        struct proc *p;
        Osenv *o;
@@ -690,16 +540,15 @@ fddump()
 
        p = proctab(6);
        o = p->env;
-       for(i = 0; i <= o->fgrp->maxfd; i++) {
-               if((c = o->fgrp->fd[i]) == NULL)
+       for (i = 0; i <= o->fgrp->maxfd; i++) {
+               if ((c = o->fgrp->fd[i]) == NULL)
                        continue;
-               printd("%d: %s\n", i, c->name == NULL? "???": c->name->s);
+               printd("%d: %s\n", i, c->name == NULL ? "???" : c->name->s);
        }
 }
 #endif
 
-static void
-consinit(void)
+static void consinit(void)
 {
        randominit();
 #if 0
@@ -707,141 +556,136 @@ consinit(void)
        debugkey('f', "files/6", fddump, 0);
        debugkey('q', "panic", qpanic, 1);
        debugkey('r', "exit", rexit, 1);
-       klogq = qopen(128*1024, 0, 0, 0);
+       klogq = qopen(128 * 1024, 0, 0, 0);
 #endif
 }
 
-static struct chan*
-consattach(char *spec)
+static struct chan *consattach(char *spec)
 {
        return devattach('c', spec);
 }
 
-static struct walkqid*
-conswalk(struct chan *c, struct chan *nc, char **name, int nname)
+static struct walkqid *conswalk(struct chan *c, struct chan *nc, char **name,
+                                                               int nname)
 {
        return devwalk(c, nc, name, nname, consdir, ARRAY_SIZE(consdir), devgen);
 }
 
-static int
-consstat(struct chan *c, uint8_t *dp, int n)
+static int consstat(struct chan *c, uint8_t * dp, int n)
 {
        return devstat(c, dp, n, consdir, ARRAY_SIZE(consdir), devgen);
 }
 
 #if 0
-static void
-flushkbdline(struct queue *q)
+static void flushkbdline(struct queue *q)
 {
-       if(kbd.x){
+       if (kbd.x) {
                qwrite(q, kbd.line, kbd.x);
                kbd.x = 0;
        }
 }
 #endif
 
-static struct chan*
-consopen(struct chan *c, int omode)
+static struct chan *consopen(struct chan *c, int omode)
 {
        c->aux = 0;
 #if 0
-       switch((uint32_t)c->qid.path){
-       case Qconsctl:
-               if(!iseve())
-                       error(Eperm);
-               qlock(&(&kbd)->qlock);
-               kbd.ctl++;
-               qunlock(&(&kbd)->qlock);
-               break;
-
-       case Qkeyboard:
-               if((omode & 3) != OWRITE) {
+       switch ((uint32_t) c->qid.path) {
+               case Qconsctl:
+                       if (!iseve())
+                               error(Eperm);
                        qlock(&(&kbd)->qlock);
-                       kbd.kbdr++;
-                       flushkbdline(kbdq);
-                       kbd.raw = 1;
+                       kbd.ctl++;
                        qunlock(&(&kbd)->qlock);
-               }
-               break;
+                       break;
 
-       case Qscancode:
-               qlock(&(&kbd)->qlock);
-               if(kscanq || !kscanid) {
-                       qunlock(&(&kbd)->qlock);
-                       c->flag &= ~COPEN;
-                       if(kscanq)
-                               error(Einuse);
-                       else
-                               error(Ebadarg);
-               }
-               kscanq = qopen(256, 0, NULL, NULL);
-               qunlock(&(&kbd)->qlock);
-               break;
+               case Qkeyboard:
+                       if ((omode & 3) != OWRITE) {
+                               qlock(&(&kbd)->qlock);
+                               kbd.kbdr++;
+                               flushkbdline(kbdq);
+                               kbd.raw = 1;
+                               qunlock(&(&kbd)->qlock);
+                       }
+                       break;
 
-       case Qkprint:
-               if((omode & 3) != OWRITE) {
-                       wlock(&(&kprintq)->rwlock);
-                       if(kprintq.q != NULL){
-                               wunlock(&(&kprintq)->rwlock);
-                               error(Einuse);
+               case Qscancode:
+                       qlock(&(&kbd)->qlock);
+                       if (kscanq || !kscanid) {
+                               qunlock(&(&kbd)->qlock);
+                               c->flag &= ~COPEN;
+                               if (kscanq)
+                                       error(Einuse);
+                               else
+                                       error(Ebadarg);
                        }
-                       kprintq.q = qopen(32*1024, Qcoalesce, NULL, NULL);
-                       if(kprintq.q == NULL){
+                       kscanq = qopen(256, 0, NULL, NULL);
+                       qunlock(&(&kbd)->qlock);
+                       break;
+
+               case Qkprint:
+                       if ((omode & 3) != OWRITE) {
+                               wlock(&(&kprintq)->rwlock);
+                               if (kprintq.q != NULL) {
+                                       wunlock(&(&kprintq)->rwlock);
+                                       error(Einuse);
+                               }
+                               kprintq.q = qopen(32 * 1024, Qcoalesce, NULL, NULL);
+                               if (kprintq.q == NULL) {
+                                       wunlock(&(&kprintq)->rwlock);
+                                       error(Enomem);
+                               }
+                               qnoblock(kprintq.q, 1);
                                wunlock(&(&kprintq)->rwlock);
-                               error(Enomem);
+                               c->iounit = qiomaxatomic;
                        }
-                       qnoblock(kprintq.q, 1);
-                       wunlock(&(&kprintq)->rwlock);
-                       c->iounit = qiomaxatomic;
-               }
-               break;
+                       break;
        }
 #endif
        return devopen(c, omode, consdir, ARRAY_SIZE(consdir), devgen);
 }
 
-static void
-consclose(struct chan *c)
+static void consclose(struct chan *c)
 {
-       if((c->flag&COPEN) == 0)
+       if ((c->flag & COPEN) == 0)
                return;
 
-       switch((uint32_t)c->qid.path){
+       switch ((uint32_t) c->qid.path) {
 #if 0
-       case Qconsctl:
-               /* last close of control file turns off raw */
-               qlock(&(&kbd)->qlock);
-               if(--kbd.ctl == 0)
-                       kbd.raw = 0;
-               qunlock(&(&kbd)->qlock);
-               break;
-
-       case Qkeyboard:
-               if(c->mode != OWRITE) {
+               case Qconsctl:
+                       /* last close of control file turns off raw */
                        qlock(&(&kbd)->qlock);
-                       --kbd.kbdr;
+                       if (--kbd.ctl == 0)
+                               kbd.raw = 0;
                        qunlock(&(&kbd)->qlock);
-               }
-               break;
+                       break;
 
-       case Qscancode:
-               qlock(&(&kbd)->qlock);
-               if(kscanq) {
-                       qfree(kscanq);
-                       kscanq = 0;
-               }
-               qunlock(&(&kbd)->qlock);
-               break;
-
-       case Qkprint:
-               wlock(&(&kprintq)->rwlock);
-               qfree(kprintq.q);
-               kprintq.q = NULL;
-               wunlock(&(&kprintq)->rwlock);
-               break;
+               case Qkeyboard:
+                       if (c->mode != OWRITE) {
+                               qlock(&(&kbd)->qlock);
+                               --kbd.kbdr;
+                               qunlock(&(&kbd)->qlock);
+                       }
+                       break;
+
+               case Qscancode:
+                       qlock(&(&kbd)->qlock);
+                       if (kscanq) {
+                               qfree(kscanq);
+                               kscanq = 0;
+                       }
+                       qunlock(&(&kbd)->qlock);
+                       break;
+
+               case Qkprint:
+                       wlock(&(&kprintq)->rwlock);
+                       qfree(kprintq.q);
+                       kprintq.q = NULL;
+                       wunlock(&(&kprintq)->rwlock);
+                       break;
 #endif
-       default: 
-               break;
+               default:
+                       break;
        }
 }
 
@@ -850,7 +694,7 @@ consclose(struct chan *c)
  * out soon enough, you lost it. No real effort to ensure goodness
  * here as it can get called anywhere. Barret will fix it.
  */
-static uint8_t logbuffer[1<<20];
+static uint8_t logbuffer[1 << 20];
 static int index = 0;
 static struct queue *logqueue = NULL;
 static int reading_kmesg = 0;
@@ -858,13 +702,12 @@ void logbuf(int c)
 {
        if (reading_kmesg)
                return;
-       if (index > 1<<20)
+       if (index > 1 << 20)
                return;
        logbuffer[index++] = c;
 }
 
-static long
-consread(struct chan *c, void *buf, long n, int64_t offset)
+static long consread(struct chan *c, void *buf, long n, int64_t offset)
 {
        ERRSTACK(1);
        int l;
@@ -873,97 +716,97 @@ consread(struct chan *c, void *buf, long n, int64_t offset)
        char *p, tmp[128];
        char *cbuf = buf;
 
-       if(n <= 0)
+       if (n <= 0)
                return n;
 
-       switch((uint32_t)c->qid.path){
-       case Qdir:
-               return devdirread(c, buf, n, consdir, ARRAY_SIZE(consdir), devgen);
-       case Qsysctl:
-               return readstr(offset, buf, n, "akaros");
+       switch ((uint32_t) c->qid.path) {
+               case Qdir:
+                       return devdirread(c, buf, n, consdir, ARRAY_SIZE(consdir), devgen);
+               case Qsysctl:
+                       return readstr(offset, buf, n, "akaros");
 #if 0
-       case Qcons:
-       case Qkeyboard:
-               qlock(&(&kbd)->qlock);
-               if(waserror()) {
-                       qunlock(&(&kbd)->qlock);
-                       nexterror();
-               }
-               if(kbd.raw || kbd.kbdr) {
-                       if(qcanread(lineq))
-                               n = qread(lineq, buf, n);
-                       else {
-                               /* read as much as possible */
-                               do {
-                                       i = qread(kbdq, cbuf, n);
-                                       cbuf += i;
-                                       n -= i;
-                               } while(n>0 && qcanread(kbdq));
-                               n = cbuf - ( char *unused_char_p_t)buf;
+               case Qcons:
+               case Qkeyboard:
+                       qlock(&(&kbd)->qlock);
+                       if (waserror()) {
+                               qunlock(&(&kbd)->qlock);
+                               nexterror();
                        }
-               } else {
-                       while(!qcanread(lineq)) {
-                               qread(kbdq, &kbd.line[kbd.x], 1);
-                               ch = kbd.line[kbd.x];
-                               eol = 0;
-                               switch(ch){
-                               case '\b':
-                                       if(kbd.x)
-                                               kbd.x--;
-                                       break;
-                               case 0x15:
-                                       kbd.x = 0;
-                                       break;
-                               case '\n':
-                               case 0x04:
-                                       eol = 1;
-                               default:
-                                       kbd.line[kbd.x++] = ch;
-                                       break;
+                       if (kbd.raw || kbd.kbdr) {
+                               if (qcanread(lineq))
+                                       n = qread(lineq, buf, n);
+                               else {
+                                       /* read as much as possible */
+                                       do {
+                                               i = qread(kbdq, cbuf, n);
+                                               cbuf += i;
+                                               n -= i;
+                                       } while (n > 0 && qcanread(kbdq));
+                                       n = cbuf - (char *unused_char_p_t)buf;
                                }
-                               if(kbd.x == sizeof(kbd.line) || eol) {
-                                       if(ch == 0x04)
-                                               kbd.x--;
-                                       qwrite(lineq, kbd.line, kbd.x);
-                                       kbd.x = 0;
+                       } else {
+                               while (!qcanread(lineq)) {
+                                       qread(kbdq, &kbd.line[kbd.x], 1);
+                                       ch = kbd.line[kbd.x];
+                                       eol = 0;
+                                       switch (ch) {
+                                               case '\b':
+                                                       if (kbd.x)
+                                                               kbd.x--;
+                                                       break;
+                                               case 0x15:
+                                                       kbd.x = 0;
+                                                       break;
+                                               case '\n':
+                                               case 0x04:
+                                                       eol = 1;
+                                               default:
+                                                       kbd.line[kbd.x++] = ch;
+                                                       break;
+                                       }
+                                       if (kbd.x == sizeof(kbd.line) || eol) {
+                                               if (ch == 0x04)
+                                                       kbd.x--;
+                                               qwrite(lineq, kbd.line, kbd.x);
+                                               kbd.x = 0;
+                                       }
                                }
+                               n = qread(lineq, buf, n);
                        }
-                       n = qread(lineq, buf, n);
-               }
-               qunlock(&(&kbd)->qlock);
-               poperror();
-               return n;
+                       qunlock(&(&kbd)->qlock);
+                       poperror();
+                       return n;
 
-       case Qscancode:
-               if(offset == 0)
-                       return readstr(0, buf, n, kscanid);
-               else
-                       return qread(kscanq, buf, n);
+               case Qscancode:
+                       if (offset == 0)
+                               return readstr(0, buf, n, kscanid);
+                       else
+                               return qread(kscanq, buf, n);
 
-       case Qtime:
-               snprintf(tmp, sizeof(tmp), "%.lld", (int64_t)mseconds()*1000);
-               return readstr(offset, buf, n, tmp);
+               case Qtime:
+                       snprintf(tmp, sizeof(tmp), "%.lld", (int64_t) mseconds() * 1000);
+                       return readstr(offset, buf, n, tmp);
 
-       case Qhostowner:
-               return readstr(offset, buf, n, eve);
+               case Qhostowner:
+                       return readstr(offset, buf, n, eve);
 
-       case Quser:
-               return readstr(offset, buf, n, o->user);
+               case Quser:
+                       return readstr(offset, buf, n, o->user);
 
-       case Qjit:
-               snprintf(tmp, sizeof(tmp), "%d", cflag);
-               return readstr(offset, buf, n, tmp);
+               case Qjit:
+                       snprintf(tmp, sizeof(tmp), "%d", cflag);
+                       return readstr(offset, buf, n, tmp);
 #endif
-       case Qnull:
-               return 0;
+               case Qnull:
+                       return 0;
 #if 0
-       case Qmsec:
-               return readnum(offset, buf, n, TK2MS(MACHP(0)->ticks), NUMSIZE);
+               case Qmsec:
+                       return readnum(offset, buf, n, TK2MS(MACHP(0)->ticks), NUMSIZE);
 #endif
-       case Qsysname:
-               if(sysname == NULL)
-                       return 0;
-               return readstr(offset, buf, n, "Windows 95");
+               case Qsysname:
+                       if (sysname == NULL)
+                               return 0;
+                       return readstr(offset, buf, n, "Windows 95");
 
 /* not in akaros, inferno was a special case. 
        case Qnotquiterandom:
@@ -971,64 +814,64 @@ consread(struct chan *c, void *buf, long n, int64_t offset)
                return n;
 */
 
-       case Qrandom:
-               return randomread(buf, n);
+               case Qrandom:
+                       return randomread(buf, n);
 #if 0
-       case Qmemory:
-               return poolread(buf, n, offset);
+               case Qmemory:
+                       return poolread(buf, n, offset);
 #endif
-       case Qdrivers:
-               p = kzmalloc(READSTR, 0);
-               if(p == NULL)
-                       error(Enomem);
-               l = 0;
-               for(i = 0; &devtab[i] < __devtabend; i++)
-                       l += snprintf(p+l, READSTR-l, "#%c %s\n", devtab[i].dc,  devtab[i].name);
-               if(waserror()){
+               case Qdrivers:
+                       p = kzmalloc(READSTR, 0);
+                       if (p == NULL)
+                               error(Enomem);
+                       l = 0;
+                       for (i = 0; &devtab[i] < __devtabend; i++)
+                               l += snprintf(p + l, READSTR - l, "#%c %s\n", devtab[i].dc,
+                                                         devtab[i].name);
+                       if (waserror()) {
+                               kfree(p);
+                               nexterror();
+                       }
+                       n = readstr(offset, buf, n, p);
                        kfree(p);
-                       nexterror();
-               }
-               n = readstr(offset, buf, n, p);
-               kfree(p);
-               poperror();
-               return n;
-       case Qklog:
-               //return qread(klogq, buf, n);  
-               /* the queue gives us some elasticity for log reading. */
-               if (! logqueue)
-                       logqueue = qopen(1<<20, 0, 0, 0);
-               if (logqueue){
-                       int ret;
-                       /* atomic sets/gets are not that important in this case. */
-                       reading_kmesg = 1;
-                       qwrite(logqueue, logbuffer, index);
-                       index = 0;
-                       ret = qread(logqueue, buf, n);
-                       reading_kmesg = 0;
-                       return ret;
-               }
-               break;
+                       poperror();
+                       return n;
+               case Qklog:
+                       //return qread(klogq, buf, n);  
+                       /* the queue gives us some elasticity for log reading. */
+                       if (!logqueue)
+                               logqueue = qopen(1 << 20, 0, 0, 0);
+                       if (logqueue) {
+                               int ret;
+                               /* atomic sets/gets are not that important in this case. */
+                               reading_kmesg = 1;
+                               qwrite(logqueue, logbuffer, index);
+                               index = 0;
+                               ret = qread(logqueue, buf, n);
+                               reading_kmesg = 0;
+                               return ret;
+                       }
+                       break;
 #if 0
-       case Qkprint:
-               rlock(&(&kprintq)->rwlock);
-               if(waserror()){
+               case Qkprint:
+                       rlock(&(&kprintq)->rwlock);
+                       if (waserror()) {
+                               runlock(&(&kprintq)->rwlock);
+                               nexterror();
+                       }
+                       n = qread(kprintq.q, buf, n);
+                       poperror();
                        runlock(&(&kprintq)->rwlock);
-                       nexterror();
-               }
-               n = qread(kprintq.q, buf, n);
-               poperror();
-               runlock(&(&kprintq)->rwlock);
-               return n;
+                       return n;
 #endif
-       default:
-               printd("consread %llud\n", c->qid.path);
-               error(Egreg);
+               default:
+                       printd("consread %llu\n", c->qid.path);
+                       error(Egreg);
        }
-       return -1;              /* never reached */
+       return -1;      /* never reached */
 }
 
-static long
-conswrite(struct chan *c, void *va, long n, int64_t offset)
+static long conswrite(struct chan *c, void *va, long n, int64_t offset)
 {
        ERRSTACK(1);
        int64_t t;
@@ -1039,155 +882,155 @@ conswrite(struct chan *c, void *va, long n, int64_t offset)
        char buf[256];
        int x;
 
-       switch((uint32_t)c->qid.path){
+       switch ((uint32_t) c->qid.path) {
 #if 0
-       case Qcons:
-               /*
-                * Can't page fault in putstrn, so copy the data locally.
-                */
-               l = n;
-               while(l > 0){
-                       bp = l;
-                       if(bp > sizeof buf)
-                               bp = sizeof buf;
-                       memmove(buf, a, bp);
-                       putstrn0(a, bp, 1);
-                       a += bp;
-                       l -= bp;
-               }
-               break;
-
-       case Qconsctl:
-               if(n >= sizeof(buf))
-                       n = sizeof(buf)-1;
-               strncpy(buf, a, n);
-               buf[n] = 0;
-               for(a = buf; a;){
-                       if(strncmp(a, "rawon", 5) == 0){
-                               qlock(&(&kbd)->qlock);
-                               flushkbdline(kbdq);
-                               kbd.raw = 1;
-                               qunlock(&(&kbd)->qlock);
-                       } else if(strncmp(a, "rawoff", 6) == 0){
-                               qlock(&(&kbd)->qlock);
-                               kbd.raw = 0;
-                               kbd.x = 0;
-                               qunlock(&(&kbd)->qlock);
+               case Qcons:
+                       /*
+                        * Can't page fault in putstrn, so copy the data locally.
+                        */
+                       l = n;
+                       while (l > 0) {
+                               bp = l;
+                               if (bp > sizeof buf)
+                                       bp = sizeof buf;
+                               memmove(buf, a, bp);
+                               putstrn0(a, bp, 1);
+                               a += bp;
+                               l -= bp;
                        }
-                       if(a = strchr(a, ' '))
-                               a++;
-               }
-               break;
+                       break;
 
-       case Qkeyboard:
-               for(x=0; x<n; ) {
-                       Rune r;
-                       x += chartorune(&r, &a[x]);
-                       kbdputc(kbdq, r);
-               }
-               break;
-       
-       case Qtime:
-               if(n >= sizeof(buf))
-                       n = sizeof(buf)-1;
-               strncpy(buf, a, n);
-               buf[n] = 0;
-               t = strtoll(buf, 0, 0)/1000000;
-               boottime = t - TK2SEC(MACHP(0)->ticks);
-               break;
-
-       case Qhostowner:
-               if(!iseve())
-                       error(Eperm);
-               if(offset != 0 || n >= sizeof(buf))
-                       error(Ebadarg);
-               memmove(buf, a, n);
-               buf[n] = '\0';
-               if(n > 0 && buf[n-1] == '\n')
-                       buf[--n] = 0;
-               if(n <= 0)
-                       error(Ebadarg);
-               renameuser(eve, buf);
-               renameproguser(eve, buf);
-               kstrdup(&eve, buf);
-               kstrdup(&up->env->user, buf);
-               break;
-
-       case Quser:
-               if(!iseve())
-                       error(Eperm);
-               if(offset != 0)
-                       error(Ebadarg);
-               if(n <= 0 || n >= sizeof(buf))
-                       error(Ebadarg);
-               strncpy(buf, a, n);
-               buf[n] = 0;
-               if(buf[n-1] == '\n')
-                       buf[n-1] = 0;
-               kstrdup(&up->env->user, buf);
-               break;
-
-       case Qjit:
-               if(n >= sizeof(buf))
-                       n = sizeof(buf)-1;
-               strncpy(buf, va, n);
-               buf[n] = '\0';
-               x = atoi(buf);
-               if(x < 0 || x > 9)
-                       error(Ebadarg);
-               cflag = x;
-               return n;
+               case Qconsctl:
+                       if (n >= sizeof(buf))
+                               n = sizeof(buf) - 1;
+                       strncpy(buf, a, n);
+                       buf[n] = 0;
+                       for (a = buf; a;) {
+                               if (strncmp(a, "rawon", 5) == 0) {
+                                       qlock(&(&kbd)->qlock);
+                                       flushkbdline(kbdq);
+                                       kbd.raw = 1;
+                                       qunlock(&(&kbd)->qlock);
+                               } else if (strncmp(a, "rawoff", 6) == 0) {
+                                       qlock(&(&kbd)->qlock);
+                                       kbd.raw = 0;
+                                       kbd.x = 0;
+                                       qunlock(&(&kbd)->qlock);
+                               }
+                               if (a = strchr(a, ' '))
+                                       a++;
+                       }
+                       break;
 
-       case Qnull:
-               break;
-
-       case Qsysname:
-               if(offset != 0)
-                       error(Ebadarg);
-               if(n <= 0 || n >= sizeof(buf))
-                       error(Ebadarg);
-               strncpy(buf, a, n);
-               buf[n] = 0;
-               if(buf[n-1] == '\n')
-                       buf[n-1] = 0;
-               kstrdup(&sysname, buf);
-               break;
-
-       case Qsysctl:
-               if(!iseve())
-                       error(Eperm);
-               cb = parsecmd(a, n);
-               if(waserror()){
-                       kfree(cb);
-                       nexterror();
-               }
-               ct = lookupcmd(cb, sysctlcmd, ARRAY_SIZE(sysctlcmd));
-               switch(ct->index){
-               case CMreboot:
-                       reboot();
+               case Qkeyboard:
+                       for (x = 0; x < n;) {
+                               Rune r;
+                               x += chartorune(&r, &a[x]);
+                               kbdputc(kbdq, r);
+                       }
                        break;
-               case CMhalt:
-                       halt();
+
+               case Qtime:
+                       if (n >= sizeof(buf))
+                               n = sizeof(buf) - 1;
+                       strncpy(buf, a, n);
+                       buf[n] = 0;
+                       t = strtoll(buf, 0, 0) / 1000000;
+                       boottime = t - TK2SEC(MACHP(0)->ticks);
                        break;
-               case CMpanic:
-                       panic("sysctl");
-               case CMconsole:
-                       consoleprint = strcmp(cb->f[1], "off") != 0;
+
+               case Qhostowner:
+                       if (!iseve())
+                               error(Eperm);
+                       if (offset != 0 || n >= sizeof(buf))
+                               error(Ebadarg);
+                       memmove(buf, a, n);
+                       buf[n] = '\0';
+                       if (n > 0 && buf[n - 1] == '\n')
+                               buf[--n] = 0;
+                       if (n <= 0)
+                               error(Ebadarg);
+                       renameuser(eve, buf);
+                       renameproguser(eve, buf);
+                       kstrdup(&eve, buf);
+                       kstrdup(&up->env->user, buf);
                        break;
-               case CMbroken:
-                       keepbroken = 1;
+
+               case Quser:
+                       if (!iseve())
+                               error(Eperm);
+                       if (offset != 0)
+                               error(Ebadarg);
+                       if (n <= 0 || n >= sizeof(buf))
+                               error(Ebadarg);
+                       strncpy(buf, a, n);
+                       buf[n] = 0;
+                       if (buf[n - 1] == '\n')
+                               buf[n - 1] = 0;
+                       kstrdup(&up->env->user, buf);
                        break;
-               case CMnobroken:
-                       keepbroken = 0;
+
+               case Qjit:
+                       if (n >= sizeof(buf))
+                               n = sizeof(buf) - 1;
+                       strncpy(buf, va, n);
+                       buf[n] = '\0';
+                       x = atoi(buf);
+                       if (x < 0 || x > 9)
+                               error(Ebadarg);
+                       cflag = x;
+                       return n;
+
+               case Qnull:
+                       break;
+
+               case Qsysname:
+                       if (offset != 0)
+                               error(Ebadarg);
+                       if (n <= 0 || n >= sizeof(buf))
+                               error(Ebadarg);
+                       strncpy(buf, a, n);
+                       buf[n] = 0;
+                       if (buf[n - 1] == '\n')
+                               buf[n - 1] = 0;
+                       kstrdup(&sysname, buf);
+                       break;
+
+               case Qsysctl:
+                       if (!iseve())
+                               error(Eperm);
+                       cb = parsecmd(a, n);
+                       if (waserror()) {
+                               kfree(cb);
+                               nexterror();
+                       }
+                       ct = lookupcmd(cb, sysctlcmd, ARRAY_SIZE(sysctlcmd));
+                       switch (ct->index) {
+                               case CMreboot:
+                                       reboot();
+                                       break;
+                               case CMhalt:
+                                       halt();
+                                       break;
+                               case CMpanic:
+                                       panic("sysctl");
+                               case CMconsole:
+                                       consoleprint = strcmp(cb->f[1], "off") != 0;
+                                       break;
+                               case CMbroken:
+                                       keepbroken = 1;
+                                       break;
+                               case CMnobroken:
+                                       keepbroken = 0;
+                                       break;
+                       }
+                       poperror();
+                       kfree(cb);
                        break;
-               }
-               poperror();
-               kfree(cb);
-               break;
 #endif
-       default:
-               printd("conswrite: %llud\n", c->qid.path);
-               error(Egreg);
+               default:
+                       printd("conswrite: %llu\n", c->qid.path);
+                       error(Egreg);
        }
        return n;
 }
@@ -1211,34 +1054,32 @@ struct dev consdevtab __devtab = {
        devbwrite,
        devremove,
        devwstat,
+       devpower,
+       devchaninfo,
 };
 
-static uint32_t        randn;
+static uint32_t randn;
 
-static void
-seedrand(void)
+static void seedrand(void)
 {
-       randomread((void*)&randn, sizeof(randn));
+       randomread((void *)&randn, sizeof(randn));
 }
 
-int
-nrand(int n)
+int nrand(int n)
 {
-       if(randn == 0)
+       if (randn == 0)
                seedrand();
-       randn = randn*1103515245 + 12345 + read_tsc();
-       return (randn>>16) % n;
+       randn = randn * 1103515245 + 12345 + read_tsc();
+       return (randn >> 16) % n;
 }
 
-int
-rand(void)
+int rand(void)
 {
        nrand(1);
        return randn;
 }
 
-uint32_t
-truerand(void)
+uint32_t truerand(void)
 {
        uint32_t x;
 
@@ -1249,15 +1090,12 @@ truerand(void)
 /* TODO: qlock_init this, if you ever use this */
 qlock_t grandomlk;
 
-void
-_genrandomqlock(void)
+void _genrandomqlock(void)
 {
        qlock(&grandomlk);
 }
 
-
-void
-_genrandomqunlock(void)
+void _genrandomqunlock(void)
 {
        qunlock(&grandomlk);
 }