3 #include <linux/module.h>
4 #include <linux/smp_lock.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)
14 * find_exported_dentry - helper routine to implement export_operations->decode_fh
15 * @sb: The &super_block identifying the filesystem
16 * @obj: An opaque identifier of the object to be found - passed to
18 * @parent: An optional opqaue identifier of the parent of the object.
19 * @acceptable: A function used to test possible &dentries to see if they are
21 * @context: A parameter to @acceptable so that it knows on what basis to
24 * find_exported_dentry is the central helper routine to enable file systems
25 * to provide the decode_fh() export_operation. It's main task is to take
26 * an &inode, find or create an appropriate &dentry structure, and possibly
27 * splice this into the dcache in the correct place.
29 * The decode_fh() operation provided by the filesystem should call
30 * find_exported_dentry() with the same parameters that it received except
31 * that instead of the file handle fragment, pointers to opaque identifiers
32 * for the object and optionally its parent are passed. The default decode_fh
33 * routine passes one pointer to the start of the filehandle fragment, and
34 * one 8 bytes into the fragment. It is expected that most filesystems will
35 * take this approach, though the offset to the parent identifier may well be
38 * find_exported_dentry() will call get_dentry to get an dentry pointer from
39 * the file system. If any &dentry in the d_alias list is acceptable, it will
40 * be returned. Otherwise find_exported_dentry() will attempt to splice a new
41 * &dentry into the dcache using get_name() and get_parent() to find the
46 find_exported_dentry(struct super_block
*sb
, void *obj
, void *parent
,
47 int (*acceptable
)(void *context
, struct dentry
*de
),
50 struct dentry
*result
= NULL
;
51 struct dentry
*target_dir
;
53 struct export_operations
*nops
= sb
->s_export_op
;
54 struct list_head
*le
, *head
;
55 struct dentry
*toput
= NULL
;
60 * Attempt to find the inode.
62 result
= CALL(sb
->s_export_op
,get_dentry
)(sb
,obj
);
67 err
= PTR_ERR(result
);
70 if (S_ISDIR(result
->d_inode
->i_mode
) &&
71 (result
->d_flags
& DCACHE_DISCONNECTED
)) {
72 /* it is an unconnected directory, we must connect it */
75 if (acceptable(context
, result
))
77 if (S_ISDIR(result
->d_inode
->i_mode
)) {
78 /* there is no other dentry, so fail */
81 /* try any other aliases */
82 spin_lock(&dcache_lock
);
83 head
= &result
->d_inode
->i_dentry
;
84 list_for_each(le
, head
) {
85 struct dentry
*dentry
= list_entry(le
, struct dentry
, d_alias
);
87 spin_unlock(&dcache_lock
);
91 if (dentry
!= result
&&
92 acceptable(context
, dentry
)) {
96 spin_lock(&dcache_lock
);
99 spin_unlock(&dcache_lock
);
104 /* It's a directory, or we are required to confirm the file's
105 * location in the tree based on the parent information
107 dprintk("find_exported_dentry: need to look harder for %s/%d\n",sb
->s_id
,*(int*)obj
);
108 if (S_ISDIR(result
->d_inode
->i_mode
))
109 target_dir
= dget(result
);
114 target_dir
= CALL(sb
->s_export_op
,get_dentry
)(sb
,parent
);
115 if (IS_ERR(target_dir
))
116 err
= PTR_ERR(target_dir
);
117 if (target_dir
== NULL
|| IS_ERR(target_dir
))
121 * Now we need to make sure that target_dir is properly connected.
122 * It may already be, as the flag isn't always updated when connection
124 * So, we walk up parent links until we find a connected directory,
125 * or we run out of directories. Then we find the parent, find
126 * the name of the child in that parent, and do a lookup.
127 * This should connect the child into the parent
131 /* it is possible that a confused file system might not let us complete
132 * the path to the root. For example, if get_parent returns a directory
133 * in which we cannot find a name for the child. While this implies a
134 * very sick filesystem we don't want it to cause knfsd to spin. Hence
135 * the noprogress counter. If we go through the loop 10 times (2 is
136 * probably enough) without getting anywhere, we just give up
140 while (target_dir
->d_flags
& DCACHE_DISCONNECTED
&& noprogress
++ < 10) {
141 struct dentry
*pd
= target_dir
;
144 spin_lock(&pd
->d_lock
);
145 while (!IS_ROOT(pd
) &&
146 (pd
->d_parent
->d_flags
&DCACHE_DISCONNECTED
)) {
147 struct dentry
*parent
= pd
->d_parent
;
150 spin_unlock(&pd
->d_lock
);
153 spin_lock(&pd
->d_lock
);
155 spin_unlock(&pd
->d_lock
);
158 /* must have found a connected parent - great */
159 pd
->d_flags
&= ~DCACHE_DISCONNECTED
;
161 } else if (pd
== sb
->s_root
) {
162 printk(KERN_ERR
"export: Eeek filesystem root is not connected, impossible\n");
163 pd
->d_flags
&= ~DCACHE_DISCONNECTED
;
166 /* we have hit the top of a disconnected path. Try
167 * to find parent and connect
168 * note: racing with some other process renaming a
169 * directory isn't much of a problem here. If someone
170 * renames the directory, it will end up properly
171 * connected, which is what we want
175 char nbuf
[NAME_MAX
+1];
177 down(&pd
->d_inode
->i_sem
);
178 ppd
= CALL(nops
,get_parent
)(pd
);
179 up(&pd
->d_inode
->i_sem
);
183 dprintk("find_exported_dentry: get_parent of %ld failed, err %d\n",
184 pd
->d_inode
->i_ino
, err
);
188 dprintk("find_exported_dentry: find name of %lu in %lu\n", pd
->d_inode
->i_ino
, ppd
->d_inode
->i_ino
);
189 err
= CALL(nops
,get_name
)(ppd
, nbuf
, pd
);
194 /* some race between get_parent and
195 * get_name? just try again
200 dprintk("find_exported_dentry: found name: %s\n", nbuf
);
201 down(&ppd
->d_inode
->i_sem
);
202 npd
= lookup_one_len(nbuf
, ppd
, strlen(nbuf
));
203 up(&ppd
->d_inode
->i_sem
);
206 dprintk("find_exported_dentry: lookup failed: %d\n", err
);
211 /* we didn't really want npd, we really wanted
212 * a side-effect of the lookup.
213 * hopefully, npd == pd, though it isn't really
214 * a problem if it isn't
219 printk("find_exported_dentry: npd != pd\n");
223 /* something went wrong, we have to give up */
231 if (target_dir
->d_flags
& DCACHE_DISCONNECTED
) {
232 /* something went wrong - oh-well */
238 /* if we weren't after a directory, have one more step to go */
239 if (result
!= target_dir
) {
240 struct dentry
*nresult
;
241 char nbuf
[NAME_MAX
+1];
242 err
= CALL(nops
,get_name
)(target_dir
, nbuf
, result
);
244 down(&target_dir
->d_inode
->i_sem
);
245 nresult
= lookup_one_len(nbuf
, target_dir
, strlen(nbuf
));
246 up(&target_dir
->d_inode
->i_sem
);
247 if (!IS_ERR(nresult
)) {
248 if (nresult
->d_inode
) {
258 /* now result is properly connected, it is our best bet */
259 if (acceptable(context
, result
))
261 /* one last try of the aliases.. */
262 spin_lock(&dcache_lock
);
264 head
= &result
->d_inode
->i_dentry
;
265 list_for_each(le
, head
) {
266 struct dentry
*dentry
= list_entry(le
, struct dentry
, d_alias
);
268 spin_unlock(&dcache_lock
);
269 if (toput
) dput(toput
);
270 if (dentry
!= result
&&
271 acceptable(context
, dentry
)) {
275 spin_lock(&dcache_lock
);
278 spin_unlock(&dcache_lock
);
282 /* drat - I just cannot find anything acceptable */
284 return ERR_PTR(-ESTALE
);
296 static struct dentry
*get_parent(struct dentry
*child
)
298 /* get_parent cannot be supported generically, the locking
300 * instead, we just return EACCES. If server reboots or inodes
301 * get flushed, you lose
303 return ERR_PTR(-EACCES
);
307 struct getdents_callback
{
308 char *name
; /* name that was found. It already points to a
309 buffer NAME_MAX+1 is size */
310 unsigned long ino
; /* the inum we are looking for */
311 int found
; /* inode matched? */
312 int sequence
; /* sequence counter */
316 * A rather strange filldir function to capture
317 * the name matching the specified inode number.
319 static int filldir_one(void * __buf
, const char * name
, int len
,
320 loff_t pos
, ino_t ino
, unsigned int d_type
)
322 struct getdents_callback
*buf
= __buf
;
326 if (buf
->ino
== ino
) {
327 memcpy(buf
->name
, name
, len
);
328 buf
->name
[len
] = '\0';
336 * get_name - default export_operations->get_name function
337 * @dentry: the directory in which to find a name
338 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
339 * @child: the dentry for the child directory.
341 * calls readdir on the parent until it finds an entry with
342 * the same inode number as the child, and returns that.
344 static int get_name(struct dentry
*dentry
, char *name
,
345 struct dentry
*child
)
347 struct inode
*dir
= dentry
->d_inode
;
350 struct getdents_callback buffer
;
353 if (!dir
|| !S_ISDIR(dir
->i_mode
))
359 * Open the directory ...
361 error
= open_private_file(&file
, dentry
, O_RDONLY
);
365 if (!file
.f_op
->readdir
)
369 buffer
.ino
= child
->d_inode
->i_ino
;
373 int old_seq
= buffer
.sequence
;
375 error
= vfs_readdir(&file
, filldir_one
, &buffer
);
384 if (old_seq
== buffer
.sequence
)
389 close_private_file(&file
);
395 static struct dentry
*export_iget(struct super_block
*sb
, unsigned long ino
, __u32 generation
)
398 /* iget isn't really right if the inode is currently unallocated!!
399 * This should really all be done inside each filesystem
401 * ext2fs' read_inode has been strengthed to return a bad_inode if
402 * the inode had been deleted.
404 * Currently we don't know the generation for parent directory, so
405 * a generation of 0 means "accept any"
408 struct dentry
*result
;
410 return ERR_PTR(-ESTALE
);
411 inode
= iget(sb
, ino
);
413 return ERR_PTR(-ENOMEM
);
414 if (is_bad_inode(inode
)
415 || (generation
&& inode
->i_generation
!= generation
)
417 /* we didn't find the right inode.. */
418 dprintk("fh_verify: Inode %lu, Bad count: %d %d or version %u %u\n",
420 inode
->i_nlink
, atomic_read(&inode
->i_count
),
425 return ERR_PTR(-ESTALE
);
427 /* now to find a dentry.
428 * If possible, get a well-connected one
430 result
= d_alloc_anon(inode
);
433 return ERR_PTR(-ENOMEM
);
439 static struct dentry
*get_object(struct super_block
*sb
, void *vobjp
)
442 unsigned long ino
= objp
[0];
443 __u32 generation
= objp
[1];
445 return export_iget(sb
, ino
, generation
);
450 * export_encode_fh - default export_operations->encode_fh function
451 * @dentry: the dentry to encode
452 * @fh: where to store the file handle fragment
453 * @max_len: maximum length to store there
454 * @connectable: whether to store parent information
456 * This default encode_fh function assumes that the 32 inode number
457 * is suitable for locating an inode, and that the generation number
458 * can be used to check that it is still valid. It places them in the
459 * filehandle fragment where export_decode_fh expects to find them.
461 static int export_encode_fh(struct dentry
*dentry
, __u32
*fh
, int *max_len
,
464 struct inode
* inode
= dentry
->d_inode
;
468 if (len
< 2 || (connectable
&& len
< 4))
472 fh
[0] = inode
->i_ino
;
473 fh
[1] = inode
->i_generation
;
474 if (connectable
&& !S_ISDIR(inode
->i_mode
)) {
475 struct inode
*parent
;
477 spin_lock(&dentry
->d_lock
);
478 parent
= dentry
->d_parent
->d_inode
;
479 fh
[2] = parent
->i_ino
;
480 fh
[3] = parent
->i_generation
;
481 spin_unlock(&dentry
->d_lock
);
491 * export_decode_fh - default export_operations->decode_fh function
492 * @sb: The superblock
493 * @fh: pointer to the file handle fragment
494 * @fh_len: length of file handle fragment
495 * @acceptable: function for testing acceptability of dentrys
496 * @context: context for @acceptable
498 * This is the default decode_fh() function.
499 * a fileid_type of 1 indicates that the filehandlefragment
500 * just contains an object identifier understood by get_dentry.
501 * a fileid_type of 2 says that there is also a directory
502 * identifier 8 bytes in to the filehandlefragement.
504 static struct dentry
*export_decode_fh(struct super_block
*sb
, __u32
*fh
, int fh_len
,
506 int (*acceptable
)(void *context
, struct dentry
*de
),
510 parent
[0] = parent
[1] = 0;
511 if (fh_len
< 2 || fileid_type
> 2)
513 if (fileid_type
== 2) {
514 if (fh_len
> 2) parent
[0] = fh
[2];
515 if (fh_len
> 3) parent
[1] = fh
[3];
517 return find_exported_dentry(sb
, fh
, parent
,
518 acceptable
, context
);
521 struct export_operations export_op_default
= {
522 .decode_fh
= export_decode_fh
,
523 .encode_fh
= export_encode_fh
,
525 .get_name
= get_name
,
526 .get_parent
= get_parent
,
527 .get_dentry
= get_object
,
530 EXPORT_SYMBOL(export_op_default
);
531 EXPORT_SYMBOL(find_exported_dentry
);
533 MODULE_LICENSE("GPL");