Lines Matching defs:transaction
196 * For inodes with journalled data, transaction commit could have
207 * protection against it. When we are in a running transaction though,
294 * (transaction abort, IO errors, whatever), then we can still
693 * visible after transaction commit must be on transaction's
978 * dirty data. ext4_writepages() then commits appropriate transaction to
1112 * the data write be encapsulated in a single transaction. We cannot
1113 * close off a transaction and start a new one between the ext4_get_block()
1155 * the transaction handle. This also allows us to allocate
1307 * ordering of folio lock and transaction start for journaling
2202 * cannot map more because we are limited by reserved transaction credits. On
2538 * a transaction for special inodes like journal inode on last iput()
2580 * transaction to make data stable. We expect all the data to be
2582 * dirtied behind our back) so we commit transaction here and run the
2629 * starting a transaction unnecessarily and also avoid being blocked
2630 * in the block layer on device congestion while having transaction
2669 /* start a new transaction */
2691 * ext4_journal_stop() can wait for transaction commit
2712 * we are still holding the transaction as we can
2725 * Commit the transaction which would
2726 * free blocks released in the transaction
2780 * running transaction. Try once more to get them to stable storage.
3400 * we are reading to save overhead of starting a transaction.
3521 * transaction and marked as jbddirty (we take care of this in
3522 * ext4_page_mkwrite()). On transaction commit, we writeprotect page mappings
3526 * transaction but we cannot due to lock ordering. We cannot just dirty the
3531 * to the transaction appropriately.
4079 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
4087 * probably isn't), but whenever we close off and commit a journal transaction,
4162 * truncatable state while each transaction commits.
4870 * Set transaction id's of transactions that have to be committed
4871 * to finish f[data]sync. We set them to currently running transaction
4873 * part of the transaction - the inode could have been reclaimed and
4877 transaction_t *transaction;
4882 transaction = journal->j_running_transaction;
4884 transaction = journal->j_committing_transaction;
4885 if (transaction)
4886 tid = transaction->t_tid;
5151 * Here, there will be no transaction running. We wait for any running
5152 * transaction to commit.
5197 * No need to force transaction in WB_SYNC_NONE mode. Also
5289 * and inode is still attached to the committing transaction, we must
5292 * transaction are already on disk (truncate waits for pages under
5361 * one transaction */
5496 * If the call to ext4_truncate failed to get a transaction handle at
5681 * the modification of a single pages into a single transaction,
5915 * have a transaction open against a different journal.
5952 * to include the updated inode in the current transaction.
6095 * On data journalling we skip straight to the transaction handle:
6131 * inode to the transaction's list to writeprotect pages on commit.