xref: /openbmc/linux/fs/btrfs/export.c (revision e23feb16)
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 
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)
15 
16 static int btrfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,
17 			   struct inode *parent)
18 {
19 	struct btrfs_fid *fid = (struct btrfs_fid *)fh;
20 	int len = *max_len;
21 	int type;
22 
23 	if (parent && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
24 		*max_len = BTRFS_FID_SIZE_CONNECTABLE;
25 		return FILEID_INVALID;
26 	} else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) {
27 		*max_len = BTRFS_FID_SIZE_NON_CONNECTABLE;
28 		return FILEID_INVALID;
29 	}
30 
31 	len  = BTRFS_FID_SIZE_NON_CONNECTABLE;
32 	type = FILEID_BTRFS_WITHOUT_PARENT;
33 
34 	fid->objectid = btrfs_ino(inode);
35 	fid->root_objectid = BTRFS_I(inode)->root->objectid;
36 	fid->gen = inode->i_generation;
37 
38 	if (parent) {
39 		u64 parent_root_id;
40 
41 		fid->parent_objectid = BTRFS_I(parent)->location.objectid;
42 		fid->parent_gen = parent->i_generation;
43 		parent_root_id = BTRFS_I(parent)->root->objectid;
44 
45 		if (parent_root_id != fid->root_objectid) {
46 			fid->parent_root_objectid = parent_root_id;
47 			len = BTRFS_FID_SIZE_CONNECTABLE_ROOT;
48 			type = FILEID_BTRFS_WITH_PARENT_ROOT;
49 		} else {
50 			len = BTRFS_FID_SIZE_CONNECTABLE;
51 			type = FILEID_BTRFS_WITH_PARENT;
52 		}
53 	}
54 
55 	*max_len = len;
56 	return type;
57 }
58 
59 static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
60 				       u64 root_objectid, u32 generation,
61 				       int check_generation)
62 {
63 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
64 	struct btrfs_root *root;
65 	struct inode *inode;
66 	struct btrfs_key key;
67 	int index;
68 	int err = 0;
69 
70 	if (objectid < BTRFS_FIRST_FREE_OBJECTID)
71 		return ERR_PTR(-ESTALE);
72 
73 	key.objectid = root_objectid;
74 	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
75 	key.offset = (u64)-1;
76 
77 	index = srcu_read_lock(&fs_info->subvol_srcu);
78 
79 	root = btrfs_read_fs_root_no_name(fs_info, &key);
80 	if (IS_ERR(root)) {
81 		err = PTR_ERR(root);
82 		goto fail;
83 	}
84 
85 	key.objectid = objectid;
86 	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
87 	key.offset = 0;
88 
89 	inode = btrfs_iget(sb, &key, root, NULL);
90 	if (IS_ERR(inode)) {
91 		err = PTR_ERR(inode);
92 		goto fail;
93 	}
94 
95 	srcu_read_unlock(&fs_info->subvol_srcu, index);
96 
97 	if (check_generation && generation != inode->i_generation) {
98 		iput(inode);
99 		return ERR_PTR(-ESTALE);
100 	}
101 
102 	return d_obtain_alias(inode);
103 fail:
104 	srcu_read_unlock(&fs_info->subvol_srcu, index);
105 	return ERR_PTR(err);
106 }
107 
108 static struct dentry *btrfs_fh_to_parent(struct super_block *sb, struct fid *fh,
109 					 int fh_len, int fh_type)
110 {
111 	struct btrfs_fid *fid = (struct btrfs_fid *) fh;
112 	u64 objectid, root_objectid;
113 	u32 generation;
114 
115 	if (fh_type == FILEID_BTRFS_WITH_PARENT) {
116 		if (fh_len !=  BTRFS_FID_SIZE_CONNECTABLE)
117 			return NULL;
118 		root_objectid = fid->root_objectid;
119 	} else if (fh_type == FILEID_BTRFS_WITH_PARENT_ROOT) {
120 		if (fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT)
121 			return NULL;
122 		root_objectid = fid->parent_root_objectid;
123 	} else
124 		return NULL;
125 
126 	objectid = fid->parent_objectid;
127 	generation = fid->parent_gen;
128 
129 	return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1);
130 }
131 
132 static struct dentry *btrfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
133 					 int fh_len, int fh_type)
134 {
135 	struct btrfs_fid *fid = (struct btrfs_fid *) fh;
136 	u64 objectid, root_objectid;
137 	u32 generation;
138 
139 	if ((fh_type != FILEID_BTRFS_WITH_PARENT ||
140 	     fh_len != BTRFS_FID_SIZE_CONNECTABLE) &&
141 	    (fh_type != FILEID_BTRFS_WITH_PARENT_ROOT ||
142 	     fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT) &&
143 	    (fh_type != FILEID_BTRFS_WITHOUT_PARENT ||
144 	     fh_len != BTRFS_FID_SIZE_NON_CONNECTABLE))
145 		return NULL;
146 
147 	objectid = fid->objectid;
148 	root_objectid = fid->root_objectid;
149 	generation = fid->gen;
150 
151 	return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1);
152 }
153 
154 static struct dentry *btrfs_get_parent(struct dentry *child)
155 {
156 	struct inode *dir = child->d_inode;
157 	struct btrfs_root *root = BTRFS_I(dir)->root;
158 	struct btrfs_path *path;
159 	struct extent_buffer *leaf;
160 	struct btrfs_root_ref *ref;
161 	struct btrfs_key key;
162 	struct btrfs_key found_key;
163 	int ret;
164 
165 	path = btrfs_alloc_path();
166 	if (!path)
167 		return ERR_PTR(-ENOMEM);
168 
169 	if (btrfs_ino(dir) == BTRFS_FIRST_FREE_OBJECTID) {
170 		key.objectid = root->root_key.objectid;
171 		key.type = BTRFS_ROOT_BACKREF_KEY;
172 		key.offset = (u64)-1;
173 		root = root->fs_info->tree_root;
174 	} else {
175 		key.objectid = btrfs_ino(dir);
176 		key.type = BTRFS_INODE_REF_KEY;
177 		key.offset = (u64)-1;
178 	}
179 
180 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
181 	if (ret < 0)
182 		goto fail;
183 
184 	BUG_ON(ret == 0); /* Key with offset of -1 found */
185 	if (path->slots[0] == 0) {
186 		ret = -ENOENT;
187 		goto fail;
188 	}
189 
190 	path->slots[0]--;
191 	leaf = path->nodes[0];
192 
193 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
194 	if (found_key.objectid != key.objectid || found_key.type != key.type) {
195 		ret = -ENOENT;
196 		goto fail;
197 	}
198 
199 	if (found_key.type == BTRFS_ROOT_BACKREF_KEY) {
200 		ref = btrfs_item_ptr(leaf, path->slots[0],
201 				     struct btrfs_root_ref);
202 		key.objectid = btrfs_root_ref_dirid(leaf, ref);
203 	} else {
204 		key.objectid = found_key.offset;
205 	}
206 	btrfs_free_path(path);
207 
208 	if (found_key.type == BTRFS_ROOT_BACKREF_KEY) {
209 		return btrfs_get_dentry(root->fs_info->sb, key.objectid,
210 					found_key.offset, 0, 0);
211 	}
212 
213 	key.type = BTRFS_INODE_ITEM_KEY;
214 	key.offset = 0;
215 	return d_obtain_alias(btrfs_iget(root->fs_info->sb, &key, root, NULL));
216 fail:
217 	btrfs_free_path(path);
218 	return ERR_PTR(ret);
219 }
220 
221 static int btrfs_get_name(struct dentry *parent, char *name,
222 			  struct dentry *child)
223 {
224 	struct inode *inode = child->d_inode;
225 	struct inode *dir = parent->d_inode;
226 	struct btrfs_path *path;
227 	struct btrfs_root *root = BTRFS_I(dir)->root;
228 	struct btrfs_inode_ref *iref;
229 	struct btrfs_root_ref *rref;
230 	struct extent_buffer *leaf;
231 	unsigned long name_ptr;
232 	struct btrfs_key key;
233 	int name_len;
234 	int ret;
235 	u64 ino;
236 
237 	if (!dir || !inode)
238 		return -EINVAL;
239 
240 	if (!S_ISDIR(dir->i_mode))
241 		return -EINVAL;
242 
243 	ino = btrfs_ino(inode);
244 
245 	path = btrfs_alloc_path();
246 	if (!path)
247 		return -ENOMEM;
248 	path->leave_spinning = 1;
249 
250 	if (ino == BTRFS_FIRST_FREE_OBJECTID) {
251 		key.objectid = BTRFS_I(inode)->root->root_key.objectid;
252 		key.type = BTRFS_ROOT_BACKREF_KEY;
253 		key.offset = (u64)-1;
254 		root = root->fs_info->tree_root;
255 	} else {
256 		key.objectid = ino;
257 		key.offset = btrfs_ino(dir);
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) {
266 		if (ino == BTRFS_FIRST_FREE_OBJECTID) {
267 			path->slots[0]--;
268 		} else {
269 			btrfs_free_path(path);
270 			return -ENOENT;
271 		}
272 	}
273 	leaf = path->nodes[0];
274 
275 	if (ino == BTRFS_FIRST_FREE_OBJECTID) {
276 		rref = btrfs_item_ptr(leaf, path->slots[0],
277 				     struct btrfs_root_ref);
278 		name_ptr = (unsigned long)(rref + 1);
279 		name_len = btrfs_root_ref_name_len(leaf, rref);
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 
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,
304 	.get_name	= btrfs_get_name,
305 };
306