Add a bulk interface to sem_down()
[akaros.git] / kern / src / ns / convM2D.c
index a0ba36c..1492751 100644 (file)
@@ -6,7 +6,7 @@
  *
  * Modified for the Akaros operating system:
  * Copyright (c) 2013-2014 The Regents of the University of California
- * Copyright (c) 2013-2015 Google Inc.
+ * Copyright (c) 2013-2018 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
@@ -26,8 +26,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE. */
 
-#include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
@@ -40,6 +38,8 @@
 #include <smp.h>
 #include <net/ip.h>
 
+/* It looks like the intent of this code is to check any stat that we, the
+ * kernel or our userspace, send out. */
 int statcheck(uint8_t * buf, unsigned int nbuf)
 {
        uint8_t *ebuf;
@@ -47,26 +47,38 @@ int statcheck(uint8_t * buf, unsigned int nbuf)
 
        ebuf = buf + nbuf;
 
-       if (nbuf < STATFIXLEN || nbuf != BIT16SZ + GBIT16(buf)){
-               printk("nbuf %d, STATFIXLEN %d ", nbuf, STATFIXLEN);
+       if (nbuf < STAT_FIX_LEN_9P || nbuf != BIT16SZ + GBIT16(buf)) {
+               printk("nbuf %d, STAT_FIX_LEN_9P %d ", nbuf, STAT_FIX_LEN_9P);
                printk("BIT16SZ %d, GBIT16(buf) %d ",
                        BIT16SZ, GBIT16(buf));
                printk("This is bad!\n");
                return -1;
        }
 
-       buf += STATFIXLEN - 4 * BIT16SZ;
+       buf += STAT_FIX_LEN_9P - STAT_NR_STRINGS_9P * BIT16SZ;
 
-       for (i = 0; i < 4; i++) {
+       /* Check the legacy strings that all stats have. */
+       for (i = 0; i < STAT_NR_STRINGS_9P; i++) {
                if (buf + BIT16SZ > ebuf)
                        return -1;
                buf += BIT16SZ + GBIT16(buf);
        }
+       /* Legacy 9p stats are OK
+        * TODO: consider removing this.  We get them from userspace, e.g. mkdir. */
+       if (buf == ebuf)
+               return 0;
 
-       if (buf != ebuf){
-               return -1;
+       for (i = STAT_NR_STRINGS_9P; i < STAT_NR_STRINGS_AK; i++) {
+               if (buf + BIT16SZ > ebuf)
+                       return -1;
+               buf += BIT16SZ + GBIT16(buf);
        }
 
+       if (buf + __STAT_FIX_LEN_AK_NONSTRING > ebuf)
+               return -1;
+       buf += __STAT_FIX_LEN_AK_NONSTRING;
+       if (buf != ebuf)
+               return -1;
        return 0;
 }
 
@@ -76,42 +88,55 @@ unsigned int
 convM2D(uint8_t * buf, unsigned int nbuf, struct dir *d, char *strs)
 {
        uint8_t *p, *ebuf;
-       char *sv[4];
+       char *sv[STAT_NR_STRINGS_AK] = {nullstring};
        int i, ns;
+       bool good_stat = false;
+       size_t msg_sz = 0;
 
-       if (nbuf < STATFIXLEN)
+       if (nbuf < STAT_FIX_LEN_9P)
                return 0;
 
-       p = buf;
-       ebuf = buf + nbuf;
+       /* This M might not have all the fields we expect.  We'll ensure the strings
+        * have the right values later.  We still need to initialize all of the
+        * non-string extended fields. */
+       init_empty_dir(d);
 
-       p += BIT16SZ;   /* ignore size */
-       d->type = GBIT16(p);
-       p += BIT16SZ;
-       d->dev = GBIT32(p);
-       p += BIT32SZ;
-       d->qid.type = GBIT8(p);
-       p += BIT8SZ;
-       d->qid.vers = GBIT32(p);
-       p += BIT32SZ;
-       d->qid.path = GBIT64(p);
-       p += BIT64SZ;
-       d->mode = GBIT32(p);
-       p += BIT32SZ;
-       d->atime = GBIT32(p);
-       p += BIT32SZ;
-       d->mtime = GBIT32(p);
-       p += BIT32SZ;
-       d->length = GBIT64(p);
-       p += BIT64SZ;
-
-       for (i = 0; i < 4; i++) {
+       p = buf;
+       /* They might have given us more than one M, so we need to use the size
+        * field to determine the real end of this M. */
+       msg_sz = GBIT16(p) + BIT16SZ;
+       ebuf = buf + MIN(nbuf, msg_sz);
+
+       p += BIT16SZ;   /* jump over size */
+       d->type = GBIT16(p);            p += BIT16SZ;
+       d->dev = GBIT32(p);             p += BIT32SZ;
+       d->qid.type = GBIT8(p);         p += BIT8SZ;
+       d->qid.vers = GBIT32(p);        p += BIT32SZ;
+       d->qid.path = GBIT64(p);        p += BIT64SZ;
+       d->mode = GBIT32(p);            p += BIT32SZ;
+       /* Get a first attempt at atime/mtime.  Revisit this in 2038. */
+       d->atime.tv_sec = GBIT32(p);    p += BIT32SZ;
+       d->mtime.tv_sec = GBIT32(p);    p += BIT32SZ;
+       d->length = GBIT64(p);          p += BIT64SZ;
+
+       /* They might have asked for -1, meaning "don't touch".  Need to convert
+        * that to our 64 bit times. */
+       if ((int32_t)d->atime.tv_sec == -1)
+               d->atime.tv_sec = ~0;
+       if ((int32_t)d->mtime.tv_sec == -1)
+               d->mtime.tv_sec = ~0;
+
+       /* Anything beyond the legacy 9p strings might not be supported.  Though if
+        * you have more, you probably have at least EVH's 9p2000.u extensions.
+        * Once we get all of the legacy strings, we have a good stat. */
+       for (i = 0; i < STAT_NR_STRINGS_AK; i++) {
+               if (i == STAT_NR_STRINGS_9P)
+                       good_stat = true;
                if (p + BIT16SZ > ebuf)
-                       return 0;
-               ns = GBIT16(p);
-               p += BIT16SZ;
+                       goto out;
+               ns = GBIT16(p); p += BIT16SZ;
                if (p + ns > ebuf)
-                       return 0;
+                       goto out;
                if (strs) {
                        sv[i] = strs;
                        memmove(strs, p, ns);
@@ -121,17 +146,33 @@ convM2D(uint8_t * buf, unsigned int nbuf, struct dir *d, char *strs)
                p += ns;
        }
 
-       if (strs) {
-               d->name = sv[0];
-               d->uid = sv[1];
-               d->gid = sv[2];
-               d->muid = sv[3];
-       } else {
-               d->name = nullstring;
-               d->uid = nullstring;
-               d->gid = nullstring;
-               d->muid = nullstring;
-       }
-
+       /* Check for 9p2000.u */
+       if (p + 3 * BIT32SZ > ebuf)
+               goto out;
+       d->n_uid = GBIT32(p);           p += BIT32SZ;
+       d->n_gid = GBIT32(p);           p += BIT32SZ;
+       d->n_muid = GBIT32(p);          p += BIT32SZ;
+
+       /* Check for extended timespecs */
+       if (p + 4 * (2 * BIT64SZ) > ebuf)
+               goto out;
+       d->atime.tv_sec = GBIT64(p);    p += BIT64SZ;
+       d->atime.tv_nsec = GBIT64(p);   p += BIT64SZ;
+       d->btime.tv_sec = GBIT64(p);    p += BIT64SZ;
+       d->btime.tv_nsec = GBIT64(p);   p += BIT64SZ;
+       d->ctime.tv_sec = GBIT64(p);    p += BIT64SZ;
+       d->ctime.tv_nsec = GBIT64(p);   p += BIT64SZ;
+       d->mtime.tv_sec = GBIT64(p);    p += BIT64SZ;
+       d->mtime.tv_nsec = GBIT64(p);   p += BIT64SZ;
+
+       /* Fall-through */
+out:
+       if (!good_stat)
+               return 0;
+       d->name = sv[0];
+       d->uid = sv[1];
+       d->gid = sv[2];
+       d->muid = sv[3];
+       d->ext = sv[4];
        return p - buf;
 }