3 #include <linux/file.h>
4 #include <linux/module.h>
5 #include <linux/namei.h>
7 struct export_operations export_op_default
;
9 #define CALL(ops,fun) ((ops->fun)?(ops->fun):export_op_default.fun)
11 #define dprintk(fmt, args...) do{}while(0)
13 static struct dentry
*
14 find_acceptable_alias(struct dentry
*result
,
15 int (*acceptable
)(void *context
, struct dentry
*dentry
),
18 struct dentry
*dentry
, *toput
= NULL
;
20 spin_lock(&dcache_lock
);
21 list_for_each_entry(dentry
, &result
->d_inode
->i_dentry
, d_alias
) {
23 spin_unlock(&dcache_lock
);
26 if (dentry
!= result
&& acceptable(context
, dentry
)) {
30 spin_lock(&dcache_lock
);
33 spin_unlock(&dcache_lock
);
41 * find_exported_dentry - helper routine to implement export_operations->decode_fh
42 * @sb: The &super_block identifying the filesystem
43 * @obj: An opaque identifier of the object to be found - passed to
45 * @parent: An optional opqaue identifier of the parent of the object.
46 * @acceptable: A function used to test possible &dentries to see if they are
48 * @context: A parameter to @acceptable so that it knows on what basis to
51 * find_exported_dentry is the central helper routine to enable file systems
52 * to provide the decode_fh() export_operation. It's main task is to take
53 * an &inode, find or create an appropriate &dentry structure, and possibly
54 * splice this into the dcache in the correct place.
56 * The decode_fh() operation provided by the filesystem should call
57 * find_exported_dentry() with the same parameters that it received except
58 * that instead of the file handle fragment, pointers to opaque identifiers
59 * for the object and optionally its parent are passed. The default decode_fh
60 * routine passes one pointer to the start of the filehandle fragment, and
61 * one 8 bytes into the fragment. It is expected that most filesystems will
62 * take this approach, though the offset to the parent identifier may well be
65 * find_exported_dentry() will call get_dentry to get an dentry pointer from
66 * the file system. If any &dentry in the d_alias list is acceptable, it will
67 * be returned. Otherwise find_exported_dentry() will attempt to splice a new
68 * &dentry into the dcache using get_name() and get_parent() to find the
73 find_exported_dentry(struct super_block
*sb
, void *obj
, void *parent
,
74 int (*acceptable
)(void *context
, struct dentry
*de
),
77 struct dentry
*result
= NULL
;
78 struct dentry
*target_dir
;
80 struct export_operations
*nops
= sb
->s_export_op
;
83 char nbuf
[NAME_MAX
+1];
86 * Attempt to find the inode.
88 result
= CALL(sb
->s_export_op
,get_dentry
)(sb
,obj
);
93 err
= PTR_ERR(result
);
96 if (S_ISDIR(result
->d_inode
->i_mode
) &&
97 (result
->d_flags
& DCACHE_DISCONNECTED
)) {
98 /* it is an unconnected directory, we must connect it */
101 if (acceptable(context
, result
))
103 if (S_ISDIR(result
->d_inode
->i_mode
)) {
108 alias
= find_acceptable_alias(result
, acceptable
, context
);
113 /* It's a directory, or we are required to confirm the file's
114 * location in the tree based on the parent information
116 dprintk("find_exported_dentry: need to look harder for %s/%d\n",sb
->s_id
,*(int*)obj
);
117 if (S_ISDIR(result
->d_inode
->i_mode
))
118 target_dir
= dget(result
);
123 target_dir
= CALL(sb
->s_export_op
,get_dentry
)(sb
,parent
);
124 if (IS_ERR(target_dir
))
125 err
= PTR_ERR(target_dir
);
126 if (target_dir
== NULL
|| IS_ERR(target_dir
))
130 * Now we need to make sure that target_dir is properly connected.
131 * It may already be, as the flag isn't always updated when connection
133 * So, we walk up parent links until we find a connected directory,
134 * or we run out of directories. Then we find the parent, find
135 * the name of the child in that parent, and do a lookup.
136 * This should connect the child into the parent
140 /* it is possible that a confused file system might not let us complete
141 * the path to the root. For example, if get_parent returns a directory
142 * in which we cannot find a name for the child. While this implies a
143 * very sick filesystem we don't want it to cause knfsd to spin. Hence
144 * the noprogress counter. If we go through the loop 10 times (2 is
145 * probably enough) without getting anywhere, we just give up
148 while (target_dir
->d_flags
& DCACHE_DISCONNECTED
&& noprogress
++ < 10) {
149 struct dentry
*pd
= target_dir
;
152 spin_lock(&pd
->d_lock
);
153 while (!IS_ROOT(pd
) &&
154 (pd
->d_parent
->d_flags
&DCACHE_DISCONNECTED
)) {
155 struct dentry
*parent
= pd
->d_parent
;
158 spin_unlock(&pd
->d_lock
);
161 spin_lock(&pd
->d_lock
);
163 spin_unlock(&pd
->d_lock
);
166 /* must have found a connected parent - great */
167 spin_lock(&pd
->d_lock
);
168 pd
->d_flags
&= ~DCACHE_DISCONNECTED
;
169 spin_unlock(&pd
->d_lock
);
171 } else if (pd
== sb
->s_root
) {
172 printk(KERN_ERR
"export: Eeek filesystem root is not connected, impossible\n");
173 spin_lock(&pd
->d_lock
);
174 pd
->d_flags
&= ~DCACHE_DISCONNECTED
;
175 spin_unlock(&pd
->d_lock
);
178 /* we have hit the top of a disconnected path. Try
179 * to find parent and connect
180 * note: racing with some other process renaming a
181 * directory isn't much of a problem here. If someone
182 * renames the directory, it will end up properly
183 * connected, which is what we want
188 mutex_lock(&pd
->d_inode
->i_mutex
);
189 ppd
= CALL(nops
,get_parent
)(pd
);
190 mutex_unlock(&pd
->d_inode
->i_mutex
);
194 dprintk("find_exported_dentry: get_parent of %ld failed, err %d\n",
195 pd
->d_inode
->i_ino
, err
);
199 dprintk("find_exported_dentry: find name of %lu in %lu\n", pd
->d_inode
->i_ino
, ppd
->d_inode
->i_ino
);
200 err
= CALL(nops
,get_name
)(ppd
, nbuf
, pd
);
205 /* some race between get_parent and
206 * get_name? just try again
211 dprintk("find_exported_dentry: found name: %s\n", nbuf
);
212 mutex_lock(&ppd
->d_inode
->i_mutex
);
213 npd
= lookup_one_len(nbuf
, ppd
, strlen(nbuf
));
214 mutex_unlock(&ppd
->d_inode
->i_mutex
);
217 dprintk("find_exported_dentry: lookup failed: %d\n", err
);
222 /* we didn't really want npd, we really wanted
223 * a side-effect of the lookup.
224 * hopefully, npd == pd, though it isn't really
225 * a problem if it isn't
230 printk("find_exported_dentry: npd != pd\n");
234 /* something went wrong, we have to give up */
242 if (target_dir
->d_flags
& DCACHE_DISCONNECTED
) {
243 /* something went wrong - oh-well */
248 /* if we weren't after a directory, have one more step to go */
249 if (result
!= target_dir
) {
250 struct dentry
*nresult
;
251 err
= CALL(nops
,get_name
)(target_dir
, nbuf
, result
);
253 mutex_lock(&target_dir
->d_inode
->i_mutex
);
254 nresult
= lookup_one_len(nbuf
, target_dir
, strlen(nbuf
));
255 mutex_unlock(&target_dir
->d_inode
->i_mutex
);
256 if (!IS_ERR(nresult
)) {
257 if (nresult
->d_inode
) {
266 /* now result is properly connected, it is our best bet */
267 if (acceptable(context
, result
))
270 alias
= find_acceptable_alias(result
, acceptable
, context
);
274 /* drat - I just cannot find anything acceptable */
276 /* It might be justifiable to return ESTALE here,
277 * but the filehandle at-least looks reasonable good
278 * and it just be a permission problem, so returning
281 return ERR_PTR(-EACCES
);
293 static struct dentry
*get_parent(struct dentry
*child
)
295 /* get_parent cannot be supported generically, the locking
297 * instead, we just return EACCES. If server reboots or inodes
298 * get flushed, you lose
300 return ERR_PTR(-EACCES
);
304 struct getdents_callback
{
305 char *name
; /* name that was found. It already points to a
306 buffer NAME_MAX+1 is size */
307 unsigned long ino
; /* the inum we are looking for */
308 int found
; /* inode matched? */
309 int sequence
; /* sequence counter */
313 * A rather strange filldir function to capture
314 * the name matching the specified inode number.
316 static int filldir_one(void * __buf
, const char * name
, int len
,
317 loff_t pos
, u64 ino
, unsigned int d_type
)
319 struct getdents_callback
*buf
= __buf
;
323 if (buf
->ino
== ino
) {
324 memcpy(buf
->name
, name
, len
);
325 buf
->name
[len
] = '\0';
333 * get_name - default export_operations->get_name function
334 * @dentry: the directory in which to find a name
335 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
336 * @child: the dentry for the child directory.
338 * calls readdir on the parent until it finds an entry with
339 * the same inode number as the child, and returns that.
341 static int get_name(struct dentry
*dentry
, char *name
,
342 struct dentry
*child
)
344 struct inode
*dir
= dentry
->d_inode
;
347 struct getdents_callback buffer
;
350 if (!dir
|| !S_ISDIR(dir
->i_mode
))
356 * Open the directory ...
358 file
= dentry_open(dget(dentry
), NULL
, O_RDONLY
);
359 error
= PTR_ERR(file
);
364 if (!file
->f_op
->readdir
)
368 buffer
.ino
= child
->d_inode
->i_ino
;
372 int old_seq
= buffer
.sequence
;
374 error
= vfs_readdir(file
, filldir_one
, &buffer
);
383 if (old_seq
== buffer
.sequence
)
394 static struct dentry
*export_iget(struct super_block
*sb
, unsigned long ino
, __u32 generation
)
397 /* iget isn't really right if the inode is currently unallocated!!
398 * This should really all be done inside each filesystem
400 * ext2fs' read_inode has been strengthed to return a bad_inode if
401 * the inode had been deleted.
403 * Currently we don't know the generation for parent directory, so
404 * a generation of 0 means "accept any"
407 struct dentry
*result
;
409 return ERR_PTR(-ESTALE
);
410 inode
= iget(sb
, ino
);
412 return ERR_PTR(-ENOMEM
);
413 if (is_bad_inode(inode
)
414 || (generation
&& inode
->i_generation
!= generation
)
416 /* we didn't find the right inode.. */
417 dprintk("fh_verify: Inode %lu, Bad count: %d %d or version %u %u\n",
419 inode
->i_nlink
, atomic_read(&inode
->i_count
),
424 return ERR_PTR(-ESTALE
);
426 /* now to find a dentry.
427 * If possible, get a well-connected one
429 result
= d_alloc_anon(inode
);
432 return ERR_PTR(-ENOMEM
);
438 static struct dentry
*get_object(struct super_block
*sb
, void *vobjp
)
441 unsigned long ino
= objp
[0];
442 __u32 generation
= objp
[1];
444 return export_iget(sb
, ino
, generation
);
449 * export_encode_fh - default export_operations->encode_fh function
450 * @dentry: the dentry to encode
451 * @fh: where to store the file handle fragment
452 * @max_len: maximum length to store there
453 * @connectable: whether to store parent information
455 * This default encode_fh function assumes that the 32 inode number
456 * is suitable for locating an inode, and that the generation number
457 * can be used to check that it is still valid. It places them in the
458 * filehandle fragment where export_decode_fh expects to find them.
460 static int export_encode_fh(struct dentry
*dentry
, __u32
*fh
, int *max_len
,
463 struct inode
* inode
= dentry
->d_inode
;
467 if (len
< 2 || (connectable
&& len
< 4))
471 fh
[0] = inode
->i_ino
;
472 fh
[1] = inode
->i_generation
;
473 if (connectable
&& !S_ISDIR(inode
->i_mode
)) {
474 struct inode
*parent
;
476 spin_lock(&dentry
->d_lock
);
477 parent
= dentry
->d_parent
->d_inode
;
478 fh
[2] = parent
->i_ino
;
479 fh
[3] = parent
->i_generation
;
480 spin_unlock(&dentry
->d_lock
);
490 * export_decode_fh - default export_operations->decode_fh function
491 * @sb: The superblock
492 * @fh: pointer to the file handle fragment
493 * @fh_len: length of file handle fragment
494 * @acceptable: function for testing acceptability of dentrys
495 * @context: context for @acceptable
497 * This is the default decode_fh() function.
498 * a fileid_type of 1 indicates that the filehandlefragment
499 * just contains an object identifier understood by get_dentry.
500 * a fileid_type of 2 says that there is also a directory
501 * identifier 8 bytes in to the filehandlefragement.
503 static struct dentry
*export_decode_fh(struct super_block
*sb
, __u32
*fh
, int fh_len
,
505 int (*acceptable
)(void *context
, struct dentry
*de
),
509 parent
[0] = parent
[1] = 0;
510 if (fh_len
< 2 || fileid_type
> 2)
512 if (fileid_type
== 2) {
513 if (fh_len
> 2) parent
[0] = fh
[2];
514 if (fh_len
> 3) parent
[1] = fh
[3];
516 return find_exported_dentry(sb
, fh
, parent
,
517 acceptable
, context
);
520 struct export_operations export_op_default
= {
521 .decode_fh
= export_decode_fh
,
522 .encode_fh
= export_encode_fh
,
524 .get_name
= get_name
,
525 .get_parent
= get_parent
,
526 .get_dentry
= get_object
,
529 EXPORT_SYMBOL(export_op_default
);
530 EXPORT_SYMBOL(find_exported_dentry
);
532 MODULE_LICENSE("GPL");