blob: 2a3d5f50e7a1d07939cc6b9d34c032a5fb2d332e [file] [log] [blame]
Thomas Gleixnerd6910052019-05-22 09:51:29 +02001/* SPDX-License-Identifier: GPL-2.0-or-later */
Dave Kleikamp470decc2006-10-11 01:20:57 -07002/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07003 * linux/include/linux/jbd2.h
Dave Kleikamp470decc2006-10-11 01:20:57 -07004 *
5 * Written by Stephen C. Tweedie <sct@redhat.com>
6 *
7 * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
8 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07009 * Definitions for transaction data structures for the buffer cache
10 * filesystem journaling support.
11 */
12
Mingming Caocd02ff02007-10-16 18:38:25 -040013#ifndef _LINUX_JBD2_H
14#define _LINUX_JBD2_H
Dave Kleikamp470decc2006-10-11 01:20:57 -070015
16/* Allow this file to be included directly into e2fsprogs */
17#ifndef __KERNEL__
18#include "jfs_compat.h"
Mingming Caof7f4bcc2006-10-11 01:20:59 -070019#define JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -070020#else
21
22#include <linux/types.h>
23#include <linux/buffer_head.h>
24#include <linux/journal-head.h>
25#include <linux/stddef.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070026#include <linux/mutex.h>
27#include <linux/timer.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.h>
Jan Karac290ea02015-06-18 16:52:29 +020029#include <linux/bit_spinlock.h>
Darrick J. Wong01b5adc2012-05-27 07:50:56 -040030#include <crypto/hash.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070031#endif
32
33#define journal_oom_retry 1
34
35/*
Mingming Caocd02ff02007-10-16 18:38:25 -040036 * Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
Dave Kleikamp470decc2006-10-11 01:20:57 -070037 * certain classes of error which can occur due to failed IOs. Under
Mingming Caocd02ff02007-10-16 18:38:25 -040038 * normal use we want ext4 to continue after such errors, because
Dave Kleikamp470decc2006-10-11 01:20:57 -070039 * hardware _can_ fail, but for debugging purposes when running tests on
40 * known-good hardware we may want to trap these errors.
41 */
Mingming Caocd02ff02007-10-16 18:38:25 -040042#undef JBD2_PARANOID_IOFAIL
Dave Kleikamp470decc2006-10-11 01:20:57 -070043
44/*
45 * The default maximum commit age, in seconds.
46 */
Mingming Caocd02ff02007-10-16 18:38:25 -040047#define JBD2_DEFAULT_MAX_COMMIT_AGE 5
Dave Kleikamp470decc2006-10-11 01:20:57 -070048
Jose R. Santose23291b2007-07-18 08:57:06 -040049#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -070050/*
Mingming Caocd02ff02007-10-16 18:38:25 -040051 * Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
Dave Kleikamp470decc2006-10-11 01:20:57 -070052 * consistency checks. By default we don't do this unless
Jose R. Santose23291b2007-07-18 08:57:06 -040053 * CONFIG_JBD2_DEBUG is on.
Dave Kleikamp470decc2006-10-11 01:20:57 -070054 */
Mingming Caocd02ff02007-10-16 18:38:25 -040055#define JBD2_EXPENSIVE_CHECKING
Theodore Ts'ob6e96d02013-02-09 16:29:20 -050056extern ushort jbd2_journal_enable_debug;
Paul Gortmaker169f1a22013-06-12 23:04:04 -040057void __jbd2_debug(int level, const char *file, const char *func,
58 unsigned int line, const char *fmt, ...);
Dave Kleikamp470decc2006-10-11 01:20:57 -070059
Paul Gortmaker169f1a22013-06-12 23:04:04 -040060#define jbd_debug(n, fmt, a...) \
61 __jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
Dave Kleikamp470decc2006-10-11 01:20:57 -070062#else
Paul Gortmaker169f1a22013-06-12 23:04:04 -040063#define jbd_debug(n, fmt, a...) /**/
Dave Kleikamp470decc2006-10-11 01:20:57 -070064#endif
65
Theodore Ts'od2eecb02009-12-07 10:36:20 -050066extern void *jbd2_alloc(size_t size, gfp_t flags);
67extern void jbd2_free(void *ptr, size_t size);
Mingming Caoaf1e76d2007-10-16 18:38:25 -040068
Mingming Caof7f4bcc2006-10-11 01:20:59 -070069#define JBD2_MIN_JOURNAL_BLOCKS 1024
Dave Kleikamp470decc2006-10-11 01:20:57 -070070
71#ifdef __KERNEL__
72
73/**
74 * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
75 *
76 * All filesystem modifications made by the process go
77 * through this handle. Recursive operations (such as quota operations)
78 * are gathered into a single update.
79 *
80 * The buffer credits field is used to account for journaled buffers
81 * being modified by the running process. To ensure that there is
82 * enough log space for all outstanding operations, we need to limit the
83 * number of outstanding buffers possible at any time. When the
84 * operation completes, any buffer credits not used are credited back to
85 * the transaction, so that at all times we know how many buffers the
86 * outstanding updates on a transaction might possibly touch.
87 *
88 * This is an opaque datatype.
89 **/
Theodore Ts'o8aefcd52011-01-10 12:29:43 -050090typedef struct jbd2_journal_handle handle_t; /* Atomic operation type */
Dave Kleikamp470decc2006-10-11 01:20:57 -070091
92
93/**
94 * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
95 *
96 * journal_t is linked to from the fs superblock structure.
97 *
98 * We use the journal_t to keep track of all outstanding transaction
99 * activity on the filesystem, and to manage the state of the log
100 * writing process.
101 *
102 * This is an opaque datatype.
103 **/
104typedef struct journal_s journal_t; /* Journal control structure */
105#endif
106
107/*
108 * Internal structures used by the logging mechanism:
109 */
110
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700111#define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700112
113/*
114 * On-disk structures
115 */
116
117/*
118 * Descriptor block types:
119 */
120
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700121#define JBD2_DESCRIPTOR_BLOCK 1
122#define JBD2_COMMIT_BLOCK 2
123#define JBD2_SUPERBLOCK_V1 3
124#define JBD2_SUPERBLOCK_V2 4
125#define JBD2_REVOKE_BLOCK 5
Dave Kleikamp470decc2006-10-11 01:20:57 -0700126
127/*
128 * Standard header for all descriptor blocks:
129 */
130typedef struct journal_header_s
131{
132 __be32 h_magic;
133 __be32 h_blocktype;
134 __be32 h_sequence;
135} journal_header_t;
136
Girish Shilamkar818d2762008-01-28 23:58:27 -0500137/*
138 * Checksum types.
139 */
140#define JBD2_CRC32_CHKSUM 1
141#define JBD2_MD5_CHKSUM 2
142#define JBD2_SHA1_CHKSUM 3
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400143#define JBD2_CRC32C_CHKSUM 4
Girish Shilamkar818d2762008-01-28 23:58:27 -0500144
145#define JBD2_CRC32_CHKSUM_SIZE 4
146
147#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
148/*
149 * Commit block header for storing transactional checksums:
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400150 *
151 * NOTE: If FEATURE_COMPAT_CHECKSUM (checksum v1) is set, the h_chksum*
152 * fields are used to store a checksum of the descriptor and data blocks.
153 *
154 * If FEATURE_INCOMPAT_CSUM_V2 (checksum v2) is set, then the h_chksum
155 * field is used to store crc32c(uuid+commit_block). Each journal metadata
156 * block gets its own checksum, and data block checksums are stored in
157 * journal_block_tag (in the descriptor). The other h_chksum* fields are
158 * not used.
159 *
Darrick J. Wongdb9ee222014-08-27 18:40:07 -0400160 * If FEATURE_INCOMPAT_CSUM_V3 is set, the descriptor block uses
161 * journal_block_tag3_t to store a full 32-bit checksum. Everything else
162 * is the same as v2.
163 *
164 * Checksum v1, v2, and v3 are mutually exclusive features.
Girish Shilamkar818d2762008-01-28 23:58:27 -0500165 */
166struct commit_header {
167 __be32 h_magic;
168 __be32 h_blocktype;
169 __be32 h_sequence;
170 unsigned char h_chksum_type;
171 unsigned char h_chksum_size;
172 unsigned char h_padding[2];
173 __be32 h_chksum[JBD2_CHECKSUM_BYTES];
Theodore Ts'o736603a2008-07-11 19:27:31 -0400174 __be64 h_commit_sec;
175 __be32 h_commit_nsec;
Girish Shilamkar818d2762008-01-28 23:58:27 -0500176};
Dave Kleikamp470decc2006-10-11 01:20:57 -0700177
178/*
Zach Brownb517bea2006-10-11 01:21:08 -0700179 * The block tag: used to describe a single buffer in the journal.
180 * t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
181 * raw struct shouldn't be used for pointer math or sizeof() - use
182 * journal_tag_bytes(journal) instead to compute this.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700183 */
Darrick J. Wongdb9ee222014-08-27 18:40:07 -0400184typedef struct journal_block_tag3_s
185{
186 __be32 t_blocknr; /* The on-disk block number */
187 __be32 t_flags; /* See below */
188 __be32 t_blocknr_high; /* most-significant high 32bits. */
189 __be32 t_checksum; /* crc32c(uuid+seq+block) */
190} journal_block_tag3_t;
191
Dave Kleikamp470decc2006-10-11 01:20:57 -0700192typedef struct journal_block_tag_s
193{
194 __be32 t_blocknr; /* The on-disk block number */
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400195 __be16 t_checksum; /* truncated crc32c(uuid+seq+block) */
196 __be16 t_flags; /* See below */
Zach Brownb517bea2006-10-11 01:21:08 -0700197 __be32 t_blocknr_high; /* most-significant high 32bits. */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700198} journal_block_tag_t;
199
Jan Kara1101cd42016-02-22 23:19:09 -0500200/* Tail of descriptor or revoke block, for checksumming */
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400201struct jbd2_journal_block_tail {
202 __be32 t_checksum; /* crc32c(uuid+descr_block) */
203};
204
Dave Kleikamp470decc2006-10-11 01:20:57 -0700205/*
206 * The revoke descriptor: used on disk to describe a series of blocks to
207 * be revoked from the log
208 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700209typedef struct jbd2_journal_revoke_header_s
Dave Kleikamp470decc2006-10-11 01:20:57 -0700210{
211 journal_header_t r_header;
212 __be32 r_count; /* Count of bytes used in the block */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700213} jbd2_journal_revoke_header_t;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700214
Dave Kleikamp470decc2006-10-11 01:20:57 -0700215/* Definitions for the journal tag flags word: */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700216#define JBD2_FLAG_ESCAPE 1 /* on-disk block is escaped */
217#define JBD2_FLAG_SAME_UUID 2 /* block has same uuid as previous */
218#define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
219#define JBD2_FLAG_LAST_TAG 8 /* last tag in this descriptor block */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700220
221
222/*
223 * The journal superblock. All fields are in big-endian byte order.
224 */
225typedef struct journal_superblock_s
226{
227/* 0x0000 */
228 journal_header_t s_header;
229
230/* 0x000C */
231 /* Static information describing the journal */
232 __be32 s_blocksize; /* journal device blocksize */
233 __be32 s_maxlen; /* total blocks in journal file */
234 __be32 s_first; /* first block of log information */
235
236/* 0x0018 */
237 /* Dynamic information describing the current state of the log */
238 __be32 s_sequence; /* first commit ID expected in log */
239 __be32 s_start; /* blocknr of start of log */
240
241/* 0x0020 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700242 /* Error value, as set by jbd2_journal_abort(). */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700243 __be32 s_errno;
244
245/* 0x0024 */
246 /* Remaining fields are only valid in a version-2 superblock */
247 __be32 s_feature_compat; /* compatible feature set */
248 __be32 s_feature_incompat; /* incompatible feature set */
249 __be32 s_feature_ro_compat; /* readonly-compatible feature set */
250/* 0x0030 */
251 __u8 s_uuid[16]; /* 128-bit uuid for journal */
252
253/* 0x0040 */
254 __be32 s_nr_users; /* Nr of filesystems sharing log */
255
256 __be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/
257
258/* 0x0048 */
259 __be32 s_max_transaction; /* Limit of journal blocks per trans.*/
260 __be32 s_max_trans_data; /* Limit of data blocks per trans. */
261
262/* 0x0050 */
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400263 __u8 s_checksum_type; /* checksum type */
264 __u8 s_padding2[3];
265 __u32 s_padding[42];
266 __be32 s_checksum; /* crc32c(superblock) */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700267
268/* 0x0100 */
269 __u8 s_users[16*48]; /* ids of all fs'es sharing the log */
270/* 0x0400 */
271} journal_superblock_t;
272
Darrick J. Wong56316a02015-10-17 16:18:45 -0400273/* Use the jbd2_{has,set,clear}_feature_* helpers; these will be removed */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700274#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700275 ((j)->j_format_version >= 2 && \
276 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700277#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700278 ((j)->j_format_version >= 2 && \
279 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700280#define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700281 ((j)->j_format_version >= 2 && \
282 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
283
Darrick J. Wong56316a02015-10-17 16:18:45 -0400284#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
Girish Shilamkar818d2762008-01-28 23:58:27 -0500285
286#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
287#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
288#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400289#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
Darrick J. Wongdb9ee222014-08-27 18:40:07 -0400290#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010
Dave Kleikamp470decc2006-10-11 01:20:57 -0700291
Darrick J. Wong56316a02015-10-17 16:18:45 -0400292/* See "journal feature predicate functions" below */
293
Dave Kleikamp470decc2006-10-11 01:20:57 -0700294/* Features known to this kernel version: */
Girish Shilamkar818d2762008-01-28 23:58:27 -0500295#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700296#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
Zach Brownb517bea2006-10-11 01:21:08 -0700297#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
Girish Shilamkar818d2762008-01-28 23:58:27 -0500298 JBD2_FEATURE_INCOMPAT_64BIT | \
Darrick J. Wonge93376c2012-05-27 08:12:42 -0400299 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
Darrick J. Wongdb9ee222014-08-27 18:40:07 -0400300 JBD2_FEATURE_INCOMPAT_CSUM_V2 | \
301 JBD2_FEATURE_INCOMPAT_CSUM_V3)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700302
303#ifdef __KERNEL__
304
305#include <linux/fs.h>
306#include <linux/sched.h>
Jan Karab34090e2013-06-04 12:08:56 -0400307
308enum jbd_state_bits {
309 BH_JBD /* Has an attached ext3 journal_head */
310 = BH_PrivateStart,
311 BH_JWrite, /* Being written to log (@@@ DEBUGGING) */
312 BH_Freed, /* Has been freed (truncated) */
313 BH_Revoked, /* Has been revoked from the log */
314 BH_RevokeValid, /* Revoked flag is valid */
315 BH_JBDDirty, /* Is dirty but journaled */
316 BH_State, /* Pins most journal_head state */
317 BH_JournalHead, /* Pins bh->b_private and jh->b_bh */
318 BH_Shadow, /* IO on shadow buffer is running */
319 BH_Verified, /* Metadata block has been verified ok */
320 BH_JBDPrivateStart, /* First bit available for private use by FS */
321};
322
323BUFFER_FNS(JBD, jbd)
324BUFFER_FNS(JWrite, jwrite)
325BUFFER_FNS(JBDDirty, jbddirty)
326TAS_BUFFER_FNS(JBDDirty, jbddirty)
327BUFFER_FNS(Revoked, revoked)
328TAS_BUFFER_FNS(Revoked, revoked)
329BUFFER_FNS(RevokeValid, revokevalid)
330TAS_BUFFER_FNS(RevokeValid, revokevalid)
331BUFFER_FNS(Freed, freed)
332BUFFER_FNS(Shadow, shadow)
333BUFFER_FNS(Verified, verified)
334
Jan Karac290ea02015-06-18 16:52:29 +0200335static inline struct buffer_head *jh2bh(struct journal_head *jh)
336{
337 return jh->b_bh;
338}
339
340static inline struct journal_head *bh2jh(struct buffer_head *bh)
341{
342 return bh->b_private;
343}
344
345static inline void jbd_lock_bh_state(struct buffer_head *bh)
346{
347 bit_spin_lock(BH_State, &bh->b_state);
348}
349
350static inline int jbd_trylock_bh_state(struct buffer_head *bh)
351{
352 return bit_spin_trylock(BH_State, &bh->b_state);
353}
354
355static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
356{
357 return bit_spin_is_locked(BH_State, &bh->b_state);
358}
359
360static inline void jbd_unlock_bh_state(struct buffer_head *bh)
361{
362 bit_spin_unlock(BH_State, &bh->b_state);
363}
364
365static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
366{
367 bit_spin_lock(BH_JournalHead, &bh->b_state);
368}
369
370static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
371{
372 bit_spin_unlock(BH_JournalHead, &bh->b_state);
373}
Dave Kleikamp470decc2006-10-11 01:20:57 -0700374
Chris Snook36df53f2008-01-28 23:58:27 -0500375#define J_ASSERT(assert) BUG_ON(!(assert))
Dave Kleikamp470decc2006-10-11 01:20:57 -0700376
Dave Kleikamp470decc2006-10-11 01:20:57 -0700377#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
378#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700379
Mingming Caocd02ff02007-10-16 18:38:25 -0400380#if defined(JBD2_PARANOID_IOFAIL)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700381#define J_EXPECT(expr, why...) J_ASSERT(expr)
382#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
383#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
384#else
385#define __journal_expect(expr, why...) \
386 ({ \
387 int val = (expr); \
388 if (!val) { \
389 printk(KERN_ERR \
Theodore Ts'o08ec8c32009-01-16 11:57:00 -0500390 "JBD2 unexpected failure: %s: %s;\n", \
391 __func__, #expr); \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700392 printk(KERN_ERR why "\n"); \
393 } \
394 val; \
395 })
396#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
397#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
398#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
399#endif
400
Jan Karac851ed52008-07-11 19:27:31 -0400401/* Flags in jbd_inode->i_flags */
402#define __JI_COMMIT_RUNNING 0
Jan Kara41617e12016-04-24 00:56:07 -0400403#define __JI_WRITE_DATA 1
404#define __JI_WAIT_DATA 2
405
406/*
407 * Commit of the inode data in progress. We use this flag to protect us from
Jan Karac851ed52008-07-11 19:27:31 -0400408 * concurrent deletion of inode. We cannot use reference to inode for this
409 * since we cannot afford doing last iput() on behalf of kjournald
410 */
411#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
Jan Kara41617e12016-04-24 00:56:07 -0400412/* Write allocated dirty buffers in this inode before commit */
413#define JI_WRITE_DATA (1 << __JI_WRITE_DATA)
414/* Wait for outstanding data writes for this inode before commit */
415#define JI_WAIT_DATA (1 << __JI_WAIT_DATA)
Jan Karac851ed52008-07-11 19:27:31 -0400416
417/**
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500418 * struct jbd_inode - The jbd_inode type is the structure linking inodes in
419 * ordered mode present in a transaction so that we can sync them during commit.
Jan Karac851ed52008-07-11 19:27:31 -0400420 */
421struct jbd2_inode {
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500422 /**
423 * @i_transaction:
424 *
425 * Which transaction does this inode belong to? Either the running
426 * transaction or the committing one. [j_list_lock]
427 */
Jan Karac851ed52008-07-11 19:27:31 -0400428 transaction_t *i_transaction;
429
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500430 /**
431 * @i_next_transaction:
432 *
433 * Pointer to the running transaction modifying inode's data in case
434 * there is already a committing transaction touching it. [j_list_lock]
435 */
Jan Karac851ed52008-07-11 19:27:31 -0400436 transaction_t *i_next_transaction;
437
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500438 /**
439 * @i_list: List of inodes in the i_transaction [j_list_lock]
440 */
Jan Karac851ed52008-07-11 19:27:31 -0400441 struct list_head i_list;
442
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500443 /**
444 * @i_vfs_inode:
445 *
446 * VFS inode this inode belongs to [constant for lifetime of structure]
447 */
Jan Karac851ed52008-07-11 19:27:31 -0400448 struct inode *i_vfs_inode;
449
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500450 /**
451 * @i_flags: Flags of inode [j_list_lock]
452 */
Brian King39e3ac22010-10-27 21:25:12 -0400453 unsigned long i_flags;
Ross Zwisler6ba0e7d2019-06-20 17:24:56 -0400454
455 /**
456 * @i_dirty_start:
457 *
458 * Offset in bytes where the dirty range for this inode starts.
459 * [j_list_lock]
460 */
461 loff_t i_dirty_start;
462
463 /**
464 * @i_dirty_end:
465 *
466 * Inclusive offset in bytes where the dirty range for this inode
467 * ends. [j_list_lock]
468 */
469 loff_t i_dirty_end;
Jan Karac851ed52008-07-11 19:27:31 -0400470};
471
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700472struct jbd2_revoke_table_s;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700473
474/**
475 * struct handle_s - The handle_s type is the concrete type associated with
476 * handle_t.
477 * @h_transaction: Which compound transaction is this update a part of?
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500478 * @h_journal: Which journal handle belongs to - used iff h_reserved set.
479 * @h_rsv_handle: Handle reserved for finishing the logical operation.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700480 * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
Jan Karafdc3ef82019-11-05 17:44:26 +0100481 * @h_revoke_credits: Number of remaining revoke records available for handle
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500482 * @h_ref: Reference count on this handle.
483 * @h_err: Field for caller's use to track errors through large fs operations.
484 * @h_sync: Flag for sync-on-close.
485 * @h_jdata: Flag to force data journaling.
486 * @h_reserved: Flag for handle for reserved credits.
487 * @h_aborted: Flag indicating fatal error on handle.
488 * @h_type: For handle statistics.
489 * @h_line_no: For handle statistics.
490 * @h_start_jiffies: Handle Start time.
491 * @h_requested_credits: Holds @h_buffer_credits after handle is started.
Jan Karafdc3ef82019-11-05 17:44:26 +0100492 * @h_revoke_credits_requested: Holds @h_revoke_credits after handle is started.
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500493 * @saved_alloc_context: Saved context while transaction is open.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700494 **/
495
496/* Docbook can't yet cope with the bit fields, but will leave the documentation
497 * in so it can be fixed later.
498 */
499
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500500struct jbd2_journal_handle
Dave Kleikamp470decc2006-10-11 01:20:57 -0700501{
Jan Kara8f7d89f2013-06-04 12:35:11 -0400502 union {
Jan Kara8f7d89f2013-06-04 12:35:11 -0400503 transaction_t *h_transaction;
504 /* Which journal handle belongs to - used iff h_reserved set */
505 journal_t *h_journal;
506 };
507
Jan Kara8f7d89f2013-06-04 12:35:11 -0400508 handle_t *h_rsv_handle;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700509 int h_buffer_credits;
Jan Karafdc3ef82019-11-05 17:44:26 +0100510 int h_revoke_credits;
511 int h_revoke_credits_requested;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700512 int h_ref;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700513 int h_err;
514
515 /* Flags [no locking] */
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500516 unsigned int h_sync: 1;
517 unsigned int h_jdata: 1;
518 unsigned int h_reserved: 1;
519 unsigned int h_aborted: 1;
520 unsigned int h_type: 8;
521 unsigned int h_line_no: 16;
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500522
523 unsigned long h_start_jiffies;
524 unsigned int h_requested_credits;
Michal Hocko81378da2017-05-03 14:53:22 -0700525
526 unsigned int saved_alloc_context;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700527};
528
529
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500530/*
531 * Some stats for checkpoint phase
532 */
533struct transaction_chp_stats_s {
534 unsigned long cs_chp_time;
Theodore Ts'obf699322009-09-30 00:32:06 -0400535 __u32 cs_forced_to_close;
536 __u32 cs_written;
537 __u32 cs_dropped;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500538};
539
Dave Kleikamp470decc2006-10-11 01:20:57 -0700540/* The transaction_t type is the guts of the journaling mechanism. It
541 * tracks a compound transaction through its various states:
542 *
543 * RUNNING: accepting new updates
544 * LOCKED: Updates still running but we don't accept new ones
545 * RUNDOWN: Updates are tidying up but have finished requesting
546 * new buffers to modify (state not used for now)
547 * FLUSH: All updates complete, but we are still writing to disk
548 * COMMIT: All data on disk, writing commit record
549 * FINISHED: We still have to keep the transaction for checkpointing.
550 *
551 * The transaction keeps track of all of the buffers modified by a
552 * running transaction, and all of the buffers committed but not yet
553 * flushed to home for finished transactions.
554 */
555
556/*
557 * Lock ranking:
558 *
559 * j_list_lock
560 * ->jbd_lock_bh_journal_head() (This is "innermost")
561 *
562 * j_state_lock
563 * ->jbd_lock_bh_state()
564 *
565 * jbd_lock_bh_state()
566 * ->j_list_lock
567 *
568 * j_state_lock
569 * ->t_handle_lock
570 *
571 * j_state_lock
572 * ->j_list_lock (journal_unmap_buffer)
573 *
574 */
575
576struct transaction_s
577{
578 /* Pointer to the journal for this transaction. [no locking] */
579 journal_t *t_journal;
580
581 /* Sequence number for this transaction [no locking] */
582 tid_t t_tid;
583
584 /*
585 * Transaction's current state
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700586 * [no locking - only kjournald2 alters this]
Jan Karaf5a7a6b2008-01-28 23:58:27 -0500587 * [j_list_lock] guards transition of a transaction into T_FINISHED
588 * state and subsequent call of __jbd2_journal_drop_transaction()
Dave Kleikamp470decc2006-10-11 01:20:57 -0700589 * FIXME: needs barriers
590 * KLUDGE: [use j_state_lock]
591 */
592 enum {
593 T_RUNNING,
594 T_LOCKED,
Jan Kara96f1e092018-12-03 23:16:07 -0500595 T_SWITCH,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700596 T_FLUSH,
597 T_COMMIT,
Jan Karabbd2be32011-05-24 11:59:18 -0400598 T_COMMIT_DFLUSH,
599 T_COMMIT_JFLUSH,
Dmitry Monakhov794446c2013-04-03 22:06:52 -0400600 T_COMMIT_CALLBACK,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700601 T_FINISHED
602 } t_state;
603
604 /*
605 * Where in the log does this transaction's commit start? [no locking]
606 */
607 unsigned long t_log_start;
608
609 /* Number of buffers on the t_buffers list [j_list_lock] */
610 int t_nr_buffers;
611
612 /*
613 * Doubly-linked circular list of all buffers reserved but not yet
614 * modified by this transaction [j_list_lock]
615 */
616 struct journal_head *t_reserved_list;
617
618 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700619 * Doubly-linked circular list of all metadata buffers owned by this
620 * transaction [j_list_lock]
621 */
622 struct journal_head *t_buffers;
623
624 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700625 * Doubly-linked circular list of all forget buffers (superseded
626 * buffers which we can un-checkpoint once this transaction commits)
627 * [j_list_lock]
628 */
629 struct journal_head *t_forget;
630
631 /*
632 * Doubly-linked circular list of all buffers still to be flushed before
633 * this transaction can be checkpointed. [j_list_lock]
634 */
635 struct journal_head *t_checkpoint_list;
636
637 /*
638 * Doubly-linked circular list of all buffers submitted for IO while
639 * checkpointing. [j_list_lock]
640 */
641 struct journal_head *t_checkpoint_io_list;
642
643 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700644 * Doubly-linked circular list of metadata buffers being shadowed by log
645 * IO. The IO buffers on the iobuf list and the shadow buffers on this
646 * list match each other one for one at all times. [j_list_lock]
647 */
648 struct journal_head *t_shadow_list;
649
650 /*
Jan Karac851ed52008-07-11 19:27:31 -0400651 * List of inodes whose data we've modified in data=ordered mode.
652 * [j_list_lock]
653 */
654 struct list_head t_inode_list;
655
656 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700657 * Protects info related to handles
658 */
659 spinlock_t t_handle_lock;
660
661 /*
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500662 * Longest time some handle had to wait for running transaction
663 */
664 unsigned long t_max_wait;
665
666 /*
667 * When transaction started
668 */
669 unsigned long t_start;
670
671 /*
Theodore Ts'o9fff24a2013-02-06 22:30:23 -0500672 * When commit was requested
673 */
674 unsigned long t_requested;
675
676 /*
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500677 * Checkpointing stats [j_checkpoint_sem]
678 */
679 struct transaction_chp_stats_s t_chp_stats;
680
681 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700682 * Number of outstanding updates running on this transaction
Alexander Lochmann32ea2752018-12-04 00:30:22 -0500683 * [none]
Dave Kleikamp470decc2006-10-11 01:20:57 -0700684 */
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400685 atomic_t t_updates;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700686
687 /*
Jan Kara9f356e52019-11-05 17:44:24 +0100688 * Number of blocks reserved for this transaction in the journal.
689 * This is including all credits reserved when starting transaction
690 * handles as well as all journal descriptor blocks needed for this
691 * transaction. [none]
Dave Kleikamp470decc2006-10-11 01:20:57 -0700692 */
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400693 atomic_t t_outstanding_credits;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700694
695 /*
Jan Karafdc3ef82019-11-05 17:44:26 +0100696 * Number of revoke records for this transaction added by already
697 * stopped handles. [none]
698 */
699 atomic_t t_outstanding_revokes;
700
701 /*
702 * How many handles used this transaction? [none]
703 */
704 atomic_t t_handle_count;
705
706 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700707 * Forward and backward links for the circular list of all transactions
708 * awaiting checkpoint. [j_list_lock]
709 */
710 transaction_t *t_cpnext, *t_cpprev;
711
712 /*
713 * When will the transaction expire (become due for commit), in jiffies?
714 * [no locking]
715 */
716 unsigned long t_expires;
717
718 /*
Josef Bacike07f7182008-11-26 01:14:26 -0500719 * When this transaction started, in nanoseconds [no locking]
720 */
721 ktime_t t_start_time;
722
723 /*
Theodore Ts'o70585482009-03-25 23:35:46 -0400724 * This transaction is being forced and some process is
725 * waiting for it to finish.
726 */
H Hartley Sweeten0ccff1a2009-08-17 22:38:04 -0400727 unsigned int t_synchronous_commit:1;
Jan Kara81be12c2011-05-24 11:52:40 -0400728
729 /* Disk flush needs to be sent to fs partition [no locking] */
730 int t_need_data_flush;
Theodore Ts'o70585482009-03-25 23:35:46 -0400731
732 /*
Theodore Ts'o3e624fc2008-10-16 20:00:24 -0400733 * For use by the filesystem to store fs-specific data
734 * structures associated with the transaction
735 */
736 struct list_head t_private_list;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700737};
738
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500739struct transaction_run_stats_s {
740 unsigned long rs_wait;
Theodore Ts'o9fff24a2013-02-06 22:30:23 -0500741 unsigned long rs_request_delay;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500742 unsigned long rs_running;
743 unsigned long rs_locked;
744 unsigned long rs_flushing;
745 unsigned long rs_logging;
746
Theodore Ts'obf699322009-09-30 00:32:06 -0400747 __u32 rs_handle_count;
748 __u32 rs_blocks;
749 __u32 rs_blocks_logged;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500750};
751
752struct transaction_stats_s {
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500753 unsigned long ts_tid;
Theodore Ts'o9fff24a2013-02-06 22:30:23 -0500754 unsigned long ts_requested;
Theodore Ts'obf699322009-09-30 00:32:06 -0400755 struct transaction_run_stats_s run;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500756};
757
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500758static inline unsigned long
759jbd2_time_diff(unsigned long start, unsigned long end)
760{
761 if (end >= start)
762 return end - start;
763
764 return end + (MAX_JIFFY_OFFSET - start);
765}
766
Theodore Ts'o1a0d3782008-11-05 00:09:22 -0500767#define JBD2_NR_BATCH 64
768
Dave Kleikamp470decc2006-10-11 01:20:57 -0700769/**
770 * struct journal_s - The journal_s type is the concrete type associated with
771 * journal_t.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700772 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700773struct journal_s
774{
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500775 /**
776 * @j_flags: General journaling state flags [j_state_lock]
777 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700778 unsigned long j_flags;
779
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500780 /**
781 * @j_errno:
782 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700783 * Is there an outstanding uncleared error on the journal (from a prior
784 * abort)? [j_state_lock]
785 */
786 int j_errno;
787
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500788 /**
789 * @j_sb_buffer: The first part of the superblock buffer.
790 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700791 struct buffer_head *j_sb_buffer;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500792
793 /**
794 * @j_superblock: The second part of the superblock buffer.
795 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700796 journal_superblock_t *j_superblock;
797
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500798 /**
799 * @j_format_version: Version of the superblock format.
800 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700801 int j_format_version;
802
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500803 /**
804 * @j_state_lock: Protect the various scalars in the journal.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700805 */
Theodore Ts'oa931da62010-08-03 21:35:12 -0400806 rwlock_t j_state_lock;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700807
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500808 /**
809 * @j_barrier_count:
810 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700811 * Number of processes waiting to create a barrier lock [j_state_lock]
812 */
813 int j_barrier_count;
814
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500815 /**
816 * @j_barrier: The barrier lock itself.
817 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700818 struct mutex j_barrier;
819
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500820 /**
821 * @j_running_transaction:
822 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700823 * Transactions: The current running transaction...
824 * [j_state_lock] [caller holding open handle]
825 */
826 transaction_t *j_running_transaction;
827
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500828 /**
829 * @j_committing_transaction:
830 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700831 * the transaction we are pushing to disk
832 * [j_state_lock] [caller holding open handle]
833 */
834 transaction_t *j_committing_transaction;
835
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500836 /**
837 * @j_checkpoint_transactions:
838 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700839 * ... and a linked circular list of all transactions waiting for
840 * checkpointing. [j_list_lock]
841 */
842 transaction_t *j_checkpoint_transactions;
843
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500844 /**
845 * @j_wait_transaction_locked:
846 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700847 * Wait queue for waiting for a locked transaction to start committing,
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500848 * or for a barrier lock to be released.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700849 */
850 wait_queue_head_t j_wait_transaction_locked;
851
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500852 /**
853 * @j_wait_done_commit: Wait queue for waiting for commit to complete.
854 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700855 wait_queue_head_t j_wait_done_commit;
856
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500857 /**
858 * @j_wait_commit: Wait queue to trigger commit.
859 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700860 wait_queue_head_t j_wait_commit;
861
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500862 /**
863 * @j_wait_updates: Wait queue to wait for updates to complete.
864 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700865 wait_queue_head_t j_wait_updates;
866
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500867 /**
868 * @j_wait_reserved:
869 *
870 * Wait queue to wait for reserved buffer credits to drop.
871 */
Jan Kara8f7d89f2013-06-04 12:35:11 -0400872 wait_queue_head_t j_wait_reserved;
873
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500874 /**
875 * @j_checkpoint_mutex:
876 *
877 * Semaphore for locking against concurrent checkpoints.
878 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700879 struct mutex j_checkpoint_mutex;
880
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500881 /**
882 * @j_chkpt_bhs:
883 *
Theodore Ts'o1a0d3782008-11-05 00:09:22 -0500884 * List of buffer heads used by the checkpoint routine. This
885 * was moved from jbd2_log_do_checkpoint() to reduce stack
886 * usage. Access to this array is controlled by the
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500887 * @j_checkpoint_mutex. [j_checkpoint_mutex]
Theodore Ts'o1a0d3782008-11-05 00:09:22 -0500888 */
889 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500890
891 /**
892 * @j_head:
893 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700894 * Journal head: identifies the first unused block in the journal.
895 * [j_state_lock]
896 */
897 unsigned long j_head;
898
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500899 /**
900 * @j_tail:
901 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700902 * Journal tail: identifies the oldest still-used block in the journal.
903 * [j_state_lock]
904 */
905 unsigned long j_tail;
906
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500907 /**
908 * @j_free:
909 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700910 * Journal free: how many free blocks are there in the journal?
911 * [j_state_lock]
912 */
913 unsigned long j_free;
914
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500915 /**
916 * @j_first:
917 *
918 * The block number of the first usable block in the journal
919 * [j_state_lock].
Dave Kleikamp470decc2006-10-11 01:20:57 -0700920 */
921 unsigned long j_first;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500922
923 /**
924 * @j_last:
925 *
926 * The block number one beyond the last usable block in the journal
927 * [j_state_lock].
928 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700929 unsigned long j_last;
930
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500931 /**
932 * @j_dev: Device where we store the journal.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700933 */
934 struct block_device *j_dev;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500935
936 /**
937 * @j_blocksize: Block size for the location where we store the journal.
938 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700939 int j_blocksize;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500940
941 /**
942 * @j_blk_offset:
943 *
944 * Starting block offset into the device where we store the journal.
945 */
Theodore Ts'o05496762008-09-16 14:36:17 -0400946 unsigned long long j_blk_offset;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500947
948 /**
949 * @j_devname: Journal device name.
950 */
Theodore Ts'o05496762008-09-16 14:36:17 -0400951 char j_devname[BDEVNAME_SIZE+24];
Dave Kleikamp470decc2006-10-11 01:20:57 -0700952
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500953 /**
954 * @j_fs_dev:
955 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700956 * Device which holds the client fs. For internal journal this will be
957 * equal to j_dev.
958 */
959 struct block_device *j_fs_dev;
960
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500961 /**
962 * @j_maxlen: Total maximum capacity of the journal region on disk.
963 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700964 unsigned int j_maxlen;
965
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500966 /**
967 * @j_reserved_credits:
968 *
969 * Number of buffers reserved from the running transaction.
970 */
Jan Kara8f7d89f2013-06-04 12:35:11 -0400971 atomic_t j_reserved_credits;
972
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500973 /**
974 * @j_list_lock: Protects the buffer lists and internal buffer state.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700975 */
976 spinlock_t j_list_lock;
977
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500978 /**
979 * @j_inode:
980 *
981 * Optional inode where we store the journal. If present, all
982 * journal block numbers are mapped into this inode via bmap().
983 */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700984 struct inode *j_inode;
985
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500986 /**
987 * @j_tail_sequence:
988 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700989 * Sequence number of the oldest transaction in the log [j_state_lock]
990 */
991 tid_t j_tail_sequence;
992
Tobin C. Hardingf69120c2018-01-10 00:27:29 -0500993 /**
994 * @j_transaction_sequence:
995 *
Dave Kleikamp470decc2006-10-11 01:20:57 -0700996 * Sequence number of the next transaction to grant [j_state_lock]
997 */
998 tid_t j_transaction_sequence;
999
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001000 /**
1001 * @j_commit_sequence:
1002 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001003 * Sequence number of the most recently committed transaction
1004 * [j_state_lock].
1005 */
1006 tid_t j_commit_sequence;
1007
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001008 /**
1009 * @j_commit_request:
1010 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001011 * Sequence number of the most recent transaction wanting commit
1012 * [j_state_lock]
1013 */
1014 tid_t j_commit_request;
1015
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001016 /**
1017 * @j_uuid:
1018 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001019 * Journal uuid: identifies the object (filesystem, LVM volume etc)
1020 * backed by this journal. This will eventually be replaced by an array
1021 * of uuids, allowing us to index multiple devices within a single
1022 * journal and to perform atomic updates across them.
1023 */
1024 __u8 j_uuid[16];
1025
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001026 /**
1027 * @j_task: Pointer to the current commit thread for this journal.
1028 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001029 struct task_struct *j_task;
1030
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001031 /**
1032 * @j_max_transaction_buffers:
1033 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001034 * Maximum number of metadata buffers to allow in a single compound
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001035 * commit transaction.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001036 */
1037 int j_max_transaction_buffers;
1038
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001039 /**
Jan Karafdc3ef82019-11-05 17:44:26 +01001040 * @j_revoke_records_per_block:
1041 *
1042 * Number of revoke records that fit in one descriptor block.
1043 */
1044 int j_revoke_records_per_block;
1045
1046 /**
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001047 * @j_commit_interval:
1048 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001049 * What is the maximum transaction lifetime before we begin a commit?
1050 */
1051 unsigned long j_commit_interval;
1052
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001053 /**
1054 * @j_commit_timer: The timer used to wakeup the commit thread.
1055 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001056 struct timer_list j_commit_timer;
1057
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001058 /**
1059 * @j_revoke_lock: Protect the revoke table.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001060 */
1061 spinlock_t j_revoke_lock;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001062
1063 /**
1064 * @j_revoke:
1065 *
1066 * The revoke table - maintains the list of revoked blocks in the
1067 * current transaction.
1068 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001069 struct jbd2_revoke_table_s *j_revoke;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001070
1071 /**
1072 * @j_revoke_table: Alternate revoke tables for j_revoke.
1073 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001074 struct jbd2_revoke_table_s *j_revoke_table[2];
Dave Kleikamp470decc2006-10-11 01:20:57 -07001075
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001076 /**
1077 * @j_wbuf: Array of bhs for jbd2_journal_commit_transaction.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001078 */
1079 struct buffer_head **j_wbuf;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001080
1081 /**
1082 * @j_wbufsize:
1083 *
1084 * Size of @j_wbuf array.
1085 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001086 int j_wbufsize;
1087
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001088 /**
1089 * @j_last_sync_writer:
1090 *
1091 * The pid of the last person to run a synchronous operation
1092 * through the journal.
Josef Bacike07f7182008-11-26 01:14:26 -05001093 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001094 pid_t j_last_sync_writer;
1095
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001096 /**
1097 * @j_average_commit_time:
1098 *
1099 * The average amount of time in nanoseconds it takes to commit a
Josef Bacike07f7182008-11-26 01:14:26 -05001100 * transaction to disk. [j_state_lock]
1101 */
1102 u64 j_average_commit_time;
1103
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001104 /**
1105 * @j_min_batch_time:
1106 *
1107 * Minimum time that we should wait for additional filesystem operations
1108 * to get batched into a synchronous handle in microseconds.
Theodore Ts'o30773842009-01-03 20:27:38 -05001109 */
1110 u32 j_min_batch_time;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001111
1112 /**
1113 * @j_max_batch_time:
1114 *
1115 * Maximum time that we should wait for additional filesystem operations
1116 * to get batched into a synchronous handle in microseconds.
1117 */
Theodore Ts'o30773842009-01-03 20:27:38 -05001118 u32 j_max_batch_time;
1119
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001120 /**
1121 * @j_commit_callback:
1122 *
1123 * This function is called when a transaction is closed.
1124 */
Theodore Ts'o3e624fc2008-10-16 20:00:24 -04001125 void (*j_commit_callback)(journal_t *,
1126 transaction_t *);
1127
Dave Kleikamp470decc2006-10-11 01:20:57 -07001128 /*
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001129 * Journal statistics
1130 */
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001131
1132 /**
1133 * @j_history_lock: Protect the transactions statistics history.
1134 */
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001135 spinlock_t j_history_lock;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001136
1137 /**
1138 * @j_proc_entry: procfs entry for the jbd statistics directory.
1139 */
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001140 struct proc_dir_entry *j_proc_entry;
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001141
1142 /**
1143 * @j_stats: Overall statistics.
1144 */
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001145 struct transaction_stats_s j_stats;
1146
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001147 /**
1148 * @j_failed_commit: Failed journal commit ID.
1149 */
Theodore Ts'o624080e2008-06-06 17:50:40 -04001150 unsigned int j_failed_commit;
1151
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001152 /**
1153 * @j_private:
1154 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001155 * An opaque pointer to fs-private information. ext3 puts its
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001156 * superblock pointer here.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001157 */
1158 void *j_private;
Darrick J. Wong01b5adc2012-05-27 07:50:56 -04001159
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001160 /**
1161 * @j_chksum_driver:
1162 *
1163 * Reference to checksum algorithm driver via cryptoapi.
1164 */
Darrick J. Wong01b5adc2012-05-27 07:50:56 -04001165 struct crypto_shash *j_chksum_driver;
Darrick J. Wong4fd5ea42012-05-27 08:08:22 -04001166
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001167 /**
1168 * @j_csum_seed:
1169 *
1170 * Precomputed journal UUID checksum for seeding other checksums.
1171 */
Darrick J. Wong4fd5ea42012-05-27 08:08:22 -04001172 __u32 j_csum_seed;
Jan Karaab714af2016-06-30 11:39:38 -04001173
1174#ifdef CONFIG_DEBUG_LOCK_ALLOC
Tobin C. Hardingf69120c2018-01-10 00:27:29 -05001175 /**
1176 * @j_trans_commit_map:
1177 *
Jan Karaab714af2016-06-30 11:39:38 -04001178 * Lockdep entity to track transaction commit dependencies. Handles
1179 * hold this "lock" for read, when we wait for commit, we acquire the
1180 * "lock" for writing. This matches the properties of jbd2 journalling
1181 * where the running transaction has to wait for all handles to be
1182 * dropped to commit that transaction and also acquiring a handle may
1183 * require transaction commit to finish.
1184 */
1185 struct lockdep_map j_trans_commit_map;
1186#endif
Dave Kleikamp470decc2006-10-11 01:20:57 -07001187};
1188
Jan Kara1eaa5662016-06-30 11:40:54 -04001189#define jbd2_might_wait_for_commit(j) \
1190 do { \
1191 rwsem_acquire(&j->j_trans_commit_map, 0, 0, _THIS_IP_); \
1192 rwsem_release(&j->j_trans_commit_map, 1, _THIS_IP_); \
1193 } while (0)
1194
Darrick J. Wong56316a02015-10-17 16:18:45 -04001195/* journal feature predicate functions */
1196#define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
1197static inline bool jbd2_has_feature_##name(journal_t *j) \
1198{ \
1199 return ((j)->j_format_version >= 2 && \
1200 ((j)->j_superblock->s_feature_compat & \
1201 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
1202} \
1203static inline void jbd2_set_feature_##name(journal_t *j) \
1204{ \
1205 (j)->j_superblock->s_feature_compat |= \
1206 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1207} \
1208static inline void jbd2_clear_feature_##name(journal_t *j) \
1209{ \
1210 (j)->j_superblock->s_feature_compat &= \
1211 ~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1212}
1213
1214#define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
1215static inline bool jbd2_has_feature_##name(journal_t *j) \
1216{ \
1217 return ((j)->j_format_version >= 2 && \
1218 ((j)->j_superblock->s_feature_ro_compat & \
1219 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
1220} \
1221static inline void jbd2_set_feature_##name(journal_t *j) \
1222{ \
1223 (j)->j_superblock->s_feature_ro_compat |= \
1224 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1225} \
1226static inline void jbd2_clear_feature_##name(journal_t *j) \
1227{ \
1228 (j)->j_superblock->s_feature_ro_compat &= \
1229 ~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1230}
1231
1232#define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
1233static inline bool jbd2_has_feature_##name(journal_t *j) \
1234{ \
1235 return ((j)->j_format_version >= 2 && \
1236 ((j)->j_superblock->s_feature_incompat & \
1237 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
1238} \
1239static inline void jbd2_set_feature_##name(journal_t *j) \
1240{ \
1241 (j)->j_superblock->s_feature_incompat |= \
1242 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1243} \
1244static inline void jbd2_clear_feature_##name(journal_t *j) \
1245{ \
1246 (j)->j_superblock->s_feature_incompat &= \
1247 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1248}
1249
1250JBD2_FEATURE_COMPAT_FUNCS(checksum, CHECKSUM)
1251
1252JBD2_FEATURE_INCOMPAT_FUNCS(revoke, REVOKE)
1253JBD2_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
1254JBD2_FEATURE_INCOMPAT_FUNCS(async_commit, ASYNC_COMMIT)
1255JBD2_FEATURE_INCOMPAT_FUNCS(csum2, CSUM_V2)
1256JBD2_FEATURE_INCOMPAT_FUNCS(csum3, CSUM_V3)
1257
Dave Kleikamp470decc2006-10-11 01:20:57 -07001258/*
1259 * Journal flag definitions
1260 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001261#define JBD2_UNMOUNT 0x001 /* Journal thread is being destroyed */
1262#define JBD2_ABORT 0x002 /* Journaling has been aborted for errors. */
1263#define JBD2_ACK_ERR 0x004 /* The errno in the sb has been acked */
1264#define JBD2_FLUSHED 0x008 /* The journal superblock has been flushed */
1265#define JBD2_LOADED 0x010 /* The journal superblock has been loaded */
1266#define JBD2_BARRIER 0x020 /* Use IDE barriers */
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04001267#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file
1268 * data write error in ordered
1269 * mode */
Daeho Jeong4327ba52015-10-18 17:02:56 -04001270#define JBD2_REC_ERR 0x080 /* The errno in the sb has been recorded */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001271
1272/*
1273 * Function declarations for the journaling transaction and buffer
1274 * management
1275 */
1276
1277/* Filing buffers */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001278extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001279extern void __jbd2_journal_refile_buffer(struct journal_head *);
1280extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1281extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001282extern void __journal_free_buffer(struct journal_head *bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001283extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001284extern void __journal_clean_data_list(transaction_t *transaction);
Jan Karaf5113ef2013-06-04 12:01:45 -04001285static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
1286{
1287 list_add_tail(&bh->b_assoc_buffers, head);
1288}
1289static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
1290{
1291 list_del_init(&bh->b_assoc_buffers);
1292}
Dave Kleikamp470decc2006-10-11 01:20:57 -07001293
1294/* Log buffer allocation */
Jan Kara32ab6712016-02-22 23:17:15 -05001295struct buffer_head *jbd2_journal_get_descriptor_buffer(transaction_t *, int);
Jan Kara1101cd42016-02-22 23:19:09 -05001296void jbd2_descriptor_block_csum_set(journal_t *, struct buffer_head *);
Mingming Cao18eba7a2006-10-11 01:21:13 -07001297int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
Jan Kara79feb522012-03-13 22:22:54 -04001298int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1299 unsigned long *block);
Joseph Qi6f6a6fd2015-06-15 14:36:01 -04001300int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
Jan Kara33395782012-03-13 22:45:38 -04001301void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001302
1303/* Commit management */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001304extern void jbd2_journal_commit_transaction(journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001305
1306/* Checkpoint list management */
Jan Kara841df7df2015-07-28 14:57:14 -04001307void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001308int __jbd2_journal_remove_checkpoint(struct journal_head *);
Jan Kara841df7df2015-07-28 14:57:14 -04001309void jbd2_journal_destroy_checkpoint(journal_t *journal);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001310void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001311
Joel Beckere06c8222008-09-11 15:35:47 -07001312
1313/*
1314 * Triggers
1315 */
1316
1317struct jbd2_buffer_trigger_type {
1318 /*
Jan Kara13ceef02010-07-14 07:56:33 +02001319 * Fired a the moment data to write to the journal are known to be
1320 * stable - so either at the moment b_frozen_data is created or just
1321 * before a buffer is written to the journal. mapped_data is a mapped
1322 * buffer that is the frozen data for commit.
Joel Beckere06c8222008-09-11 15:35:47 -07001323 */
Jan Kara13ceef02010-07-14 07:56:33 +02001324 void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
Joel Beckere06c8222008-09-11 15:35:47 -07001325 struct buffer_head *bh, void *mapped_data,
1326 size_t size);
1327
1328 /*
1329 * Fired during journal abort for dirty buffers that will not be
1330 * committed.
1331 */
1332 void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1333 struct buffer_head *bh);
1334};
1335
Jan Kara13ceef02010-07-14 07:56:33 +02001336extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
Joel Beckere06c8222008-09-11 15:35:47 -07001337 void *mapped_data,
1338 struct jbd2_buffer_trigger_type *triggers);
1339extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1340 struct jbd2_buffer_trigger_type *triggers);
1341
Dave Kleikamp470decc2006-10-11 01:20:57 -07001342/* Buffer IO */
Jan Karaf5113ef2013-06-04 12:01:45 -04001343extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1344 struct journal_head *jh_in,
1345 struct buffer_head **bh_out,
1346 sector_t blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001347
1348/* Transaction locking */
1349extern void __wait_on_journal (journal_t *);
1350
Yongqiang Yang0c2022e2012-02-20 17:53:02 -05001351/* Transaction cache support */
1352extern void jbd2_journal_destroy_transaction_cache(void);
Chengguang Xu0d521542019-05-10 21:15:47 -04001353extern int __init jbd2_journal_init_transaction_cache(void);
Yongqiang Yang0c2022e2012-02-20 17:53:02 -05001354extern void jbd2_journal_free_transaction(transaction_t *);
1355
Dave Kleikamp470decc2006-10-11 01:20:57 -07001356/*
1357 * Journal locking.
1358 *
1359 * We need to lock the journal during transaction state changes so that nobody
1360 * ever tries to take a handle on the running transaction while we are in the
1361 * middle of moving it to the commit phase. j_state_lock does this.
1362 *
1363 * Note that the locking is completely interrupt unsafe. We never touch
1364 * journal structures from interrupts.
1365 */
1366
1367static inline handle_t *journal_current_handle(void)
1368{
1369 return current->journal_info;
1370}
1371
1372/* The journaling code user interface:
1373 *
1374 * Create and destroy handles
1375 * Register buffer modifications against the current transaction.
1376 */
1377
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001378extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
Jan Kara8f7d89f2013-06-04 12:35:11 -04001379extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
Jan Karafdc3ef82019-11-05 17:44:26 +01001380 int revoke_records, gfp_t gfp_mask,
1381 unsigned int type, unsigned int line_no);
Theodore Ts'o47def822010-07-27 11:56:05 -04001382extern int jbd2_journal_restart(handle_t *, int nblocks);
Jan Karafdc3ef82019-11-05 17:44:26 +01001383extern int jbd2__journal_restart(handle_t *, int nblocks,
1384 int revoke_records, gfp_t gfp_mask);
Jan Kara8f7d89f2013-06-04 12:35:11 -04001385extern int jbd2_journal_start_reserved(handle_t *handle,
1386 unsigned int type, unsigned int line_no);
1387extern void jbd2_journal_free_reserved(handle_t *handle);
Jan Karafdc3ef82019-11-05 17:44:26 +01001388extern int jbd2_journal_extend(handle_t *handle, int nblocks,
1389 int revoke_records);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001390extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1391extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1392extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
Joel Beckere06c8222008-09-11 15:35:47 -07001393void jbd2_journal_set_triggers(struct buffer_head *,
1394 struct jbd2_buffer_trigger_type *type);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001395extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001396extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
Jan Kara53e87262012-12-25 13:29:52 -05001397extern int jbd2_journal_invalidatepage(journal_t *,
Lukas Czerner259709b2013-05-21 23:20:03 -04001398 struct page *, unsigned int, unsigned int);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001399extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1400extern int jbd2_journal_stop(handle_t *);
1401extern int jbd2_journal_flush (journal_t *);
1402extern void jbd2_journal_lock_updates (journal_t *);
1403extern void jbd2_journal_unlock_updates (journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001404
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001405extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001406 struct block_device *fs_dev,
Mingming Cao18eba7a2006-10-11 01:21:13 -07001407 unsigned long long start, int len, int bsize);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001408extern journal_t * jbd2_journal_init_inode (struct inode *);
1409extern int jbd2_journal_update_format (journal_t *);
1410extern int jbd2_journal_check_used_features
Dave Kleikamp470decc2006-10-11 01:20:57 -07001411 (journal_t *, unsigned long, unsigned long, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001412extern int jbd2_journal_check_available_features
Dave Kleikamp470decc2006-10-11 01:20:57 -07001413 (journal_t *, unsigned long, unsigned long, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001414extern int jbd2_journal_set_features
Dave Kleikamp470decc2006-10-11 01:20:57 -07001415 (journal_t *, unsigned long, unsigned long, unsigned long);
Girish Shilamkar818d2762008-01-28 23:58:27 -05001416extern void jbd2_journal_clear_features
1417 (journal_t *, unsigned long, unsigned long, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001418extern int jbd2_journal_load (journal_t *journal);
Hidehiro Kawai44519fa2008-10-10 20:29:13 -04001419extern int jbd2_journal_destroy (journal_t *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001420extern int jbd2_journal_recover (journal_t *journal);
1421extern int jbd2_journal_wipe (journal_t *, int);
1422extern int jbd2_journal_skip_recovery (journal_t *);
Theodore Ts'od796c522012-08-05 19:04:57 -04001423extern void jbd2_journal_update_sb_errno(journal_t *);
Joseph Qi6f6a6fd2015-06-15 14:36:01 -04001424extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
Jan Kara79feb522012-03-13 22:22:54 -04001425 unsigned long, int);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001426extern void __jbd2_journal_abort_hard (journal_t *);
1427extern void jbd2_journal_abort (journal_t *, int);
1428extern int jbd2_journal_errno (journal_t *);
1429extern void jbd2_journal_ack_err (journal_t *);
1430extern int jbd2_journal_clear_err (journal_t *);
Mingming Cao18eba7a2006-10-11 01:21:13 -07001431extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001432extern int jbd2_journal_force_commit(journal_t *);
Dmitry Monakhov9ff86442013-06-12 22:24:07 -04001433extern int jbd2_journal_force_commit_nested(journal_t *);
Ross Zwisler6ba0e7d2019-06-20 17:24:56 -04001434extern int jbd2_journal_inode_ranged_write(handle_t *handle,
1435 struct jbd2_inode *inode, loff_t start_byte,
1436 loff_t length);
1437extern int jbd2_journal_inode_ranged_wait(handle_t *handle,
1438 struct jbd2_inode *inode, loff_t start_byte,
1439 loff_t length);
Jan Kara7f5aa212009-02-10 11:15:34 -05001440extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1441 struct jbd2_inode *inode, loff_t new_size);
Jan Karac851ed52008-07-11 19:27:31 -04001442extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1443extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001444
1445/*
1446 * journal_head management
1447 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001448struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1449struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001450void jbd2_journal_put_journal_head(struct journal_head *jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001451
1452/*
1453 * handle management
1454 */
Christoph Lametere18b8902006-12-06 20:33:20 -08001455extern struct kmem_cache *jbd2_handle_cache;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001456
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001457static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001458{
Zheng Liu28daf4f2013-04-19 17:49:23 -04001459 return kmem_cache_zalloc(jbd2_handle_cache, gfp_flags);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001460}
1461
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001462static inline void jbd2_free_handle(handle_t *handle)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001463{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001464 kmem_cache_free(jbd2_handle_cache, handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001465}
1466
Theodore Ts'o8aefcd52011-01-10 12:29:43 -05001467/*
1468 * jbd2_inode management (optional, for those file systems that want to use
1469 * dynamically allocated jbd2_inode structures)
1470 */
1471extern struct kmem_cache *jbd2_inode_cache;
1472
1473static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1474{
1475 return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1476}
1477
1478static inline void jbd2_free_inode(struct jbd2_inode *jinode)
1479{
1480 kmem_cache_free(jbd2_inode_cache, jinode);
1481}
1482
Dave Kleikamp470decc2006-10-11 01:20:57 -07001483/* Primary revoke support */
1484#define JOURNAL_REVOKE_DEFAULT_HASH 256
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001485extern int jbd2_journal_init_revoke(journal_t *, int);
Chengguang Xu0d521542019-05-10 21:15:47 -04001486extern void jbd2_journal_destroy_revoke_record_cache(void);
1487extern void jbd2_journal_destroy_revoke_table_cache(void);
1488extern int __init jbd2_journal_init_revoke_record_cache(void);
1489extern int __init jbd2_journal_init_revoke_table_cache(void);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001490
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001491extern void jbd2_journal_destroy_revoke(journal_t *);
Mingming Cao18eba7a2006-10-11 01:21:13 -07001492extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001493extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
Jan Kara9bcf9762016-02-22 23:07:30 -05001494extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
1495 struct list_head *log_bufs);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001496
1497/* Recovery revoke support */
Mingming Cao18eba7a2006-10-11 01:21:13 -07001498extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1499extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001500extern void jbd2_journal_clear_revoke(journal_t *);
1501extern void jbd2_journal_switch_revoke_table(journal_t *journal);
Yongqiang Yang1ba37262011-12-28 17:46:46 -05001502extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001503
1504/*
1505 * The log thread user interface:
1506 *
1507 * Request space in the current transaction, and force transaction commit
1508 * transitions on demand.
1509 */
1510
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001511int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1512int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1513int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001514int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
Jan Karab8a61762017-11-01 16:36:45 +01001515int jbd2_transaction_committed(journal_t *journal, tid_t tid);
Theodore Ts'od76a3a772013-04-03 22:02:52 -04001516int jbd2_complete_transaction(journal_t *journal, tid_t tid);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001517int jbd2_log_do_checkpoint(journal_t *journal);
Jan Karabbd2be32011-05-24 11:59:18 -04001518int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001519
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001520void __jbd2_log_wait_for_space(journal_t *journal);
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001521extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1522extern int jbd2_cleanup_journal_tail(journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001523
Dave Kleikamp470decc2006-10-11 01:20:57 -07001524/*
1525 * is_journal_abort
1526 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001527 * Simple test wrapper function to test the JBD2_ABORT state flag. This
Dave Kleikamp470decc2006-10-11 01:20:57 -07001528 * bit, when set, indicates that we have had a fatal error somewhere,
1529 * either inside the journaling layer or indicated to us by the client
1530 * (eg. ext3), and that we and should not commit any further
1531 * transactions.
1532 */
1533
1534static inline int is_journal_aborted(journal_t *journal)
1535{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001536 return journal->j_flags & JBD2_ABORT;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001537}
1538
1539static inline int is_handle_aborted(handle_t *handle)
1540{
Theodore Ts'o41a5b912013-07-01 08:12:41 -04001541 if (handle->h_aborted || !handle->h_transaction)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001542 return 1;
1543 return is_journal_aborted(handle->h_transaction->t_journal);
1544}
1545
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001546static inline void jbd2_journal_abort_handle(handle_t *handle)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001547{
1548 handle->h_aborted = 1;
1549}
1550
1551#endif /* __KERNEL__ */
1552
1553/* Comparison functions for transaction IDs: perform comparisons using
1554 * modulo arithmetic so that they work over sequence number wraps. */
1555
1556static inline int tid_gt(tid_t x, tid_t y)
1557{
1558 int difference = (x - y);
1559 return (difference > 0);
1560}
1561
1562static inline int tid_geq(tid_t x, tid_t y)
1563{
1564 int difference = (x - y);
1565 return (difference >= 0);
1566}
1567
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001568extern int jbd2_journal_blocks_per_page(struct inode *inode);
Zach Brownb517bea2006-10-11 01:21:08 -07001569extern size_t journal_tag_bytes(journal_t *journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001570
Darrick J. Wong85957982015-10-15 10:30:36 -04001571static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
1572{
Darrick J. Wong56316a02015-10-17 16:18:45 -04001573 return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
Darrick J. Wong85957982015-10-15 10:30:36 -04001574}
1575
Darrick J. Wongdb9ee222014-08-27 18:40:07 -04001576static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
1577{
Darrick J. Wong85957982015-10-15 10:30:36 -04001578 WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
1579 journal->j_chksum_driver == NULL);
Darrick J. Wongdb9ee222014-08-27 18:40:07 -04001580
Darrick J. Wong85957982015-10-15 10:30:36 -04001581 return journal->j_chksum_driver != NULL;
Darrick J. Wongdb9ee222014-08-27 18:40:07 -04001582}
1583
Dave Kleikamp470decc2006-10-11 01:20:57 -07001584/*
Jan Kara76c39902013-06-04 12:12:57 -04001585 * Return number of free blocks in the log. Must be called under j_state_lock.
1586 */
1587static inline unsigned long jbd2_log_space_left(journal_t *journal)
1588{
1589 /* Allow for rounding errors */
Jan Karaadd3efd2019-11-05 17:44:07 +01001590 long free = journal->j_free - 32;
Jan Kara76c39902013-06-04 12:12:57 -04001591
1592 if (journal->j_committing_transaction) {
Jan Kara9f356e52019-11-05 17:44:24 +01001593 free -= atomic_read(&journal->
1594 j_committing_transaction->t_outstanding_credits);
Jan Kara76c39902013-06-04 12:12:57 -04001595 }
Jan Karaadd3efd2019-11-05 17:44:07 +01001596 return max_t(long, free, 0);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001597}
1598
1599/*
1600 * Definitions which augment the buffer_head layer
1601 */
1602
1603/* journaling buffer types */
1604#define BJ_None 0 /* Not journaled */
Jan Kara87c89c22008-07-11 19:27:31 -04001605#define BJ_Metadata 1 /* Normal journaled metadata */
1606#define BJ_Forget 2 /* Buffer superseded by this transaction */
Jan Karaf5113ef2013-06-04 12:01:45 -04001607#define BJ_Shadow 3 /* Buffer contents being shadowed to the log */
Jan Karae5a120a2013-06-04 12:06:01 -04001608#define BJ_Reserved 4 /* Buffer is reserved for access by journal */
1609#define BJ_Types 5
Dave Kleikamp470decc2006-10-11 01:20:57 -07001610
1611extern int jbd_blocks_per_page(struct inode *inode);
1612
Behan Websterfd47d3e2012-11-08 11:24:46 -05001613/* JBD uses a CRC32 checksum */
1614#define JBD_MAX_CHECKSUM_SIZE 4
1615
Darrick J. Wong01b5adc2012-05-27 07:50:56 -04001616static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
1617 const void *address, unsigned int length)
1618{
1619 struct {
1620 struct shash_desc shash;
Behan Websterfd47d3e2012-11-08 11:24:46 -05001621 char ctx[JBD_MAX_CHECKSUM_SIZE];
Darrick J. Wong01b5adc2012-05-27 07:50:56 -04001622 } desc;
1623 int err;
1624
Behan Websterfd47d3e2012-11-08 11:24:46 -05001625 BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
1626 JBD_MAX_CHECKSUM_SIZE);
1627
Darrick J. Wong01b5adc2012-05-27 07:50:56 -04001628 desc.shash.tfm = journal->j_chksum_driver;
Darrick J. Wong01b5adc2012-05-27 07:50:56 -04001629 *(u32 *)desc.ctx = crc;
1630
1631 err = crypto_shash_update(&desc.shash, address, length);
1632 BUG_ON(err);
1633
1634 return *(u32 *)desc.ctx;
1635}
1636
Dmitry Monakhov06a407f2013-06-12 22:25:07 -04001637/* Return most recent uncommitted transaction */
1638static inline tid_t jbd2_get_latest_transaction(journal_t *journal)
1639{
1640 tid_t tid;
1641
1642 read_lock(&journal->j_state_lock);
1643 tid = journal->j_commit_request;
1644 if (journal->j_running_transaction)
1645 tid = journal->j_running_transaction->t_tid;
1646 read_unlock(&journal->j_state_lock);
1647 return tid;
1648}
1649
Jan Karaa9a83442019-11-05 17:44:17 +01001650
1651static inline int jbd2_handle_buffer_credits(handle_t *handle)
1652{
Jan Karafdc3ef82019-11-05 17:44:26 +01001653 journal_t *journal = handle->h_transaction->t_journal;
1654
1655 return handle->h_buffer_credits -
1656 DIV_ROUND_UP(handle->h_revoke_credits_requested,
1657 journal->j_revoke_records_per_block);
Jan Karaa9a83442019-11-05 17:44:17 +01001658}
1659
Dave Kleikamp470decc2006-10-11 01:20:57 -07001660#ifdef __KERNEL__
1661
1662#define buffer_trace_init(bh) do {} while (0)
1663#define print_buffer_fields(bh) do {} while (0)
1664#define print_buffer_trace(bh) do {} while (0)
1665#define BUFFER_TRACE(bh, info) do {} while (0)
1666#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1667#define JBUFFER_TRACE(jh, info) do {} while (0)
1668
1669#endif /* __KERNEL__ */
1670
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001671#define EFSBADCRC EBADMSG /* Bad CRC detected */
1672#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
1673
Mingming Caocd02ff02007-10-16 18:38:25 -04001674#endif /* _LINUX_JBD2_H */