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