3 #include "bkey_methods.h"
4 #include "btree_update.h"
12 #include <linux/dcache.h>
13 #include <linux/posix_acl_xattr.h>
14 #include <linux/xattr.h>
16 static unsigned xattr_val_u64s(unsigned name_len, unsigned val_len)
18 return DIV_ROUND_UP(sizeof(struct bch_xattr) +
19 name_len + val_len, sizeof(u64));
22 #define xattr_val(_xattr) ((_xattr)->x_name + (_xattr)->x_name_len)
24 static const struct xattr_handler *bch2_xattr_type_to_handler(unsigned);
26 struct xattr_search_key {
31 #define X_SEARCH(_type, _name, _len) ((struct xattr_search_key) \
32 { .type = _type, .name = QSTR_INIT(_name, _len) })
34 static u64 bch2_xattr_hash(const struct bch_hash_info *info,
35 const struct xattr_search_key *key)
37 struct bch_str_hash_ctx ctx;
39 bch2_str_hash_init(&ctx, info);
40 bch2_str_hash_update(&ctx, info, &key->type, sizeof(key->type));
41 bch2_str_hash_update(&ctx, info, key->name.name, key->name.len);
43 return bch2_str_hash_end(&ctx, info);
46 static u64 xattr_hash_key(const struct bch_hash_info *info, const void *key)
48 return bch2_xattr_hash(info, key);
51 static u64 xattr_hash_bkey(const struct bch_hash_info *info, struct bkey_s_c k)
53 struct bkey_s_c_xattr x = bkey_s_c_to_xattr(k);
55 return bch2_xattr_hash(info,
56 &X_SEARCH(x.v->x_type, x.v->x_name, x.v->x_name_len));
59 static bool xattr_cmp_key(struct bkey_s_c _l, const void *_r)
61 struct bkey_s_c_xattr l = bkey_s_c_to_xattr(_l);
62 const struct xattr_search_key *r = _r;
64 return l.v->x_type != r->type ||
65 l.v->x_name_len != r->name.len ||
66 memcmp(l.v->x_name, r->name.name, r->name.len);
69 static bool xattr_cmp_bkey(struct bkey_s_c _l, struct bkey_s_c _r)
71 struct bkey_s_c_xattr l = bkey_s_c_to_xattr(_l);
72 struct bkey_s_c_xattr r = bkey_s_c_to_xattr(_r);
74 return l.v->x_type != r.v->x_type ||
75 l.v->x_name_len != r.v->x_name_len ||
76 memcmp(l.v->x_name, r.v->x_name, r.v->x_name_len);
79 const struct bch_hash_desc bch2_xattr_hash_desc = {
80 .btree_id = BTREE_ID_XATTRS,
81 .key_type = BCH_XATTR,
82 .whiteout_type = BCH_XATTR_WHITEOUT,
83 .hash_key = xattr_hash_key,
84 .hash_bkey = xattr_hash_bkey,
85 .cmp_key = xattr_cmp_key,
86 .cmp_bkey = xattr_cmp_bkey,
89 const char *bch2_xattr_invalid(const struct bch_fs *c, struct bkey_s_c k)
91 const struct xattr_handler *handler;
92 struct bkey_s_c_xattr xattr;
97 if (bkey_val_bytes(k.k) < sizeof(struct bch_xattr))
98 return "value too small";
100 xattr = bkey_s_c_to_xattr(k);
101 u64s = xattr_val_u64s(xattr.v->x_name_len,
102 le16_to_cpu(xattr.v->x_val_len));
104 if (bkey_val_u64s(k.k) < u64s)
105 return "value too small";
107 if (bkey_val_u64s(k.k) > u64s)
108 return "value too big";
110 handler = bch2_xattr_type_to_handler(xattr.v->x_type);
112 return "invalid type";
114 if (memchr(xattr.v->x_name, '\0', xattr.v->x_name_len))
115 return "xattr name has invalid characters";
118 case BCH_XATTR_WHITEOUT:
119 return bkey_val_bytes(k.k) != 0
120 ? "value size should be zero"
124 return "invalid type";
128 void bch2_xattr_to_text(struct bch_fs *c, char *buf,
129 size_t size, struct bkey_s_c k)
131 const struct xattr_handler *handler;
132 struct bkey_s_c_xattr xattr;
137 xattr = bkey_s_c_to_xattr(k);
139 handler = bch2_xattr_type_to_handler(xattr.v->x_type);
140 if (handler && handler->prefix)
141 n += scnprintf(buf + n, size - n, "%s", handler->prefix);
143 n += scnprintf(buf + n, size - n, "(type %u)",
146 n += scnprintf(buf + n, size - n, "(unknown type %u)",
149 n += bch_scnmemcpy(buf + n, size - n, xattr.v->x_name,
150 xattr.v->x_name_len);
151 n += scnprintf(buf + n, size - n, ":");
152 n += bch_scnmemcpy(buf + n, size - n, xattr_val(xattr.v),
153 le16_to_cpu(xattr.v->x_val_len));
155 case BCH_XATTR_WHITEOUT:
156 scnprintf(buf, size, "whiteout");
161 int bch2_xattr_get(struct bch_fs *c, struct bch_inode_info *inode,
162 const char *name, void *buffer, size_t size, int type)
164 struct btree_iter iter;
166 struct bkey_s_c_xattr xattr;
169 k = bch2_hash_lookup(bch2_xattr_hash_desc, &inode->ei_str_hash, c,
170 inode->v.i_ino, &iter,
171 &X_SEARCH(type, name, strlen(name)));
173 return bch2_btree_iter_unlock(&iter) ?: -ENODATA;
175 xattr = bkey_s_c_to_xattr(k);
176 ret = le16_to_cpu(xattr.v->x_val_len);
181 memcpy(buffer, xattr_val(xattr.v), ret);
184 bch2_btree_iter_unlock(&iter);
188 int __bch2_xattr_set(struct bch_fs *c, u64 inum,
189 const struct bch_hash_info *hash_info,
190 const char *name, const void *value, size_t size,
191 int flags, int type, u64 *journal_seq)
193 struct xattr_search_key search = X_SEARCH(type, name, strlen(name));
197 ret = bch2_hash_delete(bch2_xattr_hash_desc, hash_info,
199 journal_seq, &search);
201 struct bkey_i_xattr *xattr;
202 unsigned u64s = BKEY_U64s +
203 xattr_val_u64s(search.name.len, size);
208 xattr = kmalloc(u64s * sizeof(u64), GFP_NOFS);
212 bkey_xattr_init(&xattr->k_i);
213 xattr->k.u64s = u64s;
214 xattr->v.x_type = type;
215 xattr->v.x_name_len = search.name.len;
216 xattr->v.x_val_len = cpu_to_le16(size);
217 memcpy(xattr->v.x_name, search.name.name, search.name.len);
218 memcpy(xattr_val(&xattr->v), value, size);
220 ret = bch2_hash_set(bch2_xattr_hash_desc, hash_info, c,
223 (flags & XATTR_CREATE ? BCH_HASH_SET_MUST_CREATE : 0)|
224 (flags & XATTR_REPLACE ? BCH_HASH_SET_MUST_REPLACE : 0));
229 ret = flags & XATTR_REPLACE ? -ENODATA : 0;
234 int bch2_xattr_set(struct bch_fs *c, struct bch_inode_info *inode,
235 const char *name, const void *value, size_t size,
238 return __bch2_xattr_set(c, inode->v.i_ino, &inode->ei_str_hash,
239 name, value, size, flags, type,
240 &inode->ei_journal_seq);
243 static size_t bch2_xattr_emit(struct dentry *dentry,
244 const struct bch_xattr *xattr,
245 char *buffer, size_t buffer_size)
247 const struct xattr_handler *handler =
248 bch2_xattr_type_to_handler(xattr->x_type);
250 if (handler && (!handler->list || handler->list(dentry))) {
251 const char *prefix = handler->prefix ?: handler->name;
252 const size_t prefix_len = strlen(prefix);
253 const size_t total_len = prefix_len + xattr->x_name_len + 1;
255 if (buffer && total_len <= buffer_size) {
256 memcpy(buffer, prefix, prefix_len);
257 memcpy(buffer + prefix_len,
258 xattr->x_name, xattr->x_name_len);
259 buffer[prefix_len + xattr->x_name_len] = '\0';
268 ssize_t bch2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
270 struct bch_fs *c = dentry->d_sb->s_fs_info;
271 struct btree_iter iter;
273 const struct bch_xattr *xattr;
274 u64 inum = dentry->d_inode->i_ino;
278 for_each_btree_key(&iter, c, BTREE_ID_XATTRS, POS(inum, 0), 0, k) {
279 BUG_ON(k.k->p.inode < inum);
281 if (k.k->p.inode > inum)
284 if (k.k->type != BCH_XATTR)
287 xattr = bkey_s_c_to_xattr(k).v;
289 len = bch2_xattr_emit(dentry, xattr, buffer, buffer_size);
291 if (len > buffer_size) {
292 bch2_btree_iter_unlock(&iter);
303 bch2_btree_iter_unlock(&iter);
308 static int bch2_xattr_get_handler(const struct xattr_handler *handler,
309 struct dentry *dentry, struct inode *vinode,
310 const char *name, void *buffer, size_t size)
312 struct bch_inode_info *inode = to_bch_ei(vinode);
313 struct bch_fs *c = inode->v.i_sb->s_fs_info;
315 return bch2_xattr_get(c, inode, name, buffer, size, handler->flags);
318 static int bch2_xattr_set_handler(const struct xattr_handler *handler,
319 struct dentry *dentry, struct inode *vinode,
320 const char *name, const void *value,
321 size_t size, int flags)
323 struct bch_inode_info *inode = to_bch_ei(vinode);
324 struct bch_fs *c = inode->v.i_sb->s_fs_info;
326 return bch2_xattr_set(c, inode, name, value, size, flags,
330 static const struct xattr_handler bch_xattr_user_handler = {
331 .prefix = XATTR_USER_PREFIX,
332 .get = bch2_xattr_get_handler,
333 .set = bch2_xattr_set_handler,
334 .flags = BCH_XATTR_INDEX_USER,
337 static bool bch2_xattr_trusted_list(struct dentry *dentry)
339 return capable(CAP_SYS_ADMIN);
342 static const struct xattr_handler bch_xattr_trusted_handler = {
343 .prefix = XATTR_TRUSTED_PREFIX,
344 .list = bch2_xattr_trusted_list,
345 .get = bch2_xattr_get_handler,
346 .set = bch2_xattr_set_handler,
347 .flags = BCH_XATTR_INDEX_TRUSTED,
350 static const struct xattr_handler bch_xattr_security_handler = {
351 .prefix = XATTR_SECURITY_PREFIX,
352 .get = bch2_xattr_get_handler,
353 .set = bch2_xattr_set_handler,
354 .flags = BCH_XATTR_INDEX_SECURITY,
357 #ifndef NO_BCACHEFS_FS
359 static int bch2_xattr_bcachefs_get(const struct xattr_handler *handler,
360 struct dentry *dentry, struct inode *vinode,
361 const char *name, void *buffer, size_t size)
363 struct bch_inode_info *inode = to_bch_ei(vinode);
364 struct bch_fs *c = inode->v.i_sb->s_fs_info;
365 struct bch_opts opts =
366 bch2_inode_opts_to_opts(bch2_inode_opts_get(&inode->ei_inode));
367 const struct bch_option *opt;
371 id = bch2_opt_lookup(name);
372 if (id < 0 || !bch2_opt_is_inode_opt(id))
375 opt = bch2_opt_table + id;
377 if (!bch2_opt_defined_by_id(&opts, id))
380 v = bch2_opt_get_by_id(&opts, id);
382 ret = bch2_opt_to_text(c, buffer, size, opt, v, 0);
384 return ret < size || !buffer ? ret : -ERANGE;
387 struct inode_opt_set {
393 static int inode_opt_set_fn(struct bch_inode_info *inode,
394 struct bch_inode_unpacked *bi,
397 struct inode_opt_set *s = p;
400 bch2_inode_opt_set(bi, s->id, s->v);
402 bch2_inode_opt_clear(bi, s->id);
406 static int bch2_xattr_bcachefs_set(const struct xattr_handler *handler,
407 struct dentry *dentry, struct inode *vinode,
408 const char *name, const void *value,
409 size_t size, int flags)
411 struct bch_inode_info *inode = to_bch_ei(vinode);
412 struct bch_fs *c = inode->v.i_sb->s_fs_info;
413 const struct bch_option *opt;
415 struct inode_opt_set s;
418 s.id = bch2_opt_lookup(name);
419 if (s.id < 0 || !bch2_opt_is_inode_opt(s.id))
422 opt = bch2_opt_table + s.id;
425 buf = kmalloc(size + 1, GFP_KERNEL);
428 memcpy(buf, value, size);
431 ret = bch2_opt_parse(c, opt, buf, &s.v);
437 if (s.id == Opt_compression ||
438 s.id == Opt_background_compression) {
439 ret = bch2_check_set_has_compressed_data(c, s.v);
449 mutex_lock(&inode->ei_update_lock);
450 ret = __bch2_write_inode(c, inode, inode_opt_set_fn, &s);
451 mutex_unlock(&inode->ei_update_lock);
454 (s.id == Opt_background_compression ||
455 s.id == Opt_background_target))
456 bch2_rebalance_add_work(c, inode->v.i_blocks);
461 static const struct xattr_handler bch_xattr_bcachefs_handler = {
462 .prefix = "bcachefs.",
463 .get = bch2_xattr_bcachefs_get,
464 .set = bch2_xattr_bcachefs_set,
467 #endif /* NO_BCACHEFS_FS */
469 const struct xattr_handler *bch2_xattr_handlers[] = {
470 &bch_xattr_user_handler,
471 &posix_acl_access_xattr_handler,
472 &posix_acl_default_xattr_handler,
473 &bch_xattr_trusted_handler,
474 &bch_xattr_security_handler,
475 #ifndef NO_BCACHEFS_FS
476 &bch_xattr_bcachefs_handler,
481 static const struct xattr_handler *bch_xattr_handler_map[] = {
482 [BCH_XATTR_INDEX_USER] = &bch_xattr_user_handler,
483 [BCH_XATTR_INDEX_POSIX_ACL_ACCESS] =
484 &posix_acl_access_xattr_handler,
485 [BCH_XATTR_INDEX_POSIX_ACL_DEFAULT] =
486 &posix_acl_default_xattr_handler,
487 [BCH_XATTR_INDEX_TRUSTED] = &bch_xattr_trusted_handler,
488 [BCH_XATTR_INDEX_SECURITY] = &bch_xattr_security_handler,
491 static const struct xattr_handler *bch2_xattr_type_to_handler(unsigned type)
493 return type < ARRAY_SIZE(bch_xattr_handler_map)
494 ? bch_xattr_handler_map[type]