Lines Matching defs:transaction
189 * write in the running transaction or waiting to be
195 * read them before the transaction is checkpointed. So be
197 * ei->i_datasync_tid to store the newest transaction
227 * For inodes with journalled data, transaction commit could have
238 * protection against it. When we are in a running transaction though,
325 * (transaction abort, IO errors, whatever), then we can still
721 * visible after transaction commit must be on transaction's
988 * the data write be encapsulated in a single transaction. We cannot
989 * close off a transaction and start a new one between the ext4_get_block()
998 * By accident, ext4 can be reentered when a transaction is open via
999 * quota file writes. If we were to commit the transaction while thus
1002 * transaction open and was blocking on the quota lock - a ranking
1169 * the transaction handle. This also allows us to allocate
1318 * ordering of page lock and transaction start for journaling
1969 * Note that we don't need to start a transaction unless we're journaling data
1971 * need to file the inode to the transaction's list in ordered mode because if
1974 * transaction the data will hit the disk. In case we are journaling data, we
1975 * cannot start transaction directly because transaction start ranks above page
2459 * cannot map more because we are limited by reserved transaction credits. On
2720 * a transaction for special inodes like journal inode on last iput()
2798 * starting a transaction unnecessarily and also avoid being blocked
2799 * in the block layer on device congestion while having transaction
2837 /* start a new transaction */
2859 * ext4_journal_stop() can wait for transaction commit
2880 * we are still holding the transaction as we can
2893 * Commit the transaction which would
2894 * free blocks released in the transaction
3502 * we are reading to save overhead of starting a transaction.
4179 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
4187 * probably isn't), but whenever we close off and commit a journal transaction,
4262 * truncatable state while each transaction commits.
4965 * Set transaction id's of transactions that have to be committed
4966 * to finish f[data]sync. We set them to currently running transaction
4968 * part of the transaction - the inode could have been reclaimed and
4972 transaction_t *transaction;
4977 transaction = journal->j_running_transaction;
4979 transaction = journal->j_committing_transaction;
4980 if (transaction)
4981 tid = transaction->t_tid;
5248 * Here, there will be no transaction running. We wait for any running
5249 * transaction to commit.
5295 * No need to force transaction in WB_SYNC_NONE mode. Also
5388 * and inode is still attached to the committing transaction, we must
5391 * transaction are already on disk (truncate waits for pages under
5458 * one transaction */
5595 * If the call to ext4_truncate failed to get a transaction handle at
5742 * the modification of a single pages into a single transaction,
5982 * have a transaction open against a different journal.
6019 * to include the updated inode in the current transaction.
6171 * On data journalling we skip straight to the transaction handle:
6208 * inode to the transaction's list to writeprotect pages on commit.