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);
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;
1242 jh = jbd2_journal_add_journal_head(bh);
1246 rc = do_get_write_access(handle, jh, 0);
1247 jbd2_journal_put_journal_head(jh);
1275 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1278 jbd2_debug(5, "journal_head %p\n", jh);
1285 JBUFFER_TRACE(jh, "entry");
1293 spin_lock(&jh->b_state_lock);
1294 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
1295 jh->b_transaction == NULL ||
1296 (jh->b_transaction == journal->j_committing_transaction &&
1297 jh->b_jlist == BJ_Forget)));
1299 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1300 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
1302 if (jh->b_transaction == NULL) {
1311 clear_buffer_dirty(jh2bh(jh));
1313 jh->b_modified = 0;
1315 JBUFFER_TRACE(jh, "file as BJ_Reserved");
1317 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
1319 } else if (jh->b_transaction == journal->j_committing_transaction) {
1321 jh->b_modified = 0;
1323 JBUFFER_TRACE(jh, "set next transaction");
1325 jh->b_next_transaction = transaction;
1328 spin_unlock(&jh->b_state_lock);
1337 JBUFFER_TRACE(jh, "cancelling revoke");
1338 jbd2_journal_cancel_revoke(handle, jh);
1340 jbd2_journal_put_journal_head(jh);
1373 struct journal_head *jh;
1382 jh = jbd2_journal_add_journal_head(bh);
1383 JBUFFER_TRACE(jh, "entry");
1390 err = do_get_write_access(handle, jh, 1);
1395 if (!jh->b_committed_data)
1396 committed_data = jbd2_alloc(jh2bh(jh)->b_size,
1399 spin_lock(&jh->b_state_lock);
1400 if (!jh->b_committed_data) {
1403 JBUFFER_TRACE(jh, "generate b_committed data");
1405 spin_unlock(&jh->b_state_lock);
1409 jh->b_committed_data = committed_data;
1411 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1413 spin_unlock(&jh->b_state_lock);
1415 jbd2_journal_put_journal_head(jh);
1435 struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
1437 if (WARN_ON_ONCE(!jh))
1439 jh->b_triggers = type;
1440 jbd2_journal_put_journal_head(jh);
1443 void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
1446 struct buffer_head *bh = jh2bh(jh);
1454 void jbd2_buffer_abort_trigger(struct journal_head *jh,
1460 triggers->t_abort(triggers, jh2bh(jh));
1490 struct journal_head *jh;
1497 * We don't grab jh reference here since the buffer must be part
1500 jh = bh2jh(bh);
1501 jbd2_debug(5, "journal_head %p\n", jh);
1502 JBUFFER_TRACE(jh, "entry");
1505 * This and the following assertions are unreliable since we may see jh
1510 if (data_race(jh->b_transaction != transaction &&
1511 jh->b_next_transaction != transaction)) {
1512 spin_lock(&jh->b_state_lock);
1513 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
1514 jh->b_next_transaction == transaction);
1515 spin_unlock(&jh->b_state_lock);
1517 if (jh->b_modified == 1) {
1519 if (data_race(jh->b_transaction == transaction &&
1520 jh->b_jlist != BJ_Metadata)) {
1521 spin_lock(&jh->b_state_lock);
1522 if (jh->b_transaction == transaction &&
1523 jh->b_jlist != BJ_Metadata)
1528 jh->b_jlist);
1529 J_ASSERT_JH(jh, jh->b_transaction != transaction ||
1530 jh->b_jlist == BJ_Metadata);
1531 spin_unlock(&jh->b_state_lock);
1537 spin_lock(&jh->b_state_lock);
1541 * Check journal aborting with @jh->b_state_lock locked,
1542 * since 'jh->b_transaction' could be replaced with
1543 * 'jh->b_next_transaction' during old transaction
1545 * assertion on 'jh->b_frozen_data == NULL'.
1551 if (jh->b_modified == 0) {
1561 jh->b_modified = 1;
1572 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1573 JBUFFER_TRACE(jh, "fastpath");
1574 if (unlikely(jh->b_transaction !=
1577 "jh->b_transaction (%llu, %p, %u) != "
1581 jh->b_transaction,
1582 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1599 if (jh->b_transaction != transaction) {
1600 JBUFFER_TRACE(jh, "already on other transaction");
1601 if (unlikely(((jh->b_transaction !=
1603 (jh->b_next_transaction != transaction))) {
1605 "bad jh for block %llu: "
1607 "jh->b_transaction (%p, %u), "
1608 "jh->b_next_transaction (%p, %u), jlist %u\n",
1612 jh->b_transaction,
1613 jh->b_transaction ?
1614 jh->b_transaction->t_tid : 0,
1615 jh->b_next_transaction,
1616 jh->b_next_transaction ?
1617 jh->b_next_transaction->t_tid : 0,
1618 jh->b_jlist);
1628 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
1630 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1632 __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
1635 spin_unlock(&jh->b_state_lock);
1637 JBUFFER_TRACE(jh, "exit");
1662 struct journal_head *jh;
1673 jh = jbd2_journal_grab_journal_head(bh);
1674 if (!jh) {
1679 spin_lock(&jh->b_state_lock);
1683 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1690 was_modified = jh->b_modified;
1696 jh->b_modified = 0;
1698 if (jh->b_transaction == transaction) {
1699 J_ASSERT_JH(jh, !jh->b_frozen_data);
1707 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1729 if (jh->b_cp_transaction) {
1730 __jbd2_journal_temp_unlink_buffer(jh);
1731 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1733 __jbd2_journal_unfile_buffer(jh);
1734 jbd2_journal_put_journal_head(jh);
1737 } else if (jh->b_transaction) {
1738 J_ASSERT_JH(jh, (jh->b_transaction ==
1742 JBUFFER_TRACE(jh, "belongs to older transaction");
1752 if (!jh->b_next_transaction) {
1754 jh->b_next_transaction = transaction;
1757 J_ASSERT(jh->b_next_transaction == transaction);
1773 if (!jh->b_cp_transaction) {
1774 JBUFFER_TRACE(jh, "belongs to none transaction");
1783 if (jbd2_journal_try_remove_checkpoint(jh) >= 0) {
1795 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
1800 spin_unlock(&jh->b_state_lock);
1801 jbd2_journal_put_journal_head(jh);
1976 * jh->b_state_lock is held.
1980 __blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1983 jh->b_tnext = jh->b_tprev = jh;
1984 *list = jh;
1988 jh->b_tprev = last;
1989 jh->b_tnext = first;
1990 last->b_tnext = first->b_tprev = jh;
2000 * jh->b_state_lock is held.
2004 __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
2006 if (*list == jh) {
2007 *list = jh->b_tnext;
2008 if (*list == jh)
2011 jh->b_tprev->b_tnext = jh->b_tnext;
2012 jh->b_tnext->b_tprev = jh->b_tprev;
2026 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
2030 struct buffer_head *bh = jh2bh(jh);
2032 lockdep_assert_held(&jh->b_state_lock);
2033 transaction = jh->b_transaction;
2037 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2038 if (jh->b_jlist != BJ_None)
2039 J_ASSERT_JH(jh, transaction != NULL);
2041 switch (jh->b_jlist) {
2046 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
2060 __blist_del_buffer(list, jh);
2061 jh->b_jlist = BJ_None;
2070 * the jh reference that belonged to the transaction.
2074 static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
2076 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2077 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2079 __jbd2_journal_temp_unlink_buffer(jh);
2080 jh->b_transaction = NULL;
2083 void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
2085 struct buffer_head *bh = jh2bh(jh);
2089 spin_lock(&jh->b_state_lock);
2091 __jbd2_journal_unfile_buffer(jh);
2093 spin_unlock(&jh->b_state_lock);
2094 jbd2_journal_put_journal_head(jh);
2143 struct journal_head *jh;
2150 jh = jbd2_journal_grab_journal_head(bh);
2151 if (!jh)
2154 spin_lock(&jh->b_state_lock);
2155 if (!jh->b_transaction && !jh->b_next_transaction) {
2158 if (jh->b_cp_transaction != NULL)
2159 jbd2_journal_try_remove_checkpoint(jh);
2162 spin_unlock(&jh->b_state_lock);
2163 jbd2_journal_put_journal_head(jh);
2183 * Called under jh->b_state_lock.
2185 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
2188 struct buffer_head *bh = jh2bh(jh);
2190 if (jh->b_cp_transaction) {
2191 JBUFFER_TRACE(jh, "on running+cp transaction");
2192 __jbd2_journal_temp_unlink_buffer(jh);
2199 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
2202 JBUFFER_TRACE(jh, "on running transaction");
2203 __jbd2_journal_unfile_buffer(jh);
2204 jbd2_journal_put_journal_head(jh);
2260 struct journal_head *jh;
2271 jh = jbd2_journal_grab_journal_head(bh);
2272 if (!jh)
2277 spin_lock(&jh->b_state_lock);
2303 transaction = jh->b_transaction;
2309 if (!jh->b_cp_transaction) {
2310 JBUFFER_TRACE(jh, "not on any transaction: zap");
2316 __jbd2_journal_remove_checkpoint(jh);
2328 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
2329 may_free = __dispose_buffer(jh,
2338 JBUFFER_TRACE(jh, "give to committing trans");
2339 may_free = __dispose_buffer(jh,
2346 __jbd2_journal_remove_checkpoint(jh);
2351 JBUFFER_TRACE(jh, "on committing transaction");
2359 spin_unlock(&jh->b_state_lock);
2361 jbd2_journal_put_journal_head(jh);
2376 jh->b_next_transaction = journal->j_running_transaction;
2377 jh->b_modified = 0;
2379 spin_unlock(&jh->b_state_lock);
2381 jbd2_journal_put_journal_head(jh);
2390 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
2391 JBUFFER_TRACE(jh, "on running transaction");
2392 may_free = __dispose_buffer(jh, transaction);
2404 jh->b_modified = 0;
2406 spin_unlock(&jh->b_state_lock);
2408 jbd2_journal_put_journal_head(jh);
2487 void __jbd2_journal_file_buffer(struct journal_head *jh,
2492 struct buffer_head *bh = jh2bh(jh);
2494 lockdep_assert_held(&jh->b_state_lock);
2497 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2498 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
2499 jh->b_transaction == NULL);
2501 if (jh->b_transaction && jh->b_jlist == jlist)
2520 if (jh->b_transaction)
2521 __jbd2_journal_temp_unlink_buffer(jh);
2524 jh->b_transaction = transaction;
2528 J_ASSERT_JH(jh, !jh->b_committed_data);
2529 J_ASSERT_JH(jh, !jh->b_frozen_data);
2546 __blist_add_buffer(list, jh);
2547 jh->b_jlist = jlist;
2553 void jbd2_journal_file_buffer(struct journal_head *jh,
2556 spin_lock(&jh->b_state_lock);
2558 __jbd2_journal_file_buffer(jh, transaction, jlist);
2560 spin_unlock(&jh->b_state_lock);
2570 * Called under jh->b_state_lock
2573 * and the caller has to drop jh reference through
2576 bool __jbd2_journal_refile_buffer(struct journal_head *jh)
2579 struct buffer_head *bh = jh2bh(jh);
2581 lockdep_assert_held(&jh->b_state_lock);
2582 if (jh->b_transaction)
2583 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2586 if (jh->b_next_transaction == NULL) {
2587 __jbd2_journal_unfile_buffer(jh);
2597 __jbd2_journal_temp_unlink_buffer(jh);
2601 * be holding jh reference
2603 J_ASSERT_JH(jh, jh->b_transaction != NULL);
2607 * our jh reference and thus __jbd2_journal_file_buffer() must not
2610 WRITE_ONCE(jh->b_transaction, jh->b_next_transaction);
2611 WRITE_ONCE(jh->b_next_transaction, NULL);
2614 else if (jh->b_modified)
2618 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
2619 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2630 * The jh and bh may be freed by this call.
2632 void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2636 spin_lock(&jh->b_state_lock);
2638 drop = __jbd2_journal_refile_buffer(jh);
2639 spin_unlock(&jh->b_state_lock);
2642 jbd2_journal_put_journal_head(jh);