Line data Source code
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 : * 64 bit object ID, 64 bit root object ID,
39 : * 32 bit generation number.
40 : */
41 : FILEID_BTRFS_WITHOUT_PARENT = 0x4d,
42 :
43 : /*
44 : * 64 bit object ID, 64 bit root object ID,
45 : * 32 bit generation number,
46 : * 64 bit parent object ID, 32 bit parent generation.
47 : */
48 : FILEID_BTRFS_WITH_PARENT = 0x4e,
49 :
50 : /*
51 : * 64 bit object ID, 64 bit root object ID,
52 : * 32 bit generation number,
53 : * 64 bit parent object ID, 32 bit parent generation,
54 : * 64 bit parent root object ID.
55 : */
56 : FILEID_BTRFS_WITH_PARENT_ROOT = 0x4f,
57 :
58 : /*
59 : * 32 bit block number, 16 bit partition reference,
60 : * 16 bit unused, 32 bit generation number.
61 : */
62 : FILEID_UDF_WITHOUT_PARENT = 0x51,
63 :
64 : /*
65 : * 32 bit block number, 16 bit partition reference,
66 : * 16 bit unused, 32 bit generation number,
67 : * 32 bit parent block number, 32 bit parent generation number
68 : */
69 : FILEID_UDF_WITH_PARENT = 0x52,
70 : };
71 :
72 : struct fid {
73 : union {
74 : struct {
75 : u32 ino;
76 : u32 gen;
77 : u32 parent_ino;
78 : u32 parent_gen;
79 : } i32;
80 : struct {
81 : u32 block;
82 : u16 partref;
83 : u16 parent_partref;
84 : u32 generation;
85 : u32 parent_block;
86 : u32 parent_generation;
87 : } udf;
88 : __u32 raw[0];
89 : };
90 : };
91 1 :
92 : /**
93 : * struct export_operations - for nfsd to communicate with file systems
94 : * @encode_fh: encode a file handle fragment from a dentry
95 : * @fh_to_dentry: find the implied object and get a dentry for it
96 : * @fh_to_parent: find the implied object's parent and get a dentry for it
97 : * @get_name: find the name for a given inode in a given directory
98 : * @get_parent: find the parent of a given directory
99 : *
100 : * See Documentation/filesystems/nfs/Exporting for details on how to use
101 : * this interface correctly.
102 : *
103 : * encode_fh:
104 : * @encode_fh should store in the file handle fragment @fh (using at most
105 : * @max_len bytes) information that can be used by @decode_fh to recover the
106 : * file refered to by the &struct dentry @de. If the @connectable flag is
107 : * set, the encode_fh() should store sufficient information so that a good
108 : * attempt can be made to find not only the file but also it's place in the
109 : * filesystem. This typically means storing a reference to de->d_parent in
110 : * the filehandle fragment. encode_fh() should return the number of bytes
111 : * stored or a negative error code such as %-ENOSPC
112 : *
113 : * fh_to_dentry:
114 : * @fh_to_dentry is given a &struct super_block (@sb) and a file handle
115 : * fragment (@fh, @fh_len). It should return a &struct dentry which refers
116 : * to the same file that the file handle fragment refers to. If it cannot,
117 : * it should return a %NULL pointer if the file was found but no acceptable
118 : * &dentries were available, or an %ERR_PTR error code indicating why it
119 : * couldn't be found (e.g. %ENOENT or %ENOMEM). Any suitable dentry can be
120 : * returned including, if necessary, a new dentry created with d_alloc_root.
121 : * The caller can then find any other extant dentries by following the
122 : * d_alias links.
123 : *
124 : * fh_to_parent:
125 : * Same as @fh_to_dentry, except that it returns a pointer to the parent
126 : * dentry if it was encoded into the filehandle fragment by @encode_fh.
127 : *
128 : * get_name:
129 : * @get_name should find a name for the given @child in the given @parent
130 : * directory. The name should be stored in the @name (with the
131 : * understanding that it is already pointing to a a %NAME_MAX+1 sized
132 : * buffer. get_name() should return %0 on success, a negative error code
133 : * or error. @get_name will be called without @parent->i_mutex held.
134 : *
135 : * get_parent:
136 : * @get_parent should find the parent directory for the given @child which
137 : * is also a directory. In the event that it cannot be found, or storage
138 : * space cannot be allocated, a %ERR_PTR should be returned.
139 : *
140 : * Locking rules:
141 : * get_parent is called with child->d_inode->i_mutex down
142 : * get_name is not (which is possibly inconsistent)
143 : */
144 :
145 : struct export_operations {
146 : int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
147 : int connectable);
148 : struct dentry * (*fh_to_dentry)(struct super_block *sb, struct fid *fid,
149 : int fh_len, int fh_type);
150 : struct dentry * (*fh_to_parent)(struct super_block *sb, struct fid *fid,
151 : int fh_len, int fh_type);
152 : int (*get_name)(struct dentry *parent, char *name,
153 : struct dentry *child);
154 : struct dentry * (*get_parent)(struct dentry *child);
155 : };
156 :
157 : extern int exportfs_encode_fh(struct dentry *dentry, struct fid *fid,
158 : int *max_len, int connectable);
159 : extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
160 : int fh_len, int fileid_type, int (*acceptable)(void *, struct dentry *),
161 : void *context);
162 :
163 : /*
164 : * Generic helpers for filesystems.
165 : */
166 : extern struct dentry *generic_fh_to_dentry(struct super_block *sb,
167 : struct fid *fid, int fh_len, int fh_type,
168 : struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
169 : extern struct dentry *generic_fh_to_parent(struct super_block *sb,
170 : struct fid *fid, int fh_len, int fh_type,
171 : struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
172 :
173 : #endif /* LINUX_EXPORTFS_H */
|