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  */
 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 = sb->s_blocksize;
 835         sector_t block1, block2;
 836         u32 bytes;
 837
 838         if (!(sbi->flags & NTFS_FLAGS_MFTMIRR))
 839                 return 0;
 840
 841         err = 0;
 842         bytes = sbi->mft.recs_mirr << sbi->record_bits;
 843         block1 = sbi->mft.lbo >> sb->s_blocksize_bits;
 844         block2 = sbi->mft.lbo2 >> sb->s_blocksize_bits;
 845
 846         for (; bytes >= blocksize; bytes -= blocksize) {
 847                 struct buffer_head *bh1, *bh2;
 848
 849                 bh1 = sb_bread(sb, block1++);
 850                 if (!bh1) {
 851                         err = -EIO;
 852                         goto out;
 853                 }
 854
 855                 bh2 = sb_getblk(sb, block2++);
 856                 if (!bh2) {
 857                         put_bh(bh1);
 858                         err = -EIO;
 859                         goto out;
 860                 }
 861
 862                 if (buffer_locked(bh2))
 863                         __wait_on_buffer(bh2);
 864
 865                 lock_buffer(bh2);
 866                 memcpy(bh2->b_data, bh1->b_data, blocksize);
 867                 set_buffer_uptodate(bh2);
 868                 mark_buffer_dirty(bh2);
 869                 unlock_buffer(bh2);
 870
 871                 put_bh(bh1);
 872                 bh1 = NULL;
 873
 874                 if (wait)
 875                         err = sync_dirty_buffer(bh2);
 876
 877                 put_bh(bh2);
 878                 if (err)
 879                         goto out;
 880         }
 881
 882         sbi->flags &= ~NTFS_FLAGS_MFTMIRR;
 883
 884 out:
 885         return err;
 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(nb->bh[idx]);
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 static inline struct bio *ntfs_alloc_bio(u32 nr_vecs)
1447 {
1448         struct bio *bio = bio_alloc(GFP_NOFS | __GFP_HIGH, nr_vecs);
1449
1450         if (!bio && (current->flags & PF_MEMALLOC)) {
1451                 while (!bio && (nr_vecs /= 2))
1452                         bio = bio_alloc(GFP_NOFS | __GFP_HIGH, nr_vecs);
1453         }
1454         return bio;
1455 }
1456
1457 /*
1458  * ntfs_bio_pages - Read/write pages from/to disk.
1459  */
1460 int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run,
1461                    struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
1462                    u32 op)
1463 {
1464         int err = 0;
1465         struct bio *new, *bio = NULL;
1466         struct super_block *sb = sbi->sb;
1467         struct block_device *bdev = sb->s_bdev;
1468         struct page *page;
1469         u8 cluster_bits = sbi->cluster_bits;
1470         CLST lcn, clen, vcn, vcn_next;
1471         u32 add, off, page_idx;
1472         u64 lbo, len;
1473         size_t run_idx;
1474         struct blk_plug plug;
1475
1476         if (!bytes)
1477                 return 0;
1478
1479         blk_start_plug(&plug);
1480
1481         /* Align vbo and bytes to be 512 bytes aligned. */
1482         lbo = (vbo + bytes + 511) & ~511ull;
1483         vbo = vbo & ~511ull;
1484         bytes = lbo - vbo;
1485
1486         vcn = vbo >> cluster_bits;
1487         if (!run_lookup_entry(run, vcn, &lcn, &clen, &run_idx)) {
1488                 err = -ENOENT;
1489                 goto out;
1490         }
1491         off = vbo & sbi->cluster_mask;
1492         page_idx = 0;
1493         page = pages[0];
1494
1495         for (;;) {
1496                 lbo = ((u64)lcn << cluster_bits) + off;
1497                 len = ((u64)clen << cluster_bits) - off;
1498 new_bio:
1499                 new = ntfs_alloc_bio(nr_pages - page_idx);
1500                 if (!new) {
1501                         err = -ENOMEM;
1502                         goto out;
1503                 }
1504                 if (bio) {
1505                         bio_chain(bio, new);
1506                         submit_bio(bio);
1507                 }
1508                 bio = new;
1509                 bio_set_dev(bio, bdev);
1510                 bio->bi_iter.bi_sector = lbo >> 9;
1511                 bio->bi_opf = op;
1512
1513                 while (len) {
1514                         off = vbo & (PAGE_SIZE - 1);
1515                         add = off + len > PAGE_SIZE ? (PAGE_SIZE - off) : len;
1516
1517                         if (bio_add_page(bio, page, add, off) < add)
1518                                 goto new_bio;
1519
1520                         if (bytes <= add)
1521                                 goto out;
1522                         bytes -= add;
1523                         vbo += add;
1524
1525                         if (add + off == PAGE_SIZE) {
1526                                 page_idx += 1;
1527                                 if (WARN_ON(page_idx >= nr_pages)) {
1528                                         err = -EINVAL;
1529                                         goto out;
1530                                 }
1531                                 page = pages[page_idx];
1532                         }
1533
1534                         if (len <= add)
1535                                 break;
1536                         len -= add;
1537                         lbo += add;
1538                 }
1539
1540                 vcn_next = vcn + clen;
1541                 if (!run_get_entry(run, ++run_idx, &vcn, &lcn, &clen) ||
1542                     vcn != vcn_next) {
1543                         err = -ENOENT;
1544                         goto out;
1545                 }
1546                 off = 0;
1547         }
1548 out:
1549         if (bio) {
1550                 if (!err)
1551                         err = submit_bio_wait(bio);
1552                 bio_put(bio);
1553         }
1554         blk_finish_plug(&plug);
1555
1556         return err;
1557 }
1558
1559 /*
1560  * ntfs_bio_fill_1 - Helper for ntfs_loadlog_and_replay().
1561  *
1562  * Fill on-disk logfile range by (-1)
1563  * this means empty logfile.
1564  */
1565 int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run)
1566 {
1567         int err = 0;
1568         struct super_block *sb = sbi->sb;
1569         struct block_device *bdev = sb->s_bdev;
1570         u8 cluster_bits = sbi->cluster_bits;
1571         struct bio *new, *bio = NULL;
1572         CLST lcn, clen;
1573         u64 lbo, len;
1574         size_t run_idx;
1575         struct page *fill;
1576         void *kaddr;
1577         struct blk_plug plug;
1578
1579         fill = alloc_page(GFP_KERNEL);
1580         if (!fill)
1581                 return -ENOMEM;
1582
1583         kaddr = kmap_atomic(fill);
1584         memset(kaddr, -1, PAGE_SIZE);
1585         kunmap_atomic(kaddr);
1586         flush_dcache_page(fill);
1587         lock_page(fill);
1588
1589         if (!run_lookup_entry(run, 0, &lcn, &clen, &run_idx)) {
1590                 err = -ENOENT;
1591                 goto out;
1592         }
1593
1594         /*
1595          * TODO: Try blkdev_issue_write_same.
1596          */
1597         blk_start_plug(&plug);
1598         do {
1599                 lbo = (u64)lcn << cluster_bits;
1600                 len = (u64)clen << cluster_bits;
1601 new_bio:
1602                 new = ntfs_alloc_bio(BIO_MAX_VECS);
1603                 if (!new) {
1604                         err = -ENOMEM;
1605                         break;
1606                 }
1607                 if (bio) {
1608                         bio_chain(bio, new);
1609                         submit_bio(bio);
1610                 }
1611                 bio = new;
1612                 bio_set_dev(bio, bdev);
1613                 bio->bi_opf = REQ_OP_WRITE;
1614                 bio->bi_iter.bi_sector = lbo >> 9;
1615
1616                 for (;;) {
1617                         u32 add = len > PAGE_SIZE ? PAGE_SIZE : len;
1618
1619                         if (bio_add_page(bio, fill, add, 0) < add)
1620                                 goto new_bio;
1621
1622                         lbo += add;
1623                         if (len <= add)
1624                                 break;
1625                         len -= add;
1626                 }
1627         } while (run_get_entry(run, ++run_idx, NULL, &lcn, &clen));
1628
1629         if (bio) {
1630                 if (!err)
1631                         err = submit_bio_wait(bio);
1632                 bio_put(bio);
1633         }
1634         blk_finish_plug(&plug);
1635 out:
1636         unlock_page(fill);
1637         put_page(fill);
1638
1639         return err;
1640 }
1641
1642 int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run,
1643                     u64 vbo, u64 *lbo, u64 *bytes)
1644 {
1645         u32 off;
1646         CLST lcn, len;
1647         u8 cluster_bits = sbi->cluster_bits;
1648
1649         if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &len, NULL))
1650                 return -ENOENT;
1651
1652         off = vbo & sbi->cluster_mask;
1653         *lbo = lcn == SPARSE_LCN ? -1 : (((u64)lcn << cluster_bits) + off);
1654         *bytes = ((u64)len << cluster_bits) - off;
1655
1656         return 0;
1657 }
1658
1659 struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST rno, bool dir)
1660 {
1661         int err = 0;
1662         struct super_block *sb = sbi->sb;
1663         struct inode *inode = new_inode(sb);
1664         struct ntfs_inode *ni;
1665
1666         if (!inode)
1667                 return ERR_PTR(-ENOMEM);
1668
1669         ni = ntfs_i(inode);
1670
1671         err = mi_format_new(&ni->mi, sbi, rno, dir ? RECORD_FLAG_DIR : 0,
1672                             false);
1673         if (err)
1674                 goto out;
1675
1676         inode->i_ino = rno;
1677         if (insert_inode_locked(inode) < 0) {
1678                 err = -EIO;
1679                 goto out;
1680         }
1681
1682 out:
1683         if (err) {
1684                 iput(inode);
1685                 ni = ERR_PTR(err);
1686         }
1687         return ni;
1688 }
1689
1690 /*
1691  * O:BAG:BAD:(A;OICI;FA;;;WD)
1692  * Owner S-1-5-32-544 (Administrators)
1693  * Group S-1-5-32-544 (Administrators)
1694  * ACE: allow S-1-1-0 (Everyone) with FILE_ALL_ACCESS
1695  */
1696 const u8 s_default_security[] __aligned(8) = {
1697         0x01, 0x00, 0x04, 0x80, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
1698         0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1C, 0x00,
1699         0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x14, 0x00, 0xFF, 0x01, 0x1F, 0x00,
1700         0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1701         0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x20, 0x00, 0x00, 0x00,
1702         0x20, 0x02, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
1703         0x20, 0x00, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00,
1704 };
1705
1706 static_assert(sizeof(s_default_security) == 0x50);
1707
1708 static inline u32 sid_length(const struct SID *sid)
1709 {
1710         return struct_size(sid, SubAuthority, sid->SubAuthorityCount);
1711 }
1712
1713 /*
1714  * is_acl_valid
1715  *
1716  * Thanks Mark Harmstone for idea.
1717  */
1718 static bool is_acl_valid(const struct ACL *acl, u32 len)
1719 {
1720         const struct ACE_HEADER *ace;
1721         u32 i;
1722         u16 ace_count, ace_size;
1723
1724         if (acl->AclRevision != ACL_REVISION &&
1725             acl->AclRevision != ACL_REVISION_DS) {
1726                 /*
1727                  * This value should be ACL_REVISION, unless the ACL contains an
1728                  * object-specific ACE, in which case this value must be ACL_REVISION_DS.
1729                  * All ACEs in an ACL must be at the same revision level.
1730                  */
1731                 return false;
1732         }
1733
1734         if (acl->Sbz1)
1735                 return false;
1736
1737         if (le16_to_cpu(acl->AclSize) > len)
1738                 return false;
1739
1740         if (acl->Sbz2)
1741                 return false;
1742
1743         len -= sizeof(struct ACL);
1744         ace = (struct ACE_HEADER *)&acl[1];
1745         ace_count = le16_to_cpu(acl->AceCount);
1746
1747         for (i = 0; i < ace_count; i++) {
1748                 if (len < sizeof(struct ACE_HEADER))
1749                         return false;
1750
1751                 ace_size = le16_to_cpu(ace->AceSize);
1752                 if (len < ace_size)
1753                         return false;
1754
1755                 len -= ace_size;
1756                 ace = Add2Ptr(ace, ace_size);
1757         }
1758
1759         return true;
1760 }
1761
1762 bool is_sd_valid(const struct SECURITY_DESCRIPTOR_RELATIVE *sd, u32 len)
1763 {
1764         u32 sd_owner, sd_group, sd_sacl, sd_dacl;
1765
1766         if (len < sizeof(struct SECURITY_DESCRIPTOR_RELATIVE))
1767                 return false;
1768
1769         if (sd->Revision != 1)
1770                 return false;
1771
1772         if (sd->Sbz1)
1773                 return false;
1774
1775         if (!(sd->Control & SE_SELF_RELATIVE))
1776                 return false;
1777
1778         sd_owner = le32_to_cpu(sd->Owner);
1779         if (sd_owner) {
1780                 const struct SID *owner = Add2Ptr(sd, sd_owner);
1781
1782                 if (sd_owner + offsetof(struct SID, SubAuthority) > len)
1783                         return false;
1784
1785                 if (owner->Revision != 1)
1786                         return false;
1787
1788                 if (sd_owner + sid_length(owner) > len)
1789                         return false;
1790         }
1791
1792         sd_group = le32_to_cpu(sd->Group);
1793         if (sd_group) {
1794                 const struct SID *group = Add2Ptr(sd, sd_group);
1795
1796                 if (sd_group + offsetof(struct SID, SubAuthority) > len)
1797                         return false;
1798
1799                 if (group->Revision != 1)
1800                         return false;
1801
1802                 if (sd_group + sid_length(group) > len)
1803                         return false;
1804         }
1805
1806         sd_sacl = le32_to_cpu(sd->Sacl);
1807         if (sd_sacl) {
1808                 const struct ACL *sacl = Add2Ptr(sd, sd_sacl);
1809
1810                 if (sd_sacl + sizeof(struct ACL) > len)
1811                         return false;
1812
1813                 if (!is_acl_valid(sacl, len - sd_sacl))
1814                         return false;
1815         }
1816
1817         sd_dacl = le32_to_cpu(sd->Dacl);
1818         if (sd_dacl) {
1819                 const struct ACL *dacl = Add2Ptr(sd, sd_dacl);
1820
1821                 if (sd_dacl + sizeof(struct ACL) > len)
1822                         return false;
1823
1824                 if (!is_acl_valid(dacl, len - sd_dacl))
1825                         return false;
1826         }
1827
1828         return true;
1829 }
1830
1831 /*
1832  * ntfs_security_init - Load and parse $Secure.
1833  */
1834 int ntfs_security_init(struct ntfs_sb_info *sbi)
1835 {
1836         int err;
1837         struct super_block *sb = sbi->sb;
1838         struct inode *inode;
1839         struct ntfs_inode *ni;
1840         struct MFT_REF ref;
1841         struct ATTRIB *attr;
1842         struct ATTR_LIST_ENTRY *le;
1843         u64 sds_size;
1844         size_t off;
1845         struct NTFS_DE *ne;
1846         struct NTFS_DE_SII *sii_e;
1847         struct ntfs_fnd *fnd_sii = NULL;
1848         const struct INDEX_ROOT *root_sii;
1849         const struct INDEX_ROOT *root_sdh;
1850         struct ntfs_index *indx_sdh = &sbi->security.index_sdh;
1851         struct ntfs_index *indx_sii = &sbi->security.index_sii;
1852
1853         ref.low = cpu_to_le32(MFT_REC_SECURE);
1854         ref.high = 0;
1855         ref.seq = cpu_to_le16(MFT_REC_SECURE);
1856
1857         inode = ntfs_iget5(sb, &ref, &NAME_SECURE);
1858         if (IS_ERR(inode)) {
1859                 err = PTR_ERR(inode);
1860                 ntfs_err(sb, "Failed to load $Secure.");
1861                 inode = NULL;
1862                 goto out;
1863         }
1864
1865         ni = ntfs_i(inode);
1866
1867         le = NULL;
1868
1869         attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SDH_NAME,
1870                             ARRAY_SIZE(SDH_NAME), NULL, NULL);
1871         if (!attr) {
1872                 err = -EINVAL;
1873                 goto out;
1874         }
1875
1876         root_sdh = resident_data(attr);
1877         if (root_sdh->type != ATTR_ZERO ||
1878             root_sdh->rule != NTFS_COLLATION_TYPE_SECURITY_HASH) {
1879                 err = -EINVAL;
1880                 goto out;
1881         }
1882
1883         err = indx_init(indx_sdh, sbi, attr, INDEX_MUTEX_SDH);
1884         if (err)
1885                 goto out;
1886
1887         attr = ni_find_attr(ni, attr, &le, ATTR_ROOT, SII_NAME,
1888                             ARRAY_SIZE(SII_NAME), NULL, NULL);
1889         if (!attr) {
1890                 err = -EINVAL;
1891                 goto out;
1892         }
1893
1894         root_sii = resident_data(attr);
1895         if (root_sii->type != ATTR_ZERO ||
1896             root_sii->rule != NTFS_COLLATION_TYPE_UINT) {
1897                 err = -EINVAL;
1898                 goto out;
1899         }
1900
1901         err = indx_init(indx_sii, sbi, attr, INDEX_MUTEX_SII);
1902         if (err)
1903                 goto out;
1904
1905         fnd_sii = fnd_get();
1906         if (!fnd_sii) {
1907                 err = -ENOMEM;
1908                 goto out;
1909         }
1910
1911         sds_size = inode->i_size;
1912
1913         /* Find the last valid Id. */
1914         sbi->security.next_id = SECURITY_ID_FIRST;
1915         /* Always write new security at the end of bucket. */
1916         sbi->security.next_off =
1917                 ALIGN(sds_size - SecurityDescriptorsBlockSize, 16);
1918
1919         off = 0;
1920         ne = NULL;
1921
1922         for (;;) {
1923                 u32 next_id;
1924
1925                 err = indx_find_raw(indx_sii, ni, root_sii, &ne, &off, fnd_sii);
1926                 if (err || !ne)
1927                         break;
1928
1929                 sii_e = (struct NTFS_DE_SII *)ne;
1930                 if (le16_to_cpu(ne->view.data_size) < SIZEOF_SECURITY_HDR)
1931                         continue;
1932
1933                 next_id = le32_to_cpu(sii_e->sec_id) + 1;
1934                 if (next_id >= sbi->security.next_id)
1935                         sbi->security.next_id = next_id;
1936         }
1937
1938         sbi->security.ni = ni;
1939         inode = NULL;
1940 out:
1941         iput(inode);
1942         fnd_put(fnd_sii);
1943
1944         return err;
1945 }
1946
1947 /*
1948  * ntfs_get_security_by_id - Read security descriptor by id.
1949  */
1950 int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id,
1951                             struct SECURITY_DESCRIPTOR_RELATIVE **sd,
1952                             size_t *size)
1953 {
1954         int err;
1955         int diff;
1956         struct ntfs_inode *ni = sbi->security.ni;
1957         struct ntfs_index *indx = &sbi->security.index_sii;
1958         void *p = NULL;
1959         struct NTFS_DE_SII *sii_e;
1960         struct ntfs_fnd *fnd_sii;
1961         struct SECURITY_HDR d_security;
1962         const struct INDEX_ROOT *root_sii;
1963         u32 t32;
1964
1965         *sd = NULL;
1966
1967         mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY);
1968
1969         fnd_sii = fnd_get();
1970         if (!fnd_sii) {
1971                 err = -ENOMEM;
1972                 goto out;
1973         }
1974
1975         root_sii = indx_get_root(indx, ni, NULL, NULL);
1976         if (!root_sii) {
1977                 err = -EINVAL;
1978                 goto out;
1979         }
1980
1981         /* Try to find this SECURITY descriptor in SII indexes. */
1982         err = indx_find(indx, ni, root_sii, &security_id, sizeof(security_id),
1983                         NULL, &diff, (struct NTFS_DE **)&sii_e, fnd_sii);
1984         if (err)
1985                 goto out;
1986
1987         if (diff)
1988                 goto out;
1989
1990         t32 = le32_to_cpu(sii_e->sec_hdr.size);
1991         if (t32 < SIZEOF_SECURITY_HDR) {
1992                 err = -EINVAL;
1993                 goto out;
1994         }
1995
1996         if (t32 > SIZEOF_SECURITY_HDR + 0x10000) {
1997                 /* Looks like too big security. 0x10000 - is arbitrary big number. */
1998                 err = -EFBIG;
1999                 goto out;
2000         }
2001
2002         *size = t32 - SIZEOF_SECURITY_HDR;
2003
2004         p = kmalloc(*size, GFP_NOFS);
2005         if (!p) {
2006                 err = -ENOMEM;
2007                 goto out;
2008         }
2009
2010         err = ntfs_read_run_nb(sbi, &ni->file.run,
2011                                le64_to_cpu(sii_e->sec_hdr.off), &d_security,
2012                                sizeof(d_security), NULL);
2013         if (err)
2014                 goto out;
2015
2016         if (memcmp(&d_security, &sii_e->sec_hdr, SIZEOF_SECURITY_HDR)) {
2017                 err = -EINVAL;
2018                 goto out;
2019         }
2020
2021         err = ntfs_read_run_nb(sbi, &ni->file.run,
2022                                le64_to_cpu(sii_e->sec_hdr.off) +
2023                                        SIZEOF_SECURITY_HDR,
2024                                p, *size, NULL);
2025         if (err)
2026                 goto out;
2027
2028         *sd = p;
2029         p = NULL;
2030
2031 out:
2032         kfree(p);
2033         fnd_put(fnd_sii);
2034         ni_unlock(ni);
2035
2036         return err;
2037 }
2038
2039 /*
2040  * ntfs_insert_security - Insert security descriptor into $Secure::SDS.
2041  *
2042  * SECURITY Descriptor Stream data is organized into chunks of 256K bytes
2043  * and it contains a mirror copy of each security descriptor.  When writing
2044  * to a security descriptor at location X, another copy will be written at
2045  * location (X+256K).
2046  * When writing a security descriptor that will cross the 256K boundary,
2047  * the pointer will be advanced by 256K to skip
2048  * over the mirror portion.
2049  */
2050 int ntfs_insert_security(struct ntfs_sb_info *sbi,
2051                          const struct SECURITY_DESCRIPTOR_RELATIVE *sd,
2052                          u32 size_sd, __le32 *security_id, bool *inserted)
2053 {
2054         int err, diff;
2055         struct ntfs_inode *ni = sbi->security.ni;
2056         struct ntfs_index *indx_sdh = &sbi->security.index_sdh;
2057         struct ntfs_index *indx_sii = &sbi->security.index_sii;
2058         struct NTFS_DE_SDH *e;
2059         struct NTFS_DE_SDH sdh_e;
2060         struct NTFS_DE_SII sii_e;
2061         struct SECURITY_HDR *d_security;
2062         u32 new_sec_size = size_sd + SIZEOF_SECURITY_HDR;
2063         u32 aligned_sec_size = ALIGN(new_sec_size, 16);
2064         struct SECURITY_KEY hash_key;
2065         struct ntfs_fnd *fnd_sdh = NULL;
2066         const struct INDEX_ROOT *root_sdh;
2067         const struct INDEX_ROOT *root_sii;
2068         u64 mirr_off, new_sds_size;
2069         u32 next, left;
2070
2071         static_assert((1 << Log2OfSecurityDescriptorsBlockSize) ==
2072                       SecurityDescriptorsBlockSize);
2073
2074         hash_key.hash = security_hash(sd, size_sd);
2075         hash_key.sec_id = SECURITY_ID_INVALID;
2076
2077         if (inserted)
2078                 *inserted = false;
2079         *security_id = SECURITY_ID_INVALID;
2080
2081         /* Allocate a temporal buffer. */
2082         d_security = kzalloc(aligned_sec_size, GFP_NOFS);
2083         if (!d_security)
2084                 return -ENOMEM;
2085
2086         mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY);
2087
2088         fnd_sdh = fnd_get();
2089         if (!fnd_sdh) {
2090                 err = -ENOMEM;
2091                 goto out;
2092         }
2093
2094         root_sdh = indx_get_root(indx_sdh, ni, NULL, NULL);
2095         if (!root_sdh) {
2096                 err = -EINVAL;
2097                 goto out;
2098         }
2099
2100         root_sii = indx_get_root(indx_sii, ni, NULL, NULL);
2101         if (!root_sii) {
2102                 err = -EINVAL;
2103                 goto out;
2104         }
2105
2106         /*
2107          * Check if such security already exists.
2108          * Use "SDH" and hash -> to get the offset in "SDS".
2109          */
2110         err = indx_find(indx_sdh, ni, root_sdh, &hash_key, sizeof(hash_key),
2111                         &d_security->key.sec_id, &diff, (struct NTFS_DE **)&e,
2112                         fnd_sdh);
2113         if (err)
2114                 goto out;
2115
2116         while (e) {
2117                 if (le32_to_cpu(e->sec_hdr.size) == new_sec_size) {
2118                         err = ntfs_read_run_nb(sbi, &ni->file.run,
2119                                                le64_to_cpu(e->sec_hdr.off),
2120                                                d_security, new_sec_size, NULL);
2121                         if (err)
2122                                 goto out;
2123
2124                         if (le32_to_cpu(d_security->size) == new_sec_size &&
2125                             d_security->key.hash == hash_key.hash &&
2126                             !memcmp(d_security + 1, sd, size_sd)) {
2127                                 *security_id = d_security->key.sec_id;
2128                                 /* Such security already exists. */
2129                                 err = 0;
2130                                 goto out;
2131                         }
2132                 }
2133
2134                 err = indx_find_sort(indx_sdh, ni, root_sdh,
2135                                      (struct NTFS_DE **)&e, fnd_sdh);
2136                 if (err)
2137                         goto out;
2138
2139                 if (!e || e->key.hash != hash_key.hash)
2140                         break;
2141         }
2142
2143         /* Zero unused space. */
2144         next = sbi->security.next_off & (SecurityDescriptorsBlockSize - 1);
2145         left = SecurityDescriptorsBlockSize - next;
2146
2147         /* Zero gap until SecurityDescriptorsBlockSize. */
2148         if (left < new_sec_size) {
2149                 /* Zero "left" bytes from sbi->security.next_off. */
2150                 sbi->security.next_off += SecurityDescriptorsBlockSize + left;
2151         }
2152
2153         /* Zero tail of previous security. */
2154         //used = ni->vfs_inode.i_size & (SecurityDescriptorsBlockSize - 1);
2155
2156         /*
2157          * Example:
2158          * 0x40438 == ni->vfs_inode.i_size
2159          * 0x00440 == sbi->security.next_off
2160          * need to zero [0x438-0x440)
2161          * if (next > used) {
2162          *  u32 tozero = next - used;
2163          *  zero "tozero" bytes from sbi->security.next_off - tozero
2164          */
2165
2166         /* Format new security descriptor. */
2167         d_security->key.hash = hash_key.hash;
2168         d_security->key.sec_id = cpu_to_le32(sbi->security.next_id);
2169         d_security->off = cpu_to_le64(sbi->security.next_off);
2170         d_security->size = cpu_to_le32(new_sec_size);
2171         memcpy(d_security + 1, sd, size_sd);
2172
2173         /* Write main SDS bucket. */
2174         err = ntfs_sb_write_run(sbi, &ni->file.run, sbi->security.next_off,
2175                                 d_security, aligned_sec_size, 0);
2176
2177         if (err)
2178                 goto out;
2179
2180         mirr_off = sbi->security.next_off + SecurityDescriptorsBlockSize;
2181         new_sds_size = mirr_off + aligned_sec_size;
2182
2183         if (new_sds_size > ni->vfs_inode.i_size) {
2184                 err = attr_set_size(ni, ATTR_DATA, SDS_NAME,
2185                                     ARRAY_SIZE(SDS_NAME), &ni->file.run,
2186                                     new_sds_size, &new_sds_size, false, NULL);
2187                 if (err)
2188                         goto out;
2189         }
2190
2191         /* Write copy SDS bucket. */
2192         err = ntfs_sb_write_run(sbi, &ni->file.run, mirr_off, d_security,
2193                                 aligned_sec_size, 0);
2194         if (err)
2195                 goto out;
2196
2197         /* Fill SII entry. */
2198         sii_e.de.view.data_off =
2199                 cpu_to_le16(offsetof(struct NTFS_DE_SII, sec_hdr));
2200         sii_e.de.view.data_size = cpu_to_le16(SIZEOF_SECURITY_HDR);
2201         sii_e.de.view.res = 0;
2202         sii_e.de.size = cpu_to_le16(SIZEOF_SII_DIRENTRY);
2203         sii_e.de.key_size = cpu_to_le16(sizeof(d_security->key.sec_id));
2204         sii_e.de.flags = 0;
2205         sii_e.de.res = 0;
2206         sii_e.sec_id = d_security->key.sec_id;
2207         memcpy(&sii_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR);
2208
2209         err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL, 0);
2210         if (err)
2211                 goto out;
2212
2213         /* Fill SDH entry. */
2214         sdh_e.de.view.data_off =
2215                 cpu_to_le16(offsetof(struct NTFS_DE_SDH, sec_hdr));
2216         sdh_e.de.view.data_size = cpu_to_le16(SIZEOF_SECURITY_HDR);
2217         sdh_e.de.view.res = 0;
2218         sdh_e.de.size = cpu_to_le16(SIZEOF_SDH_DIRENTRY);
2219         sdh_e.de.key_size = cpu_to_le16(sizeof(sdh_e.key));
2220         sdh_e.de.flags = 0;
2221         sdh_e.de.res = 0;
2222         sdh_e.key.hash = d_security->key.hash;
2223         sdh_e.key.sec_id = d_security->key.sec_id;
2224         memcpy(&sdh_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR);
2225         sdh_e.magic[0] = cpu_to_le16('I');
2226         sdh_e.magic[1] = cpu_to_le16('I');
2227
2228         fnd_clear(fnd_sdh);
2229         err = indx_insert_entry(indx_sdh, ni, &sdh_e.de, (void *)(size_t)1,
2230                                 fnd_sdh, 0);
2231         if (err)
2232                 goto out;
2233
2234         *security_id = d_security->key.sec_id;
2235         if (inserted)
2236                 *inserted = true;
2237
2238         /* Update Id and offset for next descriptor. */
2239         sbi->security.next_id += 1;
2240         sbi->security.next_off += aligned_sec_size;
2241
2242 out:
2243         fnd_put(fnd_sdh);
2244         mark_inode_dirty(&ni->vfs_inode);
2245         ni_unlock(ni);
2246         kfree(d_security);
2247
2248         return err;
2249 }
2250
2251 /*
2252  * ntfs_reparse_init - Load and parse $Extend/$Reparse.
2253  */
2254 int ntfs_reparse_init(struct ntfs_sb_info *sbi)
2255 {
2256         int err;
2257         struct ntfs_inode *ni = sbi->reparse.ni;
2258         struct ntfs_index *indx = &sbi->reparse.index_r;
2259         struct ATTRIB *attr;
2260         struct ATTR_LIST_ENTRY *le;
2261         const struct INDEX_ROOT *root_r;
2262
2263         if (!ni)
2264                 return 0;
2265
2266         le = NULL;
2267         attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SR_NAME,
2268                             ARRAY_SIZE(SR_NAME), NULL, NULL);
2269         if (!attr) {
2270                 err = -EINVAL;
2271                 goto out;
2272         }
2273
2274         root_r = resident_data(attr);
2275         if (root_r->type != ATTR_ZERO ||
2276             root_r->rule != NTFS_COLLATION_TYPE_UINTS) {
2277                 err = -EINVAL;
2278                 goto out;
2279         }
2280
2281         err = indx_init(indx, sbi, attr, INDEX_MUTEX_SR);
2282         if (err)
2283                 goto out;
2284
2285 out:
2286         return err;
2287 }
2288
2289 /*
2290  * ntfs_objid_init - Load and parse $Extend/$ObjId.
2291  */
2292 int ntfs_objid_init(struct ntfs_sb_info *sbi)
2293 {
2294         int err;
2295         struct ntfs_inode *ni = sbi->objid.ni;
2296         struct ntfs_index *indx = &sbi->objid.index_o;
2297         struct ATTRIB *attr;
2298         struct ATTR_LIST_ENTRY *le;
2299         const struct INDEX_ROOT *root;
2300
2301         if (!ni)
2302                 return 0;
2303
2304         le = NULL;
2305         attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SO_NAME,
2306                             ARRAY_SIZE(SO_NAME), NULL, NULL);
2307         if (!attr) {
2308                 err = -EINVAL;
2309                 goto out;
2310         }
2311
2312         root = resident_data(attr);
2313         if (root->type != ATTR_ZERO ||
2314             root->rule != NTFS_COLLATION_TYPE_UINTS) {
2315                 err = -EINVAL;
2316                 goto out;
2317         }
2318
2319         err = indx_init(indx, sbi, attr, INDEX_MUTEX_SO);
2320         if (err)
2321                 goto out;
2322
2323 out:
2324         return err;
2325 }
2326
2327 int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid)
2328 {
2329         int err;
2330         struct ntfs_inode *ni = sbi->objid.ni;
2331         struct ntfs_index *indx = &sbi->objid.index_o;
2332
2333         if (!ni)
2334                 return -EINVAL;
2335
2336         mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_OBJID);
2337
2338         err = indx_delete_entry(indx, ni, guid, sizeof(*guid), NULL);
2339
2340         mark_inode_dirty(&ni->vfs_inode);
2341         ni_unlock(ni);
2342
2343         return err;
2344 }
2345
2346 int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
2347                         const struct MFT_REF *ref)
2348 {
2349         int err;
2350         struct ntfs_inode *ni = sbi->reparse.ni;
2351         struct ntfs_index *indx = &sbi->reparse.index_r;
2352         struct NTFS_DE_R re;
2353
2354         if (!ni)
2355                 return -EINVAL;
2356
2357         memset(&re, 0, sizeof(re));
2358
2359         re.de.view.data_off = cpu_to_le16(offsetof(struct NTFS_DE_R, zero));
2360         re.de.size = cpu_to_le16(sizeof(struct NTFS_DE_R));
2361         re.de.key_size = cpu_to_le16(sizeof(re.key));
2362
2363         re.key.ReparseTag = rtag;
2364         memcpy(&re.key.ref, ref, sizeof(*ref));
2365
2366         mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE);
2367
2368         err = indx_insert_entry(indx, ni, &re.de, NULL, NULL, 0);
2369
2370         mark_inode_dirty(&ni->vfs_inode);
2371         ni_unlock(ni);
2372
2373         return err;
2374 }
2375
2376 int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
2377                         const struct MFT_REF *ref)
2378 {
2379         int err, diff;
2380         struct ntfs_inode *ni = sbi->reparse.ni;
2381         struct ntfs_index *indx = &sbi->reparse.index_r;
2382         struct ntfs_fnd *fnd = NULL;
2383         struct REPARSE_KEY rkey;
2384         struct NTFS_DE_R *re;
2385         struct INDEX_ROOT *root_r;
2386
2387         if (!ni)
2388                 return -EINVAL;
2389
2390         rkey.ReparseTag = rtag;
2391         rkey.ref = *ref;
2392
2393         mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE);
2394
2395         if (rtag) {
2396                 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL);
2397                 goto out1;
2398         }
2399
2400         fnd = fnd_get();
2401         if (!fnd) {
2402                 err = -ENOMEM;
2403                 goto out1;
2404         }
2405
2406         root_r = indx_get_root(indx, ni, NULL, NULL);
2407         if (!root_r) {
2408                 err = -EINVAL;
2409                 goto out;
2410         }
2411
2412         /* 1 - forces to ignore rkey.ReparseTag when comparing keys. */
2413         err = indx_find(indx, ni, root_r, &rkey, sizeof(rkey), (void *)1, &diff,
2414                         (struct NTFS_DE **)&re, fnd);
2415         if (err)
2416                 goto out;
2417
2418         if (memcmp(&re->key.ref, ref, sizeof(*ref))) {
2419                 /* Impossible. Looks like volume corrupt? */
2420                 goto out;
2421         }
2422
2423         memcpy(&rkey, &re->key, sizeof(rkey));
2424
2425         fnd_put(fnd);
2426         fnd = NULL;
2427
2428         err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL);
2429         if (err)
2430                 goto out;
2431
2432 out:
2433         fnd_put(fnd);
2434
2435 out1:
2436         mark_inode_dirty(&ni->vfs_inode);
2437         ni_unlock(ni);
2438
2439         return err;
2440 }
2441
2442 static inline void ntfs_unmap_and_discard(struct ntfs_sb_info *sbi, CLST lcn,
2443                                           CLST len)
2444 {
2445         ntfs_unmap_meta(sbi->sb, lcn, len);
2446         ntfs_discard(sbi, lcn, len);
2447 }
2448
2449 void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim)
2450 {
2451         CLST end, i;
2452         struct wnd_bitmap *wnd = &sbi->used.bitmap;
2453
2454         down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS);
2455         if (!wnd_is_used(wnd, lcn, len)) {
2456                 ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
2457
2458                 end = lcn + len;
2459                 len = 0;
2460                 for (i = lcn; i < end; i++) {
2461                         if (wnd_is_used(wnd, i, 1)) {
2462                                 if (!len)
2463                                         lcn = i;
2464                                 len += 1;
2465                                 continue;
2466                         }
2467
2468                         if (!len)
2469                                 continue;
2470
2471                         if (trim)
2472                                 ntfs_unmap_and_discard(sbi, lcn, len);
2473
2474                         wnd_set_free(wnd, lcn, len);
2475                         len = 0;
2476                 }
2477
2478                 if (!len)
2479                         goto out;
2480         }
2481
2482         if (trim)
2483                 ntfs_unmap_and_discard(sbi, lcn, len);
2484         wnd_set_free(wnd, lcn, len);
2485
2486 out:
2487         up_write(&wnd->rw_lock);
2488 }
2489
2490 /*
2491  * run_deallocate - Deallocate clusters.
2492  */
2493 int run_deallocate(struct ntfs_sb_info *sbi, struct runs_tree *run, bool trim)
2494 {
2495         CLST lcn, len;
2496         size_t idx = 0;
2497
2498         while (run_get_entry(run, idx++, NULL, &lcn, &len)) {
2499                 if (lcn == SPARSE_LCN)
2500                         continue;
2501
2502                 mark_as_free_ex(sbi, lcn, len, trim);
2503         }
2504
2505         return 0;
2506 }