fs/ntfs3/fsntfs.c

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