blob: a4b531be9168d576e7e5f875bf5af6dc9a01020c [file] [log] [blame]
Christoph Hellwige38f9812007-10-21 16:42:19 -07001/*
2 * Copyright (C) Neil Brown 2002
3 * Copyright (C) Christoph Hellwig 2007
4 *
5 * This file contains the code mapping from inodes to NFS file handles,
6 * and for mapping back from file handles to dentries.
7 *
8 * For details on why we do all the strange and hairy things in here
J. Bruce Fieldsdc7a0812009-10-27 14:41:35 -04009 * take a look at Documentation/filesystems/nfs/Exporting.
Christoph Hellwige38f9812007-10-21 16:42:19 -070010 */
Christoph Hellwiga5694252007-07-17 04:04:28 -070011#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/fs.h>
13#include <linux/file.h>
14#include <linux/module.h>
Christoph Hellwigd37065c2007-07-17 04:04:30 -070015#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/namei.h>
David Howells745ca242008-11-14 10:39:22 +110017#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#define dprintk(fmt, args...) do{}while(0)
20
Christoph Hellwig10f11c32007-07-17 04:04:31 -070021
Al Viro765927b2012-06-26 21:58:53 +040022static int get_name(const struct path *path, char *name, struct dentry *child);
Christoph Hellwig10f11c32007-07-17 04:04:31 -070023
24
Christoph Hellwige38f9812007-10-21 16:42:19 -070025static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
26 char *name, struct dentry *child)
Christoph Hellwig10f11c32007-07-17 04:04:31 -070027{
Christoph Hellwig39655162007-10-21 16:42:17 -070028 const struct export_operations *nop = dir->d_sb->s_export_op;
Al Viro765927b2012-06-26 21:58:53 +040029 struct path path = {.mnt = mnt, .dentry = dir};
Christoph Hellwig10f11c32007-07-17 04:04:31 -070030
31 if (nop->get_name)
32 return nop->get_name(dir, name, child);
33 else
Al Viro765927b2012-06-26 21:58:53 +040034 return get_name(&path, name, child);
Christoph Hellwig10f11c32007-07-17 04:04:31 -070035}
36
Christoph Hellwigfb66a192007-07-17 04:04:32 -070037/*
38 * Check if the dentry or any of it's aliases is acceptable.
39 */
Christoph Hellwige2f99012006-01-18 17:43:52 -080040static struct dentry *
41find_acceptable_alias(struct dentry *result,
42 int (*acceptable)(void *context, struct dentry *dentry),
43 void *context)
44{
45 struct dentry *dentry, *toput = NULL;
Nick Piggin873feea2011-01-07 17:50:06 +110046 struct inode *inode;
Christoph Hellwige2f99012006-01-18 17:43:52 -080047
Christoph Hellwigfb66a192007-07-17 04:04:32 -070048 if (acceptable(context, result))
49 return result;
50
Nick Piggin873feea2011-01-07 17:50:06 +110051 inode = result->d_inode;
52 spin_lock(&inode->i_lock);
Al Viro946e51f2014-10-26 19:19:16 -040053 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
Nick Piggindc0474b2011-01-07 17:49:43 +110054 dget(dentry);
Nick Piggin873feea2011-01-07 17:50:06 +110055 spin_unlock(&inode->i_lock);
Christoph Hellwige2f99012006-01-18 17:43:52 -080056 if (toput)
57 dput(toput);
58 if (dentry != result && acceptable(context, dentry)) {
59 dput(result);
60 return dentry;
61 }
Nick Piggin873feea2011-01-07 17:50:06 +110062 spin_lock(&inode->i_lock);
Christoph Hellwige2f99012006-01-18 17:43:52 -080063 toput = dentry;
64 }
Nick Piggin873feea2011-01-07 17:50:06 +110065 spin_unlock(&inode->i_lock);
Christoph Hellwige2f99012006-01-18 17:43:52 -080066
67 if (toput)
68 dput(toput);
69 return NULL;
70}
71
J. Bruce Fieldsa056cc82013-10-16 21:09:30 -040072static bool dentry_connected(struct dentry *dentry)
73{
74 dget(dentry);
75 while (dentry->d_flags & DCACHE_DISCONNECTED) {
76 struct dentry *parent = dget_parent(dentry);
77
78 dput(dentry);
79 if (IS_ROOT(dentry)) {
80 dput(parent);
81 return false;
82 }
83 dentry = parent;
84 }
85 dput(dentry);
86 return true;
87}
88
J. Bruce Fields0dbc0182013-09-09 16:15:13 -040089static void clear_disconnected(struct dentry *dentry)
90{
91 dget(dentry);
92 while (dentry->d_flags & DCACHE_DISCONNECTED) {
93 struct dentry *parent = dget_parent(dentry);
94
95 WARN_ON_ONCE(IS_ROOT(dentry));
96
97 spin_lock(&dentry->d_lock);
98 dentry->d_flags &= ~DCACHE_DISCONNECTED;
99 spin_unlock(&dentry->d_lock);
100
101 dput(dentry);
102 dentry = parent;
103 }
104 dput(dentry);
105}
106
Christoph Hellwig019ab802007-07-17 04:04:33 -0700107/*
J. Bruce Fieldsbbf7a8a2013-10-17 11:13:00 -0400108 * Reconnect a directory dentry with its parent.
109 *
110 * This can return a dentry, or NULL, or an error.
111 *
112 * In the first case the returned dentry is the parent of the given
113 * dentry, and may itself need to be reconnected to its parent.
114 *
115 * In the NULL case, a concurrent VFS operation has either renamed or
116 * removed this directory. The concurrent operation has reconnected our
117 * dentry, so we no longer need to.
118 */
119static struct dentry *reconnect_one(struct vfsmount *mnt,
120 struct dentry *dentry, char *nbuf)
121{
122 struct dentry *parent;
123 struct dentry *tmp;
124 int err;
125
126 parent = ERR_PTR(-EACCES);
Al Viro59551022016-01-22 15:40:57 -0500127 inode_lock(dentry->d_inode);
J. Bruce Fieldsbbf7a8a2013-10-17 11:13:00 -0400128 if (mnt->mnt_sb->s_export_op->get_parent)
129 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
Al Viro59551022016-01-22 15:40:57 -0500130 inode_unlock(dentry->d_inode);
J. Bruce Fieldsbbf7a8a2013-10-17 11:13:00 -0400131
132 if (IS_ERR(parent)) {
133 dprintk("%s: get_parent of %ld failed, err %d\n",
134 __func__, dentry->d_inode->i_ino, PTR_ERR(parent));
135 return parent;
136 }
137
138 dprintk("%s: find name of %lu in %lu\n", __func__,
139 dentry->d_inode->i_ino, parent->d_inode->i_ino);
140 err = exportfs_get_name(mnt, parent, nbuf, dentry);
141 if (err == -ENOENT)
142 goto out_reconnected;
143 if (err)
144 goto out_err;
145 dprintk("%s: found name: %s\n", __func__, nbuf);
Al Viro383d4e82016-04-14 19:12:42 -0400146 tmp = lookup_one_len_unlocked(nbuf, parent, strlen(nbuf));
J. Bruce Fieldsbbf7a8a2013-10-17 11:13:00 -0400147 if (IS_ERR(tmp)) {
148 dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));
149 goto out_err;
150 }
151 if (tmp != dentry) {
Al Viro383d4e82016-04-14 19:12:42 -0400152 /*
153 * Somebody has renamed it since exportfs_get_name();
154 * great, since it could've only been renamed if it
155 * got looked up and thus connected, and it would
156 * remain connected afterwards. We are done.
157 */
J. Bruce Fieldsbbf7a8a2013-10-17 11:13:00 -0400158 dput(tmp);
159 goto out_reconnected;
160 }
161 dput(tmp);
162 if (IS_ROOT(dentry)) {
163 err = -ESTALE;
164 goto out_err;
165 }
166 return parent;
167
168out_err:
169 dput(parent);
170 return ERR_PTR(err);
171out_reconnected:
172 dput(parent);
173 /*
174 * Someone must have renamed our entry into another parent, in
175 * which case it has been reconnected by the rename.
176 *
177 * Or someone removed it entirely, in which case filehandle
178 * lookup will succeed but the directory is now IS_DEAD and
179 * subsequent operations on it will fail.
180 *
181 * Alternatively, maybe there was no race at all, and the
182 * filesystem is just corrupt and gave us a parent that doesn't
183 * actually contain any entry pointing to this inode. So,
184 * double check that this worked and return -ESTALE if not:
185 */
186 if (!dentry_connected(dentry))
187 return ERR_PTR(-ESTALE);
188 return NULL;
189}
190
191/*
Christoph Hellwig019ab802007-07-17 04:04:33 -0700192 * Make sure target_dir is fully connected to the dentry tree.
193 *
J. Bruce Fields78cee9a2013-10-22 20:59:19 -0400194 * On successful return, DCACHE_DISCONNECTED will be cleared on
195 * target_dir, and target_dir->d_parent->...->d_parent will reach the
196 * root of the filesystem.
197 *
198 * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
199 * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
200 * set but already be connected. In that case we'll verify the
201 * connection to root and then clear the flag.
202 *
203 * Note that target_dir could be removed by a concurrent operation. In
204 * that case reconnect_path may still succeed with target_dir fully
205 * connected, but further operations using the filehandle will fail when
206 * necessary (due to S_DEAD being set on the directory).
Christoph Hellwig019ab802007-07-17 04:04:33 -0700207 */
208static int
Al Virof3f8e172008-08-11 12:39:47 -0400209reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
Christoph Hellwig019ab802007-07-17 04:04:33 -0700210{
J. Bruce Fieldsf27c9292013-10-17 21:34:21 -0400211 struct dentry *dentry, *parent;
Christoph Hellwig019ab802007-07-17 04:04:33 -0700212
J. Bruce Fieldsf27c9292013-10-17 21:34:21 -0400213 dentry = dget(target_dir);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700214
J. Bruce Fieldsf27c9292013-10-17 21:34:21 -0400215 while (dentry->d_flags & DCACHE_DISCONNECTED) {
J. Bruce Fieldsefbf2012013-10-17 21:42:35 -0400216 BUG_ON(dentry == mnt->mnt_sb->s_root);
Christoph Hellwig854ff5c2013-10-16 15:48:53 -0400217
J. Bruce Fieldsf27c9292013-10-17 21:34:21 -0400218 if (IS_ROOT(dentry))
219 parent = reconnect_one(mnt, dentry, nbuf);
220 else
221 parent = dget_parent(dentry);
222
223 if (!parent)
J. Bruce Fields0dbc0182013-09-09 16:15:13 -0400224 break;
J. Bruce Fieldsefbf2012013-10-17 21:42:35 -0400225 dput(dentry);
J. Bruce Fieldsf27c9292013-10-17 21:34:21 -0400226 if (IS_ERR(parent))
227 return PTR_ERR(parent);
228 dentry = parent;
Christoph Hellwig019ab802007-07-17 04:04:33 -0700229 }
J. Bruce Fieldsf27c9292013-10-17 21:34:21 -0400230 dput(dentry);
J. Bruce Fieldsa056cc82013-10-16 21:09:30 -0400231 clear_disconnected(target_dir);
232 return 0;
Christoph Hellwig019ab802007-07-17 04:04:33 -0700233}
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235struct getdents_callback {
Al Viro5c0ba4e2013-05-15 13:52:59 -0400236 struct dir_context ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 char *name; /* name that was found. It already points to a
238 buffer NAME_MAX+1 is size */
J. Bruce Fields950ee952013-09-10 11:41:12 -0400239 u64 ino; /* the inum we are looking for */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 int found; /* inode matched? */
241 int sequence; /* sequence counter */
242};
243
244/*
245 * A rather strange filldir function to capture
246 * the name matching the specified inode number.
247 */
Miklos Szerediac7576f2014-10-30 17:37:34 +0100248static int filldir_one(struct dir_context *ctx, const char *name, int len,
David Howellsafefdbb2006-10-03 01:13:46 -0700249 loff_t pos, u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
Miklos Szerediac7576f2014-10-30 17:37:34 +0100251 struct getdents_callback *buf =
252 container_of(ctx, struct getdents_callback, ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 int result = 0;
254
255 buf->sequence++;
Al Virodfc59e2c2013-09-06 16:55:36 -0400256 if (buf->ino == ino && len <= NAME_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 memcpy(buf->name, name, len);
258 buf->name[len] = '\0';
259 buf->found = 1;
260 result = -1;
261 }
262 return result;
263}
264
265/**
266 * get_name - default export_operations->get_name function
Fabian Frederick00f01792014-06-04 16:11:15 -0700267 * @path: the directory in which to find a name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
269 * @child: the dentry for the child directory.
270 *
271 * calls readdir on the parent until it finds an entry with
272 * the same inode number as the child, and returns that.
273 */
Al Viro765927b2012-06-26 21:58:53 +0400274static int get_name(const struct path *path, char *name, struct dentry *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
David Howells745ca242008-11-14 10:39:22 +1100276 const struct cred *cred = current_cred();
Al Viro765927b2012-06-26 21:58:53 +0400277 struct inode *dir = path->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 int error;
279 struct file *file;
J. Bruce Fields950ee952013-09-10 11:41:12 -0400280 struct kstat stat;
281 struct path child_path = {
282 .mnt = path->mnt,
283 .dentry = child,
284 };
Al Viroac6614b2013-05-22 22:22:04 -0400285 struct getdents_callback buffer = {
286 .ctx.actor = filldir_one,
287 .name = name,
Al Viroac6614b2013-05-22 22:22:04 -0400288 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 error = -ENOTDIR;
291 if (!dir || !S_ISDIR(dir->i_mode))
292 goto out;
293 error = -EINVAL;
294 if (!dir->i_fop)
295 goto out;
296 /*
J. Bruce Fields950ee952013-09-10 11:41:12 -0400297 * inode->i_ino is unsigned long, kstat->ino is u64, so the
298 * former would be insufficient on 32-bit hosts when the
299 * filesystem supports 64-bit inode numbers. So we need to
300 * actually call ->getattr, not just read i_ino:
301 */
302 error = vfs_getattr_nosec(&child_path, &stat);
303 if (error)
304 return error;
305 buffer.ino = stat.ino;
306 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 * Open the directory ...
308 */
Al Viro765927b2012-06-26 21:58:53 +0400309 file = dentry_open(path, O_RDONLY, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 error = PTR_ERR(file);
311 if (IS_ERR(file))
312 goto out;
313
314 error = -EINVAL;
Al Viro61922692016-04-20 23:08:32 -0400315 if (!file->f_op->iterate && !file->f_op->iterate_shared)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 goto out_close;
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 buffer.sequence = 0;
319 while (1) {
320 int old_seq = buffer.sequence;
321
Al Viro5c0ba4e2013-05-15 13:52:59 -0400322 error = iterate_dir(file, &buffer.ctx);
Al Viro53c9c5c2008-08-24 07:29:52 -0400323 if (buffer.found) {
324 error = 0;
325 break;
326 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 if (error < 0)
329 break;
330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 error = -ENOENT;
332 if (old_seq == buffer.sequence)
333 break;
334 }
335
336out_close:
337 fput(file);
338out:
339 return error;
340}
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342/**
343 * export_encode_fh - default export_operations->encode_fh function
Al Virob0b03822012-04-02 14:34:06 -0400344 * @inode: the object to encode
Fabian Frederick00f01792014-06-04 16:11:15 -0700345 * @fid: where to store the file handle fragment
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 * @max_len: maximum length to store there
Al Virob0b03822012-04-02 14:34:06 -0400347 * @parent: parent directory inode, if wanted
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 *
349 * This default encode_fh function assumes that the 32 inode number
350 * is suitable for locating an inode, and that the generation number
351 * can be used to check that it is still valid. It places them in the
352 * filehandle fragment where export_decode_fh expects to find them.
353 */
Al Virob0b03822012-04-02 14:34:06 -0400354static int export_encode_fh(struct inode *inode, struct fid *fid,
355 int *max_len, struct inode *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 int len = *max_len;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700358 int type = FILEID_INO32_GEN;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530359
Al Virob0b03822012-04-02 14:34:06 -0400360 if (parent && (len < 4)) {
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530361 *max_len = 4;
Namjae Jeon216b6cb2012-08-29 10:10:10 -0400362 return FILEID_INVALID;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530363 } else if (len < 2) {
364 *max_len = 2;
Namjae Jeon216b6cb2012-08-29 10:10:10 -0400365 return FILEID_INVALID;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530366 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 len = 2;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700369 fid->i32.ino = inode->i_ino;
370 fid->i32.gen = inode->i_generation;
Al Virob0b03822012-04-02 14:34:06 -0400371 if (parent) {
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700372 fid->i32.parent_ino = parent->i_ino;
373 fid->i32.parent_gen = parent->i_generation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 len = 4;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700375 type = FILEID_INO32_GEN_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 }
377 *max_len = len;
378 return type;
379}
380
Cyrill Gorcunov711c7bf2012-12-17 16:05:08 -0800381int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
382 int *max_len, struct inode *parent)
383{
384 const struct export_operations *nop = inode->i_sb->s_export_op;
385
386 if (nop && nop->encode_fh)
387 return nop->encode_fh(inode, fid->raw, max_len, parent);
388
389 return export_encode_fh(inode, fid, max_len, parent);
390}
391EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
392
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700393int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700394 int connectable)
395{
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700396 int error;
Al Virob0b03822012-04-02 14:34:06 -0400397 struct dentry *p = NULL;
398 struct inode *inode = dentry->d_inode, *parent = NULL;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700399
Al Virob0b03822012-04-02 14:34:06 -0400400 if (connectable && !S_ISDIR(inode->i_mode)) {
401 p = dget_parent(dentry);
402 /*
403 * note that while p might've ceased to be our parent already,
404 * it's still pinned by and still positive.
405 */
406 parent = p->d_inode;
407 }
Cyrill Gorcunov711c7bf2012-12-17 16:05:08 -0800408
409 error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
Al Virob0b03822012-04-02 14:34:06 -0400410 dput(p);
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700411
412 return error;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700413}
414EXPORT_SYMBOL_GPL(exportfs_encode_fh);
415
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700416struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
417 int fh_len, int fileid_type,
418 int (*acceptable)(void *, struct dentry *), void *context)
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700419{
Christoph Hellwig39655162007-10-21 16:42:17 -0700420 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
Christoph Hellwig25961102007-10-21 16:42:05 -0700421 struct dentry *result, *alias;
Al Virof3f8e172008-08-11 12:39:47 -0400422 char nbuf[NAME_MAX+1];
Christoph Hellwig25961102007-10-21 16:42:05 -0700423 int err;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700424
Christoph Hellwig25961102007-10-21 16:42:05 -0700425 /*
Christoph Hellwig25961102007-10-21 16:42:05 -0700426 * Try to get any dentry for the given file handle from the filesystem.
427 */
Aneesh Kumar K.Vbecfd1f2011-01-29 18:43:26 +0530428 if (!nop || !nop->fh_to_dentry)
429 return ERR_PTR(-ESTALE);
Christoph Hellwig25961102007-10-21 16:42:05 -0700430 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
NeilBrown09bb8bf2016-08-04 10:19:06 +1000431 if (PTR_ERR(result) == -ENOMEM)
432 return ERR_CAST(result);
433 if (IS_ERR_OR_NULL(result))
434 return ERR_PTR(-ESTALE);
Christoph Hellwig25961102007-10-21 16:42:05 -0700435
David Howellse36cb0b2015-01-29 12:02:35 +0000436 if (d_is_dir(result)) {
Christoph Hellwig25961102007-10-21 16:42:05 -0700437 /*
438 * This request is for a directory.
439 *
440 * On the positive side there is only one dentry for each
441 * directory inode. On the negative side this implies that we
442 * to ensure our dentry is connected all the way up to the
443 * filesystem root.
444 */
445 if (result->d_flags & DCACHE_DISCONNECTED) {
Al Virof3f8e172008-08-11 12:39:47 -0400446 err = reconnect_path(mnt, result, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700447 if (err)
448 goto err_result;
449 }
450
451 if (!acceptable(context, result)) {
452 err = -EACCES;
453 goto err_result;
454 }
455
456 return result;
457 } else {
458 /*
459 * It's not a directory. Life is a little more complicated.
460 */
461 struct dentry *target_dir, *nresult;
Christoph Hellwig25961102007-10-21 16:42:05 -0700462
463 /*
464 * See if either the dentry we just got from the filesystem
465 * or any alias for it is acceptable. This is always true
466 * if this filesystem is exported without the subtreecheck
467 * option. If the filesystem is exported with the subtree
468 * check option there's a fair chance we need to look at
469 * the parent directory in the file handle and make sure
470 * it's connected to the filesystem root.
471 */
472 alias = find_acceptable_alias(result, acceptable, context);
473 if (alias)
474 return alias;
475
476 /*
477 * Try to extract a dentry for the parent directory from the
478 * file handle. If this fails we'll have to give up.
479 */
480 err = -ESTALE;
481 if (!nop->fh_to_parent)
482 goto err_result;
483
484 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
485 fh_len, fileid_type);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500486 if (!target_dir)
487 goto err_result;
Christoph Hellwig25961102007-10-21 16:42:05 -0700488 err = PTR_ERR(target_dir);
489 if (IS_ERR(target_dir))
490 goto err_result;
491
492 /*
493 * And as usual we need to make sure the parent directory is
494 * connected to the filesystem root. The VFS really doesn't
495 * like disconnected directories..
496 */
Al Virof3f8e172008-08-11 12:39:47 -0400497 err = reconnect_path(mnt, target_dir, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700498 if (err) {
499 dput(target_dir);
500 goto err_result;
501 }
502
503 /*
504 * Now that we've got both a well-connected parent and a
505 * dentry for the inode we're after, make sure that our
506 * inode is actually connected to the parent.
507 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700508 err = exportfs_get_name(mnt, target_dir, nbuf, result);
Christoph Hellwig25961102007-10-21 16:42:05 -0700509 if (!err) {
Al Viro59551022016-01-22 15:40:57 -0500510 inode_lock(target_dir->d_inode);
Christoph Hellwig25961102007-10-21 16:42:05 -0700511 nresult = lookup_one_len(nbuf, target_dir,
512 strlen(nbuf));
Al Viro59551022016-01-22 15:40:57 -0500513 inode_unlock(target_dir->d_inode);
Christoph Hellwig25961102007-10-21 16:42:05 -0700514 if (!IS_ERR(nresult)) {
515 if (nresult->d_inode) {
516 dput(result);
517 result = nresult;
518 } else
519 dput(nresult);
520 }
521 }
522
523 /*
524 * At this point we are done with the parent, but it's pinned
525 * by the child dentry anyway.
526 */
527 dput(target_dir);
528
529 /*
530 * And finally make sure the dentry is actually acceptable
531 * to NFSD.
532 */
533 alias = find_acceptable_alias(result, acceptable, context);
534 if (!alias) {
535 err = -EACCES;
536 goto err_result;
537 }
538
539 return alias;
540 }
541
542 err_result:
543 dput(result);
NeilBrown09bb8bf2016-08-04 10:19:06 +1000544 if (err != -ENOMEM)
545 err = -ESTALE;
Christoph Hellwig25961102007-10-21 16:42:05 -0700546 return ERR_PTR(err);
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700547}
548EXPORT_SYMBOL_GPL(exportfs_decode_fh);
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550MODULE_LICENSE("GPL");