Commit | Line | Data |
---|---|---|
be6e8dc0 BR |
1 | #include <linux/fs.h> |
2 | #include <linux/types.h> | |
3 | #include "ctree.h" | |
4 | #include "disk-io.h" | |
5 | #include "btrfs_inode.h" | |
6 | #include "print-tree.h" | |
7 | #include "export.h" | |
8 | #include "compat.h" | |
9 | ||
d397712b CM |
10 | #define BTRFS_FID_SIZE_NON_CONNECTABLE (offsetof(struct btrfs_fid, \ |
11 | parent_objectid) / 4) | |
12 | #define BTRFS_FID_SIZE_CONNECTABLE (offsetof(struct btrfs_fid, \ | |
13 | parent_root_objectid) / 4) | |
14 | #define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid) / 4) | |
be6e8dc0 BR |
15 | |
16 | static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len, | |
17 | int connectable) | |
18 | { | |
19 | struct btrfs_fid *fid = (struct btrfs_fid *)fh; | |
20 | struct inode *inode = dentry->d_inode; | |
21 | int len = *max_len; | |
22 | int type; | |
23 | ||
5fe0c237 AK |
24 | if (connectable && (len < BTRFS_FID_SIZE_CONNECTABLE)) { |
25 | *max_len = BTRFS_FID_SIZE_CONNECTABLE; | |
be6e8dc0 | 26 | return 255; |
5fe0c237 AK |
27 | } else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) { |
28 | *max_len = BTRFS_FID_SIZE_NON_CONNECTABLE; | |
29 | return 255; | |
30 | } | |
be6e8dc0 BR |
31 | |
32 | len = BTRFS_FID_SIZE_NON_CONNECTABLE; | |
33 | type = FILEID_BTRFS_WITHOUT_PARENT; | |
34 | ||
76dda93c | 35 | fid->objectid = inode->i_ino; |
be6e8dc0 BR |
36 | fid->root_objectid = BTRFS_I(inode)->root->objectid; |
37 | fid->gen = inode->i_generation; | |
38 | ||
39 | if (connectable && !S_ISDIR(inode->i_mode)) { | |
40 | struct inode *parent; | |
41 | u64 parent_root_id; | |
42 | ||
43 | spin_lock(&dentry->d_lock); | |
44 | ||
45 | parent = dentry->d_parent->d_inode; | |
46 | fid->parent_objectid = BTRFS_I(parent)->location.objectid; | |
47 | fid->parent_gen = parent->i_generation; | |
48 | parent_root_id = BTRFS_I(parent)->root->objectid; | |
49 | ||
50 | spin_unlock(&dentry->d_lock); | |
51 | ||
52 | if (parent_root_id != fid->root_objectid) { | |
53 | fid->parent_root_objectid = parent_root_id; | |
54 | len = BTRFS_FID_SIZE_CONNECTABLE_ROOT; | |
55 | type = FILEID_BTRFS_WITH_PARENT_ROOT; | |
56 | } else { | |
57 | len = BTRFS_FID_SIZE_CONNECTABLE; | |
58 | type = FILEID_BTRFS_WITH_PARENT; | |
59 | } | |
60 | } | |
61 | ||
62 | *max_len = len; | |
63 | return type; | |
64 | } | |
65 | ||
66 | static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid, | |
76dda93c YZ |
67 | u64 root_objectid, u32 generation, |
68 | int check_generation) | |
be6e8dc0 | 69 | { |
76dda93c | 70 | struct btrfs_fs_info *fs_info = btrfs_sb(sb)->fs_info; |
be6e8dc0 BR |
71 | struct btrfs_root *root; |
72 | struct inode *inode; | |
be6e8dc0 | 73 | struct btrfs_key key; |
76dda93c YZ |
74 | int index; |
75 | int err = 0; | |
76 | ||
77 | if (objectid < BTRFS_FIRST_FREE_OBJECTID) | |
78 | return ERR_PTR(-ESTALE); | |
be6e8dc0 | 79 | |
2d4d9fbd DW |
80 | key.objectid = root_objectid; |
81 | btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); | |
82 | key.offset = (u64)-1; | |
83 | ||
76dda93c YZ |
84 | index = srcu_read_lock(&fs_info->subvol_srcu); |
85 | ||
86 | root = btrfs_read_fs_root_no_name(fs_info, &key); | |
87 | if (IS_ERR(root)) { | |
88 | err = PTR_ERR(root); | |
89 | goto fail; | |
90 | } | |
91 | ||
92 | if (btrfs_root_refs(&root->root_item) == 0) { | |
93 | err = -ENOENT; | |
94 | goto fail; | |
95 | } | |
2d4d9fbd | 96 | |
be6e8dc0 BR |
97 | key.objectid = objectid; |
98 | btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY); | |
99 | key.offset = 0; | |
100 | ||
73f73415 | 101 | inode = btrfs_iget(sb, &key, root, NULL); |
76dda93c YZ |
102 | if (IS_ERR(inode)) { |
103 | err = PTR_ERR(inode); | |
104 | goto fail; | |
105 | } | |
106 | ||
107 | srcu_read_unlock(&fs_info->subvol_srcu, index); | |
be6e8dc0 | 108 | |
76dda93c | 109 | if (check_generation && generation != inode->i_generation) { |
be6e8dc0 BR |
110 | iput(inode); |
111 | return ERR_PTR(-ESTALE); | |
112 | } | |
113 | ||
af53d29a | 114 | return d_obtain_alias(inode); |
76dda93c YZ |
115 | fail: |
116 | srcu_read_unlock(&fs_info->subvol_srcu, index); | |
117 | return ERR_PTR(err); | |
be6e8dc0 BR |
118 | } |
119 | ||
120 | static struct dentry *btrfs_fh_to_parent(struct super_block *sb, struct fid *fh, | |
121 | int fh_len, int fh_type) | |
122 | { | |
123 | struct btrfs_fid *fid = (struct btrfs_fid *) fh; | |
124 | u64 objectid, root_objectid; | |
125 | u32 generation; | |
126 | ||
127 | if (fh_type == FILEID_BTRFS_WITH_PARENT) { | |
128 | if (fh_len != BTRFS_FID_SIZE_CONNECTABLE) | |
129 | return NULL; | |
130 | root_objectid = fid->root_objectid; | |
131 | } else if (fh_type == FILEID_BTRFS_WITH_PARENT_ROOT) { | |
132 | if (fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT) | |
133 | return NULL; | |
134 | root_objectid = fid->parent_root_objectid; | |
135 | } else | |
136 | return NULL; | |
137 | ||
138 | objectid = fid->parent_objectid; | |
139 | generation = fid->parent_gen; | |
140 | ||
76dda93c | 141 | return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1); |
be6e8dc0 BR |
142 | } |
143 | ||
144 | static struct dentry *btrfs_fh_to_dentry(struct super_block *sb, struct fid *fh, | |
145 | int fh_len, int fh_type) | |
146 | { | |
147 | struct btrfs_fid *fid = (struct btrfs_fid *) fh; | |
148 | u64 objectid, root_objectid; | |
149 | u32 generation; | |
150 | ||
151 | if ((fh_type != FILEID_BTRFS_WITH_PARENT || | |
152 | fh_len != BTRFS_FID_SIZE_CONNECTABLE) && | |
153 | (fh_type != FILEID_BTRFS_WITH_PARENT_ROOT || | |
154 | fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT) && | |
155 | (fh_type != FILEID_BTRFS_WITHOUT_PARENT || | |
156 | fh_len != BTRFS_FID_SIZE_NON_CONNECTABLE)) | |
157 | return NULL; | |
158 | ||
159 | objectid = fid->objectid; | |
160 | root_objectid = fid->root_objectid; | |
161 | generation = fid->gen; | |
162 | ||
76dda93c | 163 | return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1); |
be6e8dc0 BR |
164 | } |
165 | ||
166 | static struct dentry *btrfs_get_parent(struct dentry *child) | |
167 | { | |
168 | struct inode *dir = child->d_inode; | |
be6e8dc0 | 169 | struct btrfs_root *root = BTRFS_I(dir)->root; |
be6e8dc0 BR |
170 | struct btrfs_path *path; |
171 | struct extent_buffer *leaf; | |
76dda93c YZ |
172 | struct btrfs_root_ref *ref; |
173 | struct btrfs_key key; | |
174 | struct btrfs_key found_key; | |
be6e8dc0 BR |
175 | int ret; |
176 | ||
177 | path = btrfs_alloc_path(); | |
2a29edc6 | 178 | if (!path) |
179 | return ERR_PTR(-ENOMEM); | |
be6e8dc0 | 180 | |
76dda93c YZ |
181 | if (dir->i_ino == BTRFS_FIRST_FREE_OBJECTID) { |
182 | key.objectid = root->root_key.objectid; | |
183 | key.type = BTRFS_ROOT_BACKREF_KEY; | |
184 | key.offset = (u64)-1; | |
185 | root = root->fs_info->tree_root; | |
186 | } else { | |
187 | key.objectid = dir->i_ino; | |
188 | key.type = BTRFS_INODE_REF_KEY; | |
189 | key.offset = (u64)-1; | |
190 | } | |
be6e8dc0 | 191 | |
87acb4ef | 192 | ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); |
76dda93c YZ |
193 | if (ret < 0) |
194 | goto fail; | |
195 | ||
196 | BUG_ON(ret == 0); | |
197 | if (path->slots[0] == 0) { | |
198 | ret = -ENOENT; | |
199 | goto fail; | |
d54a8390 | 200 | } |
76dda93c YZ |
201 | |
202 | path->slots[0]--; | |
be6e8dc0 | 203 | leaf = path->nodes[0]; |
76dda93c YZ |
204 | |
205 | btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); | |
206 | if (found_key.objectid != key.objectid || found_key.type != key.type) { | |
207 | ret = -ENOENT; | |
208 | goto fail; | |
be6e8dc0 BR |
209 | } |
210 | ||
76dda93c YZ |
211 | if (found_key.type == BTRFS_ROOT_BACKREF_KEY) { |
212 | ref = btrfs_item_ptr(leaf, path->slots[0], | |
213 | struct btrfs_root_ref); | |
214 | key.objectid = btrfs_root_ref_dirid(leaf, ref); | |
215 | } else { | |
216 | key.objectid = found_key.offset; | |
217 | } | |
be6e8dc0 BR |
218 | btrfs_free_path(path); |
219 | ||
76dda93c YZ |
220 | if (found_key.type == BTRFS_ROOT_BACKREF_KEY) { |
221 | return btrfs_get_dentry(root->fs_info->sb, key.objectid, | |
222 | found_key.offset, 0, 0); | |
223 | } | |
2d4d9fbd | 224 | |
76dda93c | 225 | key.type = BTRFS_INODE_ITEM_KEY; |
be6e8dc0 | 226 | key.offset = 0; |
af53d29a | 227 | return d_obtain_alias(btrfs_iget(root->fs_info->sb, &key, root, NULL)); |
76dda93c YZ |
228 | fail: |
229 | btrfs_free_path(path); | |
230 | return ERR_PTR(ret); | |
be6e8dc0 BR |
231 | } |
232 | ||
2ede0daf JB |
233 | static int btrfs_get_name(struct dentry *parent, char *name, |
234 | struct dentry *child) | |
235 | { | |
236 | struct inode *inode = child->d_inode; | |
237 | struct inode *dir = parent->d_inode; | |
238 | struct btrfs_path *path; | |
239 | struct btrfs_root *root = BTRFS_I(dir)->root; | |
240 | struct btrfs_inode_ref *iref; | |
241 | struct btrfs_root_ref *rref; | |
242 | struct extent_buffer *leaf; | |
243 | unsigned long name_ptr; | |
244 | struct btrfs_key key; | |
245 | int name_len; | |
246 | int ret; | |
247 | ||
248 | if (!dir || !inode) | |
249 | return -EINVAL; | |
250 | ||
251 | if (!S_ISDIR(dir->i_mode)) | |
252 | return -EINVAL; | |
253 | ||
254 | path = btrfs_alloc_path(); | |
255 | if (!path) | |
256 | return -ENOMEM; | |
257 | path->leave_spinning = 1; | |
258 | ||
259 | if (inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) { | |
260 | key.objectid = BTRFS_I(inode)->root->root_key.objectid; | |
261 | key.type = BTRFS_ROOT_BACKREF_KEY; | |
262 | key.offset = (u64)-1; | |
263 | root = root->fs_info->tree_root; | |
264 | } else { | |
265 | key.objectid = inode->i_ino; | |
266 | key.offset = dir->i_ino; | |
267 | key.type = BTRFS_INODE_REF_KEY; | |
268 | } | |
269 | ||
270 | ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); | |
271 | if (ret < 0) { | |
272 | btrfs_free_path(path); | |
273 | return ret; | |
274 | } else if (ret > 0) { | |
275 | if (inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) { | |
276 | path->slots[0]--; | |
277 | } else { | |
278 | btrfs_free_path(path); | |
279 | return -ENOENT; | |
280 | } | |
281 | } | |
282 | leaf = path->nodes[0]; | |
283 | ||
284 | if (inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) { | |
285 | rref = btrfs_item_ptr(leaf, path->slots[0], | |
286 | struct btrfs_root_ref); | |
287 | name_ptr = (unsigned long)(rref + 1); | |
288 | name_len = btrfs_root_ref_name_len(leaf, rref); | |
289 | } else { | |
290 | iref = btrfs_item_ptr(leaf, path->slots[0], | |
291 | struct btrfs_inode_ref); | |
292 | name_ptr = (unsigned long)(iref + 1); | |
293 | name_len = btrfs_inode_ref_name_len(leaf, iref); | |
294 | } | |
295 | ||
296 | read_extent_buffer(leaf, name, name_ptr, name_len); | |
297 | btrfs_free_path(path); | |
298 | ||
299 | /* | |
300 | * have to add the null termination to make sure that reconnect_path | |
301 | * gets the right len for strlen | |
302 | */ | |
303 | name[name_len] = '\0'; | |
304 | ||
305 | return 0; | |
306 | } | |
307 | ||
be6e8dc0 BR |
308 | const struct export_operations btrfs_export_ops = { |
309 | .encode_fh = btrfs_encode_fh, | |
310 | .fh_to_dentry = btrfs_fh_to_dentry, | |
311 | .fh_to_parent = btrfs_fh_to_parent, | |
312 | .get_parent = btrfs_get_parent, | |
2ede0daf | 313 | .get_name = btrfs_get_name, |
be6e8dc0 | 314 | }; |