Print. Add printing for qids, cnams, and chans
[akaros.git] / kern / src / net / netlog.c
index 083825d..ee33e24 100644 (file)
-#include       "u.h"
-#include       "../port/lib.h"
-#include       "mem.h"
-#include       "dat.h"
-#include       "fns.h"
-#include       "../port/error.h"
-#include       "../ip/ip.h"
+// INFERNO
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 
 enum {
-       Nlog            = 4*1024,
+       Nlog = 4 * 1024,
 };
 
 /*
  *  action log
  */
 struct Netlog {
-       Lock;
-       int     opens;
-       char*   buf;
-       char    *end;
-       char    *rptr;
-       int     len;
-
-       int     logmask;                        /* mask of things to debug */
-       uchar   iponly[IPaddrlen];              /* ip address to print debugging for */
-       int     iponlyset;
-
-       QLock;
-       Rendez;
+       spinlock_t lock;
+       int opens;
+       char *buf;
+       char *end;
+       char *rptr;
+       int len;
+
+       int logmask;                            /* mask of things to debug */
+       uint8_t iponly[IPaddrlen];      /* ip address to print debugging for */
+       int iponlyset;
+
+       qlock_t qlock;
+       struct rendez r;
 };
 
 typedef struct Netlogflag {
-       char*   name;
-       int     mask;
+       char *name;
+       int mask;
 } Netlogflag;
 
-static Netlogflag flags[] =
-{
-       { "ppp",        Logppp, },
-       { "ip",         Logip, },
-       { "fs",         Logfs, },
-       { "tcp",        Logtcp, },
-       { "il",         Logil, },
-       { "icmp",       Logicmp, },
-       { "udp",        Logudp, },
-       { "compress",   Logcompress, },
-       { "ilmsg",      Logil|Logilmsg, },
-       { "gre",        Loggre, },
-       { "tcpwin",     Logtcp|Logtcpwin, },
-       { "tcprxmt",    Logtcp|Logtcprxmt, },
-       { "udpmsg",     Logudp|Logudpmsg, },
-       { "ipmsg",      Logip|Logipmsg, },
-       { "esp",        Logesp, },
-       { nil,          0, },
+static Netlogflag flags[] = {
+       {"ppp", Logppp,},
+       {"ip", Logip,},
+       {"fs", Logfs,},
+       {"tcp", Logtcp,},
+       {"il", Logil,},
+       {"icmp", Logicmp,},
+       {"udp", Logudp,},
+       {"compress", Logcompress,},
+       {"ilmsg", Logil | Logilmsg,},
+       {"gre", Loggre,},
+       {"tcpwin", Logtcp | Logtcpwin,},
+       {"tcprxmt", Logtcp | Logtcprxmt,},
+       {"udpmsg", Logudp | Logudpmsg,},
+       {"ipmsg", Logip | Logipmsg,},
+       {"esp", Logesp,},
+       {NULL, 0,},
 };
 
 char Ebadnetctl[] = "too few arguments for netlog control message";
 
-enum
-{
+enum {
        CMset,
        CMclear,
        CMonly,
 };
 
 static
-Cmdtab routecmd[] = {
-       CMset,          "set",          0,
-       CMclear,        "clear",        0,
-       CMonly,         "only",         0,
+struct cmdtab routecmd[] = {
+       {CMset, "set", 0},
+       {CMclear, "clear", 0},
+       {CMonly, "only", 0},
 };
 
-void
-netloginit(Fs *f)
+void netloginit(struct Fs *f)
 {
-       f->alog = smalloc(sizeof(Netlog));
+       f->alog = kzmalloc(sizeof(struct Netlog), 0);
+       spinlock_init(&f->alog->lock);
+       qlock_init(&f->alog->qlock);
+       rendez_init(&f->alog->r);
 }
 
-void
-netlogopen(Fs *f)
+void netlogopen(struct Fs *f)
 {
-       lock(f->alog);
-       if(waserror()){
-               unlock(f->alog);
+       ERRSTACK(1);
+       spin_lock(&f->alog->lock);
+       if (waserror()) {
+               spin_unlock(&f->alog->lock);
                nexterror();
        }
-       if(f->alog->opens == 0){
-               if(f->alog->buf == nil)
-                       f->alog->buf = malloc(Nlog);
+       if (f->alog->opens == 0) {
+               if (f->alog->buf == NULL)
+                       f->alog->buf = kzmalloc(Nlog, 0);
                f->alog->rptr = f->alog->buf;
                f->alog->end = f->alog->buf + Nlog;
        }
        f->alog->opens++;
-       unlock(f->alog);
+       spin_unlock(&f->alog->lock);
        poperror();
 }
 
-void
-netlogclose(Fs *f)
+void netlogclose(struct Fs *f)
 {
-       lock(f->alog);
-       if(waserror()){
-               unlock(f->alog);
+       ERRSTACK(1);
+       spin_lock(&f->alog->lock);
+       if (waserror()) {
+               spin_unlock(&f->alog->lock);
                nexterror();
        }
        f->alog->opens--;
-       if(f->alog->opens == 0){
-               free(f->alog->buf);
-               f->alog->buf = nil;
+       if (f->alog->opens == 0) {
+               kfree(f->alog->buf);
+               f->alog->buf = NULL;
        }
-       unlock(f->alog);
+       spin_unlock(&f->alog->lock);
        poperror();
 }
 
-static int
-netlogready(void *a)
+static int netlogready(void *a)
 {
-       Fs *f = a;
+       struct Fs *f = a;
 
        return f->alog->len;
 }
 
-long
-netlogread(Fs *f, void *a, ulong, long n)
+long netlogread(struct Fs *f, void *a, uint32_t unused, long n)
 {
+       ERRSTACK(1);
        int i, d;
        char *p, *rptr;
 
-       qlock(f->alog);
-       if(waserror()){
-               qunlock(f->alog);
+       qlock(&f->alog->qlock);
+       if (waserror()) {
+               qunlock(&f->alog->qlock);
                nexterror();
        }
 
-       for(;;){
-               lock(f->alog);
-               if(f->alog->len){
-                       if(n > f->alog->len)
+       for (;;) {
+               spin_lock(&f->alog->lock);
+               if (f->alog->len) {
+                       if (n > f->alog->len)
                                n = f->alog->len;
                        d = 0;
                        rptr = f->alog->rptr;
                        f->alog->rptr += n;
-                       if(f->alog->rptr >= f->alog->end){
+                       if (f->alog->rptr >= f->alog->end) {
                                d = f->alog->rptr - f->alog->end;
                                f->alog->rptr = f->alog->buf + d;
                        }
                        f->alog->len -= n;
-                       unlock(f->alog);
+                       spin_unlock(&f->alog->lock);
 
-                       i = n-d;
+                       i = n - d;
                        p = a;
                        memmove(p, rptr, i);
-                       memmove(p+i, f->alog->buf, d);
+                       memmove(p + i, f->alog->buf, d);
                        break;
-               }
-               else
-                       unlock(f->alog);
+               } else
+                       spin_unlock(&f->alog->lock);
 
-               rendez_sleep(f->alog, netlogready, f);
+               rendez_sleep(&f->alog->r, netlogready, f);
        }
 
-       qunlock(f->alog);
+       qunlock(&f->alog->qlock);
        poperror();
 
        return n;
 }
 
-void
-netlogctl(Fs *f, char* s, int n)
+void netlogctl(struct Fs *f, char *s, int n)
 {
-       int i, set;
+       ERRSTACK(1);
+       int i, set = 0;
        Netlogflag *fp;
-       Cmdbuf *cb;
-       Cmdtab *ct;
+       struct cmdbuf *cb;
+       struct cmdtab *ct;
 
        cb = parsecmd(s, n);
-       if(waserror()){
-               free(cb);
+       if (waserror()) {
+               kfree(cb);
                nexterror();
        }
 
-       if(cb->nf < 2)
+       if (cb->nf < 2)
                error(Ebadnetctl);
 
-       ct = lookupcmd(cb, routecmd, nelem(routecmd));
-
-       SET(set);
+       ct = lookupcmd(cb, routecmd, ARRAY_SIZE(routecmd));
 
-       switch(ct->index){
-       case CMset:
-               set = 1;
-               break;
-
-       case CMclear:
-               set = 0;
-               break;
+       switch (ct->index) {
+               case CMset:
+                       set = 1;
+                       break;
 
-       case CMonly:
-               parseip(f->alog->iponly, cb->f[1]);
-               if(ipcmp(f->alog->iponly, IPnoaddr) == 0)
-                       f->alog->iponlyset = 0;
-               else
-                       f->alog->iponlyset = 1;
-               free(cb);
-               return;
+               case CMclear:
+                       set = 0;
+                       break;
 
-       default:
-               cmderror(cb, "unknown ip control message");
+               case CMonly:
+                       parseip(f->alog->iponly, cb->f[1]);
+                       if (ipcmp(f->alog->iponly, IPnoaddr) == 0)
+                               f->alog->iponlyset = 0;
+                       else
+                               f->alog->iponlyset = 1;
+                       kfree(cb);
+                       poperror();
+                       return;
+
+               default:
+                       cmderror(cb, "unknown ip control message");
        }
 
-       for(i = 1; i < cb->nf; i++){
-               for(fp = flags; fp->name; fp++)
-                       if(strcmp(fp->name, cb->f[i]) == 0)
+       for (i = 1; i < cb->nf; i++) {
+               for (fp = flags; fp->name; fp++)
+                       if (strcmp(fp->name, cb->f[i]) == 0)
                                break;
-               if(fp->name == nil)
+               if (fp->name == NULL)
                        continue;
-               if(set)
+               if (set)
                        f->alog->logmask |= fp->mask;
                else
                        f->alog->logmask &= ~fp->mask;
        }
 
-       free(cb);
+       kfree(cb);
        poperror();
 }
 
-void
-netlog(Fs *f, int mask, char *fmt, ...)
+void netlog(struct Fs *f, int mask, char *fmt, ...)
 {
        char buf[128], *t, *fp;
        int i, n;
        va_list arg;
 
-       if(!(f->alog->logmask & mask))
+       if (!(f->alog->logmask & mask))
                return;
 
-       if(f->alog->opens == 0)
+       if (f->alog->opens == 0)
                return;
 
        va_start(arg, fmt);
-       n = vseprint(buf, buf+sizeof(buf), fmt, arg) - buf;
+       n = snprintf(buf, sizeof(buf), fmt, arg);
        va_end(arg);
 
-       lock(f->alog);
+       spin_lock(&f->alog->lock);
        i = f->alog->len + n - Nlog;
-       if(i > 0){
+       if (i > 0) {
                f->alog->len -= i;
                f->alog->rptr += i;
-               if(f->alog->rptr >= f->alog->end)
+               if (f->alog->rptr >= f->alog->end)
                        f->alog->rptr = f->alog->buf + (f->alog->rptr - f->alog->end);
        }
        t = f->alog->rptr + f->alog->len;
        fp = buf;
        f->alog->len += n;
-       while(n-- > 0){
-               if(t >= f->alog->end)
+       while (n-- > 0) {
+               if (t >= f->alog->end)
                        t = f->alog->buf + (t - f->alog->end);
                *t++ = *fp++;
        }
-       unlock(f->alog);
+       spin_unlock(&f->alog->lock);
 
-       rendez_wakeup(f->alog);
+       rendez_wakeup(&f->alog->r);
 }