Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 94e5165a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6 

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6:
  quota: Improve checking of quota file header
  jbd: jbd-debug and jbd2-debug should be writable
  ext4: fix sleep inside spinlock issue with quota and dealloc (#14739)
  ext4: Fix potential quota deadlock
  quota: Fix 64-bit limits setting on 32-bit archs
  ext3: Replace lock/unlock_super() with an explicit lock for resizing
  ext3: Replace lock/unlock_super() with an explicit lock for the orphan list
  ext3: ext3_mark_recovery_complete() doesn't need to use lock_super
  ext3: Remove outdated comment about lock_super()
  quota: Move duplicated code to separate functions
  ext4: Convert to generic reserved quota's space management.
  quota: decouple fs reserved space from quota reservation
  Add unlocked version of inode_add_bytes() function
  ext3: quota macros cleanup [V2]
parents f42ecb28 869835df

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 @@ static int setup_new_group_blocks(struct super_block *sb, 
	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 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode, 
 * 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);