blob: 197c7db583c716f1f33544ae372331c842b9c730 [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
9 * take a look at Documentation/filesystems/Exporting.
10 */
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
Christoph Hellwige38f9812007-10-21 16:42:19 -070022static int get_name(struct vfsmount *mnt, struct dentry *dentry, char *name,
Christoph Hellwig10f11c32007-07-17 04:04:31 -070023 struct dentry *child);
24
25
Christoph Hellwige38f9812007-10-21 16:42:19 -070026static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
27 char *name, struct dentry *child)
Christoph Hellwig10f11c32007-07-17 04:04:31 -070028{
Christoph Hellwig39655162007-10-21 16:42:17 -070029 const struct export_operations *nop = dir->d_sb->s_export_op;
Christoph Hellwig10f11c32007-07-17 04:04:31 -070030
31 if (nop->get_name)
32 return nop->get_name(dir, name, child);
33 else
Christoph Hellwige38f9812007-10-21 16:42:19 -070034 return get_name(mnt, dir, 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;
46
Christoph Hellwigfb66a192007-07-17 04:04:32 -070047 if (acceptable(context, result))
48 return result;
49
Christoph Hellwige2f99012006-01-18 17:43:52 -080050 spin_lock(&dcache_lock);
51 list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) {
52 dget_locked(dentry);
53 spin_unlock(&dcache_lock);
54 if (toput)
55 dput(toput);
56 if (dentry != result && acceptable(context, dentry)) {
57 dput(result);
58 return dentry;
59 }
60 spin_lock(&dcache_lock);
61 toput = dentry;
62 }
63 spin_unlock(&dcache_lock);
64
65 if (toput)
66 dput(toput);
67 return NULL;
68}
69
Christoph Hellwigdd90b502007-07-17 04:04:32 -070070/*
71 * Find root of a disconnected subtree and return a reference to it.
72 */
73static struct dentry *
74find_disconnected_root(struct dentry *dentry)
75{
76 dget(dentry);
77 spin_lock(&dentry->d_lock);
78 while (!IS_ROOT(dentry) &&
79 (dentry->d_parent->d_flags & DCACHE_DISCONNECTED)) {
80 struct dentry *parent = dentry->d_parent;
81 dget(parent);
82 spin_unlock(&dentry->d_lock);
83 dput(dentry);
84 dentry = parent;
85 spin_lock(&dentry->d_lock);
86 }
87 spin_unlock(&dentry->d_lock);
88 return dentry;
89}
90
Christoph Hellwig019ab802007-07-17 04:04:33 -070091
92/*
93 * Make sure target_dir is fully connected to the dentry tree.
94 *
95 * It may already be, as the flag isn't always updated when connection happens.
96 */
97static int
Al Virof3f8e172008-08-11 12:39:47 -040098reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
Christoph Hellwig019ab802007-07-17 04:04:33 -070099{
Christoph Hellwig019ab802007-07-17 04:04:33 -0700100 int noprogress = 0;
101 int err = -ESTALE;
102
103 /*
104 * It is possible that a confused file system might not let us complete
105 * the path to the root. For example, if get_parent returns a directory
106 * in which we cannot find a name for the child. While this implies a
107 * very sick filesystem we don't want it to cause knfsd to spin. Hence
108 * the noprogress counter. If we go through the loop 10 times (2 is
109 * probably enough) without getting anywhere, we just give up
110 */
111 while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
112 struct dentry *pd = find_disconnected_root(target_dir);
113
114 if (!IS_ROOT(pd)) {
115 /* must have found a connected parent - great */
116 spin_lock(&pd->d_lock);
117 pd->d_flags &= ~DCACHE_DISCONNECTED;
118 spin_unlock(&pd->d_lock);
119 noprogress = 0;
Christoph Hellwige38f9812007-10-21 16:42:19 -0700120 } else if (pd == mnt->mnt_sb->s_root) {
Christoph Hellwig019ab802007-07-17 04:04:33 -0700121 printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n");
122 spin_lock(&pd->d_lock);
123 pd->d_flags &= ~DCACHE_DISCONNECTED;
124 spin_unlock(&pd->d_lock);
125 noprogress = 0;
126 } else {
127 /*
128 * We have hit the top of a disconnected path, try to
129 * find parent and connect.
130 *
131 * Racing with some other process renaming a directory
132 * isn't much of a problem here. If someone renames
133 * the directory, it will end up properly connected,
134 * which is what we want
135 *
136 * Getting the parent can't be supported generically,
137 * the locking is too icky.
138 *
139 * Instead we just return EACCES. If server reboots
140 * or inodes get flushed, you lose
141 */
142 struct dentry *ppd = ERR_PTR(-EACCES);
143 struct dentry *npd;
144
145 mutex_lock(&pd->d_inode->i_mutex);
Christoph Hellwige38f9812007-10-21 16:42:19 -0700146 if (mnt->mnt_sb->s_export_op->get_parent)
147 ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700148 mutex_unlock(&pd->d_inode->i_mutex);
149
150 if (IS_ERR(ppd)) {
151 err = PTR_ERR(ppd);
152 dprintk("%s: get_parent of %ld failed, err %d\n",
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700153 __func__, pd->d_inode->i_ino, err);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700154 dput(pd);
155 break;
156 }
157
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700158 dprintk("%s: find name of %lu in %lu\n", __func__,
Christoph Hellwig019ab802007-07-17 04:04:33 -0700159 pd->d_inode->i_ino, ppd->d_inode->i_ino);
Christoph Hellwige38f9812007-10-21 16:42:19 -0700160 err = exportfs_get_name(mnt, ppd, nbuf, pd);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700161 if (err) {
162 dput(ppd);
163 dput(pd);
164 if (err == -ENOENT)
165 /* some race between get_parent and
166 * get_name? just try again
167 */
168 continue;
169 break;
170 }
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700171 dprintk("%s: found name: %s\n", __func__, nbuf);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700172 mutex_lock(&ppd->d_inode->i_mutex);
173 npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
174 mutex_unlock(&ppd->d_inode->i_mutex);
175 if (IS_ERR(npd)) {
176 err = PTR_ERR(npd);
177 dprintk("%s: lookup failed: %d\n",
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700178 __func__, err);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700179 dput(ppd);
180 dput(pd);
181 break;
182 }
183 /* we didn't really want npd, we really wanted
184 * a side-effect of the lookup.
185 * hopefully, npd == pd, though it isn't really
186 * a problem if it isn't
187 */
188 if (npd == pd)
189 noprogress = 0;
190 else
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700191 printk("%s: npd != pd\n", __func__);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700192 dput(npd);
193 dput(ppd);
194 if (IS_ROOT(pd)) {
195 /* something went wrong, we have to give up */
196 dput(pd);
197 break;
198 }
199 }
200 dput(pd);
201 }
202
203 if (target_dir->d_flags & DCACHE_DISCONNECTED) {
204 /* something went wrong - oh-well */
205 if (!err)
206 err = -ESTALE;
207 return err;
208 }
209
210 return 0;
211}
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213struct getdents_callback {
214 char *name; /* name that was found. It already points to a
215 buffer NAME_MAX+1 is size */
216 unsigned long ino; /* the inum we are looking for */
217 int found; /* inode matched? */
218 int sequence; /* sequence counter */
219};
220
221/*
222 * A rather strange filldir function to capture
223 * the name matching the specified inode number.
224 */
225static int filldir_one(void * __buf, const char * name, int len,
David Howellsafefdbb2006-10-03 01:13:46 -0700226 loff_t pos, u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 struct getdents_callback *buf = __buf;
229 int result = 0;
230
231 buf->sequence++;
232 if (buf->ino == ino) {
233 memcpy(buf->name, name, len);
234 buf->name[len] = '\0';
235 buf->found = 1;
236 result = -1;
237 }
238 return result;
239}
240
241/**
242 * get_name - default export_operations->get_name function
243 * @dentry: the directory in which to find a name
244 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
245 * @child: the dentry for the child directory.
246 *
247 * calls readdir on the parent until it finds an entry with
248 * the same inode number as the child, and returns that.
249 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700250static int get_name(struct vfsmount *mnt, struct dentry *dentry,
251 char *name, struct dentry *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
David Howells745ca242008-11-14 10:39:22 +1100253 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 struct inode *dir = dentry->d_inode;
255 int error;
256 struct file *file;
257 struct getdents_callback buffer;
258
259 error = -ENOTDIR;
260 if (!dir || !S_ISDIR(dir->i_mode))
261 goto out;
262 error = -EINVAL;
263 if (!dir->i_fop)
264 goto out;
265 /*
266 * Open the directory ...
267 */
David Howells745ca242008-11-14 10:39:22 +1100268 file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 error = PTR_ERR(file);
270 if (IS_ERR(file))
271 goto out;
272
273 error = -EINVAL;
274 if (!file->f_op->readdir)
275 goto out_close;
276
277 buffer.name = name;
278 buffer.ino = child->d_inode->i_ino;
279 buffer.found = 0;
280 buffer.sequence = 0;
281 while (1) {
282 int old_seq = buffer.sequence;
283
284 error = vfs_readdir(file, filldir_one, &buffer);
Al Viro53c9c5c2008-08-24 07:29:52 -0400285 if (buffer.found) {
286 error = 0;
287 break;
288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 if (error < 0)
291 break;
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 error = -ENOENT;
294 if (old_seq == buffer.sequence)
295 break;
296 }
297
298out_close:
299 fput(file);
300out:
301 return error;
302}
303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304/**
305 * export_encode_fh - default export_operations->encode_fh function
306 * @dentry: the dentry to encode
307 * @fh: where to store the file handle fragment
308 * @max_len: maximum length to store there
309 * @connectable: whether to store parent information
310 *
311 * This default encode_fh function assumes that the 32 inode number
312 * is suitable for locating an inode, and that the generation number
313 * can be used to check that it is still valid. It places them in the
314 * filehandle fragment where export_decode_fh expects to find them.
315 */
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700316static int export_encode_fh(struct dentry *dentry, struct fid *fid,
317 int *max_len, int connectable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
319 struct inode * inode = dentry->d_inode;
320 int len = *max_len;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700321 int type = FILEID_INO32_GEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
323 if (len < 2 || (connectable && len < 4))
324 return 255;
325
326 len = 2;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700327 fid->i32.ino = inode->i_ino;
328 fid->i32.gen = inode->i_generation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 if (connectable && !S_ISDIR(inode->i_mode)) {
330 struct inode *parent;
331
332 spin_lock(&dentry->d_lock);
333 parent = dentry->d_parent->d_inode;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700334 fid->i32.parent_ino = parent->i_ino;
335 fid->i32.parent_gen = parent->i_generation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 spin_unlock(&dentry->d_lock);
337 len = 4;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700338 type = FILEID_INO32_GEN_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
340 *max_len = len;
341 return type;
342}
343
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700344int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700345 int connectable)
346{
Christoph Hellwig39655162007-10-21 16:42:17 -0700347 const struct export_operations *nop = dentry->d_sb->s_export_op;
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700348 int error;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700349
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700350 if (nop->encode_fh)
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700351 error = nop->encode_fh(dentry, fid->raw, max_len, connectable);
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700352 else
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700353 error = export_encode_fh(dentry, fid, max_len, connectable);
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700354
355 return error;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700356}
357EXPORT_SYMBOL_GPL(exportfs_encode_fh);
358
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700359struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
360 int fh_len, int fileid_type,
361 int (*acceptable)(void *, struct dentry *), void *context)
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700362{
Christoph Hellwig39655162007-10-21 16:42:17 -0700363 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
Christoph Hellwig25961102007-10-21 16:42:05 -0700364 struct dentry *result, *alias;
Al Virof3f8e172008-08-11 12:39:47 -0400365 char nbuf[NAME_MAX+1];
Christoph Hellwig25961102007-10-21 16:42:05 -0700366 int err;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700367
Christoph Hellwig25961102007-10-21 16:42:05 -0700368 /*
Christoph Hellwig25961102007-10-21 16:42:05 -0700369 * Try to get any dentry for the given file handle from the filesystem.
370 */
371 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500372 if (!result)
373 result = ERR_PTR(-ESTALE);
Christoph Hellwig25961102007-10-21 16:42:05 -0700374 if (IS_ERR(result))
375 return result;
376
377 if (S_ISDIR(result->d_inode->i_mode)) {
378 /*
379 * This request is for a directory.
380 *
381 * On the positive side there is only one dentry for each
382 * directory inode. On the negative side this implies that we
383 * to ensure our dentry is connected all the way up to the
384 * filesystem root.
385 */
386 if (result->d_flags & DCACHE_DISCONNECTED) {
Al Virof3f8e172008-08-11 12:39:47 -0400387 err = reconnect_path(mnt, result, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700388 if (err)
389 goto err_result;
390 }
391
392 if (!acceptable(context, result)) {
393 err = -EACCES;
394 goto err_result;
395 }
396
397 return result;
398 } else {
399 /*
400 * It's not a directory. Life is a little more complicated.
401 */
402 struct dentry *target_dir, *nresult;
Christoph Hellwig25961102007-10-21 16:42:05 -0700403
404 /*
405 * See if either the dentry we just got from the filesystem
406 * or any alias for it is acceptable. This is always true
407 * if this filesystem is exported without the subtreecheck
408 * option. If the filesystem is exported with the subtree
409 * check option there's a fair chance we need to look at
410 * the parent directory in the file handle and make sure
411 * it's connected to the filesystem root.
412 */
413 alias = find_acceptable_alias(result, acceptable, context);
414 if (alias)
415 return alias;
416
417 /*
418 * Try to extract a dentry for the parent directory from the
419 * file handle. If this fails we'll have to give up.
420 */
421 err = -ESTALE;
422 if (!nop->fh_to_parent)
423 goto err_result;
424
425 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
426 fh_len, fileid_type);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500427 if (!target_dir)
428 goto err_result;
Christoph Hellwig25961102007-10-21 16:42:05 -0700429 err = PTR_ERR(target_dir);
430 if (IS_ERR(target_dir))
431 goto err_result;
432
433 /*
434 * And as usual we need to make sure the parent directory is
435 * connected to the filesystem root. The VFS really doesn't
436 * like disconnected directories..
437 */
Al Virof3f8e172008-08-11 12:39:47 -0400438 err = reconnect_path(mnt, target_dir, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700439 if (err) {
440 dput(target_dir);
441 goto err_result;
442 }
443
444 /*
445 * Now that we've got both a well-connected parent and a
446 * dentry for the inode we're after, make sure that our
447 * inode is actually connected to the parent.
448 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700449 err = exportfs_get_name(mnt, target_dir, nbuf, result);
Christoph Hellwig25961102007-10-21 16:42:05 -0700450 if (!err) {
451 mutex_lock(&target_dir->d_inode->i_mutex);
452 nresult = lookup_one_len(nbuf, target_dir,
453 strlen(nbuf));
454 mutex_unlock(&target_dir->d_inode->i_mutex);
455 if (!IS_ERR(nresult)) {
456 if (nresult->d_inode) {
457 dput(result);
458 result = nresult;
459 } else
460 dput(nresult);
461 }
462 }
463
464 /*
465 * At this point we are done with the parent, but it's pinned
466 * by the child dentry anyway.
467 */
468 dput(target_dir);
469
470 /*
471 * And finally make sure the dentry is actually acceptable
472 * to NFSD.
473 */
474 alias = find_acceptable_alias(result, acceptable, context);
475 if (!alias) {
476 err = -EACCES;
477 goto err_result;
478 }
479
480 return alias;
481 }
482
483 err_result:
484 dput(result);
485 return ERR_PTR(err);
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700486}
487EXPORT_SYMBOL_GPL(exportfs_decode_fh);
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489MODULE_LICENSE("GPL");