Lines Matching refs:jh
33 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
34 static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
909 /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
910 static void jbd2_freeze_jh_data(struct journal_head *jh)
915 struct buffer_head *bh = jh2bh(jh);
917 J_EXPECT_JH(jh, buffer_uptodate(bh), "Possible IO failure.\n");
922 jbd2_buffer_frozen_trigger(jh, source + offset, jh->b_triggers);
923 memcpy(jh->b_frozen_data, source + offset, bh->b_size);
930 jh->b_frozen_triggers = jh->b_triggers;
944 do_get_write_access(handle_t *handle, struct journal_head *jh,
956 jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
958 JBUFFER_TRACE(jh, "entry");
960 bh = jh2bh(jh);
966 spin_lock(&jh->b_state_lock);
987 if (buffer_dirty(bh) && jh->b_transaction) {
993 JBUFFER_TRACE(jh, "Journalling dirty buffer");
1007 spin_unlock(&jh->b_state_lock);
1017 if (jh->b_transaction == transaction ||
1018 jh->b_next_transaction == transaction) {
1027 jh->b_modified = 0;
1034 if (!jh->b_transaction) {
1035 JBUFFER_TRACE(jh, "no transaction");
1036 J_ASSERT_JH(jh, !jh->b_next_transaction);
1037 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1039 * Make sure all stores to jh (b_modified, b_frozen_data) are
1047 * Execute buffer dirty clearing and jh->b_transaction
1051 * and jh->b_transaction is NULL).
1053 JBUFFER_TRACE(jh, "Journalling dirty buffer");
1056 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1067 if (jh->b_frozen_data) {
1068 JBUFFER_TRACE(jh, "has frozen data");
1069 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1073 JBUFFER_TRACE(jh, "owned by older transaction");
1074 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1075 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
1087 JBUFFER_TRACE(jh, "on shadow: sleep");
1088 spin_unlock(&jh->b_state_lock);
1105 if (jh->b_jlist == BJ_Metadata || force_copy) {
1106 JBUFFER_TRACE(jh, "generate frozen data");
1108 JBUFFER_TRACE(jh, "allocate memory for buffer");
1109 spin_unlock(&jh->b_state_lock);
1110 frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
1114 jh->b_frozen_data = frozen_buffer;
1116 jbd2_freeze_jh_data(jh);
1120 * Make sure all stores to jh (b_modified, b_frozen_data) are visible
1125 jh->b_next_transaction = transaction;
1128 spin_unlock(&jh->b_state_lock);
1134 jbd2_journal_cancel_revoke(handle, jh);
1140 JBUFFER_TRACE(jh, "exit");
1148 struct journal_head *jh;
1157 * are guaranteed not to oops. However the jh slab object can get freed
1159 * we see jh attached to the running transaction, we know it must stay
1160 * so until the transaction is committed. Thus jh won't be freed and
1162 * happen jh gets freed, reallocated, and attached to the transaction
1164 * and recheck jh still belongs to our bh before we return success.
1170 jh = READ_ONCE(bh->b_private);
1171 if (!jh)
1174 if (undo && !jh->b_committed_data)
1176 if (READ_ONCE(jh->b_transaction) != handle->h_transaction &&
1177 READ_ONCE(jh->b_next_transaction) != handle->h_transaction)
1182 * detect when jh went through free, realloc, attach to transaction
1189 if (unlikely(jh->b_bh != bh))
1211 struct journal_head *jh;
1220 jh = jbd2_journal_add_journal_head(bh);
1224 rc = do_get_write_access(handle, jh, 0);
1225 jbd2_journal_put_journal_head(jh);
1253 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1256 jbd_debug(5, "journal_head %p\n", jh);
1263 JBUFFER_TRACE(jh, "entry");
1271 spin_lock(&jh->b_state_lock);
1272 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
1273 jh->b_transaction == NULL ||
1274 (jh->b_transaction == journal->j_committing_transaction &&
1275 jh->b_jlist == BJ_Forget)));
1277 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1278 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
1280 if (jh->b_transaction == NULL) {
1289 clear_buffer_dirty(jh2bh(jh));
1291 jh->b_modified = 0;
1293 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1295 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1297 } else if (jh->b_transaction == journal->j_committing_transaction) {
1299 jh->b_modified = 0;
1301 JBUFFER_TRACE(jh, "set next transaction");
1303 jh->b_next_transaction = transaction;
1306 spin_unlock(&jh->b_state_lock);
1315 JBUFFER_TRACE(jh, "cancelling revoke");
1316 jbd2_journal_cancel_revoke(handle, jh);
1318 jbd2_journal_put_journal_head(jh);
1351 struct journal_head *jh;
1360 jh = jbd2_journal_add_journal_head(bh);
1361 JBUFFER_TRACE(jh, "entry");
1368 err = do_get_write_access(handle, jh, 1);
1373 if (!jh->b_committed_data)
1374 committed_data = jbd2_alloc(jh2bh(jh)->b_size,
1377 spin_lock(&jh->b_state_lock);
1378 if (!jh->b_committed_data) {
1381 JBUFFER_TRACE(jh, "generate b_committed data");
1383 spin_unlock(&jh->b_state_lock);
1387 jh->b_committed_data = committed_data;
1389 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1391 spin_unlock(&jh->b_state_lock);
1393 jbd2_journal_put_journal_head(jh);
1413 struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
1415 if (WARN_ON(!jh))
1417 jh->b_triggers = type;
1418 jbd2_journal_put_journal_head(jh);
1421 void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
1424 struct buffer_head *bh = jh2bh(jh);
1432 void jbd2_buffer_abort_trigger(struct journal_head *jh,
1438 triggers->t_abort(triggers, jh2bh(jh));
1468 struct journal_head *jh;
1475 * We don't grab jh reference here since the buffer must be part
1478 jh = bh2jh(bh);
1479 jbd_debug(5, "journal_head %p\n", jh);
1480 JBUFFER_TRACE(jh, "entry");
1483 * This and the following assertions are unreliable since we may see jh
1488 if (data_race(jh->b_transaction != transaction &&
1489 jh->b_next_transaction != transaction)) {
1490 spin_lock(&jh->b_state_lock);
1491 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
1492 jh->b_next_transaction == transaction);
1493 spin_unlock(&jh->b_state_lock);
1495 if (jh->b_modified == 1) {
1497 if (data_race(jh->b_transaction == transaction &&
1498 jh->b_jlist != BJ_Metadata)) {
1499 spin_lock(&jh->b_state_lock);
1500 if (jh->b_transaction == transaction &&
1501 jh->b_jlist != BJ_Metadata)
1506 jh->b_jlist);
1507 J_ASSERT_JH(jh, jh->b_transaction != transaction ||
1508 jh->b_jlist == BJ_Metadata);
1509 spin_unlock(&jh->b_state_lock);
1515 spin_lock(&jh->b_state_lock);
1519 * Check journal aborting with @jh->b_state_lock locked,
1520 * since 'jh->b_transaction' could be replaced with
1521 * 'jh->b_next_transaction' during old transaction
1523 * assertion on 'jh->b_frozen_data == NULL'.
1529 if (jh->b_modified == 0) {
1539 jh->b_modified = 1;
1550 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1551 JBUFFER_TRACE(jh, "fastpath");
1552 if (unlikely(jh->b_transaction !=
1555 "jh->b_transaction (%llu, %p, %u) != "
1559 jh->b_transaction,
1560 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1577 if (jh->b_transaction != transaction) {
1578 JBUFFER_TRACE(jh, "already on other transaction");
1579 if (unlikely(((jh->b_transaction !=
1581 (jh->b_next_transaction != transaction))) {
1583 "bad jh for block %llu: "
1585 "jh->b_transaction (%p, %u), "
1586 "jh->b_next_transaction (%p, %u), jlist %u\n",
1590 jh->b_transaction,
1591 jh->b_transaction ?
1592 jh->b_transaction->t_tid : 0,
1593 jh->b_next_transaction,
1594 jh->b_next_transaction ?
1595 jh->b_next_transaction->t_tid : 0,
1596 jh->b_jlist);
1606 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
1608 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1610 __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
1613 spin_unlock(&jh->b_state_lock);
1615 JBUFFER_TRACE(jh, "exit");
1640 struct journal_head *jh;
1651 jh = jbd2_journal_grab_journal_head(bh);
1652 if (!jh) {
1657 spin_lock(&jh->b_state_lock);
1661 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1668 was_modified = jh->b_modified;
1674 jh->b_modified = 0;
1676 if (jh->b_transaction == transaction) {
1677 J_ASSERT_JH(jh, !jh->b_frozen_data);
1685 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1707 if (jh->b_cp_transaction) {
1708 __jbd2_journal_temp_unlink_buffer(jh);
1709 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1711 __jbd2_journal_unfile_buffer(jh);
1712 jbd2_journal_put_journal_head(jh);
1715 } else if (jh->b_transaction) {
1716 J_ASSERT_JH(jh, (jh->b_transaction ==
1720 JBUFFER_TRACE(jh, "belongs to older transaction");
1730 if (!jh->b_next_transaction) {
1732 jh->b_next_transaction = transaction;
1735 J_ASSERT(jh->b_next_transaction == transaction);
1751 if (!jh->b_cp_transaction) {
1752 JBUFFER_TRACE(jh, "belongs to none transaction");
1762 __jbd2_journal_remove_checkpoint(jh);
1774 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1779 spin_unlock(&jh->b_state_lock);
1780 jbd2_journal_put_journal_head(jh);
1955 * jh->b_state_lock is held.
1959 __blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1962 jh->b_tnext = jh->b_tprev = jh;
1963 *list = jh;
1967 jh->b_tprev = last;
1968 jh->b_tnext = first;
1969 last->b_tnext = first->b_tprev = jh;
1979 * jh->b_state_lock is held.
1983 __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
1985 if (*list == jh) {
1986 *list = jh->b_tnext;
1987 if (*list == jh)
1990 jh->b_tprev->b_tnext = jh->b_tnext;
1991 jh->b_tnext->b_tprev = jh->b_tprev;
2005 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
2009 struct buffer_head *bh = jh2bh(jh);
2011 lockdep_assert_held(&jh->b_state_lock);
2012 transaction = jh->b_transaction;
2016 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2017 if (jh->b_jlist != BJ_None)
2018 J_ASSERT_JH(jh, transaction != NULL);
2020 switch (jh->b_jlist) {
2025 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
2039 __blist_del_buffer(list, jh);
2040 jh->b_jlist = BJ_None;
2049 * the jh reference that belonged to the transaction.
2053 static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
2055 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2056 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2058 __jbd2_journal_temp_unlink_buffer(jh);
2059 jh->b_transaction = NULL;
2062 void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
2064 struct buffer_head *bh = jh2bh(jh);
2068 spin_lock(&jh->b_state_lock);
2070 __jbd2_journal_unfile_buffer(jh);
2072 spin_unlock(&jh->b_state_lock);
2073 jbd2_journal_put_journal_head(jh);
2080 * Called under jh->b_state_lock
2085 struct journal_head *jh;
2087 jh = bh2jh(bh);
2092 if (jh->b_next_transaction != NULL || jh->b_transaction != NULL)
2096 if (jh->b_cp_transaction != NULL) {
2098 JBUFFER_TRACE(jh, "remove from checkpoint list");
2099 __jbd2_journal_remove_checkpoint(jh);
2151 struct journal_head *jh;
2158 jh = jbd2_journal_grab_journal_head(bh);
2159 if (!jh)
2162 spin_lock(&jh->b_state_lock);
2164 spin_unlock(&jh->b_state_lock);
2165 jbd2_journal_put_journal_head(jh);
2185 * Called under jh->b_state_lock.
2187 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
2190 struct buffer_head *bh = jh2bh(jh);
2192 if (jh->b_cp_transaction) {
2193 JBUFFER_TRACE(jh, "on running+cp transaction");
2194 __jbd2_journal_temp_unlink_buffer(jh);
2201 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
2204 JBUFFER_TRACE(jh, "on running transaction");
2205 __jbd2_journal_unfile_buffer(jh);
2206 jbd2_journal_put_journal_head(jh);
2262 struct journal_head *jh;
2273 jh = jbd2_journal_grab_journal_head(bh);
2274 if (!jh)
2279 spin_lock(&jh->b_state_lock);
2305 transaction = jh->b_transaction;
2311 if (!jh->b_cp_transaction) {
2312 JBUFFER_TRACE(jh, "not on any transaction: zap");
2318 __jbd2_journal_remove_checkpoint(jh);
2330 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
2331 may_free = __dispose_buffer(jh,
2340 JBUFFER_TRACE(jh, "give to committing trans");
2341 may_free = __dispose_buffer(jh,
2348 __jbd2_journal_remove_checkpoint(jh);
2353 JBUFFER_TRACE(jh, "on committing transaction");
2361 spin_unlock(&jh->b_state_lock);
2363 jbd2_journal_put_journal_head(jh);
2378 jh->b_next_transaction = journal->j_running_transaction;
2379 jh->b_modified = 0;
2381 spin_unlock(&jh->b_state_lock);
2383 jbd2_journal_put_journal_head(jh);
2392 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2393 JBUFFER_TRACE(jh, "on running transaction");
2394 may_free = __dispose_buffer(jh, transaction);
2406 jh->b_modified = 0;
2408 spin_unlock(&jh->b_state_lock);
2410 jbd2_journal_put_journal_head(jh);
2490 void __jbd2_journal_file_buffer(struct journal_head *jh,
2495 struct buffer_head *bh = jh2bh(jh);
2497 lockdep_assert_held(&jh->b_state_lock);
2500 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2501 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
2502 jh->b_transaction == NULL);
2504 if (jh->b_transaction && jh->b_jlist == jlist)
2523 if (jh->b_transaction)
2524 __jbd2_journal_temp_unlink_buffer(jh);
2527 jh->b_transaction = transaction;
2531 J_ASSERT_JH(jh, !jh->b_committed_data);
2532 J_ASSERT_JH(jh, !jh->b_frozen_data);
2549 __blist_add_buffer(list, jh);
2550 jh->b_jlist = jlist;
2556 void jbd2_journal_file_buffer(struct journal_head *jh,
2559 spin_lock(&jh->b_state_lock);
2561 __jbd2_journal_file_buffer(jh, transaction, jlist);
2563 spin_unlock(&jh->b_state_lock);
2573 * Called under jh->b_state_lock
2576 * and the caller has to drop jh reference through
2579 bool __jbd2_journal_refile_buffer(struct journal_head *jh)
2582 struct buffer_head *bh = jh2bh(jh);
2584 lockdep_assert_held(&jh->b_state_lock);
2585 if (jh->b_transaction)
2586 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2589 if (jh->b_next_transaction == NULL) {
2590 __jbd2_journal_unfile_buffer(jh);
2600 __jbd2_journal_temp_unlink_buffer(jh);
2604 * be holding jh reference
2606 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2610 * our jh reference and thus __jbd2_journal_file_buffer() must not
2613 WRITE_ONCE(jh->b_transaction, jh->b_next_transaction);
2614 WRITE_ONCE(jh->b_next_transaction, NULL);
2617 else if (jh->b_modified)
2621 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
2622 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2633 * The jh and bh may be freed by this call.
2635 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2639 spin_lock(&jh->b_state_lock);
2641 drop = __jbd2_journal_refile_buffer(jh);
2642 spin_unlock(&jh->b_state_lock);
2645 jbd2_journal_put_journal_head(jh);