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 = ntfs3_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 unlikely(ntfs3_forced_shutdown(sb))) 858 return; 859 860 blocksize = sb->s_blocksize; 861 bytes = sbi->mft.recs_mirr << sbi->record_bits; 862 block1 = sbi->mft.lbo >> sb->s_blocksize_bits; 863 block2 = sbi->mft.lbo2 >> sb->s_blocksize_bits; 864 865 for (; bytes >= blocksize; bytes -= blocksize) { 866 struct buffer_head *bh1, *bh2; 867 868 bh1 = sb_bread(sb, block1++); 869 if (!bh1) 870 return; 871 872 bh2 = sb_getblk(sb, block2++); 873 if (!bh2) { 874 put_bh(bh1); 875 return; 876 } 877 878 if (buffer_locked(bh2)) 879 __wait_on_buffer(bh2); 880 881 lock_buffer(bh2); 882 memcpy(bh2->b_data, bh1->b_data, blocksize); 883 set_buffer_uptodate(bh2); 884 mark_buffer_dirty(bh2); 885 unlock_buffer(bh2); 886 887 put_bh(bh1); 888 bh1 = NULL; 889 890 err = wait ? sync_dirty_buffer(bh2) : 0; 891 892 put_bh(bh2); 893 if (err) 894 return; 895 } 896 897 sbi->flags &= ~NTFS_FLAGS_MFTMIRR; 898 } 899 900 /* 901 * ntfs_bad_inode 902 * 903 * Marks inode as bad and marks fs as 'dirty' 904 */ 905 void ntfs_bad_inode(struct inode *inode, const char *hint) 906 { 907 struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info; 908 909 ntfs_inode_err(inode, "%s", hint); 910 make_bad_inode(inode); 911 ntfs_set_state(sbi, NTFS_DIRTY_ERROR); 912 } 913 914 /* 915 * ntfs_set_state 916 * 917 * Mount: ntfs_set_state(NTFS_DIRTY_DIRTY) 918 * Umount: ntfs_set_state(NTFS_DIRTY_CLEAR) 919 * NTFS error: ntfs_set_state(NTFS_DIRTY_ERROR) 920 */ 921 int ntfs_set_state(struct ntfs_sb_info *sbi, enum NTFS_DIRTY_FLAGS dirty) 922 { 923 int err; 924 struct ATTRIB *attr; 925 struct VOLUME_INFO *info; 926 struct mft_inode *mi; 927 struct ntfs_inode *ni; 928 __le16 info_flags; 929 930 /* 931 * Do not change state if fs was real_dirty. 932 * Do not change state if fs already dirty(clear). 933 * Do not change any thing if mounted read only. 934 */ 935 if (sbi->volume.real_dirty || sb_rdonly(sbi->sb)) 936 return 0; 937 938 /* Check cached value. */ 939 if ((dirty == NTFS_DIRTY_CLEAR ? 0 : VOLUME_FLAG_DIRTY) == 940 (sbi->volume.flags & VOLUME_FLAG_DIRTY)) 941 return 0; 942 943 ni = sbi->volume.ni; 944 if (!ni) 945 return -EINVAL; 946 947 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_DIRTY); 948 949 attr = ni_find_attr(ni, NULL, NULL, ATTR_VOL_INFO, NULL, 0, NULL, &mi); 950 if (!attr) { 951 err = -EINVAL; 952 goto out; 953 } 954 955 info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO); 956 if (!info) { 957 err = -EINVAL; 958 goto out; 959 } 960 961 info_flags = info->flags; 962 963 switch (dirty) { 964 case NTFS_DIRTY_ERROR: 965 ntfs_notice(sbi->sb, "Mark volume as dirty due to NTFS errors"); 966 sbi->volume.real_dirty = true; 967 fallthrough; 968 case NTFS_DIRTY_DIRTY: 969 info->flags |= VOLUME_FLAG_DIRTY; 970 break; 971 case NTFS_DIRTY_CLEAR: 972 info->flags &= ~VOLUME_FLAG_DIRTY; 973 break; 974 } 975 /* Cache current volume flags. */ 976 if (info_flags != info->flags) { 977 sbi->volume.flags = info->flags; 978 mi->dirty = true; 979 } 980 err = 0; 981 982 out: 983 ni_unlock(ni); 984 if (err) 985 return err; 986 987 mark_inode_dirty_sync(&ni->vfs_inode); 988 /* verify(!ntfs_update_mftmirr()); */ 989 990 /* write mft record on disk. */ 991 err = _ni_write_inode(&ni->vfs_inode, 1); 992 993 return err; 994 } 995 996 /* 997 * security_hash - Calculates a hash of security descriptor. 998 */ 999 static inline __le32 security_hash(const void *sd, size_t bytes) 1000 { 1001 u32 hash = 0; 1002 const __le32 *ptr = sd; 1003 1004 bytes >>= 2; 1005 while (bytes--) 1006 hash = ((hash >> 0x1D) | (hash << 3)) + le32_to_cpu(*ptr++); 1007 return cpu_to_le32(hash); 1008 } 1009 1010 /* 1011 * simple wrapper for sb_bread_unmovable. 1012 */ 1013 struct buffer_head *ntfs_bread(struct super_block *sb, sector_t block) 1014 { 1015 struct ntfs_sb_info *sbi = sb->s_fs_info; 1016 struct buffer_head *bh; 1017 1018 if (unlikely(block >= sbi->volume.blocks)) { 1019 /* prevent generic message "attempt to access beyond end of device" */ 1020 ntfs_err(sb, "try to read out of volume at offset 0x%llx", 1021 (u64)block << sb->s_blocksize_bits); 1022 return NULL; 1023 } 1024 1025 bh = sb_bread_unmovable(sb, block); 1026 if (bh) 1027 return bh; 1028 1029 ntfs_err(sb, "failed to read volume at offset 0x%llx", 1030 (u64)block << sb->s_blocksize_bits); 1031 return NULL; 1032 } 1033 1034 int ntfs_sb_read(struct super_block *sb, u64 lbo, size_t bytes, void *buffer) 1035 { 1036 struct block_device *bdev = sb->s_bdev; 1037 u32 blocksize = sb->s_blocksize; 1038 u64 block = lbo >> sb->s_blocksize_bits; 1039 u32 off = lbo & (blocksize - 1); 1040 u32 op = blocksize - off; 1041 1042 for (; bytes; block += 1, off = 0, op = blocksize) { 1043 struct buffer_head *bh = __bread(bdev, block, blocksize); 1044 1045 if (!bh) 1046 return -EIO; 1047 1048 if (op > bytes) 1049 op = bytes; 1050 1051 memcpy(buffer, bh->b_data + off, op); 1052 1053 put_bh(bh); 1054 1055 bytes -= op; 1056 buffer = Add2Ptr(buffer, op); 1057 } 1058 1059 return 0; 1060 } 1061 1062 int ntfs_sb_write(struct super_block *sb, u64 lbo, size_t bytes, 1063 const void *buf, int wait) 1064 { 1065 u32 blocksize = sb->s_blocksize; 1066 struct block_device *bdev = sb->s_bdev; 1067 sector_t block = lbo >> sb->s_blocksize_bits; 1068 u32 off = lbo & (blocksize - 1); 1069 u32 op = blocksize - off; 1070 struct buffer_head *bh; 1071 1072 if (!wait && (sb->s_flags & SB_SYNCHRONOUS)) 1073 wait = 1; 1074 1075 for (; bytes; block += 1, off = 0, op = blocksize) { 1076 if (op > bytes) 1077 op = bytes; 1078 1079 if (op < blocksize) { 1080 bh = __bread(bdev, block, blocksize); 1081 if (!bh) { 1082 ntfs_err(sb, "failed to read block %llx", 1083 (u64)block); 1084 return -EIO; 1085 } 1086 } else { 1087 bh = __getblk(bdev, block, blocksize); 1088 if (!bh) 1089 return -ENOMEM; 1090 } 1091 1092 if (buffer_locked(bh)) 1093 __wait_on_buffer(bh); 1094 1095 lock_buffer(bh); 1096 if (buf) { 1097 memcpy(bh->b_data + off, buf, op); 1098 buf = Add2Ptr(buf, op); 1099 } else { 1100 memset(bh->b_data + off, -1, op); 1101 } 1102 1103 set_buffer_uptodate(bh); 1104 mark_buffer_dirty(bh); 1105 unlock_buffer(bh); 1106 1107 if (wait) { 1108 int err = sync_dirty_buffer(bh); 1109 1110 if (err) { 1111 ntfs_err( 1112 sb, 1113 "failed to sync buffer at block %llx, error %d", 1114 (u64)block, err); 1115 put_bh(bh); 1116 return err; 1117 } 1118 } 1119 1120 put_bh(bh); 1121 1122 bytes -= op; 1123 } 1124 return 0; 1125 } 1126 1127 int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1128 u64 vbo, const void *buf, size_t bytes, int sync) 1129 { 1130 struct super_block *sb = sbi->sb; 1131 u8 cluster_bits = sbi->cluster_bits; 1132 u32 off = vbo & sbi->cluster_mask; 1133 CLST lcn, clen, vcn = vbo >> cluster_bits, vcn_next; 1134 u64 lbo, len; 1135 size_t idx; 1136 1137 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) 1138 return -ENOENT; 1139 1140 if (lcn == SPARSE_LCN) 1141 return -EINVAL; 1142 1143 lbo = ((u64)lcn << cluster_bits) + off; 1144 len = ((u64)clen << cluster_bits) - off; 1145 1146 for (;;) { 1147 u32 op = min_t(u64, len, bytes); 1148 int err = ntfs_sb_write(sb, lbo, op, buf, sync); 1149 1150 if (err) 1151 return err; 1152 1153 bytes -= op; 1154 if (!bytes) 1155 break; 1156 1157 vcn_next = vcn + clen; 1158 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) || 1159 vcn != vcn_next) 1160 return -ENOENT; 1161 1162 if (lcn == SPARSE_LCN) 1163 return -EINVAL; 1164 1165 if (buf) 1166 buf = Add2Ptr(buf, op); 1167 1168 lbo = ((u64)lcn << cluster_bits); 1169 len = ((u64)clen << cluster_bits); 1170 } 1171 1172 return 0; 1173 } 1174 1175 struct buffer_head *ntfs_bread_run(struct ntfs_sb_info *sbi, 1176 const struct runs_tree *run, u64 vbo) 1177 { 1178 struct super_block *sb = sbi->sb; 1179 u8 cluster_bits = sbi->cluster_bits; 1180 CLST lcn; 1181 u64 lbo; 1182 1183 if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, NULL, NULL)) 1184 return ERR_PTR(-ENOENT); 1185 1186 lbo = ((u64)lcn << cluster_bits) + (vbo & sbi->cluster_mask); 1187 1188 return ntfs_bread(sb, lbo >> sb->s_blocksize_bits); 1189 } 1190 1191 int ntfs_read_run_nb(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1192 u64 vbo, void *buf, u32 bytes, struct ntfs_buffers *nb) 1193 { 1194 int err; 1195 struct super_block *sb = sbi->sb; 1196 u32 blocksize = sb->s_blocksize; 1197 u8 cluster_bits = sbi->cluster_bits; 1198 u32 off = vbo & sbi->cluster_mask; 1199 u32 nbh = 0; 1200 CLST vcn_next, vcn = vbo >> cluster_bits; 1201 CLST lcn, clen; 1202 u64 lbo, len; 1203 size_t idx; 1204 struct buffer_head *bh; 1205 1206 if (!run) { 1207 /* First reading of $Volume + $MFTMirr + $LogFile goes here. */ 1208 if (vbo > MFT_REC_VOL * sbi->record_size) { 1209 err = -ENOENT; 1210 goto out; 1211 } 1212 1213 /* Use absolute boot's 'MFTCluster' to read record. */ 1214 lbo = vbo + sbi->mft.lbo; 1215 len = sbi->record_size; 1216 } else if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) { 1217 err = -ENOENT; 1218 goto out; 1219 } else { 1220 if (lcn == SPARSE_LCN) { 1221 err = -EINVAL; 1222 goto out; 1223 } 1224 1225 lbo = ((u64)lcn << cluster_bits) + off; 1226 len = ((u64)clen << cluster_bits) - off; 1227 } 1228 1229 off = lbo & (blocksize - 1); 1230 if (nb) { 1231 nb->off = off; 1232 nb->bytes = bytes; 1233 } 1234 1235 for (;;) { 1236 u32 len32 = len >= bytes ? bytes : len; 1237 sector_t block = lbo >> sb->s_blocksize_bits; 1238 1239 do { 1240 u32 op = blocksize - off; 1241 1242 if (op > len32) 1243 op = len32; 1244 1245 bh = ntfs_bread(sb, block); 1246 if (!bh) { 1247 err = -EIO; 1248 goto out; 1249 } 1250 1251 if (buf) { 1252 memcpy(buf, bh->b_data + off, op); 1253 buf = Add2Ptr(buf, op); 1254 } 1255 1256 if (!nb) { 1257 put_bh(bh); 1258 } else if (nbh >= ARRAY_SIZE(nb->bh)) { 1259 err = -EINVAL; 1260 goto out; 1261 } else { 1262 nb->bh[nbh++] = bh; 1263 nb->nbufs = nbh; 1264 } 1265 1266 bytes -= op; 1267 if (!bytes) 1268 return 0; 1269 len32 -= op; 1270 block += 1; 1271 off = 0; 1272 1273 } while (len32); 1274 1275 vcn_next = vcn + clen; 1276 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) || 1277 vcn != vcn_next) { 1278 err = -ENOENT; 1279 goto out; 1280 } 1281 1282 if (lcn == SPARSE_LCN) { 1283 err = -EINVAL; 1284 goto out; 1285 } 1286 1287 lbo = ((u64)lcn << cluster_bits); 1288 len = ((u64)clen << cluster_bits); 1289 } 1290 1291 out: 1292 if (!nbh) 1293 return err; 1294 1295 while (nbh) { 1296 put_bh(nb->bh[--nbh]); 1297 nb->bh[nbh] = NULL; 1298 } 1299 1300 nb->nbufs = 0; 1301 return err; 1302 } 1303 1304 /* 1305 * ntfs_read_bh 1306 * 1307 * Return: < 0 if error, 0 if ok, -E_NTFS_FIXUP if need to update fixups. 1308 */ 1309 int ntfs_read_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo, 1310 struct NTFS_RECORD_HEADER *rhdr, u32 bytes, 1311 struct ntfs_buffers *nb) 1312 { 1313 int err = ntfs_read_run_nb(sbi, run, vbo, rhdr, bytes, nb); 1314 1315 if (err) 1316 return err; 1317 return ntfs_fix_post_read(rhdr, nb->bytes, true); 1318 } 1319 1320 int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo, 1321 u32 bytes, struct ntfs_buffers *nb) 1322 { 1323 int err = 0; 1324 struct super_block *sb = sbi->sb; 1325 u32 blocksize = sb->s_blocksize; 1326 u8 cluster_bits = sbi->cluster_bits; 1327 CLST vcn_next, vcn = vbo >> cluster_bits; 1328 u32 off; 1329 u32 nbh = 0; 1330 CLST lcn, clen; 1331 u64 lbo, len; 1332 size_t idx; 1333 1334 nb->bytes = bytes; 1335 1336 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) { 1337 err = -ENOENT; 1338 goto out; 1339 } 1340 1341 off = vbo & sbi->cluster_mask; 1342 lbo = ((u64)lcn << cluster_bits) + off; 1343 len = ((u64)clen << cluster_bits) - off; 1344 1345 nb->off = off = lbo & (blocksize - 1); 1346 1347 for (;;) { 1348 u32 len32 = min_t(u64, len, bytes); 1349 sector_t block = lbo >> sb->s_blocksize_bits; 1350 1351 do { 1352 u32 op; 1353 struct buffer_head *bh; 1354 1355 if (nbh >= ARRAY_SIZE(nb->bh)) { 1356 err = -EINVAL; 1357 goto out; 1358 } 1359 1360 op = blocksize - off; 1361 if (op > len32) 1362 op = len32; 1363 1364 if (op == blocksize) { 1365 bh = sb_getblk(sb, block); 1366 if (!bh) { 1367 err = -ENOMEM; 1368 goto out; 1369 } 1370 if (buffer_locked(bh)) 1371 __wait_on_buffer(bh); 1372 set_buffer_uptodate(bh); 1373 } else { 1374 bh = ntfs_bread(sb, block); 1375 if (!bh) { 1376 err = -EIO; 1377 goto out; 1378 } 1379 } 1380 1381 nb->bh[nbh++] = bh; 1382 bytes -= op; 1383 if (!bytes) { 1384 nb->nbufs = nbh; 1385 return 0; 1386 } 1387 1388 block += 1; 1389 len32 -= op; 1390 off = 0; 1391 } while (len32); 1392 1393 vcn_next = vcn + clen; 1394 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) || 1395 vcn != vcn_next) { 1396 err = -ENOENT; 1397 goto out; 1398 } 1399 1400 lbo = ((u64)lcn << cluster_bits); 1401 len = ((u64)clen << cluster_bits); 1402 } 1403 1404 out: 1405 while (nbh) { 1406 put_bh(nb->bh[--nbh]); 1407 nb->bh[nbh] = NULL; 1408 } 1409 1410 nb->nbufs = 0; 1411 1412 return err; 1413 } 1414 1415 int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr, 1416 struct ntfs_buffers *nb, int sync) 1417 { 1418 int err = 0; 1419 struct super_block *sb = sbi->sb; 1420 u32 block_size = sb->s_blocksize; 1421 u32 bytes = nb->bytes; 1422 u32 off = nb->off; 1423 u16 fo = le16_to_cpu(rhdr->fix_off); 1424 u16 fn = le16_to_cpu(rhdr->fix_num); 1425 u32 idx; 1426 __le16 *fixup; 1427 __le16 sample; 1428 1429 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || 1430 fn * SECTOR_SIZE > bytes) { 1431 return -EINVAL; 1432 } 1433 1434 for (idx = 0; bytes && idx < nb->nbufs; idx += 1, off = 0) { 1435 u32 op = block_size - off; 1436 char *bh_data; 1437 struct buffer_head *bh = nb->bh[idx]; 1438 __le16 *ptr, *end_data; 1439 1440 if (op > bytes) 1441 op = bytes; 1442 1443 if (buffer_locked(bh)) 1444 __wait_on_buffer(bh); 1445 1446 lock_buffer(bh); 1447 1448 bh_data = bh->b_data + off; 1449 end_data = Add2Ptr(bh_data, op); 1450 memcpy(bh_data, rhdr, op); 1451 1452 if (!idx) { 1453 u16 t16; 1454 1455 fixup = Add2Ptr(bh_data, fo); 1456 sample = *fixup; 1457 t16 = le16_to_cpu(sample); 1458 if (t16 >= 0x7FFF) { 1459 sample = *fixup = cpu_to_le16(1); 1460 } else { 1461 sample = cpu_to_le16(t16 + 1); 1462 *fixup = sample; 1463 } 1464 1465 *(__le16 *)Add2Ptr(rhdr, fo) = sample; 1466 } 1467 1468 ptr = Add2Ptr(bh_data, SECTOR_SIZE - sizeof(short)); 1469 1470 do { 1471 *++fixup = *ptr; 1472 *ptr = sample; 1473 ptr += SECTOR_SIZE / sizeof(short); 1474 } while (ptr < end_data); 1475 1476 set_buffer_uptodate(bh); 1477 mark_buffer_dirty(bh); 1478 unlock_buffer(bh); 1479 1480 if (sync) { 1481 int err2 = sync_dirty_buffer(bh); 1482 1483 if (!err && err2) 1484 err = err2; 1485 } 1486 1487 bytes -= op; 1488 rhdr = Add2Ptr(rhdr, op); 1489 } 1490 1491 return err; 1492 } 1493 1494 /* 1495 * ntfs_bio_pages - Read/write pages from/to disk. 1496 */ 1497 int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1498 struct page **pages, u32 nr_pages, u64 vbo, u32 bytes, 1499 enum req_op op) 1500 { 1501 int err = 0; 1502 struct bio *new, *bio = NULL; 1503 struct super_block *sb = sbi->sb; 1504 struct block_device *bdev = sb->s_bdev; 1505 struct page *page; 1506 u8 cluster_bits = sbi->cluster_bits; 1507 CLST lcn, clen, vcn, vcn_next; 1508 u32 add, off, page_idx; 1509 u64 lbo, len; 1510 size_t run_idx; 1511 struct blk_plug plug; 1512 1513 if (!bytes) 1514 return 0; 1515 1516 blk_start_plug(&plug); 1517 1518 /* Align vbo and bytes to be 512 bytes aligned. */ 1519 lbo = (vbo + bytes + 511) & ~511ull; 1520 vbo = vbo & ~511ull; 1521 bytes = lbo - vbo; 1522 1523 vcn = vbo >> cluster_bits; 1524 if (!run_lookup_entry(run, vcn, &lcn, &clen, &run_idx)) { 1525 err = -ENOENT; 1526 goto out; 1527 } 1528 off = vbo & sbi->cluster_mask; 1529 page_idx = 0; 1530 page = pages[0]; 1531 1532 for (;;) { 1533 lbo = ((u64)lcn << cluster_bits) + off; 1534 len = ((u64)clen << cluster_bits) - off; 1535 new_bio: 1536 new = bio_alloc(bdev, nr_pages - page_idx, op, GFP_NOFS); 1537 if (bio) { 1538 bio_chain(bio, new); 1539 submit_bio(bio); 1540 } 1541 bio = new; 1542 bio->bi_iter.bi_sector = lbo >> 9; 1543 1544 while (len) { 1545 off = vbo & (PAGE_SIZE - 1); 1546 add = off + len > PAGE_SIZE ? (PAGE_SIZE - off) : len; 1547 1548 if (bio_add_page(bio, page, add, off) < add) 1549 goto new_bio; 1550 1551 if (bytes <= add) 1552 goto out; 1553 bytes -= add; 1554 vbo += add; 1555 1556 if (add + off == PAGE_SIZE) { 1557 page_idx += 1; 1558 if (WARN_ON(page_idx >= nr_pages)) { 1559 err = -EINVAL; 1560 goto out; 1561 } 1562 page = pages[page_idx]; 1563 } 1564 1565 if (len <= add) 1566 break; 1567 len -= add; 1568 lbo += add; 1569 } 1570 1571 vcn_next = vcn + clen; 1572 if (!run_get_entry(run, ++run_idx, &vcn, &lcn, &clen) || 1573 vcn != vcn_next) { 1574 err = -ENOENT; 1575 goto out; 1576 } 1577 off = 0; 1578 } 1579 out: 1580 if (bio) { 1581 if (!err) 1582 err = submit_bio_wait(bio); 1583 bio_put(bio); 1584 } 1585 blk_finish_plug(&plug); 1586 1587 return err; 1588 } 1589 1590 /* 1591 * ntfs_bio_fill_1 - Helper for ntfs_loadlog_and_replay(). 1592 * 1593 * Fill on-disk logfile range by (-1) 1594 * this means empty logfile. 1595 */ 1596 int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run) 1597 { 1598 int err = 0; 1599 struct super_block *sb = sbi->sb; 1600 struct block_device *bdev = sb->s_bdev; 1601 u8 cluster_bits = sbi->cluster_bits; 1602 struct bio *new, *bio = NULL; 1603 CLST lcn, clen; 1604 u64 lbo, len; 1605 size_t run_idx; 1606 struct page *fill; 1607 void *kaddr; 1608 struct blk_plug plug; 1609 1610 fill = alloc_page(GFP_KERNEL); 1611 if (!fill) 1612 return -ENOMEM; 1613 1614 kaddr = kmap_atomic(fill); 1615 memset(kaddr, -1, PAGE_SIZE); 1616 kunmap_atomic(kaddr); 1617 flush_dcache_page(fill); 1618 lock_page(fill); 1619 1620 if (!run_lookup_entry(run, 0, &lcn, &clen, &run_idx)) { 1621 err = -ENOENT; 1622 goto out; 1623 } 1624 1625 /* 1626 * TODO: Try blkdev_issue_write_same. 1627 */ 1628 blk_start_plug(&plug); 1629 do { 1630 lbo = (u64)lcn << cluster_bits; 1631 len = (u64)clen << cluster_bits; 1632 new_bio: 1633 new = bio_alloc(bdev, BIO_MAX_VECS, REQ_OP_WRITE, GFP_NOFS); 1634 if (bio) { 1635 bio_chain(bio, new); 1636 submit_bio(bio); 1637 } 1638 bio = new; 1639 bio->bi_iter.bi_sector = lbo >> 9; 1640 1641 for (;;) { 1642 u32 add = len > PAGE_SIZE ? PAGE_SIZE : len; 1643 1644 if (bio_add_page(bio, fill, add, 0) < add) 1645 goto new_bio; 1646 1647 lbo += add; 1648 if (len <= add) 1649 break; 1650 len -= add; 1651 } 1652 } while (run_get_entry(run, ++run_idx, NULL, &lcn, &clen)); 1653 1654 if (!err) 1655 err = submit_bio_wait(bio); 1656 bio_put(bio); 1657 1658 blk_finish_plug(&plug); 1659 out: 1660 unlock_page(fill); 1661 put_page(fill); 1662 1663 return err; 1664 } 1665 1666 int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run, 1667 u64 vbo, u64 *lbo, u64 *bytes) 1668 { 1669 u32 off; 1670 CLST lcn, len; 1671 u8 cluster_bits = sbi->cluster_bits; 1672 1673 if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &len, NULL)) 1674 return -ENOENT; 1675 1676 off = vbo & sbi->cluster_mask; 1677 *lbo = lcn == SPARSE_LCN ? -1 : (((u64)lcn << cluster_bits) + off); 1678 *bytes = ((u64)len << cluster_bits) - off; 1679 1680 return 0; 1681 } 1682 1683 struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST rno, 1684 enum RECORD_FLAG flag) 1685 { 1686 int err = 0; 1687 struct super_block *sb = sbi->sb; 1688 struct inode *inode = new_inode(sb); 1689 struct ntfs_inode *ni; 1690 1691 if (!inode) 1692 return ERR_PTR(-ENOMEM); 1693 1694 ni = ntfs_i(inode); 1695 1696 err = mi_format_new(&ni->mi, sbi, rno, flag, false); 1697 if (err) 1698 goto out; 1699 1700 inode->i_ino = rno; 1701 if (insert_inode_locked(inode) < 0) { 1702 err = -EIO; 1703 goto out; 1704 } 1705 1706 out: 1707 if (err) { 1708 make_bad_inode(inode); 1709 iput(inode); 1710 ni = ERR_PTR(err); 1711 } 1712 return ni; 1713 } 1714 1715 /* 1716 * O:BAG:BAD:(A;OICI;FA;;;WD) 1717 * Owner S-1-5-32-544 (Administrators) 1718 * Group S-1-5-32-544 (Administrators) 1719 * ACE: allow S-1-1-0 (Everyone) with FILE_ALL_ACCESS 1720 */ 1721 const u8 s_default_security[] __aligned(8) = { 1722 0x01, 0x00, 0x04, 0x80, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 1723 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1C, 0x00, 1724 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x14, 0x00, 0xFF, 0x01, 0x1F, 0x00, 1725 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 1726 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x20, 0x00, 0x00, 0x00, 1727 0x20, 0x02, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 1728 0x20, 0x00, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 1729 }; 1730 1731 static_assert(sizeof(s_default_security) == 0x50); 1732 1733 static inline u32 sid_length(const struct SID *sid) 1734 { 1735 return struct_size(sid, SubAuthority, sid->SubAuthorityCount); 1736 } 1737 1738 /* 1739 * is_acl_valid 1740 * 1741 * Thanks Mark Harmstone for idea. 1742 */ 1743 static bool is_acl_valid(const struct ACL *acl, u32 len) 1744 { 1745 const struct ACE_HEADER *ace; 1746 u32 i; 1747 u16 ace_count, ace_size; 1748 1749 if (acl->AclRevision != ACL_REVISION && 1750 acl->AclRevision != ACL_REVISION_DS) { 1751 /* 1752 * This value should be ACL_REVISION, unless the ACL contains an 1753 * object-specific ACE, in which case this value must be ACL_REVISION_DS. 1754 * All ACEs in an ACL must be at the same revision level. 1755 */ 1756 return false; 1757 } 1758 1759 if (acl->Sbz1) 1760 return false; 1761 1762 if (le16_to_cpu(acl->AclSize) > len) 1763 return false; 1764 1765 if (acl->Sbz2) 1766 return false; 1767 1768 len -= sizeof(struct ACL); 1769 ace = (struct ACE_HEADER *)&acl[1]; 1770 ace_count = le16_to_cpu(acl->AceCount); 1771 1772 for (i = 0; i < ace_count; i++) { 1773 if (len < sizeof(struct ACE_HEADER)) 1774 return false; 1775 1776 ace_size = le16_to_cpu(ace->AceSize); 1777 if (len < ace_size) 1778 return false; 1779 1780 len -= ace_size; 1781 ace = Add2Ptr(ace, ace_size); 1782 } 1783 1784 return true; 1785 } 1786 1787 bool is_sd_valid(const struct SECURITY_DESCRIPTOR_RELATIVE *sd, u32 len) 1788 { 1789 u32 sd_owner, sd_group, sd_sacl, sd_dacl; 1790 1791 if (len < sizeof(struct SECURITY_DESCRIPTOR_RELATIVE)) 1792 return false; 1793 1794 if (sd->Revision != 1) 1795 return false; 1796 1797 if (sd->Sbz1) 1798 return false; 1799 1800 if (!(sd->Control & SE_SELF_RELATIVE)) 1801 return false; 1802 1803 sd_owner = le32_to_cpu(sd->Owner); 1804 if (sd_owner) { 1805 const struct SID *owner = Add2Ptr(sd, sd_owner); 1806 1807 if (sd_owner + offsetof(struct SID, SubAuthority) > len) 1808 return false; 1809 1810 if (owner->Revision != 1) 1811 return false; 1812 1813 if (sd_owner + sid_length(owner) > len) 1814 return false; 1815 } 1816 1817 sd_group = le32_to_cpu(sd->Group); 1818 if (sd_group) { 1819 const struct SID *group = Add2Ptr(sd, sd_group); 1820 1821 if (sd_group + offsetof(struct SID, SubAuthority) > len) 1822 return false; 1823 1824 if (group->Revision != 1) 1825 return false; 1826 1827 if (sd_group + sid_length(group) > len) 1828 return false; 1829 } 1830 1831 sd_sacl = le32_to_cpu(sd->Sacl); 1832 if (sd_sacl) { 1833 const struct ACL *sacl = Add2Ptr(sd, sd_sacl); 1834 1835 if (sd_sacl + sizeof(struct ACL) > len) 1836 return false; 1837 1838 if (!is_acl_valid(sacl, len - sd_sacl)) 1839 return false; 1840 } 1841 1842 sd_dacl = le32_to_cpu(sd->Dacl); 1843 if (sd_dacl) { 1844 const struct ACL *dacl = Add2Ptr(sd, sd_dacl); 1845 1846 if (sd_dacl + sizeof(struct ACL) > len) 1847 return false; 1848 1849 if (!is_acl_valid(dacl, len - sd_dacl)) 1850 return false; 1851 } 1852 1853 return true; 1854 } 1855 1856 /* 1857 * ntfs_security_init - Load and parse $Secure. 1858 */ 1859 int ntfs_security_init(struct ntfs_sb_info *sbi) 1860 { 1861 int err; 1862 struct super_block *sb = sbi->sb; 1863 struct inode *inode; 1864 struct ntfs_inode *ni; 1865 struct MFT_REF ref; 1866 struct ATTRIB *attr; 1867 struct ATTR_LIST_ENTRY *le; 1868 u64 sds_size; 1869 size_t off; 1870 struct NTFS_DE *ne; 1871 struct NTFS_DE_SII *sii_e; 1872 struct ntfs_fnd *fnd_sii = NULL; 1873 const struct INDEX_ROOT *root_sii; 1874 const struct INDEX_ROOT *root_sdh; 1875 struct ntfs_index *indx_sdh = &sbi->security.index_sdh; 1876 struct ntfs_index *indx_sii = &sbi->security.index_sii; 1877 1878 ref.low = cpu_to_le32(MFT_REC_SECURE); 1879 ref.high = 0; 1880 ref.seq = cpu_to_le16(MFT_REC_SECURE); 1881 1882 inode = ntfs_iget5(sb, &ref, &NAME_SECURE); 1883 if (IS_ERR(inode)) { 1884 err = PTR_ERR(inode); 1885 ntfs_err(sb, "Failed to load $Secure (%d).", err); 1886 inode = NULL; 1887 goto out; 1888 } 1889 1890 ni = ntfs_i(inode); 1891 1892 le = NULL; 1893 1894 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SDH_NAME, 1895 ARRAY_SIZE(SDH_NAME), NULL, NULL); 1896 if (!attr || 1897 !(root_sdh = resident_data_ex(attr, sizeof(struct INDEX_ROOT))) || 1898 root_sdh->type != ATTR_ZERO || 1899 root_sdh->rule != NTFS_COLLATION_TYPE_SECURITY_HASH || 1900 offsetof(struct INDEX_ROOT, ihdr) + 1901 le32_to_cpu(root_sdh->ihdr.used) > 1902 le32_to_cpu(attr->res.data_size)) { 1903 ntfs_err(sb, "$Secure::$SDH is corrupted."); 1904 err = -EINVAL; 1905 goto out; 1906 } 1907 1908 err = indx_init(indx_sdh, sbi, attr, INDEX_MUTEX_SDH); 1909 if (err) { 1910 ntfs_err(sb, "Failed to initialize $Secure::$SDH (%d).", err); 1911 goto out; 1912 } 1913 1914 attr = ni_find_attr(ni, attr, &le, ATTR_ROOT, SII_NAME, 1915 ARRAY_SIZE(SII_NAME), NULL, NULL); 1916 if (!attr || 1917 !(root_sii = resident_data_ex(attr, sizeof(struct INDEX_ROOT))) || 1918 root_sii->type != ATTR_ZERO || 1919 root_sii->rule != NTFS_COLLATION_TYPE_UINT || 1920 offsetof(struct INDEX_ROOT, ihdr) + 1921 le32_to_cpu(root_sii->ihdr.used) > 1922 le32_to_cpu(attr->res.data_size)) { 1923 ntfs_err(sb, "$Secure::$SII is corrupted."); 1924 err = -EINVAL; 1925 goto out; 1926 } 1927 1928 err = indx_init(indx_sii, sbi, attr, INDEX_MUTEX_SII); 1929 if (err) { 1930 ntfs_err(sb, "Failed to initialize $Secure::$SII (%d).", err); 1931 goto out; 1932 } 1933 1934 fnd_sii = fnd_get(); 1935 if (!fnd_sii) { 1936 err = -ENOMEM; 1937 goto out; 1938 } 1939 1940 sds_size = inode->i_size; 1941 1942 /* Find the last valid Id. */ 1943 sbi->security.next_id = SECURITY_ID_FIRST; 1944 /* Always write new security at the end of bucket. */ 1945 sbi->security.next_off = 1946 ALIGN(sds_size - SecurityDescriptorsBlockSize, 16); 1947 1948 off = 0; 1949 ne = NULL; 1950 1951 for (;;) { 1952 u32 next_id; 1953 1954 err = indx_find_raw(indx_sii, ni, root_sii, &ne, &off, fnd_sii); 1955 if (err || !ne) 1956 break; 1957 1958 sii_e = (struct NTFS_DE_SII *)ne; 1959 if (le16_to_cpu(ne->view.data_size) < sizeof(sii_e->sec_hdr)) 1960 continue; 1961 1962 next_id = le32_to_cpu(sii_e->sec_id) + 1; 1963 if (next_id >= sbi->security.next_id) 1964 sbi->security.next_id = next_id; 1965 } 1966 1967 sbi->security.ni = ni; 1968 inode = NULL; 1969 out: 1970 iput(inode); 1971 fnd_put(fnd_sii); 1972 1973 return err; 1974 } 1975 1976 /* 1977 * ntfs_get_security_by_id - Read security descriptor by id. 1978 */ 1979 int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id, 1980 struct SECURITY_DESCRIPTOR_RELATIVE **sd, 1981 size_t *size) 1982 { 1983 int err; 1984 int diff; 1985 struct ntfs_inode *ni = sbi->security.ni; 1986 struct ntfs_index *indx = &sbi->security.index_sii; 1987 void *p = NULL; 1988 struct NTFS_DE_SII *sii_e; 1989 struct ntfs_fnd *fnd_sii; 1990 struct SECURITY_HDR d_security; 1991 const struct INDEX_ROOT *root_sii; 1992 u32 t32; 1993 1994 *sd = NULL; 1995 1996 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY); 1997 1998 fnd_sii = fnd_get(); 1999 if (!fnd_sii) { 2000 err = -ENOMEM; 2001 goto out; 2002 } 2003 2004 root_sii = indx_get_root(indx, ni, NULL, NULL); 2005 if (!root_sii) { 2006 err = -EINVAL; 2007 goto out; 2008 } 2009 2010 /* Try to find this SECURITY descriptor in SII indexes. */ 2011 err = indx_find(indx, ni, root_sii, &security_id, sizeof(security_id), 2012 NULL, &diff, (struct NTFS_DE **)&sii_e, fnd_sii); 2013 if (err) 2014 goto out; 2015 2016 if (diff) 2017 goto out; 2018 2019 t32 = le32_to_cpu(sii_e->sec_hdr.size); 2020 if (t32 < sizeof(struct SECURITY_HDR)) { 2021 err = -EINVAL; 2022 goto out; 2023 } 2024 2025 if (t32 > sizeof(struct SECURITY_HDR) + 0x10000) { 2026 /* Looks like too big security. 0x10000 - is arbitrary big number. */ 2027 err = -EFBIG; 2028 goto out; 2029 } 2030 2031 *size = t32 - sizeof(struct SECURITY_HDR); 2032 2033 p = kmalloc(*size, GFP_NOFS); 2034 if (!p) { 2035 err = -ENOMEM; 2036 goto out; 2037 } 2038 2039 err = ntfs_read_run_nb(sbi, &ni->file.run, 2040 le64_to_cpu(sii_e->sec_hdr.off), &d_security, 2041 sizeof(d_security), NULL); 2042 if (err) 2043 goto out; 2044 2045 if (memcmp(&d_security, &sii_e->sec_hdr, sizeof(d_security))) { 2046 err = -EINVAL; 2047 goto out; 2048 } 2049 2050 err = ntfs_read_run_nb(sbi, &ni->file.run, 2051 le64_to_cpu(sii_e->sec_hdr.off) + 2052 sizeof(struct SECURITY_HDR), 2053 p, *size, NULL); 2054 if (err) 2055 goto out; 2056 2057 *sd = p; 2058 p = NULL; 2059 2060 out: 2061 kfree(p); 2062 fnd_put(fnd_sii); 2063 ni_unlock(ni); 2064 2065 return err; 2066 } 2067 2068 /* 2069 * ntfs_insert_security - Insert security descriptor into $Secure::SDS. 2070 * 2071 * SECURITY Descriptor Stream data is organized into chunks of 256K bytes 2072 * and it contains a mirror copy of each security descriptor. When writing 2073 * to a security descriptor at location X, another copy will be written at 2074 * location (X+256K). 2075 * When writing a security descriptor that will cross the 256K boundary, 2076 * the pointer will be advanced by 256K to skip 2077 * over the mirror portion. 2078 */ 2079 int ntfs_insert_security(struct ntfs_sb_info *sbi, 2080 const struct SECURITY_DESCRIPTOR_RELATIVE *sd, 2081 u32 size_sd, __le32 *security_id, bool *inserted) 2082 { 2083 int err, diff; 2084 struct ntfs_inode *ni = sbi->security.ni; 2085 struct ntfs_index *indx_sdh = &sbi->security.index_sdh; 2086 struct ntfs_index *indx_sii = &sbi->security.index_sii; 2087 struct NTFS_DE_SDH *e; 2088 struct NTFS_DE_SDH sdh_e; 2089 struct NTFS_DE_SII sii_e; 2090 struct SECURITY_HDR *d_security; 2091 u32 new_sec_size = size_sd + sizeof(struct SECURITY_HDR); 2092 u32 aligned_sec_size = ALIGN(new_sec_size, 16); 2093 struct SECURITY_KEY hash_key; 2094 struct ntfs_fnd *fnd_sdh = NULL; 2095 const struct INDEX_ROOT *root_sdh; 2096 const struct INDEX_ROOT *root_sii; 2097 u64 mirr_off, new_sds_size; 2098 u32 next, left; 2099 2100 static_assert((1 << Log2OfSecurityDescriptorsBlockSize) == 2101 SecurityDescriptorsBlockSize); 2102 2103 hash_key.hash = security_hash(sd, size_sd); 2104 hash_key.sec_id = SECURITY_ID_INVALID; 2105 2106 if (inserted) 2107 *inserted = false; 2108 *security_id = SECURITY_ID_INVALID; 2109 2110 /* Allocate a temporal buffer. */ 2111 d_security = kzalloc(aligned_sec_size, GFP_NOFS); 2112 if (!d_security) 2113 return -ENOMEM; 2114 2115 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY); 2116 2117 fnd_sdh = fnd_get(); 2118 if (!fnd_sdh) { 2119 err = -ENOMEM; 2120 goto out; 2121 } 2122 2123 root_sdh = indx_get_root(indx_sdh, ni, NULL, NULL); 2124 if (!root_sdh) { 2125 err = -EINVAL; 2126 goto out; 2127 } 2128 2129 root_sii = indx_get_root(indx_sii, ni, NULL, NULL); 2130 if (!root_sii) { 2131 err = -EINVAL; 2132 goto out; 2133 } 2134 2135 /* 2136 * Check if such security already exists. 2137 * Use "SDH" and hash -> to get the offset in "SDS". 2138 */ 2139 err = indx_find(indx_sdh, ni, root_sdh, &hash_key, sizeof(hash_key), 2140 &d_security->key.sec_id, &diff, (struct NTFS_DE **)&e, 2141 fnd_sdh); 2142 if (err) 2143 goto out; 2144 2145 while (e) { 2146 if (le32_to_cpu(e->sec_hdr.size) == new_sec_size) { 2147 err = ntfs_read_run_nb(sbi, &ni->file.run, 2148 le64_to_cpu(e->sec_hdr.off), 2149 d_security, new_sec_size, NULL); 2150 if (err) 2151 goto out; 2152 2153 if (le32_to_cpu(d_security->size) == new_sec_size && 2154 d_security->key.hash == hash_key.hash && 2155 !memcmp(d_security + 1, sd, size_sd)) { 2156 *security_id = d_security->key.sec_id; 2157 /* Such security already exists. */ 2158 err = 0; 2159 goto out; 2160 } 2161 } 2162 2163 err = indx_find_sort(indx_sdh, ni, root_sdh, 2164 (struct NTFS_DE **)&e, fnd_sdh); 2165 if (err) 2166 goto out; 2167 2168 if (!e || e->key.hash != hash_key.hash) 2169 break; 2170 } 2171 2172 /* Zero unused space. */ 2173 next = sbi->security.next_off & (SecurityDescriptorsBlockSize - 1); 2174 left = SecurityDescriptorsBlockSize - next; 2175 2176 /* Zero gap until SecurityDescriptorsBlockSize. */ 2177 if (left < new_sec_size) { 2178 /* Zero "left" bytes from sbi->security.next_off. */ 2179 sbi->security.next_off += SecurityDescriptorsBlockSize + left; 2180 } 2181 2182 /* Zero tail of previous security. */ 2183 //used = ni->vfs_inode.i_size & (SecurityDescriptorsBlockSize - 1); 2184 2185 /* 2186 * Example: 2187 * 0x40438 == ni->vfs_inode.i_size 2188 * 0x00440 == sbi->security.next_off 2189 * need to zero [0x438-0x440) 2190 * if (next > used) { 2191 * u32 tozero = next - used; 2192 * zero "tozero" bytes from sbi->security.next_off - tozero 2193 */ 2194 2195 /* Format new security descriptor. */ 2196 d_security->key.hash = hash_key.hash; 2197 d_security->key.sec_id = cpu_to_le32(sbi->security.next_id); 2198 d_security->off = cpu_to_le64(sbi->security.next_off); 2199 d_security->size = cpu_to_le32(new_sec_size); 2200 memcpy(d_security + 1, sd, size_sd); 2201 2202 /* Write main SDS bucket. */ 2203 err = ntfs_sb_write_run(sbi, &ni->file.run, sbi->security.next_off, 2204 d_security, aligned_sec_size, 0); 2205 2206 if (err) 2207 goto out; 2208 2209 mirr_off = sbi->security.next_off + SecurityDescriptorsBlockSize; 2210 new_sds_size = mirr_off + aligned_sec_size; 2211 2212 if (new_sds_size > ni->vfs_inode.i_size) { 2213 err = attr_set_size(ni, ATTR_DATA, SDS_NAME, 2214 ARRAY_SIZE(SDS_NAME), &ni->file.run, 2215 new_sds_size, &new_sds_size, false, NULL); 2216 if (err) 2217 goto out; 2218 } 2219 2220 /* Write copy SDS bucket. */ 2221 err = ntfs_sb_write_run(sbi, &ni->file.run, mirr_off, d_security, 2222 aligned_sec_size, 0); 2223 if (err) 2224 goto out; 2225 2226 /* Fill SII entry. */ 2227 sii_e.de.view.data_off = 2228 cpu_to_le16(offsetof(struct NTFS_DE_SII, sec_hdr)); 2229 sii_e.de.view.data_size = cpu_to_le16(sizeof(struct SECURITY_HDR)); 2230 sii_e.de.view.res = 0; 2231 sii_e.de.size = cpu_to_le16(sizeof(struct NTFS_DE_SII)); 2232 sii_e.de.key_size = cpu_to_le16(sizeof(d_security->key.sec_id)); 2233 sii_e.de.flags = 0; 2234 sii_e.de.res = 0; 2235 sii_e.sec_id = d_security->key.sec_id; 2236 memcpy(&sii_e.sec_hdr, d_security, sizeof(struct SECURITY_HDR)); 2237 2238 err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL, 0); 2239 if (err) 2240 goto out; 2241 2242 /* Fill SDH entry. */ 2243 sdh_e.de.view.data_off = 2244 cpu_to_le16(offsetof(struct NTFS_DE_SDH, sec_hdr)); 2245 sdh_e.de.view.data_size = cpu_to_le16(sizeof(struct SECURITY_HDR)); 2246 sdh_e.de.view.res = 0; 2247 sdh_e.de.size = cpu_to_le16(SIZEOF_SDH_DIRENTRY); 2248 sdh_e.de.key_size = cpu_to_le16(sizeof(sdh_e.key)); 2249 sdh_e.de.flags = 0; 2250 sdh_e.de.res = 0; 2251 sdh_e.key.hash = d_security->key.hash; 2252 sdh_e.key.sec_id = d_security->key.sec_id; 2253 memcpy(&sdh_e.sec_hdr, d_security, sizeof(struct SECURITY_HDR)); 2254 sdh_e.magic[0] = cpu_to_le16('I'); 2255 sdh_e.magic[1] = cpu_to_le16('I'); 2256 2257 fnd_clear(fnd_sdh); 2258 err = indx_insert_entry(indx_sdh, ni, &sdh_e.de, (void *)(size_t)1, 2259 fnd_sdh, 0); 2260 if (err) 2261 goto out; 2262 2263 *security_id = d_security->key.sec_id; 2264 if (inserted) 2265 *inserted = true; 2266 2267 /* Update Id and offset for next descriptor. */ 2268 sbi->security.next_id += 1; 2269 sbi->security.next_off += aligned_sec_size; 2270 2271 out: 2272 fnd_put(fnd_sdh); 2273 mark_inode_dirty(&ni->vfs_inode); 2274 ni_unlock(ni); 2275 kfree(d_security); 2276 2277 return err; 2278 } 2279 2280 /* 2281 * ntfs_reparse_init - Load and parse $Extend/$Reparse. 2282 */ 2283 int ntfs_reparse_init(struct ntfs_sb_info *sbi) 2284 { 2285 int err; 2286 struct ntfs_inode *ni = sbi->reparse.ni; 2287 struct ntfs_index *indx = &sbi->reparse.index_r; 2288 struct ATTRIB *attr; 2289 struct ATTR_LIST_ENTRY *le; 2290 const struct INDEX_ROOT *root_r; 2291 2292 if (!ni) 2293 return 0; 2294 2295 le = NULL; 2296 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SR_NAME, 2297 ARRAY_SIZE(SR_NAME), NULL, NULL); 2298 if (!attr) { 2299 err = -EINVAL; 2300 goto out; 2301 } 2302 2303 root_r = resident_data(attr); 2304 if (root_r->type != ATTR_ZERO || 2305 root_r->rule != NTFS_COLLATION_TYPE_UINTS) { 2306 err = -EINVAL; 2307 goto out; 2308 } 2309 2310 err = indx_init(indx, sbi, attr, INDEX_MUTEX_SR); 2311 if (err) 2312 goto out; 2313 2314 out: 2315 return err; 2316 } 2317 2318 /* 2319 * ntfs_objid_init - Load and parse $Extend/$ObjId. 2320 */ 2321 int ntfs_objid_init(struct ntfs_sb_info *sbi) 2322 { 2323 int err; 2324 struct ntfs_inode *ni = sbi->objid.ni; 2325 struct ntfs_index *indx = &sbi->objid.index_o; 2326 struct ATTRIB *attr; 2327 struct ATTR_LIST_ENTRY *le; 2328 const struct INDEX_ROOT *root; 2329 2330 if (!ni) 2331 return 0; 2332 2333 le = NULL; 2334 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SO_NAME, 2335 ARRAY_SIZE(SO_NAME), NULL, NULL); 2336 if (!attr) { 2337 err = -EINVAL; 2338 goto out; 2339 } 2340 2341 root = resident_data(attr); 2342 if (root->type != ATTR_ZERO || 2343 root->rule != NTFS_COLLATION_TYPE_UINTS) { 2344 err = -EINVAL; 2345 goto out; 2346 } 2347 2348 err = indx_init(indx, sbi, attr, INDEX_MUTEX_SO); 2349 if (err) 2350 goto out; 2351 2352 out: 2353 return err; 2354 } 2355 2356 int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid) 2357 { 2358 int err; 2359 struct ntfs_inode *ni = sbi->objid.ni; 2360 struct ntfs_index *indx = &sbi->objid.index_o; 2361 2362 if (!ni) 2363 return -EINVAL; 2364 2365 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_OBJID); 2366 2367 err = indx_delete_entry(indx, ni, guid, sizeof(*guid), NULL); 2368 2369 mark_inode_dirty(&ni->vfs_inode); 2370 ni_unlock(ni); 2371 2372 return err; 2373 } 2374 2375 int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag, 2376 const struct MFT_REF *ref) 2377 { 2378 int err; 2379 struct ntfs_inode *ni = sbi->reparse.ni; 2380 struct ntfs_index *indx = &sbi->reparse.index_r; 2381 struct NTFS_DE_R re; 2382 2383 if (!ni) 2384 return -EINVAL; 2385 2386 memset(&re, 0, sizeof(re)); 2387 2388 re.de.view.data_off = cpu_to_le16(offsetof(struct NTFS_DE_R, zero)); 2389 re.de.size = cpu_to_le16(sizeof(struct NTFS_DE_R)); 2390 re.de.key_size = cpu_to_le16(sizeof(re.key)); 2391 2392 re.key.ReparseTag = rtag; 2393 memcpy(&re.key.ref, ref, sizeof(*ref)); 2394 2395 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE); 2396 2397 err = indx_insert_entry(indx, ni, &re.de, NULL, NULL, 0); 2398 2399 mark_inode_dirty(&ni->vfs_inode); 2400 ni_unlock(ni); 2401 2402 return err; 2403 } 2404 2405 int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag, 2406 const struct MFT_REF *ref) 2407 { 2408 int err, diff; 2409 struct ntfs_inode *ni = sbi->reparse.ni; 2410 struct ntfs_index *indx = &sbi->reparse.index_r; 2411 struct ntfs_fnd *fnd = NULL; 2412 struct REPARSE_KEY rkey; 2413 struct NTFS_DE_R *re; 2414 struct INDEX_ROOT *root_r; 2415 2416 if (!ni) 2417 return -EINVAL; 2418 2419 rkey.ReparseTag = rtag; 2420 rkey.ref = *ref; 2421 2422 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE); 2423 2424 if (rtag) { 2425 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL); 2426 goto out1; 2427 } 2428 2429 fnd = fnd_get(); 2430 if (!fnd) { 2431 err = -ENOMEM; 2432 goto out1; 2433 } 2434 2435 root_r = indx_get_root(indx, ni, NULL, NULL); 2436 if (!root_r) { 2437 err = -EINVAL; 2438 goto out; 2439 } 2440 2441 /* 1 - forces to ignore rkey.ReparseTag when comparing keys. */ 2442 err = indx_find(indx, ni, root_r, &rkey, sizeof(rkey), (void *)1, &diff, 2443 (struct NTFS_DE **)&re, fnd); 2444 if (err) 2445 goto out; 2446 2447 if (memcmp(&re->key.ref, ref, sizeof(*ref))) { 2448 /* Impossible. Looks like volume corrupt? */ 2449 goto out; 2450 } 2451 2452 memcpy(&rkey, &re->key, sizeof(rkey)); 2453 2454 fnd_put(fnd); 2455 fnd = NULL; 2456 2457 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL); 2458 if (err) 2459 goto out; 2460 2461 out: 2462 fnd_put(fnd); 2463 2464 out1: 2465 mark_inode_dirty(&ni->vfs_inode); 2466 ni_unlock(ni); 2467 2468 return err; 2469 } 2470 2471 static inline void ntfs_unmap_and_discard(struct ntfs_sb_info *sbi, CLST lcn, 2472 CLST len) 2473 { 2474 ntfs_unmap_meta(sbi->sb, lcn, len); 2475 ntfs_discard(sbi, lcn, len); 2476 } 2477 2478 void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim) 2479 { 2480 CLST end, i, zone_len, zlen; 2481 struct wnd_bitmap *wnd = &sbi->used.bitmap; 2482 bool dirty = false; 2483 2484 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS); 2485 if (!wnd_is_used(wnd, lcn, len)) { 2486 /* mark volume as dirty out of wnd->rw_lock */ 2487 dirty = true; 2488 2489 end = lcn + len; 2490 len = 0; 2491 for (i = lcn; i < end; i++) { 2492 if (wnd_is_used(wnd, i, 1)) { 2493 if (!len) 2494 lcn = i; 2495 len += 1; 2496 continue; 2497 } 2498 2499 if (!len) 2500 continue; 2501 2502 if (trim) 2503 ntfs_unmap_and_discard(sbi, lcn, len); 2504 2505 wnd_set_free(wnd, lcn, len); 2506 len = 0; 2507 } 2508 2509 if (!len) 2510 goto out; 2511 } 2512 2513 if (trim) 2514 ntfs_unmap_and_discard(sbi, lcn, len); 2515 wnd_set_free(wnd, lcn, len); 2516 2517 /* append to MFT zone, if possible. */ 2518 zone_len = wnd_zone_len(wnd); 2519 zlen = min(zone_len + len, sbi->zone_max); 2520 2521 if (zlen == zone_len) { 2522 /* MFT zone already has maximum size. */ 2523 } else if (!zone_len) { 2524 /* Create MFT zone only if 'zlen' is large enough. */ 2525 if (zlen == sbi->zone_max) 2526 wnd_zone_set(wnd, lcn, zlen); 2527 } else { 2528 CLST zone_lcn = wnd_zone_bit(wnd); 2529 2530 if (lcn + len == zone_lcn) { 2531 /* Append into head MFT zone. */ 2532 wnd_zone_set(wnd, lcn, zlen); 2533 } else if (zone_lcn + zone_len == lcn) { 2534 /* Append into tail MFT zone. */ 2535 wnd_zone_set(wnd, zone_lcn, zlen); 2536 } 2537 } 2538 2539 out: 2540 up_write(&wnd->rw_lock); 2541 if (dirty) 2542 ntfs_set_state(sbi, NTFS_DIRTY_ERROR); 2543 } 2544 2545 /* 2546 * run_deallocate - Deallocate clusters. 2547 */ 2548 int run_deallocate(struct ntfs_sb_info *sbi, const struct runs_tree *run, 2549 bool trim) 2550 { 2551 CLST lcn, len; 2552 size_t idx = 0; 2553 2554 while (run_get_entry(run, idx++, NULL, &lcn, &len)) { 2555 if (lcn == SPARSE_LCN) 2556 continue; 2557 2558 mark_as_free_ex(sbi, lcn, len, trim); 2559 } 2560 2561 return 0; 2562 } 2563 2564 static inline bool name_has_forbidden_chars(const struct le_str *fname) 2565 { 2566 int i, ch; 2567 2568 /* check for forbidden chars */ 2569 for (i = 0; i < fname->len; ++i) { 2570 ch = le16_to_cpu(fname->name[i]); 2571 2572 /* control chars */ 2573 if (ch < 0x20) 2574 return true; 2575 2576 switch (ch) { 2577 /* disallowed by Windows */ 2578 case '\\': 2579 case '/': 2580 case ':': 2581 case '*': 2582 case '?': 2583 case '<': 2584 case '>': 2585 case '|': 2586 case '\"': 2587 return true; 2588 2589 default: 2590 /* allowed char */ 2591 break; 2592 } 2593 } 2594 2595 /* file names cannot end with space or . */ 2596 if (fname->len > 0) { 2597 ch = le16_to_cpu(fname->name[fname->len - 1]); 2598 if (ch == ' ' || ch == '.') 2599 return true; 2600 } 2601 2602 return false; 2603 } 2604 2605 static inline bool is_reserved_name(const struct ntfs_sb_info *sbi, 2606 const struct le_str *fname) 2607 { 2608 int port_digit; 2609 const __le16 *name = fname->name; 2610 int len = fname->len; 2611 const u16 *upcase = sbi->upcase; 2612 2613 /* check for 3 chars reserved names (device names) */ 2614 /* name by itself or with any extension is forbidden */ 2615 if (len == 3 || (len > 3 && le16_to_cpu(name[3]) == '.')) 2616 if (!ntfs_cmp_names(name, 3, CON_NAME, 3, upcase, false) || 2617 !ntfs_cmp_names(name, 3, NUL_NAME, 3, upcase, false) || 2618 !ntfs_cmp_names(name, 3, AUX_NAME, 3, upcase, false) || 2619 !ntfs_cmp_names(name, 3, PRN_NAME, 3, upcase, false)) 2620 return true; 2621 2622 /* check for 4 chars reserved names (port name followed by 1..9) */ 2623 /* name by itself or with any extension is forbidden */ 2624 if (len == 4 || (len > 4 && le16_to_cpu(name[4]) == '.')) { 2625 port_digit = le16_to_cpu(name[3]); 2626 if (port_digit >= '1' && port_digit <= '9') 2627 if (!ntfs_cmp_names(name, 3, COM_NAME, 3, upcase, 2628 false) || 2629 !ntfs_cmp_names(name, 3, LPT_NAME, 3, upcase, 2630 false)) 2631 return true; 2632 } 2633 2634 return false; 2635 } 2636 2637 /* 2638 * valid_windows_name - Check if a file name is valid in Windows. 2639 */ 2640 bool valid_windows_name(struct ntfs_sb_info *sbi, const struct le_str *fname) 2641 { 2642 return !name_has_forbidden_chars(fname) && 2643 !is_reserved_name(sbi, fname); 2644 } 2645 2646 /* 2647 * ntfs_set_label - updates current ntfs label. 2648 */ 2649 int ntfs_set_label(struct ntfs_sb_info *sbi, u8 *label, int len) 2650 { 2651 int err; 2652 struct ATTRIB *attr; 2653 struct ntfs_inode *ni = sbi->volume.ni; 2654 const u8 max_ulen = 0x80; /* TODO: use attrdef to get maximum length */ 2655 /* Allocate PATH_MAX bytes. */ 2656 struct cpu_str *uni = __getname(); 2657 2658 if (!uni) 2659 return -ENOMEM; 2660 2661 err = ntfs_nls_to_utf16(sbi, label, len, uni, (PATH_MAX - 2) / 2, 2662 UTF16_LITTLE_ENDIAN); 2663 if (err < 0) 2664 goto out; 2665 2666 if (uni->len > max_ulen) { 2667 ntfs_warn(sbi->sb, "new label is too long"); 2668 err = -EFBIG; 2669 goto out; 2670 } 2671 2672 ni_lock(ni); 2673 2674 /* Ignore any errors. */ 2675 ni_remove_attr(ni, ATTR_LABEL, NULL, 0, false, NULL); 2676 2677 err = ni_insert_resident(ni, uni->len * sizeof(u16), ATTR_LABEL, NULL, 2678 0, &attr, NULL, NULL); 2679 if (err < 0) 2680 goto unlock_out; 2681 2682 /* write new label in on-disk struct. */ 2683 memcpy(resident_data(attr), uni->name, uni->len * sizeof(u16)); 2684 2685 /* update cached value of current label. */ 2686 if (len >= ARRAY_SIZE(sbi->volume.label)) 2687 len = ARRAY_SIZE(sbi->volume.label) - 1; 2688 memcpy(sbi->volume.label, label, len); 2689 sbi->volume.label[len] = 0; 2690 mark_inode_dirty_sync(&ni->vfs_inode); 2691 2692 unlock_out: 2693 ni_unlock(ni); 2694 2695 if (!err) 2696 err = _ni_write_inode(&ni->vfs_inode, 0); 2697 2698 out: 2699 __putname(uni); 2700 return err; 2701 }