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 13 #include "debug.h" 14 #include "ntfs.h" 15 #include "ntfs_fs.h" 16 17 // clang-format off 18 const struct cpu_str NAME_MFT = { 19 4, 0, { '$', 'M', 'F', 'T' }, 20 }; 21 const struct cpu_str NAME_MIRROR = { 22 8, 0, { '$', 'M', 'F', 'T', 'M', 'i', 'r', 'r' }, 23 }; 24 const struct cpu_str NAME_LOGFILE = { 25 8, 0, { '$', 'L', 'o', 'g', 'F', 'i', 'l', 'e' }, 26 }; 27 const struct cpu_str NAME_VOLUME = { 28 7, 0, { '$', 'V', 'o', 'l', 'u', 'm', 'e' }, 29 }; 30 const struct cpu_str NAME_ATTRDEF = { 31 8, 0, { '$', 'A', 't', 't', 'r', 'D', 'e', 'f' }, 32 }; 33 const struct cpu_str NAME_ROOT = { 34 1, 0, { '.' }, 35 }; 36 const struct cpu_str NAME_BITMAP = { 37 7, 0, { '$', 'B', 'i', 't', 'm', 'a', 'p' }, 38 }; 39 const struct cpu_str NAME_BOOT = { 40 5, 0, { '$', 'B', 'o', 'o', 't' }, 41 }; 42 const struct cpu_str NAME_BADCLUS = { 43 8, 0, { '$', 'B', 'a', 'd', 'C', 'l', 'u', 's' }, 44 }; 45 const struct cpu_str NAME_QUOTA = { 46 6, 0, { '$', 'Q', 'u', 'o', 't', 'a' }, 47 }; 48 const struct cpu_str NAME_SECURE = { 49 7, 0, { '$', 'S', 'e', 'c', 'u', 'r', 'e' }, 50 }; 51 const struct cpu_str NAME_UPCASE = { 52 7, 0, { '$', 'U', 'p', 'C', 'a', 's', 'e' }, 53 }; 54 const struct cpu_str NAME_EXTEND = { 55 7, 0, { '$', 'E', 'x', 't', 'e', 'n', 'd' }, 56 }; 57 const struct cpu_str NAME_OBJID = { 58 6, 0, { '$', 'O', 'b', 'j', 'I', 'd' }, 59 }; 60 const struct cpu_str NAME_REPARSE = { 61 8, 0, { '$', 'R', 'e', 'p', 'a', 'r', 's', 'e' }, 62 }; 63 const struct cpu_str NAME_USNJRNL = { 64 8, 0, { '$', 'U', 's', 'n', 'J', 'r', 'n', 'l' }, 65 }; 66 const __le16 BAD_NAME[4] = { 67 cpu_to_le16('$'), cpu_to_le16('B'), cpu_to_le16('a'), cpu_to_le16('d'), 68 }; 69 const __le16 I30_NAME[4] = { 70 cpu_to_le16('$'), cpu_to_le16('I'), cpu_to_le16('3'), cpu_to_le16('0'), 71 }; 72 const __le16 SII_NAME[4] = { 73 cpu_to_le16('$'), cpu_to_le16('S'), cpu_to_le16('I'), cpu_to_le16('I'), 74 }; 75 const __le16 SDH_NAME[4] = { 76 cpu_to_le16('$'), cpu_to_le16('S'), cpu_to_le16('D'), cpu_to_le16('H'), 77 }; 78 const __le16 SDS_NAME[4] = { 79 cpu_to_le16('$'), cpu_to_le16('S'), cpu_to_le16('D'), cpu_to_le16('S'), 80 }; 81 const __le16 SO_NAME[2] = { 82 cpu_to_le16('$'), cpu_to_le16('O'), 83 }; 84 const __le16 SQ_NAME[2] = { 85 cpu_to_le16('$'), cpu_to_le16('Q'), 86 }; 87 const __le16 SR_NAME[2] = { 88 cpu_to_le16('$'), cpu_to_le16('R'), 89 }; 90 91 #ifdef CONFIG_NTFS3_LZX_XPRESS 92 const __le16 WOF_NAME[17] = { 93 cpu_to_le16('W'), cpu_to_le16('o'), cpu_to_le16('f'), cpu_to_le16('C'), 94 cpu_to_le16('o'), cpu_to_le16('m'), cpu_to_le16('p'), cpu_to_le16('r'), 95 cpu_to_le16('e'), cpu_to_le16('s'), cpu_to_le16('s'), cpu_to_le16('e'), 96 cpu_to_le16('d'), cpu_to_le16('D'), cpu_to_le16('a'), cpu_to_le16('t'), 97 cpu_to_le16('a'), 98 }; 99 #endif 100 101 // clang-format on 102 103 /* 104 * ntfs_fix_pre_write - Insert fixups into @rhdr before writing to disk. 105 */ 106 bool ntfs_fix_pre_write(struct NTFS_RECORD_HEADER *rhdr, size_t bytes) 107 { 108 u16 *fixup, *ptr; 109 u16 sample; 110 u16 fo = le16_to_cpu(rhdr->fix_off); 111 u16 fn = le16_to_cpu(rhdr->fix_num); 112 113 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || 114 fn * SECTOR_SIZE > bytes) { 115 return false; 116 } 117 118 /* Get fixup pointer. */ 119 fixup = Add2Ptr(rhdr, fo); 120 121 if (*fixup >= 0x7FFF) 122 *fixup = 1; 123 else 124 *fixup += 1; 125 126 sample = *fixup; 127 128 ptr = Add2Ptr(rhdr, SECTOR_SIZE - sizeof(short)); 129 130 while (fn--) { 131 *++fixup = *ptr; 132 *ptr = sample; 133 ptr += SECTOR_SIZE / sizeof(short); 134 } 135 return true; 136 } 137 138 /* 139 * ntfs_fix_post_read - Remove fixups after reading from disk. 140 * 141 * Return: < 0 if error, 0 if ok, 1 if need to update fixups. 142 */ 143 int ntfs_fix_post_read(struct NTFS_RECORD_HEADER *rhdr, size_t bytes, 144 bool simple) 145 { 146 int ret; 147 u16 *fixup, *ptr; 148 u16 sample, fo, fn; 149 150 fo = le16_to_cpu(rhdr->fix_off); 151 fn = simple ? ((bytes >> SECTOR_SHIFT) + 1) 152 : le16_to_cpu(rhdr->fix_num); 153 154 /* Check errors. */ 155 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || 156 fn * SECTOR_SIZE > bytes) { 157 return -EINVAL; /* Native chkntfs returns ok! */ 158 } 159 160 /* Get fixup pointer. */ 161 fixup = Add2Ptr(rhdr, fo); 162 sample = *fixup; 163 ptr = Add2Ptr(rhdr, SECTOR_SIZE - sizeof(short)); 164 ret = 0; 165 166 while (fn--) { 167 /* Test current word. */ 168 if (*ptr != sample) { 169 /* Fixup does not match! Is it serious error? */ 170 ret = -E_NTFS_FIXUP; 171 } 172 173 /* Replace fixup. */ 174 *ptr = *++fixup; 175 ptr += SECTOR_SIZE / sizeof(short); 176 } 177 178 return ret; 179 } 180 181 /* 182 * ntfs_extend_init - Load $Extend file. 183 */ 184 int ntfs_extend_init(struct ntfs_sb_info *sbi) 185 { 186 int err; 187 struct super_block *sb = sbi->sb; 188 struct inode *inode, *inode2; 189 struct MFT_REF ref; 190 191 if (sbi->volume.major_ver < 3) { 192 ntfs_notice(sb, "Skip $Extend 'cause NTFS version"); 193 return 0; 194 } 195 196 ref.low = cpu_to_le32(MFT_REC_EXTEND); 197 ref.high = 0; 198 ref.seq = cpu_to_le16(MFT_REC_EXTEND); 199 inode = ntfs_iget5(sb, &ref, &NAME_EXTEND); 200 if (IS_ERR(inode)) { 201 err = PTR_ERR(inode); 202 ntfs_err(sb, "Failed to load $Extend."); 203 inode = NULL; 204 goto out; 205 } 206 207 /* If ntfs_iget5() reads from disk it never returns bad inode. */ 208 if (!S_ISDIR(inode->i_mode)) { 209 err = -EINVAL; 210 goto out; 211 } 212 213 /* Try to find $ObjId */ 214 inode2 = dir_search_u(inode, &NAME_OBJID, NULL); 215 if (inode2 && !IS_ERR(inode2)) { 216 if (is_bad_inode(inode2)) { 217 iput(inode2); 218 } else { 219 sbi->objid.ni = ntfs_i(inode2); 220 sbi->objid_no = inode2->i_ino; 221 } 222 } 223 224 /* Try to find $Quota */ 225 inode2 = dir_search_u(inode, &NAME_QUOTA, NULL); 226 if (inode2 && !IS_ERR(inode2)) { 227 sbi->quota_no = inode2->i_ino; 228 iput(inode2); 229 } 230 231 /* Try to find $Reparse */ 232 inode2 = dir_search_u(inode, &NAME_REPARSE, NULL); 233 if (inode2 && !IS_ERR(inode2)) { 234 sbi->reparse.ni = ntfs_i(inode2); 235 sbi->reparse_no = inode2->i_ino; 236 } 237 238 /* Try to find $UsnJrnl */ 239 inode2 = dir_search_u(inode, &NAME_USNJRNL, NULL); 240 if (inode2 && !IS_ERR(inode2)) { 241 sbi->usn_jrnl_no = inode2->i_ino; 242 iput(inode2); 243 } 244 245 err = 0; 246 out: 247 iput(inode); 248 return err; 249 } 250 251 int ntfs_loadlog_and_replay(struct ntfs_inode *ni, struct ntfs_sb_info *sbi) 252 { 253 int err = 0; 254 struct super_block *sb = sbi->sb; 255 bool initialized = false; 256 struct MFT_REF ref; 257 struct inode *inode; 258 259 /* Check for 4GB. */ 260 if (ni->vfs_inode.i_size >= 0x100000000ull) { 261 ntfs_err(sb, "\x24LogFile is too big"); 262 err = -EINVAL; 263 goto out; 264 } 265 266 sbi->flags |= NTFS_FLAGS_LOG_REPLAYING; 267 268 ref.low = cpu_to_le32(MFT_REC_MFT); 269 ref.high = 0; 270 ref.seq = cpu_to_le16(1); 271 272 inode = ntfs_iget5(sb, &ref, NULL); 273 274 if (IS_ERR(inode)) 275 inode = NULL; 276 277 if (!inode) { 278 /* Try to use MFT copy. */ 279 u64 t64 = sbi->mft.lbo; 280 281 sbi->mft.lbo = sbi->mft.lbo2; 282 inode = ntfs_iget5(sb, &ref, NULL); 283 sbi->mft.lbo = t64; 284 if (IS_ERR(inode)) 285 inode = NULL; 286 } 287 288 if (!inode) { 289 err = -EINVAL; 290 ntfs_err(sb, "Failed to load $MFT."); 291 goto out; 292 } 293 294 sbi->mft.ni = ntfs_i(inode); 295 296 /* LogFile should not contains attribute list. */ 297 err = ni_load_all_mi(sbi->mft.ni); 298 if (!err) 299 err = log_replay(ni, &initialized); 300 301 iput(inode); 302 sbi->mft.ni = NULL; 303 304 sync_blockdev(sb->s_bdev); 305 invalidate_bdev(sb->s_bdev); 306 307 if (sbi->flags & NTFS_FLAGS_NEED_REPLAY) { 308 err = 0; 309 goto out; 310 } 311 312 if (sb_rdonly(sb) || !initialized) 313 goto out; 314 315 /* Fill LogFile by '-1' if it is initialized. */ 316 err = ntfs_bio_fill_1(sbi, &ni->file.run); 317 318 out: 319 sbi->flags &= ~NTFS_FLAGS_LOG_REPLAYING; 320 321 return err; 322 } 323 324 /* 325 * ntfs_query_def 326 * 327 * Return: Current ATTR_DEF_ENTRY for given attribute type. 328 */ 329 const struct ATTR_DEF_ENTRY *ntfs_query_def(struct ntfs_sb_info *sbi, 330 enum ATTR_TYPE type) 331 { 332 int type_in = le32_to_cpu(type); 333 size_t min_idx = 0; 334 size_t max_idx = sbi->def_entries - 1; 335 336 while (min_idx <= max_idx) { 337 size_t i = min_idx + ((max_idx - min_idx) >> 1); 338 const struct ATTR_DEF_ENTRY *entry = sbi->def_table + i; 339 int diff = le32_to_cpu(entry->type) - type_in; 340 341 if (!diff) 342 return entry; 343 if (diff < 0) 344 min_idx = i + 1; 345 else if (i) 346 max_idx = i - 1; 347 else 348 return NULL; 349 } 350 return NULL; 351 } 352 353 /* 354 * ntfs_look_for_free_space - Look for a free space in bitmap. 355 */ 356 int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len, 357 CLST *new_lcn, CLST *new_len, 358 enum ALLOCATE_OPT opt) 359 { 360 int err; 361 CLST alen = 0; 362 struct super_block *sb = sbi->sb; 363 size_t alcn, zlen, zeroes, zlcn, zlen2, ztrim, new_zlen; 364 struct wnd_bitmap *wnd = &sbi->used.bitmap; 365 366 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS); 367 if (opt & ALLOCATE_MFT) { 368 zlen = wnd_zone_len(wnd); 369 370 if (!zlen) { 371 err = ntfs_refresh_zone(sbi); 372 if (err) 373 goto out; 374 zlen = wnd_zone_len(wnd); 375 } 376 377 if (!zlen) { 378 ntfs_err(sbi->sb, "no free space to extend mft"); 379 goto out; 380 } 381 382 lcn = wnd_zone_bit(wnd); 383 alen = zlen > len ? len : zlen; 384 385 wnd_zone_set(wnd, lcn + alen, zlen - alen); 386 387 err = wnd_set_used(wnd, lcn, alen); 388 if (err) { 389 up_write(&wnd->rw_lock); 390 return err; 391 } 392 alcn = lcn; 393 goto out; 394 } 395 /* 396 * 'Cause cluster 0 is always used this value means that we should use 397 * cached value of 'next_free_lcn' to improve performance. 398 */ 399 if (!lcn) 400 lcn = sbi->used.next_free_lcn; 401 402 if (lcn >= wnd->nbits) 403 lcn = 0; 404 405 alen = wnd_find(wnd, len, lcn, BITMAP_FIND_MARK_AS_USED, &alcn); 406 if (alen) 407 goto out; 408 409 /* Try to use clusters from MftZone. */ 410 zlen = wnd_zone_len(wnd); 411 zeroes = wnd_zeroes(wnd); 412 413 /* Check too big request */ 414 if (len > zeroes + zlen || zlen <= NTFS_MIN_MFT_ZONE) 415 goto out; 416 417 /* How many clusters to cat from zone. */ 418 zlcn = wnd_zone_bit(wnd); 419 zlen2 = zlen >> 1; 420 ztrim = len > zlen ? zlen : (len > zlen2 ? len : zlen2); 421 new_zlen = zlen - ztrim; 422 423 if (new_zlen < NTFS_MIN_MFT_ZONE) { 424 new_zlen = NTFS_MIN_MFT_ZONE; 425 if (new_zlen > zlen) 426 new_zlen = zlen; 427 } 428 429 wnd_zone_set(wnd, zlcn, new_zlen); 430 431 /* Allocate continues clusters. */ 432 alen = wnd_find(wnd, len, 0, 433 BITMAP_FIND_MARK_AS_USED | BITMAP_FIND_FULL, &alcn); 434 435 out: 436 if (alen) { 437 err = 0; 438 *new_len = alen; 439 *new_lcn = alcn; 440 441 ntfs_unmap_meta(sb, alcn, alen); 442 443 /* Set hint for next requests. */ 444 if (!(opt & ALLOCATE_MFT)) 445 sbi->used.next_free_lcn = alcn + alen; 446 } else { 447 err = -ENOSPC; 448 } 449 450 up_write(&wnd->rw_lock); 451 return err; 452 } 453 454 /* 455 * ntfs_extend_mft - Allocate additional MFT records. 456 * 457 * sbi->mft.bitmap is locked for write. 458 * 459 * NOTE: recursive: 460 * ntfs_look_free_mft -> 461 * ntfs_extend_mft -> 462 * attr_set_size -> 463 * ni_insert_nonresident -> 464 * ni_insert_attr -> 465 * ni_ins_attr_ext -> 466 * ntfs_look_free_mft -> 467 * ntfs_extend_mft 468 * 469 * To avoid recursive always allocate space for two new MFT records 470 * see attrib.c: "at least two MFT to avoid recursive loop". 471 */ 472 static int ntfs_extend_mft(struct ntfs_sb_info *sbi) 473 { 474 int err; 475 struct ntfs_inode *ni = sbi->mft.ni; 476 size_t new_mft_total; 477 u64 new_mft_bytes, new_bitmap_bytes; 478 struct ATTRIB *attr; 479 struct wnd_bitmap *wnd = &sbi->mft.bitmap; 480 481 new_mft_total = (wnd->nbits + MFT_INCREASE_CHUNK + 127) & (CLST)~127; 482 new_mft_bytes = (u64)new_mft_total << sbi->record_bits; 483 484 /* Step 1: Resize $MFT::DATA. */ 485 down_write(&ni->file.run_lock); 486 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, 487 new_mft_bytes, NULL, false, &attr); 488 489 if (err) { 490 up_write(&ni->file.run_lock); 491 goto out; 492 } 493 494 attr->nres.valid_size = attr->nres.data_size; 495 new_mft_total = le64_to_cpu(attr->nres.alloc_size) >> sbi->record_bits; 496 ni->mi.dirty = true; 497 498 /* Step 2: Resize $MFT::BITMAP. */ 499 new_bitmap_bytes = bitmap_size(new_mft_total); 500 501 err = attr_set_size(ni, ATTR_BITMAP, NULL, 0, &sbi->mft.bitmap.run, 502 new_bitmap_bytes, &new_bitmap_bytes, true, NULL); 503 504 /* Refresh MFT Zone if necessary. */ 505 down_write_nested(&sbi->used.bitmap.rw_lock, BITMAP_MUTEX_CLUSTERS); 506 507 ntfs_refresh_zone(sbi); 508 509 up_write(&sbi->used.bitmap.rw_lock); 510 up_write(&ni->file.run_lock); 511 512 if (err) 513 goto out; 514 515 err = wnd_extend(wnd, new_mft_total); 516 517 if (err) 518 goto out; 519 520 ntfs_clear_mft_tail(sbi, sbi->mft.used, new_mft_total); 521 522 err = _ni_write_inode(&ni->vfs_inode, 0); 523 out: 524 return err; 525 } 526 527 /* 528 * ntfs_look_free_mft - Look for a free MFT record. 529 */ 530 int ntfs_look_free_mft(struct ntfs_sb_info *sbi, CLST *rno, bool mft, 531 struct ntfs_inode *ni, struct mft_inode **mi) 532 { 533 int err = 0; 534 size_t zbit, zlen, from, to, fr; 535 size_t mft_total; 536 struct MFT_REF ref; 537 struct super_block *sb = sbi->sb; 538 struct wnd_bitmap *wnd = &sbi->mft.bitmap; 539 u32 ir; 540 541 static_assert(sizeof(sbi->mft.reserved_bitmap) * 8 >= 542 MFT_REC_FREE - MFT_REC_RESERVED); 543 544 if (!mft) 545 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT); 546 547 zlen = wnd_zone_len(wnd); 548 549 /* Always reserve space for MFT. */ 550 if (zlen) { 551 if (mft) { 552 zbit = wnd_zone_bit(wnd); 553 *rno = zbit; 554 wnd_zone_set(wnd, zbit + 1, zlen - 1); 555 } 556 goto found; 557 } 558 559 /* No MFT zone. Find the nearest to '0' free MFT. */ 560 if (!wnd_find(wnd, 1, MFT_REC_FREE, 0, &zbit)) { 561 /* Resize MFT */ 562 mft_total = wnd->nbits; 563 564 err = ntfs_extend_mft(sbi); 565 if (!err) { 566 zbit = mft_total; 567 goto reserve_mft; 568 } 569 570 if (!mft || MFT_REC_FREE == sbi->mft.next_reserved) 571 goto out; 572 573 err = 0; 574 575 /* 576 * Look for free record reserved area [11-16) == 577 * [MFT_REC_RESERVED, MFT_REC_FREE ) MFT bitmap always 578 * marks it as used. 579 */ 580 if (!sbi->mft.reserved_bitmap) { 581 /* Once per session create internal bitmap for 5 bits. */ 582 sbi->mft.reserved_bitmap = 0xFF; 583 584 ref.high = 0; 585 for (ir = MFT_REC_RESERVED; ir < MFT_REC_FREE; ir++) { 586 struct inode *i; 587 struct ntfs_inode *ni; 588 struct MFT_REC *mrec; 589 590 ref.low = cpu_to_le32(ir); 591 ref.seq = cpu_to_le16(ir); 592 593 i = ntfs_iget5(sb, &ref, NULL); 594 if (IS_ERR(i)) { 595 next: 596 ntfs_notice( 597 sb, 598 "Invalid reserved record %x", 599 ref.low); 600 continue; 601 } 602 if (is_bad_inode(i)) { 603 iput(i); 604 goto next; 605 } 606 607 ni = ntfs_i(i); 608 609 mrec = ni->mi.mrec; 610 611 if (!is_rec_base(mrec)) 612 goto next; 613 614 if (mrec->hard_links) 615 goto next; 616 617 if (!ni_std(ni)) 618 goto next; 619 620 if (ni_find_attr(ni, NULL, NULL, ATTR_NAME, 621 NULL, 0, NULL, NULL)) 622 goto next; 623 624 __clear_bit(ir - MFT_REC_RESERVED, 625 &sbi->mft.reserved_bitmap); 626 } 627 } 628 629 /* Scan 5 bits for zero. Bit 0 == MFT_REC_RESERVED */ 630 zbit = find_next_zero_bit(&sbi->mft.reserved_bitmap, 631 MFT_REC_FREE, MFT_REC_RESERVED); 632 if (zbit >= MFT_REC_FREE) { 633 sbi->mft.next_reserved = MFT_REC_FREE; 634 goto out; 635 } 636 637 zlen = 1; 638 sbi->mft.next_reserved = zbit; 639 } else { 640 reserve_mft: 641 zlen = zbit == MFT_REC_FREE ? (MFT_REC_USER - MFT_REC_FREE) : 4; 642 if (zbit + zlen > wnd->nbits) 643 zlen = wnd->nbits - zbit; 644 645 while (zlen > 1 && !wnd_is_free(wnd, zbit, zlen)) 646 zlen -= 1; 647 648 /* [zbit, zbit + zlen) will be used for MFT itself. */ 649 from = sbi->mft.used; 650 if (from < zbit) 651 from = zbit; 652 to = zbit + zlen; 653 if (from < to) { 654 ntfs_clear_mft_tail(sbi, from, to); 655 sbi->mft.used = to; 656 } 657 } 658 659 if (mft) { 660 *rno = zbit; 661 zbit += 1; 662 zlen -= 1; 663 } 664 665 wnd_zone_set(wnd, zbit, zlen); 666 667 found: 668 if (!mft) { 669 /* The request to get record for general purpose. */ 670 if (sbi->mft.next_free < MFT_REC_USER) 671 sbi->mft.next_free = MFT_REC_USER; 672 673 for (;;) { 674 if (sbi->mft.next_free >= sbi->mft.bitmap.nbits) { 675 } else if (!wnd_find(wnd, 1, MFT_REC_USER, 0, &fr)) { 676 sbi->mft.next_free = sbi->mft.bitmap.nbits; 677 } else { 678 *rno = fr; 679 sbi->mft.next_free = *rno + 1; 680 break; 681 } 682 683 err = ntfs_extend_mft(sbi); 684 if (err) 685 goto out; 686 } 687 } 688 689 if (ni && !ni_add_subrecord(ni, *rno, mi)) { 690 err = -ENOMEM; 691 goto out; 692 } 693 694 /* We have found a record that are not reserved for next MFT. */ 695 if (*rno >= MFT_REC_FREE) 696 wnd_set_used(wnd, *rno, 1); 697 else if (*rno >= MFT_REC_RESERVED && sbi->mft.reserved_bitmap_inited) 698 __set_bit(*rno - MFT_REC_RESERVED, &sbi->mft.reserved_bitmap); 699 700 out: 701 if (!mft) 702 up_write(&wnd->rw_lock); 703 704 return err; 705 } 706 707 /* 708 * ntfs_mark_rec_free - Mark record as free. 709 */ 710 void ntfs_mark_rec_free(struct ntfs_sb_info *sbi, CLST rno) 711 { 712 struct wnd_bitmap *wnd = &sbi->mft.bitmap; 713 714 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT); 715 if (rno >= wnd->nbits) 716 goto out; 717 718 if (rno >= MFT_REC_FREE) { 719 if (!wnd_is_used(wnd, rno, 1)) 720 ntfs_set_state(sbi, NTFS_DIRTY_ERROR); 721 else 722 wnd_set_free(wnd, rno, 1); 723 } else if (rno >= MFT_REC_RESERVED && sbi->mft.reserved_bitmap_inited) { 724 __clear_bit(rno - MFT_REC_RESERVED, &sbi->mft.reserved_bitmap); 725 } 726 727 if (rno < wnd_zone_bit(wnd)) 728 wnd_zone_set(wnd, rno, 1); 729 else if (rno < sbi->mft.next_free && rno >= MFT_REC_USER) 730 sbi->mft.next_free = rno; 731 732 out: 733 up_write(&wnd->rw_lock); 734 } 735 736 /* 737 * ntfs_clear_mft_tail - Format empty records [from, to). 738 * 739 * sbi->mft.bitmap is locked for write. 740 */ 741 int ntfs_clear_mft_tail(struct ntfs_sb_info *sbi, size_t from, size_t to) 742 { 743 int err; 744 u32 rs; 745 u64 vbo; 746 struct runs_tree *run; 747 struct ntfs_inode *ni; 748 749 if (from >= to) 750 return 0; 751 752 rs = sbi->record_size; 753 ni = sbi->mft.ni; 754 run = &ni->file.run; 755 756 down_read(&ni->file.run_lock); 757 vbo = (u64)from * rs; 758 for (; from < to; from++, vbo += rs) { 759 struct ntfs_buffers nb; 760 761 err = ntfs_get_bh(sbi, run, vbo, rs, &nb); 762 if (err) 763 goto out; 764 765 err = ntfs_write_bh(sbi, &sbi->new_rec->rhdr, &nb, 0); 766 nb_put(&nb); 767 if (err) 768 goto out; 769 } 770 771 out: 772 sbi->mft.used = from; 773 up_read(&ni->file.run_lock); 774 return err; 775 } 776 777 /* 778 * ntfs_refresh_zone - Refresh MFT zone. 779 * 780 * sbi->used.bitmap is locked for rw. 781 * sbi->mft.bitmap is locked for write. 782 * sbi->mft.ni->file.run_lock for write. 783 */ 784 int ntfs_refresh_zone(struct ntfs_sb_info *sbi) 785 { 786 CLST zone_limit, zone_max, lcn, vcn, len; 787 size_t lcn_s, zlen; 788 struct wnd_bitmap *wnd = &sbi->used.bitmap; 789 struct ntfs_inode *ni = sbi->mft.ni; 790 791 /* Do not change anything unless we have non empty MFT zone. */ 792 if (wnd_zone_len(wnd)) 793 return 0; 794 795 /* 796 * Compute the MFT zone at two steps. 797 * It would be nice if we are able to allocate 1/8 of 798 * total clusters for MFT but not more then 512 MB. 799 */ 800 zone_limit = (512 * 1024 * 1024) >> sbi->cluster_bits; 801 zone_max = wnd->nbits >> 3; 802 if (zone_max > zone_limit) 803 zone_max = zone_limit; 804 805 vcn = bytes_to_cluster(sbi, 806 (u64)sbi->mft.bitmap.nbits << sbi->record_bits); 807 808 if (!run_lookup_entry(&ni->file.run, vcn - 1, &lcn, &len, NULL)) 809 lcn = SPARSE_LCN; 810 811 /* We should always find Last Lcn for MFT. */ 812 if (lcn == SPARSE_LCN) 813 return -EINVAL; 814 815 lcn_s = lcn + 1; 816 817 /* Try to allocate clusters after last MFT run. */ 818 zlen = wnd_find(wnd, zone_max, lcn_s, 0, &lcn_s); 819 if (!zlen) { 820 ntfs_notice(sbi->sb, "MftZone: unavailable"); 821 return 0; 822 } 823 824 /* Truncate too large zone. */ 825 wnd_zone_set(wnd, lcn_s, zlen); 826 827 return 0; 828 } 829 830 /* 831 * ntfs_update_mftmirr - Update $MFTMirr data. 832 */ 833 int ntfs_update_mftmirr(struct ntfs_sb_info *sbi, int wait) 834 { 835 int err; 836 struct super_block *sb = sbi->sb; 837 u32 blocksize = sb->s_blocksize; 838 sector_t block1, block2; 839 u32 bytes; 840 841 if (!(sbi->flags & NTFS_FLAGS_MFTMIRR)) 842 return 0; 843 844 err = 0; 845 bytes = sbi->mft.recs_mirr << sbi->record_bits; 846 block1 = sbi->mft.lbo >> sb->s_blocksize_bits; 847 block2 = sbi->mft.lbo2 >> sb->s_blocksize_bits; 848 849 for (; bytes >= blocksize; bytes -= blocksize) { 850 struct buffer_head *bh1, *bh2; 851 852 bh1 = sb_bread(sb, block1++); 853 if (!bh1) { 854 err = -EIO; 855 goto out; 856 } 857 858 bh2 = sb_getblk(sb, block2++); 859 if (!bh2) { 860 put_bh(bh1); 861 err = -EIO; 862 goto out; 863 } 864 865 if (buffer_locked(bh2)) 866 __wait_on_buffer(bh2); 867 868 lock_buffer(bh2); 869 memcpy(bh2->b_data, bh1->b_data, blocksize); 870 set_buffer_uptodate(bh2); 871 mark_buffer_dirty(bh2); 872 unlock_buffer(bh2); 873 874 put_bh(bh1); 875 bh1 = NULL; 876 877 if (wait) 878 err = sync_dirty_buffer(bh2); 879 880 put_bh(bh2); 881 if (err) 882 goto out; 883 } 884 885 sbi->flags &= ~NTFS_FLAGS_MFTMIRR; 886 887 out: 888 return err; 889 } 890 891 /* 892 * ntfs_set_state 893 * 894 * Mount: ntfs_set_state(NTFS_DIRTY_DIRTY) 895 * Umount: ntfs_set_state(NTFS_DIRTY_CLEAR) 896 * NTFS error: ntfs_set_state(NTFS_DIRTY_ERROR) 897 */ 898 int ntfs_set_state(struct ntfs_sb_info *sbi, enum NTFS_DIRTY_FLAGS dirty) 899 { 900 int err; 901 struct ATTRIB *attr; 902 struct VOLUME_INFO *info; 903 struct mft_inode *mi; 904 struct ntfs_inode *ni; 905 906 /* 907 * Do not change state if fs was real_dirty. 908 * Do not change state if fs already dirty(clear). 909 * Do not change any thing if mounted read only. 910 */ 911 if (sbi->volume.real_dirty || sb_rdonly(sbi->sb)) 912 return 0; 913 914 /* Check cached value. */ 915 if ((dirty == NTFS_DIRTY_CLEAR ? 0 : VOLUME_FLAG_DIRTY) == 916 (sbi->volume.flags & VOLUME_FLAG_DIRTY)) 917 return 0; 918 919 ni = sbi->volume.ni; 920 if (!ni) 921 return -EINVAL; 922 923 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_DIRTY); 924 925 attr = ni_find_attr(ni, NULL, NULL, ATTR_VOL_INFO, NULL, 0, NULL, &mi); 926 if (!attr) { 927 err = -EINVAL; 928 goto out; 929 } 930 931 info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO); 932 if (!info) { 933 err = -EINVAL; 934 goto out; 935 } 936 937 switch (dirty) { 938 case NTFS_DIRTY_ERROR: 939 ntfs_notice(sbi->sb, "Mark volume as dirty due to NTFS errors"); 940 sbi->volume.real_dirty = true; 941 fallthrough; 942 case NTFS_DIRTY_DIRTY: 943 info->flags |= VOLUME_FLAG_DIRTY; 944 break; 945 case NTFS_DIRTY_CLEAR: 946 info->flags &= ~VOLUME_FLAG_DIRTY; 947 break; 948 } 949 /* Cache current volume flags. */ 950 sbi->volume.flags = info->flags; 951 mi->dirty = true; 952 err = 0; 953 954 out: 955 ni_unlock(ni); 956 if (err) 957 return err; 958 959 mark_inode_dirty(&ni->vfs_inode); 960 /* verify(!ntfs_update_mftmirr()); */ 961 962 /* 963 * If we used wait=1, sync_inode_metadata waits for the io for the 964 * inode to finish. It hangs when media is removed. 965 * So wait=0 is sent down to sync_inode_metadata 966 * and filemap_fdatawrite is used for the data blocks. 967 */ 968 err = sync_inode_metadata(&ni->vfs_inode, 0); 969 if (!err) 970 err = filemap_fdatawrite(ni->vfs_inode.i_mapping); 971 972 return err; 973 } 974 975 /* 976 * security_hash - Calculates a hash of security descriptor. 977 */ 978 static inline __le32 security_hash(const void *sd, size_t bytes) 979 { 980 u32 hash = 0; 981 const __le32 *ptr = sd; 982 983 bytes >>= 2; 984 while (bytes--) 985 hash = ((hash >> 0x1D) | (hash << 3)) + le32_to_cpu(*ptr++); 986 return cpu_to_le32(hash); 987 } 988 989 int ntfs_sb_read(struct super_block *sb, u64 lbo, size_t bytes, void *buffer) 990 { 991 struct block_device *bdev = sb->s_bdev; 992 u32 blocksize = sb->s_blocksize; 993 u64 block = lbo >> sb->s_blocksize_bits; 994 u32 off = lbo & (blocksize - 1); 995 u32 op = blocksize - off; 996 997 for (; bytes; block += 1, off = 0, op = blocksize) { 998 struct buffer_head *bh = __bread(bdev, block, blocksize); 999 1000 if (!bh) 1001 return -EIO; 1002 1003 if (op > bytes) 1004 op = bytes; 1005 1006 memcpy(buffer, bh->b_data + off, op); 1007 1008 put_bh(bh); 1009 1010 bytes -= op; 1011 buffer = Add2Ptr(buffer, op); 1012 } 1013 1014 return 0; 1015 } 1016 1017 int ntfs_sb_write(struct super_block *sb, u64 lbo, size_t bytes, 1018 const void *buf, int wait) 1019 { 1020 u32 blocksize = sb->s_blocksize; 1021 struct block_device *bdev = sb->s_bdev; 1022 sector_t block = lbo >> sb->s_blocksize_bits; 1023 u32 off = lbo & (blocksize - 1); 1024 u32 op = blocksize - off; 1025 struct buffer_head *bh; 1026 1027 if (!wait && (sb->s_flags & SB_SYNCHRONOUS)) 1028 wait = 1; 1029 1030 for (; bytes; block += 1, off = 0, op = blocksize) { 1031 if (op > bytes) 1032 op = bytes; 1033 1034 if (op < blocksize) { 1035 bh = __bread(bdev, block, blocksize); 1036 if (!bh) { 1037 ntfs_err(sb, "failed to read block %llx", 1038 (u64)block); 1039 return -EIO; 1040 } 1041 } else { 1042 bh = __getblk(bdev, block, blocksize); 1043 if (!bh) 1044 return -ENOMEM; 1045 } 1046 1047 if (buffer_locked(bh)) 1048 __wait_on_buffer(bh); 1049 1050 lock_buffer(bh); 1051 if (buf) { 1052 memcpy(bh->b_data + off, buf, op); 1053 buf = Add2Ptr(buf, op); 1054 } else { 1055 memset(bh->b_data + off, -1, op); 1056 } 1057 1058 set_buffer_uptodate(bh); 1059 mark_buffer_dirty(bh); 1060 unlock_buffer(bh); 1061 1062 if (wait) { 1063 int err = sync_dirty_buffer(bh); 1064 1065 if (err) { 1066 ntfs_err( 1067 sb, 1068 "failed to sync buffer at block %llx, error %d", 1069 (u64)block, err); 1070 put_bh(bh); 1071 return err; 1072 } 1073 } 1074 1075 put_bh(bh); 1076 1077 bytes -= op; 1078 } 1079 return 0; 1080 } 1081 1082 int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1083 u64 vbo, const void *buf, size_t bytes) 1084 { 1085 struct super_block *sb = sbi->sb; 1086 u8 cluster_bits = sbi->cluster_bits; 1087 u32 off = vbo & sbi->cluster_mask; 1088 CLST lcn, clen, vcn = vbo >> cluster_bits, vcn_next; 1089 u64 lbo, len; 1090 size_t idx; 1091 1092 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) 1093 return -ENOENT; 1094 1095 if (lcn == SPARSE_LCN) 1096 return -EINVAL; 1097 1098 lbo = ((u64)lcn << cluster_bits) + off; 1099 len = ((u64)clen << cluster_bits) - off; 1100 1101 for (;;) { 1102 u32 op = len < bytes ? len : bytes; 1103 int err = ntfs_sb_write(sb, lbo, op, buf, 0); 1104 1105 if (err) 1106 return err; 1107 1108 bytes -= op; 1109 if (!bytes) 1110 break; 1111 1112 vcn_next = vcn + clen; 1113 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) || 1114 vcn != vcn_next) 1115 return -ENOENT; 1116 1117 if (lcn == SPARSE_LCN) 1118 return -EINVAL; 1119 1120 if (buf) 1121 buf = Add2Ptr(buf, op); 1122 1123 lbo = ((u64)lcn << cluster_bits); 1124 len = ((u64)clen << cluster_bits); 1125 } 1126 1127 return 0; 1128 } 1129 1130 struct buffer_head *ntfs_bread_run(struct ntfs_sb_info *sbi, 1131 const struct runs_tree *run, u64 vbo) 1132 { 1133 struct super_block *sb = sbi->sb; 1134 u8 cluster_bits = sbi->cluster_bits; 1135 CLST lcn; 1136 u64 lbo; 1137 1138 if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, NULL, NULL)) 1139 return ERR_PTR(-ENOENT); 1140 1141 lbo = ((u64)lcn << cluster_bits) + (vbo & sbi->cluster_mask); 1142 1143 return ntfs_bread(sb, lbo >> sb->s_blocksize_bits); 1144 } 1145 1146 int ntfs_read_run_nb(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1147 u64 vbo, void *buf, u32 bytes, struct ntfs_buffers *nb) 1148 { 1149 int err; 1150 struct super_block *sb = sbi->sb; 1151 u32 blocksize = sb->s_blocksize; 1152 u8 cluster_bits = sbi->cluster_bits; 1153 u32 off = vbo & sbi->cluster_mask; 1154 u32 nbh = 0; 1155 CLST vcn_next, vcn = vbo >> cluster_bits; 1156 CLST lcn, clen; 1157 u64 lbo, len; 1158 size_t idx; 1159 struct buffer_head *bh; 1160 1161 if (!run) { 1162 /* First reading of $Volume + $MFTMirr + $LogFile goes here. */ 1163 if (vbo > MFT_REC_VOL * sbi->record_size) { 1164 err = -ENOENT; 1165 goto out; 1166 } 1167 1168 /* Use absolute boot's 'MFTCluster' to read record. */ 1169 lbo = vbo + sbi->mft.lbo; 1170 len = sbi->record_size; 1171 } else if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) { 1172 err = -ENOENT; 1173 goto out; 1174 } else { 1175 if (lcn == SPARSE_LCN) { 1176 err = -EINVAL; 1177 goto out; 1178 } 1179 1180 lbo = ((u64)lcn << cluster_bits) + off; 1181 len = ((u64)clen << cluster_bits) - off; 1182 } 1183 1184 off = lbo & (blocksize - 1); 1185 if (nb) { 1186 nb->off = off; 1187 nb->bytes = bytes; 1188 } 1189 1190 for (;;) { 1191 u32 len32 = len >= bytes ? bytes : len; 1192 sector_t block = lbo >> sb->s_blocksize_bits; 1193 1194 do { 1195 u32 op = blocksize - off; 1196 1197 if (op > len32) 1198 op = len32; 1199 1200 bh = ntfs_bread(sb, block); 1201 if (!bh) { 1202 err = -EIO; 1203 goto out; 1204 } 1205 1206 if (buf) { 1207 memcpy(buf, bh->b_data + off, op); 1208 buf = Add2Ptr(buf, op); 1209 } 1210 1211 if (!nb) { 1212 put_bh(bh); 1213 } else if (nbh >= ARRAY_SIZE(nb->bh)) { 1214 err = -EINVAL; 1215 goto out; 1216 } else { 1217 nb->bh[nbh++] = bh; 1218 nb->nbufs = nbh; 1219 } 1220 1221 bytes -= op; 1222 if (!bytes) 1223 return 0; 1224 len32 -= op; 1225 block += 1; 1226 off = 0; 1227 1228 } while (len32); 1229 1230 vcn_next = vcn + clen; 1231 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) || 1232 vcn != vcn_next) { 1233 err = -ENOENT; 1234 goto out; 1235 } 1236 1237 if (lcn == SPARSE_LCN) { 1238 err = -EINVAL; 1239 goto out; 1240 } 1241 1242 lbo = ((u64)lcn << cluster_bits); 1243 len = ((u64)clen << cluster_bits); 1244 } 1245 1246 out: 1247 if (!nbh) 1248 return err; 1249 1250 while (nbh) { 1251 put_bh(nb->bh[--nbh]); 1252 nb->bh[nbh] = NULL; 1253 } 1254 1255 nb->nbufs = 0; 1256 return err; 1257 } 1258 1259 /* 1260 * ntfs_read_bh 1261 * 1262 * Return: < 0 if error, 0 if ok, -E_NTFS_FIXUP if need to update fixups. 1263 */ 1264 int ntfs_read_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo, 1265 struct NTFS_RECORD_HEADER *rhdr, u32 bytes, 1266 struct ntfs_buffers *nb) 1267 { 1268 int err = ntfs_read_run_nb(sbi, run, vbo, rhdr, bytes, nb); 1269 1270 if (err) 1271 return err; 1272 return ntfs_fix_post_read(rhdr, nb->bytes, true); 1273 } 1274 1275 int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo, 1276 u32 bytes, struct ntfs_buffers *nb) 1277 { 1278 int err = 0; 1279 struct super_block *sb = sbi->sb; 1280 u32 blocksize = sb->s_blocksize; 1281 u8 cluster_bits = sbi->cluster_bits; 1282 CLST vcn_next, vcn = vbo >> cluster_bits; 1283 u32 off; 1284 u32 nbh = 0; 1285 CLST lcn, clen; 1286 u64 lbo, len; 1287 size_t idx; 1288 1289 nb->bytes = bytes; 1290 1291 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) { 1292 err = -ENOENT; 1293 goto out; 1294 } 1295 1296 off = vbo & sbi->cluster_mask; 1297 lbo = ((u64)lcn << cluster_bits) + off; 1298 len = ((u64)clen << cluster_bits) - off; 1299 1300 nb->off = off = lbo & (blocksize - 1); 1301 1302 for (;;) { 1303 u32 len32 = len < bytes ? len : bytes; 1304 sector_t block = lbo >> sb->s_blocksize_bits; 1305 1306 do { 1307 u32 op; 1308 struct buffer_head *bh; 1309 1310 if (nbh >= ARRAY_SIZE(nb->bh)) { 1311 err = -EINVAL; 1312 goto out; 1313 } 1314 1315 op = blocksize - off; 1316 if (op > len32) 1317 op = len32; 1318 1319 if (op == blocksize) { 1320 bh = sb_getblk(sb, block); 1321 if (!bh) { 1322 err = -ENOMEM; 1323 goto out; 1324 } 1325 if (buffer_locked(bh)) 1326 __wait_on_buffer(bh); 1327 set_buffer_uptodate(bh); 1328 } else { 1329 bh = ntfs_bread(sb, block); 1330 if (!bh) { 1331 err = -EIO; 1332 goto out; 1333 } 1334 } 1335 1336 nb->bh[nbh++] = bh; 1337 bytes -= op; 1338 if (!bytes) { 1339 nb->nbufs = nbh; 1340 return 0; 1341 } 1342 1343 block += 1; 1344 len32 -= op; 1345 off = 0; 1346 } while (len32); 1347 1348 vcn_next = vcn + clen; 1349 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) || 1350 vcn != vcn_next) { 1351 err = -ENOENT; 1352 goto out; 1353 } 1354 1355 lbo = ((u64)lcn << cluster_bits); 1356 len = ((u64)clen << cluster_bits); 1357 } 1358 1359 out: 1360 while (nbh) { 1361 put_bh(nb->bh[--nbh]); 1362 nb->bh[nbh] = NULL; 1363 } 1364 1365 nb->nbufs = 0; 1366 1367 return err; 1368 } 1369 1370 int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr, 1371 struct ntfs_buffers *nb, int sync) 1372 { 1373 int err = 0; 1374 struct super_block *sb = sbi->sb; 1375 u32 block_size = sb->s_blocksize; 1376 u32 bytes = nb->bytes; 1377 u32 off = nb->off; 1378 u16 fo = le16_to_cpu(rhdr->fix_off); 1379 u16 fn = le16_to_cpu(rhdr->fix_num); 1380 u32 idx; 1381 __le16 *fixup; 1382 __le16 sample; 1383 1384 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || 1385 fn * SECTOR_SIZE > bytes) { 1386 return -EINVAL; 1387 } 1388 1389 for (idx = 0; bytes && idx < nb->nbufs; idx += 1, off = 0) { 1390 u32 op = block_size - off; 1391 char *bh_data; 1392 struct buffer_head *bh = nb->bh[idx]; 1393 __le16 *ptr, *end_data; 1394 1395 if (op > bytes) 1396 op = bytes; 1397 1398 if (buffer_locked(bh)) 1399 __wait_on_buffer(bh); 1400 1401 lock_buffer(nb->bh[idx]); 1402 1403 bh_data = bh->b_data + off; 1404 end_data = Add2Ptr(bh_data, op); 1405 memcpy(bh_data, rhdr, op); 1406 1407 if (!idx) { 1408 u16 t16; 1409 1410 fixup = Add2Ptr(bh_data, fo); 1411 sample = *fixup; 1412 t16 = le16_to_cpu(sample); 1413 if (t16 >= 0x7FFF) { 1414 sample = *fixup = cpu_to_le16(1); 1415 } else { 1416 sample = cpu_to_le16(t16 + 1); 1417 *fixup = sample; 1418 } 1419 1420 *(__le16 *)Add2Ptr(rhdr, fo) = sample; 1421 } 1422 1423 ptr = Add2Ptr(bh_data, SECTOR_SIZE - sizeof(short)); 1424 1425 do { 1426 *++fixup = *ptr; 1427 *ptr = sample; 1428 ptr += SECTOR_SIZE / sizeof(short); 1429 } while (ptr < end_data); 1430 1431 set_buffer_uptodate(bh); 1432 mark_buffer_dirty(bh); 1433 unlock_buffer(bh); 1434 1435 if (sync) { 1436 int err2 = sync_dirty_buffer(bh); 1437 1438 if (!err && err2) 1439 err = err2; 1440 } 1441 1442 bytes -= op; 1443 rhdr = Add2Ptr(rhdr, op); 1444 } 1445 1446 return err; 1447 } 1448 1449 static inline struct bio *ntfs_alloc_bio(u32 nr_vecs) 1450 { 1451 struct bio *bio = bio_alloc(GFP_NOFS | __GFP_HIGH, nr_vecs); 1452 1453 if (!bio && (current->flags & PF_MEMALLOC)) { 1454 while (!bio && (nr_vecs /= 2)) 1455 bio = bio_alloc(GFP_NOFS | __GFP_HIGH, nr_vecs); 1456 } 1457 return bio; 1458 } 1459 1460 /* 1461 * ntfs_bio_pages - Read/write pages from/to disk. 1462 */ 1463 int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1464 struct page **pages, u32 nr_pages, u64 vbo, u32 bytes, 1465 u32 op) 1466 { 1467 int err = 0; 1468 struct bio *new, *bio = NULL; 1469 struct super_block *sb = sbi->sb; 1470 struct block_device *bdev = sb->s_bdev; 1471 struct page *page; 1472 u8 cluster_bits = sbi->cluster_bits; 1473 CLST lcn, clen, vcn, vcn_next; 1474 u32 add, off, page_idx; 1475 u64 lbo, len; 1476 size_t run_idx; 1477 struct blk_plug plug; 1478 1479 if (!bytes) 1480 return 0; 1481 1482 blk_start_plug(&plug); 1483 1484 /* Align vbo and bytes to be 512 bytes aligned. */ 1485 lbo = (vbo + bytes + 511) & ~511ull; 1486 vbo = vbo & ~511ull; 1487 bytes = lbo - vbo; 1488 1489 vcn = vbo >> cluster_bits; 1490 if (!run_lookup_entry(run, vcn, &lcn, &clen, &run_idx)) { 1491 err = -ENOENT; 1492 goto out; 1493 } 1494 off = vbo & sbi->cluster_mask; 1495 page_idx = 0; 1496 page = pages[0]; 1497 1498 for (;;) { 1499 lbo = ((u64)lcn << cluster_bits) + off; 1500 len = ((u64)clen << cluster_bits) - off; 1501 new_bio: 1502 new = ntfs_alloc_bio(nr_pages - page_idx); 1503 if (!new) { 1504 err = -ENOMEM; 1505 goto out; 1506 } 1507 if (bio) { 1508 bio_chain(bio, new); 1509 submit_bio(bio); 1510 } 1511 bio = new; 1512 bio_set_dev(bio, bdev); 1513 bio->bi_iter.bi_sector = lbo >> 9; 1514 bio->bi_opf = op; 1515 1516 while (len) { 1517 off = vbo & (PAGE_SIZE - 1); 1518 add = off + len > PAGE_SIZE ? (PAGE_SIZE - off) : len; 1519 1520 if (bio_add_page(bio, page, add, off) < add) 1521 goto new_bio; 1522 1523 if (bytes <= add) 1524 goto out; 1525 bytes -= add; 1526 vbo += add; 1527 1528 if (add + off == PAGE_SIZE) { 1529 page_idx += 1; 1530 if (WARN_ON(page_idx >= nr_pages)) { 1531 err = -EINVAL; 1532 goto out; 1533 } 1534 page = pages[page_idx]; 1535 } 1536 1537 if (len <= add) 1538 break; 1539 len -= add; 1540 lbo += add; 1541 } 1542 1543 vcn_next = vcn + clen; 1544 if (!run_get_entry(run, ++run_idx, &vcn, &lcn, &clen) || 1545 vcn != vcn_next) { 1546 err = -ENOENT; 1547 goto out; 1548 } 1549 off = 0; 1550 } 1551 out: 1552 if (bio) { 1553 if (!err) 1554 err = submit_bio_wait(bio); 1555 bio_put(bio); 1556 } 1557 blk_finish_plug(&plug); 1558 1559 return err; 1560 } 1561 1562 /* 1563 * ntfs_bio_fill_1 - Helper for ntfs_loadlog_and_replay(). 1564 * 1565 * Fill on-disk logfile range by (-1) 1566 * this means empty logfile. 1567 */ 1568 int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run) 1569 { 1570 int err = 0; 1571 struct super_block *sb = sbi->sb; 1572 struct block_device *bdev = sb->s_bdev; 1573 u8 cluster_bits = sbi->cluster_bits; 1574 struct bio *new, *bio = NULL; 1575 CLST lcn, clen; 1576 u64 lbo, len; 1577 size_t run_idx; 1578 struct page *fill; 1579 void *kaddr; 1580 struct blk_plug plug; 1581 1582 fill = alloc_page(GFP_KERNEL); 1583 if (!fill) 1584 return -ENOMEM; 1585 1586 kaddr = kmap_atomic(fill); 1587 memset(kaddr, -1, PAGE_SIZE); 1588 kunmap_atomic(kaddr); 1589 flush_dcache_page(fill); 1590 lock_page(fill); 1591 1592 if (!run_lookup_entry(run, 0, &lcn, &clen, &run_idx)) { 1593 err = -ENOENT; 1594 goto out; 1595 } 1596 1597 /* 1598 * TODO: Try blkdev_issue_write_same. 1599 */ 1600 blk_start_plug(&plug); 1601 do { 1602 lbo = (u64)lcn << cluster_bits; 1603 len = (u64)clen << cluster_bits; 1604 new_bio: 1605 new = ntfs_alloc_bio(BIO_MAX_VECS); 1606 if (!new) { 1607 err = -ENOMEM; 1608 break; 1609 } 1610 if (bio) { 1611 bio_chain(bio, new); 1612 submit_bio(bio); 1613 } 1614 bio = new; 1615 bio_set_dev(bio, bdev); 1616 bio->bi_opf = REQ_OP_WRITE; 1617 bio->bi_iter.bi_sector = lbo >> 9; 1618 1619 for (;;) { 1620 u32 add = len > PAGE_SIZE ? PAGE_SIZE : len; 1621 1622 if (bio_add_page(bio, fill, add, 0) < add) 1623 goto new_bio; 1624 1625 lbo += add; 1626 if (len <= add) 1627 break; 1628 len -= add; 1629 } 1630 } while (run_get_entry(run, ++run_idx, NULL, &lcn, &clen)); 1631 1632 if (bio) { 1633 if (!err) 1634 err = submit_bio_wait(bio); 1635 bio_put(bio); 1636 } 1637 blk_finish_plug(&plug); 1638 out: 1639 unlock_page(fill); 1640 put_page(fill); 1641 1642 return err; 1643 } 1644 1645 int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1646 u64 vbo, u64 *lbo, u64 *bytes) 1647 { 1648 u32 off; 1649 CLST lcn, len; 1650 u8 cluster_bits = sbi->cluster_bits; 1651 1652 if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &len, NULL)) 1653 return -ENOENT; 1654 1655 off = vbo & sbi->cluster_mask; 1656 *lbo = lcn == SPARSE_LCN ? -1 : (((u64)lcn << cluster_bits) + off); 1657 *bytes = ((u64)len << cluster_bits) - off; 1658 1659 return 0; 1660 } 1661 1662 struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST rno, bool dir) 1663 { 1664 int err = 0; 1665 struct super_block *sb = sbi->sb; 1666 struct inode *inode = new_inode(sb); 1667 struct ntfs_inode *ni; 1668 1669 if (!inode) 1670 return ERR_PTR(-ENOMEM); 1671 1672 ni = ntfs_i(inode); 1673 1674 err = mi_format_new(&ni->mi, sbi, rno, dir ? RECORD_FLAG_DIR : 0, 1675 false); 1676 if (err) 1677 goto out; 1678 1679 inode->i_ino = rno; 1680 if (insert_inode_locked(inode) < 0) { 1681 err = -EIO; 1682 goto out; 1683 } 1684 1685 out: 1686 if (err) { 1687 iput(inode); 1688 ni = ERR_PTR(err); 1689 } 1690 return ni; 1691 } 1692 1693 /* 1694 * O:BAG:BAD:(A;OICI;FA;;;WD) 1695 * Owner S-1-5-32-544 (Administrators) 1696 * Group S-1-5-32-544 (Administrators) 1697 * ACE: allow S-1-1-0 (Everyone) with FILE_ALL_ACCESS 1698 */ 1699 const u8 s_default_security[] __aligned(8) = { 1700 0x01, 0x00, 0x04, 0x80, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 1701 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1C, 0x00, 1702 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x14, 0x00, 0xFF, 0x01, 0x1F, 0x00, 1703 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 1704 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x20, 0x00, 0x00, 0x00, 1705 0x20, 0x02, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 1706 0x20, 0x00, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 1707 }; 1708 1709 static_assert(sizeof(s_default_security) == 0x50); 1710 1711 static inline u32 sid_length(const struct SID *sid) 1712 { 1713 return struct_size(sid, SubAuthority, sid->SubAuthorityCount); 1714 } 1715 1716 /* 1717 * is_acl_valid 1718 * 1719 * Thanks Mark Harmstone for idea. 1720 */ 1721 static bool is_acl_valid(const struct ACL *acl, u32 len) 1722 { 1723 const struct ACE_HEADER *ace; 1724 u32 i; 1725 u16 ace_count, ace_size; 1726 1727 if (acl->AclRevision != ACL_REVISION && 1728 acl->AclRevision != ACL_REVISION_DS) { 1729 /* 1730 * This value should be ACL_REVISION, unless the ACL contains an 1731 * object-specific ACE, in which case this value must be ACL_REVISION_DS. 1732 * All ACEs in an ACL must be at the same revision level. 1733 */ 1734 return false; 1735 } 1736 1737 if (acl->Sbz1) 1738 return false; 1739 1740 if (le16_to_cpu(acl->AclSize) > len) 1741 return false; 1742 1743 if (acl->Sbz2) 1744 return false; 1745 1746 len -= sizeof(struct ACL); 1747 ace = (struct ACE_HEADER *)&acl[1]; 1748 ace_count = le16_to_cpu(acl->AceCount); 1749 1750 for (i = 0; i < ace_count; i++) { 1751 if (len < sizeof(struct ACE_HEADER)) 1752 return false; 1753 1754 ace_size = le16_to_cpu(ace->AceSize); 1755 if (len < ace_size) 1756 return false; 1757 1758 len -= ace_size; 1759 ace = Add2Ptr(ace, ace_size); 1760 } 1761 1762 return true; 1763 } 1764 1765 bool is_sd_valid(const struct SECURITY_DESCRIPTOR_RELATIVE *sd, u32 len) 1766 { 1767 u32 sd_owner, sd_group, sd_sacl, sd_dacl; 1768 1769 if (len < sizeof(struct SECURITY_DESCRIPTOR_RELATIVE)) 1770 return false; 1771 1772 if (sd->Revision != 1) 1773 return false; 1774 1775 if (sd->Sbz1) 1776 return false; 1777 1778 if (!(sd->Control & SE_SELF_RELATIVE)) 1779 return false; 1780 1781 sd_owner = le32_to_cpu(sd->Owner); 1782 if (sd_owner) { 1783 const struct SID *owner = Add2Ptr(sd, sd_owner); 1784 1785 if (sd_owner + offsetof(struct SID, SubAuthority) > len) 1786 return false; 1787 1788 if (owner->Revision != 1) 1789 return false; 1790 1791 if (sd_owner + sid_length(owner) > len) 1792 return false; 1793 } 1794 1795 sd_group = le32_to_cpu(sd->Group); 1796 if (sd_group) { 1797 const struct SID *group = Add2Ptr(sd, sd_group); 1798 1799 if (sd_group + offsetof(struct SID, SubAuthority) > len) 1800 return false; 1801 1802 if (group->Revision != 1) 1803 return false; 1804 1805 if (sd_group + sid_length(group) > len) 1806 return false; 1807 } 1808 1809 sd_sacl = le32_to_cpu(sd->Sacl); 1810 if (sd_sacl) { 1811 const struct ACL *sacl = Add2Ptr(sd, sd_sacl); 1812 1813 if (sd_sacl + sizeof(struct ACL) > len) 1814 return false; 1815 1816 if (!is_acl_valid(sacl, len - sd_sacl)) 1817 return false; 1818 } 1819 1820 sd_dacl = le32_to_cpu(sd->Dacl); 1821 if (sd_dacl) { 1822 const struct ACL *dacl = Add2Ptr(sd, sd_dacl); 1823 1824 if (sd_dacl + sizeof(struct ACL) > len) 1825 return false; 1826 1827 if (!is_acl_valid(dacl, len - sd_dacl)) 1828 return false; 1829 } 1830 1831 return true; 1832 } 1833 1834 /* 1835 * ntfs_security_init - Load and parse $Secure. 1836 */ 1837 int ntfs_security_init(struct ntfs_sb_info *sbi) 1838 { 1839 int err; 1840 struct super_block *sb = sbi->sb; 1841 struct inode *inode; 1842 struct ntfs_inode *ni; 1843 struct MFT_REF ref; 1844 struct ATTRIB *attr; 1845 struct ATTR_LIST_ENTRY *le; 1846 u64 sds_size; 1847 size_t off; 1848 struct NTFS_DE *ne; 1849 struct NTFS_DE_SII *sii_e; 1850 struct ntfs_fnd *fnd_sii = NULL; 1851 const struct INDEX_ROOT *root_sii; 1852 const struct INDEX_ROOT *root_sdh; 1853 struct ntfs_index *indx_sdh = &sbi->security.index_sdh; 1854 struct ntfs_index *indx_sii = &sbi->security.index_sii; 1855 1856 ref.low = cpu_to_le32(MFT_REC_SECURE); 1857 ref.high = 0; 1858 ref.seq = cpu_to_le16(MFT_REC_SECURE); 1859 1860 inode = ntfs_iget5(sb, &ref, &NAME_SECURE); 1861 if (IS_ERR(inode)) { 1862 err = PTR_ERR(inode); 1863 ntfs_err(sb, "Failed to load $Secure."); 1864 inode = NULL; 1865 goto out; 1866 } 1867 1868 ni = ntfs_i(inode); 1869 1870 le = NULL; 1871 1872 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SDH_NAME, 1873 ARRAY_SIZE(SDH_NAME), NULL, NULL); 1874 if (!attr) { 1875 err = -EINVAL; 1876 goto out; 1877 } 1878 1879 root_sdh = resident_data(attr); 1880 if (root_sdh->type != ATTR_ZERO || 1881 root_sdh->rule != NTFS_COLLATION_TYPE_SECURITY_HASH) { 1882 err = -EINVAL; 1883 goto out; 1884 } 1885 1886 err = indx_init(indx_sdh, sbi, attr, INDEX_MUTEX_SDH); 1887 if (err) 1888 goto out; 1889 1890 attr = ni_find_attr(ni, attr, &le, ATTR_ROOT, SII_NAME, 1891 ARRAY_SIZE(SII_NAME), NULL, NULL); 1892 if (!attr) { 1893 err = -EINVAL; 1894 goto out; 1895 } 1896 1897 root_sii = resident_data(attr); 1898 if (root_sii->type != ATTR_ZERO || 1899 root_sii->rule != NTFS_COLLATION_TYPE_UINT) { 1900 err = -EINVAL; 1901 goto out; 1902 } 1903 1904 err = indx_init(indx_sii, sbi, attr, INDEX_MUTEX_SII); 1905 if (err) 1906 goto out; 1907 1908 fnd_sii = fnd_get(); 1909 if (!fnd_sii) { 1910 err = -ENOMEM; 1911 goto out; 1912 } 1913 1914 sds_size = inode->i_size; 1915 1916 /* Find the last valid Id. */ 1917 sbi->security.next_id = SECURITY_ID_FIRST; 1918 /* Always write new security at the end of bucket. */ 1919 sbi->security.next_off = 1920 ALIGN(sds_size - SecurityDescriptorsBlockSize, 16); 1921 1922 off = 0; 1923 ne = NULL; 1924 1925 for (;;) { 1926 u32 next_id; 1927 1928 err = indx_find_raw(indx_sii, ni, root_sii, &ne, &off, fnd_sii); 1929 if (err || !ne) 1930 break; 1931 1932 sii_e = (struct NTFS_DE_SII *)ne; 1933 if (le16_to_cpu(ne->view.data_size) < SIZEOF_SECURITY_HDR) 1934 continue; 1935 1936 next_id = le32_to_cpu(sii_e->sec_id) + 1; 1937 if (next_id >= sbi->security.next_id) 1938 sbi->security.next_id = next_id; 1939 } 1940 1941 sbi->security.ni = ni; 1942 inode = NULL; 1943 out: 1944 iput(inode); 1945 fnd_put(fnd_sii); 1946 1947 return err; 1948 } 1949 1950 /* 1951 * ntfs_get_security_by_id - Read security descriptor by id. 1952 */ 1953 int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id, 1954 struct SECURITY_DESCRIPTOR_RELATIVE **sd, 1955 size_t *size) 1956 { 1957 int err; 1958 int diff; 1959 struct ntfs_inode *ni = sbi->security.ni; 1960 struct ntfs_index *indx = &sbi->security.index_sii; 1961 void *p = NULL; 1962 struct NTFS_DE_SII *sii_e; 1963 struct ntfs_fnd *fnd_sii; 1964 struct SECURITY_HDR d_security; 1965 const struct INDEX_ROOT *root_sii; 1966 u32 t32; 1967 1968 *sd = NULL; 1969 1970 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY); 1971 1972 fnd_sii = fnd_get(); 1973 if (!fnd_sii) { 1974 err = -ENOMEM; 1975 goto out; 1976 } 1977 1978 root_sii = indx_get_root(indx, ni, NULL, NULL); 1979 if (!root_sii) { 1980 err = -EINVAL; 1981 goto out; 1982 } 1983 1984 /* Try to find this SECURITY descriptor in SII indexes. */ 1985 err = indx_find(indx, ni, root_sii, &security_id, sizeof(security_id), 1986 NULL, &diff, (struct NTFS_DE **)&sii_e, fnd_sii); 1987 if (err) 1988 goto out; 1989 1990 if (diff) 1991 goto out; 1992 1993 t32 = le32_to_cpu(sii_e->sec_hdr.size); 1994 if (t32 < SIZEOF_SECURITY_HDR) { 1995 err = -EINVAL; 1996 goto out; 1997 } 1998 1999 if (t32 > SIZEOF_SECURITY_HDR + 0x10000) { 2000 /* Looks like too big security. 0x10000 - is arbitrary big number. */ 2001 err = -EFBIG; 2002 goto out; 2003 } 2004 2005 *size = t32 - SIZEOF_SECURITY_HDR; 2006 2007 p = kmalloc(*size, GFP_NOFS); 2008 if (!p) { 2009 err = -ENOMEM; 2010 goto out; 2011 } 2012 2013 err = ntfs_read_run_nb(sbi, &ni->file.run, 2014 le64_to_cpu(sii_e->sec_hdr.off), &d_security, 2015 sizeof(d_security), NULL); 2016 if (err) 2017 goto out; 2018 2019 if (memcmp(&d_security, &sii_e->sec_hdr, SIZEOF_SECURITY_HDR)) { 2020 err = -EINVAL; 2021 goto out; 2022 } 2023 2024 err = ntfs_read_run_nb(sbi, &ni->file.run, 2025 le64_to_cpu(sii_e->sec_hdr.off) + 2026 SIZEOF_SECURITY_HDR, 2027 p, *size, NULL); 2028 if (err) 2029 goto out; 2030 2031 *sd = p; 2032 p = NULL; 2033 2034 out: 2035 kfree(p); 2036 fnd_put(fnd_sii); 2037 ni_unlock(ni); 2038 2039 return err; 2040 } 2041 2042 /* 2043 * ntfs_insert_security - Insert security descriptor into $Secure::SDS. 2044 * 2045 * SECURITY Descriptor Stream data is organized into chunks of 256K bytes 2046 * and it contains a mirror copy of each security descriptor. When writing 2047 * to a security descriptor at location X, another copy will be written at 2048 * location (X+256K). 2049 * When writing a security descriptor that will cross the 256K boundary, 2050 * the pointer will be advanced by 256K to skip 2051 * over the mirror portion. 2052 */ 2053 int ntfs_insert_security(struct ntfs_sb_info *sbi, 2054 const struct SECURITY_DESCRIPTOR_RELATIVE *sd, 2055 u32 size_sd, __le32 *security_id, bool *inserted) 2056 { 2057 int err, diff; 2058 struct ntfs_inode *ni = sbi->security.ni; 2059 struct ntfs_index *indx_sdh = &sbi->security.index_sdh; 2060 struct ntfs_index *indx_sii = &sbi->security.index_sii; 2061 struct NTFS_DE_SDH *e; 2062 struct NTFS_DE_SDH sdh_e; 2063 struct NTFS_DE_SII sii_e; 2064 struct SECURITY_HDR *d_security; 2065 u32 new_sec_size = size_sd + SIZEOF_SECURITY_HDR; 2066 u32 aligned_sec_size = ALIGN(new_sec_size, 16); 2067 struct SECURITY_KEY hash_key; 2068 struct ntfs_fnd *fnd_sdh = NULL; 2069 const struct INDEX_ROOT *root_sdh; 2070 const struct INDEX_ROOT *root_sii; 2071 u64 mirr_off, new_sds_size; 2072 u32 next, left; 2073 2074 static_assert((1 << Log2OfSecurityDescriptorsBlockSize) == 2075 SecurityDescriptorsBlockSize); 2076 2077 hash_key.hash = security_hash(sd, size_sd); 2078 hash_key.sec_id = SECURITY_ID_INVALID; 2079 2080 if (inserted) 2081 *inserted = false; 2082 *security_id = SECURITY_ID_INVALID; 2083 2084 /* Allocate a temporal buffer. */ 2085 d_security = kzalloc(aligned_sec_size, GFP_NOFS); 2086 if (!d_security) 2087 return -ENOMEM; 2088 2089 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY); 2090 2091 fnd_sdh = fnd_get(); 2092 if (!fnd_sdh) { 2093 err = -ENOMEM; 2094 goto out; 2095 } 2096 2097 root_sdh = indx_get_root(indx_sdh, ni, NULL, NULL); 2098 if (!root_sdh) { 2099 err = -EINVAL; 2100 goto out; 2101 } 2102 2103 root_sii = indx_get_root(indx_sii, ni, NULL, NULL); 2104 if (!root_sii) { 2105 err = -EINVAL; 2106 goto out; 2107 } 2108 2109 /* 2110 * Check if such security already exists. 2111 * Use "SDH" and hash -> to get the offset in "SDS". 2112 */ 2113 err = indx_find(indx_sdh, ni, root_sdh, &hash_key, sizeof(hash_key), 2114 &d_security->key.sec_id, &diff, (struct NTFS_DE **)&e, 2115 fnd_sdh); 2116 if (err) 2117 goto out; 2118 2119 while (e) { 2120 if (le32_to_cpu(e->sec_hdr.size) == new_sec_size) { 2121 err = ntfs_read_run_nb(sbi, &ni->file.run, 2122 le64_to_cpu(e->sec_hdr.off), 2123 d_security, new_sec_size, NULL); 2124 if (err) 2125 goto out; 2126 2127 if (le32_to_cpu(d_security->size) == new_sec_size && 2128 d_security->key.hash == hash_key.hash && 2129 !memcmp(d_security + 1, sd, size_sd)) { 2130 *security_id = d_security->key.sec_id; 2131 /* Such security already exists. */ 2132 err = 0; 2133 goto out; 2134 } 2135 } 2136 2137 err = indx_find_sort(indx_sdh, ni, root_sdh, 2138 (struct NTFS_DE **)&e, fnd_sdh); 2139 if (err) 2140 goto out; 2141 2142 if (!e || e->key.hash != hash_key.hash) 2143 break; 2144 } 2145 2146 /* Zero unused space. */ 2147 next = sbi->security.next_off & (SecurityDescriptorsBlockSize - 1); 2148 left = SecurityDescriptorsBlockSize - next; 2149 2150 /* Zero gap until SecurityDescriptorsBlockSize. */ 2151 if (left < new_sec_size) { 2152 /* Zero "left" bytes from sbi->security.next_off. */ 2153 sbi->security.next_off += SecurityDescriptorsBlockSize + left; 2154 } 2155 2156 /* Zero tail of previous security. */ 2157 //used = ni->vfs_inode.i_size & (SecurityDescriptorsBlockSize - 1); 2158 2159 /* 2160 * Example: 2161 * 0x40438 == ni->vfs_inode.i_size 2162 * 0x00440 == sbi->security.next_off 2163 * need to zero [0x438-0x440) 2164 * if (next > used) { 2165 * u32 tozero = next - used; 2166 * zero "tozero" bytes from sbi->security.next_off - tozero 2167 */ 2168 2169 /* Format new security descriptor. */ 2170 d_security->key.hash = hash_key.hash; 2171 d_security->key.sec_id = cpu_to_le32(sbi->security.next_id); 2172 d_security->off = cpu_to_le64(sbi->security.next_off); 2173 d_security->size = cpu_to_le32(new_sec_size); 2174 memcpy(d_security + 1, sd, size_sd); 2175 2176 /* Write main SDS bucket. */ 2177 err = ntfs_sb_write_run(sbi, &ni->file.run, sbi->security.next_off, 2178 d_security, aligned_sec_size); 2179 2180 if (err) 2181 goto out; 2182 2183 mirr_off = sbi->security.next_off + SecurityDescriptorsBlockSize; 2184 new_sds_size = mirr_off + aligned_sec_size; 2185 2186 if (new_sds_size > ni->vfs_inode.i_size) { 2187 err = attr_set_size(ni, ATTR_DATA, SDS_NAME, 2188 ARRAY_SIZE(SDS_NAME), &ni->file.run, 2189 new_sds_size, &new_sds_size, false, NULL); 2190 if (err) 2191 goto out; 2192 } 2193 2194 /* Write copy SDS bucket. */ 2195 err = ntfs_sb_write_run(sbi, &ni->file.run, mirr_off, d_security, 2196 aligned_sec_size); 2197 if (err) 2198 goto out; 2199 2200 /* Fill SII entry. */ 2201 sii_e.de.view.data_off = 2202 cpu_to_le16(offsetof(struct NTFS_DE_SII, sec_hdr)); 2203 sii_e.de.view.data_size = cpu_to_le16(SIZEOF_SECURITY_HDR); 2204 sii_e.de.view.res = 0; 2205 sii_e.de.size = cpu_to_le16(SIZEOF_SII_DIRENTRY); 2206 sii_e.de.key_size = cpu_to_le16(sizeof(d_security->key.sec_id)); 2207 sii_e.de.flags = 0; 2208 sii_e.de.res = 0; 2209 sii_e.sec_id = d_security->key.sec_id; 2210 memcpy(&sii_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR); 2211 2212 err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL, 0); 2213 if (err) 2214 goto out; 2215 2216 /* Fill SDH entry. */ 2217 sdh_e.de.view.data_off = 2218 cpu_to_le16(offsetof(struct NTFS_DE_SDH, sec_hdr)); 2219 sdh_e.de.view.data_size = cpu_to_le16(SIZEOF_SECURITY_HDR); 2220 sdh_e.de.view.res = 0; 2221 sdh_e.de.size = cpu_to_le16(SIZEOF_SDH_DIRENTRY); 2222 sdh_e.de.key_size = cpu_to_le16(sizeof(sdh_e.key)); 2223 sdh_e.de.flags = 0; 2224 sdh_e.de.res = 0; 2225 sdh_e.key.hash = d_security->key.hash; 2226 sdh_e.key.sec_id = d_security->key.sec_id; 2227 memcpy(&sdh_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR); 2228 sdh_e.magic[0] = cpu_to_le16('I'); 2229 sdh_e.magic[1] = cpu_to_le16('I'); 2230 2231 fnd_clear(fnd_sdh); 2232 err = indx_insert_entry(indx_sdh, ni, &sdh_e.de, (void *)(size_t)1, 2233 fnd_sdh, 0); 2234 if (err) 2235 goto out; 2236 2237 *security_id = d_security->key.sec_id; 2238 if (inserted) 2239 *inserted = true; 2240 2241 /* Update Id and offset for next descriptor. */ 2242 sbi->security.next_id += 1; 2243 sbi->security.next_off += aligned_sec_size; 2244 2245 out: 2246 fnd_put(fnd_sdh); 2247 mark_inode_dirty(&ni->vfs_inode); 2248 ni_unlock(ni); 2249 kfree(d_security); 2250 2251 return err; 2252 } 2253 2254 /* 2255 * ntfs_reparse_init - Load and parse $Extend/$Reparse. 2256 */ 2257 int ntfs_reparse_init(struct ntfs_sb_info *sbi) 2258 { 2259 int err; 2260 struct ntfs_inode *ni = sbi->reparse.ni; 2261 struct ntfs_index *indx = &sbi->reparse.index_r; 2262 struct ATTRIB *attr; 2263 struct ATTR_LIST_ENTRY *le; 2264 const struct INDEX_ROOT *root_r; 2265 2266 if (!ni) 2267 return 0; 2268 2269 le = NULL; 2270 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SR_NAME, 2271 ARRAY_SIZE(SR_NAME), NULL, NULL); 2272 if (!attr) { 2273 err = -EINVAL; 2274 goto out; 2275 } 2276 2277 root_r = resident_data(attr); 2278 if (root_r->type != ATTR_ZERO || 2279 root_r->rule != NTFS_COLLATION_TYPE_UINTS) { 2280 err = -EINVAL; 2281 goto out; 2282 } 2283 2284 err = indx_init(indx, sbi, attr, INDEX_MUTEX_SR); 2285 if (err) 2286 goto out; 2287 2288 out: 2289 return err; 2290 } 2291 2292 /* 2293 * ntfs_objid_init - Load and parse $Extend/$ObjId. 2294 */ 2295 int ntfs_objid_init(struct ntfs_sb_info *sbi) 2296 { 2297 int err; 2298 struct ntfs_inode *ni = sbi->objid.ni; 2299 struct ntfs_index *indx = &sbi->objid.index_o; 2300 struct ATTRIB *attr; 2301 struct ATTR_LIST_ENTRY *le; 2302 const struct INDEX_ROOT *root; 2303 2304 if (!ni) 2305 return 0; 2306 2307 le = NULL; 2308 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SO_NAME, 2309 ARRAY_SIZE(SO_NAME), NULL, NULL); 2310 if (!attr) { 2311 err = -EINVAL; 2312 goto out; 2313 } 2314 2315 root = resident_data(attr); 2316 if (root->type != ATTR_ZERO || 2317 root->rule != NTFS_COLLATION_TYPE_UINTS) { 2318 err = -EINVAL; 2319 goto out; 2320 } 2321 2322 err = indx_init(indx, sbi, attr, INDEX_MUTEX_SO); 2323 if (err) 2324 goto out; 2325 2326 out: 2327 return err; 2328 } 2329 2330 int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid) 2331 { 2332 int err; 2333 struct ntfs_inode *ni = sbi->objid.ni; 2334 struct ntfs_index *indx = &sbi->objid.index_o; 2335 2336 if (!ni) 2337 return -EINVAL; 2338 2339 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_OBJID); 2340 2341 err = indx_delete_entry(indx, ni, guid, sizeof(*guid), NULL); 2342 2343 mark_inode_dirty(&ni->vfs_inode); 2344 ni_unlock(ni); 2345 2346 return err; 2347 } 2348 2349 int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag, 2350 const struct MFT_REF *ref) 2351 { 2352 int err; 2353 struct ntfs_inode *ni = sbi->reparse.ni; 2354 struct ntfs_index *indx = &sbi->reparse.index_r; 2355 struct NTFS_DE_R re; 2356 2357 if (!ni) 2358 return -EINVAL; 2359 2360 memset(&re, 0, sizeof(re)); 2361 2362 re.de.view.data_off = cpu_to_le16(offsetof(struct NTFS_DE_R, zero)); 2363 re.de.size = cpu_to_le16(sizeof(struct NTFS_DE_R)); 2364 re.de.key_size = cpu_to_le16(sizeof(re.key)); 2365 2366 re.key.ReparseTag = rtag; 2367 memcpy(&re.key.ref, ref, sizeof(*ref)); 2368 2369 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE); 2370 2371 err = indx_insert_entry(indx, ni, &re.de, NULL, NULL, 0); 2372 2373 mark_inode_dirty(&ni->vfs_inode); 2374 ni_unlock(ni); 2375 2376 return err; 2377 } 2378 2379 int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag, 2380 const struct MFT_REF *ref) 2381 { 2382 int err, diff; 2383 struct ntfs_inode *ni = sbi->reparse.ni; 2384 struct ntfs_index *indx = &sbi->reparse.index_r; 2385 struct ntfs_fnd *fnd = NULL; 2386 struct REPARSE_KEY rkey; 2387 struct NTFS_DE_R *re; 2388 struct INDEX_ROOT *root_r; 2389 2390 if (!ni) 2391 return -EINVAL; 2392 2393 rkey.ReparseTag = rtag; 2394 rkey.ref = *ref; 2395 2396 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE); 2397 2398 if (rtag) { 2399 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL); 2400 goto out1; 2401 } 2402 2403 fnd = fnd_get(); 2404 if (!fnd) { 2405 err = -ENOMEM; 2406 goto out1; 2407 } 2408 2409 root_r = indx_get_root(indx, ni, NULL, NULL); 2410 if (!root_r) { 2411 err = -EINVAL; 2412 goto out; 2413 } 2414 2415 /* 1 - forces to ignore rkey.ReparseTag when comparing keys. */ 2416 err = indx_find(indx, ni, root_r, &rkey, sizeof(rkey), (void *)1, &diff, 2417 (struct NTFS_DE **)&re, fnd); 2418 if (err) 2419 goto out; 2420 2421 if (memcmp(&re->key.ref, ref, sizeof(*ref))) { 2422 /* Impossible. Looks like volume corrupt? */ 2423 goto out; 2424 } 2425 2426 memcpy(&rkey, &re->key, sizeof(rkey)); 2427 2428 fnd_put(fnd); 2429 fnd = NULL; 2430 2431 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL); 2432 if (err) 2433 goto out; 2434 2435 out: 2436 fnd_put(fnd); 2437 2438 out1: 2439 mark_inode_dirty(&ni->vfs_inode); 2440 ni_unlock(ni); 2441 2442 return err; 2443 } 2444 2445 static inline void ntfs_unmap_and_discard(struct ntfs_sb_info *sbi, CLST lcn, 2446 CLST len) 2447 { 2448 ntfs_unmap_meta(sbi->sb, lcn, len); 2449 ntfs_discard(sbi, lcn, len); 2450 } 2451 2452 void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim) 2453 { 2454 CLST end, i; 2455 struct wnd_bitmap *wnd = &sbi->used.bitmap; 2456 2457 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS); 2458 if (!wnd_is_used(wnd, lcn, len)) { 2459 ntfs_set_state(sbi, NTFS_DIRTY_ERROR); 2460 2461 end = lcn + len; 2462 len = 0; 2463 for (i = lcn; i < end; i++) { 2464 if (wnd_is_used(wnd, i, 1)) { 2465 if (!len) 2466 lcn = i; 2467 len += 1; 2468 continue; 2469 } 2470 2471 if (!len) 2472 continue; 2473 2474 if (trim) 2475 ntfs_unmap_and_discard(sbi, lcn, len); 2476 2477 wnd_set_free(wnd, lcn, len); 2478 len = 0; 2479 } 2480 2481 if (!len) 2482 goto out; 2483 } 2484 2485 if (trim) 2486 ntfs_unmap_and_discard(sbi, lcn, len); 2487 wnd_set_free(wnd, lcn, len); 2488 2489 out: 2490 up_write(&wnd->rw_lock); 2491 } 2492 2493 /* 2494 * run_deallocate - Deallocate clusters. 2495 */ 2496 int run_deallocate(struct ntfs_sb_info *sbi, struct runs_tree *run, bool trim) 2497 { 2498 CLST lcn, len; 2499 size_t idx = 0; 2500 2501 while (run_get_entry(run, idx++, NULL, &lcn, &len)) { 2502 if (lcn == SPARSE_LCN) 2503 continue; 2504 2505 mark_as_free_ex(sbi, lcn, len, trim); 2506 } 2507 2508 return 0; 2509 } 2510