Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6 (dc522adb) · Commits · 戴 / test

fs/ext2/super.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -898,7 +898,8 @@ static int ext2_fill_super(struct super_block sb, void data, int silent)
		brelse(bh);

		if (!sb_set_blocksize(sb, blocksize)) {
		ext2_msg(sb, KERN_ERR, "error: blocksize is too small");
		ext2_msg(sb, KERN_ERR,
		"error: bad blocksize %d", blocksize);
		goto failed_sbi;
		}

fs/ext3/namei.c

+67 −13

Original line number	Diff line number	Diff line
		@@ -1416,10 +1416,19 @@ static int make_indexed_dir(handle_t handle, struct dentry dentry,
		frame->at = entries;
		frame->bh = bh;
		bh = bh2;
		/*
		* Mark buffers dirty here so that if do_split() fails we write a
		* consistent set of buffers to disk.
		*/
		ext3_journal_dirty_metadata(handle, frame->bh);
		ext3_journal_dirty_metadata(handle, bh);
		de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
		if (!de) {
		ext3_mark_inode_dirty(handle, dir);
		dx_release(frames);
		if (!(de))
		return retval;
		}
		dx_release(frames);

		return add_dirent_to_buf(handle, dentry, inode, de, bh);
		}
		@@ -2189,6 +2198,7 @@ static int ext3_symlink (struct inode * dir,
		handle_t *handle;
		struct inode * inode;
		int l, err, retries = 0;
		int credits;

		l = strlen(symname)+1;
		if (l > dir->i_sb->s_blocksize)
		@@ -2196,10 +2206,26 @@ static int ext3_symlink (struct inode * dir,

		dquot_initialize(dir);

		if (l > EXT3_N_BLOCKS * 4) {
		/*
		* For non-fast symlinks, we just allocate inode and put it on
		* orphan list in the first transaction => we need bitmap,
		* group descriptor, sb, inode block, quota blocks.
		*/
		credits = 4 + EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb);
		} else {
		/*
		* Fast symlink. We have to add entry to directory
		* (EXT3_DATA_TRANS_BLOCKS + EXT3_INDEX_EXTRA_TRANS_BLOCKS),
		* allocate new inode (bitmap, group descriptor, inode block,
		* quota blocks, sb is already counted in previous macros).
		*/
		credits = EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
		EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb);
		}
		retry:
		handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 5 +
		EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
		handle = ext3_journal_start(dir, credits);
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		@@ -2211,21 +2237,45 @@ retry:
		if (IS_ERR(inode))
		goto out_stop;

		if (l > sizeof (EXT3_I(inode)->i_data)) {
		if (l > EXT3_N_BLOCKS * 4) {
		inode->i_op = &ext3_symlink_inode_operations;
		ext3_set_aops(inode);
		/*
		* page_symlink() calls into ext3_prepare/commit_write.
		* We have a transaction open. All is sweetness. It also sets
		* i_size in generic_commit_write().
		* We cannot call page_symlink() with transaction started
		* because it calls into ext3_write_begin() which acquires page
		* lock which ranks below transaction start (and it can also
		* wait for journal commit if we are running out of space). So
		* we have to stop transaction now and restart it when symlink
		* contents is written.
		*
		* To keep fs consistent in case of crash, we have to put inode
		* to orphan list in the mean time.
		*/
		drop_nlink(inode);
		err = ext3_orphan_add(handle, inode);
		ext3_journal_stop(handle);
		if (err)
		goto err_drop_inode;
		err = __page_symlink(inode, symname, l, 1);
		if (err)
		goto err_drop_inode;
		/*
		* Now inode is being linked into dir (EXT3_DATA_TRANS_BLOCKS
		* + EXT3_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified
		*/
		handle = ext3_journal_start(dir,
		EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 1);
		if (IS_ERR(handle)) {
		err = PTR_ERR(handle);
		goto err_drop_inode;
		}
		inc_nlink(inode);
		err = ext3_orphan_del(handle, inode);
		if (err) {
		ext3_journal_stop(handle);
		drop_nlink(inode);
		unlock_new_inode(inode);
		ext3_mark_inode_dirty(handle, inode);
		iput (inode);
		goto out_stop;
		goto err_drop_inode;
		}
		} else {
		inode->i_op = &ext3_fast_symlink_inode_operations;
		@@ -2239,6 +2289,10 @@ out_stop:
		if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries))
		goto retry;
		return err;
		err_drop_inode:
		unlock_new_inode(inode);
		iput(inode);
		return err;
		}

		static int ext3_link (struct dentry * old_dentry,

fs/jbd/commit.c

+7 −8

Original line number	Diff line number	Diff line
		@@ -302,12 +302,6 @@ void journal_commit_transaction(journal_t *journal)
		* all outstanding updates to complete.
		*/

		#ifdef COMMIT_STATS
		spin_lock(&journal->j_list_lock);
		summarise_journal_usage(journal);
		spin_unlock(&journal->j_list_lock);
		#endif

		/* 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");
		@@ -722,8 +716,13 @@ wait_for_iobuf:
		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 */
		/*
		* 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);

fs/jbd/journal.c

+13 −3

Original line number	Diff line number	Diff line
		@@ -437,9 +437,12 @@ int __log_space_left(journal_t *journal)
		int __log_start_commit(journal_t *journal, tid_t target)
		{
		/*
		* Are we already doing a recent enough commit?
		* 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 (!tid_geq(journal->j_commit_request, target)) {
		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.
		@@ -451,7 +454,14 @@ int __log_start_commit(journal_t *journal, tid_t target)
		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;
		}

fs/jbd/transaction.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -266,7 +266,8 @@ static handle_t *new_handle(int nblocks)
		* This function is visible to journal users (like ext3fs), so is not
		* called with the journal already locked.
		*
		* Return a pointer to a newly allocated handle, or NULL on failure
		* Return a pointer to a newly allocated handle, or an ERR_PTR() value
		* on failure.
		*/
		handle_t journal_start(journal_t journal, int nblocks)
		{

Admin message