fs/btrfs/props.c

   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 char *value, size_t len);
  21         int (*apply)(struct inode *inode, const char *value, size_t len);
  22         const char *(*extract)(struct inode *inode);
  23         int inheritable;
  24 };
  25
  26 static const struct hlist_head *find_prop_handlers_by_hash(const u64 hash)
  27 {
  28         struct hlist_head *h;
  29
  30         h = &prop_handlers_ht[hash_min(hash, BTRFS_PROP_HANDLERS_HT_BITS)];
  31         if (hlist_empty(h))
  32                 return NULL;
  33
  34         return h;
  35 }
  36
  37 static const struct prop_handler *
  38 find_prop_handler(const char *name,
  39                   const struct hlist_head *handlers)
  40 {
  41         struct prop_handler *h;
  42
  43         if (!handlers) {
  44                 u64 hash = btrfs_name_hash(name, strlen(name));
  45
  46                 handlers = find_prop_handlers_by_hash(hash);
  47                 if (!handlers)
  48                         return NULL;
  49         }
  50
  51         hlist_for_each_entry(h, handlers, node)
  52                 if (!strcmp(h->xattr_name, name))
  53                         return h;
  54
  55         return NULL;
  56 }
  57
  58 static int btrfs_set_prop(struct btrfs_trans_handle *trans, struct inode *inode,
  59                           const char *name, const char *value, size_t value_len,
  60                           int flags)
  61 {
  62         const struct prop_handler *handler;
  63         int ret;
  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                 ret = btrfs_setxattr(trans, inode, handler->xattr_name,
  74                                        NULL, 0, flags);
  75                 if (ret)
  76                         return ret;
  77
  78                 ret = handler->apply(inode, NULL, 0);
  79                 ASSERT(ret == 0);
  80
  81                 return ret;
  82         }
  83
  84         ret = handler->validate(value, value_len);
  85         if (ret)
  86                 return ret;
  87         ret = btrfs_setxattr(trans, inode, handler->xattr_name,
  88                                value, value_len, flags);
  89         if (ret)
  90                 return ret;
  91         ret = handler->apply(inode, value, value_len);
  92         if (ret) {
  93                 btrfs_setxattr(trans, inode, handler->xattr_name,
  94                                  NULL, 0, flags);
  95                 return ret;
  96         }
  97
  98         set_bit(BTRFS_INODE_HAS_PROPS, &BTRFS_I(inode)->runtime_flags);
  99
 100         return 0;
 101 }
 102
 103 int btrfs_set_prop_trans(struct inode *inode, const char *name,
 104                          const char *value, size_t value_len, int flags)
 105 {
 106         return btrfs_set_prop(NULL, inode, name, value, value_len, flags);
 107 }
 108
 109 static int iterate_object_props(struct btrfs_root *root,
 110                                 struct btrfs_path *path,
 111                                 u64 objectid,
 112                                 void (*iterator)(void *,
 113                                                  const struct prop_handler *,
 114                                                  const char *,
 115                                                  size_t),
 116                                 void *ctx)
 117 {
 118         int ret;
 119         char *name_buf = NULL;
 120         char *value_buf = NULL;
 121         int name_buf_len = 0;
 122         int value_buf_len = 0;
 123
 124         while (1) {
 125                 struct btrfs_key key;
 126                 struct btrfs_dir_item *di;
 127                 struct extent_buffer *leaf;
 128                 u32 total_len, cur, this_len;
 129                 int slot;
 130                 const struct hlist_head *handlers;
 131
 132                 slot = path->slots[0];
 133                 leaf = path->nodes[0];
 134
 135                 if (slot >= btrfs_header_nritems(leaf)) {
 136                         ret = btrfs_next_leaf(root, path);
 137                         if (ret < 0)
 138                                 goto out;
 139                         else if (ret > 0)
 140                                 break;
 141                         continue;
 142                 }
 143
 144                 btrfs_item_key_to_cpu(leaf, &key, slot);
 145                 if (key.objectid != objectid)
 146                         break;
 147                 if (key.type != BTRFS_XATTR_ITEM_KEY)
 148                         break;
 149
 150                 handlers = find_prop_handlers_by_hash(key.offset);
 151                 if (!handlers)
 152                         goto next_slot;
 153
 154                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
 155                 cur = 0;
 156                 total_len = btrfs_item_size_nr(leaf, slot);
 157
 158                 while (cur < total_len) {
 159                         u32 name_len = btrfs_dir_name_len(leaf, di);
 160                         u32 data_len = btrfs_dir_data_len(leaf, di);
 161                         unsigned long name_ptr, data_ptr;
 162                         const struct prop_handler *handler;
 163
 164                         this_len = sizeof(*di) + name_len + data_len;
 165                         name_ptr = (unsigned long)(di + 1);
 166                         data_ptr = name_ptr + name_len;
 167
 168                         if (name_len <= XATTR_BTRFS_PREFIX_LEN ||
 169                             memcmp_extent_buffer(leaf, XATTR_BTRFS_PREFIX,
 170                                                  name_ptr,
 171                                                  XATTR_BTRFS_PREFIX_LEN))
 172                                 goto next_dir_item;
 173
 174                         if (name_len >= name_buf_len) {
 175                                 kfree(name_buf);
 176                                 name_buf_len = name_len + 1;
 177                                 name_buf = kmalloc(name_buf_len, GFP_NOFS);
 178                                 if (!name_buf) {
 179                                         ret = -ENOMEM;
 180                                         goto out;
 181                                 }
 182                         }
 183                         read_extent_buffer(leaf, name_buf, name_ptr, name_len);
 184                         name_buf[name_len] = '\0';
 185
 186                         handler = find_prop_handler(name_buf, handlers);
 187                         if (!handler)
 188                                 goto next_dir_item;
 189
 190                         if (data_len > value_buf_len) {
 191                                 kfree(value_buf);
 192                                 value_buf_len = data_len;
 193                                 value_buf = kmalloc(data_len, GFP_NOFS);
 194                                 if (!value_buf) {
 195                                         ret = -ENOMEM;
 196                                         goto out;
 197                                 }
 198                         }
 199                         read_extent_buffer(leaf, value_buf, data_ptr, data_len);
 200
 201                         iterator(ctx, handler, value_buf, data_len);
 202 next_dir_item:
 203                         cur += this_len;
 204                         di = (struct btrfs_dir_item *)((char *) di + this_len);
 205                 }
 206
 207 next_slot:
 208                 path->slots[0]++;
 209         }
 210
 211         ret = 0;
 212 out:
 213         btrfs_release_path(path);
 214         kfree(name_buf);
 215         kfree(value_buf);
 216
 217         return ret;
 218 }
 219
 220 static void inode_prop_iterator(void *ctx,
 221                                 const struct prop_handler *handler,
 222                                 const char *value,
 223                                 size_t len)
 224 {
 225         struct inode *inode = ctx;
 226         struct btrfs_root *root = BTRFS_I(inode)->root;
 227         int ret;
 228
 229         ret = handler->apply(inode, value, len);
 230         if (unlikely(ret))
 231                 btrfs_warn(root->fs_info,
 232                            "error applying prop %s to ino %llu (root %llu): %d",
 233                            handler->xattr_name, btrfs_ino(BTRFS_I(inode)),
 234                            root->root_key.objectid, ret);
 235         else
 236                 set_bit(BTRFS_INODE_HAS_PROPS, &BTRFS_I(inode)->runtime_flags);
 237 }
 238
 239 int btrfs_load_inode_props(struct inode *inode, struct btrfs_path *path)
 240 {
 241         struct btrfs_root *root = BTRFS_I(inode)->root;
 242         u64 ino = btrfs_ino(BTRFS_I(inode));
 243         int ret;
 244
 245         ret = iterate_object_props(root, path, ino, inode_prop_iterator, inode);
 246
 247         return ret;
 248 }
 249
 250 static int prop_compression_validate(const char *value, size_t len)
 251 {
 252         if (!value)
 253                 return 0;
 254
 255         if (!strncmp("lzo", value, 3))
 256                 return 0;
 257         else if (!strncmp("zlib", value, 4))
 258                 return 0;
 259         else if (!strncmp("zstd", value, 4))
 260                 return 0;
 261
 262         return -EINVAL;
 263 }
 264
 265 static int prop_compression_apply(struct inode *inode, const char *value,
 266                                   size_t len)
 267 {
 268         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 269         int type;
 270
 271         if (len == 0) {
 272                 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
 273                 BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
 274                 BTRFS_I(inode)->prop_compress = BTRFS_COMPRESS_NONE;
 275
 276                 return 0;
 277         }
 278
 279         if (!strncmp("lzo", value, 3)) {
 280                 type = BTRFS_COMPRESS_LZO;
 281                 btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);
 282         } else if (!strncmp("zlib", value, 4)) {
 283                 type = BTRFS_COMPRESS_ZLIB;
 284         } else if (!strncmp("zstd", value, 4)) {
 285                 type = BTRFS_COMPRESS_ZSTD;
 286                 btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);
 287         } else {
 288                 return -EINVAL;
 289         }
 290
 291         BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
 292         BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
 293         BTRFS_I(inode)->prop_compress = type;
 294
 295         return 0;
 296 }
 297
 298 static const char *prop_compression_extract(struct inode *inode)
 299 {
 300         switch (BTRFS_I(inode)->prop_compress) {
 301         case BTRFS_COMPRESS_ZLIB:
 302         case BTRFS_COMPRESS_LZO:
 303         case BTRFS_COMPRESS_ZSTD:
 304                 return btrfs_compress_type2str(BTRFS_I(inode)->prop_compress);
 305         default:
 306                 break;
 307         }
 308
 309         return NULL;
 310 }
 311
 312 static struct prop_handler prop_handlers[] = {
 313         {
 314                 .xattr_name = XATTR_BTRFS_PREFIX "compression",
 315                 .validate = prop_compression_validate,
 316                 .apply = prop_compression_apply,
 317                 .extract = prop_compression_extract,
 318                 .inheritable = 1
 319         },
 320 };
 321
 322 static int inherit_props(struct btrfs_trans_handle *trans,
 323                          struct inode *inode,
 324                          struct inode *parent)
 325 {
 326         struct btrfs_root *root = BTRFS_I(inode)->root;
 327         struct btrfs_fs_info *fs_info = root->fs_info;
 328         int ret;
 329         int i;
 330
 331         if (!test_bit(BTRFS_INODE_HAS_PROPS,
 332                       &BTRFS_I(parent)->runtime_flags))
 333                 return 0;
 334
 335         for (i = 0; i < ARRAY_SIZE(prop_handlers); i++) {
 336                 const struct prop_handler *h = &prop_handlers[i];
 337                 const char *value;
 338                 u64 num_bytes;
 339
 340                 if (!h->inheritable)
 341                         continue;
 342
 343                 value = h->extract(parent);
 344                 if (!value)
 345                         continue;
 346
 347                 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
 348                 ret = btrfs_block_rsv_add(root, trans->block_rsv,
 349                                           num_bytes, BTRFS_RESERVE_NO_FLUSH);
 350                 if (ret)
 351                         goto out;
 352                 ret = btrfs_set_prop(trans, inode, h->xattr_name, value,
 353                                      strlen(value), 0);
 354                 btrfs_block_rsv_release(fs_info, trans->block_rsv, num_bytes);
 355                 if (ret)
 356                         goto out;
 357         }
 358         ret = 0;
 359 out:
 360         return ret;
 361 }
 362
 363 int btrfs_inode_inherit_props(struct btrfs_trans_handle *trans,
 364                               struct inode *inode,
 365                               struct inode *dir)
 366 {
 367         if (!dir)
 368                 return 0;
 369
 370         return inherit_props(trans, inode, dir);
 371 }
 372
 373 int btrfs_subvol_inherit_props(struct btrfs_trans_handle *trans,
 374                                struct btrfs_root *root,
 375                                struct btrfs_root *parent_root)
 376 {
 377         struct super_block *sb = root->fs_info->sb;
 378         struct btrfs_key key;
 379         struct inode *parent_inode, *child_inode;
 380         int ret;
 381
 382         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
 383         key.type = BTRFS_INODE_ITEM_KEY;
 384         key.offset = 0;
 385
 386         parent_inode = btrfs_iget(sb, &key, parent_root, NULL);
 387         if (IS_ERR(parent_inode))
 388                 return PTR_ERR(parent_inode);
 389
 390         child_inode = btrfs_iget(sb, &key, root, NULL);
 391         if (IS_ERR(child_inode)) {
 392                 iput(parent_inode);
 393                 return PTR_ERR(child_inode);
 394         }
 395
 396         ret = inherit_props(trans, child_inode, parent_inode);
 397         iput(child_inode);
 398         iput(parent_inode);
 399
 400         return ret;
 401 }
 402
 403 void __init btrfs_props_init(void)
 404 {
 405         int i;
 406
 407         hash_init(prop_handlers_ht);
 408
 409         for (i = 0; i < ARRAY_SIZE(prop_handlers); i++) {
 410                 struct prop_handler *p = &prop_handlers[i];
 411                 u64 h = btrfs_name_hash(p->xattr_name, strlen(p->xattr_name));
 412
 413                 hash_add(prop_handlers_ht, &p->node, h);
 414         }
 415 }
 416