Lines Matching full:transaction
9 * Definitions for transaction data structures for the buffer cache
87 * the transaction, so that at all times we know how many buffers the
88 * outstanding updates on a transaction might possibly touch.
100 * We use the journal_t to keep track of all outstanding transaction
220 #define JBD2_FLAG_DELETED 4 /* block deleted by this transaction */
405 * ordered mode present in a transaction so that we can sync them during commit.
411 * Which transaction does this inode belong to? Either the running
412 * transaction or the committing one. [j_list_lock]
419 * Pointer to the running transaction modifying inode's data in case
420 * there is already a committing transaction touching it. [j_list_lock]
463 * @h_transaction: Which compound transaction is this update a part of?
480 * @saved_alloc_context: Saved context while transaction is open.
528 * tracks a compound transaction through its various states:
536 * FINISHED: We still have to keep the transaction for checkpointing.
538 * The transaction keeps track of all of the buffers modified by a
539 * running transaction, and all of the buffers committed but not yet
565 /* Pointer to the journal for this transaction. [no locking] */
568 /* Sequence number for this transaction [no locking] */
572 * Transaction's current state
574 * [j_list_lock] guards transition of a transaction into T_FINISHED
592 * Where in the log does this transaction's commit start? [no locking]
601 * modified by this transaction [j_list_lock]
607 * transaction [j_list_lock]
613 * buffers which we can un-checkpoint once this transaction commits)
620 * this transaction can be checkpointed. [j_list_lock]
638 * List of inodes associated with the transaction; e.g., ext4 uses
640 * need special handling on transaction commit; also used by ocfs2.
651 * Longest time some handle had to wait for running transaction
656 * When transaction started
671 * Number of outstanding updates running on this transaction
677 * Number of blocks reserved for this transaction in the journal.
678 * This is including all credits reserved when starting transaction
680 * transaction. [none]
685 * Number of revoke records for this transaction added by already
691 * How many handles used this transaction? [none]
702 * When will the transaction expire (become due for commit), in jiffies?
708 * When this transaction started, in nanoseconds [no locking]
713 * This transaction is being forced and some process is
723 * structures associated with the transaction
827 * Transactions: The current running transaction...
835 * the transaction we are pushing to disk
851 * Wait queue for waiting for a locked transaction to start committing,
920 * Record next transaction will shrink on the checkpoint list.
1028 * Number of buffers reserved from the running transaction.
1048 * Sequence number of the oldest transaction in the log [j_state_lock]
1055 * Sequence number of the next transaction to grant [j_state_lock]
1062 * Sequence number of the most recently committed transaction
1070 * Sequence number of the most recent transaction wanting commit
1094 * commit transaction.
1108 * What is the maximum transaction lifetime before we begin a commit?
1126 * current transaction.
1173 * transaction to disk. [j_state_lock]
1196 * This function is called when a transaction is closed.
1205 * committing transaction marked with JI_WRITE_DATA flag
1206 * before we start to write out the transaction to the journal.
1215 * committing transaction marked with JI_WAIT_DATA flag
1216 * after we have written the transaction to the journal
1272 * Lockdep entity to track transaction commit dependencies. Handles
1275 * where the running transaction has to wait for all handles to be
1276 * dropped to commit that transaction and also acquiring a handle may
1277 * require transaction commit to finish.
1399 * Function declarations for the journaling transaction and buffer
1410 extern void __journal_clean_data_list(transaction_t *transaction);
1470 extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1475 /* Transaction locking */
1478 /* Transaction cache support */
1486 * We need to lock the journal during transaction state changes so that nobody
1487 * ever tries to take a handle on the running transaction while we are in the
1502 * 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
1698 /* Comparison functions for transaction IDs: perform comparisons using
1751 #define BJ_Forget 2 /* Buffer superseded by this transaction */
1782 /* Return most recent uncommitted transaction */