Interim commit, compiles. We need to bring in support code now.
authorRonald G. Minnich <rminnich@google.com>
Thu, 16 Jan 2014 16:31:12 +0000 (08:31 -0800)
committerRonald G. Minnich <rminnich@google.com>
Thu, 16 Jan 2014 22:44:52 +0000 (14:44 -0800)
Signed-off-by: Ronald G. Minnich <rminnich@google.com>
kern/include/env.h
kern/include/ip.h
kern/include/ns.h
kern/include/setjmp.h
kern/src/Kbuild
kern/src/ns/Kbuild [new file with mode: 0644]
kern/src/ns/chan.c
kern/src/testing.c
scripts/PATCHPLAN9
scripts/fixincludes
scripts/spatch/typedef.cocci

index 838b3fb..68e93a1 100644 (file)
@@ -21,6 +21,7 @@
 #include <vfs.h>
 #include <schedule.h>
 #include <devalarm.h>
+#include <ns.h>
 
 TAILQ_HEAD(vcore_tailq, vcore);
 /* 'struct proc_list' declared in sched.h (not ideal...) */
@@ -83,6 +84,7 @@ struct proc {
        struct namespace                        *ns;
        struct fs_struct                        fs_env;
        struct files_struct                     open_files;
+       struct pgrp                             *pgrp;
 
        /* UCQ hashlocks */
        struct hashlock                         *ucq_hashlock;
index ef88455..311e860 100644 (file)
@@ -1,3 +1,4 @@
+// INFERNO
 //INFERNO
 
 typedef struct Conv    Conv;
@@ -77,7 +78,7 @@ enum
  */
 struct Conv
 {
-       QLock;
+       qlock_t qlock;
 
        int     x;                      /* conversation index */
        Proto*  p;
@@ -87,11 +88,11 @@ struct Conv
        uint    tos;                    /* type of service */
        int     ignoreadvice;           /* don't terminate connection on icmp errors */
 
-       uchar   ipversion;
-       uchar   laddr[IPaddrlen];       /* local IP address */
-       uchar   raddr[IPaddrlen];       /* remote IP address */
-       ushort  lport;                  /* local port number */
-       ushort  rport;                  /* remote port number */
+       uint8_t ipversion;
+       uint8_t laddr[IPaddrlen];       /* local IP address */
+       uint8_t raddr[IPaddrlen];       /* remote IP address */
+       uint16_t        lport;                  /* local port number */
+       uint16_t        rport;                  /* remote port number */
 
        char    *owner;                 /* protections */
        int     perm;
@@ -123,7 +124,7 @@ struct Conv
        void*   ptcl;                   /* protocol specific stuff */
 
        Route   *r;                     /* last route used */
-       ulong   rgen;                   /* routetable generation for *r */
+       uint32_t        rgen;                   /* routetable generation for *r */
 };
 
 struct Medium
@@ -133,32 +134,35 @@ struct Medium
        int     mintu;          /* default min mtu */
        int     maxtu;          /* default max mtu */
        int     maclen;         /* mac address length  */
-       void    (*bind)(Ipifc*, int, char**);
-       void    (*unbind)(Ipifc*);
-       void    (*bwrite)(Ipifc *ifc, Block *b, int version, uchar *ip);
+       void    (*bind)(struct ipifc *unused_ipifc, int unused_int, char **unused_char_pp_t);
+       void    (*unbind)(struct ipifc *unused_ipifc);
+       void    (*bwrite)(struct ipifc *ifc,
+                             struct block *b, int version, uint8_t *ip);
 
        /* for arming interfaces to receive multicast */
-       void    (*addmulti)(Ipifc *ifc, uchar *a, uchar *ia);
-       void    (*remmulti)(Ipifc *ifc, uchar *a, uchar *ia);
+       void    (*addmulti)(struct ipifc *ifc, uint8_t *a, uint8_t *ia);
+       void    (*remmulti)(struct ipifc *ifc, uint8_t *a, uint8_t *ia);
 
        /* process packets written to 'data' */
-       void    (*pktin)(Fs *f, Ipifc *ifc, Block *bp);
+       void    (*pktin)(struct fs *f, struct ipifc *ifc,
+                            struct block *bp);
 
        /* routes for router boards */
-       void    (*addroute)(Ipifc *ifc, int, uchar*, uchar*, uchar*, int);
-       void    (*remroute)(Ipifc *ifc, int, uchar*, uchar*);
-       void    (*flushroutes)(Ipifc *ifc);
+       void    (*addroute)(struct ipifc *ifc, int unused_int, uint8_t *unused_uint8_p_t, uint8_t*,
+                                uint8_t *unused_uint8_p_t, int);
+       void    (*remroute)(struct ipifc *ifc, int unused_int, uint8_t *unused_uint8_p_t, uint8_t *unused_uint8_p_t);
+       void    (*flushroutes)(struct ipifc *ifc);
 
        /* for routing multicast groups */
-       void    (*joinmulti)(Ipifc *ifc, uchar *a, uchar *ia);
-       void    (*leavemulti)(Ipifc *ifc, uchar *a, uchar *ia);
+       void    (*joinmulti)(struct ipifc *ifc, uint8_t *a, uint8_t *ia);
+       void    (*leavemulti)(struct ipifc *ifc, uint8_t *a, uint8_t *ia);
 
        /* address resolution */
-       void    (*ares)(Fs*, int, uchar*, uchar*, int, int);    /* resolve */
-       void    (*areg)(Ipifc*, uchar*);                        /* register */
+       void    (*ares)(struct fs*, int unused_int, uint8_t *unused_uint8_p_t, uint8_t*, int, int);     /* resolve */
+       void    (*areg)(struct ipifc *unused_ipifc, uint8_t *unused_uint8_p_t);                 /* register */
 
        /* v6 address generation */
-       void    (*pref2addr)(uchar *pref, uchar *ea);
+       void    (*pref2addr)(uint8_t *pref, uint8_t *ea);
 
        int     unbindonclose;  /* if non-zero, unbind on last close */
 };
@@ -166,29 +170,29 @@ struct Medium
 /* logical interface associated with a physical one */
 struct Iplifc
 {
-       uchar   local[IPaddrlen];
-       uchar   mask[IPaddrlen];
-       uchar   remote[IPaddrlen];
-       uchar   net[IPaddrlen];
-       uchar   tentative;      /* =1 => v6 dup disc on, =0 => confirmed unique */
-       uchar   onlink;         /* =1 => onlink, =0 offlink. */
-       uchar   autoflag;       /* v6 autonomous flag */
+       uint8_t local[IPaddrlen];
+       uint8_t mask[IPaddrlen];
+       uint8_t remote[IPaddrlen];
+       uint8_t net[IPaddrlen];
+       uint8_t tentative;      /* =1 => v6 dup disc on, =0 => confirmed unique */
+       uint8_t onlink;         /* =1 => onlink, =0 offlink. */
+       uint8_t autoflag;       /* v6 autonomous flag */
        long    validlt;        /* v6 valid lifetime */
        long    preflt;         /* v6 preferred lifetime */
        long    origint;        /* time when addr was added */
-       Iplink  *link;          /* addresses linked to this lifc */
-       Iplifc  *next;
+       struct Iplink   *link;          /* addresses linked to this lifc */
+       struct iplifc   *next;
 };
 
 /* binding twixt Ipself and Iplifc */
 struct Iplink
 {
-       Ipself  *self;
-       Iplifc  *lifc;
-       Iplink  *selflink;      /* next link for this local address */
-       Iplink  *lifclink;      /* next link for this ifc */
-       ulong   expire;
-       Iplink  *next;          /* free list */
+       struct Ipself   *self;
+       struct iplifc   *lifc;
+       struct Iplink   *selflink;      /* next link for this local address */
+       struct Iplink   *lifclink;      /* next link for this ifc */
+       uint32_t        expire;
+       struct Iplink   *next;          /* free list */
        int     ref;
 };
 
@@ -226,20 +230,20 @@ struct Ipifc
 
        /* these are used so that we can unbind on the fly */
        Lock    idlock;
-       uchar   ifcid;          /* incremented each 'bind/unbind/add/remove' */
+       uint8_t ifcid;          /* incremented each 'bind/unbind/add/remove' */
        int     ref;            /* number of proc's using this ipifc */
        Rendez  wait;           /* where unbinder waits for ref == 0 */
        int     unbinding;
 
-       uchar   mac[MAClen];    /* MAC address */
+       uint8_t mac[MAClen];    /* MAC address */
 
        Iplifc  *lifc;          /* logical interfaces on this physical one */
 
-       ulong   in, out;        /* message statistics */
-       ulong   inerr, outerr;  /* ... */
+       uint32_t        in, out;        /* message statistics */
+       uint32_t        inerr, outerr;  /* ... */
 
-       uchar   sendra6;        /* == 1 => send router advs on this ifc */
-       uchar   recvra6;        /* == 1 => recv router advs on this ifc */
+       uint8_t sendra6;        /* == 1 => send router advs on this ifc */
+       uint8_t recvra6;        /* == 1 => recv router advs on this ifc */
        Routerparams rp;        /* router parameters as in RFC 2461, pp.40--43. 
                                        used only if node is router */
 };
@@ -249,9 +253,9 @@ struct Ipifc
  */
 struct Ipmulti
 {
-       uchar   ma[IPaddrlen];
-       uchar   ia[IPaddrlen];
-       Ipmulti *next;
+       uint8_t ma[IPaddrlen];
+       uint8_t ia[IPaddrlen];
+       struct Ipmulti  *next;
 };
 
 /*
@@ -269,8 +273,8 @@ enum
 };
 struct Iphash
 {
-       Iphash  *next;
-       Conv    *c;
+       struct iphash   *next;
+       struct conv     *c;
        int     match;
 };
 struct Ipht
@@ -278,32 +282,32 @@ struct Ipht
        Lock;
        Iphash  *tab[Nipht];
 };
-void iphtadd(Ipht*, Conv*);
-void iphtrem(Ipht*, Conv*);
-Conv* iphtlook(Ipht *ht, uchar *sa, ushort sp, uchar *da, ushort dp);
+void iphtadd(struct Ipht*, struct conv*);
+void iphtrem(struct Ipht*, struct conv*);
+struct conv* iphtlook(struct Ipht *ht, uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp);
 
 /*
  *  one per multiplexed protocol
  */
 struct Proto
 {
-       QLock;
+       qlock_t qlock;
        char*           name;           /* protocol name */
        int             x;              /* protocol index */
        int             ipproto;        /* ip protocol type */
 
-       char*           (*connect)(Conv*, char**, int);
-       char*           (*announce)(Conv*, char**, int);
-       char*           (*bind)(Conv*, char**, int);
-       int             (*state)(Conv*, char*, int);
+       char*           (*connect)(Conv*, char **unused_char_pp_t, int);
+       char*           (*announce)(Conv*, char **unused_char_pp_t, int);
+       char*           (*bind)(Conv*, char **unused_char_pp_t, int);
+       int             (*state)(Conv*, char *unused_char_p_t, int);
        void            (*create)(Conv*);
        void            (*close)(Conv*);
        void            (*rcv)(Proto*, Ipifc*, Block*);
-       char*           (*ctl)(Conv*, char**, int);
-       void            (*advise)(Proto*, Block*, char*);
-       int             (*stats)(Proto*, char*, int);
-       int             (*local)(Conv*, char*, int);
-       int             (*remote)(Conv*, char*, int);
+       char*           (*ctl)(Conv*, char **unused_char_pp_t, int);
+       void            (*advise)(Proto*, Block*, char *unused_char_p_t);
+       int             (*stats)(Proto*, char *unused_char_p_t, int);
+       int             (*local)(Conv*, char *unused_char_p_t, int);
+       int             (*remote)(Conv*, char *unused_char_p_t, int);
        int             (*inuse)(Conv*);
        int             (*gc)(Proto*);  /* returns true if any conversations are freed */
 
@@ -313,8 +317,8 @@ struct Proto
        int             nc;             /* number of conversations */
        int             ac;
        Qid             qid;            /* qid for protocol directory */
-       ushort          nextport;
-       ushort          nextrport;
+       uint16_t                nextport;
+       uint16_t                nextrport;
 
        void            *priv;
 };
@@ -323,7 +327,7 @@ struct Proto
  *  Stream for sending packets to user level
  */
 struct IProuter {
-       QLock;
+       qlock_t qlock;
        int     opens;
        Queue   *q;
 };
@@ -362,36 +366,36 @@ struct Fs
 
 /* one per default router known to host */
 struct V6router {
-       uchar   inuse;
-       Ipifc   *ifc;
+       uint8_t inuse;
+       struct ipifc    *ifc;
        int     ifcid;
-       uchar   routeraddr[IPaddrlen];
+       uint8_t routeraddr[IPaddrlen];
        long    ltorigin;
-       Routerparams    rp;
+       struct routerparams     rp;
 };
 
 struct V6params
 {
-       Routerparams    rp;             /* v6 params, one copy per node now */
-       Hostparams      hp;
+       struct routerparams     rp;             /* v6 params, one copy per node now */
+       struct hostparams       hp;
        V6router        v6rlist[3];     /* max 3 default routers, currently */
        int             cdrouter;       /* uses only v6rlist[cdrouter] if   */ 
                                        /* cdrouter >= 0. */
 };
 
 
-int    Fsconnected(Conv*, char*);
-Conv*  Fsnewcall(Conv*, uchar*, ushort, uchar*, ushort, uchar);
-int    Fspcolstats(char*, int);
-int    Fsproto(Fs*, Proto*);
-int    Fsbuiltinproto(Fs*, uchar);
-Conv*  Fsprotoclone(Proto*, char*);
-Proto* Fsrcvpcol(Fs*, uchar);
-Proto* Fsrcvpcolx(Fs*, uchar);
-char*  Fsstdconnect(Conv*, char**, int);
-char*  Fsstdannounce(Conv*, char**, int);
-char*  Fsstdbind(Conv*, char**, int);
-ulong  scalednconv(void);
+int    Fsconnected(struct conv*, char *unused_char_p_t);
+struct conv*   Fsnewcall(struct conv*, uint8_t *unused_uint8_p_t, uint16_t, uint8_t*, uint16_t, uint8_t unused_uint8_t);
+int    Fspcolstats( char *unused_char_p_t, int);
+int    Fsproto(struct fs*, struct proto*);
+int    Fsbuiltinproto(struct fs*, uint8_t unused_uint8_t);
+struct conv*   Fsprotoclone(struct proto*, char *unused_char_p_t);
+struct proto*  Fsrcvpcol(struct fs*, uint8_t unused_uint8_t);
+struct proto*  Fsrcvpcolx(struct fs*, uint8_t unused_uint8_t);
+char*  Fsstdconnect(struct conv*, char **unused_char_pp_t, int);
+char*  Fsstdannounce(struct conv*, char **unused_char_pp_t, int);
+char*  Fsstdbind(struct conv*, char **unused_char_pp_t, int);
+uint32_t       scalednconv(void);
 
 /* 
  *  logging
@@ -418,17 +422,17 @@ enum
        Logtcpwin=      1<<18,
 };
 
-void   netloginit(Fs*);
-void   netlogopen(Fs*);
-void   netlogclose(Fs*);
-void   netlogctl(Fs*, char*, int);
-long   netlogread(Fs*, void*, ulong, long);
-void   netlog(Fs*, int, char*, ...);
-void   ifcloginit(Fs*);
-long   ifclogread(Fs*, Chan *,void*, ulong, long);
-void   ifclog(Fs*, uchar *, int);
-void   ifclogopen(Fs*, Chan*);
-void   ifclogclose(Fs*, Chan*);
+void   netloginit(struct fs*);
+void   netlogopen(struct fs*);
+void   netlogclose(struct fs*);
+void   netlogctl(struct fs*, char *unused_char_p_t, int);
+long   netlogread(struct fs*, void*, uint32_t, long);
+void   netlog(struct fs*, int unused_int, char *unused_char_p_t, ...);
+void   ifcloginit(struct fs*);
+long   ifclogread(struct fs*, struct chan *,void*, uint32_t, long);
+void   ifclog(struct fs*, uint8_t *, int);
+void   ifclogopen(struct fs*, struct chan*);
+void   ifclogclose(struct fs*, struct chan*);
 
 /*
  *  iproute.c
@@ -458,56 +462,59 @@ struct Routewalk
        char*   p;
        char*   e;
        void*   state;
-       void    (*walk)(Route*, Routewalk*);
+       void    (*walk)(struct route*, struct routewalk*);
 };
 
 struct RouteTree
 {
-       Route*  right;
-       Route*  left;
-       Route*  mid;
-       uchar   depth;
-       uchar   type;
-       uchar   ifcid;          /* must match ifc->id */
-       Ipifc   *ifc;
+       struct route*   right;
+       struct route*   left;
+       struct route*   mid;
+       uint8_t depth;
+       uint8_t type;
+       uint8_t ifcid;          /* must match ifc->id */
+       struct ipifc    *ifc;
        char    tag[4];
        int     ref;
 };
 
 struct V4route
 {
-       ulong   address;
-       ulong   endaddress;
-       uchar   gate[IPv4addrlen];
+       uint32_t        address;
+       uint32_t        endaddress;
+       uint8_t gate[IPv4addrlen];
 };
 
 struct V6route
 {
-       ulong   address[IPllen];
-       ulong   endaddress[IPllen];
-       uchar   gate[IPaddrlen];
+       uint32_t        address[IPllen];
+       uint32_t        endaddress[IPllen];
+       uint8_t gate[IPaddrlen];
 };
 
 struct Route
 {
-       RouteTree;
+       struct RouteTree;
 
        union {
-               V6route v6;
-               V4route v4;
+               struct V6route  v6;
+               struct V4route v4;
        };
 };
-extern void    v4addroute(Fs *f, char *tag, uchar *a, uchar *mask, uchar *gate, int type);
-extern void    v6addroute(Fs *f, char *tag, uchar *a, uchar *mask, uchar *gate, int type);
-extern void    v4delroute(Fs *f, uchar *a, uchar *mask, int dolock);
-extern void    v6delroute(Fs *f, uchar *a, uchar *mask, int dolock);
-extern Route*  v4lookup(Fs *f, uchar *a, Conv *c);
-extern Route*  v6lookup(Fs *f, uchar *a, Conv *c);
-extern long    routeread(Fs *f, char*, ulong, int);
-extern long    routewrite(Fs *f, Chan*, char*, int);
-extern void    routetype(int, char*);
-extern void    ipwalkroutes(Fs*, Routewalk*);
-extern void    convroute(Route*, uchar*, uchar*, uchar*, char*, int*);
+extern void    v4addroute(struct fs *f, char *tag, uint8_t *a, uint8_t *mask,
+                             uint8_t *gate, int type);
+extern void    v6addroute(struct fs *f, char *tag, uint8_t *a, uint8_t *mask,
+                             uint8_t *gate, int type);
+extern void    v4delroute(struct fs *f, uint8_t *a, uint8_t *mask, int dolock);
+extern void    v6delroute(struct fs *f, uint8_t *a, uint8_t *mask, int dolock);
+extern struct route*   v4lookup(struct fs *f, uint8_t *a, struct conv *c);
+extern struct route*   v6lookup(struct fs *f, uint8_t *a, struct conv *c);
+extern long    routeread(struct fs *f, char *unused_char_p_t, uint32_t, int);
+extern long    routewrite(struct fs *f, struct chan*, char *unused_char_p_t, int);
+extern void    routetype( int unused_int, char *unused_char_p_t);
+extern void    ipwalkroutes(struct fs*, struct routewalk*);
+extern void    convroute(struct route*, uint8_t *unused_uint8_p_t, uint8_t*,
+                        uint8_t *unused_uint8_p_t, char *unused_char_p_t, int*);
 
 /*
  *  devip.c
@@ -523,155 +530,161 @@ struct IPaux
        char    tag[4];
 };
 
-extern IPaux*  newipaux(char*, char*);
+extern struct IPaux*   newipaux( char *unused_char_p_t, char*);
 
 /*
  *  arp.c
  */
 struct Arpent
 {
-       uchar   ip[IPaddrlen];
-       uchar   mac[MAClen];
-       Medium  *type;                  /* media type */
-       Arpent* hash;
-       Block*  hold;
-       Block*  last;
-       uint    ctime;                  /* time entry was created or refreshed */
-       uint    utime;                  /* time entry was last used */
-       uchar   state;
-       Arpent  *nextrxt;               /* re-transmit chain */
-       uint    rtime;                  /* time for next retransmission */
-       uchar   rxtsrem;
-       Ipifc   *ifc;
-       uchar   ifcid;                  /* must match ifc->id */
-};
-
-extern void    arpinit(Fs*);
-extern int     arpread(Arp*, char*, ulong, int);
-extern int     arpwrite(Fs*, char*, int);
-extern Arpent* arpget(Arp*, Block *bp, int version, Ipifc *ifc, uchar *ip, uchar *h);
-extern void    arprelease(Arp*, Arpent *a);
-extern Block*  arpresolve(Arp*, Arpent *a, Medium *type, uchar *mac);
-extern void    arpenter(Fs*, int version, uchar *ip, uchar *mac, int len, int norefresh);
+       uint8_t ip[IPaddrlen];
+       uint8_t mac[MAClen];
+       struct medium   *type;                  /* media type */
+       struct arpent*  hash;
+       struct block*   hold;
+       struct block*   last;
+       unsigned int    ctime;                  /* time entry was created or refreshed */
+       unsigned int    utime;                  /* time entry was last used */
+       uint8_t state;
+       struct arpent   *nextrxt;               /* re-transmit chain */
+       unsigned int    rtime;                  /* time for next retransmission */
+       uint8_t rxtsrem;
+       struct ipifc    *ifc;
+       uint8_t ifcid;                  /* must match ifc->id */
+};
+
+extern void    arpinit(struct fs*);
+extern int     arpread(struct arp*, char *unused_char_p_t, uint32_t, int);
+extern int     arpwrite(struct fs*, char *unused_char_p_t, int);
+extern struct arpent*  arpget(struct arp*, struct block *bp, int version, struct ipifc *ifc, uint8_t *ip,
+                            uint8_t *h);
+extern void    arprelease(struct arp*, struct arpent *a);
+extern struct block*   arpresolve(struct arp*, struct arpent *a,
+                               struct medium *type, uint8_t *mac);
+extern void    arpenter(struct fs*, int version, uint8_t *ip,
+                           uint8_t *mac, int len, int norefresh);
 
 /*
  * ipaux.c
  */
 
-extern int     myetheraddr(uchar*, char*);
-extern ulong   parseip(uchar*, char*);
-extern ulong   parseipmask(uchar*, char*);
-extern char*   v4parseip(uchar*, char*);
-extern void    maskip(uchar *from, uchar *mask, uchar *to);
-extern int     parsemac(uchar *to, char *from, int len);
-extern uchar*  defmask(uchar*);
-extern int     isv4(uchar*);
-extern void    v4tov6(uchar *v6, uchar *v4);
-extern int     v6tov4(uchar *v4, uchar *v6);
+extern int     myetheraddr( uint8_t *unused_uint8_p_t, char *unused_char_p_t);
+extern uint32_t        parseip( uint8_t *unused_uint8_p_t, char *unused_char_p_t);
+extern uint32_t        parseipmask( uint8_t *unused_uint8_p_t, char *unused_char_p_t);
+extern char*   v4parseip( uint8_t *unused_uint8_p_t, char *unused_char_p_t);
+extern void    maskip(uint8_t *from, uint8_t *mask, uint8_t *to);
+extern int     parsemac(uint8_t *to, char *from, int len);
+extern uint8_t*        defmask( uint8_t *unused_uint8_p_t);
+extern int     isv4( uint8_t *unused_uint8_p_t);
+extern void    v4tov6(uint8_t *v6, uint8_t *v4);
+extern int     v6tov4(uint8_t *v4, uint8_t *v6);
 extern int     eipfmt(Fmt*);
 
 #define        ipmove(x, y) memmove(x, y, IPaddrlen)
 #define        ipcmp(x, y) ( (x)[IPaddrlen-1] != (y)[IPaddrlen-1] || memcmp(x, y, IPaddrlen) )
 
-extern uchar IPv4bcast[IPaddrlen];
-extern uchar IPv4bcastobs[IPaddrlen];
-extern uchar IPv4allsys[IPaddrlen];
-extern uchar IPv4allrouter[IPaddrlen];
-extern uchar IPnoaddr[IPaddrlen];
-extern uchar v4prefix[IPaddrlen];
-extern uchar IPallbits[IPaddrlen];
+extern uint8_t IPv4bcast[IPaddrlen];
+extern uint8_t IPv4bcastobs[IPaddrlen];
+extern uint8_t IPv4allsys[IPaddrlen];
+extern uint8_t IPv4allrouter[IPaddrlen];
+extern uint8_t IPnoaddr[IPaddrlen];
+extern uint8_t v4prefix[IPaddrlen];
+extern uint8_t IPallbits[IPaddrlen];
 
 #define        NOW     TK2MS(MACHP(0)->ticks)
 
 /*
  *  media
  */
-extern Medium  ethermedium;
-extern Medium  nullmedium;
-extern Medium  pktmedium;
-extern Medium  tripmedium;
+extern struct medium   ethermedium;
+extern struct medium   nullmedium;
+extern struct medium   pktmedium;
+extern struct medium   tripmedium;
 
 /*
  *  ipifc.c
  */
-extern Medium* ipfindmedium(char *name);
-extern void    addipmedium(Medium *med);
-extern int     ipforme(Fs*, uchar *addr);
-extern int     iptentative(Fs*, uchar *addr);
-extern int     ipisbm(uchar *);
-extern int     ipismulticast(uchar *);
-extern Ipifc*  findipifc(Fs*, uchar *remote, int type);
-extern void    findprimaryip(Fs*, uchar*);
-extern void    findlocalip(Fs*, uchar *local, uchar *remote);
-extern int     ipv4local(Ipifc *ifc, uchar *addr);
-extern int     ipv6local(Ipifc *ifc, uchar *addr);
-extern int     ipv6anylocal(Ipifc *ifc, uchar *addr);
-extern Iplifc* iplocalonifc(Ipifc *ifc, uchar *ip);
-extern int     ipproxyifc(Fs *f, Ipifc *ifc, uchar *ip);
-extern int     ipismulticast(uchar *ip);
+extern struct medium*  ipfindmedium(char *name);
+extern void    addipmedium(struct medium *med);
+extern int     ipforme(struct fs*, uint8_t *addr);
+extern int     iptentative(struct fs*, uint8_t *addr);
+extern int     ipisbm(uint8_t *);
+extern int     ipismulticast(uint8_t *);
+extern struct ipifc*   findipifc(struct fs*, uint8_t *remote, int type);
+extern void    findprimaryip(struct fs*, uint8_t *unused_uint8_p_t);
+extern void    findlocalip(struct fs*, uint8_t *local, uint8_t *remote);
+extern int     ipv4local(struct ipifc *ifc, uint8_t *addr);
+extern int     ipv6local(struct ipifc *ifc, uint8_t *addr);
+extern int     ipv6anylocal(struct ipifc *ifc, uint8_t *addr);
+extern struct iplifc*  iplocalonifc(struct ipifc *ifc, uint8_t *ip);
+extern int     ipproxyifc(struct fs *f, struct ipifc *ifc, uint8_t *ip);
+extern int     ipismulticast(uint8_t *ip);
 extern int     ipisbooting(void);
-extern int     ipifccheckin(Ipifc *ifc, Medium *med);
-extern void    ipifccheckout(Ipifc *ifc);
-extern int     ipifcgrab(Ipifc *ifc);
-extern void    ipifcaddroute(Fs*, int, uchar*, uchar*, uchar*, int);
-extern void    ipifcremroute(Fs*, int, uchar*, uchar*);
-extern void    ipifcremmulti(Conv *c, uchar *ma, uchar *ia);
-extern void    ipifcaddmulti(Conv *c, uchar *ma, uchar *ia);
-extern char*   ipifcrem(Ipifc *ifc, char **argv, int argc);
-extern char*   ipifcadd(Ipifc *ifc, char **argv, int argc, int tentative, Iplifc *lifcp);
-extern long    ipselftabread(Fs*, char *a, ulong offset, int n);
-extern char*   ipifcaddpref6(Ipifc *ifc, char**argv, int argc);
-extern void    ipsendra6(Fs *f, int on);
+extern int     ipifccheckin(struct ipifc *ifc, struct medium *med);
+extern void    ipifccheckout(struct ipifc *ifc);
+extern int     ipifcgrab(struct ipifc *ifc);
+extern void    ipifcaddroute(struct fs*, int unused_int, uint8_t *unused_uint8_p_t, uint8_t*, uint8_t*, int);
+extern void    ipifcremroute(struct fs*, int unused_int, uint8_t *unused_uint8_p_t, uint8_t *unused_uint8_p_t);
+extern void    ipifcremmulti(struct conv *c, uint8_t *ma, uint8_t *ia);
+extern void    ipifcaddmulti(struct conv *c, uint8_t *ma, uint8_t *ia);
+extern char*   ipifcrem(struct ipifc *ifc, char **argv, int argc);
+extern char*   ipifcadd(struct ipifc *ifc, char **argv, int argc, int tentative,
+                            struct iplifc *lifcp);
+extern long    ipselftabread(struct fs*, char *a, uint32_t offset, int n);
+extern char*   ipifcaddpref6(struct ipifc *ifc, char**argv, int argc);
+extern void    ipsendra6(struct fs *f, int on);
 
 /*
  *  ip.c
  */
-extern void    iprouting(Fs*, int);
-extern void    icmpnoconv(Fs*, Block*);
-extern void    icmpcantfrag(Fs*, Block*, int);
-extern void    icmpttlexceeded(Fs*, uchar*, Block*);
-extern ushort  ipcsum(uchar*);
-extern void    ipiput4(Fs*, Ipifc*, Block*);
-extern void    ipiput6(Fs*, Ipifc*, Block*);
-extern int     ipoput4(Fs*, Block*, int, int, int, Conv*);
-extern int     ipoput6(Fs*, Block*, int, int, int, Conv*);
-extern int     ipstats(Fs*, char*, int);
-extern ushort  ptclbsum(uchar*, int);
-extern ushort  ptclcsum(Block*, int, int);
-extern void    ip_init(Fs*);
-extern void    update_mtucache(uchar*, ulong);
-extern ulong   restrict_mtu(uchar*, ulong);
+extern void    iprouting(struct fs*, int);
+extern void    icmpnoconv(struct fs*, struct block*);
+extern void    icmpcantfrag(struct fs*, struct block*, int);
+extern void    icmpttlexceeded(struct fs*, uint8_t *unused_uint8_p_t, struct block*);
+extern uint16_t        ipcsum( uint8_t *unused_uint8_p_t);
+extern void    ipiput4(struct fs*, struct ipifc *unused_ipifc, struct block*);
+extern void    ipiput6(struct fs*, struct ipifc *unused_ipifc, struct block*);
+extern int     ipoput4(struct fs*,
+                         struct block*, int unused_int, int, int, struct conv*);
+extern int     ipoput6(struct fs*,
+                         struct block*, int unused_int, int, int, struct conv*);
+extern int     ipstats(struct fs*, char *unused_char_p_t, int);
+extern uint16_t        ptclbsum( uint8_t *unused_uint8_p_t, int);
+extern uint16_t        ptclcsum(struct block*, int unused_int, int);
+extern void    ip_init(struct fs*);
+extern void    update_mtucache( uint8_t *unused_uint8_p_t, uint32_t);
+extern uint32_t        restrict_mtu( uint8_t *unused_uint8_p_t, uint32_t);
 
 /*
  * bootp.c
  */
-char*  (*bootp)(Ipifc*);
-int    (*bootpread)(char*, ulong, int);
+char*  (*bootp)(struct ipifc *unused_ipifc);
+int    (*bootpread)( char *unused_char_p_t, uint32_t, int);
 
 /*
  *  iprouter.c
  */
-void   useriprouter(Fs*, Ipifc*, Block*);
-void   iprouteropen(Fs*);
-void   iprouterclose(Fs*);
-long   iprouterread(Fs*, void*, int);
+void   useriprouter(struct fs*, struct ipifc *unused_ipifc, struct block*);
+void   iprouteropen(struct fs*);
+void   iprouterclose(struct fs*);
+long   iprouterread(struct fs*, void*, int);
 
 /*
  *  resolving inferno/plan9 differences
  */
-Chan*          commonfdtochan(int, int, int, int);
+struct chan*           commonfdtochan( int unused_int, int, int, int);
 char*          commonuser(void);
 char*          commonerror(void);
 
 /*
  * chandial.c
  */
-extern Chan*   chandial(char*, char*, char*, Chan**);
+extern struct chan*    chandial( char *unused_char_p_t, char*, char*, struct chan**);
 
 /*
  *  global to all of the stack
  */
-extern void    (*igmpreportfn)(Ipifc*, uchar*);
+extern void    (*igmpreportfn)(struct ipifc *unused_ipifc, uint8_t *unused_uint8_p_t);
 
 /* IPV6 */
 #define MIN(a, b) ((a) <= (b) ? (a) : (b))
@@ -693,31 +706,31 @@ typedef struct Routinghdr Routinghdr;
 typedef struct Fraghdr6    Fraghdr6;
 
 struct Ip6hdr {
-       uchar vcf[4];           // version:4, traffic class:8, flow label:20
-       uchar ploadlen[2];      // payload length: packet length - 40
-       uchar proto;            // next header type
-       uchar ttl;              // hop limit
-       uchar src[IPaddrlen];
-       uchar dst[IPaddrlen];
+       uint8_t vcf[4];         // version:4, traffic class:8, flow label:20
+       uint8_t ploadlen[2];    // payload length: packet length - 40
+       uint8_t proto;          // next header type
+       uint8_t ttl;            // hop limit
+       uint8_t src[IPaddrlen];
+       uint8_t dst[IPaddrlen];
 };
 
 struct Opthdr {
-       uchar nexthdr;
-       uchar len;
+       uint8_t nexthdr;
+       uint8_t len;
 };
 
 struct Routinghdr {
-       uchar nexthdr;
-       uchar len;
-       uchar rtetype;
-       uchar segrem;
+       uint8_t nexthdr;
+       uint8_t len;
+       uint8_t rtetype;
+       uint8_t segrem;
 };
 
 struct Fraghdr6 {
-       uchar nexthdr;
-       uchar res;
-       uchar offsetRM[2];      // Offset, Res, M flag
-       uchar id[4];
+       uint8_t nexthdr;
+       uint8_t res;
+       uint8_t offsetRM[2];    // Offset, Res, M flag
+       uint8_t id[4];
 };
 
 
@@ -823,32 +836,37 @@ enum {
 
 };
 
-extern void ipv62smcast(uchar *, uchar *);
-extern void icmpns(Fs *f, uchar* src, int suni, uchar* targ, int tuni, uchar* mac);
-extern void icmpna(Fs *f, uchar* src, uchar* dst, uchar* targ, uchar* mac, uchar flags);
-extern void icmpttlexceeded6(Fs *f, Ipifc *ifc, Block *bp);
-extern void icmppkttoobig6(Fs *f, Ipifc *ifc, Block *bp);
-extern void icmphostunr(Fs *f, Ipifc *ifc, Block *bp, int code, int free);
-
-extern uchar v6allnodesN[IPaddrlen];
-extern uchar v6allnodesL[IPaddrlen];
-extern uchar v6allroutersN[IPaddrlen];
-extern uchar v6allroutersL[IPaddrlen];
-extern uchar v6allnodesNmask[IPaddrlen];
-extern uchar v6allnodesLmask[IPaddrlen];
-extern uchar v6allroutersS[IPaddrlen];
-extern uchar v6solicitednode[IPaddrlen];
-extern uchar v6solicitednodemask[IPaddrlen];
-extern uchar v6Unspecified[IPaddrlen];
-extern uchar v6loopback[IPaddrlen];
-extern uchar v6loopbackmask[IPaddrlen];
-extern uchar v6linklocal[IPaddrlen];
-extern uchar v6linklocalmask[IPaddrlen];
-extern uchar v6sitelocal[IPaddrlen];
-extern uchar v6sitelocalmask[IPaddrlen];
-extern uchar v6glunicast[IPaddrlen];
-extern uchar v6multicast[IPaddrlen];
-extern uchar v6multicastmask[IPaddrlen];
+extern void ipv62smcast(uint8_t *, uint8_t *);
+extern void icmpns(struct fs *f, uint8_t* src, int suni, uint8_t* targ, int tuni,
+                  uint8_t* mac);
+extern void icmpna(struct fs *f, uint8_t* src, uint8_t* dst, uint8_t* targ, uint8_t* mac,
+                  uint8_t flags);
+extern void icmpttlexceeded6(struct fs *f, struct ipifc *ifc,
+                            struct block *bp);
+extern void icmppkttoobig6(struct fs *f, struct ipifc *ifc, struct block *bp);
+extern void icmphostunr(struct fs *f,
+                       struct ipifc *ifc,
+                       struct block *bp, int code, int free);
+
+extern uint8_t v6allnodesN[IPaddrlen];
+extern uint8_t v6allnodesL[IPaddrlen];
+extern uint8_t v6allroutersN[IPaddrlen];
+extern uint8_t v6allroutersL[IPaddrlen];
+extern uint8_t v6allnodesNmask[IPaddrlen];
+extern uint8_t v6allnodesLmask[IPaddrlen];
+extern uint8_t v6allroutersS[IPaddrlen];
+extern uint8_t v6solicitednode[IPaddrlen];
+extern uint8_t v6solicitednodemask[IPaddrlen];
+extern uint8_t v6Unspecified[IPaddrlen];
+extern uint8_t v6loopback[IPaddrlen];
+extern uint8_t v6loopbackmask[IPaddrlen];
+extern uint8_t v6linklocal[IPaddrlen];
+extern uint8_t v6linklocalmask[IPaddrlen];
+extern uint8_t v6sitelocal[IPaddrlen];
+extern uint8_t v6sitelocalmask[IPaddrlen];
+extern uint8_t v6glunicast[IPaddrlen];
+extern uint8_t v6multicast[IPaddrlen];
+extern uint8_t v6multicastmask[IPaddrlen];
 
 extern int v6llpreflen;
 extern int v6slpreflen;
index 545778d..3bef58b 100644 (file)
-//INFERNO
-#pragma src "/usr/inferno/lib9"
-#pragma        lib     "libc.a"
+// INFERNO
+
+/* error stacks, as defined by us. These are a new implementation. */
+/* add 1 in case they forget they need an entry for the passed-in errbuf */
+#include <setjmp.h>
+struct errbuf *get_cur_errbuf(void);
+void set_cur_errbuf(struct errbuf *ebuf);
+
+struct errbuf {
+       struct jmpbuf jmpbuf;
+};
+
+#define ERRSTACK(x) struct errbuf *prev_errbuf; struct errbuf errstack[(x)];   \
+                    int curindex = 0;
+#define waserror() (errpush(errstack, ARRAY_SIZE(errstack), &curindex,         \
+                            &prev_errbuf) ||                                   \
+                    setjmp(&(get_cur_errbuf()->jmpbuf)))
+#define error(x,...) {set_errstr(x, ##__VA_ARGS__);                            \
+                      longjmp(&get_cur_errbuf()->jmpbuf, (void *)x);}
+#define nexterror() {errpop(errstack, ARRAY_SIZE(errstack), &curindex,         \
+                            prev_errbuf);                                      \
+                     longjmp(&(get_cur_errbuf())->jmpbuf, (void *)1);}
+#define poperror() {errpop(errstack, ARRAY_SIZE(errstack), &curindex,          \
+                           prev_errbuf);}
+
+
+/*
+ * functions (possibly) linked in, complete, from libc.
+ */
+#define ARRAY_SIZE(x)  (sizeof(x)/sizeof((x)[0]))
+
+enum
+{
+       UTFmax          = 4,            /* maximum bytes per rune */
+       Runesync        = 0x80,         /* cannot represent part of a UTF sequence (<) */
+       Runeself        = 0x80,         /* rune and UTF sequences are the same (<) */
+       Runeerror       = 0xFFFD,       /* decoding error in UTF */
+       Runemax         = 0x10FFFF,     /* 21-bit rune */
+       Runemask        = 0x1FFFFF,     /* bits used by runes (see grep) */
+};
+
+extern int     abs(int);
+
+/*
+ * math
+ */
+extern int     isNaN(double);
+extern int     isInf(double, int);
+extern double  floor(double);
+extern double  frexp(double, int*);
+extern double  pow10(int);
+
+/*
+ * one-of-a-kind
+ */
+extern char*   cleanname( char *unused_char_p_t);
+extern uint32_t        getcallerpc(void*);
+
+extern char    etext[];
+extern char    edata[];
+extern char    end[];
+extern int     getfields( char *unused_char_p_t, char **unused_char_pp_t, int unused_int, int, char*);
+extern int     tokenize( char *unused_char_p_t, char **unused_char_pp_t, int);
+extern int     dec64( uint8_t *unused_uint8_p_t, int unused_int, char *unused_char_p_t, int);
+extern void    qsort(void*, long, long, int (*)(void*, void*));
+
+extern int     toupper(int);
+extern char*   netmkaddr( char *unused_char_p_t, char*, char*);
+extern int     myetheraddr( uint8_t *unused_uint8_p_t, char *unused_char_p_t);
+extern int     parseether( uint8_t *unused_uint8_p_t, char *unused_char_p_t);
+
+/*
+ * network dialling
+ */
+#define        NETPATHLEN      40
+
+/*
+ * Syscall data structures
+ */
+#define        MORDER  0x0003  /* mask for bits defining order of mounting */
+#define        MREPL   0x0000  /* mount replaces object */
+#define        MBEFORE 0x0001  /* mount goes before others in union directory */
+#define        MAFTER  0x0002  /* mount goes after others in union directory */
+#define        MCREATE 0x0004  /* permit creation in mounted directory */
+#define        MCACHE  0x0010  /* cache some data */
+#define        MMASK   0x0017  /* all bits on */
+
+#define        OREAD   0       /* open for read */
+#define        OWRITE  1       /* write */
+#define        ORDWR   2       /* read and write */
+#define        OEXEC   3       /* execute, == read but check execute permission */
+#define        OTRUNC  16      /* or'ed in (except for exec), truncate file first */
+#define        OCEXEC  32      /* or'ed in, close on exec */
+#define        ORCLOSE 64      /* or'ed in, remove on close */
+#define OEXCL   0x1000 /* or'ed in, exclusive create */
+
+#define        NCONT   0       /* continue after note */
+#define        NDFLT   1       /* terminate after note */
+#define        NSAVE   2       /* clear note but hold state */
+#define        NRSTR   3       /* restore saved state */
+
+#define        STATMAX 65535U  /* max length of machine-independent stat structure */
+#define        ERRMAX                  128     /* max length of error string */
+#define        KNAMELEN                28      /* max length of name held in kernel */
+
+/* bits in Qid.type */
+#define QTDIR          0x80            /* type bit for directories */
+#define QTAPPEND       0x40            /* type bit for append only files */
+#define QTEXCL         0x20            /* type bit for exclusive use files */
+#define QTMOUNT                0x10            /* type bit for mounted channel */
+#define QTAUTH         0x08            /* type bit for authentication file */
+#define QTFILE         0x00            /* plain file */
+
+/* bits in Dir.mode */
+#define DMDIR          0x80000000      /* mode bit for directories */
+#define DMAPPEND       0x40000000      /* mode bit for append only files */
+#define DMEXCL         0x20000000      /* mode bit for exclusive use files */
+#define DMMOUNT                0x10000000      /* mode bit for mounted channel */
+#define DMREAD         0x4             /* mode bit for read permission */
+#define DMWRITE                0x2             /* mode bit for write permission */
+#define DMEXEC         0x1             /* mode bit for execute permission */
+
+struct qid
+{
+       uint64_t        path;
+       uint32_t        vers;
+       uint8_t type;
+};
+
+struct dir {
+       /* system-modified data */
+       uint16_t        type;   /* server type */
+       unsigned int    dev;    /* server subtype */
+       /* file data */
+       struct qid      qid;    /* unique id from server */
+       uint32_t        mode;   /* permissions */
+       uint32_t        atime;  /* last read time */
+       uint32_t        mtime;  /* last write time */
+       int64_t length; /* file length: see <u.h> */
+       char    *name;  /* last element of path */
+       char    *uid;   /* owner name */
+       char    *gid;   /* group name */
+       char    *muid;  /* last modifier name */
+};
+
+struct waitmsg
+{
+       int     pid;    /* of loved one */
+       uint32_t        time[3];        /* of loved one and descendants */
+       char    msg[ERRMAX];    /* actually variable-size in user mode */
+};
 
 #define        VERSION9P       "9P2000"
 
 #define        MAXWELEM        16
 
 typedef
-struct Fcall
+struct fcall
 {
-       uchar   type;
-       u32int  fid;
-       ushort  tag;
+       uint8_t type;
+       uint32_t        fid;
+       uint16_t        tag;
        /* union { */
                /* struct { */
-                       u32int  msize;          /* Tversion, Rversion */
+                       uint32_t        msize;          /* Tversion, Rversion */
                        char    *version;       /* Tversion, Rversion */
                /* }; */
                /* struct { */
-                       ushort  oldtag;         /* Tflush */
+                       uint16_t        oldtag;         /* Tflush */
                /* }; */
                /* struct { */
                        char    *ename;         /* Rerror */
                /* }; */
                /* struct { */
-                       Qid     qid;            /* Rattach, Ropen, Rcreate */
-                       u32int  iounit;         /* Ropen, Rcreate */
+                       struct qid      qid;            /* Rattach, Ropen, Rcreate */
+                       uint32_t        iounit;         /* Ropen, Rcreate */
                /* }; */
                /* struct { */
-                       Qid     aqid;           /* Rauth */
+                       struct qid      aqid;           /* Rauth */
                /* }; */
                /* struct { */
-                       u32int  afid;           /* Tauth, Tattach */
+                       uint32_t        afid;           /* Tauth, Tattach */
                        char    *uname;         /* Tauth, Tattach */
                        char    *aname;         /* Tauth, Tattach */
                /* }; */
                /* struct { */
-                       u32int  perm;           /* Tcreate */ 
+                       uint32_t        perm;           /* Tcreate */ 
                        char    *name;          /* Tcreate */
-                       uchar   mode;           /* Tcreate, Topen */
+                       uint8_t mode;           /* Tcreate, Topen */
                /* }; */
                /* struct { */
-                       u32int  newfid;         /* Twalk */
-                       ushort  nwname;         /* Twalk */
+                       uint32_t        newfid;         /* Twalk */
+                       uint16_t        nwname;         /* Twalk */
                        char    *wname[MAXWELEM];       /* Twalk */
                /* }; */
                /* struct { */
-                       ushort  nwqid;          /* Rwalk */
-                       Qid     wqid[MAXWELEM];         /* Rwalk */
+                       uint16_t        nwqid;          /* Rwalk */
+                       struct qid      wqid[MAXWELEM];         /* Rwalk */
                /* }; */
                /* struct { */
-                       vlong   offset;         /* Tread, Twrite */
-                       u32int  count;          /* Tread, Twrite, Rread */
+                       int64_t offset;         /* Tread, Twrite */
+                       uint32_t        count;          /* Tread, Twrite, Rread */
                        char    *data;          /* Twrite, Rread */
                /* }; */
                /* struct { */
-                       ushort  nstat;          /* Twstat, Rstat */
-                       uchar   *stat;          /* Twstat, Rstat */
+                       uint16_t        nstat;          /* Twstat, Rstat */
+                       uint8_t *stat;          /* Twstat, Rstat */
                /* }; */
        /* }; */
-} Fcall;
+} fcall;
 
 
 #define        GBIT8(p)        ((p)[0])
 #define        GBIT16(p)       ((p)[0]|((p)[1]<<8))
-#define        GBIT32(p)       ((u32int)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)))
-#define        GBIT64(p)       ((u32int)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\
-                               ((vlong)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32))
+#define        GBIT32(p)       ((uint32_t)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)))
+#define        GBIT64(p)       ((uint32_t)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\
+                               ((int64_t)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32))
 
 #define        PBIT8(p,v)      (p)[0]=(v)
 #define        PBIT16(p,v)     (p)[0]=(v);(p)[1]=(v)>>8
@@ -84,8 +232,8 @@ struct       Fcall
 /* The count, however, excludes itself; total size is BIT16SZ+count */
 #define STATFIXLEN     (BIT16SZ+QIDSZ+5*BIT16SZ+4*BIT32SZ+1*BIT64SZ)   /* amount of fixed length data in a stat buffer */
 
-#define        NOTAG           (ushort)~0U     /* Dummy tag */
-#define        NOFID           (u32int)~0U     /* Dummy fid */
+#define        NOTAG           (uint16_t)~0U   /* Dummy tag */
+#define        NOFID           (uint32_t)~0U   /* Dummy fid */
 #define        IOHDRSZ         24      /* ample room for Twrite/Rread header (iounit) */
 
 enum
@@ -121,96 +269,33 @@ enum
        Tmax,
 };
 
-uint   convM2S(uchar*, uint, Fcall*);
-uint   convS2M(Fcall*, uchar*, uint);
-uint   sizeS2M(Fcall*);
-
-int    statcheck(uchar *abuf, uint nbuf);
-uint   convM2D(uchar*, uint, Dir*, char*);
-uint   convD2M(Dir*, uchar*, uint);
-uint   sizeD2M(Dir*);
-
-int    fcallfmt(Fmt*);
-int    dirfmt(Fmt*);
-int    dirmodefmt(Fmt*);
-
-int    read9pmsg(int, void*, uint);
-
-#pragma        varargck        type    "F"     Fcall*
-#pragma        varargck        type    "M"     ulong
-#pragma        varargck        type    "D"     Dir*
-
-typedef struct Alarms  Alarms;
-typedef struct Block   Block;
-typedef struct Bkpt Bkpt;
-typedef struct BkptCond BkptCond;
-typedef struct Chan    Chan;
-typedef struct Cmdbuf  Cmdbuf;
-typedef struct Cmdtab  Cmdtab;
-typedef struct Cname   Cname;
-typedef struct Crypt   Crypt;
-typedef struct Dev     Dev;
-typedef struct DevConf DevConf;
-typedef struct Dirtab  Dirtab;
-typedef struct Edf     Edf;
-typedef struct Egrp    Egrp;
-typedef struct Evalue  Evalue;
-typedef struct Fgrp    Fgrp;
-typedef struct List    List;
-typedef struct Log     Log;
-typedef struct Logflag Logflag;
-typedef struct Mntcache Mntcache;
-typedef struct Mntparam Mntparam;
-typedef struct Mount   Mount;
-typedef struct Mntrpc  Mntrpc;
-typedef struct Mntwalk Mntwalk;
-typedef struct Mnt     Mnt;
-typedef struct Mhead   Mhead;
-typedef struct Osenv   Osenv;
-typedef struct Pgrp    Pgrp;
-typedef struct Proc    Proc;
-typedef struct QLock   QLock;
-typedef struct Queue   Queue;
-typedef struct Ref     Ref;
-typedef struct Rendez  Rendez;
-typedef struct Rept    Rept;
-typedef struct Rootdata        Rootdata;
-typedef struct RWlock  RWlock;
-typedef struct Signerkey Signerkey;
-typedef struct Skeyset Skeyset;
-typedef struct Talarm  Talarm;
-typedef struct Timer   Timer;
-typedef struct Timers  Timers;
-typedef struct Uart    Uart;
-typedef struct Walkqid Walkqid;
-typedef int    Devgen(Chan*, char*, Dirtab*, int, int, Dir*);
-
-#pragma incomplete DevConf
-#pragma incomplete Edf
-#pragma incomplete Mntcache
-#pragma incomplete Mntrpc
-#pragma incomplete Queue
-#pragma incomplete Timers
-
-#include "fcall.h"
-#include <pool.h>
-
-struct Ref
-{
-       Lock    l;
+unsigned int   convM2S( uint8_t *unused_uint8_p_t, unsigned int unused_int, struct fcall*);
+unsigned int   convS2M(struct fcall*, uint8_t *unused_uint8_p_t, unsigned int);
+unsigned int   sizeS2M(struct fcall*);
+
+int    statcheck(uint8_t *abuf, unsigned int nbuf);
+unsigned int   convM2D( uint8_t *unused_uint8_p_t, unsigned int unused_int, struct dir*, char *unused_char_p_t);
+unsigned int   convD2M(struct dir*, uint8_t *unused_uint8_p_t, unsigned int);
+unsigned int   sizeD2M(struct dir*);
+
+int    read9pmsg( int unused_int, void*, unsigned int);
+
+struct ref
+{
+       spinlock_t      l;
        long    ref;
 };
 
-struct Rendez
+struct rendez
 {
-       Lock;
-       Proc    *p;
+       spinlock_t lock;
+       struct proc     *p;
 };
 
-struct Rept
+struct rept
 {
-       Lock    l;
-       Rendez  r;
+       spinlock_t      l;
+       struct rendez   r;
        void    *o;
        int     t;
        int     (*active)(void*);
@@ -218,60 +303,40 @@ struct Rept
        void    (*f)(void*);    /* called with VM acquire()'d */
 };
 
-struct Osenv
-{
-       char    *syserrstr;     /* last error from a system call, errbuf0 or 1 */
-       char    *errstr;        /* reason we're unwinding the error stack, errbuf1 or 0 */
-       char    errbuf0[ERRMAX];
-       char    errbuf1[ERRMAX];
-       Pgrp*   pgrp;           /* Ref to namespace, working dir and root */
-       Fgrp*   fgrp;           /* Ref to file descriptors */
-       Egrp*   egrp;   /* Environment vars */
-       Skeyset*        sigs;           /* Signed module keys */
-       Rendez* rend;           /* Synchro point */
-       Queue*  waitq;          /* Info about dead children */
-       Queue*  childq;         /* Info about children for debuggers */
-       void*   debug;          /* Debugging master */
-       int     uid;            /* Numeric user id for system */
-       int     gid;            /* Numeric group id for system */
-       char*   user;           /* Inferno user name */
-       FPenv   fpu;            /* Floating point thread state */
-};
-
 enum
 {
        Nopin = -1
 };
 
-struct QLock
+typedef struct qlock
 {
-       Lock    use;                    /* to access Qlock structure */
-       Proc    *head;                  /* next process waiting for object */
-       Proc    *tail;                  /* last process waiting for object */
+       spinlock_t      use;                    /* to access Qlock structure */
+       struct proc     *head;                  /* next process waiting for object */
+       struct proc     *tail;                  /* last process waiting for object */
        int     locked;                 /* flag */
-};
+}qlock_t ;
 
-struct RWlock
+typedef struct rwlock
 {
-       Lock;                           /* Lock modify lock */
-       QLock   x;                      /* Mutual exclusion lock */
-       QLock   k;                      /* Lock for waiting writers */
+       spinlock_t rwlock;                              /* Lock modify lock */
+       struct qlock    x;                      /* Mutual exclusion lock */
+       struct qlock    k;                      /* Lock for waiting writers */
        int     readers;                /* Count of readers in lock */
-};
+} rwlock_t;
 
-struct Talarm
+struct talarm
 {
-       Lock;
-       Proc*   list;
+       spinlock_t lock;
+       struct proc*    list;
 };
 
-struct Alarms
+struct alarms
 {
-       QLock;
-       Proc*   head;
+       struct qlock qlock;
+       struct proc*    head;
 };
 
-struct Rootdata
+struct rootdata
 {
        int     dotdot;
        void    *ptr;
@@ -310,61 +375,61 @@ enum
        Bpktck  =       (1<<5),         /* packet checksum */
 };
 
-struct Block
+struct block
 {
-       Block*  next;
-       Block*  list;
-       uchar*  rp;                     /* first unconsumed byte */
-       uchar*  wp;                     /* first empty byte */
-       uchar*  lim;                    /* 1 past the end of the buffer */
-       uchar*  base;                   /* start of the buffer */
-       void    (*free)(Block*);
-       ushort  flag;
-       ushort  checksum;               /* IP checksum of complete packet (minus media header) */
+       struct block*   next;
+       struct block*   list;
+       uint8_t*        rp;                     /* first unconsumed byte */
+       uint8_t*        wp;                     /* first empty byte */
+       uint8_t*        lim;                    /* 1 past the end of the buffer */
+       uint8_t*        base;                   /* start of the buffer */
+       void    (*free)(struct block*);
+       uint16_t        flag;
+       uint16_t        checksum;               /* IP checksum of complete packet (minus media header) */
 };
 #define BLEN(s)        ((s)->wp - (s)->rp)
 #define BALLOC(s) ((s)->lim - (s)->base)
 
-struct Chan
-{
-       Lock;
-       Ref;
-       Chan*   next;                   /* allocation */
-       Chan*   link;
-       vlong   offset;                 /* in file */
-       ushort  type;
-       ulong   dev;
-       ushort  mode;                   /* read/write */
-       ushort  flag;
-       Qid     qid;
+struct chan
+{
+       spinlock_t lock;
+       struct kref ref;
+       struct chan*    next;                   /* allocation */
+       struct chan*    link;
+       int64_t offset;                 /* in file */
+       uint16_t        type;
+       uint32_t        dev;
+       uint16_t        mode;                   /* read/write */
+       uint16_t        flag;
+       struct qid      qid;
        int     fid;                    /* for devmnt */
-       ulong   iounit; /* chunk size for i/o; 0==default */
-       Mhead*  umh;                    /* mount point that derived Chan; used in unionread */
-       Chan*   umc;                    /* channel in union; held for union read */
-       QLock   umqlock;                /* serialize unionreads */
+       uint32_t        iounit; /* chunk size for i/o; 0==default */
+       struct mhead*   umh;                    /* mount point that derived Chan; used in unionread */
+       struct chan*    umc;                    /* channel in union; held for union read */
+       struct qlock    umqlock;                /* serialize unionreads */
        int     uri;                    /* union read index */
        int     dri;                    /* devdirread index */
-       ulong   mountid;
-       Mntcache *mcp;                  /* Mount cache pointer */
-       Mnt             *mux;           /* Mnt for clients using me for messages */
+       uint32_t        mountid;
+       struct mntcache *mcp;                   /* Mount cache pointer */
+       struct mnt              *mux;           /* Mnt for clients using me for messages */
        union {
                void*   aux;
                char    tag[4];         /* for iproute */
        };
-       Chan*   mchan;                  /* channel to mounted server */
-       Qid     mqid;                   /* qid of root of mount point */
-       Cname   *name;
+       struct chan*    mchan;                  /* channel to mounted server */
+       struct qid      mqid;                   /* qid of root of mount point */
+       struct cname    *name;
 };
 
-struct Cname
+struct cname
 {
-       Ref;
+       struct kref ref;
        int     alen;                   /* allocated length */
        int     len;                    /* strlen(s) */
        char    *s;
 };
 
-struct Dev
+struct dev
 {
        int     dc;
        char*   name;
@@ -372,35 +437,35 @@ struct Dev
        void    (*reset)(void);
        void    (*init)(void);
        void    (*shutdown)(void);
-       Chan*   (*attach)(char*);
-       Walkqid*        (*walk)(Chan*, Chan*, char**, int);
-       int     (*stat)(Chan*, uchar*, int);
-       Chan*   (*open)(Chan*, int);
-       void    (*create)(Chan*, char*, int, ulong);
-       void    (*close)(Chan*);
-       long    (*read)(Chan*, void*, long, vlong);
-       Block*  (*bread)(Chan*, long, ulong);
-       long    (*write)(Chan*, void*, long, vlong);
-       long    (*bwrite)(Chan*, Block*, ulong);
-       void    (*remove)(Chan*);
-       int     (*wstat)(Chan*, uchar*, int);
+       struct chan*    (*attach)( char *unused_char_p_t);
+       struct walkqid* (*walk)(struct chan*, struct chan*, char **unused_char_pp_t, int);
+       int     (*stat)(struct chan*, uint8_t *unused_uint8_p_t, int);
+       struct chan*    (*open)(struct chan*, int);
+       void    (*create)(struct chan*, char *unused_char_p_t, int unused_int, uint32_t);
+       void    (*close)(struct chan*);
+       long    (*read)(struct chan*, void*, long, int64_t);
+       struct block*   (*bread)(struct chan*, long, uint32_t);
+       long    (*write)(struct chan*, void*, long, int64_t);
+       long    (*bwrite)(struct chan*, struct block*, uint32_t);
+       void    (*remove)(struct chan*);
+       int     (*wstat)(struct chan*, uint8_t *unused_uint8_p_t, int);
        void    (*power)(int);  /* power mgt: power(1) → on, power (0) → off */
-       int     (*config)(int, char*, DevConf*);
+//     int     (*config)( int unused_int, char *unused_char_p_t, DevConf*);
 };
 
-struct Dirtab
+struct dirtab
 {
        char    name[KNAMELEN];
-       Qid     qid;
-       vlong   length;
+       struct qid      qid;
+       int64_t length;
        long    perm;
 };
 
-struct Walkqid
+struct walkqid
 {
-       Chan    *clone;
+       struct chan     *clone;
        int     nqid;
-       Qid     qid[1];
+       struct qid      qid[1];
 };
 
 enum
@@ -410,48 +475,48 @@ enum
        NSCACHE =       (1<<NSLOG),
 };
 
-struct Mntwalk                         /* state for /proc/#/ns */
+struct mntwalk                         /* state for /proc/#/ns */
 {
        int             cddone;
-       ulong   id;
-       Mhead*  mh;
-       Mount*  cm;
+       uint32_t        id;
+       struct mhead*   mh;
+       struct mount*   cm;
 };
 
-struct Mount
+struct mount
 {
-       ulong   mountid;
-       Mount*  next;
-       Mhead*  head;
-       Mount*  copy;
-       Mount*  order;
-       Chan*   to;                     /* channel replacing channel */
+       uint32_t        mountid;
+       struct mount*   next;
+       struct mhead*   head;
+       struct mount*   copy;
+       struct mount*   order;
+       struct chan*    to;                     /* channel replacing channel */
        int     mflag;
        char    *spec;
 };
 
-struct Mhead
+struct mhead
 {
-       Ref;
-       RWlock  lock;
-       Chan*   from;                   /* channel mounted upon */
-       Mount*  mount;                  /* what's mounted upon it */
-       Mhead*  hash;                   /* Hash chain */
+       struct kref ref;
+       struct rwlock   lock;
+       struct chan*    from;                   /* channel mounted upon */
+       struct mount*   mount;                  /* what's mounted upon it */
+       struct mhead*   hash;                   /* Hash chain */
 };
 
-struct Mnt
+struct mnt
 {
-       Lock;
+       spinlock_t lock;
        /* references are counted using c->ref; channels on this mount point incref(c->mchan) == Mnt.c */
-       Chan    *c;             /* Channel to file service */
-       Proc    *rip;           /* Reader in progress */
-       Mntrpc  *queue;         /* Queue of pending requests on this channel */
-       ulong   id;             /* Multiplexer id for channel check */
-       Mnt     *list;          /* Free list */
+       struct chan     *c;             /* Channel to file service */
+       struct proc     *rip;           /* Reader in progress */
+       struct mntrpc   *queue;         /* Queue of pending requests on this channel */
+       uint32_t        id;             /* Multiplexer id for channel check */
+       struct mnt      *list;          /* Free list */
        int     flags;          /* cache */
        int     msize;          /* data + IOHDRSZ */
        char    *version;                       /* 9P version */
-       Queue   *q;             /* input queue */
+       struct queue    *q;             /* input queue */
 };
 
 enum
@@ -466,75 +531,75 @@ enum
 };
 #define MOUNTH(p,qid)  ((p)->mnthash[(qid).path&((1<<MNTLOG)-1)])
 
-struct Mntparam {
-       Chan*   chan;
-       Chan*   authchan;
+struct mntparam {
+       struct chan*    chan;
+       struct chan*    authchan;
        char*   spec;
        int     flags;
 };
 
-struct Pgrp
+struct pgrp
 {
-       Ref;                            /* also used as a lock when mounting */
-       ulong   pgrpid;
-       QLock   debug;                  /* single access via devproc.c */
-       RWlock  ns;                     /* Namespace n read/one write lock */
-       QLock   nsh;
-       Mhead*  mnthash[MNTHASH];
+       struct kref ref;                                /* also used as a lock when mounting */
+       uint32_t        pgrpid;
+       struct qlock    debug;                  /* single access via devproc.c */
+       struct rwlock   ns;                     /* Namespace n read/one write lock */
+       struct qlock    nsh;
+       struct mhead*   mnthash[MNTHASH];
        int     progmode;
-       Chan*   dot;
-       Chan*   slash;
+       struct chan*    dot;
+       struct chan*    slash;
        int     nodevs;
        int     pin;
 };
 
-struct Fgrp
+struct fgrp
 {
-       Lock;
-       Ref;
-       Chan**  fd;
+       spinlock_t lock;
+       struct kref ref;
+       struct chan**   fd;
        int     nfd;                    /* number of fd slots */
        int     maxfd;                  /* highest fd in use */
        int     minfd;                  /* lower bound on free fd */
 };
 
-struct Evalue
+struct evalue
 {
        char    *var;
        char    *val;
        int     len;
-       Qid     qid;
-       Evalue  *next;
+       struct qid      qid;
+       struct evalue   *next;
 };
 
-struct Egrp
+struct egrp
 {
-       Ref;
-       QLock;
-       Evalue  *entries;
-       ulong   path;   /* qid.path of next Evalue to be allocated */
-       ulong   vers;   /* of Egrp */
+       struct kref ref;
+       struct qlock qlock;
+       struct evalue   *entries;
+       uint32_t        path;   /* qid.path of next Evalue to be allocated */
+       uint32_t        vers;   /* of Egrp */
 };
 
-struct Signerkey
+struct signerkey
 {
-       Ref;
+       struct kref ref;
        char*   owner;
-       ushort  footprint;
-       ulong   expires;
+       uint16_t        footprint;
+       uint32_t        expires;
        void*   alg;
        void*   pk;
        void    (*pkfree)(void*);
 };
 
-struct Skeyset
+struct skeyset
 {
-       Ref;
-       QLock;
-       ulong   flags;
+       struct kref ref;
+       struct qlock qlock;
+       uint32_t        flags;
        char*   devs;
        int     nkey;
-       Signerkey       *keys[MAXKEY];
+       struct signerkey        *keys[MAXKEY];
 };
 
 /*
@@ -547,144 +612,6 @@ enum {
        Tperiodic,      /* periodic timer, period in ns */
 };
 
-struct Timer
-{
-       /* Public interface */
-       int     tmode;          /* See above */
-       vlong   tns;            /* meaning defined by mode */
-       void    (*tf)(Ureg*, Timer*);
-       void    *ta;
-       /* Internal */
-       Lock;
-       Timers  *tt;            /* Timers queue this timer runs on */
-       vlong   twhen;          /* ns represented in fastticks */
-       Timer   *tnext;
-};
-
-enum
-{
-       Dead = 0,               /* Process states */
-       Moribund,
-       Ready,
-       Scheding,
-       Running,
-       Queueing,
-       Wakeme,
-       Broken,
-       Stopped,
-       Rendezvous,
-       Waitrelease,
-
-       Proc_stopme = 1,        /* devproc requests */
-       Proc_exitme,
-       Proc_traceme,
-       Proc_exitbig,
-
-       NERR            = 30,
-
-       Unknown         = 0,
-       IdleGC,
-       Interp,
-       BusyGC,
-
-       PriLock         = 0,    /* Holding Spin lock */
-       PriEdf, /* active edf processes */
-       PriRelease,     /* released edf processes */
-       PriRealtime,            /* Video telephony */
-       PriHicodec,             /* MPEG codec */
-       PriLocodec,             /* Audio codec */
-       PriHi,                  /* Important task */
-       PriNormal,
-       PriLo,
-       PriBackground,
-       PriExtra,       /* edf processes we don't care about */
-       Nrq
-};
-
-struct Proc
-{
-       Label           sched;          /* known to l.s */
-       char*           kstack;         /* known to l.s */
-       Mach*           mach;           /* machine running this proc */
-       char            text[KNAMELEN];
-       Proc*           rnext;          /* next process in run queue */
-       Proc*           qnext;          /* next process on queue for a QLock */
-       QLock*          qlock;          /* addrof qlock being queued for DEBUG */
-       int             state;
-       int             type;
-       void*           prog;           /* Dummy Prog for interp release */
-       void*           iprog;
-       Osenv*          env;
-       Osenv           defenv;
-       int             swipend;        /* software interrupt pending for Prog */
-       Lock            sysio;          /* note handler lock */
-       char*           psstate;        /* What /proc/#/status reports */
-       ulong           pid;
-       int             fpstate;
-       int             procctl;        /* Control for /proc debugging */
-       ulong           pc;             /* DEBUG only */
-       Lock    rlock;  /* sync between sleep/swiproc for r */
-       Rendez*         r;              /* rendezvous point slept on */
-       Rendez          sleep;          /* place for syssleep/debug */
-       int             killed;         /* by swiproc */
-       int             kp;             /* true if a kernel process */
-       ulong           alarm;          /* Time of call */
-       int             pri;            /* scheduler priority */
-       ulong           twhen;
-       Rendez*         trend;
-       Proc*           tlink;
-       int             (*tfn)(void*);
-       void            (*kpfun)(void*);
-       void*           arg;
-       FPU             fpsave;
-       int             scallnr;
-       int             nerrlab;
-       Label           errlab[NERR];
-       char    genbuf[128];    /* buffer used e.g. for last name element from namec */
-       Mach*           mp;             /* machine this process last ran on */
-       Mach*           wired;
-       ulong           movetime;       /* next time process should switch processors */
-       ulong           delaysched;
-       int                     preempted;      /* process yielding in interrupt */
-       ulong           qpc;            /* last call that blocked in qlock */
-       void*           dbgreg;         /* User registers for devproc */
-       int             dbgstop;                /* don't run this kproc */
-       Edf*    edf;    /* if non-null, real-time proc, edf contains scheduling params */
-};
-
-enum
-{
-       /* kproc flags */
-       KPDUPPG         = (1<<0),
-       KPDUPFDG        = (1<<1),
-       KPDUPENVG       = (1<<2),
-       KPDUP = KPDUPPG | KPDUPFDG | KPDUPENVG
-};
-
-enum {
-       BrkSched,
-       BrkNoSched,
-};
-
-struct BkptCond
-{
-       uchar op;
-       ulong val;
-       BkptCond *next;
-};
-
-struct Bkpt
-{
-       int id;
-       ulong addr;
-       BkptCond *conditions;
-       Instr instr;
-       void (*handler)(Bkpt*);
-       void *aux;
-       Bkpt *next;
-       Bkpt *link;
-};
-
 enum
 {
        PRINTSIZE =     256,
@@ -693,69 +620,21 @@ enum
        READSTR =       1000,           /* temporary buffer size for device reads */
 };
 
-extern Conf    conf;
-extern char*   conffile;
-extern int     consoleprint;
-extern Dev*    devtab[];
-extern char*   eve;
-extern int     hwcurs;
-extern FPU     initfp;
-extern  Queue  *kbdq;
-extern  Queue  *kscanq;
-extern  Ref    noteidalloc;
-extern  Queue  *printq;
-extern uint    qiomaxatomic;
-extern char*   statename[];
-extern char*   sysname;
-extern Talarm  talarm;
-
-/*
- *  action log
- */
-struct Log {
-       Lock;
-       int     opens;
-       char*   buf;
-       char    *end;
-       char    *rptr;
-       int     len;
-       int     nlog;
-       int     minread;
-
-       int     logmask;        /* mask of things to debug */
-
-       QLock   readq;
-       Rendez  readr;
-};
-
-struct Logflag {
-       char*   name;
-       int     mask;
-};
-
-struct Cmdbuf
+extern struct dev*     devtab[];
+struct cmdbuf
 {
        char    *buf;
        char    **f;
        int     nf;
 };
 
-struct Cmdtab
+struct cmdtab
 {
        int     index;  /* used by client to switch on result */
        char    *cmd;   /* command name */
        int     narg;   /* expected #args; 0 ==> variadic */
 };
 
-enum
-{
-       MAXPOOL         = 8,
-};
-
-extern Pool*   mainmem;
-extern Pool*   heapmem;
-extern Pool*   imagmem;
-
 /* queue state bits,  Qmsg, Qcoalesce, and Qkick can be set in qopen */
 enum
 {
@@ -770,43 +649,373 @@ enum
 
 #define DEVDOTDOT -1
 
-#pragma        varargck        argpos  print   1
-#pragma        varargck        argpos  snprint 3
-#pragma        varargck        argpos  seprint 3
-#pragma        varargck        argpos  sprint  2
-#pragma        varargck        argpos  fprint  2
-#pragma        varargck        argpos  iprint  1
-#pragma        varargck        argpos  panic   1
-#pragma        varargck        argpos  kwerrstr        1
-#pragma        varargck        argpos  kprint  1
-
-#pragma        varargck        type    "lld"   vlong
-#pragma        varargck        type    "llx"   vlong
-#pragma        varargck        type    "lld"   uvlong
-#pragma        varargck        type    "llx"   uvlong
-#pragma        varargck        type    "lx"    void*
-#pragma        varargck        type    "ld"    long
-#pragma        varargck        type    "lx"    long
-#pragma        varargck        type    "ld"    ulong
-#pragma        varargck        type    "lx"    ulong
-#pragma        varargck        type    "d"     int
-#pragma        varargck        type    "x"     int
-#pragma        varargck        type    "c"     int
-#pragma        varargck        type    "C"     int
-#pragma        varargck        type    "d"     uint
-#pragma        varargck        type    "x"     uint
-#pragma        varargck        type    "c"     uint
-#pragma        varargck        type    "C"     uint
-#pragma        varargck        type    "f"     double
-#pragma        varargck        type    "e"     double
-#pragma        varargck        type    "g"     double
-#pragma        varargck        type    "s"     char*
-#pragma        varargck        type    "S"     Rune*
-#pragma        varargck        type    "r"     void
-#pragma        varargck        type    "%"     void
-#pragma        varargck        type    "I"     uchar*
-#pragma        varargck        type    "V"     uchar*
-#pragma        varargck        type    "E"     uchar*
-#pragma        varargck        type    "M"     uchar*
-#pragma        varargck        type    "p"     void*
-#pragma        varargck        type    "q"     char*
+
+typedef int    Devgen(struct chan*, char *unused_char_p_t, struct dirtab*, int unused_int, int,
+                     struct dir*);
+
+/* inferno portfns.h. Not all these are needed. */
+// INFERNO
+#define                FPinit() fpinit() /* remove this if math lib is linked */
+void           FPrestore(void*);
+void           FPsave(void*);
+struct cname*          addelem(struct cname*, char *unused_char_p_t);
+void           addprog(struct proc*);
+void           addrootfile( char *unused_char_p_t, uint8_t *unused_uint8_p_t, uint32_t);
+struct block*          adjustblock(struct block*, int);
+struct block*          allocb(int);
+int    anyhigher(void);
+int    anyready(void);
+void   _assert( char *unused_char_p_t);
+struct block*          bl2mem( uint8_t *unused_uint8_p_t, struct block*, int);
+int            blocklen(struct block*);
+char*          channame(struct chan*);
+int            canlock(spinlock_t*);
+int            canqlock(qlock_t*);
+void           cclose(struct chan*);
+int            canrlock(rwlock_t*);
+void           chandevinit(void);
+void           chandevreset(void);
+void           chandevshutdown(void);
+struct dir*            chandirstat(struct chan*);
+void           chanfree(struct chan*);
+void           chanrec(struct mnt*);
+void           checkalarms(void);
+void           checkb(struct block*, char *unused_char_p_t);
+void           cinit(void);
+struct chan*           cclone(struct chan*);
+void           cclose(struct chan*);
+void           closeegrp(struct egrp*);
+void           closefgrp(struct fgrp*);
+void           closemount(struct mount*);
+void           closepgrp(struct pgrp*);
+void           closesigs(struct skeyset*);
+void           cmderror(struct cmdbuf*, char *unused_char_p_t);
+int            cmount(struct chan*, struct chan*, int unused_int, char *unused_char_p_t);
+void           cnameclose(struct cname*);
+struct block*          concatblock(struct block*);
+void           confinit(void);
+void           copen(struct chan*);
+struct block*          copyblock(struct block*, int);
+int            cread(struct chan*, uint8_t *unused_uint8_p_t, int unused_int, int64_t);
+struct chan*   cunique(struct chan*);
+struct chan*           createdir(struct chan*, struct mhead*);
+void           cunmount(struct chan*, struct chan*);
+void           cupdate(struct chan*, uint8_t *unused_uint8_p_t, int unused_int, int64_t);
+void           cursorenable(void);
+void           cursordisable(void);
+int            cursoron(int);
+void           cursoroff(int);
+void           cwrite(struct chan*, uint8_t *unused_uint8_p_t, int unused_int, int64_t);
+struct chan*           devattach( int unused_int, char *unused_char_p_t);
+struct block*          devbread(struct chan*, long, uint32_t);
+long           devbwrite(struct chan*, struct block*, uint32_t);
+struct chan*           devclone(struct chan*);
+void           devcreate(struct chan*, char *unused_char_p_t, int unused_int, uint32_t);
+void           devdir(struct chan*, struct qid, char *unused_char_p_t, int64_t, char*, long,
+                          struct dir*);
+long           devdirread(struct chan*, char *unused_char_p_t, long,
+                              struct dirtab*, int unused_int, Devgen*);
+Devgen         devgen;
+void           devinit(void);
+int            devno( int unused_int, int);
+void   devpower(int);
+struct dev*    devbyname( char *unused_char_p_t);
+struct chan*           devopen(struct chan*, int unused_int,
+                                   struct dirtab*, int unused_int2, Devgen*);
+void           devpermcheck( char *unused_char_p_t, uint32_t, int);
+void           devremove(struct chan*);
+void           devreset(void);
+void           devshutdown(void);
+int            devstat(struct chan*, uint8_t *unused_uint8_p_t, int unused_int,
+                          struct dirtab*, int unused_int2, Devgen*);
+struct walkqid*        devwalk(struct chan*,
+                       struct chan*, char **unused_char_pp_t, int unused_int,
+                       struct dirtab*, int unused_intw, Devgen*);
+int            devwstat(struct chan*, uint8_t *unused_uint8_p_t, int);
+void           disinit(void*);
+void           disfault(void*, char *unused_char_p_t);
+int            domount(struct chan**, struct mhead**);
+void           drawactive(int);
+void           drawcmap(void);
+void           dumpstack(void);
+struct fgrp*           dupfgrp(struct fgrp*);
+void           egrpcpy(struct egrp*, struct egrp*);
+int            emptystr( char *unused_char_p_t);
+int            eqchan(struct chan*, struct chan*, int);
+int            eqqid(struct qid, struct qid);
+
+void           errorf( char *unused_char_p_t, ...);
+void           errstr( char *unused_char_p_t, int);
+void           excinit(void);
+void           exhausted( char *unused_char_p_t);
+void           exit(int);
+void           reboot(void);
+void           halt(void);
+int            export( int unused_int, char *unused_char_p_t, int);
+uint64_t               fastticks(uint64_t*);
+uint64_t               fastticks2ns(uint64_t);
+void           fdclose(struct fgrp*, int);
+struct chan*           fdtochan(struct fgrp*, int unused_int, int, int, int);
+int            findmount(struct chan**,
+                            struct mhead**, int unused_int, int, struct qid);
+void           free(void*);
+void           freeb(struct block*);
+void           freeblist(struct block*);
+void           freeskey(struct signerkey*);
+void           getcolor(uint32_t, uint32_t*, uint32_t*, uint32_t*);
+uint32_t       getmalloctag(void*);
+uint32_t       getrealloctag(void*);
+void           hnputl(void*, uint32_t);
+void           hnputs(void*, uint16_t);
+struct block*          iallocb(int);
+void           iallocsummary(void);
+void           ilock(spinlock_t*);
+int            incref(struct kref*);
+int            iprint( char *unused_char_p_t, ...);
+void           isdir(struct chan*);
+int            iseve(void);
+int            islo(void);
+void           iunlock(spinlock_t*);
+void           ixsummary(void);
+void           kbdclock(void);
+int            kbdcr2nl(struct queue*, int);
+int            kbdputc(struct queue*, int);
+void           kbdrepeat(int);
+void           kproc( char *unused_char_p_t, void(*)(void*), void*, int);
+int            kfgrpclose(struct fgrp*, int);
+void           kprocchild(struct proc*, void (*)(void*), void*);
+int            kprint( char *unused_char_p_t, ...);
+void   (*kproftick)(uint32_t);
+void           ksetenv( char *unused_char_p_t, char*, int);
+//void         kstrncpy( char *unused_char_p_t, char*, int unused_int, sizeof(char*, char*));
+void           kstrdup( char **unused_char_pp_t, char *unused_char_p_t);
+void           lock(spinlock_t*);
+
+struct cmdtab*         lookupcmd(struct cmdbuf*, struct cmdtab*, int);
+void*          malloc(uint32_t);
+void*          mallocz(uint32_t, int);
+struct block*          mem2bl( uint8_t *unused_uint8_p_t, int);
+int                    memusehigh(void);
+void           microdelay(int);
+uint64_t               mk64fract(uint64_t, uint64_t);
+void           mkqid(struct qid*, int64_t, uint32_t, int);
+void           modinit(void);
+struct chan*           mntauth(struct chan*, char *unused_char_p_t);
+long           mntversion(struct chan*, char *unused_char_p_t, int unused_int, int);
+void           mountfree(struct mount*);
+void           mousetrack( int unused_int, int, int, int);
+uint64_t               ms2fastticks(uint32_t);
+uint32_t               msize(void*);
+void           mul64fract(uint64_t*, uint64_t, uint64_t);
+void           muxclose(struct mnt*);
+struct chan*           namec( char *unused_char_p_t, int unused_int, int, uint32_t);
+struct chan*           newchan(void);
+struct egrp*           newegrp(void);
+struct fgrp*           newfgrp(struct fgrp*);
+struct mount*          newmount(struct mhead*, struct chan*, int unused_int, char *unused_char_p_t);
+struct pgrp*           newpgrp(void);
+struct proc*           newproc(void);
+char*          nextelem( char *unused_char_p_t, char*);
+
+struct cname*          newcname( char *unused_char_p_t);
+void   notkilled(void);
+int            nrand(int);
+uint64_t               ns2fastticks(uint64_t);
+int            okaddr(uint32_t, uint32_t, int);
+int            openmode(uint32_t);
+struct block*          packblock(struct block*);
+struct block*          padblock(struct block*, int);
+
+struct cmdbuf*         parsecmd( char *unused_char_p_t, int);
+
+void           pgrpcpy(struct pgrp*, struct pgrp*);
+
+int            progfdprint(struct chan*, int unused_int, int, char *unused_char_p_t, int i);
+int            pullblock(struct block**, int);
+struct block*          pullupblock(struct block*, int);
+struct block*          pullupqueue(struct queue*, int);
+void           putmhead(struct mhead*);
+void           putstrn( char *unused_char_p_t, int);
+void           qaddlist(struct queue*, struct block*);
+struct block*          qbread(struct queue*, int);
+long           qbwrite(struct queue*, struct block*);
+struct queue*  qbypass(void (*)(void*, struct block*), void*);
+int            qcanread(struct queue*);
+void           qclose(struct queue*);
+int            qconsume(struct queue*, void*, int);
+struct block*          qcopy(struct queue*, int unused_int, uint32_t);
+int            qdiscard(struct queue*, int);
+void           qflush(struct queue*);
+void           qfree(struct queue*);
+int            qfull(struct queue*);
+struct block*          qget(struct queue*);
+void           qhangup(struct queue*, char *unused_char_p_t);
+int            qisclosed(struct queue*);
+int            qiwrite(struct queue*, void*, int);
+int            qlen(struct queue*);
+void           qlock(qlock_t*);
+void           qnoblock(struct queue*, int);
+struct queue*          qopen( int unused_int, int, void (*)(void*), void*);
+int            qpass(struct queue*, struct block*);
+int            qpassnolim(struct queue*, struct block*);
+int            qproduce(struct queue*, void*, int);
+void           qputback(struct queue*, struct block*);
+long           qread(struct queue*, void*, int);
+struct block*          qremove(struct queue*);
+void           qreopen(struct queue*);
+void           qsetlimit(struct queue*, int);
+void           qunlock(qlock_t*);
+int            qwindow(struct queue*);
+int            qwrite(struct queue*, void*, int);
+void           randominit(void);
+uint32_t       randomread(void*, uint32_t);
+void*  realloc(void*, uint32_t);
+int            readnum(uint32_t, char *unused_char_p_t, uint32_t, uint32_t, int);
+int            readnum_int64_t(uint32_t, char *unused_char_p_t, uint32_t, int64_t, int);
+int            readstr(uint32_t, char *unused_char_p_t, uint32_t, char*);
+void           ready(struct proc*);
+void           renameproguser( char *unused_char_p_t, char*);
+void           renameuser( char *unused_char_p_t, char*);
+void           resrcwait( char *unused_char_p_t);
+int            return0(void*);
+void           rlock(rwlock_t*);
+void           runlock(rwlock_t*);
+struct proc*           runproc(void);
+void           sched(void);
+void           schedinit(void);
+long           seconds(void);
+void           (*serwrite)( char *unused_char_p_t, int);
+int            setcolor(uint32_t, uint32_t, uint32_t, uint32_t);
+
+void           setmalloctag(void*, uint32_t);
+int            setpri(int);
+void           setrealloctag(void*, uint32_t);
+char*          skipslash( char *unused_char_p_t);
+void           sleep(struct rendez*, int(*)(void*), void*);
+void*          smalloc(uint32_t);
+int            splhi(void);
+int            spllo(void);
+void           splx(int);
+void   splxpc(int);
+void           swiproc(struct proc*, int);
+uint32_t               _tas(uint32_t*);
+uint32_t       tk2ms(uint32_t);
+#define                TK2MS(x) ((x)*(1000/HZ))
+uint64_t               tod2fastticks(int64_t);
+int64_t                todget(int64_t*);
+void           todfix(void);
+void           todsetfreq(int64_t);
+void           todinit(void);
+void           todset(int64_t, int64_t, int);
+int            tready(void*);
+struct block*          trimblock(struct block*, int unused_int, int);
+void           tsleep(struct rendez*, int (*)(void*), void*, int);
+int            uartgetc(void);
+void           uartputc(int);
+void           uartputs( char *unused_char_p_t, int);
+long           unionread(struct chan*, void*, long);
+void           unlock(spinlock_t*);
+void           userinit(void);
+uint32_t               userpc(void);
+void           validname( char *unused_char_p_t, int);
+void           validstat( uint8_t *unused_uint8_p_t, int);
+void           validwstatname( char *unused_char_p_t);
+int            wakeup(struct rendez*);
+int            walk(struct chan**, char **unused_char_pp_t, int unused_int, int, int*);
+void           werrstr( char *unused_char_p_t, ...);
+void           wlock(rwlock_t*);
+void           wunlock(rwlock_t*);
+void*          xalloc(uint32_t);
+void*          xallocz(uint32_t, int);
+void           xfree(void*);
+void           xhole(uint32_t, uint32_t);
+void           xinit(void);
+int            xmerge(void*, void*);
+void*          xspanalloc(uint32_t, int unused_int, uint32_t);
+void           xsummary(void);
+void           validaddr(void*, uint32_t, int);
+void*  vmemchr(void*, int unused_int, int);
+void           hnputv(void*, int64_t);
+void           hnputl(void*, uint32_t);
+void           hnputs(void*, uint16_t);
+int64_t                nhgetv(void*);
+uint32_t               nhgetl(void*);
+uint16_t               nhgets(void*);
+
+/* error messages, from inferno emu error.h */
+extern char Enoerror[];                /* no error */
+extern char Emount[];          /* inconsistent mount */
+extern char Eunmount[];                /* not mounted */
+extern char Eunion[];          /* not in union */
+extern char Emountrpc[];       /* mount rpc error */
+extern char Eshutdown[];       /* mounted device shut down */
+extern char Eowner[];          /* not owner */
+extern char Eunknown[];                /* unknown user or group id */
+extern char Enocreate[];       /* mounted directory forbids creation */
+extern char Enonexist[];       /* file does not exist */
+extern char Eexist[];          /* file already exists */
+extern char Ebadsharp[];       /* unknown device in # filename */
+extern char Enotdir[];         /* not a directory */
+extern char Eisdir[];          /* file is a directory */
+extern char Ebadchar[];                /* bad character in file name */
+extern char Efilename[];       /* file name syntax */
+extern char Eperm[];           /* permission denied */
+extern char Ebadusefd[];       /* inappropriate use of fd */
+extern char Ebadarg[];         /* bad arg in system call */
+extern char Einuse[];          /* device or object already in use */
+extern char Eio[];             /* i/o error */
+extern char Etoobig[];         /* read or write too large */
+extern char Etoosmall[];       /* read or write too small */
+extern char Enetaddr[];                /* bad network address */
+extern char Emsgsize[];                /* message is too big for protocol */
+extern char Enetbusy[];                /* network device is busy or allocated */
+extern char Enoproto[];                /* network protocol not supported */
+extern char Enoport[];         /* network port not available */
+extern char Enoifc[];          /* bad interface or no free interface slots */
+extern char Enolisten[];       /* not announced */
+extern char Ehungup[];         /* i/o on hungup channel */
+extern char Ebadctl[];         /* bad process or channel control request */
+extern char Enodev[];          /* no free devices */
+extern char Enoenv[];          /* no free environment resources */
+extern char Ethread[];         /* thread exited */
+extern char Enochild[];                /* no living children */
+extern char Eioload[];         /* i/o error in demand load */
+extern char Enovmem[];         /* out of memory: virtual memory */
+extern char Ebadld[];          /* illegal line discipline */
+extern char Ebadfd[];          /* fd out of range or not open */
+extern char Eisstream[];       /* seek on a stream */
+extern char Ebadexec[];                /* exec header invalid */
+extern char Etimedout[];       /* connection timed out */
+extern char Econrefused[];     /* connection refused */
+extern char Econinuse[];       /* connection in use */
+extern char Enetunreach[];     /* network unreachable */
+extern char Eintr[];           /* interrupted */
+extern char Enomem[];          /* out of memory: kernel */
+extern char Esfnotcached[];    /* subfont not cached */
+extern char Esoverlap[];       /* segments overlap */
+extern char Emouseset[];       /* mouse type already set */
+extern char Eshort[];          /* i/o count too small */
+extern char Enobitstore[];     /* out of screen memory */
+extern char Egreg[];           /* jim'll fix it */
+extern char Ebadspec[];                /* bad attach specifier */
+extern char Estopped[];                /* thread must be stopped */
+extern char Enoattach[];       /* mount/attach disallowed */
+extern char Eshortstat[];      /* stat buffer too small */
+extern char Enegoff[]; /* negative i/o offset */
+extern char Ebadstat[];        /* malformed stat buffer */
+extern char Ecmdargs[];                /* wrong #args in control message */
+extern char    Enofd[];        /* no free file descriptors */
+extern char Enoctl[];  /* unknown control request */
+
+
+/* kern/src/err.c */
+int errpush(struct errbuf *errstack, int stacksize, int *curindex,
+            struct errbuf **prev_errbuf);
+void errpop(struct errbuf *errstack, int stacksize, int *curindex,
+            struct errbuf *prev_errbuf);
+/* */
+char *get_cur_genbuf(void);
+
+/* stuff we really ought to have ... */
+char *index(char *s, int c);
index 88f7ccd..c6c612e 100644 (file)
@@ -6,6 +6,6 @@
 #include <arch/setjmp.h>
 
 int setjmp(struct jmpbuf *env) __attribute__((returns_twice));
-void longjmp(struct jmpbuf *env, int val) __attribute__((noreturn));
+void longjmp(struct jmpbuf *env, void * val) __attribute__((noreturn));
 
 #endif /* !ROS_SETJMP_H */
index ebdc70c..ab25624 100644 (file)
@@ -50,3 +50,4 @@ obj-y                                         += trap.o
 obj-y                                          += ucq.o
 obj-y                                          += umem.o
 obj-y                                          += vfs.o
+obj-y                                          += ns/
diff --git a/kern/src/ns/Kbuild b/kern/src/ns/Kbuild
new file mode 100644 (file)
index 0000000..4a2b3da
--- /dev/null
@@ -0,0 +1 @@
+obj-y                                          += chan.o
index c3a56b0..5670912 100644 (file)
@@ -1,19 +1,27 @@
-#include       "u.h"
-#include       "../port/lib.h"
-#include       "mem.h"
-#include       "dat.h"
-#include       "fns.h"
-#include       "../port/error.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 <syscall.h>
 
 char*
-channame(Chan *c)              /* DEBUGGING */
+channame(struct chan *c)               /* DEBUGGING */
 {
-       if(c == nil)
-               return "<nil chan>";
-       if(c->name == nil)
-               return "<nil name>";
-       if(c->name->s == nil)
-               return "<nil name.s>";
+       if(c == NULL)
+               return "<NULL chan>";
+       if(c->name == NULL)
+               return "<NULL name>";
+       if(c->name->s == NULL)
+               return "<NULL name.s>";
        return c->name->s;
 }
 
@@ -24,10 +32,10 @@ enum
 
 struct
 {
-       Lock;
+       spinlock_t lock;
        int     fid;
-       Chan    *free;
-       Chan    *list;
+       struct chan     *free;
+       struct chan     *list;
 }chanalloc;
 
 typedef struct Elemlist Elemlist;
@@ -35,14 +43,14 @@ typedef struct Elemlist Elemlist;
 struct Elemlist
 {
        char    *name;  /* copy of name, so '/' can be overwritten */
-       int     nelems;
+       int     ARRAY_SIZEs;
        char    **elems;
        int     *off;
        int     mustbedir;
 };
 
 #define SEP(c) ((c) == 0 || (c) == '/')
-void cleancname(Cname*);
+void cleancname(struct cname*);
 
 int
 isdotdot(char *p)
@@ -51,66 +59,9 @@ isdotdot(char *p)
 }
 
 int
-incref(Ref *r)
-{
-       int x;
-
-       lock(&r->l);
-       x = ++r->ref;
-       unlock(&r->l);
-       return x;
-}
-
-int
-decref(Ref *r)
-{
-       int x;
-
-       lock(&r->l);
-       x = --r->ref;
-       unlock(&r->l);
-       if(x < 0)
-               panic("decref, pc=0x%lux", getcallerpc(&r));
-
-       return x;
-}
-
-/*
- * Rather than strncpy, which zeros the rest of the buffer, kstrcpy
- * truncates if necessary, always zero terminates, does not zero fill,
- * and puts ... at the end of the string if it's too long.  Usually used to
- * save a string in up->genbuf;
- */
-void
-kstrcpy(char *s, char *t, int ns)
-{
-       int nt;
-
-       nt = strlen(t);
-       if(nt+1 <= ns){
-               memmove(s, t, nt+1);
-               return;
-       }
-       /* too long */
-       if(ns < 4){
-               /* but very short! */
-               strncpy(s, t, ns);
-               return;
-       }
-       /* truncate with ... at character boundary (very rare case) */
-       memmove(s, t, ns-4);
-       ns -= 4;
-       s[ns] = '\0';
-       /* look for first byte of UTF-8 sequence by skipping continuation bytes */
-       while(ns>0 && (s[--ns]&0xC0)==0x80)
-               ;
-       strcpy(s+ns, "...");
-}
-
-int
 emptystr(char *s)
 {
-       if(s == nil)
+       if(s == NULL)
                return 1;
        if(s[0] == '\0')
                return 1;
@@ -128,18 +79,17 @@ kstrdup(char **p, char *s)
 
        n = strlen(s)+1;
        /* if it's a user, we can wait for memory; if not, something's very wrong */
-       if(up){
-               t = smalloc(n);
-               setmalloctag(t, getcallerpc(&p));
+       if (current) {
+               t = kzmalloc(n, 0);
        }else{
-               t = malloc(n);
-               if(t == nil)
+               t = kzmalloc(n, 0);
+               if(t == NULL)
                        panic("kstrdup: no memory");
        }
        memmove(t, s, n);
        prev = *p;
        *p = t;
-       free(prev);
+       kfree(prev);
 }
 
 void
@@ -147,7 +97,7 @@ chandevreset(void)
 {
        int i;
 
-       for(i=0; devtab[i] != nil; i++)
+       for(i=0; devtab[i] != NULL; i++)
                devtab[i]->reset();
 }
 
@@ -156,7 +106,7 @@ chandevinit(void)
 {
        int i;
 
-       for(i=0; devtab[i] != nil; i++)
+       for(i=0; devtab[i] != NULL; i++)
                devtab[i]->init();
 }
 
@@ -166,37 +116,37 @@ chandevshutdown(void)
        int i;
        
        /* shutdown in reverse order */
-       for(i=0; devtab[i] != nil; i++)
+       for(i=0; devtab[i] != NULL; i++)
                ;
        for(i--; i >= 0; i--)
                devtab[i]->shutdown();
 }
 
-Chan*
+struct chan*
 newchan(void)
 {
-       Chan *c;
+       struct chan *c;
 
-       lock(&chanalloc);
+       spin_lock(&(&chanalloc)->lock);
        c = chanalloc.free;
        if(c != 0)
                chanalloc.free = c->next;
-       unlock(&chanalloc);
+       spin_unlock(&(&chanalloc)->lock);
 
-       if(c == nil) {
-               c = smalloc(sizeof(Chan));
-               lock(&chanalloc);
+       if(c == NULL) {
+               c = kzmalloc(sizeof(struct chan), 0);
+               spin_lock(&(&chanalloc)->lock);
                c->fid = ++chanalloc.fid;
                c->link = chanalloc.list;
                chanalloc.list = c;
-               unlock(&chanalloc);
+               spin_unlock(&(&chanalloc)->lock);
        }
 
        /* if you get an error before associating with a dev,
           close calls rootclose, a nop */
        c->type = 0;
        c->flag = 0;
-       c->ref = 1;
+       kref_init(&c->ref, fake_release, 1);
        c->dev = 0;
        c->offset = 0;
        c->iounit = 0;
@@ -214,48 +164,48 @@ newchan(void)
        return c;
 }
 
-static Ref ncname;
+static struct kref ncname;
 
-Cname*
+struct cname*
 newcname(char *s)
 {
-       Cname *n;
+       struct cname *n;
        int i;
 
-       n = smalloc(sizeof(Cname));
+       n = kzmalloc(sizeof(*n), 0);
        i = strlen(s);
        n->len = i;
        n->alen = i+CNAMESLOP;
-       n->s = smalloc(n->alen);
+       n->s = kzmalloc(n->alen, 0);
        memmove(n->s, s, i+1);
-       n->ref = 1;
-       incref(&ncname);
+       kref_init(&n->ref, fake_release, 1);
+       kref_get(&n->ref, 1);
        return n;
 }
 
 void
-cnameclose(Cname *n)
+cnameclose(struct cname *n)
 {
-       if(n == nil)
+       if(n == NULL)
                return;
-       if(decref(n))
+       if(kref_put(&n->ref))
                return;
-       decref(&ncname);
-       free(n->s);
-       free(n);
+       kref_put(&n->ref);
+       kfree(n->s);
+       kfree(n);
 }
 
-Cname*
-addelem(Cname *n, char *s)
+struct cname*
+addelem(struct cname *n, char *s)
 {
        int i, a;
        char *t;
-       Cname *new;
+       struct cname *new;
 
        if(s[0]=='.' && s[1]=='\0')
                return n;
 
-       if(n->ref > 1){
+       if(kref_refcnt(&n->ref) > 1){
                /* copy on write */
                new = newcname(n->s);
                cnameclose(n);
@@ -265,9 +215,9 @@ addelem(Cname *n, char *s)
        i = strlen(s);
        if(n->len+1+i+1 > n->alen){
                a = n->len+1+i+1 + CNAMESLOP;
-               t = smalloc(a);
+               t = kzmalloc(a, 0);
                memmove(t, n->s, n->len+1);
-               free(n->s);
+               kfree(n->s);
                n->s = t;
                n->alen = a;
        }
@@ -281,45 +231,47 @@ addelem(Cname *n, char *s)
 }
 
 void
-chanfree(Chan *c)
+chanfree(struct chan *c)
 {
        c->flag = CFREE;
 
-       if(c->umh != nil){
+       if(c->umh != NULL){
                putmhead(c->umh);
-               c->umh = nil;
+               c->umh = NULL;
        }
-       if(c->umc != nil){
+       if(c->umc != NULL){
                cclose(c->umc);
-               c->umc = nil;
+               c->umc = NULL;
        }
-       if(c->mux != nil){
+       if(c->mux != NULL){
+               //
                muxclose(c->mux);
-               c->mux = nil;
+               c->mux = NULL;
        }
-       if(c->mchan != nil){
+       if(c->mchan != NULL){
                cclose(c->mchan);
-               c->mchan = nil;
+               c->mchan = NULL;
        }
 
        cnameclose(c->name);
 
-       lock(&chanalloc);
+       spin_lock(&(&chanalloc)->lock);
        c->next = chanalloc.free;
        chanalloc.free = c;
-       unlock(&chanalloc);
+       spin_unlock(&(&chanalloc)->lock);
 }
 
 void
-cclose(Chan *c)
+cclose(struct chan *c)
 {
+       ERRSTACK(2);
        if(c == 0)
                return;
 
        if(c->flag&CFREE)
                panic("cclose %lux", getcallerpc(&c));
 
-       if(decref(c))
+       if(kref_put(&c->ref))
                return;
 
        if(!waserror()){
@@ -332,12 +284,12 @@ cclose(Chan *c)
 /*
  * Make sure we have the only copy of c.  (Copy on write.)
  */
-Chan*
-cunique(Chan *c)
+struct chan*
+cunique(struct chan *c)
 {
-       Chan *nc;
+       struct chan *nc;
 
-       if(c->ref != 1) {
+       if(kref_refcnt(&c->ref) != 1) {
                nc = cclone(c);
                cclose(c);
                c = nc;
@@ -347,13 +299,13 @@ cunique(Chan *c)
 }
 
 int
-eqqid(Qid a, Qid b)
+eqqid(struct qid a, struct qid b)
 {
        return a.path==b.path && a.vers==b.vers;
 }
 
 int
-eqchan(Chan *a, Chan *b, int pathonly)
+eqchan(struct chan *a, struct chan *b, int pathonly)
 {
        if(a->qid.path != b->qid.path)
                return 0;
@@ -367,7 +319,7 @@ eqchan(Chan *a, Chan *b, int pathonly)
 }
 
 int
-eqchantdqid(Chan *a, int type, int dev, Qid qid, int pathonly)
+eqchantdqid(struct chan *a, int type, int dev, struct qid qid, int pathonly)
 {
        if(a->qid.path != qid.path)
                return 0;
@@ -380,15 +332,15 @@ eqchantdqid(Chan *a, int type, int dev, Qid qid, int pathonly)
        return 1;
 }
 
-Mhead*
-newmhead(Chan *from)
+struct mhead*
+newmhead(struct chan *from)
 {
-       Mhead *mh;
+       struct mhead *mh;
 
-       mh = smalloc(sizeof(Mhead));
-       mh->ref = 1;
+       mh = kzmalloc(sizeof(struct mhead), 0);
+       kref_init(&mh->ref, fake_release, 1);
        mh->from = from;
-       incref(from);
+       kref_get(&from->ref, 1);
 
 /*
        n = from->name->len;
@@ -401,18 +353,19 @@ newmhead(Chan *from)
 }
 
 int
-cmount(Chan *new, Chan *old, int flag, char *spec)
+cmount(struct chan *new, struct chan *old, int flag, char *spec)
 {
-       Pgrp *pg;
+       ERRSTACK(2);
+       struct pgrp *pg;
        int order, flg;
-       Mhead *m, **l, *mh;
-       Mount *nm, *f, *um, **h;
+       struct mhead *m, **l, *mh;
+       struct mount *nm, *f, *um, **h;
 
        if(QTDIR & (old->qid.type^new->qid.type))
                error(Emount);
 
 if(old->umh)
-       print("cmount old extra umh\n");
+       printd("cmount old extra umh\n");
 
        order = flag&MORDER;
 
@@ -441,7 +394,7 @@ if(old->umh)
        && (mh->mount->next || !(mh->mount->mflag&MCREATE)))
                error(Emount);
 
-       pg = up->env->pgrp;
+       pg = current->pgrp;
        wlock(&pg->ns);
 
        l = &MOUNTH(pg, old->qid);
@@ -451,7 +404,7 @@ if(old->umh)
                l = &m->hash;
        }
 
-       if(m == nil) {
+       if(m == NULL) {
                /*
                 *  nothing mounted here yet.  create a mount
                 *  head and add to the hash table.
@@ -474,7 +427,7 @@ if(old->umh)
        wunlock(&pg->ns);
 
        nm = newmount(m, new, flag, spec);
-       if(mh != nil && mh->mount != nil) {
+       if(mh != NULL && mh->mount != NULL) {
                /*
                 *  copy a union when binding it onto a directory
                 */
@@ -516,17 +469,17 @@ if(old->umh)
 }
 
 void
-cunmount(Chan *mnt, Chan *mounted)
+cunmount(struct chan *mnt, struct chan *mounted)
 {
-       Pgrp *pg;
-       Mhead *m, **l;
-       Mount *f, **p;
+       struct pgrp *pg;
+       struct mhead *m, **l;
+       struct mount *f, **p;
 
        if(mnt->umh)    /* should not happen */
-               print("cunmount newp extra umh %p has %p\n", mnt, mnt->umh);
+               printd("cunmount newp extra umh %p has %p\n", mnt, mnt->umh);
 
        /*
-        * It _can_ happen that mounted->umh is non-nil
+        * It _can_ happen that mounted->umh is non-NULL
         * because mounted is the result of namec(Aopen)
         * (see sysfile.c:/^sysunmount).
         * If we open a union directory, it will have a umh.
@@ -534,7 +487,7 @@ cunmount(Chan *mnt, Chan *mounted)
         * cclose will take care of freeing the umh.
         */
 
-       pg = up->env->pgrp;
+       pg = current->pgrp;
        wlock(&pg->ns);
 
        l = &MOUNTH(pg, mnt->qid);
@@ -554,7 +507,7 @@ cunmount(Chan *mnt, Chan *mounted)
                *l = m->hash;
                wunlock(&pg->ns);
                mountfree(m->mount);
-               m->mount = nil;
+               m->mount = NULL;
                cclose(m->from);
                wunlock(&m->lock);
                putmhead(m);
@@ -569,7 +522,7 @@ cunmount(Chan *mnt, Chan *mounted)
                        *p = f->next;
                        f->next = 0;
                        mountfree(f);
-                       if(m->mount == nil) {
+                       if(m->mount == NULL) {
                                *l = m->hash;
                                cclose(m->from);
                                wunlock(&m->lock);
@@ -588,49 +541,50 @@ cunmount(Chan *mnt, Chan *mounted)
        error(Eunion);
 }
 
-Chan*
-cclone(Chan *c)
+struct chan*
+cclone(struct chan *c)
 {
-       Chan *nc;
-       Walkqid *wq;
+       struct chan *nc;
+       struct walkqid *wq;
 
-       wq = devtab[c->type]->walk(c, nil, nil, 0);
-       if(wq == nil)
+       wq = devtab[c->type]->walk(c, NULL, NULL, 0);
+       if(wq == NULL)
                error("clone failed");
        nc = wq->clone;
-       free(wq);
+       kfree(wq);
        nc->name = c->name;
        if(c->name)
-               incref(c->name);
+               kref_get(&c->name->ref, 1);
        return nc;
 }
 
 int
-findmount(Chan **cp, Mhead **mp, int type, int dev, Qid qid)
+findmount(struct chan **cp,
+         struct mhead **mp, int type, int dev, struct qid qid)
 {
-       Pgrp *pg;
-       Mhead *m;
+       struct pgrp *pg;
+       struct mhead *m;
 
-       pg = up->env->pgrp;
+       pg = current->pgrp;
        rlock(&pg->ns);
        for(m = MOUNTH(pg, qid); m; m = m->hash){
                rlock(&m->lock);
-if(m->from == nil){
-       print("m %p m->from 0\n", m);
+if(m->from == NULL){
+       printd("m %p m->from 0\n", m);
        runlock(&m->lock);
        continue;
 }
                if(eqchantdqid(m->from, type, dev, qid, 1)) {
                        runlock(&pg->ns);
-                       if(mp != nil){
-                               incref(m);
-                               if(*mp != nil)
+                       if(mp != NULL){
+                               kref_get(&m->ref, 1);
+                               if(*mp != NULL)
                                        putmhead(*mp);
                                *mp = m;
                        }
-                       if(*cp != nil)
+                       if(*cp != NULL)
                                cclose(*cp);
-                       incref(m->mount->to);
+                       kref_get(&m->mount->to->ref, 1);
                        *cp = m->mount->to;
                        runlock(&m->lock);
                        return 1;
@@ -643,20 +597,21 @@ if(m->from == nil){
 }
 
 int
-domount(Chan **cp, Mhead **mp)
+domount(struct chan **cp, struct mhead **mp)
 {
        return findmount(cp, mp, (*cp)->type, (*cp)->dev, (*cp)->qid);
 }
 
-Chan*
-undomount(Chan *c, Cname *name)
+struct chan*
+undomount(struct chan *c, struct cname *name)
 {
-       Chan *nc;
-       Pgrp *pg;
-       Mount *t;
-       Mhead **h, **he, *f;
+       ERRSTACK(2);
+       struct chan *nc;
+       struct pgrp *pg;
+       struct mount *t;
+       struct mhead **h, **he, *f;
 
-       pg = up->env->pgrp;
+       pg = current->pgrp;
        rlock(&pg->ns);
        if(waserror()) {
                runlock(&pg->ns);
@@ -679,7 +634,7 @@ undomount(Chan *c, Cname *name)
                                        if(strcmp(t->head->from->name->s, name->s) != 0)
                                                continue;
                                        nc = t->head->from;
-                                       incref(nc);
+                                       kref_get(&nc->ref, 1);
                                        cclose(c);
                                        c = nc;
                                        break;
@@ -698,30 +653,30 @@ undomount(Chan *c, Cname *name)
  */
 static char Edoesnotexist[] = "does not exist";
 int
-walk(Chan **cp, char **names, int nnames, int nomount, int *nerror)
+walk(struct chan **cp, char **names, int nnames, int nomount, int *nerror)
 {
        int dev, dotdot, i, n, nhave, ntry, type;
-       Chan *c, *nc;
-       Cname *cname;
-       Mount *f;
-       Mhead *mh, *nmh;
-       Walkqid *wq;
+       struct chan *c, *nc;
+       struct cname *cname;
+       struct mount *f;
+       struct mhead *mh, *nmh;
+       struct walkqid *wq;
 
        c = *cp;
-       incref(c);
+       kref_get(&c->ref, 1);
        cname = c->name;
-       incref(cname);
-       mh = nil;
+       kref_get(&cname->ref, 1);
+       mh = NULL;
 
        /*
         * While we haven't gotten all the way down the path:
-        *    1. step through a mount point, if any
+        *    1. step through a mount po int unused_int, if any
         *    2. send a walk request for initial dotdot or initial prefix without dotdot
         *    3. move to the first mountpoint along the way.
         *    4. repeat.
         *
         * An invariant is that each time through the loop, c is on the undomount
-        * side of the mount point, and c's name is cname.
+        * side of the mount po int unused_int, and c's name is cname.
         */
        for(nhave=0; nhave<nnames; nhave+=n){
                if((c->qid.type&QTDIR)==0){
@@ -729,8 +684,8 @@ walk(Chan **cp, char **names, int nnames, int nomount, int *nerror)
                                *nerror = nhave;
                        cnameclose(cname);
                        cclose(c);
-                       strcpy(up->env->errstr, Enotdir);
-                       if(mh != nil)
+                       set_errstr(Enotdir);
+                       if(mh != NULL)
                                putmhead(mh);
                        return -1;
                }
@@ -755,7 +710,7 @@ walk(Chan **cp, char **names, int nnames, int nomount, int *nerror)
                type = c->type;
                dev = c->dev;
 
-               if((wq = devtab[type]->walk(c, nil, names+nhave, ntry)) == nil){
+               if((wq = devtab[type]->walk(c, NULL, names+nhave, ntry)) == NULL){
                        /* try a union mount, if any */
                        if(mh && !nomount){
                                /*
@@ -763,63 +718,63 @@ walk(Chan **cp, char **names, int nnames, int nomount, int *nerror)
                                 */
                                rlock(&mh->lock);
                                for(f = mh->mount->next; f; f = f->next)
-                                       if((wq = devtab[f->to->type]->walk(f->to, nil, names+nhave, ntry)) != nil)
+                                       if((wq = devtab[f->to->type]->walk(f->to, NULL, names+nhave, ntry)) != NULL)
                                                break;
                                runlock(&mh->lock);
-                               if(f != nil){
+                               if(f != NULL){
                                        type = f->to->type;
                                        dev = f->to->dev;
                                }
                        }
-                       if(wq == nil){
+                       if(wq == NULL){
                                cclose(c);
                                cnameclose(cname);
                                if(nerror)
                                        *nerror = nhave+1;
-                               if(mh != nil)
+                               if(mh != NULL)
                                        putmhead(mh);
                                return -1;
                        }
                }
 
-               nmh = nil;
+               nmh = NULL;
                if(dotdot) {
                        assert(wq->nqid == 1);
-                       assert(wq->clone != nil);
+                       assert(wq->clone != NULL);
 
                        cname = addelem(cname, "..");
                        nc = undomount(wq->clone, cname);
                        n = 1;
                } else {
-                       nc = nil;
+                       nc = NULL;
                        if(!nomount)
                                for(i=0; i<wq->nqid && i<ntry-1; i++)
                                        if(findmount(&nc, &nmh, type, dev, wq->qid[i]))
                                                break;
-                       if(nc == nil){  /* no mount points along path */
-                               if(wq->clone == nil){
+                       if(nc == NULL){ /* no mount points along path */
+                               if(wq->clone == NULL){
                                        cclose(c);
                                        cnameclose(cname);
                                        if(wq->nqid==0 || (wq->qid[wq->nqid-1].type&QTDIR)){
                                                if(nerror)
                                                        *nerror = nhave+wq->nqid+1;
-                                               strcpy(up->env->errstr, Edoesnotexist);
+                                               set_errstr(Edoesnotexist);
                                        }else{
                                                if(nerror)
                                                        *nerror = nhave+wq->nqid;
-                                               strcpy(up->env->errstr, Enotdir);
+                                               set_errstr(Enotdir);
                                        }
-                                       free(wq);
-                                       if(mh != nil)
+                                       kfree(wq);
+                                       if(mh != NULL)
                                                putmhead(mh);
                                        return -1;
                                }
                                n = wq->nqid;
                                nc = wq->clone;
                        }else{          /* stopped early, at a mount point */
-                               if(wq->clone != nil){
+                               if(wq->clone != NULL){
                                        cclose(wq->clone);
-                                       wq->clone = nil;
+                                       wq->clone = NULL;
                                }
                                n = i+1;
                        }
@@ -830,17 +785,17 @@ walk(Chan **cp, char **names, int nnames, int nomount, int *nerror)
                c = nc;
                putmhead(mh);
                mh = nmh;
-               free(wq);
+               kfree(wq);
        }
 
        putmhead(mh);
 
        c = cunique(c);
 
-       if(c->umh != nil){      //BUG
-               print("walk umh\n");
+       if(c->umh != NULL){     //BUG
+               printd("walk umh\n");
                putmhead(c->umh);
-               c->umh = nil;
+               c->umh = NULL;
        }
 
        cnameclose(c->name);
@@ -856,11 +811,12 @@ walk(Chan **cp, char **names, int nnames, int nomount, int *nerror)
 /*
  * c is a mounted non-creatable directory.  find a creatable one.
  */
-Chan*
-createdir(Chan *c, Mhead *m)
+struct chan*
+createdir(struct chan *c, struct mhead *m)
 {
-       Chan *nc;
-       Mount *f;
+       ERRSTACK(2);
+       struct chan *nc;
+       struct mount *f;
 
        rlock(&m->lock);
        if(waserror()) {
@@ -880,22 +836,17 @@ createdir(Chan *c, Mhead *m)
        return 0;
 }
 
-void
-saveregisters(void)
-{
-}
-
 /*
  * In place, rewrite name to compress multiple /, eliminate ., and process ..
  */
 void
-cleancname(Cname *n)
+cleancname(struct cname *n)
 {
        char *p;
 
        if(n->s[0] == '#'){
                p = strchr(n->s, '/');
-               if(p == nil)
+               if(p == NULL)
                        return;
                cleanname(p);
 
@@ -917,14 +868,14 @@ growparse(Elemlist *e)
        int *inew;
        enum { Delta = 8 };
 
-       if(e->nelems % Delta == 0){
-               new = smalloc((e->nelems+Delta) * sizeof(char*));
-               memmove(new, e->elems, e->nelems*sizeof(char*));
-               free(e->elems);
+       if(e->ARRAY_SIZEs % Delta == 0){
+               new = kzmalloc((e->ARRAY_SIZEs + Delta) * sizeof(char *), 0);
+               memmove(new, e->elems, e->ARRAY_SIZEs*sizeof( char *));
+               kfree(e->elems);
                e->elems = new;
-               inew = smalloc((e->nelems+Delta+1) * sizeof(int));
-               memmove(inew, e->off, e->nelems*sizeof(int));
-               free(e->off);
+               inew = kzmalloc((e->ARRAY_SIZEs + Delta + 1) * sizeof(int), 0);
+               memmove(inew, e->off, e->ARRAY_SIZEs*sizeof(int));
+               kfree(e->off);
                e->off = inew;
        }
 }
@@ -932,7 +883,7 @@ growparse(Elemlist *e)
 /*
  * The name is known to be valid.
  * Copy the name so slashes can be overwritten.
- * An empty string will set nelem=0.
+ * An empty string will set ARRAY_SIZE=0.
  * A path ending in / or /. or /.//./ etc. will have
  * e.mustbedir = 1, so that we correctly
  * reject, e.g., "/adm/users/." when /adm/users is a file
@@ -945,9 +896,9 @@ parsename(char *name, Elemlist *e)
 
        kstrdup(&e->name, name);
        name = e->name;
-       e->nelems = 0;
-       e->elems = nil;
-       e->off = smalloc(sizeof(int));
+       e->ARRAY_SIZEs = 0;
+       e->elems = NULL;
+       e->off = kzmalloc(sizeof(int), 0);
        e->off[0] = skipslash(name) - name;
        for(;;){
                name = skipslash(name);
@@ -957,14 +908,17 @@ parsename(char *name, Elemlist *e)
                }
                growparse(e);
                
-               e->elems[e->nelems++] = name;
+               e->elems[e->ARRAY_SIZEs++] = name;
+               /* we may want to do this again some day
                slash = utfrune(name, '/');
-               if(slash == nil){
-                       e->off[e->nelems] = name+strlen(name) - e->name;
+               */
+               slash = index(name, '/');
+               if(slash == NULL){
+                       e->off[e->ARRAY_SIZEs] = name+strlen(name) - e->name;
                        e->mustbedir = 0;
                        break;
                }
-               e->off[e->nelems] = slash - e->name;
+               e->off[e->ARRAY_SIZEs] = slash - e->name;
                *slash++ = '\0';
                name = slash;
        }
@@ -973,13 +927,13 @@ parsename(char *name, Elemlist *e)
 void*
 memrchr(void *va, int c, long n)
 {
-       uchar *a, *e;
+       uint8_t *a, *e;
 
        a = va;
        for(e=a+n-1; e>a; e--)
                if(*e == c)
                        return e;
-       return nil;
+       return NULL;
 }
 
 /*
@@ -994,21 +948,22 @@ memrchr(void *va, int c, long n)
  * Opening Atodir, Amount, or Aaccess does not guarantee this.
  *
  * Opening Aaccess can, under certain conditions, return a
- * correct Chan* but with an incorrect Cname attached.
+ * correct Chan* but with an incorrect struct cname attached.
  * Since the functions that open Aaccess (sysstat, syswstat, sys_stat)
- * do not use the Cname*, this avoids an unnecessary clone.
+ * do not use the struct cname*, this avoids an unnecessary clone.
  */
-Chan*
-namec(char *aname, int amode, int omode, ulong perm)
+struct chan*
+namec(char *aname, int amode, int omode, uint32_t perm)
 {
+       ERRSTACK(4);
        int n, prefix, len, t, nomount, npath;
-       Chan *c, *cnew;
-       Cname *cname;
+       struct chan *c, *cnew;
+       struct cname *cname;
        Elemlist e;
-       Rune r;
-       Mhead *m;
+       struct mhead *m;
        char *createerr, tmperrbuf[ERRMAX];
        char *name;
+       // Rune r;
 
        name = aname;
        if(name[0] == '\0')
@@ -1023,23 +978,27 @@ namec(char *aname, int amode, int omode, ulong perm)
        nomount = 0;
        switch(name[0]){
        case '/':
-               c = up->env->pgrp->slash;
-               incref(c);
+               c = current->pgrp->slash;
+               kref_get(&c->ref, 1);
                break;
        
        case '#':
                nomount = 1;
-               up->genbuf[0] = '\0';
+               get_cur_genbuf()[0] = '\0';
                n = 0;
                while(*name!='\0' && (*name != '/' || n < 2)){
-                       if(n >= sizeof(up->genbuf)-1)
+                       if(n >= sizeof(get_cur_genbuf())-1)
                                error(Efilename);
-                       up->genbuf[n++] = *name++;
+                       get_cur_genbuf()[n++] = *name++;
                }
-               up->genbuf[n] = '\0';
-               n = chartorune(&r, up->genbuf+1)+1;
+               get_cur_genbuf()[n] = '\0';
+#if 0
+               n = chartorune(&r, get_cur_genbuf()+1)+1;
                if(r == 'M')
                        error(Enoattach);
+#endif
+               if (get_cur_genbuf()[1] == 'M')
+                       error(Enoattach);
                /*
                 *  the nodevs exceptions are
                 *      |  it only gives access to pipes you create
@@ -1048,31 +1007,34 @@ namec(char *aname, int amode, int omode, ulong perm)
                 *      D private secure sockets name space
                 *      a private TLS name space
                 */
-               if(up->env->pgrp->nodevs &&
-                  (utfrune("|esDa", r) == nil || r == 's' && up->genbuf[n]!='\0'))
+               if(current->pgrp->nodevs &&
+                  //              (utfrune("|esDa", r) == NULL
+                  ((index("|esDa", get_cur_genbuf()[1]) == NULL)
+                   || (get_cur_genbuf()[1] == 's' // || r == 's'
+                       && get_cur_genbuf()[n]!='\0')))
                        error(Enoattach);
-               t = devno(r, 1);
+               t = devno(/*r*/get_cur_genbuf()[1], 1);
                if(t == -1)
                        error(Ebadsharp);
-               c = devtab[t]->attach(up->genbuf+n);
+               c = devtab[t]->attach(get_cur_genbuf()+n);
                break;
 
        default:
-               c = up->env->pgrp->dot;
-               incref(c);
+               c = current->pgrp->dot;
+               kref_get(&c->ref, 1);
                break;
        }
        prefix = name - aname;
 
-       e.name = nil;
-       e.elems = nil;
-       e.off = nil;
-       e.nelems = 0;
+       e.name = NULL;
+       e.elems = NULL;
+       e.off = NULL;
+       e.ARRAY_SIZEs = 0;
        if(waserror()){
                cclose(c);
-               free(e.name);
-               free(e.elems);
-               free(e.off);
+               kfree(e.name);
+               kfree(e.elems);
+               kfree(e.off);
 //dumpmount();
                nexterror();
        }
@@ -1088,55 +1050,61 @@ namec(char *aname, int amode, int omode, ulong perm)
        if(amode == Acreate){
                /* perm must have DMDIR if last element is / or /. */
                if(e.mustbedir && !(perm&DMDIR)){
-                       npath = e.nelems;
-                       strcpy(tmperrbuf, "create without DMDIR");
+                       npath = e.ARRAY_SIZEs;
+                       strncpy(tmperrbuf,  "create without DMDIR", sizeof(tmperrbuf));
                        goto NameError;
                }
 
                /* don't try to walk the last path element just yet. */
-               if(e.nelems == 0)
+               if(e.ARRAY_SIZEs == 0)
                        error(Eexist);
-               e.nelems--;
+               e.ARRAY_SIZEs--;
        }
 
-       if(walk(&c, e.elems, e.nelems, nomount, &npath) < 0){
-               if(npath < 0 || npath > e.nelems){
-                       print("namec %s walk error npath=%d\n", aname, npath);
+       if(walk(&c, e.elems, e.ARRAY_SIZEs, nomount, &npath) < 0){
+               if(npath < 0 || npath > e.ARRAY_SIZEs){
+                       printd("namec %s walk error npath=%d\n", aname, npath);
                        nexterror();
                }
-               strcpy(tmperrbuf, up->env->errstr);
+#warning "fix this mess with errstr and walking"
+#if 0
+               strncpy(tmperrbuf,  current->errstr, sizeof(tmperrbuf));
+#endif
        NameError:
+#if 0
                len = prefix+e.off[npath];
-               if(len < ERRMAX/3 || (name=memrchr(aname, '/', len))==nil || name==aname)
-                       snprint(up->genbuf, sizeof up->genbuf, "%.*s", len, aname);
+               if(len < ERRMAX/3 || (name=memrchr(aname, '/', len))==NULL || name==aname)
+                       snprintf(get_cur_genbuf(), sizeof current->genbuf, "%.*s", len, aname);
                else
-                       snprint(up->genbuf, sizeof up->genbuf, "...%.*s", (int)(len-(name-aname)), name);
-               snprint(up->env->errstr, ERRMAX, "%#q %s", up->genbuf, tmperrbuf);
+                       snprintf(get_cur_genbuf(), sizeof current->genbuf, "...%.*s", (int)(len-(name-aname)), name);
+               snprintf(current->errstr, ERRMAX, "%#q %s", get_cur_genbuf(), tmperrbuf);
+#endif
+               error("some kinda name error");
                nexterror();
        }
 
        if(e.mustbedir && !(c->qid.type&QTDIR)){
-               npath = e.nelems;
-               strcpy(tmperrbuf, "not a directory");
+               npath = e.ARRAY_SIZEs;
+               strncpy(tmperrbuf,  "not a directory", sizeof(tmperrbuf));
                goto NameError;
        }
 
        if(amode == Aopen && (omode&3) == OEXEC && (c->qid.type&QTDIR)){
-               npath = e.nelems;
+               npath = e.ARRAY_SIZEs;
                error("cannot exec directory");
        }
 
        switch(amode){
        case Aaccess:
                if(!nomount)
-                       domount(&c, nil);
+                       domount(&c, NULL);
                break;
 
        case Abind:
-               m = nil;
+               m = NULL;
                if(!nomount)
                        domount(&c, &m);
-               if(c->umh != nil)
+               if(c->umh != NULL)
                        putmhead(c->umh);
                c->umh = m;
                break;
@@ -1146,8 +1114,8 @@ namec(char *aname, int amode, int omode, ulong perm)
        Open:
                /* save the name; domount might change c */
                cname = c->name;
-               incref(cname);
-               m = nil;
+               kref_get(&cname->ref, 1);
+               m = NULL;
                if(!nomount)
                        domount(&c, &m);
 
@@ -1165,10 +1133,10 @@ namec(char *aname, int amode, int omode, ulong perm)
 
                case Aopen:
                case Acreate:
-if(c->umh != nil){
-       print("cunique umh\n");
+if(c->umh != NULL){
+       printd("cunique umh\n");
        putmhead(c->umh);
-       c->umh = nil;
+       c->umh = NULL;
 }
 
                        /* only save the mount head if it's a multiple element union */
@@ -1177,9 +1145,6 @@ if(c->umh != nil){
                        else
                                putmhead(m);
 
-                       /* save registers else error() in open has wrong value of c saved */
-                       saveregisters();
-
                        if(omode == OEXEC)
                                c->flag &= ~CCACHE;
 
@@ -1195,7 +1160,7 @@ if(c->umh != nil){
 
        case Atodir:
                /*
-                * Directories (e.g. for cd) are left before the mount point,
+                * Directories (e.g. for cd) are left before the mount po int unused_int,
                 * so one may mount on / or . and see the effect.
                 */
                if(!(c->qid.type & QTDIR))
@@ -1216,8 +1181,8 @@ if(c->umh != nil){
                 * If the last exists, try to open it OTRUNC.
                 * If omode&OEXCL is set, just give up.
                 */
-               e.nelems++;
-               if(walk(&c, e.elems+e.nelems-1, 1, nomount, nil) == 0){
+               e.ARRAY_SIZEs++;
+               if(walk(&c, e.elems+e.ARRAY_SIZEs-1, 1, nomount, NULL) == 0){
                        if(omode&OEXCL)
                                error(Eexist);
                        omode |= OTRUNC;
@@ -1264,14 +1229,14 @@ if(c->umh != nil){
                 *
                 * The channel staying behind is c, the one moving forward is cnew.
                 */
-               m = nil;
-               cnew = nil;     /* is this assignment necessary? */
+               m = NULL;
+               cnew = NULL;    /* is this assignment necessary? */
                if(!waserror()){        /* try create */
                        if(!nomount && findmount(&cnew, &m, c->type, c->dev, c->qid))
                                cnew = createdir(cnew, m);
                        else{
                                cnew = c;
-                               incref(cnew);
+                               kref_get(&cnew->ref, 1);
                        }
 
                        /*
@@ -1283,9 +1248,9 @@ if(c->umh != nil){
                        cnew = cunique(cnew);
                        cnameclose(cnew->name);
                        cnew->name = c->name;
-                       incref(cnew->name);
+                       kref_get(&cnew->name->ref, 1);
 
-                       devtab[cnew->type]->create(cnew, e.elems[e.nelems-1], omode&~(OEXCL|OCEXEC), perm);
+                       devtab[cnew->type]->create(cnew, e.elems[e.ARRAY_SIZEs-1], omode&~(OEXCL|OCEXEC), perm);
                        poperror();
                        if(omode & OCEXEC)
                                cnew->flag |= CCEXEC;
@@ -1295,7 +1260,7 @@ if(c->umh != nil){
                                putmhead(m);
                        cclose(c);
                        c = cnew;
-                       c->name = addelem(c->name, e.elems[e.nelems-1]);
+                       c->name = addelem(c->name, e.elems[e.ARRAY_SIZEs-1]);
                        break;
                }
 
@@ -1306,14 +1271,18 @@ if(c->umh != nil){
                if(omode & OEXCL)
                        nexterror();
                /* save error */
-               createerr = up->env->errstr;
-               up->env->errstr = tmperrbuf;
+#warning "more mess with errstr"
+#if 0
+               createerr = current->errstr;
+               current->errstr = tmperrbuf;
+#endif
                /* note: we depend that walk does not error */
-               if(walk(&c, e.elems+e.nelems-1, 1, nomount, nil) < 0){
-                       up->env->errstr = createerr;
+               if(walk(&c, e.elems+e.ARRAY_SIZEs-1, 1, nomount, NULL) < 0){
                        error(createerr);       /* report true error */
                }
-               up->env->errstr = createerr;
+#if 0
+               set_errstr(createerr);
+#endif
                omode |= OTRUNC;
                goto Open;
 
@@ -1322,15 +1291,17 @@ if(c->umh != nil){
        }
 
        poperror();
-
+#warning "how big is genbuf?"
        /* place final element in genbuf for e.g. exec */
-       if(e.nelems > 0)
-               kstrcpy(up->genbuf, e.elems[e.nelems-1], sizeof up->genbuf);
+#if 0
+       if(e.ARRAY_SIZEs > 0)
+               kstrncpy(get_cur_genbuf(), e.elems[e.ARRAY_SIZEs-1],  sizeof current->genbuf, sizeof(current->genbuf, e.elems[e.ARRAY_SIZEs-1]));
        else
-               kstrcpy(up->genbuf, ".", sizeof up->genbuf);
-       free(e.name);
-       free(e.elems);
-       free(e.off);
+               kstrncpy(get_cur_genbuf(), ".",  sizeof current->genbuf, sizeof(current->genbuf, "."));
+#endif
+       kfree(e.name);
+       kfree(e.elems);
+       kfree(e.off);
 
        return c;
 }
@@ -1370,24 +1341,26 @@ validname(char *aname, int slashok)
 {
        char *ename, *name;
        int c;
-       Rune r;
 
        name = aname;
        ename = memchr(name, 0, (1<<16));
 
-       if(ename==nil || ename-name>=(1<<16))
+       if(ename==NULL || ename-name>=(1<<16))
                error("name too long");
 
        while(*name){
                /* all characters above '~' are ok */
-               c = *(uchar*)name;
+               c = *( uint8_t *)name;
+#if 0      
                if(c >= Runeself)
                        name += chartorune(&r, name);
-               else{
+#endif
+               if(c >= 0x7f){
+                       error("Akaros doesn't do UTF-8");
+               } else {
                        if(isfrog[c])
                                if(!slashok || c!='/'){
-                                       snprint(up->genbuf, sizeof(up->genbuf), "%s: %q", Ebadchar, aname);
-                                       error(up->genbuf);
+                                       error("%s: %q", Ebadchar, aname);
                        }
                        name++;
                }
@@ -1395,7 +1368,7 @@ validname(char *aname, int slashok)
 }
 
 void
-isdir(Chan *c)
+isdir(struct chan *c)
 {
        if(c->qid.type & QTDIR)
                return;
@@ -1422,10 +1395,10 @@ isdir(Chan *c)
  * This comment might belong somewhere else.
  */
 void
-putmhead(Mhead *m)
+putmhead(struct mhead *m)
 {
-       if(m && decref(m) == 0){
-               m->mount = (Mount*)0xCafeBeef;
-               free(m);
+       if(m && kref_put(&m->ref) == 0){
+               m->mount = (struct mount*)0xCafeBeef;
+               kfree(m);
        }
 }
index 7894bf3..73c3e2c 100644 (file)
@@ -1602,7 +1602,7 @@ void __attribute__((noinline)) __longjmp_wrapper(struct jmpbuf* jb)
 {
        asm ("");
        printk("Starting: %s\n", __FUNCTION__);
-       longjmp(jb, 1);
+       longjmp(jb, (void *)1);
        // Should never get here
        printk("Exiting: %s\n", __FUNCTION__); 
 }
index 7cd8770..829c4dc 100644 (file)
@@ -29,6 +29,8 @@ spatch --sp-file scripts/spatch/locks.cocci --in-place $1
 sh scripts/fixincludes $1
 # Scalars. Idempotent.
 sh scripts/scalar $1
+# remove pragmas. Idempotent.
+sed -i '/^#pragma/d' $1
 # Stuff we might want to think about later. Idempotent
 sh scripts/temporary_hack $1
 # malloc. Idempotent.
index 413216c..43af126 100644 (file)
@@ -13,5 +13,5 @@ sed -i '/^#include/,/^$/c\
 #include <cpio.h>\
 #include <pmap.h>\
 #include <smp.h>\
-#include <fcall.h>\
+#include <ns.h>\
 ' $1
index 4bf5cb8..f1186f2 100644 (file)
@@ -1,4 +1,16 @@
 @@
+typedef Cname;
+@@
+-Cname
++struct cname
+
+@@
+typedef Fmt;
+@@
+-Fmt
++struct fmt
+
+@@
 typedef Ipifc;
 @@
 -Ipifc