Loading...
1/*
2 * linux/include/linux/jbd2.h
3 *
4 * Written by Stephen C. Tweedie <sct@redhat.com>
5 *
6 * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
7 *
8 * This file is part of the Linux kernel and is made available under
9 * the terms of the GNU General Public License, version 2, or at your
10 * option, any later version, incorporated herein by reference.
11 *
12 * Definitions for transaction data structures for the buffer cache
13 * filesystem journaling support.
14 */
15
16#ifndef _LINUX_JBD2_H
17#define _LINUX_JBD2_H
18
19/* Allow this file to be included directly into e2fsprogs */
20#ifndef __KERNEL__
21#include "jfs_compat.h"
22#define JBD2_DEBUG
23#define jfs_debug jbd_debug
24#else
25
26#include <linux/types.h>
27#include <linux/buffer_head.h>
28#include <linux/journal-head.h>
29#include <linux/stddef.h>
30#include <linux/bit_spinlock.h>
31#include <linux/mutex.h>
32#include <linux/timer.h>
33#include <linux/slab.h>
34#include <crypto/hash.h>
35#endif
36
37#define journal_oom_retry 1
38
39/*
40 * Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
41 * certain classes of error which can occur due to failed IOs. Under
42 * normal use we want ext4 to continue after such errors, because
43 * hardware _can_ fail, but for debugging purposes when running tests on
44 * known-good hardware we may want to trap these errors.
45 */
46#undef JBD2_PARANOID_IOFAIL
47
48/*
49 * The default maximum commit age, in seconds.
50 */
51#define JBD2_DEFAULT_MAX_COMMIT_AGE 5
52
53#ifdef CONFIG_JBD2_DEBUG
54/*
55 * Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
56 * consistency checks. By default we don't do this unless
57 * CONFIG_JBD2_DEBUG is on.
58 */
59#define JBD2_EXPENSIVE_CHECKING
60extern u8 jbd2_journal_enable_debug;
61
62#define jbd_debug(n, f, a...) \
63 do { \
64 if ((n) <= jbd2_journal_enable_debug) { \
65 printk (KERN_DEBUG "(%s, %d): %s: ", \
66 __FILE__, __LINE__, __func__); \
67 printk (f, ## a); \
68 } \
69 } while (0)
70#else
71#define jbd_debug(f, a...) /**/
72#endif
73
74extern void *jbd2_alloc(size_t size, gfp_t flags);
75extern void jbd2_free(void *ptr, size_t size);
76
77#define JBD2_MIN_JOURNAL_BLOCKS 1024
78
79#ifdef __KERNEL__
80
81/**
82 * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
83 *
84 * All filesystem modifications made by the process go
85 * through this handle. Recursive operations (such as quota operations)
86 * are gathered into a single update.
87 *
88 * The buffer credits field is used to account for journaled buffers
89 * being modified by the running process. To ensure that there is
90 * enough log space for all outstanding operations, we need to limit the
91 * number of outstanding buffers possible at any time. When the
92 * operation completes, any buffer credits not used are credited back to
93 * the transaction, so that at all times we know how many buffers the
94 * outstanding updates on a transaction might possibly touch.
95 *
96 * This is an opaque datatype.
97 **/
98typedef struct jbd2_journal_handle handle_t; /* Atomic operation type */
99
100
101/**
102 * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
103 *
104 * journal_t is linked to from the fs superblock structure.
105 *
106 * We use the journal_t to keep track of all outstanding transaction
107 * activity on the filesystem, and to manage the state of the log
108 * writing process.
109 *
110 * This is an opaque datatype.
111 **/
112typedef struct journal_s journal_t; /* Journal control structure */
113#endif
114
115/*
116 * Internal structures used by the logging mechanism:
117 */
118
119#define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
120
121/*
122 * On-disk structures
123 */
124
125/*
126 * Descriptor block types:
127 */
128
129#define JBD2_DESCRIPTOR_BLOCK 1
130#define JBD2_COMMIT_BLOCK 2
131#define JBD2_SUPERBLOCK_V1 3
132#define JBD2_SUPERBLOCK_V2 4
133#define JBD2_REVOKE_BLOCK 5
134
135/*
136 * Standard header for all descriptor blocks:
137 */
138typedef struct journal_header_s
139{
140 __be32 h_magic;
141 __be32 h_blocktype;
142 __be32 h_sequence;
143} journal_header_t;
144
145/*
146 * Checksum types.
147 */
148#define JBD2_CRC32_CHKSUM 1
149#define JBD2_MD5_CHKSUM 2
150#define JBD2_SHA1_CHKSUM 3
151#define JBD2_CRC32C_CHKSUM 4
152
153#define JBD2_CRC32_CHKSUM_SIZE 4
154
155#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
156/*
157 * Commit block header for storing transactional checksums:
158 *
159 * NOTE: If FEATURE_COMPAT_CHECKSUM (checksum v1) is set, the h_chksum*
160 * fields are used to store a checksum of the descriptor and data blocks.
161 *
162 * If FEATURE_INCOMPAT_CSUM_V2 (checksum v2) is set, then the h_chksum
163 * field is used to store crc32c(uuid+commit_block). Each journal metadata
164 * block gets its own checksum, and data block checksums are stored in
165 * journal_block_tag (in the descriptor). The other h_chksum* fields are
166 * not used.
167 *
168 * Checksum v1 and v2 are mutually exclusive features.
169 */
170struct commit_header {
171 __be32 h_magic;
172 __be32 h_blocktype;
173 __be32 h_sequence;
174 unsigned char h_chksum_type;
175 unsigned char h_chksum_size;
176 unsigned char h_padding[2];
177 __be32 h_chksum[JBD2_CHECKSUM_BYTES];
178 __be64 h_commit_sec;
179 __be32 h_commit_nsec;
180};
181
182/*
183 * The block tag: used to describe a single buffer in the journal.
184 * t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
185 * raw struct shouldn't be used for pointer math or sizeof() - use
186 * journal_tag_bytes(journal) instead to compute this.
187 */
188typedef struct journal_block_tag_s
189{
190 __be32 t_blocknr; /* The on-disk block number */
191 __be16 t_checksum; /* truncated crc32c(uuid+seq+block) */
192 __be16 t_flags; /* See below */
193 __be32 t_blocknr_high; /* most-significant high 32bits. */
194} journal_block_tag_t;
195
196#define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
197#define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
198
199/* Tail of descriptor block, for checksumming */
200struct jbd2_journal_block_tail {
201 __be32 t_checksum; /* crc32c(uuid+descr_block) */
202};
203
204/*
205 * The revoke descriptor: used on disk to describe a series of blocks to
206 * be revoked from the log
207 */
208typedef struct jbd2_journal_revoke_header_s
209{
210 journal_header_t r_header;
211 __be32 r_count; /* Count of bytes used in the block */
212} jbd2_journal_revoke_header_t;
213
214/* Tail of revoke block, for checksumming */
215struct jbd2_journal_revoke_tail {
216 __be32 r_checksum; /* crc32c(uuid+revoke_block) */
217};
218
219/* Definitions for the journal tag flags word: */
220#define JBD2_FLAG_ESCAPE 1 /* on-disk block is escaped */
221#define JBD2_FLAG_SAME_UUID 2 /* block has same uuid as previous */
222#define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
223#define JBD2_FLAG_LAST_TAG 8 /* last tag in this descriptor block */
224
225
226/*
227 * The journal superblock. All fields are in big-endian byte order.
228 */
229typedef struct journal_superblock_s
230{
231/* 0x0000 */
232 journal_header_t s_header;
233
234/* 0x000C */
235 /* Static information describing the journal */
236 __be32 s_blocksize; /* journal device blocksize */
237 __be32 s_maxlen; /* total blocks in journal file */
238 __be32 s_first; /* first block of log information */
239
240/* 0x0018 */
241 /* Dynamic information describing the current state of the log */
242 __be32 s_sequence; /* first commit ID expected in log */
243 __be32 s_start; /* blocknr of start of log */
244
245/* 0x0020 */
246 /* Error value, as set by jbd2_journal_abort(). */
247 __be32 s_errno;
248
249/* 0x0024 */
250 /* Remaining fields are only valid in a version-2 superblock */
251 __be32 s_feature_compat; /* compatible feature set */
252 __be32 s_feature_incompat; /* incompatible feature set */
253 __be32 s_feature_ro_compat; /* readonly-compatible feature set */
254/* 0x0030 */
255 __u8 s_uuid[16]; /* 128-bit uuid for journal */
256
257/* 0x0040 */
258 __be32 s_nr_users; /* Nr of filesystems sharing log */
259
260 __be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/
261
262/* 0x0048 */
263 __be32 s_max_transaction; /* Limit of journal blocks per trans.*/
264 __be32 s_max_trans_data; /* Limit of data blocks per trans. */
265
266/* 0x0050 */
267 __u8 s_checksum_type; /* checksum type */
268 __u8 s_padding2[3];
269 __u32 s_padding[42];
270 __be32 s_checksum; /* crc32c(superblock) */
271
272/* 0x0100 */
273 __u8 s_users[16*48]; /* ids of all fs'es sharing the log */
274/* 0x0400 */
275} journal_superblock_t;
276
277#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
278 ((j)->j_format_version >= 2 && \
279 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
280#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
281 ((j)->j_format_version >= 2 && \
282 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
283#define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
284 ((j)->j_format_version >= 2 && \
285 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
286
287#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
288
289#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
290#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
291#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
292#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
293
294/* Features known to this kernel version: */
295#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
296#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
297#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
298 JBD2_FEATURE_INCOMPAT_64BIT | \
299 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
300 JBD2_FEATURE_INCOMPAT_CSUM_V2)
301
302#ifdef __KERNEL__
303
304#include <linux/fs.h>
305#include <linux/sched.h>
306#include <linux/jbd_common.h>
307
308#define J_ASSERT(assert) BUG_ON(!(assert))
309
310#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
311#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
312
313#if defined(JBD2_PARANOID_IOFAIL)
314#define J_EXPECT(expr, why...) J_ASSERT(expr)
315#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
316#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
317#else
318#define __journal_expect(expr, why...) \
319 ({ \
320 int val = (expr); \
321 if (!val) { \
322 printk(KERN_ERR \
323 "JBD2 unexpected failure: %s: %s;\n", \
324 __func__, #expr); \
325 printk(KERN_ERR why "\n"); \
326 } \
327 val; \
328 })
329#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
330#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
331#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
332#endif
333
334/* Flags in jbd_inode->i_flags */
335#define __JI_COMMIT_RUNNING 0
336/* Commit of the inode data in progress. We use this flag to protect us from
337 * concurrent deletion of inode. We cannot use reference to inode for this
338 * since we cannot afford doing last iput() on behalf of kjournald
339 */
340#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
341
342/**
343 * struct jbd_inode is the structure linking inodes in ordered mode
344 * present in a transaction so that we can sync them during commit.
345 */
346struct jbd2_inode {
347 /* Which transaction does this inode belong to? Either the running
348 * transaction or the committing one. [j_list_lock] */
349 transaction_t *i_transaction;
350
351 /* Pointer to the running transaction modifying inode's data in case
352 * there is already a committing transaction touching it. [j_list_lock] */
353 transaction_t *i_next_transaction;
354
355 /* List of inodes in the i_transaction [j_list_lock] */
356 struct list_head i_list;
357
358 /* VFS inode this inode belongs to [constant during the lifetime
359 * of the structure] */
360 struct inode *i_vfs_inode;
361
362 /* Flags of inode [j_list_lock] */
363 unsigned long i_flags;
364};
365
366struct jbd2_revoke_table_s;
367
368/**
369 * struct handle_s - The handle_s type is the concrete type associated with
370 * handle_t.
371 * @h_transaction: Which compound transaction is this update a part of?
372 * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
373 * @h_ref: Reference count on this handle
374 * @h_err: Field for caller's use to track errors through large fs operations
375 * @h_sync: flag for sync-on-close
376 * @h_jdata: flag to force data journaling
377 * @h_aborted: flag indicating fatal error on handle
378 **/
379
380/* Docbook can't yet cope with the bit fields, but will leave the documentation
381 * in so it can be fixed later.
382 */
383
384struct jbd2_journal_handle
385{
386 /* Which compound transaction is this update a part of? */
387 transaction_t *h_transaction;
388
389 /* Number of remaining buffers we are allowed to dirty: */
390 int h_buffer_credits;
391
392 /* Reference count on this handle */
393 int h_ref;
394
395 /* Field for caller's use to track errors through large fs */
396 /* operations */
397 int h_err;
398
399 /* Flags [no locking] */
400 unsigned int h_sync:1; /* sync-on-close */
401 unsigned int h_jdata:1; /* force data journaling */
402 unsigned int h_aborted:1; /* fatal error on handle */
403 unsigned int h_cowing:1; /* COWing block to snapshot */
404
405 /* Number of buffers requested by user:
406 * (before adding the COW credits factor) */
407 unsigned int h_base_credits:14;
408
409 /* Number of buffers the user is allowed to dirty:
410 * (counts only buffers dirtied when !h_cowing) */
411 unsigned int h_user_credits:14;
412
413
414#ifdef CONFIG_DEBUG_LOCK_ALLOC
415 struct lockdep_map h_lockdep_map;
416#endif
417
418#ifdef CONFIG_JBD2_DEBUG
419 /* COW debugging counters: */
420 unsigned int h_cow_moved; /* blocks moved to snapshot */
421 unsigned int h_cow_copied; /* blocks copied to snapshot */
422 unsigned int h_cow_ok_jh; /* blocks already COWed during current
423 transaction */
424 unsigned int h_cow_ok_bitmap; /* blocks not set in COW bitmap */
425 unsigned int h_cow_ok_mapped;/* blocks already mapped in snapshot */
426 unsigned int h_cow_bitmaps; /* COW bitmaps created */
427 unsigned int h_cow_excluded; /* blocks set in exclude bitmap */
428#endif
429};
430
431
432/*
433 * Some stats for checkpoint phase
434 */
435struct transaction_chp_stats_s {
436 unsigned long cs_chp_time;
437 __u32 cs_forced_to_close;
438 __u32 cs_written;
439 __u32 cs_dropped;
440};
441
442/* The transaction_t type is the guts of the journaling mechanism. It
443 * tracks a compound transaction through its various states:
444 *
445 * RUNNING: accepting new updates
446 * LOCKED: Updates still running but we don't accept new ones
447 * RUNDOWN: Updates are tidying up but have finished requesting
448 * new buffers to modify (state not used for now)
449 * FLUSH: All updates complete, but we are still writing to disk
450 * COMMIT: All data on disk, writing commit record
451 * FINISHED: We still have to keep the transaction for checkpointing.
452 *
453 * The transaction keeps track of all of the buffers modified by a
454 * running transaction, and all of the buffers committed but not yet
455 * flushed to home for finished transactions.
456 */
457
458/*
459 * Lock ranking:
460 *
461 * j_list_lock
462 * ->jbd_lock_bh_journal_head() (This is "innermost")
463 *
464 * j_state_lock
465 * ->jbd_lock_bh_state()
466 *
467 * jbd_lock_bh_state()
468 * ->j_list_lock
469 *
470 * j_state_lock
471 * ->t_handle_lock
472 *
473 * j_state_lock
474 * ->j_list_lock (journal_unmap_buffer)
475 *
476 */
477
478struct transaction_s
479{
480 /* Pointer to the journal for this transaction. [no locking] */
481 journal_t *t_journal;
482
483 /* Sequence number for this transaction [no locking] */
484 tid_t t_tid;
485
486 /*
487 * Transaction's current state
488 * [no locking - only kjournald2 alters this]
489 * [j_list_lock] guards transition of a transaction into T_FINISHED
490 * state and subsequent call of __jbd2_journal_drop_transaction()
491 * FIXME: needs barriers
492 * KLUDGE: [use j_state_lock]
493 */
494 enum {
495 T_RUNNING,
496 T_LOCKED,
497 T_FLUSH,
498 T_COMMIT,
499 T_COMMIT_DFLUSH,
500 T_COMMIT_JFLUSH,
501 T_FINISHED
502 } t_state;
503
504 /*
505 * Where in the log does this transaction's commit start? [no locking]
506 */
507 unsigned long t_log_start;
508
509 /* Number of buffers on the t_buffers list [j_list_lock] */
510 int t_nr_buffers;
511
512 /*
513 * Doubly-linked circular list of all buffers reserved but not yet
514 * modified by this transaction [j_list_lock]
515 */
516 struct journal_head *t_reserved_list;
517
518 /*
519 * Doubly-linked circular list of all metadata buffers owned by this
520 * transaction [j_list_lock]
521 */
522 struct journal_head *t_buffers;
523
524 /*
525 * Doubly-linked circular list of all forget buffers (superseded
526 * buffers which we can un-checkpoint once this transaction commits)
527 * [j_list_lock]
528 */
529 struct journal_head *t_forget;
530
531 /*
532 * Doubly-linked circular list of all buffers still to be flushed before
533 * this transaction can be checkpointed. [j_list_lock]
534 */
535 struct journal_head *t_checkpoint_list;
536
537 /*
538 * Doubly-linked circular list of all buffers submitted for IO while
539 * checkpointing. [j_list_lock]
540 */
541 struct journal_head *t_checkpoint_io_list;
542
543 /*
544 * Doubly-linked circular list of temporary buffers currently undergoing
545 * IO in the log [j_list_lock]
546 */
547 struct journal_head *t_iobuf_list;
548
549 /*
550 * Doubly-linked circular list of metadata buffers being shadowed by log
551 * IO. The IO buffers on the iobuf list and the shadow buffers on this
552 * list match each other one for one at all times. [j_list_lock]
553 */
554 struct journal_head *t_shadow_list;
555
556 /*
557 * Doubly-linked circular list of control buffers being written to the
558 * log. [j_list_lock]
559 */
560 struct journal_head *t_log_list;
561
562 /*
563 * List of inodes whose data we've modified in data=ordered mode.
564 * [j_list_lock]
565 */
566 struct list_head t_inode_list;
567
568 /*
569 * Protects info related to handles
570 */
571 spinlock_t t_handle_lock;
572
573 /*
574 * Longest time some handle had to wait for running transaction
575 */
576 unsigned long t_max_wait;
577
578 /*
579 * When transaction started
580 */
581 unsigned long t_start;
582
583 /*
584 * Checkpointing stats [j_checkpoint_sem]
585 */
586 struct transaction_chp_stats_s t_chp_stats;
587
588 /*
589 * Number of outstanding updates running on this transaction
590 * [t_handle_lock]
591 */
592 atomic_t t_updates;
593
594 /*
595 * Number of buffers reserved for use by all handles in this transaction
596 * handle but not yet modified. [t_handle_lock]
597 */
598 atomic_t t_outstanding_credits;
599
600 /*
601 * Forward and backward links for the circular list of all transactions
602 * awaiting checkpoint. [j_list_lock]
603 */
604 transaction_t *t_cpnext, *t_cpprev;
605
606 /*
607 * When will the transaction expire (become due for commit), in jiffies?
608 * [no locking]
609 */
610 unsigned long t_expires;
611
612 /*
613 * When this transaction started, in nanoseconds [no locking]
614 */
615 ktime_t t_start_time;
616
617 /*
618 * How many handles used this transaction? [t_handle_lock]
619 */
620 atomic_t t_handle_count;
621
622 /*
623 * This transaction is being forced and some process is
624 * waiting for it to finish.
625 */
626 unsigned int t_synchronous_commit:1;
627
628 /* Disk flush needs to be sent to fs partition [no locking] */
629 int t_need_data_flush;
630
631 /*
632 * For use by the filesystem to store fs-specific data
633 * structures associated with the transaction
634 */
635 struct list_head t_private_list;
636};
637
638struct transaction_run_stats_s {
639 unsigned long rs_wait;
640 unsigned long rs_running;
641 unsigned long rs_locked;
642 unsigned long rs_flushing;
643 unsigned long rs_logging;
644
645 __u32 rs_handle_count;
646 __u32 rs_blocks;
647 __u32 rs_blocks_logged;
648};
649
650struct transaction_stats_s {
651 unsigned long ts_tid;
652 struct transaction_run_stats_s run;
653};
654
655static inline unsigned long
656jbd2_time_diff(unsigned long start, unsigned long end)
657{
658 if (end >= start)
659 return end - start;
660
661 return end + (MAX_JIFFY_OFFSET - start);
662}
663
664#define JBD2_NR_BATCH 64
665
666/**
667 * struct journal_s - The journal_s type is the concrete type associated with
668 * journal_t.
669 * @j_flags: General journaling state flags
670 * @j_errno: Is there an outstanding uncleared error on the journal (from a
671 * prior abort)?
672 * @j_sb_buffer: First part of superblock buffer
673 * @j_superblock: Second part of superblock buffer
674 * @j_format_version: Version of the superblock format
675 * @j_state_lock: Protect the various scalars in the journal
676 * @j_barrier_count: Number of processes waiting to create a barrier lock
677 * @j_barrier: The barrier lock itself
678 * @j_running_transaction: The current running transaction..
679 * @j_committing_transaction: the transaction we are pushing to disk
680 * @j_checkpoint_transactions: a linked circular list of all transactions
681 * waiting for checkpointing
682 * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
683 * to start committing, or for a barrier lock to be released
684 * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
685 * @j_wait_done_commit: Wait queue for waiting for commit to complete
686 * @j_wait_checkpoint: Wait queue to trigger checkpointing
687 * @j_wait_commit: Wait queue to trigger commit
688 * @j_wait_updates: Wait queue to wait for updates to complete
689 * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
690 * @j_head: Journal head - identifies the first unused block in the journal
691 * @j_tail: Journal tail - identifies the oldest still-used block in the
692 * journal.
693 * @j_free: Journal free - how many free blocks are there in the journal?
694 * @j_first: The block number of the first usable block
695 * @j_last: The block number one beyond the last usable block
696 * @j_dev: Device where we store the journal
697 * @j_blocksize: blocksize for the location where we store the journal.
698 * @j_blk_offset: starting block offset for into the device where we store the
699 * journal
700 * @j_fs_dev: Device which holds the client fs. For internal journal this will
701 * be equal to j_dev
702 * @j_maxlen: Total maximum capacity of the journal region on disk.
703 * @j_list_lock: Protects the buffer lists and internal buffer state.
704 * @j_inode: Optional inode where we store the journal. If present, all journal
705 * block numbers are mapped into this inode via bmap().
706 * @j_tail_sequence: Sequence number of the oldest transaction in the log
707 * @j_transaction_sequence: Sequence number of the next transaction to grant
708 * @j_commit_sequence: Sequence number of the most recently committed
709 * transaction
710 * @j_commit_request: Sequence number of the most recent transaction wanting
711 * commit
712 * @j_uuid: Uuid of client object.
713 * @j_task: Pointer to the current commit thread for this journal
714 * @j_max_transaction_buffers: Maximum number of metadata buffers to allow in a
715 * single compound commit transaction
716 * @j_commit_interval: What is the maximum transaction lifetime before we begin
717 * a commit?
718 * @j_commit_timer: The timer used to wakeup the commit thread
719 * @j_revoke_lock: Protect the revoke table
720 * @j_revoke: The revoke table - maintains the list of revoked blocks in the
721 * current transaction.
722 * @j_revoke_table: alternate revoke tables for j_revoke
723 * @j_wbuf: array of buffer_heads for jbd2_journal_commit_transaction
724 * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
725 * number that will fit in j_blocksize
726 * @j_last_sync_writer: most recent pid which did a synchronous write
727 * @j_history: Buffer storing the transactions statistics history
728 * @j_history_max: Maximum number of transactions in the statistics history
729 * @j_history_cur: Current number of transactions in the statistics history
730 * @j_history_lock: Protect the transactions statistics history
731 * @j_proc_entry: procfs entry for the jbd statistics directory
732 * @j_stats: Overall statistics
733 * @j_private: An opaque pointer to fs-private information.
734 */
735
736struct journal_s
737{
738 /* General journaling state flags [j_state_lock] */
739 unsigned long j_flags;
740
741 /*
742 * Is there an outstanding uncleared error on the journal (from a prior
743 * abort)? [j_state_lock]
744 */
745 int j_errno;
746
747 /* The superblock buffer */
748 struct buffer_head *j_sb_buffer;
749 journal_superblock_t *j_superblock;
750
751 /* Version of the superblock format */
752 int j_format_version;
753
754 /*
755 * Protect the various scalars in the journal
756 */
757 rwlock_t j_state_lock;
758
759 /*
760 * Number of processes waiting to create a barrier lock [j_state_lock]
761 */
762 int j_barrier_count;
763
764 /* The barrier lock itself */
765 struct mutex j_barrier;
766
767 /*
768 * Transactions: The current running transaction...
769 * [j_state_lock] [caller holding open handle]
770 */
771 transaction_t *j_running_transaction;
772
773 /*
774 * the transaction we are pushing to disk
775 * [j_state_lock] [caller holding open handle]
776 */
777 transaction_t *j_committing_transaction;
778
779 /*
780 * ... and a linked circular list of all transactions waiting for
781 * checkpointing. [j_list_lock]
782 */
783 transaction_t *j_checkpoint_transactions;
784
785 /*
786 * Wait queue for waiting for a locked transaction to start committing,
787 * or for a barrier lock to be released
788 */
789 wait_queue_head_t j_wait_transaction_locked;
790
791 /* Wait queue for waiting for checkpointing to complete */
792 wait_queue_head_t j_wait_logspace;
793
794 /* Wait queue for waiting for commit to complete */
795 wait_queue_head_t j_wait_done_commit;
796
797 /* Wait queue to trigger checkpointing */
798 wait_queue_head_t j_wait_checkpoint;
799
800 /* Wait queue to trigger commit */
801 wait_queue_head_t j_wait_commit;
802
803 /* Wait queue to wait for updates to complete */
804 wait_queue_head_t j_wait_updates;
805
806 /* Semaphore for locking against concurrent checkpoints */
807 struct mutex j_checkpoint_mutex;
808
809 /*
810 * List of buffer heads used by the checkpoint routine. This
811 * was moved from jbd2_log_do_checkpoint() to reduce stack
812 * usage. Access to this array is controlled by the
813 * j_checkpoint_mutex. [j_checkpoint_mutex]
814 */
815 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
816
817 /*
818 * Journal head: identifies the first unused block in the journal.
819 * [j_state_lock]
820 */
821 unsigned long j_head;
822
823 /*
824 * Journal tail: identifies the oldest still-used block in the journal.
825 * [j_state_lock]
826 */
827 unsigned long j_tail;
828
829 /*
830 * Journal free: how many free blocks are there in the journal?
831 * [j_state_lock]
832 */
833 unsigned long j_free;
834
835 /*
836 * Journal start and end: the block numbers of the first usable block
837 * and one beyond the last usable block in the journal. [j_state_lock]
838 */
839 unsigned long j_first;
840 unsigned long j_last;
841
842 /*
843 * Device, blocksize and starting block offset for the location where we
844 * store the journal.
845 */
846 struct block_device *j_dev;
847 int j_blocksize;
848 unsigned long long j_blk_offset;
849 char j_devname[BDEVNAME_SIZE+24];
850
851 /*
852 * Device which holds the client fs. For internal journal this will be
853 * equal to j_dev.
854 */
855 struct block_device *j_fs_dev;
856
857 /* Total maximum capacity of the journal region on disk. */
858 unsigned int j_maxlen;
859
860 /*
861 * Protects the buffer lists and internal buffer state.
862 */
863 spinlock_t j_list_lock;
864
865 /* Optional inode where we store the journal. If present, all */
866 /* journal block numbers are mapped into this inode via */
867 /* bmap(). */
868 struct inode *j_inode;
869
870 /*
871 * Sequence number of the oldest transaction in the log [j_state_lock]
872 */
873 tid_t j_tail_sequence;
874
875 /*
876 * Sequence number of the next transaction to grant [j_state_lock]
877 */
878 tid_t j_transaction_sequence;
879
880 /*
881 * Sequence number of the most recently committed transaction
882 * [j_state_lock].
883 */
884 tid_t j_commit_sequence;
885
886 /*
887 * Sequence number of the most recent transaction wanting commit
888 * [j_state_lock]
889 */
890 tid_t j_commit_request;
891
892 /*
893 * Journal uuid: identifies the object (filesystem, LVM volume etc)
894 * backed by this journal. This will eventually be replaced by an array
895 * of uuids, allowing us to index multiple devices within a single
896 * journal and to perform atomic updates across them.
897 */
898 __u8 j_uuid[16];
899
900 /* Pointer to the current commit thread for this journal */
901 struct task_struct *j_task;
902
903 /*
904 * Maximum number of metadata buffers to allow in a single compound
905 * commit transaction
906 */
907 int j_max_transaction_buffers;
908
909 /*
910 * What is the maximum transaction lifetime before we begin a commit?
911 */
912 unsigned long j_commit_interval;
913
914 /* The timer used to wakeup the commit thread: */
915 struct timer_list j_commit_timer;
916
917 /*
918 * The revoke table: maintains the list of revoked blocks in the
919 * current transaction. [j_revoke_lock]
920 */
921 spinlock_t j_revoke_lock;
922 struct jbd2_revoke_table_s *j_revoke;
923 struct jbd2_revoke_table_s *j_revoke_table[2];
924
925 /*
926 * array of bhs for jbd2_journal_commit_transaction
927 */
928 struct buffer_head **j_wbuf;
929 int j_wbufsize;
930
931 /*
932 * this is the pid of hte last person to run a synchronous operation
933 * through the journal
934 */
935 pid_t j_last_sync_writer;
936
937 /*
938 * the average amount of time in nanoseconds it takes to commit a
939 * transaction to disk. [j_state_lock]
940 */
941 u64 j_average_commit_time;
942
943 /*
944 * minimum and maximum times that we should wait for
945 * additional filesystem operations to get batched into a
946 * synchronous handle in microseconds
947 */
948 u32 j_min_batch_time;
949 u32 j_max_batch_time;
950
951 /* This function is called when a transaction is closed */
952 void (*j_commit_callback)(journal_t *,
953 transaction_t *);
954
955 /*
956 * Journal statistics
957 */
958 spinlock_t j_history_lock;
959 struct proc_dir_entry *j_proc_entry;
960 struct transaction_stats_s j_stats;
961
962 /* Failed journal commit ID */
963 unsigned int j_failed_commit;
964
965 /*
966 * An opaque pointer to fs-private information. ext3 puts its
967 * superblock pointer here
968 */
969 void *j_private;
970
971 /* Reference to checksum algorithm driver via cryptoapi */
972 struct crypto_shash *j_chksum_driver;
973
974 /* Precomputed journal UUID checksum for seeding other checksums */
975 __u32 j_csum_seed;
976};
977
978/*
979 * Journal flag definitions
980 */
981#define JBD2_UNMOUNT 0x001 /* Journal thread is being destroyed */
982#define JBD2_ABORT 0x002 /* Journaling has been aborted for errors. */
983#define JBD2_ACK_ERR 0x004 /* The errno in the sb has been acked */
984#define JBD2_FLUSHED 0x008 /* The journal superblock has been flushed */
985#define JBD2_LOADED 0x010 /* The journal superblock has been loaded */
986#define JBD2_BARRIER 0x020 /* Use IDE barriers */
987#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file
988 * data write error in ordered
989 * mode */
990
991/*
992 * Function declarations for the journaling transaction and buffer
993 * management
994 */
995
996/* Filing buffers */
997extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
998extern void __jbd2_journal_refile_buffer(struct journal_head *);
999extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1000extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1001extern void __journal_free_buffer(struct journal_head *bh);
1002extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1003extern void __journal_clean_data_list(transaction_t *transaction);
1004
1005/* Log buffer allocation */
1006extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
1007int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
1008int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1009 unsigned long *block);
1010void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1011void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1012
1013/* Commit management */
1014extern void jbd2_journal_commit_transaction(journal_t *);
1015
1016/* Checkpoint list management */
1017int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
1018int __jbd2_journal_remove_checkpoint(struct journal_head *);
1019void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
1020
1021
1022/*
1023 * Triggers
1024 */
1025
1026struct jbd2_buffer_trigger_type {
1027 /*
1028 * Fired a the moment data to write to the journal are known to be
1029 * stable - so either at the moment b_frozen_data is created or just
1030 * before a buffer is written to the journal. mapped_data is a mapped
1031 * buffer that is the frozen data for commit.
1032 */
1033 void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
1034 struct buffer_head *bh, void *mapped_data,
1035 size_t size);
1036
1037 /*
1038 * Fired during journal abort for dirty buffers that will not be
1039 * committed.
1040 */
1041 void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1042 struct buffer_head *bh);
1043};
1044
1045extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
1046 void *mapped_data,
1047 struct jbd2_buffer_trigger_type *triggers);
1048extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1049 struct jbd2_buffer_trigger_type *triggers);
1050
1051/* Buffer IO */
1052extern int
1053jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1054 struct journal_head *jh_in,
1055 struct journal_head **jh_out,
1056 unsigned long long blocknr);
1057
1058/* Transaction locking */
1059extern void __wait_on_journal (journal_t *);
1060
1061/* Transaction cache support */
1062extern void jbd2_journal_destroy_transaction_cache(void);
1063extern int jbd2_journal_init_transaction_cache(void);
1064extern void jbd2_journal_free_transaction(transaction_t *);
1065
1066/*
1067 * Journal locking.
1068 *
1069 * We need to lock the journal during transaction state changes so that nobody
1070 * ever tries to take a handle on the running transaction while we are in the
1071 * middle of moving it to the commit phase. j_state_lock does this.
1072 *
1073 * Note that the locking is completely interrupt unsafe. We never touch
1074 * journal structures from interrupts.
1075 */
1076
1077static inline handle_t *journal_current_handle(void)
1078{
1079 return current->journal_info;
1080}
1081
1082/* The journaling code user interface:
1083 *
1084 * Create and destroy handles
1085 * Register buffer modifications against the current transaction.
1086 */
1087
1088extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1089extern handle_t *jbd2__journal_start(journal_t *, int nblocks, gfp_t gfp_mask);
1090extern int jbd2_journal_restart(handle_t *, int nblocks);
1091extern int jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
1092extern int jbd2_journal_extend (handle_t *, int nblocks);
1093extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1094extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1095extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1096void jbd2_journal_set_triggers(struct buffer_head *,
1097 struct jbd2_buffer_trigger_type *type);
1098extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1099extern void jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
1100extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1101extern void journal_sync_buffer (struct buffer_head *);
1102extern void jbd2_journal_invalidatepage(journal_t *,
1103 struct page *, unsigned long);
1104extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1105extern int jbd2_journal_stop(handle_t *);
1106extern int jbd2_journal_flush (journal_t *);
1107extern void jbd2_journal_lock_updates (journal_t *);
1108extern void jbd2_journal_unlock_updates (journal_t *);
1109
1110extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1111 struct block_device *fs_dev,
1112 unsigned long long start, int len, int bsize);
1113extern journal_t * jbd2_journal_init_inode (struct inode *);
1114extern int jbd2_journal_update_format (journal_t *);
1115extern int jbd2_journal_check_used_features
1116 (journal_t *, unsigned long, unsigned long, unsigned long);
1117extern int jbd2_journal_check_available_features
1118 (journal_t *, unsigned long, unsigned long, unsigned long);
1119extern int jbd2_journal_set_features
1120 (journal_t *, unsigned long, unsigned long, unsigned long);
1121extern void jbd2_journal_clear_features
1122 (journal_t *, unsigned long, unsigned long, unsigned long);
1123extern int jbd2_journal_load (journal_t *journal);
1124extern int jbd2_journal_destroy (journal_t *);
1125extern int jbd2_journal_recover (journal_t *journal);
1126extern int jbd2_journal_wipe (journal_t *, int);
1127extern int jbd2_journal_skip_recovery (journal_t *);
1128extern void jbd2_journal_update_sb_errno(journal_t *);
1129extern void jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1130 unsigned long, int);
1131extern void __jbd2_journal_abort_hard (journal_t *);
1132extern void jbd2_journal_abort (journal_t *, int);
1133extern int jbd2_journal_errno (journal_t *);
1134extern void jbd2_journal_ack_err (journal_t *);
1135extern int jbd2_journal_clear_err (journal_t *);
1136extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1137extern int jbd2_journal_force_commit(journal_t *);
1138extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
1139extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1140 struct jbd2_inode *inode, loff_t new_size);
1141extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1142extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1143
1144/*
1145 * journal_head management
1146 */
1147struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1148struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1149void jbd2_journal_put_journal_head(struct journal_head *jh);
1150
1151/*
1152 * handle management
1153 */
1154extern struct kmem_cache *jbd2_handle_cache;
1155
1156static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1157{
1158 return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
1159}
1160
1161static inline void jbd2_free_handle(handle_t *handle)
1162{
1163 kmem_cache_free(jbd2_handle_cache, handle);
1164}
1165
1166/*
1167 * jbd2_inode management (optional, for those file systems that want to use
1168 * dynamically allocated jbd2_inode structures)
1169 */
1170extern struct kmem_cache *jbd2_inode_cache;
1171
1172static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1173{
1174 return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1175}
1176
1177static inline void jbd2_free_inode(struct jbd2_inode *jinode)
1178{
1179 kmem_cache_free(jbd2_inode_cache, jinode);
1180}
1181
1182/* Primary revoke support */
1183#define JOURNAL_REVOKE_DEFAULT_HASH 256
1184extern int jbd2_journal_init_revoke(journal_t *, int);
1185extern void jbd2_journal_destroy_revoke_caches(void);
1186extern int jbd2_journal_init_revoke_caches(void);
1187
1188extern void jbd2_journal_destroy_revoke(journal_t *);
1189extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1190extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1191extern void jbd2_journal_write_revoke_records(journal_t *,
1192 transaction_t *, int);
1193
1194/* Recovery revoke support */
1195extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1196extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1197extern void jbd2_journal_clear_revoke(journal_t *);
1198extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1199extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
1200
1201/*
1202 * The log thread user interface:
1203 *
1204 * Request space in the current transaction, and force transaction commit
1205 * transitions on demand.
1206 */
1207
1208int __jbd2_log_space_left(journal_t *); /* Called with journal locked */
1209int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1210int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1211int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1212int jbd2_journal_force_commit_nested(journal_t *journal);
1213int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1214int jbd2_log_do_checkpoint(journal_t *journal);
1215int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
1216
1217void __jbd2_log_wait_for_space(journal_t *journal);
1218extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1219extern int jbd2_cleanup_journal_tail(journal_t *);
1220
1221/* Debugging code only: */
1222
1223#define jbd_ENOSYS() \
1224do { \
1225 printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
1226 current->state = TASK_UNINTERRUPTIBLE; \
1227 schedule(); \
1228} while (1)
1229
1230/*
1231 * is_journal_abort
1232 *
1233 * Simple test wrapper function to test the JBD2_ABORT state flag. This
1234 * bit, when set, indicates that we have had a fatal error somewhere,
1235 * either inside the journaling layer or indicated to us by the client
1236 * (eg. ext3), and that we and should not commit any further
1237 * transactions.
1238 */
1239
1240static inline int is_journal_aborted(journal_t *journal)
1241{
1242 return journal->j_flags & JBD2_ABORT;
1243}
1244
1245static inline int is_handle_aborted(handle_t *handle)
1246{
1247 if (handle->h_aborted)
1248 return 1;
1249 return is_journal_aborted(handle->h_transaction->t_journal);
1250}
1251
1252static inline void jbd2_journal_abort_handle(handle_t *handle)
1253{
1254 handle->h_aborted = 1;
1255}
1256
1257#endif /* __KERNEL__ */
1258
1259/* Comparison functions for transaction IDs: perform comparisons using
1260 * modulo arithmetic so that they work over sequence number wraps. */
1261
1262static inline int tid_gt(tid_t x, tid_t y)
1263{
1264 int difference = (x - y);
1265 return (difference > 0);
1266}
1267
1268static inline int tid_geq(tid_t x, tid_t y)
1269{
1270 int difference = (x - y);
1271 return (difference >= 0);
1272}
1273
1274extern int jbd2_journal_blocks_per_page(struct inode *inode);
1275extern size_t journal_tag_bytes(journal_t *journal);
1276
1277/*
1278 * Return the minimum number of blocks which must be free in the journal
1279 * before a new transaction may be started. Must be called under j_state_lock.
1280 */
1281static inline int jbd_space_needed(journal_t *journal)
1282{
1283 int nblocks = journal->j_max_transaction_buffers;
1284 if (journal->j_committing_transaction)
1285 nblocks += atomic_read(&journal->j_committing_transaction->
1286 t_outstanding_credits);
1287 return nblocks;
1288}
1289
1290/*
1291 * Definitions which augment the buffer_head layer
1292 */
1293
1294/* journaling buffer types */
1295#define BJ_None 0 /* Not journaled */
1296#define BJ_Metadata 1 /* Normal journaled metadata */
1297#define BJ_Forget 2 /* Buffer superseded by this transaction */
1298#define BJ_IO 3 /* Buffer is for temporary IO use */
1299#define BJ_Shadow 4 /* Buffer contents being shadowed to the log */
1300#define BJ_LogCtl 5 /* Buffer contains log descriptors */
1301#define BJ_Reserved 6 /* Buffer is reserved for access by journal */
1302#define BJ_Types 7
1303
1304extern int jbd_blocks_per_page(struct inode *inode);
1305
1306static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
1307 const void *address, unsigned int length)
1308{
1309 struct {
1310 struct shash_desc shash;
1311 char ctx[crypto_shash_descsize(journal->j_chksum_driver)];
1312 } desc;
1313 int err;
1314
1315 desc.shash.tfm = journal->j_chksum_driver;
1316 desc.shash.flags = 0;
1317 *(u32 *)desc.ctx = crc;
1318
1319 err = crypto_shash_update(&desc.shash, address, length);
1320 BUG_ON(err);
1321
1322 return *(u32 *)desc.ctx;
1323}
1324
1325#ifdef __KERNEL__
1326
1327#define buffer_trace_init(bh) do {} while (0)
1328#define print_buffer_fields(bh) do {} while (0)
1329#define print_buffer_trace(bh) do {} while (0)
1330#define BUFFER_TRACE(bh, info) do {} while (0)
1331#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1332#define JBUFFER_TRACE(jh, info) do {} while (0)
1333
1334#endif /* __KERNEL__ */
1335
1336#endif /* _LINUX_JBD2_H */