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
566 /* Pointer to the journal for this transaction. [no locking] */
569 /* Sequence number for this transaction [no locking] */
573 * Transaction's current state
575 * [j_list_lock] guards transition of a transaction into T_FINISHED
593 * Where in the log does this transaction's commit start? [no locking]
605 * modified by this transaction [j_list_lock, no locks needed fo
612 * transaction [j_list_lock, no locks needed for jbd2 thread]
618 * buffers which we can un-checkpoint once this transaction commits)
625 * this transaction can be checkpointed. [j_list_lock]
645 * List of inodes associated with the transaction; e.g., ext4 uses
647 * need special handling on transaction commit; also used by ocfs2.
658 * Longest time some handle had to wait for running transaction
663 * When transaction started
678 * Number of outstanding updates running on this transaction
684 * Number of blocks reserved for this transaction in the journal.
685 * This is including all credits reserved when starting transaction
687 * transaction. [none]
692 * Number of revoke records for this transaction added by already
698 * How many handles used this transaction? [none]
709 * When will the transaction expire (become due for commit), in jiffies?
715 * When this transaction started, in nanoseconds [no locking]
720 * This transaction is being forced and some process is
730 * structures associated with the transaction
836 * Transactions: The current running transaction...
845 * the transaction we are pushing to disk
861 * Wait queue for waiting for a locked transaction to start committing,
930 * Record next transaction will shrink on the checkpoint list.
1038 * Number of buffers reserved from the running transaction.
1058 * Sequence number of the oldest transaction in the log [j_state_lock]
1065 * Sequence number of the next transaction to grant [j_state_lock]
1072 * Sequence number of the most recently committed transaction
1080 * Sequence number of the most recent transaction wanting commit
1104 * commit transaction.
1118 * What is the maximum transaction lifetime before we begin a commit?
1136 * current transaction.
1183 * transaction to disk. [j_state_lock]
1206 * This function is called when a transaction is closed.
1215 * committing transaction marked with JI_WRITE_DATA flag
1216 * before we start to write out the transaction to the journal.
1225 * committing transaction marked with JI_WAIT_DATA flag
1226 * after we have written the transaction to the journal
1282 * Lockdep entity to track transaction commit dependencies. Handles
1285 * where the running transaction has to wait for all handles to be
1286 * dropped to commit that transaction and also acquiring a handle may
1287 * require transaction commit to finish.
1413 * Function declarations for the journaling transaction and buffer
1424 extern void __journal_clean_data_list(transaction_t *transaction);
1484 extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1489 /* Transaction locking */
1492 /* Transaction cache support */
1500 * We need to lock the journal during transaction state changes so that nobody
1501 * ever tries to take a handle on the running transaction while we are in the
1516 * Register buffer modifications against the current transaction.
1638 extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
1651 * Request space in the current transaction, and force transaction commit
1712 /* Comparison functions for transaction IDs: perform comparisons using
1772 #define BJ_Forget 2 /* Buffer superseded by this transaction */
1803 /* Return most recent uncommitted transaction */