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