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

fs/ext3/inode.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -970,7 +970,7 @@ static int ext3_get_block(struct inode *inode, sector_t iblock,
		if (max_blocks > DIO_MAX_BLOCKS)
		max_blocks = DIO_MAX_BLOCKS;
		handle = ext3_journal_start(inode, DIO_CREDITS +
		2 * EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb));
		EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
		if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out;
		@@ -3146,8 +3146,8 @@ int ext3_setattr(struct dentry dentry, struct iattr attr)

		/* (user+group)*(old+new) structure, inode write (sb,
		* inode block, ? - but truncate inode update has it) */
		handle = ext3_journal_start(inode, 2*(EXT3_QUOTA_INIT_BLOCKS(inode->i_sb)+
		EXT3_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
		handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
		EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
		if (IS_ERR(handle)) {
		error = PTR_ERR(handle);
		goto err_out;
		@@ -3239,7 +3239,7 @@ static int ext3_writepage_trans_blocks(struct inode *inode)
		#ifdef CONFIG_QUOTA
		/* We know that structure was already allocated during vfs_dq_init so
		* we will be updating only the data blocks + inodes */
		ret += 2*EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb);
		ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
		#endif

		return ret;

fs/ext3/namei.c

+15 −13

Original line number	Diff line number	Diff line
		@@ -1699,7 +1699,7 @@ static int ext3_create (struct inode * dir, struct dentry * dentry, int mode,
		retry:
		handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
		2*EXT3_QUOTA_INIT_BLOCKS(dir->i_sb));
		EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		@@ -1733,7 +1733,7 @@ static int ext3_mknod (struct inode * dir, struct dentry *dentry,
		retry:
		handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
		2*EXT3_QUOTA_INIT_BLOCKS(dir->i_sb));
		EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		@@ -1769,7 +1769,7 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
		retry:
		handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
		2*EXT3_QUOTA_INIT_BLOCKS(dir->i_sb));
		EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		@@ -1920,7 +1920,7 @@ int ext3_orphan_add(handle_t handle, struct inode inode)
		struct ext3_iloc iloc;
		int err = 0, rc;

		lock_super(sb);
		mutex_lock(&EXT3_SB(sb)->s_orphan_lock);
		if (!list_empty(&EXT3_I(inode)->i_orphan))
		goto out_unlock;

		@@ -1929,9 +1929,13 @@ int ext3_orphan_add(handle_t handle, struct inode inode)

		/* @@@ FIXME: Observation from aviro:
		* I think I can trigger J_ASSERT in ext3_orphan_add(). We block
		* here (on lock_super()), so race with ext3_link() which might bump
		* here (on s_orphan_lock), so race with ext3_link() which might bump
		* ->i_nlink. For, say it, character device. Not a regular file,
		* not a directory, not a symlink and ->i_nlink > 0.
		*
		* tytso, 4/25/2009: I'm not sure how that could happen;
		* shouldn't the fs core protect us from these sort of
		* unlink()/link() races?
		*/
		J_ASSERT ((S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode) \|\|
		S_ISLNK(inode->i_mode)) \|\| inode->i_nlink == 0);
		@@ -1968,7 +1972,7 @@ int ext3_orphan_add(handle_t handle, struct inode inode)
		jbd_debug(4, "orphan inode %lu will point to %d\n",
		inode->i_ino, NEXT_ORPHAN(inode));
		out_unlock:
		unlock_super(sb);
		mutex_unlock(&EXT3_SB(sb)->s_orphan_lock);
		ext3_std_error(inode->i_sb, err);
		return err;
		}
		@@ -1986,11 +1990,9 @@ int ext3_orphan_del(handle_t handle, struct inode inode)
		struct ext3_iloc iloc;
		int err = 0;

		lock_super(inode->i_sb);
		if (list_empty(&ei->i_orphan)) {
		unlock_super(inode->i_sb);
		return 0;
		}
		mutex_lock(&EXT3_SB(inode->i_sb)->s_orphan_lock);
		if (list_empty(&ei->i_orphan))
		goto out;

		ino_next = NEXT_ORPHAN(inode);
		prev = ei->i_orphan.prev;
		@@ -2040,7 +2042,7 @@ int ext3_orphan_del(handle_t handle, struct inode inode)
		out_err:
		ext3_std_error(inode->i_sb, err);
		out:
		unlock_super(inode->i_sb);
		mutex_unlock(&EXT3_SB(inode->i_sb)->s_orphan_lock);
		return err;

		out_brelse:
		@@ -2175,7 +2177,7 @@ static int ext3_symlink (struct inode * dir,
		retry:
		handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
		EXT3_INDEX_EXTRA_TRANS_BLOCKS + 5 +
		2*EXT3_QUOTA_INIT_BLOCKS(dir->i_sb));
		EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
		if (IS_ERR(handle))
		return PTR_ERR(handle);

fs/ext3/resize.c

+18 −17

Original line number	Diff line number	Diff line
		@@ -209,7 +209,7 @@ static int setup_new_group_blocks(struct super_block *sb,
		if (IS_ERR(handle))
		return PTR_ERR(handle);

		lock_super(sb);
		mutex_lock(&sbi->s_resize_lock);
		if (input->group != sbi->s_groups_count) {
		err = -EBUSY;
		goto exit_journal;
		@@ -324,7 +324,7 @@ exit_bh:
		brelse(bh);

		exit_journal:
		unlock_super(sb);
		mutex_unlock(&sbi->s_resize_lock);
		if ((err2 = ext3_journal_stop(handle)) && !err)
		err = err2;

		@@ -662,11 +662,12 @@ exit_free:
		* important part is that the new block and inode counts are in the backup
		* superblocks, and the location of the new group metadata in the GDT backups.
		*
		* We do not need lock_super() for this, because these blocks are not
		* otherwise touched by the filesystem code when it is mounted. We don't
		* need to worry about last changing from sbi->s_groups_count, because the
		* worst that can happen is that we do not copy the full number of backups
		* at this time. The resize which changed s_groups_count will backup again.
		* We do not need take the s_resize_lock for this, because these
		* blocks are not otherwise touched by the filesystem code when it is
		* mounted. We don't need to worry about last changing from
		* sbi->s_groups_count, because the worst that can happen is that we
		* do not copy the full number of backups at this time. The resize
		* which changed s_groups_count will backup again.
		*/
		static void update_backups(struct super_block *sb,
		int blk_off, char *data, int size)
		@@ -825,7 +826,7 @@ int ext3_group_add(struct super_block sb, struct ext3_new_group_data input)
		goto exit_put;
		}

		lock_super(sb);
		mutex_lock(&sbi->s_resize_lock);
		if (input->group != sbi->s_groups_count) {
		ext3_warning(sb, __func__,
		"multiple resizers run on filesystem!");
		@@ -856,7 +857,7 @@ int ext3_group_add(struct super_block sb, struct ext3_new_group_data input)
		/*
		* OK, now we've set up the new group. Time to make it active.
		*
		* Current kernels don't lock all allocations via lock_super(),
		* We do not lock all allocations via s_resize_lock
		* so we have to be safe wrt. concurrent accesses the group
		* data. So we need to be careful to set all of the relevant
		* group descriptor data etc. before we enable the group.
		@@ -900,12 +901,12 @@ int ext3_group_add(struct super_block sb, struct ext3_new_group_data input)
		*
		* The precise rules we use are:
		*
		* * Writers of s_groups_count must hold lock_super
		* * Writers of s_groups_count must hold s_resize_lock
		* AND
		* * Writers must perform a smp_wmb() after updating all dependent
		* data and before modifying the groups count
		*
		* * Readers must hold lock_super() over the access
		* * Readers must hold s_resize_lock over the access
		* OR
		* * Readers must perform an smp_rmb() after reading the groups count
		* and before reading any dependent data.
		@@ -936,7 +937,7 @@ int ext3_group_add(struct super_block sb, struct ext3_new_group_data input)
		ext3_journal_dirty_metadata(handle, sbi->s_sbh);

		exit_journal:
		unlock_super(sb);
		mutex_unlock(&sbi->s_resize_lock);
		if ((err2 = ext3_journal_stop(handle)) && !err)
		err = err2;
		if (!err) {
		@@ -973,7 +974,7 @@ int ext3_group_extend(struct super_block sb, struct ext3_super_block es,

		/* We don't need to worry about locking wrt other resizers just
		* yet: we're going to revalidate es->s_blocks_count after
		* taking lock_super() below. */
		* taking the s_resize_lock below. */
		o_blocks_count = le32_to_cpu(es->s_blocks_count);
		o_groups_count = EXT3_SB(sb)->s_groups_count;

		@@ -1045,11 +1046,11 @@ int ext3_group_extend(struct super_block sb, struct ext3_super_block es,
		goto exit_put;
		}

		lock_super(sb);
		mutex_lock(&EXT3_SB(sb)->s_resize_lock);
		if (o_blocks_count != le32_to_cpu(es->s_blocks_count)) {
		ext3_warning(sb, __func__,
		"multiple resizers run on filesystem!");
		unlock_super(sb);
		mutex_unlock(&EXT3_SB(sb)->s_resize_lock);
		ext3_journal_stop(handle);
		err = -EBUSY;
		goto exit_put;
		@@ -1059,13 +1060,13 @@ int ext3_group_extend(struct super_block sb, struct ext3_super_block es,
		EXT3_SB(sb)->s_sbh))) {
		ext3_warning(sb, __func__,
		"error %d on journal write access", err);
		unlock_super(sb);
		mutex_unlock(&EXT3_SB(sb)->s_resize_lock);
		ext3_journal_stop(handle);
		goto exit_put;
		}
		es->s_blocks_count = cpu_to_le32(o_blocks_count + add);
		ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
		unlock_super(sb);
		mutex_unlock(&EXT3_SB(sb)->s_resize_lock);
		ext3_debug("freeing blocks %lu through "E3FSBLK"\n", o_blocks_count,
		o_blocks_count + add);
		ext3_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks);

fs/ext3/super.c

+3 −16

Original line number	Diff line number	Diff line
		@@ -1928,6 +1928,8 @@ static int ext3_fill_super (struct super_block sb, void data, int silent)
		sb->dq_op = &ext3_quota_operations;
		#endif
		INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
		mutex_init(&sbi->s_orphan_lock);
		mutex_init(&sbi->s_resize_lock);

		sb->s_root = NULL;

		@@ -2014,14 +2016,7 @@ static int ext3_fill_super (struct super_block sb, void data, int silent)
		}

		ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
		/*
		* akpm: core read_super() calls in here with the superblock locked.
		* That deadlocks, because orphan cleanup needs to lock the superblock
		* in numerous places. Here we just pop the lock - it's relatively
		* harmless, because we are now ready to accept write_super() requests,
		* and aviro says that's the only reason for hanging onto the
		* superblock lock.
		*/

		EXT3_SB(sb)->s_mount_state \|= EXT3_ORPHAN_FS;
		ext3_orphan_cleanup(sb, es);
		EXT3_SB(sb)->s_mount_state &= ~EXT3_ORPHAN_FS;
		@@ -2403,13 +2398,11 @@ static void ext3_mark_recovery_complete(struct super_block * sb,
		if (journal_flush(journal) < 0)
		goto out;

		lock_super(sb);
		if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
		sb->s_flags & MS_RDONLY) {
		EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
		ext3_commit_super(sb, es, 1);
		}
		unlock_super(sb);

		out:
		journal_unlock_updates(journal);
		@@ -2601,13 +2594,7 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
		(sbi->s_mount_state & EXT3_VALID_FS))
		es->s_state = cpu_to_le16(sbi->s_mount_state);

		/*
		* We have to unlock super so that we can wait for
		* transactions.
		*/
		unlock_super(sb);
		ext3_mark_recovery_complete(sb, es);
		lock_super(sb);
		} else {
		__le32 ret;
		if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,

fs/ext4/ext4.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -704,6 +704,10 @@ struct ext4_inode_info {
		__u16 i_extra_isize;

		spinlock_t i_block_reservation_lock;
		#ifdef CONFIG_QUOTA
		/* quota space reservation, managed internally by quota code */
		qsize_t i_reserved_quota;
		#endif

		/* completed async DIOs that might need unwritten extents handling */
		struct list_head i_aio_dio_complete_list;
		@@ -1435,7 +1439,7 @@ extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
		extern int ext4_block_truncate_page(handle_t *handle,
		struct address_space *mapping, loff_t from);
		extern int ext4_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf);
		extern qsize_t ext4_get_reserved_space(struct inode *inode);
		extern qsize_t ext4_get_reserved_space(struct inode inode);
		extern int flush_aio_dio_completed_IO(struct inode *inode);
		/* ioctl.c */
		extern long ext4_ioctl(struct file *, unsigned int, unsigned long);

Admin message