new ->follow_link() and ->put_link() calling conventions

a) instead of storing the symlink body (via nd_set_link()) and returning
an opaque pointer later passed to ->put_link(), ->follow_link() _stores_
that opaque pointer (into void * passed by address by caller) and returns
the symlink body.  Returning ERR_PTR() on error, NULL on jump (procfs magic
symlinks) and pointer to symlink body for normal symlinks.  Stored pointer
is ignored in all cases except the last one.

Storing NULL for opaque pointer (or not storing it at all) means no call
of ->put_link().

b) the body used to be passed to ->put_link() implicitly (via nameidata).
Now only the opaque pointer is.  In the cases when we used the symlink body
to free stuff, ->follow_link() now should store it as opaque pointer in addition
to returning it.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

31 files changed, 195 insertions, 273 deletions

diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking
index 0a926e2ba3ab..7fa6c4ac858c 100644
--- a/Documentation/filesystems/Locking
+++ b/Documentation/filesystems/Locking
@@ -50,8 +50,8 @@ prototypes:
         int (*rename2) (struct inode *, struct dentry *,
                         struct inode *, struct dentry *, unsigned int);
         int (*readlink) (struct dentry *, char __user *,int);
-        void * (*follow_link) (struct dentry *, struct nameidata *);
-        void (*put_link) (struct dentry *, struct nameidata *, void *);
+        const char *(*follow_link) (struct dentry *, void **, struct nameidata *);
+        void (*put_link) (struct dentry *, void *);
         void (*truncate) (struct inode *);
         int (*permission) (struct inode *, int, unsigned int);
         int (*get_acl)(struct inode *, int);
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 5d833b32bbcd..1c6b03ac2e5a 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -350,8 +350,8 @@ struct inode_operations {
         int (*rename2) (struct inode *, struct dentry *,
                         struct inode *, struct dentry *, unsigned int);
         int (*readlink) (struct dentry *, char __user *,int);
-        void * (*follow_link) (struct dentry *, struct nameidata *);
-        void (*put_link) (struct dentry *, struct nameidata *, void *);
+        const char *(*follow_link) (struct dentry *, void **, struct nameidata *);
+        void (*put_link) (struct dentry *, void *);
         int (*permission) (struct inode *, int);
         int (*get_acl)(struct inode *, int);
         int (*setattr) (struct dentry *, struct iattr *);
diff --git a/drivers/staging/lustre/lustre/llite/symlink.c b/drivers/staging/lustre/lustre/llite/symlink.c
index 3711e671a4df..e488cb3bb25d 100644
--- a/drivers/staging/lustre/lustre/llite/symlink.c
+++ b/drivers/staging/lustre/lustre/llite/symlink.c
@@ -118,7 +118,7 @@ failed:
         return rc;
 }
 
-static void *ll_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *ll_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct inode *inode = d_inode(dentry);
         struct ptlrpc_request *request = NULL;
@@ -140,18 +140,17 @@ static void *ll_follow_link(struct dentry *dentry, struct nameidata *nd)
         }
         if (rc) {
                 ptlrpc_req_finished(request);
-                request = NULL;
-                symname = ERR_PTR(rc);
+                return ERR_PTR(rc);
         }
 
-        nd_set_link(nd, symname);
         /* symname may contain a pointer to the request message buffer,
          * we delay request releasing until ll_put_link then.
          */
-        return request;
+        *cookie = request;
+        return symname;
 }
 
-static void ll_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
+static void ll_put_link(struct dentry *dentry, void *cookie)
 {
         ptlrpc_req_finished(cookie);
 }
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 0ba11712b388..7cc70a39a1d8 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -1230,11 +1230,12 @@ ino_t v9fs_qid2ino(struct p9_qid *qid)
  *
  */
 
-static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *v9fs_vfs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct v9fs_session_info *v9ses = v9fs_dentry2v9ses(dentry);
         struct p9_fid *fid = v9fs_fid_lookup(dentry);
         struct p9_wstat *st;
+        char *res;
 
         p9_debug(P9_DEBUG_VFS, "%pd\n", dentry);
 
@@ -1253,14 +1254,14 @@ static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
                 kfree(st);
                 return ERR_PTR(-EINVAL);
         }
-        if (strlen(st->extension) >= PATH_MAX)
-                st->extension[PATH_MAX - 1] = '\0';
-
-        nd_set_link(nd, st->extension);
+        res = st->extension;
         st->extension = NULL;
+        if (strlen(res) >= PATH_MAX)
+                res[PATH_MAX - 1] = '\0';
+
         p9stat_free(st);
         kfree(st);
-        return NULL;
+        return *cookie = res;
 }
 
 /**
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index bc2a91f2b910..ae062ffa0f1f 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -909,8 +909,8 @@ error:
  *
  */
 
-static void *
-v9fs_vfs_follow_link_dotl(struct dentry *dentry, struct nameidata *nd)
+static const char *
+v9fs_vfs_follow_link_dotl(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct p9_fid *fid = v9fs_fid_lookup(dentry);
         char *target;
@@ -923,8 +923,7 @@ v9fs_vfs_follow_link_dotl(struct dentry *dentry, struct nameidata *nd)
         retval = p9_client_readlink(fid, &target);
         if (retval)
                 return ERR_PTR(retval);
-        nd_set_link(nd, target);
-        return NULL;
+        return *cookie = target;
 }
 
 int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
diff --git a/fs/autofs4/symlink.c b/fs/autofs4/symlink.c
index de58cc7b8076..9c6a07739c9b 100644
--- a/fs/autofs4/symlink.c
+++ b/fs/autofs4/symlink.c
@@ -12,14 +12,13 @@
 
 #include "autofs_i.h"
 
-static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *autofs4_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         if (ino && !autofs4_oz_mode(sbi))
                 ino->last_used = jiffies;
-        nd_set_link(nd, d_inode(dentry)->i_private);
-        return NULL;
+        return d_inode(dentry)->i_private;
 }
 
 const struct inode_operations autofs4_symlink_inode_operations = {
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 172e306d68a7..3a1aefb86a11 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -42,7 +42,7 @@ static struct inode *befs_iget(struct super_block *, unsigned long);
 static struct inode *befs_alloc_inode(struct super_block *sb);
 static void befs_destroy_inode(struct inode *inode);
 static void befs_destroy_inodecache(void);
-static void *befs_follow_link(struct dentry *, struct nameidata *);
+static const char *befs_follow_link(struct dentry *, void **, struct nameidata *nd);
 static int befs_utf2nls(struct super_block *sb, const char *in, int in_len,
                         char **out, int *out_len);
 static int befs_nls2utf(struct super_block *sb, const char *in, int in_len,
@@ -463,8 +463,8 @@ befs_destroy_inodecache(void)
  * The data stream become link name. Unless the LONG_SYMLINK
  * flag is set.
  */
-static void *
-befs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *
+befs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct super_block *sb = dentry->d_sb;
         struct befs_inode_info *befs_ino = BEFS_I(d_inode(dentry));
@@ -474,23 +474,20 @@ befs_follow_link(struct dentry *dentry, struct nameidata *nd)
 
         if (len == 0) {
                 befs_error(sb, "Long symlink with illegal length");
-                link = ERR_PTR(-EIO);
-        } else {
-                befs_debug(sb, "Follow long symlink");
-
-                link = kmalloc(len, GFP_NOFS);
-                if (!link) {
-                        link = ERR_PTR(-ENOMEM);
-                } else if (befs_read_lsymlink(sb, data, link, len) != len) {
-                        kfree(link);
-                        befs_error(sb, "Failed to read entire long symlink");
-                        link = ERR_PTR(-EIO);
-                } else {
-                        link[len - 1] = '\0';
-                }
+                return ERR_PTR(-EIO);
         }
-        nd_set_link(nd, link);
-        return NULL;
+        befs_debug(sb, "Follow long symlink");
+
+        link = kmalloc(len, GFP_NOFS);
+        if (!link)
+                return ERR_PTR(-ENOMEM);
+        if (befs_read_lsymlink(sb, data, link, len) != len) {
+                kfree(link);
+                befs_error(sb, "Failed to read entire long symlink");
+                return ERR_PTR(-EIO);
+        }
+        link[len - 1] = '\0';
+        return *cookie = link;
 }
 
 /*
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 252f5c15806b..61012da7e9d8 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -120,7 +120,7 @@ extern struct vfsmount *cifs_dfs_d_automount(struct path *path);
 #endif
 
 /* Functions related to symlinks */
-extern void *cifs_follow_link(struct dentry *direntry, struct nameidata *nd);
+extern const char *cifs_follow_link(struct dentry *direntry, void **cookie, struct nameidata *nd);
 extern int cifs_readlink(struct dentry *direntry, char __user *buffer,
                          int buflen);
 extern int cifs_symlink(struct inode *inode, struct dentry *direntry,
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 252e672d5604..4a439c2c0c7f 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -626,8 +626,8 @@ cifs_hl_exit:
         return rc;
 }
 
-void *
-cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
+const char *
+cifs_follow_link(struct dentry *direntry, void **cookie, struct nameidata *nd)
 {
         struct inode *inode = d_inode(direntry);
         int rc = -ENOMEM;
@@ -643,16 +643,18 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
-                rc = PTR_ERR(tlink);
-                tlink = NULL;
-                goto out;
+                free_xid(xid);
+                return ERR_CAST(tlink);
         }
         tcon = tlink_tcon(tlink);
         server = tcon->ses->server;
 
         full_path = build_path_from_dentry(direntry);
-        if (!full_path)
-                goto out;
+        if (!full_path) {
+                free_xid(xid);
+                cifs_put_tlink(tlink);
+                return ERR_PTR(-ENOMEM);
+        }
 
         cifs_dbg(FYI, "Full path: %s inode = 0x%p\n", full_path, inode);
 
@@ -670,17 +672,13 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
                                                 &target_path, cifs_sb);
 
         kfree(full_path);
-out:
+        free_xid(xid);
+        cifs_put_tlink(tlink);
         if (rc != 0) {
                 kfree(target_path);
-                target_path = ERR_PTR(rc);
+                return ERR_PTR(rc);
         }
-
-        free_xid(xid);
-        if (tlink)
-                cifs_put_tlink(tlink);
-        nd_set_link(nd, target_path);
-        return NULL;
+        return *cookie = target_path;
 }
 
 int
diff --git a/fs/configfs/symlink.c b/fs/configfs/symlink.c
index cc9f2546ea4a..fac8e8517f33 100644
--- a/fs/configfs/symlink.c
+++ b/fs/configfs/symlink.c
@@ -279,30 +279,26 @@ static int configfs_getlink(struct dentry *dentry, char * path)
 
 }
 
-static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *configfs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
-        int error = -ENOMEM;
         unsigned long page = get_zeroed_page(GFP_KERNEL);
+        int error;
 
-        if (page) {
-                error = configfs_getlink(dentry, (char *)page);
-                if (!error) {
-                        nd_set_link(nd, (char *)page);
-                        return (void *)page;
-                }
+        if (!page)
+                return ERR_PTR(-ENOMEM);
+
+        error = configfs_getlink(dentry, (char *)page);
+        if (!error) {
+                return *cookie = (void *)page;
         }
 
-        nd_set_link(nd, ERR_PTR(error));
-        return NULL;
+        free_page(page);
+        return ERR_PTR(error);
 }
 
-static void configfs_put_link(struct dentry *dentry, struct nameidata *nd,
-                              void *cookie)
+static void configfs_put_link(struct dentry *dentry, void *cookie)
 {
-        if (cookie) {
-                unsigned long page = (unsigned long)cookie;
-                free_page(page);
-        }
+        free_page((unsigned long)cookie);
 }
 
 const struct inode_operations configfs_symlink_inode_operations = {
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index fc850b55db67..cdb9d6c4532d 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -675,18 +675,16 @@ out:
         return rc ? ERR_PTR(rc) : buf;
 }
 
-static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *ecryptfs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         size_t len;
         char *buf = ecryptfs_readlink_lower(dentry, &len);
         if (IS_ERR(buf))
-                goto out;
+                return buf;
         fsstack_copy_attr_atime(d_inode(dentry),
                                 d_inode(ecryptfs_dentry_to_lower(dentry)));
         buf[len] = '\0';
-out:
-        nd_set_link(nd, buf);
-        return NULL;
+        return *cookie = buf;
 }
 
 /**
diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c
index 4264fb1e341a..afec475aaf5c 100644
--- a/fs/ext4/symlink.c
+++ b/fs/ext4/symlink.c
@@ -23,7 +23,7 @@
 #include "xattr.h"
 
 #ifdef CONFIG_EXT4_FS_ENCRYPTION
-static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *ext4_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct page *cpage = NULL;
         char *caddr, *paddr = NULL;
@@ -37,7 +37,7 @@ static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
 
         ctx = ext4_get_fname_crypto_ctx(inode, inode->i_sb->s_blocksize);
         if (IS_ERR(ctx))
-                return ctx;
+                return ERR_CAST(ctx);
 
         if (ext4_inode_is_fast_symlink(inode)) {
                 caddr = (char *) EXT4_I(inode)->i_data;
@@ -46,7 +46,7 @@ static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
                 cpage = read_mapping_page(inode->i_mapping, 0, NULL);
                 if (IS_ERR(cpage)) {
                         ext4_put_fname_crypto_ctx(&ctx);
-                        return cpage;
+                        return ERR_CAST(cpage);
                 }
                 caddr = kmap(cpage);
                 caddr[size] = 0;
@@ -77,13 +77,12 @@ static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
         /* Null-terminate the name */
         if (res <= plen)
                 paddr[res] = '\0';
-        nd_set_link(nd, paddr);
         ext4_put_fname_crypto_ctx(&ctx);
         if (cpage) {
                 kunmap(cpage);
                 page_cache_release(cpage);
         }
-        return NULL;
+        return *cookie = paddr;
 errout:
         ext4_put_fname_crypto_ctx(&ctx);
         if (cpage) {
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 658e8079aaf9..d2947937515e 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -296,19 +296,15 @@ fail:
         return err;
 }
 
-static void *f2fs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *f2fs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
-        struct page *page = page_follow_link_light(dentry, nd);
-
-        if (IS_ERR_OR_NULL(page))
-                return page;
-
-        /* this is broken symlink case */
-        if (*nd_get_link(nd) == 0) {
-                page_put_link(dentry, nd, page);
-                return ERR_PTR(-ENOENT);
+        const char *link = page_follow_link_light(dentry, cookie, nd);
+        if (!IS_ERR(link) && !*link) {
+                /* this is broken symlink case */
+                page_put_link(dentry, *cookie);
+                link = ERR_PTR(-ENOENT);
         }
-        return page;
+        return link;
 }
 
 static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 0572bca49f15..f9cb260375cf 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1365,7 +1365,7 @@ static int fuse_readdir(struct file *file, struct dir_context *ctx)
         return err;
 }
 
-static char *read_link(struct dentry *dentry)
+static const char *fuse_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct inode *inode = d_inode(dentry);
         struct fuse_conn *fc = get_fuse_conn(inode);
@@ -1389,26 +1389,15 @@ static char *read_link(struct dentry *dentry)
                 link = ERR_PTR(ret);
         } else {
                 link[ret] = '\0';
+                *cookie = link;
         }
         fuse_invalidate_atime(inode);
         return link;
 }
 
-static void free_link(char *link)
+static void fuse_put_link(struct dentry *dentry, void *cookie)
 {
-        if (!IS_ERR(link))
-                free_page((unsigned long) link);
-}
-
-static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
-{
-        nd_set_link(nd, read_link(dentry));
-        return NULL;
-}
-
-static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
-{
-        free_link(nd_get_link(nd));
+        free_page((unsigned long) cookie);
 }
 
 static int fuse_dir_open(struct inode *inode, struct file *file)
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 1b3ca7a2e3fc..f59390aebffb 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -1548,7 +1548,7 @@ out:
  * Returns: 0 on success or error code
  */
 
-static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *gfs2_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
         struct gfs2_holder i_gh;
@@ -1561,8 +1561,7 @@ static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
         error = gfs2_glock_nq(&i_gh);
         if (error) {
                 gfs2_holder_uninit(&i_gh);
-                nd_set_link(nd, ERR_PTR(error));
-                return NULL;
+                return ERR_PTR(error);
         }
 
         size = (unsigned int)i_size_read(&ip->i_inode);
@@ -1586,8 +1585,9 @@ static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
         brelse(dibh);
 out:
         gfs2_glock_dq_uninit(&i_gh);
-        nd_set_link(nd, buf);
-        return NULL;
+        if (!IS_ERR(buf))
+                *cookie = buf;
+        return buf;
 }
 
 /**
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index ef263174acd2..f650ed661fab 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -892,7 +892,7 @@ static const struct inode_operations hostfs_dir_iops = {
         .setattr        = hostfs_setattr,
 };
 
-static void *hostfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *hostfs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         char *link = __getname();
         if (link) {
@@ -906,21 +906,18 @@ static void *hostfs_follow_link(struct dentry *dentry, struct nameidata *nd)
                 }
                 if (err < 0) {
                         __putname(link);
-                        link = ERR_PTR(err);
+                        return ERR_PTR(err);
                 }
         } else {
-                link = ERR_PTR(-ENOMEM);
+                return ERR_PTR(-ENOMEM);
         }
 
-        nd_set_link(nd, link);
-        return NULL;
+        return *cookie = link;
 }
 
-static void hostfs_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
+static void hostfs_put_link(struct dentry *dentry, void *cookie)
 {
-        char *s = nd_get_link(nd);
-        if (!IS_ERR(s))
-                __putname(s);
+        __putname(cookie);
 }
 
 static const struct inode_operations hostfs_link_iops = {
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index fa2bd5366ecf..b8f24d3b04ee 100644
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -642,20 +642,19 @@ static int hppfs_readlink(struct dentry *dentry, char __user *buffer,
                                                     buflen);
 }
 
-static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *hppfs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
 
-        return d_inode(proc_dentry)->i_op->follow_link(proc_dentry, nd);
+        return d_inode(proc_dentry)->i_op->follow_link(proc_dentry, cookie, nd);
 }
 
-static void hppfs_put_link(struct dentry *dentry, struct nameidata *nd,
-                           void *cookie)
+static void hppfs_put_link(struct dentry *dentry, void *cookie)
 {
         struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
 
         if (d_inode(proc_dentry)->i_op->put_link)
-                d_inode(proc_dentry)->i_op->put_link(proc_dentry, nd, cookie);
+                d_inode(proc_dentry)->i_op->put_link(proc_dentry, cookie);
 }
 
 static const struct inode_operations hppfs_dir_iops = {
diff --git a/fs/kernfs/symlink.c b/fs/kernfs/symlink.c
index 8a198898e39a..3c7e799974a2 100644
--- a/fs/kernfs/symlink.c
+++ b/fs/kernfs/symlink.c
@@ -112,25 +112,23 @@ static int kernfs_getlink(struct dentry *dentry, char *path)
         return error;
 }
 
-static void *kernfs_iop_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *kernfs_iop_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         int error = -ENOMEM;
         unsigned long page = get_zeroed_page(GFP_KERNEL);
-        if (page) {
-                error = kernfs_getlink(dentry, (char *) page);
-                if (error < 0)
-                        free_page((unsigned long)page);
+        if (!page)
+                return ERR_PTR(-ENOMEM);
+        error = kernfs_getlink(dentry, (char *)page);
+        if (unlikely(error < 0)) {
+                free_page((unsigned long)page);
+                return ERR_PTR(error);
         }
-        nd_set_link(nd, error ? ERR_PTR(error) : (char *)page);
-        return NULL;
+        return *cookie = (char *)page;
 }
 
-static void kernfs_iop_put_link(struct dentry *dentry, struct nameidata *nd,
-                                void *cookie)
+static void kernfs_iop_put_link(struct dentry *dentry, void *cookie)
 {
-        char *page = nd_get_link(nd);
-        if (!IS_ERR(page))
-                free_page((unsigned long)page);
+        free_page((unsigned long)cookie);
 }
 
 const struct inode_operations kernfs_symlink_iops = {
diff --git a/fs/libfs.c b/fs/libfs.c
index 72e4e015455f..0c83fde20dbd 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -1024,12 +1024,9 @@ int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 }
 EXPORT_SYMBOL(noop_fsync);
 
-void kfree_put_link(struct dentry *dentry, struct nameidata *nd,
-                                void *cookie)
+void kfree_put_link(struct dentry *dentry, void *cookie)
 {
-        char *s = nd_get_link(nd);
-        if (!IS_ERR(s))
-                kfree(s);
+        kfree(cookie);
 }
 EXPORT_SYMBOL(kfree_put_link);
 
@@ -1094,10 +1091,9 @@ simple_nosetlease(struct file *filp, long arg, struct file_lock **flp,
 }
 EXPORT_SYMBOL(simple_nosetlease);
 
-void *simple_follow_link(struct dentry *dentry, struct nameidata *nd)
+const char *simple_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
-        nd_set_link(nd, d_inode(dentry)->i_link);
-        return NULL;
+        return d_inode(dentry)->i_link;
 }
 EXPORT_SYMBOL(simple_follow_link);
 
diff --git a/fs/namei.c b/fs/namei.c
index ab2bcbdbd683..aeca44877371 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -502,7 +502,6 @@ struct nameidata {
         int             last_type;
         unsigned        depth;
         struct file     *base;
-        char *saved_names[MAX_NESTED_LINKS + 1];
 };
 
 /*
@@ -713,23 +712,11 @@ void nd_jump_link(struct nameidata *nd, struct path *path)
         nd->flags |= LOOKUP_JUMPED;
 }
 
-void nd_set_link(struct nameidata *nd, char *path)
-{
-        nd->saved_names[nd->depth] = path;
-}
-EXPORT_SYMBOL(nd_set_link);
-
-char *nd_get_link(struct nameidata *nd)
-{
-        return nd->saved_names[nd->depth];
-}
-EXPORT_SYMBOL(nd_get_link);
-
 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
 {
         struct inode *inode = link->dentry->d_inode;
-        if (inode->i_op->put_link)
-                inode->i_op->put_link(link->dentry, nd, cookie);
+        if (cookie && inode->i_op->put_link)
+                inode->i_op->put_link(link->dentry, cookie);
         path_put(link);
 }
 
@@ -854,7 +841,7 @@ follow_link(struct path *link, struct nameidata *nd, void **p)
 {
         struct dentry *dentry = link->dentry;
         int error;
-        char *s;
+        const char *s;
 
         BUG_ON(nd->flags & LOOKUP_RCU);
 
@@ -869,26 +856,20 @@ follow_link(struct path *link, struct nameidata *nd, void **p)
         current->total_link_count++;
 
         touch_atime(link);
-        nd_set_link(nd, NULL);
 
         error = security_inode_follow_link(dentry);
         if (error)
                 goto out_put_nd_path;
 
         nd->last_type = LAST_BIND;
-        *p = dentry->d_inode->i_op->follow_link(dentry, nd);
-        error = PTR_ERR(*p);
-        if (IS_ERR(*p))
+        *p = NULL;
+        s = dentry->d_inode->i_op->follow_link(dentry, p, nd);
+        error = PTR_ERR(s);
+        if (IS_ERR(s))
                 goto out_put_nd_path;
 
         error = 0;
-        s = nd_get_link(nd);
         if (s) {
-                if (unlikely(IS_ERR(s))) {
-                        path_put(&nd->path);
-                        put_link(nd, link, *p);
-                        return PTR_ERR(s);
-                }
                 if (*s == '/') {
                         if (!nd->root.mnt)
                                 set_root(nd);
@@ -906,7 +887,6 @@ follow_link(struct path *link, struct nameidata *nd, void **p)
         return error;
 
 out_put_nd_path:
-        *p = NULL;
         path_put(&nd->path);
         path_put(link);
         return error;
@@ -4430,18 +4410,15 @@ EXPORT_SYMBOL(readlink_copy);
  */
 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
 {
-        struct nameidata nd;
         void *cookie;
+        const char *link = dentry->d_inode->i_op->follow_link(dentry, &cookie, NULL);
         int res;
 
-        nd.depth = 0;
-        cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
-        if (IS_ERR(cookie))
-                return PTR_ERR(cookie);
-
-        res = readlink_copy(buffer, buflen, nd_get_link(&nd));
-        if (dentry->d_inode->i_op->put_link)
-                dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
+        if (IS_ERR(link))
+                return PTR_ERR(link);
+        res = readlink_copy(buffer, buflen, link);
+        if (cookie && dentry->d_inode->i_op->put_link)
+                dentry->d_inode->i_op->put_link(dentry, cookie);
         return res;
 }
 EXPORT_SYMBOL(generic_readlink);
@@ -4473,22 +4450,21 @@ int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
 }
 EXPORT_SYMBOL(page_readlink);
 
-void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
+const char *page_follow_link_light(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct page *page = NULL;
-        nd_set_link(nd, page_getlink(dentry, &page));
-        return page;
+        char *res = page_getlink(dentry, &page);
+        if (!IS_ERR(res))
+                *cookie = page;
+        return res;
 }
 EXPORT_SYMBOL(page_follow_link_light);
 
-void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
+void page_put_link(struct dentry *dentry, void *cookie)
 {
         struct page *page = cookie;
-
-        if (page) {
-                kunmap(page);
-                page_cache_release(page);
-        }
+        kunmap(page);
+        page_cache_release(page);
 }
 EXPORT_SYMBOL(page_put_link);
 
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index 2d56200655fe..c992b200ae7e 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -20,7 +20,6 @@
 #include <linux/stat.h>
 #include <linux/mm.h>
 #include <linux/string.h>
-#include <linux/namei.h>
 
 /* Symlink caching in the page cache is even more simplistic
  * and straight-forward than readdir caching.
@@ -43,7 +42,7 @@ error:
         return -EIO;
 }
 
-static void *nfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *nfs_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct inode *inode = d_inode(dentry);
         struct page *page;
@@ -51,19 +50,13 @@ static void *nfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 
         err = ERR_PTR(nfs_revalidate_mapping(inode, inode->i_mapping));
         if (err)
-                goto read_failed;
+                return err;
         page = read_cache_page(&inode->i_data, 0,
                                 (filler_t *)nfs_symlink_filler, inode);
-        if (IS_ERR(page)) {
-                err = page;
-                goto read_failed;
-        }
-        nd_set_link(nd, kmap(page));
-        return page;
-
-read_failed:
-        nd_set_link(nd, err);
-        return NULL;
+        if (IS_ERR(page))
+                return ERR_CAST(page);
+        *cookie = page;
+        return kmap(page);
 }
 
 /*
diff --git a/fs/overlayfs/inode.c b/fs/overlayfs/inode.c
index 1b4b9c5e51b7..235ad42afb57 100644
--- a/fs/overlayfs/inode.c
+++ b/fs/overlayfs/inode.c
@@ -140,12 +140,12 @@ struct ovl_link_data {
         void *cookie;
 };
 
-static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *ovl_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
-        void *ret;
         struct dentry *realdentry;
         struct inode *realinode;
         struct ovl_link_data *data = NULL;
+        const char *ret;
 
         realdentry = ovl_dentry_real(dentry);
         realinode = realdentry->d_inode;
@@ -160,19 +160,21 @@ static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd)
                 data->realdentry = realdentry;
         }
 
-        ret = realinode->i_op->follow_link(realdentry, nd);
-        if (IS_ERR(ret)) {
+        ret = realinode->i_op->follow_link(realdentry, cookie, nd);
+        if (IS_ERR_OR_NULL(ret)) {
                 kfree(data);
                 return ret;
         }
 
         if (data)
-                data->cookie = ret;
+                data->cookie = *cookie;
 
-        return data;
+        *cookie = data;
+
+        return ret;
 }
 
-static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
+static void ovl_put_link(struct dentry *dentry, void *c)
 {
         struct inode *realinode;
         struct ovl_link_data *data = c;
@@ -181,7 +183,7 @@ static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
                 return;
 
         realinode = data->realdentry->d_inode;
-        realinode->i_op->put_link(data->realdentry, nd, data->cookie);
+        realinode->i_op->put_link(data->realdentry, data->cookie);
         kfree(data);
 }
 
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 093ca14f5701..52652f86b187 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1380,7 +1380,7 @@ static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
                 return -ENOENT;
 }
 
-static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *proc_pid_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct inode *inode = d_inode(dentry);
         struct path path;
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 8272aaba1bb0..acd51d75387d 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -23,7 +23,6 @@
 #include <linux/slab.h>
 #include <linux/mount.h>
 #include <linux/magic.h>
-#include <linux/namei.h>
 
 #include <asm/uaccess.h>
 
@@ -394,16 +393,16 @@ static const struct file_operations proc_reg_file_ops_no_compat = {
 };
 #endif
 
-static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *proc_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct proc_dir_entry *pde = PDE(d_inode(dentry));
         if (unlikely(!use_pde(pde)))
                 return ERR_PTR(-EINVAL);
-        nd_set_link(nd, pde->data);
-        return pde;
+        *cookie = pde;
+        return pde->data;
 }
 
-static void proc_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
+static void proc_put_link(struct dentry *dentry, void *p)
 {
         unuse_pde(p);
 }
diff --git a/fs/proc/namespaces.c b/fs/proc/namespaces.c
index e512642dbbdc..10d24dd096e8 100644
--- a/fs/proc/namespaces.c
+++ b/fs/proc/namespaces.c
@@ -30,7 +30,7 @@ static const struct proc_ns_operations *ns_entries[] = {
         &mntns_operations,
 };
 
-static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *proc_ns_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct inode *inode = d_inode(dentry);
         const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
diff --git a/fs/proc/self.c b/fs/proc/self.c
index 6195b4a7c3b1..ad333946b53a 100644
--- a/fs/proc/self.c
+++ b/fs/proc/self.c
@@ -1,5 +1,4 @@
 #include <linux/sched.h>
-#include <linux/namei.h>
 #include <linux/slab.h>
 #include <linux/pid_namespace.h>
 #include "internal.h"
@@ -19,21 +18,20 @@ static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
         return readlink_copy(buffer, buflen, tmp);
 }
 
-static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *proc_self_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct pid_namespace *ns = dentry->d_sb->s_fs_info;
         pid_t tgid = task_tgid_nr_ns(current, ns);
-        char *name = ERR_PTR(-ENOENT);
-        if (tgid) {
-                /* 11 for max length of signed int in decimal + NULL term */
-                name = kmalloc(12, GFP_KERNEL);
-                if (!name)
-                        name = ERR_PTR(-ENOMEM);
-                else
-                        sprintf(name, "%d", tgid);
-        }
-        nd_set_link(nd, name);
-        return NULL;
+        char *name;
+
+        if (!tgid)
+                return ERR_PTR(-ENOENT);
+        /* 11 for max length of signed int in decimal + NULL term */
+        name = kmalloc(12, GFP_KERNEL);
+        if (!name)
+                return ERR_PTR(-ENOMEM);
+        sprintf(name, "%d", tgid);
+        return *cookie = name;
 }
 
 static const struct inode_operations proc_self_inode_operations = {
diff --git a/fs/proc/thread_self.c b/fs/proc/thread_self.c
index a8371993b4fb..85c96e0d7aaa 100644
--- a/fs/proc/thread_self.c
+++ b/fs/proc/thread_self.c
@@ -1,5 +1,4 @@
 #include <linux/sched.h>
-#include <linux/namei.h>
 #include <linux/slab.h>
 #include <linux/pid_namespace.h>
 #include "internal.h"
@@ -20,21 +19,20 @@ static int proc_thread_self_readlink(struct dentry *dentry, char __user *buffer,
         return readlink_copy(buffer, buflen, tmp);
 }
 
-static void *proc_thread_self_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *proc_thread_self_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct pid_namespace *ns = dentry->d_sb->s_fs_info;
         pid_t tgid = task_tgid_nr_ns(current, ns);
         pid_t pid = task_pid_nr_ns(current, ns);
-        char *name = ERR_PTR(-ENOENT);
-        if (pid) {
-                name = kmalloc(PROC_NUMBUF + 6 + PROC_NUMBUF, GFP_KERNEL);
-                if (!name)
-                        name = ERR_PTR(-ENOMEM);
-                else
-                        sprintf(name, "%d/task/%d", tgid, pid);
-        }
-        nd_set_link(nd, name);
-        return NULL;
+        char *name;
+
+        if (!pid)
+                return ERR_PTR(-ENOENT);
+        name = kmalloc(PROC_NUMBUF + 6 + PROC_NUMBUF, GFP_KERNEL);
+        if (!name)
+                return ERR_PTR(-ENOMEM);
+        sprintf(name, "%d/task/%d", tgid, pid);
+        return *cookie = name;
 }
 
 static const struct inode_operations proc_thread_self_inode_operations = {
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index f4cd7204e236..26c4dcb1ef56 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -41,7 +41,6 @@
 
 #include <linux/capability.h>
 #include <linux/xattr.h>
-#include <linux/namei.h>
 #include <linux/posix_acl.h>
 #include <linux/security.h>
 #include <linux/fiemap.h>
@@ -414,9 +413,10 @@ xfs_vn_rename(
  * we need to be very careful about how much stack we use.
  * uio is kmalloced for this reason...
  */
-STATIC void *
+STATIC const char *
 xfs_vn_follow_link(
         struct dentry           *dentry,
+        void                    **cookie,
         struct nameidata        *nd)
 {
         char                    *link;
@@ -430,14 +430,12 @@ xfs_vn_follow_link(
         if (unlikely(error))
                 goto out_kfree;
 
-        nd_set_link(nd, link);
-        return NULL;
+        return *cookie = link;
 
  out_kfree:
         kfree(link);
  out_err:
-        nd_set_link(nd, ERR_PTR(error));
-        return NULL;
+        return ERR_PTR(error);
 }
 
 STATIC int
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 0ac758fcff00..9ab934113a28 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1608,12 +1608,12 @@ struct file_operations {
 
 struct inode_operations {
         struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
-        void * (*follow_link) (struct dentry *, struct nameidata *);
+        const char * (*follow_link) (struct dentry *, void **, struct nameidata *);
         int (*permission) (struct inode *, int);
         struct posix_acl * (*get_acl)(struct inode *, int);
 
         int (*readlink) (struct dentry *, char __user *,int);
-        void (*put_link) (struct dentry *, struct nameidata *, void *);
+        void (*put_link) (struct dentry *, void *);
 
         int (*create) (struct inode *,struct dentry *, umode_t, bool);
         int (*link) (struct dentry *,struct inode *,struct dentry *);
@@ -2705,13 +2705,13 @@ extern const struct file_operations generic_ro_fops;
 
 extern int readlink_copy(char __user *, int, const char *);
 extern int page_readlink(struct dentry *, char __user *, int);
-extern void *page_follow_link_light(struct dentry *, struct nameidata *);
-extern void page_put_link(struct dentry *, struct nameidata *, void *);
+extern const char *page_follow_link_light(struct dentry *, void **, struct nameidata *);
+extern void page_put_link(struct dentry *, void *);
 extern int __page_symlink(struct inode *inode, const char *symname, int len,
                 int nofs);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern const struct inode_operations page_symlink_inode_operations;
-extern void kfree_put_link(struct dentry *, struct nameidata *, void *);
+extern void kfree_put_link(struct dentry *, void *);
 extern int generic_readlink(struct dentry *, char __user *, int);
 extern void generic_fillattr(struct inode *, struct kstat *);
 int vfs_getattr_nosec(struct path *path, struct kstat *stat);
@@ -2722,7 +2722,7 @@ void __inode_sub_bytes(struct inode *inode, loff_t bytes);
 void inode_sub_bytes(struct inode *inode, loff_t bytes);
 loff_t inode_get_bytes(struct inode *inode);
 void inode_set_bytes(struct inode *inode, loff_t bytes);
-void *simple_follow_link(struct dentry *, struct nameidata *);
+const char *simple_follow_link(struct dentry *, void **, struct nameidata *);
 extern const struct inode_operations simple_symlink_inode_operations;
 
 extern int iterate_dir(struct file *, struct dir_context *);
diff --git a/include/linux/namei.h b/include/linux/namei.h
index c8990779f0c3..a5d5bed2c0e1 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -71,8 +71,6 @@ extern struct dentry *lock_rename(struct dentry *, struct dentry *);
 extern void unlock_rename(struct dentry *, struct dentry *);
 
 extern void nd_jump_link(struct nameidata *nd, struct path *path);
-extern void nd_set_link(struct nameidata *nd, char *path);
-extern char *nd_get_link(struct nameidata *nd);
 
 static inline void nd_terminate_link(void *name, size_t len, size_t maxlen)
 {
diff --git a/mm/shmem.c b/mm/shmem.c
index 7f6e2f889122..d1693dcb4285 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2475,24 +2475,23 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
         return 0;
 }
 
-static void *shmem_follow_link(struct dentry *dentry, struct nameidata *nd)
+static const char *shmem_follow_link(struct dentry *dentry, void **cookie, struct nameidata *nd)
 {
         struct page *page = NULL;
         int error = shmem_getpage(d_inode(dentry), 0, &page, SGP_READ, NULL);
-        nd_set_link(nd, error ? ERR_PTR(error) : kmap(page));
-        if (page)
-                unlock_page(page);
-        return page;
+        if (error)
+                return ERR_PTR(error);
+        unlock_page(page);
+        *cookie = page;
+        return kmap(page);
 }
 
-static void shmem_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
+static void shmem_put_link(struct dentry *dentry, void *cookie)
 {
-        if (!IS_ERR(nd_get_link(nd))) {
-                struct page *page = cookie;
-                kunmap(page);
-                mark_page_accessed(page);
-                page_cache_release(page);
-        }
+        struct page *page = cookie;
+        kunmap(page);
+        mark_page_accessed(page);
+        page_cache_release(page);
 }
 
 #ifdef CONFIG_TMPFS_XATTR