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);
916 /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
917 static void jbd2_freeze_jh_data(struct journal_head *jh)
920 struct buffer_head *bh = jh2bh(jh);
922 J_EXPECT_JH(jh, buffer_uptodate(bh), "Possible IO failure.\n");
925 jbd2_buffer_frozen_trigger(jh, source, jh->b_triggers);
926 memcpy(jh->b_frozen_data, source, bh->b_size);
933 jh->b_frozen_triggers = jh->b_triggers;
947 do_get_write_access(handle_t *handle, struct journal_head *jh,
959 jbd2_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
961 JBUFFER_TRACE(jh, "entry");
963 bh = jh2bh(jh);
969 spin_lock(&jh->b_state_lock);
990 if (buffer_dirty(bh) && jh->b_transaction) {
996 JBUFFER_TRACE(jh, "Journalling dirty buffer");
1010 spin_unlock(&jh->b_state_lock);
1020 if (jh->b_transaction == transaction ||
1021 jh->b_next_transaction == transaction) {
1030 jh->b_modified = 0;
1037 if (!jh->b_transaction) {
1038 JBUFFER_TRACE(jh, "no transaction");
1039 J_ASSERT_JH(jh, !jh->b_next_transaction);
1040 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1042 * Make sure all stores to jh (b_modified, b_frozen_data) are
1050 * Execute buffer dirty clearing and jh->b_transaction
1054 * and jh->b_transaction is NULL).
1056 JBUFFER_TRACE(jh, "Journalling dirty buffer");
1059 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1070 if (jh->b_frozen_data) {
1071 JBUFFER_TRACE(jh, "has frozen data");
1072 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1076 JBUFFER_TRACE(jh, "owned by older transaction");
1077 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1078 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
1090 JBUFFER_TRACE(jh, "on shadow: sleep");
1091 spin_unlock(&jh->b_state_lock);
1108 if (jh->b_jlist == BJ_Metadata || force_copy) {
1109 JBUFFER_TRACE(jh, "generate frozen data");
1111 JBUFFER_TRACE(jh, "allocate memory for buffer");
1112 spin_unlock(&jh->b_state_lock);
1113 frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
1117 jh->b_frozen_data = frozen_buffer;
1119 jbd2_freeze_jh_data(jh);
1123 * Make sure all stores to jh (b_modified, b_frozen_data) are visible
1128 jh->b_next_transaction = transaction;
1131 spin_unlock(&jh->b_state_lock);
1137 jbd2_journal_cancel_revoke(handle, jh);
1143 JBUFFER_TRACE(jh, "exit");
1151 struct journal_head *jh;
1160 * are guaranteed not to oops. However the jh slab object can get freed
1162 * we see jh attached to the running transaction, we know it must stay
1163 * so until the transaction is committed. Thus jh won't be freed and
1165 * happen jh gets freed, reallocated, and attached to the transaction
1167 * and recheck jh still belongs to our bh before we return success.
1173 jh = READ_ONCE(bh->b_private);
1174 if (!jh)
1177 if (undo && !jh->b_committed_data)
1179 if (READ_ONCE(jh->b_transaction) != handle->h_transaction &&
1180 READ_ONCE(jh->b_next_transaction) != handle->h_transaction)
1185 * detect when jh went through free, realloc, attach to transaction
1192 if (unlikely(jh->b_bh != bh))
1214 struct journal_head *jh;
1237 jh = jbd2_journal_add_journal_head(bh);
1241 rc = do_get_write_access(handle, jh, 0);
1242 jbd2_journal_put_journal_head(jh);
1270 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1273 jbd2_debug(5, "journal_head %p\n", jh);
1280 JBUFFER_TRACE(jh, "entry");
1288 spin_lock(&jh->b_state_lock);
1289 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
1290 jh->b_transaction == NULL ||
1291 (jh->b_transaction == journal->j_committing_transaction &&
1292 jh->b_jlist == BJ_Forget)));
1294 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1295 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
1297 if (jh->b_transaction == NULL) {
1306 clear_buffer_dirty(jh2bh(jh));
1308 jh->b_modified = 0;
1310 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1312 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1314 } else if (jh->b_transaction == journal->j_committing_transaction) {
1316 jh->b_modified = 0;
1318 JBUFFER_TRACE(jh, "set next transaction");
1320 jh->b_next_transaction = transaction;
1323 spin_unlock(&jh->b_state_lock);
1332 JBUFFER_TRACE(jh, "cancelling revoke");
1333 jbd2_journal_cancel_revoke(handle, jh);
1335 jbd2_journal_put_journal_head(jh);
1368 struct journal_head *jh;
1377 jh = jbd2_journal_add_journal_head(bh);
1378 JBUFFER_TRACE(jh, "entry");
1385 err = do_get_write_access(handle, jh, 1);
1390 if (!jh->b_committed_data)
1391 committed_data = jbd2_alloc(jh2bh(jh)->b_size,
1394 spin_lock(&jh->b_state_lock);
1395 if (!jh->b_committed_data) {
1398 JBUFFER_TRACE(jh, "generate b_committed data");
1400 spin_unlock(&jh->b_state_lock);
1404 jh->b_committed_data = committed_data;
1406 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1408 spin_unlock(&jh->b_state_lock);
1410 jbd2_journal_put_journal_head(jh);
1430 struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
1432 if (WARN_ON_ONCE(!jh))
1434 jh->b_triggers = type;
1435 jbd2_journal_put_journal_head(jh);
1438 void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
1441 struct buffer_head *bh = jh2bh(jh);
1449 void jbd2_buffer_abort_trigger(struct journal_head *jh,
1455 triggers->t_abort(triggers, jh2bh(jh));
1485 struct journal_head *jh;
1492 * We don't grab jh reference here since the buffer must be part
1495 jh = bh2jh(bh);
1496 jbd2_debug(5, "journal_head %p\n", jh);
1497 JBUFFER_TRACE(jh, "entry");
1500 * This and the following assertions are unreliable since we may see jh
1505 if (data_race(jh->b_transaction != transaction &&
1506 jh->b_next_transaction != transaction)) {
1507 spin_lock(&jh->b_state_lock);
1508 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
1509 jh->b_next_transaction == transaction);
1510 spin_unlock(&jh->b_state_lock);
1512 if (data_race(jh->b_modified == 1)) {
1514 if (data_race(jh->b_transaction == transaction &&
1515 jh->b_jlist != BJ_Metadata)) {
1516 spin_lock(&jh->b_state_lock);
1517 if (jh->b_transaction == transaction &&
1518 jh->b_jlist != BJ_Metadata)
1523 jh->b_jlist);
1524 J_ASSERT_JH(jh, jh->b_transaction != transaction ||
1525 jh->b_jlist == BJ_Metadata);
1526 spin_unlock(&jh->b_state_lock);
1531 spin_lock(&jh->b_state_lock);
1535 * Check journal aborting with @jh->b_state_lock locked,
1536 * since 'jh->b_transaction' could be replaced with
1537 * 'jh->b_next_transaction' during old transaction
1539 * assertion on 'jh->b_frozen_data == NULL'.
1547 if (jh->b_modified == 0) {
1557 jh->b_modified = 1;
1568 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1569 JBUFFER_TRACE(jh, "fastpath");
1570 if (unlikely(jh->b_transaction !=
1573 "jh->b_transaction (%llu, %p, %u) != "
1577 jh->b_transaction,
1578 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1595 if (jh->b_transaction != transaction) {
1596 JBUFFER_TRACE(jh, "already on other transaction");
1597 if (unlikely(((jh->b_transaction !=
1599 (jh->b_next_transaction != transaction))) {
1601 "bad jh for block %llu: "
1603 "jh->b_transaction (%p, %u), "
1604 "jh->b_next_transaction (%p, %u), jlist %u\n",
1608 jh->b_transaction,
1609 jh->b_transaction ?
1610 jh->b_transaction->t_tid : 0,
1611 jh->b_next_transaction,
1612 jh->b_next_transaction ?
1613 jh->b_next_transaction->t_tid : 0,
1614 jh->b_jlist);
1624 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
1626 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1628 __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
1631 spin_unlock(&jh->b_state_lock);
1633 JBUFFER_TRACE(jh, "exit");
1658 struct journal_head *jh;
1669 jh = jbd2_journal_grab_journal_head(bh);
1670 if (!jh) {
1675 spin_lock(&jh->b_state_lock);
1679 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1686 was_modified = jh->b_modified;
1692 jh->b_modified = 0;
1694 if (jh->b_transaction == transaction) {
1695 J_ASSERT_JH(jh, !jh->b_frozen_data);
1703 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1725 if (jh->b_cp_transaction) {
1726 __jbd2_journal_temp_unlink_buffer(jh);
1727 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1729 __jbd2_journal_unfile_buffer(jh);
1730 jbd2_journal_put_journal_head(jh);
1733 } else if (jh->b_transaction) {
1734 J_ASSERT_JH(jh, (jh->b_transaction ==
1738 JBUFFER_TRACE(jh, "belongs to older transaction");
1748 if (!jh->b_next_transaction) {
1750 jh->b_next_transaction = transaction;
1753 J_ASSERT(jh->b_next_transaction == transaction);
1769 if (!jh->b_cp_transaction) {
1770 JBUFFER_TRACE(jh, "belongs to none transaction");
1779 if (jbd2_journal_try_remove_checkpoint(jh) >= 0) {
1791 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1796 spin_unlock(&jh->b_state_lock);
1797 jbd2_journal_put_journal_head(jh);
1972 * jh->b_state_lock is held.
1976 __blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1979 jh->b_tnext = jh->b_tprev = jh;
1980 *list = jh;
1984 jh->b_tprev = last;
1985 jh->b_tnext = first;
1986 last->b_tnext = first->b_tprev = jh;
1996 * jh->b_state_lock is held.
2000 __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
2002 if (*list == jh) {
2003 *list = jh->b_tnext;
2004 if (*list == jh)
2007 jh->b_tprev->b_tnext = jh->b_tnext;
2008 jh->b_tnext->b_tprev = jh->b_tprev;
2022 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
2026 struct buffer_head *bh = jh2bh(jh);
2028 lockdep_assert_held(&jh->b_state_lock);
2029 transaction = jh->b_transaction;
2033 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2034 if (jh->b_jlist != BJ_None)
2035 J_ASSERT_JH(jh, transaction != NULL);
2037 switch (jh->b_jlist) {
2042 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
2056 __blist_del_buffer(list, jh);
2057 jh->b_jlist = BJ_None;
2066 * the jh reference that belonged to the transaction.
2070 static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
2072 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2073 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2075 __jbd2_journal_temp_unlink_buffer(jh);
2076 jh->b_transaction = NULL;
2124 struct journal_head *jh;
2131 jh = jbd2_journal_grab_journal_head(bh);
2132 if (!jh)
2135 spin_lock(&jh->b_state_lock);
2136 if (!jh->b_transaction && !jh->b_next_transaction) {
2139 if (jh->b_cp_transaction != NULL)
2140 jbd2_journal_try_remove_checkpoint(jh);
2143 spin_unlock(&jh->b_state_lock);
2144 jbd2_journal_put_journal_head(jh);
2164 * Called under jh->b_state_lock.
2166 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
2169 struct buffer_head *bh = jh2bh(jh);
2171 if (jh->b_cp_transaction) {
2172 JBUFFER_TRACE(jh, "on running+cp transaction");
2173 __jbd2_journal_temp_unlink_buffer(jh);
2180 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
2183 JBUFFER_TRACE(jh, "on running transaction");
2184 __jbd2_journal_unfile_buffer(jh);
2185 jbd2_journal_put_journal_head(jh);
2241 struct journal_head *jh;
2252 jh = jbd2_journal_grab_journal_head(bh);
2253 if (!jh)
2258 spin_lock(&jh->b_state_lock);
2284 transaction = jh->b_transaction;
2290 if (!jh->b_cp_transaction) {
2291 JBUFFER_TRACE(jh, "not on any transaction: zap");
2297 __jbd2_journal_remove_checkpoint(jh);
2309 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
2310 may_free = __dispose_buffer(jh,
2319 JBUFFER_TRACE(jh, "give to committing trans");
2320 may_free = __dispose_buffer(jh,
2327 __jbd2_journal_remove_checkpoint(jh);
2332 JBUFFER_TRACE(jh, "on committing transaction");
2340 spin_unlock(&jh->b_state_lock);
2342 jbd2_journal_put_journal_head(jh);
2357 jh->b_next_transaction = journal->j_running_transaction;
2358 jh->b_modified = 0;
2360 spin_unlock(&jh->b_state_lock);
2362 jbd2_journal_put_journal_head(jh);
2371 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2372 JBUFFER_TRACE(jh, "on running transaction");
2373 may_free = __dispose_buffer(jh, transaction);
2385 jh->b_modified = 0;
2387 spin_unlock(&jh->b_state_lock);
2389 jbd2_journal_put_journal_head(jh);
2468 void __jbd2_journal_file_buffer(struct journal_head *jh,
2473 struct buffer_head *bh = jh2bh(jh);
2475 lockdep_assert_held(&jh->b_state_lock);
2478 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2479 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
2480 jh->b_transaction == NULL);
2482 if (jh->b_transaction && jh->b_jlist == jlist)
2501 if (jh->b_transaction)
2502 __jbd2_journal_temp_unlink_buffer(jh);
2505 jh->b_transaction = transaction;
2509 J_ASSERT_JH(jh, !jh->b_committed_data);
2510 J_ASSERT_JH(jh, !jh->b_frozen_data);
2527 __blist_add_buffer(list, jh);
2528 jh->b_jlist = jlist;
2534 void jbd2_journal_file_buffer(struct journal_head *jh,
2537 spin_lock(&jh->b_state_lock);
2539 __jbd2_journal_file_buffer(jh, transaction, jlist);
2541 spin_unlock(&jh->b_state_lock);
2551 * Called under jh->b_state_lock
2554 * and the caller has to drop jh reference through
2557 bool __jbd2_journal_refile_buffer(struct journal_head *jh)
2560 struct buffer_head *bh = jh2bh(jh);
2562 lockdep_assert_held(&jh->b_state_lock);
2563 if (jh->b_transaction)
2564 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2567 if (jh->b_next_transaction == NULL) {
2568 __jbd2_journal_unfile_buffer(jh);
2578 __jbd2_journal_temp_unlink_buffer(jh);
2582 * be holding jh reference
2584 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2588 * our jh reference and thus __jbd2_journal_file_buffer() must not
2591 WRITE_ONCE(jh->b_transaction, jh->b_next_transaction);
2592 WRITE_ONCE(jh->b_next_transaction, NULL);
2595 else if (jh->b_modified)
2599 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
2600 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2611 * The jh and bh may be freed by this call.
2613 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2617 spin_lock(&jh->b_state_lock);
2619 drop = __jbd2_journal_refile_buffer(jh);
2620 spin_unlock(&jh->b_state_lock);
2623 jbd2_journal_put_journal_head(jh);