if (new_transaction) kfree(new_transaction); 
kfree(new_transaction); 
static int start_this_handle(journal_t *journal, handle_t *handle){	transaction_t *transaction;	int needed;	int nblocks = handle->h_buffer_credits;	transaction_t *new_transaction = NULL;	int ret = 0;	if (nblocks > journal->j_max_transaction_buffers) {		printk(KERN_ERR "JBD: %s wants too many credits (%d > %d)\n",		       current->comm, nblocks,		       journal->j_max_transaction_buffers);		ret = -ENOSPC;		goto out;	}alloc_transaction:	if (!journal->j_running_transaction) {		new_transaction = jbd_kmalloc(sizeof(*new_transaction),						GFP_NOFS);		if (!new_transaction) {			ret = -ENOMEM;			goto out;		}		memset(new_transaction, 0, sizeof(*new_transaction));	}	jbd_debug(3, "New handle %p going live.\n", handle);repeat:	/*	 * We need to hold j_state_lock until t_updates has been incremented,	 * for proper journal barrier handling	 */	spin_lock(&journal->j_state_lock);repeat_locked:	if (is_journal_aborted(journal) ||	    (journal->j_errno != 0 && !(journal->j_flags & JFS_ACK_ERR))) {		spin_unlock(&journal->j_state_lock);		ret = -EROFS; 		goto out;	}	/* Wait on the journal's transaction barrier if necessary */	if (journal->j_barrier_count) {		spin_unlock(&journal->j_state_lock);		wait_event(journal->j_wait_transaction_locked,				journal->j_barrier_count == 0);		goto repeat;	}	if (!journal->j_running_transaction) {		if (!new_transaction) {			spin_unlock(&journal->j_state_lock);			goto alloc_transaction;		}		get_transaction(journal, new_transaction);		new_transaction = NULL;	}	transaction = journal->j_running_transaction;	/*	 * If the current transaction is locked down for commit, wait for the	 * lock to be released.	 */	if (transaction->t_state == T_LOCKED) {		DEFINE_WAIT(wait);		prepare_to_wait(&journal->j_wait_transaction_locked,					&wait, TASK_UNINTERRUPTIBLE);		spin_unlock(&journal->j_state_lock);		schedule();		finish_wait(&journal->j_wait_transaction_locked, &wait);		goto repeat;	}	/*	 * If there is not enough space left in the log to write all potential	 * buffers requested by this operation, we need to stall pending a log	 * checkpoint to free some more log space.	 */	spin_lock(&transaction->t_handle_lock);	needed = transaction->t_outstanding_credits + nblocks;	if (needed > journal->j_max_transaction_buffers) {		/*		 * If the current transaction is already too large, then start		 * to commit it: we can then go back and attach this handle to		 * a new transaction.		 */		DEFINE_WAIT(wait);		jbd_debug(2, "Handle %p starting new commit...\n", handle);		spin_unlock(&transaction->t_handle_lock);		prepare_to_wait(&journal->j_wait_transaction_locked, &wait,				TASK_UNINTERRUPTIBLE);		__log_start_commit(journal, transaction->t_tid);		spin_unlock(&journal->j_state_lock);		schedule();		finish_wait(&journal->j_wait_transaction_locked, &wait);		goto repeat;	}	/* 	 * The commit code assumes that it can get enough log space	 * without forcing a checkpoint.  This is *critical* for	 * correctness: a checkpoint of a buffer which is also	 * associated with a committing transaction creates a deadlock,	 * so commit simply cannot force through checkpoints.	 *	 * We must therefore ensure the necessary space in the journal	 * *before* starting to dirty potentially checkpointed buffers	 * in the new transaction. 	 *	 * The worst part is, any transaction currently committing can	 * reduce the free space arbitrarily.  Be careful to account for	 * those buffers when checkpointing.	 */	/*	 * @@@ AKPM: This seems rather over-defensive.  We're giving commit	 * a _lot_ of headroom: 1/4 of the journal plus the size of	 * the committing transaction.  Really, we only need to give it	 * committing_transaction->t_outstanding_credits plus "enough" for	 * the log control blocks.	 * Also, this test is inconsitent with the matching one in	 * journal_extend().	 */	if (__log_space_left(journal) < jbd_space_needed(journal)) {		jbd_debug(2, "Handle %p waiting for checkpoint...\n", handle);		spin_unlock(&transaction->t_handle_lock);		__log_wait_for_space(journal);		goto repeat_locked;	}	/* OK, account for the buffers that this operation expects to	 * use and add the handle to the running transaction. */	handle->h_transaction = transaction;	transaction->t_outstanding_credits += nblocks;	transaction->t_updates++;	transaction->t_handle_count++;	jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n",		  handle, nblocks, transaction->t_outstanding_credits,		  __log_space_left(journal));	spin_unlock(&transaction->t_handle_lock);	spin_unlock(&journal->j_state_lock);out:	if (new_transaction)		kfree(new_transaction);	return ret;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/f99d49adf527fa6f7a9c42257fa76bca6b8df1e3/transaction.c/clean/fs/jbd/transaction.c