2 * Copyright (C) Neil Brown 2002
3 * Copyright (C) Christoph Hellwig 2007
5 * This file contains the code mapping from inodes to NFS file handles,
6 * and for mapping back from file handles to dentries.
8 * For details on why we do all the strange and hairy things in here
9 * take a look at Documentation/filesystems/nfs/Exporting.
11 #include <linux/exportfs.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>
19 #define dprintk(fmt, args...) do{}while(0)
22 static int get_name(const struct path *path, char *name, struct dentry *child);
25 static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
26 char *name, struct dentry *child)
28 const struct export_operations *nop = dir->d_sb->s_export_op;
29 struct path path = {.mnt = mnt, .dentry = dir};
32 return nop->get_name(dir, name, child);
34 return get_name(&path, name, child);
38 * Check if the dentry or any of it's aliases is acceptable.
40 static struct dentry *
41 find_acceptable_alias(struct dentry *result,
42 int (*acceptable)(void *context, struct dentry *dentry),
45 struct dentry *dentry, *toput = NULL;
48 if (acceptable(context, result))
51 inode = result->d_inode;
52 spin_lock(&inode->i_lock);
53 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
55 spin_unlock(&inode->i_lock);
58 if (dentry != result && acceptable(context, dentry)) {
62 spin_lock(&inode->i_lock);
65 spin_unlock(&inode->i_lock);
73 * Find root of a disconnected subtree and return a reference to it.
75 static struct dentry *
76 find_disconnected_root(struct dentry *dentry)
79 while (!IS_ROOT(dentry)) {
80 struct dentry *parent = dget_parent(dentry);
82 if (!(parent->d_flags & DCACHE_DISCONNECTED)) {
94 * Make sure target_dir is fully connected to the dentry tree.
96 * On successful return, DCACHE_DISCONNECTED will be cleared on
97 * target_dir, and target_dir->d_parent->...->d_parent will reach the
98 * root of the filesystem.
100 * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
101 * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
102 * set but already be connected. In that case we'll verify the
103 * connection to root and then clear the flag.
105 * Note that target_dir could be removed by a concurrent operation. In
106 * that case reconnect_path may still succeed with target_dir fully
107 * connected, but further operations using the filehandle will fail when
108 * necessary (due to S_DEAD being set on the directory).
111 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
117 * It is possible that a confused file system might not let us complete
118 * the path to the root. For example, if get_parent returns a directory
119 * in which we cannot find a name for the child. While this implies a
120 * very sick filesystem we don't want it to cause knfsd to spin. Hence
121 * the noprogress counter. If we go through the loop 10 times (2 is
122 * probably enough) without getting anywhere, we just give up
124 while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
125 struct dentry *pd = find_disconnected_root(target_dir);
127 BUG_ON(pd == mnt->mnt_sb->s_root);
130 /* must have found a connected parent - great */
131 spin_lock(&pd->d_lock);
132 pd->d_flags &= ~DCACHE_DISCONNECTED;
133 spin_unlock(&pd->d_lock);
137 * We have hit the top of a disconnected path, try to
138 * find parent and connect.
140 * Racing with some other process renaming a directory
141 * isn't much of a problem here. If someone renames
142 * the directory, it will end up properly connected,
143 * which is what we want
145 * Getting the parent can't be supported generically,
146 * the locking is too icky.
148 * Instead we just return EACCES. If server reboots
149 * or inodes get flushed, you lose
151 struct dentry *ppd = ERR_PTR(-EACCES);
154 mutex_lock(&pd->d_inode->i_mutex);
155 if (mnt->mnt_sb->s_export_op->get_parent)
156 ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
157 mutex_unlock(&pd->d_inode->i_mutex);
161 dprintk("%s: get_parent of %ld failed, err %d\n",
162 __func__, pd->d_inode->i_ino, err);
167 dprintk("%s: find name of %lu in %lu\n", __func__,
168 pd->d_inode->i_ino, ppd->d_inode->i_ino);
169 err = exportfs_get_name(mnt, ppd, nbuf, pd);
174 /* some race between get_parent and
175 * get_name? just try again
180 dprintk("%s: found name: %s\n", __func__, nbuf);
181 mutex_lock(&ppd->d_inode->i_mutex);
182 npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
183 mutex_unlock(&ppd->d_inode->i_mutex);
186 dprintk("%s: lookup failed: %d\n",
192 /* we didn't really want npd, we really wanted
193 * a side-effect of the lookup.
194 * hopefully, npd == pd, though it isn't really
195 * a problem if it isn't
200 printk("%s: npd != pd\n", __func__);
204 /* something went wrong, we have to give up */
212 if (target_dir->d_flags & DCACHE_DISCONNECTED) {
213 /* something went wrong - oh-well */
222 struct getdents_callback {
223 struct dir_context ctx;
224 char *name; /* name that was found. It already points to a
225 buffer NAME_MAX+1 is size */
226 u64 ino; /* the inum we are looking for */
227 int found; /* inode matched? */
228 int sequence; /* sequence counter */
232 * A rather strange filldir function to capture
233 * the name matching the specified inode number.
235 static int filldir_one(void * __buf, const char * name, int len,
236 loff_t pos, u64 ino, unsigned int d_type)
238 struct getdents_callback *buf = __buf;
242 if (buf->ino == ino && len <= NAME_MAX) {
243 memcpy(buf->name, name, len);
244 buf->name[len] = '\0';
252 * get_name - default export_operations->get_name function
253 * @dentry: the directory in which to find a name
254 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
255 * @child: the dentry for the child directory.
257 * calls readdir on the parent until it finds an entry with
258 * the same inode number as the child, and returns that.
260 static int get_name(const struct path *path, char *name, struct dentry *child)
262 const struct cred *cred = current_cred();
263 struct inode *dir = path->dentry->d_inode;
267 struct path child_path = {
271 struct getdents_callback buffer = {
272 .ctx.actor = filldir_one,
277 if (!dir || !S_ISDIR(dir->i_mode))
283 * inode->i_ino is unsigned long, kstat->ino is u64, so the
284 * former would be insufficient on 32-bit hosts when the
285 * filesystem supports 64-bit inode numbers. So we need to
286 * actually call ->getattr, not just read i_ino:
288 error = vfs_getattr_nosec(&child_path, &stat);
291 buffer.ino = stat.ino;
293 * Open the directory ...
295 file = dentry_open(path, O_RDONLY, cred);
296 error = PTR_ERR(file);
301 if (!file->f_op->iterate)
306 int old_seq = buffer.sequence;
308 error = iterate_dir(file, &buffer.ctx);
318 if (old_seq == buffer.sequence)
329 * export_encode_fh - default export_operations->encode_fh function
330 * @inode: the object to encode
331 * @fh: where to store the file handle fragment
332 * @max_len: maximum length to store there
333 * @parent: parent directory inode, if wanted
335 * This default encode_fh function assumes that the 32 inode number
336 * is suitable for locating an inode, and that the generation number
337 * can be used to check that it is still valid. It places them in the
338 * filehandle fragment where export_decode_fh expects to find them.
340 static int export_encode_fh(struct inode *inode, struct fid *fid,
341 int *max_len, struct inode *parent)
344 int type = FILEID_INO32_GEN;
346 if (parent && (len < 4)) {
348 return FILEID_INVALID;
349 } else if (len < 2) {
351 return FILEID_INVALID;
355 fid->i32.ino = inode->i_ino;
356 fid->i32.gen = inode->i_generation;
358 fid->i32.parent_ino = parent->i_ino;
359 fid->i32.parent_gen = parent->i_generation;
361 type = FILEID_INO32_GEN_PARENT;
367 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
368 int *max_len, struct inode *parent)
370 const struct export_operations *nop = inode->i_sb->s_export_op;
372 if (nop && nop->encode_fh)
373 return nop->encode_fh(inode, fid->raw, max_len, parent);
375 return export_encode_fh(inode, fid, max_len, parent);
377 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
379 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
383 struct dentry *p = NULL;
384 struct inode *inode = dentry->d_inode, *parent = NULL;
386 if (connectable && !S_ISDIR(inode->i_mode)) {
387 p = dget_parent(dentry);
389 * note that while p might've ceased to be our parent already,
390 * it's still pinned by and still positive.
395 error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
400 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
402 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
403 int fh_len, int fileid_type,
404 int (*acceptable)(void *, struct dentry *), void *context)
406 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
407 struct dentry *result, *alias;
408 char nbuf[NAME_MAX+1];
412 * Try to get any dentry for the given file handle from the filesystem.
414 if (!nop || !nop->fh_to_dentry)
415 return ERR_PTR(-ESTALE);
416 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
418 result = ERR_PTR(-ESTALE);
422 if (S_ISDIR(result->d_inode->i_mode)) {
424 * This request is for a directory.
426 * On the positive side there is only one dentry for each
427 * directory inode. On the negative side this implies that we
428 * to ensure our dentry is connected all the way up to the
431 if (result->d_flags & DCACHE_DISCONNECTED) {
432 err = reconnect_path(mnt, result, nbuf);
437 if (!acceptable(context, result)) {
445 * It's not a directory. Life is a little more complicated.
447 struct dentry *target_dir, *nresult;
450 * See if either the dentry we just got from the filesystem
451 * or any alias for it is acceptable. This is always true
452 * if this filesystem is exported without the subtreecheck
453 * option. If the filesystem is exported with the subtree
454 * check option there's a fair chance we need to look at
455 * the parent directory in the file handle and make sure
456 * it's connected to the filesystem root.
458 alias = find_acceptable_alias(result, acceptable, context);
463 * Try to extract a dentry for the parent directory from the
464 * file handle. If this fails we'll have to give up.
467 if (!nop->fh_to_parent)
470 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
471 fh_len, fileid_type);
474 err = PTR_ERR(target_dir);
475 if (IS_ERR(target_dir))
479 * And as usual we need to make sure the parent directory is
480 * connected to the filesystem root. The VFS really doesn't
481 * like disconnected directories..
483 err = reconnect_path(mnt, target_dir, nbuf);
490 * Now that we've got both a well-connected parent and a
491 * dentry for the inode we're after, make sure that our
492 * inode is actually connected to the parent.
494 err = exportfs_get_name(mnt, target_dir, nbuf, result);
496 mutex_lock(&target_dir->d_inode->i_mutex);
497 nresult = lookup_one_len(nbuf, target_dir,
499 mutex_unlock(&target_dir->d_inode->i_mutex);
500 if (!IS_ERR(nresult)) {
501 if (nresult->d_inode) {
510 * At this point we are done with the parent, but it's pinned
511 * by the child dentry anyway.
516 * And finally make sure the dentry is actually acceptable
519 alias = find_acceptable_alias(result, acceptable, context);
532 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
534 MODULE_LICENSE("GPL");