1 /* 2 * linux/include/linux/jbd.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_JBD_H 17 #define _LINUX_JBD_H 18 19 /* Allow this file to be included directly into e2fsprogs */ 20 #ifndef __KERNEL__ 21 #include "jfs_compat.h" 22 #define JFS_DEBUG 23 #define jfs_debug jbd_debug 24 #else 25 26 #include <linux/module.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/lockdep.h> 34 35 #include <asm/semaphore.h> 36 37 #define journal_oom_retry 1 38 39 #define jbdlock_t FAST_MUTEX 40 41 static inline void jbd_lock_init(jbdlock_t *lock) 42 { 43 ExInitializeFastMutex(lock); 44 } 45 46 static inline void jbd_lock(jbdlock_t *lock) 47 { 48 ExAcquireFastMutex(lock); 49 } 50 51 static inline void jbd_unlock(jbdlock_t *lock) 52 { 53 ExReleaseFastMutex(lock); 54 } 55 56 static inline int assert_jbd_locked(jbdlock_t *lock) 57 { 58 int rc = 1; 59 60 if (ExTryToAcquireFastMutex(lock)) { 61 ExReleaseFastMutex(lock); 62 rc = 0; 63 } 64 65 return rc; 66 } 67 68 69 /* 70 * Define JBD_PARANIOD_IOFAIL to cause a kernel BUG() if ext3 finds 71 * certain classes of error which can occur due to failed IOs. Under 72 * normal use we want ext3 to continue after such errors, because 73 * hardware _can_ fail, but for debugging purposes when running tests on 74 * known-good hardware we may want to trap these errors. 75 */ 76 #undef JBD_PARANOID_IOFAIL 77 78 /* 79 * The default maximum commit age, in seconds. 80 */ 81 #define JBD_DEFAULT_MAX_COMMIT_AGE 5 82 83 #ifdef CONFIG_JBD_DEBUG 84 /* 85 * Define JBD_EXPENSIVE_CHECKING to enable more expensive internal 86 * consistency checks. By default we don't do this unless 87 * CONFIG_JBD_DEBUG is on. 88 */ 89 #define JBD_EXPENSIVE_CHECKING 90 extern u8 journal_enable_debug; 91 92 #define jbd_debug(n, f, a...) \ 93 do { \ 94 if ((n) <= journal_enable_debug) { \ 95 printk (KERN_DEBUG "(%s, %d): %s: ", \ 96 __FILE__, __LINE__, __FUNCTION__); \ 97 printk (f, ## a); \ 98 } \ 99 } while (0) 100 #else 101 #define jbd_debug 102 #endif 103 104 static inline void *jbd_alloc(size_t size, gfp_t flags) 105 { 106 return kmalloc(size, flags); 107 /*__get_free_pages(flags, get_order(size));*/ 108 } 109 110 static inline void jbd_free(void *ptr, size_t size) 111 { 112 if (ptr) { 113 kfree(ptr); 114 } 115 /* free_pages((unsigned long)ptr, get_order(size)); */ 116 }; 117 118 #define JFS_MIN_JOURNAL_BLOCKS 1024 119 120 121 /** 122 * typedef handle_t - The handle_t type represents a single atomic update being performed by some process. 123 * 124 * All filesystem modifications made by the process go 125 * through this handle. Recursive operations (such as quota operations) 126 * are gathered into a single update. 127 * 128 * The buffer credits field is used to account for journaled buffers 129 * being modified by the running process. To ensure that there is 130 * enough log space for all outstanding operations, we need to limit the 131 * number of outstanding buffers possible at any time. When the 132 * operation completes, any buffer credits not used are credited back to 133 * the transaction, so that at all times we know how many buffers the 134 * outstanding updates on a transaction might possibly touch. 135 * 136 * This is an opaque datatype. 137 **/ 138 typedef struct handle_s handle_t; /* Atomic operation type */ 139 140 141 /** 142 * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem. 143 * 144 * journal_t is linked to from the fs superblock structure. 145 * 146 * We use the journal_t to keep track of all outstanding transaction 147 * activity on the filesystem, and to manage the state of the log 148 * writing process. 149 * 150 * This is an opaque datatype. 151 **/ 152 typedef struct journal_s journal_t; /* Journal control structure */ 153 #endif 154 155 /* 156 * Internal structures used by the logging mechanism: 157 */ 158 159 #define JFS_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */ 160 161 /* 162 * On-disk structures 163 */ 164 165 /* 166 * Descriptor block types: 167 */ 168 169 #define JFS_DESCRIPTOR_BLOCK 1 170 #define JFS_COMMIT_BLOCK 2 171 #define JFS_SUPERBLOCK_V1 3 172 #define JFS_SUPERBLOCK_V2 4 173 #define JFS_REVOKE_BLOCK 5 174 175 /* 176 * Standard header for all descriptor blocks: 177 */ 178 typedef struct journal_header_s 179 { 180 __be32 h_magic; 181 __be32 h_blocktype; 182 __be32 h_sequence; 183 } journal_header_t; 184 185 186 /* 187 * The block tag: used to describe a single buffer in the journal 188 */ 189 typedef struct journal_block_tag_s 190 { 191 __be32 t_blocknr; /* The on-disk block number */ 192 __be32 t_flags; /* See below */ 193 } journal_block_tag_t; 194 195 /* 196 * The revoke descriptor: used on disk to describe a series of blocks to 197 * be revoked from the log 198 */ 199 typedef struct journal_revoke_header_s 200 { 201 journal_header_t r_header; 202 __be32 r_count; /* Count of bytes used in the block */ 203 } journal_revoke_header_t; 204 205 206 /* Definitions for the journal tag flags word: */ 207 #define JFS_FLAG_ESCAPE 1 /* on-disk block is escaped */ 208 #define JFS_FLAG_SAME_UUID 2 /* block has same uuid as previous */ 209 #define JFS_FLAG_DELETED 4 /* block deleted by this transaction */ 210 #define JFS_FLAG_LAST_TAG 8 /* last tag in this descriptor block */ 211 212 213 /* 214 * The journal superblock. All fields are in big-endian byte order. 215 */ 216 typedef struct journal_superblock_s 217 { 218 /* 0x0000 */ 219 journal_header_t s_header; 220 221 /* 0x000C */ 222 /* Static information describing the journal */ 223 __be32 s_blocksize; /* journal device blocksize */ 224 __be32 s_maxlen; /* total blocks in journal file */ 225 __be32 s_first; /* first block of log information */ 226 227 /* 0x0018 */ 228 /* Dynamic information describing the current state of the log */ 229 __be32 s_sequence; /* first commit ID expected in log */ 230 __be32 s_start; /* blocknr of start of log */ 231 232 /* 0x0020 */ 233 /* Error value, as set by journal_abort(). */ 234 __be32 s_errno; 235 236 /* 0x0024 */ 237 /* Remaining fields are only valid in a version-2 superblock */ 238 __be32 s_feature_compat; /* compatible feature set */ 239 __be32 s_feature_incompat; /* incompatible feature set */ 240 __be32 s_feature_ro_compat; /* readonly-compatible feature set */ 241 /* 0x0030 */ 242 __u8 s_uuid[16]; /* 128-bit uuid for journal */ 243 244 /* 0x0040 */ 245 __be32 s_nr_users; /* Nr of filesystems sharing log */ 246 247 __be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/ 248 249 /* 0x0048 */ 250 __be32 s_max_transaction; /* Limit of journal blocks per trans.*/ 251 __be32 s_max_trans_data; /* Limit of data blocks per trans. */ 252 253 /* 0x0050 */ 254 __u32 s_padding[44]; 255 256 /* 0x0100 */ 257 __u8 s_users[16*48]; /* ids of all fs'es sharing the log */ 258 /* 0x0400 */ 259 } journal_superblock_t; 260 261 #define JFS_HAS_COMPAT_FEATURE(j,mask) \ 262 ((j)->j_format_version >= 2 && \ 263 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask)))) 264 #define JFS_HAS_RO_COMPAT_FEATURE(j,mask) \ 265 ((j)->j_format_version >= 2 && \ 266 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask)))) 267 #define JFS_HAS_INCOMPAT_FEATURE(j,mask) \ 268 ((j)->j_format_version >= 2 && \ 269 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask)))) 270 271 #define JFS_FEATURE_INCOMPAT_REVOKE 0x00000001 272 273 /* Features known to this kernel version: */ 274 #define JFS_KNOWN_COMPAT_FEATURES 0 275 #define JFS_KNOWN_ROCOMPAT_FEATURES 0 276 #define JFS_KNOWN_INCOMPAT_FEATURES JFS_FEATURE_INCOMPAT_REVOKE 277 278 #ifdef __KERNEL__ 279 280 #include <linux/fs.h> 281 #include <linux/sched.h> 282 283 #define J_ASSERT ASSERT 284 285 #if defined(CONFIG_BUFFER_DEBUG) 286 void 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 299 #if defined(JBD_PARANOID_IOFAIL) 300 #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 #if 0 305 #define __journal_expect(expr, why...) \ 306 ({ \ 307 int val = (expr); \ 308 if (!val) { \ 309 printk(KERN_ERR \ 310 "EXT3-fs unexpected failure: %s;\n",# expr); \ 311 printk(KERN_ERR why "\n"); \ 312 } \ 313 val; \ 314 }) 315 #define J_EXPECT(expr, why...) __journal_expect(expr, ## why) 316 #define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why) 317 #define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why) 318 #endif 319 #define __journal_expect 320 321 #define J_EXPECT 322 #define J_EXPECT_BH 323 #define J_EXPECT_JH 324 325 #endif 326 327 enum jbd_state_bits { 328 BH_JBD /* Has an attached ext3 journal_head */ 329 = BH_PrivateStart, 330 BH_JWrite, /* Being written to log (@@@ DEBUGGING) */ 331 BH_Freed, /* Has been freed (truncated) */ 332 BH_Revoked, /* Has been revoked from the log */ 333 BH_RevokeValid, /* Revoked flag is valid */ 334 BH_JBDDirty, /* Is dirty but journaled */ 335 BH_State, /* Pins most journal_head state */ 336 BH_JournalHead, /* Pins bh->b_private and jh->b_bh */ 337 BH_Unshadow, /* Dummy bit, for BJ_Shadow wakeup filtering */ 338 }; 339 340 BUFFER_FNS(JBD, jbd) 341 BUFFER_FNS(JWrite, jwrite) 342 BUFFER_FNS(JBDDirty, jbddirty) 343 TAS_BUFFER_FNS(JBDDirty, jbddirty) 344 BUFFER_FNS(Revoked, revoked) 345 TAS_BUFFER_FNS(Revoked, revoked) 346 BUFFER_FNS(RevokeValid, revokevalid) 347 TAS_BUFFER_FNS(RevokeValid, revokevalid) 348 BUFFER_FNS(Freed, freed) 349 350 static inline struct buffer_head *jh2bh(struct journal_head *jh) 351 { 352 return jh->b_bh; 353 } 354 355 static inline struct journal_head *bh2jh(struct buffer_head *bh) 356 { 357 return bh->b_private; 358 } 359 360 static inline void jbd_lock_bh_state(struct buffer_head *bh) 361 { 362 bit_spin_lock(BH_State, &bh->b_state); 363 } 364 365 static inline int jbd_trylock_bh_state(struct buffer_head *bh) 366 { 367 return bit_spin_trylock(BH_State, &bh->b_state); 368 } 369 370 static inline int jbd_is_locked_bh_state(struct buffer_head *bh) 371 { 372 return bit_spin_is_locked(BH_State, &bh->b_state); 373 } 374 375 static inline void jbd_unlock_bh_state(struct buffer_head *bh) 376 { 377 bit_spin_unlock(BH_State, &bh->b_state); 378 } 379 380 static inline void jbd_lock_bh_journal_head(struct buffer_head *bh) 381 { 382 bit_spin_lock(BH_JournalHead, &bh->b_state); 383 } 384 385 static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh) 386 { 387 bit_spin_unlock(BH_JournalHead, &bh->b_state); 388 } 389 390 struct jbd_revoke_table_s; 391 392 /** 393 * struct handle_s - The handle_s type is the concrete type associated with 394 * handle_t. 395 * @h_transaction: Which compound transaction is this update a part of? 396 * @h_buffer_credits: Number of remaining buffers we are allowed to dirty. 397 * @h_ref: Reference count on this handle 398 * @h_err: Field for caller's use to track errors through large fs operations 399 * @h_sync: flag for sync-on-close 400 * @h_jdata: flag to force data journaling 401 * @h_aborted: flag indicating fatal error on handle 402 * @h_lockdep_map: lockdep info for debugging lock problems 403 **/ 404 405 /* Docbook can't yet cope with the bit fields, but will leave the documentation 406 * in so it can be fixed later. 407 */ 408 409 struct handle_s 410 { 411 /* Which compound transaction is this update a part of? */ 412 transaction_t *h_transaction; 413 414 /* Number of remaining buffers we are allowed to dirty: */ 415 int h_buffer_credits; 416 417 /* Reference count on this handle */ 418 int h_ref; 419 420 /* Field for caller's use to track errors through large fs */ 421 /* operations */ 422 int h_err; 423 424 /* Flags [no locking] */ 425 unsigned int h_sync: 426 1; /* sync-on-close */ 427 unsigned int h_jdata: 428 1; /* force data journaling */ 429 unsigned int h_aborted: 430 1; /* fatal error on handle */ 431 432 #ifdef CONFIG_DEBUG_LOCK_ALLOC 433 struct lockdep_map h_lockdep_map; 434 #endif 435 }; 436 437 438 /* The transaction_t type is the guts of the journaling mechanism. It 439 * tracks a compound transaction through its various states: 440 * 441 * RUNNING: accepting new updates 442 * LOCKED: Updates still running but we don't accept new ones 443 * RUNDOWN: Updates are tidying up but have finished requesting 444 * new buffers to modify (state not used for now) 445 * FLUSH: All updates complete, but we are still writing to disk 446 * COMMIT: All data on disk, writing commit record 447 * FINISHED: We still have to keep the transaction for checkpointing. 448 * 449 * The transaction keeps track of all of the buffers modified by a 450 * running transaction, and all of the buffers committed but not yet 451 * flushed to home for finished transactions. 452 */ 453 454 /* 455 * Lock ranking: 456 * 457 * j_list_lock 458 * ->jbd_lock_bh_journal_head() (This is "innermost") 459 * 460 * j_state_lock 461 * ->jbd_lock_bh_state() 462 * 463 * jbd_lock_bh_state() 464 * ->j_list_lock 465 * 466 * j_state_lock 467 * ->t_handle_lock 468 * 469 * j_state_lock 470 * ->j_list_lock (journal_unmap_buffer) 471 * 472 */ 473 474 struct transaction_s 475 { 476 /* Pointer to the journal for this transaction. [no locking] */ 477 journal_t *t_journal; 478 479 /* Sequence number for this transaction [no locking] */ 480 tid_t t_tid; 481 482 /* 483 * Transaction's current state 484 * [no locking - only kjournald alters this] 485 * [j_list_lock] guards transition of a transaction into T_FINISHED 486 * state and subsequent call of __journal_drop_transaction() 487 * FIXME: needs barriers 488 * KLUDGE: [use j_state_lock] 489 */ 490 enum { 491 T_RUNNING, 492 T_LOCKED, 493 T_RUNDOWN, 494 T_FLUSH, 495 T_COMMIT, 496 T_FINISHED 497 } t_state; 498 499 /* 500 * Where in the log does this transaction's commit start? [no locking] 501 */ 502 unsigned long t_log_start; 503 504 /* Number of buffers on the t_buffers list [j_list_lock] */ 505 int t_nr_buffers; 506 507 /* 508 * Doubly-linked circular list of all buffers reserved but not yet 509 * modified by this transaction [j_list_lock] 510 */ 511 struct journal_head *t_reserved_list; 512 513 /* 514 * Doubly-linked circular list of all buffers under writeout during 515 * commit [j_list_lock] 516 */ 517 struct journal_head *t_locked_list; 518 519 /* 520 * Doubly-linked circular list of all metadata buffers owned by this 521 * transaction [j_list_lock] 522 */ 523 struct journal_head *t_buffers; 524 525 /* 526 * Doubly-linked circular list of all data buffers still to be 527 * flushed before this transaction can be committed [j_list_lock] 528 */ 529 struct journal_head *t_sync_datalist; 530 531 /* 532 * Doubly-linked circular list of all forget buffers (superseded 533 * buffers which we can un-checkpoint once this transaction commits) 534 * [j_list_lock] 535 */ 536 struct journal_head *t_forget; 537 538 /* 539 * Doubly-linked circular list of all buffers still to be flushed before 540 * this transaction can be checkpointed. [j_list_lock] 541 */ 542 struct journal_head *t_checkpoint_list; 543 544 /* 545 * Doubly-linked circular list of all buffers submitted for IO while 546 * checkpointing. [j_list_lock] 547 */ 548 struct journal_head *t_checkpoint_io_list; 549 550 /* 551 * Doubly-linked circular list of temporary buffers currently undergoing 552 * IO in the log [j_list_lock] 553 */ 554 struct journal_head *t_iobuf_list; 555 556 /* 557 * Doubly-linked circular list of metadata buffers being shadowed by log 558 * IO. The IO buffers on the iobuf list and the shadow buffers on this 559 * list match each other one for one at all times. [j_list_lock] 560 */ 561 struct journal_head *t_shadow_list; 562 563 /* 564 * Doubly-linked circular list of control buffers being written to the 565 * log. [j_list_lock] 566 */ 567 struct journal_head *t_log_list; 568 569 /* 570 * Protects info related to handles 571 */ 572 jbdlock_t t_handle_lock; 573 574 /* 575 * Number of outstanding updates running on this transaction 576 * [t_handle_lock] 577 */ 578 int t_updates; 579 580 /* 581 * Number of buffers reserved for use by all handles in this transaction 582 * handle but not yet modified. [t_handle_lock] 583 */ 584 int t_outstanding_credits; 585 586 /* 587 * Forward and backward links for the circular list of all transactions 588 * awaiting checkpoint. [j_list_lock] 589 */ 590 transaction_t *t_cpnext, *t_cpprev; 591 592 /* 593 * When will the transaction expire (become due for commit), in jiffies? 594 * [no locking] 595 */ 596 unsigned long t_expires; 597 598 /* 599 * How many handles used this transaction? [t_handle_lock] 600 */ 601 int t_handle_count; 602 603 }; 604 605 /** 606 * struct journal_s - The journal_s type is the concrete type associated with 607 * journal_t. 608 * @j_flags: General journaling state flags 609 * @j_errno: Is there an outstanding uncleared error on the journal (from a 610 * prior abort)? 611 * @j_sb_buffer: First part of superblock buffer 612 * @j_superblock: Second part of superblock buffer 613 * @j_format_version: Version of the superblock format 614 * @j_state_lock: Protect the various scalars in the journal 615 * @j_barrier_count: Number of processes waiting to create a barrier lock 616 * @j_barrier: The barrier lock itself 617 * @j_running_transaction: The current running transaction.. 618 * @j_committing_transaction: the transaction we are pushing to disk 619 * @j_checkpoint_transactions: a linked circular list of all transactions 620 * waiting for checkpointing 621 * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction 622 * to start committing, or for a barrier lock to be released 623 * @j_wait_logspace: Wait queue for waiting for checkpointing to complete 624 * @j_wait_done_commit: Wait queue for waiting for commit to complete 625 * @j_wait_checkpoint: Wait queue to trigger checkpointing 626 * @j_wait_commit: Wait queue to trigger commit 627 * @j_wait_updates: Wait queue to wait for updates to complete 628 * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints 629 * @j_head: Journal head - identifies the first unused block in the journal 630 * @j_tail: Journal tail - identifies the oldest still-used block in the 631 * journal. 632 * @j_free: Journal free - how many free blocks are there in the journal? 633 * @j_first: The block number of the first usable block 634 * @j_last: The block number one beyond the last usable block 635 * @j_dev: Device where we store the journal 636 * @j_blocksize: blocksize for the location where we store the journal. 637 * @j_blk_offset: starting block offset for into the device where we store the 638 * journal 639 * @j_fs_dev: Device which holds the client fs. For internal journal this will 640 * be equal to j_dev 641 * @j_maxlen: Total maximum capacity of the journal region on disk. 642 * @j_list_lock: Protects the buffer lists and internal buffer state. 643 * @j_inode: Optional inode where we store the journal. If present, all journal 644 * block numbers are mapped into this inode via bmap(). 645 * @j_tail_sequence: Sequence number of the oldest transaction in the log 646 * @j_transaction_sequence: Sequence number of the next transaction to grant 647 * @j_commit_sequence: Sequence number of the most recently committed 648 * transaction 649 * @j_commit_request: Sequence number of the most recent transaction wanting 650 * commit 651 * @j_uuid: Uuid of client object. 652 * @j_task: Pointer to the current commit thread for this journal 653 * @j_max_transaction_buffers: Maximum number of metadata buffers to allow in a 654 * single compound commit transaction 655 * @j_commit_interval: What is the maximum transaction lifetime before we begin 656 * a commit? 657 * @j_commit_timer: The timer used to wakeup the commit thread 658 * @j_revoke_lock: Protect the revoke table 659 * @j_revoke: The revoke table - maintains the list of revoked blocks in the 660 * current transaction. 661 * @j_revoke_table: alternate revoke tables for j_revoke 662 * @j_wbuf: array of buffer_heads for journal_commit_transaction 663 * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the 664 * number that will fit in j_blocksize 665 * @j_last_sync_writer: most recent pid which did a synchronous write 666 * @j_private: An opaque pointer to fs-private information. 667 */ 668 669 struct journal_s 670 { 671 /* General journaling state flags [j_state_lock] */ 672 unsigned long j_flags; 673 674 /* 675 * Is there an outstanding uncleared error on the journal (from a prior 676 * abort)? [j_state_lock] 677 */ 678 int j_errno; 679 680 /* The superblock buffer */ 681 struct buffer_head *j_sb_buffer; 682 journal_superblock_t *j_superblock; 683 684 /* Version of the superblock format */ 685 int j_format_version; 686 687 /* 688 * Protect the various scalars in the journal 689 */ 690 jbdlock_t j_state_lock; 691 692 /* 693 * Number of processes waiting to create a barrier lock [j_state_lock] 694 */ 695 int j_barrier_count; 696 697 /* The barrier lock itself */ 698 struct mutex j_barrier; 699 700 /* 701 * Transactions: The current running transaction... 702 * [j_state_lock] [caller holding open handle] 703 */ 704 transaction_t *j_running_transaction; 705 706 /* 707 * the transaction we are pushing to disk 708 * [j_state_lock] [caller holding open handle] 709 */ 710 transaction_t *j_committing_transaction; 711 712 /* 713 * ... and a linked circular list of all transactions waiting for 714 * checkpointing. [j_list_lock] 715 */ 716 transaction_t *j_checkpoint_transactions; 717 718 /* 719 * Wait queue for waiting for a locked transaction to start committing, 720 * or for a barrier lock to be released 721 */ 722 wait_queue_head_t j_wait_transaction_locked; 723 724 /* Wait queue for waiting for checkpointing to complete */ 725 wait_queue_head_t j_wait_logspace; 726 727 /* Wait queue for waiting for commit to complete */ 728 wait_queue_head_t j_wait_done_commit; 729 730 /* Wait queue to trigger checkpointing */ 731 wait_queue_head_t j_wait_checkpoint; 732 733 /* Wait queue to trigger commit */ 734 wait_queue_head_t j_wait_commit; 735 736 /* Wait queue to wait for updates to complete */ 737 wait_queue_head_t j_wait_updates; 738 739 /* Semaphore for locking against concurrent checkpoints */ 740 struct mutex j_checkpoint_mutex; 741 742 /* 743 * Journal head: identifies the first unused block in the journal. 744 * [j_state_lock] 745 */ 746 unsigned long j_head; 747 748 /* 749 * Journal tail: identifies the oldest still-used block in the journal. 750 * [j_state_lock] 751 */ 752 unsigned long j_tail; 753 754 /* 755 * Journal free: how many free blocks are there in the journal? 756 * [j_state_lock] 757 */ 758 unsigned long j_free; 759 760 /* 761 * Journal start and end: the block numbers of the first usable block 762 * and one beyond the last usable block in the journal. [j_state_lock] 763 */ 764 unsigned long j_first; 765 unsigned long j_last; 766 767 /* 768 * Device, blocksize and starting block offset for the location where we 769 * store the journal. 770 */ 771 struct block_device *j_dev; 772 int j_blocksize; 773 unsigned long j_blk_offset; 774 775 /* 776 * Device which holds the client fs. For internal journal this will be 777 * equal to j_dev. 778 */ 779 struct block_device *j_fs_dev; 780 781 /* Total maximum capacity of the journal region on disk. */ 782 unsigned int j_maxlen; 783 784 /* 785 * Protects the buffer lists and internal buffer state. 786 */ 787 jbdlock_t j_list_lock; 788 789 /* Optional inode where we store the journal. If present, all */ 790 /* journal block numbers are mapped into this inode via */ 791 /* bmap(). */ 792 struct inode *j_inode; 793 794 /* 795 * Sequence number of the oldest transaction in the log [j_state_lock] 796 */ 797 tid_t j_tail_sequence; 798 799 /* 800 * Sequence number of the next transaction to grant [j_state_lock] 801 */ 802 tid_t j_transaction_sequence; 803 804 /* 805 * Sequence number of the most recently committed transaction 806 * [j_state_lock]. 807 */ 808 tid_t j_commit_sequence; 809 810 /* 811 * Sequence number of the most recent transaction wanting commit 812 * [j_state_lock] 813 */ 814 tid_t j_commit_request; 815 816 /* 817 * Journal uuid: identifies the object (filesystem, LVM volume etc) 818 * backed by this journal. This will eventually be replaced by an array 819 * of uuids, allowing us to index multiple devices within a single 820 * journal and to perform atomic updates across them. 821 */ 822 __u8 j_uuid[16]; 823 824 /* Pointer to the current commit thread for this journal */ 825 struct task_struct *j_task; 826 827 /* 828 * Maximum number of metadata buffers to allow in a single compound 829 * commit transaction 830 */ 831 int j_max_transaction_buffers; 832 833 /* 834 * What is the maximum transaction lifetime before we begin a commit? 835 */ 836 unsigned long j_commit_interval; 837 838 /* The timer used to wakeup the commit thread: */ 839 struct timer_list j_commit_timer; 840 841 /* 842 * The revoke table: maintains the list of revoked blocks in the 843 * current transaction. [j_revoke_lock] 844 */ 845 jbdlock_t j_revoke_lock; 846 struct jbd_revoke_table_s *j_revoke; 847 struct jbd_revoke_table_s *j_revoke_table[2]; 848 849 /* 850 * array of bhs for journal_commit_transaction 851 */ 852 struct buffer_head **j_wbuf; 853 int j_wbufsize; 854 855 pid_t j_last_sync_writer; 856 857 /* 858 * An opaque pointer to fs-private information. ext3 puts its 859 * superblock pointer here 860 */ 861 void *j_private; 862 }; 863 864 /* 865 * Journal flag definitions 866 */ 867 #define JFS_UNMOUNT 0x001 /* Journal thread is being destroyed */ 868 #define JFS_ABORT 0x002 /* Journaling has been aborted for errors. */ 869 #define JFS_ACK_ERR 0x004 /* The errno in the sb has been acked */ 870 #define JFS_FLUSHED 0x008 /* The journal superblock has been flushed */ 871 #define JFS_LOADED 0x010 /* The journal superblock has been loaded */ 872 #define JFS_BARRIER 0x020 /* Use IDE barriers */ 873 874 /* 875 * Function declarations for the journaling transaction and buffer 876 * management 877 */ 878 879 /* Filing buffers */ 880 extern void journal_unfile_buffer(journal_t *, struct journal_head *); 881 extern void __journal_unfile_buffer(struct journal_head *); 882 extern void __journal_refile_buffer(struct journal_head *); 883 extern void journal_refile_buffer(journal_t *, struct journal_head *); 884 extern void __journal_file_buffer(struct journal_head *, transaction_t *, int); 885 extern void __journal_free_buffer(struct journal_head *bh); 886 extern void journal_file_buffer(struct journal_head *, transaction_t *, int); 887 extern void __journal_clean_data_list(transaction_t *transaction); 888 889 /* Log buffer allocation */ 890 extern struct journal_head * journal_get_descriptor_buffer(journal_t *); 891 int journal_next_log_block(journal_t *, unsigned long *); 892 893 /* Commit management */ 894 extern void journal_commit_transaction(journal_t *); 895 896 /* Checkpoint list management */ 897 int __journal_clean_checkpoint_list(journal_t *journal); 898 int __journal_remove_checkpoint(struct journal_head *); 899 void __journal_insert_checkpoint(struct journal_head *, transaction_t *); 900 901 /* Buffer IO */ 902 extern int 903 journal_write_metadata_buffer(transaction_t *transaction, 904 struct journal_head *jh_in, 905 struct journal_head **jh_out, 906 unsigned long blocknr); 907 908 /* Transaction locking */ 909 extern void __wait_on_journal (journal_t *); 910 911 /* 912 * Journal locking. 913 * 914 * We need to lock the journal during transaction state changes so that nobody 915 * ever tries to take a handle on the running transaction while we are in the 916 * middle of moving it to the commit phase. j_state_lock does this. 917 * 918 * Note that the locking is completely interrupt unsafe. We never touch 919 * journal structures from interrupts. 920 */ 921 922 static inline handle_t *journal_current_handle(void) 923 { 924 return NULL; 925 /* return current->journal_info; */ 926 #ifdef _MSC_VER 927 #pragma message("WARNINGS: journal_current_handle NOT implemented") 928 #endif 929 } 930 931 /* The journaling code user interface: 932 * 933 * Create and destroy handles 934 * Register buffer modifications against the current transaction. 935 */ 936 937 extern handle_t *journal_start(journal_t *, int nblocks); 938 extern int journal_restart (handle_t *, int nblocks); 939 extern int journal_extend (handle_t *, int nblocks); 940 extern int journal_get_write_access(handle_t *, struct buffer_head *); 941 extern int journal_get_create_access (handle_t *, struct buffer_head *); 942 extern int journal_get_undo_access(handle_t *, struct buffer_head *); 943 extern int journal_dirty_data (handle_t *, struct buffer_head *); 944 extern int journal_dirty_metadata (handle_t *, struct buffer_head *); 945 extern void journal_release_buffer (handle_t *, struct buffer_head *); 946 extern int journal_forget (handle_t *, struct buffer_head *); 947 extern void journal_sync_buffer (struct buffer_head *); 948 extern void journal_invalidatepage(journal_t *, 949 struct page *, unsigned long); 950 extern int journal_try_to_free_buffers(journal_t *, struct page *, gfp_t); 951 extern int journal_stop(handle_t *); 952 extern int journal_flush (journal_t *); 953 extern void journal_lock_updates (journal_t *); 954 extern void journal_unlock_updates (journal_t *); 955 956 extern journal_t * journal_init_dev(struct block_device *bdev, 957 struct block_device *fs_dev, 958 int start, int len, int bsize); 959 extern journal_t * journal_init_inode (struct inode *); 960 extern int journal_update_format (journal_t *); 961 extern int journal_check_used_features 962 (journal_t *, unsigned long, unsigned long, unsigned long); 963 extern int journal_check_available_features 964 (journal_t *, unsigned long, unsigned long, unsigned long); 965 extern int journal_set_features 966 (journal_t *, unsigned long, unsigned long, unsigned long); 967 extern int journal_create (journal_t *); 968 extern int journal_load (journal_t *journal); 969 extern void journal_destroy (journal_t *); 970 extern int journal_recover (journal_t *journal); 971 extern int journal_wipe (journal_t *, int); 972 extern int journal_skip_recovery (journal_t *); 973 extern void journal_update_superblock (journal_t *, int); 974 void journal_abort (journal_t *, int); 975 extern int journal_errno (journal_t *); 976 extern void journal_ack_err (journal_t *); 977 extern int journal_clear_err (journal_t *); 978 extern int journal_bmap(journal_t *, unsigned long, unsigned long *); 979 extern int journal_force_commit(journal_t *); 980 981 /* added by matt */ 982 void journal_wipe_recovery(journal_t *journal); 983 984 /* 985 * journal_head management 986 */ 987 struct journal_head *journal_add_journal_head(struct buffer_head *bh); 988 struct journal_head *journal_grab_journal_head(struct buffer_head *bh); 989 void journal_remove_journal_head(struct buffer_head *bh); 990 void journal_put_journal_head(struct journal_head *jh); 991 992 /* 993 * handle management 994 */ 995 extern struct kmem_cache *jbd_handle_cache; 996 997 static inline handle_t *jbd_alloc_handle(gfp_t gfp_flags) 998 { 999 return (handle_t *)kmem_cache_alloc(jbd_handle_cache, gfp_flags); 1000 } 1001 1002 static inline void jbd_free_handle(handle_t *handle) 1003 { 1004 kmem_cache_free(jbd_handle_cache, handle); 1005 } 1006 1007 /* Primary revoke support */ 1008 #define JOURNAL_REVOKE_DEFAULT_HASH 256 1009 extern int journal_init_revoke(journal_t *, int); 1010 extern void journal_destroy_revoke_caches(void); 1011 extern int journal_init_revoke_caches(void); 1012 1013 extern void journal_destroy_revoke(journal_t *); 1014 extern int journal_revoke (handle_t *, 1015 unsigned long, struct buffer_head *); 1016 extern int journal_cancel_revoke(handle_t *, struct journal_head *); 1017 extern void journal_write_revoke_records(journal_t *, transaction_t *); 1018 1019 /* Recovery revoke support */ 1020 extern int journal_set_revoke(journal_t *, unsigned long, tid_t); 1021 extern int journal_test_revoke(journal_t *, unsigned long, tid_t); 1022 extern void journal_clear_revoke(journal_t *); 1023 extern void journal_switch_revoke_table(journal_t *journal); 1024 1025 /* 1026 * The log thread user interface: 1027 * 1028 * Request space in the current transaction, and force transaction commit 1029 * transitions on demand. 1030 */ 1031 1032 int __log_space_left(journal_t *); /* Called with journal locked */ 1033 int log_start_commit(journal_t *journal, tid_t tid); 1034 int __log_start_commit(journal_t *journal, tid_t tid); 1035 int journal_start_commit(journal_t *journal, tid_t *tid); 1036 int journal_force_commit_nested(journal_t *journal); 1037 int log_wait_commit(journal_t *journal, tid_t tid); 1038 int log_do_checkpoint(journal_t *journal); 1039 1040 void __log_wait_for_space(journal_t *journal); 1041 extern void __journal_drop_transaction(journal_t *, transaction_t *); 1042 extern int cleanup_journal_tail(journal_t *); 1043 1044 /* Debugging code only: */ 1045 1046 #define jbd_ENOSYS() \ 1047 do { \ 1048 printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \ 1049 current->state = TASK_UNINTERRUPTIBLE; \ 1050 schedule(); \ 1051 } while (1) 1052 1053 /* 1054 * is_journal_abort 1055 * 1056 * Simple test wrapper function to test the JFS_ABORT state flag. This 1057 * bit, when set, indicates that we have had a fatal error somewhere, 1058 * either inside the journaling layer or indicated to us by the client 1059 * (eg. ext3), and that we and should not commit any further 1060 * transactions. 1061 */ 1062 1063 static inline int is_journal_aborted(journal_t *journal) 1064 { 1065 return journal->j_flags & JFS_ABORT; 1066 } 1067 1068 static inline int is_handle_aborted(handle_t *handle) 1069 { 1070 if (handle->h_aborted) 1071 return 1; 1072 return is_journal_aborted(handle->h_transaction->t_journal); 1073 } 1074 1075 static inline void journal_abort_handle(handle_t *handle) 1076 { 1077 handle->h_aborted = 1; 1078 } 1079 1080 #endif /* __KERNEL__ */ 1081 1082 /* Comparison functions for transaction IDs: perform comparisons using 1083 * modulo arithmetic so that they work over sequence number wraps. */ 1084 1085 static inline int tid_gt(tid_t x, tid_t y) 1086 { 1087 int difference = (x - y); 1088 return (difference > 0); 1089 } 1090 1091 static inline int tid_geq(tid_t x, tid_t y) 1092 { 1093 int difference = (x - y); 1094 return (difference >= 0); 1095 } 1096 1097 extern int journal_blocks_per_page(struct inode *inode); 1098 1099 /* 1100 * Return the minimum number of blocks which must be free in the journal 1101 * before a new transaction may be started. Must be called under j_state_lock. 1102 */ 1103 static inline int jbd_space_needed(journal_t *journal) 1104 { 1105 int nblocks = journal->j_max_transaction_buffers; 1106 if (journal->j_committing_transaction) 1107 nblocks += journal->j_committing_transaction-> 1108 t_outstanding_credits; 1109 return nblocks; 1110 } 1111 1112 /* 1113 * Definitions which augment the buffer_head layer 1114 */ 1115 1116 /* journaling buffer types */ 1117 #define BJ_None 0 /* Not journaled */ 1118 #define BJ_SyncData 1 /* Normal data: flush before commit */ 1119 #define BJ_Metadata 2 /* Normal journaled metadata */ 1120 #define BJ_Forget 3 /* Buffer superseded by this transaction */ 1121 #define BJ_IO 4 /* Buffer is for temporary IO use */ 1122 #define BJ_Shadow 5 /* Buffer contents being shadowed to the log */ 1123 #define BJ_LogCtl 6 /* Buffer contains log descriptors */ 1124 #define BJ_Reserved 7 /* Buffer is reserved for access by journal */ 1125 #define BJ_Locked 8 /* Locked for I/O during commit */ 1126 #define BJ_Types 9 1127 1128 extern int jbd_blocks_per_page(struct inode *inode); 1129 1130 #ifdef __KERNEL__ 1131 1132 #define buffer_trace_init(bh) do {} while (0) 1133 #define print_buffer_fields(bh) do {} while (0) 1134 #define print_buffer_trace(bh) do {} while (0) 1135 #define BUFFER_TRACE(bh, info) do {} while (0) 1136 #define BUFFER_TRACE2(bh, bh2, info) do {} while (0) 1137 #define JBUFFER_TRACE(jh, info) do {} while (0) 1138 1139 #endif /* __KERNEL__ */ 1140 1141 #endif /* _LINUX_JBD_H */ 1142