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
822 * Transactions: The current running transaction...
830 * the transaction we are pushing to disk
846 * Wait queue for waiting for a locked transaction to start committing,
1000 * Number of buffers reserved from the running transaction.
1020 * Sequence number of the oldest transaction in the log [j_state_lock]
1027 * Sequence number of the next transaction to grant [j_state_lock]
1034 * Sequence number of the most recently committed transaction
1042 * Sequence number of the most recent transaction wanting commit
1066 * commit transaction.
1080 * What is the maximum transaction lifetime before we begin a commit?
1098 * current transaction.
1145 * transaction to disk. [j_state_lock]
1168 * This function is called when a transaction is closed.
1177 * committing transaction marked with JI_WRITE_DATA flag
1178 * before we start to write out the transaction to the journal.
1187 * committing transaction marked with JI_WAIT_DATA flag
1188 * after we have written the transaction to the journal
1244 * Lockdep entity to track transaction commit dependencies. Handles
1247 * where the running transaction has to wait for all handles to be
1248 * dropped to commit that transaction and also acquiring a handle may
1249 * require transaction commit to finish.
1365 * Function declarations for the journaling transaction and buffer
1376 extern void __journal_clean_data_list(transaction_t *transaction);
1435 extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1440 /* Transaction locking */
1443 /* Transaction cache support */
1451 * We need to lock the journal during transaction state changes so that nobody
1452 * ever tries to take a handle on the running transaction while we are in the
1467 * Register buffer modifications against the current transaction.
1589 extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
1602 * Request space in the current transaction, and force transaction commit
1663 /* Comparison functions for transaction IDs: perform comparisons using
1716 #define BJ_Forget 2 /* Buffer superseded by this transaction */
1747 /* Return most recent uncommitted transaction */