Lines Matching refs:transaction
77 * truncate transaction.
94 /* But we need to bound the transaction so we don't overflow the
104 * be able to restart the transaction at a conventient checkpoint to make
107 * start_transaction gets us a new handle for a truncate transaction,
110 * transaction in the top-level truncate loop. --sct
125 * Try to extend this transaction for the purposes of truncation.
128 * room, and the transaction must be restarted we return 1.
142 * Restart the transaction associated with *handle. This does a commit,
144 * this transaction.
247 * (transaction abort, IO errors, whatever), then we can still
998 * up transaction credits, especially for bitmaps where the
1506 * the data write be encapsulated in a single transaction. We cannot
1507 * close off a transaction and start a new one between the ext4_get_block()
1517 * By accident, ext4 can be reentered when a transaction is open via
1518 * quota file writes. If we were to commit the transaction while thus
1521 * transaction open and was blocking on the quota lock - a ranking
1594 /* We cannot recurse into the filesystem as the transaction is already
1696 * ordering of page lock and transaction start for journaling
2641 * Note that we don't need to start a transaction unless we're journaling data
2643 * need to file the inode to the transaction's list in ordered mode because if
2646 * transaction the data will hit the disk. In case we are journaling data, we
2647 * cannot start transaction directly because transaction start ranks above page
2775 * a single extent allocation into a single transaction,
2936 * a transaction for special inodes like journal inode on last iput()
3016 /* start a new transaction*/
3061 /* commit the transaction which would
3062 * free blocks released in the transaction
3180 /* We cannot recurse into the filesystem as the transaction is already
4317 * If we restart the transaction we must again get write access to the
4366 * @handle: handle for this transaction
4453 * @handle: JBD handle for this transaction
4525 * the release into the same transaction, recovery
4545 * transaction where the data blocks are
4593 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
4601 * probably isn't), but whenever we close off and commit a journal transaction,
4667 * truncatable state while each transaction commits.
4754 * In a multi-transaction truncate, we only make the final transaction
5065 * Set transaction id's of transactions that have to be committed
5066 * to finish f[data]sync. We set them to currently running transaction
5068 * part of the transaction - the inode could have been reclaimed and
5072 transaction_t *transaction;
5077 transaction = journal->j_running_transaction;
5079 transaction = journal->j_committing_transaction;
5080 if (transaction)
5081 tid = transaction->t_tid;
5353 * Here, there will be no transaction running. We wait for any running
5434 * and inode is still attached to the committing transaction, we must
5437 * transaction are already on disk (truncate waits for pages under
5472 * one transaction */
5539 * If the call to ext4_truncate failed to get a transaction handle at
5671 * the modification of a single pages into a single transaction,
5790 * have a transaction open against a different journal.
5854 * to include the updated inode in the current transaction.