1 /*
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
9 * take a look at Documentation/filesystems/nfs/Exporting.
10 */
11 #include <linux/exportfs.h>
12 #include <linux/fs.h>
13 #include <linux/file.h>
14 #include <linux/module.h>
15 #include <linux/mount.h>
16 #include <linux/namei.h>
17 #include <linux/sched.h>
18
19 #define dprintk(fmt, args...) do{}while(0)
20
21
22 static int get_name(const struct path *path, char *name, struct dentry *child);
23
24
exportfs_get_name(struct vfsmount * mnt,struct dentry * dir,char * name,struct dentry * child)25 static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
26 char *name, struct dentry *child)
27 {
28 const struct export_operations *nop = dir->d_sb->s_export_op;
29 struct path path = {.mnt = mnt, .dentry = dir};
30
31 if (nop->get_name)
32 return nop->get_name(dir, name, child);
33 else
34 return get_name(&path, name, child);
35 }
36
37 /*
38 * Check if the dentry or any of it's aliases is acceptable.
39 */
40 static struct dentry *
find_acceptable_alias(struct dentry * result,int (* acceptable)(void * context,struct dentry * dentry),void * context)41 find_acceptable_alias(struct dentry *result,
42 int (*acceptable)(void *context, struct dentry *dentry),
43 void *context)
44 {
45 struct dentry *dentry, *toput = NULL;
46 struct inode *inode;
47
48 if (acceptable(context, result))
49 return result;
50
51 inode = result->d_inode;
52 spin_lock(&inode->i_lock);
53 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
54 dget(dentry);
55 spin_unlock(&inode->i_lock);
56 if (toput)
57 dput(toput);
58 if (dentry != result && acceptable(context, dentry)) {
59 dput(result);
60 return dentry;
61 }
62 spin_lock(&inode->i_lock);
63 toput = dentry;
64 }
65 spin_unlock(&inode->i_lock);
66
67 if (toput)
68 dput(toput);
69 return NULL;
70 }
71
dentry_connected(struct dentry * dentry)72 static 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 (dentry == parent) {
80 dput(parent);
81 return false;
82 }
83 dentry = parent;
84 }
85 dput(dentry);
86 return true;
87 }
88
clear_disconnected(struct dentry * dentry)89 static 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
107 /*
108 * 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 */
reconnect_one(struct vfsmount * mnt,struct dentry * dentry,char * nbuf)119 static 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);
127 mutex_lock(&dentry->d_inode->i_mutex);
128 if (mnt->mnt_sb->s_export_op->get_parent)
129 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
130 mutex_unlock(&dentry->d_inode->i_mutex);
131
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);
146 mutex_lock(&parent->d_inode->i_mutex);
147 tmp = lookup_one_len(nbuf, parent, strlen(nbuf));
148 mutex_unlock(&parent->d_inode->i_mutex);
149 if (IS_ERR(tmp)) {
150 dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));
151 err = PTR_ERR(tmp);
152 goto out_err;
153 }
154 if (tmp != dentry) {
155 dput(tmp);
156 goto out_reconnected;
157 }
158 dput(tmp);
159 if (IS_ROOT(dentry)) {
160 err = -ESTALE;
161 goto out_err;
162 }
163 return parent;
164
165 out_err:
166 dput(parent);
167 return ERR_PTR(err);
168 out_reconnected:
169 dput(parent);
170 /*
171 * Someone must have renamed our entry into another parent, in
172 * which case it has been reconnected by the rename.
173 *
174 * Or someone removed it entirely, in which case filehandle
175 * lookup will succeed but the directory is now IS_DEAD and
176 * subsequent operations on it will fail.
177 *
178 * Alternatively, maybe there was no race at all, and the
179 * filesystem is just corrupt and gave us a parent that doesn't
180 * actually contain any entry pointing to this inode. So,
181 * double check that this worked and return -ESTALE if not:
182 */
183 if (!dentry_connected(dentry))
184 return ERR_PTR(-ESTALE);
185 return NULL;
186 }
187
188 /*
189 * Make sure target_dir is fully connected to the dentry tree.
190 *
191 * On successful return, DCACHE_DISCONNECTED will be cleared on
192 * target_dir, and target_dir->d_parent->...->d_parent will reach the
193 * root of the filesystem.
194 *
195 * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
196 * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
197 * set but already be connected. In that case we'll verify the
198 * connection to root and then clear the flag.
199 *
200 * Note that target_dir could be removed by a concurrent operation. In
201 * that case reconnect_path may still succeed with target_dir fully
202 * connected, but further operations using the filehandle will fail when
203 * necessary (due to S_DEAD being set on the directory).
204 */
205 static int
reconnect_path(struct vfsmount * mnt,struct dentry * target_dir,char * nbuf)206 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
207 {
208 struct dentry *dentry, *parent;
209
210 dentry = dget(target_dir);
211
212 while (dentry->d_flags & DCACHE_DISCONNECTED) {
213 BUG_ON(dentry == mnt->mnt_sb->s_root);
214
215 if (IS_ROOT(dentry))
216 parent = reconnect_one(mnt, dentry, nbuf);
217 else
218 parent = dget_parent(dentry);
219
220 if (!parent)
221 break;
222 dput(dentry);
223 if (IS_ERR(parent))
224 return PTR_ERR(parent);
225 dentry = parent;
226 }
227 dput(dentry);
228 clear_disconnected(target_dir);
229 return 0;
230 }
231
232 struct getdents_callback {
233 struct dir_context ctx;
234 char *name; /* name that was found. It already points to a
235 buffer NAME_MAX+1 is size */
236 u64 ino; /* the inum we are looking for */
237 int found; /* inode matched? */
238 int sequence; /* sequence counter */
239 };
240
241 /*
242 * A rather strange filldir function to capture
243 * the name matching the specified inode number.
244 */
filldir_one(struct dir_context * ctx,const char * name,int len,loff_t pos,u64 ino,unsigned int d_type)245 static int filldir_one(struct dir_context *ctx, const char *name, int len,
246 loff_t pos, u64 ino, unsigned int d_type)
247 {
248 struct getdents_callback *buf =
249 container_of(ctx, struct getdents_callback, ctx);
250 int result = 0;
251
252 buf->sequence++;
253 if (buf->ino == ino && len <= NAME_MAX) {
254 memcpy(buf->name, name, len);
255 buf->name[len] = '\0';
256 buf->found = 1;
257 result = -1;
258 }
259 return result;
260 }
261
262 /**
263 * get_name - default export_operations->get_name function
264 * @path: the directory in which to find a name
265 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
266 * @child: the dentry for the child directory.
267 *
268 * calls readdir on the parent until it finds an entry with
269 * the same inode number as the child, and returns that.
270 */
get_name(const struct path * path,char * name,struct dentry * child)271 static int get_name(const struct path *path, char *name, struct dentry *child)
272 {
273 const struct cred *cred = current_cred();
274 struct inode *dir = path->dentry->d_inode;
275 int error;
276 struct file *file;
277 struct kstat stat;
278 struct path child_path = {
279 .mnt = path->mnt,
280 .dentry = child,
281 };
282 struct getdents_callback buffer = {
283 .ctx.actor = filldir_one,
284 .name = name,
285 };
286
287 error = -ENOTDIR;
288 if (!dir || !S_ISDIR(dir->i_mode))
289 goto out;
290 error = -EINVAL;
291 if (!dir->i_fop)
292 goto out;
293 /*
294 * inode->i_ino is unsigned long, kstat->ino is u64, so the
295 * former would be insufficient on 32-bit hosts when the
296 * filesystem supports 64-bit inode numbers. So we need to
297 * actually call ->getattr, not just read i_ino:
298 */
299 error = vfs_getattr_nosec(&child_path, &stat);
300 if (error)
301 return error;
302 buffer.ino = stat.ino;
303 /*
304 * Open the directory ...
305 */
306 file = dentry_open(path, O_RDONLY, cred);
307 error = PTR_ERR(file);
308 if (IS_ERR(file))
309 goto out;
310
311 error = -EINVAL;
312 if (!file->f_op->iterate)
313 goto out_close;
314
315 buffer.sequence = 0;
316 while (1) {
317 int old_seq = buffer.sequence;
318
319 error = iterate_dir(file, &buffer.ctx);
320 if (buffer.found) {
321 error = 0;
322 break;
323 }
324
325 if (error < 0)
326 break;
327
328 error = -ENOENT;
329 if (old_seq == buffer.sequence)
330 break;
331 }
332
333 out_close:
334 fput(file);
335 out:
336 return error;
337 }
338
339 /**
340 * export_encode_fh - default export_operations->encode_fh function
341 * @inode: the object to encode
342 * @fid: where to store the file handle fragment
343 * @max_len: maximum length to store there
344 * @parent: parent directory inode, if wanted
345 *
346 * This default encode_fh function assumes that the 32 inode number
347 * is suitable for locating an inode, and that the generation number
348 * can be used to check that it is still valid. It places them in the
349 * filehandle fragment where export_decode_fh expects to find them.
350 */
export_encode_fh(struct inode * inode,struct fid * fid,int * max_len,struct inode * parent)351 static int export_encode_fh(struct inode *inode, struct fid *fid,
352 int *max_len, struct inode *parent)
353 {
354 int len = *max_len;
355 int type = FILEID_INO32_GEN;
356
357 if (parent && (len < 4)) {
358 *max_len = 4;
359 return FILEID_INVALID;
360 } else if (len < 2) {
361 *max_len = 2;
362 return FILEID_INVALID;
363 }
364
365 len = 2;
366 fid->i32.ino = inode->i_ino;
367 fid->i32.gen = inode->i_generation;
368 if (parent) {
369 fid->i32.parent_ino = parent->i_ino;
370 fid->i32.parent_gen = parent->i_generation;
371 len = 4;
372 type = FILEID_INO32_GEN_PARENT;
373 }
374 *max_len = len;
375 return type;
376 }
377
exportfs_encode_inode_fh(struct inode * inode,struct fid * fid,int * max_len,struct inode * parent)378 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
379 int *max_len, struct inode *parent)
380 {
381 const struct export_operations *nop = inode->i_sb->s_export_op;
382
383 if (nop && nop->encode_fh)
384 return nop->encode_fh(inode, fid->raw, max_len, parent);
385
386 return export_encode_fh(inode, fid, max_len, parent);
387 }
388 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
389
exportfs_encode_fh(struct dentry * dentry,struct fid * fid,int * max_len,int connectable)390 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
391 int connectable)
392 {
393 int error;
394 struct dentry *p = NULL;
395 struct inode *inode = dentry->d_inode, *parent = NULL;
396
397 if (connectable && !S_ISDIR(inode->i_mode)) {
398 p = dget_parent(dentry);
399 /*
400 * note that while p might've ceased to be our parent already,
401 * it's still pinned by and still positive.
402 */
403 parent = p->d_inode;
404 }
405
406 error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
407 dput(p);
408
409 return error;
410 }
411 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
412
exportfs_decode_fh(struct vfsmount * mnt,struct fid * fid,int fh_len,int fileid_type,int (* acceptable)(void *,struct dentry *),void * context)413 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
414 int fh_len, int fileid_type,
415 int (*acceptable)(void *, struct dentry *), void *context)
416 {
417 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
418 struct dentry *result, *alias;
419 char nbuf[NAME_MAX+1];
420 int err;
421
422 /*
423 * Try to get any dentry for the given file handle from the filesystem.
424 */
425 if (!nop || !nop->fh_to_dentry)
426 return ERR_PTR(-ESTALE);
427 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
428 if (!result)
429 result = ERR_PTR(-ESTALE);
430 if (IS_ERR(result))
431 return result;
432
433 if (d_is_dir(result)) {
434 /*
435 * This request is for a directory.
436 *
437 * On the positive side there is only one dentry for each
438 * directory inode. On the negative side this implies that we
439 * to ensure our dentry is connected all the way up to the
440 * filesystem root.
441 */
442 if (result->d_flags & DCACHE_DISCONNECTED) {
443 err = reconnect_path(mnt, result, nbuf);
444 if (err)
445 goto err_result;
446 }
447
448 if (!acceptable(context, result)) {
449 err = -EACCES;
450 goto err_result;
451 }
452
453 return result;
454 } else {
455 /*
456 * It's not a directory. Life is a little more complicated.
457 */
458 struct dentry *target_dir, *nresult;
459
460 /*
461 * See if either the dentry we just got from the filesystem
462 * or any alias for it is acceptable. This is always true
463 * if this filesystem is exported without the subtreecheck
464 * option. If the filesystem is exported with the subtree
465 * check option there's a fair chance we need to look at
466 * the parent directory in the file handle and make sure
467 * it's connected to the filesystem root.
468 */
469 alias = find_acceptable_alias(result, acceptable, context);
470 if (alias)
471 return alias;
472
473 /*
474 * Try to extract a dentry for the parent directory from the
475 * file handle. If this fails we'll have to give up.
476 */
477 err = -ESTALE;
478 if (!nop->fh_to_parent)
479 goto err_result;
480
481 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
482 fh_len, fileid_type);
483 if (!target_dir)
484 goto err_result;
485 err = PTR_ERR(target_dir);
486 if (IS_ERR(target_dir))
487 goto err_result;
488
489 /*
490 * And as usual we need to make sure the parent directory is
491 * connected to the filesystem root. The VFS really doesn't
492 * like disconnected directories..
493 */
494 err = reconnect_path(mnt, target_dir, nbuf);
495 if (err) {
496 dput(target_dir);
497 goto err_result;
498 }
499
500 /*
501 * Now that we've got both a well-connected parent and a
502 * dentry for the inode we're after, make sure that our
503 * inode is actually connected to the parent.
504 */
505 err = exportfs_get_name(mnt, target_dir, nbuf, result);
506 if (!err) {
507 mutex_lock(&target_dir->d_inode->i_mutex);
508 nresult = lookup_one_len(nbuf, target_dir,
509 strlen(nbuf));
510 mutex_unlock(&target_dir->d_inode->i_mutex);
511 if (!IS_ERR(nresult)) {
512 if (nresult->d_inode) {
513 dput(result);
514 result = nresult;
515 } else
516 dput(nresult);
517 }
518 }
519
520 /*
521 * At this point we are done with the parent, but it's pinned
522 * by the child dentry anyway.
523 */
524 dput(target_dir);
525
526 /*
527 * And finally make sure the dentry is actually acceptable
528 * to NFSD.
529 */
530 alias = find_acceptable_alias(result, acceptable, context);
531 if (!alias) {
532 err = -EACCES;
533 goto err_result;
534 }
535
536 return alias;
537 }
538
539 err_result:
540 dput(result);
541 return ERR_PTR(err);
542 }
543 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
544
545 MODULE_LICENSE("GPL");
546