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