Fixes insert_file()
[akaros.git] / kern / src / vfs.c
index 16f1d40..bc43859 100644 (file)
@@ -463,6 +463,8 @@ 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 */
+       /* TODO: RCU read lock on pwd or kref_not_zero in a loop.  concurrent chdir
+        * could decref nd->dentry before we get to incref it below. */
        if (path[0] == '/') {                   /* absolute lookup */
                if (!current)
                        nd->dentry = default_ns.root->mnt_root;
@@ -1328,7 +1330,16 @@ struct file *do_file_open(char *path, int flags, int mode)
        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 this is a directory, make sure we are opening with O_RDONLY.
+                * Unfortunately we can't just check for O_RDONLY directly because its
+                * value is 0x0.  We instead have to make sure it's not O_WRONLY and
+                * not O_RDWR explicitly. */
+               if (S_ISDIR(nd->dentry->d_inode->i_mode) &&
+                   ((flags & O_WRONLY) || (flags & O_RDWR))) {
+                       set_errno(EISDIR);
+                       goto out_path_only;
+               }
+               /* Also 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;
@@ -2215,7 +2226,8 @@ static int __claim_fd(struct files_struct *open_files, int file_desc)
                return -ENFILE; /* Should never really happen. Here to catch bugs. */
 
        SET_BITMASK_BIT(open_files->open_fds->fds_bits, file_desc);
-       assert(file_desc < open_files->max_files && open_files->fd[0].fd_file == 0);
+       assert(file_desc < open_files->max_files &&
+              open_files->fd[file_desc].fd_file == 0);
        if (file_desc >= open_files->next_fd)
                open_files->next_fd = file_desc + 1;
        return 0;
@@ -2233,11 +2245,23 @@ int claim_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 start looking for open fds from low_fd. */
-int insert_file(struct files_struct *open_files, struct file *file, int low_fd)
+int insert_file(struct files_struct *open_files, struct file *file, int low_fd,
+                bool must)
 {
-       int slot;
+       int slot, ret;
        spin_lock(&open_files->lock);
-       slot = __get_fd(open_files, low_fd);
+       if (must) {
+               ret = __claim_fd(open_files, low_fd);
+               if (ret < 0) {
+                       spin_unlock(&open_files->lock);
+                       return ret;
+               }
+               assert(!ret);   /* issues with claim_fd returning status, not the fd */
+               slot = low_fd;
+       } else {
+               slot = __get_fd(open_files, low_fd);
+       }
+
        if (slot < 0) {
                spin_unlock(&open_files->lock);
                return slot;
@@ -2322,6 +2346,20 @@ void clone_files(struct files_struct *src, struct files_struct *dst)
        spin_unlock(&src->lock);
 }
 
+static void __chpwd(struct fs_struct *fs_env, struct dentry *new_pwd)
+{
+       struct dentry *old_pwd;
+       kref_get(&new_pwd->d_kref, 1);
+       /* writer lock, make sure we replace pwd with ours.  could also CAS.
+        * readers don't lock at all, so they need to either loop, or we need to
+        * delay releasing old_pwd til an RCU grace period. */
+       spin_lock(&fs_env->lock);
+       old_pwd = fs_env->pwd;
+       fs_env->pwd = new_pwd;
+       spin_unlock(&fs_env->lock);
+       kref_put(&old_pwd->d_kref);
+}
+
 /* 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)
@@ -2331,14 +2369,22 @@ int do_chdir(struct fs_struct *fs_env, char *path)
        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;
+               __chpwd(fs_env, nd->dentry);
        }
        path_release(nd);
        return retval;
 }
 
+int do_fchdir(struct fs_struct *fs_env, struct file *file)
+{
+       if ((file->f_dentry->d_inode->i_mode & __S_IFMT) != __S_IFDIR) {
+               set_errno(ENOTDIR);
+               return -1;
+       }
+       __chpwd(fs_env, file->f_dentry);
+       return 0;
+}
+
 /* 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