Commit fdc3ef88 authored by Jan Kara's avatar Jan Kara Committed by Theodore Ts'o
Browse files

jbd2: Reserve space for revoke descriptor blocks 



Extend functions for starting, extending, and restarting transaction
handles to take number of revoke records handle must be able to
accommodate. These functions then make sure transaction has enough
credits to be able to store resulting revoke descriptor blocks. Also
revoke code tracks number of revoke records created by a handle to catch
situation where some place didn't reserve enough space for revoke
records. Similarly to standard transaction credits, space for unused
reserved revoke records is released when the handle is stopped.

On the ext4 side we currently take a simplistic approach of reserving
space for 1024 revoke records for any transaction. This grows amount of
credits reserved for each handle only by a few and is enough for any
normal workload so that we don't hit warnings in jbd2. We will refine
the logic in following commits.

Signed-off-by: default avatarJan Kara <jack@suse.cz>
Link: https://lore.kernel.org/r/20191105164437.32602-20-jack@suse.cz


Signed-off-by: default avatarTheodore Ts'o <tytso@mit.edu>
parent 77444ac4

fs/ext4/ext4_jbd2.c

+1 −1
Original line number Diff line number Diff line
@@ -78,7 +78,7 @@ handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, 
	journal = EXT4_SB(sb)->s_journal;

	if (!journal)

		return ext4_get_nojournal();

	return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS,

	return jbd2__journal_start(journal, blocks, rsv_blocks, 1024, GFP_NOFS,

				   type, line);

}

fs/ext4/ext4_jbd2.h

+2 −2
Original line number Diff line number Diff line
@@ -328,14 +328,14 @@ static inline handle_t *ext4_journal_current_handle(void) 
static inline int ext4_journal_extend(handle_t *handle, int nblocks)

{

	if (ext4_handle_valid(handle))

		return jbd2_journal_extend(handle, nblocks);

		return jbd2_journal_extend(handle, nblocks, 1024);

	return 0;

}



static inline int ext4_journal_restart(handle_t *handle, int nblocks)

{

	if (ext4_handle_valid(handle))

		return jbd2_journal_restart(handle, nblocks);

		return jbd2__journal_restart(handle, nblocks, 1024, GFP_NOFS);

	return 0;

}

fs/jbd2/journal.c

+21 −0
Original line number Diff line number Diff line
@@ -1500,6 +1500,21 @@ void jbd2_journal_update_sb_errno(journal_t *journal) 
}

EXPORT_SYMBOL(jbd2_journal_update_sb_errno);



static int journal_revoke_records_per_block(journal_t *journal)

{

	int record_size;

	int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t);



	if (jbd2_has_feature_64bit(journal))

		record_size = 8;

	else

		record_size = 4;



	if (jbd2_journal_has_csum_v2or3(journal))

		space -= sizeof(struct jbd2_journal_block_tail);

	return space / record_size;

}



/*

 * Read the superblock for a given journal, performing initial

 * validation of the format.
@@ -1608,6 +1623,8 @@ static int journal_get_superblock(journal_t *journal) 
						   sizeof(sb->s_uuid));

	}



	journal->j_revoke_records_per_block =

				journal_revoke_records_per_block(journal);

	set_buffer_verified(bh);



	return 0;
@@ -1928,6 +1945,8 @@ int jbd2_journal_set_features (journal_t *journal, unsigned long compat, 
	sb->s_feature_ro_compat |= cpu_to_be32(ro);

	sb->s_feature_incompat  |= cpu_to_be32(incompat);

	unlock_buffer(journal->j_sb_buffer);

	journal->j_revoke_records_per_block =

				journal_revoke_records_per_block(journal);



	return 1;

#undef COMPAT_FEATURE_ON
@@ -1958,6 +1977,8 @@ void jbd2_journal_clear_features(journal_t *journal, unsigned long compat, 
	sb->s_feature_compat    &= ~cpu_to_be32(compat);

	sb->s_feature_ro_compat &= ~cpu_to_be32(ro);

	sb->s_feature_incompat  &= ~cpu_to_be32(incompat);

	journal->j_revoke_records_per_block =

				journal_revoke_records_per_block(journal);

}

EXPORT_SYMBOL(jbd2_journal_clear_features);

fs/jbd2/revoke.c

+6 −0
Original line number Diff line number Diff line
@@ -371,6 +371,11 @@ int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr, 
	}

#endif



	if (WARN_ON_ONCE(handle->h_revoke_credits <= 0)) {

		if (!bh_in)

			brelse(bh);

		return -EIO;

	}

	/* We really ought not ever to revoke twice in a row without

           first having the revoke cancelled: it's illegal to free a

           block twice without allocating it in between! */
@@ -391,6 +396,7 @@ int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr, 
			__brelse(bh);

		}

	}

	handle->h_revoke_credits--;



	jbd_debug(2, "insert revoke for block %llu, bh_in=%p\n",blocknr, bh_in);

	err = insert_revoke_hash(journal, blocknr,

fs/jbd2/transaction.c

+47 −7
Original line number Diff line number Diff line
@@ -101,6 +101,7 @@ static void jbd2_get_transaction(journal_t *journal, 
	atomic_set(&transaction->t_outstanding_credits,

		   jbd2_descriptor_blocks_per_trans(journal) +

		   atomic_read(&journal->j_reserved_credits));

	atomic_set(&transaction->t_outstanding_revokes, 0);

	atomic_set(&transaction->t_handle_count, 0);

	INIT_LIST_HEAD(&transaction->t_inode_list);

	INIT_LIST_HEAD(&transaction->t_private_list);
@@ -418,6 +419,7 @@ repeat: 
	update_t_max_wait(transaction, ts);

	handle->h_transaction = transaction;

	handle->h_requested_credits = blocks;

	handle->h_revoke_credits_requested = handle->h_revoke_credits;

	handle->h_start_jiffies = jiffies;

	atomic_inc(&transaction->t_updates);

	atomic_inc(&transaction->t_handle_count);
@@ -451,8 +453,8 @@ static handle_t *new_handle(int nblocks) 
}



handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,

			      gfp_t gfp_mask, unsigned int type,

			      unsigned int line_no)

			      int revoke_records, gfp_t gfp_mask,

			      unsigned int type, unsigned int line_no)

{

	handle_t *handle = journal_current_handle();

	int err;
@@ -466,6 +468,8 @@ handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks, 
		return handle;

	}



	nblocks += DIV_ROUND_UP(revoke_records,

				journal->j_revoke_records_per_block);

	handle = new_handle(nblocks);

	if (!handle)

		return ERR_PTR(-ENOMEM);
@@ -481,6 +485,7 @@ handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks, 
		rsv_handle->h_journal = journal;

		handle->h_rsv_handle = rsv_handle;

	}

	handle->h_revoke_credits = revoke_records;



	err = start_this_handle(journal, handle, gfp_mask);

	if (err < 0) {
@@ -521,7 +526,7 @@ EXPORT_SYMBOL(jbd2__journal_start); 
 */

handle_t *jbd2_journal_start(journal_t *journal, int nblocks)

{

	return jbd2__journal_start(journal, nblocks, 0, GFP_NOFS, 0, 0);

	return jbd2__journal_start(journal, nblocks, 0, 0, GFP_NOFS, 0, 0);

}

EXPORT_SYMBOL(jbd2_journal_start);
@@ -598,6 +603,7 @@ EXPORT_SYMBOL(jbd2_journal_start_reserved); 
 * int jbd2_journal_extend() - extend buffer credits.

 * @handle:  handle to 'extend'

 * @nblocks: nr blocks to try to extend by.

 * @revoke_records: number of revoke records to try to extend by.

 *

 * Some transactions, such as large extends and truncates, can be done

 * atomically all at once or in several stages.  The operation requests
@@ -614,7 +620,7 @@ EXPORT_SYMBOL(jbd2_journal_start_reserved); 
 * return code < 0 implies an error

 * return code > 0 implies normal transaction-full status.

 */

int jbd2_journal_extend(handle_t *handle, int nblocks)

int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records)

{

	transaction_t *transaction = handle->h_transaction;

	journal_t *journal;
@@ -636,6 +642,12 @@ int jbd2_journal_extend(handle_t *handle, int nblocks) 
		goto error_out;

	}



	nblocks += DIV_ROUND_UP(

			handle->h_revoke_credits_requested + revoke_records,

			journal->j_revoke_records_per_block) -

		DIV_ROUND_UP(

			handle->h_revoke_credits_requested,

			journal->j_revoke_records_per_block);

	spin_lock(&transaction->t_handle_lock);

	wanted = atomic_add_return(nblocks,

				   &transaction->t_outstanding_credits);
@@ -655,6 +667,8 @@ int jbd2_journal_extend(handle_t *handle, int nblocks) 


	handle->h_buffer_credits += nblocks;

	handle->h_requested_credits += nblocks;

	handle->h_revoke_credits += revoke_records;

	handle->h_revoke_credits_requested += revoke_records;

	result = 0;



	jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
@@ -669,10 +683,31 @@ static void stop_this_handle(handle_t *handle) 
{

	transaction_t *transaction = handle->h_transaction;

	journal_t *journal = transaction->t_journal;

	int revokes;



	J_ASSERT(journal_current_handle() == handle);

	J_ASSERT(atomic_read(&transaction->t_updates) > 0);

	current->journal_info = NULL;

	/*

	 * Subtract necessary revoke descriptor blocks from handle credits. We

	 * take care to account only for revoke descriptor blocks the

	 * transaction will really need as large sequences of transactions with

	 * small numbers of revokes are relatively common.

	 */

	revokes = handle->h_revoke_credits_requested - handle->h_revoke_credits;

	if (revokes) {

		int t_revokes, revoke_descriptors;

		int rr_per_blk = journal->j_revoke_records_per_block;



		WARN_ON_ONCE(DIV_ROUND_UP(revokes, rr_per_blk)

				> handle->h_buffer_credits);

		t_revokes = atomic_add_return(revokes,

				&transaction->t_outstanding_revokes);

		revoke_descriptors =

			DIV_ROUND_UP(t_revokes, rr_per_blk) -

			DIV_ROUND_UP(t_revokes - revokes, rr_per_blk);

		handle->h_buffer_credits -= revoke_descriptors;

	}

	atomic_sub(handle->h_buffer_credits,

		   &transaction->t_outstanding_credits);

	if (handle->h_rsv_handle)
@@ -692,6 +727,7 @@ static void stop_this_handle(handle_t *handle) 
 * int jbd2_journal_restart() - restart a handle .

 * @handle:  handle to restart

 * @nblocks: nr credits requested

 * @revoke_records: number of revoke record credits requested

 * @gfp_mask: memory allocation flags (for start_this_handle)

 *

 * Restart a handle for a multi-transaction filesystem
@@ -704,7 +740,8 @@ static void stop_this_handle(handle_t *handle) 
 * credits. We preserve reserved handle if there's any attached to the

 * passed in handle.

 */

int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)

int jbd2__journal_restart(handle_t *handle, int nblocks, int revoke_records,

			  gfp_t gfp_mask)

{

	transaction_t *transaction = handle->h_transaction;

	journal_t *journal;
@@ -735,7 +772,10 @@ int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask) 
	read_unlock(&journal->j_state_lock);

	if (need_to_start)

		jbd2_log_start_commit(journal, tid);

	handle->h_buffer_credits = nblocks;

	handle->h_buffer_credits = nblocks +

		DIV_ROUND_UP(revoke_records,

			     journal->j_revoke_records_per_block);

	handle->h_revoke_credits = revoke_records;

	return start_this_handle(journal, handle, gfp_mask);

}

EXPORT_SYMBOL(jbd2__journal_restart);
@@ -743,7 +783,7 @@ EXPORT_SYMBOL(jbd2__journal_restart); 


int jbd2_journal_restart(handle_t *handle, int nblocks)

{

	return jbd2__journal_restart(handle, nblocks, GFP_NOFS);

	return jbd2__journal_restart(handle, nblocks, 0, GFP_NOFS);

}

EXPORT_SYMBOL(jbd2_journal_restart);

CRA Git | Maintained and supported by SUSTech CRA and CCSE