linux-next: manual merge of the ext4 tree with Linus' tree

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 522 bytes --]

Hi Ted,

Today's linux-next merge of the ext4 tree got a conflict in
fs/ext4/super.c between commit fd89d5f2030a ("ext4: convert to
alloc_workqueue()") from Linus' tree and commit 198868f35de9 ("ext4: Use
single thread to perform DIO unwritten convertion") from the ext4 tree.

I just used the ext4 tree version.

P.S. Ted, that ext4 tree commit has no SOB from you even though you are
the committer ...
-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au
http://www.canb.auug.org.au/~sfr/

[-- Attachment #2: Type: application/pgp-signature, Size: 490 bytes --]

Re: linux-next: manual merge of the ext4 tree with Linus' tree

[Tejun Heo]

Hello, Stephen, Ted.

On Fri, Mar 25, 2011 at 12:56:43PM +1100, Stephen Rothwell wrote:
> Today's linux-next merge of the ext4 tree got a conflict in
> fs/ext4/super.c between commit fd89d5f2030a ("ext4: convert to
> alloc_workqueue()") from Linus' tree and commit 198868f35de9 ("ext4: Use
> single thread to perform DIO unwritten convertion") from the ext4 tree.
> 
> I just used the ext4 tree version.

Both are about the same conversion but the one using alloc_workqueue()
is better because 1. create_singlethread_workqueue() is going away and
2. it doesn't require strict ordering among queued works.

Ted, what do you think?

Thanks.

-- 
tejun

Re: linux-next: manual merge of the ext4 tree with Linus' tree

[Sedat Dilek]

On Fri, Mar 25, 2011 at 3:45 PM, Tejun Heo <tj@kernel.org> wrote:
> Hello, Stephen, Ted.
>
> On Fri, Mar 25, 2011 at 12:56:43PM +1100, Stephen Rothwell wrote:
>> Today's linux-next merge of the ext4 tree got a conflict in
>> fs/ext4/super.c between commit fd89d5f2030a ("ext4: convert to
>> alloc_workqueue()") from Linus' tree and commit 198868f35de9 ("ext4: Use
>> single thread to perform DIO unwritten convertion") from the ext4 tree.
>>
>> I just used the ext4 tree version.
>
> Both are about the same conversion but the one using alloc_workqueue()
> is better because 1. create_singlethread_workqueue() is going away and
> 2. it doesn't require strict ordering among queued works.
>
> Ted, what do you think?
>
> Thanks.
>
> --
> tejun
>

As my linux-next system is unstable, I had a look into my own merge
(into linux-next GIT) before ext4 stuff went to mainline.
Just wanted to test a revert to "old" code in linux-next (see below).

- Sedat -

--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -596,7 +596,7 @@ __acquires(bitlock)

        vaf.fmt = fmt;
        vaf.va = &args;
-       printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u",
+       printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
               sb->s_id, function, line, grp);
        if (ino)
                printk(KERN_CONT "inode %lu: ", ino);
@@ -3518,12 +3518,7 @@ static int ext4_fill_super(struct super_block
*sb, void *data, int silent)
        percpu_counter_set(&sbi->s_dirtyblocks_counter, 0);

 no_journal:
-       /*
-        * The maximum number of concurrent works can be high and
-        * concurrency isn't really necessary.  Limit it to 1.
-        */
-       EXT4_SB(sb)->dio_unwritten_wq =
-               alloc_workqueue("ext4-dio-unwritten", WQ_MEM_RECLAIM, 1);
+       EXT4_SB(sb)->dio_unwritten_wq =
create_singlethread_workqueue("ext4-dio-unwritten");
        if (!EXT4_SB(sb)->dio_unwritten_wq) {
                printk(KERN_ERR "EXT4-fs: failed to create DIO workqueue\n");
                goto failed_mount_wq;
- EOT -

Re: linux-next: manual merge of the ext4 tree with Linus' tree

[Ted Ts'o]

On Fri, Mar 25, 2011 at 03:45:44PM +0100, Tejun Heo wrote:
> Both are about the same conversion but the one using alloc_workqueue()
> is better because 1. create_singlethread_workqueue() is going away and
> 2. it doesn't require strict ordering among queued works.
> 
> Ted, what do you think?

Agreed.  And it looks like Linus agreed as well:

diff --cc fs/ext4/super.c
index 203f9e4,ccfa686..22546ad
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@@ -3511,12 -3514,7 +3516,12 @@@ static int ext4_fill_super(struct super
        percpu_counter_set(&sbi->s_dirtyblocks_counter, 0);
  
  no_journal:
 -      EXT4_SB(sb)->dio_unwritten_wq = create_singlethread_workqueue("ext4-dio-
 +      /*
 +       * The maximum number of concurrent works can be high and
 +       * concurrency isn't really necessary.  Limit it to 1.
 +       */
 +      EXT4_SB(sb)->dio_unwritten_wq =
-               alloc_workqueue("ext4-dio-unwritten", WQ_MEM_RECLAIM, 1);
++              alloc_workqueue("ext4-dio-unwritten", WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
        if (!EXT4_SB(sb)->dio_unwritten_wq) {
                printk(KERN_ERR "EXT4-fs: failed to create DIO workqueue\n");
                goto failed_mount_wq;

						- Ted

Re: linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 791 bytes --]

Hi Christoph,

On Tue, 27 Jun 2023 08:37:53 +0200 Christoph Hellwig <hch@lst.de> wrote:
>
> On Tue, Jun 27, 2023 at 10:39:00AM +1000, Stephen Rothwell wrote:
> > Hi all,
> > 
> > Today's linux-next merge of the ext4 tree got a conflict in:
> > 
> >   fs/ext4/ioctl.c
> > 
> > between commit:
> > 
> >   97524b454bc5 ("ext4: split ext4_shutdown")
> > 
> > from Linus' tree and commit:
> > 
> >   c4d13222afd8 ("ext4: fix to check return value of freeze_bdev() in ext4_shutdown()")  
> 
> Hmm, I can't actually find the latter commit in linux-next and the context
> below also doesn't make it obviously cler to me what the conflict was.

That is probably because today's tree had not been released yet ..
please refetch and try again.

-- 
Cheers,
Stephen Rothwell

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

Re: linux-next: manual merge of the ext4 tree with Linus' tree

[Christoph Hellwig]

On Tue, Jun 27, 2023 at 10:39:00AM +1000, Stephen Rothwell wrote:
> Hi all,
> 
> Today's linux-next merge of the ext4 tree got a conflict in:
> 
>   fs/ext4/ioctl.c
> 
> between commit:
> 
>   97524b454bc5 ("ext4: split ext4_shutdown")
> 
> from Linus' tree and commit:
> 
>   c4d13222afd8 ("ext4: fix to check return value of freeze_bdev() in ext4_shutdown()")

Hmm, I can't actually find the latter commit in linux-next and the context
below also doesn't make it obviously cler to me what the conflict was.

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 1344 bytes --]

Hi all,

Today's linux-next merge of the ext4 tree got a conflict in:

  fs/ext4/ioctl.c

between commit:

  97524b454bc5 ("ext4: split ext4_shutdown")

from Linus' tree and commit:

  c4d13222afd8 ("ext4: fix to check return value of freeze_bdev() in ext4_shutdown()")

from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc fs/ext4/ioctl.c
index 961284cc9b65,55be1b8a6360..000000000000
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@@ -793,10 -793,18 +793,11 @@@ static int ext4_ioctl_setproject(struc
  }
  #endif
  
 -static int ext4_shutdown(struct super_block *sb, unsigned long arg)
 +int ext4_force_shutdown(struct super_block *sb, u32 flags)
  {
  	struct ext4_sb_info *sbi = EXT4_SB(sb);
 -	__u32 flags;
+ 	int ret;
  
 -	if (!capable(CAP_SYS_ADMIN))
 -		return -EPERM;
 -
 -	if (get_user(flags, (__u32 __user *)arg))
 -		return -EFAULT;
 -
  	if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH)
  		return -EINVAL;
  

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 1111 bytes --]

Hi all,

Today's linux-next merge of the ext4 tree got a conflict in:

  fs/ext4/ioctl.c

between commit:

  4db5c2e6236f ("ext4: convert to fileattr")

from Linus' tree and commit:

  339183dfb87c ("ext4: add ioctl EXT4_IOC_CHECKPOINT")

from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc fs/ext4/ioctl.c
index 31627f7dc5cd,d25eaec1afdc..000000000000
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@@ -1291,6 -1455,9 +1335,7 @@@ long ext4_compat_ioctl(struct file *fil
  	case EXT4_IOC_CLEAR_ES_CACHE:
  	case EXT4_IOC_GETSTATE:
  	case EXT4_IOC_GET_ES_CACHE:
 -	case FS_IOC_FSGETXATTR:
 -	case FS_IOC_FSSETXATTR:
+ 	case EXT4_IOC_CHECKPOINT:
  		break;
  	default:
  		return -ENOIOCTLCMD;

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 4420 bytes --]

Hi all,

Today's linux-next merge of the ext4 tree got a conflict in:

  fs/ext4/super.c

between commit:

  8446fe9255be ("block: switch partition lookup to use struct block_device")

from Linus' tree and commit:

  8e6f04c5e918 ("ext4: use sbi instead of EXT4_SB(sb) in ext4_update_super()")

from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc fs/ext4/super.c
index 830c196ec069,f53e69ec858d..000000000000
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@@ -5499,22 -5493,76 +5487,72 @@@ static void ext4_update_super(struct su
  	 */
  	if (!(sb->s_flags & SB_RDONLY))
  		ext4_update_tstamp(es, s_wtime);
 -	if (sb->s_bdev->bd_part)
 -		es->s_kbytes_written =
 -			cpu_to_le64(sbi->s_kbytes_written +
 -			    ((part_stat_read(sb->s_bdev->bd_part,
 -					     sectors[STAT_WRITE]) -
 -			      sbi->s_sectors_written_start) >> 1));
 -	else
 -		es->s_kbytes_written = cpu_to_le64(sbi->s_kbytes_written);
 +	es->s_kbytes_written =
- 		cpu_to_le64(EXT4_SB(sb)->s_kbytes_written +
++		cpu_to_le64(sbi->s_kbytes_written +
 +		    ((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) -
- 		      EXT4_SB(sb)->s_sectors_written_start) >> 1));
- 	if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeclusters_counter))
++		      sbi->s_sectors_written_start) >> 1));
+ 	if (percpu_counter_initialized(&sbi->s_freeclusters_counter))
  		ext4_free_blocks_count_set(es,
- 			EXT4_C2B(EXT4_SB(sb), percpu_counter_sum_positive(
- 				&EXT4_SB(sb)->s_freeclusters_counter)));
- 	if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeinodes_counter))
+ 			EXT4_C2B(sbi, percpu_counter_sum_positive(
+ 				&sbi->s_freeclusters_counter)));
+ 	if (percpu_counter_initialized(&sbi->s_freeinodes_counter))
  		es->s_free_inodes_count =
  			cpu_to_le32(percpu_counter_sum_positive(
- 				&EXT4_SB(sb)->s_freeinodes_counter));
- 	BUFFER_TRACE(sbh, "marking dirty");
+ 				&sbi->s_freeinodes_counter));
+ 	/* Copy error information to the on-disk superblock */
+ 	spin_lock(&sbi->s_error_lock);
+ 	if (sbi->s_add_error_count > 0) {
+ 		es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
+ 		if (!es->s_first_error_time && !es->s_first_error_time_hi) {
+ 			__ext4_update_tstamp(&es->s_first_error_time,
+ 					     &es->s_first_error_time_hi,
+ 					     sbi->s_first_error_time);
+ 			strncpy(es->s_first_error_func, sbi->s_first_error_func,
+ 				sizeof(es->s_first_error_func));
+ 			es->s_first_error_line =
+ 				cpu_to_le32(sbi->s_first_error_line);
+ 			es->s_first_error_ino =
+ 				cpu_to_le32(sbi->s_first_error_ino);
+ 			es->s_first_error_block =
+ 				cpu_to_le64(sbi->s_first_error_block);
+ 			es->s_first_error_errcode =
+ 				ext4_errno_to_code(sbi->s_first_error_code);
+ 		}
+ 		__ext4_update_tstamp(&es->s_last_error_time,
+ 				     &es->s_last_error_time_hi,
+ 				     sbi->s_last_error_time);
+ 		strncpy(es->s_last_error_func, sbi->s_last_error_func,
+ 			sizeof(es->s_last_error_func));
+ 		es->s_last_error_line = cpu_to_le32(sbi->s_last_error_line);
+ 		es->s_last_error_ino = cpu_to_le32(sbi->s_last_error_ino);
+ 		es->s_last_error_block = cpu_to_le64(sbi->s_last_error_block);
+ 		es->s_last_error_errcode =
+ 				ext4_errno_to_code(sbi->s_last_error_code);
+ 		/*
+ 		 * Start the daily error reporting function if it hasn't been
+ 		 * started already
+ 		 */
+ 		if (!es->s_error_count)
+ 			mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ);
+ 		le32_add_cpu(&es->s_error_count, sbi->s_add_error_count);
+ 		sbi->s_add_error_count = 0;
+ 	}
+ 	spin_unlock(&sbi->s_error_lock);
+ 
  	ext4_superblock_csum_set(sb);
- 	if (sync)
- 		lock_buffer(sbh);
+ 	unlock_buffer(sbh);
+ }
+ 
+ static int ext4_commit_super(struct super_block *sb)
+ {
+ 	struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
+ 	int error = 0;
+ 
+ 	if (!sbh || block_device_ejected(sb))
+ 		return error;
+ 
+ 	ext4_update_super(sb);
+ 
  	if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) {
  		/*
  		 * Oh, dear.  A previous attempt to write the

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 6392 bytes --]

Hi all,

Today's linux-next merge of the ext4 tree got a conflict in:

  fs/ext4/ialloc.c

between commits:

  177cc0e71008 ("ext4: factor out ext4_xattr_credits_for_new_inode()")
  02ce5316afc8 ("ext4: use fscrypt_prepare_new_inode() and fscrypt_set_context()")

from Linus' tree and commit:

  44059e503b03 ("ext4: fast commit recovery path")

from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc fs/ext4/ialloc.c
index 698ca4a4db5f,2400a8200435..000000000000
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@@ -742,53 -746,122 +746,169 @@@ not_found
  	return 1;
  }
  
 +static int ext4_xattr_credits_for_new_inode(struct inode *dir, mode_t mode,
 +					    bool encrypt)
 +{
 +	struct super_block *sb = dir->i_sb;
 +	int nblocks = 0;
 +#ifdef CONFIG_EXT4_FS_POSIX_ACL
 +	struct posix_acl *p = get_acl(dir, ACL_TYPE_DEFAULT);
 +
 +	if (IS_ERR(p))
 +		return PTR_ERR(p);
 +	if (p) {
 +		int acl_size = p->a_count * sizeof(ext4_acl_entry);
 +
 +		nblocks += (S_ISDIR(mode) ? 2 : 1) *
 +			__ext4_xattr_set_credits(sb, NULL /* inode */,
 +						 NULL /* block_bh */, acl_size,
 +						 true /* is_create */);
 +		posix_acl_release(p);
 +	}
 +#endif
 +
 +#ifdef CONFIG_SECURITY
 +	{
 +		int num_security_xattrs = 1;
 +
 +#ifdef CONFIG_INTEGRITY
 +		num_security_xattrs++;
 +#endif
 +		/*
 +		 * We assume that security xattrs are never more than 1k.
 +		 * In practice they are under 128 bytes.
 +		 */
 +		nblocks += num_security_xattrs *
 +			__ext4_xattr_set_credits(sb, NULL /* inode */,
 +						 NULL /* block_bh */, 1024,
 +						 true /* is_create */);
 +	}
 +#endif
 +	if (encrypt)
 +		nblocks += __ext4_xattr_set_credits(sb,
 +						    NULL /* inode */,
 +						    NULL /* block_bh */,
 +						    FSCRYPT_SET_CONTEXT_MAX_SIZE,
 +						    true /* is_create */);
 +	return nblocks;
 +}
 +
+ int ext4_mark_inode_used(struct super_block *sb, int ino)
+ {
+ 	unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
+ 	struct buffer_head *inode_bitmap_bh = NULL, *group_desc_bh = NULL;
+ 	struct ext4_group_desc *gdp;
+ 	ext4_group_t group;
+ 	int bit;
+ 	int err = -EFSCORRUPTED;
+ 
+ 	if (ino < EXT4_FIRST_INO(sb) || ino > max_ino)
+ 		goto out;
+ 
+ 	group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
+ 	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
+ 	inode_bitmap_bh = ext4_read_inode_bitmap(sb, group);
+ 	if (IS_ERR(inode_bitmap_bh))
+ 		return PTR_ERR(inode_bitmap_bh);
+ 
+ 	if (ext4_test_bit(bit, inode_bitmap_bh->b_data)) {
+ 		err = 0;
+ 		goto out;
+ 	}
+ 
+ 	gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
+ 	if (!gdp || !group_desc_bh) {
+ 		err = -EINVAL;
+ 		goto out;
+ 	}
+ 
+ 	ext4_set_bit(bit, inode_bitmap_bh->b_data);
+ 
+ 	BUFFER_TRACE(inode_bitmap_bh, "call ext4_handle_dirty_metadata");
+ 	err = ext4_handle_dirty_metadata(NULL, NULL, inode_bitmap_bh);
+ 	if (err) {
+ 		ext4_std_error(sb, err);
+ 		goto out;
+ 	}
+ 	err = sync_dirty_buffer(inode_bitmap_bh);
+ 	if (err) {
+ 		ext4_std_error(sb, err);
+ 		goto out;
+ 	}
+ 
+ 	/* We may have to initialize the block bitmap if it isn't already */
+ 	if (ext4_has_group_desc_csum(sb) &&
+ 	    gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
+ 		struct buffer_head *block_bitmap_bh;
+ 
+ 		block_bitmap_bh = ext4_read_block_bitmap(sb, group);
+ 		if (IS_ERR(block_bitmap_bh)) {
+ 			err = PTR_ERR(block_bitmap_bh);
+ 			goto out;
+ 		}
+ 
+ 		BUFFER_TRACE(block_bitmap_bh, "dirty block bitmap");
+ 		err = ext4_handle_dirty_metadata(NULL, NULL, block_bitmap_bh);
+ 		sync_dirty_buffer(block_bitmap_bh);
+ 
+ 		/* recheck and clear flag under lock if we still need to */
+ 		ext4_lock_group(sb, group);
+ 		if (ext4_has_group_desc_csum(sb) &&
+ 		    (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))) {
+ 			gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
+ 			ext4_free_group_clusters_set(sb, gdp,
+ 				ext4_free_clusters_after_init(sb, group, gdp));
+ 			ext4_block_bitmap_csum_set(sb, group, gdp,
+ 						   block_bitmap_bh);
+ 			ext4_group_desc_csum_set(sb, group, gdp);
+ 		}
+ 		ext4_unlock_group(sb, group);
+ 		brelse(block_bitmap_bh);
+ 
+ 		if (err) {
+ 			ext4_std_error(sb, err);
+ 			goto out;
+ 		}
+ 	}
+ 
+ 	/* Update the relevant bg descriptor fields */
+ 	if (ext4_has_group_desc_csum(sb)) {
+ 		int free;
+ 
+ 		ext4_lock_group(sb, group); /* while we modify the bg desc */
+ 		free = EXT4_INODES_PER_GROUP(sb) -
+ 			ext4_itable_unused_count(sb, gdp);
+ 		if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
+ 			gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
+ 			free = 0;
+ 		}
+ 
+ 		/*
+ 		 * Check the relative inode number against the last used
+ 		 * relative inode number in this group. if it is greater
+ 		 * we need to update the bg_itable_unused count
+ 		 */
+ 		if (bit >= free)
+ 			ext4_itable_unused_set(sb, gdp,
+ 					(EXT4_INODES_PER_GROUP(sb) - bit - 1));
+ 	} else {
+ 		ext4_lock_group(sb, group);
+ 	}
+ 
+ 	ext4_free_inodes_set(sb, gdp, ext4_free_inodes_count(sb, gdp) - 1);
+ 	if (ext4_has_group_desc_csum(sb)) {
+ 		ext4_inode_bitmap_csum_set(sb, group, gdp, inode_bitmap_bh,
+ 					   EXT4_INODES_PER_GROUP(sb) / 8);
+ 		ext4_group_desc_csum_set(sb, group, gdp);
+ 	}
+ 
+ 	ext4_unlock_group(sb, group);
+ 	err = ext4_handle_dirty_metadata(NULL, NULL, group_desc_bh);
+ 	sync_dirty_buffer(group_desc_bh);
+ out:
+ 	return err;
+ }
+ 
  /*
   * There are two policies for allocating an inode.  If the new inode is
   * a directory, then a forward search is made for a block group with both
@@@ -818,8 -891,8 +938,8 @@@ struct inode *__ext4_new_inode(handle_
  	struct inode *ret;
  	ext4_group_t i;
  	ext4_group_t flex_group;
- 	struct ext4_group_info *grp;
+ 	struct ext4_group_info *grp = NULL;
 -	int encrypt = 0;
 +	bool encrypt = false;
  
  	/* Cannot create files in a deleted directory */
  	if (!dir || !dir->i_nlink)

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Mark Brown]

[-- Attachment #1: Type: text/plain, Size: 3517 bytes --]

Hi all,

Today's linux-next merge of the ext4 tree got a conflict in:

  fs/ext4/ioctl.c

between commit:

  29b3692e6dbf8226 ("ext4: wire up new fscrypt ioctls")

from Linus' tree and commits:

  bb5835edcdf8bf7 ("ext4: add new ioctl EXT4_IOC_GET_ES_CACHE")
  1ad3ea6e0a694b0 ("ext4: add a new ioctl EXT4_IOC_GETSTATE")

from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --cc fs/ext4/ioctl.c
index 5444d49cbf09d,d6242b7b87182..0000000000000
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@@ -1113,35 -1181,35 +1181,62 @@@ resizefs_out
  #endif
  	}
  	case EXT4_IOC_GET_ENCRYPTION_POLICY:
 +		if (!ext4_has_feature_encrypt(sb))
 +			return -EOPNOTSUPP;
  		return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
  
 +	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
 +		if (!ext4_has_feature_encrypt(sb))
 +			return -EOPNOTSUPP;
 +		return fscrypt_ioctl_get_policy_ex(filp, (void __user *)arg);
 +
 +	case FS_IOC_ADD_ENCRYPTION_KEY:
 +		if (!ext4_has_feature_encrypt(sb))
 +			return -EOPNOTSUPP;
 +		return fscrypt_ioctl_add_key(filp, (void __user *)arg);
 +
 +	case FS_IOC_REMOVE_ENCRYPTION_KEY:
 +		if (!ext4_has_feature_encrypt(sb))
 +			return -EOPNOTSUPP;
 +		return fscrypt_ioctl_remove_key(filp, (void __user *)arg);
 +
 +	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
 +		if (!ext4_has_feature_encrypt(sb))
 +			return -EOPNOTSUPP;
 +		return fscrypt_ioctl_remove_key_all_users(filp,
 +							  (void __user *)arg);
 +	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
 +		if (!ext4_has_feature_encrypt(sb))
 +			return -EOPNOTSUPP;
 +		return fscrypt_ioctl_get_key_status(filp, (void __user *)arg);
 +
+ 	case EXT4_IOC_CLEAR_ES_CACHE:
+ 	{
+ 		if (!inode_owner_or_capable(inode))
+ 			return -EACCES;
+ 		ext4_clear_inode_es(inode);
+ 		return 0;
+ 	}
+ 
+ 	case EXT4_IOC_GETSTATE:
+ 	{
+ 		__u32	state = 0;
+ 
+ 		if (ext4_test_inode_state(inode, EXT4_STATE_EXT_PRECACHED))
+ 			state |= EXT4_STATE_FLAG_EXT_PRECACHED;
+ 		if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
+ 			state |= EXT4_STATE_FLAG_NEW;
+ 		if (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY))
+ 			state |= EXT4_STATE_FLAG_NEWENTRY;
+ 		if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE))
+ 			state |= EXT4_STATE_FLAG_DA_ALLOC_CLOSE;
+ 
+ 		return put_user(state, (__u32 __user *) arg);
+ 	}
+ 
+ 	case EXT4_IOC_GET_ES_CACHE:
+ 		return ext4_ioctl_get_es_cache(filp, arg);
+ 
  	case EXT4_IOC_FSGETXATTR:
  	{
  		struct fsxattr fa;
@@@ -1269,15 -1326,11 +1364,18 @@@ long ext4_compat_ioctl(struct file *fil
  	case EXT4_IOC_SET_ENCRYPTION_POLICY:
  	case EXT4_IOC_GET_ENCRYPTION_PWSALT:
  	case EXT4_IOC_GET_ENCRYPTION_POLICY:
 +	case FS_IOC_GET_ENCRYPTION_POLICY_EX:
 +	case FS_IOC_ADD_ENCRYPTION_KEY:
 +	case FS_IOC_REMOVE_ENCRYPTION_KEY:
 +	case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
 +	case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
  	case EXT4_IOC_SHUTDOWN:
  	case FS_IOC_GETFSMAP:
 +	case FS_IOC_ENABLE_VERITY:
 +	case FS_IOC_MEASURE_VERITY:
+ 	case EXT4_IOC_CLEAR_ES_CACHE:
+ 	case EXT4_IOC_GETSTATE:
+ 	case EXT4_IOC_GET_ES_CACHE:
  		break;
  	default:
  		return -ENOIOCTLCMD;

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

Hi Theodore,

Today's linux-next merge of the ext4 tree got a conflict in:

  fs/overlayfs/super.c

between commit:

  b5891cfab08f ("ovl: fix working on distributed fs as lower layer")

from Linus' tree and commit:

  a7f7fb45f728 ("vfs: add file_dentry()")

from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc fs/overlayfs/super.c
index 619ad4b016d2,10dbdc7da69d..000000000000
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@@ -343,7 -356,7 +358,8 @@@ static const struct dentry_operations o
  
  static const struct dentry_operations ovl_reval_dentry_operations = {
  	.d_release = ovl_dentry_release,
 +	.d_select_inode = ovl_d_select_inode,
+ 	.d_native_dentry = ovl_d_native_dentry,
  	.d_revalidate = ovl_dentry_revalidate,
  	.d_weak_revalidate = ovl_dentry_weak_revalidate,
  };

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 549 bytes --]

Hi Theodore,

Today's linux-next merge of the ext4 tree got a conflict in
fs/ext4/ioctl.c between commit cde2d7a796f7 ("ext4: flush the extent
status cache during EXT4_IOC_SWAP_BOOT") from Linus' tree and commit
0dee1a241030 ("ext4: swap all the extent_status LRU fields during
EXT4_IOC_SWAP_BOOT") from the ext4 tree.

I fixed it up (I guessed that the ext4 tree version is a better fix(?) so
used that) and can carry the fix as necessary (no action is required).

-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au

[-- Attachment #2: Type: application/pgp-signature, Size: 836 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 509 bytes --]

Hi Ted,

Today's linux-next merge of the ext4 tree got a conflict in
fs/ext4/mballoc.c between commit 2892c15ddda6a76dc10b7499e56c0f3b892e5a69
("ext4: make grpinfo slab cache names static") from Linus' tree and
commit 63a1555068c51e47fcdd3c097e9891ac88e86184 ("ext4: make grpinfo slab
cache names static") from the ext4 tree.

I used the version from Linus' tree (since that one was updated).
-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au
http://www.canb.auug.org.au/~sfr/

[-- Attachment #2: Type: application/pgp-signature, Size: 490 bytes --]

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

Hi Ted,

Today's linux-next merge of the ext4 tree got a conflict in
fs/ext4/inode.c between commit ebdec241d509cf69f6ebf1ecdc036359d3dbe154
("fs: kill block_prepare_write") from Linus' tree and commits
dd26005ac2f8b62a18fa33cfe082e94ff6151a73 ("ext4: simplify ext4_writepage
()") and a848e44595e1dfe55c3e85432ab018c49674281f ("ext4: inline
ext4_writepage() into mpage_da_submit_io()") from the ext4 tree.

I fixed it up (see below) and can carry the fix as necessary.

(I do wish that all those commits had appeared in linux-next some time
before today ...)
-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au

diff --cc fs/ext4/inode.c
index 49635ef,45fc5bd..0000000
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@@ -2030,86 -2062,32 +2062,32 @@@ static int mpage_da_submit_io(struct mp
  			BUG_ON(!PageLocked(page));
  			BUG_ON(PageWriteback(page));
  
- 			pages_skipped = mpd->wbc->pages_skipped;
- 			err = mapping->a_ops->writepage(page, mpd->wbc);
- 			if (!err && (pages_skipped == mpd->wbc->pages_skipped))
- 				/*
- 				 * have successfully written the page
- 				 * without skipping the same
- 				 */
- 				mpd->pages_written++;
  			/*
- 			 * In error case, we have to continue because
- 			 * remaining pages are still locked
- 			 * XXX: unlock and re-dirty them?
+ 			 * If the page does not have buffers (for
+ 			 * whatever reason), try to create them using
 -			 * block_prepare_write.  If this fails,
++			 * __block_write_begin.  If this fails,
+ 			 * redirty the page and move on.
  			 */
- 			if (ret == 0)
- 				ret = err;
- 		}
- 		pagevec_release(&pvec);
- 	}
- 	return ret;
- }
- 
- /*
-  * mpage_put_bnr_to_bhs - walk blocks and assign them actual numbers
-  *
-  * the function goes through all passed space and put actual disk
-  * block numbers into buffer heads, dropping BH_Delay and BH_Unwritten
-  */
- static void mpage_put_bnr_to_bhs(struct mpage_da_data *mpd,
- 				 struct ext4_map_blocks *map)
- {
- 	struct inode *inode = mpd->inode;
- 	struct address_space *mapping = inode->i_mapping;
- 	int blocks = map->m_len;
- 	sector_t pblock = map->m_pblk, cur_logical;
- 	struct buffer_head *head, *bh;
- 	pgoff_t index, end;
- 	struct pagevec pvec;
- 	int nr_pages, i;
- 
- 	index = map->m_lblk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
- 	end = (map->m_lblk + blocks - 1) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
- 	cur_logical = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
- 
- 	pagevec_init(&pvec, 0);
- 
- 	while (index <= end) {
- 		/* XXX: optimize tail */
- 		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
- 		if (nr_pages == 0)
- 			break;
- 		for (i = 0; i < nr_pages; i++) {
- 			struct page *page = pvec.pages[i];
- 
- 			index = page->index;
- 			if (index > end)
- 				break;
- 			index++;
- 
- 			BUG_ON(!PageLocked(page));
- 			BUG_ON(PageWriteback(page));
- 			BUG_ON(!page_has_buffers(page));
- 
- 			bh = page_buffers(page);
- 			head = bh;
- 
- 			/* skip blocks out of the range */
- 			do {
- 				if (cur_logical >= map->m_lblk)
- 					break;
- 				cur_logical++;
- 			} while ((bh = bh->b_this_page) != head);
+ 			if (!page_has_buffers(page)) {
 -				if (block_prepare_write(page, 0, len,
++				if (__block_write_begin(page, 0, len,
+ 						noalloc_get_block_write)) {
+ 				redirty_page:
+ 					redirty_page_for_writepage(mpd->wbc,
+ 								   page);
+ 					unlock_page(page);
+ 					continue;
+ 				}
+ 				commit_write = 1;
+ 			}
  
+ 			bh = page_bufs = page_buffers(page);
+ 			block_start = 0;
  			do {
- 				if (cur_logical >= map->m_lblk + blocks)
- 					break;
- 
- 				if (buffer_delay(bh) || buffer_unwritten(bh)) {
- 
- 					BUG_ON(bh->b_bdev != inode->i_sb->s_bdev);
- 
+ 				if (!bh)
+ 					goto redirty_page;
+ 				if (map && (cur_logical >= map->m_lblk) &&
+ 				    (cur_logical <= (map->m_lblk +
+ 						     (map->m_len - 1)))) {
  					if (buffer_delay(bh)) {
  						clear_buffer_delay(bh);
  						bh->b_blocknr = pblock;
@@@ -2712,18 -2714,15 +2713,15 @@@ static int ext4_writepage(struct page *
  	else
  		len = PAGE_CACHE_SIZE;
  
- 	if (page_has_buffers(page)) {
- 		page_bufs = page_buffers(page);
- 		if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
- 					ext4_bh_delay_or_unwritten)) {
- 			/*
- 			 * We don't want to do  block allocation
- 			 * So redirty the page and return
- 			 * We may reach here when we do a journal commit
- 			 * via journal_submit_inode_data_buffers.
- 			 * If we don't have mapping block we just ignore
- 			 * them. We can also reach here via shrink_page_list
- 			 */
+ 	/*
+ 	 * If the page does not have buffers (for whatever reason),
 -	 * try to create them using block_prepare_write.  If this
++	 * try to create them using __block_write_begin.  If this
+ 	 * fails, redirty the page and move on.
+ 	 */
+ 	if (!page_buffers(page)) {
 -		if (block_prepare_write(page, 0, len,
++		if (__block_write_begin(page, 0, len,
+ 					noalloc_get_block_write)) {
+ 		redirty_page:
  			redirty_page_for_writepage(wbc, page);
  			unlock_page(page);
  			return 0;

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

Hi Ted,

Today's linux-next merge of the ext4 tree got a conflict in
include/linux/quotaops.h between commit
12755627bdcddcdb30a1bfb9a09395a52b1d6838 ("quota: unify quota init
condition in setattr") from Linus' tree and commits
2b03a9dee57f0a567b17571774d6a6ee8e0135b6 ("quota: use flags interface for
dquot alloc/free space") and facd5e10d2eca8b0eb85eba94494d9302c3740ad
("quota: add the option to not fail with EDQUOT in block") from the ext4
tree.

Juts overlapping additions.  I fixed it up (see below) and can carry the
fix for a while.
-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au

diff --cc include/linux/quotaops.h
index 0c77cd8,8f858ce..0000000
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@@ -14,14 -14,10 +14,18 @@@ static inline struct quota_info *sb_dqo
  	return &sb->s_dquot;
  }
  
 +/* i_mutex must being held */
 +static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
 +{
 +	return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
 +		(ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
 +		(ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
 +}
 +
+ #define DQUOT_SPACE_WARN	0x1
+ #define DQUOT_SPACE_RESERVE	0x2
+ #define DQUOT_SPACE_NOFAIL	0x4
+ 
  #if defined(CONFIG_QUOTA)
  
  /*

Re: linux-next: manual merge of the ext4 tree with Linus tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 319 bytes --]

Hi Ted,

On Thu, 17 Sep 2009 09:22:43 -0400 Theodore Tso <tytso@mit.edu> wrote:
>
> Thanks, this is in a patch series which I'm preparing to push to
> Linus, so I've fixed it up on my end.

OK, thanks.

-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au
http://www.canb.auug.org.au/~sfr/

[-- Attachment #2: Type: application/pgp-signature, Size: 198 bytes --]

Re: linux-next: manual merge of the ext4 tree with Linus tree

[Theodore Tso]

On Thu, Sep 17, 2009 at 11:56:53AM +1000, Stephen Rothwell wrote:
> Hi Theodore,
> 
> Today's linux-next merge of the ext4 tree got a conflict in
> include/trace/events/ext4.h between commit
> 1fe06ad89255c211fe100d7f690d10b161398df8 ("writeback: get rid of
> wbc->for_writepages") from Linus tree and commits
> b3107b75b479ff8f0a8aba9cdb38ec13284ce7eb ("ext4: Fix spelling typo in the
> trace format for trace_ext4_da_writepages()") from the ext4 tree.
> 
> I fixed it up (see below) and can carry the fix for a while.

Thanks, this is in a patch series which I'm preparing to push to
Linus, so I've fixed it up on my end.

						- Ted

linux-next: manual merge of the ext4 tree with Linus tree

[Stephen Rothwell]

Hi Theodore,

Today's linux-next merge of the ext4 tree got a conflict in
include/trace/events/ext4.h between commit
1fe06ad89255c211fe100d7f690d10b161398df8 ("writeback: get rid of
wbc->for_writepages") from Linus tree and commits
b3107b75b479ff8f0a8aba9cdb38ec13284ce7eb ("ext4: Fix spelling typo in the
trace format for trace_ext4_da_writepages()") from the ext4 tree.

I fixed it up (see below) and can carry the fix for a while.
-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au

diff --cc include/trace/events/ext4.h
index 8d433c4e,3d26f9d..0000000
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@@ -243,14 -247,50 +246,49 @@@ TRACE_EVENT(ext4_da_writepages
  		__entry->range_cyclic	= wbc->range_cyclic;
  	),
  
- 	TP_printk("dev %s ino %lu nr_t_write %ld pages_skipped %ld range_start %llu range_end %llu nonblocking %d for_kupdate %d for_reclaim %d range_cyclic %d",
- 		  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->nr_to_write,
 -	TP_printk("dev %s ino %lu nr_to_write %ld pages_skipped %ld range_start %llu range_end %llu nonblocking %d for_kupdate %d for_reclaim %d for_writepages %d range_cyclic %d",
++	TP_printk("dev %s ino %lu nr_to_write %ld pages_skipped %ld range_start %llu range_end %llu nonblocking %d for_kupdate %d for_reclaim %d range_cyclic %d",
+ 		  jbd2_dev_to_name(__entry->dev),
+ 		  (unsigned long) __entry->ino, __entry->nr_to_write,
  		  __entry->pages_skipped, __entry->range_start,
  		  __entry->range_end, __entry->nonblocking,
  		  __entry->for_kupdate, __entry->for_reclaim,
 -		  __entry->for_writepages, __entry->range_cyclic)
 +		  __entry->range_cyclic)
  );
  
+ TRACE_EVENT(ext4_da_write_pages,
+ 	TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
+ 
+ 	TP_ARGS(inode, mpd),
+ 
+ 	TP_STRUCT__entry(
+ 		__field(	dev_t,	dev			)
+ 		__field(	ino_t,	ino			)
+ 		__field(	__u64,	b_blocknr		)
+ 		__field(	__u32,	b_size			)
+ 		__field(	__u32,	b_state			)
+ 		__field(	unsigned long,	first_page	)
+ 		__field(	int,	io_done			)
+ 		__field(	int,	pages_written		)
+ 	),
+ 
+ 	TP_fast_assign(
+ 		__entry->dev		= inode->i_sb->s_dev;
+ 		__entry->ino		= inode->i_ino;
+ 		__entry->b_blocknr	= mpd->b_blocknr;
+ 		__entry->b_size		= mpd->b_size;
+ 		__entry->b_state	= mpd->b_state;
+ 		__entry->first_page	= mpd->first_page;
+ 		__entry->io_done	= mpd->io_done;
+ 		__entry->pages_written	= mpd->pages_written;
+ 	),
+ 
+ 	TP_printk("dev %s ino %lu b_blocknr %llu b_size %u b_state 0x%04x first_page %lu io_done %d pages_written %d",
+ 		  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+ 		  __entry->b_blocknr, __entry->b_size,
+ 		  __entry->b_state, __entry->first_page,
+ 		  __entry->io_done, __entry->pages_written)
+ );
+ 
  TRACE_EVENT(ext4_da_writepages_result,
  	TP_PROTO(struct inode *inode, struct writeback_control *wbc,
  			int ret, int pages_written),

linux-next: manual merge of the ext4 tree with Linus' tree

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 621 bytes --]

Hi Ted,

Today's linux-next merge of the ext4 tree got a conflict in
fs/ext4/ext4.h between commit 06a279d636734da32bb62dd2f7b0ade666f65d7c
("ext4: only use i_size_high for regular files") from Linus' tree and
commit eef9a6114469769465d43b1f8198ee1ae888e143 ("ext4: ignore
i_size_high for directories") from the ext4 tree.

These two commits appear to do almost the same thing.  I used the version
from Linus' tree.  Please either merge Linus' tree into the ext4 tree or
drop/modify the commit there.

-- 
Cheers,
Stephen Rothwell                    sfr@canb.auug.org.au
http://www.canb.auug.org.au/~sfr/

[-- Attachment #2: Type: application/pgp-signature, Size: 197 bytes --]