sys_chmod()
[akaros.git] / kern / src / vfs.c
index 20cf1ac..2fa4e47 100644 (file)
@@ -485,8 +485,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 +503,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 +512,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 +525,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 +573,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,11 +591,13 @@ 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);
 }
@@ -753,7 +758,12 @@ 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);
+       /* 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);
@@ -964,8 +974,10 @@ struct file *do_file_open(char *path, int flags, int mode)
                /* 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. */
+               /* Note that the mode technically should only apply to future opens,
+                * but we apply it immediately. */
+               if (current)
+                       mode &= ~current->fs_env.umask;
                if (create_file(parent_i, file_d, mode)) {
                        kref_put(&file_d->d_kref);
                        path_release(nd);
@@ -1023,6 +1035,11 @@ int do_symlink(char *path, const char *symname, int mode)
        }
        /* Doesn't already exist, let's try to make it: */
        sym_d = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
+       if (!sym_d) {
+               set_errno(ENOMEM);
+               path_release(nd);
+               return -1;
+       }
        parent_i = nd->dentry->d_inode;
        /* TODO: mode should be & ~umask. */
        if (create_symlink(parent_i, sym_d, symname, mode)) {
@@ -1036,9 +1053,125 @@ int do_symlink(char *path, const char *symname, int mode)
        return 0;
 }
 
-/* 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. */
+/* 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 (old_d->d_inode->i_type != FS_I_FILE) {
+               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++;
+       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;
+}
+
+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 (dentry->d_inode->i_type == FS_I_DIR) {
+               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 */
+       /* 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.  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_file_access(char *path, int mode)
 {
        struct nameidata nd_r = {0}, *nd = &nd_r;
@@ -1049,6 +1182,24 @@ int do_file_access(char *path, int mode)
        return retval;
 }
 
+int do_file_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 & 0777;
+       }
+       path_release(nd);       
+       return retval;
+}
+
 /* Opens and returns the file specified by dentry */
 struct file *dentry_open(struct dentry *dentry, int flags)
 {
@@ -1366,6 +1517,67 @@ void clone_files(struct files_struct *src, struct files_struct *dst)
        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;
@@ -1402,8 +1614,8 @@ static void print_dir(struct dentry *dentry, char *buf, int depth)
                                        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);
+                                       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):
                                        printk("%s%s -> %s\n", buf, next.d_name,