Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
jbd2.h
Go to the documentation of this file.
1 /*
2  * linux/include/linux/jbd2.h
3  *
4  * Written by Stephen C. Tweedie <[email protected]>
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
60 extern 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 
74 extern void *jbd2_alloc(size_t size, gfp_t flags);
75 extern void jbd2_free(void *ptr, size_t size);
76 
77 #define JBD2_MIN_JOURNAL_BLOCKS 1024
78 
79 #ifdef __KERNEL__
80 
98 typedef struct jbd2_journal_handle handle_t; /* Atomic operation type */
99 
100 
112 typedef 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  */
138 typedef struct journal_header_s
139 {
140  __be32 h_magic;
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  */
174  unsigned char h_chksum_type;
175  unsigned char h_chksum_size;
176  unsigned char h_padding[2];
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  */
188 typedef 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. */
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 */
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  */
209 {
211  __be32 r_count; /* Count of bytes used in the block */
213 
214 /* Tail of revoke block, for checksumming */
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  */
229 typedef struct journal_superblock_s
230 {
231 /* 0x0000 */
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 */
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 */
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 
346 struct 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 
366 struct jbd2_revoke_table_s;
367 
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 
384 struct 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  */
435 struct 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 
478 struct 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 
638 struct 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 
650 struct transaction_stats_s {
651  unsigned long ts_tid;
652  struct transaction_run_stats_s run;
653 };
654 
655 static inline unsigned long
656 jbd2_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 
736 struct 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 */
997 extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
998 extern void __jbd2_journal_refile_buffer(struct journal_head *);
999 extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1000 extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1001 extern void __journal_free_buffer(struct journal_head *bh);
1002 extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1003 extern void __journal_clean_data_list(transaction_t *transaction);
1004 
1005 /* Log buffer allocation */
1006 extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
1007 int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
1008 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1009  unsigned long *block);
1010 void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1011 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1012 
1013 /* Commit management */
1014 extern void jbd2_journal_commit_transaction(journal_t *);
1015 
1016 /* Checkpoint list management */
1017 int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
1020 
1021 
1022 /*
1023  * Triggers
1024  */
1025 
1026 struct 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 
1045 extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
1046  void *mapped_data,
1047  struct jbd2_buffer_trigger_type *triggers);
1048 extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1049  struct jbd2_buffer_trigger_type *triggers);
1050 
1051 /* Buffer IO */
1052 extern int
1054  struct journal_head *jh_in,
1055  struct journal_head **jh_out,
1056  unsigned long long blocknr);
1057 
1058 /* Transaction locking */
1059 extern void __wait_on_journal (journal_t *);
1060 
1061 /* Transaction cache support */
1062 extern void jbd2_journal_destroy_transaction_cache(void);
1063 extern int jbd2_journal_init_transaction_cache(void);
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 
1077 static 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 
1088 extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1089 extern handle_t *jbd2__journal_start(journal_t *, int nblocks, gfp_t gfp_mask);
1090 extern int jbd2_journal_restart(handle_t *, int nblocks);
1091 extern int jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
1092 extern int jbd2_journal_extend (handle_t *, int nblocks);
1093 extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1094 extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1095 extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1096 void jbd2_journal_set_triggers(struct buffer_head *,
1097  struct jbd2_buffer_trigger_type *type);
1098 extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1099 extern void jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
1100 extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1101 extern void journal_sync_buffer (struct buffer_head *);
1102 extern void jbd2_journal_invalidatepage(journal_t *,
1103  struct page *, unsigned long);
1104 extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1105 extern int jbd2_journal_stop(handle_t *);
1106 extern int jbd2_journal_flush (journal_t *);
1107 extern void jbd2_journal_lock_updates (journal_t *);
1108 extern void jbd2_journal_unlock_updates (journal_t *);
1109 
1110 extern 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);
1113 extern journal_t * jbd2_journal_init_inode (struct inode *);
1114 extern int jbd2_journal_update_format (journal_t *);
1116  (journal_t *, unsigned long, unsigned long, unsigned long);
1118  (journal_t *, unsigned long, unsigned long, unsigned long);
1119 extern int jbd2_journal_set_features
1120  (journal_t *, unsigned long, unsigned long, unsigned long);
1121 extern void jbd2_journal_clear_features
1122  (journal_t *, unsigned long, unsigned long, unsigned long);
1123 extern int jbd2_journal_load (journal_t *journal);
1124 extern int jbd2_journal_destroy (journal_t *);
1125 extern int jbd2_journal_recover (journal_t *journal);
1126 extern int jbd2_journal_wipe (journal_t *, int);
1127 extern int jbd2_journal_skip_recovery (journal_t *);
1128 extern void jbd2_journal_update_sb_errno(journal_t *);
1129 extern void jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1130  unsigned long, int);
1131 extern void __jbd2_journal_abort_hard (journal_t *);
1132 extern void jbd2_journal_abort (journal_t *, int);
1133 extern int jbd2_journal_errno (journal_t *);
1134 extern void jbd2_journal_ack_err (journal_t *);
1135 extern int jbd2_journal_clear_err (journal_t *);
1136 extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1137 extern int jbd2_journal_force_commit(journal_t *);
1138 extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
1139 extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1140  struct jbd2_inode *inode, loff_t new_size);
1141 extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1142 extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1143 
1144 /*
1145  * journal_head management
1146  */
1147 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1148 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1150 
1151 /*
1152  * handle management
1153  */
1154 extern struct kmem_cache *jbd2_handle_cache;
1155 
1156 static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1157 {
1158  return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
1159 }
1160 
1161 static 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  */
1170 extern struct kmem_cache *jbd2_inode_cache;
1171 
1172 static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1173 {
1174  return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1175 }
1176 
1177 static 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
1184 extern int jbd2_journal_init_revoke(journal_t *, int);
1185 extern void jbd2_journal_destroy_revoke_caches(void);
1186 extern int jbd2_journal_init_revoke_caches(void);
1187 
1188 extern void jbd2_journal_destroy_revoke(journal_t *);
1189 extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1190 extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1191 extern void jbd2_journal_write_revoke_records(journal_t *,
1192  transaction_t *, int);
1193 
1194 /* Recovery revoke support */
1195 extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1196 extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1197 extern void jbd2_journal_clear_revoke(journal_t *);
1198 extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1199 extern 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 
1208 int __jbd2_log_space_left(journal_t *); /* Called with journal locked */
1209 int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1210 int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1211 int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1212 int jbd2_journal_force_commit_nested(journal_t *journal);
1213 int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1214 int jbd2_log_do_checkpoint(journal_t *journal);
1215 int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
1216 
1217 void __jbd2_log_wait_for_space(journal_t *journal);
1218 extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1219 extern int jbd2_cleanup_journal_tail(journal_t *);
1220 
1221 /* Debugging code only: */
1222 
1223 #define jbd_ENOSYS() \
1224 do { \
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 
1240 static inline int is_journal_aborted(journal_t *journal)
1241 {
1242  return journal->j_flags & JBD2_ABORT;
1243 }
1244 
1245 static 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 
1252 static 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 
1262 static inline int tid_gt(tid_t x, tid_t y)
1263 {
1264  int difference = (x - y);
1265  return (difference > 0);
1266 }
1267 
1268 static inline int tid_geq(tid_t x, tid_t y)
1269 {
1270  int difference = (x - y);
1271  return (difference >= 0);
1272 }
1273 
1274 extern int jbd2_journal_blocks_per_page(struct inode *inode);
1275 extern 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  */
1281 static 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 
1304 extern int jbd_blocks_per_page(struct inode *inode);
1305 
1306 static 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 */