vfs: add helpers to get root and pwd

Add three helpers that retrieve a refcounted copy of the root and cwd
from the supplied fs_struct.

 get_fs_root()
 get_fs_pwd()
 get_fs_root_and_pwd()

Signed-off-by: Miklos Szeredi <mszeredi@suse.cz>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c
index 72d4d004282617dcd50d2c1b9c26e72ded745638..727caedcdd921142323e62eaf56c8cdeee5afed4 100644 (file)
--- a/fs/cachefiles/daemon.c
+++ b/fs/cachefiles/daemon.c
@@ -552,7 +552,6 @@ static int cachefiles_daemon_tag(struct cachefiles_cache *cache, char *args)
  */
 static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
 {
-       struct fs_struct *fs;
        struct path path;
        const struct cred *saved_cred;
        int ret;
@@ -573,11 +572,7 @@ static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
        }
 
        /* extract the directory dentry from the cwd */
-       fs = current->fs;
-       read_lock(&fs->lock);
-       path = fs->pwd;
-       path_get(&path);
-       read_unlock(&fs->lock);
+       get_fs_pwd(current->fs, &path);
 
        if (!S_ISDIR(path.dentry->d_inode->i_mode))
                goto notdir;
@@ -629,7 +624,6 @@ inval:
  */
 static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
 {
-       struct fs_struct *fs;
        struct path path;
        const struct cred *saved_cred;
        int ret;
@@ -650,11 +644,7 @@ static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
        }
 
        /* extract the directory dentry from the cwd */
-       fs = current->fs;
-       read_lock(&fs->lock);
-       path = fs->pwd;
-       path_get(&path);
-       read_unlock(&fs->lock);
+       get_fs_pwd(current->fs, &path);
 
        if (!S_ISDIR(path.dentry->d_inode->i_mode))
                goto notdir;

diff --git a/fs/dcache.c b/fs/dcache.c
index 9f2c13417969f564ef502ed3745a04d144419820..995d08069d26d960de990beefadbc2323abaca73 100644 (file)
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2014,10 +2014,7 @@ char *d_path(const struct path *path, char *buf, int buflen)
        if (path->dentry->d_op && path->dentry->d_op->d_dname)
                return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
 
-       read_lock(&current->fs->lock);
-       root = current->fs->root;
-       path_get(&root);
-       read_unlock(&current->fs->lock);
+       get_fs_root(current->fs, &root);
        spin_lock(&dcache_lock);
        tmp = root;
        res = __d_path(path, &tmp, buf, buflen);
@@ -2129,12 +2126,7 @@ SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
        if (!page)
                return -ENOMEM;
 
-       read_lock(&current->fs->lock);
-       pwd = current->fs->pwd;
-       path_get(&pwd);
-       root = current->fs->root;
-       path_get(&root);
-       read_unlock(&current->fs->lock);
+       get_fs_root_and_pwd(current->fs, &root, &pwd);
 
        error = -ENOENT;
        spin_lock(&dcache_lock);

diff --git a/fs/fs_struct.c b/fs/fs_struct.c
index eee059052db5b723e690fc5c1892062540c35c2b..1ee40eb9a2c05cc1751828af612c6942758b4c72 100644 (file)
--- a/fs/fs_struct.c
+++ b/fs/fs_struct.c
@@ -106,12 +106,7 @@ struct fs_struct *copy_fs_struct(struct fs_struct *old)
                fs->in_exec = 0;
                rwlock_init(&fs->lock);
                fs->umask = old->umask;
-               read_lock(&old->lock);
-               fs->root = old->root;
-               path_get(&old->root);
-               fs->pwd = old->pwd;
-               path_get(&old->pwd);
-               read_unlock(&old->lock);
+               get_fs_root_and_pwd(old, &fs->root, &fs->pwd);
        }
        return fs;
 }

diff --git a/fs/namei.c b/fs/namei.c
index 13ff4abdbdcad8e3a67c63a932f476e612bcc762..17ea76bf2fbee41e9ff8a20616e0523781ed2315 100644 (file)
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -483,13 +483,8 @@ ok:
 
 static __always_inline void set_root(struct nameidata *nd)
 {
-       if (!nd->root.mnt) {
-               struct fs_struct *fs = current->fs;
-               read_lock(&fs->lock);
-               nd->root = fs->root;
-               path_get(&nd->root);
-               read_unlock(&fs->lock);
-       }
+       if (!nd->root.mnt)
+               get_fs_root(current->fs, &nd->root);
 }
 
 static int link_path_walk(const char *, struct nameidata *);
@@ -1015,11 +1010,7 @@ static int path_init(int dfd, const char *name, unsigned int flags, struct namei
                nd->path = nd->root;
                path_get(&nd->root);
        } else if (dfd == AT_FDCWD) {
-               struct fs_struct *fs = current->fs;
-               read_lock(&fs->lock);
-               nd->path = fs->pwd;
-               path_get(&fs->pwd);
-               read_unlock(&fs->lock);
+               get_fs_pwd(current->fs, &nd->path);
        } else {
                struct dentry *dentry;
 

diff --git a/fs/namespace.c b/fs/namespace.c
index 66c4f7e781cbfa4b710bd144c50857e4741dcbbe..7972e51ccc06c5ab569074c6c8ff798a3c0d1daa 100644 (file)
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2213,10 +2213,7 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
                goto out1;
        }
 
-       read_lock(&current->fs->lock);
-       root = current->fs->root;
-       path_get(&current->fs->root);
-       read_unlock(&current->fs->lock);
+       get_fs_root(current->fs, &root);
        down_write(&namespace_sem);
        mutex_lock(&old.dentry->d_inode->i_mutex);
        error = -EINVAL;

diff --git a/fs/proc/base.c b/fs/proc/base.c
index c806dfb24e082d94a14e8516ee6cecd327f926ab..4cf5abf77ddf0a7158a223effa74baf5fc3ec140 100644 (file)
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -149,18 +149,13 @@ static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
        return count;
 }
 
-static int get_fs_path(struct task_struct *task, struct path *path, bool root)
+static int get_task_root(struct task_struct *task, struct path *root)
 {
-       struct fs_struct *fs;
        int result = -ENOENT;
 
        task_lock(task);
-       fs = task->fs;
-       if (fs) {
-               read_lock(&fs->lock);
-               *path = root ? fs->root : fs->pwd;
-               path_get(path);
-               read_unlock(&fs->lock);
+       if (task->fs) {
+               get_fs_root(task->fs, root);
                result = 0;
        }
        task_unlock(task);
@@ -173,7 +168,12 @@ static int proc_cwd_link(struct inode *inode, struct path *path)
        int result = -ENOENT;
 
        if (task) {
-               result = get_fs_path(task, path, 0);
+               task_lock(task);
+               if (task->fs) {
+                       get_fs_pwd(task->fs, path);
+                       result = 0;
+               }
+               task_unlock(task);
                put_task_struct(task);
        }
        return result;
@@ -185,7 +185,7 @@ static int proc_root_link(struct inode *inode, struct path *path)
        int result = -ENOENT;
 
        if (task) {
-               result = get_fs_path(task, path, 1);
+               result = get_task_root(task, path);
                put_task_struct(task);
        }
        return result;
@@ -597,7 +597,7 @@ static int mounts_open_common(struct inode *inode, struct file *file,
                                get_mnt_ns(ns);
                }
                rcu_read_unlock();
-               if (ns && get_fs_path(task, &root, 1) == 0)
+               if (ns && get_task_root(task, &root) == 0)
                        ret = 0;
                put_task_struct(task);
        }

diff --git a/include/linux/fs_struct.h b/include/linux/fs_struct.h
index 78a05bfcd8ebd6075b2add0da9da064804e645d6..eca3d5202138f68bb30dd1a308aaf4e121171663 100644 (file)
--- a/include/linux/fs_struct.h
+++ b/include/linux/fs_struct.h
@@ -21,4 +21,31 @@ extern void free_fs_struct(struct fs_struct *);
 extern void daemonize_fs_struct(void);
 extern int unshare_fs_struct(void);
 
+static inline void get_fs_root(struct fs_struct *fs, struct path *root)
+{
+       read_lock(&fs->lock);
+       *root = fs->root;
+       path_get(root);
+       read_unlock(&fs->lock);
+}
+
+static inline void get_fs_pwd(struct fs_struct *fs, struct path *pwd)
+{
+       read_lock(&fs->lock);
+       *pwd = fs->pwd;
+       path_get(pwd);
+       read_unlock(&fs->lock);
+}
+
+static inline void get_fs_root_and_pwd(struct fs_struct *fs, struct path *root,
+                                      struct path *pwd)
+{
+       read_lock(&fs->lock);
+       *root = fs->root;
+       path_get(root);
+       *pwd = fs->pwd;
+       path_get(pwd);
+       read_unlock(&fs->lock);
+}
+
 #endif /* _LINUX_FS_STRUCT_H */

diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index b87a63beb66c4e72bbaa456864bf3421069420e9..1b31c130d0349faee4dc5ac7a219a3a27ff5e031 100644 (file)
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -1835,13 +1835,8 @@ void __audit_getname(const char *name)
        context->names[context->name_count].ino  = (unsigned long)-1;
        context->names[context->name_count].osid = 0;
        ++context->name_count;
-       if (!context->pwd.dentry) {
-               read_lock(&current->fs->lock);
-               context->pwd = current->fs->pwd;
-               path_get(&current->fs->pwd);
-               read_unlock(&current->fs->lock);
-       }
-
+       if (!context->pwd.dentry)
+               get_fs_pwd(current->fs, &context->pwd);
 }
 
 /* audit_putname - intercept a putname request