1 /* getroot.c: get the root dentry for an NFS mount
3 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/module.h>
13 #include <linux/init.h>
15 #include <linux/time.h>
16 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/stat.h>
20 #include <linux/errno.h>
21 #include <linux/unistd.h>
22 #include <linux/sunrpc/clnt.h>
23 #include <linux/sunrpc/stats.h>
24 #include <linux/nfs_fs.h>
25 #include <linux/nfs_mount.h>
26 #include <linux/nfs4_mount.h>
27 #include <linux/lockd/bind.h>
28 #include <linux/seq_file.h>
29 #include <linux/mount.h>
30 #include <linux/nfs_idmap.h>
31 #include <linux/vfs.h>
32 #include <linux/namei.h>
33 #include <linux/security.h>
35 #include <asm/system.h>
36 #include <asm/uaccess.h>
39 #include "delegation.h"
42 #define NFSDBG_FACILITY NFSDBG_CLIENT
45 * Set the superblock root dentry.
46 * Note that this function frees the inode in case of error.
48 static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *inode)
50 /* The mntroot acts as the dummy root dentry for this superblock */
51 if (sb->s_root == NULL) {
52 sb->s_root = d_alloc_root(inode);
53 if (sb->s_root == NULL) {
59 * Ensure that this dentry is invisible to d_find_alias().
60 * Otherwise, it may be spliced into the tree by
61 * d_materialise_unique if a parent directory from the same
62 * filesystem gets mounted at a later time.
63 * This again causes shrink_dcache_for_umount_subtree() to
64 * Oops, since the test for IS_ROOT() will fail.
66 spin_lock(&dcache_lock);
67 spin_lock(&dcache_inode_lock);
68 spin_lock(&sb->s_root->d_lock);
69 list_del_init(&sb->s_root->d_alias);
70 spin_unlock(&sb->s_root->d_lock);
71 spin_unlock(&dcache_inode_lock);
72 spin_unlock(&dcache_lock);
78 * get an NFS2/NFS3 root dentry from the root filehandle
80 struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh)
82 struct nfs_server *server = NFS_SB(sb);
83 struct nfs_fsinfo fsinfo;
88 /* get the actual root for this mount */
89 fsinfo.fattr = nfs_alloc_fattr();
90 if (fsinfo.fattr == NULL)
91 return ERR_PTR(-ENOMEM);
93 error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
95 dprintk("nfs_get_root: getattr error = %d\n", -error);
100 inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
102 dprintk("nfs_get_root: get root inode failed\n");
103 ret = ERR_CAST(inode);
107 error = nfs_superblock_set_dummy_root(sb, inode);
109 ret = ERR_PTR(error);
113 /* root dentries normally start off anonymous and get spliced in later
114 * if the dentry tree reaches them; however if the dentry already
115 * exists, we'll pick it up at this point and use it as the root
117 ret = d_obtain_alias(inode);
119 dprintk("nfs_get_root: get root dentry failed\n");
123 security_d_instantiate(ret, inode);
125 if (ret->d_op == NULL)
126 ret->d_op = server->nfs_client->rpc_ops->dentry_ops;
128 nfs_free_fattr(fsinfo.fattr);
134 int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh)
136 struct nfs_fsinfo fsinfo;
139 dprintk("--> nfs4_get_rootfh()\n");
141 fsinfo.fattr = nfs_alloc_fattr();
142 if (fsinfo.fattr == NULL)
145 /* Start by getting the root filehandle from the server */
146 ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
148 dprintk("nfs4_get_rootfh: getroot error = %d\n", -ret);
152 if (!(fsinfo.fattr->valid & NFS_ATTR_FATTR_TYPE)
153 || !S_ISDIR(fsinfo.fattr->mode)) {
154 printk(KERN_ERR "nfs4_get_rootfh:"
155 " getroot encountered non-directory\n");
160 if (fsinfo.fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
161 printk(KERN_ERR "nfs4_get_rootfh:"
162 " getroot obtained referral\n");
167 memcpy(&server->fsid, &fsinfo.fattr->fsid, sizeof(server->fsid));
169 nfs_free_fattr(fsinfo.fattr);
170 dprintk("<-- nfs4_get_rootfh() = %d\n", ret);
175 * get an NFS4 root dentry from the root filehandle
177 struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh)
179 struct nfs_server *server = NFS_SB(sb);
180 struct nfs_fattr *fattr = NULL;
185 dprintk("--> nfs4_get_root()\n");
187 /* get the info about the server and filesystem */
188 error = nfs4_server_capabilities(server, mntfh);
190 dprintk("nfs_get_root: getcaps error = %d\n",
192 return ERR_PTR(error);
195 fattr = nfs_alloc_fattr();
197 return ERR_PTR(-ENOMEM);;
199 /* get the actual root for this mount */
200 error = server->nfs_client->rpc_ops->getattr(server, mntfh, fattr);
202 dprintk("nfs_get_root: getattr error = %d\n", -error);
203 ret = ERR_PTR(error);
207 inode = nfs_fhget(sb, mntfh, fattr);
209 dprintk("nfs_get_root: get root inode failed\n");
210 ret = ERR_CAST(inode);
214 error = nfs_superblock_set_dummy_root(sb, inode);
216 ret = ERR_PTR(error);
220 /* root dentries normally start off anonymous and get spliced in later
221 * if the dentry tree reaches them; however if the dentry already
222 * exists, we'll pick it up at this point and use it as the root
224 ret = d_obtain_alias(inode);
226 dprintk("nfs_get_root: get root dentry failed\n");
230 security_d_instantiate(ret, inode);
232 if (ret->d_op == NULL)
233 ret->d_op = server->nfs_client->rpc_ops->dentry_ops;
236 nfs_free_fattr(fattr);
237 dprintk("<-- nfs4_get_root()\n");
241 #endif /* CONFIG_NFS_V4 */