git.sesse.net Git - bcachefs-tools-debian/blob - c_src/libbcachefs/acl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "bcachefs.h"
   4
   5 #include "acl.h"
   6 #include "xattr.h"
   7
   8 #include <linux/posix_acl.h>
   9
  10 static const char * const acl_types[] = {
  11         [ACL_USER_OBJ]  = "user_obj",
  12         [ACL_USER]      = "user",
  13         [ACL_GROUP_OBJ] = "group_obj",
  14         [ACL_GROUP]     = "group",
  15         [ACL_MASK]      = "mask",
  16         [ACL_OTHER]     = "other",
  17         NULL,
  18 };
  19
  20 void bch2_acl_to_text(struct printbuf *out, const void *value, size_t size)
  21 {
  22         const void *p, *end = value + size;
  23
  24         if (!value ||
  25             size < sizeof(bch_acl_header) ||
  26             ((bch_acl_header *)value)->a_version != cpu_to_le32(BCH_ACL_VERSION))
  27                 return;
  28
  29         p = value + sizeof(bch_acl_header);
  30         while (p < end) {
  31                 const bch_acl_entry *in = p;
  32                 unsigned tag = le16_to_cpu(in->e_tag);
  33
  34                 prt_str(out, acl_types[tag]);
  35
  36                 switch (tag) {
  37                 case ACL_USER_OBJ:
  38                 case ACL_GROUP_OBJ:
  39                 case ACL_MASK:
  40                 case ACL_OTHER:
  41                         p += sizeof(bch_acl_entry_short);
  42                         break;
  43                 case ACL_USER:
  44                         prt_printf(out, " uid %u", le32_to_cpu(in->e_id));
  45                         p += sizeof(bch_acl_entry);
  46                         break;
  47                 case ACL_GROUP:
  48                         prt_printf(out, " gid %u", le32_to_cpu(in->e_id));
  49                         p += sizeof(bch_acl_entry);
  50                         break;
  51                 }
  52
  53                 prt_printf(out, " %o", le16_to_cpu(in->e_perm));
  54
  55                 if (p != end)
  56                         prt_char(out, ' ');
  57         }
  58 }
  59
  60 #ifdef CONFIG_BCACHEFS_POSIX_ACL
  61
  62 #include "fs.h"
  63
  64 #include <linux/fs.h>
  65 #include <linux/posix_acl_xattr.h>
  66 #include <linux/sched.h>
  67 #include <linux/slab.h>
  68
  69 static inline size_t bch2_acl_size(unsigned nr_short, unsigned nr_long)
  70 {
  71         return sizeof(bch_acl_header) +
  72                 sizeof(bch_acl_entry_short) * nr_short +
  73                 sizeof(bch_acl_entry) * nr_long;
  74 }
  75
  76 static inline int acl_to_xattr_type(int type)
  77 {
  78         switch (type) {
  79         case ACL_TYPE_ACCESS:
  80                 return KEY_TYPE_XATTR_INDEX_POSIX_ACL_ACCESS;
  81         case ACL_TYPE_DEFAULT:
  82                 return KEY_TYPE_XATTR_INDEX_POSIX_ACL_DEFAULT;
  83         default:
  84                 BUG();
  85         }
  86 }
  87
  88 /*
  89  * Convert from filesystem to in-memory representation.
  90  */
  91 static struct posix_acl *bch2_acl_from_disk(struct btree_trans *trans,
  92                                             const void *value, size_t size)
  93 {
  94         const void *p, *end = value + size;
  95         struct posix_acl *acl;
  96         struct posix_acl_entry *out;
  97         unsigned count = 0;
  98         int ret;
  99
 100         if (!value)
 101                 return NULL;
 102         if (size < sizeof(bch_acl_header))
 103                 goto invalid;
 104         if (((bch_acl_header *)value)->a_version !=
 105             cpu_to_le32(BCH_ACL_VERSION))
 106                 goto invalid;
 107
 108         p = value + sizeof(bch_acl_header);
 109         while (p < end) {
 110                 const bch_acl_entry *entry = p;
 111
 112                 if (p + sizeof(bch_acl_entry_short) > end)
 113                         goto invalid;
 114
 115                 switch (le16_to_cpu(entry->e_tag)) {
 116                 case ACL_USER_OBJ:
 117                 case ACL_GROUP_OBJ:
 118                 case ACL_MASK:
 119                 case ACL_OTHER:
 120                         p += sizeof(bch_acl_entry_short);
 121                         break;
 122                 case ACL_USER:
 123                 case ACL_GROUP:
 124                         p += sizeof(bch_acl_entry);
 125                         break;
 126                 default:
 127                         goto invalid;
 128                 }
 129
 130                 count++;
 131         }
 132
 133         if (p > end)
 134                 goto invalid;
 135
 136         if (!count)
 137                 return NULL;
 138
 139         acl = allocate_dropping_locks(trans, ret,
 140                         posix_acl_alloc(count, _gfp));
 141         if (!acl)
 142                 return ERR_PTR(-ENOMEM);
 143         if (ret) {
 144                 kfree(acl);
 145                 return ERR_PTR(ret);
 146         }
 147
 148         out = acl->a_entries;
 149
 150         p = value + sizeof(bch_acl_header);
 151         while (p < end) {
 152                 const bch_acl_entry *in = p;
 153
 154                 out->e_tag  = le16_to_cpu(in->e_tag);
 155                 out->e_perm = le16_to_cpu(in->e_perm);
 156
 157                 switch (out->e_tag) {
 158                 case ACL_USER_OBJ:
 159                 case ACL_GROUP_OBJ:
 160                 case ACL_MASK:
 161                 case ACL_OTHER:
 162                         p += sizeof(bch_acl_entry_short);
 163                         break;
 164                 case ACL_USER:
 165                         out->e_uid = make_kuid(&init_user_ns,
 166                                                le32_to_cpu(in->e_id));
 167                         p += sizeof(bch_acl_entry);
 168                         break;
 169                 case ACL_GROUP:
 170                         out->e_gid = make_kgid(&init_user_ns,
 171                                                le32_to_cpu(in->e_id));
 172                         p += sizeof(bch_acl_entry);
 173                         break;
 174                 }
 175
 176                 out++;
 177         }
 178
 179         BUG_ON(out != acl->a_entries + acl->a_count);
 180
 181         return acl;
 182 invalid:
 183         pr_err("invalid acl entry");
 184         return ERR_PTR(-EINVAL);
 185 }
 186
 187 #define acl_for_each_entry(acl, acl_e)                  \
 188         for (acl_e = acl->a_entries;                    \
 189              acl_e < acl->a_entries + acl->a_count;     \
 190              acl_e++)
 191
 192 /*
 193  * Convert from in-memory to filesystem representation.
 194  */
 195 static struct bkey_i_xattr *
 196 bch2_acl_to_xattr(struct btree_trans *trans,
 197                   const struct posix_acl *acl,
 198                   int type)
 199 {
 200         struct bkey_i_xattr *xattr;
 201         bch_acl_header *acl_header;
 202         const struct posix_acl_entry *acl_e;
 203         void *outptr;
 204         unsigned nr_short = 0, nr_long = 0, acl_len, u64s;
 205
 206         acl_for_each_entry(acl, acl_e) {
 207                 switch (acl_e->e_tag) {
 208                 case ACL_USER:
 209                 case ACL_GROUP:
 210                         nr_long++;
 211                         break;
 212                 case ACL_USER_OBJ:
 213                 case ACL_GROUP_OBJ:
 214                 case ACL_MASK:
 215                 case ACL_OTHER:
 216                         nr_short++;
 217                         break;
 218                 default:
 219                         return ERR_PTR(-EINVAL);
 220                 }
 221         }
 222
 223         acl_len = bch2_acl_size(nr_short, nr_long);
 224         u64s = BKEY_U64s + xattr_val_u64s(0, acl_len);
 225
 226         if (u64s > U8_MAX)
 227                 return ERR_PTR(-E2BIG);
 228
 229         xattr = bch2_trans_kmalloc(trans, u64s * sizeof(u64));
 230         if (IS_ERR(xattr))
 231                 return xattr;
 232
 233         bkey_xattr_init(&xattr->k_i);
 234         xattr->k.u64s           = u64s;
 235         xattr->v.x_type         = acl_to_xattr_type(type);
 236         xattr->v.x_name_len     = 0;
 237         xattr->v.x_val_len      = cpu_to_le16(acl_len);
 238
 239         acl_header = xattr_val(&xattr->v);
 240         acl_header->a_version = cpu_to_le32(BCH_ACL_VERSION);
 241
 242         outptr = (void *) acl_header + sizeof(*acl_header);
 243
 244         acl_for_each_entry(acl, acl_e) {
 245                 bch_acl_entry *entry = outptr;
 246
 247                 entry->e_tag = cpu_to_le16(acl_e->e_tag);
 248                 entry->e_perm = cpu_to_le16(acl_e->e_perm);
 249                 switch (acl_e->e_tag) {
 250                 case ACL_USER:
 251                         entry->e_id = cpu_to_le32(
 252                                 from_kuid(&init_user_ns, acl_e->e_uid));
 253                         outptr += sizeof(bch_acl_entry);
 254                         break;
 255                 case ACL_GROUP:
 256                         entry->e_id = cpu_to_le32(
 257                                 from_kgid(&init_user_ns, acl_e->e_gid));
 258                         outptr += sizeof(bch_acl_entry);
 259                         break;
 260
 261                 case ACL_USER_OBJ:
 262                 case ACL_GROUP_OBJ:
 263                 case ACL_MASK:
 264                 case ACL_OTHER:
 265                         outptr += sizeof(bch_acl_entry_short);
 266                         break;
 267                 }
 268         }
 269
 270         BUG_ON(outptr != xattr_val(&xattr->v) + acl_len);
 271
 272         return xattr;
 273 }
 274
 275 struct posix_acl *bch2_get_acl(struct mnt_idmap *idmap,
 276                                struct dentry *dentry, int type)
 277 {
 278         struct bch_inode_info *inode = to_bch_ei(dentry->d_inode);
 279         struct bch_fs *c = inode->v.i_sb->s_fs_info;
 280         struct bch_hash_info hash = bch2_hash_info_init(c, &inode->ei_inode);
 281         struct xattr_search_key search = X_SEARCH(acl_to_xattr_type(type), "", 0);
 282         struct btree_trans *trans = bch2_trans_get(c);
 283         struct btree_iter iter = { NULL };
 284         struct bkey_s_c_xattr xattr;
 285         struct posix_acl *acl = NULL;
 286         struct bkey_s_c k;
 287         int ret;
 288 retry:
 289         bch2_trans_begin(trans);
 290
 291         ret = bch2_hash_lookup(trans, &iter, bch2_xattr_hash_desc,
 292                         &hash, inode_inum(inode), &search, 0);
 293         if (ret) {
 294                 if (!bch2_err_matches(ret, ENOENT))
 295                         acl = ERR_PTR(ret);
 296                 goto out;
 297         }
 298
 299         k = bch2_btree_iter_peek_slot(&iter);
 300         ret = bkey_err(k);
 301         if (ret) {
 302                 acl = ERR_PTR(ret);
 303                 goto out;
 304         }
 305
 306         xattr = bkey_s_c_to_xattr(k);
 307         acl = bch2_acl_from_disk(trans, xattr_val(xattr.v),
 308                         le16_to_cpu(xattr.v->x_val_len));
 309
 310         if (!IS_ERR(acl))
 311                 set_cached_acl(&inode->v, type, acl);
 312 out:
 313         if (bch2_err_matches(PTR_ERR_OR_ZERO(acl), BCH_ERR_transaction_restart))
 314                 goto retry;
 315
 316         bch2_trans_iter_exit(trans, &iter);
 317         bch2_trans_put(trans);
 318         return acl;
 319 }
 320
 321 int bch2_set_acl_trans(struct btree_trans *trans, subvol_inum inum,
 322                        struct bch_inode_unpacked *inode_u,
 323                        struct posix_acl *acl, int type)
 324 {
 325         struct bch_hash_info hash_info = bch2_hash_info_init(trans->c, inode_u);
 326         int ret;
 327
 328         if (type == ACL_TYPE_DEFAULT &&
 329             !S_ISDIR(inode_u->bi_mode))
 330                 return acl ? -EACCES : 0;
 331
 332         if (acl) {
 333                 struct bkey_i_xattr *xattr =
 334                         bch2_acl_to_xattr(trans, acl, type);
 335                 if (IS_ERR(xattr))
 336                         return PTR_ERR(xattr);
 337
 338                 ret = bch2_hash_set(trans, bch2_xattr_hash_desc, &hash_info,
 339                                     inum, &xattr->k_i, 0);
 340         } else {
 341                 struct xattr_search_key search =
 342                         X_SEARCH(acl_to_xattr_type(type), "", 0);
 343
 344                 ret = bch2_hash_delete(trans, bch2_xattr_hash_desc, &hash_info,
 345                                        inum, &search);
 346         }
 347
 348         return bch2_err_matches(ret, ENOENT) ? 0 : ret;
 349 }
 350
 351 int bch2_set_acl(struct mnt_idmap *idmap,
 352                  struct dentry *dentry,
 353                  struct posix_acl *_acl, int type)
 354 {
 355         struct bch_inode_info *inode = to_bch_ei(dentry->d_inode);
 356         struct bch_fs *c = inode->v.i_sb->s_fs_info;
 357         struct btree_trans *trans = bch2_trans_get(c);
 358         struct btree_iter inode_iter = { NULL };
 359         struct bch_inode_unpacked inode_u;
 360         struct posix_acl *acl;
 361         umode_t mode;
 362         int ret;
 363
 364         mutex_lock(&inode->ei_update_lock);
 365 retry:
 366         bch2_trans_begin(trans);
 367         acl = _acl;
 368
 369         ret   = bch2_subvol_is_ro_trans(trans, inode->ei_subvol) ?:
 370                 bch2_inode_peek(trans, &inode_iter, &inode_u, inode_inum(inode),
 371                               BTREE_ITER_INTENT);
 372         if (ret)
 373                 goto btree_err;
 374
 375         mode = inode_u.bi_mode;
 376
 377         if (type == ACL_TYPE_ACCESS) {
 378                 ret = posix_acl_update_mode(idmap, &inode->v, &mode, &acl);
 379                 if (ret)
 380                         goto btree_err;
 381         }
 382
 383         ret = bch2_set_acl_trans(trans, inode_inum(inode), &inode_u, acl, type);
 384         if (ret)
 385                 goto btree_err;
 386
 387         inode_u.bi_ctime        = bch2_current_time(c);
 388         inode_u.bi_mode         = mode;
 389
 390         ret =   bch2_inode_write(trans, &inode_iter, &inode_u) ?:
 391                 bch2_trans_commit(trans, NULL, NULL, 0);
 392 btree_err:
 393         bch2_trans_iter_exit(trans, &inode_iter);
 394
 395         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 396                 goto retry;
 397         if (unlikely(ret))
 398                 goto err;
 399
 400         bch2_inode_update_after_write(trans, inode, &inode_u,
 401                                       ATTR_CTIME|ATTR_MODE);
 402
 403         set_cached_acl(&inode->v, type, acl);
 404 err:
 405         mutex_unlock(&inode->ei_update_lock);
 406         bch2_trans_put(trans);
 407
 408         return ret;
 409 }
 410
 411 int bch2_acl_chmod(struct btree_trans *trans, subvol_inum inum,
 412                    struct bch_inode_unpacked *inode,
 413                    umode_t mode,
 414                    struct posix_acl **new_acl)
 415 {
 416         struct bch_hash_info hash_info = bch2_hash_info_init(trans->c, inode);
 417         struct xattr_search_key search = X_SEARCH(KEY_TYPE_XATTR_INDEX_POSIX_ACL_ACCESS, "", 0);
 418         struct btree_iter iter;
 419         struct bkey_s_c_xattr xattr;
 420         struct bkey_i_xattr *new;
 421         struct posix_acl *acl = NULL;
 422         struct bkey_s_c k;
 423         int ret;
 424
 425         ret = bch2_hash_lookup(trans, &iter, bch2_xattr_hash_desc,
 426                                &hash_info, inum, &search, BTREE_ITER_INTENT);
 427         if (ret)
 428                 return bch2_err_matches(ret, ENOENT) ? 0 : ret;
 429
 430         k = bch2_btree_iter_peek_slot(&iter);
 431         ret = bkey_err(k);
 432         if (ret)
 433                 goto err;
 434         xattr = bkey_s_c_to_xattr(k);
 435
 436         acl = bch2_acl_from_disk(trans, xattr_val(xattr.v),
 437                         le16_to_cpu(xattr.v->x_val_len));
 438         ret = PTR_ERR_OR_ZERO(acl);
 439         if (IS_ERR_OR_NULL(acl))
 440                 goto err;
 441
 442         ret = allocate_dropping_locks_errcode(trans,
 443                                 __posix_acl_chmod(&acl, _gfp, mode));
 444         if (ret)
 445                 goto err;
 446
 447         new = bch2_acl_to_xattr(trans, acl, ACL_TYPE_ACCESS);
 448         if (IS_ERR(new)) {
 449                 ret = PTR_ERR(new);
 450                 goto err;
 451         }
 452
 453         new->k.p = iter.pos;
 454         ret = bch2_trans_update(trans, &iter, &new->k_i, 0);
 455         *new_acl = acl;
 456         acl = NULL;
 457 err:
 458         bch2_trans_iter_exit(trans, &iter);
 459         if (!IS_ERR_OR_NULL(acl))
 460                 kfree(acl);
 461         return ret;
 462 }
 463
 464 #endif /* CONFIG_BCACHEFS_POSIX_ACL */