2019-05-22 15:51:29 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
2006-10-11 16:20:59 +08:00
|
|
|
* linux/include/linux/jbd2.h
|
2006-10-11 16:20:57 +08:00
|
|
|
*
|
|
|
|
* Written by Stephen C. Tweedie <sct@redhat.com>
|
|
|
|
*
|
|
|
|
* Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
|
|
|
|
*
|
|
|
|
* Definitions for transaction data structures for the buffer cache
|
|
|
|
* filesystem journaling support.
|
|
|
|
*/
|
|
|
|
|
2007-10-17 06:38:25 +08:00
|
|
|
#ifndef _LINUX_JBD2_H
|
|
|
|
#define _LINUX_JBD2_H
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Allow this file to be included directly into e2fsprogs */
|
|
|
|
#ifndef __KERNEL__
|
|
|
|
#include "jfs_compat.h"
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_DEBUG
|
2006-10-11 16:20:57 +08:00
|
|
|
#else
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/journal-head.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/timer.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2015-06-18 22:52:29 +08:00
|
|
|
#include <linux/bit_spinlock.h>
|
2020-06-20 15:16:41 +08:00
|
|
|
#include <linux/blkdev.h>
|
2012-05-27 19:50:56 +08:00
|
|
|
#include <crypto/hash.h>
|
2006-10-11 16:20:57 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define journal_oom_retry 1
|
|
|
|
|
|
|
|
/*
|
2007-10-17 06:38:25 +08:00
|
|
|
* Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
|
2006-10-11 16:20:57 +08:00
|
|
|
* certain classes of error which can occur due to failed IOs. Under
|
2007-10-17 06:38:25 +08:00
|
|
|
* normal use we want ext4 to continue after such errors, because
|
2006-10-11 16:20:57 +08:00
|
|
|
* hardware _can_ fail, but for debugging purposes when running tests on
|
|
|
|
* known-good hardware we may want to trap these errors.
|
|
|
|
*/
|
2007-10-17 06:38:25 +08:00
|
|
|
#undef JBD2_PARANOID_IOFAIL
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The default maximum commit age, in seconds.
|
|
|
|
*/
|
2007-10-17 06:38:25 +08:00
|
|
|
#define JBD2_DEFAULT_MAX_COMMIT_AGE 5
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2007-07-18 20:57:06 +08:00
|
|
|
#ifdef CONFIG_JBD2_DEBUG
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
2007-10-17 06:38:25 +08:00
|
|
|
* Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
|
2006-10-11 16:20:57 +08:00
|
|
|
* consistency checks. By default we don't do this unless
|
2007-07-18 20:57:06 +08:00
|
|
|
* CONFIG_JBD2_DEBUG is on.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
2007-10-17 06:38:25 +08:00
|
|
|
#define JBD2_EXPENSIVE_CHECKING
|
2013-02-10 05:29:20 +08:00
|
|
|
extern ushort jbd2_journal_enable_debug;
|
jbd2: use a single printk for jbd_debug()
Since the jbd_debug() is implemented with two separate printk()
calls, it can lead to corrupted and misleading debug output like
the following (see lines marked with "*"):
[ 290.339362] (fs/jbd2/journal.c, 203): kjournald2: kjournald2 wakes
[ 290.339365] (fs/jbd2/journal.c, 155): kjournald2: commit_sequence=42103, commit_request=42104
[ 290.339369] (fs/jbd2/journal.c, 158): kjournald2: OK, requests differ
[* 290.339376] (fs/jbd2/journal.c, 648): jbd2_log_wait_commit:
[* 290.339379] (fs/jbd2/commit.c, 370): jbd2_journal_commit_transaction: JBD2: want 42104, j_commit_sequence=42103
[* 290.339382] JBD2: starting commit of transaction 42104
[ 290.339410] (fs/jbd2/revoke.c, 566): jbd2_journal_write_revoke_records: Wrote 0 revoke records
[ 290.376555] (fs/jbd2/commit.c, 1088): jbd2_journal_commit_transaction: JBD2: commit 42104 complete, head 42079
i.e. the debug output from log_wait_commit and journal_commit_transaction
have become interleaved. The output should have been:
(fs/jbd2/journal.c, 648): jbd2_log_wait_commit: JBD2: want 42104, j_commit_sequence=42103
(fs/jbd2/commit.c, 370): jbd2_journal_commit_transaction: JBD2: starting commit of transaction 42104
It is expected that this is not easy to replicate -- I was only able
to cause it on preempt-rt kernels, and even then only under heavy
I/O load.
Reported-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Suggested-by: "Theodore Ts'o" <tytso@mit.edu>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-06-13 11:04:04 +08:00
|
|
|
void __jbd2_debug(int level, const char *file, const char *func,
|
|
|
|
unsigned int line, const char *fmt, ...);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
jbd2: use a single printk for jbd_debug()
Since the jbd_debug() is implemented with two separate printk()
calls, it can lead to corrupted and misleading debug output like
the following (see lines marked with "*"):
[ 290.339362] (fs/jbd2/journal.c, 203): kjournald2: kjournald2 wakes
[ 290.339365] (fs/jbd2/journal.c, 155): kjournald2: commit_sequence=42103, commit_request=42104
[ 290.339369] (fs/jbd2/journal.c, 158): kjournald2: OK, requests differ
[* 290.339376] (fs/jbd2/journal.c, 648): jbd2_log_wait_commit:
[* 290.339379] (fs/jbd2/commit.c, 370): jbd2_journal_commit_transaction: JBD2: want 42104, j_commit_sequence=42103
[* 290.339382] JBD2: starting commit of transaction 42104
[ 290.339410] (fs/jbd2/revoke.c, 566): jbd2_journal_write_revoke_records: Wrote 0 revoke records
[ 290.376555] (fs/jbd2/commit.c, 1088): jbd2_journal_commit_transaction: JBD2: commit 42104 complete, head 42079
i.e. the debug output from log_wait_commit and journal_commit_transaction
have become interleaved. The output should have been:
(fs/jbd2/journal.c, 648): jbd2_log_wait_commit: JBD2: want 42104, j_commit_sequence=42103
(fs/jbd2/commit.c, 370): jbd2_journal_commit_transaction: JBD2: starting commit of transaction 42104
It is expected that this is not easy to replicate -- I was only able
to cause it on preempt-rt kernels, and even then only under heavy
I/O load.
Reported-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Suggested-by: "Theodore Ts'o" <tytso@mit.edu>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2013-06-13 11:04:04 +08:00
|
|
|
#define jbd_debug(n, fmt, a...) \
|
|
|
|
__jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
|
2006-10-11 16:20:57 +08:00
|
|
|
#else
|
2021-03-22 18:21:38 +08:00
|
|
|
#define jbd_debug(n, fmt, a...) no_printk(fmt, ##a)
|
2006-10-11 16:20:57 +08:00
|
|
|
#endif
|
|
|
|
|
2009-12-07 23:36:20 +08:00
|
|
|
extern void *jbd2_alloc(size_t size, gfp_t flags);
|
|
|
|
extern void jbd2_free(void *ptr, size_t size);
|
2007-10-17 06:38:25 +08:00
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_MIN_JOURNAL_BLOCKS 1024
|
2020-11-21 04:22:32 +08:00
|
|
|
#define JBD2_DEFAULT_FAST_COMMIT_BLOCKS 256
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
|
|
|
/**
|
|
|
|
* typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
|
|
|
|
*
|
|
|
|
* All filesystem modifications made by the process go
|
|
|
|
* through this handle. Recursive operations (such as quota operations)
|
|
|
|
* are gathered into a single update.
|
|
|
|
*
|
|
|
|
* The buffer credits field is used to account for journaled buffers
|
|
|
|
* being modified by the running process. To ensure that there is
|
|
|
|
* enough log space for all outstanding operations, we need to limit the
|
|
|
|
* number of outstanding buffers possible at any time. When the
|
|
|
|
* operation completes, any buffer credits not used are credited back to
|
|
|
|
* the transaction, so that at all times we know how many buffers the
|
|
|
|
* outstanding updates on a transaction might possibly touch.
|
|
|
|
*
|
|
|
|
* This is an opaque datatype.
|
|
|
|
**/
|
2011-01-11 01:29:43 +08:00
|
|
|
typedef struct jbd2_journal_handle handle_t; /* Atomic operation type */
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
|
|
|
|
*
|
|
|
|
* journal_t is linked to from the fs superblock structure.
|
|
|
|
*
|
|
|
|
* We use the journal_t to keep track of all outstanding transaction
|
|
|
|
* activity on the filesystem, and to manage the state of the log
|
|
|
|
* writing process.
|
|
|
|
*
|
|
|
|
* This is an opaque datatype.
|
|
|
|
**/
|
|
|
|
typedef struct journal_s journal_t; /* Journal control structure */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal structures used by the logging mechanism:
|
|
|
|
*/
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* On-disk structures
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Descriptor block types:
|
|
|
|
*/
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_DESCRIPTOR_BLOCK 1
|
|
|
|
#define JBD2_COMMIT_BLOCK 2
|
|
|
|
#define JBD2_SUPERBLOCK_V1 3
|
|
|
|
#define JBD2_SUPERBLOCK_V2 4
|
|
|
|
#define JBD2_REVOKE_BLOCK 5
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Standard header for all descriptor blocks:
|
|
|
|
*/
|
|
|
|
typedef struct journal_header_s
|
|
|
|
{
|
|
|
|
__be32 h_magic;
|
|
|
|
__be32 h_blocktype;
|
|
|
|
__be32 h_sequence;
|
|
|
|
} journal_header_t;
|
|
|
|
|
2008-01-29 12:58:27 +08:00
|
|
|
/*
|
|
|
|
* Checksum types.
|
|
|
|
*/
|
|
|
|
#define JBD2_CRC32_CHKSUM 1
|
|
|
|
#define JBD2_MD5_CHKSUM 2
|
|
|
|
#define JBD2_SHA1_CHKSUM 3
|
2012-05-23 10:43:41 +08:00
|
|
|
#define JBD2_CRC32C_CHKSUM 4
|
2008-01-29 12:58:27 +08:00
|
|
|
|
|
|
|
#define JBD2_CRC32_CHKSUM_SIZE 4
|
|
|
|
|
|
|
|
#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
|
|
|
|
/*
|
|
|
|
* Commit block header for storing transactional checksums:
|
2012-05-23 10:43:41 +08:00
|
|
|
*
|
|
|
|
* NOTE: If FEATURE_COMPAT_CHECKSUM (checksum v1) is set, the h_chksum*
|
|
|
|
* fields are used to store a checksum of the descriptor and data blocks.
|
|
|
|
*
|
|
|
|
* If FEATURE_INCOMPAT_CSUM_V2 (checksum v2) is set, then the h_chksum
|
|
|
|
* field is used to store crc32c(uuid+commit_block). Each journal metadata
|
|
|
|
* block gets its own checksum, and data block checksums are stored in
|
|
|
|
* journal_block_tag (in the descriptor). The other h_chksum* fields are
|
|
|
|
* not used.
|
|
|
|
*
|
2014-08-28 06:40:07 +08:00
|
|
|
* If FEATURE_INCOMPAT_CSUM_V3 is set, the descriptor block uses
|
|
|
|
* journal_block_tag3_t to store a full 32-bit checksum. Everything else
|
|
|
|
* is the same as v2.
|
|
|
|
*
|
|
|
|
* Checksum v1, v2, and v3 are mutually exclusive features.
|
2008-01-29 12:58:27 +08:00
|
|
|
*/
|
|
|
|
struct commit_header {
|
|
|
|
__be32 h_magic;
|
|
|
|
__be32 h_blocktype;
|
|
|
|
__be32 h_sequence;
|
|
|
|
unsigned char h_chksum_type;
|
|
|
|
unsigned char h_chksum_size;
|
|
|
|
unsigned char h_padding[2];
|
|
|
|
__be32 h_chksum[JBD2_CHECKSUM_BYTES];
|
2008-07-12 07:27:31 +08:00
|
|
|
__be64 h_commit_sec;
|
|
|
|
__be32 h_commit_nsec;
|
2008-01-29 12:58:27 +08:00
|
|
|
};
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
2006-10-11 16:21:08 +08:00
|
|
|
* The block tag: used to describe a single buffer in the journal.
|
|
|
|
* t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
|
|
|
|
* raw struct shouldn't be used for pointer math or sizeof() - use
|
|
|
|
* journal_tag_bytes(journal) instead to compute this.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
2014-08-28 06:40:07 +08:00
|
|
|
typedef struct journal_block_tag3_s
|
|
|
|
{
|
|
|
|
__be32 t_blocknr; /* The on-disk block number */
|
|
|
|
__be32 t_flags; /* See below */
|
|
|
|
__be32 t_blocknr_high; /* most-significant high 32bits. */
|
|
|
|
__be32 t_checksum; /* crc32c(uuid+seq+block) */
|
|
|
|
} journal_block_tag3_t;
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
typedef struct journal_block_tag_s
|
|
|
|
{
|
|
|
|
__be32 t_blocknr; /* The on-disk block number */
|
2012-05-23 10:43:41 +08:00
|
|
|
__be16 t_checksum; /* truncated crc32c(uuid+seq+block) */
|
|
|
|
__be16 t_flags; /* See below */
|
2006-10-11 16:21:08 +08:00
|
|
|
__be32 t_blocknr_high; /* most-significant high 32bits. */
|
2006-10-11 16:20:57 +08:00
|
|
|
} journal_block_tag_t;
|
|
|
|
|
2016-02-23 12:19:09 +08:00
|
|
|
/* Tail of descriptor or revoke block, for checksumming */
|
2012-05-23 10:43:41 +08:00
|
|
|
struct jbd2_journal_block_tail {
|
|
|
|
__be32 t_checksum; /* crc32c(uuid+descr_block) */
|
|
|
|
};
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* The revoke descriptor: used on disk to describe a series of blocks to
|
|
|
|
* be revoked from the log
|
|
|
|
*/
|
2006-10-11 16:20:59 +08:00
|
|
|
typedef struct jbd2_journal_revoke_header_s
|
2006-10-11 16:20:57 +08:00
|
|
|
{
|
|
|
|
journal_header_t r_header;
|
|
|
|
__be32 r_count; /* Count of bytes used in the block */
|
2006-10-11 16:20:59 +08:00
|
|
|
} jbd2_journal_revoke_header_t;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Definitions for the journal tag flags word: */
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_FLAG_ESCAPE 1 /* on-disk block is escaped */
|
|
|
|
#define JBD2_FLAG_SAME_UUID 2 /* block has same uuid as previous */
|
|
|
|
#define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
|
|
|
|
#define JBD2_FLAG_LAST_TAG 8 /* last tag in this descriptor block */
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The journal superblock. All fields are in big-endian byte order.
|
|
|
|
*/
|
|
|
|
typedef struct journal_superblock_s
|
|
|
|
{
|
|
|
|
/* 0x0000 */
|
|
|
|
journal_header_t s_header;
|
|
|
|
|
|
|
|
/* 0x000C */
|
|
|
|
/* Static information describing the journal */
|
|
|
|
__be32 s_blocksize; /* journal device blocksize */
|
|
|
|
__be32 s_maxlen; /* total blocks in journal file */
|
|
|
|
__be32 s_first; /* first block of log information */
|
|
|
|
|
|
|
|
/* 0x0018 */
|
|
|
|
/* Dynamic information describing the current state of the log */
|
|
|
|
__be32 s_sequence; /* first commit ID expected in log */
|
|
|
|
__be32 s_start; /* blocknr of start of log */
|
|
|
|
|
|
|
|
/* 0x0020 */
|
2006-10-11 16:20:59 +08:00
|
|
|
/* Error value, as set by jbd2_journal_abort(). */
|
2006-10-11 16:20:57 +08:00
|
|
|
__be32 s_errno;
|
|
|
|
|
|
|
|
/* 0x0024 */
|
|
|
|
/* Remaining fields are only valid in a version-2 superblock */
|
|
|
|
__be32 s_feature_compat; /* compatible feature set */
|
|
|
|
__be32 s_feature_incompat; /* incompatible feature set */
|
|
|
|
__be32 s_feature_ro_compat; /* readonly-compatible feature set */
|
|
|
|
/* 0x0030 */
|
|
|
|
__u8 s_uuid[16]; /* 128-bit uuid for journal */
|
|
|
|
|
|
|
|
/* 0x0040 */
|
|
|
|
__be32 s_nr_users; /* Nr of filesystems sharing log */
|
|
|
|
|
|
|
|
__be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/
|
|
|
|
|
|
|
|
/* 0x0048 */
|
|
|
|
__be32 s_max_transaction; /* Limit of journal blocks per trans.*/
|
|
|
|
__be32 s_max_trans_data; /* Limit of data blocks per trans. */
|
|
|
|
|
|
|
|
/* 0x0050 */
|
2012-05-23 10:43:41 +08:00
|
|
|
__u8 s_checksum_type; /* checksum type */
|
|
|
|
__u8 s_padding2[3];
|
2020-10-27 12:49:14 +08:00
|
|
|
/* 0x0054 */
|
|
|
|
__be32 s_num_fc_blks; /* Number of fast commit blocks */
|
|
|
|
/* 0x0058 */
|
|
|
|
__u32 s_padding[41];
|
2012-05-23 10:43:41 +08:00
|
|
|
__be32 s_checksum; /* crc32c(superblock) */
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* 0x0100 */
|
|
|
|
__u8 s_users[16*48]; /* ids of all fs'es sharing the log */
|
|
|
|
/* 0x0400 */
|
|
|
|
} journal_superblock_t;
|
|
|
|
|
2015-10-18 04:18:45 +08:00
|
|
|
/* Use the jbd2_{has,set,clear}_feature_* helpers; these will be removed */
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
|
2006-10-11 16:20:57 +08:00
|
|
|
((j)->j_format_version >= 2 && \
|
|
|
|
((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
|
2006-10-11 16:20:57 +08:00
|
|
|
((j)->j_format_version >= 2 && \
|
|
|
|
((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
|
2006-10-11 16:20:57 +08:00
|
|
|
((j)->j_format_version >= 2 && \
|
|
|
|
((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
|
|
|
|
|
2015-10-18 04:18:45 +08:00
|
|
|
#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
|
2008-01-29 12:58:27 +08:00
|
|
|
|
|
|
|
#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
|
|
|
|
#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
|
|
|
|
#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
|
2012-05-23 10:43:41 +08:00
|
|
|
#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
|
2014-08-28 06:40:07 +08:00
|
|
|
#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010
|
2020-10-16 04:37:54 +08:00
|
|
|
#define JBD2_FEATURE_INCOMPAT_FAST_COMMIT 0x00000020
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2015-10-18 04:18:45 +08:00
|
|
|
/* See "journal feature predicate functions" below */
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/* Features known to this kernel version: */
|
2008-01-29 12:58:27 +08:00
|
|
|
#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
|
2006-10-11 16:21:08 +08:00
|
|
|
#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
|
2008-01-29 12:58:27 +08:00
|
|
|
JBD2_FEATURE_INCOMPAT_64BIT | \
|
2012-05-27 20:12:42 +08:00
|
|
|
JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
|
2014-08-28 06:40:07 +08:00
|
|
|
JBD2_FEATURE_INCOMPAT_CSUM_V2 | \
|
2020-10-16 04:37:54 +08:00
|
|
|
JBD2_FEATURE_INCOMPAT_CSUM_V3 | \
|
|
|
|
JBD2_FEATURE_INCOMPAT_FAST_COMMIT)
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/sched.h>
|
2013-06-05 00:08:56 +08:00
|
|
|
|
|
|
|
enum jbd_state_bits {
|
|
|
|
BH_JBD /* Has an attached ext3 journal_head */
|
|
|
|
= BH_PrivateStart,
|
|
|
|
BH_JWrite, /* Being written to log (@@@ DEBUGGING) */
|
|
|
|
BH_Freed, /* Has been freed (truncated) */
|
|
|
|
BH_Revoked, /* Has been revoked from the log */
|
|
|
|
BH_RevokeValid, /* Revoked flag is valid */
|
|
|
|
BH_JBDDirty, /* Is dirty but journaled */
|
|
|
|
BH_JournalHead, /* Pins bh->b_private and jh->b_bh */
|
|
|
|
BH_Shadow, /* IO on shadow buffer is running */
|
|
|
|
BH_Verified, /* Metadata block has been verified ok */
|
|
|
|
BH_JBDPrivateStart, /* First bit available for private use by FS */
|
|
|
|
};
|
|
|
|
|
|
|
|
BUFFER_FNS(JBD, jbd)
|
|
|
|
BUFFER_FNS(JWrite, jwrite)
|
|
|
|
BUFFER_FNS(JBDDirty, jbddirty)
|
|
|
|
TAS_BUFFER_FNS(JBDDirty, jbddirty)
|
|
|
|
BUFFER_FNS(Revoked, revoked)
|
|
|
|
TAS_BUFFER_FNS(Revoked, revoked)
|
|
|
|
BUFFER_FNS(RevokeValid, revokevalid)
|
|
|
|
TAS_BUFFER_FNS(RevokeValid, revokevalid)
|
|
|
|
BUFFER_FNS(Freed, freed)
|
|
|
|
BUFFER_FNS(Shadow, shadow)
|
|
|
|
BUFFER_FNS(Verified, verified)
|
|
|
|
|
2015-06-18 22:52:29 +08:00
|
|
|
static inline struct buffer_head *jh2bh(struct journal_head *jh)
|
|
|
|
{
|
|
|
|
return jh->b_bh;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct journal_head *bh2jh(struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
return bh->b_private;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
bit_spin_lock(BH_JournalHead, &bh->b_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
bit_spin_unlock(BH_JournalHead, &bh->b_state);
|
|
|
|
}
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2008-01-29 12:58:27 +08:00
|
|
|
#define J_ASSERT(assert) BUG_ON(!(assert))
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
|
|
|
|
#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
|
|
|
|
|
2007-10-17 06:38:25 +08:00
|
|
|
#if defined(JBD2_PARANOID_IOFAIL)
|
2006-10-11 16:20:57 +08:00
|
|
|
#define J_EXPECT(expr, why...) J_ASSERT(expr)
|
|
|
|
#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
|
|
|
|
#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
|
|
|
|
#else
|
|
|
|
#define __journal_expect(expr, why...) \
|
|
|
|
({ \
|
|
|
|
int val = (expr); \
|
|
|
|
if (!val) { \
|
|
|
|
printk(KERN_ERR \
|
2009-01-17 00:57:00 +08:00
|
|
|
"JBD2 unexpected failure: %s: %s;\n", \
|
|
|
|
__func__, #expr); \
|
2006-10-11 16:20:57 +08:00
|
|
|
printk(KERN_ERR why "\n"); \
|
|
|
|
} \
|
|
|
|
val; \
|
|
|
|
})
|
|
|
|
#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
|
|
|
|
#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
|
|
|
|
#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
|
|
|
|
#endif
|
|
|
|
|
2008-07-12 07:27:31 +08:00
|
|
|
/* Flags in jbd_inode->i_flags */
|
|
|
|
#define __JI_COMMIT_RUNNING 0
|
2016-04-24 12:56:07 +08:00
|
|
|
#define __JI_WRITE_DATA 1
|
|
|
|
#define __JI_WAIT_DATA 2
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit of the inode data in progress. We use this flag to protect us from
|
2008-07-12 07:27:31 +08:00
|
|
|
* concurrent deletion of inode. We cannot use reference to inode for this
|
|
|
|
* since we cannot afford doing last iput() on behalf of kjournald
|
|
|
|
*/
|
|
|
|
#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
|
2016-04-24 12:56:07 +08:00
|
|
|
/* Write allocated dirty buffers in this inode before commit */
|
|
|
|
#define JI_WRITE_DATA (1 << __JI_WRITE_DATA)
|
|
|
|
/* Wait for outstanding data writes for this inode before commit */
|
|
|
|
#define JI_WAIT_DATA (1 << __JI_WAIT_DATA)
|
2008-07-12 07:27:31 +08:00
|
|
|
|
|
|
|
/**
|
2020-11-16 18:18:08 +08:00
|
|
|
* struct jbd2_inode - The jbd_inode type is the structure linking inodes in
|
2018-01-10 13:27:29 +08:00
|
|
|
* ordered mode present in a transaction so that we can sync them during commit.
|
2008-07-12 07:27:31 +08:00
|
|
|
*/
|
|
|
|
struct jbd2_inode {
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @i_transaction:
|
|
|
|
*
|
|
|
|
* Which transaction does this inode belong to? Either the running
|
|
|
|
* transaction or the committing one. [j_list_lock]
|
|
|
|
*/
|
2008-07-12 07:27:31 +08:00
|
|
|
transaction_t *i_transaction;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @i_next_transaction:
|
|
|
|
*
|
|
|
|
* Pointer to the running transaction modifying inode's data in case
|
|
|
|
* there is already a committing transaction touching it. [j_list_lock]
|
|
|
|
*/
|
2008-07-12 07:27:31 +08:00
|
|
|
transaction_t *i_next_transaction;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @i_list: List of inodes in the i_transaction [j_list_lock]
|
|
|
|
*/
|
2008-07-12 07:27:31 +08:00
|
|
|
struct list_head i_list;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @i_vfs_inode:
|
|
|
|
*
|
|
|
|
* VFS inode this inode belongs to [constant for lifetime of structure]
|
|
|
|
*/
|
2008-07-12 07:27:31 +08:00
|
|
|
struct inode *i_vfs_inode;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @i_flags: Flags of inode [j_list_lock]
|
|
|
|
*/
|
2010-10-28 09:25:12 +08:00
|
|
|
unsigned long i_flags;
|
2019-06-21 05:24:56 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @i_dirty_start:
|
|
|
|
*
|
|
|
|
* Offset in bytes where the dirty range for this inode starts.
|
|
|
|
* [j_list_lock]
|
|
|
|
*/
|
|
|
|
loff_t i_dirty_start;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @i_dirty_end:
|
|
|
|
*
|
|
|
|
* Inclusive offset in bytes where the dirty range for this inode
|
|
|
|
* ends. [j_list_lock]
|
|
|
|
*/
|
|
|
|
loff_t i_dirty_end;
|
2008-07-12 07:27:31 +08:00
|
|
|
};
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
struct jbd2_revoke_table_s;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/**
|
2020-09-23 01:12:31 +08:00
|
|
|
* struct jbd2_journal_handle - The jbd2_journal_handle type is the concrete
|
|
|
|
* type associated with handle_t.
|
2006-10-11 16:20:57 +08:00
|
|
|
* @h_transaction: Which compound transaction is this update a part of?
|
2018-01-10 13:27:29 +08:00
|
|
|
* @h_journal: Which journal handle belongs to - used iff h_reserved set.
|
|
|
|
* @h_rsv_handle: Handle reserved for finishing the logical operation.
|
2019-11-06 00:44:27 +08:00
|
|
|
* @h_total_credits: Number of remaining buffers we are allowed to add to
|
2019-12-09 12:31:32 +08:00
|
|
|
* journal. These are dirty buffers and revoke descriptor blocks.
|
2019-11-06 00:44:26 +08:00
|
|
|
* @h_revoke_credits: Number of remaining revoke records available for handle
|
2018-01-10 13:27:29 +08:00
|
|
|
* @h_ref: Reference count on this handle.
|
|
|
|
* @h_err: Field for caller's use to track errors through large fs operations.
|
|
|
|
* @h_sync: Flag for sync-on-close.
|
|
|
|
* @h_jdata: Flag to force data journaling.
|
|
|
|
* @h_reserved: Flag for handle for reserved credits.
|
|
|
|
* @h_aborted: Flag indicating fatal error on handle.
|
|
|
|
* @h_type: For handle statistics.
|
|
|
|
* @h_line_no: For handle statistics.
|
|
|
|
* @h_start_jiffies: Handle Start time.
|
2019-11-06 00:44:27 +08:00
|
|
|
* @h_requested_credits: Holds @h_total_credits after handle is started.
|
2019-11-06 00:44:26 +08:00
|
|
|
* @h_revoke_credits_requested: Holds @h_revoke_credits after handle is started.
|
2018-01-10 13:27:29 +08:00
|
|
|
* @saved_alloc_context: Saved context while transaction is open.
|
2006-10-11 16:20:57 +08:00
|
|
|
**/
|
|
|
|
|
|
|
|
/* Docbook can't yet cope with the bit fields, but will leave the documentation
|
|
|
|
* in so it can be fixed later.
|
|
|
|
*/
|
|
|
|
|
2011-01-11 01:29:43 +08:00
|
|
|
struct jbd2_journal_handle
|
2006-10-11 16:20:57 +08:00
|
|
|
{
|
2013-06-05 00:35:11 +08:00
|
|
|
union {
|
|
|
|
transaction_t *h_transaction;
|
|
|
|
/* Which journal handle belongs to - used iff h_reserved set */
|
|
|
|
journal_t *h_journal;
|
|
|
|
};
|
|
|
|
|
|
|
|
handle_t *h_rsv_handle;
|
2019-11-06 00:44:27 +08:00
|
|
|
int h_total_credits;
|
2019-11-06 00:44:26 +08:00
|
|
|
int h_revoke_credits;
|
|
|
|
int h_revoke_credits_requested;
|
2006-10-11 16:20:57 +08:00
|
|
|
int h_ref;
|
|
|
|
int h_err;
|
|
|
|
|
|
|
|
/* Flags [no locking] */
|
2018-01-10 13:27:29 +08:00
|
|
|
unsigned int h_sync: 1;
|
|
|
|
unsigned int h_jdata: 1;
|
|
|
|
unsigned int h_reserved: 1;
|
|
|
|
unsigned int h_aborted: 1;
|
|
|
|
unsigned int h_type: 8;
|
|
|
|
unsigned int h_line_no: 16;
|
2013-02-09 02:00:22 +08:00
|
|
|
|
|
|
|
unsigned long h_start_jiffies;
|
|
|
|
unsigned int h_requested_credits;
|
2017-05-04 05:53:22 +08:00
|
|
|
|
|
|
|
unsigned int saved_alloc_context;
|
2006-10-11 16:20:57 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-01-29 12:58:27 +08:00
|
|
|
/*
|
|
|
|
* Some stats for checkpoint phase
|
|
|
|
*/
|
|
|
|
struct transaction_chp_stats_s {
|
|
|
|
unsigned long cs_chp_time;
|
2009-09-30 12:32:06 +08:00
|
|
|
__u32 cs_forced_to_close;
|
|
|
|
__u32 cs_written;
|
|
|
|
__u32 cs_dropped;
|
2008-01-29 12:58:27 +08:00
|
|
|
};
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/* The transaction_t type is the guts of the journaling mechanism. It
|
|
|
|
* tracks a compound transaction through its various states:
|
|
|
|
*
|
|
|
|
* RUNNING: accepting new updates
|
|
|
|
* LOCKED: Updates still running but we don't accept new ones
|
|
|
|
* RUNDOWN: Updates are tidying up but have finished requesting
|
|
|
|
* new buffers to modify (state not used for now)
|
|
|
|
* FLUSH: All updates complete, but we are still writing to disk
|
|
|
|
* COMMIT: All data on disk, writing commit record
|
|
|
|
* FINISHED: We still have to keep the transaction for checkpointing.
|
|
|
|
*
|
|
|
|
* The transaction keeps track of all of the buffers modified by a
|
|
|
|
* running transaction, and all of the buffers committed but not yet
|
|
|
|
* flushed to home for finished transactions.
|
2020-10-15 21:24:52 +08:00
|
|
|
* (Locking Documentation improved by LockDoc)
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock ranking:
|
|
|
|
*
|
|
|
|
* j_list_lock
|
|
|
|
* ->jbd_lock_bh_journal_head() (This is "innermost")
|
|
|
|
*
|
|
|
|
* j_state_lock
|
2019-08-09 20:42:32 +08:00
|
|
|
* ->b_state_lock
|
2006-10-11 16:20:57 +08:00
|
|
|
*
|
2019-08-09 20:42:32 +08:00
|
|
|
* b_state_lock
|
2006-10-11 16:20:57 +08:00
|
|
|
* ->j_list_lock
|
|
|
|
*
|
|
|
|
* j_state_lock
|
|
|
|
* ->t_handle_lock
|
|
|
|
*
|
|
|
|
* j_state_lock
|
|
|
|
* ->j_list_lock (journal_unmap_buffer)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct transaction_s
|
|
|
|
{
|
|
|
|
/* Pointer to the journal for this transaction. [no locking] */
|
|
|
|
journal_t *t_journal;
|
|
|
|
|
|
|
|
/* Sequence number for this transaction [no locking] */
|
|
|
|
tid_t t_tid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Transaction's current state
|
2006-10-11 16:20:59 +08:00
|
|
|
* [no locking - only kjournald2 alters this]
|
2008-01-29 12:58:27 +08:00
|
|
|
* [j_list_lock] guards transition of a transaction into T_FINISHED
|
|
|
|
* state and subsequent call of __jbd2_journal_drop_transaction()
|
2006-10-11 16:20:57 +08:00
|
|
|
* FIXME: needs barriers
|
|
|
|
* KLUDGE: [use j_state_lock]
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
T_RUNNING,
|
|
|
|
T_LOCKED,
|
2018-12-04 12:16:07 +08:00
|
|
|
T_SWITCH,
|
2006-10-11 16:20:57 +08:00
|
|
|
T_FLUSH,
|
|
|
|
T_COMMIT,
|
2011-05-24 23:59:18 +08:00
|
|
|
T_COMMIT_DFLUSH,
|
|
|
|
T_COMMIT_JFLUSH,
|
2013-04-04 10:06:52 +08:00
|
|
|
T_COMMIT_CALLBACK,
|
2006-10-11 16:20:57 +08:00
|
|
|
T_FINISHED
|
|
|
|
} t_state;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Where in the log does this transaction's commit start? [no locking]
|
|
|
|
*/
|
|
|
|
unsigned long t_log_start;
|
|
|
|
|
2021-02-12 01:14:10 +08:00
|
|
|
/*
|
|
|
|
* Number of buffers on the t_buffers list [j_list_lock, no locks
|
|
|
|
* needed for jbd2 thread]
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
int t_nr_buffers;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Doubly-linked circular list of all buffers reserved but not yet
|
2021-02-12 01:14:10 +08:00
|
|
|
* modified by this transaction [j_list_lock, no locks needed fo
|
|
|
|
* jbd2 thread]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
struct journal_head *t_reserved_list;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Doubly-linked circular list of all metadata buffers owned by this
|
2021-02-12 01:14:10 +08:00
|
|
|
* transaction [j_list_lock, no locks needed for jbd2 thread]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
struct journal_head *t_buffers;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Doubly-linked circular list of all forget buffers (superseded
|
|
|
|
* buffers which we can un-checkpoint once this transaction commits)
|
|
|
|
* [j_list_lock]
|
|
|
|
*/
|
|
|
|
struct journal_head *t_forget;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Doubly-linked circular list of all buffers still to be flushed before
|
|
|
|
* this transaction can be checkpointed. [j_list_lock]
|
|
|
|
*/
|
|
|
|
struct journal_head *t_checkpoint_list;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Doubly-linked circular list of all buffers submitted for IO while
|
|
|
|
* checkpointing. [j_list_lock]
|
|
|
|
*/
|
|
|
|
struct journal_head *t_checkpoint_io_list;
|
|
|
|
|
|
|
|
/*
|
2021-02-12 01:14:10 +08:00
|
|
|
* Doubly-linked circular list of metadata buffers being
|
|
|
|
* shadowed by log IO. The IO buffers on the iobuf list and
|
|
|
|
* the shadow buffers on this list match each other one for
|
|
|
|
* one at all times. [j_list_lock, no locks needed for jbd2
|
|
|
|
* thread]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
struct journal_head *t_shadow_list;
|
|
|
|
|
2008-07-12 07:27:31 +08:00
|
|
|
/*
|
2020-10-06 08:48:39 +08:00
|
|
|
* List of inodes associated with the transaction; e.g., ext4 uses
|
|
|
|
* this to track inodes in data=ordered and data=journal mode that
|
|
|
|
* need special handling on transaction commit; also used by ocfs2.
|
2008-07-12 07:27:31 +08:00
|
|
|
* [j_list_lock]
|
|
|
|
*/
|
|
|
|
struct list_head t_inode_list;
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* Protects info related to handles
|
|
|
|
*/
|
|
|
|
spinlock_t t_handle_lock;
|
|
|
|
|
2008-01-29 12:58:27 +08:00
|
|
|
/*
|
|
|
|
* Longest time some handle had to wait for running transaction
|
|
|
|
*/
|
|
|
|
unsigned long t_max_wait;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When transaction started
|
|
|
|
*/
|
|
|
|
unsigned long t_start;
|
|
|
|
|
2013-02-07 11:30:23 +08:00
|
|
|
/*
|
2020-10-15 21:24:52 +08:00
|
|
|
* When commit was requested [j_state_lock]
|
2013-02-07 11:30:23 +08:00
|
|
|
*/
|
|
|
|
unsigned long t_requested;
|
|
|
|
|
2008-01-29 12:58:27 +08:00
|
|
|
/*
|
2020-10-15 21:24:52 +08:00
|
|
|
* Checkpointing stats [j_list_lock]
|
2008-01-29 12:58:27 +08:00
|
|
|
*/
|
|
|
|
struct transaction_chp_stats_s t_chp_stats;
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* Number of outstanding updates running on this transaction
|
2018-12-04 13:30:22 +08:00
|
|
|
* [none]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
2010-08-02 20:43:25 +08:00
|
|
|
atomic_t t_updates;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
2019-11-06 00:44:24 +08:00
|
|
|
* Number of blocks reserved for this transaction in the journal.
|
|
|
|
* This is including all credits reserved when starting transaction
|
|
|
|
* handles as well as all journal descriptor blocks needed for this
|
|
|
|
* transaction. [none]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
2010-08-02 20:43:25 +08:00
|
|
|
atomic_t t_outstanding_credits;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2019-11-06 00:44:26 +08:00
|
|
|
/*
|
|
|
|
* Number of revoke records for this transaction added by already
|
|
|
|
* stopped handles. [none]
|
|
|
|
*/
|
|
|
|
atomic_t t_outstanding_revokes;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* How many handles used this transaction? [none]
|
|
|
|
*/
|
|
|
|
atomic_t t_handle_count;
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* Forward and backward links for the circular list of all transactions
|
|
|
|
* awaiting checkpoint. [j_list_lock]
|
|
|
|
*/
|
|
|
|
transaction_t *t_cpnext, *t_cpprev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When will the transaction expire (become due for commit), in jiffies?
|
|
|
|
* [no locking]
|
|
|
|
*/
|
|
|
|
unsigned long t_expires;
|
|
|
|
|
2008-11-26 14:14:26 +08:00
|
|
|
/*
|
|
|
|
* When this transaction started, in nanoseconds [no locking]
|
|
|
|
*/
|
|
|
|
ktime_t t_start_time;
|
|
|
|
|
2009-03-26 11:35:46 +08:00
|
|
|
/*
|
|
|
|
* This transaction is being forced and some process is
|
|
|
|
* waiting for it to finish.
|
|
|
|
*/
|
2009-08-18 10:38:04 +08:00
|
|
|
unsigned int t_synchronous_commit:1;
|
2011-05-24 23:52:40 +08:00
|
|
|
|
|
|
|
/* Disk flush needs to be sent to fs partition [no locking] */
|
|
|
|
int t_need_data_flush;
|
2009-03-26 11:35:46 +08:00
|
|
|
|
2008-10-17 08:00:24 +08:00
|
|
|
/*
|
|
|
|
* For use by the filesystem to store fs-specific data
|
|
|
|
* structures associated with the transaction
|
|
|
|
*/
|
|
|
|
struct list_head t_private_list;
|
2006-10-11 16:20:57 +08:00
|
|
|
};
|
|
|
|
|
2008-01-29 12:58:27 +08:00
|
|
|
struct transaction_run_stats_s {
|
|
|
|
unsigned long rs_wait;
|
2013-02-07 11:30:23 +08:00
|
|
|
unsigned long rs_request_delay;
|
2008-01-29 12:58:27 +08:00
|
|
|
unsigned long rs_running;
|
|
|
|
unsigned long rs_locked;
|
|
|
|
unsigned long rs_flushing;
|
|
|
|
unsigned long rs_logging;
|
|
|
|
|
2009-09-30 12:32:06 +08:00
|
|
|
__u32 rs_handle_count;
|
|
|
|
__u32 rs_blocks;
|
|
|
|
__u32 rs_blocks_logged;
|
2008-01-29 12:58:27 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct transaction_stats_s {
|
|
|
|
unsigned long ts_tid;
|
2013-02-07 11:30:23 +08:00
|
|
|
unsigned long ts_requested;
|
2009-09-30 12:32:06 +08:00
|
|
|
struct transaction_run_stats_s run;
|
2008-01-29 12:58:27 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline unsigned long
|
|
|
|
jbd2_time_diff(unsigned long start, unsigned long end)
|
|
|
|
{
|
|
|
|
if (end >= start)
|
|
|
|
return end - start;
|
|
|
|
|
|
|
|
return end + (MAX_JIFFY_OFFSET - start);
|
|
|
|
}
|
|
|
|
|
2008-11-05 13:09:22 +08:00
|
|
|
#define JBD2_NR_BATCH 64
|
|
|
|
|
2020-10-16 04:37:58 +08:00
|
|
|
enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY};
|
|
|
|
|
|
|
|
#define JBD2_FC_REPLAY_STOP 0
|
|
|
|
#define JBD2_FC_REPLAY_CONTINUE 1
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/**
|
|
|
|
* struct journal_s - The journal_s type is the concrete type associated with
|
|
|
|
* journal_t.
|
|
|
|
*/
|
|
|
|
struct journal_s
|
|
|
|
{
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
2021-02-11 17:51:55 +08:00
|
|
|
* @j_flags: General journaling state flags [j_state_lock,
|
|
|
|
* no lock for quick racy checks]
|
2018-01-10 13:27:29 +08:00
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
unsigned long j_flags;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_errno:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Is there an outstanding uncleared error on the journal (from a prior
|
|
|
|
* abort)? [j_state_lock]
|
|
|
|
*/
|
|
|
|
int j_errno;
|
|
|
|
|
2020-06-09 15:35:40 +08:00
|
|
|
/**
|
|
|
|
* @j_abort_mutex: Lock the whole aborting procedure.
|
|
|
|
*/
|
|
|
|
struct mutex j_abort_mutex;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_sb_buffer: The first part of the superblock buffer.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
struct buffer_head *j_sb_buffer;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_superblock: The second part of the superblock buffer.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
journal_superblock_t *j_superblock;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_format_version: Version of the superblock format.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
int j_format_version;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_state_lock: Protect the various scalars in the journal.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
2010-08-04 09:35:12 +08:00
|
|
|
rwlock_t j_state_lock;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_barrier_count:
|
|
|
|
*
|
2021-02-11 17:51:55 +08:00
|
|
|
* Number of processes waiting to create a barrier lock [j_state_lock,
|
|
|
|
* no lock for quick racy checks]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
int j_barrier_count;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_barrier: The barrier lock itself.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
struct mutex j_barrier;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_running_transaction:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Transactions: The current running transaction...
|
2021-02-11 17:51:55 +08:00
|
|
|
* [j_state_lock, no lock for quick racy checks] [caller holding
|
|
|
|
* open handle]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
transaction_t *j_running_transaction;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_committing_transaction:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* the transaction we are pushing to disk
|
|
|
|
* [j_state_lock] [caller holding open handle]
|
|
|
|
*/
|
|
|
|
transaction_t *j_committing_transaction;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_checkpoint_transactions:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* ... and a linked circular list of all transactions waiting for
|
|
|
|
* checkpointing. [j_list_lock]
|
|
|
|
*/
|
|
|
|
transaction_t *j_checkpoint_transactions;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wait_transaction_locked:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Wait queue for waiting for a locked transaction to start committing,
|
2018-01-10 13:27:29 +08:00
|
|
|
* or for a barrier lock to be released.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
wait_queue_head_t j_wait_transaction_locked;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wait_done_commit: Wait queue for waiting for commit to complete.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
wait_queue_head_t j_wait_done_commit;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wait_commit: Wait queue to trigger commit.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
wait_queue_head_t j_wait_commit;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wait_updates: Wait queue to wait for updates to complete.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
wait_queue_head_t j_wait_updates;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wait_reserved:
|
|
|
|
*
|
|
|
|
* Wait queue to wait for reserved buffer credits to drop.
|
|
|
|
*/
|
2013-06-05 00:35:11 +08:00
|
|
|
wait_queue_head_t j_wait_reserved;
|
|
|
|
|
2020-10-16 04:37:56 +08:00
|
|
|
/**
|
|
|
|
* @j_fc_wait:
|
|
|
|
*
|
|
|
|
* Wait queue to wait for completion of async fast commits.
|
|
|
|
*/
|
|
|
|
wait_queue_head_t j_fc_wait;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_checkpoint_mutex:
|
|
|
|
*
|
|
|
|
* Semaphore for locking against concurrent checkpoints.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
struct mutex j_checkpoint_mutex;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_chkpt_bhs:
|
|
|
|
*
|
2008-11-05 13:09:22 +08:00
|
|
|
* List of buffer heads used by the checkpoint routine. This
|
|
|
|
* was moved from jbd2_log_do_checkpoint() to reduce stack
|
|
|
|
* usage. Access to this array is controlled by the
|
2018-01-10 13:27:29 +08:00
|
|
|
* @j_checkpoint_mutex. [j_checkpoint_mutex]
|
2008-11-05 13:09:22 +08:00
|
|
|
*/
|
|
|
|
struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_head:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Journal head: identifies the first unused block in the journal.
|
|
|
|
* [j_state_lock]
|
|
|
|
*/
|
|
|
|
unsigned long j_head;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_tail:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Journal tail: identifies the oldest still-used block in the journal.
|
|
|
|
* [j_state_lock]
|
|
|
|
*/
|
|
|
|
unsigned long j_tail;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_free:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Journal free: how many free blocks are there in the journal?
|
|
|
|
* [j_state_lock]
|
|
|
|
*/
|
|
|
|
unsigned long j_free;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_first:
|
|
|
|
*
|
|
|
|
* The block number of the first usable block in the journal
|
|
|
|
* [j_state_lock].
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
unsigned long j_first;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_last:
|
|
|
|
*
|
|
|
|
* The block number one beyond the last usable block in the journal
|
|
|
|
* [j_state_lock].
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
unsigned long j_last;
|
|
|
|
|
2020-10-16 04:37:55 +08:00
|
|
|
/**
|
|
|
|
* @j_fc_first:
|
|
|
|
*
|
|
|
|
* The block number of the first fast commit block in the journal
|
|
|
|
* [j_state_lock].
|
|
|
|
*/
|
|
|
|
unsigned long j_fc_first;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_fc_off:
|
|
|
|
*
|
2020-11-06 11:58:57 +08:00
|
|
|
* Number of fast commit blocks currently allocated. Accessed only
|
|
|
|
* during fast commit. Currently only process can do fast commit, so
|
|
|
|
* this field is not protected by any lock.
|
2020-10-16 04:37:55 +08:00
|
|
|
*/
|
|
|
|
unsigned long j_fc_off;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_fc_last:
|
|
|
|
*
|
|
|
|
* The block number one beyond the last fast commit block in the journal
|
|
|
|
* [j_state_lock].
|
|
|
|
*/
|
|
|
|
unsigned long j_fc_last;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_dev: Device where we store the journal.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
struct block_device *j_dev;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_blocksize: Block size for the location where we store the journal.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
int j_blocksize;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_blk_offset:
|
|
|
|
*
|
|
|
|
* Starting block offset into the device where we store the journal.
|
|
|
|
*/
|
2008-09-17 02:36:17 +08:00
|
|
|
unsigned long long j_blk_offset;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_devname: Journal device name.
|
|
|
|
*/
|
2008-09-17 02:36:17 +08:00
|
|
|
char j_devname[BDEVNAME_SIZE+24];
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_fs_dev:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Device which holds the client fs. For internal journal this will be
|
|
|
|
* equal to j_dev.
|
|
|
|
*/
|
|
|
|
struct block_device *j_fs_dev;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
2020-11-06 11:58:54 +08:00
|
|
|
* @j_total_len: Total maximum capacity of the journal region on disk.
|
2018-01-10 13:27:29 +08:00
|
|
|
*/
|
2020-11-06 11:58:54 +08:00
|
|
|
unsigned int j_total_len;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_reserved_credits:
|
|
|
|
*
|
|
|
|
* Number of buffers reserved from the running transaction.
|
|
|
|
*/
|
2013-06-05 00:35:11 +08:00
|
|
|
atomic_t j_reserved_credits;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_list_lock: Protects the buffer lists and internal buffer state.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
spinlock_t j_list_lock;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_inode:
|
|
|
|
*
|
|
|
|
* Optional inode where we store the journal. If present, all
|
|
|
|
* journal block numbers are mapped into this inode via bmap().
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
struct inode *j_inode;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_tail_sequence:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Sequence number of the oldest transaction in the log [j_state_lock]
|
|
|
|
*/
|
|
|
|
tid_t j_tail_sequence;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_transaction_sequence:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Sequence number of the next transaction to grant [j_state_lock]
|
|
|
|
*/
|
|
|
|
tid_t j_transaction_sequence;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_commit_sequence:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Sequence number of the most recently committed transaction
|
2021-02-11 17:51:55 +08:00
|
|
|
* [j_state_lock, no lock for quick racy checks]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
tid_t j_commit_sequence;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_commit_request:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Sequence number of the most recent transaction wanting commit
|
2021-02-11 17:51:55 +08:00
|
|
|
* [j_state_lock, no lock for quick racy checks]
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
tid_t j_commit_request;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_uuid:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Journal uuid: identifies the object (filesystem, LVM volume etc)
|
|
|
|
* backed by this journal. This will eventually be replaced by an array
|
|
|
|
* of uuids, allowing us to index multiple devices within a single
|
|
|
|
* journal and to perform atomic updates across them.
|
|
|
|
*/
|
|
|
|
__u8 j_uuid[16];
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_task: Pointer to the current commit thread for this journal.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
struct task_struct *j_task;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_max_transaction_buffers:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* Maximum number of metadata buffers to allow in a single compound
|
2018-01-10 13:27:29 +08:00
|
|
|
* commit transaction.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
int j_max_transaction_buffers;
|
|
|
|
|
2019-11-06 00:44:26 +08:00
|
|
|
/**
|
|
|
|
* @j_revoke_records_per_block:
|
|
|
|
*
|
|
|
|
* Number of revoke records that fit in one descriptor block.
|
|
|
|
*/
|
|
|
|
int j_revoke_records_per_block;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_commit_interval:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* What is the maximum transaction lifetime before we begin a commit?
|
|
|
|
*/
|
|
|
|
unsigned long j_commit_interval;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_commit_timer: The timer used to wakeup the commit thread.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
struct timer_list j_commit_timer;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_revoke_lock: Protect the revoke table.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
spinlock_t j_revoke_lock;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_revoke:
|
|
|
|
*
|
|
|
|
* The revoke table - maintains the list of revoked blocks in the
|
|
|
|
* current transaction.
|
|
|
|
*/
|
2006-10-11 16:20:59 +08:00
|
|
|
struct jbd2_revoke_table_s *j_revoke;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_revoke_table: Alternate revoke tables for j_revoke.
|
|
|
|
*/
|
2006-10-11 16:20:59 +08:00
|
|
|
struct jbd2_revoke_table_s *j_revoke_table[2];
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wbuf: Array of bhs for jbd2_journal_commit_transaction.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
struct buffer_head **j_wbuf;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
2020-10-16 04:37:55 +08:00
|
|
|
/**
|
2020-11-06 11:58:57 +08:00
|
|
|
* @j_fc_wbuf: Array of fast commit bhs for fast commit. Accessed only
|
|
|
|
* during a fast commit. Currently only process can do fast commit, so
|
|
|
|
* this field is not protected by any lock.
|
2020-10-16 04:37:55 +08:00
|
|
|
*/
|
|
|
|
struct buffer_head **j_fc_wbuf;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_wbufsize:
|
|
|
|
*
|
|
|
|
* Size of @j_wbuf array.
|
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
int j_wbufsize;
|
|
|
|
|
2020-10-16 04:37:55 +08:00
|
|
|
/**
|
|
|
|
* @j_fc_wbufsize:
|
|
|
|
*
|
|
|
|
* Size of @j_fc_wbuf array.
|
|
|
|
*/
|
|
|
|
int j_fc_wbufsize;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_last_sync_writer:
|
|
|
|
*
|
|
|
|
* The pid of the last person to run a synchronous operation
|
|
|
|
* through the journal.
|
2008-11-26 14:14:26 +08:00
|
|
|
*/
|
2006-10-11 16:20:57 +08:00
|
|
|
pid_t j_last_sync_writer;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_average_commit_time:
|
|
|
|
*
|
|
|
|
* The average amount of time in nanoseconds it takes to commit a
|
2008-11-26 14:14:26 +08:00
|
|
|
* transaction to disk. [j_state_lock]
|
|
|
|
*/
|
|
|
|
u64 j_average_commit_time;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_min_batch_time:
|
|
|
|
*
|
|
|
|
* Minimum time that we should wait for additional filesystem operations
|
|
|
|
* to get batched into a synchronous handle in microseconds.
|
2009-01-04 09:27:38 +08:00
|
|
|
*/
|
|
|
|
u32 j_min_batch_time;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_max_batch_time:
|
|
|
|
*
|
|
|
|
* Maximum time that we should wait for additional filesystem operations
|
|
|
|
* to get batched into a synchronous handle in microseconds.
|
|
|
|
*/
|
2009-01-04 09:27:38 +08:00
|
|
|
u32 j_max_batch_time;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_commit_callback:
|
|
|
|
*
|
|
|
|
* This function is called when a transaction is closed.
|
|
|
|
*/
|
2008-10-17 08:00:24 +08:00
|
|
|
void (*j_commit_callback)(journal_t *,
|
|
|
|
transaction_t *);
|
|
|
|
|
2020-10-06 08:48:39 +08:00
|
|
|
/**
|
|
|
|
* @j_submit_inode_data_buffers:
|
|
|
|
*
|
|
|
|
* This function is called for all inodes associated with the
|
|
|
|
* committing transaction marked with JI_WRITE_DATA flag
|
|
|
|
* before we start to write out the transaction to the journal.
|
|
|
|
*/
|
|
|
|
int (*j_submit_inode_data_buffers)
|
|
|
|
(struct jbd2_inode *);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_finish_inode_data_buffers:
|
|
|
|
*
|
|
|
|
* This function is called for all inodes associated with the
|
|
|
|
* committing transaction marked with JI_WAIT_DATA flag
|
|
|
|
* after we have written the transaction to the journal
|
|
|
|
* but before we write out the commit block.
|
|
|
|
*/
|
|
|
|
int (*j_finish_inode_data_buffers)
|
|
|
|
(struct jbd2_inode *);
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
2008-01-29 12:58:27 +08:00
|
|
|
* Journal statistics
|
|
|
|
*/
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_history_lock: Protect the transactions statistics history.
|
|
|
|
*/
|
2008-01-29 12:58:27 +08:00
|
|
|
spinlock_t j_history_lock;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_proc_entry: procfs entry for the jbd statistics directory.
|
|
|
|
*/
|
2008-01-29 12:58:27 +08:00
|
|
|
struct proc_dir_entry *j_proc_entry;
|
2018-01-10 13:27:29 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_stats: Overall statistics.
|
|
|
|
*/
|
2008-01-29 12:58:27 +08:00
|
|
|
struct transaction_stats_s j_stats;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_failed_commit: Failed journal commit ID.
|
|
|
|
*/
|
2008-06-07 05:50:40 +08:00
|
|
|
unsigned int j_failed_commit;
|
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_private:
|
|
|
|
*
|
2006-10-11 16:20:57 +08:00
|
|
|
* An opaque pointer to fs-private information. ext3 puts its
|
2018-01-10 13:27:29 +08:00
|
|
|
* superblock pointer here.
|
2006-10-11 16:20:57 +08:00
|
|
|
*/
|
|
|
|
void *j_private;
|
2012-05-27 19:50:56 +08:00
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_chksum_driver:
|
|
|
|
*
|
|
|
|
* Reference to checksum algorithm driver via cryptoapi.
|
|
|
|
*/
|
2012-05-27 19:50:56 +08:00
|
|
|
struct crypto_shash *j_chksum_driver;
|
2012-05-27 20:08:22 +08:00
|
|
|
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_csum_seed:
|
|
|
|
*
|
|
|
|
* Precomputed journal UUID checksum for seeding other checksums.
|
|
|
|
*/
|
2012-05-27 20:08:22 +08:00
|
|
|
__u32 j_csum_seed;
|
2016-06-30 23:39:38 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
2018-01-10 13:27:29 +08:00
|
|
|
/**
|
|
|
|
* @j_trans_commit_map:
|
|
|
|
*
|
2016-06-30 23:39:38 +08:00
|
|
|
* Lockdep entity to track transaction commit dependencies. Handles
|
|
|
|
* hold this "lock" for read, when we wait for commit, we acquire the
|
|
|
|
* "lock" for writing. This matches the properties of jbd2 journalling
|
|
|
|
* where the running transaction has to wait for all handles to be
|
|
|
|
* dropped to commit that transaction and also acquiring a handle may
|
|
|
|
* require transaction commit to finish.
|
|
|
|
*/
|
|
|
|
struct lockdep_map j_trans_commit_map;
|
|
|
|
#endif
|
2020-10-16 04:37:56 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @j_fc_cleanup_callback:
|
|
|
|
*
|
|
|
|
* Clean-up after fast commit or full commit. JBD2 calls this function
|
|
|
|
* after every commit operation.
|
|
|
|
*/
|
|
|
|
void (*j_fc_cleanup_callback)(struct journal_s *journal, int);
|
|
|
|
|
2020-10-27 17:51:27 +08:00
|
|
|
/**
|
2020-10-16 04:37:58 +08:00
|
|
|
* @j_fc_replay_callback:
|
|
|
|
*
|
|
|
|
* File-system specific function that performs replay of a fast
|
|
|
|
* commit. JBD2 calls this function for each fast commit block found in
|
|
|
|
* the journal. This function should return JBD2_FC_REPLAY_CONTINUE
|
|
|
|
* to indicate that the block was processed correctly and more fast
|
|
|
|
* commit replay should continue. Return value of JBD2_FC_REPLAY_STOP
|
|
|
|
* indicates the end of replay (no more blocks remaining). A negative
|
|
|
|
* return value indicates error.
|
|
|
|
*/
|
|
|
|
int (*j_fc_replay_callback)(struct journal_s *journal,
|
|
|
|
struct buffer_head *bh,
|
|
|
|
enum passtype pass, int off,
|
|
|
|
tid_t expected_commit_id);
|
2006-10-11 16:20:57 +08:00
|
|
|
};
|
|
|
|
|
2016-06-30 23:40:54 +08:00
|
|
|
#define jbd2_might_wait_for_commit(j) \
|
|
|
|
do { \
|
|
|
|
rwsem_acquire(&j->j_trans_commit_map, 0, 0, _THIS_IP_); \
|
2019-09-20 00:09:40 +08:00
|
|
|
rwsem_release(&j->j_trans_commit_map, _THIS_IP_); \
|
2016-06-30 23:40:54 +08:00
|
|
|
} while (0)
|
|
|
|
|
2015-10-18 04:18:45 +08:00
|
|
|
/* journal feature predicate functions */
|
|
|
|
#define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
|
|
|
|
static inline bool jbd2_has_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
return ((j)->j_format_version >= 2 && \
|
|
|
|
((j)->j_superblock->s_feature_compat & \
|
|
|
|
cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
|
|
|
|
} \
|
|
|
|
static inline void jbd2_set_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
(j)->j_superblock->s_feature_compat |= \
|
|
|
|
cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
|
|
|
|
} \
|
|
|
|
static inline void jbd2_clear_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
(j)->j_superblock->s_feature_compat &= \
|
|
|
|
~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
|
|
|
|
static inline bool jbd2_has_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
return ((j)->j_format_version >= 2 && \
|
|
|
|
((j)->j_superblock->s_feature_ro_compat & \
|
|
|
|
cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
|
|
|
|
} \
|
|
|
|
static inline void jbd2_set_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
(j)->j_superblock->s_feature_ro_compat |= \
|
|
|
|
cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
|
|
|
|
} \
|
|
|
|
static inline void jbd2_clear_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
(j)->j_superblock->s_feature_ro_compat &= \
|
|
|
|
~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
|
|
|
|
static inline bool jbd2_has_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
return ((j)->j_format_version >= 2 && \
|
|
|
|
((j)->j_superblock->s_feature_incompat & \
|
|
|
|
cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
|
|
|
|
} \
|
|
|
|
static inline void jbd2_set_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
(j)->j_superblock->s_feature_incompat |= \
|
|
|
|
cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
|
|
|
|
} \
|
|
|
|
static inline void jbd2_clear_feature_##name(journal_t *j) \
|
|
|
|
{ \
|
|
|
|
(j)->j_superblock->s_feature_incompat &= \
|
|
|
|
~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
|
|
|
|
}
|
|
|
|
|
|
|
|
JBD2_FEATURE_COMPAT_FUNCS(checksum, CHECKSUM)
|
|
|
|
|
|
|
|
JBD2_FEATURE_INCOMPAT_FUNCS(revoke, REVOKE)
|
|
|
|
JBD2_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
|
|
|
|
JBD2_FEATURE_INCOMPAT_FUNCS(async_commit, ASYNC_COMMIT)
|
|
|
|
JBD2_FEATURE_INCOMPAT_FUNCS(csum2, CSUM_V2)
|
|
|
|
JBD2_FEATURE_INCOMPAT_FUNCS(csum3, CSUM_V3)
|
2020-10-16 04:37:54 +08:00
|
|
|
JBD2_FEATURE_INCOMPAT_FUNCS(fast_commit, FAST_COMMIT)
|
2015-10-18 04:18:45 +08:00
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* Journal flag definitions
|
|
|
|
*/
|
2006-10-11 16:20:59 +08:00
|
|
|
#define JBD2_UNMOUNT 0x001 /* Journal thread is being destroyed */
|
|
|
|
#define JBD2_ABORT 0x002 /* Journaling has been aborted for errors. */
|
|
|
|
#define JBD2_ACK_ERR 0x004 /* The errno in the sb has been acked */
|
|
|
|
#define JBD2_FLUSHED 0x008 /* The journal superblock has been flushed */
|
|
|
|
#define JBD2_LOADED 0x010 /* The journal superblock has been loaded */
|
|
|
|
#define JBD2_BARRIER 0x020 /* Use IDE barriers */
|
2008-10-11 10:12:43 +08:00
|
|
|
#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file
|
|
|
|
* data write error in ordered
|
|
|
|
* mode */
|
2020-10-16 04:37:56 +08:00
|
|
|
#define JBD2_FAST_COMMIT_ONGOING 0x100 /* Fast commit is ongoing */
|
|
|
|
#define JBD2_FULL_COMMIT_ONGOING 0x200 /* Full commit is ongoing */
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Function declarations for the journaling transaction and buffer
|
|
|
|
* management
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Filing buffers */
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
|
2019-08-09 20:42:29 +08:00
|
|
|
extern bool __jbd2_journal_refile_buffer(struct journal_head *);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
|
|
|
|
extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
|
2006-10-11 16:20:57 +08:00
|
|
|
extern void __journal_free_buffer(struct journal_head *bh);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
|
2006-10-11 16:20:57 +08:00
|
|
|
extern void __journal_clean_data_list(transaction_t *transaction);
|
2013-06-05 00:01:45 +08:00
|
|
|
static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
list_add_tail(&bh->b_assoc_buffers, head);
|
|
|
|
}
|
|
|
|
static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
list_del_init(&bh->b_assoc_buffers);
|
|
|
|
}
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Log buffer allocation */
|
2016-02-23 12:17:15 +08:00
|
|
|
struct buffer_head *jbd2_journal_get_descriptor_buffer(transaction_t *, int);
|
2016-02-23 12:19:09 +08:00
|
|
|
void jbd2_descriptor_block_csum_set(journal_t *, struct buffer_head *);
|
2006-10-11 16:21:13 +08:00
|
|
|
int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
|
2012-03-14 10:22:54 +08:00
|
|
|
int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
|
|
|
|
unsigned long *block);
|
2015-06-16 02:36:01 +08:00
|
|
|
int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
|
2012-03-14 10:45:38 +08:00
|
|
|
void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Commit management */
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_commit_transaction(journal_t *);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Checkpoint list management */
|
2015-07-29 02:57:14 +08:00
|
|
|
void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy);
|
2006-10-11 16:20:59 +08:00
|
|
|
int __jbd2_journal_remove_checkpoint(struct journal_head *);
|
2015-07-29 02:57:14 +08:00
|
|
|
void jbd2_journal_destroy_checkpoint(journal_t *journal);
|
2006-10-11 16:20:59 +08:00
|
|
|
void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2008-09-12 06:35:47 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Triggers
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct jbd2_buffer_trigger_type {
|
|
|
|
/*
|
2010-07-14 13:56:33 +08:00
|
|
|
* Fired a the moment data to write to the journal are known to be
|
|
|
|
* stable - so either at the moment b_frozen_data is created or just
|
|
|
|
* before a buffer is written to the journal. mapped_data is a mapped
|
|
|
|
* buffer that is the frozen data for commit.
|
2008-09-12 06:35:47 +08:00
|
|
|
*/
|
2010-07-14 13:56:33 +08:00
|
|
|
void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
|
2008-09-12 06:35:47 +08:00
|
|
|
struct buffer_head *bh, void *mapped_data,
|
|
|
|
size_t size);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fired during journal abort for dirty buffers that will not be
|
|
|
|
* committed.
|
|
|
|
*/
|
|
|
|
void (*t_abort)(struct jbd2_buffer_trigger_type *type,
|
|
|
|
struct buffer_head *bh);
|
|
|
|
};
|
|
|
|
|
2010-07-14 13:56:33 +08:00
|
|
|
extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
|
2008-09-12 06:35:47 +08:00
|
|
|
void *mapped_data,
|
|
|
|
struct jbd2_buffer_trigger_type *triggers);
|
|
|
|
extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
|
|
|
|
struct jbd2_buffer_trigger_type *triggers);
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/* Buffer IO */
|
2013-06-05 00:01:45 +08:00
|
|
|
extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
|
|
|
|
struct journal_head *jh_in,
|
|
|
|
struct buffer_head **bh_out,
|
|
|
|
sector_t blocknr);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Transaction locking */
|
|
|
|
extern void __wait_on_journal (journal_t *);
|
|
|
|
|
2012-02-21 06:53:02 +08:00
|
|
|
/* Transaction cache support */
|
|
|
|
extern void jbd2_journal_destroy_transaction_cache(void);
|
2019-05-11 09:15:47 +08:00
|
|
|
extern int __init jbd2_journal_init_transaction_cache(void);
|
2012-02-21 06:53:02 +08:00
|
|
|
extern void jbd2_journal_free_transaction(transaction_t *);
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* Journal locking.
|
|
|
|
*
|
|
|
|
* We need to lock the journal during transaction state changes so that nobody
|
|
|
|
* ever tries to take a handle on the running transaction while we are in the
|
|
|
|
* middle of moving it to the commit phase. j_state_lock does this.
|
|
|
|
*
|
|
|
|
* Note that the locking is completely interrupt unsafe. We never touch
|
|
|
|
* journal structures from interrupts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline handle_t *journal_current_handle(void)
|
|
|
|
{
|
|
|
|
return current->journal_info;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The journaling code user interface:
|
|
|
|
*
|
|
|
|
* Create and destroy handles
|
|
|
|
* Register buffer modifications against the current transaction.
|
|
|
|
*/
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
|
2013-06-05 00:35:11 +08:00
|
|
|
extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
|
2019-11-06 00:44:26 +08:00
|
|
|
int revoke_records, gfp_t gfp_mask,
|
|
|
|
unsigned int type, unsigned int line_no);
|
2010-07-27 23:56:05 +08:00
|
|
|
extern int jbd2_journal_restart(handle_t *, int nblocks);
|
2019-11-06 00:44:26 +08:00
|
|
|
extern int jbd2__journal_restart(handle_t *, int nblocks,
|
|
|
|
int revoke_records, gfp_t gfp_mask);
|
2013-06-05 00:35:11 +08:00
|
|
|
extern int jbd2_journal_start_reserved(handle_t *handle,
|
|
|
|
unsigned int type, unsigned int line_no);
|
|
|
|
extern void jbd2_journal_free_reserved(handle_t *handle);
|
2019-11-06 00:44:26 +08:00
|
|
|
extern int jbd2_journal_extend(handle_t *handle, int nblocks,
|
|
|
|
int revoke_records);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
|
|
|
|
extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
|
|
|
|
extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
|
2008-09-12 06:35:47 +08:00
|
|
|
void jbd2_journal_set_triggers(struct buffer_head *,
|
|
|
|
struct jbd2_buffer_trigger_type *type);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
|
|
|
|
extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
|
2012-12-26 02:29:52 +08:00
|
|
|
extern int jbd2_journal_invalidatepage(journal_t *,
|
2013-05-22 11:20:03 +08:00
|
|
|
struct page *, unsigned int, unsigned int);
|
2020-06-20 10:54:27 +08:00
|
|
|
extern int jbd2_journal_try_to_free_buffers(journal_t *journal, struct page *page);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_stop(handle_t *);
|
|
|
|
extern int jbd2_journal_flush (journal_t *);
|
|
|
|
extern void jbd2_journal_lock_updates (journal_t *);
|
|
|
|
extern void jbd2_journal_unlock_updates (journal_t *);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
|
2006-10-11 16:20:57 +08:00
|
|
|
struct block_device *fs_dev,
|
2006-10-11 16:21:13 +08:00
|
|
|
unsigned long long start, int len, int bsize);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern journal_t * jbd2_journal_init_inode (struct inode *);
|
|
|
|
extern int jbd2_journal_update_format (journal_t *);
|
|
|
|
extern int jbd2_journal_check_used_features
|
2006-10-11 16:20:57 +08:00
|
|
|
(journal_t *, unsigned long, unsigned long, unsigned long);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_check_available_features
|
2006-10-11 16:20:57 +08:00
|
|
|
(journal_t *, unsigned long, unsigned long, unsigned long);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_set_features
|
2006-10-11 16:20:57 +08:00
|
|
|
(journal_t *, unsigned long, unsigned long, unsigned long);
|
2008-01-29 12:58:27 +08:00
|
|
|
extern void jbd2_journal_clear_features
|
|
|
|
(journal_t *, unsigned long, unsigned long, unsigned long);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_load (journal_t *journal);
|
2008-10-11 08:29:13 +08:00
|
|
|
extern int jbd2_journal_destroy (journal_t *);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_recover (journal_t *journal);
|
|
|
|
extern int jbd2_journal_wipe (journal_t *, int);
|
|
|
|
extern int jbd2_journal_skip_recovery (journal_t *);
|
2012-08-06 07:04:57 +08:00
|
|
|
extern void jbd2_journal_update_sb_errno(journal_t *);
|
2015-06-16 02:36:01 +08:00
|
|
|
extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
|
2012-03-14 10:22:54 +08:00
|
|
|
unsigned long, int);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_abort (journal_t *, int);
|
|
|
|
extern int jbd2_journal_errno (journal_t *);
|
|
|
|
extern void jbd2_journal_ack_err (journal_t *);
|
|
|
|
extern int jbd2_journal_clear_err (journal_t *);
|
2006-10-11 16:21:13 +08:00
|
|
|
extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_force_commit(journal_t *);
|
2013-06-13 10:24:07 +08:00
|
|
|
extern int jbd2_journal_force_commit_nested(journal_t *);
|
2019-06-21 05:24:56 +08:00
|
|
|
extern int jbd2_journal_inode_ranged_write(handle_t *handle,
|
|
|
|
struct jbd2_inode *inode, loff_t start_byte,
|
|
|
|
loff_t length);
|
|
|
|
extern int jbd2_journal_inode_ranged_wait(handle_t *handle,
|
|
|
|
struct jbd2_inode *inode, loff_t start_byte,
|
|
|
|
loff_t length);
|
2020-10-06 08:48:38 +08:00
|
|
|
extern int jbd2_journal_submit_inode_data_buffers(
|
|
|
|
struct jbd2_inode *jinode);
|
|
|
|
extern int jbd2_journal_finish_inode_data_buffers(
|
|
|
|
struct jbd2_inode *jinode);
|
2009-02-11 00:15:34 +08:00
|
|
|
extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
|
|
|
|
struct jbd2_inode *inode, loff_t new_size);
|
2008-07-12 07:27:31 +08:00
|
|
|
extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
|
|
|
|
extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* journal_head management
|
|
|
|
*/
|
2006-10-11 16:20:59 +08:00
|
|
|
struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
|
|
|
|
struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
|
|
|
|
void jbd2_journal_put_journal_head(struct journal_head *jh);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* handle management
|
|
|
|
*/
|
2006-12-07 12:33:20 +08:00
|
|
|
extern struct kmem_cache *jbd2_handle_cache;
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2007-10-17 06:38:25 +08:00
|
|
|
static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
|
2006-10-11 16:20:57 +08:00
|
|
|
{
|
2013-04-20 05:49:23 +08:00
|
|
|
return kmem_cache_zalloc(jbd2_handle_cache, gfp_flags);
|
2006-10-11 16:20:57 +08:00
|
|
|
}
|
|
|
|
|
2007-10-17 06:38:25 +08:00
|
|
|
static inline void jbd2_free_handle(handle_t *handle)
|
2006-10-11 16:20:57 +08:00
|
|
|
{
|
2006-10-11 16:20:59 +08:00
|
|
|
kmem_cache_free(jbd2_handle_cache, handle);
|
2006-10-11 16:20:57 +08:00
|
|
|
}
|
|
|
|
|
2011-01-11 01:29:43 +08:00
|
|
|
/*
|
|
|
|
* jbd2_inode management (optional, for those file systems that want to use
|
|
|
|
* dynamically allocated jbd2_inode structures)
|
|
|
|
*/
|
|
|
|
extern struct kmem_cache *jbd2_inode_cache;
|
|
|
|
|
|
|
|
static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
|
|
|
|
{
|
|
|
|
return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void jbd2_free_inode(struct jbd2_inode *jinode)
|
|
|
|
{
|
|
|
|
kmem_cache_free(jbd2_inode_cache, jinode);
|
|
|
|
}
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/* Primary revoke support */
|
|
|
|
#define JOURNAL_REVOKE_DEFAULT_HASH 256
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_init_revoke(journal_t *, int);
|
2019-05-11 09:15:47 +08:00
|
|
|
extern void jbd2_journal_destroy_revoke_record_cache(void);
|
|
|
|
extern void jbd2_journal_destroy_revoke_table_cache(void);
|
|
|
|
extern int __init jbd2_journal_init_revoke_record_cache(void);
|
|
|
|
extern int __init jbd2_journal_init_revoke_table_cache(void);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_destroy_revoke(journal_t *);
|
2006-10-11 16:21:13 +08:00
|
|
|
extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
|
2016-02-23 12:07:30 +08:00
|
|
|
extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
|
|
|
|
struct list_head *log_bufs);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/* Recovery revoke support */
|
2006-10-11 16:21:13 +08:00
|
|
|
extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
|
|
|
|
extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
|
2006-10-11 16:20:59 +08:00
|
|
|
extern void jbd2_journal_clear_revoke(journal_t *);
|
|
|
|
extern void jbd2_journal_switch_revoke_table(journal_t *journal);
|
2011-12-29 06:46:46 +08:00
|
|
|
extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The log thread user interface:
|
|
|
|
*
|
|
|
|
* Request space in the current transaction, and force transaction commit
|
|
|
|
* transitions on demand.
|
|
|
|
*/
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
int jbd2_log_start_commit(journal_t *journal, tid_t tid);
|
|
|
|
int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
|
|
|
|
int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
|
|
|
|
int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
|
2017-11-01 23:36:45 +08:00
|
|
|
int jbd2_transaction_committed(journal_t *journal, tid_t tid);
|
ext4/jbd2: don't wait (forever) for stale tid caused by wraparound
In the case where an inode has a very stale transaction id (tid) in
i_datasync_tid or i_sync_tid, it's possible that after a very large
(2**31) number of transactions, that the tid number space might wrap,
causing tid_geq()'s calculations to fail.
Commit deeeaf13 "jbd2: fix fsync() tid wraparound bug", later modified
by commit e7b04ac0 "jbd2: don't wake kjournald unnecessarily",
attempted to fix this problem, but it only avoided kjournald spinning
forever by fixing the logic in jbd2_log_start_commit().
Unfortunately, in the codepaths in fs/ext4/fsync.c and fs/ext4/inode.c
that might call jbd2_log_start_commit() with a stale tid, those
functions will subsequently call jbd2_log_wait_commit() with the same
stale tid, and then wait for a very long time. To fix this, we
replace the calls to jbd2_log_start_commit() and
jbd2_log_wait_commit() with a call to a new function,
jbd2_complete_transaction(), which will correctly handle stale tid's.
As a bonus, jbd2_complete_transaction() will avoid locking
j_state_lock for writing unless a commit needs to be started. This
should have a small (but probably not measurable) improvement for
ext4's scalability.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Reported-by: Ben Hutchings <ben@decadent.org.uk>
Reported-by: George Barnett <gbarnett@atlassian.com>
Cc: stable@vger.kernel.org
2013-04-04 10:02:52 +08:00
|
|
|
int jbd2_complete_transaction(journal_t *journal, tid_t tid);
|
2006-10-11 16:20:59 +08:00
|
|
|
int jbd2_log_do_checkpoint(journal_t *journal);
|
2011-05-24 23:59:18 +08:00
|
|
|
int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
void __jbd2_log_wait_for_space(journal_t *journal);
|
2008-11-07 06:50:21 +08:00
|
|
|
extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
|
|
|
|
extern int jbd2_cleanup_journal_tail(journal_t *);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2020-10-16 04:37:55 +08:00
|
|
|
/* Fast commit related APIs */
|
2020-10-16 04:37:56 +08:00
|
|
|
int jbd2_fc_begin_commit(journal_t *journal, tid_t tid);
|
|
|
|
int jbd2_fc_end_commit(journal_t *journal);
|
2020-11-06 11:58:58 +08:00
|
|
|
int jbd2_fc_end_commit_fallback(journal_t *journal);
|
2020-10-16 04:37:56 +08:00
|
|
|
int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out);
|
|
|
|
int jbd2_submit_inode_data(struct jbd2_inode *jinode);
|
|
|
|
int jbd2_wait_inode_data(journal_t *journal, struct jbd2_inode *jinode);
|
|
|
|
int jbd2_fc_wait_bufs(journal_t *journal, int num_blks);
|
|
|
|
int jbd2_fc_release_bufs(journal_t *journal);
|
|
|
|
|
2020-11-06 11:58:54 +08:00
|
|
|
static inline int jbd2_journal_get_max_txn_bufs(journal_t *journal)
|
|
|
|
{
|
|
|
|
return (journal->j_total_len - journal->j_fc_wbufsize) / 4;
|
|
|
|
}
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
/*
|
|
|
|
* is_journal_abort
|
|
|
|
*
|
2006-10-11 16:20:59 +08:00
|
|
|
* Simple test wrapper function to test the JBD2_ABORT state flag. This
|
2006-10-11 16:20:57 +08:00
|
|
|
* bit, when set, indicates that we have had a fatal error somewhere,
|
|
|
|
* either inside the journaling layer or indicated to us by the client
|
|
|
|
* (eg. ext3), and that we and should not commit any further
|
|
|
|
* transactions.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline int is_journal_aborted(journal_t *journal)
|
|
|
|
{
|
2006-10-11 16:20:59 +08:00
|
|
|
return journal->j_flags & JBD2_ABORT;
|
2006-10-11 16:20:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_handle_aborted(handle_t *handle)
|
|
|
|
{
|
2013-07-01 20:12:41 +08:00
|
|
|
if (handle->h_aborted || !handle->h_transaction)
|
2006-10-11 16:20:57 +08:00
|
|
|
return 1;
|
|
|
|
return is_journal_aborted(handle->h_transaction->t_journal);
|
|
|
|
}
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
static inline void jbd2_journal_abort_handle(handle_t *handle)
|
2006-10-11 16:20:57 +08:00
|
|
|
{
|
|
|
|
handle->h_aborted = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
|
|
/* Comparison functions for transaction IDs: perform comparisons using
|
|
|
|
* modulo arithmetic so that they work over sequence number wraps. */
|
|
|
|
|
|
|
|
static inline int tid_gt(tid_t x, tid_t y)
|
|
|
|
{
|
|
|
|
int difference = (x - y);
|
|
|
|
return (difference > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tid_geq(tid_t x, tid_t y)
|
|
|
|
{
|
|
|
|
int difference = (x - y);
|
|
|
|
return (difference >= 0);
|
|
|
|
}
|
|
|
|
|
2006-10-11 16:20:59 +08:00
|
|
|
extern int jbd2_journal_blocks_per_page(struct inode *inode);
|
2006-10-11 16:21:08 +08:00
|
|
|
extern size_t journal_tag_bytes(journal_t *journal);
|
2006-10-11 16:20:57 +08:00
|
|
|
|
2015-10-15 22:30:36 +08:00
|
|
|
static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
|
|
|
|
{
|
2015-10-18 04:18:45 +08:00
|
|
|
return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
|
2015-10-15 22:30:36 +08:00
|
|
|
}
|
|
|
|
|
2014-08-28 06:40:07 +08:00
|
|
|
static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
|
|
|
|
{
|
2015-10-15 22:30:36 +08:00
|
|
|
WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
|
|
|
|
journal->j_chksum_driver == NULL);
|
2014-08-28 06:40:07 +08:00
|
|
|
|
2015-10-15 22:30:36 +08:00
|
|
|
return journal->j_chksum_driver != NULL;
|
2014-08-28 06:40:07 +08:00
|
|
|
}
|
|
|
|
|
2020-11-21 04:22:32 +08:00
|
|
|
static inline int jbd2_journal_get_num_fc_blks(journal_superblock_t *jsb)
|
|
|
|
{
|
|
|
|
int num_fc_blocks = be32_to_cpu(jsb->s_num_fc_blks);
|
|
|
|
|
|
|
|
return num_fc_blocks ? num_fc_blocks : JBD2_DEFAULT_FAST_COMMIT_BLOCKS;
|
|
|
|
}
|
|
|
|
|
2013-06-05 00:12:57 +08:00
|
|
|
/*
|
|
|
|
* Return number of free blocks in the log. Must be called under j_state_lock.
|
|
|
|
*/
|
|
|
|
static inline unsigned long jbd2_log_space_left(journal_t *journal)
|
|
|
|
{
|
|
|
|
/* Allow for rounding errors */
|
2019-11-06 00:44:07 +08:00
|
|
|
long free = journal->j_free - 32;
|
2013-06-05 00:12:57 +08:00
|
|
|
|
|
|
|
if (journal->j_committing_transaction) {
|
2019-11-06 00:44:24 +08:00
|
|
|
free -= atomic_read(&journal->
|
|
|
|
j_committing_transaction->t_outstanding_credits);
|
2013-06-05 00:12:57 +08:00
|
|
|
}
|
2019-11-06 00:44:07 +08:00
|
|
|
return max_t(long, free, 0);
|
2006-10-11 16:20:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Definitions which augment the buffer_head layer
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* journaling buffer types */
|
|
|
|
#define BJ_None 0 /* Not journaled */
|
2008-07-12 07:27:31 +08:00
|
|
|
#define BJ_Metadata 1 /* Normal journaled metadata */
|
|
|
|
#define BJ_Forget 2 /* Buffer superseded by this transaction */
|
2013-06-05 00:01:45 +08:00
|
|
|
#define BJ_Shadow 3 /* Buffer contents being shadowed to the log */
|
2013-06-05 00:06:01 +08:00
|
|
|
#define BJ_Reserved 4 /* Buffer is reserved for access by journal */
|
|
|
|
#define BJ_Types 5
|
2006-10-11 16:20:57 +08:00
|
|
|
|
|
|
|
extern int jbd_blocks_per_page(struct inode *inode);
|
|
|
|
|
2012-11-09 00:24:46 +08:00
|
|
|
/* JBD uses a CRC32 checksum */
|
|
|
|
#define JBD_MAX_CHECKSUM_SIZE 4
|
|
|
|
|
2012-05-27 19:50:56 +08:00
|
|
|
static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
|
|
|
|
const void *address, unsigned int length)
|
|
|
|
{
|
|
|
|
struct {
|
|
|
|
struct shash_desc shash;
|
2012-11-09 00:24:46 +08:00
|
|
|
char ctx[JBD_MAX_CHECKSUM_SIZE];
|
2012-05-27 19:50:56 +08:00
|
|
|
} desc;
|
|
|
|
int err;
|
|
|
|
|
2012-11-09 00:24:46 +08:00
|
|
|
BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
|
|
|
|
JBD_MAX_CHECKSUM_SIZE);
|
|
|
|
|
2012-05-27 19:50:56 +08:00
|
|
|
desc.shash.tfm = journal->j_chksum_driver;
|
|
|
|
*(u32 *)desc.ctx = crc;
|
|
|
|
|
|
|
|
err = crypto_shash_update(&desc.shash, address, length);
|
|
|
|
BUG_ON(err);
|
|
|
|
|
|
|
|
return *(u32 *)desc.ctx;
|
|
|
|
}
|
|
|
|
|
2013-06-13 10:25:07 +08:00
|
|
|
/* Return most recent uncommitted transaction */
|
|
|
|
static inline tid_t jbd2_get_latest_transaction(journal_t *journal)
|
|
|
|
{
|
|
|
|
tid_t tid;
|
|
|
|
|
|
|
|
read_lock(&journal->j_state_lock);
|
|
|
|
tid = journal->j_commit_request;
|
|
|
|
if (journal->j_running_transaction)
|
|
|
|
tid = journal->j_running_transaction->t_tid;
|
|
|
|
read_unlock(&journal->j_state_lock);
|
|
|
|
return tid;
|
|
|
|
}
|
|
|
|
|
2019-11-06 00:44:17 +08:00
|
|
|
static inline int jbd2_handle_buffer_credits(handle_t *handle)
|
|
|
|
{
|
2019-11-15 18:22:10 +08:00
|
|
|
journal_t *journal;
|
|
|
|
|
|
|
|
if (!handle->h_reserved)
|
|
|
|
journal = handle->h_transaction->t_journal;
|
|
|
|
else
|
|
|
|
journal = handle->h_journal;
|
2019-11-06 00:44:26 +08:00
|
|
|
|
2019-11-06 00:44:27 +08:00
|
|
|
return handle->h_total_credits -
|
2019-11-06 00:44:26 +08:00
|
|
|
DIV_ROUND_UP(handle->h_revoke_credits_requested,
|
|
|
|
journal->j_revoke_records_per_block);
|
2019-11-06 00:44:17 +08:00
|
|
|
}
|
|
|
|
|
2006-10-11 16:20:57 +08:00
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
|
|
|
#define buffer_trace_init(bh) do {} while (0)
|
|
|
|
#define print_buffer_fields(bh) do {} while (0)
|
|
|
|
#define print_buffer_trace(bh) do {} while (0)
|
|
|
|
#define BUFFER_TRACE(bh, info) do {} while (0)
|
|
|
|
#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
|
|
|
|
#define JBUFFER_TRACE(jh, info) do {} while (0)
|
|
|
|
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
2015-10-18 04:16:04 +08:00
|
|
|
#define EFSBADCRC EBADMSG /* Bad CRC detected */
|
|
|
|
#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
|
|
|
|
|
2007-10-17 06:38:25 +08:00
|
|
|
#endif /* _LINUX_JBD2_H */
|