~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/getroot.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* getroot.c: get the root dentry for an NFS mount
  2  *
  3  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
  4  * Written by David Howells (dhowells@redhat.com)
  5  *
  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.
 10  */
 11 
 12 #include <linux/module.h>
 13 #include <linux/init.h>
 14 
 15 #include <linux/time.h>
 16 #include <linux/kernel.h>
 17 #include <linux/mm.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>
 34 
 35 #include <asm/system.h>
 36 #include <asm/uaccess.h>
 37 
 38 #include "nfs4_fs.h"
 39 #include "delegation.h"
 40 #include "internal.h"
 41 
 42 #define NFSDBG_FACILITY         NFSDBG_CLIENT
 43 
 44 /*
 45  * Set the superblock root dentry.
 46  * Note that this function frees the inode in case of error.
 47  */
 48 static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *inode)
 49 {
 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) {
 54                         iput(inode);
 55                         return -ENOMEM;
 56                 }
 57                 ihold(inode);
 58                 /*
 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.
 65                  */
 66                 spin_lock(&sb->s_root->d_inode->i_lock);
 67                 spin_lock(&sb->s_root->d_lock);
 68                 list_del_init(&sb->s_root->d_u.d_alias);
 69                 spin_unlock(&sb->s_root->d_lock);
 70                 spin_unlock(&sb->s_root->d_inode->i_lock);
 71         }
 72         return 0;
 73 }
 74 
 75 /*
 76  * get an NFS2/NFS3 root dentry from the root filehandle
 77  */
 78 struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
 79                             const char *devname)
 80 {
 81         struct nfs_server *server = NFS_SB(sb);
 82         struct nfs_fsinfo fsinfo;
 83         struct dentry *ret;
 84         struct inode *inode;
 85         void *name = kstrdup(devname, GFP_KERNEL);
 86         int error;
 87 
 88         if (!name)
 89                 return ERR_PTR(-ENOMEM);
 90 
 91         /* get the actual root for this mount */
 92         fsinfo.fattr = nfs_alloc_fattr();
 93         if (fsinfo.fattr == NULL) {
 94                 kfree(name);
 95                 return ERR_PTR(-ENOMEM);
 96         }
 97 
 98         error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
 99         if (error < 0) {
100                 dprintk("nfs_get_root: getattr error = %d\n", -error);
101                 ret = ERR_PTR(error);
102                 goto out;
103         }
104 
105         inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
106         if (IS_ERR(inode)) {
107                 dprintk("nfs_get_root: get root inode failed\n");
108                 ret = ERR_CAST(inode);
109                 goto out;
110         }
111 
112         error = nfs_superblock_set_dummy_root(sb, inode);
113         if (error != 0) {
114                 ret = ERR_PTR(error);
115                 goto out;
116         }
117 
118         /* root dentries normally start off anonymous and get spliced in later
119          * if the dentry tree reaches them; however if the dentry already
120          * exists, we'll pick it up at this point and use it as the root
121          */
122         ret = d_obtain_alias(inode);
123         if (IS_ERR(ret)) {
124                 dprintk("nfs_get_root: get root dentry failed\n");
125                 goto out;
126         }
127 
128         security_d_instantiate(ret, inode);
129         spin_lock(&ret->d_lock);
130         if (IS_ROOT(ret) && !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
131                 ret->d_fsdata = name;
132                 name = NULL;
133         }
134         spin_unlock(&ret->d_lock);
135 out:
136         if (name)
137                 kfree(name);
138         nfs_free_fattr(fsinfo.fattr);
139         return ret;
140 }
141 
142 #ifdef CONFIG_NFS_V4
143 
144 int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh)
145 {
146         struct nfs_fsinfo fsinfo;
147         int ret = -ENOMEM;
148 
149         dprintk("--> nfs4_get_rootfh()\n");
150 
151         fsinfo.fattr = nfs_alloc_fattr();
152         if (fsinfo.fattr == NULL)
153                 goto out;
154 
155         /* Start by getting the root filehandle from the server */
156         ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
157         if (ret < 0) {
158                 dprintk("nfs4_get_rootfh: getroot error = %d\n", -ret);
159                 goto out;
160         }
161 
162         if (!(fsinfo.fattr->valid & NFS_ATTR_FATTR_TYPE)
163                         || !S_ISDIR(fsinfo.fattr->mode)) {
164                 printk(KERN_ERR "nfs4_get_rootfh:"
165                        " getroot encountered non-directory\n");
166                 ret = -ENOTDIR;
167                 goto out;
168         }
169 
170         if (fsinfo.fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
171                 printk(KERN_ERR "nfs4_get_rootfh:"
172                        " getroot obtained referral\n");
173                 ret = -EREMOTE;
174                 goto out;
175         }
176 
177         memcpy(&server->fsid, &fsinfo.fattr->fsid, sizeof(server->fsid));
178 out:
179         nfs_free_fattr(fsinfo.fattr);
180         dprintk("<-- nfs4_get_rootfh() = %d\n", ret);
181         return ret;
182 }
183 
184 /*
185  * get an NFS4 root dentry from the root filehandle
186  */
187 struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh,
188                              const char *devname)
189 {
190         struct nfs_server *server = NFS_SB(sb);
191         struct nfs_fattr *fattr = NULL;
192         struct dentry *ret;
193         struct inode *inode;
194         void *name = kstrdup(devname, GFP_KERNEL);
195         int error;
196 
197         dprintk("--> nfs4_get_root()\n");
198 
199         if (!name)
200                 return ERR_PTR(-ENOMEM);
201 
202         /* get the info about the server and filesystem */
203         error = nfs4_server_capabilities(server, mntfh);
204         if (error < 0) {
205                 dprintk("nfs_get_root: getcaps error = %d\n",
206                         -error);
207                 kfree(name);
208                 return ERR_PTR(error);
209         }
210 
211         fattr = nfs_alloc_fattr();
212         if (fattr == NULL) {
213                 kfree(name);
214                 return ERR_PTR(-ENOMEM);
215         }
216 
217         /* get the actual root for this mount */
218         error = server->nfs_client->rpc_ops->getattr(server, mntfh, fattr);
219         if (error < 0) {
220                 dprintk("nfs_get_root: getattr error = %d\n", -error);
221                 ret = ERR_PTR(error);
222                 goto out;
223         }
224 
225         if (fattr->valid & NFS_ATTR_FATTR_FSID &&
226             !nfs_fsid_equal(&server->fsid, &fattr->fsid))
227                 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
228 
229         inode = nfs_fhget(sb, mntfh, fattr);
230         if (IS_ERR(inode)) {
231                 dprintk("nfs_get_root: get root inode failed\n");
232                 ret = ERR_CAST(inode);
233                 goto out;
234         }
235 
236         error = nfs_superblock_set_dummy_root(sb, inode);
237         if (error != 0) {
238                 ret = ERR_PTR(error);
239                 goto out;
240         }
241 
242         /* root dentries normally start off anonymous and get spliced in later
243          * if the dentry tree reaches them; however if the dentry already
244          * exists, we'll pick it up at this point and use it as the root
245          */
246         ret = d_obtain_alias(inode);
247         if (IS_ERR(ret)) {
248                 dprintk("nfs_get_root: get root dentry failed\n");
249                 goto out;
250         }
251 
252         security_d_instantiate(ret, inode);
253         spin_lock(&ret->d_lock);
254         if (IS_ROOT(ret) && !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
255                 ret->d_fsdata = name;
256                 name = NULL;
257         }
258         spin_unlock(&ret->d_lock);
259 out:
260         if (name)
261                 kfree(name);
262         nfs_free_fattr(fattr);
263         dprintk("<-- nfs4_get_root()\n");
264         return ret;
265 }
266 
267 #endif /* CONFIG_NFS_V4 */
268 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp