Lines Matching refs:transaction
163 transaction_t *transaction;
180 * transaction commit and any fs involvement might get stuck waiting for
229 transaction = journal->j_running_transaction;
230 if (transaction && time_after_eq(jiffies,
231 transaction->t_expires))
248 transaction = journal->j_running_transaction;
249 if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
250 journal->j_commit_request = transaction->t_tid;
308 * If the source buffer has already been modified by a new transaction
326 int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
339 journal_t *journal = transaction->t_journal;
343 * transaction is allowed to write it, so nobody else is allowed
360 * If a new transaction has already done a buffer copy-out, then
448 * copying is moved to the transaction's shadow queue.
452 __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
467 * Returns true if a transaction commit was started.
476 * The only transaction we can possibly wait upon is the
477 * currently running transaction (if it exists). Otherwise,
518 * transaction if we don't have an active handle, otherwise, we will deadlock.
521 * 1 if transaction was successfully committed.
525 transaction_t *transaction = NULL;
531 transaction = journal->j_running_transaction;
532 if (!tid_geq(journal->j_commit_request, transaction->t_tid))
535 transaction = journal->j_committing_transaction;
537 if (!transaction) {
542 tid = transaction->t_tid;
555 * calling process is not within transaction.
575 * Caller want unconditional commit. We can only force the running transaction
590 * Start a commit of the current running transaction (if any). Returns true
591 * if a transaction is going to be committed (or is currently already
603 /* There's a running transaction and we've just made sure
611 * completion of that transaction.
622 * Return 1 if a given transaction has not yet sent barrier request
623 * connected with a transaction commit. If 0 is returned, transaction
673 * Some callers make sure transaction is already committing and in that
789 /* Return 1 when transaction with given tid has already committed. */
807 * When this function returns the transaction corresponding to tid
808 * will be completed. If the transaction has currently running, start
809 * committing that transaction before waiting for it to complete. If
810 * the transaction id is stale, it is by definition already completed,
821 /* transaction not yet started, so request it */
997 jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)
999 journal_t *journal = transaction->t_journal;
1013 atomic_dec(&transaction->t_outstanding_credits);
1019 header->h_sequence = cpu_to_be32(transaction->t_tid);
1042 * Return tid of the oldest transaction in the journal and block in the journal
1043 * where the transaction starts.
1045 * If the journal is now empty, return which will be the next transaction ID
1046 * we will write and where will that transaction start.
1054 transaction_t *transaction;
1059 transaction = journal->j_checkpoint_transactions;
1060 if (transaction) {
1061 *tid = transaction->t_tid;
1062 *block = transaction->t_log_start;
1063 } else if ((transaction = journal->j_committing_transaction) != NULL) {
1064 *tid = transaction->t_tid;
1065 *block = transaction->t_log_start;
1066 } else if ((transaction = journal->j_running_transaction) != NULL) {
1067 *tid = transaction->t_tid;
1099 * soon as we update j_tail, next transaction can start reusing journal
1101 * old transaction with possibly newly overwritten data.
1170 seq_printf(seq, "average: \n %ums waiting for transaction\n",
1176 seq_printf(seq, " %ums running transaction\n",
1178 seq_printf(seq, " %ums transaction was being locked\n",
1182 seq_printf(seq, " %ums logging transaction\n",
1184 seq_printf(seq, " %lluus average transaction commit time\n",
1186 seq_printf(seq, " %lu handles per transaction\n",
1188 seq_printf(seq, " %lu blocks per transaction\n",
1190 seq_printf(seq, " %lu logged blocks per transaction\n",
1764 * transaction will start reusing journal space and so we
1841 * @tail_tid: TID of the new transaction at the tail of the log
1842 * @tail_block: The first block of the transaction at the tail of the log
2084 printk(KERN_ERR "JBD2: journal transaction %u on %s "
2423 transaction_t *transaction = NULL;
2429 transaction = journal->j_running_transaction;
2430 __jbd2_log_start_commit(journal, transaction->t_tid);
2432 transaction = journal->j_committing_transaction;
2435 if (transaction) {
2436 tid_t tid = transaction->t_tid;
2533 * journal (not of a single transaction). This operation cannot be
2543 * immediately and no further transaction commits will be honoured.
2550 * Any attempt to get a new transaction handle on a journal which is in
2561 * transaction without having to complete the transaction to record the
2569 transaction_t *transaction;
2597 * Mark the abort as occurred and start current running transaction
2604 transaction = journal->j_running_transaction;
2605 if (transaction)
2606 __jbd2_log_start_commit(journal, transaction->t_tid);
2879 * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
2880 * transaction (b_cp_transaction) hold their references to b_jcount.
2883 * _before_ attaching the journal_head to a transaction. To protect the
2893 * (Get another reference for transaction)
3030 * transaction's lists.