include/linux/jbd2.h

9  * Definitions for transaction data structures for the buffer cache
86  * the transaction, so that at all times we know how many buffers the
87  * outstanding updates on a transaction might possibly touch.
99  * We use the journal_t to keep track of all outstanding transaction
219 #define JBD2_FLAG_DELETED	4	/* block deleted by this transaction */
395  * ordered mode present in a transaction so that we can sync them during commit.
401 	 * Which transaction does this inode belong to? Either the running
402 	 * transaction or the committing one. [j_list_lock]
409 	 * Pointer to the running transaction modifying inode's data in case
410 	 * there is already a committing transaction touching it. [j_list_lock]
453  * @h_transaction: Which compound transaction is this update a part of?
469  * @saved_alloc_context: Saved context while transaction is open.
516  * tracks a compound transaction through its various states:
524  * FINISHED:	We still have to keep the transaction for checkpointing.
526  * The transaction keeps track of all of the buffers modified by a
527  * running transaction, and all of the buffers committed but not yet
551 	/* Pointer to the journal for this transaction. [no locking] */
554 	/* Sequence number for this transaction [no locking] */
558 	 * Transaction's current state
560 	 * [j_list_lock] guards transition of a transaction into T_FINISHED
578 	 * Where in the log does this transaction's commit start? [no locking]
590 	 * modified by this transaction [j_list_lock, no locks needed fo
597 	 * transaction [j_list_lock, no locks needed for jbd2 thread]
603 	 * buffers which we can un-checkpoint once this transaction commits)
610 	 * this transaction can be checkpointed. [j_list_lock]
624 	 * List of inodes associated with the transaction; e.g., ext4 uses
626 	 * need special handling on transaction commit; also used by ocfs2.
632 	 * Longest time some handle had to wait for running transaction
637 	 * When transaction started
652 	 * Number of outstanding updates running on this transaction
658 	 * Number of blocks reserved for this transaction in the journal.
659 	 * This is including all credits reserved when starting transaction
661 	 * transaction. [none]
666 	 * Number of revoke records for this transaction added by already
672 	 * How many handles used this transaction? [none]
683 	 * When will the transaction expire (become due for commit), in jiffies?
689 	 * When this transaction started, in nanoseconds [no locking]
694 	 * This transaction is being forced and some process is
794 	 * Transactions: The current running transaction...
803 	 * the transaction we are pushing to disk
819 	 * Wait queue for waiting for a locked transaction to start committing,
888 	 * Record next transaction will shrink on the checkpoint list.
1003 	 * Number of buffers reserved from the running transaction.
1023 	 * Sequence number of the oldest transaction in the log [j_state_lock]
1030 	 * Sequence number of the next transaction to grant [j_state_lock]
1037 	 * Sequence number of the most recently committed transaction
1045 	 * Sequence number of the most recent transaction wanting commit
1069 	 * commit transaction.
1083 	 * Number of blocks each transaction needs for its own bookkeeping
1090 	 * What is the maximum transaction lifetime before we begin a commit?
1108 	 * current transaction.
1155 	 * transaction to disk. [j_state_lock]
1178 	 * This function is called when a transaction is closed.
1187 	 * committing transaction marked with JI_WRITE_DATA flag
1188 	 * before we start to write out the transaction to the journal.
1197 	 * committing transaction marked with JI_WAIT_DATA flag
1198 	 * after we have written the transaction to the journal
1247 	 * Lockdep entity to track transaction commit dependencies. Handles
1250 	 * where the running transaction has to wait for all handles to be
1251 	 * dropped to commit that transaction and also acquiring a handle may
1252 	 * require transaction commit to finish.
1394  * Function declarations for the journaling transaction and buffer
1465 extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1470 /* Transaction cache support */
1478  * We need to lock the journal during transaction state changes so that nobody
1479  * ever tries to take a handle on the running transaction while we are in the
1494  * Register buffer modifications against the current transaction.
1624 extern void	   jbd2_journal_write_revoke_records(transaction_t *transaction,
1637  * Request space in the current transaction, and force transaction commit
1711 /* Comparison functions for transaction IDs: perform comparisons using
1764 #define BJ_Forget	2	/* Buffer superseded by this transaction */
1775 /* Return most recent uncommitted transaction */