blob: 890e018288171e90d9991b47e7077dfbaf9c7cf8 [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
Al Virof3f8e172008-08-11 12:39:47 -040097reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
Christoph Hellwig019ab802007-07-17 04:04:33 -070098{
Christoph Hellwig019ab802007-07-17 04:04:33 -070099 int noprogress = 0;
100 int err = -ESTALE;
101
102 /*
103 * It is possible that a confused file system might not let us complete
104 * the path to the root. For example, if get_parent returns a directory
105 * in which we cannot find a name for the child. While this implies a
106 * very sick filesystem we don't want it to cause knfsd to spin. Hence
107 * the noprogress counter. If we go through the loop 10 times (2 is
108 * probably enough) without getting anywhere, we just give up
109 */
110 while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
111 struct dentry *pd = find_disconnected_root(target_dir);
112
113 if (!IS_ROOT(pd)) {
114 /* must have found a connected parent - great */
115 spin_lock(&pd->d_lock);
116 pd->d_flags &= ~DCACHE_DISCONNECTED;
117 spin_unlock(&pd->d_lock);
118 noprogress = 0;
Christoph Hellwige38f9812007-10-21 16:42:19 -0700119 } else if (pd == mnt->mnt_sb->s_root) {
Christoph Hellwig019ab802007-07-17 04:04:33 -0700120 printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n");
121 spin_lock(&pd->d_lock);
122 pd->d_flags &= ~DCACHE_DISCONNECTED;
123 spin_unlock(&pd->d_lock);
124 noprogress = 0;
125 } else {
126 /*
127 * We have hit the top of a disconnected path, try to
128 * find parent and connect.
129 *
130 * Racing with some other process renaming a directory
131 * isn't much of a problem here. If someone renames
132 * the directory, it will end up properly connected,
133 * which is what we want
134 *
135 * Getting the parent can't be supported generically,
136 * the locking is too icky.
137 *
138 * Instead we just return EACCES. If server reboots
139 * or inodes get flushed, you lose
140 */
141 struct dentry *ppd = ERR_PTR(-EACCES);
142 struct dentry *npd;
143
144 mutex_lock(&pd->d_inode->i_mutex);
Christoph Hellwige38f9812007-10-21 16:42:19 -0700145 if (mnt->mnt_sb->s_export_op->get_parent)
146 ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700147 mutex_unlock(&pd->d_inode->i_mutex);
148
149 if (IS_ERR(ppd)) {
150 err = PTR_ERR(ppd);
151 dprintk("%s: get_parent of %ld failed, err %d\n",
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700152 __func__, pd->d_inode->i_ino, err);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700153 dput(pd);
154 break;
155 }
156
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700157 dprintk("%s: find name of %lu in %lu\n", __func__,
Christoph Hellwig019ab802007-07-17 04:04:33 -0700158 pd->d_inode->i_ino, ppd->d_inode->i_ino);
Christoph Hellwige38f9812007-10-21 16:42:19 -0700159 err = exportfs_get_name(mnt, ppd, nbuf, pd);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700160 if (err) {
161 dput(ppd);
162 dput(pd);
163 if (err == -ENOENT)
164 /* some race between get_parent and
165 * get_name? just try again
166 */
167 continue;
168 break;
169 }
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700170 dprintk("%s: found name: %s\n", __func__, nbuf);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700171 mutex_lock(&ppd->d_inode->i_mutex);
172 npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
173 mutex_unlock(&ppd->d_inode->i_mutex);
174 if (IS_ERR(npd)) {
175 err = PTR_ERR(npd);
176 dprintk("%s: lookup failed: %d\n",
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700177 __func__, err);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700178 dput(ppd);
179 dput(pd);
180 break;
181 }
182 /* we didn't really want npd, we really wanted
183 * a side-effect of the lookup.
184 * hopefully, npd == pd, though it isn't really
185 * a problem if it isn't
186 */
187 if (npd == pd)
188 noprogress = 0;
189 else
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700190 printk("%s: npd != pd\n", __func__);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700191 dput(npd);
192 dput(ppd);
193 if (IS_ROOT(pd)) {
194 /* something went wrong, we have to give up */
195 dput(pd);
196 break;
197 }
198 }
199 dput(pd);
200 }
201
202 if (target_dir->d_flags & DCACHE_DISCONNECTED) {
203 /* something went wrong - oh-well */
204 if (!err)
205 err = -ESTALE;
206 return err;
207 }
208
209 return 0;
210}
211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212struct getdents_callback {
213 char *name; /* name that was found. It already points to a
214 buffer NAME_MAX+1 is size */
215 unsigned long ino; /* the inum we are looking for */
216 int found; /* inode matched? */
217 int sequence; /* sequence counter */
218};
219
220/*
221 * A rather strange filldir function to capture
222 * the name matching the specified inode number.
223 */
224static int filldir_one(void * __buf, const char * name, int len,
David Howellsafefdbb2006-10-03 01:13:46 -0700225 loff_t pos, u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
227 struct getdents_callback *buf = __buf;
228 int result = 0;
229
230 buf->sequence++;
231 if (buf->ino == ino) {
232 memcpy(buf->name, name, len);
233 buf->name[len] = '\0';
234 buf->found = 1;
235 result = -1;
236 }
237 return result;
238}
239
240/**
241 * get_name - default export_operations->get_name function
242 * @dentry: the directory in which to find a name
243 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
244 * @child: the dentry for the child directory.
245 *
246 * calls readdir on the parent until it finds an entry with
247 * the same inode number as the child, and returns that.
248 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700249static int get_name(struct vfsmount *mnt, struct dentry *dentry,
250 char *name, struct dentry *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
252 struct inode *dir = dentry->d_inode;
253 int error;
254 struct file *file;
255 struct getdents_callback buffer;
256
257 error = -ENOTDIR;
258 if (!dir || !S_ISDIR(dir->i_mode))
259 goto out;
260 error = -EINVAL;
261 if (!dir->i_fop)
262 goto out;
263 /*
264 * Open the directory ...
265 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700266 file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 error = PTR_ERR(file);
268 if (IS_ERR(file))
269 goto out;
270
271 error = -EINVAL;
272 if (!file->f_op->readdir)
273 goto out_close;
274
275 buffer.name = name;
276 buffer.ino = child->d_inode->i_ino;
277 buffer.found = 0;
278 buffer.sequence = 0;
279 while (1) {
280 int old_seq = buffer.sequence;
281
282 error = vfs_readdir(file, filldir_one, &buffer);
Al Viro53c9c5c2008-08-24 07:29:52 -0400283 if (buffer.found) {
284 error = 0;
285 break;
286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 if (error < 0)
289 break;
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 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;
Al Virof3f8e172008-08-11 12:39:47 -0400363 char nbuf[NAME_MAX+1];
Christoph Hellwig25961102007-10-21 16:42:05 -0700364 int err;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700365
Christoph Hellwig25961102007-10-21 16:42:05 -0700366 /*
Christoph Hellwig25961102007-10-21 16:42:05 -0700367 * Try to get any dentry for the given file handle from the filesystem.
368 */
369 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500370 if (!result)
371 result = ERR_PTR(-ESTALE);
Christoph Hellwig25961102007-10-21 16:42:05 -0700372 if (IS_ERR(result))
373 return result;
374
375 if (S_ISDIR(result->d_inode->i_mode)) {
376 /*
377 * This request is for a directory.
378 *
379 * On the positive side there is only one dentry for each
380 * directory inode. On the negative side this implies that we
381 * to ensure our dentry is connected all the way up to the
382 * filesystem root.
383 */
384 if (result->d_flags & DCACHE_DISCONNECTED) {
Al Virof3f8e172008-08-11 12:39:47 -0400385 err = reconnect_path(mnt, result, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700386 if (err)
387 goto err_result;
388 }
389
390 if (!acceptable(context, result)) {
391 err = -EACCES;
392 goto err_result;
393 }
394
395 return result;
396 } else {
397 /*
398 * It's not a directory. Life is a little more complicated.
399 */
400 struct dentry *target_dir, *nresult;
Christoph Hellwig25961102007-10-21 16:42:05 -0700401
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);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500425 if (!target_dir)
426 goto err_result;
Christoph Hellwig25961102007-10-21 16:42:05 -0700427 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 */
Al Virof3f8e172008-08-11 12:39:47 -0400436 err = reconnect_path(mnt, target_dir, nbuf);
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");