checkpoint.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697
  1. /*
  2. * linux/fs/checkpoint.c
  3. *
  4. * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
  5. *
  6. * Copyright 1999 Red Hat Software --- All Rights Reserved
  7. *
  8. * This file is part of the Linux kernel and is made available under
  9. * the terms of the GNU General Public License, version 2, or at your
  10. * option, any later version, incorporated herein by reference.
  11. *
  12. * Checkpoint routines for the generic filesystem journaling code.
  13. * Part of the ext2fs journaling system.
  14. *
  15. * Checkpointing is the process of ensuring that a section of the log is
  16. * committed fully to disk, so that that portion of the log can be
  17. * reused.
  18. */
  19. #include <linux/time.h>
  20. #include <linux/fs.h>
  21. #include <linux/jbd.h>
  22. #include <linux/errno.h>
  23. #include <linux/slab.h>
  24. /*
  25. * Unlink a buffer from a transaction checkpoint list.
  26. *
  27. * Called with j_list_lock held.
  28. */
  29. static inline void __buffer_unlink_first(struct journal_head *jh)
  30. {
  31. transaction_t *transaction = jh->b_cp_transaction;
  32. jh->b_cpnext->b_cpprev = jh->b_cpprev;
  33. jh->b_cpprev->b_cpnext = jh->b_cpnext;
  34. if (transaction->t_checkpoint_list == jh) {
  35. transaction->t_checkpoint_list = jh->b_cpnext;
  36. if (transaction->t_checkpoint_list == jh)
  37. transaction->t_checkpoint_list = NULL;
  38. }
  39. }
  40. /*
  41. * Unlink a buffer from a transaction checkpoint(io) list.
  42. *
  43. * Called with j_list_lock held.
  44. */
  45. static inline void __buffer_unlink(struct journal_head *jh)
  46. {
  47. transaction_t *transaction = jh->b_cp_transaction;
  48. __buffer_unlink_first(jh);
  49. if (transaction->t_checkpoint_io_list == jh) {
  50. transaction->t_checkpoint_io_list = jh->b_cpnext;
  51. if (transaction->t_checkpoint_io_list == jh)
  52. transaction->t_checkpoint_io_list = NULL;
  53. }
  54. }
  55. /*
  56. * Move a buffer from the checkpoint list to the checkpoint io list
  57. *
  58. * Called with j_list_lock held
  59. */
  60. static inline void __buffer_relink_io(struct journal_head *jh)
  61. {
  62. transaction_t *transaction = jh->b_cp_transaction;
  63. __buffer_unlink_first(jh);
  64. if (!transaction->t_checkpoint_io_list) {
  65. jh->b_cpnext = jh->b_cpprev = jh;
  66. } else {
  67. jh->b_cpnext = transaction->t_checkpoint_io_list;
  68. jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev;
  69. jh->b_cpprev->b_cpnext = jh;
  70. jh->b_cpnext->b_cpprev = jh;
  71. }
  72. transaction->t_checkpoint_io_list = jh;
  73. }
  74. /*
  75. * Try to release a checkpointed buffer from its transaction.
  76. * Returns 1 if we released it and 2 if we also released the
  77. * whole transaction.
  78. *
  79. * Requires j_list_lock
  80. * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
  81. */
  82. static int __try_to_free_cp_buf(struct journal_head *jh)
  83. {
  84. int ret = 0;
  85. struct buffer_head *bh = jh2bh(jh);
  86. if (jh->b_jlist == BJ_None && !buffer_locked(bh) && !buffer_dirty(bh)) {
  87. JBUFFER_TRACE(jh, "remove from checkpoint list");
  88. ret = __journal_remove_checkpoint(jh) + 1;
  89. jbd_unlock_bh_state(bh);
  90. journal_remove_journal_head(bh);
  91. BUFFER_TRACE(bh, "release");
  92. __brelse(bh);
  93. } else {
  94. jbd_unlock_bh_state(bh);
  95. }
  96. return ret;
  97. }
  98. /*
  99. * __log_wait_for_space: wait until there is space in the journal.
  100. *
  101. * Called under j-state_lock *only*. It will be unlocked if we have to wait
  102. * for a checkpoint to free up some space in the log.
  103. */
  104. void __log_wait_for_space(journal_t *journal)
  105. {
  106. int nblocks;
  107. assert_spin_locked(&journal->j_state_lock);
  108. nblocks = jbd_space_needed(journal);
  109. while (__log_space_left(journal) < nblocks) {
  110. if (journal->j_flags & JFS_ABORT)
  111. return;
  112. spin_unlock(&journal->j_state_lock);
  113. mutex_lock(&journal->j_checkpoint_mutex);
  114. /*
  115. * Test again, another process may have checkpointed while we
  116. * were waiting for the checkpoint lock
  117. */
  118. spin_lock(&journal->j_state_lock);
  119. nblocks = jbd_space_needed(journal);
  120. if (__log_space_left(journal) < nblocks) {
  121. spin_unlock(&journal->j_state_lock);
  122. log_do_checkpoint(journal);
  123. spin_lock(&journal->j_state_lock);
  124. }
  125. mutex_unlock(&journal->j_checkpoint_mutex);
  126. }
  127. }
  128. /*
  129. * We were unable to perform jbd_trylock_bh_state() inside j_list_lock.
  130. * The caller must restart a list walk. Wait for someone else to run
  131. * jbd_unlock_bh_state().
  132. */
  133. static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
  134. __releases(journal->j_list_lock)
  135. {
  136. get_bh(bh);
  137. spin_unlock(&journal->j_list_lock);
  138. jbd_lock_bh_state(bh);
  139. jbd_unlock_bh_state(bh);
  140. put_bh(bh);
  141. }
  142. /*
  143. * Clean up transaction's list of buffers submitted for io.
  144. * We wait for any pending IO to complete and remove any clean
  145. * buffers. Note that we take the buffers in the opposite ordering
  146. * from the one in which they were submitted for IO.
  147. *
  148. * Called with j_list_lock held.
  149. */
  150. static void __wait_cp_io(journal_t *journal, transaction_t *transaction)
  151. {
  152. struct journal_head *jh;
  153. struct buffer_head *bh;
  154. tid_t this_tid;
  155. int released = 0;
  156. this_tid = transaction->t_tid;
  157. restart:
  158. /* Did somebody clean up the transaction in the meanwhile? */
  159. if (journal->j_checkpoint_transactions != transaction ||
  160. transaction->t_tid != this_tid)
  161. return;
  162. while (!released && transaction->t_checkpoint_io_list) {
  163. jh = transaction->t_checkpoint_io_list;
  164. bh = jh2bh(jh);
  165. if (!jbd_trylock_bh_state(bh)) {
  166. jbd_sync_bh(journal, bh);
  167. spin_lock(&journal->j_list_lock);
  168. goto restart;
  169. }
  170. if (buffer_locked(bh)) {
  171. atomic_inc(&bh->b_count);
  172. spin_unlock(&journal->j_list_lock);
  173. jbd_unlock_bh_state(bh);
  174. wait_on_buffer(bh);
  175. /* the journal_head may have gone by now */
  176. BUFFER_TRACE(bh, "brelse");
  177. __brelse(bh);
  178. spin_lock(&journal->j_list_lock);
  179. goto restart;
  180. }
  181. /*
  182. * Now in whatever state the buffer currently is, we know that
  183. * it has been written out and so we can drop it from the list
  184. */
  185. released = __journal_remove_checkpoint(jh);
  186. jbd_unlock_bh_state(bh);
  187. journal_remove_journal_head(bh);
  188. __brelse(bh);
  189. }
  190. }
  191. #define NR_BATCH 64
  192. static void
  193. __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
  194. {
  195. int i;
  196. ll_rw_block(SWRITE, *batch_count, bhs);
  197. for (i = 0; i < *batch_count; i++) {
  198. struct buffer_head *bh = bhs[i];
  199. clear_buffer_jwrite(bh);
  200. BUFFER_TRACE(bh, "brelse");
  201. __brelse(bh);
  202. }
  203. *batch_count = 0;
  204. }
  205. /*
  206. * Try to flush one buffer from the checkpoint list to disk.
  207. *
  208. * Return 1 if something happened which requires us to abort the current
  209. * scan of the checkpoint list.
  210. *
  211. * Called with j_list_lock held and drops it if 1 is returned
  212. * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
  213. */
  214. static int __process_buffer(journal_t *journal, struct journal_head *jh,
  215. struct buffer_head **bhs, int *batch_count)
  216. {
  217. struct buffer_head *bh = jh2bh(jh);
  218. int ret = 0;
  219. if (buffer_locked(bh)) {
  220. atomic_inc(&bh->b_count);
  221. spin_unlock(&journal->j_list_lock);
  222. jbd_unlock_bh_state(bh);
  223. wait_on_buffer(bh);
  224. /* the journal_head may have gone by now */
  225. BUFFER_TRACE(bh, "brelse");
  226. __brelse(bh);
  227. ret = 1;
  228. } else if (jh->b_transaction != NULL) {
  229. transaction_t *t = jh->b_transaction;
  230. tid_t tid = t->t_tid;
  231. spin_unlock(&journal->j_list_lock);
  232. jbd_unlock_bh_state(bh);
  233. log_start_commit(journal, tid);
  234. log_wait_commit(journal, tid);
  235. ret = 1;
  236. } else if (!buffer_dirty(bh)) {
  237. J_ASSERT_JH(jh, !buffer_jbddirty(bh));
  238. BUFFER_TRACE(bh, "remove from checkpoint");
  239. __journal_remove_checkpoint(jh);
  240. spin_unlock(&journal->j_list_lock);
  241. jbd_unlock_bh_state(bh);
  242. journal_remove_journal_head(bh);
  243. __brelse(bh);
  244. ret = 1;
  245. } else {
  246. /*
  247. * Important: we are about to write the buffer, and
  248. * possibly block, while still holding the journal lock.
  249. * We cannot afford to let the transaction logic start
  250. * messing around with this buffer before we write it to
  251. * disk, as that would break recoverability.
  252. */
  253. BUFFER_TRACE(bh, "queue");
  254. get_bh(bh);
  255. J_ASSERT_BH(bh, !buffer_jwrite(bh));
  256. set_buffer_jwrite(bh);
  257. bhs[*batch_count] = bh;
  258. __buffer_relink_io(jh);
  259. jbd_unlock_bh_state(bh);
  260. (*batch_count)++;
  261. if (*batch_count == NR_BATCH) {
  262. spin_unlock(&journal->j_list_lock);
  263. __flush_batch(journal, bhs, batch_count);
  264. ret = 1;
  265. }
  266. }
  267. return ret;
  268. }
  269. /*
  270. * Perform an actual checkpoint. We take the first transaction on the
  271. * list of transactions to be checkpointed and send all its buffers
  272. * to disk. We submit larger chunks of data at once.
  273. *
  274. * The journal should be locked before calling this function.
  275. */
  276. int log_do_checkpoint(journal_t *journal)
  277. {
  278. transaction_t *transaction;
  279. tid_t this_tid;
  280. int result;
  281. jbd_debug(1, "Start checkpoint\n");
  282. /*
  283. * First thing: if there are any transactions in the log which
  284. * don't need checkpointing, just eliminate them from the
  285. * journal straight away.
  286. */
  287. result = cleanup_journal_tail(journal);
  288. jbd_debug(1, "cleanup_journal_tail returned %d\n", result);
  289. if (result <= 0)
  290. return result;
  291. /*
  292. * OK, we need to start writing disk blocks. Take one transaction
  293. * and write it.
  294. */
  295. spin_lock(&journal->j_list_lock);
  296. if (!journal->j_checkpoint_transactions)
  297. goto out;
  298. transaction = journal->j_checkpoint_transactions;
  299. this_tid = transaction->t_tid;
  300. restart:
  301. /*
  302. * If someone cleaned up this transaction while we slept, we're
  303. * done (maybe it's a new transaction, but it fell at the same
  304. * address).
  305. */
  306. if (journal->j_checkpoint_transactions == transaction &&
  307. transaction->t_tid == this_tid) {
  308. int batch_count = 0;
  309. struct buffer_head *bhs[NR_BATCH];
  310. struct journal_head *jh;
  311. int retry = 0;
  312. while (!retry && transaction->t_checkpoint_list) {
  313. struct buffer_head *bh;
  314. jh = transaction->t_checkpoint_list;
  315. bh = jh2bh(jh);
  316. if (!jbd_trylock_bh_state(bh)) {
  317. jbd_sync_bh(journal, bh);
  318. retry = 1;
  319. break;
  320. }
  321. retry = __process_buffer(journal, jh, bhs,&batch_count);
  322. if (!retry && lock_need_resched(&journal->j_list_lock)){
  323. spin_unlock(&journal->j_list_lock);
  324. retry = 1;
  325. break;
  326. }
  327. }
  328. if (batch_count) {
  329. if (!retry) {
  330. spin_unlock(&journal->j_list_lock);
  331. retry = 1;
  332. }
  333. __flush_batch(journal, bhs, &batch_count);
  334. }
  335. if (retry) {
  336. spin_lock(&journal->j_list_lock);
  337. goto restart;
  338. }
  339. /*
  340. * Now we have cleaned up the first transaction's checkpoint
  341. * list. Let's clean up the second one
  342. */
  343. __wait_cp_io(journal, transaction);
  344. }
  345. out:
  346. spin_unlock(&journal->j_list_lock);
  347. result = cleanup_journal_tail(journal);
  348. if (result < 0)
  349. return result;
  350. return 0;
  351. }
  352. /*
  353. * Check the list of checkpoint transactions for the journal to see if
  354. * we have already got rid of any since the last update of the log tail
  355. * in the journal superblock. If so, we can instantly roll the
  356. * superblock forward to remove those transactions from the log.
  357. *
  358. * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
  359. *
  360. * Called with the journal lock held.
  361. *
  362. * This is the only part of the journaling code which really needs to be
  363. * aware of transaction aborts. Checkpointing involves writing to the
  364. * main filesystem area rather than to the journal, so it can proceed
  365. * even in abort state, but we must not update the journal superblock if
  366. * we have an abort error outstanding.
  367. */
  368. int cleanup_journal_tail(journal_t *journal)
  369. {
  370. transaction_t * transaction;
  371. tid_t first_tid;
  372. unsigned long blocknr, freed;
  373. /* OK, work out the oldest transaction remaining in the log, and
  374. * the log block it starts at.
  375. *
  376. * If the log is now empty, we need to work out which is the
  377. * next transaction ID we will write, and where it will
  378. * start. */
  379. spin_lock(&journal->j_state_lock);
  380. spin_lock(&journal->j_list_lock);
  381. transaction = journal->j_checkpoint_transactions;
  382. if (transaction) {
  383. first_tid = transaction->t_tid;
  384. blocknr = transaction->t_log_start;
  385. } else if ((transaction = journal->j_committing_transaction) != NULL) {
  386. first_tid = transaction->t_tid;
  387. blocknr = transaction->t_log_start;
  388. } else if ((transaction = journal->j_running_transaction) != NULL) {
  389. first_tid = transaction->t_tid;
  390. blocknr = journal->j_head;
  391. } else {
  392. first_tid = journal->j_transaction_sequence;
  393. blocknr = journal->j_head;
  394. }
  395. spin_unlock(&journal->j_list_lock);
  396. J_ASSERT(blocknr != 0);
  397. /* If the oldest pinned transaction is at the tail of the log
  398. already then there's not much we can do right now. */
  399. if (journal->j_tail_sequence == first_tid) {
  400. spin_unlock(&journal->j_state_lock);
  401. return 1;
  402. }
  403. /* OK, update the superblock to recover the freed space.
  404. * Physical blocks come first: have we wrapped beyond the end of
  405. * the log? */
  406. freed = blocknr - journal->j_tail;
  407. if (blocknr < journal->j_tail)
  408. freed = freed + journal->j_last - journal->j_first;
  409. jbd_debug(1,
  410. "Cleaning journal tail from %d to %d (offset %lu), "
  411. "freeing %lu\n",
  412. journal->j_tail_sequence, first_tid, blocknr, freed);
  413. journal->j_free += freed;
  414. journal->j_tail_sequence = first_tid;
  415. journal->j_tail = blocknr;
  416. spin_unlock(&journal->j_state_lock);
  417. if (!(journal->j_flags & JFS_ABORT))
  418. journal_update_superblock(journal, 1);
  419. return 0;
  420. }
  421. /* Checkpoint list management */
  422. /*
  423. * journal_clean_one_cp_list
  424. *
  425. * Find all the written-back checkpoint buffers in the given list and release them.
  426. *
  427. * Called with the journal locked.
  428. * Called with j_list_lock held.
  429. * Returns number of bufers reaped (for debug)
  430. */
  431. static int journal_clean_one_cp_list(struct journal_head *jh, int *released)
  432. {
  433. struct journal_head *last_jh;
  434. struct journal_head *next_jh = jh;
  435. int ret, freed = 0;
  436. *released = 0;
  437. if (!jh)
  438. return 0;
  439. last_jh = jh->b_cpprev;
  440. do {
  441. jh = next_jh;
  442. next_jh = jh->b_cpnext;
  443. /* Use trylock because of the ranking */
  444. if (jbd_trylock_bh_state(jh2bh(jh))) {
  445. ret = __try_to_free_cp_buf(jh);
  446. if (ret) {
  447. freed++;
  448. if (ret == 2) {
  449. *released = 1;
  450. return freed;
  451. }
  452. }
  453. }
  454. /*
  455. * This function only frees up some memory
  456. * if possible so we dont have an obligation
  457. * to finish processing. Bail out if preemption
  458. * requested:
  459. */
  460. if (need_resched())
  461. return freed;
  462. } while (jh != last_jh);
  463. return freed;
  464. }
  465. /*
  466. * journal_clean_checkpoint_list
  467. *
  468. * Find all the written-back checkpoint buffers in the journal and release them.
  469. *
  470. * Called with the journal locked.
  471. * Called with j_list_lock held.
  472. * Returns number of buffers reaped (for debug)
  473. */
  474. int __journal_clean_checkpoint_list(journal_t *journal)
  475. {
  476. transaction_t *transaction, *last_transaction, *next_transaction;
  477. int ret = 0;
  478. int released;
  479. transaction = journal->j_checkpoint_transactions;
  480. if (!transaction)
  481. goto out;
  482. last_transaction = transaction->t_cpprev;
  483. next_transaction = transaction;
  484. do {
  485. transaction = next_transaction;
  486. next_transaction = transaction->t_cpnext;
  487. ret += journal_clean_one_cp_list(transaction->
  488. t_checkpoint_list, &released);
  489. /*
  490. * This function only frees up some memory if possible so we
  491. * dont have an obligation to finish processing. Bail out if
  492. * preemption requested:
  493. */
  494. if (need_resched())
  495. goto out;
  496. if (released)
  497. continue;
  498. /*
  499. * It is essential that we are as careful as in the case of
  500. * t_checkpoint_list with removing the buffer from the list as
  501. * we can possibly see not yet submitted buffers on io_list
  502. */
  503. ret += journal_clean_one_cp_list(transaction->
  504. t_checkpoint_io_list, &released);
  505. if (need_resched())
  506. goto out;
  507. } while (transaction != last_transaction);
  508. out:
  509. return ret;
  510. }
  511. /*
  512. * journal_remove_checkpoint: called after a buffer has been committed
  513. * to disk (either by being write-back flushed to disk, or being
  514. * committed to the log).
  515. *
  516. * We cannot safely clean a transaction out of the log until all of the
  517. * buffer updates committed in that transaction have safely been stored
  518. * elsewhere on disk. To achieve this, all of the buffers in a
  519. * transaction need to be maintained on the transaction's checkpoint
  520. * lists until they have been rewritten, at which point this function is
  521. * called to remove the buffer from the existing transaction's
  522. * checkpoint lists.
  523. *
  524. * The function returns 1 if it frees the transaction, 0 otherwise.
  525. *
  526. * This function is called with the journal locked.
  527. * This function is called with j_list_lock held.
  528. * This function is called with jbd_lock_bh_state(jh2bh(jh))
  529. */
  530. int __journal_remove_checkpoint(struct journal_head *jh)
  531. {
  532. transaction_t *transaction;
  533. journal_t *journal;
  534. int ret = 0;
  535. JBUFFER_TRACE(jh, "entry");
  536. if ((transaction = jh->b_cp_transaction) == NULL) {
  537. JBUFFER_TRACE(jh, "not on transaction");
  538. goto out;
  539. }
  540. journal = transaction->t_journal;
  541. __buffer_unlink(jh);
  542. jh->b_cp_transaction = NULL;
  543. if (transaction->t_checkpoint_list != NULL ||
  544. transaction->t_checkpoint_io_list != NULL)
  545. goto out;
  546. JBUFFER_TRACE(jh, "transaction has no more buffers");
  547. /*
  548. * There is one special case to worry about: if we have just pulled the
  549. * buffer off a committing transaction's forget list, then even if the
  550. * checkpoint list is empty, the transaction obviously cannot be
  551. * dropped!
  552. *
  553. * The locking here around j_committing_transaction is a bit sleazy.
  554. * See the comment at the end of journal_commit_transaction().
  555. */
  556. if (transaction == journal->j_committing_transaction) {
  557. JBUFFER_TRACE(jh, "belongs to committing transaction");
  558. goto out;
  559. }
  560. /* OK, that was the last buffer for the transaction: we can now
  561. safely remove this transaction from the log */
  562. __journal_drop_transaction(journal, transaction);
  563. /* Just in case anybody was waiting for more transactions to be
  564. checkpointed... */
  565. wake_up(&journal->j_wait_logspace);
  566. ret = 1;
  567. out:
  568. JBUFFER_TRACE(jh, "exit");
  569. return ret;
  570. }
  571. /*
  572. * journal_insert_checkpoint: put a committed buffer onto a checkpoint
  573. * list so that we know when it is safe to clean the transaction out of
  574. * the log.
  575. *
  576. * Called with the journal locked.
  577. * Called with j_list_lock held.
  578. */
  579. void __journal_insert_checkpoint(struct journal_head *jh,
  580. transaction_t *transaction)
  581. {
  582. JBUFFER_TRACE(jh, "entry");
  583. J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
  584. J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
  585. jh->b_cp_transaction = transaction;
  586. if (!transaction->t_checkpoint_list) {
  587. jh->b_cpnext = jh->b_cpprev = jh;
  588. } else {
  589. jh->b_cpnext = transaction->t_checkpoint_list;
  590. jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
  591. jh->b_cpprev->b_cpnext = jh;
  592. jh->b_cpnext->b_cpprev = jh;
  593. }
  594. transaction->t_checkpoint_list = jh;
  595. }
  596. /*
  597. * We've finished with this transaction structure: adios...
  598. *
  599. * The transaction must have no links except for the checkpoint by this
  600. * point.
  601. *
  602. * Called with the journal locked.
  603. * Called with j_list_lock held.
  604. */
  605. void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)
  606. {
  607. assert_spin_locked(&journal->j_list_lock);
  608. if (transaction->t_cpnext) {
  609. transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
  610. transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
  611. if (journal->j_checkpoint_transactions == transaction)
  612. journal->j_checkpoint_transactions =
  613. transaction->t_cpnext;
  614. if (journal->j_checkpoint_transactions == transaction)
  615. journal->j_checkpoint_transactions = NULL;
  616. }
  617. J_ASSERT(transaction->t_state == T_FINISHED);
  618. J_ASSERT(transaction->t_buffers == NULL);
  619. J_ASSERT(transaction->t_sync_datalist == NULL);
  620. J_ASSERT(transaction->t_forget == NULL);
  621. J_ASSERT(transaction->t_iobuf_list == NULL);
  622. J_ASSERT(transaction->t_shadow_list == NULL);
  623. J_ASSERT(transaction->t_log_list == NULL);
  624. J_ASSERT(transaction->t_checkpoint_list == NULL);
  625. J_ASSERT(transaction->t_checkpoint_io_list == NULL);
  626. J_ASSERT(transaction->t_updates == 0);
  627. J_ASSERT(journal->j_committing_transaction != transaction);
  628. J_ASSERT(journal->j_running_transaction != transaction);
  629. jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
  630. kfree(transaction);
  631. }