[PATCH] fs/ntfs: Conversion to generic boolean

		bh->b_bdev = vol->sb->s_bdev;

		/* Is the block within the allowed limits? */

		if (iblock < lblock) {

			BOOL is_retry = FALSE;

			bool is_retry = false;

			/* Convert iblock into corresponding vcn and offset. */

			vcn = (VCN)iblock << blocksize_bits >>

				goto handle_hole;

			/* If first try and runlist unmapped, map and retry. */

			if (!is_retry && lcn == LCN_RL_NOT_MAPPED) {

				is_retry = TRUE;

				is_retry = true;

				/*

				 * Attempt to map runlist, dropping lock for

				 * the duration.

	unsigned long flags;

	unsigned int blocksize, vcn_ofs;

	int err;

	BOOL need_end_writeback;

	bool need_end_writeback;

	unsigned char blocksize_bits;

	vi = page->mapping->host;

	rl = NULL;

	err = 0;

	do {

		BOOL is_retry = FALSE;

		bool is_retry = false;

		if (unlikely(block >= dblock)) {

			/*

		}

		/* If first try and runlist unmapped, map and retry. */

		if (!is_retry && lcn == LCN_RL_NOT_MAPPED) {

			is_retry = TRUE;

			is_retry = true;

			/*

			 * Attempt to map runlist, dropping lock for

			 * the duration.

	set_page_writeback(page);	/* Keeps try_to_free_buffers() away. */

	/* Submit the prepared buffers for i/o. */

	need_end_writeback = TRUE;

	need_end_writeback = true;

	do {

		struct buffer_head *next = bh->b_this_page;

		if (buffer_async_write(bh)) {

			submit_bh(WRITE, bh);

			need_end_writeback = FALSE;

			need_end_writeback = false;

		}

		bh = next;

	} while (bh != head);

	runlist_element *rl;

	int i, nr_locked_nis, nr_recs, nr_bhs, max_bhs, bhs_per_rec, err, err2;

	unsigned bh_size, rec_size_bits;

	BOOL sync, is_mft, page_is_dirty, rec_is_dirty;

	bool sync, is_mft, page_is_dirty, rec_is_dirty;

	unsigned char bh_size_bits;

	ntfs_debug("Entering for inode 0x%lx, attribute type 0x%x, page index "

	rl = NULL;

	err = err2 = nr_bhs = nr_recs = nr_locked_nis = 0;

	page_is_dirty = rec_is_dirty = FALSE;

	page_is_dirty = rec_is_dirty = false;

	rec_start_bh = NULL;

	do {

		BOOL is_retry = FALSE;

		bool is_retry = false;

		if (likely(block < rec_block)) {

			if (unlikely(block >= dblock)) {

			}

			if (!buffer_dirty(bh)) {

				/* Clean records are not written out. */

				rec_is_dirty = FALSE;

				rec_is_dirty = false;

				continue;

			}

			rec_is_dirty = TRUE;

			rec_is_dirty = true;

			rec_start_bh = bh;

		}

		/* Need to map the buffer if it is not mapped already. */

				 */

				if (!is_mft && !is_retry &&

						lcn == LCN_RL_NOT_MAPPED) {

					is_retry = TRUE;

					is_retry = true;

					/*

					 * Attempt to map runlist, dropping

					 * lock for the duration.

					if (likely(!err2))

						goto lock_retry_remap;

					if (err2 == -ENOMEM)

						page_is_dirty = TRUE;

						page_is_dirty = true;

					lcn = err2;

				} else {

					err2 = -EIO;

				 * means we need to redirty the page before

				 * returning.

				 */

				page_is_dirty = TRUE;

				page_is_dirty = true;

				/*

				 * Remove the buffers in this mft record from

				 * the list of buffers to write.

 *

 * The unlocked and uptodate page is returned on success or an encoded error

 * on failure. Caller has to test for error using the IS_ERR() macro on the

 * return value. If that evaluates to TRUE, the negative error code can be

 * return value. If that evaluates to 'true', the negative error code can be

 * obtained using PTR_ERR() on the return value of ntfs_map_page().

 */

static inline struct page *ntfs_map_page(struct address_space *mapping,

 * the attribute has zero allocated size, i.e. there simply is no runlist.

 *

 * WARNING: If @ctx is supplied, regardless of whether success or failure is

 *	    returned, you need to check IS_ERR(@ctx->mrec) and if TRUE the @ctx

 *	    returned, you need to check IS_ERR(@ctx->mrec) and if 'true' the @ctx

 *	    is no longer valid, i.e. you need to either call

 *	    ntfs_attr_reinit_search_ctx() or ntfs_attr_put_search_ctx() on it.

 *	    In that case PTR_ERR(@ctx->mrec) will give you the error code for

	runlist_element *rl;

	struct page *put_this_page = NULL;

	int err = 0;

	BOOL ctx_is_temporary, ctx_needs_reset;

	bool ctx_is_temporary, ctx_needs_reset;

	ntfs_attr_search_ctx old_ctx = { NULL, };

	ntfs_debug("Mapping runlist part containing vcn 0x%llx.",

	else

		base_ni = ni->ext.base_ntfs_ino;

	if (!ctx) {

		ctx_is_temporary = ctx_needs_reset = TRUE;

		ctx_is_temporary = ctx_needs_reset = true;

		m = map_mft_record(base_ni);

		if (IS_ERR(m))

			return PTR_ERR(m);

		BUG_ON(IS_ERR(ctx->mrec));

		a = ctx->attr;

		BUG_ON(!a->non_resident);

		ctx_is_temporary = FALSE;

		ctx_is_temporary = false;

		end_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn);

		read_lock_irqsave(&ni->size_lock, flags);

		allocated_size_vcn = ni->allocated_size >>

				ni->name, ni->name_len) &&

				sle64_to_cpu(a->data.non_resident.lowest_vcn)

				<= vcn && end_vcn >= vcn))

			ctx_needs_reset = FALSE;

			ctx_needs_reset = false;

		else {

			/* Save the old search context. */

			old_ctx = *ctx;

			 * needed attribute extent.

			 */

			ntfs_attr_reinit_search_ctx(ctx);

			ctx_needs_reset = TRUE;

			ctx_needs_reset = true;

		}

	}

	if (ctx_needs_reset) {

 *  LCN_EIO	Critical error (runlist/file is corrupt, i/o error, etc).

 *

 * Locking: - The runlist must be locked on entry and is left locked on return.

 *	    - If @write_locked is FALSE, i.e. the runlist is locked for reading,

 *	    - If @write_locked is 'false', i.e. the runlist is locked for reading,

 *	      the lock may be dropped inside the function so you cannot rely on

 *	      the runlist still being the same when this function returns.

 */

LCN ntfs_attr_vcn_to_lcn_nolock(ntfs_inode *ni, const VCN vcn,

		const BOOL write_locked)

		const bool write_locked)

{

	LCN lcn;

	unsigned long flags;

	BOOL is_retry = FALSE;

	bool is_retry = false;

	ntfs_debug("Entering for i_ino 0x%lx, vcn 0x%llx, %s_locked.",

			ni->mft_no, (unsigned long long)vcn,

			down_read(&ni->runlist.lock);

		}

		if (likely(!err)) {

			is_retry = TRUE;

			is_retry = true;

			goto retry_remap;

		}

		if (err == -ENOENT)

 *	-EIO	- Critical error (runlist/file is corrupt, i/o error, etc).

 *

 * WARNING: If @ctx is supplied, regardless of whether success or failure is

 *	    returned, you need to check IS_ERR(@ctx->mrec) and if TRUE the @ctx

 *	    returned, you need to check IS_ERR(@ctx->mrec) and if 'true' the @ctx

 *	    is no longer valid, i.e. you need to either call

 *	    ntfs_attr_reinit_search_ctx() or ntfs_attr_put_search_ctx() on it.

 *	    In that case PTR_ERR(@ctx->mrec) will give you the error code for

	unsigned long flags;

	runlist_element *rl;

	int err = 0;

	BOOL is_retry = FALSE;

	bool is_retry = false;

	ntfs_debug("Entering for i_ino 0x%lx, vcn 0x%llx, with%s ctx.",

			ni->mft_no, (unsigned long long)vcn, ctx ? "" : "out");

			 */

			err = ntfs_map_runlist_nolock(ni, vcn, ctx);

			if (likely(!err)) {

				is_retry = TRUE;

				is_retry = true;

				goto retry_remap;

			}

		}

 * On actual error, ntfs_attr_find() returns -EIO.  In this case @ctx->attr is

 * undefined and in particular do not rely on it not changing.

 *

 * If @ctx->is_first is TRUE, the search begins with @ctx->attr itself.  If it

 * is FALSE, the search begins after @ctx->attr.

 * If @ctx->is_first is 'true', the search begins with @ctx->attr itself.  If it

 * is 'false', the search begins after @ctx->attr.

 *

 * If @ic is IGNORE_CASE, the @name comparisson is not case sensitive and

 * @ctx->ntfs_ino must be set to the ntfs inode to which the mft record

	/*

	 * Iterate over attributes in mft record starting at @ctx->attr, or the

	 * attribute following that, if @ctx->is_first is TRUE.

	 * attribute following that, if @ctx->is_first is 'true'.

	 */

	if (ctx->is_first) {

		a = ctx->attr;

		ctx->is_first = FALSE;

		ctx->is_first = false;

	} else

		a = (ATTR_RECORD*)((u8*)ctx->attr +

				le32_to_cpu(ctx->attr->length));

		ctx->al_entry = (ATTR_LIST_ENTRY*)al_start;

	/*

	 * Iterate over entries in attribute list starting at @ctx->al_entry,

	 * or the entry following that, if @ctx->is_first is TRUE.

	 * or the entry following that, if @ctx->is_first is 'true'.

	 */

	if (ctx->is_first) {

		al_entry = ctx->al_entry;

		ctx->is_first = FALSE;

		ctx->is_first = false;

	} else

		al_entry = (ATTR_LIST_ENTRY*)((u8*)ctx->al_entry +

				le16_to_cpu(ctx->al_entry->length));

	ctx->mrec = ctx->base_mrec;

	ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +

			le16_to_cpu(ctx->mrec->attrs_offset));

	ctx->is_first = TRUE;

	ctx->is_first = true;

	ctx->ntfs_ino = base_ni;

	ctx->base_ntfs_ino = NULL;

	ctx->base_mrec = NULL;

		/* Sanity checks are performed elsewhere. */

		.attr = (ATTR_RECORD*)((u8*)mrec +

				le16_to_cpu(mrec->attrs_offset)),

		.is_first = TRUE,

		.is_first = true,

		.ntfs_ino = ni,

	};

}

{

	if (likely(!ctx->base_ntfs_ino)) {

		/* No attribute list. */

		ctx->is_first = TRUE;

		ctx->is_first = true;

		/* Sanity checks are performed elsewhere. */

		ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec +

				le16_to_cpu(ctx->mrec->attrs_offset));

			return -ENOMEM;

		/* Start by allocating clusters to hold the attribute value. */

		rl = ntfs_cluster_alloc(vol, 0, new_size >>

				vol->cluster_size_bits, -1, DATA_ZONE, TRUE);

				vol->cluster_size_bits, -1, DATA_ZONE, true);

		if (IS_ERR(rl)) {

			err = PTR_ERR(rl);

			ntfs_debug("Failed to allocate cluster%s, error code "

	unsigned long flags;

	int err, mp_size;

	u32 attr_len = 0; /* Silence stupid gcc warning. */

	BOOL mp_rebuilt;

	bool mp_rebuilt;

#ifdef NTFS_DEBUG

	read_lock_irqsave(&ni->size_lock, flags);

	rl2 = ntfs_cluster_alloc(vol, allocated_size >> vol->cluster_size_bits,

			(new_alloc_size - allocated_size) >>

			vol->cluster_size_bits, (rl && (rl->lcn >= 0)) ?

			rl->lcn + rl->length : -1, DATA_ZONE, TRUE);

			rl->lcn + rl->length : -1, DATA_ZONE, true);

	if (IS_ERR(rl2)) {

		err = PTR_ERR(rl2);

		if (start < 0 || start >= allocated_size)

	BUG_ON(!rl2);

	BUG_ON(!rl2->length);

	BUG_ON(rl2->lcn < LCN_HOLE);

	mp_rebuilt = FALSE;

	mp_rebuilt = false;

	/* Get the size for the new mapping pairs array for this extent. */

	mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, ll, -1);

	if (unlikely(mp_size <= 0)) {

		err = -EOPNOTSUPP;

		goto undo_alloc;

	}

	mp_rebuilt = TRUE;

	mp_rebuilt = true;

	/* Generate the mapping pairs array directly into the attr record. */

	err = ntfs_mapping_pairs_build(vol, (u8*)a +

			le16_to_cpu(a->data.non_resident.mapping_pairs_offset),

 * Structure must be initialized to zero before the first call to one of the

 * attribute search functions. Initialize @mrec to point to the mft record to

 * search, and @attr to point to the first attribute within @mrec (not necessary

 * if calling the _first() functions), and set @is_first to TRUE (not necessary

 * if calling the _first() functions), and set @is_first to 'true' (not necessary

 * if calling the _first() functions).

 *

 * If @is_first is TRUE, the search begins with @attr. If @is_first is FALSE,

 * If @is_first is 'true', the search begins with @attr. If @is_first is 'false',

 * the search begins after @attr. This is so that, after the first call to one

 * of the search attribute functions, we can call the function again, without

 * any modification of the search context, to automagically get the next

typedef struct {

	MFT_RECORD *mrec;

	ATTR_RECORD *attr;

	BOOL is_first;

	bool is_first;

	ntfs_inode *ntfs_ino;

	ATTR_LIST_ENTRY *al_entry;

	ntfs_inode *base_ntfs_ino;

extern int ntfs_map_runlist(ntfs_inode *ni, VCN vcn);

extern LCN ntfs_attr_vcn_to_lcn_nolock(ntfs_inode *ni, const VCN vcn,

		const BOOL write_locked);

		const bool write_locked);

extern runlist_element *ntfs_attr_find_vcn_nolock(ntfs_inode *ni,

		const VCN vcn, ntfs_attr_search_ctx *ctx);

 * @start_bit:		first bit to set

 * @count:		number of bits to set

 * @value:		value to set the bits to (i.e. 0 or 1)

 * @is_rollback:	if TRUE this is a rollback operation

 * @is_rollback:	if 'true' this is a rollback operation

 *

 * Set @count bits starting at bit @start_bit in the bitmap described by the

 * vfs inode @vi to @value, where @value is either 0 or 1.

 *

 * @is_rollback should always be FALSE, it is for internal use to rollback

 * @is_rollback should always be 'false', it is for internal use to rollback

 * errors.  You probably want to use ntfs_bitmap_set_bits_in_run() instead.

 *

 * Return 0 on success and -errno on error.

 */

int __ntfs_bitmap_set_bits_in_run(struct inode *vi, const s64 start_bit,

		const s64 count, const u8 value, const BOOL is_rollback)

		const s64 count, const u8 value, const bool is_rollback)

{

	s64 cnt = count;

	pgoff_t index, end_index;

		return PTR_ERR(page);

	if (count != cnt)

		pos = __ntfs_bitmap_set_bits_in_run(vi, start_bit, count - cnt,

				value ? 0 : 1, TRUE);

				value ? 0 : 1, true);

	else

		pos = 0;

	if (!pos) {