Lines Matching defs:jh
33 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
34 static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
935 /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
936 static void jbd2_freeze_jh_data(struct journal_head *jh)
939 struct buffer_head *bh = jh2bh(jh);
941 J_EXPECT_JH(jh, buffer_uptodate(bh), "Possible IO failure.\n");
944 jbd2_buffer_frozen_trigger(jh, source, jh->b_triggers);
945 memcpy(jh->b_frozen_data, source, bh->b_size);
952 jh->b_frozen_triggers = jh->b_triggers;
966 do_get_write_access(handle_t *handle, struct journal_head *jh,
978 jbd2_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
980 JBUFFER_TRACE(jh, "entry");
982 bh = jh2bh(jh);
988 spin_lock(&jh->b_state_lock);
1009 if (buffer_dirty(bh) && jh->b_transaction) {
1015 JBUFFER_TRACE(jh, "Journalling dirty buffer");
1029 spin_unlock(&jh->b_state_lock);
1039 if (jh->b_transaction == transaction ||
1040 jh->b_next_transaction == transaction) {
1049 jh->b_modified = 0;
1056 if (!jh->b_transaction) {
1057 JBUFFER_TRACE(jh, "no transaction");
1058 J_ASSERT_JH(jh, !jh->b_next_transaction);
1059 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1061 * Make sure all stores to jh (b_modified, b_frozen_data) are
1069 * Execute buffer dirty clearing and jh->b_transaction
1073 * and jh->b_transaction is NULL).
1075 JBUFFER_TRACE(jh, "Journalling dirty buffer");
1078 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1089 if (jh->b_frozen_data) {
1090 JBUFFER_TRACE(jh, "has frozen data");
1091 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1095 JBUFFER_TRACE(jh, "owned by older transaction");
1096 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1097 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
1109 JBUFFER_TRACE(jh, "on shadow: sleep");
1110 spin_unlock(&jh->b_state_lock);
1127 if (jh->b_jlist == BJ_Metadata || force_copy) {
1128 JBUFFER_TRACE(jh, "generate frozen data");
1130 JBUFFER_TRACE(jh, "allocate memory for buffer");
1131 spin_unlock(&jh->b_state_lock);
1132 frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
1136 jh->b_frozen_data = frozen_buffer;
1138 jbd2_freeze_jh_data(jh);
1142 * Make sure all stores to jh (b_modified, b_frozen_data) are visible
1147 jh->b_next_transaction = transaction;
1150 spin_unlock(&jh->b_state_lock);
1156 jbd2_journal_cancel_revoke(handle, jh);
1162 JBUFFER_TRACE(jh, "exit");
1170 struct journal_head *jh;
1179 * are guaranteed not to oops. However the jh slab object can get freed
1181 * we see jh attached to the running transaction, we know it must stay
1182 * so until the transaction is committed. Thus jh won't be freed and
1184 * happen jh gets freed, reallocated, and attached to the transaction
1186 * and recheck jh still belongs to our bh before we return success.
1192 jh = READ_ONCE(bh->b_private);
1193 if (!jh)
1196 if (undo && !jh->b_committed_data)
1198 if (READ_ONCE(jh->b_transaction) != handle->h_transaction &&
1199 READ_ONCE(jh->b_next_transaction) != handle->h_transaction)
1204 * detect when jh went through free, realloc, attach to transaction
1211 if (unlikely(jh->b_bh != bh))
1233 struct journal_head *jh;
1256 jh = jbd2_journal_add_journal_head(bh);
1260 rc = do_get_write_access(handle, jh, 0);
1261 jbd2_journal_put_journal_head(jh);
1289 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1292 jbd2_debug(5, "journal_head %p\n", jh);
1299 JBUFFER_TRACE(jh, "entry");
1307 spin_lock(&jh->b_state_lock);
1308 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
1309 jh->b_transaction == NULL ||
1310 (jh->b_transaction == journal->j_committing_transaction &&
1311 jh->b_jlist == BJ_Forget)));
1313 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1314 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
1316 if (jh->b_transaction == NULL) {
1325 clear_buffer_dirty(jh2bh(jh));
1327 jh->b_modified = 0;
1329 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1331 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1333 } else if (jh->b_transaction == journal->j_committing_transaction) {
1335 jh->b_modified = 0;
1337 JBUFFER_TRACE(jh, "set next transaction");
1339 jh->b_next_transaction = transaction;
1342 spin_unlock(&jh->b_state_lock);
1351 JBUFFER_TRACE(jh, "cancelling revoke");
1352 jbd2_journal_cancel_revoke(handle, jh);
1354 jbd2_journal_put_journal_head(jh);
1387 struct journal_head *jh;
1396 jh = jbd2_journal_add_journal_head(bh);
1397 JBUFFER_TRACE(jh, "entry");
1404 err = do_get_write_access(handle, jh, 1);
1409 if (!jh->b_committed_data)
1410 committed_data = jbd2_alloc(jh2bh(jh)->b_size,
1413 spin_lock(&jh->b_state_lock);
1414 if (!jh->b_committed_data) {
1417 JBUFFER_TRACE(jh, "generate b_committed data");
1419 spin_unlock(&jh->b_state_lock);
1423 jh->b_committed_data = committed_data;
1425 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1427 spin_unlock(&jh->b_state_lock);
1429 jbd2_journal_put_journal_head(jh);
1449 struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
1451 if (WARN_ON_ONCE(!jh))
1453 jh->b_triggers = type;
1454 jbd2_journal_put_journal_head(jh);
1457 void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
1460 struct buffer_head *bh = jh2bh(jh);
1468 void jbd2_buffer_abort_trigger(struct journal_head *jh,
1474 triggers->t_abort(triggers, jh2bh(jh));
1504 struct journal_head *jh;
1511 * We don't grab jh reference here since the buffer must be part
1514 jh = bh2jh(bh);
1515 jbd2_debug(5, "journal_head %p\n", jh);
1516 JBUFFER_TRACE(jh, "entry");
1519 * This and the following assertions are unreliable since we may see jh
1524 if (data_race(jh->b_transaction != transaction &&
1525 jh->b_next_transaction != transaction)) {
1526 spin_lock(&jh->b_state_lock);
1527 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
1528 jh->b_next_transaction == transaction);
1529 spin_unlock(&jh->b_state_lock);
1531 if (jh->b_modified == 1) {
1533 if (data_race(jh->b_transaction == transaction &&
1534 jh->b_jlist != BJ_Metadata)) {
1535 spin_lock(&jh->b_state_lock);
1536 if (jh->b_transaction == transaction &&
1537 jh->b_jlist != BJ_Metadata)
1542 jh->b_jlist);
1543 J_ASSERT_JH(jh, jh->b_transaction != transaction ||
1544 jh->b_jlist == BJ_Metadata);
1545 spin_unlock(&jh->b_state_lock);
1551 spin_lock(&jh->b_state_lock);
1555 * Check journal aborting with @jh->b_state_lock locked,
1556 * since 'jh->b_transaction' could be replaced with
1557 * 'jh->b_next_transaction' during old transaction
1559 * assertion on 'jh->b_frozen_data == NULL'.
1565 if (jh->b_modified == 0) {
1575 jh->b_modified = 1;
1586 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1587 JBUFFER_TRACE(jh, "fastpath");
1588 if (unlikely(jh->b_transaction !=
1591 "jh->b_transaction (%llu, %p, %u) != "
1595 jh->b_transaction,
1596 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1613 if (jh->b_transaction != transaction) {
1614 JBUFFER_TRACE(jh, "already on other transaction");
1615 if (unlikely(((jh->b_transaction !=
1617 (jh->b_next_transaction != transaction))) {
1619 "bad jh for block %llu: "
1621 "jh->b_transaction (%p, %u), "
1622 "jh->b_next_transaction (%p, %u), jlist %u\n",
1626 jh->b_transaction,
1627 jh->b_transaction ?
1628 jh->b_transaction->t_tid : 0,
1629 jh->b_next_transaction,
1630 jh->b_next_transaction ?
1631 jh->b_next_transaction->t_tid : 0,
1632 jh->b_jlist);
1642 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
1644 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1646 __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
1649 spin_unlock(&jh->b_state_lock);
1651 JBUFFER_TRACE(jh, "exit");
1676 struct journal_head *jh;
1687 jh = jbd2_journal_grab_journal_head(bh);
1688 if (!jh) {
1693 spin_lock(&jh->b_state_lock);
1697 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1704 was_modified = jh->b_modified;
1710 jh->b_modified = 0;
1712 if (jh->b_transaction == transaction) {
1713 J_ASSERT_JH(jh, !jh->b_frozen_data);
1721 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1743 if (jh->b_cp_transaction) {
1744 __jbd2_journal_temp_unlink_buffer(jh);
1745 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1747 __jbd2_journal_unfile_buffer(jh);
1748 jbd2_journal_put_journal_head(jh);
1751 } else if (jh->b_transaction) {
1752 J_ASSERT_JH(jh, (jh->b_transaction ==
1756 JBUFFER_TRACE(jh, "belongs to older transaction");
1766 if (!jh->b_next_transaction) {
1768 jh->b_next_transaction = transaction;
1771 J_ASSERT(jh->b_next_transaction == transaction);
1787 if (!jh->b_cp_transaction) {
1788 JBUFFER_TRACE(jh, "belongs to none transaction");
1797 if (jbd2_journal_try_remove_checkpoint(jh) >= 0) {
1809 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1814 spin_unlock(&jh->b_state_lock);
1815 jbd2_journal_put_journal_head(jh);
1990 * jh->b_state_lock is held.
1994 __blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1997 jh->b_tnext = jh->b_tprev = jh;
1998 *list = jh;
2002 jh->b_tprev = last;
2003 jh->b_tnext = first;
2004 last->b_tnext = first->b_tprev = jh;
2014 * jh->b_state_lock is held.
2018 __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
2020 if (*list == jh) {
2021 *list = jh->b_tnext;
2022 if (*list == jh)
2025 jh->b_tprev->b_tnext = jh->b_tnext;
2026 jh->b_tnext->b_tprev = jh->b_tprev;
2040 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
2044 struct buffer_head *bh = jh2bh(jh);
2046 lockdep_assert_held(&jh->b_state_lock);
2047 transaction = jh->b_transaction;
2051 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2052 if (jh->b_jlist != BJ_None)
2053 J_ASSERT_JH(jh, transaction != NULL);
2055 switch (jh->b_jlist) {
2060 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
2074 __blist_del_buffer(list, jh);
2075 jh->b_jlist = BJ_None;
2084 * the jh reference that belonged to the transaction.
2088 static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
2090 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2091 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2093 __jbd2_journal_temp_unlink_buffer(jh);
2094 jh->b_transaction = NULL;
2097 void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
2099 struct buffer_head *bh = jh2bh(jh);
2103 spin_lock(&jh->b_state_lock);
2105 __jbd2_journal_unfile_buffer(jh);
2107 spin_unlock(&jh->b_state_lock);
2108 jbd2_journal_put_journal_head(jh);
2157 struct journal_head *jh;
2164 jh = jbd2_journal_grab_journal_head(bh);
2165 if (!jh)
2168 spin_lock(&jh->b_state_lock);
2169 if (!jh->b_transaction && !jh->b_next_transaction) {
2172 if (jh->b_cp_transaction != NULL)
2173 jbd2_journal_try_remove_checkpoint(jh);
2176 spin_unlock(&jh->b_state_lock);
2177 jbd2_journal_put_journal_head(jh);
2197 * Called under jh->b_state_lock.
2199 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
2202 struct buffer_head *bh = jh2bh(jh);
2204 if (jh->b_cp_transaction) {
2205 JBUFFER_TRACE(jh, "on running+cp transaction");
2206 __jbd2_journal_temp_unlink_buffer(jh);
2213 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
2216 JBUFFER_TRACE(jh, "on running transaction");
2217 __jbd2_journal_unfile_buffer(jh);
2218 jbd2_journal_put_journal_head(jh);
2274 struct journal_head *jh;
2285 jh = jbd2_journal_grab_journal_head(bh);
2286 if (!jh)
2291 spin_lock(&jh->b_state_lock);
2317 transaction = jh->b_transaction;
2323 if (!jh->b_cp_transaction) {
2324 JBUFFER_TRACE(jh, "not on any transaction: zap");
2330 __jbd2_journal_remove_checkpoint(jh);
2342 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
2343 may_free = __dispose_buffer(jh,
2352 JBUFFER_TRACE(jh, "give to committing trans");
2353 may_free = __dispose_buffer(jh,
2360 __jbd2_journal_remove_checkpoint(jh);
2365 JBUFFER_TRACE(jh, "on committing transaction");
2373 spin_unlock(&jh->b_state_lock);
2375 jbd2_journal_put_journal_head(jh);
2390 jh->b_next_transaction = journal->j_running_transaction;
2391 jh->b_modified = 0;
2393 spin_unlock(&jh->b_state_lock);
2395 jbd2_journal_put_journal_head(jh);
2404 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2405 JBUFFER_TRACE(jh, "on running transaction");
2406 may_free = __dispose_buffer(jh, transaction);
2418 jh->b_modified = 0;
2420 spin_unlock(&jh->b_state_lock);
2422 jbd2_journal_put_journal_head(jh);
2501 void __jbd2_journal_file_buffer(struct journal_head *jh,
2506 struct buffer_head *bh = jh2bh(jh);
2508 lockdep_assert_held(&jh->b_state_lock);
2511 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2512 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
2513 jh->b_transaction == NULL);
2515 if (jh->b_transaction && jh->b_jlist == jlist)
2534 if (jh->b_transaction)
2535 __jbd2_journal_temp_unlink_buffer(jh);
2538 jh->b_transaction = transaction;
2542 J_ASSERT_JH(jh, !jh->b_committed_data);
2543 J_ASSERT_JH(jh, !jh->b_frozen_data);
2560 __blist_add_buffer(list, jh);
2561 jh->b_jlist = jlist;
2567 void jbd2_journal_file_buffer(struct journal_head *jh,
2570 spin_lock(&jh->b_state_lock);
2572 __jbd2_journal_file_buffer(jh, transaction, jlist);
2574 spin_unlock(&jh->b_state_lock);
2584 * Called under jh->b_state_lock
2587 * and the caller has to drop jh reference through
2590 bool __jbd2_journal_refile_buffer(struct journal_head *jh)
2593 struct buffer_head *bh = jh2bh(jh);
2595 lockdep_assert_held(&jh->b_state_lock);
2596 if (jh->b_transaction)
2597 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2600 if (jh->b_next_transaction == NULL) {
2601 __jbd2_journal_unfile_buffer(jh);
2611 __jbd2_journal_temp_unlink_buffer(jh);
2615 * be holding jh reference
2617 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2621 * our jh reference and thus __jbd2_journal_file_buffer() must not
2624 WRITE_ONCE(jh->b_transaction, jh->b_next_transaction);
2625 WRITE_ONCE(jh->b_next_transaction, NULL);
2628 else if (jh->b_modified)
2632 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
2633 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2644 * The jh and bh may be freed by this call.
2646 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2650 spin_lock(&jh->b_state_lock);
2652 drop = __jbd2_journal_refile_buffer(jh);
2653 spin_unlock(&jh->b_state_lock);
2656 jbd2_journal_put_journal_head(jh);