Lines Matching refs:journal
38 * RUNNING state and add it to the current journal (which should not
43 * The journal MUST be locked. We don't perform atomic mallocs on the
45 * processes trying to touch the journal while it is in transition.
50 jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
52 transaction->t_journal = journal;
55 transaction->t_tid = journal->j_transaction_sequence++;
56 transaction->t_expires = jiffies + journal->j_commit_interval;
65 journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
66 add_timer(&journal->j_commit_timer);
68 J_ASSERT(journal->j_running_transaction == NULL);
69 journal->j_running_transaction = transaction;
112 * needed to make sure that there is enough journal space for the handle
117 static int start_this_handle(journal_t *journal, handle_t *handle,
125 if (nblocks > journal->j_max_transaction_buffers) {
128 journal->j_max_transaction_buffers);
133 if (!journal->j_running_transaction) {
155 * for proper journal barrier handling
158 read_lock(&journal->j_state_lock);
159 if (is_journal_aborted(journal) ||
160 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
161 read_unlock(&journal->j_state_lock);
166 /* Wait on the journal's transaction barrier if necessary */
167 if (journal->j_barrier_count) {
168 read_unlock(&journal->j_state_lock);
169 wait_event(journal->j_wait_transaction_locked,
170 journal->j_barrier_count == 0);
174 if (!journal->j_running_transaction) {
175 read_unlock(&journal->j_state_lock);
178 write_lock(&journal->j_state_lock);
179 if (!journal->j_running_transaction) {
180 jbd2_get_transaction(journal, new_transaction);
183 write_unlock(&journal->j_state_lock);
187 transaction = journal->j_running_transaction;
196 prepare_to_wait(&journal->j_wait_transaction_locked,
198 read_unlock(&journal->j_state_lock);
200 finish_wait(&journal->j_wait_transaction_locked, &wait);
212 if (needed > journal->j_max_transaction_buffers) {
222 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
224 __jbd2_log_start_commit(journal, transaction->t_tid);
225 read_unlock(&journal->j_state_lock);
227 finish_wait(&journal->j_wait_transaction_locked, &wait);
238 * We must therefore ensure the necessary space in the journal
249 * a _lot_ of headroom: 1/4 of the journal plus the size of
256 if (__jbd2_log_space_left(journal) < jbd_space_needed(journal)) {
259 read_unlock(&journal->j_state_lock);
260 write_lock(&journal->j_state_lock);
261 if (__jbd2_log_space_left(journal) < jbd_space_needed(journal))
262 __jbd2_log_wait_for_space(journal);
263 write_unlock(&journal->j_state_lock);
277 __jbd2_log_space_left(journal));
278 read_unlock(&journal->j_state_lock);
305 * @journal: Journal to start transaction on.
312 * This function is visible to journal users (like ext3fs), so is not
313 * called with the journal already locked.
317 handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int gfp_mask)
322 if (!journal)
326 J_ASSERT(handle->h_transaction->t_journal == journal);
337 err = start_this_handle(journal, handle, gfp_mask);
350 handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
352 return jbd2__journal_start(journal, nblocks, GFP_NOFS);
380 journal_t *journal = transaction->t_journal;
390 read_lock(&journal->j_state_lock);
402 if (wanted > journal->j_max_transaction_buffers) {
408 if (wanted > __jbd2_log_space_left(journal)) {
422 read_unlock(&journal->j_state_lock);
445 journal_t *journal = transaction->t_journal;
460 read_lock(&journal->j_state_lock);
465 wake_up(&journal->j_wait_updates);
469 __jbd2_log_start_commit(journal, transaction->t_tid);
470 read_unlock(&journal->j_state_lock);
474 ret = start_this_handle(journal, handle, gfp_mask);
488 * @journal: Journal to establish a barrier on.
492 * journal is in a quiescent state with no updates running.
494 * The journal lock should not be held on entry.
496 void jbd2_journal_lock_updates(journal_t *journal)
500 write_lock(&journal->j_state_lock);
501 ++journal->j_barrier_count;
505 transaction_t *transaction = journal->j_running_transaction;
515 prepare_to_wait(&journal->j_wait_updates, &wait,
518 write_unlock(&journal->j_state_lock);
520 finish_wait(&journal->j_wait_updates, &wait);
521 write_lock(&journal->j_state_lock);
523 write_unlock(&journal->j_state_lock);
528 * to make sure that we serialise special journal-locked operations
531 mutex_lock(&journal->j_barrier);
535 * void jbd2_journal_unlock_updates (journal_t* journal) - release barrier
536 * @journal: Journal to release the barrier on.
540 * Should be called without the journal lock held.
542 void jbd2_journal_unlock_updates (journal_t *journal)
544 J_ASSERT(journal->j_barrier_count != 0);
546 mutex_unlock(&journal->j_barrier);
547 write_lock(&journal->j_state_lock);
548 --journal->j_barrier_count;
549 write_unlock(&journal->j_state_lock);
550 wake_up(&journal->j_wait_transaction_locked);
580 journal_t *journal;
589 journal = transaction->t_journal;
624 journal->j_committing_transaction);
680 journal->j_committing_transaction);
715 * but that should be true --- we hold the journal lock
762 spin_lock(&journal->j_list_lock);
764 spin_unlock(&journal->j_list_lock);
793 * If we are about to journal a buffer, then any revoke pending on it is
833 * When the user wants to journal a newly created buffer_head
854 journal_t *journal = transaction->t_journal;
873 spin_lock(&journal->j_list_lock);
876 (jh->b_transaction == journal->j_committing_transaction &&
899 } else if (jh->b_transaction == journal->j_committing_transaction) {
906 spin_unlock(&journal->j_list_lock);
959 * Do this first --- it can drop the journal lock, so we want to
1063 journal_t *journal = transaction->t_journal;
1094 journal->j_running_transaction);
1109 journal->j_committing_transaction);
1120 spin_lock(&journal->j_list_lock);
1122 spin_unlock(&journal->j_list_lock);
1161 journal_t *journal = transaction->t_journal;
1170 spin_lock(&journal->j_list_lock);
1212 * We are no longer going to journal this buffer.
1231 spin_unlock(&journal->j_list_lock);
1239 journal->j_committing_transaction));
1260 spin_unlock(&journal->j_list_lock);
1290 journal_t *journal = transaction->t_journal;
1340 if (handle->h_sync && journal->j_last_sync_writer != pid) {
1343 journal->j_last_sync_writer = pid;
1345 read_lock(&journal->j_state_lock);
1346 commit_time = journal->j_average_commit_time;
1347 read_unlock(&journal->j_state_lock);
1353 1000*journal->j_min_batch_time);
1355 1000*journal->j_max_batch_time);
1379 journal->j_max_transaction_buffers) ||
1388 jbd2_log_start_commit(journal, transaction->t_tid);
1406 wake_up(&journal->j_wait_updates);
1407 if (journal->j_barrier_count)
1408 wake_up(&journal->j_wait_transaction_locked);
1412 err = jbd2_log_wait_commit(journal, tid);
1422 * @journal: journal to force
1428 int jbd2_journal_force_commit(journal_t *journal)
1433 handle = jbd2_journal_start(journal, 1);
1478 * Called with j_list_lock held, and the journal may not be locked.
1504 * Called under j_list_lock. The journal may not be locked.
1558 void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
1561 spin_lock(&journal->j_list_lock);
1563 spin_unlock(&journal->j_list_lock);
1573 __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1585 spin_lock(&journal->j_list_lock);
1595 spin_unlock(&journal->j_list_lock);
1602 * @journal: journal for operation
1638 int jbd2_journal_try_to_free_buffers(journal_t *journal,
1663 __journal_try_to_free_buffer(journal, bh);
1760 static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh)
1779 write_lock(&journal->j_state_lock);
1781 spin_lock(&journal->j_list_lock);
1791 * buffer would be cleaned from the journal before T is
1818 /* OK, it must be in the journal but still not
1822 if (journal->j_running_transaction) {
1828 journal->j_running_transaction);
1830 spin_unlock(&journal->j_list_lock);
1832 write_unlock(&journal->j_state_lock);
1839 if (journal->j_committing_transaction) {
1842 journal->j_committing_transaction);
1844 spin_unlock(&journal->j_list_lock);
1846 write_unlock(&journal->j_state_lock);
1855 } else if (transaction == journal->j_committing_transaction) {
1865 if (journal->j_running_transaction && buffer_jbddirty(bh))
1866 jh->b_next_transaction = journal->j_running_transaction;
1868 spin_unlock(&journal->j_list_lock);
1870 write_unlock(&journal->j_state_lock);
1879 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
1887 spin_unlock(&journal->j_list_lock);
1889 write_unlock(&journal->j_state_lock);
1902 * @journal: journal to use for flush...
1909 void jbd2_journal_invalidatepage(journal_t *journal,
1934 may_free &= journal_unmap_buffer(journal, bh);
2037 * Called under journal->j_list_lock
2092 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2097 spin_lock(&journal->j_list_lock);
2103 spin_unlock(&journal->j_list_lock);
2113 journal_t *journal = transaction->t_journal;
2138 spin_lock(&journal->j_list_lock);
2149 journal->j_committing_transaction);
2158 spin_unlock(&journal->j_list_lock);
2183 int jbd2_journal_begin_ordered_truncate(journal_t *journal,
2196 read_lock(&journal->j_state_lock);
2197 commit_trans = journal->j_committing_transaction;
2198 read_unlock(&journal->j_state_lock);
2199 spin_lock(&journal->j_list_lock);
2201 spin_unlock(&journal->j_list_lock);
2206 jbd2_journal_abort(journal, ret);