1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2017-2018 HUAWEI, Inc. 4 * https://www.huawei.com/ 5 * Copyright (C) 2021-2022, Alibaba Cloud 6 */ 7 #include <linux/security.h> 8 #include "xattr.h" 9 10 struct erofs_xattr_iter { 11 struct super_block *sb; 12 struct erofs_buf buf; 13 erofs_off_t pos; 14 void *kaddr; 15 16 char *buffer; 17 int buffer_size, buffer_ofs; 18 19 /* getxattr */ 20 int index, infix_len; 21 struct qstr name; 22 23 /* listxattr */ 24 struct dentry *dentry; 25 }; 26 27 static int erofs_init_inode_xattrs(struct inode *inode) 28 { 29 struct erofs_inode *const vi = EROFS_I(inode); 30 struct erofs_xattr_iter it; 31 unsigned int i; 32 struct erofs_xattr_ibody_header *ih; 33 struct super_block *sb = inode->i_sb; 34 int ret = 0; 35 36 /* the most case is that xattrs of this inode are initialized. */ 37 if (test_bit(EROFS_I_EA_INITED_BIT, &vi->flags)) { 38 /* 39 * paired with smp_mb() at the end of the function to ensure 40 * fields will only be observed after the bit is set. 41 */ 42 smp_mb(); 43 return 0; 44 } 45 46 if (wait_on_bit_lock(&vi->flags, EROFS_I_BL_XATTR_BIT, TASK_KILLABLE)) 47 return -ERESTARTSYS; 48 49 /* someone has initialized xattrs for us? */ 50 if (test_bit(EROFS_I_EA_INITED_BIT, &vi->flags)) 51 goto out_unlock; 52 53 /* 54 * bypass all xattr operations if ->xattr_isize is not greater than 55 * sizeof(struct erofs_xattr_ibody_header), in detail: 56 * 1) it is not enough to contain erofs_xattr_ibody_header then 57 * ->xattr_isize should be 0 (it means no xattr); 58 * 2) it is just to contain erofs_xattr_ibody_header, which is on-disk 59 * undefined right now (maybe use later with some new sb feature). 60 */ 61 if (vi->xattr_isize == sizeof(struct erofs_xattr_ibody_header)) { 62 erofs_err(sb, 63 "xattr_isize %d of nid %llu is not supported yet", 64 vi->xattr_isize, vi->nid); 65 ret = -EOPNOTSUPP; 66 goto out_unlock; 67 } else if (vi->xattr_isize < sizeof(struct erofs_xattr_ibody_header)) { 68 if (vi->xattr_isize) { 69 erofs_err(sb, "bogus xattr ibody @ nid %llu", vi->nid); 70 DBG_BUGON(1); 71 ret = -EFSCORRUPTED; 72 goto out_unlock; /* xattr ondisk layout error */ 73 } 74 ret = -ENOATTR; 75 goto out_unlock; 76 } 77 78 it.buf = __EROFS_BUF_INITIALIZER; 79 erofs_init_metabuf(&it.buf, sb); 80 it.pos = erofs_iloc(inode) + vi->inode_isize; 81 82 /* read in shared xattr array (non-atomic, see kmalloc below) */ 83 it.kaddr = erofs_bread(&it.buf, erofs_blknr(sb, it.pos), EROFS_KMAP); 84 if (IS_ERR(it.kaddr)) { 85 ret = PTR_ERR(it.kaddr); 86 goto out_unlock; 87 } 88 89 ih = it.kaddr + erofs_blkoff(sb, it.pos); 90 vi->xattr_shared_count = ih->h_shared_count; 91 vi->xattr_shared_xattrs = kmalloc_array(vi->xattr_shared_count, 92 sizeof(uint), GFP_KERNEL); 93 if (!vi->xattr_shared_xattrs) { 94 erofs_put_metabuf(&it.buf); 95 ret = -ENOMEM; 96 goto out_unlock; 97 } 98 99 /* let's skip ibody header */ 100 it.pos += sizeof(struct erofs_xattr_ibody_header); 101 102 for (i = 0; i < vi->xattr_shared_count; ++i) { 103 it.kaddr = erofs_bread(&it.buf, erofs_blknr(sb, it.pos), 104 EROFS_KMAP); 105 if (IS_ERR(it.kaddr)) { 106 kfree(vi->xattr_shared_xattrs); 107 vi->xattr_shared_xattrs = NULL; 108 ret = PTR_ERR(it.kaddr); 109 goto out_unlock; 110 } 111 vi->xattr_shared_xattrs[i] = le32_to_cpu(*(__le32 *) 112 (it.kaddr + erofs_blkoff(sb, it.pos))); 113 it.pos += sizeof(__le32); 114 } 115 erofs_put_metabuf(&it.buf); 116 117 /* paired with smp_mb() at the beginning of the function. */ 118 smp_mb(); 119 set_bit(EROFS_I_EA_INITED_BIT, &vi->flags); 120 121 out_unlock: 122 clear_and_wake_up_bit(EROFS_I_BL_XATTR_BIT, &vi->flags); 123 return ret; 124 } 125 126 /* 127 * the general idea for these return values is 128 * if 0 is returned, go on processing the current xattr; 129 * 1 (> 0) is returned, skip this round to process the next xattr; 130 * -err (< 0) is returned, an error (maybe ENOXATTR) occurred 131 * and need to be handled 132 */ 133 struct xattr_iter_handlers { 134 int (*entry)(struct erofs_xattr_iter *it, struct erofs_xattr_entry *entry); 135 int (*name)(struct erofs_xattr_iter *it, unsigned int processed, char *buf, 136 unsigned int len); 137 int (*alloc_buffer)(struct erofs_xattr_iter *it, unsigned int value_sz); 138 void (*value)(struct erofs_xattr_iter *it, unsigned int processed, char *buf, 139 unsigned int len); 140 }; 141 142 static int inline_xattr_iter_begin(struct erofs_xattr_iter *it, 143 struct inode *inode) 144 { 145 struct erofs_inode *const vi = EROFS_I(inode); 146 unsigned int xattr_header_sz; 147 148 xattr_header_sz = sizeof(struct erofs_xattr_ibody_header) + 149 sizeof(u32) * vi->xattr_shared_count; 150 if (xattr_header_sz >= vi->xattr_isize) { 151 DBG_BUGON(xattr_header_sz > vi->xattr_isize); 152 return -ENOATTR; 153 } 154 155 it->pos = erofs_iloc(inode) + vi->inode_isize + xattr_header_sz; 156 it->kaddr = erofs_bread(&it->buf, erofs_blknr(it->sb, it->pos), 157 EROFS_KMAP); 158 if (IS_ERR(it->kaddr)) 159 return PTR_ERR(it->kaddr); 160 return vi->xattr_isize - xattr_header_sz; 161 } 162 163 /* 164 * Regardless of success or failure, `xattr_foreach' will end up with 165 * `pos' pointing to the next xattr item rather than an arbitrary position. 166 */ 167 static int xattr_foreach(struct erofs_xattr_iter *it, 168 const struct xattr_iter_handlers *op, 169 unsigned int *tlimit) 170 { 171 struct erofs_xattr_entry entry; 172 struct super_block *sb = it->sb; 173 unsigned int value_sz, processed, slice; 174 int err; 175 176 /* 0. fixup blkaddr, pos */ 177 it->kaddr = erofs_bread(&it->buf, erofs_blknr(sb, it->pos), EROFS_KMAP); 178 if (IS_ERR(it->kaddr)) 179 return PTR_ERR(it->kaddr); 180 181 /* 182 * 1. read xattr entry to the memory, 183 * since we do EROFS_XATTR_ALIGN 184 * therefore entry should be in the page 185 */ 186 entry = *(struct erofs_xattr_entry *) 187 (it->kaddr + erofs_blkoff(sb, it->pos)); 188 if (tlimit) { 189 unsigned int entry_sz = erofs_xattr_entry_size(&entry); 190 191 /* xattr on-disk corruption: xattr entry beyond xattr_isize */ 192 if (*tlimit < entry_sz) { 193 DBG_BUGON(1); 194 return -EFSCORRUPTED; 195 } 196 *tlimit -= entry_sz; 197 } 198 199 it->pos += sizeof(struct erofs_xattr_entry); 200 value_sz = le16_to_cpu(entry.e_value_size); 201 202 /* handle entry */ 203 err = op->entry(it, &entry); 204 if (err) { 205 it->pos += entry.e_name_len + value_sz; 206 goto out; 207 } 208 209 /* 2. handle xattr name (pos will finally be at the end of name) */ 210 processed = 0; 211 212 while (processed < entry.e_name_len) { 213 it->kaddr = erofs_bread(&it->buf, erofs_blknr(sb, it->pos), 214 EROFS_KMAP); 215 if (IS_ERR(it->kaddr)) { 216 err = PTR_ERR(it->kaddr); 217 goto out; 218 } 219 220 slice = min_t(unsigned int, 221 sb->s_blocksize - erofs_blkoff(sb, it->pos), 222 entry.e_name_len - processed); 223 224 /* handle name */ 225 err = op->name(it, processed, 226 it->kaddr + erofs_blkoff(sb, it->pos), slice); 227 if (err) { 228 it->pos += entry.e_name_len - processed + value_sz; 229 goto out; 230 } 231 232 it->pos += slice; 233 processed += slice; 234 } 235 236 /* 3. handle xattr value */ 237 processed = 0; 238 239 if (op->alloc_buffer) { 240 err = op->alloc_buffer(it, value_sz); 241 if (err) { 242 it->pos += value_sz; 243 goto out; 244 } 245 } 246 247 while (processed < value_sz) { 248 it->kaddr = erofs_bread(&it->buf, erofs_blknr(sb, it->pos), 249 EROFS_KMAP); 250 if (IS_ERR(it->kaddr)) { 251 err = PTR_ERR(it->kaddr); 252 goto out; 253 } 254 255 slice = min_t(unsigned int, 256 sb->s_blocksize - erofs_blkoff(sb, it->pos), 257 value_sz - processed); 258 op->value(it, processed, it->kaddr + erofs_blkoff(sb, it->pos), 259 slice); 260 it->pos += slice; 261 processed += slice; 262 } 263 264 out: 265 /* xattrs should be 4-byte aligned (on-disk constraint) */ 266 it->pos = EROFS_XATTR_ALIGN(it->pos); 267 return err < 0 ? err : 0; 268 } 269 270 static int erofs_xattr_long_entrymatch(struct erofs_xattr_iter *it, 271 struct erofs_xattr_entry *entry) 272 { 273 struct erofs_sb_info *sbi = EROFS_SB(it->sb); 274 struct erofs_xattr_prefix_item *pf = sbi->xattr_prefixes + 275 (entry->e_name_index & EROFS_XATTR_LONG_PREFIX_MASK); 276 277 if (pf >= sbi->xattr_prefixes + sbi->xattr_prefix_count) 278 return -ENOATTR; 279 280 if (it->index != pf->prefix->base_index || 281 it->name.len != entry->e_name_len + pf->infix_len) 282 return -ENOATTR; 283 284 if (memcmp(it->name.name, pf->prefix->infix, pf->infix_len)) 285 return -ENOATTR; 286 287 it->infix_len = pf->infix_len; 288 return 0; 289 } 290 291 static int xattr_entrymatch(struct erofs_xattr_iter *it, 292 struct erofs_xattr_entry *entry) 293 { 294 /* should also match the infix for long name prefixes */ 295 if (entry->e_name_index & EROFS_XATTR_LONG_PREFIX) 296 return erofs_xattr_long_entrymatch(it, entry); 297 298 if (it->index != entry->e_name_index || 299 it->name.len != entry->e_name_len) 300 return -ENOATTR; 301 it->infix_len = 0; 302 return 0; 303 } 304 305 static int xattr_namematch(struct erofs_xattr_iter *it, 306 unsigned int processed, char *buf, unsigned int len) 307 { 308 if (memcmp(buf, it->name.name + it->infix_len + processed, len)) 309 return -ENOATTR; 310 return 0; 311 } 312 313 static int xattr_checkbuffer(struct erofs_xattr_iter *it, 314 unsigned int value_sz) 315 { 316 int err = it->buffer_size < value_sz ? -ERANGE : 0; 317 318 it->buffer_size = value_sz; 319 return !it->buffer ? 1 : err; 320 } 321 322 static void xattr_copyvalue(struct erofs_xattr_iter *it, 323 unsigned int processed, 324 char *buf, unsigned int len) 325 { 326 memcpy(it->buffer + processed, buf, len); 327 } 328 329 static const struct xattr_iter_handlers find_xattr_handlers = { 330 .entry = xattr_entrymatch, 331 .name = xattr_namematch, 332 .alloc_buffer = xattr_checkbuffer, 333 .value = xattr_copyvalue 334 }; 335 336 static int inline_getxattr(struct inode *inode, struct erofs_xattr_iter *it) 337 { 338 int ret; 339 unsigned int remaining; 340 341 ret = inline_xattr_iter_begin(it, inode); 342 if (ret < 0) 343 return ret; 344 345 remaining = ret; 346 while (remaining) { 347 ret = xattr_foreach(it, &find_xattr_handlers, &remaining); 348 if (ret != -ENOATTR) 349 break; 350 } 351 return ret ? ret : it->buffer_size; 352 } 353 354 static int shared_getxattr(struct inode *inode, struct erofs_xattr_iter *it) 355 { 356 struct erofs_inode *const vi = EROFS_I(inode); 357 struct super_block *const sb = it->sb; 358 struct erofs_sb_info *sbi = EROFS_SB(sb); 359 unsigned int i; 360 int ret = -ENOATTR; 361 362 for (i = 0; i < vi->xattr_shared_count; ++i) { 363 it->pos = erofs_pos(sb, sbi->xattr_blkaddr) + 364 vi->xattr_shared_xattrs[i] * sizeof(__le32); 365 it->kaddr = erofs_bread(&it->buf, erofs_blknr(sb, it->pos), 366 EROFS_KMAP); 367 if (IS_ERR(it->kaddr)) 368 return PTR_ERR(it->kaddr); 369 370 ret = xattr_foreach(it, &find_xattr_handlers, NULL); 371 if (ret != -ENOATTR) 372 break; 373 } 374 return ret ? ret : it->buffer_size; 375 } 376 377 static bool erofs_xattr_user_list(struct dentry *dentry) 378 { 379 return test_opt(&EROFS_SB(dentry->d_sb)->opt, XATTR_USER); 380 } 381 382 static bool erofs_xattr_trusted_list(struct dentry *dentry) 383 { 384 return capable(CAP_SYS_ADMIN); 385 } 386 387 int erofs_getxattr(struct inode *inode, int index, 388 const char *name, 389 void *buffer, size_t buffer_size) 390 { 391 int ret; 392 struct erofs_xattr_iter it; 393 394 if (!name) 395 return -EINVAL; 396 397 ret = erofs_init_inode_xattrs(inode); 398 if (ret) 399 return ret; 400 401 it.index = index; 402 it.name = (struct qstr)QSTR_INIT(name, strlen(name)); 403 if (it.name.len > EROFS_NAME_LEN) 404 return -ERANGE; 405 406 it.sb = inode->i_sb; 407 it.buf = __EROFS_BUF_INITIALIZER; 408 erofs_init_metabuf(&it.buf, it.sb); 409 it.buffer = buffer; 410 it.buffer_size = buffer_size; 411 it.buffer_ofs = 0; 412 413 ret = inline_getxattr(inode, &it); 414 if (ret == -ENOATTR) 415 ret = shared_getxattr(inode, &it); 416 erofs_put_metabuf(&it.buf); 417 return ret; 418 } 419 420 static int erofs_xattr_generic_get(const struct xattr_handler *handler, 421 struct dentry *unused, struct inode *inode, 422 const char *name, void *buffer, size_t size) 423 { 424 if (handler->flags == EROFS_XATTR_INDEX_USER && 425 !test_opt(&EROFS_I_SB(inode)->opt, XATTR_USER)) 426 return -EOPNOTSUPP; 427 428 return erofs_getxattr(inode, handler->flags, name, buffer, size); 429 } 430 431 const struct xattr_handler erofs_xattr_user_handler = { 432 .prefix = XATTR_USER_PREFIX, 433 .flags = EROFS_XATTR_INDEX_USER, 434 .list = erofs_xattr_user_list, 435 .get = erofs_xattr_generic_get, 436 }; 437 438 const struct xattr_handler erofs_xattr_trusted_handler = { 439 .prefix = XATTR_TRUSTED_PREFIX, 440 .flags = EROFS_XATTR_INDEX_TRUSTED, 441 .list = erofs_xattr_trusted_list, 442 .get = erofs_xattr_generic_get, 443 }; 444 445 #ifdef CONFIG_EROFS_FS_SECURITY 446 const struct xattr_handler __maybe_unused erofs_xattr_security_handler = { 447 .prefix = XATTR_SECURITY_PREFIX, 448 .flags = EROFS_XATTR_INDEX_SECURITY, 449 .get = erofs_xattr_generic_get, 450 }; 451 #endif 452 453 const struct xattr_handler *erofs_xattr_handlers[] = { 454 &erofs_xattr_user_handler, 455 &erofs_xattr_trusted_handler, 456 #ifdef CONFIG_EROFS_FS_SECURITY 457 &erofs_xattr_security_handler, 458 #endif 459 NULL, 460 }; 461 462 static int xattr_entrylist(struct erofs_xattr_iter *it, 463 struct erofs_xattr_entry *entry) 464 { 465 unsigned int base_index = entry->e_name_index; 466 unsigned int prefix_len, infix_len = 0; 467 const char *prefix, *infix = NULL; 468 469 if (entry->e_name_index & EROFS_XATTR_LONG_PREFIX) { 470 struct erofs_sb_info *sbi = EROFS_SB(it->sb); 471 struct erofs_xattr_prefix_item *pf = sbi->xattr_prefixes + 472 (entry->e_name_index & EROFS_XATTR_LONG_PREFIX_MASK); 473 474 if (pf >= sbi->xattr_prefixes + sbi->xattr_prefix_count) 475 return 1; 476 infix = pf->prefix->infix; 477 infix_len = pf->infix_len; 478 base_index = pf->prefix->base_index; 479 } 480 481 prefix = erofs_xattr_prefix(base_index, it->dentry); 482 if (!prefix) 483 return 1; 484 prefix_len = strlen(prefix); 485 486 if (!it->buffer) { 487 it->buffer_ofs += prefix_len + infix_len + 488 entry->e_name_len + 1; 489 return 1; 490 } 491 492 if (it->buffer_ofs + prefix_len + infix_len + 493 + entry->e_name_len + 1 > it->buffer_size) 494 return -ERANGE; 495 496 memcpy(it->buffer + it->buffer_ofs, prefix, prefix_len); 497 memcpy(it->buffer + it->buffer_ofs + prefix_len, infix, infix_len); 498 it->buffer_ofs += prefix_len + infix_len; 499 return 0; 500 } 501 502 static int xattr_namelist(struct erofs_xattr_iter *it, 503 unsigned int processed, char *buf, unsigned int len) 504 { 505 memcpy(it->buffer + it->buffer_ofs, buf, len); 506 it->buffer_ofs += len; 507 return 0; 508 } 509 510 static int xattr_skipvalue(struct erofs_xattr_iter *it, 511 unsigned int value_sz) 512 { 513 it->buffer[it->buffer_ofs++] = '\0'; 514 return 1; 515 } 516 517 static const struct xattr_iter_handlers list_xattr_handlers = { 518 .entry = xattr_entrylist, 519 .name = xattr_namelist, 520 .alloc_buffer = xattr_skipvalue, 521 .value = NULL 522 }; 523 524 static int inline_listxattr(struct erofs_xattr_iter *it) 525 { 526 int ret; 527 unsigned int remaining; 528 529 ret = inline_xattr_iter_begin(it, d_inode(it->dentry)); 530 if (ret < 0) 531 return ret; 532 533 remaining = ret; 534 while (remaining) { 535 ret = xattr_foreach(it, &list_xattr_handlers, &remaining); 536 if (ret) 537 break; 538 } 539 return ret ? ret : it->buffer_ofs; 540 } 541 542 static int shared_listxattr(struct erofs_xattr_iter *it) 543 { 544 struct inode *const inode = d_inode(it->dentry); 545 struct erofs_inode *const vi = EROFS_I(inode); 546 struct super_block *const sb = it->sb; 547 struct erofs_sb_info *sbi = EROFS_SB(sb); 548 unsigned int i; 549 int ret = 0; 550 551 for (i = 0; i < vi->xattr_shared_count; ++i) { 552 it->pos = erofs_pos(sb, sbi->xattr_blkaddr) + 553 vi->xattr_shared_xattrs[i] * sizeof(__le32); 554 it->kaddr = erofs_bread(&it->buf, erofs_blknr(sb, it->pos), 555 EROFS_KMAP); 556 if (IS_ERR(it->kaddr)) 557 return PTR_ERR(it->kaddr); 558 559 ret = xattr_foreach(it, &list_xattr_handlers, NULL); 560 if (ret) 561 break; 562 } 563 return ret ? ret : it->buffer_ofs; 564 } 565 566 ssize_t erofs_listxattr(struct dentry *dentry, 567 char *buffer, size_t buffer_size) 568 { 569 int ret; 570 struct erofs_xattr_iter it; 571 572 ret = erofs_init_inode_xattrs(d_inode(dentry)); 573 if (ret == -ENOATTR) 574 return 0; 575 if (ret) 576 return ret; 577 578 it.sb = dentry->d_sb; 579 it.buf = __EROFS_BUF_INITIALIZER; 580 erofs_init_metabuf(&it.buf, it.sb); 581 it.dentry = dentry; 582 it.buffer = buffer; 583 it.buffer_size = buffer_size; 584 it.buffer_ofs = 0; 585 586 ret = inline_listxattr(&it); 587 if (ret >= 0 || ret == -ENOATTR) 588 ret = shared_listxattr(&it); 589 erofs_put_metabuf(&it.buf); 590 return ret; 591 } 592 593 void erofs_xattr_prefixes_cleanup(struct super_block *sb) 594 { 595 struct erofs_sb_info *sbi = EROFS_SB(sb); 596 int i; 597 598 if (sbi->xattr_prefixes) { 599 for (i = 0; i < sbi->xattr_prefix_count; i++) 600 kfree(sbi->xattr_prefixes[i].prefix); 601 kfree(sbi->xattr_prefixes); 602 sbi->xattr_prefixes = NULL; 603 } 604 } 605 606 int erofs_xattr_prefixes_init(struct super_block *sb) 607 { 608 struct erofs_sb_info *sbi = EROFS_SB(sb); 609 struct erofs_buf buf = __EROFS_BUF_INITIALIZER; 610 erofs_off_t pos = (erofs_off_t)sbi->xattr_prefix_start << 2; 611 struct erofs_xattr_prefix_item *pfs; 612 int ret = 0, i, len; 613 614 if (!sbi->xattr_prefix_count) 615 return 0; 616 617 pfs = kzalloc(sbi->xattr_prefix_count * sizeof(*pfs), GFP_KERNEL); 618 if (!pfs) 619 return -ENOMEM; 620 621 if (sbi->packed_inode) 622 buf.inode = sbi->packed_inode; 623 else 624 erofs_init_metabuf(&buf, sb); 625 626 for (i = 0; i < sbi->xattr_prefix_count; i++) { 627 void *ptr = erofs_read_metadata(sb, &buf, &pos, &len); 628 629 if (IS_ERR(ptr)) { 630 ret = PTR_ERR(ptr); 631 break; 632 } else if (len < sizeof(*pfs->prefix) || 633 len > EROFS_NAME_LEN + sizeof(*pfs->prefix)) { 634 kfree(ptr); 635 ret = -EFSCORRUPTED; 636 break; 637 } 638 pfs[i].prefix = ptr; 639 pfs[i].infix_len = len - sizeof(struct erofs_xattr_long_prefix); 640 } 641 642 erofs_put_metabuf(&buf); 643 sbi->xattr_prefixes = pfs; 644 if (ret) 645 erofs_xattr_prefixes_cleanup(sb); 646 return ret; 647 } 648 649 #ifdef CONFIG_EROFS_FS_POSIX_ACL 650 struct posix_acl *erofs_get_acl(struct inode *inode, int type, bool rcu) 651 { 652 struct posix_acl *acl; 653 int prefix, rc; 654 char *value = NULL; 655 656 if (rcu) 657 return ERR_PTR(-ECHILD); 658 659 switch (type) { 660 case ACL_TYPE_ACCESS: 661 prefix = EROFS_XATTR_INDEX_POSIX_ACL_ACCESS; 662 break; 663 case ACL_TYPE_DEFAULT: 664 prefix = EROFS_XATTR_INDEX_POSIX_ACL_DEFAULT; 665 break; 666 default: 667 return ERR_PTR(-EINVAL); 668 } 669 670 rc = erofs_getxattr(inode, prefix, "", NULL, 0); 671 if (rc > 0) { 672 value = kmalloc(rc, GFP_KERNEL); 673 if (!value) 674 return ERR_PTR(-ENOMEM); 675 rc = erofs_getxattr(inode, prefix, "", value, rc); 676 } 677 678 if (rc == -ENOATTR) 679 acl = NULL; 680 else if (rc < 0) 681 acl = ERR_PTR(rc); 682 else 683 acl = posix_acl_from_xattr(&init_user_ns, value, rc); 684 kfree(value); 685 return acl; 686 } 687 #endif 688