[PATCH] ext3: cleanups and WARN_ON()

/*

 * Test whether an inode is a fast symlink.

 */

static inline int ext3_inode_is_fast_symlink(struct inode *inode)

static int ext3_inode_is_fast_symlink(struct inode *inode)

{

	int ea_blocks = EXT3_I(inode)->i_file_acl ?

		(inode->i_sb->s_blocksize >> 9) : 0;

	return (S_ISLNK(inode->i_mode) &&

		inode->i_blocks - ea_blocks == 0);

	return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);

}

/* The ext3 forget function must perform a revoke if we are freeing data

/*

 * The ext3 forget function must perform a revoke if we are freeing data

 * which has been journaled.  Metadata (eg. indirect blocks) must be

 * revoked in all cases. 

 *

 * but there may still be a record of it in the journal, and that record

 * still needs to be revoked.

 */

int ext3_forget(handle_t *handle, int is_metadata,

		       struct inode *inode, struct buffer_head *bh,

		       int blocknr)

int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,

			struct buffer_head *bh, int blocknr)

{

	int err;

}

/*

 * Work out how many blocks we need to progress with the next chunk of a

 * Work out how many blocks we need to proceed with the next chunk of a

 * truncate transaction.

 */

static unsigned long blocks_for_truncate(struct inode *inode) 

{

	unsigned long needed;

 * extend fails, we need to propagate the failure up and restart the

 * transaction in the top-level truncate loop. --sct 

 */

static handle_t *start_transaction(struct inode *inode) 

{

	handle_t *result;

	handle = start_transaction(inode);

	if (IS_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. */

		/*

		 * 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.

		 */

		ext3_orphan_del(NULL, inode);

		goto no_delete;

	}

	p->bh = bh;

}

static inline int verify_chain(Indirect *from, Indirect *to)

static int verify_chain(Indirect *from, Indirect *to)

{

	while (from <= to && from->key == *from->p)

		from++;

 *

 *	Caller must make sure that @ind is valid and will stay that way.

 */

static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)

{

	struct ext3_inode_info *ei = EXT3_I(inode);

	unsigned long colour;

	/* Try to find previous block */

	for (p = ind->p - 1; p >= start; p--)

	for (p = ind->p - 1; p >= start; p--) {

		if (*p)

			return le32_to_cpu(*p);

	}

	/* No such thing, so let's try location of indirect block */

	if (ind->bh)

		return ind->bh->b_blocknr;

	/*

	 * It is going to be refered from inode itself? OK, just put it into

	 * the same cylinder group then.

	 * It is going to be referred to from the inode itself? OK, just put it

	 * into the same cylinder group then.

	 */

	bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +

		le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);

static unsigned long ext3_find_goal(struct inode *inode, long block,

		Indirect chain[4], Indirect *partial)

{

	struct ext3_block_alloc_info *block_i =  EXT3_I(inode)->i_block_alloc_info;

	struct ext3_block_alloc_info *block_i;

	block_i =  EXT3_I(inode)->i_block_alloc_info;

	/*

	 * try the heuristic for sequential allocation,

	return ext3_find_near(inode, partial);

}

/**

 *	ext3_blks_to_allocate: Look up the block map and count the number

 *	of direct blocks need to be allocated for the given branch.

 *	return the total number of blocks to be allocate, including the

 *	direct and indirect blocks.

 */

static int

ext3_blks_to_allocate(Indirect * branch, int k, unsigned long blks,

static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,

		int blocks_to_boundary)

{

	unsigned long count = 0;

	 * then it's clear blocks on that path have not allocated

	 */

	if (k > 0) {

		/* right now don't hanel cross boundary allocation */

		/* right now we don't handle cross boundary allocation */

		if (blks < blocks_to_boundary + 1)

			count += blks;

		else

 *	ext3_alloc_block() (normally -ENOSPC). Otherwise we set the chain

 *	as described above and return 0.

 */

static int ext3_alloc_branch(handle_t *handle, struct inode *inode,

			int indirect_blks, int *blks, unsigned long goal,

			int *offsets, Indirect *branch)

 * inode (->i_blocks, etc.). In case of success we end up with the full

 * chain to new block and return 0.

 */

static int ext3_splice_branch(handle_t *handle, struct inode *inode, long block,

			      Indirect *where, int num, int blks)

static int ext3_splice_branch(handle_t *handle, struct inode *inode,

			long block, Indirect *where, int num, int blks)

{

	int i;

	int err = 0;

	struct ext3_block_alloc_info *block_i = EXT3_I(inode)->i_block_alloc_info;

	struct ext3_block_alloc_info *block_i;

	unsigned long current_block;

	block_i = EXT3_I(inode)->i_block_alloc_info;

	/*

	 * If we're splicing into a [td]indirect block (as opposed to the

	 * inode) then we need to get write access to the [td]indirect block

	/* That's it */

	*where->p = where->key;

	/* update host bufferhead or inode to point to

	 * more just allocated direct blocks blocks */

	/*

	 * Update the host buffer_head or inode to point to more just allocated

	 * direct blocks blocks

	 */

	if (num == 0 && blks > 1) {

		current_block = le32_to_cpu(where->key + 1);

		for (i = 1; i < blks; i++)

	 */

	if (block_i) {

		block_i->last_alloc_logical_block = block + blks - 1;

		block_i->last_alloc_physical_block = le32_to_cpu(where[num].key + blks - 1);

		block_i->last_alloc_physical_block =

				le32_to_cpu(where[num].key + blks - 1);

	}

	/* We are done with atomic stuff, now do the rest of housekeeping */

	/* had we spliced it onto indirect block? */

	if (where->bh) {

		/*

		 * akpm: If we spliced it onto an indirect block, we haven't

		 * If we spliced it onto an indirect block, we haven't

		 * altered the inode.  Note however that if it is being spliced

		 * onto an indirect block at the very end of the file (the

		 * file is growing) then we *will* alter the inode to reflect

 * allocations is needed - we simply release blocks and do not touch anything

 * reachable from inode.

 *

 * akpm: `handle' can be NULL if create == 0.

 * `handle' can be NULL if create == 0.

 *

 * The BKL may not be held on entry here.  Be sure to take it early.

 * return > 0, # of blocks mapped or allocated.

 * return = 0, if plain lookup failed.

 * return < 0, error case.

 */

int

ext3_get_blocks_handle(handle_t *handle, struct inode *inode, sector_t iblock,

		unsigned long maxblocks, struct buffer_head *bh_result,

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

		sector_t iblock, unsigned long maxblocks,

		struct buffer_head *bh_result,

		int create, int extend_disksize)

{

	int err = -EIO;

			J_ASSERT(create != 0);

			J_ASSERT(handle != 0);

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

			   ext3_get_block instead, so it's not a

			   problem. */

			/*

			 * 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 ext3_get_block instead, so it's not a

			 * problem.

			 */

			lock_buffer(bh);

			BUFFER_TRACE(bh, "call get_create_access");

			fatal = ext3_journal_get_create_access(handle, bh);

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

{

	return ret;

}

int

ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)

int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)

{

	int err = journal_dirty_data(handle, bh);

	if (err)

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

 * buffers are managed internally.

 */

static int ext3_ordered_commit_write(struct file *file, struct page *page,

			     unsigned from, unsigned to)

{

 *		c) free the subtrees growing from the inode past the @chain[0].

 *			(no partially truncated stuff there).  */

static Indirect *ext3_find_shared(struct inode *inode,

				int depth,

				int offsets[4],

				Indirect chain[4],

				__le32 *top)

static Indirect *ext3_find_shared(struct inode *inode, int depth,

			int offsets[4], Indirect chain[4], __le32 *top)

{

	Indirect *partial, *p;

	int k, err;

	}

	/* Writer: end */

	while(partial > p)

	{

	while(partial > p) {

		brelse(partial->bh);

		partial--;

	}

 * We release `count' blocks on disk, but (last - first) may be greater

 * than `count' because there can be holes in there.

 */

static void

ext3_clear_blocks(handle_t *handle, struct inode *inode, struct buffer_head *bh,

		unsigned long block_to_free, unsigned long count,

		__le32 *first, __le32 *last)

static void ext3_clear_blocks(handle_t *handle, struct inode *inode,

		struct buffer_head *bh, unsigned long block_to_free,

		unsigned long count, __le32 *first, __le32 *last)

{

	__le32 *p;

	if (try_to_extend_transaction(handle, inode)) {

 * that's fine - as long as they are linked from the inode, the post-crash

 * ext3_truncate() run will find them and release them.

 */

void ext3_truncate(struct inode *inode)

{

	handle_t *handle;

	default:

		nr = i_data[EXT3_IND_BLOCK];

		if (nr) {

				ext3_free_branches(handle, inode, NULL,

						   &nr, &nr+1, 1);

			ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);

			i_data[EXT3_IND_BLOCK] = 0;

		}

	case EXT3_IND_BLOCK:

		nr = i_data[EXT3_DIND_BLOCK];

		if (nr) {

				ext3_free_branches(handle, inode, NULL,

						   &nr, &nr+1, 2);

			ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);

			i_data[EXT3_DIND_BLOCK] = 0;

		}

	case EXT3_DIND_BLOCK:

		nr = i_data[EXT3_TIND_BLOCK];

		if (nr) {

				ext3_free_branches(handle, inode, NULL,

						   &nr, &nr+1, 3);

			ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);

			i_data[EXT3_TIND_BLOCK] = 0;

		}

	case EXT3_TIND_BLOCK:

	inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;

	ext3_mark_inode_dirty(handle, inode);

	/* In a multi-transaction truncate, we only make the final

	 * transaction synchronous */

	/*

	 * In a multi-transaction truncate, we only make the final transaction

	 * synchronous

	 */

	if (IS_SYNC(inode))

		handle->h_sync = 1;

out_stop:

	struct ext3_group_desc * gdp;

	if ((ino != EXT3_ROOT_INO &&

		ino != EXT3_JOURNAL_INO &&

		ino != EXT3_RESIZE_INO &&

		ino < EXT3_FIRST_INO(sb)) ||

		ino > le32_to_cpu(

			EXT3_SB(sb)->s_es->s_inodes_count)) {

	if ((ino != EXT3_ROOT_INO && ino != EXT3_JOURNAL_INO &&

		ino != EXT3_RESIZE_INO && ino < EXT3_FIRST_INO(sb)) ||

		ino > le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count)) {

		ext3_error(sb, "ext3_get_inode_block",

			    "bad inode number: %lu", ino);

		return 0;

	}

	block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);

	if (block_group >= EXT3_SB(sb)->s_groups_count) {

		ext3_error (sb, "ext3_get_inode_block",

			    "group >= groups count");

		ext3_error(sb,"ext3_get_inode_block","group >= groups count");

		return 0;

	}

	smp_rmb();

/*

 * akpm: how many blocks doth make a writepage()?

 * How many blocks doth make a writepage()?

 *

 * With N blocks per page, it may be:

 * N data blocks

}

/*

 * akpm: What we do here is to mark the in-core inode as clean

 * with respect to inode dirtiness (it may still be data-dirty).

 * What we do here is to mark the in-core inode as clean with respect to inode

 * dirtiness (it may still be data-dirty).

 * This means that the in-core inode may be reaped by prune_icache

 * without having to perform any I/O.  This is a very good thing,

 * because *any* task may call prune_icache - even ones which

}

/*

 * akpm: ext3_dirty_inode() is called from __mark_inode_dirty()

 * ext3_dirty_inode() is called from __mark_inode_dirty()

 *

 * We're really interested in the case where a file is being extended.

 * i_size has been changed by generic_commit_write() and we thus need

	return;

}

#ifdef AKPM

#if 0

/* 

 * Bind an inode's backing buffer_head into this transaction, to prevent

 * it from being flushed to disk early.  Unlike

 * returns no iloc structure, so the caller needs to repeat the iloc

 * lookup to mark the inode dirty later.

 */

static inline int

ext3_pin_inode(handle_t *handle, struct inode *inode)

static int ext3_pin_inode(handle_t *handle, struct inode *inode)

{

	struct ext3_iloc iloc;