Lines Matching refs:journal
111 * __log_wait_for_space: wait until there is space in the journal.
116 void __log_wait_for_space(journal_t *journal)
119 assert_spin_locked(&journal->j_state_lock);
121 nblocks = jbd_space_needed(journal);
122 while (__log_space_left(journal) < nblocks) {
123 if (journal->j_flags & JFS_ABORT)
125 spin_unlock(&journal->j_state_lock);
126 mutex_lock(&journal->j_checkpoint_mutex);
132 * journal space by calling cleanup_journal_tail(), and if
136 * filesystem, so abort the journal and leave a stack
139 spin_lock(&journal->j_state_lock);
140 spin_lock(&journal->j_list_lock);
141 nblocks = jbd_space_needed(journal);
142 space_left = __log_space_left(journal);
144 int chkpt = journal->j_checkpoint_transactions != NULL;
147 if (journal->j_committing_transaction)
148 tid = journal->j_committing_transaction->t_tid;
149 spin_unlock(&journal->j_list_lock);
150 spin_unlock(&journal->j_state_lock);
152 log_do_checkpoint(journal);
153 } else if (cleanup_journal_tail(journal) == 0) {
157 log_wait_commit(journal, tid);
163 "journal space\n", __func__);
165 journal_abort(journal, 0);
167 spin_lock(&journal->j_state_lock);
169 spin_unlock(&journal->j_list_lock);
171 mutex_unlock(&journal->j_checkpoint_mutex);
180 static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
181 __releases(journal->j_list_lock)
184 spin_unlock(&journal->j_list_lock);
201 static int __wait_cp_io(journal_t *journal, transaction_t *transaction)
212 if (journal->j_checkpoint_transactions != transaction ||
219 jbd_sync_bh(journal, bh);
220 spin_lock(&journal->j_list_lock);
225 spin_unlock(&journal->j_list_lock);
231 spin_lock(&journal->j_list_lock);
253 __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
279 static int __process_buffer(journal_t *journal, struct journal_head *jh,
287 spin_unlock(&journal->j_list_lock);
298 spin_unlock(&journal->j_list_lock);
300 log_start_commit(journal, tid);
301 log_wait_commit(journal, tid);
310 spin_unlock(&journal->j_list_lock);
317 * possibly block, while still holding the journal lock.
331 spin_unlock(&journal->j_list_lock);
332 __flush_batch(journal, bhs, batch_count);
344 * The journal should be locked before calling this function.
347 int log_do_checkpoint(journal_t *journal)
358 * journal straight away.
360 result = cleanup_journal_tail(journal);
370 spin_lock(&journal->j_list_lock);
371 if (!journal->j_checkpoint_transactions)
373 transaction = journal->j_checkpoint_transactions;
381 if (journal->j_checkpoint_transactions == transaction &&
394 jbd_sync_bh(journal, bh);
398 retry = __process_buffer(journal, jh, bhs,&batch_count);
402 spin_needbreak(&journal->j_list_lock))) {
403 spin_unlock(&journal->j_list_lock);
411 spin_unlock(&journal->j_list_lock);
414 __flush_batch(journal, bhs, &batch_count);
418 spin_lock(&journal->j_list_lock);
425 err = __wait_cp_io(journal, transaction);
430 spin_unlock(&journal->j_list_lock);
432 journal_abort(journal, result);
434 result = cleanup_journal_tail(journal);
440 * Check the list of checkpoint transactions for the journal to see if
442 * in the journal superblock. If so, we can instantly roll the
447 * Called with the journal lock held.
451 * main filesystem area rather than to the journal, so it can proceed
457 int cleanup_journal_tail(journal_t *journal)
463 if (is_journal_aborted(journal))
473 spin_lock(&journal->j_state_lock);
474 spin_lock(&journal->j_list_lock);
475 transaction = journal->j_checkpoint_transactions;
479 } else if ((transaction = journal->j_committing_transaction) != NULL) {
482 } else if ((transaction = journal->j_running_transaction) != NULL) {
484 blocknr = journal->j_head;
486 first_tid = journal->j_transaction_sequence;
487 blocknr = journal->j_head;
489 spin_unlock(&journal->j_list_lock);
494 if (journal->j_tail_sequence == first_tid) {
495 spin_unlock(&journal->j_state_lock);
502 freed = blocknr - journal->j_tail;
503 if (blocknr < journal->j_tail)
504 freed = freed + journal->j_last - journal->j_first;
507 "Cleaning journal tail from %d to %d (offset %u), "
509 journal->j_tail_sequence, first_tid, blocknr, freed);
511 journal->j_free += freed;
512 journal->j_tail_sequence = first_tid;
513 journal->j_tail = blocknr;
514 spin_unlock(&journal->j_state_lock);
515 if (!(journal->j_flags & JFS_ABORT))
516 journal_update_superblock(journal, 1);
528 * Called with the journal locked.
574 * Find all the written-back checkpoint buffers in the journal and release them.
576 * Called with the journal locked.
581 int __journal_clean_checkpoint_list(journal_t *journal)
587 transaction = journal->j_checkpoint_transactions;
636 * This function is called with the journal locked.
644 journal_t *journal;
653 journal = transaction->t_journal;
680 __journal_drop_transaction(journal, transaction);
684 wake_up(&journal->j_wait_logspace);
696 * Called with the journal locked.
725 * Called with the journal locked.
729 void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)
731 assert_spin_locked(&journal->j_list_lock);
735 if (journal->j_checkpoint_transactions == transaction)
736 journal->j_checkpoint_transactions =
738 if (journal->j_checkpoint_transactions == transaction)
739 journal->j_checkpoint_transactions = NULL;
752 J_ASSERT(journal->j_committing_transaction != transaction);
753 J_ASSERT(journal->j_running_transaction != transaction);