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