if (frozen_buffer) kfree(frozen_buffer); 
kfree(frozen_buffer); 
do_get_write_access(handle_t *handle, struct journal_head *jh,			int force_copy){	struct buffer_head *bh;	transaction_t *transaction;	journal_t *journal;	int error;	char *frozen_buffer = NULL;	int need_copy = 0;	if (is_handle_aborted(handle))		return -EROFS;	transaction = handle->h_transaction;	journal = transaction->t_journal;	jbd_debug(5, "buffer_head %p, force_copy %d\n", jh, force_copy);	JBUFFER_TRACE(jh, "entry");repeat:	bh = jh2bh(jh);	/* @@@ Need to check for errors here at some point. */	lock_buffer(bh);	jbd_lock_bh_state(bh);	/* We now hold the buffer lock so it is safe to query the buffer	 * state.  Is the buffer dirty? 	 * 	 * If so, there are two possibilities.  The buffer may be	 * non-journaled, and undergoing a quite legitimate writeback.	 * Otherwise, it is journaled, and we don't expect dirty buffers	 * in that state (the buffers should be marked JBD_Dirty	 * instead.)  So either the IO is being done under our own	 * control and this is a bug, or it's a third party IO such as	 * dump(8) (which may leave the buffer scheduled for read ---	 * ie. locked but not dirty) or tune2fs (which may actually have	 * the buffer dirtied, ugh.)  */	if (buffer_dirty(bh)) {		/*		 * First question: is this buffer already part of the current		 * transaction or the existing committing transaction?		 */		if (jh->b_transaction) {			J_ASSERT_JH(jh,				jh->b_transaction == transaction || 				jh->b_transaction ==					journal->j_committing_transaction);			if (jh->b_next_transaction)				J_ASSERT_JH(jh, jh->b_next_transaction ==							transaction);		}		/*		 * In any case we need to clean the dirty flag and we must		 * do it under the buffer lock to be sure we don't race		 * with running write-out.		 */		JBUFFER_TRACE(jh, "Unexpected dirty buffer");		jbd_unexpected_dirty_buffer(jh); 	}	unlock_buffer(bh);	error = -EROFS;	if (is_handle_aborted(handle)) {		jbd_unlock_bh_state(bh);		goto out;	}	error = 0;	/*	 * The buffer is already part of this transaction if b_transaction or	 * b_next_transaction points to it	 */	if (jh->b_transaction == transaction ||	    jh->b_next_transaction == transaction)		goto done;	/*	 * If there is already a copy-out version of this buffer, then we don't	 * need to make another one	 */	if (jh->b_frozen_data) {		JBUFFER_TRACE(jh, "has frozen data");		J_ASSERT_JH(jh, jh->b_next_transaction == NULL);		jh->b_next_transaction = transaction;		goto done;	}	/* Is there data here we need to preserve? */	if (jh->b_transaction && jh->b_transaction != transaction) {		JBUFFER_TRACE(jh, "owned by older transaction");		J_ASSERT_JH(jh, jh->b_next_transaction == NULL);		J_ASSERT_JH(jh, jh->b_transaction ==					journal->j_committing_transaction);		/* There is one case we have to be very careful about.		 * If the committing transaction is currently writing		 * this buffer out to disk and has NOT made a copy-out,		 * then we cannot modify the buffer contents at all		 * right now.  The essence of copy-out is that it is the		 * extra copy, not the primary copy, which gets		 * journaled.  If the primary copy is already going to		 * disk then we cannot do copy-out here. */		if (jh->b_jlist == BJ_Shadow) {			DEFINE_WAIT_BIT(wait, &bh->b_state, BH_Unshadow);			wait_queue_head_t *wqh;			wqh = bit_waitqueue(&bh->b_state, BH_Unshadow);			JBUFFER_TRACE(jh, "on shadow: sleep");			jbd_unlock_bh_state(bh);			/* commit wakes up all shadow buffers after IO */			for ( ; ; ) {				prepare_to_wait(wqh, &wait.wait,						TASK_UNINTERRUPTIBLE);				if (jh->b_jlist != BJ_Shadow)					break;				schedule();			}			finish_wait(wqh, &wait.wait);			goto repeat;		}		/* Only do the copy if the currently-owning transaction		 * still needs it.  If it is on the Forget list, the		 * committing transaction is past that stage.  The		 * buffer had better remain locked during the kmalloc,		 * but that should be true --- we hold the journal lock		 * still and the buffer is already on the BUF_JOURNAL		 * list so won't be flushed. 		 *		 * Subtle point, though: if this is a get_undo_access,		 * then we will be relying on the frozen_data to contain		 * the new value of the committed_data record after the		 * transaction, so we HAVE to force the frozen_data copy		 * in that case. */		if (jh->b_jlist != BJ_Forget || force_copy) {			JBUFFER_TRACE(jh, "generate frozen data");			if (!frozen_buffer) {				JBUFFER_TRACE(jh, "allocate memory for buffer");				jbd_unlock_bh_state(bh);				frozen_buffer = jbd_kmalloc(jh2bh(jh)->b_size,							    GFP_NOFS);				if (!frozen_buffer) {					printk(KERN_EMERG					       "%s: OOM for frozen_buffer\n",					       __FUNCTION__);					JBUFFER_TRACE(jh, "oom!");					error = -ENOMEM;					jbd_lock_bh_state(bh);					goto done;				}				goto repeat;			}			jh->b_frozen_data = frozen_buffer;			frozen_buffer = NULL;			need_copy = 1;		}		jh->b_next_transaction = transaction;	}	/*	 * Finally, if the buffer is not journaled right now, we need to make	 * sure it doesn't get written to disk before the caller actually	 * commits the new data	 */	if (!jh->b_transaction) {		JBUFFER_TRACE(jh, "no transaction");		J_ASSERT_JH(jh, !jh->b_next_transaction);		jh->b_transaction = transaction;		JBUFFER_TRACE(jh, "file as BJ_Reserved");		spin_lock(&journal->j_list_lock);		__journal_file_buffer(jh, transaction, BJ_Reserved);		spin_unlock(&journal->j_list_lock);	}done:	if (need_copy) {		struct page *page;		int offset;		char *source;		J_EXPECT_JH(jh, buffer_uptodate(jh2bh(jh)),			    "Possible IO failure.\n");		page = jh2bh(jh)->b_page;		offset = ((unsigned long) jh2bh(jh)->b_data) & ~PAGE_MASK;		source = kmap_atomic(page, KM_USER0);		memcpy(jh->b_frozen_data, source+offset, jh2bh(jh)->b_size);		kunmap_atomic(source, KM_USER0);	}	jbd_unlock_bh_state(bh);	/*	 * If we are about to journal a buffer, then any revoke pending on it is	 * no longer valid	 */	journal_cancel_revoke(handle, jh);out:	if (frozen_buffer)		kfree(frozen_buffer);	JBUFFER_TRACE(jh, "exit");	return error;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/f99d49adf527fa6f7a9c42257fa76bca6b8df1e3/transaction.c/clean/fs/jbd/transaction.c