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(struct vfsmount
*mnt
, struct dentry
*dentry
, char *name
,
23 struct dentry
*child
);
26 static int exportfs_get_name(struct vfsmount
*mnt
, struct dentry
*dir
,
27 char *name
, struct dentry
*child
)
29 const struct export_operations
*nop
= dir
->d_sb
->s_export_op
;
32 return nop
->get_name(dir
, name
, child
);
34 return get_name(mnt
, dir
, 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
;
47 if (acceptable(context
, result
))
50 spin_lock(&dcache_inode_lock
);
51 list_for_each_entry(dentry
, &result
->d_inode
->i_dentry
, d_alias
) {
53 spin_unlock(&dcache_inode_lock
);
56 if (dentry
!= result
&& acceptable(context
, dentry
)) {
60 spin_lock(&dcache_inode_lock
);
63 spin_unlock(&dcache_inode_lock
);
71 * Find root of a disconnected subtree and return a reference to it.
73 static struct dentry
*
74 find_disconnected_root(struct dentry
*dentry
)
77 while (!IS_ROOT(dentry
)) {
78 struct dentry
*parent
= dget_parent(dentry
);
80 if (!(parent
->d_flags
& DCACHE_DISCONNECTED
)) {
92 * Make sure target_dir is fully connected to the dentry tree.
94 * It may already be, as the flag isn't always updated when connection happens.
97 reconnect_path(struct vfsmount
*mnt
, struct dentry
*target_dir
, char *nbuf
)
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
110 while (target_dir
->d_flags
& DCACHE_DISCONNECTED
&& noprogress
++ < 10) {
111 struct dentry
*pd
= find_disconnected_root(target_dir
);
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
);
119 } else if (pd
== mnt
->mnt_sb
->s_root
) {
120 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
);
127 * We have hit the top of a disconnected path, try to
128 * find parent and connect.
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
135 * Getting the parent can't be supported generically,
136 * the locking is too icky.
138 * Instead we just return EACCES. If server reboots
139 * or inodes get flushed, you lose
141 struct dentry
*ppd
= ERR_PTR(-EACCES
);
144 mutex_lock(&pd
->d_inode
->i_mutex
);
145 if (mnt
->mnt_sb
->s_export_op
->get_parent
)
146 ppd
= mnt
->mnt_sb
->s_export_op
->get_parent(pd
);
147 mutex_unlock(&pd
->d_inode
->i_mutex
);
151 dprintk("%s: get_parent of %ld failed, err %d\n",
152 __func__
, pd
->d_inode
->i_ino
, err
);
157 dprintk("%s: find name of %lu in %lu\n", __func__
,
158 pd
->d_inode
->i_ino
, ppd
->d_inode
->i_ino
);
159 err
= exportfs_get_name(mnt
, ppd
, nbuf
, pd
);
164 /* some race between get_parent and
165 * get_name? just try again
170 dprintk("%s: found name: %s\n", __func__
, nbuf
);
171 mutex_lock(&ppd
->d_inode
->i_mutex
);
172 npd
= lookup_one_len(nbuf
, ppd
, strlen(nbuf
));
173 mutex_unlock(&ppd
->d_inode
->i_mutex
);
176 dprintk("%s: lookup failed: %d\n",
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
190 printk("%s: npd != pd\n", __func__
);
194 /* something went wrong, we have to give up */
202 if (target_dir
->d_flags
& DCACHE_DISCONNECTED
) {
203 /* something went wrong - oh-well */
212 struct 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 */
221 * A rather strange filldir function to capture
222 * the name matching the specified inode number.
224 static int filldir_one(void * __buf
, const char * name
, int len
,
225 loff_t pos
, u64 ino
, unsigned int d_type
)
227 struct getdents_callback
*buf
= __buf
;
231 if (buf
->ino
== ino
) {
232 memcpy(buf
->name
, name
, len
);
233 buf
->name
[len
] = '\0';
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.
246 * calls readdir on the parent until it finds an entry with
247 * the same inode number as the child, and returns that.
249 static int get_name(struct vfsmount
*mnt
, struct dentry
*dentry
,
250 char *name
, struct dentry
*child
)
252 const struct cred
*cred
= current_cred();
253 struct inode
*dir
= dentry
->d_inode
;
256 struct getdents_callback buffer
;
259 if (!dir
|| !S_ISDIR(dir
->i_mode
))
265 * Open the directory ...
267 file
= dentry_open(dget(dentry
), mntget(mnt
), O_RDONLY
, cred
);
268 error
= PTR_ERR(file
);
273 if (!file
->f_op
->readdir
)
277 buffer
.ino
= child
->d_inode
->i_ino
;
281 int old_seq
= buffer
.sequence
;
283 error
= vfs_readdir(file
, filldir_one
, &buffer
);
293 if (old_seq
== buffer
.sequence
)
304 * export_encode_fh - default export_operations->encode_fh function
305 * @dentry: the dentry to encode
306 * @fh: where to store the file handle fragment
307 * @max_len: maximum length to store there
308 * @connectable: whether to store parent information
310 * This default encode_fh function assumes that the 32 inode number
311 * is suitable for locating an inode, and that the generation number
312 * can be used to check that it is still valid. It places them in the
313 * filehandle fragment where export_decode_fh expects to find them.
315 static int export_encode_fh(struct dentry
*dentry
, struct fid
*fid
,
316 int *max_len
, int connectable
)
318 struct inode
* inode
= dentry
->d_inode
;
320 int type
= FILEID_INO32_GEN
;
322 if (len
< 2 || (connectable
&& len
< 4))
326 fid
->i32
.ino
= inode
->i_ino
;
327 fid
->i32
.gen
= inode
->i_generation
;
328 if (connectable
&& !S_ISDIR(inode
->i_mode
)) {
329 struct inode
*parent
;
331 spin_lock(&dentry
->d_lock
);
332 parent
= dentry
->d_parent
->d_inode
;
333 fid
->i32
.parent_ino
= parent
->i_ino
;
334 fid
->i32
.parent_gen
= parent
->i_generation
;
335 spin_unlock(&dentry
->d_lock
);
337 type
= FILEID_INO32_GEN_PARENT
;
343 int exportfs_encode_fh(struct dentry
*dentry
, struct fid
*fid
, int *max_len
,
346 const struct export_operations
*nop
= dentry
->d_sb
->s_export_op
;
350 error
= nop
->encode_fh(dentry
, fid
->raw
, max_len
, connectable
);
352 error
= export_encode_fh(dentry
, fid
, max_len
, connectable
);
356 EXPORT_SYMBOL_GPL(exportfs_encode_fh
);
358 struct dentry
*exportfs_decode_fh(struct vfsmount
*mnt
, struct fid
*fid
,
359 int fh_len
, int fileid_type
,
360 int (*acceptable
)(void *, struct dentry
*), void *context
)
362 const struct export_operations
*nop
= mnt
->mnt_sb
->s_export_op
;
363 struct dentry
*result
, *alias
;
364 char nbuf
[NAME_MAX
+1];
368 * Try to get any dentry for the given file handle from the filesystem.
370 result
= nop
->fh_to_dentry(mnt
->mnt_sb
, fid
, fh_len
, fileid_type
);
372 result
= ERR_PTR(-ESTALE
);
376 if (S_ISDIR(result
->d_inode
->i_mode
)) {
378 * This request is for a directory.
380 * On the positive side there is only one dentry for each
381 * directory inode. On the negative side this implies that we
382 * to ensure our dentry is connected all the way up to the
385 if (result
->d_flags
& DCACHE_DISCONNECTED
) {
386 err
= reconnect_path(mnt
, result
, nbuf
);
391 if (!acceptable(context
, result
)) {
399 * It's not a directory. Life is a little more complicated.
401 struct dentry
*target_dir
, *nresult
;
404 * See if either the dentry we just got from the filesystem
405 * or any alias for it is acceptable. This is always true
406 * if this filesystem is exported without the subtreecheck
407 * option. If the filesystem is exported with the subtree
408 * check option there's a fair chance we need to look at
409 * the parent directory in the file handle and make sure
410 * it's connected to the filesystem root.
412 alias
= find_acceptable_alias(result
, acceptable
, context
);
417 * Try to extract a dentry for the parent directory from the
418 * file handle. If this fails we'll have to give up.
421 if (!nop
->fh_to_parent
)
424 target_dir
= nop
->fh_to_parent(mnt
->mnt_sb
, fid
,
425 fh_len
, fileid_type
);
428 err
= PTR_ERR(target_dir
);
429 if (IS_ERR(target_dir
))
433 * And as usual we need to make sure the parent directory is
434 * connected to the filesystem root. The VFS really doesn't
435 * like disconnected directories..
437 err
= reconnect_path(mnt
, target_dir
, nbuf
);
444 * Now that we've got both a well-connected parent and a
445 * dentry for the inode we're after, make sure that our
446 * inode is actually connected to the parent.
448 err
= exportfs_get_name(mnt
, target_dir
, nbuf
, result
);
450 mutex_lock(&target_dir
->d_inode
->i_mutex
);
451 nresult
= lookup_one_len(nbuf
, target_dir
,
453 mutex_unlock(&target_dir
->d_inode
->i_mutex
);
454 if (!IS_ERR(nresult
)) {
455 if (nresult
->d_inode
) {
464 * At this point we are done with the parent, but it's pinned
465 * by the child dentry anyway.
470 * And finally make sure the dentry is actually acceptable
473 alias
= find_acceptable_alias(result
, acceptable
, context
);
486 EXPORT_SYMBOL_GPL(exportfs_decode_fh
);
488 MODULE_LICENSE("GPL");