1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2014 Filipe David Borba Manana <fdmanana@gmail.com>
4  */
5 
6 #include <linux/hashtable.h>
7 #include "props.h"
8 #include "btrfs_inode.h"
9 #include "transaction.h"
10 #include "ctree.h"
11 #include "xattr.h"
12 #include "compression.h"
13 
14 #define BTRFS_PROP_HANDLERS_HT_BITS 8
15 static DEFINE_HASHTABLE(prop_handlers_ht, BTRFS_PROP_HANDLERS_HT_BITS);
16 
17 struct prop_handler {
18 	struct hlist_node node;
19 	const char *xattr_name;
20 	int (*validate)(const struct btrfs_inode *inode, const char *value,
21 			size_t len);
22 	int (*apply)(struct inode *inode, const char *value, size_t len);
23 	const char *(*extract)(struct inode *inode);
24 	bool (*ignore)(const struct btrfs_inode *inode);
25 	int inheritable;
26 };
27 
find_prop_handlers_by_hash(const u64 hash)28 static const struct hlist_head *find_prop_handlers_by_hash(const u64 hash)
29 {
30 	struct hlist_head *h;
31 
32 	h = &prop_handlers_ht[hash_min(hash, BTRFS_PROP_HANDLERS_HT_BITS)];
33 	if (hlist_empty(h))
34 		return NULL;
35 
36 	return h;
37 }
38 
39 static const struct prop_handler *
find_prop_handler(const char * name,const struct hlist_head * handlers)40 find_prop_handler(const char *name,
41 		  const struct hlist_head *handlers)
42 {
43 	struct prop_handler *h;
44 
45 	if (!handlers) {
46 		u64 hash = btrfs_name_hash(name, strlen(name));
47 
48 		handlers = find_prop_handlers_by_hash(hash);
49 		if (!handlers)
50 			return NULL;
51 	}
52 
53 	hlist_for_each_entry(h, handlers, node)
54 		if (!strcmp(h->xattr_name, name))
55 			return h;
56 
57 	return NULL;
58 }
59 
btrfs_validate_prop(const struct btrfs_inode * inode,const char * name,const char * value,size_t value_len)60 int btrfs_validate_prop(const struct btrfs_inode *inode, const char *name,
61 			const char *value, size_t value_len)
62 {
63 	const struct prop_handler *handler;
64 
65 	if (strlen(name) <= XATTR_BTRFS_PREFIX_LEN)
66 		return -EINVAL;
67 
68 	handler = find_prop_handler(name, NULL);
69 	if (!handler)
70 		return -EINVAL;
71 
72 	if (value_len == 0)
73 		return 0;
74 
75 	return handler->validate(inode, value, value_len);
76 }
77 
78 /*
79  * Check if a property should be ignored (not set) for an inode.
80  *
81  * @inode:     The target inode.
82  * @name:      The property's name.
83  *
84  * The caller must be sure the given property name is valid, for example by
85  * having previously called btrfs_validate_prop().
86  *
87  * Returns:    true if the property should be ignored for the given inode
88  *             false if the property must not be ignored for the given inode
89  */
btrfs_ignore_prop(const struct btrfs_inode * inode,const char * name)90 bool btrfs_ignore_prop(const struct btrfs_inode *inode, const char *name)
91 {
92 	const struct prop_handler *handler;
93 
94 	handler = find_prop_handler(name, NULL);
95 	ASSERT(handler != NULL);
96 
97 	return handler->ignore(inode);
98 }
99 
btrfs_set_prop(struct btrfs_trans_handle * trans,struct inode * inode,const char * name,const char * value,size_t value_len,int flags)100 int btrfs_set_prop(struct btrfs_trans_handle *trans, struct inode *inode,
101 		   const char *name, const char *value, size_t value_len,
102 		   int flags)
103 {
104 	const struct prop_handler *handler;
105 	int ret;
106 
107 	handler = find_prop_handler(name, NULL);
108 	if (!handler)
109 		return -EINVAL;
110 
111 	if (value_len == 0) {
112 		ret = btrfs_setxattr(trans, inode, handler->xattr_name,
113 				     NULL, 0, flags);
114 		if (ret)
115 			return ret;
116 
117 		ret = handler->apply(inode, NULL, 0);
118 		ASSERT(ret == 0);
119 
120 		return ret;
121 	}
122 
123 	ret = btrfs_setxattr(trans, inode, handler->xattr_name, value,
124 			     value_len, flags);
125 	if (ret)
126 		return ret;
127 	ret = handler->apply(inode, value, value_len);
128 	if (ret) {
129 		btrfs_setxattr(trans, inode, handler->xattr_name, NULL,
130 			       0, flags);
131 		return ret;
132 	}
133 
134 	set_bit(BTRFS_INODE_HAS_PROPS, &BTRFS_I(inode)->runtime_flags);
135 
136 	return 0;
137 }
138 
iterate_object_props(struct btrfs_root * root,struct btrfs_path * path,u64 objectid,void (* iterator)(void *,const struct prop_handler *,const char *,size_t),void * ctx)139 static int iterate_object_props(struct btrfs_root *root,
140 				struct btrfs_path *path,
141 				u64 objectid,
142 				void (*iterator)(void *,
143 						 const struct prop_handler *,
144 						 const char *,
145 						 size_t),
146 				void *ctx)
147 {
148 	int ret;
149 	char *name_buf = NULL;
150 	char *value_buf = NULL;
151 	int name_buf_len = 0;
152 	int value_buf_len = 0;
153 
154 	while (1) {
155 		struct btrfs_key key;
156 		struct btrfs_dir_item *di;
157 		struct extent_buffer *leaf;
158 		u32 total_len, cur, this_len;
159 		int slot;
160 		const struct hlist_head *handlers;
161 
162 		slot = path->slots[0];
163 		leaf = path->nodes[0];
164 
165 		if (slot >= btrfs_header_nritems(leaf)) {
166 			ret = btrfs_next_leaf(root, path);
167 			if (ret < 0)
168 				goto out;
169 			else if (ret > 0)
170 				break;
171 			continue;
172 		}
173 
174 		btrfs_item_key_to_cpu(leaf, &key, slot);
175 		if (key.objectid != objectid)
176 			break;
177 		if (key.type != BTRFS_XATTR_ITEM_KEY)
178 			break;
179 
180 		handlers = find_prop_handlers_by_hash(key.offset);
181 		if (!handlers)
182 			goto next_slot;
183 
184 		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
185 		cur = 0;
186 		total_len = btrfs_item_size(leaf, slot);
187 
188 		while (cur < total_len) {
189 			u32 name_len = btrfs_dir_name_len(leaf, di);
190 			u32 data_len = btrfs_dir_data_len(leaf, di);
191 			unsigned long name_ptr, data_ptr;
192 			const struct prop_handler *handler;
193 
194 			this_len = sizeof(*di) + name_len + data_len;
195 			name_ptr = (unsigned long)(di + 1);
196 			data_ptr = name_ptr + name_len;
197 
198 			if (name_len <= XATTR_BTRFS_PREFIX_LEN ||
199 			    memcmp_extent_buffer(leaf, XATTR_BTRFS_PREFIX,
200 						 name_ptr,
201 						 XATTR_BTRFS_PREFIX_LEN))
202 				goto next_dir_item;
203 
204 			if (name_len >= name_buf_len) {
205 				kfree(name_buf);
206 				name_buf_len = name_len + 1;
207 				name_buf = kmalloc(name_buf_len, GFP_NOFS);
208 				if (!name_buf) {
209 					ret = -ENOMEM;
210 					goto out;
211 				}
212 			}
213 			read_extent_buffer(leaf, name_buf, name_ptr, name_len);
214 			name_buf[name_len] = '\0';
215 
216 			handler = find_prop_handler(name_buf, handlers);
217 			if (!handler)
218 				goto next_dir_item;
219 
220 			if (data_len > value_buf_len) {
221 				kfree(value_buf);
222 				value_buf_len = data_len;
223 				value_buf = kmalloc(data_len, GFP_NOFS);
224 				if (!value_buf) {
225 					ret = -ENOMEM;
226 					goto out;
227 				}
228 			}
229 			read_extent_buffer(leaf, value_buf, data_ptr, data_len);
230 
231 			iterator(ctx, handler, value_buf, data_len);
232 next_dir_item:
233 			cur += this_len;
234 			di = (struct btrfs_dir_item *)((char *) di + this_len);
235 		}
236 
237 next_slot:
238 		path->slots[0]++;
239 	}
240 
241 	ret = 0;
242 out:
243 	btrfs_release_path(path);
244 	kfree(name_buf);
245 	kfree(value_buf);
246 
247 	return ret;
248 }
249 
inode_prop_iterator(void * ctx,const struct prop_handler * handler,const char * value,size_t len)250 static void inode_prop_iterator(void *ctx,
251 				const struct prop_handler *handler,
252 				const char *value,
253 				size_t len)
254 {
255 	struct inode *inode = ctx;
256 	struct btrfs_root *root = BTRFS_I(inode)->root;
257 	int ret;
258 
259 	ret = handler->apply(inode, value, len);
260 	if (unlikely(ret))
261 		btrfs_warn(root->fs_info,
262 			   "error applying prop %s to ino %llu (root %llu): %d",
263 			   handler->xattr_name, btrfs_ino(BTRFS_I(inode)),
264 			   root->root_key.objectid, ret);
265 	else
266 		set_bit(BTRFS_INODE_HAS_PROPS, &BTRFS_I(inode)->runtime_flags);
267 }
268 
btrfs_load_inode_props(struct inode * inode,struct btrfs_path * path)269 int btrfs_load_inode_props(struct inode *inode, struct btrfs_path *path)
270 {
271 	struct btrfs_root *root = BTRFS_I(inode)->root;
272 	u64 ino = btrfs_ino(BTRFS_I(inode));
273 
274 	return iterate_object_props(root, path, ino, inode_prop_iterator, inode);
275 }
276 
prop_compression_validate(const struct btrfs_inode * inode,const char * value,size_t len)277 static int prop_compression_validate(const struct btrfs_inode *inode,
278 				     const char *value, size_t len)
279 {
280 	if (!btrfs_inode_can_compress(inode))
281 		return -EINVAL;
282 
283 	if (!value)
284 		return 0;
285 
286 	if (btrfs_compress_is_valid_type(value, len))
287 		return 0;
288 
289 	if ((len == 2 && strncmp("no", value, 2) == 0) ||
290 	    (len == 4 && strncmp("none", value, 4) == 0))
291 		return 0;
292 
293 	return -EINVAL;
294 }
295 
prop_compression_apply(struct inode * inode,const char * value,size_t len)296 static int prop_compression_apply(struct inode *inode, const char *value,
297 				  size_t len)
298 {
299 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
300 	int type;
301 
302 	/* Reset to defaults */
303 	if (len == 0) {
304 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
305 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
306 		BTRFS_I(inode)->prop_compress = BTRFS_COMPRESS_NONE;
307 		return 0;
308 	}
309 
310 	/* Set NOCOMPRESS flag */
311 	if ((len == 2 && strncmp("no", value, 2) == 0) ||
312 	    (len == 4 && strncmp("none", value, 4) == 0)) {
313 		BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
314 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
315 		BTRFS_I(inode)->prop_compress = BTRFS_COMPRESS_NONE;
316 
317 		return 0;
318 	}
319 
320 	if (!strncmp("lzo", value, 3)) {
321 		type = BTRFS_COMPRESS_LZO;
322 		btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);
323 	} else if (!strncmp("zlib", value, 4)) {
324 		type = BTRFS_COMPRESS_ZLIB;
325 	} else if (!strncmp("zstd", value, 4)) {
326 		type = BTRFS_COMPRESS_ZSTD;
327 		btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);
328 	} else {
329 		return -EINVAL;
330 	}
331 
332 	BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
333 	BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
334 	BTRFS_I(inode)->prop_compress = type;
335 
336 	return 0;
337 }
338 
prop_compression_ignore(const struct btrfs_inode * inode)339 static bool prop_compression_ignore(const struct btrfs_inode *inode)
340 {
341 	/*
342 	 * Compression only has effect for regular files, and for directories
343 	 * we set it just to propagate it to new files created inside them.
344 	 * Everything else (symlinks, devices, sockets, fifos) is pointless as
345 	 * it will do nothing, so don't waste metadata space on a compression
346 	 * xattr for anything that is neither a file nor a directory.
347 	 */
348 	if (!S_ISREG(inode->vfs_inode.i_mode) &&
349 	    !S_ISDIR(inode->vfs_inode.i_mode))
350 		return true;
351 
352 	return false;
353 }
354 
prop_compression_extract(struct inode * inode)355 static const char *prop_compression_extract(struct inode *inode)
356 {
357 	switch (BTRFS_I(inode)->prop_compress) {
358 	case BTRFS_COMPRESS_ZLIB:
359 	case BTRFS_COMPRESS_LZO:
360 	case BTRFS_COMPRESS_ZSTD:
361 		return btrfs_compress_type2str(BTRFS_I(inode)->prop_compress);
362 	default:
363 		break;
364 	}
365 
366 	return NULL;
367 }
368 
369 static struct prop_handler prop_handlers[] = {
370 	{
371 		.xattr_name = XATTR_BTRFS_PREFIX "compression",
372 		.validate = prop_compression_validate,
373 		.apply = prop_compression_apply,
374 		.extract = prop_compression_extract,
375 		.ignore = prop_compression_ignore,
376 		.inheritable = 1
377 	},
378 };
379 
btrfs_inode_inherit_props(struct btrfs_trans_handle * trans,struct inode * inode,struct inode * parent)380 int btrfs_inode_inherit_props(struct btrfs_trans_handle *trans,
381 			      struct inode *inode, struct inode *parent)
382 {
383 	struct btrfs_root *root = BTRFS_I(inode)->root;
384 	struct btrfs_fs_info *fs_info = root->fs_info;
385 	int ret;
386 	int i;
387 	bool need_reserve = false;
388 
389 	if (!test_bit(BTRFS_INODE_HAS_PROPS,
390 		      &BTRFS_I(parent)->runtime_flags))
391 		return 0;
392 
393 	for (i = 0; i < ARRAY_SIZE(prop_handlers); i++) {
394 		const struct prop_handler *h = &prop_handlers[i];
395 		const char *value;
396 		u64 num_bytes = 0;
397 
398 		if (!h->inheritable)
399 			continue;
400 
401 		if (h->ignore(BTRFS_I(inode)))
402 			continue;
403 
404 		value = h->extract(parent);
405 		if (!value)
406 			continue;
407 
408 		/*
409 		 * This is not strictly necessary as the property should be
410 		 * valid, but in case it isn't, don't propagate it further.
411 		 */
412 		ret = h->validate(BTRFS_I(inode), value, strlen(value));
413 		if (ret)
414 			continue;
415 
416 		/*
417 		 * Currently callers should be reserving 1 item for properties,
418 		 * since we only have 1 property that we currently support.  If
419 		 * we add more in the future we need to try and reserve more
420 		 * space for them.  But we should also revisit how we do space
421 		 * reservations if we do add more properties in the future.
422 		 */
423 		if (need_reserve) {
424 			num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
425 			ret = btrfs_block_rsv_add(fs_info, trans->block_rsv,
426 						  num_bytes,
427 						  BTRFS_RESERVE_NO_FLUSH);
428 			if (ret)
429 				return ret;
430 		}
431 
432 		ret = btrfs_setxattr(trans, inode, h->xattr_name, value,
433 				     strlen(value), 0);
434 		if (!ret) {
435 			ret = h->apply(inode, value, strlen(value));
436 			if (ret)
437 				btrfs_setxattr(trans, inode, h->xattr_name,
438 					       NULL, 0, 0);
439 			else
440 				set_bit(BTRFS_INODE_HAS_PROPS,
441 					&BTRFS_I(inode)->runtime_flags);
442 		}
443 
444 		if (need_reserve) {
445 			btrfs_block_rsv_release(fs_info, trans->block_rsv,
446 					num_bytes, NULL);
447 			if (ret)
448 				return ret;
449 		}
450 		need_reserve = true;
451 	}
452 
453 	return 0;
454 }
455 
btrfs_props_init(void)456 void __init btrfs_props_init(void)
457 {
458 	int i;
459 
460 	for (i = 0; i < ARRAY_SIZE(prop_handlers); i++) {
461 		struct prop_handler *p = &prop_handlers[i];
462 		u64 h = btrfs_name_hash(p->xattr_name, strlen(p->xattr_name));
463 
464 		hash_add(prop_handlers_ht, &p->node, h);
465 	}
466 }
467 
468