开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
commit.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

commit.c：源码内容
  1. /*
  2.  * linux/fs/commit.c
  3.  *
  4.  * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
  5.  *
  6.  * Copyright 1998 Red Hat corp --- 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.  * Journal commit routines for the generic filesystem journaling code;
  13.  * part of the ext2fs journaling system.
  14.  */
  16. #include <linux/sched.h>
  17. #include <linux/fs.h>
  18. #include <linux/jbd.h>
  19. #include <linux/errno.h>
  20. #include <linux/slab.h>
  21. #include <linux/locks.h>
  22. #include <linux/smp_lock.h>
  24. extern spinlock_t journal_datalist_lock;
  26. /*
  27.  * Default IO end handler for temporary BJ_IO buffer_heads.
  28.  */
  29. void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
  30. {
  31. BUFFER_TRACE(bh, "");
  32. mark_buffer_uptodate(bh, uptodate);
  33. unlock_buffer(bh);
  34. }
  36. /*
  37.  * journal_commit_transaction
  38.  *
  39.  * The primary function for committing a transaction to the log.  This
  40.  * function is called by the journal thread to begin a complete commit.
  41.  */
  42. void journal_commit_transaction(journal_t *journal)
  43. {
  44. transaction_t *commit_transaction;
  45. struct journal_head *jh, *new_jh, *descriptor;
  46. struct journal_head *next_jh, *last_jh;
  47. struct buffer_head *wbuf[64];
  48. int bufs;
  49. int flags;
  50. int err;
  51. unsigned long blocknr;
  52. char *tagp = NULL;
  53. journal_header_t *header;
  54. journal_block_tag_t *tag = NULL;
  55. int space_left = 0;
  56. int first_tag = 0;
  57. int tag_flag;
  58. int i;
  60. /*
  61.  * First job: lock down the current transaction and wait for
  62.  * all outstanding updates to complete.
  63.  */
  65. lock_journal(journal); /* Protect journal->j_running_transaction */
  67. #ifdef COMMIT_STATS
  68. spin_lock(&journal_datalist_lock);
  69. summarise_journal_usage(journal);
  70. spin_unlock(&journal_datalist_lock);
  71. #endif
  73. lock_kernel();
  75. J_ASSERT (journal->j_running_transaction != NULL);
  76. J_ASSERT (journal->j_committing_transaction == NULL);
  78. commit_transaction = journal->j_running_transaction;
  79. J_ASSERT (commit_transaction->t_state == T_RUNNING);
  81. jbd_debug (1, "JBD: starting commit of transaction %dn",
  82.    commit_transaction->t_tid);
  84. commit_transaction->t_state = T_LOCKED;
  85. while (commit_transaction->t_updates != 0) {
  86. unlock_journal(journal);
  87. sleep_on(&journal->j_wait_updates);
  88. lock_journal(journal);
  89. }
  91. J_ASSERT (commit_transaction->t_outstanding_credits <=
  92. journal->j_max_transaction_buffers);
  94. /* Do we need to erase the effects of a prior journal_flush? */
  95. if (journal->j_flags & JFS_FLUSHED) {
  96. jbd_debug(3, "super block updatedn");
  97. journal_update_superblock(journal, 1);
  98. } else {
  99. jbd_debug(3, "superblock not updatedn");
  100. }
  102. /*
  103.  * First thing we are allowed to do is to discard any remaining
  104.  * BJ_Reserved buffers.  Note, it is _not_ permissible to assume
  105.  * that there are no such buffers: if a large filesystem
  106.  * operation like a truncate needs to split itself over multiple
  107.  * transactions, then it may try to do a journal_restart() while
  108.  * there are still BJ_Reserved buffers outstanding.  These must
  109.  * be released cleanly from the current transaction.
  110.  *
  111.  * In this case, the filesystem must still reserve write access
  112.  * again before modifying the buffer in the new transaction, but
  113.  * we do not require it to remember exactly which old buffers it
  114.  * has reserved.  This is consistent with the existing behaviour
  115.  * that multiple journal_get_write_access() calls to the same
  116.  * buffer are perfectly permissable.
  117.  */
  119. while (commit_transaction->t_reserved_list) {
  120. jh = commit_transaction->t_reserved_list;
  121. JBUFFER_TRACE(jh, "reserved, unused: refile");
  122. journal_refile_buffer(jh);
  123. }
  125. /*
  126.  * Now try to drop any written-back buffers from the journal's
  127.  * checkpoint lists.  We do this *before* commit because it potentially
  128.  * frees some memory
  129.  */
  130. spin_lock(&journal_datalist_lock);
  131. __journal_clean_checkpoint_list(journal);
  132. spin_unlock(&journal_datalist_lock);
  134. /* First part of the commit: force the revoke list out to disk.
  135.  * The revoke code generates its own metadata blocks on disk for this.
  136.  *
  137.  * It is important that we do this while the transaction is
  138.  * still locked.  Generating the revoke records should not
  139.  * generate any IO stalls, so this should be quick; and doing
  140.  * the work while we have the transaction locked means that we
  141.  * only ever have to maintain the revoke list for one
  142.  * transaction at a time.
  143.  */
  145. jbd_debug (3, "JBD: commit phase 1n");
  147. journal_write_revoke_records(journal, commit_transaction);
  149. /*
  150.  * Now that we have built the revoke records, we can start
  151.  * reusing the revoke list for a new running transaction.  We
  152.  * can now safely start committing the old transaction: time to
  153.  * get a new running transaction for incoming filesystem updates
  154.  */
  156. commit_transaction->t_state = T_FLUSH;
  158. wake_up(&journal->j_wait_transaction_locked);
  160. journal->j_committing_transaction = commit_transaction;
  161. journal->j_running_transaction = NULL;
  163. commit_transaction->t_log_start = journal->j_head;
  165. unlock_kernel();
  167. jbd_debug (3, "JBD: commit phase 2n");
  169. /*
  170.  * Now start flushing things to disk, in the order they appear
  171.  * on the transaction lists.  Data blocks go first.
  172.  */
  174. /*
  175.  * Whenever we unlock the journal and sleep, things can get added
  176.  * onto ->t_datalist, so we have to keep looping back to write_out_data
  177.  * until we *know* that the list is empty.
  178.  */
  179. write_out_data:
  181. /*
  182.  * Cleanup any flushed data buffers from the data list.  Even in
  183.  * abort mode, we want to flush this out as soon as possible.
  184.  *
  185.  * We take journal_datalist_lock to protect the lists from
  186.  * journal_try_to_free_buffers().
  187.  */
  188. spin_lock(&journal_datalist_lock);
  190. write_out_data_locked:
  191. bufs = 0;
  192. next_jh = commit_transaction->t_sync_datalist;
  193. if (next_jh == NULL)
  194. goto sync_datalist_empty;
  195. last_jh = next_jh->b_tprev;
  197. do {
  198. struct buffer_head *bh;
  200. jh = next_jh;
  201. next_jh = jh->b_tnext;
  202. bh = jh2bh(jh);
  203. if (!buffer_locked(bh)) {
  204. if (buffer_dirty(bh)) {
  205. BUFFER_TRACE(bh, "start journal writeout");
  206. atomic_inc(&bh->b_count);
  207. wbuf[bufs++] = bh;
  208. } else {
  209. BUFFER_TRACE(bh, "writeout complete: unfile");
  210. __journal_unfile_buffer(jh);
  211. jh->b_transaction = NULL;
  212. __journal_remove_journal_head(bh);
  213. refile_buffer(bh);
  214. __brelse(bh);
  215. }
  216. }
  217. if (bufs == ARRAY_SIZE(wbuf)) {
  218. /*
  219.  * Major speedup: start here on the next scan
  220.  */
  221. J_ASSERT(commit_transaction->t_sync_datalist != 0);
  222. commit_transaction->t_sync_datalist = jh;
  223. break;
  224. }
  225. } while (jh != last_jh);
  227. if (bufs || current->need_resched) {
  228. jbd_debug(2, "submit %d writesn", bufs);
  229. spin_unlock(&journal_datalist_lock);
  230. unlock_journal(journal);
  231. if (bufs)
  232. ll_rw_block(WRITE, bufs, wbuf);
  233. if (current->need_resched)
  234. schedule();
  235. journal_brelse_array(wbuf, bufs);
  236. lock_journal(journal);
  237. spin_lock(&journal_datalist_lock);
  238. if (bufs)
  239. goto write_out_data_locked;
  240. }
  242. /*
  243.  * Wait for all previously submitted IO on the data list to complete.
  244.  */
  245. jh = commit_transaction->t_sync_datalist;
  246. if (jh == NULL)
  247. goto sync_datalist_empty;
  249. do {
  250. struct buffer_head *bh;
  251. jh = jh->b_tprev; /* Wait on the last written */
  252. bh = jh2bh(jh);
  253. if (buffer_locked(bh)) {
  254. spin_unlock(&journal_datalist_lock);
  255. unlock_journal(journal);
  256. wait_on_buffer(bh);
  257. /* the journal_head may have been removed now */
  258. lock_journal(journal);
  259. goto write_out_data;
  260. } else if (buffer_dirty(bh)) {
  261. goto write_out_data_locked;
  262. }
  263. } while (jh != commit_transaction->t_sync_datalist);
  264. goto write_out_data_locked;
  266. sync_datalist_empty:
  267. /*
  268.  * Wait for all the async writepage data.  As they become unlocked
  269.  * in end_buffer_io_async(), the only place where they can be
  270.  * reaped is in try_to_free_buffers(), and we're locked against
  271.  * that.
  272.  */
  273. while ((jh = commit_transaction->t_async_datalist)) {
  274. struct buffer_head *bh = jh2bh(jh);
  275. if (buffer_locked(bh)) {
  276. spin_unlock(&journal_datalist_lock);
  277. unlock_journal(journal);
  278. wait_on_buffer(bh);
  279. lock_journal(journal);
  280. spin_lock(&journal_datalist_lock);
  281. continue; /* List may have changed */
  282. }
  283. if (jh->b_next_transaction) {
  284. /*
  285.  * For writepage() buffers in journalled data mode: a
  286.  * later transaction may want the buffer for "metadata"
  287.  */
  288. __journal_refile_buffer(jh);
  289. } else {
  290. BUFFER_TRACE(bh, "finished async writeout: unfile");
  291. __journal_unfile_buffer(jh);
  292. jh->b_transaction = NULL;
  293. __journal_remove_journal_head(bh);
  294. BUFFER_TRACE(bh, "finished async writeout: refile");
  295. /* It can sometimes be on BUF_LOCKED due to migration
  296.  * from syncdata to asyncdata */
  297. if (bh->b_list != BUF_CLEAN)
  298. refile_buffer(bh);
  299. __brelse(bh);
  300. }
  301. }
  302. spin_unlock(&journal_datalist_lock);
  304. /*
  305.  * If we found any dirty or locked buffers, then we should have
  306.  * looped back up to the write_out_data label.  If there weren't
  307.  * any then journal_clean_data_list should have wiped the list
  308.  * clean by now, so check that it is in fact empty.
  309.  */
  310. J_ASSERT (commit_transaction->t_sync_datalist == NULL);
  311. J_ASSERT (commit_transaction->t_async_datalist == NULL);
  313. jbd_debug (3, "JBD: commit phase 3n");
  315. /*
  316.  * Way to go: we have now written out all of the data for a
  317.  * transaction!  Now comes the tricky part: we need to write out
  318.  * metadata.  Loop over the transaction's entire buffer list:
  319.  */
  320. commit_transaction->t_state = T_COMMIT;
  322. descriptor = 0;
  323. bufs = 0;
  324. while (commit_transaction->t_buffers) {
  326. /* Find the next buffer to be journaled... */
  328. jh = commit_transaction->t_buffers;
  330. /* If we're in abort mode, we just un-journal the buffer and
  331.    release it for background writing. */
  333. if (is_journal_aborted(journal)) {
  334. JBUFFER_TRACE(jh, "journal is aborting: refile");
  335. journal_refile_buffer(jh);
  336. /* If that was the last one, we need to clean up
  337.  * any descriptor buffers which may have been
  338.  * already allocated, even if we are now
  339.  * aborting. */
  340. if (!commit_transaction->t_buffers)
  341. goto start_journal_io;
  342. continue;
  343. }
  345. /* Make sure we have a descriptor block in which to
  346.    record the metadata buffer. */
  348. if (!descriptor) {
  349. struct buffer_head *bh;
  351. J_ASSERT (bufs == 0);
  353. jbd_debug(4, "JBD: get descriptorn");
  355. descriptor = journal_get_descriptor_buffer(journal);
  356. if (!descriptor) {
  357. __journal_abort_hard(journal);
  358. continue;
  359. }
  361. bh = jh2bh(descriptor);
  362. jbd_debug(4, "JBD: got buffer %ld (%p)n",
  363. bh->b_blocknr, bh->b_data);
  364. header = (journal_header_t *)&bh->b_data[0];
  365. header->h_magic     = htonl(JFS_MAGIC_NUMBER);
  366. header->h_blocktype = htonl(JFS_DESCRIPTOR_BLOCK);
  367. header->h_sequence  = htonl(commit_transaction->t_tid);
  369. tagp = &bh->b_data[sizeof(journal_header_t)];
  370. space_left = bh->b_size - sizeof(journal_header_t);
  371. first_tag = 1;
  372. set_bit(BH_JWrite, &bh->b_state);
  373. wbuf[bufs++] = bh;
  375. /* Record it so that we can wait for IO
  376.                            completion later */
  377. BUFFER_TRACE(bh, "ph3: file as descriptor");
  378. journal_file_buffer(descriptor, commit_transaction,
  379. BJ_LogCtl);
  380. }
  382. /* Where is the buffer to be written? */
  384. err = journal_next_log_block(journal, &blocknr);
  385. /* If the block mapping failed, just abandon the buffer
  386.    and repeat this loop: we'll fall into the
  387.    refile-on-abort condition above. */
  388. if (err) {
  389. __journal_abort_hard(journal);
  390. continue;
  391. }
  393. /* Bump b_count to prevent truncate from stumbling over
  394.                    the shadowed buffer!  @@@ This can go if we ever get
  395.                    rid of the BJ_IO/BJ_Shadow pairing of buffers. */
  396. atomic_inc(&jh2bh(jh)->b_count);
  398. /* Make a temporary IO buffer with which to write it out
  399.                    (this will requeue both the metadata buffer and the
  400.                    temporary IO buffer). new_bh goes on BJ_IO*/
  402. set_bit(BH_JWrite, &jh2bh(jh)->b_state);
  403. /*
  404.  * akpm: journal_write_metadata_buffer() sets
  405.  * new_bh->b_transaction to commit_transaction.
  406.  * We need to clean this up before we release new_bh
  407.  * (which is of type BJ_IO)
  408.  */
  409. JBUFFER_TRACE(jh, "ph3: write metadata");
  410. flags = journal_write_metadata_buffer(commit_transaction,
  411.       jh, &new_jh, blocknr);
  412. set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
  413. set_bit(BH_Lock, &jh2bh(new_jh)->b_state);
  414. wbuf[bufs++] = jh2bh(new_jh);
  416. /* Record the new block's tag in the current descriptor
  417.                    buffer */
  419. tag_flag = 0;
  420. if (flags & 1)
  421. tag_flag |= JFS_FLAG_ESCAPE;
  422. if (!first_tag)
  423. tag_flag |= JFS_FLAG_SAME_UUID;
  425. tag = (journal_block_tag_t *) tagp;
  426. tag->t_blocknr = htonl(jh2bh(jh)->b_blocknr);
  427. tag->t_flags = htonl(tag_flag);
  428. tagp += sizeof(journal_block_tag_t);
  429. space_left -= sizeof(journal_block_tag_t);
  431. if (first_tag) {
  432. memcpy (tagp, journal->j_uuid, 16);
  433. tagp += 16;
  434. space_left -= 16;
  435. first_tag = 0;
  436. }
  438. /* If there's no more to do, or if the descriptor is full,
  439.    let the IO rip! */
  441. if (bufs == ARRAY_SIZE(wbuf) ||
  442.     commit_transaction->t_buffers == NULL ||
  443.     space_left < sizeof(journal_block_tag_t) + 16) {
  445. jbd_debug(4, "JBD: Submit %d IOsn", bufs);
  447. /* Write an end-of-descriptor marker before
  448.                            submitting the IOs.  "tag" still points to
  449.                            the last tag we set up. */
  451. tag->t_flags |= htonl(JFS_FLAG_LAST_TAG);
  453. start_journal_io:
  454. unlock_journal(journal);
  455. for (i=0; i<bufs; i++) {
  456. struct buffer_head *bh = wbuf[i];
  457. clear_bit(BH_Dirty, &bh->b_state);
  458. bh->b_end_io = journal_end_buffer_io_sync;
  459. submit_bh(WRITE, bh);
  460. }
  461. if (current->need_resched)
  462. schedule();
  463. lock_journal(journal);
  465. /* Force a new descriptor to be generated next
  466.                            time round the loop. */
  467. descriptor = NULL;
  468. bufs = 0;
  469. }
  470. }
  472. /* Lo and behold: we have just managed to send a transaction to
  473.            the log.  Before we can commit it, wait for the IO so far to
  474.            complete.  Control buffers being written are on the
  475.            transaction's t_log_list queue, and metadata buffers are on
  476.            the t_iobuf_list queue.
  478.    Wait for the transactions in reverse order.  That way we are
  479.    less likely to be woken up until all IOs have completed, and
  480.    so we incur less scheduling load.
  481. */
  483. jbd_debug(3, "JBD: commit phase 4n");
  485. /* akpm: these are BJ_IO, and journal_datalist_lock is not needed */
  486.  wait_for_iobuf:
  487. while (commit_transaction->t_iobuf_list != NULL) {
  488. struct buffer_head *bh;
  489. jh = commit_transaction->t_iobuf_list->b_tprev;
  490. bh = jh2bh(jh);
  491. if (buffer_locked(bh)) {
  492. unlock_journal(journal);
  493. wait_on_buffer(bh);
  494. lock_journal(journal);
  495. goto wait_for_iobuf;
  496. }
  498. clear_bit(BH_JWrite, &jh2bh(jh)->b_state);
  500. JBUFFER_TRACE(jh, "ph4: unfile after journal write");
  501. journal_unfile_buffer(jh);
  503. /*
  504.  * akpm: don't put back a buffer_head with stale pointers
  505.  * dangling around.
  506.  */
  507. J_ASSERT_JH(jh, jh->b_transaction != NULL);
  508. jh->b_transaction = NULL;
  510. /*
  511.  * ->t_iobuf_list should contain only dummy buffer_heads
  512.  * which were created by journal_write_metadata_buffer().
  513.  */
  514. bh = jh2bh(jh);
  515. BUFFER_TRACE(bh, "dumping temporary bh");
  516. journal_unlock_journal_head(jh);
  517. __brelse(bh);
  518. J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
  519. put_unused_buffer_head(bh);
  521. /* We also have to unlock and free the corresponding
  522.                    shadowed buffer */
  523. jh = commit_transaction->t_shadow_list->b_tprev;
  524. bh = jh2bh(jh);
  525. clear_bit(BH_JWrite, &bh->b_state);
  526. J_ASSERT_BH(bh, buffer_jdirty(bh));
  528. /* The metadata is now released for reuse, but we need
  529.                    to remember it against this transaction so that when
  530.                    we finally commit, we can do any checkpointing
  531.                    required. */
  532. JBUFFER_TRACE(jh, "file as BJ_Forget");
  533. journal_file_buffer(jh, commit_transaction, BJ_Forget);
  534. /* Wake up any transactions which were waiting for this
  535.    IO to complete */
  536. wake_up(&bh->b_wait);
  537. JBUFFER_TRACE(jh, "brelse shadowed buffer");
  538. __brelse(bh);
  539. }
  541. J_ASSERT (commit_transaction->t_shadow_list == NULL);
  543. jbd_debug(3, "JBD: commit phase 5n");
  545. /* Here we wait for the revoke record and descriptor record buffers */
  546.  wait_for_ctlbuf:
  547. while (commit_transaction->t_log_list != NULL) {
  548. struct buffer_head *bh;
  550. jh = commit_transaction->t_log_list->b_tprev;
  551. bh = jh2bh(jh);
  552. if (buffer_locked(bh)) {
  553. unlock_journal(journal);
  554. wait_on_buffer(bh);
  555. lock_journal(journal);
  556. goto wait_for_ctlbuf;
  557. }
  559. BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
  560. clear_bit(BH_JWrite, &bh->b_state);
  561. journal_unfile_buffer(jh);
  562. jh->b_transaction = NULL;
  563. journal_unlock_journal_head(jh);
  564. put_bh(bh); /* One for getblk */
  565. }
  567. jbd_debug(3, "JBD: commit phase 6n");
  569. if (is_journal_aborted(journal))
  570. goto skip_commit;
  572. /* Done it all: now write the commit record.  We should have
  573.  * cleaned up our previous buffers by now, so if we are in abort
  574.  * mode we can now just skip the rest of the journal write
  575.  * entirely. */
  577. descriptor = journal_get_descriptor_buffer(journal);
  578. if (!descriptor) {
  579. __journal_abort_hard(journal);
  580. goto skip_commit;
  581. }
  583. /* AKPM: buglet - add `i' to tmp! */
  584. for (i = 0; i < jh2bh(descriptor)->b_size; i += 512) {
  585. journal_header_t *tmp =
  586. (journal_header_t*)jh2bh(descriptor)->b_data;
  587. tmp->h_magic = htonl(JFS_MAGIC_NUMBER);
  588. tmp->h_blocktype = htonl(JFS_COMMIT_BLOCK);
  589. tmp->h_sequence = htonl(commit_transaction->t_tid);
  590. }
  592. unlock_journal(journal);
  593. JBUFFER_TRACE(descriptor, "write commit block");
  594. {
  595. struct buffer_head *bh = jh2bh(descriptor);
  596. clear_bit(BH_Dirty, &bh->b_state);
  597. bh->b_end_io = journal_end_buffer_io_sync;
  598. submit_bh(WRITE, bh);
  599. wait_on_buffer(bh);
  600. put_bh(bh); /* One for getblk() */
  601. journal_unlock_journal_head(descriptor);
  602. }
  603. lock_journal(journal);
  605. /* End of a transaction!  Finally, we can do checkpoint
  606.            processing: any buffers committed as a result of this
  607.            transaction can be removed from any checkpoint list it was on
  608.            before. */
  610. skip_commit:
  612. jbd_debug(3, "JBD: commit phase 7n");
  614. J_ASSERT(commit_transaction->t_sync_datalist == NULL);
  615. J_ASSERT(commit_transaction->t_async_datalist == NULL);
  616. J_ASSERT(commit_transaction->t_buffers == NULL);
  617. J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
  618. J_ASSERT(commit_transaction->t_iobuf_list == NULL);
  619. J_ASSERT(commit_transaction->t_shadow_list == NULL);
  620. J_ASSERT(commit_transaction->t_log_list == NULL);
  622. while (commit_transaction->t_forget) {
  623. transaction_t *cp_transaction;
  624. struct buffer_head *bh;
  626. jh = commit_transaction->t_forget;
  627. J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
  628. jh->b_transaction == journal->j_running_transaction);
  630. /*
  631.  * If there is undo-protected committed data against
  632.  * this buffer, then we can remove it now.  If it is a
  633.  * buffer needing such protection, the old frozen_data
  634.  * field now points to a committed version of the
  635.  * buffer, so rotate that field to the new committed
  636.  * data.
  637.  *
  638.  * Otherwise, we can just throw away the frozen data now.
  639.  */
  640. if (jh->b_committed_data) {
  641. kfree(jh->b_committed_data);
  642. jh->b_committed_data = NULL;
  643. if (jh->b_frozen_data) {
  644. jh->b_committed_data = jh->b_frozen_data;
  645. jh->b_frozen_data = NULL;
  646. }
  647. } else if (jh->b_frozen_data) {
  648. kfree(jh->b_frozen_data);
  649. jh->b_frozen_data = NULL;
  650. }
  652. spin_lock(&journal_datalist_lock);
  653. cp_transaction = jh->b_cp_transaction;
  654. if (cp_transaction) {
  655. JBUFFER_TRACE(jh, "remove from old cp transaction");
  656. J_ASSERT_JH(jh, commit_transaction != cp_transaction);
  657. __journal_remove_checkpoint(jh);
  658. }
  660. /* Only re-checkpoint the buffer_head if it is marked
  661.  * dirty.  If the buffer was added to the BJ_Forget list
  662.  * by journal_forget, it may no longer be dirty and
  663.  * there's no point in keeping a checkpoint record for
  664.  * it. */
  665. bh = jh2bh(jh);
  666. if (buffer_jdirty(bh)) {
  667. JBUFFER_TRACE(jh, "add to new checkpointing trans");
  668. __journal_insert_checkpoint(jh, commit_transaction);
  669. JBUFFER_TRACE(jh, "refile for checkpoint writeback");
  670. __journal_refile_buffer(jh);
  671. } else {
  672. J_ASSERT_BH(bh, !buffer_dirty(bh));
  673. J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
  674. __journal_unfile_buffer(jh);
  675. jh->b_transaction = 0;
  676. __journal_remove_journal_head(bh);
  677. __brelse(bh);
  678. }
  679. spin_unlock(&journal_datalist_lock);
  680. }
  682. /* Done with this transaction! */
  684. jbd_debug(3, "JBD: commit phase 8n");
  686. J_ASSERT (commit_transaction->t_state == T_COMMIT);
  687. commit_transaction->t_state = T_FINISHED;
  689. J_ASSERT (commit_transaction == journal->j_committing_transaction);
  690. journal->j_commit_sequence = commit_transaction->t_tid;
  691. journal->j_committing_transaction = NULL;
  693. spin_lock(&journal_datalist_lock);
  694. if (commit_transaction->t_checkpoint_list == NULL) {
  695. __journal_drop_transaction(journal, commit_transaction);
  696. } else {
  697. if (journal->j_checkpoint_transactions == NULL) {
  698. journal->j_checkpoint_transactions = commit_transaction;
  699. commit_transaction->t_cpnext = commit_transaction;
  700. commit_transaction->t_cpprev = commit_transaction;
  701. } else {
  702. commit_transaction->t_cpnext =
  703. journal->j_checkpoint_transactions;
  704. commit_transaction->t_cpprev =
  705. commit_transaction->t_cpnext->t_cpprev;
  706. commit_transaction->t_cpnext->t_cpprev =
  707. commit_transaction;
  708. commit_transaction->t_cpprev->t_cpnext =
  709. commit_transaction;
  710. }
  711. }
  712. spin_unlock(&journal_datalist_lock);
  714. jbd_debug(1, "JBD: commit %d complete, head %dn",
  715.   journal->j_commit_sequence, journal->j_tail_sequence);
  717. unlock_journal(journal);
  718. wake_up(&journal->j_wait_done_commit);
  719. }