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_u
.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
);
72 static bool dentry_connected(struct dentry
*dentry
)
75 while (dentry
->d_flags
& DCACHE_DISCONNECTED
) {
76 struct dentry
*parent
= dget_parent(dentry
);
79 if (dentry
== parent
) {
89 static void clear_disconnected(struct dentry
*dentry
)
92 while (dentry
->d_flags
& DCACHE_DISCONNECTED
) {
93 struct dentry
*parent
= dget_parent(dentry
);
95 WARN_ON_ONCE(IS_ROOT(dentry
));
97 spin_lock(&dentry
->d_lock
);
98 dentry
->d_flags
&= ~DCACHE_DISCONNECTED
;
99 spin_unlock(&dentry
->d_lock
);
108 * Reconnect a directory dentry with its parent.
110 * This can return a dentry, or NULL, or an error.
112 * In the first case the returned dentry is the parent of the given
113 * dentry, and may itself need to be reconnected to its parent.
115 * In the NULL case, a concurrent VFS operation has either renamed or
116 * removed this directory. The concurrent operation has reconnected our
117 * dentry, so we no longer need to.
119 static struct dentry
*reconnect_one(struct vfsmount
*mnt
,
120 struct dentry
*dentry
, char *nbuf
)
122 struct dentry
*parent
;
126 parent
= ERR_PTR(-EACCES
);
127 mutex_lock(&dentry
->d_inode
->i_mutex
);
128 if (mnt
->mnt_sb
->s_export_op
->get_parent
)
129 parent
= mnt
->mnt_sb
->s_export_op
->get_parent(dentry
);
130 mutex_unlock(&dentry
->d_inode
->i_mutex
);
132 if (IS_ERR(parent
)) {
133 dprintk("%s: get_parent of %ld failed, err %d\n",
134 __func__
, dentry
->d_inode
->i_ino
, PTR_ERR(parent
));
138 dprintk("%s: find name of %lu in %lu\n", __func__
,
139 dentry
->d_inode
->i_ino
, parent
->d_inode
->i_ino
);
140 err
= exportfs_get_name(mnt
, parent
, nbuf
, dentry
);
142 goto out_reconnected
;
145 dprintk("%s: found name: %s\n", __func__
, nbuf
);
146 mutex_lock(&parent
->d_inode
->i_mutex
);
147 tmp
= lookup_one_len(nbuf
, parent
, strlen(nbuf
));
148 mutex_unlock(&parent
->d_inode
->i_mutex
);
150 dprintk("%s: lookup failed: %d\n", __func__
, PTR_ERR(tmp
));
156 goto out_reconnected
;
159 if (IS_ROOT(dentry
)) {
171 * Someone must have renamed our entry into another parent, in
172 * which case it has been reconnected by the rename.
174 * Or someone removed it entirely, in which case filehandle
175 * lookup will succeed but the directory is now IS_DEAD and
176 * subsequent operations on it will fail.
178 * Alternatively, maybe there was no race at all, and the
179 * filesystem is just corrupt and gave us a parent that doesn't
180 * actually contain any entry pointing to this inode. So,
181 * double check that this worked and return -ESTALE if not:
183 if (!dentry_connected(dentry
))
184 return ERR_PTR(-ESTALE
);
189 * Make sure target_dir is fully connected to the dentry tree.
191 * On successful return, DCACHE_DISCONNECTED will be cleared on
192 * target_dir, and target_dir->d_parent->...->d_parent will reach the
193 * root of the filesystem.
195 * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
196 * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
197 * set but already be connected. In that case we'll verify the
198 * connection to root and then clear the flag.
200 * Note that target_dir could be removed by a concurrent operation. In
201 * that case reconnect_path may still succeed with target_dir fully
202 * connected, but further operations using the filehandle will fail when
203 * necessary (due to S_DEAD being set on the directory).
206 reconnect_path(struct vfsmount
*mnt
, struct dentry
*target_dir
, char *nbuf
)
208 struct dentry
*dentry
, *parent
;
210 dentry
= dget(target_dir
);
212 while (dentry
->d_flags
& DCACHE_DISCONNECTED
) {
213 BUG_ON(dentry
== mnt
->mnt_sb
->s_root
);
216 parent
= reconnect_one(mnt
, dentry
, nbuf
);
218 parent
= dget_parent(dentry
);
224 return PTR_ERR(parent
);
228 clear_disconnected(target_dir
);
232 struct getdents_callback
{
233 struct dir_context ctx
;
234 char *name
; /* name that was found. It already points to a
235 buffer NAME_MAX+1 is size */
236 u64 ino
; /* the inum we are looking for */
237 int found
; /* inode matched? */
238 int sequence
; /* sequence counter */
242 * A rather strange filldir function to capture
243 * the name matching the specified inode number.
245 static int filldir_one(struct dir_context
*ctx
, const char *name
, int len
,
246 loff_t pos
, u64 ino
, unsigned int d_type
)
248 struct getdents_callback
*buf
=
249 container_of(ctx
, struct getdents_callback
, ctx
);
253 if (buf
->ino
== ino
&& len
<= NAME_MAX
) {
254 memcpy(buf
->name
, name
, len
);
255 buf
->name
[len
] = '\0';
263 * get_name - default export_operations->get_name function
264 * @path: the directory in which to find a name
265 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
266 * @child: the dentry for the child directory.
268 * calls readdir on the parent until it finds an entry with
269 * the same inode number as the child, and returns that.
271 static int get_name(const struct path
*path
, char *name
, struct dentry
*child
)
273 const struct cred
*cred
= current_cred();
274 struct inode
*dir
= path
->dentry
->d_inode
;
278 struct path child_path
= {
282 struct getdents_callback buffer
= {
283 .ctx
.actor
= filldir_one
,
288 if (!dir
|| !S_ISDIR(dir
->i_mode
))
294 * inode->i_ino is unsigned long, kstat->ino is u64, so the
295 * former would be insufficient on 32-bit hosts when the
296 * filesystem supports 64-bit inode numbers. So we need to
297 * actually call ->getattr, not just read i_ino:
299 error
= vfs_getattr_nosec(&child_path
, &stat
);
302 buffer
.ino
= stat
.ino
;
304 * Open the directory ...
306 file
= dentry_open(path
, O_RDONLY
, cred
);
307 error
= PTR_ERR(file
);
312 if (!file
->f_op
->iterate
)
317 int old_seq
= buffer
.sequence
;
319 error
= iterate_dir(file
, &buffer
.ctx
);
329 if (old_seq
== buffer
.sequence
)
340 * export_encode_fh - default export_operations->encode_fh function
341 * @inode: the object to encode
342 * @fid: where to store the file handle fragment
343 * @max_len: maximum length to store there
344 * @parent: parent directory inode, if wanted
346 * This default encode_fh function assumes that the 32 inode number
347 * is suitable for locating an inode, and that the generation number
348 * can be used to check that it is still valid. It places them in the
349 * filehandle fragment where export_decode_fh expects to find them.
351 static int export_encode_fh(struct inode
*inode
, struct fid
*fid
,
352 int *max_len
, struct inode
*parent
)
355 int type
= FILEID_INO32_GEN
;
357 if (parent
&& (len
< 4)) {
359 return FILEID_INVALID
;
360 } else if (len
< 2) {
362 return FILEID_INVALID
;
366 fid
->i32
.ino
= inode
->i_ino
;
367 fid
->i32
.gen
= inode
->i_generation
;
369 fid
->i32
.parent_ino
= parent
->i_ino
;
370 fid
->i32
.parent_gen
= parent
->i_generation
;
372 type
= FILEID_INO32_GEN_PARENT
;
378 int exportfs_encode_inode_fh(struct inode
*inode
, struct fid
*fid
,
379 int *max_len
, struct inode
*parent
)
381 const struct export_operations
*nop
= inode
->i_sb
->s_export_op
;
383 if (nop
&& nop
->encode_fh
)
384 return nop
->encode_fh(inode
, fid
->raw
, max_len
, parent
);
386 return export_encode_fh(inode
, fid
, max_len
, parent
);
388 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh
);
390 int exportfs_encode_fh(struct dentry
*dentry
, struct fid
*fid
, int *max_len
,
394 struct dentry
*p
= NULL
;
395 struct inode
*inode
= dentry
->d_inode
, *parent
= NULL
;
397 if (connectable
&& !S_ISDIR(inode
->i_mode
)) {
398 p
= dget_parent(dentry
);
400 * note that while p might've ceased to be our parent already,
401 * it's still pinned by and still positive.
406 error
= exportfs_encode_inode_fh(inode
, fid
, max_len
, parent
);
411 EXPORT_SYMBOL_GPL(exportfs_encode_fh
);
413 struct dentry
*exportfs_decode_fh(struct vfsmount
*mnt
, struct fid
*fid
,
414 int fh_len
, int fileid_type
,
415 int (*acceptable
)(void *, struct dentry
*), void *context
)
417 const struct export_operations
*nop
= mnt
->mnt_sb
->s_export_op
;
418 struct dentry
*result
, *alias
;
419 char nbuf
[NAME_MAX
+1];
423 * Try to get any dentry for the given file handle from the filesystem.
425 if (!nop
|| !nop
->fh_to_dentry
)
426 return ERR_PTR(-ESTALE
);
427 result
= nop
->fh_to_dentry(mnt
->mnt_sb
, fid
, fh_len
, fileid_type
);
429 result
= ERR_PTR(-ESTALE
);
433 if (d_is_dir(result
)) {
435 * This request is for a directory.
437 * On the positive side there is only one dentry for each
438 * directory inode. On the negative side this implies that we
439 * to ensure our dentry is connected all the way up to the
442 if (result
->d_flags
& DCACHE_DISCONNECTED
) {
443 err
= reconnect_path(mnt
, result
, nbuf
);
448 if (!acceptable(context
, result
)) {
456 * It's not a directory. Life is a little more complicated.
458 struct dentry
*target_dir
, *nresult
;
461 * See if either the dentry we just got from the filesystem
462 * or any alias for it is acceptable. This is always true
463 * if this filesystem is exported without the subtreecheck
464 * option. If the filesystem is exported with the subtree
465 * check option there's a fair chance we need to look at
466 * the parent directory in the file handle and make sure
467 * it's connected to the filesystem root.
469 alias
= find_acceptable_alias(result
, acceptable
, context
);
474 * Try to extract a dentry for the parent directory from the
475 * file handle. If this fails we'll have to give up.
478 if (!nop
->fh_to_parent
)
481 target_dir
= nop
->fh_to_parent(mnt
->mnt_sb
, fid
,
482 fh_len
, fileid_type
);
485 err
= PTR_ERR(target_dir
);
486 if (IS_ERR(target_dir
))
490 * And as usual we need to make sure the parent directory is
491 * connected to the filesystem root. The VFS really doesn't
492 * like disconnected directories..
494 err
= reconnect_path(mnt
, target_dir
, nbuf
);
501 * Now that we've got both a well-connected parent and a
502 * dentry for the inode we're after, make sure that our
503 * inode is actually connected to the parent.
505 err
= exportfs_get_name(mnt
, target_dir
, nbuf
, result
);
507 mutex_lock(&target_dir
->d_inode
->i_mutex
);
508 nresult
= lookup_one_len(nbuf
, target_dir
,
510 mutex_unlock(&target_dir
->d_inode
->i_mutex
);
511 if (!IS_ERR(nresult
)) {
512 if (nresult
->d_inode
) {
521 * At this point we are done with the parent, but it's pinned
522 * by the child dentry anyway.
527 * And finally make sure the dentry is actually acceptable
530 alias
= find_acceptable_alias(result
, acceptable
, context
);
543 EXPORT_SYMBOL_GPL(exportfs_decode_fh
);
545 MODULE_LICENSE("GPL");