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>

8 files changed, 49 insertions, 62 deletions

diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c
index 72d4d0042826..727caedcdd92 100644
--- 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 9f2c13417969..995d08069d26 100644
--- 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 eee059052db5..1ee40eb9a2c0 100644
--- 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 13ff4abdbdca..17ea76bf2fbe 100644
--- 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 66c4f7e781cb..7972e51ccc06 100644
--- 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 c806dfb24e08..4cf5abf77ddf 100644
--- 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 78a05bfcd8eb..eca3d5202138 100644
--- 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 b87a63beb66c..1b31c130d034 100644
--- 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