ntfs-3g/libntfs/mft.c

/*
 * mft.c - Mft record handling code. Part of the Linux-NTFS project.
 *
 * Copyright (c) 2000-2004 Anton Altaparmakov
 *
 * This program/include file is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program/include file is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program (in the main directory of the Linux-NTFS
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include "compat.h"

#include "types.h"
#include "device.h"
#include "debug.h"
#include "bitmap.h"
#include "attrib.h"
#include "inode.h"
#include "volume.h"
#include "layout.h"
#include "lcnalloc.h"
#include "mft.h"

/**
 * ntfs_mft_records_read - read records from the mft from disk
 * @vol:	volume to read from
 * @mref:	starting mft record number to read
 * @count:	number of mft records to read
 * @b:		output data buffer
 *
 * Read @count mft records starting at @mref from volume @vol into buffer
 * @b. Return 0 on success or -1 on error, with errno set to the error
 * code.
 *
 * If any of the records exceed the initialized size of the $MFT/$DATA
 * attribute, i.e. they cannot possibly be allocated mft records, assume this
 * is a bug and return error code ESPIPE.
 *
 * The read mft records are mst deprotected and are hence ready to use. The
 * caller should check each record with is_baad_record() in case mst
 * deprotection failed.
 *
 * NOTE: @b has to be at least of size @count * vol->mft_record_size.
 */
int ntfs_mft_records_read(const ntfs_volume *vol, const MFT_REF mref,
		const s64 count, MFT_RECORD *b)
{
	s64 br;
	VCN m;

	Dprintf("%s(): Entering for inode 0x%llx.\n", __FUNCTION__, MREF(mref));
	if (!vol || !vol->mft_na || !b || count < 0) {
		errno = EINVAL;
		return -1;
	}
	m = MREF(mref);
	/* Refuse to read non-allocated mft records. */
	if (m + count > vol->mft_na->initialized_size >>
			vol->mft_record_size_bits) {
		errno = ESPIPE;
		return -1;
	}
	br = ntfs_attr_mst_pread(vol->mft_na, m << vol->mft_record_size_bits,
			count, vol->mft_record_size, b);
	if (br != count) {
		if (br != -1)
			errno = EIO;
		if (br >= 0)
			Dputs("Error: partition is smaller than it should be!");
		else
			Dperror("Error reading $Mft record(s)");
		return -1;
	}
	return 0;
}

/**
 * ntfs_mft_records_write - write mft records to disk
 * @vol:	volume to write to
 * @mref:	starting mft record number to write
 * @count:	number of mft records to write
 * @b:		data buffer containing the mft records to write
 *
 * Write @count mft records starting at @mref from data buffer @b to volume
 * @vol. Return 0 on success or -1 on error, with errno set to the error code.
 *
 * If any of the records exceed the initialized size of the $MFT/$DATA
 * attribute, i.e. they cannot possibly be allocated mft records, assume this
 * is a bug and return error code ESPIPE.
 *
 * Before the mft records are written, they are mst protected. After the write,
 * they are deprotected again, thus resulting in an increase in the update
 * sequence number inside the data buffer @b.
 *
 * If any mft records are written which are also represented in the mft mirror
 * $MFTMirr, we make a copy of the relevant parts of the data buffer @b into a
 * temporary buffer before we do the actual write. Then if at least one mft
 * record was successfully written, we write the appropriate mft records from
 * the copied buffer to the mft mirror, too.
 */
int ntfs_mft_records_write(const ntfs_volume *vol, const MFT_REF mref,
		const s64 count, MFT_RECORD *b)
{
	s64 bw;
	VCN m;
	void *bmirr = NULL;
	int cnt = 0, res = 0;

	Dprintf("%s(): Entering for inode 0x%llx.\n", __FUNCTION__, MREF(mref));
	if (!vol || !vol->mft_na || vol->mftmirr_size <= 0 || !b || count < 0) {
		errno = EINVAL;
		return -1;
	}
	m = MREF(mref);
	/* Refuse to write non-allocated mft records. */
	if (m + count > vol->mft_na->initialized_size >>
			vol->mft_record_size_bits) {
		errno = ESPIPE;
		return -1;
	}
	if (m < vol->mftmirr_size) {
		if (!vol->mftmirr_na) {
			errno = EINVAL;
			return -1;
		}
		cnt = vol->mftmirr_size - m;
		if (cnt > count)
			cnt = count;
		bmirr = malloc(cnt * vol->mft_record_size);
		if (!bmirr)
			return -1;
		memcpy(bmirr, b, cnt * vol->mft_record_size);
	}
	bw = ntfs_attr_mst_pwrite(vol->mft_na, m << vol->mft_record_size_bits,
			count, vol->mft_record_size, b);
	if (bw != count) {
		if (bw != -1)
			errno = EIO;
		if (bw >= 0)
			Dputs("Error: partial write while writing $Mft "
					"record(s)!\n");
		else
			Dperror("Error writing $Mft record(s)");
		res = errno;
	}
	if (bmirr && bw > 0) {
		if (bw < cnt)
			cnt = bw;
		bw = ntfs_attr_mst_pwrite(vol->mftmirr_na,
				m << vol->mft_record_size_bits, cnt,
				vol->mft_record_size, bmirr);
		if (bw != cnt) {
			if (bw != -1)
				errno = EIO;
			Dputs("Error: failed to sync $MFTMirr! Run chkdsk.");
			res = errno;
		}
	}
	if (bmirr)
		free(bmirr);
	if (!res)
		return res;
	errno = res;
	return -1;
}

/**
 * ntfs_file_record_read - read a FILE record from the mft from disk
 * @vol:	volume to read from
 * @mref:	mft reference specifying mft record to read
 * @mrec:	address of pointer in which to return the mft record
 * @attr:	address of pointer in which to return the first attribute
 *
 * Read a FILE record from the mft of @vol from the storage medium. @mref
 * specifies the mft record to read, including the sequence number, which can
 * be 0 if no sequence number checking is to be performed.
 *
 * The function allocates a buffer large enough to hold the mft record and
 * reads the record into the buffer (mst deprotecting it in the process).
 * *@mrec is then set to point to the buffer.
 *
 * If @attr is not NULL, *@attr is set to point to the first attribute in the
 * mft record, i.e. *@attr is a pointer into *@mrec.
 *
 * Return 0 on success, or -1 on error, with errno set to the error code.
 *
 * The read mft record is checked for having the magic FILE,
 * and for having a matching sequence number (if MSEQNO(*@mref) != 0).
 * If either of these fails, -1 is returned and errno is set to EIO. If you get
 * this, but you still want to read the mft record (e.g. in order to correct
 * it), use ntfs_mft_record_read() directly.
 *
 * Note: Caller has to free *@mrec when finished.
 *
 * Note: We do not check if the mft record is flagged in use. The caller can
 *	 check if desired.
 */
int ntfs_file_record_read(const ntfs_volume *vol, const MFT_REF mref,
		MFT_RECORD **mrec, ATTR_RECORD **attr)
{
	MFT_RECORD *m;
	ATTR_RECORD *a;
	int err;

	if (!vol || !mrec) {
		errno = EINVAL;
		return -1;
	}
	m = *mrec;
	if (!m) {
		m = (MFT_RECORD*)malloc(vol->mft_record_size);
		if (!m)
			return -1;
	}
	if (ntfs_mft_record_read(vol, mref, m)) {
		err = errno;
		goto read_failed;
	}
	if (!ntfs_is_file_record(m->magic))
		goto file_corrupt;
	if (MSEQNO(mref) && MSEQNO(mref) != le16_to_cpu(m->sequence_number))
		goto file_corrupt;
	a = (ATTR_RECORD*)((char*)m + le16_to_cpu(m->attrs_offset));
	if (p2n(a) < p2n(m) || (char*)a > (char*)m + vol->mft_record_size)
		goto file_corrupt;
	*mrec = m;
	if (attr)
		*attr = a;
	return 0;
file_corrupt:
	Dputs("ntfs_file_record_read(): file is corrupt.");
	err = EIO;
read_failed:
	if (m != *mrec)
		free(m);
	errno = err;
	return -1;
}

/**
 * ntfs_mft_record_layout - layout an mft record into a memory buffer
 * @vol:	volume to which the mft record will belong
 * @mref:	mft reference specifying the mft record number
 * @m:		destination buffer of size >= @vol->mft_record_size bytes
 *
 * Layout an empty, unused mft record with the mft reference @mref into the
 * buffer @m.  The volume @vol is needed because the mft record structure was
 * modified in NTFS 3.1 so we need to know which volume version this mft record
 * will be used on.
 *
 * On success return 0 and on error return -1 with errno set to the error code.
 */
int ntfs_mft_record_layout(const ntfs_volume *vol, const MFT_REF mref,
		MFT_RECORD *m)
{
	ATTR_RECORD *a;

	if (!vol || !m) {
		errno = EINVAL;
		return -1;
	}
	/* Aligned to 2-byte boundary. */
	if (vol->major_ver < 3 || (vol->major_ver == 3 && !vol->minor_ver))
		m->usa_ofs = cpu_to_le16((sizeof(MFT_RECORD_OLD) + 1) & ~1);
	else {
		/* Abort if mref is > 32 bits. */
		if (MREF(mref) & 0x0000ffff00000000ull) {
			Dputs("Mft reference exceeds 32 bits!");
			errno = ERANGE;
			return -1;
		}
		m->usa_ofs = cpu_to_le16((sizeof(MFT_RECORD) + 1) & ~1);
		/*
		 * Set the NTFS 3.1+ specific fields while we know that the
		 * volume version is 3.1+.
		 */
		m->reserved = cpu_to_le16(0);
		m->mft_record_number = cpu_to_le32(MREF(mref));
	}
	m->magic = magic_FILE;
	if (vol->mft_record_size >= NTFS_SECTOR_SIZE)
		m->usa_count = cpu_to_le16(vol->mft_record_size /
				NTFS_SECTOR_SIZE + 1);
	else {
		m->usa_count = cpu_to_le16(1);
		Dprintf("Sector size is bigger than MFT record size.  "
				"Setting usa_count to 1.  If Windows\nchkdsk "
				"reports this as corruption, please email "
				"linux-ntfs-dev@lists.sf.net\nstating that "
				"you saw this message and that the file "
				"system created was corrupt.\nThank you.\n");
	}
	/* Set the update sequence number to 1. */
	*(u16*)((u8*)m + le16_to_cpu(m->usa_ofs)) = cpu_to_le16(1);
	m->lsn = cpu_to_le64(0ull);
	m->sequence_number = cpu_to_le16(1);
	m->link_count = cpu_to_le16(0);
	/* Aligned to 8-byte boundary. */
	m->attrs_offset = cpu_to_le16((le16_to_cpu(m->usa_ofs) +
			(le16_to_cpu(m->usa_count) << 1) + 7) & ~7);
	m->flags = cpu_to_le16(0);
	/*
	 * Using attrs_offset plus eight bytes (for the termination attribute),
	 * aligned to 8-byte boundary.
	 */
	m->bytes_in_use = cpu_to_le32((le16_to_cpu(m->attrs_offset) + 8 + 7) &
			~7);
	m->bytes_allocated = cpu_to_le32(vol->mft_record_size);
	m->base_mft_record = cpu_to_le64((MFT_REF)0);
	m->next_attr_instance = cpu_to_le16(0);
	a = (ATTR_RECORD*)((u8*)m + le16_to_cpu(m->attrs_offset));
	a->type = AT_END;
	a->length = cpu_to_le32(0);
	/* Finally, clear the unused part of the mft record. */
	memset((u8*)a + 8, 0, vol->mft_record_size - ((u8*)a + 8 - (u8*)m));
	return 0;
}

/**
 * ntfs_mft_record_format - format an mft record on an ntfs volume
 * @vol:	volume on which to format the mft record
 * @mref:	mft reference specifying mft record to format
 *
 * Format the mft record with the mft reference @mref in $MFT/$DATA, i.e. lay
 * out an empty, unused mft record in memory and write it to the volume @vol.
 *
 * On success return 0 and on error return -1 with errno set to the error code.
 */
int ntfs_mft_record_format(const ntfs_volume *vol, const MFT_REF mref)
{
	MFT_RECORD *m;
	int err;

	if (!vol || !vol->mft_na) {
		errno = EINVAL;
		return -1;
	}
	m = malloc(vol->mft_record_size);
	if (!m)
		return -1;
	if (ntfs_mft_record_layout(vol, mref, m)) {
		err = errno;
		free(m);
		errno = err;
		return -1;
	}
	if (ntfs_mft_record_write(vol, mref, m)) {
		err = errno;
		free(m);
		errno = err;
		return -1;
	}
	free(m);
	return 0;
}

/**
 * ntfs_mft_bitmap_extend_and_allocate_one -
 *
 * Extend the mft bitmap attribute by one cluster.
 *
 * Note:  Only updates allocated_size, i.e. does not update initialized_size or
 * data_size.
 */
static int ntfs_mft_bitmap_extend_by_one_cluster(ntfs_volume *vol,
		u8 *have_allocated_mftbmp)
{
	LCN lcn;
	s64 ll;
	ntfs_attr *mftbmp_na, *lcnbmp_na;
	runlist_element *rl, *rl2;
	ntfs_attr_search_ctx *ctx;
	MFT_RECORD *m;
	ATTR_RECORD *a;
	int err, mp_size;
	u8 b;

	mftbmp_na = vol->mftbmp_na;
	lcnbmp_na = vol->lcnbmp_na;
	/*
	 * Determine the last lcn of the mft bitmap.  The allocated size of the
	 * mft bitmap cannot be zero so we are ok to do this.
	 */
	rl = ntfs_attr_find_vcn(mftbmp_na, (mftbmp_na->allocated_size - 1) >>
			vol->cluster_size);
	if (!rl || !rl->length || rl->lcn < 0) {
		ntfs_error(vol->sb, "Failed to determine last allocated "
				"cluster of mft bitmap attribute.");
		if (!rl->length || rl->lcn < 0)
			errno = EIO;
		return -1;
	}
	lcn = rl->lcn + rl->length;
	/*
	 * Attempt to get the cluster following the last allocated cluster by
	 * hand as it may be in the MFT zone so the allocator would not give it
	 * to us.
	 */
	ll = ntfs_attr_pread(lcnbmp_na, lcn >> 3, 1, &b);
	if (ll < 0) {
		ntfs_error(vol->sb, "Failed to read from lcn bitmap.");
		return -1;
	}
	ntfs_debug("Read %llu byte%s.", (long long)ll, ll == 1 ? "" : "s");
	*have_allocated_mftbmp = 0;
	if (ll == 1 && b != 0xff) {
		u8 tb = 1 << (lcn & 7ull);
		if (!(b & tb)) {
			/* Next cluster is free, allocate it. */
			b |= tb;
			ll = ntfs_attr_pwrite(lcnbmp_na, lcn >> 3, 1, &b);
			if (ll < 1) {
				ntfs_error(vol->sb, "Failed to write to lcn "
						"bitmap.");
				if (!ll)
					errno = EIO;
				return -1;
			}
			/* Update the mft bitmap runlist. */
			rl->length++;
			rl[1].vcn++;
			*have_allocated_mftbmp |= 1;
			ntfs_debug("Appending one cluster to mft bitmap.");
		}
	}
	if (!have_allocated_mftbmp) {
		/* Allocate a cluster from the DATA_ZONE. */
		rl2 = ntfs_cluster_alloc(vol, 1, lcn, DATA_ZONE, rl[1].vcn);
		if (!rl2) {
			ntfs_error(vol->sb, "Failed to allocate a cluster for "
					"the mft bitmap.");
			return -1;
		}
		rl = ntfs_runlists_merge(mftbmp_na->rl, rl2);
		if (!rl) {
			err = errno;
			ntfs_error(vol->sb, "Failed to merge runlists for mft "
					"bitmap.");
			if (ntfs_cluster_free_from_rl(vol, rl2))
				ntfs_error(vol->sb, "Failed to dealocate "
						"cluster.  Run chkdsk.");
			free(rl2);
			errno = err;
			return -1;
		}
		mftbmp_na->rl = rl;
		*have_allocated_mftbmp |= 2;
		ntfs_debug("Adding run to mft bitmap.");
		rl = ntfs_attr_find_vcn(mftbmp_na, mftbmp_na->allocated_size >>
				vol->cluster_size);
		if (!rl || !rl->length) {
			ntfs_error(vol->sb, "Failed to determine last "
					"allocated cluster of mft bitmap "
					"attribute.");
			if (!rl->length)
				errno = EIO;
			return -1;
		}
	}
	/* Update the attribute record as well. */
	ctx = ntfs_attr_get_search_ctx(mftbmp_na->ni, NULL);
	if (!ctx) {
		ntfs_error(vol->sb, "Failed to get search context.");
		return -1;
	}
	if (ntfs_attr_lookup(mftbmp_na->type, mftbmp_na->name,
			mftbmp_na->name_len, 0, rl[1].vcn, NULL, 0, ctx)) {
		ntfs_error(vol->sb, "Failed to find last attribute extent of "
				"mft bitmap attribute.");
		goto put_err_out;
	}
	m = ctx->mrec;
	a = ctx->attr;
	ll = sle64_to_cpu(a->lowest_vcn);
	rl2 = ntfs_attr_find_vcn(mftbmp_na, ll);
	if (!rl2 || !rl2->length) {
		ntfs_error(vol->sb, "Failed to determine previous last "
				"allocated cluster of mft bitmap attribute.");
		if (!rl2->length)
			errno = EIO;
		goto put_err_out;
	}
	/* Get the size for the new mapping pairs array for this extent. */
	mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, ll);
	if (mp_size <= 0) {
		ntfs_error(vol->sb, "Get size for mapping pairs failed for "
				"mft bitmap attribute extent.");
		goto put_err_out;
	}
	/* Expand the attribute record if necessary. */
	if (ntfs_attr_record_resize(m, a, mp_size +
			le16_to_cpu(a->mapping_pairs_offset))) {
		if (errno != ENOSPC) {
			ntfs_error(vol->sb, "Failed to resize "
					"attribute record for mft "
					"bitmap attribute.");
			goto put_err_out;
		}
		// TODO: Deal with this by moving this extent to a new mft
		// record or by starting a new extent in a new mft record.
		ntfs_error(vol->sb, "Not enough space in this mft record to "
				"accomodate extended mft bitmap attribute "
				"extent.  Cannot handle this yet.");
		errno = ENOTSUP;
		goto put_err_out;
	}
	/* Generate the mapping pairs array directly into the attr record. */
	if (ntfs_mapping_pairs_build(vol, (u8*)a +
			le16_to_cpu(a->mapping_pairs_offset), mp_size, rl2,
			ll, NULL)) {
		ntfs_error(vol->sb, "Failed to build mapping pairs.  Run "
				"chkdsk.");
		errno = EIO;
		goto put_err_out;
	}
	/* Update the highest_vcn. */
	a->highest_vcn = scpu_to_le64(rl[1].vcn - 1);
	/*
	 * We now have extended the mft bitmap allocated_size by one cluster.
	 * Reflect this in the ntfs_attr structure and the attribute record.
	 * @rl is the last (non-terminator) runlist element of mft bitmap.
	 */
	mftbmp_na->allocated_size += vol->cluster_size;
	if (a->lowest_vcn) {
		/*
		 * We are not in the first attribute extent, switch to it, but
		 * first ensure the changes will make it to disk later.
		 */
		ntfs_inode_mark_dirty(ctx->ntfs_ino);
		ntfs_attr_reinit_search_ctx(ctx);
		if (ntfs_attr_lookup(mftbmp_na->type, mftbmp_na->name,
				mftbmp_na->name_len, 0, 0, NULL, 0, ctx)) {
			ntfs_error(vol->sb, "Failed to find first attribute "
					"extent of mft bitmap attribute.");
			goto put_err_out;
		}
		a = ctx->attr;
	}
	a->allocated_size = scpu_to_le64(mftbmp_na->allocated_size);
	/* Ensure the changes make it to disk. */
	ntfs_inode_mark_dirty(ctx->ntfs_ino);
	ntfs_attr_put_search_ctx(ctx);
	return 0;
put_err_out:
	err = errno;
	ntfs_attr_put_search_ctx(ctx);
	errno = err;
	return -1;
}

static inline unsigned int ntfs_ffz(unsigned int word)
{
	return ffs(~word) - 1;
}

/**
 * ntfs_mft_record_alloc - allocate an mft record on an ntfs volume
 * @vol:	volume on which to allocate the mft record
 * @base_ni:	open base inode if allocating an extent mft record or NULL
 *
 * Allocate an mft record in $MFT/$DATA of an open ntfs volume @vol.
 *
 * If @base_ni is NULL make the mft record a base mft record and allocate it at
 * the default allocator position.
 *
 * If @base_ni is not NULL make the allocated mft record an extent record,
 * allocate it starting at the mft record after the base mft record and attach
 * the allocated and opened ntfs inode to the base inode @base_ni.
 *
 * On success return the now opened ntfs (extent) inode of the mft record.
 *
 * On error return NULL with errno set to the error code.
 *
 * To find a free mft record, we scan the mft bitmap for a zero bit.  To
 * optimize this we start scanning at the place specified by @base_ni or if
 * @base_ni is NULL we start where we last stopped and we perform wrap around
 * when we reach the end.  Note, we do not try to allocate mft records below
 * number 24 because numbers 0 to 15 are the defined system files anyway and 16
 * to 24 are special in that they are used for storing extension mft records
 * for the $DATA attribute of $MFT.  This is required to avoid the possibility
 * of creating a run list with a circular dependence which once written to disk
 * can never be read in again.  Windows will only use records 16 to 24 for
 * normal files if the volume is completely out of space.  We never use them
 * which means that when the volume is really out of space we cannot create any
 * more files while Windows can still create up to 8 small files.  We can start
 * doing this at some later time, it does not matter much for now.
 *
 * When scanning the mft bitmap, we only search up to the last allocated mft
 * record.  If there are no free records left in the range 24 to number of
 * allocated mft records, then we extend the $MFT/$DATA attribute in order to
 * create free mft records.  We extend the allocated size of $MFT/$DATA by 16
 * records at a time or one cluster, if cluster size is above 16kiB.  If there
 * is not sufficient space to do this, we try to extend by a single mft record
 * or one cluster, if cluster size is above the mft record size, but we only do
 * this if there is enough free space, which we know from the values returned
 * by the failed cluster allocation function when we tried to do the first
 * allocation.
 *
 * No matter how many mft records we allocate, we initialize only the first
 * allocated mft record, incrementing mft data size and initialized size
 * accordingly, open an ntfs_inode for it and return it to the caller, unless
 * there are less than 24 mft records, in which case we allocate and initialize
 * mft records until we reach record 24 which we consider as the first free mft
 * record for use by normal files.
 *
 * If during any stage we overflow the initialized data in the mft bitmap, we
 * extend the initialized size (and data size) by 8 bytes, allocating another
 * cluster if required.  The bitmap data size has to be at least equal to the
 * number of mft records in the mft, but it can be bigger, in which case the
 * superflous bits are padded with zeroes.
 *
 * Thus, when we return successfully (return value non-zero), we will have:
 *	- initialized / extended the mft bitmap if necessary,
 *	- initialized / extended the mft data if necessary,
 *	- set the bit corresponding to the mft record being allocated in the
 *	  mft bitmap,
 *	- open an ntfs_inode for the allocated mft record, and we will
 *	- return the ntfs_inode.
 *
 * On error (return value zero), nothing will have changed.  If we had changed
 * anything before the error occured, we will have reverted back to the
 * starting state before returning to the caller.  Thus, except for bugs, we
 * should always leave the volume in a consistent state when returning from
 * this function.
 *
 * Note, this function cannot make use of most of the normal functions, like
 * for example for attribute resizing, etc, because when the run list overflows
 * the base mft record and an attribute list is used, it is very important that
 * the extension mft records used to store the $DATA attribute of $MFT can be
 * reached without having to read the information contained inside them, as
 * this would make it impossible to find them in the first place after the
 * volume is dismounted.  $MFT/$BITMAP probably does not need to follow this
 * rule because the bitmap is not essential for finding the mft records, but on
 * the other hand, handling the bitmap in this special way would make life
 * easier because otherwise there might be circular invocations of functions
 * when reading the bitmap but if we are careful, we should be able to avoid
 * all problems.
 */
#ifndef PAGE_SIZE
#define PAGE_SIZE 4096
#endif
ntfs_inode *ntfs_mft_record_alloc(ntfs_volume *vol, ntfs_inode *base_ni)
{
	s64 nr_allocated_mft_records, pass_end, ll, ll2, buf_pos, pass_start;
	s64 last_read_pos, bit;
	LCN lcn;
	ntfs_attr *mft_na, *mftbmp_na, *lcnbmp_na;
	u8 *buf, *byte;
	runlist_element *rl, *rl2;
	ntfs_attr_search_ctx *ctx;
	MFT_RECORD *m;
	ATTR_RECORD *a;
	ntfs_inode *ni;
	unsigned long mft_rec_size;
	unsigned int size, buf_size;
	int err, mp_size;
	u16 seq_no;
	u8 pass, b, have_allocated_mftbmp = 0;

	if (base_ni)
		ntfs_debug("Entering (allocating an extent mft record for "
				"base mft record 0x%llx).",
				(long long)base_ni->mft_no);
	else
		ntfs_debug("Entering (allocating a base mft record).");
	if (!vol || !vol->mft_na || !vol->mftbmp_na) {
		errno = EINVAL;
		return NULL;
	}
	size = PAGE_SIZE;
	if (size < vol->mft_record_size)
		size = vol->mft_record_size;
	buf = (u8*)malloc(size);
	if (!buf)
		return NULL;
	mft_na = vol->mft_na;
	mftbmp_na = vol->mftbmp_na;
	lcnbmp_na = vol->lcnbmp_na;
	/* Determine the number of allocated mft records in the mft. */
	pass_end = nr_allocated_mft_records = mft_na->allocated_size >>
			vol->mft_record_size_bits;
	ntfs_debug("nr_allocated_mft_records 0x%llx.",
			(long long)nr_allocated_mft_records);
	/* Make sure we do not overflow the mft bitmap. */
	ll = mftbmp_na->initialized_size << 3;
	if (ll < nr_allocated_mft_records) {
		// FIXME: It might be better to extend the bitmap instead.
		pass_end = ll;
	}
	pass = 1;
	if (!base_ni)
		buf_pos = vol->mft_data_pos;
	else
		buf_pos = base_ni->mft_no + 1;
	if (buf_pos >= pass_end) {
		buf_pos = 24;
		pass = 2;
	}
	pass_start = buf_pos;
	ntfs_debug("Starting bitmap search: pass %u, pass_start 0x%llx, "
			"pass_end = 0x%llx.", pass, (long long)pass_start,
			(long long)pass_end);
#ifdef DEBUG
	byte = NULL;
	b = 0;
#endif
	/* Loop until a free mft record is found. */
	size = PAGE_SIZE;
	if (size > (ll = nr_allocated_mft_records >> 3))
		size = ll;
	for (;; size = PAGE_SIZE) {
		last_read_pos = buf_pos >> 3;
		ntfs_debug("Before read: mftbmp: allocated_size 0x%llx, "
				"data_size 0x%llx, initialized_size 0x%llx.",
				(long long)mftbmp_na->allocated_size,
				(long long)mftbmp_na->data_size,
				(long long)mftbmp_na->initialized_size);
		ll = ntfs_attr_pread(mftbmp_na, last_read_pos, size, buf);
		if (ll < 0) {
			ntfs_error(vol->sb, "Failed to read mft bitmap "
					"attribute.");
			goto err_out;
		}
		ntfs_debug("Read 0x%llx bytes.", (long long)ll);
		ntfs_debug("After read: mftbmp: allocated_size 0x%llx, "
				"data_size = 0x%llx, initialized_size 0x%llx.",
				(long long)mftbmp_na->allocated_size,
				(long long)mftbmp_na->data_size,
				(long long)mftbmp_na->initialized_size);
		if (!ll)
			goto pass_done;
		buf_size = ll << 3;
		bit = buf_pos & 7;
		buf_pos &= ~7ull;
		ntfs_debug("Before for loop: buf_size 0x%x, buf_pos 0x%llx, "
				"bit 0x%llx, *byte 0x%x, b %u.", buf_size,
				(long long)buf_pos, (long long)bit,
				byte ? *byte : -1, b);
		for (; bit < buf_size && buf_pos + bit < pass_end;
				bit &= ~7ull, bit += 8) {
			byte = buf + (bit >> 3);
			if (*byte == 0xff)
				continue;
			/* Note: ffz() result must be zero based. */
			b = ntfs_ffz((unsigned long)*byte);
			if (b < 8 && b >= (bit & 7)) {
				bit = buf_pos + (bit & ~7ull) + b;
				ntfs_debug("Found free rec in for loop, "
						"bit 0x%llx.", (long long)bit);
				goto found_free_rec;
			}
		}
		ntfs_debug("After for loop: buf_size 0x%x, buf_pos 0x%llx, "
				"bit 0x%llx, *byte 0x%x, b %u.", buf_size,
				(long long)buf_pos, (long long)bit,
				byte ? *byte : -1, b);
		buf_pos += buf_size;
		if (buf_pos < pass_end)
			continue;
pass_done:
		/* Finished with the current pass. */
		ntfs_debug("At pass_done.");
		if (pass == 1) {
			/*
			 * Now do pass 2, scanning the first part of the zone
			 * we omitted in pass 1.
			 */
			ntfs_debug("Done pass 1, switching to pass 2.");
			pass = 2;
			pass_end = pass_start;
			buf_pos = pass_start = 24;
			ntfs_debug("pass %i, pass_start 0x%llx, "
					"pass_end 0x%llx.", pass,
					(long long)pass_start,
					(long long)pass_end);
			continue;
		} /* pass == 2 */
		/* No free records left. */
		if (mftbmp_na->initialized_size << 3 >
				nr_allocated_mft_records &&
				mftbmp_na->initialized_size > 3) {
			/*
			 * The mft bitmap is already bigger but the space is
			 * not covered by mft records, this implies that the
			 * next records are all free, so we already have found
			 * a free record.
			 */
			bit = nr_allocated_mft_records;
			if (bit < 24)
				bit = 24;
			ntfs_debug("Found free record bit (#1) 0x%llx.",
					(long long)bit);
			goto found_free_rec;
		}
		ntfs_debug("Done pass 2.");
		ntfs_debug("Status of mftbmp: allocated_size 0x%llx, "
				"data_size 0x%llx, initialized_size 0x%llx.",
				(long long)mftbmp_na->allocated_size,
				(long long)mftbmp_na->data_size,
				(long long)mftbmp_na->initialized_size);
		if (mftbmp_na->initialized_size + 8 >
				mftbmp_na->allocated_size) {
			/* Need to extend bitmap by one more cluster. */
			ntfs_debug("mftbmp: initialized_size + 8 > "
					"allocated_size.");
			if (ntfs_mft_bitmap_extend_by_one_cluster(vol,
					&have_allocated_mftbmp))
				goto err_out;
			ntfs_debug("New status of mftbmp: allocated_size "
					"0x%llx, data_size 0x%llx, "
					"initialized_size 0x%llx.",
					(long long)mftbmp_na->allocated_size,
					(long long)mftbmp_na->data_size,
					(long long)mftbmp_na->initialized_size);
		}
		/*
		 * We now have sufficient allocated space, extend the
		 * initialized_size as well as the data_size if necessary.
		 */
		ctx = ntfs_attr_get_search_ctx(mftbmp_na->ni, NULL);
		if (!ctx) {
			ntfs_error(vol->sb, "Failed to get search context.");
			goto err_out;
		}
		if (ntfs_attr_lookup(mftbmp_na->type, mftbmp_na->name,
				mftbmp_na->name_len, 0, 0, NULL, 0, ctx)) {
			ntfs_error(vol->sb, "Failed to find first attribute "
					"extent of mft bitmap attribute.");
			goto put_err_out;
		}
		a = ctx->attr;
		buf_pos = mftbmp_na->initialized_size;
		mftbmp_na->initialized_size += 8;
		a->initialized_size = scpu_to_le64(mftbmp_na->initialized_size);
		if (mftbmp_na->initialized_size > mftbmp_na->data_size) {
			mftbmp_na->data_size = mftbmp_na->initialized_size;
			a->data_size = scpu_to_le64(mftbmp_na->data_size);
		}
		/* Ensure the changes make it to disk. */
		ntfs_inode_mark_dirty(ctx->ntfs_ino);
		ntfs_attr_put_search_ctx(ctx);
		ntfs_debug("New status of mftbmp: allocated_size 0x%llx, "
				"data_size 0x%llx, initialized_size 0x%llx.",
				(long long)mftbmp_na->allocated_size,
				(long long)mftbmp_na->data_size,
				(long long)mftbmp_na->initialized_size);
		have_allocated_mftbmp |= 4;
		/* Initialize the mft bitmap attribute value with zeroes. */
		memset(buf, 0, 8);
		ll = ntfs_attr_pwrite(mftbmp_na, buf_pos, 8, buf);
		if (ll < 8) {
			ntfs_error(vol->sb, "Failed to write to mft bitmap.");
			if (ll >= 0)
				errno = EIO;
			goto shrink_mftbmp_err_out;
		}
		ntfs_debug("Wrote eight initialized bytes to mft bitmap.");
		bit = buf_pos << 3;
		ntfs_debug("Found free record bit (#2) 0x%llx.",
				(long long)bit);
		/* goto found_free_rec; */
		break;
	}
found_free_rec:
	/* @bit is the found free mft record, allocate it in the mft bitmap. */
	vol->mft_data_pos = bit;
	ntfs_debug("At found_free_rec.");
	ll = ntfs_attr_pread(mftbmp_na, bit >> 3, 1, buf);
	if (ll < 1) {
		ntfs_error(vol->sb, "Failed to read from mft bitmap.");
		if (!ll)
			errno = EIO;
		goto shrink_mftbmp_err_out;
	}
	ntfs_debug("Read 1 byte from mft bitmap.");
	/* Check our bit is really zero and set it. */
	b = 1 << (bit & 7);
	//BUG_ON(*buf & b);
	if (*buf & b)
		NTFS_BUG("Bit in mft bitmap is not zero!");
	*buf |= b;
	ll = ntfs_attr_pwrite(mftbmp_na, bit >> 3, 1, buf);
	if (ll < 1) {
		if (!ll)
			errno = EIO;
		goto shrink_mftbmp_err_out;
	}
	ntfs_debug("Wrote 1 byte to mft bitmap.");
	/* The mft bitmap is now uptodate.  Deal with mft data attribute now. */
	ll = (bit + 1) << vol->mft_record_size_bits;
	if (ll <= mft_na->initialized_size) {
		/* The allocated record is already initialized.  We are done! */
		ntfs_debug("Allocated mft record already initialized!");
		goto mft_rec_already_initialized;
	}
	ntfs_debug("Allocated mft record needs to be initialized.");
	/* The mft record is outside the initialized data. */
	mft_rec_size = vol->mft_record_size;
	/* Preserve old values for undo purposes. */
//FIXME:
//	s64 old_data_allocated;
//	LCN old_data_len;
//	int old_data_rlen;
//	old_data_allocated = mft_na->allocated_size;
//	old_data_rlen = mft_na->d.r.len - 1;
//	old_data_len = mft_na->d.r.runlist[old_data_rlen].len;
	/*
	 * If necessary, extend the mft until it covers the allocated record.
	 * The loop is only actually used when a freshly formatted volume is
	 * first written to so it optimizes away nicely in the common case.
	 */
	while (ll > mft_na->allocated_size) {
		s64 nr, min_nr;

		ntfs_debug("Extending mft data allocation, status of mft "
				"data: allocated_size 0x%llx, "
				"data_size 0x%llx, initialized_size 0x%llx.",
				(long long)mft_na->allocated_size,
				(long long)mft_na->data_size,
				(long long)mft_na->initialized_size);
		/*
		 * Determine the preferred allocation location, i.e. the last
		 * lcn of the mft data attribute.  The allocated size of the
		 * mft data attribute cannot be zero so we are ok to do this.
		 */
		rl = ntfs_attr_find_vcn(mft_na, (mft_na->allocated_size - 1) >>
				vol->cluster_size);
		if (!rl || !rl->length || rl->lcn < 0) {
			ntfs_error(vol->sb, "Failed to determine last "
					"allocated cluster of mft data "
					"attribute.");
			if (!rl->length || rl->lcn < 0)
				errno = EIO;
			goto undo_mftbmp_alloc_err_out;
		}
		lcn = rl->lcn + rl->length;
		ntfs_debug("Last lcn of mft data attribute is 0x%llx.",
				(long long)lcn);
		/* Minimum allocation is one mft record worth of clusters. */
		if (mft_rec_size <= vol->cluster_size)
			min_nr = 1;
		else
			min_nr = mft_rec_size >> vol->cluster_size_bits;
		/* Want to allocate 16 mft records worth of clusters. */
		nr = mft_rec_size << 4 >> vol->cluster_size_bits;
		if (!nr)
			nr = 1;
		ntfs_debug("Trying mft data allocation with default "
					"cluster count %lli.", (long long)nr);
retry_mft_data_allocation:
		rl2 = ntfs_cluster_alloc(vol, nr, lcn, MFT_ZONE, rl[1].vcn);
		if (!rl2) {
			/*
			 * There is not enough space to do the allocation, but
			 * there might be enough space to do a minimal
			 * allocation so try that before failing.
			 */
			if (errno == ENOSPC && nr > min_nr) {
				nr = min_nr;
				ntfs_debug("Retrying mft data allocation with "
						"minimal cluster count %lli.",
						(long long)nr);
				goto retry_mft_data_allocation;
			}
			ntfs_error(vol->sb, "Failed to allocate a cluster for "
					"the mft data attribute.");
			goto undo_mftbmp_alloc_err_out;
		}
		rl = ntfs_runlists_merge(mft_na->rl, rl2);
		if (!rl) {
			err = errno;
			ntfs_error(vol->sb, "Failed to merge runlists for mft "
					"data attribute.");
			if (ntfs_cluster_free_from_rl(vol, rl2))
				ntfs_error(vol->sb, "Failed to dealocate "
						"clusters.  Run chkdsk.");
			free(rl2);
			errno = err;
			goto undo_mftbmp_alloc_err_out;
		}
		mft_na->rl = rl;
		ntfs_debug("Allocated %lli clusters starting.", nr);
		/* Determine the last lcn of the mft data attribute. */
		rl = ntfs_attr_find_vcn(mft_na, (mft_na->allocated_size - 1) >>
				vol->cluster_size);
		if (!rl || !rl->length || rl->lcn < 0) {
			ntfs_error(vol->sb, "Failed to determine last "
					"allocated cluster of mft data "
					"attribute.");
			if (!rl->length || rl->lcn < 0)
				errno = EIO;
			// FIXME: Truncate mft_na->rl back to the old state and
			// release the clusters.
			goto undo_mftbmp_alloc_err_out;
		}
		lcn = rl->lcn + rl->length;
		/* Update the attribute record as well. */
		ctx = ntfs_attr_get_search_ctx(mft_na->ni, NULL);
		if (!ctx) {
			ntfs_error(vol->sb, "Failed to get search context.");
			goto trunc_mft_rl_shrink_mftbmp_alloc_err_out;
		}
		if (ntfs_attr_lookup(mft_na->type, mft_na->name,
				mft_na->name_len, 0, rl[1].vcn, NULL, 0, ctx)) {
			ntfs_error(vol->sb, "Failed to find last attribute "
					"extent of mft data attribute.");
			goto put_err_out;
		}
		m = ctx->mrec;
		a = ctx->attr;
		ll2 = sle64_to_cpu(a->lowest_vcn);
		rl2 = ntfs_attr_find_vcn(mft_na, ll2);
		if (!rl2 || !rl2->length) {
			ntfs_error(vol->sb, "Failed to determine previous "
					"last allocated cluster of mft data "
					"attribute.");
			if (!rl2->length)
				errno = EIO;
			goto put_err_out;
		}
		/*
		 * Get the size for the new mapping pairs array for this
		 * extent.
		 */
		mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, ll2);
		if (mp_size <= 0) {
			ntfs_error(vol->sb, "Get size for mapping pairs "
					"failed for mft bitmap attribute "
					"extent.");
			goto put_err_out;
		}
		/* Expand the attribute record if necessary. */
		if (ntfs_attr_record_resize(m, a, mp_size +
				le16_to_cpu(a->mapping_pairs_offset))) {
			if (errno != ENOSPC) {
				ntfs_error(vol->sb, "Failed to resize "
						"attribute record for mft "
						"data attribute.");
				goto put_err_out;
			}
			// TODO: Deal with this by moving this extent to a new
			// mft record or by starting a new extent in a new mft
			// record.  Note: Use the special reserved mft records
			// and ensure that this extent is not required to find
			// the mft record in question.
			ntfs_error(vol->sb, "Not enough space in this mft "
					"record to accomodate extended mft "
					"data attribute extent.  Cannot "
					"handle this yet.");
			errno = ENOTSUP;
			goto put_err_out;
		}
		/*
		 * Generate the mapping pairs array directly into the attribute
		 * record.
		 */
		if (ntfs_mapping_pairs_build(vol, (u8*)a +
				le16_to_cpu(a->mapping_pairs_offset), mp_size,
				rl2, ll2, NULL)) {
			ntfs_error(vol->sb, "Failed to build mapping pairs.  "
					"Run chkdsk.");
			errno = EIO;
			goto put_err_out;
		}
		/* Update the highest_vcn. */
		a->highest_vcn = scpu_to_le64(rl[1].vcn - 1);
		/*
		 * We now have extended the mft data allocated_size by nr
		 * clusters.  Reflect this in the ntfs_attr structure and the
		 * attribute record.  @rl is the last (non-terminator) runlist
		 * element of mft data attribute.
		 */
		mft_na->allocated_size += nr << vol->cluster_size_bits;
		if (a->lowest_vcn) {
			/*
			 * We are not in the first attribute extent, switch to
			 * it, but first ensure the changes will make it to
			 * disk later.
			 */
			ntfs_inode_mark_dirty(ctx->ntfs_ino);
			ntfs_attr_reinit_search_ctx(ctx);
			if (ntfs_attr_lookup(mft_na->type, mft_na->name,
					mft_na->name_len, 0, 0, NULL, 0, ctx)) {
				ntfs_error(vol->sb, "Failed to find first "
						"attribute extent of mft data "
						"attribute.");
				goto put_err_out;
			}
			a = ctx->attr;
		}
		a->allocated_size = scpu_to_le64(mft_na->allocated_size);
		/* Ensure the changes make it to disk. */
		ntfs_inode_mark_dirty(ctx->ntfs_ino);
		ntfs_attr_put_search_ctx(ctx);
		ntfs_debug("After extending mft data allocation, status of "
				"mft data: allocated_size 0x%llx, "
				"data_size 0x%llx, initialized_size 0x%llx.",
				(long long)mft_na->allocated_size,
				(long long)mft_na->data_size,
				(long long)mft_na->initialized_size);
	}
//	s64 old_data_initialized, old_data_size;
//	old_data_initialized = mft_na->initialized_size;
//	old_data_size = mft_na->data_size;
	/*
	 * Extend mft data initialized size (and data size of course) to reach
	 * the allocated mft record formatting the mft records allong the way.
	 */
	while (ll > mft_na->initialized_size) {
		ll2 = mft_na->initialized_size >> vol->mft_record_size_bits;
		mft_na->initialized_size += vol->mft_record_size;
		if (mft_na->initialized_size > mft_na->data_size)
			mft_na->data_size = mft_na->initialized_size;
		ntfs_debug("Initializing mft record 0x%llx.", ll2);
		err = ntfs_mft_record_format(vol, ll2);
		if (err) {
			ntfs_error(vol->sb, "Failed to format mft record.");
			goto undo_data_init_err_out;
		}
	}
	/* Update the mft data attribute record to reflect the new sizes. */
	ctx = ntfs_attr_get_search_ctx(mft_na->ni, NULL);
	if (!ctx) {
		ntfs_error(vol->sb, "Failed to get search context.");
		goto undo_data_init_err_out;
	}
	if (ntfs_attr_lookup(mft_na->type, mft_na->name, mft_na->name_len, 0,
			0, NULL, 0, ctx)) {
		ntfs_error(vol->sb, "Failed to find first attribute extent of "
				"mft data attribute.");
		goto put_undo_data_init_err_out;
	}
	a = ctx->attr;
	a->initialized_size = scpu_to_le64(mft_na->initialized_size);
	a->data_size = scpu_to_le64(mft_na->data_size);
	/* Ensure the changes make it to disk. */
	ntfs_inode_mark_dirty(ctx->ntfs_ino);
	ntfs_attr_put_search_ctx(ctx);
	ntfs_debug("After mft record initialization, status of mft data: "
			"allocated_size 0x%llx, data_size 0x%llx, "
			"initialized_size 0x%llx.",
			(long long)mft_na->allocated_size,
			(long long)mft_na->data_size,
			(long long)mft_na->initialized_size);
	/* Sanity checks. */
	if (mft_na->data_size > mft_na->allocated_size ||
			mft_na->initialized_size > mft_na->data_size)
		NTFS_BUG("mft_na sanity checks failed");
	// BUG_ON(mft_na->initialized_size > mft_na->data_size);
	// BUG_ON(mft_na->data_size > mft_na->allocated_size);
mft_rec_already_initialized:
	/*
	 * We now have allocated and initialized the mft record.  Need to read
	 * it from disk and re-format it.
	 */
	m = (MFT_RECORD*)malloc(vol->mft_record_size);
	if (!m) {
		ntfs_error(vol->sb, "Failed to allocate buffer for mft "
				"record.");
		goto undo_mrec_alloc_init_err_out;
	}
	if (ntfs_mft_record_read(vol, bit, m)) {
		ntfs_error(vol->sb, "Failed to read mft record.");
		goto undo_mrec_alloc_init_err_out;
	}
	/* Preserve the sequence number if it is not zero. */
	seq_no = m->sequence_number;
	if (ntfs_mft_record_layout(vol, bit, m)) {
		ntfs_error(vol->sb, "Failed to re-format mft record.");
		goto undo_mrec_alloc_init_err_out;
	}
	if (le16_to_cpu(seq_no))
		m->sequence_number = seq_no;
	/* Set the mft record itself in use. */
	m->flags |= MFT_RECORD_IN_USE;
	/* Now need to open an ntfs inode for the mft record. */
	ni = ntfs_inode_allocate(vol);
	if (!ni) {
		ntfs_error(vol->sb, "Failed to allocate buffer for inode.");
		goto undo_mrec_alloc_init_err_out;
	}
	ni->mft_no = bit;
	ni->mrec = m;
	/*
	 * If we are allocating an extent mft record, make the opened inode an
	 * extent inode and attach it to the base inode.
	 */
	if (base_ni) {
		ni->nr_extents = -1;
		ni->base_ni = base_ni;
		/*
		 * Attach extent inode to base inode, reallocating memory if
		 * needed.
		 */
		if (!(base_ni->nr_extents & 3)) {
			ntfs_inode **extent_nis;
			int i;

			i = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
			extent_nis = (ntfs_inode**)malloc(i);
			if (!extent_nis)
				goto release_mrec_alloc_init_err_out;
			if (base_ni->extent_nis) {
				memcpy(extent_nis, base_ni->extent_nis,
						i - 4 * sizeof(ntfs_inode *));
				free(base_ni->extent_nis);
			}
			base_ni->extent_nis = extent_nis;
		}
		base_ni->extent_nis[base_ni->nr_extents++] = ni;
	}
	/* Make sure the allocated inode is written out to disk. */
	ntfs_inode_mark_dirty(ni);
	/* Update the default mft allocation position if it was used. */
	if (!base_ni)
		vol->mft_data_pos = bit + 1;
	/* Return the opened, allocated inode of the allocated mft record. */
	ntfs_debug("Returning opened, allocated %sinode 0x%llx.",
			base_ni ? "extent " : "", (long long)bit);
	free(buf);
	return ni;

release_mrec_alloc_init_err_out:
	err = errno;
	free(ni);
	errno = err;

undo_mrec_alloc_init_err_out:
	err = errno;
	free(m);
	errno = err;
	goto undo_data_init_err_out;

put_undo_data_init_err_out:
	err = errno;
	ntfs_attr_put_search_ctx(ctx);
	errno = err;

undo_data_init_err_out:
	goto trunc_mft_rl_shrink_mftbmp_alloc_err_out;

put_err_out:
	err = errno;
	ntfs_attr_put_search_ctx(ctx);
	errno = err;


trunc_mft_rl_shrink_mftbmp_alloc_err_out:

undo_mftbmp_alloc_err_out:

shrink_mftbmp_err_out:

err_out:
	err = errno;
	free(buf);
	if (err)
		errno = err;
	else
		errno = EIO;
	return NULL;
}

/**
 * ntfs_mft_record_free - free an mft record on an ntfs volume
 * @vol:	volume on which to free the mft record
 * @ni:		open ntfs inode of the mft record to free
 *
 * Free the mft record of the open inode @ni on the mounted ntfs volume @vol.
 * Note that this function calls ntfs_inode_close() internally and hence you
 * cannot use the pointer @ni any more after this function returns success.
 *
 * On success return 0 and on error return -1 with errno set to the error code.
 */
int ntfs_mft_record_free(ntfs_volume *vol, ntfs_inode *ni)
{
	u64 mft_no;
	int err;
	u16 seq_no, old_seq_no;

	if (!vol || !vol->mftbmp_na || !ni) {
		errno = EINVAL;
		return -1;
	}

	/* Cache the mft reference for later. */
	mft_no = ni->mft_no;

	/* Mark the mft record as not in use. */
	ni->mrec->flags &= ~MFT_RECORD_IN_USE;

	/* Increment the sequence number, skipping zero, if it is not zero. */
	old_seq_no = seq_no = le16_to_cpu(ni->mrec->sequence_number);
	if (seq_no == 0xffff)
		seq_no = 1;
	else if (seq_no)
		seq_no++;
	ni->mrec->sequence_number = cpu_to_le16(seq_no);

	/* Set the inode dirty and write it out. */
	ntfs_inode_mark_dirty(ni);
	if (ntfs_inode_sync(ni)) {
		err = errno;
		goto sync_rollback;
	}

	/* Clear the bit in the $MFT/$BITMAP corresponding to this record. */
	if (ntfs_bitmap_clear_run(vol->mftbmp_na, mft_no, 1)) {
		err = errno;
		// FIXME: If ntfs_bitmap_clear_run() guarantees atomicity on
		//	  error, this could be changed to goto sync_rollback;
		goto bitmap_rollback;
	}

	/* Throw away the now freed inode. */
	if (!ntfs_inode_close(ni))
		return 0;
	err = errno;

	/* Rollback what we did... */
bitmap_rollback:
	if (ntfs_bitmap_set_run(vol->mftbmp_na, mft_no, 1))
		Dputs("Eeek! Rollback failed in ntfs_mft_record_free().  "
				"Leaving inconsistent metadata!");
sync_rollback:
	ni->mrec->flags |= MFT_RECORD_IN_USE;
	ni->mrec->sequence_number = cpu_to_le16(old_seq_no);
	ntfs_inode_mark_dirty(ni);
	errno = err;
	return -1;
}