Пример #1
0
/*
 * Wait for a specified commit to complete.
 * The caller may not hold the journal lock.
 */
int log_wait_commit(journal_t *journal, tid_t tid)
{
	int err = 0;

#ifdef CONFIG_JBD_DEBUG
	spin_lock(&journal->j_state_lock);
	if (!tid_geq(journal->j_commit_request, tid)) {
		printk(KERN_EMERG
		       "%s: error: j_commit_request=%d, tid=%d\n",
		       __func__, journal->j_commit_request, tid);
	}
	spin_unlock(&journal->j_state_lock);
#endif
	spin_lock(&journal->j_state_lock);
	if (!tid_geq(journal->j_commit_waited, tid))
		journal->j_commit_waited = tid;
	while (tid_gt(tid, journal->j_commit_sequence)) {
		jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
				  tid, journal->j_commit_sequence);
		wake_up(&journal->j_wait_commit);
		spin_unlock(&journal->j_state_lock);
		wait_event(journal->j_wait_done_commit,
				!tid_gt(tid, journal->j_commit_sequence));
		spin_lock(&journal->j_state_lock);
	}
	spin_unlock(&journal->j_state_lock);

	if (unlikely(is_journal_aborted(journal))) {
		printk(KERN_EMERG "journal commit I/O error\n");
		err = -EIO;
	}
	return err;
}
Пример #2
0
int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)
{
	transaction_t *transaction = handle->h_transaction;
	journal_t *journal = transaction->t_journal;
	tid_t		tid;
	int		need_to_start, ret;

	if (is_handle_aborted(handle))
		return 0;

	J_ASSERT(atomic_read(&transaction->t_updates) > 0);
	J_ASSERT(journal_current_handle() == handle);

	read_lock(&journal->j_state_lock);
	spin_lock(&transaction->t_handle_lock);
	atomic_sub(handle->h_buffer_credits,
		   &transaction->t_outstanding_credits);
	if (atomic_dec_and_test(&transaction->t_updates))
		wake_up(&journal->j_wait_updates);
	spin_unlock(&transaction->t_handle_lock);

	jbd_debug(2, "restarting handle %p\n", handle);
	tid = transaction->t_tid;
	need_to_start = !tid_geq(journal->j_commit_request, tid);
	read_unlock(&journal->j_state_lock);
	if (need_to_start)
		jbd2_log_start_commit(journal, tid);

	lock_map_release(&handle->h_lockdep_map);
	handle->h_buffer_credits = nblocks;
	ret = start_this_handle(journal, handle, gfp_mask);
	return ret;
}
Пример #3
0
/*
 * Called under j_state_lock.  Returns true if a transaction commit was started.
 */
int __log_start_commit(journal_t *journal, tid_t target)
{
	/*
	 * The only transaction we can possibly wait upon is the
	 * currently running transaction (if it exists).  Otherwise,
	 * the target tid must be an old one.
	 */
	if (journal->j_running_transaction &&
	    journal->j_running_transaction->t_tid == target) {
		/*
		 * We want a new commit: OK, mark the request and wakeup the
		 * commit thread.  We do _not_ do the commit ourselves.
		 */

		journal->j_commit_request = target;
		jbd_debug(1, "JBD: requesting commit %d/%d\n",
			  journal->j_commit_request,
			  journal->j_commit_sequence);
		wake_up(&journal->j_wait_commit);
		return 1;
	} else if (!tid_geq(journal->j_commit_request, target))
		/* This should never happen, but if it does, preserve
		   the evidence before kjournald goes into a loop and
		   increments j_commit_sequence beyond all recognition. */
		WARN_ONCE(1, "jbd: bad log_start_commit: %u %u %u %u\n",
		    journal->j_commit_request, journal->j_commit_sequence,
		    target, journal->j_running_transaction ?
		    journal->j_running_transaction->t_tid : 0);
	return 0;
}
Пример #4
0
/*
 * Called under j_state_lock.  Returns true if a transaction was started.
 */
int __log_start_commit(journal_t *journal, tid_t target)
{
    /*
     * Are we already doing a recent enough commit?
     */
    if (!tid_geq(journal->j_commit_request, target)) {
        /*
         * We want a new commit: OK, mark the request and wakup the
         * commit thread.  We do _not_ do the commit ourselves.
         */

        journal->j_commit_request = target;
        jbd_debug(1, "JBD: requesting commit %d/%d\n",
                  journal->j_commit_request,
                  journal->j_commit_sequence);
        wake_up(&journal->j_wait_commit);
        return 1;
    }
    return 0;
}
Пример #5
0
/*
 * Return 1 if a given transaction has not yet sent barrier request
 * connected with a transaction commit. If 0 is returned, transaction
 * may or may not have sent the barrier. Used to avoid sending barrier
 * twice in common cases.
 */
int journal_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
{
	int ret = 0;
	transaction_t *commit_trans;

	if (!(journal->j_flags & JFS_BARRIER))
		return 0;
	spin_lock(&journal->j_state_lock);
	/* Transaction already committed? */
	if (tid_geq(journal->j_commit_sequence, tid))
		goto out;
	/*
	 * Transaction is being committed and we already proceeded to
	 * writing commit record?
	 */
	commit_trans = journal->j_committing_transaction;
	if (commit_trans && commit_trans->t_tid == tid &&
	    commit_trans->t_state >= T_COMMIT_RECORD)
		goto out;
	ret = 1;
out:
	spin_unlock(&journal->j_state_lock);
	return ret;
}
Пример #6
0
static int do_one_pass(journal_t *journal,
			struct recovery_info *info, enum passtype pass)
{
	unsigned int		first_commit_ID, next_commit_ID;
	unsigned long		next_log_block;
	int			err, success = 0;
	journal_superblock_t *	sb;
	journal_header_t * 	tmp;
	struct buffer_head *	bh;
	unsigned int		sequence;
	int			blocktype;

	/* Precompute the maximum metadata descriptors in a descriptor block */
	int			MAX_BLOCKS_PER_DESC;
	MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t))
			       / sizeof(journal_block_tag_t));

	/* 
	 * First thing is to establish what we expect to find in the log
	 * (in terms of transaction IDs), and where (in terms of log
	 * block offsets): query the superblock.  
	 */

	sb = journal->j_superblock;
	next_commit_ID = be32_to_cpu(sb->s_sequence);
	next_log_block = be32_to_cpu(sb->s_start);

	first_commit_ID = next_commit_ID;
	if (pass == PASS_SCAN)
		info->start_transaction = first_commit_ID;

	jbd_debug(1, "Starting recovery pass %d\n", pass);

	/*
	 * Now we walk through the log, transaction by transaction,
	 * making sure that each transaction has a commit block in the
	 * expected place.  Each complete transaction gets replayed back
	 * into the main filesystem. 
	 */

	while (1) {
		int			flags;
		char *			tagp;
		journal_block_tag_t *	tag;
		struct buffer_head *	obh;
		struct buffer_head *	nbh;

		cond_resched();		/* We're under lock_kernel() */

		/* If we already know where to stop the log traversal,
		 * check right now that we haven't gone past the end of
		 * the log. */

		if (pass != PASS_SCAN)
			if (tid_geq(next_commit_ID, info->end_transaction))
				break;

		jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
			  next_commit_ID, next_log_block, journal->j_last);

		/* Skip over each chunk of the transaction looking
		 * either the next descriptor block or the final commit
		 * record. */

		jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
		err = jread(&bh, journal, next_log_block);
		if (err)
			goto failed;

		next_log_block++;
		wrap(journal, next_log_block);

		/* What kind of buffer is it? 
		 * 
		 * If it is a descriptor block, check that it has the
		 * expected sequence number.  Otherwise, we're all done
		 * here. */

		tmp = (journal_header_t *)bh->b_data;

		if (tmp->h_magic != cpu_to_be32(JFS_MAGIC_NUMBER)) {
			brelse(bh);
			break;
		}

		blocktype = be32_to_cpu(tmp->h_blocktype);
		sequence = be32_to_cpu(tmp->h_sequence);
		jbd_debug(3, "Found magic %d, sequence %d\n", 
			  blocktype, sequence);

		if (sequence != next_commit_ID) {
			brelse(bh);
			break;
		}

		/* OK, we have a valid descriptor block which matches
		 * all of the sequence number checks.  What are we going
		 * to do with it?  That depends on the pass... */

		switch(blocktype) {
		case JFS_DESCRIPTOR_BLOCK:
			/* If it is a valid descriptor block, replay it
			 * in pass REPLAY; otherwise, just skip over the
			 * blocks it describes. */
			if (pass != PASS_REPLAY) {
				next_log_block +=
					count_tags(bh, journal->j_blocksize);
				wrap(journal, next_log_block);
				brelse(bh);
				continue;
			}

			/* A descriptor block: we can now write all of
			 * the data blocks.  Yay, useful work is finally
			 * getting done here! */

			tagp = &bh->b_data[sizeof(journal_header_t)];
			while ((tagp - bh->b_data +sizeof(journal_block_tag_t))
			       <= journal->j_blocksize) {
				unsigned long io_block;

				tag = (journal_block_tag_t *) tagp;
				flags = be32_to_cpu(tag->t_flags);

				io_block = next_log_block++;
				wrap(journal, next_log_block);
				err = jread(&obh, journal, io_block);
				if (err) {
					/* Recover what we can, but
					 * report failure at the end. */
					success = err;
					printk (KERN_ERR 
						"JBD: IO error %d recovering "
						"block %ld in log\n",
						err, io_block);
				} else {
					unsigned long blocknr;

					J_ASSERT(obh != NULL);
					blocknr = be32_to_cpu(tag->t_blocknr);

					/* If the block has been
					 * revoked, then we're all done
					 * here. */
					if (journal_test_revoke
					    (journal, blocknr, 
					     next_commit_ID)) {
						brelse(obh);
						++info->nr_revoke_hits;
						goto skip_write;
					}

					/* Find a buffer for the new
					 * data being restored */
					nbh = __getblk(journal->j_fs_dev,
							blocknr,
							journal->j_blocksize);
					if (nbh == NULL) {
						printk(KERN_ERR 
						       "JBD: Out of memory "
						       "during recovery.\n");
						err = -ENOMEM;
						brelse(bh);
						brelse(obh);
						goto failed;
					}

					lock_buffer(nbh);
					memcpy(nbh->b_data, obh->b_data,
							journal->j_blocksize);
					if (flags & JFS_FLAG_ESCAPE) {
						*((__be32 *)bh->b_data) =
						cpu_to_be32(JFS_MAGIC_NUMBER);
					}

					BUFFER_TRACE(nbh, "marking dirty");
					set_buffer_uptodate(nbh);
					mark_buffer_dirty(nbh);
					BUFFER_TRACE(nbh, "marking uptodate");
					++info->nr_replays;
					/* ll_rw_block(WRITE, 1, &nbh); */
					unlock_buffer(nbh);
					brelse(obh);
					brelse(nbh);
				}

			skip_write:
				tagp += sizeof(journal_block_tag_t);
				if (!(flags & JFS_FLAG_SAME_UUID))
					tagp += 16;

				if (flags & JFS_FLAG_LAST_TAG)
					break;
			}

			brelse(bh);
			continue;

		case JFS_COMMIT_BLOCK:
			/* Found an expected commit block: not much to
			 * do other than move on to the next sequence
			 * number. */
			brelse(bh);
			next_commit_ID++;
			continue;

		case JFS_REVOKE_BLOCK:
			/* If we aren't in the REVOKE pass, then we can
			 * just skip over this block. */
			if (pass != PASS_REVOKE) {
				brelse(bh);
				continue;
			}

			err = scan_revoke_records(journal, bh,
						  next_commit_ID, info);
			brelse(bh);
			if (err)
				goto failed;
			continue;

		default:
			jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
				  blocktype);
			goto done;
		}
	}

 done:
	/* 
	 * We broke out of the log scan loop: either we came to the
	 * known end of the log or we found an unexpected block in the
	 * log.  If the latter happened, then we know that the "current"
	 * transaction marks the end of the valid log.
	 */

	if (pass == PASS_SCAN)
		info->end_transaction = next_commit_ID;
	else {
		/* It's really bad news if different passes end up at
		 * different places (but possible due to IO errors). */
		if (info->end_transaction != next_commit_ID) {
			printk (KERN_ERR "JBD: recovery pass %d ended at "
				"transaction %u, expected %u\n",
				pass, next_commit_ID, info->end_transaction);
			if (!success)
				success = -EIO;
		}
	}

	return success;

 failed:
	return err;
}
Пример #7
0
/*
 * journal_commit_transaction
 *
 * The primary function for committing a transaction to the log.  This
 * function is called by the journal thread to begin a complete commit.
 */
void journal_commit_transaction(journal_t *journal)
{
    transaction_t *commit_transaction;
    struct journal_head *jh, *new_jh, *descriptor;
    struct buffer_head **wbuf = journal->j_wbuf;
    int bufs;
    int flags;
    int err;
    unsigned int blocknr;
    ktime_t start_time;
    u64 commit_time;
    char *tagp = NULL;
    journal_header_t *header;
    journal_block_tag_t *tag = NULL;
    int space_left = 0;
    int first_tag = 0;
    int tag_flag;
    int i;
    struct blk_plug plug;
    int write_op = WRITE;

    /*
     * First job: lock down the current transaction and wait for
     * all outstanding updates to complete.
     */

    /* Do we need to erase the effects of a prior journal_flush? */
    if (journal->j_flags & JFS_FLUSHED) {
        jbd_debug(3, "super block updated\n");
        mutex_lock(&journal->j_checkpoint_mutex);
        /*
         * We hold j_checkpoint_mutex so tail cannot change under us.
         * We don't need any special data guarantees for writing sb
         * since journal is empty and it is ok for write to be
         * flushed only with transaction commit.
         */
        journal_update_sb_log_tail(journal, journal->j_tail_sequence,
                                   journal->j_tail, WRITE_SYNC);
        mutex_unlock(&journal->j_checkpoint_mutex);
    } else {
        jbd_debug(3, "superblock not updated\n");
    }

    J_ASSERT(journal->j_running_transaction != NULL);
    J_ASSERT(journal->j_committing_transaction == NULL);

    commit_transaction = journal->j_running_transaction;
    J_ASSERT(commit_transaction->t_state == T_RUNNING);

    trace_jbd_start_commit(journal, commit_transaction);
    jbd_debug(1, "JBD: starting commit of transaction %d\n",
              commit_transaction->t_tid);

    spin_lock(&journal->j_state_lock);
    commit_transaction->t_state = T_LOCKED;

    trace_jbd_commit_locking(journal, commit_transaction);
    spin_lock(&commit_transaction->t_handle_lock);
    while (commit_transaction->t_updates) {
        DEFINE_WAIT(wait);

        prepare_to_wait(&journal->j_wait_updates, &wait,
                        TASK_UNINTERRUPTIBLE);
        if (commit_transaction->t_updates) {
            spin_unlock(&commit_transaction->t_handle_lock);
            spin_unlock(&journal->j_state_lock);
            schedule();
            spin_lock(&journal->j_state_lock);
            spin_lock(&commit_transaction->t_handle_lock);
        }
        finish_wait(&journal->j_wait_updates, &wait);
    }
    spin_unlock(&commit_transaction->t_handle_lock);

    J_ASSERT (commit_transaction->t_outstanding_credits <=
              journal->j_max_transaction_buffers);

    /*
     * First thing we are allowed to do is to discard any remaining
     * BJ_Reserved buffers.  Note, it is _not_ permissible to assume
     * that there are no such buffers: if a large filesystem
     * operation like a truncate needs to split itself over multiple
     * transactions, then it may try to do a journal_restart() while
     * there are still BJ_Reserved buffers outstanding.  These must
     * be released cleanly from the current transaction.
     *
     * In this case, the filesystem must still reserve write access
     * again before modifying the buffer in the new transaction, but
     * we do not require it to remember exactly which old buffers it
     * has reserved.  This is consistent with the existing behaviour
     * that multiple journal_get_write_access() calls to the same
     * buffer are perfectly permissible.
     */
    while (commit_transaction->t_reserved_list) {
        jh = commit_transaction->t_reserved_list;
        JBUFFER_TRACE(jh, "reserved, unused: refile");
        /*
         * A journal_get_undo_access()+journal_release_buffer() may
         * leave undo-committed data.
         */
        if (jh->b_committed_data) {
            struct buffer_head *bh = jh2bh(jh);

            jbd_lock_bh_state(bh);
            jbd_free(jh->b_committed_data, bh->b_size);
            jh->b_committed_data = NULL;
            jbd_unlock_bh_state(bh);
        }
        journal_refile_buffer(journal, jh);
    }

    /*
     * Now try to drop any written-back buffers from the journal's
     * checkpoint lists.  We do this *before* commit because it potentially
     * frees some memory
     */
    spin_lock(&journal->j_list_lock);
    __journal_clean_checkpoint_list(journal);
    spin_unlock(&journal->j_list_lock);

    jbd_debug (3, "JBD: commit phase 1\n");

    /*
     * Clear revoked flag to reflect there is no revoked buffers
     * in the next transaction which is going to be started.
     */
    journal_clear_buffer_revoked_flags(journal);

    /*
     * Switch to a new revoke table.
     */
    journal_switch_revoke_table(journal);

    trace_jbd_commit_flushing(journal, commit_transaction);
    commit_transaction->t_state = T_FLUSH;
    journal->j_committing_transaction = commit_transaction;
    journal->j_running_transaction = NULL;
    start_time = ktime_get();
    commit_transaction->t_log_start = journal->j_head;
    wake_up(&journal->j_wait_transaction_locked);
    spin_unlock(&journal->j_state_lock);

    jbd_debug (3, "JBD: commit phase 2\n");

    if (tid_geq(journal->j_commit_waited, commit_transaction->t_tid))
        write_op = WRITE_SYNC;

    /*
     * Now start flushing things to disk, in the order they appear
     * on the transaction lists.  Data blocks go first.
     */
    blk_start_plug(&plug);
    err = journal_submit_data_buffers(journal, commit_transaction,
                                      write_op);
    blk_finish_plug(&plug);

    /*
     * Wait for all previously submitted IO to complete.
     */
    spin_lock(&journal->j_list_lock);
    while (commit_transaction->t_locked_list) {
        struct buffer_head *bh;

        jh = commit_transaction->t_locked_list->b_tprev;
        bh = jh2bh(jh);
        get_bh(bh);
        if (buffer_locked(bh)) {
            spin_unlock(&journal->j_list_lock);
            wait_on_buffer(bh);
            spin_lock(&journal->j_list_lock);
        }
        if (unlikely(!buffer_uptodate(bh))) {
            if (!trylock_page(bh->b_page)) {
                spin_unlock(&journal->j_list_lock);
                lock_page(bh->b_page);
                spin_lock(&journal->j_list_lock);
            }
            if (bh->b_page->mapping)
                set_bit(AS_EIO, &bh->b_page->mapping->flags);

            unlock_page(bh->b_page);
            SetPageError(bh->b_page);
            err = -EIO;
        }
        if (!inverted_lock(journal, bh)) {
            put_bh(bh);
            spin_lock(&journal->j_list_lock);
            continue;
        }
        if (buffer_jbd(bh) && bh2jh(bh) == jh &&
                jh->b_transaction == commit_transaction &&
                jh->b_jlist == BJ_Locked)
            __journal_unfile_buffer(jh);
        jbd_unlock_bh_state(bh);
        release_data_buffer(bh);
        cond_resched_lock(&journal->j_list_lock);
    }
    spin_unlock(&journal->j_list_lock);

    if (err) {
        char b[BDEVNAME_SIZE];

        printk(KERN_WARNING
               "JBD: Detected IO errors while flushing file data "
               "on %s\n", bdevname(journal->j_fs_dev, b));
        if (journal->j_flags & JFS_ABORT_ON_SYNCDATA_ERR)
            journal_abort(journal, err);
        err = 0;
    }

    blk_start_plug(&plug);

    journal_write_revoke_records(journal, commit_transaction, write_op);

    /*
     * If we found any dirty or locked buffers, then we should have
     * looped back up to the write_out_data label.  If there weren't
     * any then journal_clean_data_list should have wiped the list
     * clean by now, so check that it is in fact empty.
     */
    J_ASSERT (commit_transaction->t_sync_datalist == NULL);

    jbd_debug (3, "JBD: commit phase 3\n");

    /*
     * Way to go: we have now written out all of the data for a
     * transaction!  Now comes the tricky part: we need to write out
     * metadata.  Loop over the transaction's entire buffer list:
     */
    spin_lock(&journal->j_state_lock);
    commit_transaction->t_state = T_COMMIT;
    spin_unlock(&journal->j_state_lock);

    trace_jbd_commit_logging(journal, commit_transaction);
    J_ASSERT(commit_transaction->t_nr_buffers <=
             commit_transaction->t_outstanding_credits);

    descriptor = NULL;
    bufs = 0;
    while (commit_transaction->t_buffers) {

        /* Find the next buffer to be journaled... */

        jh = commit_transaction->t_buffers;

        /* If we're in abort mode, we just un-journal the buffer and
           release it. */

        if (is_journal_aborted(journal)) {
            clear_buffer_jbddirty(jh2bh(jh));
            JBUFFER_TRACE(jh, "journal is aborting: refile");
            journal_refile_buffer(journal, jh);
            /* If that was the last one, we need to clean up
             * any descriptor buffers which may have been
             * already allocated, even if we are now
             * aborting. */
            if (!commit_transaction->t_buffers)
                goto start_journal_io;
            continue;
        }

        /* Make sure we have a descriptor block in which to
           record the metadata buffer. */

        if (!descriptor) {
            struct buffer_head *bh;

            J_ASSERT (bufs == 0);

            jbd_debug(4, "JBD: get descriptor\n");

            descriptor = journal_get_descriptor_buffer(journal);
            if (!descriptor) {
                journal_abort(journal, -EIO);
                continue;
            }

            bh = jh2bh(descriptor);
            jbd_debug(4, "JBD: got buffer %llu (%p)\n",
                      (unsigned long long)bh->b_blocknr, bh->b_data);
            header = (journal_header_t *)&bh->b_data[0];
            header->h_magic     = cpu_to_be32(JFS_MAGIC_NUMBER);
            header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
            header->h_sequence  = cpu_to_be32(commit_transaction->t_tid);

            tagp = &bh->b_data[sizeof(journal_header_t)];
            space_left = bh->b_size - sizeof(journal_header_t);
            first_tag = 1;
            set_buffer_jwrite(bh);
            set_buffer_dirty(bh);
            wbuf[bufs++] = bh;

            /* Record it so that we can wait for IO
                           completion later */
            BUFFER_TRACE(bh, "ph3: file as descriptor");
            journal_file_buffer(descriptor, commit_transaction,
                                BJ_LogCtl);
        }

        /* Where is the buffer to be written? */

        err = journal_next_log_block(journal, &blocknr);
        /* If the block mapping failed, just abandon the buffer
           and repeat this loop: we'll fall into the
           refile-on-abort condition above. */
        if (err) {
            journal_abort(journal, err);
            continue;
        }

        /*
         * start_this_handle() uses t_outstanding_credits to determine
         * the free space in the log, but this counter is changed
         * by journal_next_log_block() also.
         */
        commit_transaction->t_outstanding_credits--;

        /* Bump b_count to prevent truncate from stumbling over
                   the shadowed buffer!  @@@ This can go if we ever get
                   rid of the BJ_IO/BJ_Shadow pairing of buffers. */
        get_bh(jh2bh(jh));

        /* Make a temporary IO buffer with which to write it out
                   (this will requeue both the metadata buffer and the
                   temporary IO buffer). new_bh goes on BJ_IO*/

        set_buffer_jwrite(jh2bh(jh));
        /*
         * akpm: journal_write_metadata_buffer() sets
         * new_bh->b_transaction to commit_transaction.
         * We need to clean this up before we release new_bh
         * (which is of type BJ_IO)
         */
        JBUFFER_TRACE(jh, "ph3: write metadata");
        flags = journal_write_metadata_buffer(commit_transaction,
                                              jh, &new_jh, blocknr);
        set_buffer_jwrite(jh2bh(new_jh));
        wbuf[bufs++] = jh2bh(new_jh);

        /* Record the new block's tag in the current descriptor
                   buffer */

        tag_flag = 0;
        if (flags & 1)
            tag_flag |= JFS_FLAG_ESCAPE;
        if (!first_tag)
            tag_flag |= JFS_FLAG_SAME_UUID;

        tag = (journal_block_tag_t *) tagp;
        tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
        tag->t_flags = cpu_to_be32(tag_flag);
        tagp += sizeof(journal_block_tag_t);
        space_left -= sizeof(journal_block_tag_t);

        if (first_tag) {
            memcpy (tagp, journal->j_uuid, 16);
            tagp += 16;
            space_left -= 16;
            first_tag = 0;
        }

        /* If there's no more to do, or if the descriptor is full,
           let the IO rip! */

        if (bufs == journal->j_wbufsize ||
                commit_transaction->t_buffers == NULL ||
                space_left < sizeof(journal_block_tag_t) + 16) {

            jbd_debug(4, "JBD: Submit %d IOs\n", bufs);

            /* Write an end-of-descriptor marker before
                           submitting the IOs.  "tag" still points to
                           the last tag we set up. */

            tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);

start_journal_io:
            for (i = 0; i < bufs; i++) {
                struct buffer_head *bh = wbuf[i];
                lock_buffer(bh);
                clear_buffer_dirty(bh);
                set_buffer_uptodate(bh);
                bh->b_end_io = journal_end_buffer_io_sync;
                submit_bh(write_op, bh);
            }
            cond_resched();

            /* Force a new descriptor to be generated next
                           time round the loop. */
            descriptor = NULL;
            bufs = 0;
        }
    }

    blk_finish_plug(&plug);

    /* Lo and behold: we have just managed to send a transaction to
           the log.  Before we can commit it, wait for the IO so far to
           complete.  Control buffers being written are on the
           transaction's t_log_list queue, and metadata buffers are on
           the t_iobuf_list queue.

       Wait for the buffers in reverse order.  That way we are
       less likely to be woken up until all IOs have completed, and
       so we incur less scheduling load.
    */

    jbd_debug(3, "JBD: commit phase 4\n");

    /*
     * akpm: these are BJ_IO, and j_list_lock is not needed.
     * See __journal_try_to_free_buffer.
     */
wait_for_iobuf:
    while (commit_transaction->t_iobuf_list != NULL) {
        struct buffer_head *bh;

        jh = commit_transaction->t_iobuf_list->b_tprev;
        bh = jh2bh(jh);
        if (buffer_locked(bh)) {
            wait_on_buffer(bh);
            goto wait_for_iobuf;
        }
        if (cond_resched())
            goto wait_for_iobuf;

        if (unlikely(!buffer_uptodate(bh)))
            err = -EIO;

        clear_buffer_jwrite(bh);

        JBUFFER_TRACE(jh, "ph4: unfile after journal write");
        journal_unfile_buffer(journal, jh);

        /*
         * ->t_iobuf_list should contain only dummy buffer_heads
         * which were created by journal_write_metadata_buffer().
         */
        BUFFER_TRACE(bh, "dumping temporary bh");
        journal_put_journal_head(jh);
        __brelse(bh);
        J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
        free_buffer_head(bh);

        /* We also have to unlock and free the corresponding
                   shadowed buffer */
        jh = commit_transaction->t_shadow_list->b_tprev;
        bh = jh2bh(jh);
        clear_buffer_jwrite(bh);
        J_ASSERT_BH(bh, buffer_jbddirty(bh));

        /* The metadata is now released for reuse, but we need
                   to remember it against this transaction so that when
                   we finally commit, we can do any checkpointing
                   required. */
        JBUFFER_TRACE(jh, "file as BJ_Forget");
        journal_file_buffer(jh, commit_transaction, BJ_Forget);
        /*
         * Wake up any transactions which were waiting for this
         * IO to complete. The barrier must be here so that changes
         * by journal_file_buffer() take effect before wake_up_bit()
         * does the waitqueue check.
         */
        smp_mb();
        wake_up_bit(&bh->b_state, BH_Unshadow);
        JBUFFER_TRACE(jh, "brelse shadowed buffer");
        __brelse(bh);
    }

    J_ASSERT (commit_transaction->t_shadow_list == NULL);

    jbd_debug(3, "JBD: commit phase 5\n");

    /* Here we wait for the revoke record and descriptor record buffers */
wait_for_ctlbuf:
    while (commit_transaction->t_log_list != NULL) {
        struct buffer_head *bh;

        jh = commit_transaction->t_log_list->b_tprev;
        bh = jh2bh(jh);
        if (buffer_locked(bh)) {
            wait_on_buffer(bh);
            goto wait_for_ctlbuf;
        }
        if (cond_resched())
            goto wait_for_ctlbuf;

        if (unlikely(!buffer_uptodate(bh)))
            err = -EIO;

        BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
        clear_buffer_jwrite(bh);
        journal_unfile_buffer(journal, jh);
        journal_put_journal_head(jh);
        __brelse(bh);		/* One for getblk */
        /* AKPM: bforget here */
    }

    if (err)
        journal_abort(journal, err);

    jbd_debug(3, "JBD: commit phase 6\n");

    /* All metadata is written, now write commit record and do cleanup */
    spin_lock(&journal->j_state_lock);
    J_ASSERT(commit_transaction->t_state == T_COMMIT);
    commit_transaction->t_state = T_COMMIT_RECORD;
    spin_unlock(&journal->j_state_lock);

    if (journal_write_commit_record(journal, commit_transaction))
        err = -EIO;

    if (err)
        journal_abort(journal, err);

    /* End of a transaction!  Finally, we can do checkpoint
           processing: any buffers committed as a result of this
           transaction can be removed from any checkpoint list it was on
           before. */

    jbd_debug(3, "JBD: commit phase 7\n");

    J_ASSERT(commit_transaction->t_sync_datalist == NULL);
    J_ASSERT(commit_transaction->t_buffers == NULL);
    J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
    J_ASSERT(commit_transaction->t_iobuf_list == NULL);
    J_ASSERT(commit_transaction->t_shadow_list == NULL);
    J_ASSERT(commit_transaction->t_log_list == NULL);

restart_loop:
    /*
     * As there are other places (journal_unmap_buffer()) adding buffers
     * to this list we have to be careful and hold the j_list_lock.
     */
    spin_lock(&journal->j_list_lock);
    while (commit_transaction->t_forget) {
        transaction_t *cp_transaction;
        struct buffer_head *bh;
        int try_to_free = 0;

        jh = commit_transaction->t_forget;
        spin_unlock(&journal->j_list_lock);
        bh = jh2bh(jh);
        /*
         * Get a reference so that bh cannot be freed before we are
         * done with it.
         */
        get_bh(bh);
        jbd_lock_bh_state(bh);
        J_ASSERT_JH(jh,	jh->b_transaction == commit_transaction ||
                    jh->b_transaction == journal->j_running_transaction);

        /*
         * If there is undo-protected committed data against
         * this buffer, then we can remove it now.  If it is a
         * buffer needing such protection, the old frozen_data
         * field now points to a committed version of the
         * buffer, so rotate that field to the new committed
         * data.
         *
         * Otherwise, we can just throw away the frozen data now.
         */
        if (jh->b_committed_data) {
            jbd_free(jh->b_committed_data, bh->b_size);
            jh->b_committed_data = NULL;
            if (jh->b_frozen_data) {
                jh->b_committed_data = jh->b_frozen_data;
                jh->b_frozen_data = NULL;
            }
        } else if (jh->b_frozen_data) {
            jbd_free(jh->b_frozen_data, bh->b_size);
            jh->b_frozen_data = NULL;
        }

        spin_lock(&journal->j_list_lock);
        cp_transaction = jh->b_cp_transaction;
        if (cp_transaction) {
            JBUFFER_TRACE(jh, "remove from old cp transaction");
            __journal_remove_checkpoint(jh);
        }

        /* Only re-checkpoint the buffer_head if it is marked
         * dirty.  If the buffer was added to the BJ_Forget list
         * by journal_forget, it may no longer be dirty and
         * there's no point in keeping a checkpoint record for
         * it. */

        /*
         * A buffer which has been freed while still being journaled by
         * a previous transaction.
         */
        if (buffer_freed(bh)) {
            /*
             * If the running transaction is the one containing
             * "add to orphan" operation (b_next_transaction !=
             * NULL), we have to wait for that transaction to
             * commit before we can really get rid of the buffer.
             * So just clear b_modified to not confuse transaction
             * credit accounting and refile the buffer to
             * BJ_Forget of the running transaction. If the just
             * committed transaction contains "add to orphan"
             * operation, we can completely invalidate the buffer
             * now. We are rather throughout in that since the
             * buffer may be still accessible when blocksize <
             * pagesize and it is attached to the last partial
             * page.
             */
            jh->b_modified = 0;
            if (!jh->b_next_transaction) {
                clear_buffer_freed(bh);
                clear_buffer_jbddirty(bh);
                clear_buffer_mapped(bh);
                clear_buffer_new(bh);
                clear_buffer_req(bh);
                bh->b_bdev = NULL;
            }
        }

        if (buffer_jbddirty(bh)) {
            JBUFFER_TRACE(jh, "add to new checkpointing trans");
            __journal_insert_checkpoint(jh, commit_transaction);
            if (is_journal_aborted(journal))
                clear_buffer_jbddirty(bh);
        } else {
            J_ASSERT_BH(bh, !buffer_dirty(bh));
            /*
             * The buffer on BJ_Forget list and not jbddirty means
             * it has been freed by this transaction and hence it
             * could not have been reallocated until this
             * transaction has committed. *BUT* it could be
             * reallocated once we have written all the data to
             * disk and before we process the buffer on BJ_Forget
             * list.
             */
            if (!jh->b_next_transaction)
                try_to_free = 1;
        }
        JBUFFER_TRACE(jh, "refile or unfile freed buffer");
        __journal_refile_buffer(jh);
        jbd_unlock_bh_state(bh);
        if (try_to_free)
            release_buffer_page(bh);
        else
            __brelse(bh);
        cond_resched_lock(&journal->j_list_lock);
    }
    spin_unlock(&journal->j_list_lock);
    /*
     * This is a bit sleazy.  We use j_list_lock to protect transition
     * of a transaction into T_FINISHED state and calling
     * __journal_drop_transaction(). Otherwise we could race with
     * other checkpointing code processing the transaction...
     */
    spin_lock(&journal->j_state_lock);
    spin_lock(&journal->j_list_lock);
    /*
     * Now recheck if some buffers did not get attached to the transaction
     * while the lock was dropped...
     */
    if (commit_transaction->t_forget) {
        spin_unlock(&journal->j_list_lock);
        spin_unlock(&journal->j_state_lock);
        goto restart_loop;
    }

    /* Done with this transaction! */

    jbd_debug(3, "JBD: commit phase 8\n");

    J_ASSERT(commit_transaction->t_state == T_COMMIT_RECORD);

    commit_transaction->t_state = T_FINISHED;
    J_ASSERT(commit_transaction == journal->j_committing_transaction);
    journal->j_commit_sequence = commit_transaction->t_tid;
    journal->j_committing_transaction = NULL;
    commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));

    /*
     * weight the commit time higher than the average time so we don't
     * react too strongly to vast changes in commit time
     */
    if (likely(journal->j_average_commit_time))
        journal->j_average_commit_time = (commit_time*3 +
                                          journal->j_average_commit_time) / 4;
    else
        journal->j_average_commit_time = commit_time;

    spin_unlock(&journal->j_state_lock);

    if (commit_transaction->t_checkpoint_list == NULL &&
            commit_transaction->t_checkpoint_io_list == NULL) {
        __journal_drop_transaction(journal, commit_transaction);
    } else {
        if (journal->j_checkpoint_transactions == NULL) {
            journal->j_checkpoint_transactions = commit_transaction;
            commit_transaction->t_cpnext = commit_transaction;
            commit_transaction->t_cpprev = commit_transaction;
        } else {
            commit_transaction->t_cpnext =
                journal->j_checkpoint_transactions;
            commit_transaction->t_cpprev =
                commit_transaction->t_cpnext->t_cpprev;
            commit_transaction->t_cpnext->t_cpprev =
                commit_transaction;
            commit_transaction->t_cpprev->t_cpnext =
                commit_transaction;
        }
    }
    spin_unlock(&journal->j_list_lock);

    trace_jbd_end_commit(journal, commit_transaction);
    jbd_debug(1, "JBD: commit %d complete, head %d\n",
              journal->j_commit_sequence, journal->j_tail_sequence);

    wake_up(&journal->j_wait_done_commit);
}
Пример #8
0
static int do_one_pass(journal_t *journal,
			struct recovery_info *info, enum passtype pass)
{
	unsigned int		first_commit_ID, next_commit_ID;
	unsigned long long	next_log_block;
	int			err, success = 0;
	journal_superblock_t *	sb;
	journal_header_t *	tmp;
	struct buffer_head *	bh;
	unsigned int		sequence;
	int			blocktype;
	int			tag_bytes = journal_tag_bytes(journal);
	__u32			crc32_sum = ~0; /* Transactional Checksums */

	/* Precompute the maximum metadata descriptors in a descriptor block */
	int			MAX_BLOCKS_PER_DESC;
	MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t))
			       / tag_bytes);

	/*
	 * First thing is to establish what we expect to find in the log
	 * (in terms of transaction IDs), and where (in terms of log
	 * block offsets): query the superblock.
	 */

	sb = journal->j_superblock;
	next_commit_ID = be32_to_cpu(sb->s_sequence);
	next_log_block = be32_to_cpu(sb->s_start);

	first_commit_ID = next_commit_ID;
	if (pass == PASS_SCAN)
		info->start_transaction = first_commit_ID;

	jbd_debug(1, "Starting recovery pass %d\n", pass);

	/*
	 * Now we walk through the log, transaction by transaction,
	 * making sure that each transaction has a commit block in the
	 * expected place.  Each complete transaction gets replayed back
	 * into the main filesystem.
	 */

	while (1) {
		int			flags;
		char *			tagp;
		journal_block_tag_t *	tag;
		struct buffer_head *	obh;
		struct buffer_head *	nbh;

		cond_resched();

		/* If we already know where to stop the log traversal,
		 * check right now that we haven't gone past the end of
		 * the log. */

		if (pass != PASS_SCAN)
			if (tid_geq(next_commit_ID, info->end_transaction))
				break;

		jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
			  next_commit_ID, next_log_block, journal->j_last);

		/* Skip over each chunk of the transaction looking
		 * either the next descriptor block or the final commit
		 * record. */

		jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
		err = jread(&bh, journal, next_log_block);
		if (err)
			goto failed;

		next_log_block++;
		wrap(journal, next_log_block);

		/* What kind of buffer is it?
		 *
		 * If it is a descriptor block, check that it has the
		 * expected sequence number.  Otherwise, we're all done
		 * here. */

		tmp = (journal_header_t *)bh->b_data;

		if (tmp->h_magic != cpu_to_be32(JFS_MAGIC_NUMBER)) {
			brelse(bh);
			break;
		}

		blocktype = be32_to_cpu(tmp->h_blocktype);
		sequence = be32_to_cpu(tmp->h_sequence);
		jbd_debug(3, "Found magic %d, sequence %d\n",
			  blocktype, sequence);

		if (sequence != next_commit_ID) {
			brelse(bh);
			break;
		}

		/* OK, we have a valid descriptor block which matches
		 * all of the sequence number checks.  What are we going
		 * to do with it?  That depends on the pass... */

		switch(blocktype) {
		case JFS_DESCRIPTOR_BLOCK:
			/* If it is a valid descriptor block, replay it
			 * in pass REPLAY; if journal_checksums enabled, then
			 * calculate checksums in PASS_SCAN, otherwise,
			 * just skip over the blocks it describes. */
			if (pass != PASS_REPLAY) {
				if (pass == PASS_SCAN &&
				    JFS_HAS_COMPAT_FEATURE(journal,
					    JFS_FEATURE_COMPAT_CHECKSUM) &&
				    !info->end_transaction) {
					if (calc_chksums(journal, bh,
							&next_log_block,
							&crc32_sum)) {
						brelse(bh);
						break;
					}
					brelse(bh);
					continue;
				}
				next_log_block += count_tags(journal, bh);
				wrap(journal, next_log_block);
				brelse(bh);
				continue;
			}

			/* A descriptor block: we can now write all of
			 * the data blocks.  Yay, useful work is finally
			 * getting done here! */

			tagp = &bh->b_data[sizeof(journal_header_t)];
			while ((tagp - bh->b_data + tag_bytes)
			       <= journal->j_blocksize) {
				unsigned long long io_block;

				tag = (journal_block_tag_t *) tagp;
				flags = be32_to_cpu(tag->t_flags);

				io_block = next_log_block++;
				wrap(journal, next_log_block);
				err = jread(&obh, journal, io_block);
				if (err) {
					/* Recover what we can, but
					 * report failure at the end. */
					success = err;
					printk (KERN_ERR
						"JBD: IO error %d recovering "
						"block %llu in log\n",
						err, io_block);
				} else {
					unsigned long long blocknr;

					J_ASSERT(obh != NULL);
					blocknr = read_tag_block(tag_bytes,
								 tag);

					/* If the block has been
					 * revoked, then we're all done
					 * here. */
					if (journal_test_revoke
					    (journal, blocknr,
					     next_commit_ID)) {
						brelse(obh);
						++info->nr_revoke_hits;
						goto skip_write;
					}

					/* Find a buffer for the new
					 * data being restored */
					nbh = __getblk(journal->j_fs_dev,
							blocknr,
							journal->j_blocksize);
					if (nbh == NULL) {
						printk(KERN_ERR
						       "JBD: Out of memory "
						       "during recovery.\n");
						err = -ENOMEM;
						brelse(bh);
						brelse(obh);
						goto failed;
					}

					lock_buffer(nbh);
					memcpy(nbh->b_data, obh->b_data,
							journal->j_blocksize);
					if (flags & JFS_FLAG_ESCAPE) {
						journal_header_t *header;

						header = (journal_header_t *) &nbh->b_data[0];
						header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
					}

					BUFFER_TRACE(nbh, "marking dirty");
					set_buffer_uptodate(nbh);
					mark_buffer_dirty(nbh);
					BUFFER_TRACE(nbh, "marking uptodate");
					++info->nr_replays;
					/* ll_rw_block(WRITE, 1, &nbh); */
					unlock_buffer(nbh);
					brelse(obh);
					brelse(nbh);
				}

			skip_write:
				tagp += tag_bytes;
				if (!(flags & JFS_FLAG_SAME_UUID))
					tagp += 16;

				if (flags & JFS_FLAG_LAST_TAG)
					break;
			}

			brelse(bh);
			continue;

		case JFS_COMMIT_BLOCK:
			jbd_debug(3, "Commit block for #%u found\n",
				  next_commit_ID);
			/*     How to differentiate between interrupted commit
			 *               and journal corruption ?
			 *
			 * {nth transaction}
			 *        Checksum Verification Failed
			 *			 |
			 *		 ____________________
			 *		|		     |
			 * 	async_commit             sync_commit
			 *     		|                    |
			 *		| GO TO NEXT    "Journal Corruption"
			 *		| TRANSACTION
			 *		|
			 * {(n+1)th transanction}
			 *		|
			 * 	 _______|______________
			 * 	|	 	      |
			 * Commit block found	Commit block not found
			 *      |		      |
			 * "Journal Corruption"       |
			 *		 _____________|_________
			 *     		|	           	|
			 *	nth trans corrupt	OR   nth trans
			 *	and (n+1)th interrupted     interrupted
			 *	before commit block
			 *      could reach the disk.
			 *	(Cannot find the difference in above
			 *	 mentioned conditions. Hence assume
			 *	 "Interrupted Commit".)
			 */

			/* Found an expected commit block: if checksums
			 * are present verify them in PASS_SCAN; else not
			 * much to do other than move on to the next sequence
			 * number. */
			if (pass == PASS_SCAN &&
			    JFS_HAS_COMPAT_FEATURE(journal,
				    JFS_FEATURE_COMPAT_CHECKSUM)) {
				int chksum_err, chksum_seen;
				struct commit_header *cbh =
					(struct commit_header *)bh->b_data;
				unsigned found_chksum =
					be32_to_cpu(cbh->h_chksum[0]);

				chksum_err = chksum_seen = 0;

				jbd_debug(3, "Checksums %x %x\n",
					  crc32_sum, found_chksum);
				if (info->end_transaction) {
					journal->j_failed_commit =
						info->end_transaction;
					brelse(bh);
					break;
				}

				if (crc32_sum == found_chksum &&
				    cbh->h_chksum_type == JBD2_CRC32_CHKSUM &&
				    cbh->h_chksum_size ==
						JBD2_CRC32_CHKSUM_SIZE)
				       chksum_seen = 1;
				else if (!(cbh->h_chksum_type == 0 &&
					     cbh->h_chksum_size == 0 &&
					     found_chksum == 0 &&
					     !chksum_seen))
				/*
				 * If fs is mounted using an old kernel and then
				 * kernel with journal_chksum is used then we
				 * get a situation where the journal flag has
				 * checksum flag set but checksums are not
				 * present i.e chksum = 0, in the individual
				 * commit blocks.
				 * Hence to avoid checksum failures, in this
				 * situation, this extra check is added.
				 */
						chksum_err = 1;

				if (chksum_err) {
					info->end_transaction = next_commit_ID;
					jbd_debug(1, "Checksum_err %x %x\n",
						  crc32_sum, found_chksum);
					if (!JFS_HAS_INCOMPAT_FEATURE(journal,
					   JFS_FEATURE_INCOMPAT_ASYNC_COMMIT)){
						journal->j_failed_commit =
							next_commit_ID;
						brelse(bh);
						break;
					}
				}
				crc32_sum = ~0;
			}
			brelse(bh);
			next_commit_ID++;
			continue;

		case JFS_REVOKE_BLOCK:
			/* If we aren't in the REVOKE pass, then we can
			 * just skip over this block. */
			if (pass != PASS_REVOKE) {
				brelse(bh);
				continue;
			}

			err = scan_revoke_records(journal, bh,
						  next_commit_ID, info);
			brelse(bh);
			if (err)
				goto failed;
			continue;

		default:
			jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
				  blocktype);
			brelse(bh);
			goto done;
		}
	}

 done:
	/*
	 * We broke out of the log scan loop: either we came to the
	 * known end of the log or we found an unexpected block in the
	 * log.  If the latter happened, then we know that the "current"
	 * transaction marks the end of the valid log.
	 */

	if (pass == PASS_SCAN) {
		if (!info->end_transaction)
			info->end_transaction = next_commit_ID;
	} else {
		/* It's really bad news if different passes end up at
		 * different places (but possible due to IO errors). */
		if (info->end_transaction != next_commit_ID) {
			printk (KERN_ERR "JBD: recovery pass %d ended at "
				"transaction %u, expected %u\n",
				pass, next_commit_ID, info->end_transaction);
			if (!success)
				success = -EIO;
		}
	}

	return success;

 failed:
	return err;
}
Пример #9
0
static int start_this_handle(journal_t *journal, handle_t *handle,
			     gfp_t gfp_mask)
{
	transaction_t	*transaction, *new_transaction = NULL;
	tid_t		tid;
	int		needed, need_to_start;
	int		nblocks = handle->h_buffer_credits;
	unsigned long ts = jiffies;

	if (nblocks > journal->j_max_transaction_buffers) {
		printk(KERN_ERR "JBD2: %s wants too many credits (%d > %d)\n",
		       current->comm, nblocks,
		       journal->j_max_transaction_buffers);
		return -ENOSPC;
	}

alloc_transaction:
	if (!journal->j_running_transaction) {
		new_transaction = kmem_cache_alloc(transaction_cache,
						   gfp_mask | __GFP_ZERO);
		if (!new_transaction) {
			if ((gfp_mask & __GFP_FS) == 0) {
				congestion_wait(BLK_RW_ASYNC, HZ/50);
				goto alloc_transaction;
			}
			return -ENOMEM;
		}
	}

	jbd_debug(3, "New handle %p going live.\n", handle);

repeat:
	read_lock(&journal->j_state_lock);
	BUG_ON(journal->j_flags & JBD2_UNMOUNT);
	if (is_journal_aborted(journal) ||
	    (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
		read_unlock(&journal->j_state_lock);
		jbd2_journal_free_transaction(new_transaction);
		return -EROFS;
	}

	
	if (journal->j_barrier_count) {
		read_unlock(&journal->j_state_lock);
		wait_event(journal->j_wait_transaction_locked,
				journal->j_barrier_count == 0);
		goto repeat;
	}

	if (!journal->j_running_transaction) {
		read_unlock(&journal->j_state_lock);
		if (!new_transaction)
			goto alloc_transaction;
		write_lock(&journal->j_state_lock);
		
		if (journal->j_barrier_count) {
			printk(KERN_WARNING "JBD: %s: wait for transaction barrier\n", __func__);
			write_unlock(&journal->j_state_lock);
			goto repeat;
		}
		if (!journal->j_running_transaction) {
			jbd2_get_transaction(journal, new_transaction);
			new_transaction = NULL;
		}
		write_unlock(&journal->j_state_lock);
		goto repeat;
	}

	transaction = journal->j_running_transaction;

	if (transaction->t_state == T_LOCKED) {
		DEFINE_WAIT(wait);

		prepare_to_wait(&journal->j_wait_transaction_locked,
					&wait, TASK_UNINTERRUPTIBLE);
		read_unlock(&journal->j_state_lock);
		schedule();
		finish_wait(&journal->j_wait_transaction_locked, &wait);
		goto repeat;
	}

	needed = atomic_add_return(nblocks,
				   &transaction->t_outstanding_credits);

	if (needed > journal->j_max_transaction_buffers) {
		DEFINE_WAIT(wait);

		jbd_debug(2, "Handle %p starting new commit...\n", handle);
		atomic_sub(nblocks, &transaction->t_outstanding_credits);
		prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
				TASK_UNINTERRUPTIBLE);
		tid = transaction->t_tid;
		need_to_start = !tid_geq(journal->j_commit_request, tid);
		read_unlock(&journal->j_state_lock);
		if (need_to_start)
			jbd2_log_start_commit(journal, tid);
		schedule();
		finish_wait(&journal->j_wait_transaction_locked, &wait);
		goto repeat;
	}


	if (__jbd2_log_space_left(journal) < jbd_space_needed(journal)) {
		jbd_debug(2, "Handle %p waiting for checkpoint...\n", handle);
		atomic_sub(nblocks, &transaction->t_outstanding_credits);
		read_unlock(&journal->j_state_lock);
		write_lock(&journal->j_state_lock);
		if (__jbd2_log_space_left(journal) < jbd_space_needed(journal))
			__jbd2_log_wait_for_space(journal);
		write_unlock(&journal->j_state_lock);
		goto repeat;
	}

	update_t_max_wait(transaction, ts);
	handle->h_transaction = transaction;
	atomic_inc(&transaction->t_updates);
	atomic_inc(&transaction->t_handle_count);
	jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n",
		  handle, nblocks,
		  atomic_read(&transaction->t_outstanding_credits),
		  __jbd2_log_space_left(journal));
	read_unlock(&journal->j_state_lock);

	lock_map_acquire(&handle->h_lockdep_map);
	jbd2_journal_free_transaction(new_transaction);
	return 0;
}
Пример #10
0
static int do_one_pass(journal_t *journal,
			struct recovery_info *info, enum passtype pass)
{
	unsigned int		first_commit_ID, next_commit_ID;
	unsigned long		next_log_block;
	int			err, success = 0;
	journal_superblock_t *	sb;
	journal_header_t *	tmp;
	struct buffer_head *	bh;
	unsigned int		sequence;
	int			blocktype;
	int			tag_bytes = journal_tag_bytes(journal);
	__u32			crc32_sum = ~0; 


	sb = journal->j_superblock;
	next_commit_ID = be32_to_cpu(sb->s_sequence);
	next_log_block = be32_to_cpu(sb->s_start);

	first_commit_ID = next_commit_ID;
	if (pass == PASS_SCAN)
		info->start_transaction = first_commit_ID;

	jbd_debug(1, "Starting recovery pass %d\n", pass);


	while (1) {
		int			flags;
		char *			tagp;
		journal_block_tag_t *	tag;
		struct buffer_head *	obh;
		struct buffer_head *	nbh;

		cond_resched();


		if (pass != PASS_SCAN)
			if (tid_geq(next_commit_ID, info->end_transaction))
				break;

		jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
			  next_commit_ID, next_log_block, journal->j_last);


		jbd_debug(3, "JBD2: checking block %ld\n", next_log_block);
		err = jread(&bh, journal, next_log_block);
		if (err)
			goto failed;

		next_log_block++;
		wrap(journal, next_log_block);


		tmp = (journal_header_t *)bh->b_data;

		if (tmp->h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER)) {
			brelse(bh);
			break;
		}

		blocktype = be32_to_cpu(tmp->h_blocktype);
		sequence = be32_to_cpu(tmp->h_sequence);
		jbd_debug(3, "Found magic %d, sequence %d\n",
			  blocktype, sequence);

		if (sequence != next_commit_ID) {
			brelse(bh);
			break;
		}


		switch(blocktype) {
		case JBD2_DESCRIPTOR_BLOCK:
			if (pass != PASS_REPLAY) {
				if (pass == PASS_SCAN &&
				    JBD2_HAS_COMPAT_FEATURE(journal,
					    JBD2_FEATURE_COMPAT_CHECKSUM) &&
				    !info->end_transaction) {
					if (calc_chksums(journal, bh,
							&next_log_block,
							&crc32_sum)) {
						put_bh(bh);
						break;
					}
					put_bh(bh);
					continue;
				}
				next_log_block += count_tags(journal, bh);
				wrap(journal, next_log_block);
				put_bh(bh);
				continue;
			}


			tagp = &bh->b_data[sizeof(journal_header_t)];
			while ((tagp - bh->b_data + tag_bytes)
			       <= journal->j_blocksize) {
				unsigned long io_block;

				tag = (journal_block_tag_t *) tagp;
				flags = be32_to_cpu(tag->t_flags);

				io_block = next_log_block++;
				wrap(journal, next_log_block);
				err = jread(&obh, journal, io_block);
				if (err) {
					success = err;
					printk(KERN_ERR
						"JBD2: IO error %d recovering "
						"block %ld in log\n",
						err, io_block);
				} else {
					unsigned long long blocknr;

					J_ASSERT(obh != NULL);
					blocknr = read_tag_block(tag_bytes,
								 tag);

					if (jbd2_journal_test_revoke
					    (journal, blocknr,
					     next_commit_ID)) {
						brelse(obh);
						++info->nr_revoke_hits;
						goto skip_write;
					}

					nbh = __getblk(journal->j_fs_dev,
							blocknr,
							journal->j_blocksize);
					if (nbh == NULL) {
						printk(KERN_ERR
						       "JBD2: Out of memory "
						       "during recovery.\n");
						err = -ENOMEM;
						brelse(bh);
						brelse(obh);
						goto failed;
					}

					lock_buffer(nbh);
					memcpy(nbh->b_data, obh->b_data,
							journal->j_blocksize);
					if (flags & JBD2_FLAG_ESCAPE) {
						*((__be32 *)nbh->b_data) =
						cpu_to_be32(JBD2_MAGIC_NUMBER);
					}

					BUFFER_TRACE(nbh, "marking dirty");
					set_buffer_uptodate(nbh);
					mark_buffer_dirty(nbh);
					BUFFER_TRACE(nbh, "marking uptodate");
					++info->nr_replays;
					
					unlock_buffer(nbh);
					brelse(obh);
					brelse(nbh);
				}

			skip_write:
				tagp += tag_bytes;
				if (!(flags & JBD2_FLAG_SAME_UUID))
					tagp += 16;

				if (flags & JBD2_FLAG_LAST_TAG)
					break;
			}

			brelse(bh);
			continue;

		case JBD2_COMMIT_BLOCK:

			if (pass == PASS_SCAN &&
			    JBD2_HAS_COMPAT_FEATURE(journal,
				    JBD2_FEATURE_COMPAT_CHECKSUM)) {
				int chksum_err, chksum_seen;
				struct commit_header *cbh =
					(struct commit_header *)bh->b_data;
				unsigned found_chksum =
					be32_to_cpu(cbh->h_chksum[0]);

				chksum_err = chksum_seen = 0;

				if (info->end_transaction) {
					journal->j_failed_commit =
						info->end_transaction;
					brelse(bh);
					break;
				}

				if (crc32_sum == found_chksum &&
				    cbh->h_chksum_type == JBD2_CRC32_CHKSUM &&
				    cbh->h_chksum_size ==
						JBD2_CRC32_CHKSUM_SIZE)
				       chksum_seen = 1;
				else if (!(cbh->h_chksum_type == 0 &&
					     cbh->h_chksum_size == 0 &&
					     found_chksum == 0 &&
					     !chksum_seen))
						chksum_err = 1;

				if (chksum_err) {
					info->end_transaction = next_commit_ID;

					if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
					   JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)){
						journal->j_failed_commit =
							next_commit_ID;
						brelse(bh);
						break;
					}
				}
				crc32_sum = ~0;
			}
			brelse(bh);
			next_commit_ID++;
			continue;

		case JBD2_REVOKE_BLOCK:
			if (pass != PASS_REVOKE) {
				brelse(bh);
				continue;
			}

			err = scan_revoke_records(journal, bh,
						  next_commit_ID, info);
			brelse(bh);
			if (err)
				goto failed;
			continue;

		default:
			jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
				  blocktype);
			brelse(bh);
			goto done;
		}
	}

 done:

	if (pass == PASS_SCAN) {
		if (!info->end_transaction)
			info->end_transaction = next_commit_ID;
	} else {
		if (info->end_transaction != next_commit_ID) {
			printk(KERN_ERR "JBD2: recovery pass %d ended at "
				"transaction %u, expected %u\n",
				pass, next_commit_ID, info->end_transaction);
			if (!success)
				success = -EIO;
		}
	}

	return success;

 failed:
	return err;
}