blob: 05e2b307161a4d7bee5482c5a9851e1110371aa4 [file] [log] [blame]
Dave Kleikamp470decc2006-10-11 01:20:57 -07001/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002 * linux/include/linux/jbd2.h
Dave Kleikamp470decc2006-10-11 01:20:57 -07003 *
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
Mingming Caocd02ff02007-10-16 18:38:25 -040016#ifndef _LINUX_JBD2_H
17#define _LINUX_JBD2_H
Dave Kleikamp470decc2006-10-11 01:20:57 -070018
19/* Allow this file to be included directly into e2fsprogs */
20#ifndef __KERNEL__
21#include "jfs_compat.h"
Mingming Caof7f4bcc2006-10-11 01:20:59 -070022#define JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -070023#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>
Dave Kleikamp470decc2006-10-11 01:20:57 -070033#endif
34
35#define journal_oom_retry 1
36
37/*
Mingming Caocd02ff02007-10-16 18:38:25 -040038 * Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
Dave Kleikamp470decc2006-10-11 01:20:57 -070039 * certain classes of error which can occur due to failed IOs. Under
Mingming Caocd02ff02007-10-16 18:38:25 -040040 * normal use we want ext4 to continue after such errors, because
Dave Kleikamp470decc2006-10-11 01:20:57 -070041 * hardware _can_ fail, but for debugging purposes when running tests on
42 * known-good hardware we may want to trap these errors.
43 */
Mingming Caocd02ff02007-10-16 18:38:25 -040044#undef JBD2_PARANOID_IOFAIL
Dave Kleikamp470decc2006-10-11 01:20:57 -070045
46/*
47 * The default maximum commit age, in seconds.
48 */
Mingming Caocd02ff02007-10-16 18:38:25 -040049#define JBD2_DEFAULT_MAX_COMMIT_AGE 5
Dave Kleikamp470decc2006-10-11 01:20:57 -070050
Jose R. Santose23291b2007-07-18 08:57:06 -040051#ifdef CONFIG_JBD2_DEBUG
Dave Kleikamp470decc2006-10-11 01:20:57 -070052/*
Mingming Caocd02ff02007-10-16 18:38:25 -040053 * Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
Dave Kleikamp470decc2006-10-11 01:20:57 -070054 * consistency checks. By default we don't do this unless
Jose R. Santose23291b2007-07-18 08:57:06 -040055 * CONFIG_JBD2_DEBUG is on.
Dave Kleikamp470decc2006-10-11 01:20:57 -070056 */
Mingming Caocd02ff02007-10-16 18:38:25 -040057#define JBD2_EXPENSIVE_CHECKING
Jose R. Santos0f49d5d2007-07-18 08:50:18 -040058extern u8 jbd2_journal_enable_debug;
Dave Kleikamp470decc2006-10-11 01:20:57 -070059
60#define jbd_debug(n, f, a...) \
61 do { \
Mingming Caof7f4bcc2006-10-11 01:20:59 -070062 if ((n) <= jbd2_journal_enable_debug) { \
Dave Kleikamp470decc2006-10-11 01:20:57 -070063 printk (KERN_DEBUG "(%s, %d): %s: ", \
64 __FILE__, __LINE__, __FUNCTION__); \
65 printk (f, ## a); \
66 } \
67 } while (0)
68#else
69#define jbd_debug(f, a...) /**/
70#endif
71
Mingming Caoaf1e76d2007-10-16 18:38:25 -040072static inline void *jbd2_alloc(size_t size, gfp_t flags)
73{
74 return (void *)__get_free_pages(flags, get_order(size));
75}
76
77static inline void jbd2_free(void *ptr, size_t size)
78{
79 free_pages((unsigned long)ptr, get_order(size));
80};
81
Mingming Caof7f4bcc2006-10-11 01:20:59 -070082#define JBD2_MIN_JOURNAL_BLOCKS 1024
Dave Kleikamp470decc2006-10-11 01:20:57 -070083
84#ifdef __KERNEL__
85
86/**
87 * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
88 *
89 * All filesystem modifications made by the process go
90 * through this handle. Recursive operations (such as quota operations)
91 * are gathered into a single update.
92 *
93 * The buffer credits field is used to account for journaled buffers
94 * being modified by the running process. To ensure that there is
95 * enough log space for all outstanding operations, we need to limit the
96 * number of outstanding buffers possible at any time. When the
97 * operation completes, any buffer credits not used are credited back to
98 * the transaction, so that at all times we know how many buffers the
99 * outstanding updates on a transaction might possibly touch.
100 *
101 * This is an opaque datatype.
102 **/
103typedef struct handle_s handle_t; /* Atomic operation type */
104
105
106/**
107 * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
108 *
109 * journal_t is linked to from the fs superblock structure.
110 *
111 * We use the journal_t to keep track of all outstanding transaction
112 * activity on the filesystem, and to manage the state of the log
113 * writing process.
114 *
115 * This is an opaque datatype.
116 **/
117typedef struct journal_s journal_t; /* Journal control structure */
118#endif
119
120/*
121 * Internal structures used by the logging mechanism:
122 */
123
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700124#define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700125
126/*
127 * On-disk structures
128 */
129
130/*
131 * Descriptor block types:
132 */
133
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700134#define JBD2_DESCRIPTOR_BLOCK 1
135#define JBD2_COMMIT_BLOCK 2
136#define JBD2_SUPERBLOCK_V1 3
137#define JBD2_SUPERBLOCK_V2 4
138#define JBD2_REVOKE_BLOCK 5
Dave Kleikamp470decc2006-10-11 01:20:57 -0700139
140/*
141 * Standard header for all descriptor blocks:
142 */
143typedef struct journal_header_s
144{
145 __be32 h_magic;
146 __be32 h_blocktype;
147 __be32 h_sequence;
148} journal_header_t;
149
Girish Shilamkar818d2762008-01-28 23:58:27 -0500150/*
151 * Checksum types.
152 */
153#define JBD2_CRC32_CHKSUM 1
154#define JBD2_MD5_CHKSUM 2
155#define JBD2_SHA1_CHKSUM 3
156
157#define JBD2_CRC32_CHKSUM_SIZE 4
158
159#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
160/*
161 * Commit block header for storing transactional checksums:
162 */
163struct commit_header {
164 __be32 h_magic;
165 __be32 h_blocktype;
166 __be32 h_sequence;
167 unsigned char h_chksum_type;
168 unsigned char h_chksum_size;
169 unsigned char h_padding[2];
170 __be32 h_chksum[JBD2_CHECKSUM_BYTES];
171};
Dave Kleikamp470decc2006-10-11 01:20:57 -0700172
173/*
Zach Brownb517bea2006-10-11 01:21:08 -0700174 * The block tag: used to describe a single buffer in the journal.
175 * t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
176 * raw struct shouldn't be used for pointer math or sizeof() - use
177 * journal_tag_bytes(journal) instead to compute this.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700178 */
179typedef struct journal_block_tag_s
180{
181 __be32 t_blocknr; /* The on-disk block number */
182 __be32 t_flags; /* See below */
Zach Brownb517bea2006-10-11 01:21:08 -0700183 __be32 t_blocknr_high; /* most-significant high 32bits. */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700184} journal_block_tag_t;
185
Mingming Caocd02ff02007-10-16 18:38:25 -0400186#define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
187#define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
Zach Brownb517bea2006-10-11 01:21:08 -0700188
Dave Kleikamp470decc2006-10-11 01:20:57 -0700189/*
190 * The revoke descriptor: used on disk to describe a series of blocks to
191 * be revoked from the log
192 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700193typedef struct jbd2_journal_revoke_header_s
Dave Kleikamp470decc2006-10-11 01:20:57 -0700194{
195 journal_header_t r_header;
196 __be32 r_count; /* Count of bytes used in the block */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700197} jbd2_journal_revoke_header_t;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700198
199
200/* Definitions for the journal tag flags word: */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700201#define JBD2_FLAG_ESCAPE 1 /* on-disk block is escaped */
202#define JBD2_FLAG_SAME_UUID 2 /* block has same uuid as previous */
203#define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
204#define JBD2_FLAG_LAST_TAG 8 /* last tag in this descriptor block */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700205
206
207/*
208 * The journal superblock. All fields are in big-endian byte order.
209 */
210typedef struct journal_superblock_s
211{
212/* 0x0000 */
213 journal_header_t s_header;
214
215/* 0x000C */
216 /* Static information describing the journal */
217 __be32 s_blocksize; /* journal device blocksize */
218 __be32 s_maxlen; /* total blocks in journal file */
219 __be32 s_first; /* first block of log information */
220
221/* 0x0018 */
222 /* Dynamic information describing the current state of the log */
223 __be32 s_sequence; /* first commit ID expected in log */
224 __be32 s_start; /* blocknr of start of log */
225
226/* 0x0020 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700227 /* Error value, as set by jbd2_journal_abort(). */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700228 __be32 s_errno;
229
230/* 0x0024 */
231 /* Remaining fields are only valid in a version-2 superblock */
232 __be32 s_feature_compat; /* compatible feature set */
233 __be32 s_feature_incompat; /* incompatible feature set */
234 __be32 s_feature_ro_compat; /* readonly-compatible feature set */
235/* 0x0030 */
236 __u8 s_uuid[16]; /* 128-bit uuid for journal */
237
238/* 0x0040 */
239 __be32 s_nr_users; /* Nr of filesystems sharing log */
240
241 __be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/
242
243/* 0x0048 */
244 __be32 s_max_transaction; /* Limit of journal blocks per trans.*/
245 __be32 s_max_trans_data; /* Limit of data blocks per trans. */
246
247/* 0x0050 */
248 __u32 s_padding[44];
249
250/* 0x0100 */
251 __u8 s_users[16*48]; /* ids of all fs'es sharing the log */
252/* 0x0400 */
253} journal_superblock_t;
254
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700255#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700256 ((j)->j_format_version >= 2 && \
257 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700258#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700259 ((j)->j_format_version >= 2 && \
260 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700261#define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
Dave Kleikamp470decc2006-10-11 01:20:57 -0700262 ((j)->j_format_version >= 2 && \
263 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
264
Girish Shilamkar818d2762008-01-28 23:58:27 -0500265#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
266
267#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
268#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
269#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
Dave Kleikamp470decc2006-10-11 01:20:57 -0700270
271/* Features known to this kernel version: */
Girish Shilamkar818d2762008-01-28 23:58:27 -0500272#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700273#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
Zach Brownb517bea2006-10-11 01:21:08 -0700274#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
Girish Shilamkar818d2762008-01-28 23:58:27 -0500275 JBD2_FEATURE_INCOMPAT_64BIT | \
276 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700277
278#ifdef __KERNEL__
279
280#include <linux/fs.h>
281#include <linux/sched.h>
282
Chris Snook36df53f2008-01-28 23:58:27 -0500283#define J_ASSERT(assert) BUG_ON(!(assert))
Dave Kleikamp470decc2006-10-11 01:20:57 -0700284
285#if defined(CONFIG_BUFFER_DEBUG)
286void buffer_assertion_failure(struct buffer_head *bh);
287#define J_ASSERT_BH(bh, expr) \
288 do { \
289 if (!(expr)) \
290 buffer_assertion_failure(bh); \
291 J_ASSERT(expr); \
292 } while (0)
293#define J_ASSERT_JH(jh, expr) J_ASSERT_BH(jh2bh(jh), expr)
294#else
295#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
296#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
297#endif
298
Mingming Caocd02ff02007-10-16 18:38:25 -0400299#if defined(JBD2_PARANOID_IOFAIL)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700300#define J_EXPECT(expr, why...) J_ASSERT(expr)
301#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
302#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
303#else
304#define __journal_expect(expr, why...) \
305 ({ \
306 int val = (expr); \
307 if (!val) { \
308 printk(KERN_ERR \
309 "EXT3-fs unexpected failure: %s;\n",# expr); \
310 printk(KERN_ERR why "\n"); \
311 } \
312 val; \
313 })
314#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
315#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
316#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
317#endif
318
319enum jbd_state_bits {
320 BH_JBD /* Has an attached ext3 journal_head */
321 = BH_PrivateStart,
322 BH_JWrite, /* Being written to log (@@@ DEBUGGING) */
323 BH_Freed, /* Has been freed (truncated) */
324 BH_Revoked, /* Has been revoked from the log */
325 BH_RevokeValid, /* Revoked flag is valid */
326 BH_JBDDirty, /* Is dirty but journaled */
327 BH_State, /* Pins most journal_head state */
328 BH_JournalHead, /* Pins bh->b_private and jh->b_bh */
329 BH_Unshadow, /* Dummy bit, for BJ_Shadow wakeup filtering */
330};
331
332BUFFER_FNS(JBD, jbd)
333BUFFER_FNS(JWrite, jwrite)
334BUFFER_FNS(JBDDirty, jbddirty)
335TAS_BUFFER_FNS(JBDDirty, jbddirty)
336BUFFER_FNS(Revoked, revoked)
337TAS_BUFFER_FNS(Revoked, revoked)
338BUFFER_FNS(RevokeValid, revokevalid)
339TAS_BUFFER_FNS(RevokeValid, revokevalid)
340BUFFER_FNS(Freed, freed)
341
342static inline struct buffer_head *jh2bh(struct journal_head *jh)
343{
344 return jh->b_bh;
345}
346
347static inline struct journal_head *bh2jh(struct buffer_head *bh)
348{
349 return bh->b_private;
350}
351
352static inline void jbd_lock_bh_state(struct buffer_head *bh)
353{
354 bit_spin_lock(BH_State, &bh->b_state);
355}
356
357static inline int jbd_trylock_bh_state(struct buffer_head *bh)
358{
359 return bit_spin_trylock(BH_State, &bh->b_state);
360}
361
362static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
363{
364 return bit_spin_is_locked(BH_State, &bh->b_state);
365}
366
367static inline void jbd_unlock_bh_state(struct buffer_head *bh)
368{
369 bit_spin_unlock(BH_State, &bh->b_state);
370}
371
372static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
373{
374 bit_spin_lock(BH_JournalHead, &bh->b_state);
375}
376
377static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
378{
379 bit_spin_unlock(BH_JournalHead, &bh->b_state);
380}
381
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700382struct jbd2_revoke_table_s;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700383
384/**
385 * struct handle_s - The handle_s type is the concrete type associated with
386 * handle_t.
387 * @h_transaction: Which compound transaction is this update a part of?
388 * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
389 * @h_ref: Reference count on this handle
390 * @h_err: Field for caller's use to track errors through large fs operations
391 * @h_sync: flag for sync-on-close
392 * @h_jdata: flag to force data journaling
393 * @h_aborted: flag indicating fatal error on handle
394 **/
395
396/* Docbook can't yet cope with the bit fields, but will leave the documentation
397 * in so it can be fixed later.
398 */
399
400struct handle_s
401{
402 /* Which compound transaction is this update a part of? */
403 transaction_t *h_transaction;
404
405 /* Number of remaining buffers we are allowed to dirty: */
406 int h_buffer_credits;
407
408 /* Reference count on this handle */
409 int h_ref;
410
411 /* Field for caller's use to track errors through large fs */
412 /* operations */
413 int h_err;
414
415 /* Flags [no locking] */
416 unsigned int h_sync: 1; /* sync-on-close */
417 unsigned int h_jdata: 1; /* force data journaling */
418 unsigned int h_aborted: 1; /* fatal error on handle */
Mingming Cao7b751062008-01-28 23:58:27 -0500419
420#ifdef CONFIG_DEBUG_LOCK_ALLOC
421 struct lockdep_map h_lockdep_map;
422#endif
Dave Kleikamp470decc2006-10-11 01:20:57 -0700423};
424
425
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500426/*
427 * Some stats for checkpoint phase
428 */
429struct transaction_chp_stats_s {
430 unsigned long cs_chp_time;
431 unsigned long cs_forced_to_close;
432 unsigned long cs_written;
433 unsigned long cs_dropped;
434};
435
Dave Kleikamp470decc2006-10-11 01:20:57 -0700436/* The transaction_t type is the guts of the journaling mechanism. It
437 * tracks a compound transaction through its various states:
438 *
439 * RUNNING: accepting new updates
440 * LOCKED: Updates still running but we don't accept new ones
441 * RUNDOWN: Updates are tidying up but have finished requesting
442 * new buffers to modify (state not used for now)
443 * FLUSH: All updates complete, but we are still writing to disk
444 * COMMIT: All data on disk, writing commit record
445 * FINISHED: We still have to keep the transaction for checkpointing.
446 *
447 * The transaction keeps track of all of the buffers modified by a
448 * running transaction, and all of the buffers committed but not yet
449 * flushed to home for finished transactions.
450 */
451
452/*
453 * Lock ranking:
454 *
455 * j_list_lock
456 * ->jbd_lock_bh_journal_head() (This is "innermost")
457 *
458 * j_state_lock
459 * ->jbd_lock_bh_state()
460 *
461 * jbd_lock_bh_state()
462 * ->j_list_lock
463 *
464 * j_state_lock
465 * ->t_handle_lock
466 *
467 * j_state_lock
468 * ->j_list_lock (journal_unmap_buffer)
469 *
470 */
471
472struct transaction_s
473{
474 /* Pointer to the journal for this transaction. [no locking] */
475 journal_t *t_journal;
476
477 /* Sequence number for this transaction [no locking] */
478 tid_t t_tid;
479
480 /*
481 * Transaction's current state
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700482 * [no locking - only kjournald2 alters this]
Jan Karaf5a7a6b2008-01-28 23:58:27 -0500483 * [j_list_lock] guards transition of a transaction into T_FINISHED
484 * state and subsequent call of __jbd2_journal_drop_transaction()
Dave Kleikamp470decc2006-10-11 01:20:57 -0700485 * FIXME: needs barriers
486 * KLUDGE: [use j_state_lock]
487 */
488 enum {
489 T_RUNNING,
490 T_LOCKED,
491 T_RUNDOWN,
492 T_FLUSH,
493 T_COMMIT,
494 T_FINISHED
495 } t_state;
496
497 /*
498 * Where in the log does this transaction's commit start? [no locking]
499 */
500 unsigned long t_log_start;
501
502 /* Number of buffers on the t_buffers list [j_list_lock] */
503 int t_nr_buffers;
504
505 /*
506 * Doubly-linked circular list of all buffers reserved but not yet
507 * modified by this transaction [j_list_lock]
508 */
509 struct journal_head *t_reserved_list;
510
511 /*
512 * Doubly-linked circular list of all buffers under writeout during
513 * commit [j_list_lock]
514 */
515 struct journal_head *t_locked_list;
516
517 /*
518 * Doubly-linked circular list of all metadata buffers owned by this
519 * transaction [j_list_lock]
520 */
521 struct journal_head *t_buffers;
522
523 /*
524 * Doubly-linked circular list of all data buffers still to be
525 * flushed before this transaction can be committed [j_list_lock]
526 */
527 struct journal_head *t_sync_datalist;
528
529 /*
530 * Doubly-linked circular list of all forget buffers (superseded
531 * buffers which we can un-checkpoint once this transaction commits)
532 * [j_list_lock]
533 */
534 struct journal_head *t_forget;
535
536 /*
537 * Doubly-linked circular list of all buffers still to be flushed before
538 * this transaction can be checkpointed. [j_list_lock]
539 */
540 struct journal_head *t_checkpoint_list;
541
542 /*
543 * Doubly-linked circular list of all buffers submitted for IO while
544 * checkpointing. [j_list_lock]
545 */
546 struct journal_head *t_checkpoint_io_list;
547
548 /*
549 * Doubly-linked circular list of temporary buffers currently undergoing
550 * IO in the log [j_list_lock]
551 */
552 struct journal_head *t_iobuf_list;
553
554 /*
555 * Doubly-linked circular list of metadata buffers being shadowed by log
556 * IO. The IO buffers on the iobuf list and the shadow buffers on this
557 * list match each other one for one at all times. [j_list_lock]
558 */
559 struct journal_head *t_shadow_list;
560
561 /*
562 * Doubly-linked circular list of control buffers being written to the
563 * log. [j_list_lock]
564 */
565 struct journal_head *t_log_list;
566
567 /*
568 * Protects info related to handles
569 */
570 spinlock_t t_handle_lock;
571
572 /*
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500573 * Longest time some handle had to wait for running transaction
574 */
575 unsigned long t_max_wait;
576
577 /*
578 * When transaction started
579 */
580 unsigned long t_start;
581
582 /*
583 * Checkpointing stats [j_checkpoint_sem]
584 */
585 struct transaction_chp_stats_s t_chp_stats;
586
587 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700588 * Number of outstanding updates running on this transaction
589 * [t_handle_lock]
590 */
591 int t_updates;
592
593 /*
594 * Number of buffers reserved for use by all handles in this transaction
595 * handle but not yet modified. [t_handle_lock]
596 */
597 int t_outstanding_credits;
598
599 /*
600 * Forward and backward links for the circular list of all transactions
601 * awaiting checkpoint. [j_list_lock]
602 */
603 transaction_t *t_cpnext, *t_cpprev;
604
605 /*
606 * When will the transaction expire (become due for commit), in jiffies?
607 * [no locking]
608 */
609 unsigned long t_expires;
610
611 /*
612 * How many handles used this transaction? [t_handle_lock]
613 */
614 int t_handle_count;
615
616};
617
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500618struct transaction_run_stats_s {
619 unsigned long rs_wait;
620 unsigned long rs_running;
621 unsigned long rs_locked;
622 unsigned long rs_flushing;
623 unsigned long rs_logging;
624
625 unsigned long rs_handle_count;
626 unsigned long rs_blocks;
627 unsigned long rs_blocks_logged;
628};
629
630struct transaction_stats_s {
631 int ts_type;
632 unsigned long ts_tid;
633 union {
634 struct transaction_run_stats_s run;
635 struct transaction_chp_stats_s chp;
636 } u;
637};
638
639#define JBD2_STATS_RUN 1
640#define JBD2_STATS_CHECKPOINT 2
641
642static inline unsigned long
643jbd2_time_diff(unsigned long start, unsigned long end)
644{
645 if (end >= start)
646 return end - start;
647
648 return end + (MAX_JIFFY_OFFSET - start);
649}
650
Dave Kleikamp470decc2006-10-11 01:20:57 -0700651/**
652 * struct journal_s - The journal_s type is the concrete type associated with
653 * journal_t.
654 * @j_flags: General journaling state flags
655 * @j_errno: Is there an outstanding uncleared error on the journal (from a
656 * prior abort)?
657 * @j_sb_buffer: First part of superblock buffer
658 * @j_superblock: Second part of superblock buffer
659 * @j_format_version: Version of the superblock format
660 * @j_state_lock: Protect the various scalars in the journal
661 * @j_barrier_count: Number of processes waiting to create a barrier lock
662 * @j_barrier: The barrier lock itself
663 * @j_running_transaction: The current running transaction..
664 * @j_committing_transaction: the transaction we are pushing to disk
665 * @j_checkpoint_transactions: a linked circular list of all transactions
666 * waiting for checkpointing
667 * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
668 * to start committing, or for a barrier lock to be released
669 * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
670 * @j_wait_done_commit: Wait queue for waiting for commit to complete
671 * @j_wait_checkpoint: Wait queue to trigger checkpointing
672 * @j_wait_commit: Wait queue to trigger commit
673 * @j_wait_updates: Wait queue to wait for updates to complete
674 * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
675 * @j_head: Journal head - identifies the first unused block in the journal
676 * @j_tail: Journal tail - identifies the oldest still-used block in the
677 * journal.
678 * @j_free: Journal free - how many free blocks are there in the journal?
679 * @j_first: The block number of the first usable block
680 * @j_last: The block number one beyond the last usable block
681 * @j_dev: Device where we store the journal
682 * @j_blocksize: blocksize for the location where we store the journal.
683 * @j_blk_offset: starting block offset for into the device where we store the
684 * journal
685 * @j_fs_dev: Device which holds the client fs. For internal journal this will
686 * be equal to j_dev
687 * @j_maxlen: Total maximum capacity of the journal region on disk.
688 * @j_list_lock: Protects the buffer lists and internal buffer state.
689 * @j_inode: Optional inode where we store the journal. If present, all journal
690 * block numbers are mapped into this inode via bmap().
691 * @j_tail_sequence: Sequence number of the oldest transaction in the log
692 * @j_transaction_sequence: Sequence number of the next transaction to grant
693 * @j_commit_sequence: Sequence number of the most recently committed
694 * transaction
695 * @j_commit_request: Sequence number of the most recent transaction wanting
696 * commit
697 * @j_uuid: Uuid of client object.
698 * @j_task: Pointer to the current commit thread for this journal
699 * @j_max_transaction_buffers: Maximum number of metadata buffers to allow in a
700 * single compound commit transaction
701 * @j_commit_interval: What is the maximum transaction lifetime before we begin
702 * a commit?
703 * @j_commit_timer: The timer used to wakeup the commit thread
704 * @j_revoke_lock: Protect the revoke table
705 * @j_revoke: The revoke table - maintains the list of revoked blocks in the
706 * current transaction.
707 * @j_revoke_table: alternate revoke tables for j_revoke
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700708 * @j_wbuf: array of buffer_heads for jbd2_journal_commit_transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -0700709 * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
710 * number that will fit in j_blocksize
711 * @j_last_sync_writer: most recent pid which did a synchronous write
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500712 * @j_history: Buffer storing the transactions statistics history
713 * @j_history_max: Maximum number of transactions in the statistics history
714 * @j_history_cur: Current number of transactions in the statistics history
715 * @j_history_lock: Protect the transactions statistics history
716 * @j_proc_entry: procfs entry for the jbd statistics directory
717 * @j_stats: Overall statistics
Dave Kleikamp470decc2006-10-11 01:20:57 -0700718 * @j_private: An opaque pointer to fs-private information.
719 */
720
721struct journal_s
722{
723 /* General journaling state flags [j_state_lock] */
724 unsigned long j_flags;
725
726 /*
727 * Is there an outstanding uncleared error on the journal (from a prior
728 * abort)? [j_state_lock]
729 */
730 int j_errno;
731
732 /* The superblock buffer */
733 struct buffer_head *j_sb_buffer;
734 journal_superblock_t *j_superblock;
735
736 /* Version of the superblock format */
737 int j_format_version;
738
739 /*
740 * Protect the various scalars in the journal
741 */
742 spinlock_t j_state_lock;
743
744 /*
745 * Number of processes waiting to create a barrier lock [j_state_lock]
746 */
747 int j_barrier_count;
748
749 /* The barrier lock itself */
750 struct mutex j_barrier;
751
752 /*
753 * Transactions: The current running transaction...
754 * [j_state_lock] [caller holding open handle]
755 */
756 transaction_t *j_running_transaction;
757
758 /*
759 * the transaction we are pushing to disk
760 * [j_state_lock] [caller holding open handle]
761 */
762 transaction_t *j_committing_transaction;
763
764 /*
765 * ... and a linked circular list of all transactions waiting for
766 * checkpointing. [j_list_lock]
767 */
768 transaction_t *j_checkpoint_transactions;
769
770 /*
771 * Wait queue for waiting for a locked transaction to start committing,
772 * or for a barrier lock to be released
773 */
774 wait_queue_head_t j_wait_transaction_locked;
775
776 /* Wait queue for waiting for checkpointing to complete */
777 wait_queue_head_t j_wait_logspace;
778
779 /* Wait queue for waiting for commit to complete */
780 wait_queue_head_t j_wait_done_commit;
781
782 /* Wait queue to trigger checkpointing */
783 wait_queue_head_t j_wait_checkpoint;
784
785 /* Wait queue to trigger commit */
786 wait_queue_head_t j_wait_commit;
787
788 /* Wait queue to wait for updates to complete */
789 wait_queue_head_t j_wait_updates;
790
791 /* Semaphore for locking against concurrent checkpoints */
792 struct mutex j_checkpoint_mutex;
793
794 /*
795 * Journal head: identifies the first unused block in the journal.
796 * [j_state_lock]
797 */
798 unsigned long j_head;
799
800 /*
801 * Journal tail: identifies the oldest still-used block in the journal.
802 * [j_state_lock]
803 */
804 unsigned long j_tail;
805
806 /*
807 * Journal free: how many free blocks are there in the journal?
808 * [j_state_lock]
809 */
810 unsigned long j_free;
811
812 /*
813 * Journal start and end: the block numbers of the first usable block
814 * and one beyond the last usable block in the journal. [j_state_lock]
815 */
816 unsigned long j_first;
817 unsigned long j_last;
818
819 /*
820 * Device, blocksize and starting block offset for the location where we
821 * store the journal.
822 */
823 struct block_device *j_dev;
824 int j_blocksize;
Mingming Cao18eba7a2006-10-11 01:21:13 -0700825 unsigned long long j_blk_offset;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700826
827 /*
828 * Device which holds the client fs. For internal journal this will be
829 * equal to j_dev.
830 */
831 struct block_device *j_fs_dev;
832
833 /* Total maximum capacity of the journal region on disk. */
834 unsigned int j_maxlen;
835
836 /*
837 * Protects the buffer lists and internal buffer state.
838 */
839 spinlock_t j_list_lock;
840
841 /* Optional inode where we store the journal. If present, all */
842 /* journal block numbers are mapped into this inode via */
843 /* bmap(). */
844 struct inode *j_inode;
845
846 /*
847 * Sequence number of the oldest transaction in the log [j_state_lock]
848 */
849 tid_t j_tail_sequence;
850
851 /*
852 * Sequence number of the next transaction to grant [j_state_lock]
853 */
854 tid_t j_transaction_sequence;
855
856 /*
857 * Sequence number of the most recently committed transaction
858 * [j_state_lock].
859 */
860 tid_t j_commit_sequence;
861
862 /*
863 * Sequence number of the most recent transaction wanting commit
864 * [j_state_lock]
865 */
866 tid_t j_commit_request;
867
868 /*
869 * Journal uuid: identifies the object (filesystem, LVM volume etc)
870 * backed by this journal. This will eventually be replaced by an array
871 * of uuids, allowing us to index multiple devices within a single
872 * journal and to perform atomic updates across them.
873 */
874 __u8 j_uuid[16];
875
876 /* Pointer to the current commit thread for this journal */
877 struct task_struct *j_task;
878
879 /*
880 * Maximum number of metadata buffers to allow in a single compound
881 * commit transaction
882 */
883 int j_max_transaction_buffers;
884
885 /*
886 * What is the maximum transaction lifetime before we begin a commit?
887 */
888 unsigned long j_commit_interval;
889
890 /* The timer used to wakeup the commit thread: */
891 struct timer_list j_commit_timer;
892
893 /*
894 * The revoke table: maintains the list of revoked blocks in the
895 * current transaction. [j_revoke_lock]
896 */
897 spinlock_t j_revoke_lock;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700898 struct jbd2_revoke_table_s *j_revoke;
899 struct jbd2_revoke_table_s *j_revoke_table[2];
Dave Kleikamp470decc2006-10-11 01:20:57 -0700900
901 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700902 * array of bhs for jbd2_journal_commit_transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -0700903 */
904 struct buffer_head **j_wbuf;
905 int j_wbufsize;
906
907 pid_t j_last_sync_writer;
908
909 /*
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500910 * Journal statistics
911 */
912 struct transaction_stats_s *j_history;
913 int j_history_max;
914 int j_history_cur;
915 /*
916 * Protect the transactions statistics history
917 */
918 spinlock_t j_history_lock;
919 struct proc_dir_entry *j_proc_entry;
920 struct transaction_stats_s j_stats;
921
922 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700923 * An opaque pointer to fs-private information. ext3 puts its
924 * superblock pointer here
925 */
926 void *j_private;
927};
928
929/*
930 * Journal flag definitions
931 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700932#define JBD2_UNMOUNT 0x001 /* Journal thread is being destroyed */
933#define JBD2_ABORT 0x002 /* Journaling has been aborted for errors. */
934#define JBD2_ACK_ERR 0x004 /* The errno in the sb has been acked */
935#define JBD2_FLUSHED 0x008 /* The journal superblock has been flushed */
936#define JBD2_LOADED 0x010 /* The journal superblock has been loaded */
937#define JBD2_BARRIER 0x020 /* Use IDE barriers */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700938
939/*
940 * Function declarations for the journaling transaction and buffer
941 * management
942 */
943
944/* Filing buffers */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700945extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
946extern void __jbd2_journal_unfile_buffer(struct journal_head *);
947extern void __jbd2_journal_refile_buffer(struct journal_head *);
948extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
949extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700950extern void __journal_free_buffer(struct journal_head *bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700951extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700952extern void __journal_clean_data_list(transaction_t *transaction);
953
954/* Log buffer allocation */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700955extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
Mingming Cao18eba7a2006-10-11 01:21:13 -0700956int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700957
958/* Commit management */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700959extern void jbd2_journal_commit_transaction(journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700960
961/* Checkpoint list management */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700962int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
963int __jbd2_journal_remove_checkpoint(struct journal_head *);
964void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700965
966/* Buffer IO */
967extern int
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700968jbd2_journal_write_metadata_buffer(transaction_t *transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700969 struct journal_head *jh_in,
970 struct journal_head **jh_out,
Mingming Cao18eba7a2006-10-11 01:21:13 -0700971 unsigned long long blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700972
973/* Transaction locking */
974extern void __wait_on_journal (journal_t *);
975
976/*
977 * Journal locking.
978 *
979 * We need to lock the journal during transaction state changes so that nobody
980 * ever tries to take a handle on the running transaction while we are in the
981 * middle of moving it to the commit phase. j_state_lock does this.
982 *
983 * Note that the locking is completely interrupt unsafe. We never touch
984 * journal structures from interrupts.
985 */
986
987static inline handle_t *journal_current_handle(void)
988{
989 return current->journal_info;
990}
991
992/* The journaling code user interface:
993 *
994 * Create and destroy handles
995 * Register buffer modifications against the current transaction.
996 */
997
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700998extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
999extern int jbd2_journal_restart (handle_t *, int nblocks);
1000extern int jbd2_journal_extend (handle_t *, int nblocks);
1001extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1002extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1003extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1004extern int jbd2_journal_dirty_data (handle_t *, struct buffer_head *);
1005extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1006extern void jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
1007extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001008extern void journal_sync_buffer (struct buffer_head *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001009extern void jbd2_journal_invalidatepage(journal_t *,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001010 struct page *, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001011extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1012extern int jbd2_journal_stop(handle_t *);
1013extern int jbd2_journal_flush (journal_t *);
1014extern void jbd2_journal_lock_updates (journal_t *);
1015extern void jbd2_journal_unlock_updates (journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001016
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001017extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001018 struct block_device *fs_dev,
Mingming Cao18eba7a2006-10-11 01:21:13 -07001019 unsigned long long start, int len, int bsize);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001020extern journal_t * jbd2_journal_init_inode (struct inode *);
1021extern int jbd2_journal_update_format (journal_t *);
1022extern int jbd2_journal_check_used_features
Dave Kleikamp470decc2006-10-11 01:20:57 -07001023 (journal_t *, unsigned long, unsigned long, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001024extern int jbd2_journal_check_available_features
Dave Kleikamp470decc2006-10-11 01:20:57 -07001025 (journal_t *, unsigned long, unsigned long, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001026extern int jbd2_journal_set_features
Dave Kleikamp470decc2006-10-11 01:20:57 -07001027 (journal_t *, unsigned long, unsigned long, unsigned long);
Girish Shilamkar818d2762008-01-28 23:58:27 -05001028extern void jbd2_journal_clear_features
1029 (journal_t *, unsigned long, unsigned long, unsigned long);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001030extern int jbd2_journal_create (journal_t *);
1031extern int jbd2_journal_load (journal_t *journal);
1032extern void jbd2_journal_destroy (journal_t *);
1033extern int jbd2_journal_recover (journal_t *journal);
1034extern int jbd2_journal_wipe (journal_t *, int);
1035extern int jbd2_journal_skip_recovery (journal_t *);
1036extern void jbd2_journal_update_superblock (journal_t *, int);
1037extern void __jbd2_journal_abort_hard (journal_t *);
1038extern void jbd2_journal_abort (journal_t *, int);
1039extern int jbd2_journal_errno (journal_t *);
1040extern void jbd2_journal_ack_err (journal_t *);
1041extern int jbd2_journal_clear_err (journal_t *);
Mingming Cao18eba7a2006-10-11 01:21:13 -07001042extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001043extern int jbd2_journal_force_commit(journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001044
1045/*
1046 * journal_head management
1047 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001048struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1049struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1050void jbd2_journal_remove_journal_head(struct buffer_head *bh);
1051void jbd2_journal_put_journal_head(struct journal_head *jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001052
1053/*
1054 * handle management
1055 */
Christoph Lametere18b8902006-12-06 20:33:20 -08001056extern struct kmem_cache *jbd2_handle_cache;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001057
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001058static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001059{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001060 return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001061}
1062
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001063static inline void jbd2_free_handle(handle_t *handle)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001064{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001065 kmem_cache_free(jbd2_handle_cache, handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001066}
1067
1068/* Primary revoke support */
1069#define JOURNAL_REVOKE_DEFAULT_HASH 256
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001070extern int jbd2_journal_init_revoke(journal_t *, int);
1071extern void jbd2_journal_destroy_revoke_caches(void);
1072extern int jbd2_journal_init_revoke_caches(void);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001073
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001074extern void jbd2_journal_destroy_revoke(journal_t *);
Mingming Cao18eba7a2006-10-11 01:21:13 -07001075extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001076extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1077extern void jbd2_journal_write_revoke_records(journal_t *, transaction_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001078
1079/* Recovery revoke support */
Mingming Cao18eba7a2006-10-11 01:21:13 -07001080extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1081extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001082extern void jbd2_journal_clear_revoke(journal_t *);
1083extern void jbd2_journal_switch_revoke_table(journal_t *journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001084
1085/*
1086 * The log thread user interface:
1087 *
1088 * Request space in the current transaction, and force transaction commit
1089 * transitions on demand.
1090 */
1091
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001092int __jbd2_log_space_left(journal_t *); /* Called with journal locked */
1093int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1094int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1095int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1096int jbd2_journal_force_commit_nested(journal_t *journal);
1097int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1098int jbd2_log_do_checkpoint(journal_t *journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001099
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001100void __jbd2_log_wait_for_space(journal_t *journal);
1101extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1102extern int jbd2_cleanup_journal_tail(journal_t *);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001103
1104/* Debugging code only: */
1105
1106#define jbd_ENOSYS() \
1107do { \
1108 printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \
1109 current->state = TASK_UNINTERRUPTIBLE; \
1110 schedule(); \
1111} while (1)
1112
1113/*
1114 * is_journal_abort
1115 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001116 * Simple test wrapper function to test the JBD2_ABORT state flag. This
Dave Kleikamp470decc2006-10-11 01:20:57 -07001117 * bit, when set, indicates that we have had a fatal error somewhere,
1118 * either inside the journaling layer or indicated to us by the client
1119 * (eg. ext3), and that we and should not commit any further
1120 * transactions.
1121 */
1122
1123static inline int is_journal_aborted(journal_t *journal)
1124{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001125 return journal->j_flags & JBD2_ABORT;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001126}
1127
1128static inline int is_handle_aborted(handle_t *handle)
1129{
1130 if (handle->h_aborted)
1131 return 1;
1132 return is_journal_aborted(handle->h_transaction->t_journal);
1133}
1134
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001135static inline void jbd2_journal_abort_handle(handle_t *handle)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001136{
1137 handle->h_aborted = 1;
1138}
1139
1140#endif /* __KERNEL__ */
1141
1142/* Comparison functions for transaction IDs: perform comparisons using
1143 * modulo arithmetic so that they work over sequence number wraps. */
1144
1145static inline int tid_gt(tid_t x, tid_t y)
1146{
1147 int difference = (x - y);
1148 return (difference > 0);
1149}
1150
1151static inline int tid_geq(tid_t x, tid_t y)
1152{
1153 int difference = (x - y);
1154 return (difference >= 0);
1155}
1156
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001157extern int jbd2_journal_blocks_per_page(struct inode *inode);
Zach Brownb517bea2006-10-11 01:21:08 -07001158extern size_t journal_tag_bytes(journal_t *journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001159
1160/*
1161 * Return the minimum number of blocks which must be free in the journal
1162 * before a new transaction may be started. Must be called under j_state_lock.
1163 */
1164static inline int jbd_space_needed(journal_t *journal)
1165{
1166 int nblocks = journal->j_max_transaction_buffers;
1167 if (journal->j_committing_transaction)
1168 nblocks += journal->j_committing_transaction->
1169 t_outstanding_credits;
1170 return nblocks;
1171}
1172
1173/*
1174 * Definitions which augment the buffer_head layer
1175 */
1176
1177/* journaling buffer types */
1178#define BJ_None 0 /* Not journaled */
1179#define BJ_SyncData 1 /* Normal data: flush before commit */
1180#define BJ_Metadata 2 /* Normal journaled metadata */
1181#define BJ_Forget 3 /* Buffer superseded by this transaction */
1182#define BJ_IO 4 /* Buffer is for temporary IO use */
1183#define BJ_Shadow 5 /* Buffer contents being shadowed to the log */
1184#define BJ_LogCtl 6 /* Buffer contains log descriptors */
1185#define BJ_Reserved 7 /* Buffer is reserved for access by journal */
1186#define BJ_Locked 8 /* Locked for I/O during commit */
1187#define BJ_Types 9
1188
1189extern int jbd_blocks_per_page(struct inode *inode);
1190
1191#ifdef __KERNEL__
1192
1193#define buffer_trace_init(bh) do {} while (0)
1194#define print_buffer_fields(bh) do {} while (0)
1195#define print_buffer_trace(bh) do {} while (0)
1196#define BUFFER_TRACE(bh, info) do {} while (0)
1197#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1198#define JBUFFER_TRACE(jh, info) do {} while (0)
1199
1200#endif /* __KERNEL__ */
1201
Mingming Caocd02ff02007-10-16 18:38:25 -04001202#endif /* _LINUX_JBD2_H */