Lines Matching full:transaction
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 */
404 * ordered mode present in a transaction so that we can sync them during commit.
410 * Which transaction does this inode belong to? Either the running
411 * transaction or the committing one. [j_list_lock]
418 * Pointer to the running transaction modifying inode's data in case
419 * there is already a committing transaction touching it. [j_list_lock]
462 * @h_transaction: Which compound transaction is this update a part of?
479 * @saved_alloc_context: Saved context while transaction is open.
527 * tracks a compound transaction through its various states:
535 * FINISHED: We still have to keep the transaction for checkpointing.
537 * The transaction keeps track of all of the buffers modified by a
538 * running transaction, and all of the buffers committed but not yet
562 /* Pointer to the journal for this transaction. [no locking] */
565 /* Sequence number for this transaction [no locking] */
569 * Transaction's current state
571 * [j_list_lock] guards transition of a transaction into T_FINISHED
589 * Where in the log does this transaction's commit start? [no locking]
601 * modified by this transaction [j_list_lock, no locks needed fo
608 * transaction [j_list_lock, no locks needed for jbd2 thread]
614 * buffers which we can un-checkpoint once this transaction commits)
621 * this transaction can be checkpointed. [j_list_lock]
641 * List of inodes associated with the transaction; e.g., ext4 uses
643 * need special handling on transaction commit; also used by ocfs2.
654 * Longest time some handle had to wait for running transaction
659 * When transaction started
674 * Number of outstanding updates running on this transaction
680 * Number of blocks reserved for this transaction in the journal.
681 * This is including all credits reserved when starting transaction
683 * transaction. [none]
688 * Number of revoke records for this transaction added by already
694 * How many handles used this transaction? [none]
705 * When will the transaction expire (become due for commit), in jiffies?
711 * When this transaction started, in nanoseconds [no locking]
716 * This transaction is being forced and some process is
726 * structures associated with the transaction
832 * Transactions: The current running transaction...
841 * the transaction we are pushing to disk
857 * Wait queue for waiting for a locked transaction to start committing,
926 * Record next transaction will shrink on the checkpoint list.
1034 * Number of buffers reserved from the running transaction.
1054 * Sequence number of the oldest transaction in the log [j_state_lock]
1061 * Sequence number of the next transaction to grant [j_state_lock]
1068 * Sequence number of the most recently committed transaction
1076 * Sequence number of the most recent transaction wanting commit
1100 * commit transaction.
1114 * What is the maximum transaction lifetime before we begin a commit?
1132 * current transaction.
1179 * transaction to disk. [j_state_lock]
1202 * This function is called when a transaction is closed.
1211 * committing transaction marked with JI_WRITE_DATA flag
1212 * before we start to write out the transaction to the journal.
1221 * committing transaction marked with JI_WAIT_DATA flag
1222 * after we have written the transaction to the journal
1278 * Lockdep entity to track transaction commit dependencies. Handles
1281 * where the running transaction has to wait for all handles to be
1282 * dropped to commit that transaction and also acquiring a handle may
1283 * require transaction commit to finish.
1409 * Function declarations for the journaling transaction and buffer
1478 extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1483 /* Transaction cache support */
1491 * We need to lock the journal during transaction state changes so that nobody
1492 * ever tries to take a handle on the running transaction while we are in the
1507 * Register buffer modifications against the current transaction.
1631 extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
1644 * Request space in the current transaction, and force transaction commit
1704 /* Comparison functions for transaction IDs: perform comparisons using
1764 #define BJ_Forget 2 /* Buffer superseded by this transaction */
1793 /* Return most recent uncommitted transaction */