namei: move link/cookie pairs into nameidata

[cascardo/linux.git] / fs / namei.c

diff --git a/fs/namei.c b/fs/namei.c
index 9f45d33..d4b238a 100644 (file)
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -505,6 +505,11 @@ struct nameidata {
        int             last_type;
        unsigned        depth;
        struct file     *base;
+       struct saved {
+               struct path link;
+               void *cookie;
+               const char *name;
+       } stack[MAX_NESTED_LINKS + 1];
 };
 
 /*
@@ -1711,8 +1716,9 @@ static inline u64 hash_name(const char *name)
  */
 static int link_path_walk(const char *name, struct nameidata *nd)
 {
+       struct saved *last = nd->stack;
        int err;
-       
+
        while (*name=='/')
                name++;
        if (!*name)
@@ -1759,7 +1765,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)
 
                name += hashlen_len(hash_len);
                if (!*name)
-                       return 0;
+                       goto OK;
                /*
                 * If it wasn't NUL, we know it was '/'. Skip that
                 * slash, and continue until no more slashes.
@@ -1768,43 +1774,45 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                        name++;
                } while (unlikely(*name == '/'));
                if (!*name)
-                       return 0;
+                       goto OK;
 
                err = walk_component(nd, LOOKUP_FOLLOW);
 Walked:
                if (err < 0)
-                       return err;
+                       goto Err;
 
                if (err) {
-                       struct path link;
-                       void *cookie;
                        const char *s;
 
                        if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
                                path_put_conditional(&nd->link, nd);
                                path_put(&nd->path);
-                               return -ELOOP;
+                               err = -ELOOP;
+                               goto Err;
                        }
                        BUG_ON(nd->depth >= MAX_NESTED_LINKS);
 
                        nd->depth++;
                        current->link_count++;
+                       last++;
 
-                       link = nd->link;
-                       s = get_link(&link, nd, &cookie);
+                       last->link = nd->link;
+                       s = get_link(&last->link, nd, &last->cookie);
 
                        if (unlikely(IS_ERR(s))) {
                                err = PTR_ERR(s);
                                current->link_count--;
                                nd->depth--;
-                               return err;
+                               last--;
+                               goto Err;
                        }
                        err = 0;
                        if (unlikely(!s)) {
                                /* jumped */
-                               put_link(nd, &link, cookie);
+                               put_link(nd, &last->link, last->cookie);
                                current->link_count--;
                                nd->depth--;
+                               last--;
                        } else {
                                if (*s == '/') {
                                        if (!nd->root.mnt)
@@ -1813,21 +1821,15 @@ Walked:
                                        nd->path = nd->root;
                                        path_get(&nd->root);
                                        nd->flags |= LOOKUP_JUMPED;
+                                       while (unlikely(*++s == '/'))
+                                               ;
                                }
                                nd->inode = nd->path.dentry->d_inode;
-                               err = link_path_walk(s, nd);
-                               if (unlikely(err)) {
-                                       put_link(nd, &link, cookie);
-                                       current->link_count--;
-                                       nd->depth--;
-                                       return err;
-                               } else {
-                                       err = walk_component(nd, LOOKUP_FOLLOW);
-                                       put_link(nd, &link, cookie);
-                                       current->link_count--;
-                                       nd->depth--;
-                                       goto Walked;
-                               }
+                               last->name = name;
+                               if (!*s)
+                                       goto OK;
+                               name = s;
+                               continue;
                        }
                }
                if (!d_can_lookup(nd->path.dentry)) {
@@ -1836,7 +1838,25 @@ Walked:
                }
        }
        terminate_walk(nd);
+Err:
+       while (unlikely(nd->depth)) {
+               put_link(nd, &last->link, last->cookie);
+               current->link_count--;
+               nd->depth--;
+               last--;
+       }
        return err;
+OK:
+       if (unlikely(nd->depth)) {
+               name = last->name;
+               err = walk_component(nd, LOOKUP_FOLLOW);
+               put_link(nd, &last->link, last->cookie);
+               current->link_count--;
+               nd->depth--;
+               last--;
+               goto Walked;
+       }
+       return 0;
 }
 
 static int path_init(int dfd, const struct filename *name, unsigned int flags,
@@ -2011,13 +2031,13 @@ static int path_lookupat(int dfd, const struct filename *name,
        if (!err && !(flags & LOOKUP_PARENT)) {
                err = lookup_last(nd);
                while (err > 0) {
-                       void *cookie;
-                       struct path link = nd->link;
-                       err = trailing_symlink(&link, nd, &cookie);
+                       nd->stack[0].link = nd->link;
+                       err = trailing_symlink(&nd->stack[0].link,
+                                               nd, &nd->stack[0].cookie);
                        if (err)
                                break;
                        err = lookup_last(nd);
-                       put_link(nd, &link, cookie);
+                       put_link(nd, &nd->stack[0].link, nd->stack[0].cookie);
                }
        }
 
@@ -2357,13 +2377,13 @@ path_mountpoint(int dfd, const struct filename *name, struct path *path,
 
        err = mountpoint_last(nd, path);
        while (err > 0) {
-               void *cookie;
-               struct path link = *path;
-               err = trailing_symlink(&link, nd, &cookie);
+               nd->stack[0].link = nd->link;
+               err = trailing_symlink(&nd->stack[0].link,
+                                       nd, &nd->stack[0].cookie);
                if (err)
                        break;
                err = mountpoint_last(nd, path);
-               put_link(nd, &link, cookie);
+               put_link(nd, &nd->stack[0].link, nd->stack[0].cookie);
        }
 out:
        path_cleanup(nd);
@@ -3240,14 +3260,14 @@ static struct file *path_openat(int dfd, struct filename *pathname,
 
        error = do_last(nd, file, op, &opened, pathname);
        while (unlikely(error > 0)) { /* trailing symlink */
-               struct path link = nd->link;
-               void *cookie;
                nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
-               error = trailing_symlink(&link, nd, &cookie);
+               nd->stack[0].link = nd->link;
+               error= trailing_symlink(&nd->stack[0].link,
+                                       nd, &nd->stack[0].cookie);
                if (unlikely(error))
                        break;
                error = do_last(nd, file, op, &opened, pathname);
-               put_link(nd, &link, cookie);
+               put_link(nd, &nd->stack[0].link, nd->stack[0].cookie);
        }
 out:
        path_cleanup(nd);