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