Fixes bug in close_all_files()
[akaros.git] / kern / src / vfs.c
index d72f48b..743413b 100644 (file)
@@ -207,7 +207,7 @@ static int follow_symlink(struct nameidata *nd)
 {
        int retval;
        char *symname;
-       if (nd->dentry->d_inode->i_type != FS_I_SYMLINK)
+       if (!S_ISLNK(nd->dentry->d_inode->i_mode))
                return 0;
        if (nd->depth > MAX_SYMLINK_DEPTH)
                return -ELOOP;
@@ -283,9 +283,17 @@ static int link_path_walk(char *path, struct nameidata *nd)
        /* skip all leading /'s */
        while (*link == '/')
                link++;
-       /* if there's nothing left (null terminated), we're done */
-       if (*link == '\0')
+       /* if there's nothing left (null terminated), we're done.  This should only
+        * happen for "/", which if we wanted a PARENT, should fail (there is no
+        * parent). */
+       if (*link == '\0') {
+               if (nd->flags & LOOKUP_PARENT) {
+                       set_errno(ENOENT);
+                       return -1;
+               }
+               /* o/w, we're good */
                return 0;
+       }
        /* iterate through each intermediate link of the path.  in general, nd
         * tracks where we are in the path, as far as dentries go.  once we have the
         * next dentry, we try to update nd based on that dentry.  link is the part
@@ -328,7 +336,7 @@ static int link_path_walk(char *path, struct nameidata *nd)
                 * during the follow_symlink (a symlink could have had a directory at
                 * the end), though it was in the middle of the real path. */
                nd->flags &= ~LOOKUP_DIRECTORY;
-               if (!(nd->dentry->d_inode->i_type & FS_I_DIR))
+               if (!S_ISDIR(nd->dentry->d_inode->i_mode))
                        return -ENOTDIR;
 next_loop:
                /* move through the path string to the next entry */
@@ -345,6 +353,7 @@ next_loop:
         * the last item (link). */
        if (!strcmp(".", link)) {
                if (nd->flags & LOOKUP_PARENT) {
+                       assert(nd->dentry->d_name.name);
                        stash_nd_name(nd, nd->dentry->d_name.name);
                        climb_up(nd);
                }
@@ -353,6 +362,7 @@ next_loop:
        if (!strcmp("..", link)) {
                climb_up(nd);
                if (nd->flags & LOOKUP_PARENT) {
+                       assert(nd->dentry->d_name.name);
                        stash_nd_name(nd, nd->dentry->d_name.name);
                        climb_up(nd);
                }
@@ -363,6 +373,7 @@ next_loop:
        if (!link_dentry) {
                /* if there's no dentry, we are okay if we are looking for the parent */
                if (nd->flags & LOOKUP_PARENT) {
+                       assert(strcmp(link, ""));
                        stash_nd_name(nd, link);
                        return 0;
                } else {
@@ -384,6 +395,7 @@ next_loop:
         * all.  Now we need to climb up to set nd back on the parent, if that's
         * what we wanted */
        if (nd->flags & LOOKUP_PARENT) {
+               assert(nd->dentry->d_name.name);
                stash_nd_name(nd, link_dentry->d_name.name);
                climb_up(nd);
                return 0;
@@ -392,8 +404,7 @@ next_loop:
         * mountpoint still.  FYI: this hasn't been thought through completely. */
        follow_mount(nd);
        /* If we wanted a directory, but didn't get one, error out */
-       if ((nd->flags & LOOKUP_DIRECTORY) &&
-          !(nd->dentry->d_inode->i_type & FS_I_DIR))
+       if ((nd->flags & LOOKUP_DIRECTORY) && !S_ISDIR(nd->dentry->d_inode->i_mode))
                return -ENOTDIR;
        return 0;
 }
@@ -402,10 +413,18 @@ next_loop:
  * initialized for the first call - specifically, we need the intent. 
  * LOOKUP_PARENT and friends go in the flags var, which is not the intent.
  *
+ * If path_lookup wants a PARENT, but hits the top of the FS (root or
+ * otherwise), we want it to error out.  It's still unclear how we want to
+ * handle processes with roots that aren't root, but at the very least, we don't
+ * want to think we have the parent of /, but have / itself.  Due to the way
+ * link_path_walk works, if that happened, we probably don't have a
+ * nd->last.name.  This needs more thought (TODO).
+ *
  * Need to be careful too.  While the path has been copied-in to the kernel,
  * it's still user input.  */
 int path_lookup(char *path, int flags, struct nameidata *nd)
 {
+       int retval;
        printd("Path lookup for %s\n", path);
        /* we allow absolute lookups with no process context */
        if (path[0] == '/') {                   /* absolute lookup */
@@ -425,7 +444,11 @@ int path_lookup(char *path, int flags, struct nameidata *nd)
        kref_get(&nd->dentry->d_kref, 1);
        nd->flags = flags;
        nd->depth = 0;                                  /* used in symlink following */
-       return link_path_walk(path, nd);        
+       retval =  link_path_walk(path, nd);     
+       /* make sure our PARENT lookup worked */
+       if (!retval && (flags & LOOKUP_PARENT))
+               assert(nd->last.name);
+       return retval;
 }
 
 /* Call this after any use of path_lookup when you are done with its results,
@@ -485,8 +508,6 @@ void init_sb(struct super_block *sb, struct vfsmount *vmnt,
        struct inode *inode = get_inode(d_root);
        if (!inode)
                panic("This FS sucks!");
-       d_root->d_inode = inode;                                /* storing the inode's kref here */
-       TAILQ_INSERT_TAIL(&inode->i_dentry, d_root, d_alias);   /* weak ref */
        inode->i_ino = root_ino;
        /* TODO: add the inode to the appropriate list (off i_list) */
        /* TODO: do we need to read in the inode?  can we do this on demand? */
@@ -505,6 +526,7 @@ void init_sb(struct super_block *sb, struct vfsmount *vmnt,
         * when's the earliest we should?  what about concurrent accesses to the
         * same dentry?  should be locking the dentry... */
        dcache_put(d_root); // TODO: should set a d_flag too
+       kref_put(&inode->i_kref);               /* give up the ref from get_inode() */
 }
 
 /* Dentry Functions */
@@ -513,6 +535,8 @@ void init_sb(struct super_block *sb, struct vfsmount *vmnt,
  * set still: d_op (if no parent), d_fs_info (opt), d_inode, connect the inode
  * to the dentry (and up the d_kref again), maybe dcache_put().  The inode
  * stitching is done in get_inode() or lookup (depending on the FS).
+ * The setting of the d_op might be problematic when dealing with mounts.  Just
+ * overwrite it.
  *
  * If the name is longer than the inline name, it will kmalloc a buffer, so
  * don't worry about the storage for *name after calling this. */
@@ -524,6 +548,8 @@ struct dentry *get_dentry(struct super_block *sb, struct dentry *parent,
        struct dentry *dentry = kmem_cache_alloc(dentry_kcache, 0);
        char *l_name = 0;
 
+       if (!dentry)
+               return 0;
        //memset(dentry, 0, sizeof(struct dentry));
        kref_init(&dentry->d_kref, dentry_release, 1);  /* this ref is returned */
        spinlock_init(&dentry->d_lock);
@@ -570,7 +596,7 @@ void dcache_put(struct dentry *dentry)
 
 /* Cleans up the dentry (after ref == 0).  We still may want it, and this is
  * where we should add it to the dentry cache.  (TODO).  For now, we do nothing,
- * since we don't have a dcache.
+ * since we don't have a dcache.  Also, if i_nlink == 0, never cache it.
  * 
  * This has to handle two types of dentries: full ones (ones that had been used)
  * and ones that had been just for lookups - hence the check for d_inode.
@@ -588,15 +614,38 @@ void dentry_release(struct kref *kref)
        if (dentry->d_name.len > DNAME_INLINE_LEN)
                kfree((void*)dentry->d_name.name);
        kref_put(&dentry->d_sb->s_kref);
+       if (dentry->d_parent)
+               kref_put(&dentry->d_parent->d_kref);
        if (dentry->d_mounted_fs)
                kref_put(&dentry->d_mounted_fs->mnt_kref);
        if (dentry->d_inode) {
                TAILQ_REMOVE(&dentry->d_inode->i_dentry, dentry, d_alias);
-               kref_put(&dentry->d_inode->i_kref);     /* but dentries kref inodes */
+               kref_put(&dentry->d_inode->i_kref);     /* dentries kref inodes */
        }
        kmem_cache_free(dentry_kcache, dentry);
 }
 
+/* Looks up the dentry for the given path, returning a refcnt'd dentry (or 0).
+ * Permissions are applied for the current user, which is quite a broken system
+ * at the moment.  Flags are lookup flags. */
+struct dentry *lookup_dentry(char *path, int flags)
+{
+       struct dentry *dentry;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+
+       error = path_lookup(path, flags, nd);
+       if (error) {
+               path_release(nd);
+               set_errno(-error);
+               return 0;
+       }
+       dentry = nd->dentry;
+       kref_get(&dentry->d_kref, 1);
+       path_release(nd);
+       return dentry;
+}
+
 /* Inode Functions */
 
 /* Creates and initializes a new inode.  Generic fields are filled in.
@@ -651,13 +700,15 @@ struct inode *get_inode(struct dentry *dentry)
  * note we don't pass this an nd, like Linux does... */
 static struct inode *create_inode(struct dentry *dentry, int mode)
 {
-       /* note it is the i_ino that uniquely identifies a file in the system.
-        * there's a diff between creating an inode (even for an in-use ino) and
-        * then filling it in, and vs creating a brand new one */
+       /* note it is the i_ino that uniquely identifies a file in the specific
+        * filesystem.  there's a diff between creating an inode (even for an in-use
+        * ino) and then filling it in, and vs creating a brand new one.
+        * get_inode() sets it to 0, and it should be filled in later in an
+        * FS-specific manner. */
        struct inode *inode = get_inode(dentry);
        if (!inode)
                return 0;
-       inode->i_mode = mode;
+       inode->i_mode = mode & S_PMASK; /* note that after this, we have no type */
        inode->i_nlink = 1;
        inode->i_size = 0;
        inode->i_blocks = 0;
@@ -676,13 +727,16 @@ static struct inode *create_inode(struct dentry *dentry, int mode)
 
 /* Create a new disk inode in dir associated with dentry, with the given mode.
  * called when creating a regular file.  dir is the directory/parent.  dentry is
- * the dentry of the inode we are creating.  Note the lack of the nd... */
+ * the dentry of the inode we are creating.  Note the lack of the nd...
+ * Also, we do the nlink++ in here, since we want to give the FS's a chance to
+ * fail. */
 int create_file(struct inode *dir, struct dentry *dentry, int mode)
 {
        struct inode *new_file = create_inode(dentry, mode);
        if (!new_file)
                return -1;
        dir->i_op->create(dir, dentry, mode, 0);
+       dir->i_nlink++;
        kref_put(&new_file->i_kref);
        return 0;
 }
@@ -695,6 +749,7 @@ int create_dir(struct inode *dir, struct dentry *dentry, int mode)
        if (!new_dir)
                return -1;
        dir->i_op->mkdir(dir, dentry, mode);
+       dir->i_nlink++;
        /* Make sure my parent tracks me.  This is okay, since no directory (dir)
         * can have more than one dentry */
        struct dentry *parent = TAILQ_FIRST(&dir->i_dentry);
@@ -714,6 +769,7 @@ int create_symlink(struct inode *dir, struct dentry *dentry,
        if (!new_sym)
                return -1;
        dir->i_op->symlink(dir, dentry, symname);
+       dir->i_nlink++;                 /* TODO: race with this, among other things */
        kref_put(&new_sym->i_kref);
        return 0;
 }
@@ -732,7 +788,13 @@ int check_perms(struct inode *inode, int access_mode)
 void inode_release(struct kref *kref)
 {
        struct inode *inode = container_of(kref, struct inode, i_kref);
-       inode->i_sb->s_op->destroy_inode(inode);
+       TAILQ_REMOVE(&inode->i_sb->s_inodes, inode, i_sb_list);
+       /* If we still have links, just dealloc the in-memory inode.  if we have no
+        * links, we need to delete it too (which calls destroy). */
+       if (inode->i_nlink)
+               inode->i_sb->s_op->dealloc_inode(inode);
+       else
+               inode->i_sb->s_op->delete_inode(inode);
        kref_put(&inode->i_sb->s_kref);
        assert(inode->i_mapping == &inode->i_pm);
        kmem_cache_free(inode_kcache, inode);
@@ -740,27 +802,6 @@ void inode_release(struct kref *kref)
        // kref_put(inode->i_bdev->kref); /* assuming it's a bdev */
 }
 
-/* Looks up the inode for the given path, returning a refcnt'd inode (or 0).
- * Permissions are applied for the current user, which is quite a broken system
- * at the moment.  Flags are lookup flags. */
-struct inode *lookup_inode(char *path, int flags)
-{
-       struct inode *inode;
-       struct nameidata nd_r = {0}, *nd = &nd_r;
-       int error;
-
-       error = path_lookup(path, flags, nd);
-       if (error) {
-               path_release(nd);
-               set_errno(-error);
-               return 0;
-       }
-       inode = nd->dentry->d_inode;
-       kref_get(&inode->i_kref, 1);
-       path_release(nd);
-       return inode;
-}
-
 /* Fills in kstat with the stat information for the inode */
 void stat_inode(struct inode *inode, struct kstat *kstat)
 {
@@ -881,6 +922,46 @@ ssize_t generic_file_write(struct file *file, const char *buf, size_t count,
        return count;
 }
 
+/* Directories usually use this for their read method, which is the way glibc
+ * currently expects us to do a readdir (short of doing linux's getdents).  Will
+ * probably need work, based on whatever real programs want. */
+ssize_t generic_dir_read(struct file *file, char *u_buf, size_t count,
+                         off_t *offset)
+{
+       struct kdirent dir_r = {0}, *dirent = &dir_r;
+       unsigned int num_dirents = count / sizeof(struct kdirent);
+       int retval = 1;
+       size_t amt_copied = 0;
+       char *buf_end = u_buf + count;
+
+       if (!count)
+               return 0;
+       if (*offset % sizeof(struct kdirent)) {
+               printk("[kernel] the f_pos for a directory should be dirent-aligned\n");
+               set_errno(EINVAL);
+               return -1;
+       }
+       /* for now, we need to tell readdir which dirent we want */
+       dirent->d_off = *offset / sizeof(struct kdirent);
+       for (; (u_buf < buf_end) && (retval == 1); u_buf += sizeof(struct kdirent)){
+               /* TODO: UMEM/KFOP (pin the u_buf in the syscall, ditch the local copy,
+                * get rid of this memcpy and reliance on current, etc).  Might be
+                * tricky with the dirent->d_off */
+               retval = file->f_op->readdir(file, dirent);
+               if (retval < 0)
+                       break;
+               if (current) {
+                       memcpy_to_user(current, u_buf, dirent, sizeof(struct dirent));
+               } else {
+                       memcpy(u_buf, dirent, sizeof(struct dirent));
+               }
+               amt_copied += sizeof(struct dirent);
+               dirent->d_off++;
+       }
+       *offset += amt_copied;
+       return amt_copied;
+}
+
 /* Opens the file, using permissions from current for lack of a better option.
  * It will attempt to create the file if it does not exist and O_CREAT is
  * specified.  This will return 0 on failure, and set errno.  TODO: There's some
@@ -900,111 +981,234 @@ struct file *do_file_open(char *path, int flags, int mode)
        struct nameidata nd_r = {0}, *nd = &nd_r;
        int error;
 
-       /* this isn't quite right, due to the nature of O_CREAT */
-       if (flags & O_CREAT)
-               nd->intent = LOOKUP_CREATE;
-       else
-               nd->intent = LOOKUP_OPEN;
+       /* The file might exist, lets try to just open it right away */
+       nd->intent = LOOKUP_OPEN;
+       error = path_lookup(path, LOOKUP_FOLLOW, nd);
+       if (!error) {
+               /* Still need to make sure we didn't want to O_EXCL create */
+               if ((flags & O_CREAT) && (flags & O_EXCL)) {
+                       set_errno(EEXIST);
+                       goto out_path_only;
+               }
+               file_d = nd->dentry;
+               kref_get(&file_d->d_kref, 1);
+               goto open_the_file;
+       }
+       /* So it didn't already exist, release the path from the previous lookup,
+        * and then we try to create it. */
+       path_release(nd);       
        /* get the parent, following links.  this means you get the parent of the
         * final link (which may not be in 'path' in the first place. */
+       nd->intent = LOOKUP_CREATE;
        error = path_lookup(path, LOOKUP_PARENT | LOOKUP_FOLLOW, nd);
        if (error) {
-               path_release(nd);
                set_errno(-error);
-               return 0;
+               goto out_path_only;
        }
-       /* see if the target is there, handle accordingly */
+       /* see if the target is there (shouldn't be), and handle accordingly */
        file_d = do_lookup(nd->dentry, nd->last.name); 
        if (!file_d) {
                if (!(flags & O_CREAT)) {
-                       path_release(nd);
                        set_errno(ENOENT);
-                       return 0;
+                       goto out_path_only;
                }
                /* Create the inode/file.  get a fresh dentry too: */
                file_d = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
                parent_i = nd->dentry->d_inode;
-               /* TODO: mode should be & ~umask.  Note that mode technically should
-                * only apply to future opens, though we apply it immediately. */
-               if (create_file(parent_i, file_d, mode)) {
-                       kref_put(&file_d->d_kref);
-                       path_release(nd);
-                       return 0;
-               }
+               /* Note that the mode technically should only apply to future opens,
+                * but we apply it immediately. */
+               if (create_file(parent_i, file_d, mode))        /* sets errno */
+                       goto out_file_d;
                dcache_put(file_d);
-       } else {        /* something already exists (might be a dir) */
+       } else {        /* something already exists */
+               /* this can happen due to concurrent access, but needs to be thought
+                * through */
+               panic("File shouldn't be here!");
                if ((flags & O_CREAT) && (flags & O_EXCL)) {
                        /* wanted to create, not open, bail out */
-                       kref_put(&file_d->d_kref);
-                       path_release(nd);
                        set_errno(EEXIST);
-                       return 0;
-               }
-               if (file_d->d_inode->i_type == FS_I_DIR) {
-                       kref_put(&file_d->d_kref);
-                       path_release(nd);
-                       set_errno(EISDIR);
-                       return 0;
+                       goto out_file_d;
                }
        }
+open_the_file:
        /* now open the file (freshly created or if it already existed).  At this
         * point, file_d is a refcnt'd dentry, regardless of which branch we took.*/
        if (flags & O_TRUNC)
                warn("File truncation not supported yet.");
-       file = dentry_open(file_d, flags);              /* sets errno */
-       if (!file) {
-               kref_put(&file_d->d_kref);
-               path_release(nd);
-               return 0;
-       }
+       file = dentry_open(file_d, flags);                              /* sets errno */
+       /* Note the fall through to the exit paths.  File is 0 by default and if
+        * dentry_open fails. */
+out_file_d:
        kref_put(&file_d->d_kref);
+out_path_only:
        path_release(nd);
        return file;
 }
 
-/* Path is the location of the symlink, symname is who we link to. */
+/* Path is the location of the symlink, sometimes called the "new path", and
+ * symname is who we link to, sometimes called the "old path". */
 int do_symlink(char *path, const char *symname, int mode)
 {
        struct dentry *sym_d;
        struct inode *parent_i;
        struct nameidata nd_r = {0}, *nd = &nd_r;
        int error;
+       int retval = -1;
 
        nd->intent = LOOKUP_CREATE;
        /* get the parent, but don't follow links */
        error = path_lookup(path, LOOKUP_PARENT, nd);
        if (error) {
                set_errno(-error);
-               path_release(nd);
-               return -1;
+               goto out_path_only;
        }
        /* see if the target is already there, handle accordingly */
        sym_d = do_lookup(nd->dentry, nd->last.name); 
        if (sym_d) {
                set_errno(EEXIST);
-               kref_put(&sym_d->d_kref);
-               path_release(nd);
-               return -1;
+               goto out_sym_d;
        }
        /* Doesn't already exist, let's try to make it: */
        sym_d = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
-       parent_i = nd->dentry->d_inode;
-       /* TODO: mode should be & ~umask. */
-       if (create_symlink(parent_i, sym_d, symname, mode)) {
-               kref_put(&sym_d->d_kref);
-               path_release(nd);
-               return -1;
+       if (!sym_d) {
+               set_errno(ENOMEM);
+               goto out_path_only;
        }
+       parent_i = nd->dentry->d_inode;
+       if (create_symlink(parent_i, sym_d, symname, mode))
+               goto out_sym_d;
        dcache_put(sym_d);
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_sym_d:
        kref_put(&sym_d->d_kref);
+out_path_only:
        path_release(nd);
-       return 0;
+       return retval;
+}
+
+/* Makes a hard link for the file behind old_path to new_path */
+int do_link(char *old_path, char *new_path)
+{
+       struct dentry *link_d, *old_d;
+       struct inode *inode, *parent_dir;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+       int retval = -1;
+
+       nd->intent = LOOKUP_CREATE;
+       /* get the absolute parent of the new_path */
+       error = path_lookup(new_path, LOOKUP_PARENT | LOOKUP_FOLLOW, nd);
+       if (error) {
+               set_errno(-error);
+               goto out_path_only;
+       }
+       parent_dir = nd->dentry->d_inode;
+       /* see if the new target is already there, handle accordingly */
+       link_d = do_lookup(nd->dentry, nd->last.name); 
+       if (link_d) {
+               set_errno(EEXIST);
+               goto out_link_d;
+       }
+       /* Doesn't already exist, let's try to make it.  Still need to stitch it to
+        * an inode and set its FS-specific stuff after this.*/
+       link_d = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
+       if (!link_d) {
+               set_errno(ENOMEM);
+               goto out_path_only;
+       }
+       /* Now let's get the old_path target */
+       old_d = lookup_dentry(old_path, LOOKUP_FOLLOW);
+       if (!old_d)                                     /* errno set by lookup_dentry */
+               goto out_link_d;
+       /* For now, can only link to files */
+       if (!S_ISREG(old_d->d_inode->i_mode)) {
+               set_errno(EPERM);
+               goto out_both_ds;
+       }
+       /* Must be on the same FS */
+       if (old_d->d_sb != link_d->d_sb) {
+               set_errno(EXDEV);
+               goto out_both_ds;
+       }
+       /* Do whatever FS specific stuff there is first (which is also a chance to
+        * bail out). */
+       error = parent_dir->i_op->link(old_d, parent_dir, link_d);
+       if (error) {
+               set_errno(-error);
+               goto out_both_ds;
+       }
+       /* Finally stitch it up */
+       inode = old_d->d_inode;
+       kref_get(&inode->i_kref, 1);
+       link_d->d_inode = inode;
+       inode->i_nlink++;
+       parent_dir->i_nlink++;
+       TAILQ_INSERT_TAIL(&inode->i_dentry, link_d, d_alias);   /* weak ref */
+       dcache_put(link_d);
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_both_ds:
+       kref_put(&old_d->d_kref);
+out_link_d:
+       kref_put(&link_d->d_kref);
+out_path_only:
+       path_release(nd);
+       return retval;
+}
+
+/* Unlinks path from the directory tree.  Read the Documentation for more info.
+ */
+int do_unlink(char *path)
+{
+       struct dentry *dentry;
+       struct inode *parent_dir;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+       int retval = -1;
+
+       /* get the parent of the target, and don't follow a final link */
+       error = path_lookup(path, LOOKUP_PARENT, nd);
+       if (error) {
+               set_errno(-error);
+               goto out_path_only;
+       }
+       parent_dir = nd->dentry->d_inode;
+       /* make sure the target is there */
+       dentry = do_lookup(nd->dentry, nd->last.name); 
+       if (!dentry) {
+               set_errno(ENOENT);
+               goto out_path_only;
+       }
+       /* Make sure the target is not a directory */
+       if (S_ISDIR(dentry->d_inode->i_mode)) {
+               set_errno(EISDIR);
+               goto out_dentry;
+       }
+       /* Remove the dentry from its parent */
+       error = parent_dir->i_op->unlink(parent_dir, dentry);
+       if (error) {
+               set_errno(-error);
+               goto out_dentry;
+       }
+       kref_put(&dentry->d_parent->d_kref);
+       dentry->d_parent = 0;           /* so we don't double-decref it later */
+       dentry->d_inode->i_nlink--;     /* TODO: race here, esp with a decref */
+       /* At this point, the dentry is unlinked from the FS, and the inode has one
+        * less link.  When the in-memory objects (dentry, inode) are going to be
+        * released (after all open files are closed, and maybe after entries are
+        * evicted from the cache), then nlinks will get checked and the FS-file
+        * will get removed from the disk */
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_dentry:
+       kref_put(&dentry->d_kref);
+out_path_only:
+       path_release(nd);
+       return retval;
 }
 
-/* Checks to see if path can be accessed via mode.  Doesn't do much now.  This
- * is an example of decent error propagation from the lower levels via int
- * retvals. */
-int do_file_access(char *path, int mode)
+/* Checks to see if path can be accessed via mode.  Need to actually send the
+ * mode along somehow, so this doesn't do much now.  This is an example of
+ * decent error propagation from the lower levels via int retvals. */
+int do_access(char *path, int mode)
 {
        struct nameidata nd_r = {0}, *nd = &nd_r;
        int retval = 0;
@@ -1014,6 +1218,120 @@ int do_file_access(char *path, int mode)
        return retval;
 }
 
+int do_chmod(char *path, int mode)
+{
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int retval = 0;
+       retval = path_lookup(path, 0, nd);
+       if (!retval) {
+               #if 0
+               /* TODO: when we have notions of uid, check for the proc's uid */
+               if (nd->dentry->d_inode->i_uid != UID_OF_ME)
+                       retval = -EPERM;
+               else
+               #endif
+                       nd->dentry->d_inode->i_mode |= mode & S_PMASK;
+       }
+       path_release(nd);       
+       return retval;
+}
+
+/* Make a directory at path with mode.  Returns -1 and sets errno on errors */
+int do_mkdir(char *path, int mode)
+{
+       struct dentry *dentry;
+       struct inode *parent_i;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+       int retval = -1;
+
+       nd->intent = LOOKUP_CREATE;
+       /* get the parent, but don't follow links */
+       error = path_lookup(path, LOOKUP_PARENT, nd);
+       if (error) {
+               set_errno(-error);
+               goto out_path_only;
+       }
+       /* see if the target is already there, handle accordingly */
+       dentry = do_lookup(nd->dentry, nd->last.name); 
+       if (dentry) {
+               set_errno(EEXIST);
+               goto out_dentry;
+       }
+       /* Doesn't already exist, let's try to make it: */
+       dentry = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
+       if (!dentry) {
+               set_errno(ENOMEM);
+               goto out_path_only;
+       }
+       parent_i = nd->dentry->d_inode;
+       if (create_dir(parent_i, dentry, mode))
+               goto out_dentry;
+       dcache_put(dentry);
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_dentry:
+       kref_put(&dentry->d_kref);
+out_path_only:
+       path_release(nd);
+       return retval;
+}
+
+int do_rmdir(char *path)
+{
+       struct dentry *dentry;
+       struct inode *parent_i;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+       int retval = -1;
+
+       /* get the parent, following links (probably want this), and we must get a
+        * directory.  Note, current versions of path_lookup can't handle both
+        * PARENT and DIRECTORY, at least, it doesn't check that *path is a
+        * directory. */
+       error = path_lookup(path, LOOKUP_PARENT | LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
+                           nd);
+       if (error) {
+               set_errno(-error);
+               goto out_path_only;
+       }
+       /* make sure the target is already there, handle accordingly */
+       dentry = do_lookup(nd->dentry, nd->last.name); 
+       if (!dentry) {
+               set_errno(ENOENT);
+               goto out_path_only;
+       }
+       if (!S_ISDIR(dentry->d_inode->i_mode)) {
+               set_errno(ENOTDIR);
+               goto out_dentry;
+       }
+       /* TODO: make sure we aren't a mount or processes root (EBUSY) */
+       /* make sure we are empty.  TODO: Race with this, and anything touching
+        * i_nlink! */
+       if (dentry->d_inode->i_nlink != 1) {
+               set_errno(ENOTEMPTY);
+               goto out_dentry;
+       }
+       /* now for the removal */
+       parent_i = nd->dentry->d_inode;
+       error = parent_i->i_op->rmdir(parent_i, dentry);
+       if (error < 0) {
+               set_errno(-error);
+               goto out_dentry;
+       }
+       /* Decref ourselves, so inode_release() knows we are done */
+       dentry->d_inode->i_nlink--;
+       TAILQ_REMOVE(&nd->dentry->d_subdirs, dentry, d_subdirs_link);
+       parent_i->i_nlink--;            /* TODO: race on this, esp since its a decref */
+       /* we still have d_parent and a kref on our parent, which will go away when
+        * the in-memory dentry object goes away. */
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_dentry:
+       kref_put(&dentry->d_kref);
+out_path_only:
+       path_release(nd);
+       return retval;
+}
+
 /* Opens and returns the file specified by dentry */
 struct file *dentry_open(struct dentry *dentry, int flags)
 {
@@ -1249,10 +1567,9 @@ struct file *put_file_from_fd(struct files_struct *open_files, int file_desc)
                        assert(file_desc < open_files->max_files);
                        file = open_files->fd[file_desc];
                        open_files->fd[file_desc] = 0;
+                       assert(file);
+                       kref_put(&file->f_kref);
                        CLR_BITMASK_BIT(open_files->open_fds->fds_bits, file_desc);
-                       /* the if case is due to files (stdin) without a *file yet */
-                       if (file)
-                               kref_put(&file->f_kref);
                }
        }
        spin_unlock(&open_files->lock);
@@ -1260,12 +1577,14 @@ struct file *put_file_from_fd(struct files_struct *open_files, int file_desc)
 }
 
 /* Inserts the file in the files_struct, returning the corresponding new file
- * descriptor, or an error code.  We currently grab the first open FD. */
-int insert_file(struct files_struct *open_files, struct file *file)
+ * descriptor, or an error code.  We start looking for open fds from low_fd. */
+int insert_file(struct files_struct *open_files, struct file *file, int low_fd)
 {
        int slot = -1;
+       if ((low_fd < 0) || (low_fd > NR_FILE_DESC_MAX))
+               return -EINVAL;
        spin_lock(&open_files->lock);
-       for (int i = 0; i < open_files->max_fdset; i++) {
+       for (int i = low_fd; i < open_files->max_fdset; i++) {
                if (GET_BITMASK_BIT(open_files->open_fds->fds_bits, i))
                        continue;
                slot = i;
@@ -1295,12 +1614,12 @@ void close_all_files(struct files_struct *open_files, bool cloexec)
                         * have a valid fdset higher than files */
                        assert(i < open_files->max_files);
                        file = open_files->fd[i];
-                       if (cloexec && !(file->f_flags | O_CLOEXEC))
+                       if (cloexec && !(file->f_flags & O_CLOEXEC))
                                continue;
+                       /* Actually close the file */
                        open_files->fd[i] = 0;
-                       /* the if case is due to files (stdin) without a *file yet */
-                       if (file)
-                               kref_put(&file->f_kref);
+                       assert(file);
+                       kref_put(&file->f_kref);
                        CLR_BITMASK_BIT(open_files->open_fds->fds_bits, i);
                }
        }
@@ -1319,18 +1638,80 @@ void clone_files(struct files_struct *src, struct files_struct *dst)
                         * have a valid fdset higher than files */
                        assert(i < src->max_files);
                        file = src->fd[i];
-                       SET_BITMASK_BIT(dst->open_fds->fds_bits, i);
                        assert(i < dst->max_files && dst->fd[i] == 0);
+                       SET_BITMASK_BIT(dst->open_fds->fds_bits, i);
                        dst->fd[i] = file;
-                       /* the if case is due to files (stdin) without a *file yet */
-                       if (file)
-                               kref_get(&file->f_kref, 1);
+                       assert(file);
+                       kref_get(&file->f_kref, 1);
+                       if (i >= dst->next_fd)
+                               dst->next_fd = i + 1;
                }
        }
        spin_unlock(&dst->lock);
        spin_unlock(&src->lock);
 }
 
+/* Change the working directory of the given fs env (one per process, at this
+ * point).  Returns 0 for success, -ERROR for whatever error. */
+int do_chdir(struct fs_struct *fs_env, char *path)
+{
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int retval;
+       retval = path_lookup(path, LOOKUP_DIRECTORY, nd);
+       if (!retval) {
+               /* nd->dentry is the place we want our PWD to be */
+               kref_get(&nd->dentry->d_kref, 1);
+               kref_put(&fs_env->pwd->d_kref);
+               fs_env->pwd = nd->dentry;
+       }
+       path_release(nd);
+       return retval;
+}
+
+/* Returns a null-terminated string of up to length cwd_l containing the
+ * absolute path of fs_env, (up to fs_env's root).  Be sure to kfree the char*
+ * "kfree_this" when you are done with it.  We do this since it's easier to
+ * build this string going backwards.  Note cwd_l is not a strlen, it's an
+ * absolute size. */
+char *do_getcwd(struct fs_struct *fs_env, char **kfree_this, size_t cwd_l)
+{
+       struct dentry *dentry = fs_env->pwd;
+       size_t link_len;
+       char *path_start, *kbuf;
+
+       if (cwd_l < 2) {
+               set_errno(ERANGE);
+               return 0;
+       }
+       kbuf = kmalloc(cwd_l, 0);
+       if (!kbuf) {
+               set_errno(ENOMEM);
+               return 0;
+       }
+       *kfree_this = kbuf;
+       kbuf[cwd_l - 1] = '\0';
+       kbuf[cwd_l - 2] = '/';
+       /* for each dentry in the path, all the way back to the root of fs_env, we
+        * grab the dentry name, push path_start back enough, and write in the name,
+        * using /'s to terminate.  We skip the root, since we don't want it's
+        * actual name, just "/", which is set before each loop. */
+       path_start = kbuf + cwd_l - 2;  /* the last byte written */
+       while (dentry != fs_env->root) {
+               link_len = dentry->d_name.len;          /* this does not count the \0 */
+               if (path_start - (link_len + 2) < kbuf) {
+                       kfree(kbuf);
+                       set_errno(ERANGE);
+                       return 0;
+               }
+               path_start -= link_len + 1;     /* the 1 is for the \0 */
+               strncpy(path_start, dentry->d_name.name, link_len);
+               path_start--;
+               *path_start = '/';
+               dentry = dentry->d_parent;      
+       }
+       return path_start;
+}
+
 static void print_dir(struct dentry *dentry, char *buf, int depth)
 {
        struct dentry *child_d;
@@ -1339,12 +1720,13 @@ static void print_dir(struct dentry *dentry, char *buf, int depth)
        int retval;
        int child_num = 0;
 
-       if (!dentry->d_inode->i_type & FS_I_DIR) {
+       if (!S_ISDIR(dentry->d_inode->i_mode)) {
                warn("Thought this was only directories!!");
                return;
        }
        /* Print this dentry */
-       printk("%s%s/\n", buf, dentry->d_name.name);
+       printk("%s%s/ nlink: %d\n", buf, dentry->d_name.name,
+              dentry->d_inode->i_nlink);
        if (depth >= 32)
                return;
        /* Set buffer for our kids */
@@ -1362,18 +1744,22 @@ static void print_dir(struct dentry *dentry, char *buf, int depth)
                        if (!child_d)
                                panic("Inconsistent FS, dirent doesn't have a dentry!");
                        /* Recurse for directories, or just print the name for others */
-                       switch (child_d->d_inode->i_type) {
-                               case (FS_I_DIR):
+                       switch (child_d->d_inode->i_mode & __S_IFMT) {
+                               case (__S_IFDIR):
                                        print_dir(child_d, buf, depth + 1);
                                        break;
-                               case (FS_I_FILE):
-                                       printk("%s%s size(B): %d\n", buf, next.d_name,
-                                              child_d->d_inode->i_size);
+                               case (__S_IFREG):
+                                       printk("%s%s size(B): %d nlink: %d\n", buf, next.d_name,
+                                              child_d->d_inode->i_size, child_d->d_inode->i_nlink);
                                        break;
-                               case (FS_I_SYMLINK):
+                               case (__S_IFLNK):
                                        printk("%s%s -> %s\n", buf, next.d_name,
                                               child_d->d_inode->i_op->readlink(child_d));
                                        break;
+                               case (__S_IFCHR):
+                                       printk("%s%s (char device) nlink: %d\n", buf, next.d_name,
+                                              child_d->d_inode->i_nlink);
+                                       break;
                                default:
                                        warn("Look around you!  Unknown filetype!");
                        }