linux.git/fs/jbd2/checkpoint.c, branch v3.12

jbd2: drop checkpoint mutex when waiting in __jbd2_log_wait_for_space()

2013-06-13T02:47:35+00:00

While trying to debug an an issue under extreme I/O loading
on preempt-rt kernels, the following backtrace was observed
via SysRQ output:

rm              D ffff8802203afbc0  4600  4878   4748 0x00000000
 ffff8802217bfb78 0000000000000082 ffff88021fc2bb80 ffff88021fc2bb80
 ffff88021fc2bb80 ffff8802217bffd8 ffff8802217bffd8 ffff8802217bffd8
 ffff88021f1d4c80 ffff88021fc2bb80 ffff8802217bfb88 ffff88022437b000
Call Trace:
 [] schedule+0x24/0x70
 [] jbd2_log_wait_commit+0xbd/0x140
 [] ? __init_waitqueue_head+0x50/0x50
 [] jbd2_log_do_checkpoint+0xf5/0x520
 [] __jbd2_log_wait_for_space+0xa9/0x1f0
 [] start_this_handle.isra.10+0x2e0/0x530
 [] ? __init_waitqueue_head+0x50/0x50
 [] jbd2__journal_start+0xc3/0x110
 [] ? ext4_rmdir+0x6e/0x230
 [] jbd2_journal_start+0xe/0x10
 [] ext4_journal_start_sb+0x5b/0x160
 [] ext4_rmdir+0x6e/0x230
 [] vfs_rmdir+0xd5/0x140
 [] do_rmdir+0xdf/0x120
 [] ? task_work_run+0x44/0x80
 [] ? do_notify_resume+0x89/0x100
 [] ? int_signal+0x12/0x17
 [] sys_unlinkat+0x25/0x40
 [] system_call_fastpath+0x16/0x1b

What is interesting here, is that we call log_wait_commit, from
within wait_for_space, but we are still holding the checkpoint_mutex
as it surrounds mostly the whole of wait_for_space.  And then, as we
are waiting, journal_commit_transaction can run, and if the JBD2_FLUSHED
bit is set, then we will also try to take the same checkpoint_mutex.

It seems that we need to drop the checkpoint_mutex while sitting in
jbd2_log_wait_commit, if we want to guarantee that progress can be made
by jbd2_journal_commit_transaction().  There does not seem to be
anything preempt-rt specific about this, other then perhaps increasing
the odds of it happening.

Signed-off-by: Paul Gortmaker 
Signed-off-by: "Theodore Ts'o"

jbd2: remove unused waitqueues

2013-06-04T16:24:11+00:00

j_wait_logspace and j_wait_checkpoint are unused.  Remove them.

Reviewed-by: Zheng Liu 
Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: cleanup needed free block estimates when starting a transaction

2013-06-04T16:12:57+00:00

__jbd2_log_space_left() and jbd_space_needed() were kind of odd.
jbd_space_needed() accounted also credits needed for currently
committing transaction while it didn't account for credits needed for
control blocks.  __jbd2_log_space_left() then accounted for control
blocks as a fraction of free space.  Since results of these two
functions are always only compared against each other, this works
correct but is somewhat strange.  Move the estimates so that
jbd_space_needed() returns number of blocks needed for a transaction
including control blocks and __jbd2_log_space_left() returns free
space in the journal (with the committing transaction already
subtracted).  Rename functions to jbd2_log_space_left() and
jbd2_space_needed() while we are changing them.

Reviewed-by: Zheng Liu 
Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: remove journal_head from descriptor buffers

2013-06-04T16:06:01+00:00

Similarly as for metadata buffers, also log descriptor buffers don't
really need the journal head. So strip it and remove BJ_LogCtl list.

Reviewed-by: Zheng Liu 
Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: don't create journal_head for temporary journal buffers

2013-06-04T16:01:45+00:00

When writing metadata to the journal, we create temporary buffer heads
for that task.  We also attach journal heads to these buffer heads but
the only purpose of the journal heads is to keep buffers linked in
transaction's BJ_IO list.  We remove the need for journal heads by
reusing buffer_head's b_assoc_buffers list for that purpose.  Also
since BJ_IO list is just a temporary list for transaction commit, we
use a private list in jbd2_journal_commit_transaction() for that thus
removing BJ_IO list from transaction completely.

Reviewed-by: Zheng Liu 
Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: remove bh_state lock from checkpointing code

2012-03-14T02:45:25+00:00

All accesses to checkpointing entries in journal_head are protected
by j_list_lock. Thus __jbd2_journal_remove_checkpoint() doesn't really
need bh_state lock.

Also the only part of journal head that the rest of checkpointing code
needs to check is jh->b_transaction which is safe to read under
j_list_lock.

So we can safely remove bh_state lock from all of checkpointing code which
makes it considerably prettier.

Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: fix BH_JWrite setting in checkpointing code

2012-03-14T02:24:54+00:00

BH_JWrite bit should be set when buffer is written to the journal. So
checkpointing shouldn't set this bit when writing out buffer. This didn't
cause any observable bug since BH_JWrite bit is used only for debugging
purposes but it's good to have this consistent.

Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: issue cache flush after checkpointing even with internal journal

2012-03-14T02:22:54+00:00

When we reach jbd2_cleanup_journal_tail(), there is no guarantee that
checkpointed buffers are on a stable storage - especially if buffers were
written out by jbd2_log_do_checkpoint(), they are likely to be only in disk's
caches. Thus when we update journal superblock effectively removing old
transaction from journal, this write of superblock can get to stable storage
before those checkpointed buffers which can result in filesystem corruption
after a crash. Thus we must unconditionally issue a cache flush before we
update journal superblock in these cases.

A similar problem can also occur if journal superblock is written only in
disk's caches, other transaction starts reusing space of the transaction
cleaned from the log and power failure happens. Subsequent journal replay would
still try to replay the old transaction but some of it's blocks may be already
overwritten by the new transaction. For this reason we must use WRITE_FUA when
updating log tail and we must first write new log tail to disk and update
in-memory information only after that.

Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: split updating of journal superblock and marking journal empty

2012-03-13T19:41:04+00:00

There are three case of updating journal superblock. In the first case, we want
to mark journal as empty (setting s_sequence to 0), in the second case we want
to update log tail, in the third case we want to update s_errno. Split these
cases into separate functions. It makes the code slightly more straightforward
and later patches will make the distinction even more important.

Signed-off-by: Jan Kara 
Signed-off-by: "Theodore Ts'o"

jbd2: allocate transaction from separate slab cache

2012-02-20T22:53:02+00:00

There is normally only a handful of these active at any one time, but
putting them in a separate slab cache makes debugging memory
corruption problems easier.  Manish Katiyar also wanted this make it
easier to test memory failure scenarios in the jbd2 layer.

Cc: Manish Katiyar 
Signed-off-by: Yongqiang Yang 
Signed-off-by: "Theodore Ts'o"