Linux Audio

Check our new training course

Loading...
Note: File does not exist in v6.13.7.
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * attrib.c - NTFS attribute operations.  Part of the Linux-NTFS project.
   4 *
   5 * Copyright (c) 2001-2012 Anton Altaparmakov and Tuxera Inc.
   6 * Copyright (c) 2002 Richard Russon
   7 */
   8
   9#include <linux/buffer_head.h>
  10#include <linux/sched.h>
  11#include <linux/slab.h>
  12#include <linux/swap.h>
  13#include <linux/writeback.h>
  14
  15#include "attrib.h"
  16#include "debug.h"
  17#include "layout.h"
  18#include "lcnalloc.h"
  19#include "malloc.h"
  20#include "mft.h"
  21#include "ntfs.h"
  22#include "types.h"
  23
  24/**
  25 * ntfs_map_runlist_nolock - map (a part of) a runlist of an ntfs inode
  26 * @ni:		ntfs inode for which to map (part of) a runlist
  27 * @vcn:	map runlist part containing this vcn
  28 * @ctx:	active attribute search context if present or NULL if not
  29 *
  30 * Map the part of a runlist containing the @vcn of the ntfs inode @ni.
  31 *
  32 * If @ctx is specified, it is an active search context of @ni and its base mft
  33 * record.  This is needed when ntfs_map_runlist_nolock() encounters unmapped
  34 * runlist fragments and allows their mapping.  If you do not have the mft
  35 * record mapped, you can specify @ctx as NULL and ntfs_map_runlist_nolock()
  36 * will perform the necessary mapping and unmapping.
  37 *
  38 * Note, ntfs_map_runlist_nolock() saves the state of @ctx on entry and
  39 * restores it before returning.  Thus, @ctx will be left pointing to the same
  40 * attribute on return as on entry.  However, the actual pointers in @ctx may
  41 * point to different memory locations on return, so you must remember to reset
  42 * any cached pointers from the @ctx, i.e. after the call to
  43 * ntfs_map_runlist_nolock(), you will probably want to do:
  44 *	m = ctx->mrec;
  45 *	a = ctx->attr;
  46 * Assuming you cache ctx->attr in a variable @a of type ATTR_RECORD * and that
  47 * you cache ctx->mrec in a variable @m of type MFT_RECORD *.
  48 *
  49 * Return 0 on success and -errno on error.  There is one special error code
  50 * which is not an error as such.  This is -ENOENT.  It means that @vcn is out
  51 * of bounds of the runlist.
  52 *
  53 * Note the runlist can be NULL after this function returns if @vcn is zero and
  54 * the attribute has zero allocated size, i.e. there simply is no runlist.
  55 *
  56 * WARNING: If @ctx is supplied, regardless of whether success or failure is
  57 *	    returned, you need to check IS_ERR(@ctx->mrec) and if 'true' the @ctx
  58 *	    is no longer valid, i.e. you need to either call
  59 *	    ntfs_attr_reinit_search_ctx() or ntfs_attr_put_search_ctx() on it.
  60 *	    In that case PTR_ERR(@ctx->mrec) will give you the error code for
  61 *	    why the mapping of the old inode failed.
  62 *
  63 * Locking: - The runlist described by @ni must be locked for writing on entry
  64 *	      and is locked on return.  Note the runlist will be modified.
  65 *	    - If @ctx is NULL, the base mft record of @ni must not be mapped on
  66 *	      entry and it will be left unmapped on return.
  67 *	    - If @ctx is not NULL, the base mft record must be mapped on entry
  68 *	      and it will be left mapped on return.
  69 */
  70int ntfs_map_runlist_nolock(ntfs_inode *ni, VCN vcn, ntfs_attr_search_ctx *ctx)
  71{
  72	VCN end_vcn;
  73	unsigned long flags;
  74	ntfs_inode *base_ni;
  75	MFT_RECORD *m;
  76	ATTR_RECORD *a;
  77	runlist_element *rl;
  78	struct page *put_this_page = NULL;
  79	int err = 0;
  80	bool ctx_is_temporary, ctx_needs_reset;
  81	ntfs_attr_search_ctx old_ctx = { NULL, };
  82
  83	ntfs_debug("Mapping runlist part containing vcn 0x%llx.",
  84			(unsigned long long)vcn);
  85	if (!NInoAttr(ni))
  86		base_ni = ni;
  87	else
  88		base_ni = ni->ext.base_ntfs_ino;
  89	if (!ctx) {
  90		ctx_is_temporary = ctx_needs_reset = true;
  91		m = map_mft_record(base_ni);
  92		if (IS_ERR(m))
  93			return PTR_ERR(m);
  94		ctx = ntfs_attr_get_search_ctx(base_ni, m);
  95		if (unlikely(!ctx)) {
  96			err = -ENOMEM;
  97			goto err_out;
  98		}
  99	} else {
 100		VCN allocated_size_vcn;
 101
 102		BUG_ON(IS_ERR(ctx->mrec));
 103		a = ctx->attr;
 104		BUG_ON(!a->non_resident);
 105		ctx_is_temporary = false;
 106		end_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn);
 107		read_lock_irqsave(&ni->size_lock, flags);
 108		allocated_size_vcn = ni->allocated_size >>
 109				ni->vol->cluster_size_bits;
 110		read_unlock_irqrestore(&ni->size_lock, flags);
 111		if (!a->data.non_resident.lowest_vcn && end_vcn <= 0)
 112			end_vcn = allocated_size_vcn - 1;
 113		/*
 114		 * If we already have the attribute extent containing @vcn in
 115		 * @ctx, no need to look it up again.  We slightly cheat in
 116		 * that if vcn exceeds the allocated size, we will refuse to
 117		 * map the runlist below, so there is definitely no need to get
 118		 * the right attribute extent.
 119		 */
 120		if (vcn >= allocated_size_vcn || (a->type == ni->type &&
 121				a->name_length == ni->name_len &&
 122				!memcmp((u8*)a + le16_to_cpu(a->name_offset),
 123				ni->name, ni->name_len) &&
 124				sle64_to_cpu(a->data.non_resident.lowest_vcn)
 125				<= vcn && end_vcn >= vcn))
 126			ctx_needs_reset = false;
 127		else {
 128			/* Save the old search context. */
 129			old_ctx = *ctx;
 130			/*
 131			 * If the currently mapped (extent) inode is not the
 132			 * base inode we will unmap it when we reinitialize the
 133			 * search context which means we need to get a
 134			 * reference to the page containing the mapped mft
 135			 * record so we do not accidentally drop changes to the
 136			 * mft record when it has not been marked dirty yet.
 137			 */
 138			if (old_ctx.base_ntfs_ino && old_ctx.ntfs_ino !=
 139					old_ctx.base_ntfs_ino) {
 140				put_this_page = old_ctx.ntfs_ino->page;
 141				get_page(put_this_page);
 142			}
 143			/*
 144			 * Reinitialize the search context so we can lookup the
 145			 * needed attribute extent.
 146			 */
 147			ntfs_attr_reinit_search_ctx(ctx);
 148			ctx_needs_reset = true;
 149		}
 150	}
 151	if (ctx_needs_reset) {
 152		err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
 153				CASE_SENSITIVE, vcn, NULL, 0, ctx);
 154		if (unlikely(err)) {
 155			if (err == -ENOENT)
 156				err = -EIO;
 157			goto err_out;
 158		}
 159		BUG_ON(!ctx->attr->non_resident);
 160	}
 161	a = ctx->attr;
 162	/*
 163	 * Only decompress the mapping pairs if @vcn is inside it.  Otherwise
 164	 * we get into problems when we try to map an out of bounds vcn because
 165	 * we then try to map the already mapped runlist fragment and
 166	 * ntfs_mapping_pairs_decompress() fails.
 167	 */
 168	end_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn) + 1;
 169	if (unlikely(vcn && vcn >= end_vcn)) {
 170		err = -ENOENT;
 171		goto err_out;
 172	}
 173	rl = ntfs_mapping_pairs_decompress(ni->vol, a, ni->runlist.rl);
 174	if (IS_ERR(rl))
 175		err = PTR_ERR(rl);
 176	else
 177		ni->runlist.rl = rl;
 178err_out:
 179	if (ctx_is_temporary) {
 180		if (likely(ctx))
 181			ntfs_attr_put_search_ctx(ctx);
 182		unmap_mft_record(base_ni);
 183	} else if (ctx_needs_reset) {
 184		/*
 185		 * If there is no attribute list, restoring the search context
 186		 * is accomplished simply by copying the saved context back over
 187		 * the caller supplied context.  If there is an attribute list,
 188		 * things are more complicated as we need to deal with mapping
 189		 * of mft records and resulting potential changes in pointers.
 190		 */
 191		if (NInoAttrList(base_ni)) {
 192			/*
 193			 * If the currently mapped (extent) inode is not the
 194			 * one we had before, we need to unmap it and map the
 195			 * old one.
 196			 */
 197			if (ctx->ntfs_ino != old_ctx.ntfs_ino) {
 198				/*
 199				 * If the currently mapped inode is not the
 200				 * base inode, unmap it.
 201				 */
 202				if (ctx->base_ntfs_ino && ctx->ntfs_ino !=
 203						ctx->base_ntfs_ino) {
 204					unmap_extent_mft_record(ctx->ntfs_ino);
 205					ctx->mrec = ctx->base_mrec;
 206					BUG_ON(!ctx->mrec);
 207				}
 208				/*
 209				 * If the old mapped inode is not the base
 210				 * inode, map it.
 211				 */
 212				if (old_ctx.base_ntfs_ino &&
 213						old_ctx.ntfs_ino !=
 214						old_ctx.base_ntfs_ino) {
 215retry_map:
 216					ctx->mrec = map_mft_record(
 217							old_ctx.ntfs_ino);
 218					/*
 219					 * Something bad has happened.  If out
 220					 * of memory retry till it succeeds.
 221					 * Any other errors are fatal and we
 222					 * return the error code in ctx->mrec.
 223					 * Let the caller deal with it...  We
 224					 * just need to fudge things so the
 225					 * caller can reinit and/or put the
 226					 * search context safely.
 227					 */
 228					if (IS_ERR(ctx->mrec)) {
 229						if (PTR_ERR(ctx->mrec) ==
 230								-ENOMEM) {
 231							schedule();
 232							goto retry_map;
 233						} else
 234							old_ctx.ntfs_ino =
 235								old_ctx.
 236								base_ntfs_ino;
 237					}
 238				}
 239			}
 240			/* Update the changed pointers in the saved context. */
 241			if (ctx->mrec != old_ctx.mrec) {
 242				if (!IS_ERR(ctx->mrec))
 243					old_ctx.attr = (ATTR_RECORD*)(
 244							(u8*)ctx->mrec +
 245							((u8*)old_ctx.attr -
 246							(u8*)old_ctx.mrec));
 247				old_ctx.mrec = ctx->mrec;
 248			}
 249		}
 250		/* Restore the search context to the saved one. */
 251		*ctx = old_ctx;
 252		/*
 253		 * We drop the reference on the page we took earlier.  In the
 254		 * case that IS_ERR(ctx->mrec) is true this means we might lose
 255		 * some changes to the mft record that had been made between
 256		 * the last time it was marked dirty/written out and now.  This
 257		 * at this stage is not a problem as the mapping error is fatal
 258		 * enough that the mft record cannot be written out anyway and
 259		 * the caller is very likely to shutdown the whole inode
 260		 * immediately and mark the volume dirty for chkdsk to pick up
 261		 * the pieces anyway.
 262		 */
 263		if (put_this_page)
 264			put_page(put_this_page);
 265	}
 266	return err;
 267}
 268
 269/**
 270 * ntfs_map_runlist - map (a part of) a runlist of an ntfs inode
 271 * @ni:		ntfs inode for which to map (part of) a runlist
 272 * @vcn:	map runlist part containing this vcn
 273 *
 274 * Map the part of a runlist containing the @vcn of the ntfs inode @ni.
 275 *
 276 * Return 0 on success and -errno on error.  There is one special error code
 277 * which is not an error as such.  This is -ENOENT.  It means that @vcn is out
 278 * of bounds of the runlist.
 279 *
 280 * Locking: - The runlist must be unlocked on entry and is unlocked on return.
 281 *	    - This function takes the runlist lock for writing and may modify
 282 *	      the runlist.
 283 */
 284int ntfs_map_runlist(ntfs_inode *ni, VCN vcn)
 285{
 286	int err = 0;
 287
 288	down_write(&ni->runlist.lock);
 289	/* Make sure someone else didn't do the work while we were sleeping. */
 290	if (likely(ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn) <=
 291			LCN_RL_NOT_MAPPED))
 292		err = ntfs_map_runlist_nolock(ni, vcn, NULL);
 293	up_write(&ni->runlist.lock);
 294	return err;
 295}
 296
 297/**
 298 * ntfs_attr_vcn_to_lcn_nolock - convert a vcn into a lcn given an ntfs inode
 299 * @ni:			ntfs inode of the attribute whose runlist to search
 300 * @vcn:		vcn to convert
 301 * @write_locked:	true if the runlist is locked for writing
 302 *
 303 * Find the virtual cluster number @vcn in the runlist of the ntfs attribute
 304 * described by the ntfs inode @ni and return the corresponding logical cluster
 305 * number (lcn).
 306 *
 307 * If the @vcn is not mapped yet, the attempt is made to map the attribute
 308 * extent containing the @vcn and the vcn to lcn conversion is retried.
 309 *
 310 * If @write_locked is true the caller has locked the runlist for writing and
 311 * if false for reading.
 312 *
 313 * Since lcns must be >= 0, we use negative return codes with special meaning:
 314 *
 315 * Return code	Meaning / Description
 316 * ==========================================
 317 *  LCN_HOLE	Hole / not allocated on disk.
 318 *  LCN_ENOENT	There is no such vcn in the runlist, i.e. @vcn is out of bounds.
 319 *  LCN_ENOMEM	Not enough memory to map runlist.
 320 *  LCN_EIO	Critical error (runlist/file is corrupt, i/o error, etc).
 321 *
 322 * Locking: - The runlist must be locked on entry and is left locked on return.
 323 *	    - If @write_locked is 'false', i.e. the runlist is locked for reading,
 324 *	      the lock may be dropped inside the function so you cannot rely on
 325 *	      the runlist still being the same when this function returns.
 326 */
 327LCN ntfs_attr_vcn_to_lcn_nolock(ntfs_inode *ni, const VCN vcn,
 328		const bool write_locked)
 329{
 330	LCN lcn;
 331	unsigned long flags;
 332	bool is_retry = false;
 333
 334	BUG_ON(!ni);
 335	ntfs_debug("Entering for i_ino 0x%lx, vcn 0x%llx, %s_locked.",
 336			ni->mft_no, (unsigned long long)vcn,
 337			write_locked ? "write" : "read");
 338	BUG_ON(!NInoNonResident(ni));
 339	BUG_ON(vcn < 0);
 340	if (!ni->runlist.rl) {
 341		read_lock_irqsave(&ni->size_lock, flags);
 342		if (!ni->allocated_size) {
 343			read_unlock_irqrestore(&ni->size_lock, flags);
 344			return LCN_ENOENT;
 345		}
 346		read_unlock_irqrestore(&ni->size_lock, flags);
 347	}
 348retry_remap:
 349	/* Convert vcn to lcn.  If that fails map the runlist and retry once. */
 350	lcn = ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn);
 351	if (likely(lcn >= LCN_HOLE)) {
 352		ntfs_debug("Done, lcn 0x%llx.", (long long)lcn);
 353		return lcn;
 354	}
 355	if (lcn != LCN_RL_NOT_MAPPED) {
 356		if (lcn != LCN_ENOENT)
 357			lcn = LCN_EIO;
 358	} else if (!is_retry) {
 359		int err;
 360
 361		if (!write_locked) {
 362			up_read(&ni->runlist.lock);
 363			down_write(&ni->runlist.lock);
 364			if (unlikely(ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn) !=
 365					LCN_RL_NOT_MAPPED)) {
 366				up_write(&ni->runlist.lock);
 367				down_read(&ni->runlist.lock);
 368				goto retry_remap;
 369			}
 370		}
 371		err = ntfs_map_runlist_nolock(ni, vcn, NULL);
 372		if (!write_locked) {
 373			up_write(&ni->runlist.lock);
 374			down_read(&ni->runlist.lock);
 375		}
 376		if (likely(!err)) {
 377			is_retry = true;
 378			goto retry_remap;
 379		}
 380		if (err == -ENOENT)
 381			lcn = LCN_ENOENT;
 382		else if (err == -ENOMEM)
 383			lcn = LCN_ENOMEM;
 384		else
 385			lcn = LCN_EIO;
 386	}
 387	if (lcn != LCN_ENOENT)
 388		ntfs_error(ni->vol->sb, "Failed with error code %lli.",
 389				(long long)lcn);
 390	return lcn;
 391}
 392
 393/**
 394 * ntfs_attr_find_vcn_nolock - find a vcn in the runlist of an ntfs inode
 395 * @ni:		ntfs inode describing the runlist to search
 396 * @vcn:	vcn to find
 397 * @ctx:	active attribute search context if present or NULL if not
 398 *
 399 * Find the virtual cluster number @vcn in the runlist described by the ntfs
 400 * inode @ni and return the address of the runlist element containing the @vcn.
 401 *
 402 * If the @vcn is not mapped yet, the attempt is made to map the attribute
 403 * extent containing the @vcn and the vcn to lcn conversion is retried.
 404 *
 405 * If @ctx is specified, it is an active search context of @ni and its base mft
 406 * record.  This is needed when ntfs_attr_find_vcn_nolock() encounters unmapped
 407 * runlist fragments and allows their mapping.  If you do not have the mft
 408 * record mapped, you can specify @ctx as NULL and ntfs_attr_find_vcn_nolock()
 409 * will perform the necessary mapping and unmapping.
 410 *
 411 * Note, ntfs_attr_find_vcn_nolock() saves the state of @ctx on entry and
 412 * restores it before returning.  Thus, @ctx will be left pointing to the same
 413 * attribute on return as on entry.  However, the actual pointers in @ctx may
 414 * point to different memory locations on return, so you must remember to reset
 415 * any cached pointers from the @ctx, i.e. after the call to
 416 * ntfs_attr_find_vcn_nolock(), you will probably want to do:
 417 *	m = ctx->mrec;
 418 *	a = ctx->attr;
 419 * Assuming you cache ctx->attr in a variable @a of type ATTR_RECORD * and that
 420 * you cache ctx->mrec in a variable @m of type MFT_RECORD *.
 421 * Note you need to distinguish between the lcn of the returned runlist element
 422 * being >= 0 and LCN_HOLE.  In the later case you have to return zeroes on
 423 * read and allocate clusters on write.
 424 *
 425 * Return the runlist element containing the @vcn on success and
 426 * ERR_PTR(-errno) on error.  You need to test the return value with IS_ERR()
 427 * to decide if the return is success or failure and PTR_ERR() to get to the
 428 * error code if IS_ERR() is true.
 429 *
 430 * The possible error return codes are:
 431 *	-ENOENT - No such vcn in the runlist, i.e. @vcn is out of bounds.
 432 *	-ENOMEM - Not enough memory to map runlist.
 433 *	-EIO	- Critical error (runlist/file is corrupt, i/o error, etc).
 434 *
 435 * WARNING: If @ctx is supplied, regardless of whether success or failure is
 436 *	    returned, you need to check IS_ERR(@ctx->mrec) and if 'true' the @ctx
 437 *	    is no longer valid, i.e. you need to either call
 438 *	    ntfs_attr_reinit_search_ctx() or ntfs_attr_put_search_ctx() on it.
 439 *	    In that case PTR_ERR(@ctx->mrec) will give you the error code for
 440 *	    why the mapping of the old inode failed.
 441 *
 442 * Locking: - The runlist described by @ni must be locked for writing on entry
 443 *	      and is locked on return.  Note the runlist may be modified when
 444 *	      needed runlist fragments need to be mapped.
 445 *	    - If @ctx is NULL, the base mft record of @ni must not be mapped on
 446 *	      entry and it will be left unmapped on return.
 447 *	    - If @ctx is not NULL, the base mft record must be mapped on entry
 448 *	      and it will be left mapped on return.
 449 */
 450runlist_element *ntfs_attr_find_vcn_nolock(ntfs_inode *ni, const VCN vcn,
 451		ntfs_attr_search_ctx *ctx)
 452{
 453	unsigned long flags;
 454	runlist_element *rl;
 455	int err = 0;
 456	bool is_retry = false;
 457
 458	BUG_ON(!ni);
 459	ntfs_debug("Entering for i_ino 0x%lx, vcn 0x%llx, with%s ctx.",
 460			ni->mft_no, (unsigned long long)vcn, ctx ? "" : "out");
 461	BUG_ON(!NInoNonResident(ni));
 462	BUG_ON(vcn < 0);
 463	if (!ni->runlist.rl) {
 464		read_lock_irqsave(&ni->size_lock, flags);
 465		if (!ni->allocated_size) {
 466			read_unlock_irqrestore(&ni->size_lock, flags);
 467			return ERR_PTR(-ENOENT);
 468		}
 469		read_unlock_irqrestore(&ni->size_lock, flags);
 470	}
 471retry_remap:
 472	rl = ni->runlist.rl;
 473	if (likely(rl && vcn >= rl[0].vcn)) {
 474		while (likely(rl->length)) {
 475			if (unlikely(vcn < rl[1].vcn)) {
 476				if (likely(rl->lcn >= LCN_HOLE)) {
 477					ntfs_debug("Done.");
 478					return rl;
 479				}
 480				break;
 481			}
 482			rl++;
 483		}
 484		if (likely(rl->lcn != LCN_RL_NOT_MAPPED)) {
 485			if (likely(rl->lcn == LCN_ENOENT))
 486				err = -ENOENT;
 487			else
 488				err = -EIO;
 489		}
 490	}
 491	if (!err && !is_retry) {
 492		/*
 493		 * If the search context is invalid we cannot map the unmapped
 494		 * region.
 495		 */
 496		if (IS_ERR(ctx->mrec))
 497			err = PTR_ERR(ctx->mrec);
 498		else {
 499			/*
 500			 * The @vcn is in an unmapped region, map the runlist
 501			 * and retry.
 502			 */
 503			err = ntfs_map_runlist_nolock(ni, vcn, ctx);
 504			if (likely(!err)) {
 505				is_retry = true;
 506				goto retry_remap;
 507			}
 508		}
 509		if (err == -EINVAL)
 510			err = -EIO;
 511	} else if (!err)
 512		err = -EIO;
 513	if (err != -ENOENT)
 514		ntfs_error(ni->vol->sb, "Failed with error code %i.", err);
 515	return ERR_PTR(err);
 516}
 517
 518/**
 519 * ntfs_attr_find - find (next) attribute in mft record
 520 * @type:	attribute type to find
 521 * @name:	attribute name to find (optional, i.e. NULL means don't care)
 522 * @name_len:	attribute name length (only needed if @name present)
 523 * @ic:		IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present)
 524 * @val:	attribute value to find (optional, resident attributes only)
 525 * @val_len:	attribute value length
 526 * @ctx:	search context with mft record and attribute to search from
 527 *
 528 * You should not need to call this function directly.  Use ntfs_attr_lookup()
 529 * instead.
 530 *
 531 * ntfs_attr_find() takes a search context @ctx as parameter and searches the
 532 * mft record specified by @ctx->mrec, beginning at @ctx->attr, for an
 533 * attribute of @type, optionally @name and @val.
 534 *
 535 * If the attribute is found, ntfs_attr_find() returns 0 and @ctx->attr will
 536 * point to the found attribute.
 537 *
 538 * If the attribute is not found, ntfs_attr_find() returns -ENOENT and
 539 * @ctx->attr will point to the attribute before which the attribute being
 540 * searched for would need to be inserted if such an action were to be desired.
 541 *
 542 * On actual error, ntfs_attr_find() returns -EIO.  In this case @ctx->attr is
 543 * undefined and in particular do not rely on it not changing.
 544 *
 545 * If @ctx->is_first is 'true', the search begins with @ctx->attr itself.  If it
 546 * is 'false', the search begins after @ctx->attr.
 547 *
 548 * If @ic is IGNORE_CASE, the @name comparisson is not case sensitive and
 549 * @ctx->ntfs_ino must be set to the ntfs inode to which the mft record
 550 * @ctx->mrec belongs.  This is so we can get at the ntfs volume and hence at
 551 * the upcase table.  If @ic is CASE_SENSITIVE, the comparison is case
 552 * sensitive.  When @name is present, @name_len is the @name length in Unicode
 553 * characters.
 554 *
 555 * If @name is not present (NULL), we assume that the unnamed attribute is
 556 * being searched for.
 557 *
 558 * Finally, the resident attribute value @val is looked for, if present.  If
 559 * @val is not present (NULL), @val_len is ignored.
 560 *
 561 * ntfs_attr_find() only searches the specified mft record and it ignores the
 562 * presence of an attribute list attribute (unless it is the one being searched
 563 * for, obviously).  If you need to take attribute lists into consideration,
 564 * use ntfs_attr_lookup() instead (see below).  This also means that you cannot
 565 * use ntfs_attr_find() to search for extent records of non-resident
 566 * attributes, as extents with lowest_vcn != 0 are usually described by the
 567 * attribute list attribute only. - Note that it is possible that the first
 568 * extent is only in the attribute list while the last extent is in the base
 569 * mft record, so do not rely on being able to find the first extent in the
 570 * base mft record.
 571 *
 572 * Warning: Never use @val when looking for attribute types which can be
 573 *	    non-resident as this most likely will result in a crash!
 574 */
 575static int ntfs_attr_find(const ATTR_TYPE type, const ntfschar *name,
 576		const u32 name_len, const IGNORE_CASE_BOOL ic,
 577		const u8 *val, const u32 val_len, ntfs_attr_search_ctx *ctx)
 578{
 579	ATTR_RECORD *a;
 580	ntfs_volume *vol = ctx->ntfs_ino->vol;
 581	ntfschar *upcase = vol->upcase;
 582	u32 upcase_len = vol->upcase_len;
 583
 584	/*
 585	 * Iterate over attributes in mft record starting at @ctx->attr, or the
 586	 * attribute following that, if @ctx->is_first is 'true'.
 587	 */
 588	if (ctx->is_first) {
 589		a = ctx->attr;
 590		ctx->is_first = false;
 591	} else
 592		a = (ATTR_RECORD*)((u8*)ctx->attr +
 593				le32_to_cpu(ctx->attr->length));
 594	for (;;	a = (ATTR_RECORD*)((u8*)a + le32_to_cpu(a->length))) {
 595		u8 *mrec_end = (u8 *)ctx->mrec +
 596		               le32_to_cpu(ctx->mrec->bytes_allocated);
 597		u8 *name_end;
 598
 599		/* check whether ATTR_RECORD wrap */
 600		if ((u8 *)a < (u8 *)ctx->mrec)
 601			break;
 602
 603		/* check whether Attribute Record Header is within bounds */
 604		if ((u8 *)a > mrec_end ||
 605		    (u8 *)a + sizeof(ATTR_RECORD) > mrec_end)
 606			break;
 607
 608		/* check whether ATTR_RECORD's name is within bounds */
 609		name_end = (u8 *)a + le16_to_cpu(a->name_offset) +
 610			   a->name_length * sizeof(ntfschar);
 611		if (name_end > mrec_end)
 612			break;
 613
 614		ctx->attr = a;
 615		if (unlikely(le32_to_cpu(a->type) > le32_to_cpu(type) ||
 616				a->type == AT_END))
 617			return -ENOENT;
 618		if (unlikely(!a->length))
 619			break;
 620
 621		/* check whether ATTR_RECORD's length wrap */
 622		if ((u8 *)a + le32_to_cpu(a->length) < (u8 *)a)
 623			break;
 624		/* check whether ATTR_RECORD's length is within bounds */
 625		if ((u8 *)a + le32_to_cpu(a->length) > mrec_end)
 626			break;
 627
 628		if (a->type != type)
 629			continue;
 630		/*
 631		 * If @name is present, compare the two names.  If @name is
 632		 * missing, assume we want an unnamed attribute.
 633		 */
 634		if (!name) {
 635			/* The search failed if the found attribute is named. */
 636			if (a->name_length)
 637				return -ENOENT;
 638		} else if (!ntfs_are_names_equal(name, name_len,
 639			    (ntfschar*)((u8*)a + le16_to_cpu(a->name_offset)),
 640			    a->name_length, ic, upcase, upcase_len)) {
 641			register int rc;
 642
 643			rc = ntfs_collate_names(name, name_len,
 644					(ntfschar*)((u8*)a +
 645					le16_to_cpu(a->name_offset)),
 646					a->name_length, 1, IGNORE_CASE,
 647					upcase, upcase_len);
 648			/*
 649			 * If @name collates before a->name, there is no
 650			 * matching attribute.
 651			 */
 652			if (rc == -1)
 653				return -ENOENT;
 654			/* If the strings are not equal, continue search. */
 655			if (rc)
 656				continue;
 657			rc = ntfs_collate_names(name, name_len,
 658					(ntfschar*)((u8*)a +
 659					le16_to_cpu(a->name_offset)),
 660					a->name_length, 1, CASE_SENSITIVE,
 661					upcase, upcase_len);
 662			if (rc == -1)
 663				return -ENOENT;
 664			if (rc)
 665				continue;
 666		}
 667		/*
 668		 * The names match or @name not present and attribute is
 669		 * unnamed.  If no @val specified, we have found the attribute
 670		 * and are done.
 671		 */
 672		if (!val)
 673			return 0;
 674		/* @val is present; compare values. */
 675		else {
 676			register int rc;
 677
 678			rc = memcmp(val, (u8*)a + le16_to_cpu(
 679					a->data.resident.value_offset),
 680					min_t(u32, val_len, le32_to_cpu(
 681					a->data.resident.value_length)));
 682			/*
 683			 * If @val collates before the current attribute's
 684			 * value, there is no matching attribute.
 685			 */
 686			if (!rc) {
 687				register u32 avl;
 688
 689				avl = le32_to_cpu(
 690						a->data.resident.value_length);
 691				if (val_len == avl)
 692					return 0;
 693				if (val_len < avl)
 694					return -ENOENT;
 695			} else if (rc < 0)
 696				return -ENOENT;
 697		}
 698	}
 699	ntfs_error(vol->sb, "Inode is corrupt.  Run chkdsk.");
 700	NVolSetErrors(vol);
 701	return -EIO;
 702}
 703
 704/**
 705 * load_attribute_list - load an attribute list into memory
 706 * @vol:		ntfs volume from which to read
 707 * @runlist:		runlist of the attribute list
 708 * @al_start:		destination buffer
 709 * @size:		size of the destination buffer in bytes
 710 * @initialized_size:	initialized size of the attribute list
 711 *
 712 * Walk the runlist @runlist and load all clusters from it copying them into
 713 * the linear buffer @al. The maximum number of bytes copied to @al is @size
 714 * bytes. Note, @size does not need to be a multiple of the cluster size. If
 715 * @initialized_size is less than @size, the region in @al between
 716 * @initialized_size and @size will be zeroed and not read from disk.
 717 *
 718 * Return 0 on success or -errno on error.
 719 */
 720int load_attribute_list(ntfs_volume *vol, runlist *runlist, u8 *al_start,
 721		const s64 size, const s64 initialized_size)
 722{
 723	LCN lcn;
 724	u8 *al = al_start;
 725	u8 *al_end = al + initialized_size;
 726	runlist_element *rl;
 727	struct buffer_head *bh;
 728	struct super_block *sb;
 729	unsigned long block_size;
 730	unsigned long block, max_block;
 731	int err = 0;
 732	unsigned char block_size_bits;
 733
 734	ntfs_debug("Entering.");
 735	if (!vol || !runlist || !al || size <= 0 || initialized_size < 0 ||
 736			initialized_size > size)
 737		return -EINVAL;
 738	if (!initialized_size) {
 739		memset(al, 0, size);
 740		return 0;
 741	}
 742	sb = vol->sb;
 743	block_size = sb->s_blocksize;
 744	block_size_bits = sb->s_blocksize_bits;
 745	down_read(&runlist->lock);
 746	rl = runlist->rl;
 747	if (!rl) {
 748		ntfs_error(sb, "Cannot read attribute list since runlist is "
 749				"missing.");
 750		goto err_out;	
 751	}
 752	/* Read all clusters specified by the runlist one run at a time. */
 753	while (rl->length) {
 754		lcn = ntfs_rl_vcn_to_lcn(rl, rl->vcn);
 755		ntfs_debug("Reading vcn = 0x%llx, lcn = 0x%llx.",
 756				(unsigned long long)rl->vcn,
 757				(unsigned long long)lcn);
 758		/* The attribute list cannot be sparse. */
 759		if (lcn < 0) {
 760			ntfs_error(sb, "ntfs_rl_vcn_to_lcn() failed.  Cannot "
 761					"read attribute list.");
 762			goto err_out;
 763		}
 764		block = lcn << vol->cluster_size_bits >> block_size_bits;
 765		/* Read the run from device in chunks of block_size bytes. */
 766		max_block = block + (rl->length << vol->cluster_size_bits >>
 767				block_size_bits);
 768		ntfs_debug("max_block = 0x%lx.", max_block);
 769		do {
 770			ntfs_debug("Reading block = 0x%lx.", block);
 771			bh = sb_bread(sb, block);
 772			if (!bh) {
 773				ntfs_error(sb, "sb_bread() failed. Cannot "
 774						"read attribute list.");
 775				goto err_out;
 776			}
 777			if (al + block_size >= al_end)
 778				goto do_final;
 779			memcpy(al, bh->b_data, block_size);
 780			brelse(bh);
 781			al += block_size;
 782		} while (++block < max_block);
 783		rl++;
 784	}
 785	if (initialized_size < size) {
 786initialize:
 787		memset(al_start + initialized_size, 0, size - initialized_size);
 788	}
 789done:
 790	up_read(&runlist->lock);
 791	return err;
 792do_final:
 793	if (al < al_end) {
 794		/*
 795		 * Partial block.
 796		 *
 797		 * Note: The attribute list can be smaller than its allocation
 798		 * by multiple clusters.  This has been encountered by at least
 799		 * two people running Windows XP, thus we cannot do any
 800		 * truncation sanity checking here. (AIA)
 801		 */
 802		memcpy(al, bh->b_data, al_end - al);
 803		brelse(bh);
 804		if (initialized_size < size)
 805			goto initialize;
 806		goto done;
 807	}
 808	brelse(bh);
 809	/* Real overflow! */
 810	ntfs_error(sb, "Attribute list buffer overflow. Read attribute list "
 811			"is truncated.");
 812err_out:
 813	err = -EIO;
 814	goto done;
 815}
 816
 817/**
 818 * ntfs_external_attr_find - find an attribute in the attribute list of an inode
 819 * @type:	attribute type to find
 820 * @name:	attribute name to find (optional, i.e. NULL means don't care)
 821 * @name_len:	attribute name length (only needed if @name present)
 822 * @ic:		IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present)
 823 * @lowest_vcn:	lowest vcn to find (optional, non-resident attributes only)
 824 * @val:	attribute value to find (optional, resident attributes only)
 825 * @val_len:	attribute value length
 826 * @ctx:	search context with mft record and attribute to search from
 827 *
 828 * You should not need to call this function directly.  Use ntfs_attr_lookup()
 829 * instead.
 830 *
 831 * Find an attribute by searching the attribute list for the corresponding
 832 * attribute list entry.  Having found the entry, map the mft record if the
 833 * attribute is in a different mft record/inode, ntfs_attr_find() the attribute
 834 * in there and return it.
 835 *
 836 * On first search @ctx->ntfs_ino must be the base mft record and @ctx must
 837 * have been obtained from a call to ntfs_attr_get_search_ctx().  On subsequent
 838 * calls @ctx->ntfs_ino can be any extent inode, too (@ctx->base_ntfs_ino is
 839 * then the base inode).
 840 *
 841 * After finishing with the attribute/mft record you need to call
 842 * ntfs_attr_put_search_ctx() to cleanup the search context (unmapping any
 843 * mapped inodes, etc).
 844 *
 845 * If the attribute is found, ntfs_external_attr_find() returns 0 and
 846 * @ctx->attr will point to the found attribute.  @ctx->mrec will point to the
 847 * mft record in which @ctx->attr is located and @ctx->al_entry will point to
 848 * the attribute list entry for the attribute.
 849 *
 850 * If the attribute is not found, ntfs_external_attr_find() returns -ENOENT and
 851 * @ctx->attr will point to the attribute in the base mft record before which
 852 * the attribute being searched for would need to be inserted if such an action
 853 * were to be desired.  @ctx->mrec will point to the mft record in which
 854 * @ctx->attr is located and @ctx->al_entry will point to the attribute list
 855 * entry of the attribute before which the attribute being searched for would
 856 * need to be inserted if such an action were to be desired.
 857 *
 858 * Thus to insert the not found attribute, one wants to add the attribute to
 859 * @ctx->mrec (the base mft record) and if there is not enough space, the
 860 * attribute should be placed in a newly allocated extent mft record.  The
 861 * attribute list entry for the inserted attribute should be inserted in the
 862 * attribute list attribute at @ctx->al_entry.
 863 *
 864 * On actual error, ntfs_external_attr_find() returns -EIO.  In this case
 865 * @ctx->attr is undefined and in particular do not rely on it not changing.
 866 */
 867static int ntfs_external_attr_find(const ATTR_TYPE type,
 868		const ntfschar *name, const u32 name_len,
 869		const IGNORE_CASE_BOOL ic, const VCN lowest_vcn,
 870		const u8 *val, const u32 val_len, ntfs_attr_search_ctx *ctx)
 871{
 872	ntfs_inode *base_ni, *ni;
 873	ntfs_volume *vol;
 874	ATTR_LIST_ENTRY *al_entry, *next_al_entry;
 875	u8 *al_start, *al_end;
 876	ATTR_RECORD *a;
 877	ntfschar *al_name;
 878	u32 al_name_len;
 879	int err = 0;
 880	static const char *es = " Unmount and run chkdsk.";
 881
 882	ni = ctx->ntfs_ino;
 883	base_ni = ctx->base_ntfs_ino;
 884	ntfs_debug("Entering for inode 0x%lx, type 0x%x.", ni->mft_no, type);
 885	if (!base_ni) {
 886		/* First call happens with the base mft record. */
 887		base_ni = ctx->base_ntfs_ino = ctx->ntfs_ino;
 888		ctx->base_mrec = ctx->mrec;
 889	}
 890	if (ni == base_ni)
 891		ctx->base_attr = ctx->attr;
 892	if (type == AT_END)
 893		goto not_found;
 894	vol = base_ni->vol;
 895	al_start = base_ni->attr_list;
 896	al_end = al_start + base_ni->attr_list_size;
 897	if (!ctx->al_entry)
 898		ctx->al_entry = (ATTR_LIST_ENTRY*)al_start;
 899	/*
 900	 * Iterate over entries in attribute list starting at @ctx->al_entry,
 901	 * or the entry following that, if @ctx->is_first is 'true'.
 902	 */
 903	if (ctx->is_first) {
 904		al_entry = ctx->al_entry;
 905		ctx->is_first = false;
 906	} else
 907		al_entry = (ATTR_LIST_ENTRY*)((u8*)ctx->al_entry +
 908				le16_to_cpu(ctx->al_entry->length));
 909	for (;; al_entry = next_al_entry) {
 910		/* Out of bounds check. */
 911		if ((u8*)al_entry < base_ni->attr_list ||
 912				(u8*)al_entry > al_end)
 913			break;	/* Inode is corrupt. */
 914		ctx->al_entry = al_entry;
 915		/* Catch the end of the attribute list. */
 916		if ((u8*)al_entry == al_end)
 917			goto not_found;
 918		if (!al_entry->length)
 919			break;
 920		if ((u8*)al_entry + 6 > al_end || (u8*)al_entry +
 921				le16_to_cpu(al_entry->length) > al_end)
 922			break;
 923		next_al_entry = (ATTR_LIST_ENTRY*)((u8*)al_entry +
 924				le16_to_cpu(al_entry->length));
 925		if (le32_to_cpu(al_entry->type) > le32_to_cpu(type))
 926			goto not_found;
 927		if (type != al_entry->type)
 928			continue;
 929		/*
 930		 * If @name is present, compare the two names.  If @name is
 931		 * missing, assume we want an unnamed attribute.
 932		 */
 933		al_name_len = al_entry->name_length;
 934		al_name = (ntfschar*)((u8*)al_entry + al_entry->name_offset);
 935		if (!name) {
 936			if (al_name_len)
 937				goto not_found;
 938		} else if (!ntfs_are_names_equal(al_name, al_name_len, name,
 939				name_len, ic, vol->upcase, vol->upcase_len)) {
 940			register int rc;
 941
 942			rc = ntfs_collate_names(name, name_len, al_name,
 943					al_name_len, 1, IGNORE_CASE,
 944					vol->upcase, vol->upcase_len);
 945			/*
 946			 * If @name collates before al_name, there is no
 947			 * matching attribute.
 948			 */
 949			if (rc == -1)
 950				goto not_found;
 951			/* If the strings are not equal, continue search. */
 952			if (rc)
 953				continue;
 954			/*
 955			 * FIXME: Reverse engineering showed 0, IGNORE_CASE but
 956			 * that is inconsistent with ntfs_attr_find().  The
 957			 * subsequent rc checks were also different.  Perhaps I
 958			 * made a mistake in one of the two.  Need to recheck
 959			 * which is correct or at least see what is going on...
 960			 * (AIA)
 961			 */
 962			rc = ntfs_collate_names(name, name_len, al_name,
 963					al_name_len, 1, CASE_SENSITIVE,
 964					vol->upcase, vol->upcase_len);
 965			if (rc == -1)
 966				goto not_found;
 967			if (rc)
 968				continue;
 969		}
 970		/*
 971		 * The names match or @name not present and attribute is
 972		 * unnamed.  Now check @lowest_vcn.  Continue search if the
 973		 * next attribute list entry still fits @lowest_vcn.  Otherwise
 974		 * we have reached the right one or the search has failed.
 975		 */
 976		if (lowest_vcn && (u8*)next_al_entry >= al_start	    &&
 977				(u8*)next_al_entry + 6 < al_end		    &&
 978				(u8*)next_al_entry + le16_to_cpu(
 979					next_al_entry->length) <= al_end    &&
 980				sle64_to_cpu(next_al_entry->lowest_vcn) <=
 981					lowest_vcn			    &&
 982				next_al_entry->type == al_entry->type	    &&
 983				next_al_entry->name_length == al_name_len   &&
 984				ntfs_are_names_equal((ntfschar*)((u8*)
 985					next_al_entry +
 986					next_al_entry->name_offset),
 987					next_al_entry->name_length,
 988					al_name, al_name_len, CASE_SENSITIVE,
 989					vol->upcase, vol->upcase_len))
 990			continue;
 991		if (MREF_LE(al_entry->mft_reference) == ni->mft_no) {
 992			if (MSEQNO_LE(al_entry->mft_reference) != ni->seq_no) {
 993				ntfs_error(vol->sb, "Found stale mft "
 994						"reference in attribute list "
 995						"of base inode 0x%lx.%s",
 996						base_ni->mft_no, es);
 997				err = -EIO;
 998				break;
 999			}
1000		} else { /* Mft references do not match. */
1001			/* If there is a mapped record unmap it first. */
1002			if (ni != base_ni)
1003				unmap_extent_mft_record(ni);
1004			/* Do we want the base record back? */
1005			if (MREF_LE(al_entry->mft_reference) ==
1006					base_ni->mft_no) {
1007				ni = ctx->ntfs_ino = base_ni;
1008				ctx->mrec = ctx->base_mrec;
1009			} else {
1010				/* We want an extent record. */
1011				ctx->mrec = map_extent_mft_record(base_ni,
1012						le64_to_cpu(
1013						al_entry->mft_reference), &ni);
1014				if (IS_ERR(ctx->mrec)) {
1015					ntfs_error(vol->sb, "Failed to map "
1016							"extent mft record "
1017							"0x%lx of base inode "
1018							"0x%lx.%s",
1019							MREF_LE(al_entry->
1020							mft_reference),
1021							base_ni->mft_no, es);
1022					err = PTR_ERR(ctx->mrec);
1023					if (err == -ENOENT)
1024						err = -EIO;
1025					/* Cause @ctx to be sanitized below. */
1026					ni = NULL;
1027					break;
1028				}
1029				ctx->ntfs_ino = ni;
1030			}
1031			ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +
1032					le16_to_cpu(ctx->mrec->attrs_offset));
1033		}
1034		/*
1035		 * ctx->vfs_ino, ctx->mrec, and ctx->attr now point to the
1036		 * mft record containing the attribute represented by the
1037		 * current al_entry.
1038		 */
1039		/*
1040		 * We could call into ntfs_attr_find() to find the right
1041		 * attribute in this mft record but this would be less
1042		 * efficient and not quite accurate as ntfs_attr_find() ignores
1043		 * the attribute instance numbers for example which become
1044		 * important when one plays with attribute lists.  Also,
1045		 * because a proper match has been found in the attribute list
1046		 * entry above, the comparison can now be optimized.  So it is
1047		 * worth re-implementing a simplified ntfs_attr_find() here.
1048		 */
1049		a = ctx->attr;
1050		/*
1051		 * Use a manual loop so we can still use break and continue
1052		 * with the same meanings as above.
1053		 */
1054do_next_attr_loop:
1055		if ((u8*)a < (u8*)ctx->mrec || (u8*)a > (u8*)ctx->mrec +
1056				le32_to_cpu(ctx->mrec->bytes_allocated))
1057			break;
1058		if (a->type == AT_END)
1059			break;
1060		if (!a->length)
1061			break;
1062		if (al_entry->instance != a->instance)
1063			goto do_next_attr;
1064		/*
1065		 * If the type and/or the name are mismatched between the
1066		 * attribute list entry and the attribute record, there is
1067		 * corruption so we break and return error EIO.
1068		 */
1069		if (al_entry->type != a->type)
1070			break;
1071		if (!ntfs_are_names_equal((ntfschar*)((u8*)a +
1072				le16_to_cpu(a->name_offset)), a->name_length,
1073				al_name, al_name_len, CASE_SENSITIVE,
1074				vol->upcase, vol->upcase_len))
1075			break;
1076		ctx->attr = a;
1077		/*
1078		 * If no @val specified or @val specified and it matches, we
1079		 * have found it!
1080		 */
1081		if (!val || (!a->non_resident && le32_to_cpu(
1082				a->data.resident.value_length) == val_len &&
1083				!memcmp((u8*)a +
1084				le16_to_cpu(a->data.resident.value_offset),
1085				val, val_len))) {
1086			ntfs_debug("Done, found.");
1087			return 0;
1088		}
1089do_next_attr:
1090		/* Proceed to the next attribute in the current mft record. */
1091		a = (ATTR_RECORD*)((u8*)a + le32_to_cpu(a->length));
1092		goto do_next_attr_loop;
1093	}
1094	if (!err) {
1095		ntfs_error(vol->sb, "Base inode 0x%lx contains corrupt "
1096				"attribute list attribute.%s", base_ni->mft_no,
1097				es);
1098		err = -EIO;
1099	}
1100	if (ni != base_ni) {
1101		if (ni)
1102			unmap_extent_mft_record(ni);
1103		ctx->ntfs_ino = base_ni;
1104		ctx->mrec = ctx->base_mrec;
1105		ctx->attr = ctx->base_attr;
1106	}
1107	if (err != -ENOMEM)
1108		NVolSetErrors(vol);
1109	return err;
1110not_found:
1111	/*
1112	 * If we were looking for AT_END, we reset the search context @ctx and
1113	 * use ntfs_attr_find() to seek to the end of the base mft record.
1114	 */
1115	if (type == AT_END) {
1116		ntfs_attr_reinit_search_ctx(ctx);
1117		return ntfs_attr_find(AT_END, name, name_len, ic, val, val_len,
1118				ctx);
1119	}
1120	/*
1121	 * The attribute was not found.  Before we return, we want to ensure
1122	 * @ctx->mrec and @ctx->attr indicate the position at which the
1123	 * attribute should be inserted in the base mft record.  Since we also
1124	 * want to preserve @ctx->al_entry we cannot reinitialize the search
1125	 * context using ntfs_attr_reinit_search_ctx() as this would set
1126	 * @ctx->al_entry to NULL.  Thus we do the necessary bits manually (see
1127	 * ntfs_attr_init_search_ctx() below).  Note, we _only_ preserve
1128	 * @ctx->al_entry as the remaining fields (base_*) are identical to
1129	 * their non base_ counterparts and we cannot set @ctx->base_attr
1130	 * correctly yet as we do not know what @ctx->attr will be set to by
1131	 * the call to ntfs_attr_find() below.
1132	 */
1133	if (ni != base_ni)
1134		unmap_extent_mft_record(ni);
1135	ctx->mrec = ctx->base_mrec;
1136	ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +
1137			le16_to_cpu(ctx->mrec->attrs_offset));
1138	ctx->is_first = true;
1139	ctx->ntfs_ino = base_ni;
1140	ctx->base_ntfs_ino = NULL;
1141	ctx->base_mrec = NULL;
1142	ctx->base_attr = NULL;
1143	/*
1144	 * In case there are multiple matches in the base mft record, need to
1145	 * keep enumerating until we get an attribute not found response (or
1146	 * another error), otherwise we would keep returning the same attribute
1147	 * over and over again and all programs using us for enumeration would
1148	 * lock up in a tight loop.
1149	 */
1150	do {
1151		err = ntfs_attr_find(type, name, name_len, ic, val, val_len,
1152				ctx);
1153	} while (!err);
1154	ntfs_debug("Done, not found.");
1155	return err;
1156}
1157
1158/**
1159 * ntfs_attr_lookup - find an attribute in an ntfs inode
1160 * @type:	attribute type to find
1161 * @name:	attribute name to find (optional, i.e. NULL means don't care)
1162 * @name_len:	attribute name length (only needed if @name present)
1163 * @ic:		IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present)
1164 * @lowest_vcn:	lowest vcn to find (optional, non-resident attributes only)
1165 * @val:	attribute value to find (optional, resident attributes only)
1166 * @val_len:	attribute value length
1167 * @ctx:	search context with mft record and attribute to search from
1168 *
1169 * Find an attribute in an ntfs inode.  On first search @ctx->ntfs_ino must
1170 * be the base mft record and @ctx must have been obtained from a call to
1171 * ntfs_attr_get_search_ctx().
1172 *
1173 * This function transparently handles attribute lists and @ctx is used to
1174 * continue searches where they were left off at.
1175 *
1176 * After finishing with the attribute/mft record you need to call
1177 * ntfs_attr_put_search_ctx() to cleanup the search context (unmapping any
1178 * mapped inodes, etc).
1179 *
1180 * Return 0 if the search was successful and -errno if not.
1181 *
1182 * When 0, @ctx->attr is the found attribute and it is in mft record
1183 * @ctx->mrec.  If an attribute list attribute is present, @ctx->al_entry is
1184 * the attribute list entry of the found attribute.
1185 *
1186 * When -ENOENT, @ctx->attr is the attribute which collates just after the
1187 * attribute being searched for, i.e. if one wants to add the attribute to the
1188 * mft record this is the correct place to insert it into.  If an attribute
1189 * list attribute is present, @ctx->al_entry is the attribute list entry which
1190 * collates just after the attribute list entry of the attribute being searched
1191 * for, i.e. if one wants to add the attribute to the mft record this is the
1192 * correct place to insert its attribute list entry into.
1193 *
1194 * When -errno != -ENOENT, an error occurred during the lookup.  @ctx->attr is
1195 * then undefined and in particular you should not rely on it not changing.
1196 */
1197int ntfs_attr_lookup(const ATTR_TYPE type, const ntfschar *name,
1198		const u32 name_len, const IGNORE_CASE_BOOL ic,
1199		const VCN lowest_vcn, const u8 *val, const u32 val_len,
1200		ntfs_attr_search_ctx *ctx)
1201{
1202	ntfs_inode *base_ni;
1203
1204	ntfs_debug("Entering.");
1205	BUG_ON(IS_ERR(ctx->mrec));
1206	if (ctx->base_ntfs_ino)
1207		base_ni = ctx->base_ntfs_ino;
1208	else
1209		base_ni = ctx->ntfs_ino;
1210	/* Sanity check, just for debugging really. */
1211	BUG_ON(!base_ni);
1212	if (!NInoAttrList(base_ni) || type == AT_ATTRIBUTE_LIST)
1213		return ntfs_attr_find(type, name, name_len, ic, val, val_len,
1214				ctx);
1215	return ntfs_external_attr_find(type, name, name_len, ic, lowest_vcn,
1216			val, val_len, ctx);
1217}
1218
1219/**
1220 * ntfs_attr_init_search_ctx - initialize an attribute search context
1221 * @ctx:	attribute search context to initialize
1222 * @ni:		ntfs inode with which to initialize the search context
1223 * @mrec:	mft record with which to initialize the search context
1224 *
1225 * Initialize the attribute search context @ctx with @ni and @mrec.
1226 */
1227static inline void ntfs_attr_init_search_ctx(ntfs_attr_search_ctx *ctx,
1228		ntfs_inode *ni, MFT_RECORD *mrec)
1229{
1230	*ctx = (ntfs_attr_search_ctx) {
1231		.mrec = mrec,
1232		/* Sanity checks are performed elsewhere. */
1233		.attr = (ATTR_RECORD*)((u8*)mrec +
1234				le16_to_cpu(mrec->attrs_offset)),
1235		.is_first = true,
1236		.ntfs_ino = ni,
1237	};
1238}
1239
1240/**
1241 * ntfs_attr_reinit_search_ctx - reinitialize an attribute search context
1242 * @ctx:	attribute search context to reinitialize
1243 *
1244 * Reinitialize the attribute search context @ctx, unmapping an associated
1245 * extent mft record if present, and initialize the search context again.
1246 *
1247 * This is used when a search for a new attribute is being started to reset
1248 * the search context to the beginning.
1249 */
1250void ntfs_attr_reinit_search_ctx(ntfs_attr_search_ctx *ctx)
1251{
1252	if (likely(!ctx->base_ntfs_ino)) {
1253		/* No attribute list. */
1254		ctx->is_first = true;
1255		/* Sanity checks are performed elsewhere. */
1256		ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +
1257				le16_to_cpu(ctx->mrec->attrs_offset));
1258		/*
1259		 * This needs resetting due to ntfs_external_attr_find() which
1260		 * can leave it set despite having zeroed ctx->base_ntfs_ino.
1261		 */
1262		ctx->al_entry = NULL;
1263		return;
1264	} /* Attribute list. */
1265	if (ctx->ntfs_ino != ctx->base_ntfs_ino)
1266		unmap_extent_mft_record(ctx->ntfs_ino);
1267	ntfs_attr_init_search_ctx(ctx, ctx->base_ntfs_ino, ctx->base_mrec);
1268	return;
1269}
1270
1271/**
1272 * ntfs_attr_get_search_ctx - allocate/initialize a new attribute search context
1273 * @ni:		ntfs inode with which to initialize the search context
1274 * @mrec:	mft record with which to initialize the search context
1275 *
1276 * Allocate a new attribute search context, initialize it with @ni and @mrec,
1277 * and return it. Return NULL if allocation failed.
1278 */
1279ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni, MFT_RECORD *mrec)
1280{
1281	ntfs_attr_search_ctx *ctx;
1282
1283	ctx = kmem_cache_alloc(ntfs_attr_ctx_cache, GFP_NOFS);
1284	if (ctx)
1285		ntfs_attr_init_search_ctx(ctx, ni, mrec);
1286	return ctx;
1287}
1288
1289/**
1290 * ntfs_attr_put_search_ctx - release an attribute search context
1291 * @ctx:	attribute search context to free
1292 *
1293 * Release the attribute search context @ctx, unmapping an associated extent
1294 * mft record if present.
1295 */
1296void ntfs_attr_put_search_ctx(ntfs_attr_search_ctx *ctx)
1297{
1298	if (ctx->base_ntfs_ino && ctx->ntfs_ino != ctx->base_ntfs_ino)
1299		unmap_extent_mft_record(ctx->ntfs_ino);
1300	kmem_cache_free(ntfs_attr_ctx_cache, ctx);
1301	return;
1302}
1303
1304#ifdef NTFS_RW
1305
1306/**
1307 * ntfs_attr_find_in_attrdef - find an attribute in the $AttrDef system file
1308 * @vol:	ntfs volume to which the attribute belongs
1309 * @type:	attribute type which to find
1310 *
1311 * Search for the attribute definition record corresponding to the attribute
1312 * @type in the $AttrDef system file.
1313 *
1314 * Return the attribute type definition record if found and NULL if not found.
1315 */
1316static ATTR_DEF *ntfs_attr_find_in_attrdef(const ntfs_volume *vol,
1317		const ATTR_TYPE type)
1318{
1319	ATTR_DEF *ad;
1320
1321	BUG_ON(!vol->attrdef);
1322	BUG_ON(!type);
1323	for (ad = vol->attrdef; (u8*)ad - (u8*)vol->attrdef <
1324			vol->attrdef_size && ad->type; ++ad) {
1325		/* We have not found it yet, carry on searching. */
1326		if (likely(le32_to_cpu(ad->type) < le32_to_cpu(type)))
1327			continue;
1328		/* We found the attribute; return it. */
1329		if (likely(ad->type == type))
1330			return ad;
1331		/* We have gone too far already.  No point in continuing. */
1332		break;
1333	}
1334	/* Attribute not found. */
1335	ntfs_debug("Attribute type 0x%x not found in $AttrDef.",
1336			le32_to_cpu(type));
1337	return NULL;
1338}
1339
1340/**
1341 * ntfs_attr_size_bounds_check - check a size of an attribute type for validity
1342 * @vol:	ntfs volume to which the attribute belongs
1343 * @type:	attribute type which to check
1344 * @size:	size which to check
1345 *
1346 * Check whether the @size in bytes is valid for an attribute of @type on the
1347 * ntfs volume @vol.  This information is obtained from $AttrDef system file.
1348 *
1349 * Return 0 if valid, -ERANGE if not valid, or -ENOENT if the attribute is not
1350 * listed in $AttrDef.
1351 */
1352int ntfs_attr_size_bounds_check(const ntfs_volume *vol, const ATTR_TYPE type,
1353		const s64 size)
1354{
1355	ATTR_DEF *ad;
1356
1357	BUG_ON(size < 0);
1358	/*
1359	 * $ATTRIBUTE_LIST has a maximum size of 256kiB, but this is not
1360	 * listed in $AttrDef.
1361	 */
1362	if (unlikely(type == AT_ATTRIBUTE_LIST && size > 256 * 1024))
1363		return -ERANGE;
1364	/* Get the $AttrDef entry for the attribute @type. */
1365	ad = ntfs_attr_find_in_attrdef(vol, type);
1366	if (unlikely(!ad))
1367		return -ENOENT;
1368	/* Do the bounds check. */
1369	if (((sle64_to_cpu(ad->min_size) > 0) &&
1370			size < sle64_to_cpu(ad->min_size)) ||
1371			((sle64_to_cpu(ad->max_size) > 0) && size >
1372			sle64_to_cpu(ad->max_size)))
1373		return -ERANGE;
1374	return 0;
1375}
1376
1377/**
1378 * ntfs_attr_can_be_non_resident - check if an attribute can be non-resident
1379 * @vol:	ntfs volume to which the attribute belongs
1380 * @type:	attribute type which to check
1381 *
1382 * Check whether the attribute of @type on the ntfs volume @vol is allowed to
1383 * be non-resident.  This information is obtained from $AttrDef system file.
1384 *
1385 * Return 0 if the attribute is allowed to be non-resident, -EPERM if not, and
1386 * -ENOENT if the attribute is not listed in $AttrDef.
1387 */
1388int ntfs_attr_can_be_non_resident(const ntfs_volume *vol, const ATTR_TYPE type)
1389{
1390	ATTR_DEF *ad;
1391
1392	/* Find the attribute definition record in $AttrDef. */
1393	ad = ntfs_attr_find_in_attrdef(vol, type);
1394	if (unlikely(!ad))
1395		return -ENOENT;
1396	/* Check the flags and return the result. */
1397	if (ad->flags & ATTR_DEF_RESIDENT)
1398		return -EPERM;
1399	return 0;
1400}
1401
1402/**
1403 * ntfs_attr_can_be_resident - check if an attribute can be resident
1404 * @vol:	ntfs volume to which the attribute belongs
1405 * @type:	attribute type which to check
1406 *
1407 * Check whether the attribute of @type on the ntfs volume @vol is allowed to
1408 * be resident.  This information is derived from our ntfs knowledge and may
1409 * not be completely accurate, especially when user defined attributes are
1410 * present.  Basically we allow everything to be resident except for index
1411 * allocation and $EA attributes.
1412 *
1413 * Return 0 if the attribute is allowed to be non-resident and -EPERM if not.
1414 *
1415 * Warning: In the system file $MFT the attribute $Bitmap must be non-resident
1416 *	    otherwise windows will not boot (blue screen of death)!  We cannot
1417 *	    check for this here as we do not know which inode's $Bitmap is
1418 *	    being asked about so the caller needs to special case this.
1419 */
1420int ntfs_attr_can_be_resident(const ntfs_volume *vol, const ATTR_TYPE type)
1421{
1422	if (type == AT_INDEX_ALLOCATION)
1423		return -EPERM;
1424	return 0;
1425}
1426
1427/**
1428 * ntfs_attr_record_resize - resize an attribute record
1429 * @m:		mft record containing attribute record
1430 * @a:		attribute record to resize
1431 * @new_size:	new size in bytes to which to resize the attribute record @a
1432 *
1433 * Resize the attribute record @a, i.e. the resident part of the attribute, in
1434 * the mft record @m to @new_size bytes.
1435 *
1436 * Return 0 on success and -errno on error.  The following error codes are
1437 * defined:
1438 *	-ENOSPC	- Not enough space in the mft record @m to perform the resize.
1439 *
1440 * Note: On error, no modifications have been performed whatsoever.
1441 *
1442 * Warning: If you make a record smaller without having copied all the data you
1443 *	    are interested in the data may be overwritten.
1444 */
1445int ntfs_attr_record_resize(MFT_RECORD *m, ATTR_RECORD *a, u32 new_size)
1446{
1447	ntfs_debug("Entering for new_size %u.", new_size);
1448	/* Align to 8 bytes if it is not already done. */
1449	if (new_size & 7)
1450		new_size = (new_size + 7) & ~7;
1451	/* If the actual attribute length has changed, move things around. */
1452	if (new_size != le32_to_cpu(a->length)) {
1453		u32 new_muse = le32_to_cpu(m->bytes_in_use) -
1454				le32_to_cpu(a->length) + new_size;
1455		/* Not enough space in this mft record. */
1456		if (new_muse > le32_to_cpu(m->bytes_allocated))
1457			return -ENOSPC;
1458		/* Move attributes following @a to their new location. */
1459		memmove((u8*)a + new_size, (u8*)a + le32_to_cpu(a->length),
1460				le32_to_cpu(m->bytes_in_use) - ((u8*)a -
1461				(u8*)m) - le32_to_cpu(a->length));
1462		/* Adjust @m to reflect the change in used space. */
1463		m->bytes_in_use = cpu_to_le32(new_muse);
1464		/* Adjust @a to reflect the new size. */
1465		if (new_size >= offsetof(ATTR_REC, length) + sizeof(a->length))
1466			a->length = cpu_to_le32(new_size);
1467	}
1468	return 0;
1469}
1470
1471/**
1472 * ntfs_resident_attr_value_resize - resize the value of a resident attribute
1473 * @m:		mft record containing attribute record
1474 * @a:		attribute record whose value to resize
1475 * @new_size:	new size in bytes to which to resize the attribute value of @a
1476 *
1477 * Resize the value of the attribute @a in the mft record @m to @new_size bytes.
1478 * If the value is made bigger, the newly allocated space is cleared.
1479 *
1480 * Return 0 on success and -errno on error.  The following error codes are
1481 * defined:
1482 *	-ENOSPC	- Not enough space in the mft record @m to perform the resize.
1483 *
1484 * Note: On error, no modifications have been performed whatsoever.
1485 *
1486 * Warning: If you make a record smaller without having copied all the data you
1487 *	    are interested in the data may be overwritten.
1488 */
1489int ntfs_resident_attr_value_resize(MFT_RECORD *m, ATTR_RECORD *a,
1490		const u32 new_size)
1491{
1492	u32 old_size;
1493
1494	/* Resize the resident part of the attribute record. */
1495	if (ntfs_attr_record_resize(m, a,
1496			le16_to_cpu(a->data.resident.value_offset) + new_size))
1497		return -ENOSPC;
1498	/*
1499	 * The resize succeeded!  If we made the attribute value bigger, clear
1500	 * the area between the old size and @new_size.
1501	 */
1502	old_size = le32_to_cpu(a->data.resident.value_length);
1503	if (new_size > old_size)
1504		memset((u8*)a + le16_to_cpu(a->data.resident.value_offset) +
1505				old_size, 0, new_size - old_size);
1506	/* Finally update the length of the attribute value. */
1507	a->data.resident.value_length = cpu_to_le32(new_size);
1508	return 0;
1509}
1510
1511/**
1512 * ntfs_attr_make_non_resident - convert a resident to a non-resident attribute
1513 * @ni:		ntfs inode describing the attribute to convert
1514 * @data_size:	size of the resident data to copy to the non-resident attribute
1515 *
1516 * Convert the resident ntfs attribute described by the ntfs inode @ni to a
1517 * non-resident one.
1518 *
1519 * @data_size must be equal to the attribute value size.  This is needed since
1520 * we need to know the size before we can map the mft record and our callers
1521 * always know it.  The reason we cannot simply read the size from the vfs
1522 * inode i_size is that this is not necessarily uptodate.  This happens when
1523 * ntfs_attr_make_non_resident() is called in the ->truncate call path(s).
1524 *
1525 * Return 0 on success and -errno on error.  The following error return codes
1526 * are defined:
1527 *	-EPERM	- The attribute is not allowed to be non-resident.
1528 *	-ENOMEM	- Not enough memory.
1529 *	-ENOSPC	- Not enough disk space.
1530 *	-EINVAL	- Attribute not defined on the volume.
1531 *	-EIO	- I/o error or other error.
1532 * Note that -ENOSPC is also returned in the case that there is not enough
1533 * space in the mft record to do the conversion.  This can happen when the mft
1534 * record is already very full.  The caller is responsible for trying to make
1535 * space in the mft record and trying again.  FIXME: Do we need a separate
1536 * error return code for this kind of -ENOSPC or is it always worth trying
1537 * again in case the attribute may then fit in a resident state so no need to
1538 * make it non-resident at all?  Ho-hum...  (AIA)
1539 *
1540 * NOTE to self: No changes in the attribute list are required to move from
1541 *		 a resident to a non-resident attribute.
1542 *
1543 * Locking: - The caller must hold i_mutex on the inode.
1544 */
1545int ntfs_attr_make_non_resident(ntfs_inode *ni, const u32 data_size)
1546{
1547	s64 new_size;
1548	struct inode *vi = VFS_I(ni);
1549	ntfs_volume *vol = ni->vol;
1550	ntfs_inode *base_ni;
1551	MFT_RECORD *m;
1552	ATTR_RECORD *a;
1553	ntfs_attr_search_ctx *ctx;
1554	struct page *page;
1555	runlist_element *rl;
1556	u8 *kaddr;
1557	unsigned long flags;
1558	int mp_size, mp_ofs, name_ofs, arec_size, err, err2;
1559	u32 attr_size;
1560	u8 old_res_attr_flags;
1561
1562	/* Check that the attribute is allowed to be non-resident. */
1563	err = ntfs_attr_can_be_non_resident(vol, ni->type);
1564	if (unlikely(err)) {
1565		if (err == -EPERM)
1566			ntfs_debug("Attribute is not allowed to be "
1567					"non-resident.");
1568		else
1569			ntfs_debug("Attribute not defined on the NTFS "
1570					"volume!");
1571		return err;
1572	}
1573	/*
1574	 * FIXME: Compressed and encrypted attributes are not supported when
1575	 * writing and we should never have gotten here for them.
1576	 */
1577	BUG_ON(NInoCompressed(ni));
1578	BUG_ON(NInoEncrypted(ni));
1579	/*
1580	 * The size needs to be aligned to a cluster boundary for allocation
1581	 * purposes.
1582	 */
1583	new_size = (data_size + vol->cluster_size - 1) &
1584			~(vol->cluster_size - 1);
1585	if (new_size > 0) {
1586		/*
1587		 * Will need the page later and since the page lock nests
1588		 * outside all ntfs locks, we need to get the page now.
1589		 */
1590		page = find_or_create_page(vi->i_mapping, 0,
1591				mapping_gfp_mask(vi->i_mapping));
1592		if (unlikely(!page))
1593			return -ENOMEM;
1594		/* Start by allocating clusters to hold the attribute value. */
1595		rl = ntfs_cluster_alloc(vol, 0, new_size >>
1596				vol->cluster_size_bits, -1, DATA_ZONE, true);
1597		if (IS_ERR(rl)) {
1598			err = PTR_ERR(rl);
1599			ntfs_debug("Failed to allocate cluster%s, error code "
1600					"%i.", (new_size >>
1601					vol->cluster_size_bits) > 1 ? "s" : "",
1602					err);
1603			goto page_err_out;
1604		}
1605	} else {
1606		rl = NULL;
1607		page = NULL;
1608	}
1609	/* Determine the size of the mapping pairs array. */
1610	mp_size = ntfs_get_size_for_mapping_pairs(vol, rl, 0, -1);
1611	if (unlikely(mp_size < 0)) {
1612		err = mp_size;
1613		ntfs_debug("Failed to get size for mapping pairs array, error "
1614				"code %i.", err);
1615		goto rl_err_out;
1616	}
1617	down_write(&ni->runlist.lock);
1618	if (!NInoAttr(ni))
1619		base_ni = ni;
1620	else
1621		base_ni = ni->ext.base_ntfs_ino;
1622	m = map_mft_record(base_ni);
1623	if (IS_ERR(m)) {
1624		err = PTR_ERR(m);
1625		m = NULL;
1626		ctx = NULL;
1627		goto err_out;
1628	}
1629	ctx = ntfs_attr_get_search_ctx(base_ni, m);
1630	if (unlikely(!ctx)) {
1631		err = -ENOMEM;
1632		goto err_out;
1633	}
1634	err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
1635			CASE_SENSITIVE, 0, NULL, 0, ctx);
1636	if (unlikely(err)) {
1637		if (err == -ENOENT)
1638			err = -EIO;
1639		goto err_out;
1640	}
1641	m = ctx->mrec;
1642	a = ctx->attr;
1643	BUG_ON(NInoNonResident(ni));
1644	BUG_ON(a->non_resident);
1645	/*
1646	 * Calculate new offsets for the name and the mapping pairs array.
1647	 */
1648	if (NInoSparse(ni) || NInoCompressed(ni))
1649		name_ofs = (offsetof(ATTR_REC,
1650				data.non_resident.compressed_size) +
1651				sizeof(a->data.non_resident.compressed_size) +
1652				7) & ~7;
1653	else
1654		name_ofs = (offsetof(ATTR_REC,
1655				data.non_resident.compressed_size) + 7) & ~7;
1656	mp_ofs = (name_ofs + a->name_length * sizeof(ntfschar) + 7) & ~7;
1657	/*
1658	 * Determine the size of the resident part of the now non-resident
1659	 * attribute record.
1660	 */
1661	arec_size = (mp_ofs + mp_size + 7) & ~7;
1662	/*
1663	 * If the page is not uptodate bring it uptodate by copying from the
1664	 * attribute value.
1665	 */
1666	attr_size = le32_to_cpu(a->data.resident.value_length);
1667	BUG_ON(attr_size != data_size);
1668	if (page && !PageUptodate(page)) {
1669		kaddr = kmap_atomic(page);
1670		memcpy(kaddr, (u8*)a +
1671				le16_to_cpu(a->data.resident.value_offset),
1672				attr_size);
1673		memset(kaddr + attr_size, 0, PAGE_SIZE - attr_size);
1674		kunmap_atomic(kaddr);
1675		flush_dcache_page(page);
1676		SetPageUptodate(page);
1677	}
1678	/* Backup the attribute flag. */
1679	old_res_attr_flags = a->data.resident.flags;
1680	/* Resize the resident part of the attribute record. */
1681	err = ntfs_attr_record_resize(m, a, arec_size);
1682	if (unlikely(err))
1683		goto err_out;
1684	/*
1685	 * Convert the resident part of the attribute record to describe a
1686	 * non-resident attribute.
1687	 */
1688	a->non_resident = 1;
1689	/* Move the attribute name if it exists and update the offset. */
1690	if (a->name_length)
1691		memmove((u8*)a + name_ofs, (u8*)a + le16_to_cpu(a->name_offset),
1692				a->name_length * sizeof(ntfschar));
1693	a->name_offset = cpu_to_le16(name_ofs);
1694	/* Setup the fields specific to non-resident attributes. */
1695	a->data.non_resident.lowest_vcn = 0;
1696	a->data.non_resident.highest_vcn = cpu_to_sle64((new_size - 1) >>
1697			vol->cluster_size_bits);
1698	a->data.non_resident.mapping_pairs_offset = cpu_to_le16(mp_ofs);
1699	memset(&a->data.non_resident.reserved, 0,
1700			sizeof(a->data.non_resident.reserved));
1701	a->data.non_resident.allocated_size = cpu_to_sle64(new_size);
1702	a->data.non_resident.data_size =
1703			a->data.non_resident.initialized_size =
1704			cpu_to_sle64(attr_size);
1705	if (NInoSparse(ni) || NInoCompressed(ni)) {
1706		a->data.non_resident.compression_unit = 0;
1707		if (NInoCompressed(ni) || vol->major_ver < 3)
1708			a->data.non_resident.compression_unit = 4;
1709		a->data.non_resident.compressed_size =
1710				a->data.non_resident.allocated_size;
1711	} else
1712		a->data.non_resident.compression_unit = 0;
1713	/* Generate the mapping pairs array into the attribute record. */
1714	err = ntfs_mapping_pairs_build(vol, (u8*)a + mp_ofs,
1715			arec_size - mp_ofs, rl, 0, -1, NULL);
1716	if (unlikely(err)) {
1717		ntfs_debug("Failed to build mapping pairs, error code %i.",
1718				err);
1719		goto undo_err_out;
1720	}
1721	/* Setup the in-memory attribute structure to be non-resident. */
1722	ni->runlist.rl = rl;
1723	write_lock_irqsave(&ni->size_lock, flags);
1724	ni->allocated_size = new_size;
1725	if (NInoSparse(ni) || NInoCompressed(ni)) {
1726		ni->itype.compressed.size = ni->allocated_size;
1727		if (a->data.non_resident.compression_unit) {
1728			ni->itype.compressed.block_size = 1U << (a->data.
1729					non_resident.compression_unit +
1730					vol->cluster_size_bits);
1731			ni->itype.compressed.block_size_bits =
1732					ffs(ni->itype.compressed.block_size) -
1733					1;
1734			ni->itype.compressed.block_clusters = 1U <<
1735					a->data.non_resident.compression_unit;
1736		} else {
1737			ni->itype.compressed.block_size = 0;
1738			ni->itype.compressed.block_size_bits = 0;
1739			ni->itype.compressed.block_clusters = 0;
1740		}
1741		vi->i_blocks = ni->itype.compressed.size >> 9;
1742	} else
1743		vi->i_blocks = ni->allocated_size >> 9;
1744	write_unlock_irqrestore(&ni->size_lock, flags);
1745	/*
1746	 * This needs to be last since the address space operations ->read_folio
1747	 * and ->writepage can run concurrently with us as they are not
1748	 * serialized on i_mutex.  Note, we are not allowed to fail once we flip
1749	 * this switch, which is another reason to do this last.
1750	 */
1751	NInoSetNonResident(ni);
1752	/* Mark the mft record dirty, so it gets written back. */
1753	flush_dcache_mft_record_page(ctx->ntfs_ino);
1754	mark_mft_record_dirty(ctx->ntfs_ino);
1755	ntfs_attr_put_search_ctx(ctx);
1756	unmap_mft_record(base_ni);
1757	up_write(&ni->runlist.lock);
1758	if (page) {
1759		set_page_dirty(page);
1760		unlock_page(page);
1761		put_page(page);
1762	}
1763	ntfs_debug("Done.");
1764	return 0;
1765undo_err_out:
1766	/* Convert the attribute back into a resident attribute. */
1767	a->non_resident = 0;
1768	/* Move the attribute name if it exists and update the offset. */
1769	name_ofs = (offsetof(ATTR_RECORD, data.resident.reserved) +
1770			sizeof(a->data.resident.reserved) + 7) & ~7;
1771	if (a->name_length)
1772		memmove((u8*)a + name_ofs, (u8*)a + le16_to_cpu(a->name_offset),
1773				a->name_length * sizeof(ntfschar));
1774	mp_ofs = (name_ofs + a->name_length * sizeof(ntfschar) + 7) & ~7;
1775	a->name_offset = cpu_to_le16(name_ofs);
1776	arec_size = (mp_ofs + attr_size + 7) & ~7;
1777	/* Resize the resident part of the attribute record. */
1778	err2 = ntfs_attr_record_resize(m, a, arec_size);
1779	if (unlikely(err2)) {
1780		/*
1781		 * This cannot happen (well if memory corruption is at work it
1782		 * could happen in theory), but deal with it as well as we can.
1783		 * If the old size is too small, truncate the attribute,
1784		 * otherwise simply give it a larger allocated size.
1785		 * FIXME: Should check whether chkdsk complains when the
1786		 * allocated size is much bigger than the resident value size.
1787		 */
1788		arec_size = le32_to_cpu(a->length);
1789		if ((mp_ofs + attr_size) > arec_size) {
1790			err2 = attr_size;
1791			attr_size = arec_size - mp_ofs;
1792			ntfs_error(vol->sb, "Failed to undo partial resident "
1793					"to non-resident attribute "
1794					"conversion.  Truncating inode 0x%lx, "
1795					"attribute type 0x%x from %i bytes to "
1796					"%i bytes to maintain metadata "
1797					"consistency.  THIS MEANS YOU ARE "
1798					"LOSING %i BYTES DATA FROM THIS %s.",
1799					vi->i_ino,
1800					(unsigned)le32_to_cpu(ni->type),
1801					err2, attr_size, err2 - attr_size,
1802					((ni->type == AT_DATA) &&
1803					!ni->name_len) ? "FILE": "ATTRIBUTE");
1804			write_lock_irqsave(&ni->size_lock, flags);
1805			ni->initialized_size = attr_size;
1806			i_size_write(vi, attr_size);
1807			write_unlock_irqrestore(&ni->size_lock, flags);
1808		}
1809	}
1810	/* Setup the fields specific to resident attributes. */
1811	a->data.resident.value_length = cpu_to_le32(attr_size);
1812	a->data.resident.value_offset = cpu_to_le16(mp_ofs);
1813	a->data.resident.flags = old_res_attr_flags;
1814	memset(&a->data.resident.reserved, 0,
1815			sizeof(a->data.resident.reserved));
1816	/* Copy the data from the page back to the attribute value. */
1817	if (page) {
1818		kaddr = kmap_atomic(page);
1819		memcpy((u8*)a + mp_ofs, kaddr, attr_size);
1820		kunmap_atomic(kaddr);
1821	}
1822	/* Setup the allocated size in the ntfs inode in case it changed. */
1823	write_lock_irqsave(&ni->size_lock, flags);
1824	ni->allocated_size = arec_size - mp_ofs;
1825	write_unlock_irqrestore(&ni->size_lock, flags);
1826	/* Mark the mft record dirty, so it gets written back. */
1827	flush_dcache_mft_record_page(ctx->ntfs_ino);
1828	mark_mft_record_dirty(ctx->ntfs_ino);
1829err_out:
1830	if (ctx)
1831		ntfs_attr_put_search_ctx(ctx);
1832	if (m)
1833		unmap_mft_record(base_ni);
1834	ni->runlist.rl = NULL;
1835	up_write(&ni->runlist.lock);
1836rl_err_out:
1837	if (rl) {
1838		if (ntfs_cluster_free_from_rl(vol, rl) < 0) {
1839			ntfs_error(vol->sb, "Failed to release allocated "
1840					"cluster(s) in error code path.  Run "
1841					"chkdsk to recover the lost "
1842					"cluster(s).");
1843			NVolSetErrors(vol);
1844		}
1845		ntfs_free(rl);
1846page_err_out:
1847		unlock_page(page);
1848		put_page(page);
1849	}
1850	if (err == -EINVAL)
1851		err = -EIO;
1852	return err;
1853}
1854
1855/**
1856 * ntfs_attr_extend_allocation - extend the allocated space of an attribute
1857 * @ni:			ntfs inode of the attribute whose allocation to extend
1858 * @new_alloc_size:	new size in bytes to which to extend the allocation to
1859 * @new_data_size:	new size in bytes to which to extend the data to
1860 * @data_start:		beginning of region which is required to be non-sparse
1861 *
1862 * Extend the allocated space of an attribute described by the ntfs inode @ni
1863 * to @new_alloc_size bytes.  If @data_start is -1, the whole extension may be
1864 * implemented as a hole in the file (as long as both the volume and the ntfs
1865 * inode @ni have sparse support enabled).  If @data_start is >= 0, then the
1866 * region between the old allocated size and @data_start - 1 may be made sparse
1867 * but the regions between @data_start and @new_alloc_size must be backed by
1868 * actual clusters.
1869 *
1870 * If @new_data_size is -1, it is ignored.  If it is >= 0, then the data size
1871 * of the attribute is extended to @new_data_size.  Note that the i_size of the
1872 * vfs inode is not updated.  Only the data size in the base attribute record
1873 * is updated.  The caller has to update i_size separately if this is required.
1874 * WARNING: It is a BUG() for @new_data_size to be smaller than the old data
1875 * size as well as for @new_data_size to be greater than @new_alloc_size.
1876 *
1877 * For resident attributes this involves resizing the attribute record and if
1878 * necessary moving it and/or other attributes into extent mft records and/or
1879 * converting the attribute to a non-resident attribute which in turn involves
1880 * extending the allocation of a non-resident attribute as described below.
1881 *
1882 * For non-resident attributes this involves allocating clusters in the data
1883 * zone on the volume (except for regions that are being made sparse) and
1884 * extending the run list to describe the allocated clusters as well as
1885 * updating the mapping pairs array of the attribute.  This in turn involves
1886 * resizing the attribute record and if necessary moving it and/or other
1887 * attributes into extent mft records and/or splitting the attribute record
1888 * into multiple extent attribute records.
1889 *
1890 * Also, the attribute list attribute is updated if present and in some of the
1891 * above cases (the ones where extent mft records/attributes come into play),
1892 * an attribute list attribute is created if not already present.
1893 *
1894 * Return the new allocated size on success and -errno on error.  In the case
1895 * that an error is encountered but a partial extension at least up to
1896 * @data_start (if present) is possible, the allocation is partially extended
1897 * and this is returned.  This means the caller must check the returned size to
1898 * determine if the extension was partial.  If @data_start is -1 then partial
1899 * allocations are not performed.
1900 *
1901 * WARNING: Do not call ntfs_attr_extend_allocation() for $MFT/$DATA.
1902 *
1903 * Locking: This function takes the runlist lock of @ni for writing as well as
1904 * locking the mft record of the base ntfs inode.  These locks are maintained
1905 * throughout execution of the function.  These locks are required so that the
1906 * attribute can be resized safely and so that it can for example be converted
1907 * from resident to non-resident safely.
1908 *
1909 * TODO: At present attribute list attribute handling is not implemented.
1910 *
1911 * TODO: At present it is not safe to call this function for anything other
1912 * than the $DATA attribute(s) of an uncompressed and unencrypted file.
1913 */
1914s64 ntfs_attr_extend_allocation(ntfs_inode *ni, s64 new_alloc_size,
1915		const s64 new_data_size, const s64 data_start)
1916{
1917	VCN vcn;
1918	s64 ll, allocated_size, start = data_start;
1919	struct inode *vi = VFS_I(ni);
1920	ntfs_volume *vol = ni->vol;
1921	ntfs_inode *base_ni;
1922	MFT_RECORD *m;
1923	ATTR_RECORD *a;
1924	ntfs_attr_search_ctx *ctx;
1925	runlist_element *rl, *rl2;
1926	unsigned long flags;
1927	int err, mp_size;
1928	u32 attr_len = 0; /* Silence stupid gcc warning. */
1929	bool mp_rebuilt;
1930
1931#ifdef DEBUG
1932	read_lock_irqsave(&ni->size_lock, flags);
1933	allocated_size = ni->allocated_size;
1934	read_unlock_irqrestore(&ni->size_lock, flags);
1935	ntfs_debug("Entering for i_ino 0x%lx, attribute type 0x%x, "
1936			"old_allocated_size 0x%llx, "
1937			"new_allocated_size 0x%llx, new_data_size 0x%llx, "
1938			"data_start 0x%llx.", vi->i_ino,
1939			(unsigned)le32_to_cpu(ni->type),
1940			(unsigned long long)allocated_size,
1941			(unsigned long long)new_alloc_size,
1942			(unsigned long long)new_data_size,
1943			(unsigned long long)start);
1944#endif
1945retry_extend:
1946	/*
1947	 * For non-resident attributes, @start and @new_size need to be aligned
1948	 * to cluster boundaries for allocation purposes.
1949	 */
1950	if (NInoNonResident(ni)) {
1951		if (start > 0)
1952			start &= ~(s64)vol->cluster_size_mask;
1953		new_alloc_size = (new_alloc_size + vol->cluster_size - 1) &
1954				~(s64)vol->cluster_size_mask;
1955	}
1956	BUG_ON(new_data_size >= 0 && new_data_size > new_alloc_size);
1957	/* Check if new size is allowed in $AttrDef. */
1958	err = ntfs_attr_size_bounds_check(vol, ni->type, new_alloc_size);
1959	if (unlikely(err)) {
1960		/* Only emit errors when the write will fail completely. */
1961		read_lock_irqsave(&ni->size_lock, flags);
1962		allocated_size = ni->allocated_size;
1963		read_unlock_irqrestore(&ni->size_lock, flags);
1964		if (start < 0 || start >= allocated_size) {
1965			if (err == -ERANGE) {
1966				ntfs_error(vol->sb, "Cannot extend allocation "
1967						"of inode 0x%lx, attribute "
1968						"type 0x%x, because the new "
1969						"allocation would exceed the "
1970						"maximum allowed size for "
1971						"this attribute type.",
1972						vi->i_ino, (unsigned)
1973						le32_to_cpu(ni->type));
1974			} else {
1975				ntfs_error(vol->sb, "Cannot extend allocation "
1976						"of inode 0x%lx, attribute "
1977						"type 0x%x, because this "
1978						"attribute type is not "
1979						"defined on the NTFS volume.  "
1980						"Possible corruption!  You "
1981						"should run chkdsk!",
1982						vi->i_ino, (unsigned)
1983						le32_to_cpu(ni->type));
1984			}
1985		}
1986		/* Translate error code to be POSIX conformant for write(2). */
1987		if (err == -ERANGE)
1988			err = -EFBIG;
1989		else
1990			err = -EIO;
1991		return err;
1992	}
1993	if (!NInoAttr(ni))
1994		base_ni = ni;
1995	else
1996		base_ni = ni->ext.base_ntfs_ino;
1997	/*
1998	 * We will be modifying both the runlist (if non-resident) and the mft
1999	 * record so lock them both down.
2000	 */
2001	down_write(&ni->runlist.lock);
2002	m = map_mft_record(base_ni);
2003	if (IS_ERR(m)) {
2004		err = PTR_ERR(m);
2005		m = NULL;
2006		ctx = NULL;
2007		goto err_out;
2008	}
2009	ctx = ntfs_attr_get_search_ctx(base_ni, m);
2010	if (unlikely(!ctx)) {
2011		err = -ENOMEM;
2012		goto err_out;
2013	}
2014	read_lock_irqsave(&ni->size_lock, flags);
2015	allocated_size = ni->allocated_size;
2016	read_unlock_irqrestore(&ni->size_lock, flags);
2017	/*
2018	 * If non-resident, seek to the last extent.  If resident, there is
2019	 * only one extent, so seek to that.
2020	 */
2021	vcn = NInoNonResident(ni) ? allocated_size >> vol->cluster_size_bits :
2022			0;
2023	/*
2024	 * Abort if someone did the work whilst we waited for the locks.  If we
2025	 * just converted the attribute from resident to non-resident it is
2026	 * likely that exactly this has happened already.  We cannot quite
2027	 * abort if we need to update the data size.
2028	 */
2029	if (unlikely(new_alloc_size <= allocated_size)) {
2030		ntfs_debug("Allocated size already exceeds requested size.");
2031		new_alloc_size = allocated_size;
2032		if (new_data_size < 0)
2033			goto done;
2034		/*
2035		 * We want the first attribute extent so that we can update the
2036		 * data size.
2037		 */
2038		vcn = 0;
2039	}
2040	err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
2041			CASE_SENSITIVE, vcn, NULL, 0, ctx);
2042	if (unlikely(err)) {
2043		if (err == -ENOENT)
2044			err = -EIO;
2045		goto err_out;
2046	}
2047	m = ctx->mrec;
2048	a = ctx->attr;
2049	/* Use goto to reduce indentation. */
2050	if (a->non_resident)
2051		goto do_non_resident_extend;
2052	BUG_ON(NInoNonResident(ni));
2053	/* The total length of the attribute value. */
2054	attr_len = le32_to_cpu(a->data.resident.value_length);
2055	/*
2056	 * Extend the attribute record to be able to store the new attribute
2057	 * size.  ntfs_attr_record_resize() will not do anything if the size is
2058	 * not changing.
2059	 */
2060	if (new_alloc_size < vol->mft_record_size &&
2061			!ntfs_attr_record_resize(m, a,
2062			le16_to_cpu(a->data.resident.value_offset) +
2063			new_alloc_size)) {
2064		/* The resize succeeded! */
2065		write_lock_irqsave(&ni->size_lock, flags);
2066		ni->allocated_size = le32_to_cpu(a->length) -
2067				le16_to_cpu(a->data.resident.value_offset);
2068		write_unlock_irqrestore(&ni->size_lock, flags);
2069		if (new_data_size >= 0) {
2070			BUG_ON(new_data_size < attr_len);
2071			a->data.resident.value_length =
2072					cpu_to_le32((u32)new_data_size);
2073		}
2074		goto flush_done;
2075	}
2076	/*
2077	 * We have to drop all the locks so we can call
2078	 * ntfs_attr_make_non_resident().  This could be optimised by try-
2079	 * locking the first page cache page and only if that fails dropping
2080	 * the locks, locking the page, and redoing all the locking and
2081	 * lookups.  While this would be a huge optimisation, it is not worth
2082	 * it as this is definitely a slow code path.
2083	 */
2084	ntfs_attr_put_search_ctx(ctx);
2085	unmap_mft_record(base_ni);
2086	up_write(&ni->runlist.lock);
2087	/*
2088	 * Not enough space in the mft record, try to make the attribute
2089	 * non-resident and if successful restart the extension process.
2090	 */
2091	err = ntfs_attr_make_non_resident(ni, attr_len);
2092	if (likely(!err))
2093		goto retry_extend;
2094	/*
2095	 * Could not make non-resident.  If this is due to this not being
2096	 * permitted for this attribute type or there not being enough space,
2097	 * try to make other attributes non-resident.  Otherwise fail.
2098	 */
2099	if (unlikely(err != -EPERM && err != -ENOSPC)) {
2100		/* Only emit errors when the write will fail completely. */
2101		read_lock_irqsave(&ni->size_lock, flags);
2102		allocated_size = ni->allocated_size;
2103		read_unlock_irqrestore(&ni->size_lock, flags);
2104		if (start < 0 || start >= allocated_size)
2105			ntfs_error(vol->sb, "Cannot extend allocation of "
2106					"inode 0x%lx, attribute type 0x%x, "
2107					"because the conversion from resident "
2108					"to non-resident attribute failed "
2109					"with error code %i.", vi->i_ino,
2110					(unsigned)le32_to_cpu(ni->type), err);
2111		if (err != -ENOMEM)
2112			err = -EIO;
2113		goto conv_err_out;
2114	}
2115	/* TODO: Not implemented from here, abort. */
2116	read_lock_irqsave(&ni->size_lock, flags);
2117	allocated_size = ni->allocated_size;
2118	read_unlock_irqrestore(&ni->size_lock, flags);
2119	if (start < 0 || start >= allocated_size) {
2120		if (err == -ENOSPC)
2121			ntfs_error(vol->sb, "Not enough space in the mft "
2122					"record/on disk for the non-resident "
2123					"attribute value.  This case is not "
2124					"implemented yet.");
2125		else /* if (err == -EPERM) */
2126			ntfs_error(vol->sb, "This attribute type may not be "
2127					"non-resident.  This case is not "
2128					"implemented yet.");
2129	}
2130	err = -EOPNOTSUPP;
2131	goto conv_err_out;
2132#if 0
2133	// TODO: Attempt to make other attributes non-resident.
2134	if (!err)
2135		goto do_resident_extend;
2136	/*
2137	 * Both the attribute list attribute and the standard information
2138	 * attribute must remain in the base inode.  Thus, if this is one of
2139	 * these attributes, we have to try to move other attributes out into
2140	 * extent mft records instead.
2141	 */
2142	if (ni->type == AT_ATTRIBUTE_LIST ||
2143			ni->type == AT_STANDARD_INFORMATION) {
2144		// TODO: Attempt to move other attributes into extent mft
2145		// records.
2146		err = -EOPNOTSUPP;
2147		if (!err)
2148			goto do_resident_extend;
2149		goto err_out;
2150	}
2151	// TODO: Attempt to move this attribute to an extent mft record, but
2152	// only if it is not already the only attribute in an mft record in
2153	// which case there would be nothing to gain.
2154	err = -EOPNOTSUPP;
2155	if (!err)
2156		goto do_resident_extend;
2157	/* There is nothing we can do to make enough space. )-: */
2158	goto err_out;
2159#endif
2160do_non_resident_extend:
2161	BUG_ON(!NInoNonResident(ni));
2162	if (new_alloc_size == allocated_size) {
2163		BUG_ON(vcn);
2164		goto alloc_done;
2165	}
2166	/*
2167	 * If the data starts after the end of the old allocation, this is a
2168	 * $DATA attribute and sparse attributes are enabled on the volume and
2169	 * for this inode, then create a sparse region between the old
2170	 * allocated size and the start of the data.  Otherwise simply proceed
2171	 * with filling the whole space between the old allocated size and the
2172	 * new allocated size with clusters.
2173	 */
2174	if ((start >= 0 && start <= allocated_size) || ni->type != AT_DATA ||
2175			!NVolSparseEnabled(vol) || NInoSparseDisabled(ni))
2176		goto skip_sparse;
2177	// TODO: This is not implemented yet.  We just fill in with real
2178	// clusters for now...
2179	ntfs_debug("Inserting holes is not-implemented yet.  Falling back to "
2180			"allocating real clusters instead.");
2181skip_sparse:
2182	rl = ni->runlist.rl;
2183	if (likely(rl)) {
2184		/* Seek to the end of the runlist. */
2185		while (rl->length)
2186			rl++;
2187	}
2188	/* If this attribute extent is not mapped, map it now. */
2189	if (unlikely(!rl || rl->lcn == LCN_RL_NOT_MAPPED ||
2190			(rl->lcn == LCN_ENOENT && rl > ni->runlist.rl &&
2191			(rl-1)->lcn == LCN_RL_NOT_MAPPED))) {
2192		if (!rl && !allocated_size)
2193			goto first_alloc;
2194		rl = ntfs_mapping_pairs_decompress(vol, a, ni->runlist.rl);
2195		if (IS_ERR(rl)) {
2196			err = PTR_ERR(rl);
2197			if (start < 0 || start >= allocated_size)
2198				ntfs_error(vol->sb, "Cannot extend allocation "
2199						"of inode 0x%lx, attribute "
2200						"type 0x%x, because the "
2201						"mapping of a runlist "
2202						"fragment failed with error "
2203						"code %i.", vi->i_ino,
2204						(unsigned)le32_to_cpu(ni->type),
2205						err);
2206			if (err != -ENOMEM)
2207				err = -EIO;
2208			goto err_out;
2209		}
2210		ni->runlist.rl = rl;
2211		/* Seek to the end of the runlist. */
2212		while (rl->length)
2213			rl++;
2214	}
2215	/*
2216	 * We now know the runlist of the last extent is mapped and @rl is at
2217	 * the end of the runlist.  We want to begin allocating clusters
2218	 * starting at the last allocated cluster to reduce fragmentation.  If
2219	 * there are no valid LCNs in the attribute we let the cluster
2220	 * allocator choose the starting cluster.
2221	 */
2222	/* If the last LCN is a hole or simillar seek back to last real LCN. */
2223	while (rl->lcn < 0 && rl > ni->runlist.rl)
2224		rl--;
2225first_alloc:
2226	// FIXME: Need to implement partial allocations so at least part of the
2227	// write can be performed when start >= 0.  (Needed for POSIX write(2)
2228	// conformance.)
2229	rl2 = ntfs_cluster_alloc(vol, allocated_size >> vol->cluster_size_bits,
2230			(new_alloc_size - allocated_size) >>
2231			vol->cluster_size_bits, (rl && (rl->lcn >= 0)) ?
2232			rl->lcn + rl->length : -1, DATA_ZONE, true);
2233	if (IS_ERR(rl2)) {
2234		err = PTR_ERR(rl2);
2235		if (start < 0 || start >= allocated_size)
2236			ntfs_error(vol->sb, "Cannot extend allocation of "
2237					"inode 0x%lx, attribute type 0x%x, "
2238					"because the allocation of clusters "
2239					"failed with error code %i.", vi->i_ino,
2240					(unsigned)le32_to_cpu(ni->type), err);
2241		if (err != -ENOMEM && err != -ENOSPC)
2242			err = -EIO;
2243		goto err_out;
2244	}
2245	rl = ntfs_runlists_merge(ni->runlist.rl, rl2);
2246	if (IS_ERR(rl)) {
2247		err = PTR_ERR(rl);
2248		if (start < 0 || start >= allocated_size)
2249			ntfs_error(vol->sb, "Cannot extend allocation of "
2250					"inode 0x%lx, attribute type 0x%x, "
2251					"because the runlist merge failed "
2252					"with error code %i.", vi->i_ino,
2253					(unsigned)le32_to_cpu(ni->type), err);
2254		if (err != -ENOMEM)
2255			err = -EIO;
2256		if (ntfs_cluster_free_from_rl(vol, rl2)) {
2257			ntfs_error(vol->sb, "Failed to release allocated "
2258					"cluster(s) in error code path.  Run "
2259					"chkdsk to recover the lost "
2260					"cluster(s).");
2261			NVolSetErrors(vol);
2262		}
2263		ntfs_free(rl2);
2264		goto err_out;
2265	}
2266	ni->runlist.rl = rl;
2267	ntfs_debug("Allocated 0x%llx clusters.", (long long)(new_alloc_size -
2268			allocated_size) >> vol->cluster_size_bits);
2269	/* Find the runlist element with which the attribute extent starts. */
2270	ll = sle64_to_cpu(a->data.non_resident.lowest_vcn);
2271	rl2 = ntfs_rl_find_vcn_nolock(rl, ll);
2272	BUG_ON(!rl2);
2273	BUG_ON(!rl2->length);
2274	BUG_ON(rl2->lcn < LCN_HOLE);
2275	mp_rebuilt = false;
2276	/* Get the size for the new mapping pairs array for this extent. */
2277	mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, ll, -1);
2278	if (unlikely(mp_size <= 0)) {
2279		err = mp_size;
2280		if (start < 0 || start >= allocated_size)
2281			ntfs_error(vol->sb, "Cannot extend allocation of "
2282					"inode 0x%lx, attribute type 0x%x, "
2283					"because determining the size for the "
2284					"mapping pairs failed with error code "
2285					"%i.", vi->i_ino,
2286					(unsigned)le32_to_cpu(ni->type), err);
2287		err = -EIO;
2288		goto undo_alloc;
2289	}
2290	/* Extend the attribute record to fit the bigger mapping pairs array. */
2291	attr_len = le32_to_cpu(a->length);
2292	err = ntfs_attr_record_resize(m, a, mp_size +
2293			le16_to_cpu(a->data.non_resident.mapping_pairs_offset));
2294	if (unlikely(err)) {
2295		BUG_ON(err != -ENOSPC);
2296		// TODO: Deal with this by moving this extent to a new mft
2297		// record or by starting a new extent in a new mft record,
2298		// possibly by extending this extent partially and filling it
2299		// and creating a new extent for the remainder, or by making
2300		// other attributes non-resident and/or by moving other
2301		// attributes out of this mft record.
2302		if (start < 0 || start >= allocated_size)
2303			ntfs_error(vol->sb, "Not enough space in the mft "
2304					"record for the extended attribute "
2305					"record.  This case is not "
2306					"implemented yet.");
2307		err = -EOPNOTSUPP;
2308		goto undo_alloc;
2309	}
2310	mp_rebuilt = true;
2311	/* Generate the mapping pairs array directly into the attr record. */
2312	err = ntfs_mapping_pairs_build(vol, (u8*)a +
2313			le16_to_cpu(a->data.non_resident.mapping_pairs_offset),
2314			mp_size, rl2, ll, -1, NULL);
2315	if (unlikely(err)) {
2316		if (start < 0 || start >= allocated_size)
2317			ntfs_error(vol->sb, "Cannot extend allocation of "
2318					"inode 0x%lx, attribute type 0x%x, "
2319					"because building the mapping pairs "
2320					"failed with error code %i.", vi->i_ino,
2321					(unsigned)le32_to_cpu(ni->type), err);
2322		err = -EIO;
2323		goto undo_alloc;
2324	}
2325	/* Update the highest_vcn. */
2326	a->data.non_resident.highest_vcn = cpu_to_sle64((new_alloc_size >>
2327			vol->cluster_size_bits) - 1);
2328	/*
2329	 * We now have extended the allocated size of the attribute.  Reflect
2330	 * this in the ntfs_inode structure and the attribute record.
2331	 */
2332	if (a->data.non_resident.lowest_vcn) {
2333		/*
2334		 * We are not in the first attribute extent, switch to it, but
2335		 * first ensure the changes will make it to disk later.
2336		 */
2337		flush_dcache_mft_record_page(ctx->ntfs_ino);
2338		mark_mft_record_dirty(ctx->ntfs_ino);
2339		ntfs_attr_reinit_search_ctx(ctx);
2340		err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
2341				CASE_SENSITIVE, 0, NULL, 0, ctx);
2342		if (unlikely(err))
2343			goto restore_undo_alloc;
2344		/* @m is not used any more so no need to set it. */
2345		a = ctx->attr;
2346	}
2347	write_lock_irqsave(&ni->size_lock, flags);
2348	ni->allocated_size = new_alloc_size;
2349	a->data.non_resident.allocated_size = cpu_to_sle64(new_alloc_size);
2350	/*
2351	 * FIXME: This would fail if @ni is a directory, $MFT, or an index,
2352	 * since those can have sparse/compressed set.  For example can be
2353	 * set compressed even though it is not compressed itself and in that
2354	 * case the bit means that files are to be created compressed in the
2355	 * directory...  At present this is ok as this code is only called for
2356	 * regular files, and only for their $DATA attribute(s).
2357	 * FIXME: The calculation is wrong if we created a hole above.  For now
2358	 * it does not matter as we never create holes.
2359	 */
2360	if (NInoSparse(ni) || NInoCompressed(ni)) {
2361		ni->itype.compressed.size += new_alloc_size - allocated_size;
2362		a->data.non_resident.compressed_size =
2363				cpu_to_sle64(ni->itype.compressed.size);
2364		vi->i_blocks = ni->itype.compressed.size >> 9;
2365	} else
2366		vi->i_blocks = new_alloc_size >> 9;
2367	write_unlock_irqrestore(&ni->size_lock, flags);
2368alloc_done:
2369	if (new_data_size >= 0) {
2370		BUG_ON(new_data_size <
2371				sle64_to_cpu(a->data.non_resident.data_size));
2372		a->data.non_resident.data_size = cpu_to_sle64(new_data_size);
2373	}
2374flush_done:
2375	/* Ensure the changes make it to disk. */
2376	flush_dcache_mft_record_page(ctx->ntfs_ino);
2377	mark_mft_record_dirty(ctx->ntfs_ino);
2378done:
2379	ntfs_attr_put_search_ctx(ctx);
2380	unmap_mft_record(base_ni);
2381	up_write(&ni->runlist.lock);
2382	ntfs_debug("Done, new_allocated_size 0x%llx.",
2383			(unsigned long long)new_alloc_size);
2384	return new_alloc_size;
2385restore_undo_alloc:
2386	if (start < 0 || start >= allocated_size)
2387		ntfs_error(vol->sb, "Cannot complete extension of allocation "
2388				"of inode 0x%lx, attribute type 0x%x, because "
2389				"lookup of first attribute extent failed with "
2390				"error code %i.", vi->i_ino,
2391				(unsigned)le32_to_cpu(ni->type), err);
2392	if (err == -ENOENT)
2393		err = -EIO;
2394	ntfs_attr_reinit_search_ctx(ctx);
2395	if (ntfs_attr_lookup(ni->type, ni->name, ni->name_len, CASE_SENSITIVE,
2396			allocated_size >> vol->cluster_size_bits, NULL, 0,
2397			ctx)) {
2398		ntfs_error(vol->sb, "Failed to find last attribute extent of "
2399				"attribute in error code path.  Run chkdsk to "
2400				"recover.");
2401		write_lock_irqsave(&ni->size_lock, flags);
2402		ni->allocated_size = new_alloc_size;
2403		/*
2404		 * FIXME: This would fail if @ni is a directory...  See above.
2405		 * FIXME: The calculation is wrong if we created a hole above.
2406		 * For now it does not matter as we never create holes.
2407		 */
2408		if (NInoSparse(ni) || NInoCompressed(ni)) {
2409			ni->itype.compressed.size += new_alloc_size -
2410					allocated_size;
2411			vi->i_blocks = ni->itype.compressed.size >> 9;
2412		} else
2413			vi->i_blocks = new_alloc_size >> 9;
2414		write_unlock_irqrestore(&ni->size_lock, flags);
2415		ntfs_attr_put_search_ctx(ctx);
2416		unmap_mft_record(base_ni);
2417		up_write(&ni->runlist.lock);
2418		/*
2419		 * The only thing that is now wrong is the allocated size of the
2420		 * base attribute extent which chkdsk should be able to fix.
2421		 */
2422		NVolSetErrors(vol);
2423		return err;
2424	}
2425	ctx->attr->data.non_resident.highest_vcn = cpu_to_sle64(
2426			(allocated_size >> vol->cluster_size_bits) - 1);
2427undo_alloc:
2428	ll = allocated_size >> vol->cluster_size_bits;
2429	if (ntfs_cluster_free(ni, ll, -1, ctx) < 0) {
2430		ntfs_error(vol->sb, "Failed to release allocated cluster(s) "
2431				"in error code path.  Run chkdsk to recover "
2432				"the lost cluster(s).");
2433		NVolSetErrors(vol);
2434	}
2435	m = ctx->mrec;
2436	a = ctx->attr;
2437	/*
2438	 * If the runlist truncation fails and/or the search context is no
2439	 * longer valid, we cannot resize the attribute record or build the
2440	 * mapping pairs array thus we mark the inode bad so that no access to
2441	 * the freed clusters can happen.
2442	 */
2443	if (ntfs_rl_truncate_nolock(vol, &ni->runlist, ll) || IS_ERR(m)) {
2444		ntfs_error(vol->sb, "Failed to %s in error code path.  Run "
2445				"chkdsk to recover.", IS_ERR(m) ?
2446				"restore attribute search context" :
2447				"truncate attribute runlist");
2448		NVolSetErrors(vol);
2449	} else if (mp_rebuilt) {
2450		if (ntfs_attr_record_resize(m, a, attr_len)) {
2451			ntfs_error(vol->sb, "Failed to restore attribute "
2452					"record in error code path.  Run "
2453					"chkdsk to recover.");
2454			NVolSetErrors(vol);
2455		} else /* if (success) */ {
2456			if (ntfs_mapping_pairs_build(vol, (u8*)a + le16_to_cpu(
2457					a->data.non_resident.
2458					mapping_pairs_offset), attr_len -
2459					le16_to_cpu(a->data.non_resident.
2460					mapping_pairs_offset), rl2, ll, -1,
2461					NULL)) {
2462				ntfs_error(vol->sb, "Failed to restore "
2463						"mapping pairs array in error "
2464						"code path.  Run chkdsk to "
2465						"recover.");
2466				NVolSetErrors(vol);
2467			}
2468			flush_dcache_mft_record_page(ctx->ntfs_ino);
2469			mark_mft_record_dirty(ctx->ntfs_ino);
2470		}
2471	}
2472err_out:
2473	if (ctx)
2474		ntfs_attr_put_search_ctx(ctx);
2475	if (m)
2476		unmap_mft_record(base_ni);
2477	up_write(&ni->runlist.lock);
2478conv_err_out:
2479	ntfs_debug("Failed.  Returning error code %i.", err);
2480	return err;
2481}
2482
2483/**
2484 * ntfs_attr_set - fill (a part of) an attribute with a byte
2485 * @ni:		ntfs inode describing the attribute to fill
2486 * @ofs:	offset inside the attribute at which to start to fill
2487 * @cnt:	number of bytes to fill
2488 * @val:	the unsigned 8-bit value with which to fill the attribute
2489 *
2490 * Fill @cnt bytes of the attribute described by the ntfs inode @ni starting at
2491 * byte offset @ofs inside the attribute with the constant byte @val.
2492 *
2493 * This function is effectively like memset() applied to an ntfs attribute.
2494 * Note thie function actually only operates on the page cache pages belonging
2495 * to the ntfs attribute and it marks them dirty after doing the memset().
2496 * Thus it relies on the vm dirty page write code paths to cause the modified
2497 * pages to be written to the mft record/disk.
2498 *
2499 * Return 0 on success and -errno on error.  An error code of -ESPIPE means
2500 * that @ofs + @cnt were outside the end of the attribute and no write was
2501 * performed.
2502 */
2503int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val)
2504{
2505	ntfs_volume *vol = ni->vol;
2506	struct address_space *mapping;
2507	struct page *page;
2508	u8 *kaddr;
2509	pgoff_t idx, end;
2510	unsigned start_ofs, end_ofs, size;
2511
2512	ntfs_debug("Entering for ofs 0x%llx, cnt 0x%llx, val 0x%hx.",
2513			(long long)ofs, (long long)cnt, val);
2514	BUG_ON(ofs < 0);
2515	BUG_ON(cnt < 0);
2516	if (!cnt)
2517		goto done;
2518	/*
2519	 * FIXME: Compressed and encrypted attributes are not supported when
2520	 * writing and we should never have gotten here for them.
2521	 */
2522	BUG_ON(NInoCompressed(ni));
2523	BUG_ON(NInoEncrypted(ni));
2524	mapping = VFS_I(ni)->i_mapping;
2525	/* Work out the starting index and page offset. */
2526	idx = ofs >> PAGE_SHIFT;
2527	start_ofs = ofs & ~PAGE_MASK;
2528	/* Work out the ending index and page offset. */
2529	end = ofs + cnt;
2530	end_ofs = end & ~PAGE_MASK;
2531	/* If the end is outside the inode size return -ESPIPE. */
2532	if (unlikely(end > i_size_read(VFS_I(ni)))) {
2533		ntfs_error(vol->sb, "Request exceeds end of attribute.");
2534		return -ESPIPE;
2535	}
2536	end >>= PAGE_SHIFT;
2537	/* If there is a first partial page, need to do it the slow way. */
2538	if (start_ofs) {
2539		page = read_mapping_page(mapping, idx, NULL);
2540		if (IS_ERR(page)) {
2541			ntfs_error(vol->sb, "Failed to read first partial "
2542					"page (error, index 0x%lx).", idx);
2543			return PTR_ERR(page);
2544		}
2545		/*
2546		 * If the last page is the same as the first page, need to
2547		 * limit the write to the end offset.
2548		 */
2549		size = PAGE_SIZE;
2550		if (idx == end)
2551			size = end_ofs;
2552		kaddr = kmap_atomic(page);
2553		memset(kaddr + start_ofs, val, size - start_ofs);
2554		flush_dcache_page(page);
2555		kunmap_atomic(kaddr);
2556		set_page_dirty(page);
2557		put_page(page);
2558		balance_dirty_pages_ratelimited(mapping);
2559		cond_resched();
2560		if (idx == end)
2561			goto done;
2562		idx++;
2563	}
2564	/* Do the whole pages the fast way. */
2565	for (; idx < end; idx++) {
2566		/* Find or create the current page.  (The page is locked.) */
2567		page = grab_cache_page(mapping, idx);
2568		if (unlikely(!page)) {
2569			ntfs_error(vol->sb, "Insufficient memory to grab "
2570					"page (index 0x%lx).", idx);
2571			return -ENOMEM;
2572		}
2573		kaddr = kmap_atomic(page);
2574		memset(kaddr, val, PAGE_SIZE);
2575		flush_dcache_page(page);
2576		kunmap_atomic(kaddr);
2577		/*
2578		 * If the page has buffers, mark them uptodate since buffer
2579		 * state and not page state is definitive in 2.6 kernels.
2580		 */
2581		if (page_has_buffers(page)) {
2582			struct buffer_head *bh, *head;
2583
2584			bh = head = page_buffers(page);
2585			do {
2586				set_buffer_uptodate(bh);
2587			} while ((bh = bh->b_this_page) != head);
2588		}
2589		/* Now that buffers are uptodate, set the page uptodate, too. */
2590		SetPageUptodate(page);
2591		/*
2592		 * Set the page and all its buffers dirty and mark the inode
2593		 * dirty, too.  The VM will write the page later on.
2594		 */
2595		set_page_dirty(page);
2596		/* Finally unlock and release the page. */
2597		unlock_page(page);
2598		put_page(page);
2599		balance_dirty_pages_ratelimited(mapping);
2600		cond_resched();
2601	}
2602	/* If there is a last partial page, need to do it the slow way. */
2603	if (end_ofs) {
2604		page = read_mapping_page(mapping, idx, NULL);
2605		if (IS_ERR(page)) {
2606			ntfs_error(vol->sb, "Failed to read last partial page "
2607					"(error, index 0x%lx).", idx);
2608			return PTR_ERR(page);
2609		}
2610		kaddr = kmap_atomic(page);
2611		memset(kaddr, val, end_ofs);
2612		flush_dcache_page(page);
2613		kunmap_atomic(kaddr);
2614		set_page_dirty(page);
2615		put_page(page);
2616		balance_dirty_pages_ratelimited(mapping);
2617		cond_resched();
2618	}
2619done:
2620	ntfs_debug("Done.");
2621	return 0;
2622}
2623
2624#endif /* NTFS_RW */