/*

   *  linux/fs/ext4/inode.c

   *
   * Copyright (C) 1992, 1993, 1994, 1995
   * Remy Card (card@masi.ibp.fr)
   * Laboratoire MASI - Institut Blaise Pascal
   * Universite Pierre et Marie Curie (Paris VI)
   *
   *  from
   *
   *  linux/fs/minix/inode.c
   *
   *  Copyright (C) 1991, 1992  Linus Torvalds
   *

   *  64-bit file support on 64-bit platforms by Jakub Jelinek
   *	(jj@sunsite.ms.mff.cuni.cz)
   *

   *  Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000

   */

  #include <linux/fs.h>
  #include <linux/time.h>

  #include <linux/jbd2.h>

  #include <linux/highuid.h>
  #include <linux/pagemap.h>
  #include <linux/quotaops.h>
  #include <linux/string.h>
  #include <linux/buffer_head.h>
  #include <linux/writeback.h>

  #include <linux/pagevec.h>

  #include <linux/mpage.h>

  #include <linux/namei.h>

  #include <linux/uio.h>
  #include <linux/bio.h>

  #include <linux/workqueue.h>

  #include <linux/kernel.h>

  #include <linux/printk.h>

  #include <linux/slab.h>

  #include <linux/ratelimit.h>

  #include "ext4_jbd2.h"

  #include "xattr.h"
  #include "acl.h"

  #include "truncate.h"

  #include <trace/events/ext4.h>

  #define MPAGE_DA_EXTENT_TAIL 0x01

  static inline int ext4_begin_ordered_truncate(struct inode *inode,
  					      loff_t new_size)
  {

  	trace_ext4_begin_ordered_truncate(inode, new_size);

  	/*
  	 * If jinode is zero, then we never opened the file for
  	 * writing, so there's no need to call
  	 * jbd2_journal_begin_ordered_truncate() since there's no
  	 * outstanding writes we need to flush.
  	 */
  	if (!EXT4_I(inode)->jinode)
  		return 0;
  	return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode),
  						   EXT4_I(inode)->jinode,
  						   new_size);

  }

  static void ext4_invalidatepage(struct page *page, unsigned long offset);

  static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
  				   struct buffer_head *bh_result, int create);
  static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
  static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);
  static int __ext4_journalled_writepage(struct page *page, unsigned int len);
  static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);

  static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
  		struct inode *inode, struct page *page, loff_t from,
  		loff_t length, int flags);

  /*
   * Test whether an inode is a fast symlink.
   */

  static int ext4_inode_is_fast_symlink(struct inode *inode)

  {

  	int ea_blocks = EXT4_I(inode)->i_file_acl ?

  		(inode->i_sb->s_blocksize >> 9) : 0;
  
  	return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
  }
  
  /*

   * Restart the transaction associated with *handle.  This does a commit,
   * so before we call here everything must be consistently dirtied against
   * this transaction.
   */

  int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,

  				 int nblocks)

  {

  	int ret;
  
  	/*

  	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this

  	 * moment, get_block can be called only for blocks inside i_size since
  	 * page cache has been already dropped and writes are blocked by
  	 * i_mutex. So we can safely drop the i_data_sem here.
  	 */

  	BUG_ON(EXT4_JOURNAL(inode) == NULL);

  	jbd_debug(2, "restarting handle %p
  ", handle);

  	up_write(&EXT4_I(inode)->i_data_sem);

  	ret = ext4_journal_restart(handle, nblocks);

  	down_write(&EXT4_I(inode)->i_data_sem);

  	ext4_discard_preallocations(inode);

  
  	return ret;

  }
  
  /*
   * Called at the last iput() if i_nlink is zero.
   */

  void ext4_evict_inode(struct inode *inode)

  {
  	handle_t *handle;

  	int err;

  	trace_ext4_evict_inode(inode);

  	ext4_ioend_wait(inode);

  	if (inode->i_nlink) {

  		/*
  		 * When journalling data dirty buffers are tracked only in the
  		 * journal. So although mm thinks everything is clean and
  		 * ready for reaping the inode might still have some pages to
  		 * write in the running transaction or waiting to be
  		 * checkpointed. Thus calling jbd2_journal_invalidatepage()
  		 * (via truncate_inode_pages()) to discard these buffers can
  		 * cause data loss. Also even if we did not discard these
  		 * buffers, we would have no way to find them after the inode
  		 * is reaped and thus user could see stale data if he tries to
  		 * read them before the transaction is checkpointed. So be
  		 * careful and force everything to disk here... We use
  		 * ei->i_datasync_tid to store the newest transaction
  		 * containing inode's data.
  		 *
  		 * Note that directories do not have this problem because they
  		 * don't use page cache.
  		 */
  		if (ext4_should_journal_data(inode) &&
  		    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {
  			journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
  			tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;
  
  			jbd2_log_start_commit(journal, commit_tid);
  			jbd2_log_wait_commit(journal, commit_tid);
  			filemap_write_and_wait(&inode->i_data);
  		}

  		truncate_inode_pages(&inode->i_data, 0);
  		goto no_delete;
  	}

  	if (!is_bad_inode(inode))

  		dquot_initialize(inode);

  	if (ext4_should_order_data(inode))
  		ext4_begin_ordered_truncate(inode, 0);

  	truncate_inode_pages(&inode->i_data, 0);
  
  	if (is_bad_inode(inode))
  		goto no_delete;

  	handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);

  	if (IS_ERR(handle)) {

  		ext4_std_error(inode->i_sb, PTR_ERR(handle));

  		/*
  		 * If we're going to skip the normal cleanup, we still need to
  		 * make sure that the in-core orphan linked list is properly
  		 * cleaned up.
  		 */

  		ext4_orphan_del(NULL, inode);

  		goto no_delete;
  	}
  
  	if (IS_SYNC(inode))

  		ext4_handle_sync(handle);

  	inode->i_size = 0;

  	err = ext4_mark_inode_dirty(handle, inode);
  	if (err) {

  		ext4_warning(inode->i_sb,

  			     "couldn't mark inode dirty (err %d)", err);
  		goto stop_handle;
  	}

  	if (inode->i_blocks)

  		ext4_truncate(inode);

  
  	/*
  	 * ext4_ext_truncate() doesn't reserve any slop when it
  	 * restarts journal transactions; therefore there may not be
  	 * enough credits left in the handle to remove the inode from
  	 * the orphan list and set the dtime field.
  	 */

  	if (!ext4_handle_has_enough_credits(handle, 3)) {

  		err = ext4_journal_extend(handle, 3);
  		if (err > 0)
  			err = ext4_journal_restart(handle, 3);
  		if (err != 0) {

  			ext4_warning(inode->i_sb,

  				     "couldn't extend journal (err %d)", err);
  		stop_handle:
  			ext4_journal_stop(handle);

  			ext4_orphan_del(NULL, inode);

  			goto no_delete;
  		}
  	}

  	/*

  	 * Kill off the orphan record which ext4_truncate created.

  	 * AKPM: I think this can be inside the above `if'.

  	 * Note that ext4_orphan_del() has to be able to cope with the

  	 * deletion of a non-existent orphan - this is because we don't

  	 * know if ext4_truncate() actually created an orphan record.

  	 * (Well, we could do this if we need to, but heck - it works)
  	 */

  	ext4_orphan_del(handle, inode);
  	EXT4_I(inode)->i_dtime	= get_seconds();

  
  	/*
  	 * One subtle ordering requirement: if anything has gone wrong
  	 * (transaction abort, IO errors, whatever), then we can still
  	 * do these next steps (the fs will already have been marked as
  	 * having errors), but we can't free the inode if the mark_dirty
  	 * fails.
  	 */

  	if (ext4_mark_inode_dirty(handle, inode))

  		/* If that failed, just do the required in-core inode clear. */

  		ext4_clear_inode(inode);

  	else

  		ext4_free_inode(handle, inode);
  	ext4_journal_stop(handle);

  	return;
  no_delete:

  	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */

  }

  #ifdef CONFIG_QUOTA
  qsize_t *ext4_get_reserved_space(struct inode *inode)

  {

  	return &EXT4_I(inode)->i_reserved_quota;

  }

  #endif

  /*
   * Calculate the number of metadata blocks need to reserve

   * to allocate a block located at @lblock

   */

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

  {

  	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))

  		return ext4_ext_calc_metadata_amount(inode, lblock);

  	return ext4_ind_calc_metadata_amount(inode, lblock);

  }

  /*
   * Called with i_data_sem down, which is important since we can call
   * ext4_discard_preallocations() from here.
   */

  void ext4_da_update_reserve_space(struct inode *inode,
  					int used, int quota_claim)

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

  	struct ext4_inode_info *ei = EXT4_I(inode);

  
  	spin_lock(&ei->i_block_reservation_lock);

  	trace_ext4_da_update_reserve_space(inode, used, quota_claim);

  	if (unlikely(used > ei->i_reserved_data_blocks)) {
  		ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "
  			 "with only %d reserved data blocks
  ",
  			 __func__, inode->i_ino, used,
  			 ei->i_reserved_data_blocks);
  		WARN_ON(1);
  		used = ei->i_reserved_data_blocks;
  	}

  	/* Update per-inode reservations */
  	ei->i_reserved_data_blocks -= used;

  	ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;

  	percpu_counter_sub(&sbi->s_dirtyclusters_counter,

  			   used + ei->i_allocated_meta_blocks);

  	ei->i_allocated_meta_blocks = 0;

  	if (ei->i_reserved_data_blocks == 0) {
  		/*
  		 * We can release all of the reserved metadata blocks
  		 * only when we have written all of the delayed
  		 * allocation blocks.
  		 */

  		percpu_counter_sub(&sbi->s_dirtyclusters_counter,

  				   ei->i_reserved_meta_blocks);

  		ei->i_reserved_meta_blocks = 0;

  		ei->i_da_metadata_calc_len = 0;

  	}

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

  	/* Update quota subsystem for data blocks */
  	if (quota_claim)

  		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, EXT4_C2B(sbi, used));

  	}

  
  	/*
  	 * If we have done all the pending block allocations and if
  	 * there aren't any writers on the inode, we can discard the
  	 * inode's preallocations.
  	 */

  	if ((ei->i_reserved_data_blocks == 0) &&
  	    (atomic_read(&inode->i_writecount) == 0))

  		ext4_discard_preallocations(inode);

  }

  static int __check_block_validity(struct inode *inode, const char *func,

  				unsigned int line,
  				struct ext4_map_blocks *map)

  {

  	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
  				   map->m_len)) {

  		ext4_error_inode(inode, func, line, map->m_pblk,
  				 "lblock %lu mapped to illegal pblock "
  				 "(length %d)", (unsigned long) map->m_lblk,
  				 map->m_len);

  		return -EIO;
  	}
  	return 0;
  }

  #define check_block_validity(inode, map)	\

  	__check_block_validity((inode), __func__, __LINE__, (map))

  /*

   * Return the number of contiguous dirty pages in a given inode
   * starting at page frame idx.

   */
  static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
  				    unsigned int max_pages)
  {
  	struct address_space *mapping = inode->i_mapping;
  	pgoff_t	index;
  	struct pagevec pvec;
  	pgoff_t num = 0;
  	int i, nr_pages, done = 0;
  
  	if (max_pages == 0)
  		return 0;
  	pagevec_init(&pvec, 0);
  	while (!done) {
  		index = idx;
  		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
  					      PAGECACHE_TAG_DIRTY,
  					      (pgoff_t)PAGEVEC_SIZE);
  		if (nr_pages == 0)
  			break;
  		for (i = 0; i < nr_pages; i++) {
  			struct page *page = pvec.pages[i];
  			struct buffer_head *bh, *head;
  
  			lock_page(page);
  			if (unlikely(page->mapping != mapping) ||
  			    !PageDirty(page) ||
  			    PageWriteback(page) ||
  			    page->index != idx) {
  				done = 1;
  				unlock_page(page);
  				break;
  			}

  			if (page_has_buffers(page)) {
  				bh = head = page_buffers(page);
  				do {
  					if (!buffer_delay(bh) &&
  					    !buffer_unwritten(bh))
  						done = 1;
  					bh = bh->b_this_page;
  				} while (!done && (bh != head));
  			}

  			unlock_page(page);
  			if (done)
  				break;
  			idx++;
  			num++;

  			if (num >= max_pages) {
  				done = 1;

  				break;

  			}

  		}
  		pagevec_release(&pvec);
  	}
  	return num;
  }
  
  /*

   * Sets the BH_Da_Mapped bit on the buffer heads corresponding to the given map.
   */
  static void set_buffers_da_mapped(struct inode *inode,
  				   struct ext4_map_blocks *map)
  {
  	struct address_space *mapping = inode->i_mapping;
  	struct pagevec pvec;
  	int i, nr_pages;
  	pgoff_t index, end;
  
  	index = map->m_lblk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
  	end = (map->m_lblk + map->m_len - 1) >>
  		(PAGE_CACHE_SHIFT - inode->i_blkbits);
  
  	pagevec_init(&pvec, 0);
  	while (index <= end) {
  		nr_pages = pagevec_lookup(&pvec, mapping, index,
  					  min(end - index + 1,
  					      (pgoff_t)PAGEVEC_SIZE));
  		if (nr_pages == 0)
  			break;
  		for (i = 0; i < nr_pages; i++) {
  			struct page *page = pvec.pages[i];
  			struct buffer_head *bh, *head;
  
  			if (unlikely(page->mapping != mapping) ||
  			    !PageDirty(page))
  				break;
  
  			if (page_has_buffers(page)) {
  				bh = head = page_buffers(page);
  				do {
  					set_buffer_da_mapped(bh);
  					bh = bh->b_this_page;
  				} while (bh != head);
  			}
  			index++;
  		}
  		pagevec_release(&pvec);
  	}
  }
  
  /*

   * The ext4_map_blocks() function tries to look up the requested blocks,

   * and returns if the blocks are already mapped.

   *

   * Otherwise it takes the write lock of the i_data_sem and allocate blocks
   * and store the allocated blocks in the result buffer head and mark it
   * mapped.
   *

   * If file type is extents based, it will call ext4_ext_map_blocks(),
   * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping

   * based files
   *
   * On success, it returns the number of blocks being mapped or allocate.
   * if create==0 and the blocks are pre-allocated and uninitialized block,
   * the result buffer head is unmapped. If the create ==1, it will make sure
   * the buffer head is mapped.
   *
   * It returns 0 if plain look up failed (blocks have not been allocated), in

   * that case, buffer head is unmapped

   *
   * It returns the error in case of allocation failure.
   */

  int ext4_map_blocks(handle_t *handle, struct inode *inode,
  		    struct ext4_map_blocks *map, int flags)

  {
  	int retval;

  	map->m_flags = 0;
  	ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u,"
  		  "logical block %lu
  ", inode->i_ino, flags, map->m_len,
  		  (unsigned long) map->m_lblk);

  	/*

  	 * Try to see if we can get the block without requesting a new
  	 * file system block.

  	 */
  	down_read((&EXT4_I(inode)->i_data_sem));

  	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {

  		retval = ext4_ext_map_blocks(handle, inode, map, flags &
  					     EXT4_GET_BLOCKS_KEEP_SIZE);

  	} else {

  		retval = ext4_ind_map_blocks(handle, inode, map, flags &
  					     EXT4_GET_BLOCKS_KEEP_SIZE);

  	}

  	up_read((&EXT4_I(inode)->i_data_sem));

  	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {

  		int ret = check_block_validity(inode, map);

  		if (ret != 0)
  			return ret;
  	}

  	/* If it is only a block(s) look up */

  	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)

  		return retval;
  
  	/*
  	 * Returns if the blocks have already allocated
  	 *
  	 * Note that if blocks have been preallocated

  	 * ext4_ext_get_block() returns the create = 0

  	 * with buffer head unmapped.
  	 */

  	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)

  		return retval;
  
  	/*

  	 * When we call get_blocks without the create flag, the
  	 * BH_Unwritten flag could have gotten set if the blocks
  	 * requested were part of a uninitialized extent.  We need to
  	 * clear this flag now that we are committed to convert all or
  	 * part of the uninitialized extent to be an initialized
  	 * extent.  This is because we need to avoid the combination
  	 * of BH_Unwritten and BH_Mapped flags being simultaneously
  	 * set on the buffer_head.
  	 */

  	map->m_flags &= ~EXT4_MAP_UNWRITTEN;

  
  	/*

  	 * New blocks allocate and/or writing to uninitialized extent
  	 * will possibly result in updating i_data, so we take
  	 * the write lock of i_data_sem, and call get_blocks()
  	 * with create == 1 flag.

  	 */
  	down_write((&EXT4_I(inode)->i_data_sem));

  
  	/*
  	 * if the caller is from delayed allocation writeout path
  	 * we have already reserved fs blocks for allocation
  	 * let the underlying get_block() function know to
  	 * avoid double accounting
  	 */

  	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)

  		ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);

  	/*
  	 * We need to check for EXT4 here because migrate
  	 * could have changed the inode type in between
  	 */

  	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {

  		retval = ext4_ext_map_blocks(handle, inode, map, flags);

  	} else {

  		retval = ext4_ind_map_blocks(handle, inode, map, flags);

  		if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {

  			/*
  			 * We allocated new blocks which will result in
  			 * i_data's format changing.  Force the migrate
  			 * to fail by clearing migrate flags
  			 */

  			ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);

  		}

  		/*
  		 * Update reserved blocks/metadata blocks after successful
  		 * block allocation which had been deferred till now. We don't
  		 * support fallocate for non extent files. So we can update
  		 * reserve space here.
  		 */
  		if ((retval > 0) &&

  			(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))

  			ext4_da_update_reserve_space(inode, retval, 1);
  	}

  	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {

  		ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);

  		/* If we have successfully mapped the delayed allocated blocks,
  		 * set the BH_Da_Mapped bit on them. Its important to do this
  		 * under the protection of i_data_sem.
  		 */
  		if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
  			set_buffers_da_mapped(inode, map);
  	}

  	up_write((&EXT4_I(inode)->i_data_sem));

  	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {

  		int ret = check_block_validity(inode, map);

  		if (ret != 0)
  			return ret;
  	}

  	return retval;
  }

  /* Maximum number of blocks we map for direct IO at once. */
  #define DIO_MAX_BLOCKS 4096

  static int _ext4_get_block(struct inode *inode, sector_t iblock,
  			   struct buffer_head *bh, int flags)

  {

  	handle_t *handle = ext4_journal_current_handle();

  	struct ext4_map_blocks map;

  	int ret = 0, started = 0;

  	int dio_credits;

  	map.m_lblk = iblock;
  	map.m_len = bh->b_size >> inode->i_blkbits;
  
  	if (flags && !handle) {

  		/* Direct IO write... */

  		if (map.m_len > DIO_MAX_BLOCKS)
  			map.m_len = DIO_MAX_BLOCKS;
  		dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);

  		handle = ext4_journal_start(inode, dio_credits);

  		if (IS_ERR(handle)) {

  			ret = PTR_ERR(handle);

  			return ret;

  		}

  		started = 1;

  	}

  	ret = ext4_map_blocks(handle, inode, &map, flags);

  	if (ret > 0) {

  		map_bh(bh, inode->i_sb, map.m_pblk);
  		bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
  		bh->b_size = inode->i_sb->s_blocksize * map.m_len;

  		ret = 0;

  	}

  	if (started)
  		ext4_journal_stop(handle);

  	return ret;
  }

  int ext4_get_block(struct inode *inode, sector_t iblock,
  		   struct buffer_head *bh, int create)
  {
  	return _ext4_get_block(inode, iblock, bh,
  			       create ? EXT4_GET_BLOCKS_CREATE : 0);
  }

  /*
   * `handle' can be NULL if create is zero
   */

  struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,

  				ext4_lblk_t block, int create, int *errp)

  {

  	struct ext4_map_blocks map;
  	struct buffer_head *bh;

  	int fatal = 0, err;
  
  	J_ASSERT(handle != NULL || create == 0);

  	map.m_lblk = block;
  	map.m_len = 1;
  	err = ext4_map_blocks(handle, inode, &map,
  			      create ? EXT4_GET_BLOCKS_CREATE : 0);

  	if (err < 0)
  		*errp = err;
  	if (err <= 0)
  		return NULL;
  	*errp = 0;
  
  	bh = sb_getblk(inode->i_sb, map.m_pblk);
  	if (!bh) {
  		*errp = -EIO;
  		return NULL;

  	}

  	if (map.m_flags & EXT4_MAP_NEW) {
  		J_ASSERT(create != 0);
  		J_ASSERT(handle != NULL);

  		/*
  		 * Now that we do not always journal data, we should
  		 * keep in mind whether this should always journal the
  		 * new buffer as metadata.  For now, regular file
  		 * writes use ext4_get_block instead, so it's not a
  		 * problem.
  		 */
  		lock_buffer(bh);
  		BUFFER_TRACE(bh, "call get_create_access");
  		fatal = ext4_journal_get_create_access(handle, bh);
  		if (!fatal && !buffer_uptodate(bh)) {
  			memset(bh->b_data, 0, inode->i_sb->s_blocksize);
  			set_buffer_uptodate(bh);

  		}

  		unlock_buffer(bh);
  		BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
  		err = ext4_handle_dirty_metadata(handle, inode, bh);
  		if (!fatal)
  			fatal = err;
  	} else {
  		BUFFER_TRACE(bh, "not a new buffer");

  	}

  	if (fatal) {
  		*errp = fatal;
  		brelse(bh);
  		bh = NULL;
  	}
  	return bh;

  }

  struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,

  			       ext4_lblk_t block, int create, int *err)

  {

  	struct buffer_head *bh;

  	bh = ext4_getblk(handle, inode, block, create, err);

  	if (!bh)
  		return bh;
  	if (buffer_uptodate(bh))
  		return bh;

  	ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh);

  	wait_on_buffer(bh);
  	if (buffer_uptodate(bh))
  		return bh;
  	put_bh(bh);
  	*err = -EIO;
  	return NULL;
  }

  static int walk_page_buffers(handle_t *handle,
  			     struct buffer_head *head,
  			     unsigned from,
  			     unsigned to,
  			     int *partial,
  			     int (*fn)(handle_t *handle,
  				       struct buffer_head *bh))

  {
  	struct buffer_head *bh;
  	unsigned block_start, block_end;
  	unsigned blocksize = head->b_size;
  	int err, ret = 0;
  	struct buffer_head *next;

  	for (bh = head, block_start = 0;
  	     ret == 0 && (bh != head || !block_start);

  	     block_start = block_end, bh = next) {

  		next = bh->b_this_page;
  		block_end = block_start + blocksize;
  		if (block_end <= from || block_start >= to) {
  			if (partial && !buffer_uptodate(bh))
  				*partial = 1;
  			continue;
  		}
  		err = (*fn)(handle, bh);
  		if (!ret)
  			ret = err;
  	}
  	return ret;
  }
  
  /*
   * To preserve ordering, it is essential that the hole instantiation and
   * the data write be encapsulated in a single transaction.  We cannot

   * close off a transaction and start a new one between the ext4_get_block()

   * and the commit_write().  So doing the jbd2_journal_start at the start of

   * prepare_write() is the right place.
   *

   * Also, this function can nest inside ext4_writepage() ->
   * block_write_full_page(). In that case, we *know* that ext4_writepage()

   * has generated enough buffer credits to do the whole page.  So we won't
   * block on the journal in that case, which is good, because the caller may
   * be PF_MEMALLOC.
   *

   * By accident, ext4 can be reentered when a transaction is open via

   * quota file writes.  If we were to commit the transaction while thus
   * reentered, there can be a deadlock - we would be holding a quota
   * lock, and the commit would never complete if another thread had a
   * transaction open and was blocking on the quota lock - a ranking
   * violation.
   *

   * So what we do is to rely on the fact that jbd2_journal_stop/journal_start

   * will _not_ run commit under these circumstances because handle->h_ref
   * is elevated.  We'll still have enough credits for the tiny quotafile
   * write.
   */
  static int do_journal_get_write_access(handle_t *handle,

  				       struct buffer_head *bh)

  {

  	int dirty = buffer_dirty(bh);
  	int ret;

  	if (!buffer_mapped(bh) || buffer_freed(bh))
  		return 0;

  	/*

  	 * __block_write_begin() could have dirtied some buffers. Clean

  	 * the dirty bit as jbd2_journal_get_write_access() could complain
  	 * otherwise about fs integrity issues. Setting of the dirty bit

  	 * by __block_write_begin() isn't a real problem here as we clear

  	 * the bit before releasing a page lock and thus writeback cannot
  	 * ever write the buffer.
  	 */
  	if (dirty)
  		clear_buffer_dirty(bh);
  	ret = ext4_journal_get_write_access(handle, bh);
  	if (!ret && dirty)
  		ret = ext4_handle_dirty_metadata(handle, NULL, bh);
  	return ret;

  }

  static int ext4_get_block_write(struct inode *inode, sector_t iblock,
  		   struct buffer_head *bh_result, int create);

  static int ext4_write_begin(struct file *file, struct address_space *mapping,

  			    loff_t pos, unsigned len, unsigned flags,
  			    struct page **pagep, void **fsdata)

  {

  	struct inode *inode = mapping->host;

  	int ret, needed_blocks;

  	handle_t *handle;
  	int retries = 0;

  	struct page *page;

  	pgoff_t index;

  	unsigned from, to;

  	trace_ext4_write_begin(inode, pos, len, flags);

  	/*
  	 * Reserve one block more for addition to orphan list in case
  	 * we allocate blocks but write fails for some reason
  	 */
  	needed_blocks = ext4_writepage_trans_blocks(inode) + 1;

  	index = pos >> PAGE_CACHE_SHIFT;

  	from = pos & (PAGE_CACHE_SIZE - 1);
  	to = from + len;

  
  retry:

  	handle = ext4_journal_start(inode, needed_blocks);
  	if (IS_ERR(handle)) {
  		ret = PTR_ERR(handle);
  		goto out;

  	}

  	/* We cannot recurse into the filesystem as the transaction is already
  	 * started */
  	flags |= AOP_FLAG_NOFS;

  	page = grab_cache_page_write_begin(mapping, index, flags);

  	if (!page) {
  		ext4_journal_stop(handle);
  		ret = -ENOMEM;
  		goto out;
  	}
  	*pagep = page;

  	if (ext4_should_dioread_nolock(inode))

  		ret = __block_write_begin(page, pos, len, ext4_get_block_write);

  	else

  		ret = __block_write_begin(page, pos, len, ext4_get_block);

  
  	if (!ret && ext4_should_journal_data(inode)) {

  		ret = walk_page_buffers(handle, page_buffers(page),
  				from, to, NULL, do_journal_get_write_access);
  	}

  
  	if (ret) {

  		unlock_page(page);

  		page_cache_release(page);

  		/*

  		 * __block_write_begin may have instantiated a few blocks

  		 * outside i_size.  Trim these off again. Don't need
  		 * i_size_read because we hold i_mutex.

  		 *
  		 * Add inode to orphan list in case we crash before
  		 * truncate finishes

  		 */

  		if (pos + len > inode->i_size && ext4_can_truncate(inode))

  			ext4_orphan_add(handle, inode);
  
  		ext4_journal_stop(handle);
  		if (pos + len > inode->i_size) {

  			ext4_truncate_failed_write(inode);

  			/*

  			 * If truncate failed early the inode might

  			 * still be on the orphan list; we need to
  			 * make sure the inode is removed from the
  			 * orphan list in that case.
  			 */
  			if (inode->i_nlink)
  				ext4_orphan_del(NULL, inode);
  		}

  	}

  	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))

  		goto retry;

  out:

  	return ret;
  }

  /* For write_end() in data=journal mode */
  static int write_end_fn(handle_t *handle, struct buffer_head *bh)

  {
  	if (!buffer_mapped(bh) || buffer_freed(bh))
  		return 0;
  	set_buffer_uptodate(bh);

  	return ext4_handle_dirty_metadata(handle, NULL, bh);

  }

  static int ext4_generic_write_end(struct file *file,

  				  struct address_space *mapping,
  				  loff_t pos, unsigned len, unsigned copied,
  				  struct page *page, void *fsdata)

  {
  	int i_size_changed = 0;
  	struct inode *inode = mapping->host;
  	handle_t *handle = ext4_journal_current_handle();
  
  	copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
  
  	/*
  	 * No need to use i_size_read() here, the i_size
  	 * cannot change under us because we hold i_mutex.
  	 *
  	 * But it's important to update i_size while still holding page lock:
  	 * page writeout could otherwise come in and zero beyond i_size.
  	 */
  	if (pos + copied > inode->i_size) {
  		i_size_write(inode, pos + copied);
  		i_size_changed = 1;
  	}
  
  	if (pos + copied >  EXT4_I(inode)->i_disksize) {
  		/* We need to mark inode dirty even if
  		 * new_i_size is less that inode->i_size
  		 * bu greater than i_disksize.(hint delalloc)
  		 */
  		ext4_update_i_disksize(inode, (pos + copied));
  		i_size_changed = 1;
  	}
  	unlock_page(page);
  	page_cache_release(page);
  
  	/*
  	 * Don't mark the inode dirty under page lock. First, it unnecessarily
  	 * makes the holding time of page lock longer. Second, it forces lock
  	 * ordering of page lock and transaction start for journaling
  	 * filesystems.
  	 */
  	if (i_size_changed)
  		ext4_mark_inode_dirty(handle, inode);
  
  	return copied;
  }

  /*
   * We need to pick up the new inode size which generic_commit_write gave us
   * `file' can be NULL - eg, when called from page_symlink().
   *

   * ext4 never places buffers on inode->i_mapping->private_list.  metadata

   * buffers are managed internally.
   */

  static int ext4_ordered_write_end(struct file *file,

  				  struct address_space *mapping,
  				  loff_t pos, unsigned len, unsigned copied,
  				  struct page *page, void *fsdata)

  {

  	handle_t *handle = ext4_journal_current_handle();

  	struct inode *inode = mapping->host;

  	int ret = 0, ret2;

  	trace_ext4_ordered_write_end(inode, pos, len, copied);

  	ret = ext4_jbd2_file_inode(handle, inode);

  
  	if (ret == 0) {

  		ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,

  							page, fsdata);

  		copied = ret2;

  		if (pos + len > inode->i_size && ext4_can_truncate(inode))

  			/* if we have allocated more blocks and copied
  			 * less. We will have blocks allocated outside
  			 * inode->i_size. So truncate them
  			 */
  			ext4_orphan_add(handle, inode);

  		if (ret2 < 0)
  			ret = ret2;

  	} else {
  		unlock_page(page);
  		page_cache_release(page);

  	}

  	ret2 = ext4_journal_stop(handle);

  	if (!ret)
  		ret = ret2;

  	if (pos + len > inode->i_size) {

  		ext4_truncate_failed_write(inode);

  		/*

  		 * If truncate failed early the inode might still be

  		 * on the orphan list; we need to make sure the inode
  		 * is removed from the orphan list in that case.
  		 */
  		if (inode->i_nlink)
  			ext4_orphan_del(NULL, inode);
  	}

  	return ret ? ret : copied;

  }

  static int ext4_writeback_write_end(struct file *file,

  				    struct address_space *mapping,
  				    loff_t pos, unsigned len, unsigned copied,
  				    struct page *page, void *fsdata)

  {

  	handle_t *handle = ext4_journal_current_handle();

  	struct inode *inode = mapping->host;

  	int ret = 0, ret2;

  	trace_ext4_writeback_write_end(inode, pos, len, copied);

  	ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,

  							page, fsdata);

  	copied = ret2;

  	if (pos + len > inode->i_size && ext4_can_truncate(inode))

  		/* if we have allocated more blocks and copied
  		 * less. We will have blocks allocated outside
  		 * inode->i_size. So truncate them
  		 */
  		ext4_orphan_add(handle, inode);

  	if (ret2 < 0)
  		ret = ret2;

  	ret2 = ext4_journal_stop(handle);

  	if (!ret)
  		ret = ret2;

  	if (pos + len > inode->i_size) {

  		ext4_truncate_failed_write(inode);

  		/*

  		 * If truncate failed early the inode might still be

  		 * on the orphan list; we need to make sure the inode
  		 * is removed from the orphan list in that case.
  		 */
  		if (inode->i_nlink)
  			ext4_orphan_del(NULL, inode);
  	}

  	return ret ? ret : copied;

  }

  static int ext4_journalled_write_end(struct file *file,

  				     struct address_space *mapping,
  				     loff_t pos, unsigned len, unsigned copied,
  				     struct page *page, void *fsdata)

  {

  	handle_t *handle = ext4_journal_current_handle();

  	struct inode *inode = mapping->host;

  	int ret = 0, ret2;
  	int partial = 0;

  	unsigned from, to;

  	loff_t new_i_size;

  	trace_ext4_journalled_write_end(inode, pos, len, copied);

  	from = pos & (PAGE_CACHE_SIZE - 1);
  	to = from + len;

  	BUG_ON(!ext4_handle_valid(handle));

  	if (copied < len) {
  		if (!PageUptodate(page))
  			copied = 0;
  		page_zero_new_buffers(page, from+copied, to);
  	}

  
  	ret = walk_page_buffers(handle, page_buffers(page), from,

  				to, &partial, write_end_fn);

  	if (!partial)
  		SetPageUptodate(page);

  	new_i_size = pos + copied;
  	if (new_i_size > inode->i_size)

  		i_size_write(inode, pos+copied);

  	ext4_set_inode_state(inode, EXT4_STATE_JDATA);

  	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;

  	if (new_i_size > EXT4_I(inode)->i_disksize) {
  		ext4_update_i_disksize(inode, new_i_size);

  		ret2 = ext4_mark_inode_dirty(handle, inode);

  		if (!ret)
  			ret = ret2;
  	}

  	unlock_page(page);

  	page_cache_release(page);

  	if (pos + len > inode->i_size && ext4_can_truncate(inode))

  		/* if we have allocated more blocks and copied
  		 * less. We will have blocks allocated outside
  		 * inode->i_size. So truncate them
  		 */
  		ext4_orphan_add(handle, inode);

  	ret2 = ext4_journal_stop(handle);

  	if (!ret)
  		ret = ret2;

  	if (pos + len > inode->i_size) {

  		ext4_truncate_failed_write(inode);

  		/*

  		 * If truncate failed early the inode might still be

  		 * on the orphan list; we need to make sure the inode
  		 * is removed from the orphan list in that case.
  		 */
  		if (inode->i_nlink)
  			ext4_orphan_del(NULL, inode);
  	}

  
  	return ret ? ret : copied;

  }

  /*

   * Reserve a single cluster located at lblock

   */

  static 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 int md_needed;

  	int ret;

  
  	/*
  	 * recalculate the amount of metadata blocks to reserve
  	 * in order to allocate nrblocks
  	 * worse case is one extent per block
  	 */

  repeat:

  	spin_lock(&ei->i_block_reservation_lock);

  	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);

  	/*

  	 * We will charge metadata quota at writeout time; this saves
  	 * 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, EXT4_C2B(sbi, 1));

  	if (ret)
  		return ret;

  	/*
  	 * We do still charge estimated metadata to the sb though;
  	 * we cannot afford to run out of free blocks.
  	 */

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

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

  		if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
  			yield();
  			goto repeat;
  		}

  		return -ENOSPC;
  	}

  	spin_lock(&ei->i_block_reservation_lock);

  	ei->i_reserved_data_blocks++;

  	ei->i_reserved_meta_blocks += md_needed;
  	spin_unlock(&ei->i_block_reservation_lock);

  	return 0;       /* success */
  }

  static void ext4_da_release_space(struct inode *inode, int to_free)

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

  	struct ext4_inode_info *ei = EXT4_I(inode);

  	if (!to_free)
  		return;		/* Nothing to release, exit */

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

  	trace_ext4_da_release_space(inode, to_free);

  	if (unlikely(to_free > ei->i_reserved_data_blocks)) {

  		/*

  		 * if there aren't enough reserved blocks, then the
  		 * counter is messed up somewhere.  Since this
  		 * function is called from invalidate page, it's
  		 * harmless to return without any action.

  		 */

  		ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: "
  			 "ino %lu, to_free %d with only %d reserved "
  			 "data blocks
  ", inode->i_ino, to_free,
  			 ei->i_reserved_data_blocks);
  		WARN_ON(1);
  		to_free = ei->i_reserved_data_blocks;

  	}

  	ei->i_reserved_data_blocks -= to_free;

  	if (ei->i_reserved_data_blocks == 0) {
  		/*
  		 * 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);

  		ei->i_reserved_meta_blocks = 0;

  		ei->i_da_metadata_calc_len = 0;

  	}

  	/* update fs dirty data blocks counter */

  	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);

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

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

  }
  
  static void ext4_da_page_release_reservation(struct page *page,

  					     unsigned long offset)

  {
  	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;
  	do {
  		unsigned int next_off = curr_off + bh->b_size;
  
  		if ((offset <= curr_off) && (buffer_delay(bh))) {
  			to_release++;
  			clear_buffer_delay(bh);

  			clear_buffer_da_mapped(bh);

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

  
  	/* 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--;
  	}

  }

  
  /*

   * Delayed allocation stuff
   */

  /*
   * mpage_da_submit_io - walks through extent of pages and try to write

   * them with writepage() call back

   *
   * @mpd->inode: inode
   * @mpd->first_page: first page of the extent
   * @mpd->next_page: page after the last page of the extent

   *
   * By the time mpage_da_submit_io() is called we expect all blocks
   * to be allocated. this may be wrong if allocation failed.
   *
   * As pages are already locked by write_cache_pages(), we can't use it
   */

  static int mpage_da_submit_io(struct mpage_da_data *mpd,
  			      struct ext4_map_blocks *map)

  {

  	struct pagevec pvec;
  	unsigned long index, end;
  	int ret = 0, err, nr_pages, i;
  	struct inode *inode = mpd->inode;
  	struct address_space *mapping = inode->i_mapping;

  	loff_t size = i_size_read(inode);

  	unsigned int len, block_start;
  	struct buffer_head *bh, *page_bufs = NULL;

  	int journal_data = ext4_should_journal_data(inode);

  	sector_t pblock = 0, cur_logical = 0;

  	struct ext4_io_submit io_submit;

  
  	BUG_ON(mpd->next_page <= mpd->first_page);

  	memset(&io_submit, 0, sizeof(io_submit));

  	/*
  	 * We need to start from the first_page to the next_page - 1
  	 * to make sure we also write the mapped dirty buffer_heads.

  	 * If we look at mpd->b_blocknr we would only be looking

  	 * at the currently mapped buffer_heads.
  	 */

  	index = mpd->first_page;
  	end = mpd->next_page - 1;

  	pagevec_init(&pvec, 0);

  	while (index <= end) {

  		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);

  		if (nr_pages == 0)
  			break;
  		for (i = 0; i < nr_pages; i++) {

  			int commit_write = 0, skip_page = 0;

  			struct page *page = pvec.pages[i];

  			index = page->index;
  			if (index > end)
  				break;

  
  			if (index == size >> PAGE_CACHE_SHIFT)
  				len = size & ~PAGE_CACHE_MASK;
  			else
  				len = PAGE_CACHE_SIZE;

  			if (map) {
  				cur_logical = index << (PAGE_CACHE_SHIFT -
  							inode->i_blkbits);
  				pblock = map->m_pblk + (cur_logical -
  							map->m_lblk);
  			}

  			index++;
  
  			BUG_ON(!PageLocked(page));
  			BUG_ON(PageWriteback(page));

  			/*

  			 * If the page does not have buffers (for
  			 * whatever reason), try to create them using

  			 * __block_write_begin.  If this fails,

  			 * skip the page and move on.

  			 */

  			if (!page_has_buffers(page)) {

  				if (__block_write_begin(page, 0, len,

  						noalloc_get_block_write)) {

  				skip_page:

  					unlock_page(page);
  					continue;
  				}
  				commit_write = 1;
  			}

  			bh = page_bufs = page_buffers(page);
  			block_start = 0;

  			do {

  				if (!bh)

  					goto skip_page;

  				if (map && (cur_logical >= map->m_lblk) &&
  				    (cur_logical <= (map->m_lblk +
  						     (map->m_len - 1)))) {

  					if (buffer_delay(bh)) {
  						clear_buffer_delay(bh);
  						bh->b_blocknr = pblock;

  					}

  					if (buffer_da_mapped(bh))
  						clear_buffer_da_mapped(bh);

  					if (buffer_unwritten(bh) ||
  					    buffer_mapped(bh))
  						BUG_ON(bh->b_blocknr != pblock);
  					if (map->m_flags & EXT4_MAP_UNINIT)
  						set_buffer_uninit(bh);
  					clear_buffer_unwritten(bh);
  				}

  				/*
  				 * skip page if block allocation undone and
  				 * block is dirty
  				 */
  				if (ext4_bh_delay_or_unwritten(NULL, bh))

  					skip_page = 1;

  				bh = bh->b_this_page;
  				block_start += bh->b_size;

  				cur_logical++;
  				pblock++;

  			} while (bh != page_bufs);

  			if (skip_page)
  				goto skip_page;

  
  			if (commit_write)
  				/* mark the buffer_heads as dirty & uptodate */
  				block_commit_write(page, 0, len);

  			clear_page_dirty_for_io(page);

  			/*
  			 * Delalloc doesn't support data journalling,
  			 * but eventually maybe we'll lift this
  			 * restriction.
  			 */
  			if (unlikely(journal_data && PageChecked(page)))

  				err = __ext4_journalled_writepage(page, len);

  			else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT))

  				err = ext4_bio_write_page(&io_submit, page,
  							  len, mpd->wbc);

  			else if (buffer_uninit(page_bufs)) {
  				ext4_set_bh_endio(page_bufs, inode);
  				err = block_write_full_page_endio(page,
  					noalloc_get_block_write,
  					mpd->wbc, ext4_end_io_buffer_write);
  			} else

  				err = block_write_full_page(page,
  					noalloc_get_block_write, mpd->wbc);

  
  			if (!err)

  				mpd->pages_written++;

  			/*
  			 * In error case, we have to continue because
  			 * remaining pages are still locked

  			 */
  			if (ret == 0)
  				ret = err;

  		}
  		pagevec_release(&pvec);
  	}

  	ext4_io_submit(&io_submit);

  	return ret;

  }

  static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)

  {
  	int nr_pages, i;
  	pgoff_t index, end;
  	struct pagevec pvec;
  	struct inode *inode = mpd->inode;
  	struct address_space *mapping = inode->i_mapping;

  	index = mpd->first_page;
  	end   = mpd->next_page - 1;

  	while (index <= end) {
  		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
  		if (nr_pages == 0)
  			break;
  		for (i = 0; i < nr_pages; i++) {
  			struct page *page = pvec.pages[i];

  			if (page->index > end)

  				break;

  			BUG_ON(!PageLocked(page));
  			BUG_ON(PageWriteback(page));
  			block_invalidatepage(page, 0);
  			ClearPageUptodate(page);
  			unlock_page(page);
  		}

  		index = pvec.pages[nr_pages - 1]->index + 1;
  		pagevec_release(&pvec);

  	}
  	return;
  }

  static void ext4_print_free_blocks(struct inode *inode)
  {
  	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

  	printk(KERN_CRIT "Total free blocks count %lld
  ",

  	       EXT4_C2B(EXT4_SB(inode->i_sb),
  			ext4_count_free_clusters(inode->i_sb)));

  	printk(KERN_CRIT "Free/Dirty block details
  ");
  	printk(KERN_CRIT "free_blocks=%lld
  ",

  	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
  		percpu_counter_sum(&sbi->s_freeclusters_counter)));

  	printk(KERN_CRIT "dirty_blocks=%lld
  ",

  	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
  		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));

  	printk(KERN_CRIT "Block reservation details
  ");
  	printk(KERN_CRIT "i_reserved_data_blocks=%u
  ",
  	       EXT4_I(inode)->i_reserved_data_blocks);
  	printk(KERN_CRIT "i_reserved_meta_blocks=%u
  ",
  	       EXT4_I(inode)->i_reserved_meta_blocks);

  	return;
  }

  /*

   * mpage_da_map_and_submit - go through given space, map them
   *       if necessary, and then submit them for I/O

   *

   * @mpd - bh describing space

   *
   * The function skips space we know is already mapped to disk blocks.
   *

   */

  static void mpage_da_map_and_submit(struct mpage_da_data *mpd)

  {

  	int err, blks, get_blocks_flags;

  	struct ext4_map_blocks map, *mapp = NULL;

  	sector_t next = mpd->b_blocknr;
  	unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
  	loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
  	handle_t *handle = NULL;

  
  	/*

  	 * If the blocks are mapped already, or we couldn't accumulate
  	 * any blocks, then proceed immediately to the submission stage.

  	 */

  	if ((mpd->b_size == 0) ||
  	    ((mpd->b_state  & (1 << BH_Mapped)) &&
  	     !(mpd->b_state & (1 << BH_Delay)) &&
  	     !(mpd->b_state & (1 << BH_Unwritten))))
  		goto submit_io;

  
  	handle = ext4_journal_current_handle();
  	BUG_ON(!handle);

  	/*

  	 * Call ext4_map_blocks() to allocate any delayed allocation

  	 * blocks, or to convert an uninitialized extent to be
  	 * initialized (in the case where we have written into
  	 * one or more preallocated blocks).
  	 *
  	 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
  	 * indicate that we are on the delayed allocation path.  This
  	 * affects functions in many different parts of the allocation
  	 * call path.  This flag exists primarily because we don't

  	 * want to change *many* call functions, so ext4_map_blocks()

  	 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the

  	 * inode's allocation semaphore is taken.
  	 *
  	 * If the blocks in questions were delalloc blocks, set
  	 * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
  	 * variables are updated after the blocks have been allocated.

  	 */

  	map.m_lblk = next;
  	map.m_len = max_blocks;

  	get_blocks_flags = EXT4_GET_BLOCKS_CREATE;

  	if (ext4_should_dioread_nolock(mpd->inode))
  		get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;

  	if (mpd->b_state & (1 << BH_Delay))

  		get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;

  	blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);

  	if (blks < 0) {

  		struct super_block *sb = mpd->inode->i_sb;

  		err = blks;

  		/*

  		 * If get block returns EAGAIN or ENOSPC and there

  		 * appears to be free blocks we will just let
  		 * mpage_da_submit_io() unlock all of the pages.

  		 */
  		if (err == -EAGAIN)

  			goto submit_io;