1 files changed, 82 insertions, 32 deletions

diff --git a/fs/dcache.c b/fs/dcache.c
index 43455776711e..3ee588d5f585 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1746,12 +1746,21 @@ shouldnt_be_hashed:
         goto shouldnt_be_hashed;
 }
 
+static int prepend(char **buffer, int *buflen, const char *str,
+                          int namelen)
+{
+        *buflen -= namelen;
+        if (*buflen < 0)
+                return -ENAMETOOLONG;
+        *buffer -= namelen;
+        memcpy(*buffer, str, namelen);
+        return 0;
+}
+
 /**
  * d_path - return the path of a dentry
- * @dentry: dentry to report
- * @vfsmnt: vfsmnt to which the dentry belongs
- * @root: root dentry
- * @rootmnt: vfsmnt to which the root dentry belongs
+ * @path: the dentry/vfsmount to report
+ * @root: root vfsmnt/dentry (may be modified by this function)
  * @buffer: buffer to return value in
  * @buflen: buffer length
  *
@@ -1761,23 +1770,22 @@ shouldnt_be_hashed:
  * Returns the buffer or an error code if the path was too long.
  *
  * "buflen" should be positive. Caller holds the dcache_lock.
+ *
+ * If path is not reachable from the supplied root, then the value of
+ * root is changed (without modifying refcounts).
  */
-static char *__d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
-                       struct path *root, char *buffer, int buflen)
+char *__d_path(const struct path *path, struct path *root,
+               char *buffer, int buflen)
 {
+        struct dentry *dentry = path->dentry;
+        struct vfsmount *vfsmnt = path->mnt;
         char * end = buffer+buflen;
         char * retval;
-        int namelen;
-
-        *--end = '\0';
-        buflen--;
-        if (!IS_ROOT(dentry) && d_unhashed(dentry)) {
-                buflen -= 10;
-                end -= 10;
-                if (buflen < 0)
+
+        prepend(&end, &buflen, "\0", 1);
+        if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
+                (prepend(&end, &buflen, " (deleted)", 10) != 0))
                         goto Elong;
-                memcpy(end, " (deleted)", 10);
-        }
 
         if (buflen < 1)
                 goto Elong;
@@ -1804,13 +1812,10 @@ static char *__d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
                 }
                 parent = dentry->d_parent;
                 prefetch(parent);
-                namelen = dentry->d_name.len;
-                buflen -= namelen + 1;
-                if (buflen < 0)
+                if ((prepend(&end, &buflen, dentry->d_name.name,
+                                dentry->d_name.len) != 0) ||
+                    (prepend(&end, &buflen, "/", 1) != 0))
                         goto Elong;
-                end -= namelen;
-                memcpy(end, dentry->d_name.name, namelen);
-                *--end = '/';
                 retval = end;
                 dentry = parent;
         }
@@ -1818,12 +1823,12 @@ static char *__d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
         return retval;
 
 global_root:
-        namelen = dentry->d_name.len;
-        buflen -= namelen;
-        if (buflen < 0)
+        retval += 1;    /* hit the slash */
+        if (prepend(&retval, &buflen, dentry->d_name.name,
+                    dentry->d_name.len) != 0)
                 goto Elong;
-        retval -= namelen-1;    /* hit the slash */
-        memcpy(retval, dentry->d_name.name, namelen);
+        root->mnt = vfsmnt;
+        root->dentry = dentry;
         return retval;
 Elong:
         return ERR_PTR(-ENAMETOOLONG);
@@ -1846,6 +1851,7 @@ char *d_path(struct path *path, char *buf, int buflen)
 {
         char *res;
         struct path root;
+        struct path tmp;
 
         /*
          * We have various synthetic filesystems that never get mounted.  On
@@ -1859,10 +1865,11 @@ char *d_path(struct path *path, char *buf, int buflen)
 
         read_lock(&current->fs->lock);
         root = current->fs->root;
-        path_get(&current->fs->root);
+        path_get(&root);
         read_unlock(&current->fs->lock);
         spin_lock(&dcache_lock);
-        res = __d_path(path->dentry, path->mnt, &root, buf, buflen);
+        tmp = root;
+        res = __d_path(path, &tmp, buf, buflen);
         spin_unlock(&dcache_lock);
         path_put(&root);
         return res;
@@ -1890,6 +1897,48 @@ char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
 }
 
 /*
+ * Write full pathname from the root of the filesystem into the buffer.
+ */
+char *dentry_path(struct dentry *dentry, char *buf, int buflen)
+{
+        char *end = buf + buflen;
+        char *retval;
+
+        spin_lock(&dcache_lock);
+        prepend(&end, &buflen, "\0", 1);
+        if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
+                (prepend(&end, &buflen, "//deleted", 9) != 0))
+                        goto Elong;
+        if (buflen < 1)
+                goto Elong;
+        /* Get '/' right */
+        retval = end-1;
+        *retval = '/';
+
+        for (;;) {
+                struct dentry *parent;
+                if (IS_ROOT(dentry))
+                        break;
+
+                parent = dentry->d_parent;
+                prefetch(parent);
+
+                if ((prepend(&end, &buflen, dentry->d_name.name,
+                                dentry->d_name.len) != 0) ||
+                    (prepend(&end, &buflen, "/", 1) != 0))
+                        goto Elong;
+
+                retval = end;
+                dentry = parent;
+        }
+        spin_unlock(&dcache_lock);
+        return retval;
+Elong:
+        spin_unlock(&dcache_lock);
+        return ERR_PTR(-ENAMETOOLONG);
+}
+
+/*
  * NOTE! The user-level library version returns a
  * character pointer. The kernel system call just
  * returns the length of the buffer filled (which
@@ -1918,9 +1967,9 @@ asmlinkage long sys_getcwd(char __user *buf, unsigned long size)
 
         read_lock(&current->fs->lock);
         pwd = current->fs->pwd;
-        path_get(&current->fs->pwd);
+        path_get(&pwd);
         root = current->fs->root;
-        path_get(&current->fs->root);
+        path_get(&root);
         read_unlock(&current->fs->lock);
 
         error = -ENOENT;
@@ -1928,9 +1977,10 @@ asmlinkage long sys_getcwd(char __user *buf, unsigned long size)
         spin_lock(&dcache_lock);
         if (pwd.dentry->d_parent == pwd.dentry || !d_unhashed(pwd.dentry)) {
                 unsigned long len;
+                struct path tmp = root;
                 char * cwd;
 
-                cwd = __d_path(pwd.dentry, pwd.mnt, &root, page, PAGE_SIZE);
+                cwd = __d_path(&pwd, &tmp, page, PAGE_SIZE);
                 spin_unlock(&dcache_lock);
 
                 error = PTR_ERR(cwd);