Lines Matching defs:journal
68 static int jbd2_descriptor_blocks_per_trans(journal_t *journal)
70 int tag_space = journal->j_blocksize - sizeof(journal_header_t);
75 if (jbd2_journal_has_csum_v2or3(journal))
78 tags_per_block = (tag_space - 16) / journal_tag_bytes(journal);
83 return 1 + DIV_ROUND_UP(journal->j_max_transaction_buffers,
91 * RUNNING state and add it to the current journal (which should not
96 * The journal MUST be locked. We don't perform atomic mallocs on the
98 * processes trying to touch the journal while it is in transition.
102 static void jbd2_get_transaction(journal_t *journal,
105 transaction->t_journal = journal;
108 transaction->t_tid = journal->j_transaction_sequence++;
109 transaction->t_expires = jiffies + journal->j_commit_interval;
113 jbd2_descriptor_blocks_per_trans(journal) +
114 atomic_read(&journal->j_reserved_credits));
121 journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
122 add_timer(&journal->j_commit_timer);
124 J_ASSERT(journal->j_running_transaction == NULL);
125 journal->j_running_transaction = transaction;
169 static void wait_transaction_locked(journal_t *journal)
170 __releases(journal->j_state_lock)
174 tid_t tid = journal->j_running_transaction->t_tid;
176 prepare_to_wait_exclusive(&journal->j_wait_transaction_locked, &wait,
178 need_to_start = !tid_geq(journal->j_commit_request, tid);
179 read_unlock(&journal->j_state_lock);
181 jbd2_log_start_commit(journal, tid);
182 jbd2_might_wait_for_commit(journal);
184 finish_wait(&journal->j_wait_transaction_locked, &wait);
192 static void wait_transaction_switching(journal_t *journal)
193 __releases(journal->j_state_lock)
197 if (WARN_ON(!journal->j_running_transaction ||
198 journal->j_running_transaction->t_state != T_SWITCH)) {
199 read_unlock(&journal->j_state_lock);
202 prepare_to_wait_exclusive(&journal->j_wait_transaction_locked, &wait,
204 read_unlock(&journal->j_state_lock);
212 finish_wait(&journal->j_wait_transaction_locked, &wait);
215 static void sub_reserved_credits(journal_t *journal, int blocks)
217 atomic_sub(blocks, &journal->j_reserved_credits);
218 wake_up(&journal->j_wait_reserved);
227 static int add_transaction_credits(journal_t *journal, int blocks,
230 transaction_t *t = journal->j_running_transaction;
240 wait_transaction_locked(journal);
250 if (needed > journal->j_max_transaction_buffers) {
262 if (atomic_read(&journal->j_reserved_credits) + total >
263 journal->j_max_transaction_buffers) {
264 read_unlock(&journal->j_state_lock);
265 jbd2_might_wait_for_commit(journal);
266 wait_event(journal->j_wait_reserved,
267 atomic_read(&journal->j_reserved_credits) + total <=
268 journal->j_max_transaction_buffers);
272 wait_transaction_locked(journal);
283 * We must therefore ensure the necessary space in the journal
287 if (jbd2_log_space_left(journal) < journal->j_max_transaction_buffers) {
289 read_unlock(&journal->j_state_lock);
290 jbd2_might_wait_for_commit(journal);
291 write_lock(&journal->j_state_lock);
292 if (jbd2_log_space_left(journal) <
293 journal->j_max_transaction_buffers)
294 __jbd2_log_wait_for_space(journal);
295 write_unlock(&journal->j_state_lock);
303 needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits);
305 if (needed > journal->j_max_transaction_buffers / 2) {
306 sub_reserved_credits(journal, rsv_blocks);
308 read_unlock(&journal->j_state_lock);
309 jbd2_might_wait_for_commit(journal);
310 wait_event(journal->j_wait_reserved,
311 atomic_read(&journal->j_reserved_credits) + rsv_blocks
312 <= journal->j_max_transaction_buffers / 2);
320 * needed to make sure that there is enough journal space for the handle
325 static int start_this_handle(journal_t *journal, handle_t *handle,
341 if ((rsv_blocks > journal->j_max_transaction_buffers / 2) ||
342 (rsv_blocks + blocks > journal->j_max_transaction_buffers)) {
346 journal->j_max_transaction_buffers);
357 if (!data_race(journal->j_running_transaction)) {
374 * for proper journal barrier handling
377 read_lock(&journal->j_state_lock);
378 BUG_ON(journal->j_flags & JBD2_UNMOUNT);
379 if (is_journal_aborted(journal) ||
380 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
381 read_unlock(&journal->j_state_lock);
387 * Wait on the journal's transaction barrier if necessary. Specifically
391 if (!handle->h_reserved && journal->j_barrier_count) {
392 read_unlock(&journal->j_state_lock);
393 wait_event(journal->j_wait_transaction_locked,
394 journal->j_barrier_count == 0);
398 if (!journal->j_running_transaction) {
399 read_unlock(&journal->j_state_lock);
402 write_lock(&journal->j_state_lock);
403 if (!journal->j_running_transaction &&
404 (handle->h_reserved || !journal->j_barrier_count)) {
405 jbd2_get_transaction(journal, new_transaction);
408 write_unlock(&journal->j_state_lock);
412 transaction = journal->j_running_transaction;
416 if (add_transaction_credits(journal, blocks, rsv_blocks))
422 * and journal space. But we still have to wait while running
427 wait_transaction_switching(journal);
430 sub_reserved_credits(journal, blocks);
447 jbd2_log_space_left(journal));
448 read_unlock(&journal->j_state_lock);
451 rwsem_acquire_read(&journal->j_trans_commit_map, 0, 0, _THIS_IP_);
473 handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,
480 if (!journal)
484 J_ASSERT(handle->h_transaction->t_journal == journal);
490 journal->j_revoke_records_per_block);
503 rsv_handle->h_journal = journal;
508 err = start_this_handle(journal, handle, gfp_mask);
517 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
528 * @journal: Journal to start transaction on.
534 * handle with rsv_blocks reserved blocks in the journal. This handle is
545 handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
547 return jbd2__journal_start(journal, nblocks, 0, 0, GFP_NOFS, 0, 0);
553 journal_t *journal = handle->h_journal;
556 sub_reserved_credits(journal, handle->h_total_credits);
563 journal_t *journal = handle->h_journal;
566 read_lock(&journal->j_state_lock);
567 __jbd2_journal_unreserve_handle(handle, journal->j_running_transaction);
568 read_unlock(&journal->j_state_lock);
582 * block on journal commit, checkpointing, or similar stuff. It can block on
583 * memory allocation or frozen journal though.
590 journal_t *journal = handle->h_journal;
612 ret = start_this_handle(journal, handle, GFP_NOFS);
614 handle->h_journal = journal;
620 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
651 journal_t *journal;
657 journal = transaction->t_journal;
661 read_lock(&journal->j_state_lock);
672 journal->j_revoke_records_per_block) -
675 journal->j_revoke_records_per_block);
680 if (wanted > journal->j_max_transaction_buffers) {
687 trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,
703 read_unlock(&journal->j_state_lock);
710 journal_t *journal = transaction->t_journal;
725 int rr_per_blk = journal->j_revoke_records_per_block;
742 wake_up(&journal->j_wait_updates);
744 rwsem_release(&journal->j_trans_commit_map, _THIS_IP_);
773 journal_t *journal;
782 journal = transaction->t_journal;
797 read_lock(&journal->j_state_lock);
798 need_to_start = !tid_geq(journal->j_commit_request, tid);
799 read_unlock(&journal->j_state_lock);
801 jbd2_log_start_commit(journal, tid);
804 journal->j_revoke_records_per_block);
806 ret = start_this_handle(journal, handle, gfp_mask);
807 trace_jbd2_handle_restart(journal->j_fs_dev->bd_dev,
824 * @journal: Journal to establish a barrier on.
828 * journal is in a quiescent state with no updates running.
830 * The journal lock should not be held on entry.
832 void jbd2_journal_lock_updates(journal_t *journal)
836 jbd2_might_wait_for_commit(journal);
838 write_lock(&journal->j_state_lock);
839 ++journal->j_barrier_count;
842 if (atomic_read(&journal->j_reserved_credits)) {
843 write_unlock(&journal->j_state_lock);
844 wait_event(journal->j_wait_reserved,
845 atomic_read(&journal->j_reserved_credits) == 0);
846 write_lock(&journal->j_state_lock);
851 transaction_t *transaction = journal->j_running_transaction;
857 prepare_to_wait(&journal->j_wait_updates, &wait,
861 finish_wait(&journal->j_wait_updates, &wait);
865 write_unlock(&journal->j_state_lock);
867 finish_wait(&journal->j_wait_updates, &wait);
868 write_lock(&journal->j_state_lock);
870 write_unlock(&journal->j_state_lock);
875 * to make sure that we serialise special journal-locked operations
878 mutex_lock(&journal->j_barrier);
883 * @journal: Journal to release the barrier on.
887 * Should be called without the journal lock held.
889 void jbd2_journal_unlock_updates (journal_t *journal)
891 J_ASSERT(journal->j_barrier_count != 0);
893 mutex_unlock(&journal->j_barrier);
894 write_lock(&journal->j_state_lock);
895 --journal->j_barrier_count;
896 write_unlock(&journal->j_state_lock);
897 wake_up_all(&journal->j_wait_transaction_locked);
949 journal_t *journal;
954 journal = transaction->t_journal;
1044 spin_lock(&journal->j_list_lock);
1048 * assignment under journal->j_list_lock locked to
1057 spin_unlock(&journal->j_list_lock);
1075 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
1131 * If we are about to journal a buffer, then any revoke pending on it is
1231 * When the user wants to journal a newly created buffer_head
1252 journal_t *journal;
1260 journal = transaction->t_journal;
1274 (jh->b_transaction == journal->j_committing_transaction &&
1294 spin_lock(&journal->j_list_lock);
1296 spin_unlock(&journal->j_list_lock);
1297 } else if (jh->b_transaction == journal->j_committing_transaction) {
1302 spin_lock(&journal->j_list_lock);
1304 spin_unlock(&journal->j_list_lock);
1364 * Do this first --- it can drop the journal lock, so we want to
1467 journal_t *journal;
1514 journal = transaction->t_journal;
1519 * Check journal aborting with @jh->b_state_lock locked,
1522 * committing if journal aborted, which may fail
1553 journal->j_running_transaction)) {
1556 "journal->j_running_transaction (%p, %u)\n",
1557 journal->j_devname,
1561 journal->j_running_transaction,
1562 journal->j_running_transaction ?
1563 journal->j_running_transaction->t_tid : 0);
1580 journal->j_committing_transaction)) ||
1587 journal->j_devname,
1609 spin_lock(&journal->j_list_lock);
1611 spin_unlock(&journal->j_list_lock);
1639 journal_t *journal;
1647 journal = transaction->t_journal;
1695 * We are no longer going to journal this buffer.
1706 spin_lock(&journal->j_list_lock);
1714 spin_unlock(&journal->j_list_lock);
1717 journal->j_committing_transaction));
1731 spin_lock(&journal->j_list_lock);
1733 spin_unlock(&journal->j_list_lock);
1750 spin_lock(&journal->j_list_lock);
1753 spin_unlock(&journal->j_list_lock);
1763 spin_unlock(&journal->j_list_lock);
1775 spin_unlock(&journal->j_list_lock);
1807 journal_t *journal;
1827 journal = transaction->t_journal;
1834 trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
1871 if (handle->h_sync && journal->j_last_sync_writer != pid &&
1872 journal->j_max_batch_time) {
1875 journal->j_last_sync_writer = pid;
1877 read_lock(&journal->j_state_lock);
1878 commit_time = journal->j_average_commit_time;
1879 read_unlock(&journal->j_state_lock);
1885 1000*journal->j_min_batch_time);
1887 1000*journal->j_max_batch_time);
1914 jbd2_log_start_commit(journal, tid);
1933 err = jbd2_log_wait_commit(journal, tid);
1977 * Called with j_list_lock held, and the journal may not be locked.
2062 void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
2069 spin_lock(&journal->j_list_lock);
2071 spin_unlock(&journal->j_list_lock);
2083 __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
2095 spin_lock(&journal->j_list_lock);
2101 spin_unlock(&journal->j_list_lock);
2108 * @journal: journal for operation
2140 int jbd2_journal_try_to_free_buffers(journal_t *journal, struct page *page)
2163 __journal_try_to_free_buffer(journal, bh);
2258 static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
2278 write_lock(&journal->j_state_lock);
2280 spin_lock(&journal->j_list_lock);
2286 * buffer would be cleaned from the journal before T is
2322 /* OK, it must be in the journal but still not
2326 if (journal->j_running_transaction) {
2332 journal->j_running_transaction);
2339 if (journal->j_committing_transaction) {
2342 journal->j_committing_transaction);
2352 } else if (transaction == journal->j_committing_transaction) {
2360 spin_unlock(&journal->j_list_lock);
2362 write_unlock(&journal->j_state_lock);
2377 if (journal->j_running_transaction && buffer_jbddirty(bh))
2378 jh->b_next_transaction = journal->j_running_transaction;
2380 spin_unlock(&journal->j_list_lock);
2382 write_unlock(&journal->j_state_lock);
2392 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2407 spin_unlock(&journal->j_list_lock);
2409 write_unlock(&journal->j_state_lock);
2425 * @journal: journal to use for flush...
2435 int jbd2_journal_invalidatepage(journal_t *journal,
2469 ret = journal_unmap_buffer(journal, bh, partial_page);
2635 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2640 spin_lock(&journal->j_list_lock);
2643 spin_unlock(&journal->j_list_lock);
2655 journal_t *journal;
2659 journal = transaction->t_journal;
2664 spin_lock(&journal->j_list_lock);
2692 journal->j_committing_transaction);
2701 spin_unlock(&journal->j_list_lock);
2741 int jbd2_journal_begin_ordered_truncate(journal_t *journal,
2754 read_lock(&journal->j_state_lock);
2755 commit_trans = journal->j_committing_transaction;
2756 read_unlock(&journal->j_state_lock);
2757 spin_lock(&journal->j_list_lock);
2759 spin_unlock(&journal->j_list_lock);
2764 jbd2_journal_abort(journal, ret);