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