fs/bcachefs/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 /*
 188  * Convert from in-memory to filesystem representation.
 189  */
 190 static struct bkey_i_xattr *
 191 bch2_acl_to_xattr(struct btree_trans *trans,
 192                   const struct posix_acl *acl,
 193                   int type)
 194 {
 195         struct bkey_i_xattr *xattr;
 196         bch_acl_header *acl_header;
 197         const struct posix_acl_entry *acl_e, *pe;
 198         void *outptr;
 199         unsigned nr_short = 0, nr_long = 0, acl_len, u64s;
 200
 201         FOREACH_ACL_ENTRY(acl_e, acl, pe) {
 202                 switch (acl_e->e_tag) {
 203                 case ACL_USER:
 204                 case ACL_GROUP:
 205                         nr_long++;
 206                         break;
 207                 case ACL_USER_OBJ:
 208                 case ACL_GROUP_OBJ:
 209                 case ACL_MASK:
 210                 case ACL_OTHER:
 211                         nr_short++;
 212                         break;
 213                 default:
 214                         return ERR_PTR(-EINVAL);
 215                 }
 216         }
 217
 218         acl_len = bch2_acl_size(nr_short, nr_long);
 219         u64s = BKEY_U64s + xattr_val_u64s(0, acl_len);
 220
 221         if (u64s > U8_MAX)
 222                 return ERR_PTR(-E2BIG);
 223
 224         xattr = bch2_trans_kmalloc(trans, u64s * sizeof(u64));
 225         if (IS_ERR(xattr))
 226                 return xattr;
 227
 228         bkey_xattr_init(&xattr->k_i);
 229         xattr->k.u64s           = u64s;
 230         xattr->v.x_type         = acl_to_xattr_type(type);
 231         xattr->v.x_name_len     = 0;
 232         xattr->v.x_val_len      = cpu_to_le16(acl_len);
 233
 234         acl_header = xattr_val(&xattr->v);
 235         acl_header->a_version = cpu_to_le32(BCH_ACL_VERSION);
 236
 237         outptr = (void *) acl_header + sizeof(*acl_header);
 238
 239         FOREACH_ACL_ENTRY(acl_e, acl, pe) {
 240                 bch_acl_entry *entry = outptr;
 241
 242                 entry->e_tag = cpu_to_le16(acl_e->e_tag);
 243                 entry->e_perm = cpu_to_le16(acl_e->e_perm);
 244                 switch (acl_e->e_tag) {
 245                 case ACL_USER:
 246                         entry->e_id = cpu_to_le32(
 247                                 from_kuid(&init_user_ns, acl_e->e_uid));
 248                         outptr += sizeof(bch_acl_entry);
 249                         break;
 250                 case ACL_GROUP:
 251                         entry->e_id = cpu_to_le32(
 252                                 from_kgid(&init_user_ns, acl_e->e_gid));
 253                         outptr += sizeof(bch_acl_entry);
 254                         break;
 255
 256                 case ACL_USER_OBJ:
 257                 case ACL_GROUP_OBJ:
 258                 case ACL_MASK:
 259                 case ACL_OTHER:
 260                         outptr += sizeof(bch_acl_entry_short);
 261                         break;
 262                 }
 263         }
 264
 265         BUG_ON(outptr != xattr_val(&xattr->v) + acl_len);
 266
 267         return xattr;
 268 }
 269
 270 struct posix_acl *bch2_get_acl(struct inode *vinode, int type, bool rcu)
 271 {
 272         struct bch_inode_info *inode = to_bch_ei(vinode);
 273         struct bch_fs *c = inode->v.i_sb->s_fs_info;
 274         struct bch_hash_info hash = bch2_hash_info_init(c, &inode->ei_inode);
 275         struct xattr_search_key search = X_SEARCH(acl_to_xattr_type(type), "", 0);
 276         struct btree_iter iter = { NULL };
 277         struct posix_acl *acl = NULL;
 278
 279         if (rcu)
 280                 return ERR_PTR(-ECHILD);
 281
 282         struct btree_trans *trans = bch2_trans_get(c);
 283 retry:
 284         bch2_trans_begin(trans);
 285
 286         struct bkey_s_c k = bch2_hash_lookup(trans, &iter, bch2_xattr_hash_desc,
 287                                              &hash, inode_inum(inode), &search, 0);
 288         int ret = bkey_err(k);
 289         if (ret)
 290                 goto err;
 291
 292         struct bkey_s_c_xattr xattr = bkey_s_c_to_xattr(k);
 293         acl = bch2_acl_from_disk(trans, xattr_val(xattr.v),
 294                                  le16_to_cpu(xattr.v->x_val_len));
 295         ret = PTR_ERR_OR_ZERO(acl);
 296 err:
 297         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 298                 goto retry;
 299
 300         if (ret)
 301                 acl = !bch2_err_matches(ret, ENOENT) ? ERR_PTR(ret) : NULL;
 302
 303         if (!IS_ERR_OR_NULL(acl))
 304                 set_cached_acl(&inode->v, type, acl);
 305
 306         bch2_trans_iter_exit(trans, &iter);
 307         bch2_trans_put(trans);
 308         return acl;
 309 }
 310
 311 int bch2_set_acl_trans(struct btree_trans *trans, subvol_inum inum,
 312                        struct bch_inode_unpacked *inode_u,
 313                        struct posix_acl *acl, int type)
 314 {
 315         struct bch_hash_info hash_info = bch2_hash_info_init(trans->c, inode_u);
 316         int ret;
 317
 318         if (type == ACL_TYPE_DEFAULT &&
 319             !S_ISDIR(inode_u->bi_mode))
 320                 return acl ? -EACCES : 0;
 321
 322         if (acl) {
 323                 struct bkey_i_xattr *xattr =
 324                         bch2_acl_to_xattr(trans, acl, type);
 325                 if (IS_ERR(xattr))
 326                         return PTR_ERR(xattr);
 327
 328                 ret = bch2_hash_set(trans, bch2_xattr_hash_desc, &hash_info,
 329                                     inum, &xattr->k_i, 0);
 330         } else {
 331                 struct xattr_search_key search =
 332                         X_SEARCH(acl_to_xattr_type(type), "", 0);
 333
 334                 ret = bch2_hash_delete(trans, bch2_xattr_hash_desc, &hash_info,
 335                                        inum, &search);
 336         }
 337
 338         return bch2_err_matches(ret, ENOENT) ? 0 : ret;
 339 }
 340
 341 int bch2_set_acl(struct mnt_idmap *idmap,
 342                  struct dentry *dentry,
 343                  struct posix_acl *_acl, int type)
 344 {
 345         struct bch_inode_info *inode = to_bch_ei(dentry->d_inode);
 346         struct bch_fs *c = inode->v.i_sb->s_fs_info;
 347         struct btree_iter inode_iter = { NULL };
 348         struct bch_inode_unpacked inode_u;
 349         struct posix_acl *acl;
 350         umode_t mode;
 351         int ret;
 352
 353         mutex_lock(&inode->ei_update_lock);
 354         struct btree_trans *trans = bch2_trans_get(c);
 355 retry:
 356         bch2_trans_begin(trans);
 357         acl = _acl;
 358
 359         ret   = bch2_subvol_is_ro_trans(trans, inode->ei_inum.subvol) ?:
 360                 bch2_inode_peek(trans, &inode_iter, &inode_u, inode_inum(inode),
 361                               BTREE_ITER_intent);
 362         if (ret)
 363                 goto btree_err;
 364
 365         mode = inode_u.bi_mode;
 366
 367         if (type == ACL_TYPE_ACCESS) {
 368                 ret = posix_acl_update_mode(idmap, &inode->v, &mode, &acl);
 369                 if (ret)
 370                         goto btree_err;
 371         }
 372
 373         ret = bch2_set_acl_trans(trans, inode_inum(inode), &inode_u, acl, type);
 374         if (ret)
 375                 goto btree_err;
 376
 377         inode_u.bi_ctime        = bch2_current_time(c);
 378         inode_u.bi_mode         = mode;
 379
 380         ret =   bch2_inode_write(trans, &inode_iter, &inode_u) ?:
 381                 bch2_trans_commit(trans, NULL, NULL, 0);
 382 btree_err:
 383         bch2_trans_iter_exit(trans, &inode_iter);
 384
 385         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 386                 goto retry;
 387         if (unlikely(ret))
 388                 goto err;
 389
 390         bch2_inode_update_after_write(trans, inode, &inode_u,
 391                                       ATTR_CTIME|ATTR_MODE);
 392
 393         set_cached_acl(&inode->v, type, acl);
 394 err:
 395         bch2_trans_put(trans);
 396         mutex_unlock(&inode->ei_update_lock);
 397
 398         return ret;
 399 }
 400
 401 int bch2_acl_chmod(struct btree_trans *trans, subvol_inum inum,
 402                    struct bch_inode_unpacked *inode,
 403                    umode_t mode,
 404                    struct posix_acl **new_acl)
 405 {
 406         struct bch_hash_info hash_info = bch2_hash_info_init(trans->c, inode);
 407         struct xattr_search_key search = X_SEARCH(KEY_TYPE_XATTR_INDEX_POSIX_ACL_ACCESS, "", 0);
 408         struct btree_iter iter;
 409         struct posix_acl *acl = NULL;
 410
 411         struct bkey_s_c k = bch2_hash_lookup(trans, &iter, bch2_xattr_hash_desc,
 412                                &hash_info, inum, &search, BTREE_ITER_intent);
 413         int ret = bkey_err(k);
 414         if (ret)
 415                 return bch2_err_matches(ret, ENOENT) ? 0 : ret;
 416
 417         struct bkey_s_c_xattr xattr = bkey_s_c_to_xattr(k);
 418
 419         acl = bch2_acl_from_disk(trans, xattr_val(xattr.v),
 420                         le16_to_cpu(xattr.v->x_val_len));
 421         ret = PTR_ERR_OR_ZERO(acl);
 422         if (ret)
 423                 goto err;
 424
 425         ret = allocate_dropping_locks_errcode(trans, __posix_acl_chmod(&acl, _gfp, mode));
 426         if (ret)
 427                 goto err;
 428
 429         struct bkey_i_xattr *new = bch2_acl_to_xattr(trans, acl, ACL_TYPE_ACCESS);
 430         ret = PTR_ERR_OR_ZERO(new);
 431         if (ret)
 432                 goto err;
 433
 434         new->k.p = iter.pos;
 435         ret = bch2_trans_update(trans, &iter, &new->k_i, 0);
 436         *new_acl = acl;
 437         acl = NULL;
 438 err:
 439         bch2_trans_iter_exit(trans, &iter);
 440         if (!IS_ERR_OR_NULL(acl))
 441                 kfree(acl);
 442         return ret;
 443 }
 444
 445 #endif /* CONFIG_BCACHEFS_POSIX_ACL */