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