ext4: Fix bigalloc quota accounting and i_blocks value

 * @handle:             handle to this transaction

 * @inode:              file inode

 * @goal:               given target block(filesystem wide)

 * @count:		pointer to total number of blocks needed

 * @count:		pointer to total number of clusters needed

 * @errp:               error code

 *

 * Return 1st allocated block number on success, *count stores total account

		spin_lock(&EXT4_I(inode)->i_block_reservation_lock);

		EXT4_I(inode)->i_allocated_meta_blocks += ar.len;

		spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);

		dquot_alloc_block_nofail(inode, ar.len);

		dquot_alloc_block_nofail(inode,

				EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));

	}

	return ret;

}

#define EXT4_MAP_UNWRITTEN	(1 << BH_Unwritten)

#define EXT4_MAP_BOUNDARY	(1 << BH_Boundary)

#define EXT4_MAP_UNINIT		(1 << BH_Uninit)

/* Sometimes (in the bigalloc case, from ext4_da_get_block_prep) the caller of

 * ext4_map_blocks wants to know whether or not the underlying cluster has

 * already been accounted for. EXT4_MAP_FROM_CLUSTER conveys to the caller that

 * the requested mapping was from previously mapped (or delayed allocated)

 * cluster. We use BH_AllocFromCluster only for this flag. BH_AllocFromCluster

 * should never appear on buffer_head's state flags.

 */

#define EXT4_MAP_FROM_CLUSTER	(1 << BH_AllocFromCluster)

#define EXT4_MAP_FLAGS		(EXT4_MAP_NEW | EXT4_MAP_MAPPED |\

				 EXT4_MAP_UNWRITTEN | EXT4_MAP_BOUNDARY |\

				 EXT4_MAP_UNINIT)

				 EXT4_MAP_UNINIT | EXT4_MAP_FROM_CLUSTER)

struct ext4_map_blocks {

	ext4_fsblk_t m_pblk;

extern qsize_t *ext4_get_reserved_space(struct inode *inode);

extern void ext4_da_update_reserve_space(struct inode *inode,

					int used, int quota_claim);

extern int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock);

/* indirect.c */

extern int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,

enum ext4_state_bits {

	BH_Uninit	/* blocks are allocated but uninitialized on disk */

	  = BH_JBDPrivateStart,

	BH_AllocFromCluster,	/* allocated blocks were part of already

				 * allocated cluster. Note that this flag will

				 * never, ever appear in a buffer_head's state

				 * flag. See EXT4_MAP_FROM_CLUSTER to see where

				 * this is used. */

};

BUFFER_FNS(Uninit, uninit)

							struct ext4_ext_path *);

extern void ext4_ext_drop_refs(struct ext4_ext_path *);

extern int ext4_ext_check_inode(struct inode *inode);

extern int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk,

				      int search_hint_reverse);

#endif /* _EXT4_EXTENTS */

		}

	}

	/* If we still have something in the partial cluster and we have removed

	 * even the first extent, then we should free the blocks in the partial

	 * cluster as well. */

	if (partial_cluster && path->p_hdr->eh_entries == 0) {

		int flags = EXT4_FREE_BLOCKS_FORGET;

		if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))

			flags |= EXT4_FREE_BLOCKS_METADATA;

		ext4_free_blocks(handle, inode, NULL,

				 EXT4_C2B(EXT4_SB(sb), partial_cluster),

				 EXT4_SB(sb)->s_cluster_ratio, flags);

		partial_cluster = 0;

	}

	/* TODO: flexible tree reduction should be here */

	if (path->p_hdr->eh_entries == 0) {

		/*

	return ext4_mark_inode_dirty(handle, inode);

}

/**

 * ext4_find_delalloc_range: find delayed allocated block in the given range.

 *

 * Goes through the buffer heads in the range [lblk_start, lblk_end] and returns

 * whether there are any buffers marked for delayed allocation. It returns '1'

 * on the first delalloc'ed buffer head found. If no buffer head in the given

 * range is marked for delalloc, it returns 0.

 * lblk_start should always be <= lblk_end.

 * search_hint_reverse is to indicate that searching in reverse from lblk_end to

 * lblk_start might be more efficient (i.e., we will likely hit the delalloc'ed

 * block sooner). This is useful when blocks are truncated sequentially from

 * lblk_start towards lblk_end.

 */

static int ext4_find_delalloc_range(struct inode *inode,

				    ext4_lblk_t lblk_start,

				    ext4_lblk_t lblk_end,

				    int search_hint_reverse)

{

	struct address_space *mapping = inode->i_mapping;

	struct buffer_head *head, *bh = NULL;

	struct page *page;

	ext4_lblk_t i, pg_lblk;

	pgoff_t index;

	/* reverse search wont work if fs block size is less than page size */

	if (inode->i_blkbits < PAGE_CACHE_SHIFT)

		search_hint_reverse = 0;

	if (search_hint_reverse)

		i = lblk_end;

	else

		i = lblk_start;

	index = i >> (PAGE_CACHE_SHIFT - inode->i_blkbits);

	while ((i >= lblk_start) && (i <= lblk_end)) {

		page = find_get_page(mapping, index);

		if (!page || !PageDirty(page))

			goto nextpage;

		if (PageWriteback(page)) {

			/*

			 * This might be a race with allocation and writeout. In

			 * this case we just assume that the rest of the range

			 * will eventually be written and there wont be any

			 * delalloc blocks left.

			 * TODO: the above assumption is troublesome, but might

			 * work better in practice. other option could be note

			 * somewhere that the cluster is getting written out and

			 * detect that here.

			 */

			page_cache_release(page);

			return 0;

		}

		if (!page_has_buffers(page))

			goto nextpage;

		head = page_buffers(page);

		if (!head)

			goto nextpage;

		bh = head;

		pg_lblk = index << (PAGE_CACHE_SHIFT -

						inode->i_blkbits);

		do {

			if (unlikely(pg_lblk < lblk_start)) {

				/*

				 * This is possible when fs block size is less

				 * than page size and our cluster starts/ends in

				 * middle of the page. So we need to skip the

				 * initial few blocks till we reach the 'lblk'

				 */

				pg_lblk++;

				continue;

			}

			if (buffer_delay(bh)) {

				page_cache_release(page);

				return 1;

			}

			if (search_hint_reverse)

				i--;

			else

				i++;

		} while ((i >= lblk_start) && (i <= lblk_end) &&

				((bh = bh->b_this_page) != head));

nextpage:

		if (page)

			page_cache_release(page);

		/*

		 * Move to next page. 'i' will be the first lblk in the next

		 * page.

		 */

		if (search_hint_reverse)

			index--;

		else

			index++;

		i = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);

	}

	return 0;

}

int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk,

			       int search_hint_reverse)

{

	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

	ext4_lblk_t lblk_start, lblk_end;

	lblk_start = lblk & (~(sbi->s_cluster_ratio - 1));

	lblk_end = lblk_start + sbi->s_cluster_ratio - 1;

	return ext4_find_delalloc_range(inode, lblk_start, lblk_end,

					search_hint_reverse);

}

/**

 * Determines how many complete clusters (out of those specified by the 'map')

 * are under delalloc and were reserved quota for.

 * This function is called when we are writing out the blocks that were

 * originally written with their allocation delayed, but then the space was

 * allocated using fallocate() before the delayed allocation could be resolved.

 * The cases to look for are:

 * ('=' indicated delayed allocated blocks

 *  '-' indicates non-delayed allocated blocks)

 * (a) partial clusters towards beginning and/or end outside of allocated range

 *     are not delalloc'ed.

 *	Ex:

 *	|----c---=|====c====|====c====|===-c----|

 *	         |++++++ allocated ++++++|

 *	==> 4 complete clusters in above example

 *

 * (b) partial cluster (outside of allocated range) towards either end is

 *     marked for delayed allocation. In this case, we will exclude that

 *     cluster.

 *	Ex:

 *	|----====c========|========c========|

 *	     |++++++ allocated ++++++|

 *	==> 1 complete clusters in above example

 *

 *	Ex:

 *	|================c================|

 *            |++++++ allocated ++++++|

 *	==> 0 complete clusters in above example

 *

 * The ext4_da_update_reserve_space will be called only if we

 * determine here that there were some "entire" clusters that span

 * this 'allocated' range.

 * In the non-bigalloc case, this function will just end up returning num_blks

 * without ever calling ext4_find_delalloc_range.

 */

static unsigned int

get_reserved_cluster_alloc(struct inode *inode, ext4_lblk_t lblk_start,

			   unsigned int num_blks)

{

	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

	ext4_lblk_t alloc_cluster_start, alloc_cluster_end;

	ext4_lblk_t lblk_from, lblk_to, c_offset;

	unsigned int allocated_clusters = 0;

	alloc_cluster_start = EXT4_B2C(sbi, lblk_start);

	alloc_cluster_end = EXT4_B2C(sbi, lblk_start + num_blks - 1);

	/* max possible clusters for this allocation */

	allocated_clusters = alloc_cluster_end - alloc_cluster_start + 1;

	/* Check towards left side */

	c_offset = lblk_start & (sbi->s_cluster_ratio - 1);

	if (c_offset) {

		lblk_from = lblk_start & (~(sbi->s_cluster_ratio - 1));

		lblk_to = lblk_from + c_offset - 1;

		if (ext4_find_delalloc_range(inode, lblk_from, lblk_to, 0))

			allocated_clusters--;

	}

	/* Now check towards right. */

	c_offset = (lblk_start + num_blks) & (sbi->s_cluster_ratio - 1);

	if (allocated_clusters && c_offset) {

		lblk_from = lblk_start + num_blks;

		lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1;

		if (ext4_find_delalloc_range(inode, lblk_from, lblk_to, 0))

			allocated_clusters--;

	}

	return allocated_clusters;

}

static int

ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode,

			struct ext4_map_blocks *map,

	 * But fallocate would have already updated quota and block

	 * count for this offset. So cancel these reservation

	 */

	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)

		ext4_da_update_reserve_space(inode, allocated, 0);

	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {

		unsigned int reserved_clusters;

		reserved_clusters = get_reserved_cluster_alloc(inode,

				map->m_lblk, map->m_len);

		if (reserved_clusters)

			ext4_da_update_reserve_space(inode,

						     reserved_clusters,

						     0);

	}

map_out:

	map->m_flags |= EXT4_MAP_MAPPED;

	ext4_fsblk_t newblock = 0;

	int free_on_err = 0, err = 0, depth, ret;

	unsigned int allocated = 0, offset = 0;

	unsigned int allocated_clusters = 0, reserved_clusters = 0;

	unsigned int punched_out = 0;

	unsigned int result = 0;

	struct ext4_allocation_request ar;

	if (!(flags & EXT4_GET_BLOCKS_PUNCH_OUT_EXT) &&

		ext4_ext_in_cache(inode, map->m_lblk, &newex)) {

		if (!newex.ee_start_lo && !newex.ee_start_hi) {

			if ((sbi->s_cluster_ratio > 1) &&

			    ext4_find_delalloc_cluster(inode, map->m_lblk, 0))

				map->m_flags |= EXT4_MAP_FROM_CLUSTER;

			if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {

				/*

				 * block isn't allocated yet and

			/* we should allocate requested block */

		} else {

			/* block is already allocated */

			if (sbi->s_cluster_ratio > 1)

				map->m_flags |= EXT4_MAP_FROM_CLUSTER;

			newblock = map->m_lblk

				   - le32_to_cpu(newex.ee_block)

				   + ext4_ext_pblock(&newex);

		}

	}

	if ((sbi->s_cluster_ratio > 1) &&

	    ext4_find_delalloc_cluster(inode, map->m_lblk, 0))

		map->m_flags |= EXT4_MAP_FROM_CLUSTER;

	/*

	 * requested block isn't allocated yet;

	 * we couldn't try to create block if create flag is zero

	/*

	 * Okay, we need to do block allocation.

	 */

	map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;

	newex.ee_block = cpu_to_le32(map->m_lblk);

	cluster_offset = map->m_lblk & (sbi->s_cluster_ratio-1);

	    get_implied_cluster_alloc(sbi, map, ex, path)) {

		ar.len = allocated = map->m_len;

		newblock = map->m_pblk;

		map->m_flags |= EXT4_MAP_FROM_CLUSTER;

		goto got_allocated_blocks;

	}

	    get_implied_cluster_alloc(sbi, map, ex2, path)) {

		ar.len = allocated = map->m_len;

		newblock = map->m_pblk;

		map->m_flags |= EXT4_MAP_FROM_CLUSTER;

		goto got_allocated_blocks;

	}

	ext_debug("allocate new block: goal %llu, found %llu/%u\n",

		  ar.goal, newblock, allocated);

	free_on_err = 1;

	allocated_clusters = ar.len;

	ar.len = EXT4_C2B(sbi, ar.len) - offset;

	if (ar.len > allocated)

		ar.len = allocated;

	 * Update reserved blocks/metadata blocks after successful

	 * block allocation which had been deferred till now.

	 */

	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)

		ext4_da_update_reserve_space(inode, allocated, 1);

	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {

		/*

		 * Check how many clusters we had reserved this allocted range.

		 */

		reserved_clusters = get_reserved_cluster_alloc(inode,

						map->m_lblk, allocated);

		if (map->m_flags & EXT4_MAP_FROM_CLUSTER) {

			if (reserved_clusters) {

				/*

				 * We have clusters reserved for this range.

				 * But since we are not doing actual allocation

				 * and are simply using blocks from previously

				 * allocated cluster, we should release the

				 * reservation and not claim quota.

				 */

				ext4_da_update_reserve_space(inode,

						reserved_clusters, 0);

			}

		} else {

			BUG_ON(allocated_clusters < reserved_clusters);

			/* We will claim quota for all newly allocated blocks.*/

			ext4_da_update_reserve_space(inode, allocated_clusters,

							1);

			if (reserved_clusters < allocated_clusters) {

				int reservation = allocated_clusters -

						  reserved_clusters;

				/*

				 * It seems we claimed few clusters outside of

				 * the range of this allocation. We should give

				 * it back to the reservation pool. This can

				 * happen in the following case:

				 *

				 * * Suppose s_cluster_ratio is 4 (i.e., each

				 *   cluster has 4 blocks. Thus, the clusters

				 *   are [0-3],[4-7],[8-11]...

				 * * First comes delayed allocation write for

				 *   logical blocks 10 & 11. Since there were no

				 *   previous delayed allocated blocks in the

				 *   range [8-11], we would reserve 1 cluster

				 *   for this write.

				 * * Next comes write for logical blocks 3 to 8.

				 *   In this case, we will reserve 2 clusters

				 *   (for [0-3] and [4-7]; and not for [8-11] as

				 *   that range has a delayed allocated blocks.

				 *   Thus total reserved clusters now becomes 3.

				 * * Now, during the delayed allocation writeout

				 *   time, we will first write blocks [3-8] and

				 *   allocate 3 clusters for writing these

				 *   blocks. Also, we would claim all these

				 *   three clusters above.

				 * * Now when we come here to writeout the

				 *   blocks [10-11], we would expect to claim

				 *   the reservation of 1 cluster we had made

				 *   (and we would claim it since there are no

				 *   more delayed allocated blocks in the range

				 *   [8-11]. But our reserved cluster count had

				 *   already gone to 0.

				 *

				 *   Thus, at the step 4 above when we determine

				 *   that there are still some unwritten delayed

				 *   allocated blocks outside of our current

				 *   block range, we should increment the

				 *   reserved clusters count so that when the

				 *   remaining blocks finally gets written, we

				 *   could claim them.

				 */

				while (reservation) {

					ext4_da_reserve_space(inode,

							      map->m_lblk);

					reservation--;

				}

			}

		}

	}

	/*

	 * Cache the extent and update transaction to commit on fdatasync only

	/* Update quota subsystem for data blocks */

	if (quota_claim)

		dquot_claim_block(inode, used);

		dquot_claim_block(inode, EXT4_C2B(sbi, used));

	else {

		/*

		 * We did fallocate with an offset that is already delayed

		 * allocated. So on delayed allocated writeback we should

		 * not re-claim the quota for fallocated blocks.

		 */

		dquot_release_reservation_block(inode, used);

		dquot_release_reservation_block(inode, EXT4_C2B(sbi, used));

	}

	/*

}

/*

 * Reserve a single block located at lblock

 * Reserve a single cluster located at lblock

 */

static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)

int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)

{

	int retries = 0;

	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

	struct ext4_inode_info *ei = EXT4_I(inode);

	unsigned long md_needed;

	unsigned int md_needed;

	int ret;

	/*

	 */

repeat:

	spin_lock(&ei->i_block_reservation_lock);

	md_needed = ext4_calc_metadata_amount(inode, lblock);

	md_needed = EXT4_NUM_B2C(sbi,

				 ext4_calc_metadata_amount(inode, lblock));

	trace_ext4_da_reserve_space(inode, md_needed);

	spin_unlock(&ei->i_block_reservation_lock);

	 * us from metadata over-estimation, though we may go over by

	 * a small amount in the end.  Here we just reserve for data.

	 */

	ret = dquot_reserve_block(inode, 1);

	ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));

	if (ret)

		return ret;

	/*

	 * we cannot afford to run out of free blocks.

	 */

	if (ext4_claim_free_blocks(sbi, md_needed + 1, 0)) {

		dquot_release_reservation_block(inode, 1);

		dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));

		if (ext4_should_retry_alloc(inode->i_sb, &retries)) {

			yield();

			goto repeat;

		 * We can release all of the reserved metadata blocks

		 * only when we have written all of the delayed

		 * allocation blocks.

		 * Note that in case of bigalloc, i_reserved_meta_blocks,

		 * i_reserved_data_blocks, etc. refer to number of clusters.

		 */

		percpu_counter_sub(&sbi->s_dirtyclusters_counter,

				   ei->i_reserved_meta_blocks);

	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);

	dquot_release_reservation_block(inode, to_free);

	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));

}

static void ext4_da_page_release_reservation(struct page *page,

	int to_release = 0;

	struct buffer_head *head, *bh;

	unsigned int curr_off = 0;

	struct inode *inode = page->mapping->host;

	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

	int num_clusters;

	head = page_buffers(page);

	bh = head;

		}

		curr_off = next_off;

	} while ((bh = bh->b_this_page) != head);

	ext4_da_release_space(page->mapping->host, to_release);

	/* If we have released all the blocks belonging to a cluster, then we

	 * need to release the reserved space for that cluster. */

	num_clusters = EXT4_NUM_B2C(sbi, to_release);

	while (num_clusters > 0) {

		ext4_fsblk_t lblk;

		lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +

			((num_clusters - 1) << sbi->s_cluster_bits);

		if (sbi->s_cluster_ratio == 1 ||

		    !ext4_find_delalloc_cluster(inode, lblk, 1))

			ext4_da_release_space(inode, 1);

		num_clusters--;

	}

}

/*

	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),

		percpu_counter_sum(&sbi->s_freeclusters_counter)));

	printk(KERN_CRIT "dirty_blocks=%lld\n",

	       (long long) percpu_counter_sum(&sbi->s_dirtyclusters_counter));

	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),

		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));

	printk(KERN_CRIT "Block reservation details\n");

	printk(KERN_CRIT "i_reserved_data_blocks=%u\n",

	       EXT4_I(inode)->i_reserved_data_blocks);

		/*

		 * XXX: __block_write_begin() unmaps passed block, is it OK?

		 */

		/* If the block was allocated from previously allocated cluster,

		 * then we dont need to reserve it again. */

		if (!(map.m_flags & EXT4_MAP_FROM_CLUSTER)) {

			ret = ext4_da_reserve_space(inode, iblock);

			if (ret)

				/* not enough space to reserve */

				return ret;

		}

		map_bh(bh, inode->i_sb, invalid_block);

		set_buffer_new(bh);