1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * 4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved. 5 * 6 */ 7 8 #include <linux/blkdev.h> 9 #include <linux/buffer_head.h> 10 #include <linux/fs.h> 11 #include <linux/nls.h> 12 #include <linux/posix_acl.h> 13 #include <linux/posix_acl_xattr.h> 14 #include <linux/xattr.h> 15 16 #include "debug.h" 17 #include "ntfs.h" 18 #include "ntfs_fs.h" 19 20 // clang-format off 21 #define SYSTEM_DOS_ATTRIB "system.dos_attrib" 22 #define SYSTEM_NTFS_ATTRIB "system.ntfs_attrib" 23 #define SYSTEM_NTFS_SECURITY "system.ntfs_security" 24 // clang-format on 25 26 static inline size_t unpacked_ea_size(const struct EA_FULL *ea) 27 { 28 return ea->size ? le32_to_cpu(ea->size) 29 : ALIGN(struct_size(ea, name, 30 1 + ea->name_len + 31 le16_to_cpu(ea->elength)), 32 4); 33 } 34 35 static inline size_t packed_ea_size(const struct EA_FULL *ea) 36 { 37 return struct_size(ea, name, 38 1 + ea->name_len + le16_to_cpu(ea->elength)) - 39 offsetof(struct EA_FULL, flags); 40 } 41 42 /* 43 * find_ea 44 * 45 * Assume there is at least one xattr in the list. 46 */ 47 static inline bool find_ea(const struct EA_FULL *ea_all, u32 bytes, 48 const char *name, u8 name_len, u32 *off) 49 { 50 *off = 0; 51 52 if (!ea_all || !bytes) 53 return false; 54 55 for (;;) { 56 const struct EA_FULL *ea = Add2Ptr(ea_all, *off); 57 u32 next_off = *off + unpacked_ea_size(ea); 58 59 if (next_off > bytes) 60 return false; 61 62 if (ea->name_len == name_len && 63 !memcmp(ea->name, name, name_len)) 64 return true; 65 66 *off = next_off; 67 if (next_off >= bytes) 68 return false; 69 } 70 } 71 72 /* 73 * ntfs_read_ea - Read all extended attributes. 74 * @ea: New allocated memory. 75 * @info: Pointer into resident data. 76 */ 77 static int ntfs_read_ea(struct ntfs_inode *ni, struct EA_FULL **ea, 78 size_t add_bytes, const struct EA_INFO **info) 79 { 80 int err; 81 struct ATTR_LIST_ENTRY *le = NULL; 82 struct ATTRIB *attr_info, *attr_ea; 83 void *ea_p; 84 u32 size; 85 86 static_assert(le32_to_cpu(ATTR_EA_INFO) < le32_to_cpu(ATTR_EA)); 87 88 *ea = NULL; 89 *info = NULL; 90 91 attr_info = 92 ni_find_attr(ni, NULL, &le, ATTR_EA_INFO, NULL, 0, NULL, NULL); 93 attr_ea = 94 ni_find_attr(ni, attr_info, &le, ATTR_EA, NULL, 0, NULL, NULL); 95 96 if (!attr_ea || !attr_info) 97 return 0; 98 99 *info = resident_data_ex(attr_info, sizeof(struct EA_INFO)); 100 if (!*info) 101 return -EINVAL; 102 103 /* Check Ea limit. */ 104 size = le32_to_cpu((*info)->size); 105 if (size > ni->mi.sbi->ea_max_size) 106 return -EFBIG; 107 108 if (attr_size(attr_ea) > ni->mi.sbi->ea_max_size) 109 return -EFBIG; 110 111 /* Allocate memory for packed Ea. */ 112 ea_p = kmalloc(size + add_bytes, GFP_NOFS); 113 if (!ea_p) 114 return -ENOMEM; 115 116 if (attr_ea->non_res) { 117 struct runs_tree run; 118 119 run_init(&run); 120 121 err = attr_load_runs(attr_ea, ni, &run, NULL); 122 if (!err) 123 err = ntfs_read_run_nb(ni->mi.sbi, &run, 0, ea_p, size, 124 NULL); 125 run_close(&run); 126 127 if (err) 128 goto out; 129 } else { 130 void *p = resident_data_ex(attr_ea, size); 131 132 if (!p) { 133 err = -EINVAL; 134 goto out; 135 } 136 memcpy(ea_p, p, size); 137 } 138 139 memset(Add2Ptr(ea_p, size), 0, add_bytes); 140 *ea = ea_p; 141 return 0; 142 143 out: 144 kfree(ea_p); 145 *ea = NULL; 146 return err; 147 } 148 149 /* 150 * ntfs_list_ea 151 * 152 * Copy a list of xattrs names into the buffer 153 * provided, or compute the buffer size required. 154 * 155 * Return: 156 * * Number of bytes used / required on 157 * * -ERRNO - on failure 158 */ 159 static ssize_t ntfs_list_ea(struct ntfs_inode *ni, char *buffer, 160 size_t bytes_per_buffer) 161 { 162 const struct EA_INFO *info; 163 struct EA_FULL *ea_all = NULL; 164 const struct EA_FULL *ea; 165 u32 off, size; 166 int err; 167 size_t ret; 168 169 err = ntfs_read_ea(ni, &ea_all, 0, &info); 170 if (err) 171 return err; 172 173 if (!info || !ea_all) 174 return 0; 175 176 size = le32_to_cpu(info->size); 177 178 /* Enumerate all xattrs. */ 179 for (ret = 0, off = 0; off < size; off += unpacked_ea_size(ea)) { 180 ea = Add2Ptr(ea_all, off); 181 182 if (buffer) { 183 if (ret + ea->name_len + 1 > bytes_per_buffer) { 184 err = -ERANGE; 185 goto out; 186 } 187 188 memcpy(buffer + ret, ea->name, ea->name_len); 189 buffer[ret + ea->name_len] = 0; 190 } 191 192 ret += ea->name_len + 1; 193 } 194 195 out: 196 kfree(ea_all); 197 return err ? err : ret; 198 } 199 200 static int ntfs_get_ea(struct inode *inode, const char *name, size_t name_len, 201 void *buffer, size_t size, size_t *required) 202 { 203 struct ntfs_inode *ni = ntfs_i(inode); 204 const struct EA_INFO *info; 205 struct EA_FULL *ea_all = NULL; 206 const struct EA_FULL *ea; 207 u32 off, len; 208 int err; 209 210 if (!(ni->ni_flags & NI_FLAG_EA)) 211 return -ENODATA; 212 213 if (!required) 214 ni_lock(ni); 215 216 len = 0; 217 218 if (name_len > 255) { 219 err = -ENAMETOOLONG; 220 goto out; 221 } 222 223 err = ntfs_read_ea(ni, &ea_all, 0, &info); 224 if (err) 225 goto out; 226 227 if (!info) 228 goto out; 229 230 /* Enumerate all xattrs. */ 231 if (!find_ea(ea_all, le32_to_cpu(info->size), name, name_len, &off)) { 232 err = -ENODATA; 233 goto out; 234 } 235 ea = Add2Ptr(ea_all, off); 236 237 len = le16_to_cpu(ea->elength); 238 if (!buffer) { 239 err = 0; 240 goto out; 241 } 242 243 if (len > size) { 244 err = -ERANGE; 245 if (required) 246 *required = len; 247 goto out; 248 } 249 250 memcpy(buffer, ea->name + ea->name_len + 1, len); 251 err = 0; 252 253 out: 254 kfree(ea_all); 255 if (!required) 256 ni_unlock(ni); 257 258 return err ? err : len; 259 } 260 261 static noinline int ntfs_set_ea(struct inode *inode, const char *name, 262 size_t name_len, const void *value, 263 size_t val_size, int flags, int locked) 264 { 265 struct ntfs_inode *ni = ntfs_i(inode); 266 struct ntfs_sb_info *sbi = ni->mi.sbi; 267 int err; 268 struct EA_INFO ea_info; 269 const struct EA_INFO *info; 270 struct EA_FULL *new_ea; 271 struct EA_FULL *ea_all = NULL; 272 size_t add, new_pack; 273 u32 off, size; 274 __le16 size_pack; 275 struct ATTRIB *attr; 276 struct ATTR_LIST_ENTRY *le; 277 struct mft_inode *mi; 278 struct runs_tree ea_run; 279 u64 new_sz; 280 void *p; 281 282 if (!locked) 283 ni_lock(ni); 284 285 run_init(&ea_run); 286 287 if (name_len > 255) { 288 err = -ENAMETOOLONG; 289 goto out; 290 } 291 292 add = ALIGN(struct_size(ea_all, name, 1 + name_len + val_size), 4); 293 294 err = ntfs_read_ea(ni, &ea_all, add, &info); 295 if (err) 296 goto out; 297 298 if (!info) { 299 memset(&ea_info, 0, sizeof(ea_info)); 300 size = 0; 301 size_pack = 0; 302 } else { 303 memcpy(&ea_info, info, sizeof(ea_info)); 304 size = le32_to_cpu(ea_info.size); 305 size_pack = ea_info.size_pack; 306 } 307 308 if (info && find_ea(ea_all, size, name, name_len, &off)) { 309 struct EA_FULL *ea; 310 size_t ea_sz; 311 312 if (flags & XATTR_CREATE) { 313 err = -EEXIST; 314 goto out; 315 } 316 317 ea = Add2Ptr(ea_all, off); 318 319 /* 320 * Check simple case when we try to insert xattr with the same value 321 * e.g. ntfs_save_wsl_perm 322 */ 323 if (val_size && le16_to_cpu(ea->elength) == val_size && 324 !memcmp(ea->name + ea->name_len + 1, value, val_size)) { 325 /* xattr already contains the required value. */ 326 goto out; 327 } 328 329 /* Remove current xattr. */ 330 if (ea->flags & FILE_NEED_EA) 331 le16_add_cpu(&ea_info.count, -1); 332 333 ea_sz = unpacked_ea_size(ea); 334 335 le16_add_cpu(&ea_info.size_pack, 0 - packed_ea_size(ea)); 336 337 memmove(ea, Add2Ptr(ea, ea_sz), size - off - ea_sz); 338 339 size -= ea_sz; 340 memset(Add2Ptr(ea_all, size), 0, ea_sz); 341 342 ea_info.size = cpu_to_le32(size); 343 344 if ((flags & XATTR_REPLACE) && !val_size) { 345 /* Remove xattr. */ 346 goto update_ea; 347 } 348 } else { 349 if (flags & XATTR_REPLACE) { 350 err = -ENODATA; 351 goto out; 352 } 353 354 if (!ea_all) { 355 ea_all = kzalloc(add, GFP_NOFS); 356 if (!ea_all) { 357 err = -ENOMEM; 358 goto out; 359 } 360 } 361 } 362 363 /* Append new xattr. */ 364 new_ea = Add2Ptr(ea_all, size); 365 new_ea->size = cpu_to_le32(add); 366 new_ea->flags = 0; 367 new_ea->name_len = name_len; 368 new_ea->elength = cpu_to_le16(val_size); 369 memcpy(new_ea->name, name, name_len); 370 new_ea->name[name_len] = 0; 371 memcpy(new_ea->name + name_len + 1, value, val_size); 372 new_pack = le16_to_cpu(ea_info.size_pack) + packed_ea_size(new_ea); 373 374 /* Should fit into 16 bits. */ 375 if (new_pack > 0xffff) { 376 err = -EFBIG; // -EINVAL? 377 goto out; 378 } 379 ea_info.size_pack = cpu_to_le16(new_pack); 380 381 /* New size of ATTR_EA. */ 382 size += add; 383 if (size > sbi->ea_max_size) { 384 err = -EFBIG; // -EINVAL? 385 goto out; 386 } 387 ea_info.size = cpu_to_le32(size); 388 389 update_ea: 390 391 if (!info) { 392 /* Create xattr. */ 393 if (!size) { 394 err = 0; 395 goto out; 396 } 397 398 err = ni_insert_resident(ni, sizeof(struct EA_INFO), 399 ATTR_EA_INFO, NULL, 0, NULL, NULL, 400 NULL); 401 if (err) 402 goto out; 403 404 err = ni_insert_resident(ni, 0, ATTR_EA, NULL, 0, NULL, NULL, 405 NULL); 406 if (err) 407 goto out; 408 } 409 410 new_sz = size; 411 err = attr_set_size(ni, ATTR_EA, NULL, 0, &ea_run, new_sz, &new_sz, 412 false, NULL); 413 if (err) 414 goto out; 415 416 le = NULL; 417 attr = ni_find_attr(ni, NULL, &le, ATTR_EA_INFO, NULL, 0, NULL, &mi); 418 if (!attr) { 419 err = -EINVAL; 420 goto out; 421 } 422 423 if (!size) { 424 /* Delete xattr, ATTR_EA_INFO */ 425 ni_remove_attr_le(ni, attr, mi, le); 426 } else { 427 p = resident_data_ex(attr, sizeof(struct EA_INFO)); 428 if (!p) { 429 err = -EINVAL; 430 goto out; 431 } 432 memcpy(p, &ea_info, sizeof(struct EA_INFO)); 433 mi->dirty = true; 434 } 435 436 le = NULL; 437 attr = ni_find_attr(ni, NULL, &le, ATTR_EA, NULL, 0, NULL, &mi); 438 if (!attr) { 439 err = -EINVAL; 440 goto out; 441 } 442 443 if (!size) { 444 /* Delete xattr, ATTR_EA */ 445 ni_remove_attr_le(ni, attr, mi, le); 446 } else if (attr->non_res) { 447 err = ntfs_sb_write_run(sbi, &ea_run, 0, ea_all, size); 448 if (err) 449 goto out; 450 } else { 451 p = resident_data_ex(attr, size); 452 if (!p) { 453 err = -EINVAL; 454 goto out; 455 } 456 memcpy(p, ea_all, size); 457 mi->dirty = true; 458 } 459 460 /* Check if we delete the last xattr. */ 461 if (size) 462 ni->ni_flags |= NI_FLAG_EA; 463 else 464 ni->ni_flags &= ~NI_FLAG_EA; 465 466 if (ea_info.size_pack != size_pack) 467 ni->ni_flags |= NI_FLAG_UPDATE_PARENT; 468 mark_inode_dirty(&ni->vfs_inode); 469 470 out: 471 if (!locked) 472 ni_unlock(ni); 473 474 run_close(&ea_run); 475 kfree(ea_all); 476 477 return err; 478 } 479 480 #ifdef CONFIG_NTFS3_FS_POSIX_ACL 481 static inline void ntfs_posix_acl_release(struct posix_acl *acl) 482 { 483 if (acl && refcount_dec_and_test(&acl->a_refcount)) 484 kfree(acl); 485 } 486 487 static struct posix_acl *ntfs_get_acl_ex(struct user_namespace *mnt_userns, 488 struct inode *inode, int type, 489 int locked) 490 { 491 struct ntfs_inode *ni = ntfs_i(inode); 492 const char *name; 493 size_t name_len; 494 struct posix_acl *acl; 495 size_t req; 496 int err; 497 void *buf; 498 499 /* Allocate PATH_MAX bytes. */ 500 buf = __getname(); 501 if (!buf) 502 return ERR_PTR(-ENOMEM); 503 504 /* Possible values of 'type' was already checked above. */ 505 if (type == ACL_TYPE_ACCESS) { 506 name = XATTR_NAME_POSIX_ACL_ACCESS; 507 name_len = sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1; 508 } else { 509 name = XATTR_NAME_POSIX_ACL_DEFAULT; 510 name_len = sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1; 511 } 512 513 if (!locked) 514 ni_lock(ni); 515 516 err = ntfs_get_ea(inode, name, name_len, buf, PATH_MAX, &req); 517 518 if (!locked) 519 ni_unlock(ni); 520 521 /* Translate extended attribute to acl. */ 522 if (err >= 0) { 523 acl = posix_acl_from_xattr(mnt_userns, buf, err); 524 if (!IS_ERR(acl)) 525 set_cached_acl(inode, type, acl); 526 } else { 527 acl = err == -ENODATA ? NULL : ERR_PTR(err); 528 } 529 530 __putname(buf); 531 532 return acl; 533 } 534 535 /* 536 * ntfs_get_acl - inode_operations::get_acl 537 */ 538 struct posix_acl *ntfs_get_acl(struct inode *inode, int type, bool rcu) 539 { 540 if (rcu) 541 return ERR_PTR(-ECHILD); 542 543 /* TODO: init_user_ns? */ 544 return ntfs_get_acl_ex(&init_user_ns, inode, type, 0); 545 } 546 547 static noinline int ntfs_set_acl_ex(struct user_namespace *mnt_userns, 548 struct inode *inode, struct posix_acl *acl, 549 int type, int locked) 550 { 551 const char *name; 552 size_t size, name_len; 553 void *value = NULL; 554 int err = 0; 555 556 if (S_ISLNK(inode->i_mode)) 557 return -EOPNOTSUPP; 558 559 switch (type) { 560 case ACL_TYPE_ACCESS: 561 if (acl) { 562 umode_t mode = inode->i_mode; 563 564 err = posix_acl_equiv_mode(acl, &mode); 565 if (err < 0) 566 return err; 567 568 if (inode->i_mode != mode) { 569 inode->i_mode = mode; 570 mark_inode_dirty(inode); 571 } 572 573 if (!err) { 574 /* 575 * ACL can be exactly represented in the 576 * traditional file mode permission bits. 577 */ 578 acl = NULL; 579 } 580 } 581 name = XATTR_NAME_POSIX_ACL_ACCESS; 582 name_len = sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1; 583 break; 584 585 case ACL_TYPE_DEFAULT: 586 if (!S_ISDIR(inode->i_mode)) 587 return acl ? -EACCES : 0; 588 name = XATTR_NAME_POSIX_ACL_DEFAULT; 589 name_len = sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1; 590 break; 591 592 default: 593 return -EINVAL; 594 } 595 596 if (!acl) { 597 size = 0; 598 value = NULL; 599 } else { 600 size = posix_acl_xattr_size(acl->a_count); 601 value = kmalloc(size, GFP_NOFS); 602 if (!value) 603 return -ENOMEM; 604 605 err = posix_acl_to_xattr(mnt_userns, acl, value, size); 606 if (err < 0) 607 goto out; 608 } 609 610 err = ntfs_set_ea(inode, name, name_len, value, size, 0, locked); 611 if (!err) 612 set_cached_acl(inode, type, acl); 613 614 out: 615 kfree(value); 616 617 return err; 618 } 619 620 /* 621 * ntfs_set_acl - inode_operations::set_acl 622 */ 623 int ntfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode, 624 struct posix_acl *acl, int type) 625 { 626 return ntfs_set_acl_ex(mnt_userns, inode, acl, type, 0); 627 } 628 629 static int ntfs_xattr_get_acl(struct user_namespace *mnt_userns, 630 struct inode *inode, int type, void *buffer, 631 size_t size) 632 { 633 struct posix_acl *acl; 634 int err; 635 636 if (!(inode->i_sb->s_flags & SB_POSIXACL)) { 637 ntfs_inode_warn(inode, "add mount option \"acl\" to use acl"); 638 return -EOPNOTSUPP; 639 } 640 641 acl = ntfs_get_acl(inode, type, false); 642 if (IS_ERR(acl)) 643 return PTR_ERR(acl); 644 645 if (!acl) 646 return -ENODATA; 647 648 err = posix_acl_to_xattr(mnt_userns, acl, buffer, size); 649 ntfs_posix_acl_release(acl); 650 651 return err; 652 } 653 654 static int ntfs_xattr_set_acl(struct user_namespace *mnt_userns, 655 struct inode *inode, int type, const void *value, 656 size_t size) 657 { 658 struct posix_acl *acl; 659 int err; 660 661 if (!(inode->i_sb->s_flags & SB_POSIXACL)) { 662 ntfs_inode_warn(inode, "add mount option \"acl\" to use acl"); 663 return -EOPNOTSUPP; 664 } 665 666 if (!inode_owner_or_capable(mnt_userns, inode)) 667 return -EPERM; 668 669 if (!value) { 670 acl = NULL; 671 } else { 672 acl = posix_acl_from_xattr(mnt_userns, value, size); 673 if (IS_ERR(acl)) 674 return PTR_ERR(acl); 675 676 if (acl) { 677 err = posix_acl_valid(mnt_userns, acl); 678 if (err) 679 goto release_and_out; 680 } 681 } 682 683 err = ntfs_set_acl(mnt_userns, inode, acl, type); 684 685 release_and_out: 686 ntfs_posix_acl_release(acl); 687 return err; 688 } 689 690 /* 691 * ntfs_init_acl - Initialize the ACLs of a new inode. 692 * 693 * Called from ntfs_create_inode(). 694 */ 695 int ntfs_init_acl(struct user_namespace *mnt_userns, struct inode *inode, 696 struct inode *dir) 697 { 698 struct posix_acl *default_acl, *acl; 699 int err; 700 701 /* 702 * TODO: Refactoring lock. 703 * ni_lock(dir) ... -> posix_acl_create(dir,...) -> ntfs_get_acl -> ni_lock(dir) 704 */ 705 inode->i_default_acl = NULL; 706 707 default_acl = ntfs_get_acl_ex(mnt_userns, dir, ACL_TYPE_DEFAULT, 1); 708 709 if (!default_acl || default_acl == ERR_PTR(-EOPNOTSUPP)) { 710 inode->i_mode &= ~current_umask(); 711 err = 0; 712 goto out; 713 } 714 715 if (IS_ERR(default_acl)) { 716 err = PTR_ERR(default_acl); 717 goto out; 718 } 719 720 acl = default_acl; 721 err = __posix_acl_create(&acl, GFP_NOFS, &inode->i_mode); 722 if (err < 0) 723 goto out1; 724 if (!err) { 725 posix_acl_release(acl); 726 acl = NULL; 727 } 728 729 if (!S_ISDIR(inode->i_mode)) { 730 posix_acl_release(default_acl); 731 default_acl = NULL; 732 } 733 734 if (default_acl) 735 err = ntfs_set_acl_ex(mnt_userns, inode, default_acl, 736 ACL_TYPE_DEFAULT, 1); 737 738 if (!acl) 739 inode->i_acl = NULL; 740 else if (!err) 741 err = ntfs_set_acl_ex(mnt_userns, inode, acl, ACL_TYPE_ACCESS, 742 1); 743 744 posix_acl_release(acl); 745 out1: 746 posix_acl_release(default_acl); 747 748 out: 749 return err; 750 } 751 #endif 752 753 /* 754 * ntfs_acl_chmod - Helper for ntfs3_setattr(). 755 */ 756 int ntfs_acl_chmod(struct user_namespace *mnt_userns, struct inode *inode) 757 { 758 struct super_block *sb = inode->i_sb; 759 760 if (!(sb->s_flags & SB_POSIXACL)) 761 return 0; 762 763 if (S_ISLNK(inode->i_mode)) 764 return -EOPNOTSUPP; 765 766 return posix_acl_chmod(mnt_userns, inode, inode->i_mode); 767 } 768 769 /* 770 * ntfs_permission - inode_operations::permission 771 */ 772 int ntfs_permission(struct user_namespace *mnt_userns, struct inode *inode, 773 int mask) 774 { 775 if (ntfs_sb(inode->i_sb)->options.no_acs_rules) { 776 /* "No access rules" mode - Allow all changes. */ 777 return 0; 778 } 779 780 return generic_permission(mnt_userns, inode, mask); 781 } 782 783 /* 784 * ntfs_listxattr - inode_operations::listxattr 785 */ 786 ssize_t ntfs_listxattr(struct dentry *dentry, char *buffer, size_t size) 787 { 788 struct inode *inode = d_inode(dentry); 789 struct ntfs_inode *ni = ntfs_i(inode); 790 ssize_t ret; 791 792 if (!(ni->ni_flags & NI_FLAG_EA)) { 793 /* no xattr in file */ 794 return 0; 795 } 796 797 ni_lock(ni); 798 799 ret = ntfs_list_ea(ni, buffer, size); 800 801 ni_unlock(ni); 802 803 return ret; 804 } 805 806 static int ntfs_getxattr(const struct xattr_handler *handler, struct dentry *de, 807 struct inode *inode, const char *name, void *buffer, 808 size_t size) 809 { 810 int err; 811 struct ntfs_inode *ni = ntfs_i(inode); 812 size_t name_len = strlen(name); 813 814 /* Dispatch request. */ 815 if (name_len == sizeof(SYSTEM_DOS_ATTRIB) - 1 && 816 !memcmp(name, SYSTEM_DOS_ATTRIB, sizeof(SYSTEM_DOS_ATTRIB))) { 817 /* system.dos_attrib */ 818 if (!buffer) { 819 err = sizeof(u8); 820 } else if (size < sizeof(u8)) { 821 err = -ENODATA; 822 } else { 823 err = sizeof(u8); 824 *(u8 *)buffer = le32_to_cpu(ni->std_fa); 825 } 826 goto out; 827 } 828 829 if (name_len == sizeof(SYSTEM_NTFS_ATTRIB) - 1 && 830 !memcmp(name, SYSTEM_NTFS_ATTRIB, sizeof(SYSTEM_NTFS_ATTRIB))) { 831 /* system.ntfs_attrib */ 832 if (!buffer) { 833 err = sizeof(u32); 834 } else if (size < sizeof(u32)) { 835 err = -ENODATA; 836 } else { 837 err = sizeof(u32); 838 *(u32 *)buffer = le32_to_cpu(ni->std_fa); 839 } 840 goto out; 841 } 842 843 if (name_len == sizeof(SYSTEM_NTFS_SECURITY) - 1 && 844 !memcmp(name, SYSTEM_NTFS_SECURITY, sizeof(SYSTEM_NTFS_SECURITY))) { 845 /* system.ntfs_security*/ 846 struct SECURITY_DESCRIPTOR_RELATIVE *sd = NULL; 847 size_t sd_size = 0; 848 849 if (!is_ntfs3(ni->mi.sbi)) { 850 /* We should get nt4 security. */ 851 err = -EINVAL; 852 goto out; 853 } else if (le32_to_cpu(ni->std_security_id) < 854 SECURITY_ID_FIRST) { 855 err = -ENOENT; 856 goto out; 857 } 858 859 err = ntfs_get_security_by_id(ni->mi.sbi, ni->std_security_id, 860 &sd, &sd_size); 861 if (err) 862 goto out; 863 864 if (!is_sd_valid(sd, sd_size)) { 865 ntfs_inode_warn( 866 inode, 867 "looks like you get incorrect security descriptor id=%u", 868 ni->std_security_id); 869 } 870 871 if (!buffer) { 872 err = sd_size; 873 } else if (size < sd_size) { 874 err = -ENODATA; 875 } else { 876 err = sd_size; 877 memcpy(buffer, sd, sd_size); 878 } 879 kfree(sd); 880 goto out; 881 } 882 883 #ifdef CONFIG_NTFS3_FS_POSIX_ACL 884 if ((name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 && 885 !memcmp(name, XATTR_NAME_POSIX_ACL_ACCESS, 886 sizeof(XATTR_NAME_POSIX_ACL_ACCESS))) || 887 (name_len == sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1 && 888 !memcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, 889 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)))) { 890 /* TODO: init_user_ns? */ 891 err = ntfs_xattr_get_acl( 892 &init_user_ns, inode, 893 name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 894 ? ACL_TYPE_ACCESS 895 : ACL_TYPE_DEFAULT, 896 buffer, size); 897 goto out; 898 } 899 #endif 900 /* Deal with NTFS extended attribute. */ 901 err = ntfs_get_ea(inode, name, name_len, buffer, size, NULL); 902 903 out: 904 return err; 905 } 906 907 /* 908 * ntfs_setxattr - inode_operations::setxattr 909 */ 910 static noinline int ntfs_setxattr(const struct xattr_handler *handler, 911 struct user_namespace *mnt_userns, 912 struct dentry *de, struct inode *inode, 913 const char *name, const void *value, 914 size_t size, int flags) 915 { 916 int err = -EINVAL; 917 struct ntfs_inode *ni = ntfs_i(inode); 918 size_t name_len = strlen(name); 919 enum FILE_ATTRIBUTE new_fa; 920 921 /* Dispatch request. */ 922 if (name_len == sizeof(SYSTEM_DOS_ATTRIB) - 1 && 923 !memcmp(name, SYSTEM_DOS_ATTRIB, sizeof(SYSTEM_DOS_ATTRIB))) { 924 if (sizeof(u8) != size) 925 goto out; 926 new_fa = cpu_to_le32(*(u8 *)value); 927 goto set_new_fa; 928 } 929 930 if (name_len == sizeof(SYSTEM_NTFS_ATTRIB) - 1 && 931 !memcmp(name, SYSTEM_NTFS_ATTRIB, sizeof(SYSTEM_NTFS_ATTRIB))) { 932 if (size != sizeof(u32)) 933 goto out; 934 new_fa = cpu_to_le32(*(u32 *)value); 935 936 if (S_ISREG(inode->i_mode)) { 937 /* Process compressed/sparsed in special way. */ 938 ni_lock(ni); 939 err = ni_new_attr_flags(ni, new_fa); 940 ni_unlock(ni); 941 if (err) 942 goto out; 943 } 944 set_new_fa: 945 /* 946 * Thanks Mark Harmstone: 947 * Keep directory bit consistency. 948 */ 949 if (S_ISDIR(inode->i_mode)) 950 new_fa |= FILE_ATTRIBUTE_DIRECTORY; 951 else 952 new_fa &= ~FILE_ATTRIBUTE_DIRECTORY; 953 954 if (ni->std_fa != new_fa) { 955 ni->std_fa = new_fa; 956 if (new_fa & FILE_ATTRIBUTE_READONLY) 957 inode->i_mode &= ~0222; 958 else 959 inode->i_mode |= 0222; 960 /* Std attribute always in primary record. */ 961 ni->mi.dirty = true; 962 mark_inode_dirty(inode); 963 } 964 err = 0; 965 966 goto out; 967 } 968 969 if (name_len == sizeof(SYSTEM_NTFS_SECURITY) - 1 && 970 !memcmp(name, SYSTEM_NTFS_SECURITY, sizeof(SYSTEM_NTFS_SECURITY))) { 971 /* system.ntfs_security*/ 972 __le32 security_id; 973 bool inserted; 974 struct ATTR_STD_INFO5 *std; 975 976 if (!is_ntfs3(ni->mi.sbi)) { 977 /* 978 * We should replace ATTR_SECURE. 979 * Skip this way cause it is nt4 feature. 980 */ 981 err = -EINVAL; 982 goto out; 983 } 984 985 if (!is_sd_valid(value, size)) { 986 err = -EINVAL; 987 ntfs_inode_warn( 988 inode, 989 "you try to set invalid security descriptor"); 990 goto out; 991 } 992 993 err = ntfs_insert_security(ni->mi.sbi, value, size, 994 &security_id, &inserted); 995 if (err) 996 goto out; 997 998 ni_lock(ni); 999 std = ni_std5(ni); 1000 if (!std) { 1001 err = -EINVAL; 1002 } else if (std->security_id != security_id) { 1003 std->security_id = ni->std_security_id = security_id; 1004 /* Std attribute always in primary record. */ 1005 ni->mi.dirty = true; 1006 mark_inode_dirty(&ni->vfs_inode); 1007 } 1008 ni_unlock(ni); 1009 goto out; 1010 } 1011 1012 #ifdef CONFIG_NTFS3_FS_POSIX_ACL 1013 if ((name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 && 1014 !memcmp(name, XATTR_NAME_POSIX_ACL_ACCESS, 1015 sizeof(XATTR_NAME_POSIX_ACL_ACCESS))) || 1016 (name_len == sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1 && 1017 !memcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, 1018 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)))) { 1019 err = ntfs_xattr_set_acl( 1020 mnt_userns, inode, 1021 name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 1022 ? ACL_TYPE_ACCESS 1023 : ACL_TYPE_DEFAULT, 1024 value, size); 1025 goto out; 1026 } 1027 #endif 1028 /* Deal with NTFS extended attribute. */ 1029 err = ntfs_set_ea(inode, name, name_len, value, size, flags, 0); 1030 1031 out: 1032 return err; 1033 } 1034 1035 /* 1036 * ntfs_save_wsl_perm 1037 * 1038 * save uid/gid/mode in xattr 1039 */ 1040 int ntfs_save_wsl_perm(struct inode *inode) 1041 { 1042 int err; 1043 __le32 value; 1044 1045 value = cpu_to_le32(i_uid_read(inode)); 1046 err = ntfs_set_ea(inode, "$LXUID", sizeof("$LXUID") - 1, &value, 1047 sizeof(value), 0, 0); 1048 if (err) 1049 goto out; 1050 1051 value = cpu_to_le32(i_gid_read(inode)); 1052 err = ntfs_set_ea(inode, "$LXGID", sizeof("$LXGID") - 1, &value, 1053 sizeof(value), 0, 0); 1054 if (err) 1055 goto out; 1056 1057 value = cpu_to_le32(inode->i_mode); 1058 err = ntfs_set_ea(inode, "$LXMOD", sizeof("$LXMOD") - 1, &value, 1059 sizeof(value), 0, 0); 1060 if (err) 1061 goto out; 1062 1063 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 1064 value = cpu_to_le32(inode->i_rdev); 1065 err = ntfs_set_ea(inode, "$LXDEV", sizeof("$LXDEV") - 1, &value, 1066 sizeof(value), 0, 0); 1067 if (err) 1068 goto out; 1069 } 1070 1071 out: 1072 /* In case of error should we delete all WSL xattr? */ 1073 return err; 1074 } 1075 1076 /* 1077 * ntfs_get_wsl_perm 1078 * 1079 * get uid/gid/mode from xattr 1080 * it is called from ntfs_iget5->ntfs_read_mft 1081 */ 1082 void ntfs_get_wsl_perm(struct inode *inode) 1083 { 1084 size_t sz; 1085 __le32 value[3]; 1086 1087 if (ntfs_get_ea(inode, "$LXUID", sizeof("$LXUID") - 1, &value[0], 1088 sizeof(value[0]), &sz) == sizeof(value[0]) && 1089 ntfs_get_ea(inode, "$LXGID", sizeof("$LXGID") - 1, &value[1], 1090 sizeof(value[1]), &sz) == sizeof(value[1]) && 1091 ntfs_get_ea(inode, "$LXMOD", sizeof("$LXMOD") - 1, &value[2], 1092 sizeof(value[2]), &sz) == sizeof(value[2])) { 1093 i_uid_write(inode, (uid_t)le32_to_cpu(value[0])); 1094 i_gid_write(inode, (gid_t)le32_to_cpu(value[1])); 1095 inode->i_mode = le32_to_cpu(value[2]); 1096 1097 if (ntfs_get_ea(inode, "$LXDEV", sizeof("$$LXDEV") - 1, 1098 &value[0], sizeof(value), 1099 &sz) == sizeof(value[0])) { 1100 inode->i_rdev = le32_to_cpu(value[0]); 1101 } 1102 } 1103 } 1104 1105 static bool ntfs_xattr_user_list(struct dentry *dentry) 1106 { 1107 return true; 1108 } 1109 1110 // clang-format off 1111 static const struct xattr_handler ntfs_xattr_handler = { 1112 .prefix = "", 1113 .get = ntfs_getxattr, 1114 .set = ntfs_setxattr, 1115 .list = ntfs_xattr_user_list, 1116 }; 1117 1118 const struct xattr_handler *ntfs_xattr_handlers[] = { 1119 &ntfs_xattr_handler, 1120 NULL, 1121 }; 1122 // clang-format on 1123