Lines Matching defs:journal
36 * RUNNING state and add it to the current journal (which should not
41 * The journal MUST be locked. We don't perform atomic mallocs on the
43 * processes trying to touch the journal while it is in transition.
49 get_transaction(journal_t *journal, transaction_t *transaction)
51 transaction->t_journal = journal;
54 transaction->t_tid = journal->j_transaction_sequence++;
55 transaction->t_expires = jiffies + journal->j_commit_interval;
59 journal->j_commit_timer.expires =
61 add_timer(&journal->j_commit_timer);
63 J_ASSERT(journal->j_running_transaction == NULL);
64 journal->j_running_transaction = transaction;
79 * needed to make sure that there is enough journal space for the handle
84 static int start_this_handle(journal_t *journal, handle_t *handle)
92 if (nblocks > journal->j_max_transaction_buffers) {
95 journal->j_max_transaction_buffers);
101 if (!journal->j_running_transaction) {
116 * for proper journal barrier handling
118 spin_lock(&journal->j_state_lock);
120 if (is_journal_aborted(journal) ||
121 (journal->j_errno != 0 && !(journal->j_flags & JFS_ACK_ERR))) {
122 spin_unlock(&journal->j_state_lock);
127 /* Wait on the journal's transaction barrier if necessary */
128 if (journal->j_barrier_count) {
129 spin_unlock(&journal->j_state_lock);
130 wait_event(journal->j_wait_transaction_locked,
131 journal->j_barrier_count == 0);
135 if (!journal->j_running_transaction) {
137 spin_unlock(&journal->j_state_lock);
140 get_transaction(journal, new_transaction);
144 transaction = journal->j_running_transaction;
153 prepare_to_wait(&journal->j_wait_transaction_locked,
155 spin_unlock(&journal->j_state_lock);
157 finish_wait(&journal->j_wait_transaction_locked, &wait);
169 if (needed > journal->j_max_transaction_buffers) {
179 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
181 __log_start_commit(journal, transaction->t_tid);
182 spin_unlock(&journal->j_state_lock);
184 finish_wait(&journal->j_wait_transaction_locked, &wait);
195 * We must therefore ensure the necessary space in the journal
206 * a _lot_ of headroom: 1/4 of the journal plus the size of
213 if (__log_space_left(journal) < jbd_space_needed(journal)) {
216 __log_wait_for_space(journal);
229 __log_space_left(journal));
231 spin_unlock(&journal->j_state_lock);
259 * @journal: Journal to start transaction on.
266 * This function is visible to journal users (like ext3fs), so is not
267 * called with the journal already locked.
271 handle_t *journal_start(journal_t *journal, int nblocks)
276 if (!journal)
280 J_ASSERT(handle->h_transaction->t_journal == journal);
291 err = start_this_handle(journal, handle);
325 journal_t *journal = transaction->t_journal;
335 spin_lock(&journal->j_state_lock);
347 if (wanted > journal->j_max_transaction_buffers) {
353 if (wanted > __log_space_left(journal)) {
367 spin_unlock(&journal->j_state_lock);
391 journal_t *journal = transaction->t_journal;
406 spin_lock(&journal->j_state_lock);
412 wake_up(&journal->j_wait_updates);
416 __log_start_commit(journal, transaction->t_tid);
417 spin_unlock(&journal->j_state_lock);
421 ret = start_this_handle(journal, handle);
428 * @journal: Journal to establish a barrier on.
432 * journal is in a quiescent state with no updates running.
434 * The journal lock should not be held on entry.
436 void journal_lock_updates(journal_t *journal)
440 spin_lock(&journal->j_state_lock);
441 ++journal->j_barrier_count;
445 transaction_t *transaction = journal->j_running_transaction;
455 prepare_to_wait(&journal->j_wait_updates, &wait,
458 spin_unlock(&journal->j_state_lock);
460 finish_wait(&journal->j_wait_updates, &wait);
461 spin_lock(&journal->j_state_lock);
463 spin_unlock(&journal->j_state_lock);
468 * to make sure that we serialise special journal-locked operations
471 mutex_lock(&journal->j_barrier);
475 * void journal_unlock_updates (journal_t* journal) - release barrier
476 * @journal: Journal to release the barrier on.
480 * Should be called without the journal lock held.
482 void journal_unlock_updates (journal_t *journal)
484 J_ASSERT(journal->j_barrier_count != 0);
486 mutex_unlock(&journal->j_barrier);
487 spin_lock(&journal->j_state_lock);
488 --journal->j_barrier_count;
489 spin_unlock(&journal->j_state_lock);
490 wake_up(&journal->j_wait_transaction_locked);
520 journal_t *journal;
529 journal = transaction->t_journal;
564 journal->j_committing_transaction);
620 journal->j_committing_transaction);
655 * but that should be true --- we hold the journal lock
702 spin_lock(&journal->j_list_lock);
704 spin_unlock(&journal->j_list_lock);
724 * If we are about to journal a buffer, then any revoke pending on it is
763 * When the user wants to journal a newly created buffer_head
784 journal_t *journal = transaction->t_journal;
803 spin_lock(&journal->j_list_lock);
806 (jh->b_transaction == journal->j_committing_transaction &&
829 } else if (jh->b_transaction == journal->j_committing_transaction) {
836 spin_unlock(&journal->j_list_lock);
887 * Do this first --- it can drop the journal lock, so we want to
947 journal_t *journal = handle->h_transaction->t_journal;
986 spin_lock(&journal->j_list_lock);
999 journal->j_committing_transaction);
1004 * in data=journal mode. The buffer's transaction has
1012 * It may be too late to journal the data. Simply
1049 spin_unlock(&journal->j_list_lock);
1054 spin_lock(&journal->j_list_lock);
1106 spin_unlock(&journal->j_list_lock);
1139 journal_t *journal = transaction->t_journal;
1170 journal->j_running_transaction);
1185 journal->j_committing_transaction);
1196 spin_lock(&journal->j_list_lock);
1198 spin_unlock(&journal->j_list_lock);
1237 journal_t *journal = transaction->t_journal;
1246 spin_lock(&journal->j_list_lock);
1288 * We are no longer going to journal this buffer.
1307 spin_unlock(&journal->j_list_lock);
1315 journal->j_committing_transaction));
1336 spin_unlock(&journal->j_list_lock);
1366 journal_t *journal = transaction->t_journal;
1413 if (handle->h_sync && journal->j_last_sync_writer != pid) {
1416 journal->j_last_sync_writer = pid;
1418 spin_lock(&journal->j_state_lock);
1419 commit_time = journal->j_average_commit_time;
1420 spin_unlock(&journal->j_state_lock);
1439 spin_lock(&journal->j_state_lock);
1444 wake_up(&journal->j_wait_updates);
1445 if (journal->j_barrier_count)
1446 wake_up(&journal->j_wait_transaction_locked);
1457 journal->j_max_transaction_buffers ||
1468 __log_start_commit(journal, transaction->t_tid);
1469 spin_unlock(&journal->j_state_lock);
1476 err = log_wait_commit(journal, tid);
1479 spin_unlock(&journal->j_state_lock);
1490 * @journal: journal to force
1496 int journal_force_commit(journal_t *journal)
1501 handle = journal_start(journal, 1);
1546 * Called with j_list_lock held, and the journal may not be locked.
1572 * Called under j_list_lock. The journal may not be locked.
1632 void journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
1635 spin_lock(&journal->j_list_lock);
1637 spin_unlock(&journal->j_list_lock);
1647 __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1659 spin_lock(&journal->j_list_lock);
1677 spin_unlock(&journal->j_list_lock);
1684 * @journal: journal for operation
1720 int journal_try_to_free_buffers(journal_t *journal,
1744 __journal_try_to_free_buffer(journal, bh);
1841 static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh)
1859 spin_lock(&journal->j_state_lock);
1861 spin_lock(&journal->j_list_lock);
1871 * buffer would be cleaned from the journal before T is
1898 /* OK, it must be in the journal but still not
1902 if (journal->j_running_transaction) {
1908 journal->j_running_transaction);
1910 spin_unlock(&journal->j_list_lock);
1912 spin_unlock(&journal->j_state_lock);
1919 if (journal->j_committing_transaction) {
1922 journal->j_committing_transaction);
1924 spin_unlock(&journal->j_list_lock);
1926 spin_unlock(&journal->j_state_lock);
1935 } else if (transaction == journal->j_committing_transaction) {
1954 if (journal->j_running_transaction && buffer_jbddirty(bh))
1955 jh->b_next_transaction = journal->j_running_transaction;
1957 spin_unlock(&journal->j_list_lock);
1959 spin_unlock(&journal->j_state_lock);
1968 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
1976 spin_unlock(&journal->j_list_lock);
1978 spin_unlock(&journal->j_state_lock);
1990 * void journal_invalidatepage() - invalidate a journal page
1991 * @journal: journal to use for flush
1997 void journal_invalidatepage(journal_t *journal,
2022 may_free &= journal_unmap_buffer(journal, bh);
2131 * Called under journal->j_list_lock
2186 void journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2191 spin_lock(&journal->j_list_lock);
2197 spin_unlock(&journal->j_list_lock);