9ns: Fix issues with can_have_children
[akaros.git] / kern / src / ns / convS2M.c
index c7babdf..b70cb0f 100644 (file)
@@ -1,6 +1,31 @@
-// INFERNO
-#include <vfs.h>
-#include <kfs.h>
+/* Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+ * Portions Copyright © 1997-1999 Vita Nuova Limited
+ * Portions Copyright © 2000-2007 Vita Nuova Holdings Limited
+ *                                (www.vitanuova.com)
+ * Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+ *
+ * Modified for the Akaros operating system:
+ * Copyright (c) 2013-2014 The Regents of the University of California
+ * Copyright (c) 2013-2015 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE. */
+
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <cpio.h>
 #include <pmap.h>
 #include <smp.h>
-#include <ip.h>
+#include <net/ip.h>
 
 static
-uint8_t*
-pstring(uint8_t *p, char *s)
+uint8_t *pstring(uint8_t * p, char *s)
 {
        unsigned int n;
 
-       if(s == NULL){
+       if (s == NULL) {
                PBIT16(p, 0);
                p += BIT16SZ;
                return p;
@@ -34,8 +58,7 @@ pstring(uint8_t *p, char *s)
 }
 
 static
-uint8_t*
-pqid(uint8_t *p, struct qid *q)
+uint8_t *pqid(uint8_t * p, struct qid *q)
 {
        PBIT8(p, q->type);
        p += BIT8SZ;
@@ -47,17 +70,15 @@ pqid(uint8_t *p, struct qid *q)
 }
 
 static
-unsigned int
-stringsz(char *s)
+unsigned int stringsz(char *s)
 {
-       if(s == NULL)
+       if (s == NULL)
                return BIT16SZ;
 
-       return BIT16SZ+strlen(s);
+       return BIT16SZ + strlen(s);
 }
 
-unsigned int
-sizeS2M(struct fcall *f)
+unsigned int sizeS2M(struct fcall *f)
 {
        unsigned int n;
        int i;
@@ -67,153 +88,151 @@ sizeS2M(struct fcall *f)
        n += BIT8SZ;    /* type */
        n += BIT16SZ;   /* tag */
 
-       switch(f->type)
-       {
-       default:
-               return 0;
+       switch (f->type) {
+               default:
+                       return 0;
 
-       case Tversion:
-               n += BIT32SZ;
-               n += stringsz(f->version);
-               break;
-
-       case Tflush:
-               n += BIT16SZ;
-               break;
-
-       case Tauth:
-               n += BIT32SZ;
-               n += stringsz(f->uname);
-               n += stringsz(f->aname);
-               break;
-
-       case Tattach:
-               n += BIT32SZ;
-               n += BIT32SZ;
-               n += stringsz(f->uname);
-               n += stringsz(f->aname);
-               break;
-
-       case Twalk:
-               n += BIT32SZ;
-               n += BIT32SZ;
-               n += BIT16SZ;
-               for(i=0; i<f->nwname; i++)
-                       n += stringsz(f->wname[i]);
-               break;
-
-       case Topen:
-               n += BIT32SZ;
-               n += BIT8SZ;
-               break;
-
-       case Tcreate:
-               n += BIT32SZ;
-               n += stringsz(f->name);
-               n += BIT32SZ;
-               n += BIT8SZ;
-               break;
-
-       case Tread:
-               n += BIT32SZ;
-               n += BIT64SZ;
-               n += BIT32SZ;
-               break;
-
-       case Twrite:
-               n += BIT32SZ;
-               n += BIT64SZ;
-               n += BIT32SZ;
-               n += f->count;
-               break;
-
-       case Tclunk:
-       case Tremove:
-               n += BIT32SZ;
-               break;
-
-       case Tstat:
-               n += BIT32SZ;
-               break;
-
-       case Twstat:
-               n += BIT32SZ;
-               n += BIT16SZ;
-               n += f->nstat;
-               break;
+               case Tversion:
+                       n += BIT32SZ;
+                       n += stringsz(f->version);
+                       break;
+
+               case Tflush:
+                       n += BIT16SZ;
+                       break;
+
+               case Tauth:
+                       n += BIT32SZ;
+                       n += stringsz(f->uname);
+                       n += stringsz(f->aname);
+                       break;
+
+               case Tattach:
+                       n += BIT32SZ;
+                       n += BIT32SZ;
+                       n += stringsz(f->uname);
+                       n += stringsz(f->aname);
+                       break;
+
+               case Twalk:
+                       n += BIT32SZ;
+                       n += BIT32SZ;
+                       n += BIT16SZ;
+                       for (i = 0; i < f->nwname; i++)
+                               n += stringsz(f->wname[i]);
+                       break;
+
+               case Topen:
+                       n += BIT32SZ;
+                       n += BIT8SZ;
+                       break;
+
+               case Tcreate:
+                       n += BIT32SZ;
+                       n += stringsz(f->name);
+                       n += BIT32SZ;
+                       n += BIT8SZ;
+                       break;
+
+               case Tread:
+                       n += BIT32SZ;
+                       n += BIT64SZ;
+                       n += BIT32SZ;
+                       break;
+
+               case Twrite:
+                       n += BIT32SZ;
+                       n += BIT64SZ;
+                       n += BIT32SZ;
+                       n += f->count;
+                       break;
+
+               case Tclunk:
+               case Tremove:
+                       n += BIT32SZ;
+                       break;
+
+               case Tstat:
+                       n += BIT32SZ;
+                       break;
+
+               case Twstat:
+                       n += BIT32SZ;
+                       n += BIT16SZ;
+                       n += f->nstat;
+                       break;
 /*
  */
 
-       case Rversion:
-               n += BIT32SZ;
-               n += stringsz(f->version);
-               break;
+               case Rversion:
+                       n += BIT32SZ;
+                       n += stringsz(f->version);
+                       break;
 
-       case Rerror:
-               n += stringsz(f->ename);
-               break;
+               case Rerror:
+                       n += stringsz(f->ename);
+                       break;
 
-       case Rflush:
-               break;
+               case Rflush:
+                       break;
 
-       case Rauth:
-               n += QIDSZ;
-               break;
+               case Rauth:
+                       n += QIDSZ;
+                       break;
 
-       case Rattach:
-               n += QIDSZ;
-               break;
+               case Rattach:
+                       n += QIDSZ;
+                       break;
 
-       case Rwalk:
-               n += BIT16SZ;
-               n += f->nwqid*QIDSZ;
-               break;
+               case Rwalk:
+                       n += BIT16SZ;
+                       n += f->nwqid * QIDSZ;
+                       break;
 
-       case Ropen:
-       case Rcreate:
-               n += QIDSZ;
-               n += BIT32SZ;
-               break;
+               case Ropen:
+               case Rcreate:
+                       n += QIDSZ;
+                       n += BIT32SZ;
+                       break;
 
-       case Rread:
-               n += BIT32SZ;
-               n += f->count;
-               break;
+               case Rread:
+                       n += BIT32SZ;
+                       n += f->count;
+                       break;
 
-       case Rwrite:
-               n += BIT32SZ;
-               break;
+               case Rwrite:
+                       n += BIT32SZ;
+                       break;
 
-       case Rclunk:
-               break;
+               case Rclunk:
+                       break;
 
-       case Rremove:
-               break;
+               case Rremove:
+                       break;
 
-       case Rstat:
-               n += BIT16SZ;
-               n += f->nstat;
-               break;
+               case Rstat:
+                       n += BIT16SZ;
+                       n += f->nstat;
+                       break;
 
-       case Rwstat:
-               break;
+               case Rwstat:
+                       break;
        }
        return n;
 }
 
-unsigned int
-convS2M(struct fcall *f, uint8_t *ap, unsigned int nap)
+unsigned int convS2M(struct fcall *f, uint8_t * ap, unsigned int nap)
 {
        uint8_t *p;
        unsigned int i, size;
 
        size = sizeS2M(f);
-       if(size == 0)
+       if (size == 0)
                return 0;
-       if(size > nap)
+       if (size > nap)
                return 0;
 
-       p = ( uint8_t *)ap;
+       p = (uint8_t *) ap;
 
        PBIT32(p, size);
        p += BIT32SZ;
@@ -222,176 +241,175 @@ convS2M(struct fcall *f, uint8_t *ap, unsigned int nap)
        PBIT16(p, f->tag);
        p += BIT16SZ;
 
-       switch(f->type)
-       {
-       default:
-               return 0;
-
-       case Tversion:
-               PBIT32(p, f->msize);
-               p += BIT32SZ;
-               p = pstring(p, f->version);
-               break;
-
-       case Tflush:
-               PBIT16(p, f->oldtag);
-               p += BIT16SZ;
-               break;
-
-       case Tauth:
-               PBIT32(p, f->afid);
-               p += BIT32SZ;
-               p  = pstring(p, f->uname);
-               p  = pstring(p, f->aname);
-               break;
-
-       case Tattach:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               PBIT32(p, f->afid);
-               p += BIT32SZ;
-               p  = pstring(p, f->uname);
-               p  = pstring(p, f->aname);
-               break;
-
-       case Twalk:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               PBIT32(p, f->newfid);
-               p += BIT32SZ;
-               PBIT16(p, f->nwname);
-               p += BIT16SZ;
-               if(f->nwname > MAXWELEM)
+       switch (f->type) {
+               default:
                        return 0;
-               for(i=0; i<f->nwname; i++)
-                       p = pstring(p, f->wname[i]);
-               break;
-
-       case Topen:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               PBIT8(p, f->mode);
-               p += BIT8SZ;
-               break;
-
-       case Tcreate:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               p = pstring(p, f->name);
-               PBIT32(p, f->perm);
-               p += BIT32SZ;
-               PBIT8(p, f->mode);
-               p += BIT8SZ;
-               break;
-
-       case Tread:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               PBIT64(p, f->offset);
-               p += BIT64SZ;
-               PBIT32(p, f->count);
-               p += BIT32SZ;
-               break;
-
-       case Twrite:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               PBIT64(p, f->offset);
-               p += BIT64SZ;
-               PBIT32(p, f->count);
-               p += BIT32SZ;
-               memmove(p, f->data, f->count);
-               p += f->count;
-               break;
-
-       case Tclunk:
-       case Tremove:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               break;
-
-       case Tstat:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               break;
-
-       case Twstat:
-               PBIT32(p, f->fid);
-               p += BIT32SZ;
-               PBIT16(p, f->nstat);
-               p += BIT16SZ;
-               memmove(p, f->stat, f->nstat);
-               p += f->nstat;
-               break;
+
+               case Tversion:
+                       PBIT32(p, f->msize);
+                       p += BIT32SZ;
+                       p = pstring(p, f->version);
+                       break;
+
+               case Tflush:
+                       PBIT16(p, f->oldtag);
+                       p += BIT16SZ;
+                       break;
+
+               case Tauth:
+                       PBIT32(p, f->afid);
+                       p += BIT32SZ;
+                       p = pstring(p, f->uname);
+                       p = pstring(p, f->aname);
+                       break;
+
+               case Tattach:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       PBIT32(p, f->afid);
+                       p += BIT32SZ;
+                       p = pstring(p, f->uname);
+                       p = pstring(p, f->aname);
+                       break;
+
+               case Twalk:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       PBIT32(p, f->newfid);
+                       p += BIT32SZ;
+                       PBIT16(p, f->nwname);
+                       p += BIT16SZ;
+                       if (f->nwname > MAXWELEM)
+                               return 0;
+                       for (i = 0; i < f->nwname; i++)
+                               p = pstring(p, f->wname[i]);
+                       break;
+
+               case Topen:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       PBIT8(p, f->mode);
+                       p += BIT8SZ;
+                       break;
+
+               case Tcreate:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       p = pstring(p, f->name);
+                       PBIT32(p, f->perm);
+                       p += BIT32SZ;
+                       PBIT8(p, f->mode);
+                       p += BIT8SZ;
+                       break;
+
+               case Tread:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       PBIT64(p, f->offset);
+                       p += BIT64SZ;
+                       PBIT32(p, f->count);
+                       p += BIT32SZ;
+                       break;
+
+               case Twrite:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       PBIT64(p, f->offset);
+                       p += BIT64SZ;
+                       PBIT32(p, f->count);
+                       p += BIT32SZ;
+                       memmove(p, f->data, f->count);
+                       p += f->count;
+                       break;
+
+               case Tclunk:
+               case Tremove:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       break;
+
+               case Tstat:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       break;
+
+               case Twstat:
+                       PBIT32(p, f->fid);
+                       p += BIT32SZ;
+                       PBIT16(p, f->nstat);
+                       p += BIT16SZ;
+                       memmove(p, f->stat, f->nstat);
+                       p += f->nstat;
+                       break;
 /*
  */
 
-       case Rversion:
-               PBIT32(p, f->msize);
-               p += BIT32SZ;
-               p = pstring(p, f->version);
-               break;
-
-       case Rerror:
-               p = pstring(p, f->ename);
-               break;
-
-       case Rflush:
-               break;
-
-       case Rauth:
-               p = pqid(p, &f->aqid);
-               break;
-
-       case Rattach:
-               p = pqid(p, &f->qid);
-               break;
-
-       case Rwalk:
-               PBIT16(p, f->nwqid);
-               p += BIT16SZ;
-               if(f->nwqid > MAXWELEM)
-                       return 0;
-               for(i=0; i<f->nwqid; i++)
-                       p = pqid(p, &f->wqid[i]);
-               break;
-
-       case Ropen:
-       case Rcreate:
-               p = pqid(p, &f->qid);
-               PBIT32(p, f->iounit);
-               p += BIT32SZ;
-               break;
-
-       case Rread:
-               PBIT32(p, f->count);
-               p += BIT32SZ;
-               memmove(p, f->data, f->count);
-               p += f->count;
-               break;
-
-       case Rwrite:
-               PBIT32(p, f->count);
-               p += BIT32SZ;
-               break;
-
-       case Rclunk:
-               break;
-
-       case Rremove:
-               break;
-
-       case Rstat:
-               PBIT16(p, f->nstat);
-               p += BIT16SZ;
-               memmove(p, f->stat, f->nstat);
-               p += f->nstat;
-               break;
-
-       case Rwstat:
-               break;
+               case Rversion:
+                       PBIT32(p, f->msize);
+                       p += BIT32SZ;
+                       p = pstring(p, f->version);
+                       break;
+
+               case Rerror:
+                       p = pstring(p, f->ename);
+                       break;
+
+               case Rflush:
+                       break;
+
+               case Rauth:
+                       p = pqid(p, &f->aqid);
+                       break;
+
+               case Rattach:
+                       p = pqid(p, &f->qid);
+                       break;
+
+               case Rwalk:
+                       PBIT16(p, f->nwqid);
+                       p += BIT16SZ;
+                       if (f->nwqid > MAXWELEM)
+                               return 0;
+                       for (i = 0; i < f->nwqid; i++)
+                               p = pqid(p, &f->wqid[i]);
+                       break;
+
+               case Ropen:
+               case Rcreate:
+                       p = pqid(p, &f->qid);
+                       PBIT32(p, f->iounit);
+                       p += BIT32SZ;
+                       break;
+
+               case Rread:
+                       PBIT32(p, f->count);
+                       p += BIT32SZ;
+                       memmove(p, f->data, f->count);
+                       p += f->count;
+                       break;
+
+               case Rwrite:
+                       PBIT32(p, f->count);
+                       p += BIT32SZ;
+                       break;
+
+               case Rclunk:
+                       break;
+
+               case Rremove:
+                       break;
+
+               case Rstat:
+                       PBIT16(p, f->nstat);
+                       p += BIT16SZ;
+                       memmove(p, f->stat, f->nstat);
+                       p += f->nstat;
+                       break;
+
+               case Rwstat:
+                       break;
        }
-       if(size != p-ap)
+       if (size != p - ap)
                return 0;
        return size;
 }