Start providing support for 9 namespaces.
authorRonald G. Minnich <rminnich@google.com>
Fri, 17 Jan 2014 23:39:49 +0000 (15:39 -0800)
committerRonald G. Minnich <rminnich@google.com>
Fri, 17 Jan 2014 23:39:49 +0000 (15:39 -0800)
No longer boots, hurrah!

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
kern/include/ns.h
kern/src/ns/sysfile.c
kern/src/syscall.c

index 2a44f18..cac26fa 100644 (file)
@@ -514,6 +514,7 @@ struct fgrp
        int     nfd;                    /* number of fd slots */
        int     maxfd;                  /* highest fd in use */
        int     minfd;                  /* lower bound on free fd */
+       int     closed;
 };
 
 struct evalue
@@ -998,6 +999,9 @@ int sysdirwstat(char *name, struct dir *dir);
 int sysdirfwstat(int fd, struct dir *dir);
 long sysdirread(int fd, struct dir **d);
 int sysiounit(int fd);
+void close_9ns_files(struct proc *p, bool only_cloexec);
+void print_chaninfo(struct chan *ch);
+void print_9ns_files(struct proc *p);
 
 int iseve(void);
 
index 8e53184..7434a16 100644 (file)
@@ -1159,3 +1159,69 @@ sysiounit(int fd)
        cclose(c);
        return n;
 }
+
+/* Notes on concurrency:
+ * - Can't hold spinlocks while we call cclose, since it might sleep eventually.
+ * - We're called from proc_destroy, so we could have concurrent openers trying
+ *   to add to the group (other syscalls), hence the "closed" flag.
+ * - dot and slash chans are dealt with in proc_free.  its difficult to close
+ *   and zero those with concurrent syscalls, since those are a source of krefs.
+ * - the memory is freed in proc_free().  need to wait to do it, since we can
+ *   have concurrent accesses to fgrp before free.
+ * - Once we lock and set closed, no further additions can happen.  To simplify
+ *   our closes, we also allow multiple calls to this func (though that should
+ *   never happen with the current code). */
+void close_9ns_files(struct proc *p, bool only_cloexec)
+{
+       struct fgrp *f = p->fgrp;
+
+       spin_lock(&f->lock);
+       if (f->closed) {
+               spin_unlock(&f->lock);
+               warn("Unexpected double-close");
+               return;
+       }
+       if (!only_cloexec)
+               f->closed = TRUE;
+       spin_unlock(&f->lock);
+
+       /* maxfd is a legit val, not a +1 */
+       for (int i = 0; i <= f->maxfd; i++) {
+               if (!f->fd[i])
+                       continue;
+               if (only_cloexec && !(f->fd[i]->flag & CCEXEC))
+                       continue;
+               cclose(f->fd[i]);
+               f->fd[i] = 0;
+       }
+}
+
+void print_chaninfo(struct chan *ch)
+{
+       char buf[64] = {0};
+#if 0
+FIXME
+       printk("Chan pathname: %s, Dev: %s, Devinfo: %s\n",
+              "ch->path ? ch->path->s : \"no path",
+              ch->dev ? ch->dev->name: "no dev",
+                  ch->dev ? ch->dev->chaninfo(ch, buf, sizeof(buf)) : "no info");
+       if (!ch->dev)
+               printk("No dev: intermediate chan? qid.path: %p\n", ch->qid.path);
+#endif
+}
+
+void print_9ns_files(struct proc *p)
+{
+       struct fgrp *f = p->fgrp;
+       spin_lock(&f->lock);
+       printk("9ns files for proc %d:\n", p->pid);
+       /* maxfd is a legit val, not a +1 */
+       for (int i = 0; i <= f->maxfd; i++) {
+               if (!f->fd[i])
+                       continue;
+               printk("\t9fs %d, ", i);
+               print_chaninfo(f->fd[i]);
+       }
+       spin_unlock(&f->lock);
+}
+
index 210537a..acebabe 100644 (file)
@@ -1163,7 +1163,7 @@ static intreg_t sys_read(struct proc *p, int fd, void *buf, int len)
                return ret;
        }
        /* plan9, should also handle errors (EBADF) */
-    ret = sysread(fd, buf, len, ~0LL);
+    ret = syspread(fd, buf, len, ~0LL);
        return ret;
 }
 
@@ -1184,7 +1184,7 @@ static intreg_t sys_write(struct proc *p, int fd, const void *buf, int len)
                return ret;
        }
        /* plan9, should also handle errors */
-       ret = syswrite(fd, (void*)buf, len, (off_t) -1);
+       ret = syspwrite(fd, (void*)buf, len, (off_t) -1);
        return ret;
 }
 
@@ -1734,7 +1734,7 @@ intreg_t sys_nbind(struct proc *p,
                return -1;
        }
        printd("sys_nbind: %s -> %s flag %d\n", t_srcpath, t_ontopath, flag);
-       ret = bindmount(0, -1, -1, t_srcpath, t_ontopath, flag, NULL);
+       ret = sysbind(t_srcpath, t_ontopath, flag);
        user_memdup_free(p, t_srcpath);
        user_memdup_free(p, t_ontopath);
        return ret;
@@ -1765,7 +1765,7 @@ intreg_t sys_nmount(struct proc *p,
        char *t_ontopath = user_strdup_errno(p, onto_path, onto_l);
        if (t_ontopath == NULL)
                return -1;
-       ret = bindmount(1, fd, afd, NULL, t_ontopath, flag, /* spec or auth */"");
+       ret = sysmount(fd, afd, t_ontopath, flag, /* spec or auth */"");
        user_memdup_free(p, t_ontopath);
        return ret;
 }
@@ -1805,8 +1805,8 @@ static int sys_fd2path(struct proc *p, int fd, void *u_buf, size_t len)
                poperror();
                return -1;
        }
-       ch = fdtochan(fd, -1, FALSE, TRUE);
-       ret = snprintf(u_buf, len, "%s", chanpath(ch));
+       ch = fdtochan(current->fgrp, fd, -1, FALSE, TRUE);
+       ret = snprintf(u_buf, len, "%s", "chanpath(ch)");
        cclose(ch);
        poperror();
        return ret;
@@ -1860,19 +1860,6 @@ const static struct sys_table_entry syscall_table[] = {
        [SYS_poke_ksched] = {(syscall_t)sys_poke_ksched, "poke_ksched"},
        [SYS_abort_sysc] = {(syscall_t)sys_abort_sysc, "abort_sysc"},
 
-// socket related syscalls
-       [SYS_socket] ={(syscall_t)sys_socket, "socket"},
-       [SYS_sendto] ={(syscall_t)sys_sendto, "sendto"},
-       [SYS_recvfrom] ={(syscall_t)sys_recvfrom, "recvfrom"},
-       [SYS_select] ={(syscall_t)sys_select, "select"},
-       [SYS_connect] = {(syscall_t)sys_connect, "connect"},
-       [SYS_send] ={(syscall_t)sys_send, "send"},
-       [SYS_recv] ={(syscall_t)sys_recv, "recvfrom"},
-       [SYS_bind] ={(syscall_t)sys_bind, "bind"},
-       [SYS_accept] ={(syscall_t)sys_accept, "accept"},
-       [SYS_listen] ={(syscall_t)sys_listen, "listen"},
-
-
        [SYS_read] = {(syscall_t)sys_read, "read"},
        [SYS_write] = {(syscall_t)sys_write, "write"},
        [SYS_open] = {(syscall_t)sys_open, "open"},