0b4a771b4903579843a8bf246b773429bdd8217e
[linux-2.6.git] / include / linux / exportfs.h
1 #ifndef LINUX_EXPORTFS_H
2 #define LINUX_EXPORTFS_H 1
3
4 #include <linux/types.h>
5
6 struct dentry;
7 struct inode;
8 struct super_block;
9 struct vfsmount;
10
11 /*
12  * The fileid_type identifies how the file within the filesystem is encoded.
13  * In theory this is freely set and parsed by the filesystem, but we try to
14  * stick to conventions so we can share some generic code and don't confuse
15  * sniffers like ethereal/wireshark.
16  *
17  * The filesystem must not use the value '0' or '0xff'.
18  */
19 enum fid_type {
20         /*
21          * The root, or export point, of the filesystem.
22          * (Never actually passed down to the filesystem.
23          */
24         FILEID_ROOT = 0,
25
26         /*
27          * 32bit inode number, 32 bit generation number.
28          */
29         FILEID_INO32_GEN = 1,
30
31         /*
32          * 32bit inode number, 32 bit generation number,
33          * 32 bit parent directory inode number.
34          */
35         FILEID_INO32_GEN_PARENT = 2,
36 };
37
38 struct fid {
39         union {
40                 struct {
41                         u32 ino;
42                         u32 gen;
43                         u32 parent_ino;
44                         u32 parent_gen;
45                 } i32;
46                 __u32 raw[6];
47         };
48 };
49
50 /**
51  * struct export_operations - for nfsd to communicate with file systems
52  * @decode_fh:      decode a file handle fragment and return a &struct dentry
53  * @encode_fh:      encode a file handle fragment from a dentry
54  * @get_name:       find the name for a given inode in a given directory
55  * @get_parent:     find the parent of a given directory
56  * @get_dentry:     find a dentry for the inode given a file handle sub-fragment
57  *
58  * Description:
59  *    The export_operations structure provides a means for nfsd to communicate
60  *    with a particular exported file system  - particularly enabling nfsd and
61  *    the filesystem to co-operate when dealing with file handles.
62  *
63  *    export_operations contains two basic operation for dealing with file
64  *    handles, decode_fh() and encode_fh(), and allows for some other
65  *    operations to be defined which standard helper routines use to get
66  *    specific information from the filesystem.
67  *
68  *    nfsd encodes information use to determine which filesystem a filehandle
69  *    applies to in the initial part of the file handle.  The remainder, termed
70  *    a file handle fragment, is controlled completely by the filesystem.  The
71  *    standard helper routines assume that this fragment will contain one or
72  *    two sub-fragments, one which identifies the file, and one which may be
73  *    used to identify the (a) directory containing the file.
74  *
75  *    In some situations, nfsd needs to get a dentry which is connected into a
76  *    specific part of the file tree.  To allow for this, it passes the
77  *    function acceptable() together with a @context which can be used to see
78  *    if the dentry is acceptable.  As there can be multiple dentrys for a
79  *    given file, the filesystem should check each one for acceptability before
80  *    looking for the next.  As soon as an acceptable one is found, it should
81  *    be returned.
82  *
83  * encode_fh:
84  *    @encode_fh should store in the file handle fragment @fh (using at most
85  *    @max_len bytes) information that can be used by @decode_fh to recover the
86  *    file refered to by the &struct dentry @de.  If the @connectable flag is
87  *    set, the encode_fh() should store sufficient information so that a good
88  *    attempt can be made to find not only the file but also it's place in the
89  *    filesystem.   This typically means storing a reference to de->d_parent in
90  *    the filehandle fragment.  encode_fh() should return the number of bytes
91  *    stored or a negative error code such as %-ENOSPC
92  *
93  * fh_to_dentry:
94  *    @fh_to_dentry is given a &struct super_block (@sb) and a file handle
95  *    fragment (@fh, @fh_len). It should return a &struct dentry which refers
96  *    to the same file that the file handle fragment refers to.  If it cannot,
97  *    it should return a %NULL pointer if the file was found but no acceptable
98  *    &dentries were available, or an %ERR_PTR error code indicating why it
99  *    couldn't be found (e.g. %ENOENT or %ENOMEM).  Any suitable dentry can be
100  *    returned including, if necessary, a new dentry created with d_alloc_root.
101  *    The caller can then find any other extant dentries by following the
102  *    d_alias links.
103  *
104  * fh_to_parent:
105  *    Same as @fh_to_dentry, except that it returns a pointer to the parent
106  *    dentry if it was encoded into the filehandle fragment by @encode_fh.
107  *
108  * get_name:
109  *    @get_name should find a name for the given @child in the given @parent
110  *    directory.  The name should be stored in the @name (with the
111  *    understanding that it is already pointing to a a %NAME_MAX+1 sized
112  *    buffer.   get_name() should return %0 on success, a negative error code
113  *    or error.  @get_name will be called without @parent->i_mutex held.
114  *
115  * get_parent:
116  *    @get_parent should find the parent directory for the given @child which
117  *    is also a directory.  In the event that it cannot be found, or storage
118  *    space cannot be allocated, a %ERR_PTR should be returned.
119  *
120  * Locking rules:
121  *    get_parent is called with child->d_inode->i_mutex down
122  *    get_name is not (which is possibly inconsistent)
123  */
124
125 struct export_operations {
126         int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
127                         int connectable);
128         struct dentry * (*fh_to_dentry)(struct super_block *sb, struct fid *fid,
129                         int fh_len, int fh_type);
130         struct dentry * (*fh_to_parent)(struct super_block *sb, struct fid *fid,
131                         int fh_len, int fh_type);
132         int (*get_name)(struct dentry *parent, char *name,
133                         struct dentry *child);
134         struct dentry * (*get_parent)(struct dentry *child);
135 };
136
137 extern int exportfs_encode_fh(struct dentry *dentry, struct fid *fid,
138         int *max_len, int connectable);
139 extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
140         int fh_len, int fileid_type, int (*acceptable)(void *, struct dentry *),
141         void *context);
142
143 /*
144  * Generic helpers for filesystems.
145  */
146 extern struct dentry *generic_fh_to_dentry(struct super_block *sb,
147         struct fid *fid, int fh_len, int fh_type,
148         struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
149 extern struct dentry *generic_fh_to_parent(struct super_block *sb,
150         struct fid *fid, int fh_len, int fh_type,
151         struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
152
153 #endif /* LINUX_EXPORTFS_H */