Lines Matching defs:journal
34 * RUNNING state and add it to the current journal (which should not
39 * The journal MUST be locked. We don't perform atomic mallocs on the
41 * processes trying to touch the journal while it is in transition.
47 get_transaction(hfsplus_jbd_t *journal, hfsplus_transaction_t *transaction)
49 transaction->t_journal = journal;
51 transaction->t_tid = journal->j_transaction_sequence++;
52 transaction->t_expires = jiffies + journal->j_commit_interval;
56 journal->j_commit_timer->expires = transaction->t_expires;
57 add_timer(journal->j_commit_timer);
59 HFSPLUS_J_ASSERT(journal->j_running_transaction == NULL);
60 journal->j_running_transaction = transaction;
75 * needed to make sure that there is enough journal space for the handle
80 static int start_this_handle(hfsplus_jbd_t *journal, hfsplus_jbd_handle_t *handle)
88 if (nblocks > journal->j_max_transaction_buffers) {
91 journal->j_max_transaction_buffers);
97 if (!journal->j_running_transaction) {
113 * for proper journal barrier handling
115 spin_lock(&journal->j_state_lock);
117 if (is_hfsplus_jbd_aborted(journal) ||
118 (journal->j_errno != 0 && !(journal->j_flags & JFS_ACK_ERR))) {
119 spin_unlock(&journal->j_state_lock);
124 /* Wait on the journal's transaction barrier if necessary */
125 if (journal->j_barrier_count) {
126 spin_unlock(&journal->j_state_lock);
127 wait_event(journal->j_wait_transaction_locked,
128 journal->j_barrier_count == 0);
132 if (!journal->j_running_transaction) {
134 spin_unlock(&journal->j_state_lock);
137 get_transaction(journal, new_transaction);
141 transaction = journal->j_running_transaction;
150 prepare_to_wait(&journal->j_wait_transaction_locked,
152 spin_unlock(&journal->j_state_lock);
154 finish_wait(&journal->j_wait_transaction_locked, &wait);
166 if (needed > journal->j_max_transaction_buffers) {
176 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
178 __hfsplus__log_start_commit(journal, transaction->t_tid);
179 spin_unlock(&journal->j_state_lock);
181 finish_wait(&journal->j_wait_transaction_locked, &wait);
192 * We must therefore ensure the necessary space in the journal
203 * a _lot_ of headroom: 1/4 of the journal plus the size of
210 if (__hfsplus__log_space_left(journal) < hfsplus_jbd_space_needed(journal)) {
213 __hfsplus__log_wait_for_space(journal);
226 __hfsplus__log_space_left(journal));
228 spin_unlock(&journal->j_state_lock);
249 * @journal: Journal to start transaction on.
256 * This function is visible to journal users (like ext3fs), so is not
257 * called with the journal already locked.
261 hfsplus_jbd_handle_t *hfsplus_jbd_start(hfsplus_jbd_t *journal, int nblocks, hfsplus_handle_t *hfsplus_handle)
266 if (!journal)
270 HFSPLUS_J_ASSERT(tmp_hfsplus_handle->handle->h_transaction->t_journal == journal);
281 err = start_this_handle(journal, hfsplus_handle->handle);
313 hfsplus_jbd_t *journal = transaction->t_journal;
323 spin_lock(&journal->j_state_lock);
335 if (wanted > journal->j_max_transaction_buffers) {
341 if (wanted > __hfsplus__log_space_left(journal)) {
355 spin_unlock(&journal->j_state_lock);
379 hfsplus_jbd_t *journal = transaction->t_journal;
396 spin_lock(&journal->j_state_lock);
402 wake_up(&journal->j_wait_updates);
406 __hfsplus__log_start_commit(journal, transaction->t_tid);
407 spin_unlock(&journal->j_state_lock);
410 ret = start_this_handle(journal, handle);
417 * @journal: Journal to establish a barrier on.
421 * journal is in a quiescent state with no updates running.
423 * The journal lock should not be held on entry.
425 void hfsplus_jbd_lock_updates(hfsplus_jbd_t *journal)
429 spin_lock(&journal->j_state_lock);
430 ++journal->j_barrier_count;
434 hfsplus_transaction_t *transaction = journal->j_running_transaction;
444 prepare_to_wait(&journal->j_wait_updates, &wait,
447 spin_unlock(&journal->j_state_lock);
449 finish_wait(&journal->j_wait_updates, &wait);
450 spin_lock(&journal->j_state_lock);
452 spin_unlock(&journal->j_state_lock);
457 * to make sure that we serialise special journal-locked operations
460 down(&journal->j_barrier);
464 * void hfsplus_jbd_unlock_updates (hfsplus_jbd_t* journal) - release barrier
465 * @journal: Journal to release the barrier on.
469 * Should be called without the journal lock held.
471 void hfsplus_jbd_unlock_updates (hfsplus_jbd_t *journal)
473 HFSPLUS_J_ASSERT(journal->j_barrier_count != 0);
475 up(&journal->j_barrier);
476 spin_lock(&journal->j_state_lock);
477 --journal->j_barrier_count;
478 spin_unlock(&journal->j_state_lock);
479 wake_up(&journal->j_wait_transaction_locked);
488 * The caller should already hold the journal lock and
497 * --- ie. data, or not part of this journal --- then
499 * move the dirty bit to the journal's own internal
528 hfsplus_jbd_t *journal;
537 journal = transaction->t_journal;
572 journal->j_committing_transaction);
620 journal->j_committing_transaction);
655 * but that should be true --- we hold the journal lock
701 spin_lock(&journal->j_list_lock);
703 spin_unlock(&journal->j_list_lock);
723 * If we are about to journal a buffer, then any revoke pending on it is
762 * When the user wants to journal a newly created buffer_head
783 hfsplus_jbd_t *journal = transaction->t_journal;
802 spin_lock(&journal->j_list_lock);
805 (jh->b_transaction == journal->j_committing_transaction &&
815 } else if (jh->b_transaction == journal->j_committing_transaction) {
819 spin_unlock(&journal->j_list_lock);
872 * Do this first --- it can drop the journal lock, so we want to
929 hfsplus_jbd_t *journal = handle->h_transaction->t_journal;
967 spin_lock(&journal->j_list_lock);
973 journal->j_committing_transaction);
978 * in data=journal mode. The buffer's transaction has
986 * It may be too late to journal the data. Simply
1023 spin_unlock(&journal->j_list_lock);
1028 spin_lock(&journal->j_list_lock);
1066 spin_unlock(&journal->j_list_lock);
1099 hfsplus_jbd_t *journal = transaction->t_journal;
1131 journal->j_running_transaction);
1147 journal->j_committing_transaction);
1159 spin_lock(&journal->j_list_lock);
1161 spin_unlock(&journal->j_list_lock);
1201 hfsplus_jbd_t *journal = transaction->t_journal;
1209 spin_lock(&journal->j_list_lock);
1243 * We are no longer going to journal this buffer.
1262 spin_unlock(&journal->j_list_lock);
1270 journal->j_committing_transaction));
1285 spin_unlock(&journal->j_list_lock);
1315 hfsplus_jbd_t *journal = transaction->t_journal;
1353 spin_lock(&journal->j_state_lock);
1358 wake_up(&journal->j_wait_updates);
1359 if (journal->j_barrier_count)
1360 wake_up(&journal->j_wait_transaction_locked);
1371 journal->j_max_transaction_buffers ||
1382 __hfsplus__log_start_commit(journal, transaction->t_tid);
1383 spin_unlock(&journal->j_state_lock);
1390 err = hfsplus_jbd_log_wait_commit(journal, tid);
1393 spin_unlock(&journal->j_state_lock);
1401 * @journal: journal to force
1407 int hfsplus_jbd_force_commit(hfsplus_jbd_t *journal)
1412 hfsplus_handle.handle = hfsplus_jbd_start(journal, 1, &hfsplus_handle);
1457 * Called with j_list_lock held, and the journal may not be locked.
1483 * Called under j_list_lock. The journal may not be locked.
1543 void hfsplus_jbd_unfile_buffer(hfsplus_jbd_t *journal, struct hfsplus_jbd_head *jh)
1546 spin_lock(&journal->j_list_lock);
1548 spin_unlock(&journal->j_list_lock);
1558 __hfsplus_jbd_try_to_free_buffer(hfsplus_jbd_t *journal, struct buffer_head *bh)
1570 spin_lock(&journal->j_list_lock);
1588 spin_unlock(&journal->j_list_lock);
1596 * @journal: journal for operation
1628 int hfsplus_jbd_try_to_free_buffers(hfsplus_jbd_t *journal,
1652 __hfsplus_jbd_try_to_free_buffer(journal, bh);
1742 static int hfsplus_jbd_unmap_buffer(hfsplus_jbd_t *journal, struct buffer_head *bh)
1760 spin_lock(&journal->j_state_lock);
1762 spin_lock(&journal->j_list_lock);
1784 /* OK, it must be in the journal but still not
1788 if (journal->j_running_transaction) {
1794 journal->j_running_transaction);
1796 spin_unlock(&journal->j_list_lock);
1798 spin_unlock(&journal->j_state_lock);
1805 if (journal->j_committing_transaction) {
1808 journal->j_committing_transaction);
1810 spin_unlock(&journal->j_list_lock);
1812 spin_unlock(&journal->j_state_lock);
1821 } else if (transaction == journal->j_committing_transaction) {
1840 journal->j_running_transaction);
1844 spin_unlock(&journal->j_list_lock);
1846 spin_unlock(&journal->j_state_lock);
1855 HFSPLUS_J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
1862 spin_unlock(&journal->j_list_lock);
1864 spin_unlock(&journal->j_state_lock);
1877 * @journal: journal to use for flush...
1885 int hfsplus_jbd_invalidatepage(hfsplus_jbd_t *journal,
1910 may_free &= hfsplus_jbd_unmap_buffer(journal, bh);
2016 * Called under journal->j_list_lock
2065 void hfsplus_jbd_refile_buffer(hfsplus_jbd_t *journal, struct hfsplus_jbd_head *jh)
2070 spin_lock(&journal->j_list_lock);
2076 spin_unlock(&journal->j_list_lock);