blob: cc91227d3bb88dcdce06b83806baf6dd7f912225 [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>
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#define dprintk(fmt, args...) do{}while(0)
19
Christoph Hellwig10f11c32007-07-17 04:04:31 -070020
Christoph Hellwige38f9812007-10-21 16:42:19 -070021static int get_name(struct vfsmount *mnt, struct dentry *dentry, char *name,
Christoph Hellwig10f11c32007-07-17 04:04:31 -070022 struct dentry *child);
23
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;
Christoph Hellwig10f11c32007-07-17 04:04:31 -070029
30 if (nop->get_name)
31 return nop->get_name(dir, name, child);
32 else
Christoph Hellwige38f9812007-10-21 16:42:19 -070033 return get_name(mnt, dir, name, child);
Christoph Hellwig10f11c32007-07-17 04:04:31 -070034}
35
Christoph Hellwigfb66a192007-07-17 04:04:32 -070036/*
37 * Check if the dentry or any of it's aliases is acceptable.
38 */
Christoph Hellwige2f99012006-01-18 17:43:52 -080039static struct dentry *
40find_acceptable_alias(struct dentry *result,
41 int (*acceptable)(void *context, struct dentry *dentry),
42 void *context)
43{
44 struct dentry *dentry, *toput = NULL;
45
Christoph Hellwigfb66a192007-07-17 04:04:32 -070046 if (acceptable(context, result))
47 return result;
48
Christoph Hellwige2f99012006-01-18 17:43:52 -080049 spin_lock(&dcache_lock);
50 list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) {
51 dget_locked(dentry);
52 spin_unlock(&dcache_lock);
53 if (toput)
54 dput(toput);
55 if (dentry != result && acceptable(context, dentry)) {
56 dput(result);
57 return dentry;
58 }
59 spin_lock(&dcache_lock);
60 toput = dentry;
61 }
62 spin_unlock(&dcache_lock);
63
64 if (toput)
65 dput(toput);
66 return NULL;
67}
68
Christoph Hellwigdd90b502007-07-17 04:04:32 -070069/*
70 * Find root of a disconnected subtree and return a reference to it.
71 */
72static struct dentry *
73find_disconnected_root(struct dentry *dentry)
74{
75 dget(dentry);
76 spin_lock(&dentry->d_lock);
77 while (!IS_ROOT(dentry) &&
78 (dentry->d_parent->d_flags & DCACHE_DISCONNECTED)) {
79 struct dentry *parent = dentry->d_parent;
80 dget(parent);
81 spin_unlock(&dentry->d_lock);
82 dput(dentry);
83 dentry = parent;
84 spin_lock(&dentry->d_lock);
85 }
86 spin_unlock(&dentry->d_lock);
87 return dentry;
88}
89
Christoph Hellwig019ab802007-07-17 04:04:33 -070090
91/*
92 * Make sure target_dir is fully connected to the dentry tree.
93 *
94 * It may already be, as the flag isn't always updated when connection happens.
95 */
96static int
Christoph Hellwige38f9812007-10-21 16:42:19 -070097reconnect_path(struct vfsmount *mnt, struct dentry *target_dir)
Christoph Hellwig019ab802007-07-17 04:04:33 -070098{
99 char nbuf[NAME_MAX+1];
100 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{
253 struct inode *dir = dentry->d_inode;
254 int error;
255 struct file *file;
256 struct getdents_callback buffer;
257
258 error = -ENOTDIR;
259 if (!dir || !S_ISDIR(dir->i_mode))
260 goto out;
261 error = -EINVAL;
262 if (!dir->i_fop)
263 goto out;
264 /*
265 * Open the directory ...
266 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700267 file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 error = PTR_ERR(file);
269 if (IS_ERR(file))
270 goto out;
271
272 error = -EINVAL;
273 if (!file->f_op->readdir)
274 goto out_close;
275
276 buffer.name = name;
277 buffer.ino = child->d_inode->i_ino;
278 buffer.found = 0;
279 buffer.sequence = 0;
280 while (1) {
281 int old_seq = buffer.sequence;
282
283 error = vfs_readdir(file, filldir_one, &buffer);
284
285 if (error < 0)
286 break;
287
288 error = 0;
289 if (buffer.found)
290 break;
291 error = -ENOENT;
292 if (old_seq == buffer.sequence)
293 break;
294 }
295
296out_close:
297 fput(file);
298out:
299 return error;
300}
301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302/**
303 * export_encode_fh - default export_operations->encode_fh function
304 * @dentry: the dentry to encode
305 * @fh: where to store the file handle fragment
306 * @max_len: maximum length to store there
307 * @connectable: whether to store parent information
308 *
309 * This default encode_fh function assumes that the 32 inode number
310 * is suitable for locating an inode, and that the generation number
311 * can be used to check that it is still valid. It places them in the
312 * filehandle fragment where export_decode_fh expects to find them.
313 */
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700314static int export_encode_fh(struct dentry *dentry, struct fid *fid,
315 int *max_len, int connectable)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
317 struct inode * inode = dentry->d_inode;
318 int len = *max_len;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700319 int type = FILEID_INO32_GEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320
321 if (len < 2 || (connectable && len < 4))
322 return 255;
323
324 len = 2;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700325 fid->i32.ino = inode->i_ino;
326 fid->i32.gen = inode->i_generation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 if (connectable && !S_ISDIR(inode->i_mode)) {
328 struct inode *parent;
329
330 spin_lock(&dentry->d_lock);
331 parent = dentry->d_parent->d_inode;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700332 fid->i32.parent_ino = parent->i_ino;
333 fid->i32.parent_gen = parent->i_generation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 spin_unlock(&dentry->d_lock);
335 len = 4;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700336 type = FILEID_INO32_GEN_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
338 *max_len = len;
339 return type;
340}
341
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700342int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700343 int connectable)
344{
Christoph Hellwig39655162007-10-21 16:42:17 -0700345 const struct export_operations *nop = dentry->d_sb->s_export_op;
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700346 int error;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700347
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700348 if (nop->encode_fh)
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700349 error = nop->encode_fh(dentry, fid->raw, max_len, connectable);
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700350 else
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700351 error = export_encode_fh(dentry, fid, max_len, connectable);
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700352
353 return error;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700354}
355EXPORT_SYMBOL_GPL(exportfs_encode_fh);
356
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700357struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
358 int fh_len, int fileid_type,
359 int (*acceptable)(void *, struct dentry *), void *context)
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700360{
Christoph Hellwig39655162007-10-21 16:42:17 -0700361 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
Christoph Hellwig25961102007-10-21 16:42:05 -0700362 struct dentry *result, *alias;
363 int err;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700364
Christoph Hellwig25961102007-10-21 16:42:05 -0700365 /*
Christoph Hellwig25961102007-10-21 16:42:05 -0700366 * Try to get any dentry for the given file handle from the filesystem.
367 */
368 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
369 if (!result)
370 result = ERR_PTR(-ESTALE);
371 if (IS_ERR(result))
372 return result;
373
374 if (S_ISDIR(result->d_inode->i_mode)) {
375 /*
376 * This request is for a directory.
377 *
378 * On the positive side there is only one dentry for each
379 * directory inode. On the negative side this implies that we
380 * to ensure our dentry is connected all the way up to the
381 * filesystem root.
382 */
383 if (result->d_flags & DCACHE_DISCONNECTED) {
Christoph Hellwige38f9812007-10-21 16:42:19 -0700384 err = reconnect_path(mnt, result);
Christoph Hellwig25961102007-10-21 16:42:05 -0700385 if (err)
386 goto err_result;
387 }
388
389 if (!acceptable(context, result)) {
390 err = -EACCES;
391 goto err_result;
392 }
393
394 return result;
395 } else {
396 /*
397 * It's not a directory. Life is a little more complicated.
398 */
399 struct dentry *target_dir, *nresult;
400 char nbuf[NAME_MAX+1];
401
402 /*
403 * See if either the dentry we just got from the filesystem
404 * or any alias for it is acceptable. This is always true
405 * if this filesystem is exported without the subtreecheck
406 * option. If the filesystem is exported with the subtree
407 * check option there's a fair chance we need to look at
408 * the parent directory in the file handle and make sure
409 * it's connected to the filesystem root.
410 */
411 alias = find_acceptable_alias(result, acceptable, context);
412 if (alias)
413 return alias;
414
415 /*
416 * Try to extract a dentry for the parent directory from the
417 * file handle. If this fails we'll have to give up.
418 */
419 err = -ESTALE;
420 if (!nop->fh_to_parent)
421 goto err_result;
422
423 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
424 fh_len, fileid_type);
425 if (!target_dir)
426 goto err_result;
427 err = PTR_ERR(target_dir);
428 if (IS_ERR(target_dir))
429 goto err_result;
430
431 /*
432 * And as usual we need to make sure the parent directory is
433 * connected to the filesystem root. The VFS really doesn't
434 * like disconnected directories..
435 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700436 err = reconnect_path(mnt, target_dir);
Christoph Hellwig25961102007-10-21 16:42:05 -0700437 if (err) {
438 dput(target_dir);
439 goto err_result;
440 }
441
442 /*
443 * Now that we've got both a well-connected parent and a
444 * dentry for the inode we're after, make sure that our
445 * inode is actually connected to the parent.
446 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700447 err = exportfs_get_name(mnt, target_dir, nbuf, result);
Christoph Hellwig25961102007-10-21 16:42:05 -0700448 if (!err) {
449 mutex_lock(&target_dir->d_inode->i_mutex);
450 nresult = lookup_one_len(nbuf, target_dir,
451 strlen(nbuf));
452 mutex_unlock(&target_dir->d_inode->i_mutex);
453 if (!IS_ERR(nresult)) {
454 if (nresult->d_inode) {
455 dput(result);
456 result = nresult;
457 } else
458 dput(nresult);
459 }
460 }
461
462 /*
463 * At this point we are done with the parent, but it's pinned
464 * by the child dentry anyway.
465 */
466 dput(target_dir);
467
468 /*
469 * And finally make sure the dentry is actually acceptable
470 * to NFSD.
471 */
472 alias = find_acceptable_alias(result, acceptable, context);
473 if (!alias) {
474 err = -EACCES;
475 goto err_result;
476 }
477
478 return alias;
479 }
480
481 err_result:
482 dput(result);
483 return ERR_PTR(err);
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700484}
485EXPORT_SYMBOL_GPL(exportfs_decode_fh);
486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487MODULE_LICENSE("GPL");