Implement sys_open() with sys_openat() (XCC)
[akaros.git] / kern / src / ns / sysfile.c
index cb18513..af0224c 100644 (file)
@@ -43,34 +43,21 @@ struct chan *fdtochan(struct fd_table *fdt, int fd, int mode, int chkmnt,
                set_errno(EBADF);
                error("Bad FD %d\n", fd);
        }
-
        if (chkmnt && (c->flag & CMSG)) {
                if (iref)
                        cclose(c);
+               set_errno(EBADF);
                error(Ebadusefd);
        }
-
-       if (mode < 0 || c->mode == ORDWR) {
+       if (mode < 0)
                return c;
-       }
-
-       if ((mode & OTRUNC) && !(c->mode & O_WRITE)) {
-               if (iref)
-                       cclose(c);
-               error(Ebadusefd);
-       }
-
-       /* TODO: this is probably wrong.  if you get this from a dev, in the dev's
-        * open, you are probably saving mode directly, without passing it through
-        * openmode. */
-       if ((mode & ~OTRUNC) != c->mode) {
-               warn("Trunc mode issue: mode %o, mode minus trunc %o, chan mode %o\n",
-                        mode, mode & ~OTRUNC, c->mode);
+       if ((mode & c->mode) != mode) {
                if (iref)
                        cclose(c);
-               error(Ebadusefd);
+               set_errno(EBADF);
+               error("FD access mode failure: chan mode 0x%x, wanted 0x%x",
+                     c->mode, mode);
        }
-
        return c;
 }
 
@@ -108,7 +95,10 @@ int openmode(uint32_t omode)
        /* this is the old plan9 style.  i think they want to turn exec into read,
         * and strip off anything higher, and just return the RD/WR style bits.  not
         * stuff like ORCLOSE.  the lack of OEXCL might be a bug on their part (it's
-        * the only one of their non-RW-related flags that isn't masked out) */
+        * the only one of their non-RW-related flags that isn't masked out).
+        *
+        * Note that we no longer convert OEXEC/O_EXEC to O_READ, and instead return
+        * just the O_ACCMODE bits. */
        if (o >= (OTRUNC | OCEXEC | ORCLOSE | OEXEC))
                error(Ebadarg);
        o &= ~(OTRUNC | OCEXEC | ORCLOSE);
@@ -120,9 +110,6 @@ int openmode(uint32_t omode)
 #endif
        /* no error checking (we have a shitload of flags anyway), and we return the
         * basic access modes (RD/WR/ETC) */
-       if (omode == O_EXEC) {
-       return O_RDONLY;
-       }
        return omode & O_ACCMODE;
 }
 
@@ -181,7 +168,7 @@ int syscreate(char *path, int mode, uint32_t perm)
                return -1;
        }
 
-       openmode(mode & ~OEXCL);        /* error check only; OEXCL okay here */
+       openmode(mode & ~O_EXCL);       /* error check only; OEXCL okay here */
        c = namec(path, Acreate, mode, perm);
        if (waserror()) {
                cclose(c);
@@ -284,7 +271,7 @@ int sysfauth(int fd, char *aname)
        }
 
        validname(aname, 0);
-       c = fdtochan(&current->open_files, fd, ORDWR, 0, 1);
+       c = fdtochan(&current->open_files, fd, O_RDWR, 0, 1);
        if (waserror()) {
                cclose(c);
                nexterror();
@@ -326,7 +313,7 @@ int sysfversion(int fd, unsigned int msize, char *vers, unsigned int arglen)
        if (arglen == 0 || memchr(vers, 0, arglen) == 0)
                error(Ebadarg);
 
-       c = fdtochan(&current->open_files, fd, ORDWR, 0, 1);
+       c = fdtochan(&current->open_files, fd, O_RDWR, 0, 1);
        if (waserror()) {
                cclose(c);
                nexterror();
@@ -348,8 +335,8 @@ int syspipe(int fd[2])
        struct chan *c[2];
        static char *names[] = { "data", "data1" };
 
-       d = &devtab[devno('|', 0)];
-       c[0] = namec("#|", Atodir, 0, 0);
+       d = &devtab[devno("pipe", 0)];
+       c[0] = 0;
        c[1] = 0;
        fd[0] = -1;
        fd[1] = -1;
@@ -369,13 +356,14 @@ int syspipe(int fd[2])
                poperror();
                return -1;
        }
+       c[0] = namec("#pipe", Atodir, 0, 0);
        c[1] = cclone(c[0]);
-       if (walk(&c[0], &names[0], 1, 1, NULL) < 0)
+       if (walk(&c[0], &names[0], 1, FALSE, NULL) < 0)
                error(Egreg);
-       if (walk(&c[1], &names[1], 1, 1, NULL) < 0)
+       if (walk(&c[1], &names[1], 1, FALSE, NULL) < 0)
                error(Egreg);
-       c[0] = d->open(c[0], ORDWR);
-       c[1] = d->open(c[1], ORDWR);
+       c[0] = d->open(c[0], O_RDWR);
+       c[1] = d->open(c[1], O_RDWR);
        fd[0] = newfd(c[0], 0);
        if (fd[0] < 0)
                error(Enofd);
@@ -480,14 +468,14 @@ int sysmount(int fd, int afd, char *old, int flags, char *spec)
                poperror();
                return -1;
        }
-       bc.c = fdtochan(&current->open_files, fd, ORDWR, 0, 1);
+       bc.c = fdtochan(&current->open_files, fd, O_RDWR, 0, 1);
        if (afd >= 0)
-               ac.c = fdtochan(&current->open_files, afd, ORDWR, 0, 1);
+               ac.c = fdtochan(&current->open_files, afd, O_RDWR, 0, 1);
        mntparam.chan = bc.c;
        mntparam.authchan = ac.c;
        mntparam.spec = spec;
        mntparam.flags = flags;
-       c0.c = devtab[devno('M', 0)].attach((char *)&mntparam);
+       c0.c = devtab[devno("mnt", 0)].attach((char *)&mntparam);
 
        r = bindmount(c0.c, old, flags, spec);
        poperror();
@@ -525,7 +513,7 @@ int sysunmount(char *src_path, char *onto_path)
                 * opening it is the only way to get at the real
                 * Chan underneath.
                 */
-               cmounted.c = namec(src_path, Aopen, OREAD, 0);
+               cmounted.c = namec(src_path, Aopen, O_READ, 0);
        }
 
        cunmount(cmount.c, cmounted.c);
@@ -535,32 +523,40 @@ int sysunmount(char *src_path, char *onto_path)
        return 0;
 }
 
-int sysopen(char *path, int vfs_flags)
+int sysopenat(int fromfd, char *path, int vfs_flags)
 {
-       ERRSTACK(2);
+       ERRSTACK(1);
        int fd;
-       struct chan *c;
+       struct chan *c = 0, *from = 0;
 
        if (waserror()) {
+               cclose(c);
                poperror();
                return -1;
        }
-
        openmode(vfs_flags);    /* error check only */
-       c = namec(path, Aopen, vfs_flags, 0);
-       if (waserror()) {
-               cclose(c);
-               nexterror();
+       if ((path[0] == '/') || (fromfd == AT_FDCWD)) {
+               c = namec(path, Aopen, vfs_flags, 0);
+       } else {
+               /* We don't cclose from.  namec_from will convert it to the new chan
+                * during the walk process (c).  It'll probably close from internally,
+                * and give us something new for c.  On error, namec_from will cclose
+                * from. */
+               from = fdtochan(&current->open_files, fromfd, -1, FALSE, TRUE);
+               c = namec_from(from, path, Aopen, vfs_flags, 0);
        }
        fd = newfd(c, vfs_flags);
        if (fd < 0)
                error(Enofd);
        poperror();
-
-       poperror();
        return fd;
 }
 
+int sysopen(char *path, int vfs_flags)
+{
+       return sysopenat(AT_FDCWD, path, vfs_flags);
+}
+
 long unionread(struct chan *c, void *va, long n)
 {
        ERRSTACK(1);
@@ -593,7 +589,8 @@ long unionread(struct chan *c, void *va, long n)
                        } else {
                                if (c->umc == NULL) {
                                        c->umc = cclone(mount->to);
-                                       c->umc = devtab[c->umc->type].open(c->umc, OREAD);
+                                       c->umc = devtab[c->umc->type].open(c->umc,
+                                                                          O_READ);
                                }
 
                                nr = devtab[c->umc->type].read(c->umc, va, n, c->umc->offset);
@@ -645,7 +642,7 @@ static long rread(int fd, void *va, long n, int64_t * offp)
                return -1;
        }
 
-       c = fdtochan(&current->open_files, fd, OREAD, 1, 1);
+       c = fdtochan(&current->open_files, fd, O_READ, 1, 1);
        if (waserror()) {
                cclose(c);
                nexterror();
@@ -819,7 +816,9 @@ int64_t sysseek(int fd, int64_t off, int whence)
                nexterror();
        }
 
-       if (devtab[c->type].dc == '|')
+       /* TODO: WTF is this?  Is pipe magically the only device that isn't
+        * seekable? */
+       if (!strcmp(devtab[c->type].name, "pipe"))
                error(Eisstream);
 
        switch (whence) {
@@ -992,7 +991,7 @@ static long rwrite(int fd, void *va, long n, int64_t * offp)
                poperror();
                return -1;
        }
-       c = fdtochan(&current->open_files, fd, OWRITE, 1, 1);
+       c = fdtochan(&current->open_files, fd, O_WRITE, 1, 1);
        if (waserror()) {
                cclose(c);
                nexterror();
@@ -1006,7 +1005,7 @@ static long rwrite(int fd, void *va, long n, int64_t * offp)
        if (offp == NULL) {
                /* append changes the offset to the end, and even if we fail later, this
                 * change will persist */
-               if (c->flag & CAPPEND) {
+               if (c->flag & O_APPEND) {
                        dir = chandirstat(c);
                        if (!dir)
                                error("internal error: stat error in append write");
@@ -1329,11 +1328,11 @@ int plan9setup(struct proc *new_proc, struct proc *parent, int flags)
                 * switch_to() also loads the cr3. */
                new_proc->pgrp = newpgrp();
                old_current = switch_to(new_proc);
-               new_proc->slash = namec("#r", Atodir, 0, 0);
+               new_proc->slash = namec("#root", Atodir, 0, 0);
                if (!new_proc->slash)
                        panic("no root device");
                switch_back(new_proc, old_current);
-               /* Want the name to be "/" instead of "#r" */
+               /* Want the name to be "/" instead of "#root" */
                cnameclose(new_proc->slash->name);
                new_proc->slash->name = newcname("/");
                new_proc->dot = cclone(new_proc->slash);
@@ -1430,6 +1429,10 @@ int fd_setfl(int fd, int flags)
                set_errno(EINVAL);
                error("can't toggle O_CLOEXEC with setfl");
        }
+       if (cexternal_flags_differ(flags, c->flag, O_PATH)) {
+               set_errno(EINVAL);
+               error("can't toggle O_PATH with setfl");
+       }
        if (cexternal_flags_differ(flags, c->flag, O_NONBLOCK)) {
                /* If we want to let them toggle NONBLOCK, it'd require a device op */
                set_errno(EINVAL);