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
)) {
93 static bool dentry_connected(struct dentry
*dentry
)
96 while (dentry
->d_flags
& DCACHE_DISCONNECTED
) {
97 struct dentry
*parent
= dget_parent(dentry
);
100 if (IS_ROOT(dentry
)) {
110 static void clear_disconnected(struct dentry
*dentry
)
113 while (dentry
->d_flags
& DCACHE_DISCONNECTED
) {
114 struct dentry
*parent
= dget_parent(dentry
);
116 WARN_ON_ONCE(IS_ROOT(dentry
));
118 spin_lock(&dentry
->d_lock
);
119 dentry
->d_flags
&= ~DCACHE_DISCONNECTED
;
120 spin_unlock(&dentry
->d_lock
);
129 * Make sure target_dir is fully connected to the dentry tree.
131 * On successful return, DCACHE_DISCONNECTED will be cleared on
132 * target_dir, and target_dir->d_parent->...->d_parent will reach the
133 * root of the filesystem.
135 * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
136 * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
137 * set but already be connected. In that case we'll verify the
138 * connection to root and then clear the flag.
140 * Note that target_dir could be removed by a concurrent operation. In
141 * that case reconnect_path may still succeed with target_dir fully
142 * connected, but further operations using the filehandle will fail when
143 * necessary (due to S_DEAD being set on the directory).
146 reconnect_path(struct vfsmount
*mnt
, struct dentry
*target_dir
, char *nbuf
)
152 * It is possible that a confused file system might not let us complete
153 * the path to the root. For example, if get_parent returns a directory
154 * in which we cannot find a name for the child. While this implies a
155 * very sick filesystem we don't want it to cause knfsd to spin. Hence
156 * the noprogress counter. If we go through the loop 10 times (2 is
157 * probably enough) without getting anywhere, we just give up
159 while (target_dir
->d_flags
& DCACHE_DISCONNECTED
&& noprogress
++ < 10) {
160 struct dentry
*pd
= find_disconnected_root(target_dir
);
162 BUG_ON(pd
== mnt
->mnt_sb
->s_root
);
165 /* must have found a connected parent - great */
166 clear_disconnected(target_dir
);
171 * We have hit the top of a disconnected path, try to
172 * find parent and connect.
174 * Racing with some other process renaming a directory
175 * isn't much of a problem here. If someone renames
176 * the directory, it will end up properly connected,
177 * which is what we want
179 * Getting the parent can't be supported generically,
180 * the locking is too icky.
182 * Instead we just return EACCES. If server reboots
183 * or inodes get flushed, you lose
185 struct dentry
*ppd
= ERR_PTR(-EACCES
);
188 mutex_lock(&pd
->d_inode
->i_mutex
);
189 if (mnt
->mnt_sb
->s_export_op
->get_parent
)
190 ppd
= mnt
->mnt_sb
->s_export_op
->get_parent(pd
);
191 mutex_unlock(&pd
->d_inode
->i_mutex
);
195 dprintk("%s: get_parent of %ld failed, err %d\n",
196 __func__
, pd
->d_inode
->i_ino
, err
);
201 dprintk("%s: find name of %lu in %lu\n", __func__
,
202 pd
->d_inode
->i_ino
, ppd
->d_inode
->i_ino
);
203 err
= exportfs_get_name(mnt
, ppd
, nbuf
, pd
);
208 /* some race between get_parent and
211 goto out_reconnected
;
214 dprintk("%s: found name: %s\n", __func__
, nbuf
);
215 mutex_lock(&ppd
->d_inode
->i_mutex
);
216 npd
= lookup_one_len(nbuf
, ppd
, strlen(nbuf
));
217 mutex_unlock(&ppd
->d_inode
->i_mutex
);
220 dprintk("%s: lookup failed: %d\n",
226 /* we didn't really want npd, we really wanted
227 * a side-effect of the lookup.
228 * hopefully, npd == pd, though it isn't really
229 * a problem if it isn't
236 goto out_reconnected
;
238 /* something went wrong, we have to give up */
246 if (target_dir
->d_flags
& DCACHE_DISCONNECTED
) {
247 /* something went wrong - oh-well */
256 * Someone must have renamed our entry into another parent, in
257 * which case it has been reconnected by the rename.
259 * Or someone removed it entirely, in which case filehandle
260 * lookup will succeed but the directory is now IS_DEAD and
261 * subsequent operations on it will fail.
263 * Alternatively, maybe there was no race at all, and the
264 * filesystem is just corrupt and gave us a parent that doesn't
265 * actually contain any entry pointing to this inode. So,
266 * double check that this worked and return -ESTALE if not:
268 if (!dentry_connected(target_dir
))
270 clear_disconnected(target_dir
);
274 struct getdents_callback
{
275 struct dir_context ctx
;
276 char *name
; /* name that was found. It already points to a
277 buffer NAME_MAX+1 is size */
278 u64 ino
; /* the inum we are looking for */
279 int found
; /* inode matched? */
280 int sequence
; /* sequence counter */
284 * A rather strange filldir function to capture
285 * the name matching the specified inode number.
287 static int filldir_one(void * __buf
, const char * name
, int len
,
288 loff_t pos
, u64 ino
, unsigned int d_type
)
290 struct getdents_callback
*buf
= __buf
;
294 if (buf
->ino
== ino
&& len
<= NAME_MAX
) {
295 memcpy(buf
->name
, name
, len
);
296 buf
->name
[len
] = '\0';
304 * get_name - default export_operations->get_name function
305 * @dentry: the directory in which to find a name
306 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
307 * @child: the dentry for the child directory.
309 * calls readdir on the parent until it finds an entry with
310 * the same inode number as the child, and returns that.
312 static int get_name(const struct path
*path
, char *name
, struct dentry
*child
)
314 const struct cred
*cred
= current_cred();
315 struct inode
*dir
= path
->dentry
->d_inode
;
319 struct path child_path
= {
323 struct getdents_callback buffer
= {
324 .ctx
.actor
= filldir_one
,
329 if (!dir
|| !S_ISDIR(dir
->i_mode
))
335 * inode->i_ino is unsigned long, kstat->ino is u64, so the
336 * former would be insufficient on 32-bit hosts when the
337 * filesystem supports 64-bit inode numbers. So we need to
338 * actually call ->getattr, not just read i_ino:
340 error
= vfs_getattr_nosec(&child_path
, &stat
);
343 buffer
.ino
= stat
.ino
;
345 * Open the directory ...
347 file
= dentry_open(path
, O_RDONLY
, cred
);
348 error
= PTR_ERR(file
);
353 if (!file
->f_op
->iterate
)
358 int old_seq
= buffer
.sequence
;
360 error
= iterate_dir(file
, &buffer
.ctx
);
370 if (old_seq
== buffer
.sequence
)
381 * export_encode_fh - default export_operations->encode_fh function
382 * @inode: the object to encode
383 * @fh: where to store the file handle fragment
384 * @max_len: maximum length to store there
385 * @parent: parent directory inode, if wanted
387 * This default encode_fh function assumes that the 32 inode number
388 * is suitable for locating an inode, and that the generation number
389 * can be used to check that it is still valid. It places them in the
390 * filehandle fragment where export_decode_fh expects to find them.
392 static int export_encode_fh(struct inode
*inode
, struct fid
*fid
,
393 int *max_len
, struct inode
*parent
)
396 int type
= FILEID_INO32_GEN
;
398 if (parent
&& (len
< 4)) {
400 return FILEID_INVALID
;
401 } else if (len
< 2) {
403 return FILEID_INVALID
;
407 fid
->i32
.ino
= inode
->i_ino
;
408 fid
->i32
.gen
= inode
->i_generation
;
410 fid
->i32
.parent_ino
= parent
->i_ino
;
411 fid
->i32
.parent_gen
= parent
->i_generation
;
413 type
= FILEID_INO32_GEN_PARENT
;
419 int exportfs_encode_inode_fh(struct inode
*inode
, struct fid
*fid
,
420 int *max_len
, struct inode
*parent
)
422 const struct export_operations
*nop
= inode
->i_sb
->s_export_op
;
424 if (nop
&& nop
->encode_fh
)
425 return nop
->encode_fh(inode
, fid
->raw
, max_len
, parent
);
427 return export_encode_fh(inode
, fid
, max_len
, parent
);
429 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh
);
431 int exportfs_encode_fh(struct dentry
*dentry
, struct fid
*fid
, int *max_len
,
435 struct dentry
*p
= NULL
;
436 struct inode
*inode
= dentry
->d_inode
, *parent
= NULL
;
438 if (connectable
&& !S_ISDIR(inode
->i_mode
)) {
439 p
= dget_parent(dentry
);
441 * note that while p might've ceased to be our parent already,
442 * it's still pinned by and still positive.
447 error
= exportfs_encode_inode_fh(inode
, fid
, max_len
, parent
);
452 EXPORT_SYMBOL_GPL(exportfs_encode_fh
);
454 struct dentry
*exportfs_decode_fh(struct vfsmount
*mnt
, struct fid
*fid
,
455 int fh_len
, int fileid_type
,
456 int (*acceptable
)(void *, struct dentry
*), void *context
)
458 const struct export_operations
*nop
= mnt
->mnt_sb
->s_export_op
;
459 struct dentry
*result
, *alias
;
460 char nbuf
[NAME_MAX
+1];
464 * Try to get any dentry for the given file handle from the filesystem.
466 if (!nop
|| !nop
->fh_to_dentry
)
467 return ERR_PTR(-ESTALE
);
468 result
= nop
->fh_to_dentry(mnt
->mnt_sb
, fid
, fh_len
, fileid_type
);
470 result
= ERR_PTR(-ESTALE
);
474 if (S_ISDIR(result
->d_inode
->i_mode
)) {
476 * This request is for a directory.
478 * On the positive side there is only one dentry for each
479 * directory inode. On the negative side this implies that we
480 * to ensure our dentry is connected all the way up to the
483 if (result
->d_flags
& DCACHE_DISCONNECTED
) {
484 err
= reconnect_path(mnt
, result
, nbuf
);
489 if (!acceptable(context
, result
)) {
497 * It's not a directory. Life is a little more complicated.
499 struct dentry
*target_dir
, *nresult
;
502 * See if either the dentry we just got from the filesystem
503 * or any alias for it is acceptable. This is always true
504 * if this filesystem is exported without the subtreecheck
505 * option. If the filesystem is exported with the subtree
506 * check option there's a fair chance we need to look at
507 * the parent directory in the file handle and make sure
508 * it's connected to the filesystem root.
510 alias
= find_acceptable_alias(result
, acceptable
, context
);
515 * Try to extract a dentry for the parent directory from the
516 * file handle. If this fails we'll have to give up.
519 if (!nop
->fh_to_parent
)
522 target_dir
= nop
->fh_to_parent(mnt
->mnt_sb
, fid
,
523 fh_len
, fileid_type
);
526 err
= PTR_ERR(target_dir
);
527 if (IS_ERR(target_dir
))
531 * And as usual we need to make sure the parent directory is
532 * connected to the filesystem root. The VFS really doesn't
533 * like disconnected directories..
535 err
= reconnect_path(mnt
, target_dir
, nbuf
);
542 * Now that we've got both a well-connected parent and a
543 * dentry for the inode we're after, make sure that our
544 * inode is actually connected to the parent.
546 err
= exportfs_get_name(mnt
, target_dir
, nbuf
, result
);
548 mutex_lock(&target_dir
->d_inode
->i_mutex
);
549 nresult
= lookup_one_len(nbuf
, target_dir
,
551 mutex_unlock(&target_dir
->d_inode
->i_mutex
);
552 if (!IS_ERR(nresult
)) {
553 if (nresult
->d_inode
) {
562 * At this point we are done with the parent, but it's pinned
563 * by the child dentry anyway.
568 * And finally make sure the dentry is actually acceptable
571 alias
= find_acceptable_alias(result
, acceptable
, context
);
584 EXPORT_SYMBOL_GPL(exportfs_decode_fh
);
586 MODULE_LICENSE("GPL");
This page took 0.042055 seconds and 6 git commands to generate.