fs/jbd2/commit.c

   1 /*
   2  * linux/fs/jbd2/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  */
  15
  16 #include <linux/time.h>
  17 #include <linux/fs.h>
  18 #include <linux/jbd2.h>
  19 #include <linux/errno.h>
  20 #include <linux/slab.h>
  21 #include <linux/mm.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/jiffies.h>
  24 #include <linux/crc32.h>
  25 #include <linux/writeback.h>
  26 #include <linux/backing-dev.h>
  27 #include <linux/bio.h>
  28 #include <linux/blkdev.h>
  29 #include <linux/bitops.h>
  30 #include <trace/events/jbd2.h>
  31 #include <asm/system.h>
  32
  33 /*
  34  * Default IO end handler for temporary BJ_IO buffer_heads.
  35  */
  36 static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
  37 {
  38         BUFFER_TRACE(bh, "");
  39         if (uptodate)
  40                 set_buffer_uptodate(bh);
  41         else
  42                 clear_buffer_uptodate(bh);
  43         unlock_buffer(bh);
  44 }
  45
  46 /*
  47  * When an ext4 file is truncated, it is possible that some pages are not
  48  * successfully freed, because they are attached to a committing transaction.
  49  * After the transaction commits, these pages are left on the LRU, with no
  50  * ->mapping, and with attached buffers.  These pages are trivially reclaimable
  51  * by the VM, but their apparent absence upsets the VM accounting, and it makes
  52  * the numbers in /proc/meminfo look odd.
  53  *
  54  * So here, we have a buffer which has just come off the forget list.  Look to
  55  * see if we can strip all buffers from the backing page.
  56  *
  57  * Called under lock_journal(), and possibly under journal_datalist_lock.  The
  58  * caller provided us with a ref against the buffer, and we drop that here.
  59  */
  60 static void release_buffer_page(struct buffer_head *bh)
  61 {
  62         struct page *page;
  63
  64         if (buffer_dirty(bh))
  65                 goto nope;
  66         if (atomic_read(&bh->b_count) != 1)
  67                 goto nope;
  68         page = bh->b_page;
  69         if (!page)
  70                 goto nope;
  71         if (page->mapping)
  72                 goto nope;
  73
  74         /* OK, it's a truncated page */
  75         if (!trylock_page(page))
  76                 goto nope;
  77
  78         page_cache_get(page);
  79         __brelse(bh);
  80         try_to_free_buffers(page);
  81         unlock_page(page);
  82         page_cache_release(page);
  83         return;
  84
  85 nope:
  86         __brelse(bh);
  87 }
  88
  89 /*
  90  * Done it all: now submit the commit record.  We should have
  91  * cleaned up our previous buffers by now, so if we are in abort
  92  * mode we can now just skip the rest of the journal write
  93  * entirely.
  94  *
  95  * Returns 1 if the journal needs to be aborted or 0 on success
  96  */
  97 static int journal_submit_commit_record(journal_t *journal,
  98                                         transaction_t *commit_transaction,
  99                                         struct buffer_head **cbh,
 100                                         __u32 crc32_sum)
 101 {
 102         struct journal_head *descriptor;
 103         struct commit_header *tmp;
 104         struct buffer_head *bh;
 105         int ret;
 106         struct timespec now = current_kernel_time();
 107
 108         *cbh = NULL;
 109
 110         if (is_journal_aborted(journal))
 111                 return 0;
 112
 113         descriptor = jbd2_journal_get_descriptor_buffer(journal);
 114         if (!descriptor)
 115                 return 1;
 116
 117         bh = jh2bh(descriptor);
 118
 119         tmp = (struct commit_header *)bh->b_data;
 120         tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
 121         tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);
 122         tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
 123         tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
 124         tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
 125
 126         if (JBD2_HAS_COMPAT_FEATURE(journal,
 127                                     JBD2_FEATURE_COMPAT_CHECKSUM)) {
 128                 tmp->h_chksum_type      = JBD2_CRC32_CHKSUM;
 129                 tmp->h_chksum_size      = JBD2_CRC32_CHKSUM_SIZE;
 130                 tmp->h_chksum[0]        = cpu_to_be32(crc32_sum);
 131         }
 132
 133         JBUFFER_TRACE(descriptor, "submit commit block");
 134         lock_buffer(bh);
 135         clear_buffer_dirty(bh);
 136         set_buffer_uptodate(bh);
 137         bh->b_end_io = journal_end_buffer_io_sync;
 138
 139         if (journal->j_flags & JBD2_BARRIER &&
 140             !JBD2_HAS_INCOMPAT_FEATURE(journal,
 141                                        JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))
 142                 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh);
 143         else
 144                 ret = submit_bh(WRITE_SYNC, bh);
 145
 146         *cbh = bh;
 147         return ret;
 148 }
 149
 150 /*
 151  * This function along with journal_submit_commit_record
 152  * allows to write the commit record asynchronously.
 153  */
 154 static int journal_wait_on_commit_record(journal_t *journal,
 155                                          struct buffer_head *bh)
 156 {
 157         int ret = 0;
 158
 159         clear_buffer_dirty(bh);
 160         wait_on_buffer(bh);
 161
 162         if (unlikely(!buffer_uptodate(bh)))
 163                 ret = -EIO;
 164         put_bh(bh);            /* One for getblk() */
 165         jbd2_journal_put_journal_head(bh2jh(bh));
 166
 167         return ret;
 168 }
 169
 170 /*
 171  * write the filemap data using writepage() address_space_operations.
 172  * We don't do block allocation here even for delalloc. We don't
 173  * use writepages() because with dealyed allocation we may be doing
 174  * block allocation in writepages().
 175  */
 176 static int journal_submit_inode_data_buffers(struct address_space *mapping)
 177 {
 178         int ret;
 179         struct writeback_control wbc = {
 180                 .sync_mode =  WB_SYNC_ALL,
 181                 .nr_to_write = mapping->nrpages * 2,
 182                 .range_start = 0,
 183                 .range_end = i_size_read(mapping->host),
 184         };
 185
 186         ret = generic_writepages(mapping, &wbc);
 187         return ret;
 188 }
 189
 190 /*
 191  * Submit all the data buffers of inode associated with the transaction to
 192  * disk.
 193  *
 194  * We are in a committing transaction. Therefore no new inode can be added to
 195  * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
 196  * operate on from being released while we write out pages.
 197  */
 198 static int journal_submit_data_buffers(journal_t *journal,
 199                 transaction_t *commit_transaction)
 200 {
 201         struct jbd2_inode *jinode;
 202         int err, ret = 0;
 203         struct address_space *mapping;
 204
 205         spin_lock(&journal->j_list_lock);
 206         list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
 207                 mapping = jinode->i_vfs_inode->i_mapping;
 208                 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
 209                 spin_unlock(&journal->j_list_lock);
 210                 /*
 211                  * submit the inode data buffers. We use writepage
 212                  * instead of writepages. Because writepages can do
 213                  * block allocation  with delalloc. We need to write
 214                  * only allocated blocks here.
 215                  */
 216                 trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
 217                 err = journal_submit_inode_data_buffers(mapping);
 218                 if (!ret)
 219                         ret = err;
 220                 spin_lock(&journal->j_list_lock);
 221                 J_ASSERT(jinode->i_transaction == commit_transaction);
 222                 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
 223                 smp_mb__after_clear_bit();
 224                 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
 225         }
 226         spin_unlock(&journal->j_list_lock);
 227         return ret;
 228 }
 229
 230 /*
 231  * Wait for data submitted for writeout, refile inodes to proper
 232  * transaction if needed.
 233  *
 234  */
 235 static int journal_finish_inode_data_buffers(journal_t *journal,
 236                 transaction_t *commit_transaction)
 237 {
 238         struct jbd2_inode *jinode, *next_i;
 239         int err, ret = 0;
 240
 241         /* For locking, see the comment in journal_submit_data_buffers() */
 242         spin_lock(&journal->j_list_lock);
 243         list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
 244                 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
 245                 spin_unlock(&journal->j_list_lock);
 246                 err = filemap_fdatawait(jinode->i_vfs_inode->i_mapping);
 247                 if (err) {
 248                         /*
 249                          * Because AS_EIO is cleared by
 250                          * filemap_fdatawait_range(), set it again so
 251                          * that user process can get -EIO from fsync().
 252                          */
 253                         set_bit(AS_EIO,
 254                                 &jinode->i_vfs_inode->i_mapping->flags);
 255
 256                         if (!ret)
 257                                 ret = err;
 258                 }
 259                 spin_lock(&journal->j_list_lock);
 260                 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
 261                 smp_mb__after_clear_bit();
 262                 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
 263         }
 264
 265         /* Now refile inode to proper lists */
 266         list_for_each_entry_safe(jinode, next_i,
 267                                  &commit_transaction->t_inode_list, i_list) {
 268                 list_del(&jinode->i_list);
 269                 if (jinode->i_next_transaction) {
 270                         jinode->i_transaction = jinode->i_next_transaction;
 271                         jinode->i_next_transaction = NULL;
 272                         list_add(&jinode->i_list,
 273                                 &jinode->i_transaction->t_inode_list);
 274                 } else {
 275                         jinode->i_transaction = NULL;
 276                 }
 277         }
 278         spin_unlock(&journal->j_list_lock);
 279
 280         return ret;
 281 }
 282
 283 static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
 284 {
 285         struct page *page = bh->b_page;
 286         char *addr;
 287         __u32 checksum;
 288
 289         addr = kmap_atomic(page, KM_USER0);
 290         checksum = crc32_be(crc32_sum,
 291                 (void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
 292         kunmap_atomic(addr, KM_USER0);
 293
 294         return checksum;
 295 }
 296
 297 static void write_tag_block(int tag_bytes, journal_block_tag_t *tag,
 298                                    unsigned long long block)
 299 {
 300         tag->t_blocknr = cpu_to_be32(block & (u32)~0);
 301         if (tag_bytes > JBD2_TAG_SIZE32)
 302                 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
 303 }
 304
 305 /*
 306  * jbd2_journal_commit_transaction
 307  *
 308  * The primary function for committing a transaction to the log.  This
 309  * function is called by the journal thread to begin a complete commit.
 310  */
 311 void jbd2_journal_commit_transaction(journal_t *journal)
 312 {
 313         struct transaction_stats_s stats;
 314         transaction_t *commit_transaction;
 315         struct journal_head *jh, *new_jh, *descriptor;
 316         struct buffer_head **wbuf = journal->j_wbuf;
 317         int bufs;
 318         int flags;
 319         int err;
 320         unsigned long long blocknr;
 321         ktime_t start_time;
 322         u64 commit_time;
 323         char *tagp = NULL;
 324         journal_header_t *header;
 325         journal_block_tag_t *tag = NULL;
 326         int space_left = 0;
 327         int first_tag = 0;
 328         int tag_flag;
 329         int i, to_free = 0;
 330         int tag_bytes = journal_tag_bytes(journal);
 331         struct buffer_head *cbh = NULL; /* For transactional checksums */
 332         __u32 crc32_sum = ~0;
 333         struct blk_plug plug;
 334
 335         /*
 336          * First job: lock down the current transaction and wait for
 337          * all outstanding updates to complete.
 338          */
 339
 340         /* Do we need to erase the effects of a prior jbd2_journal_flush? */
 341         if (journal->j_flags & JBD2_FLUSHED) {
 342                 jbd_debug(3, "super block updated\n");
 343                 mutex_lock(&journal->j_checkpoint_mutex);
 344                 jbd2_journal_update_sb_log_tail(journal);
 345                 mutex_unlock(&journal->j_checkpoint_mutex);
 346         } else {
 347                 jbd_debug(3, "superblock not updated\n");
 348         }
 349
 350         J_ASSERT(journal->j_running_transaction != NULL);
 351         J_ASSERT(journal->j_committing_transaction == NULL);
 352
 353         commit_transaction = journal->j_running_transaction;
 354         J_ASSERT(commit_transaction->t_state == T_RUNNING);
 355
 356         trace_jbd2_start_commit(journal, commit_transaction);
 357         jbd_debug(1, "JBD2: starting commit of transaction %d\n",
 358                         commit_transaction->t_tid);
 359
 360         write_lock(&journal->j_state_lock);
 361         commit_transaction->t_state = T_LOCKED;
 362
 363         trace_jbd2_commit_locking(journal, commit_transaction);
 364         stats.run.rs_wait = commit_transaction->t_max_wait;
 365         stats.run.rs_locked = jiffies;
 366         stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
 367                                               stats.run.rs_locked);
 368
 369         spin_lock(&commit_transaction->t_handle_lock);
 370         while (atomic_read(&commit_transaction->t_updates)) {
 371                 DEFINE_WAIT(wait);
 372
 373                 prepare_to_wait(&journal->j_wait_updates, &wait,
 374                                         TASK_UNINTERRUPTIBLE);
 375                 if (atomic_read(&commit_transaction->t_updates)) {
 376                         spin_unlock(&commit_transaction->t_handle_lock);
 377                         write_unlock(&journal->j_state_lock);
 378                         schedule();
 379                         write_lock(&journal->j_state_lock);
 380                         spin_lock(&commit_transaction->t_handle_lock);
 381                 }
 382                 finish_wait(&journal->j_wait_updates, &wait);
 383         }
 384         spin_unlock(&commit_transaction->t_handle_lock);
 385
 386         J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
 387                         journal->j_max_transaction_buffers);
 388
 389         /*
 390          * First thing we are allowed to do is to discard any remaining
 391          * BJ_Reserved buffers.  Note, it is _not_ permissible to assume
 392          * that there are no such buffers: if a large filesystem
 393          * operation like a truncate needs to split itself over multiple
 394          * transactions, then it may try to do a jbd2_journal_restart() while
 395          * there are still BJ_Reserved buffers outstanding.  These must
 396          * be released cleanly from the current transaction.
 397          *
 398          * In this case, the filesystem must still reserve write access
 399          * again before modifying the buffer in the new transaction, but
 400          * we do not require it to remember exactly which old buffers it
 401          * has reserved.  This is consistent with the existing behaviour
 402          * that multiple jbd2_journal_get_write_access() calls to the same
 403          * buffer are perfectly permissible.
 404          */
 405         while (commit_transaction->t_reserved_list) {
 406                 jh = commit_transaction->t_reserved_list;
 407                 JBUFFER_TRACE(jh, "reserved, unused: refile");
 408                 /*
 409                  * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
 410                  * leave undo-committed data.
 411                  */
 412                 if (jh->b_committed_data) {
 413                         struct buffer_head *bh = jh2bh(jh);
 414
 415                         jbd_lock_bh_state(bh);
 416                         jbd2_free(jh->b_committed_data, bh->b_size);
 417                         jh->b_committed_data = NULL;
 418                         jbd_unlock_bh_state(bh);
 419                 }
 420                 jbd2_journal_refile_buffer(journal, jh);
 421         }
 422
 423         /*
 424          * Now try to drop any written-back buffers from the journal's
 425          * checkpoint lists.  We do this *before* commit because it potentially
 426          * frees some memory
 427          */
 428         spin_lock(&journal->j_list_lock);
 429         __jbd2_journal_clean_checkpoint_list(journal);
 430         spin_unlock(&journal->j_list_lock);
 431
 432         jbd_debug(3, "JBD2: commit phase 1\n");
 433
 434         /*
 435          * Clear revoked flag to reflect there is no revoked buffers
 436          * in the next transaction which is going to be started.
 437          */
 438         jbd2_clear_buffer_revoked_flags(journal);
 439
 440         /*
 441          * Switch to a new revoke table.
 442          */
 443         jbd2_journal_switch_revoke_table(journal);
 444
 445         trace_jbd2_commit_flushing(journal, commit_transaction);
 446         stats.run.rs_flushing = jiffies;
 447         stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
 448                                              stats.run.rs_flushing);
 449
 450         commit_transaction->t_state = T_FLUSH;
 451         journal->j_committing_transaction = commit_transaction;
 452         journal->j_running_transaction = NULL;
 453         start_time = ktime_get();
 454         commit_transaction->t_log_start = journal->j_head;
 455         wake_up(&journal->j_wait_transaction_locked);
 456         write_unlock(&journal->j_state_lock);
 457
 458         jbd_debug(3, "JBD2: commit phase 2\n");
 459
 460         /*
 461          * Now start flushing things to disk, in the order they appear
 462          * on the transaction lists.  Data blocks go first.
 463          */
 464         err = journal_submit_data_buffers(journal, commit_transaction);
 465         if (err)
 466                 jbd2_journal_abort(journal, err);
 467
 468         blk_start_plug(&plug);
 469         jbd2_journal_write_revoke_records(journal, commit_transaction,
 470                                           WRITE_SYNC);
 471         blk_finish_plug(&plug);
 472
 473         jbd_debug(3, "JBD2: commit phase 2\n");
 474
 475         /*
 476          * Way to go: we have now written out all of the data for a
 477          * transaction!  Now comes the tricky part: we need to write out
 478          * metadata.  Loop over the transaction's entire buffer list:
 479          */
 480         write_lock(&journal->j_state_lock);
 481         commit_transaction->t_state = T_COMMIT;
 482         write_unlock(&journal->j_state_lock);
 483
 484         trace_jbd2_commit_logging(journal, commit_transaction);
 485         stats.run.rs_logging = jiffies;
 486         stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
 487                                                stats.run.rs_logging);
 488         stats.run.rs_blocks =
 489                 atomic_read(&commit_transaction->t_outstanding_credits);
 490         stats.run.rs_blocks_logged = 0;
 491
 492         J_ASSERT(commit_transaction->t_nr_buffers <=
 493                  atomic_read(&commit_transaction->t_outstanding_credits));
 494
 495         err = 0;
 496         descriptor = NULL;
 497         bufs = 0;
 498         blk_start_plug(&plug);
 499         while (commit_transaction->t_buffers) {
 500
 501                 /* Find the next buffer to be journaled... */
 502
 503                 jh = commit_transaction->t_buffers;
 504
 505                 /* If we're in abort mode, we just un-journal the buffer and
 506                    release it. */
 507
 508                 if (is_journal_aborted(journal)) {
 509                         clear_buffer_jbddirty(jh2bh(jh));
 510                         JBUFFER_TRACE(jh, "journal is aborting: refile");
 511                         jbd2_buffer_abort_trigger(jh,
 512                                                   jh->b_frozen_data ?
 513                                                   jh->b_frozen_triggers :
 514                                                   jh->b_triggers);
 515                         jbd2_journal_refile_buffer(journal, jh);
 516                         /* If that was the last one, we need to clean up
 517                          * any descriptor buffers which may have been
 518                          * already allocated, even if we are now
 519                          * aborting. */
 520                         if (!commit_transaction->t_buffers)
 521                                 goto start_journal_io;
 522                         continue;
 523                 }
 524
 525                 /* Make sure we have a descriptor block in which to
 526                    record the metadata buffer. */
 527
 528                 if (!descriptor) {
 529                         struct buffer_head *bh;
 530
 531                         J_ASSERT (bufs == 0);
 532
 533                         jbd_debug(4, "JBD2: get descriptor\n");
 534
 535                         descriptor = jbd2_journal_get_descriptor_buffer(journal);
 536                         if (!descriptor) {
 537                                 jbd2_journal_abort(journal, -EIO);
 538                                 continue;
 539                         }
 540
 541                         bh = jh2bh(descriptor);
 542                         jbd_debug(4, "JBD2: got buffer %llu (%p)\n",
 543                                 (unsigned long long)bh->b_blocknr, bh->b_data);
 544                         header = (journal_header_t *)&bh->b_data[0];
 545                         header->h_magic     = cpu_to_be32(JBD2_MAGIC_NUMBER);
 546                         header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);
 547                         header->h_sequence  = cpu_to_be32(commit_transaction->t_tid);
 548
 549                         tagp = &bh->b_data[sizeof(journal_header_t)];
 550                         space_left = bh->b_size - sizeof(journal_header_t);
 551                         first_tag = 1;
 552                         set_buffer_jwrite(bh);
 553                         set_buffer_dirty(bh);
 554                         wbuf[bufs++] = bh;
 555
 556                         /* Record it so that we can wait for IO
 557                            completion later */
 558                         BUFFER_TRACE(bh, "ph3: file as descriptor");
 559                         jbd2_journal_file_buffer(descriptor, commit_transaction,
 560                                         BJ_LogCtl);
 561                 }
 562
 563                 /* Where is the buffer to be written? */
 564
 565                 err = jbd2_journal_next_log_block(journal, &blocknr);
 566                 /* If the block mapping failed, just abandon the buffer
 567                    and repeat this loop: we'll fall into the
 568                    refile-on-abort condition above. */
 569                 if (err) {
 570                         jbd2_journal_abort(journal, err);
 571                         continue;
 572                 }
 573
 574                 /*
 575                  * start_this_handle() uses t_outstanding_credits to determine
 576                  * the free space in the log, but this counter is changed
 577                  * by jbd2_journal_next_log_block() also.
 578                  */
 579                 atomic_dec(&commit_transaction->t_outstanding_credits);
 580
 581                 /* Bump b_count to prevent truncate from stumbling over
 582                    the shadowed buffer!  @@@ This can go if we ever get
 583                    rid of the BJ_IO/BJ_Shadow pairing of buffers. */
 584                 atomic_inc(&jh2bh(jh)->b_count);
 585
 586                 /* Make a temporary IO buffer with which to write it out
 587                    (this will requeue both the metadata buffer and the
 588                    temporary IO buffer). new_bh goes on BJ_IO*/
 589
 590                 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
 591                 /*
 592                  * akpm: jbd2_journal_write_metadata_buffer() sets
 593                  * new_bh->b_transaction to commit_transaction.
 594                  * We need to clean this up before we release new_bh
 595                  * (which is of type BJ_IO)
 596                  */
 597                 JBUFFER_TRACE(jh, "ph3: write metadata");
 598                 flags = jbd2_journal_write_metadata_buffer(commit_transaction,
 599                                                       jh, &new_jh, blocknr);
 600                 if (flags < 0) {
 601                         jbd2_journal_abort(journal, flags);
 602                         continue;
 603                 }
 604                 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
 605                 wbuf[bufs++] = jh2bh(new_jh);
 606
 607                 /* Record the new block's tag in the current descriptor
 608                    buffer */
 609
 610                 tag_flag = 0;
 611                 if (flags & 1)
 612                         tag_flag |= JBD2_FLAG_ESCAPE;
 613                 if (!first_tag)
 614                         tag_flag |= JBD2_FLAG_SAME_UUID;
 615
 616                 tag = (journal_block_tag_t *) tagp;
 617                 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr);
 618                 tag->t_flags = cpu_to_be32(tag_flag);
 619                 tagp += tag_bytes;
 620                 space_left -= tag_bytes;
 621
 622                 if (first_tag) {
 623                         memcpy (tagp, journal->j_uuid, 16);
 624                         tagp += 16;
 625                         space_left -= 16;
 626                         first_tag = 0;
 627                 }
 628
 629                 /* If there's no more to do, or if the descriptor is full,
 630                    let the IO rip! */
 631
 632                 if (bufs == journal->j_wbufsize ||
 633                     commit_transaction->t_buffers == NULL ||
 634                     space_left < tag_bytes + 16) {
 635
 636                         jbd_debug(4, "JBD2: Submit %d IOs\n", bufs);
 637
 638                         /* Write an end-of-descriptor marker before
 639                            submitting the IOs.  "tag" still points to
 640                            the last tag we set up. */
 641
 642                         tag->t_flags |= cpu_to_be32(JBD2_FLAG_LAST_TAG);
 643
 644 start_journal_io:
 645                         for (i = 0; i < bufs; i++) {
 646                                 struct buffer_head *bh = wbuf[i];
 647                                 /*
 648                                  * Compute checksum.
 649                                  */
 650                                 if (JBD2_HAS_COMPAT_FEATURE(journal,
 651                                         JBD2_FEATURE_COMPAT_CHECKSUM)) {
 652                                         crc32_sum =
 653                                             jbd2_checksum_data(crc32_sum, bh);
 654                                 }
 655
 656                                 lock_buffer(bh);
 657                                 clear_buffer_dirty(bh);
 658                                 set_buffer_uptodate(bh);
 659                                 bh->b_end_io = journal_end_buffer_io_sync;
 660                                 submit_bh(WRITE_SYNC, bh);
 661                         }
 662                         cond_resched();
 663                         stats.run.rs_blocks_logged += bufs;
 664
 665                         /* Force a new descriptor to be generated next
 666                            time round the loop. */
 667                         descriptor = NULL;
 668                         bufs = 0;
 669                 }
 670         }
 671
 672         err = journal_finish_inode_data_buffers(journal, commit_transaction);
 673         if (err) {
 674                 printk(KERN_WARNING
 675                         "JBD2: Detected IO errors while flushing file data "
 676                        "on %s\n", journal->j_devname);
 677                 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
 678                         jbd2_journal_abort(journal, err);
 679                 err = 0;
 680         }
 681
 682         write_lock(&journal->j_state_lock);
 683         J_ASSERT(commit_transaction->t_state == T_COMMIT);
 684         commit_transaction->t_state = T_COMMIT_DFLUSH;
 685         write_unlock(&journal->j_state_lock);
 686         /*
 687          * If the journal is not located on the file system device,
 688          * then we must flush the file system device before we issue
 689          * the commit record
 690          */
 691         if (commit_transaction->t_need_data_flush &&
 692             (journal->j_fs_dev != journal->j_dev) &&
 693             (journal->j_flags & JBD2_BARRIER))
 694                 blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
 695
 696         /* Done it all: now write the commit record asynchronously. */
 697         if (JBD2_HAS_INCOMPAT_FEATURE(journal,
 698                                       JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
 699                 err = journal_submit_commit_record(journal, commit_transaction,
 700                                                  &cbh, crc32_sum);
 701                 if (err)
 702                         __jbd2_journal_abort_hard(journal);
 703         }
 704
 705         blk_finish_plug(&plug);
 706
 707         /* Lo and behold: we have just managed to send a transaction to
 708            the log.  Before we can commit it, wait for the IO so far to
 709            complete.  Control buffers being written are on the
 710            transaction's t_log_list queue, and metadata buffers are on
 711            the t_iobuf_list queue.
 712
 713            Wait for the buffers in reverse order.  That way we are
 714            less likely to be woken up until all IOs have completed, and
 715            so we incur less scheduling load.
 716         */
 717
 718         jbd_debug(3, "JBD2: commit phase 3\n");
 719
 720         /*
 721          * akpm: these are BJ_IO, and j_list_lock is not needed.
 722          * See __journal_try_to_free_buffer.
 723          */
 724 wait_for_iobuf:
 725         while (commit_transaction->t_iobuf_list != NULL) {
 726                 struct buffer_head *bh;
 727
 728                 jh = commit_transaction->t_iobuf_list->b_tprev;
 729                 bh = jh2bh(jh);
 730                 if (buffer_locked(bh)) {
 731                         wait_on_buffer(bh);
 732                         goto wait_for_iobuf;
 733                 }
 734                 if (cond_resched())
 735                         goto wait_for_iobuf;
 736
 737                 if (unlikely(!buffer_uptodate(bh)))
 738                         err = -EIO;
 739
 740                 clear_buffer_jwrite(bh);
 741
 742                 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
 743                 jbd2_journal_unfile_buffer(journal, jh);
 744
 745                 /*
 746                  * ->t_iobuf_list should contain only dummy buffer_heads
 747                  * which were created by jbd2_journal_write_metadata_buffer().
 748                  */
 749                 BUFFER_TRACE(bh, "dumping temporary bh");
 750                 jbd2_journal_put_journal_head(jh);
 751                 __brelse(bh);
 752                 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
 753                 free_buffer_head(bh);
 754
 755                 /* We also have to unlock and free the corresponding
 756                    shadowed buffer */
 757                 jh = commit_transaction->t_shadow_list->b_tprev;
 758                 bh = jh2bh(jh);
 759                 clear_bit(BH_JWrite, &bh->b_state);
 760                 J_ASSERT_BH(bh, buffer_jbddirty(bh));
 761
 762                 /* The metadata is now released for reuse, but we need
 763                    to remember it against this transaction so that when
 764                    we finally commit, we can do any checkpointing
 765                    required. */
 766                 JBUFFER_TRACE(jh, "file as BJ_Forget");
 767                 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
 768                 /*
 769                  * Wake up any transactions which were waiting for this IO to
 770                  * complete. The barrier must be here so that changes by
 771                  * jbd2_journal_file_buffer() take effect before wake_up_bit()
 772                  * does the waitqueue check.
 773                  */
 774                 smp_mb();
 775                 wake_up_bit(&bh->b_state, BH_Unshadow);
 776                 JBUFFER_TRACE(jh, "brelse shadowed buffer");
 777                 __brelse(bh);
 778         }
 779
 780         J_ASSERT (commit_transaction->t_shadow_list == NULL);
 781
 782         jbd_debug(3, "JBD2: commit phase 4\n");
 783
 784         /* Here we wait for the revoke record and descriptor record buffers */
 785  wait_for_ctlbuf:
 786         while (commit_transaction->t_log_list != NULL) {
 787                 struct buffer_head *bh;
 788
 789                 jh = commit_transaction->t_log_list->b_tprev;
 790                 bh = jh2bh(jh);
 791                 if (buffer_locked(bh)) {
 792                         wait_on_buffer(bh);
 793                         goto wait_for_ctlbuf;
 794                 }
 795                 if (cond_resched())
 796                         goto wait_for_ctlbuf;
 797
 798                 if (unlikely(!buffer_uptodate(bh)))
 799                         err = -EIO;
 800
 801                 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
 802                 clear_buffer_jwrite(bh);
 803                 jbd2_journal_unfile_buffer(journal, jh);
 804                 jbd2_journal_put_journal_head(jh);
 805                 __brelse(bh);           /* One for getblk */
 806                 /* AKPM: bforget here */
 807         }
 808
 809         if (err)
 810                 jbd2_journal_abort(journal, err);
 811
 812         jbd_debug(3, "JBD2: commit phase 5\n");
 813         write_lock(&journal->j_state_lock);
 814         J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
 815         commit_transaction->t_state = T_COMMIT_JFLUSH;
 816         write_unlock(&journal->j_state_lock);
 817
 818         if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
 819                                        JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
 820                 err = journal_submit_commit_record(journal, commit_transaction,
 821                                                 &cbh, crc32_sum);
 822                 if (err)
 823                         __jbd2_journal_abort_hard(journal);
 824         }
 825         if (cbh)
 826                 err = journal_wait_on_commit_record(journal, cbh);
 827         if (JBD2_HAS_INCOMPAT_FEATURE(journal,
 828                                       JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT) &&
 829             journal->j_flags & JBD2_BARRIER) {
 830                 blkdev_issue_flush(journal->j_dev, GFP_KERNEL, NULL);
 831         }
 832
 833         if (err)
 834                 jbd2_journal_abort(journal, err);
 835
 836         /* End of a transaction!  Finally, we can do checkpoint
 837            processing: any buffers committed as a result of this
 838            transaction can be removed from any checkpoint list it was on
 839            before. */
 840
 841         jbd_debug(3, "JBD2: commit phase 6\n");
 842
 843         J_ASSERT(list_empty(&commit_transaction->t_inode_list));
 844         J_ASSERT(commit_transaction->t_buffers == NULL);
 845         J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
 846         J_ASSERT(commit_transaction->t_iobuf_list == NULL);
 847         J_ASSERT(commit_transaction->t_shadow_list == NULL);
 848         J_ASSERT(commit_transaction->t_log_list == NULL);
 849
 850 restart_loop:
 851         /*
 852          * As there are other places (journal_unmap_buffer()) adding buffers
 853          * to this list we have to be careful and hold the j_list_lock.
 854          */
 855         spin_lock(&journal->j_list_lock);
 856         while (commit_transaction->t_forget) {
 857                 transaction_t *cp_transaction;
 858                 struct buffer_head *bh;
 859                 int try_to_free = 0;
 860
 861                 jh = commit_transaction->t_forget;
 862                 spin_unlock(&journal->j_list_lock);
 863                 bh = jh2bh(jh);
 864                 /*
 865                  * Get a reference so that bh cannot be freed before we are
 866                  * done with it.
 867                  */
 868                 get_bh(bh);
 869                 jbd_lock_bh_state(bh);
 870                 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction);
 871
 872                 /*
 873                  * If there is undo-protected committed data against
 874                  * this buffer, then we can remove it now.  If it is a
 875                  * buffer needing such protection, the old frozen_data
 876                  * field now points to a committed version of the
 877                  * buffer, so rotate that field to the new committed
 878                  * data.
 879                  *
 880                  * Otherwise, we can just throw away the frozen data now.
 881                  *
 882                  * We also know that the frozen data has already fired
 883                  * its triggers if they exist, so we can clear that too.
 884                  */
 885                 if (jh->b_committed_data) {
 886                         jbd2_free(jh->b_committed_data, bh->b_size);
 887                         jh->b_committed_data = NULL;
 888                         if (jh->b_frozen_data) {
 889                                 jh->b_committed_data = jh->b_frozen_data;
 890                                 jh->b_frozen_data = NULL;
 891                                 jh->b_frozen_triggers = NULL;
 892                         }
 893                 } else if (jh->b_frozen_data) {
 894                         jbd2_free(jh->b_frozen_data, bh->b_size);
 895                         jh->b_frozen_data = NULL;
 896                         jh->b_frozen_triggers = NULL;
 897                 }
 898
 899                 spin_lock(&journal->j_list_lock);
 900                 cp_transaction = jh->b_cp_transaction;
 901                 if (cp_transaction) {
 902                         JBUFFER_TRACE(jh, "remove from old cp transaction");
 903                         cp_transaction->t_chp_stats.cs_dropped++;
 904                         __jbd2_journal_remove_checkpoint(jh);
 905                 }
 906
 907                 /* Only re-checkpoint the buffer_head if it is marked
 908                  * dirty.  If the buffer was added to the BJ_Forget list
 909                  * by jbd2_journal_forget, it may no longer be dirty and
 910                  * there's no point in keeping a checkpoint record for
 911                  * it. */
 912
 913                 /* A buffer which has been freed while still being
 914                  * journaled by a previous transaction may end up still
 915                  * being dirty here, but we want to avoid writing back
 916                  * that buffer in the future after the "add to orphan"
 917                  * operation been committed,  That's not only a performance
 918                  * gain, it also stops aliasing problems if the buffer is
 919                  * left behind for writeback and gets reallocated for another
 920                  * use in a different page. */
 921                 if (buffer_freed(bh) && !jh->b_next_transaction) {
 922                         clear_buffer_freed(bh);
 923                         clear_buffer_jbddirty(bh);
 924                 }
 925
 926                 if (buffer_jbddirty(bh)) {
 927                         JBUFFER_TRACE(jh, "add to new checkpointing trans");
 928                         __jbd2_journal_insert_checkpoint(jh, commit_transaction);
 929                         if (is_journal_aborted(journal))
 930                                 clear_buffer_jbddirty(bh);
 931                 } else {
 932                         J_ASSERT_BH(bh, !buffer_dirty(bh));
 933                         /*
 934                          * The buffer on BJ_Forget list and not jbddirty means
 935                          * it has been freed by this transaction and hence it
 936                          * could not have been reallocated until this
 937                          * transaction has committed. *BUT* it could be
 938                          * reallocated once we have written all the data to
 939                          * disk and before we process the buffer on BJ_Forget
 940                          * list.
 941                          */
 942                         if (!jh->b_next_transaction)
 943                                 try_to_free = 1;
 944                 }
 945                 JBUFFER_TRACE(jh, "refile or unfile buffer");
 946                 __jbd2_journal_refile_buffer(jh);
 947                 jbd_unlock_bh_state(bh);
 948                 if (try_to_free)
 949                         release_buffer_page(bh);        /* Drops bh reference */
 950                 else
 951                         __brelse(bh);
 952                 cond_resched_lock(&journal->j_list_lock);
 953         }
 954         spin_unlock(&journal->j_list_lock);
 955         /*
 956          * This is a bit sleazy.  We use j_list_lock to protect transition
 957          * of a transaction into T_FINISHED state and calling
 958          * __jbd2_journal_drop_transaction(). Otherwise we could race with
 959          * other checkpointing code processing the transaction...
 960          */
 961         write_lock(&journal->j_state_lock);
 962         spin_lock(&journal->j_list_lock);
 963         /*
 964          * Now recheck if some buffers did not get attached to the transaction
 965          * while the lock was dropped...
 966          */
 967         if (commit_transaction->t_forget) {
 968                 spin_unlock(&journal->j_list_lock);
 969                 write_unlock(&journal->j_state_lock);
 970                 goto restart_loop;
 971         }
 972
 973         /* Done with this transaction! */
 974
 975         jbd_debug(3, "JBD2: commit phase 7\n");
 976
 977         J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
 978
 979         commit_transaction->t_start = jiffies;
 980         stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
 981                                               commit_transaction->t_start);
 982
 983         /*
 984          * File the transaction statistics
 985          */
 986         stats.ts_tid = commit_transaction->t_tid;
 987         stats.run.rs_handle_count =
 988                 atomic_read(&commit_transaction->t_handle_count);
 989         trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
 990                              commit_transaction->t_tid, &stats.run);
 991
 992         /*
 993          * Calculate overall stats
 994          */
 995         spin_lock(&journal->j_history_lock);
 996         journal->j_stats.ts_tid++;
 997         journal->j_stats.run.rs_wait += stats.run.rs_wait;
 998         journal->j_stats.run.rs_running += stats.run.rs_running;
 999         journal->j_stats.run.rs_locked += stats.run.rs_locked;
1000         journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
1001         journal->j_stats.run.rs_logging += stats.run.rs_logging;
1002         journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
1003         journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
1004         journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
1005         spin_unlock(&journal->j_history_lock);
1006
1007         commit_transaction->t_state = T_FINISHED;
1008         J_ASSERT(commit_transaction == journal->j_committing_transaction);
1009         journal->j_commit_sequence = commit_transaction->t_tid;
1010         journal->j_committing_transaction = NULL;
1011         commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
1012
1013         /*
1014          * weight the commit time higher than the average time so we don't
1015          * react too strongly to vast changes in the commit time
1016          */
1017         if (likely(journal->j_average_commit_time))
1018                 journal->j_average_commit_time = (commit_time +
1019                                 journal->j_average_commit_time*3) / 4;
1020         else
1021                 journal->j_average_commit_time = commit_time;
1022         write_unlock(&journal->j_state_lock);
1023
1024         if (commit_transaction->t_checkpoint_list == NULL &&
1025             commit_transaction->t_checkpoint_io_list == NULL) {
1026                 __jbd2_journal_drop_transaction(journal, commit_transaction);
1027                 to_free = 1;
1028         } else {
1029                 if (journal->j_checkpoint_transactions == NULL) {
1030                         journal->j_checkpoint_transactions = commit_transaction;
1031                         commit_transaction->t_cpnext = commit_transaction;
1032                         commit_transaction->t_cpprev = commit_transaction;
1033                 } else {
1034                         commit_transaction->t_cpnext =
1035                                 journal->j_checkpoint_transactions;
1036                         commit_transaction->t_cpprev =
1037                                 commit_transaction->t_cpnext->t_cpprev;
1038                         commit_transaction->t_cpnext->t_cpprev =
1039                                 commit_transaction;
1040                         commit_transaction->t_cpprev->t_cpnext =
1041                                 commit_transaction;
1042                 }
1043         }
1044         spin_unlock(&journal->j_list_lock);
1045
1046         if (journal->j_commit_callback)
1047                 journal->j_commit_callback(journal, commit_transaction);
1048
1049         trace_jbd2_end_commit(journal, commit_transaction);
1050         jbd_debug(1, "JBD2: commit %d complete, head %d\n",
1051                   journal->j_commit_sequence, journal->j_tail_sequence);
1052         if (to_free)
1053                 jbd2_journal_free_transaction(commit_transaction);
1054
1055         wake_up(&journal->j_wait_done_commit);
1056 }