(unknown),

(unknown),

[Yongqiang Yang]

Hi all,

  v1->v2:
  Reimplement old resize on new common code.

  This patch series adds new resize implementation to ext4.

  -- What's new resize implementation?
     It is a new online resize interface for ext4.  It can be used via
     ioctl with EXT4_IOC_RESIZE_FS and a 64 bit integer indicating size
     of the resized fs in block.

  -- What's difference between current resize and new resize?
     New resize lets kernel do all work, like allocating bitmaps and
     inode tables and can support flex_bg and BLOCK_UNINIT features.
     Besides these, new resize is much faster than current resize.

     Below are benchmarks I made on my personal computer, fses with
     flex_bg size = 16 were resized to 230GB evry time. The first
     row shows the size of a fs from which the fs was resized to 230GB.
     The datas were collected by 'time resize2fs'.

                        new resize
                  20GB          50GB      100GB
        real    0m3.558s     0m2.891s    0m0.394s
        user    0m0.004s     0m0.000s    0m0.394s

                        current resize
                  20GB          50GB      100GB
        real    5m2.770s     4m43.757s  3m14.840s
        user    0m0.040s     0m0.032s   0m0.024s
        sys     0m0.464s     0m0.432s   0m0.324s

     According to data above, new resize is faster than current resize in both
     user and sys time.  New resize performs well in sys time, because it
     supports BLOCK_UNINIT and adds multi-groups each time.

  -- Can new resize support new features like bigalloc and exclude bitmap easily?
     YES! New resize can support new feature like bigalloc and exclude bitmap
     easily.  Because it lets kernel do all work.

[PATCH v2 01/15] ext4: add a function which extends a group without
[PATCH v2 02/15] ext4: add a function which adds a new desc to a fs
[PATCH v2 03/15] ext4: add a function which sets up a new group desc
[PATCH v2 04/15] ext4: add a function which updates super block
[PATCH v2 05/15] ext4: add a structure which will be used by
[PATCH v2 06/15] ext4: add a function which sets up group blocks of
[PATCH v2 07/15] ext4: add a function which adds several group
[PATCH v2 08/15] ext4: add a function which sets up a flex groups
[PATCH v2 09/15] ext4: enable ext4_update_super() to handle a flex
[PATCH v2 10/15] ext4: pass verify_reserved_gdb() the number of
[PATCH v2 11/15] ext4: add a new function which allocates bitmaps
[PATCH v2 12/15] ext4: add a new function which adds a flex group to
[PATCH v2 13/15] ext4: add new online resize interface
[PATCH v2 14/15] ext4: let ext4_group_extend() use common code
[PATCH v2 15/15] ext4: let ext4_group_add() use common code

[PATCH v2 01/15] ext4: add a function which extends a group without checking parameters

[Yongqiang Yang]

This patch added a function named __ext4_group_extend() whose code
is copied from ext4_group_extend().  __ext4_group_extend() assumes
the parameter is valid and has been checked by caller.

__ext4_group_extend() will be used by new resize implementation. It
can also be used by ext4_group_extend(), but this patch series does
not do this.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 53 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 707d3f1..5126aac 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -969,6 +969,59 @@ exit_put:
 } /* ext4_group_add */
 
 /*
+ * extend a group without checking assuming that checking has been done.
+ */
+static int __ext4_group_extend(struct super_block *sb,
+			       ext4_fsblk_t o_blocks_count, ext4_grpblk_t add)
+{
+	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
+	handle_t *handle;
+	int err = 0, err2;
+
+	/* We will update the superblock, one block bitmap, and
+	 * one group descriptor via ext4_group_add_blocks().
+	 */
+	handle = ext4_journal_start_sb(sb, 3);
+	if (IS_ERR(handle)) {
+		err = PTR_ERR(handle);
+		ext4_warning(sb, "error %d on journal start", err);
+		goto out;
+	}
+
+	err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
+	if (err) {
+		ext4_warning(sb, "error %d on journal write access", err);
+		ext4_journal_stop(handle);
+		goto out;
+	}
+
+	ext4_blocks_count_set(es, o_blocks_count + add);
+	ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
+		   o_blocks_count + add);
+	/* We add the blocks to the bitmap and set the group need init bit */
+	err = ext4_group_add_blocks(handle, sb, o_blocks_count, add);
+	if (err)
+		goto exit_journal;
+	ext4_handle_dirty_super(handle, sb);
+	ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
+		   o_blocks_count + add);
+exit_journal:
+	err2 = ext4_journal_stop(handle);
+	if (err2 && !err)
+		err = err2;
+
+	if (!err) {
+		if (test_opt(sb, DEBUG))
+			printk(KERN_DEBUG "EXT4-fs: extended group to %llu "
+			       "blocks\n", ext4_blocks_count(es));
+		update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es,
+			       sizeof(struct ext4_super_block));
+	}
+out:
+	return err;
+}
+
+/*
  * Extend the filesystem to the new number of blocks specified.  This entry
  * point is only used to extend the current filesystem to the end of the last
  * existing group.  It can be accessed via ioctl, or by "remount,resize=<size>"
-- 
1.7.5.1

Re: [PATCH v2 01/15] ext4: add a function which extends a group without checking parameters

[Yongqiang Yang]

ping?

On Tue, Aug 30, 2011 at 4:10 PM, Yongqiang Yang <xiaoqiangnk@gmail.com> wrote:
> This patch added a function named __ext4_group_extend() whose code
> is copied from ext4_group_extend().  __ext4_group_extend() assumes
> the parameter is valid and has been checked by caller.
>
> __ext4_group_extend() will be used by new resize implementation. It
> can also be used by ext4_group_extend(), but this patch series does
> not do this.
>
> Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
> ---
>  fs/ext4/resize.c |   53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 files changed, 53 insertions(+), 0 deletions(-)
>
> diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
> index 707d3f1..5126aac 100644
> --- a/fs/ext4/resize.c
> +++ b/fs/ext4/resize.c
> @@ -969,6 +969,59 @@ exit_put:
>  } /* ext4_group_add */
>
>  /*
> + * extend a group without checking assuming that checking has been done.
> + */
> +static int __ext4_group_extend(struct super_block *sb,
> +                              ext4_fsblk_t o_blocks_count, ext4_grpblk_t add)
> +{
> +       struct ext4_super_block *es = EXT4_SB(sb)->s_es;
> +       handle_t *handle;
> +       int err = 0, err2;
> +
> +       /* We will update the superblock, one block bitmap, and
> +        * one group descriptor via ext4_group_add_blocks().
> +        */
> +       handle = ext4_journal_start_sb(sb, 3);
> +       if (IS_ERR(handle)) {
> +               err = PTR_ERR(handle);
> +               ext4_warning(sb, "error %d on journal start", err);
> +               goto out;
> +       }
> +
> +       err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
> +       if (err) {
> +               ext4_warning(sb, "error %d on journal write access", err);
> +               ext4_journal_stop(handle);
> +               goto out;
> +       }
> +
> +       ext4_blocks_count_set(es, o_blocks_count + add);
> +       ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
> +                  o_blocks_count + add);
> +       /* We add the blocks to the bitmap and set the group need init bit */
> +       err = ext4_group_add_blocks(handle, sb, o_blocks_count, add);
> +       if (err)
> +               goto exit_journal;
> +       ext4_handle_dirty_super(handle, sb);
> +       ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
> +                  o_blocks_count + add);
> +exit_journal:
> +       err2 = ext4_journal_stop(handle);
> +       if (err2 && !err)
> +               err = err2;
> +
> +       if (!err) {
> +               if (test_opt(sb, DEBUG))
> +                       printk(KERN_DEBUG "EXT4-fs: extended group to %llu "
> +                              "blocks\n", ext4_blocks_count(es));
> +               update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es,
> +                              sizeof(struct ext4_super_block));
> +       }
> +out:
> +       return err;
> +}
> +
> +/*
>  * Extend the filesystem to the new number of blocks specified.  This entry
>  * point is only used to extend the current filesystem to the end of the last
>  * existing group.  It can be accessed via ioctl, or by "remount,resize=<size>"
> --
> 1.7.5.1
>
>



-- 
Best Wishes
Yongqiang Yang
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v2 01/15] ext4: add a function which extends a group without checking parameters

[Ted Ts'o]

On Sun, Oct 30, 2011 at 09:48:43PM +0800, Yongqiang Yang wrote:
> ping?

I was very tempted to integrate this during this merge window, since
it only touches the online resize code, and it was pretty easy to test
it.  And, it would have been nice to have the new online resize
support released at about the same time as e2fsprogs 1.42, especially
it's much faster and handles flex_bg correctly.

Unfortunately, I tried testing both with the old and new resize2fs
binaries, and in both cases after created a stock ext4 filesystem
using the mke2fs.conf defaults as shipped with e2fsprogs, resized the
file system, and umounted the file system, the e2fsck reported file
system corruption.

I'm guesing you didn't test with the uninit_bg feature?  And it looks
like something is going wrong with the block bitmap in the last block
group.

I've put the online-resize patches with some cleanup work and some
changes so it would patch cleanly and compile into the end of the ext4
patch tree in the ext4 patch queue repository:

      git://repo.or.cz/ext4-patch-queue.git

On the whole the patch series seemed well written, but it looks like
it needs just a bit more polishing.  Hopefully we can get this fixed
up after the current merge window closes, and we can put it at the
beginning of the patches for the next merge window.

						- Ted

# e2fsck -f /dev/vdc
e2fsck 1.42-WIP (16-Oct-2011)
Last group block bitmap uninitialized.  Fix<y>? yes

Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
Block bitmap differences:  +(26206211--26206213) +26206215 +(26206219--26206221) +26206223 +(26206227--26206229) +26206231 +(26206235--26206237) +26206239 +(26206243--26206245) +26206247 +(26206251--26206253) +26206255 +(26206259--26206261) +26206263 +(26206267--26206269) +26206271 +(26206275--26206277) +26206279 +(26206283--26206285) +26206287 +(26206291--26206293) +26206295 +(26206299--26206301) +26206303 +(26206307--26206309) +26206311 +(26206315--26206317) +26206319 +(26206323--26206325) +26206327 +(26206331--26206333) +26206335 +(26206339--26206341) +26206343 +(26206347--26206349) +26206351 +(26206355--26206357) +26206359 +(26206363--26206365) +26206367 +(26206371--26206373) +26206375 +(26206379--26206381) +26206383 +(26206387--26206389) +26206391 +(26206395--26206397) +26206399 +(262
 06403--26206405) +26206407 +(26206411--26206413) +26206415 +(26206419--26206421) +26206423 +(26206427--26206429) +26206431 +(26206435--26206437) +26206439 +(26206443--26206445) +26206447 +(26206451--26206453) +26206455 +(26206459--26206461) +26206463 -(26206465--26206466) -26206470 -(26206472--26206474) -26206478 -(26206480--26206482) -26206486 -(26206488--26206490) -26206494 -(26206496--26206498) -26206502 -(26206504--26206506) -26206510 -(26206512--26206514) -26206518 -(26206520--26206522) -26206526 -(26206528--26206530) -26206534 -(26206536--26206538) -26206542 -(26206544--26206546) -26206550 -(26206552--26206554) -26206558 -(26206560--26206562) -26206566 -(26206568--26206570) -26206574 -(26206576--26206578) -26206582 -(26206584--26206586) -26206590 -(26206592--26206594) -26206598 -(2
 6206600--26206602) -26206606 -(26206608--26206610) -26206614 -(26206616--26206618) -26206622 -(26206624--26206626) -26206630 -(26206632--26206634) -26206638 -(26206640--26206642) -26206646 -(26206648--26206650) -26206654 -26206656 -26206662 -(26206664--26206666) -26206670 -(26206672--26206674) -26206678 -(26206680--26206682) -26206686 -(26206688--26206690) -26206694 -(26206696--26206698) -26206702 -(26206704--26206706) -26206710 -(26206712--26206714) -26206718 -(26206720--26206722) -26206726 -(26206728--26206730) -26206734 -(26206736--26206738) -26206742 -(26206744--26206746) -26206750 -(26206752--26206754) -26206758 -(26206760--26206762) -26206766 -(26206768--26206770) -26206774 -(26206776--26206778) -26206782 -(26206784--26206786) -26206790 -(26206792--26206794) -26206798 -(26206800--2
 6206802) -26206806 -(26206808--26206810) -26206814 -(26206816--26206818) -26206822 -(26206824--26206826) -26206830 -(26206832--26206834) -26206838 -(26206840--26206842) -26206846 -(26206848--26206850) -26206854 -(26206856--26206858) -26206862 -(26206864--26206866) -26206870 -(26206872--26206874) -26206878 -(26206880--26206882) -26206886 -(26206888--26206890) -26206894 -(26206896--26206898) -26206902 -(26206904--26206906) -26206910 -(26206912--26206914) -26206918 -(26206920--26206922) -26206926 -(26206928--26206930) -26206934 -(26206936--26206938) -26206942 -(26206944--26206946) -26206950 -(26206952--26206954) -26206958 -(26206960--26206962) -26206966 -(26206968--26206970) -26206974 -(26206976--26206978) -26206982 -(26206984--26206986) -26206990 -(26206992--26206994) -26206998 -(26207000-
 -26207002) -26207006 -(26207008--26207010) -26207014 -(26207016--26207018) -26207022 -(26207024--26207026) -26207030 -(26207032--26207034) -26207038 -(26207040--26207042) -26207046 -(26207048--26207050) -26207054 -(26207056--26207058) -26207062 -(26207064--26207066) -26207070 -(26207072--26207074) -26207078 -(26207080--26207082) -26207086 -(26207088--26207090) -26207094 -(26207096--26207098) -26207102 -(26207104--26207106) -26207110 -(26207112--26207114) -26207118 -(26207120--26207122) -26207126 -(26207128--26207130) -26207134 -(26207136--26207138) -26207142 -(26207144--26207146) -26207150 ....

Re: [PATCH v2 01/15] ext4: add a function which extends a group without checking parameters

[Yongqiang Yang]

On Wed, Nov 2, 2011 at 6:24 AM, Ted Ts'o <tytso@mit.edu> wrote:
> On Sun, Oct 30, 2011 at 09:48:43PM +0800, Yongqiang Yang wrote:
>> ping?
>
> I was very tempted to integrate this during this merge window, since
> it only touches the online resize code, and it was pretty easy to test
> it.  And, it would have been nice to have the new online resize
> support released at about the same time as e2fsprogs 1.42, especially
> it's much faster and handles flex_bg correctly.
>
> Unfortunately, I tried testing both with the old and new resize2fs
> binaries, and in both cases after created a stock ext4 filesystem
> using the mke2fs.conf defaults as shipped with e2fsprogs, resized the
> file system, and umounted the file system, the e2fsck reported file
> system corruption.
Sorry for troubles.  I have fixed the problem and post the patches out.

Yongqiang.
>
> I'm guesing you didn't test with the uninit_bg feature?  And it looks
> like something is going wrong with the block bitmap in the last block
> group.
>
> I've put the online-resize patches with some cleanup work and some
> changes so it would patch cleanly and compile into the end of the ext4
> patch tree in the ext4 patch queue repository:
>
>      git://repo.or.cz/ext4-patch-queue.git
>
> On the whole the patch series seemed well written, but it looks like
> it needs just a bit more polishing.  Hopefully we can get this fixed
> up after the current merge window closes, and we can put it at the
> beginning of the patches for the next merge window.
>
>                                                - Ted
>
> # e2fsck -f /dev/vdc
> e2fsck 1.42-WIP (16-Oct-2011)
> Last group block bitmap uninitialized.  Fix<y>? yes
>
> Pass 1: Checking inodes, blocks, and sizes
> Pass 2: Checking directory structure
> Pass 3: Checking directory connectivity
> Pass 4: Checking reference counts
> Pass 5: Checking group summary information
> Block bitmap differences:  +(26206211--26206213) +26206215 +(26206219--26206221) +26206223 +(26206227--26206229) +26206231 +(26206235--26206237) +26206239 +(26206243--26206245) +26206247 +(26206251--26206253) +26206255 +(26206259--26206261) +26206263 +(26206267--26206269) +26206271 +(26206275--26206277) +26206279 +(26206283--26206285) +26206287 +(26206291--26206293) +26206295 +(26206299--26206301) +26206303 +(26206307--26206309) +26206311 +(26206315--26206317) +26206319 +(26206323--26206325) +26206327 +(26206331--26206333) +26206335 +(26206339--26206341) +26206343 +(26206347--26206349) +26206351 +(26206355--26206357) +26206359 +(26206363--26206365) +26206367 +(26206371--26206373) +26206375 +(26206379--26206381) +26206383 +(26206387--26206389) +26206391 +(26206395--26206397) +26206399 +(26206403--26206405) +26206407 +(26206411--26206413) +26206415 +(26206419--26206421) +26206423 +(26206427--26206429) +26206431 +(26206435--26206437) +26206439 +(26206443--26206445) +26206447 +(26206451--26206453) +26206455 +(26206459--26206461) +26206463 -(26206465--26206466) -26206470 -(26206472--26206474) -26206478 -(26206480--26206482) -26206486 -(26206488--26206490) -26206494 -(26206496--26206498) -26206502 -(26206504--26206506) -26206510 -(26206512--26206514) -26206518 -(26206520--26206522) -26206526 -(26206528--26206530) -26206534 -(26206536--26206538) -26206542 -(26206544--26206546) -26206550 -(26206552--26206554) -26206558 -(26206560--26206562) -26206566 -(26206568--26206570) -26206574 -(26206576--26206578) -26206582 -(26206584--26206586) -26206590 -(26206592--26206594) -26206598 -(26206600--26206602) -26206606 -(26206608--26206610) -26206614 -(26206616--26206618) -26206622 -(26206624--26206626) -26206630 -(26206632--26206634) -26206638 -(26206640--26206642) -26206646 -(26206648--26206650) -26206654 -26206656 -26206662 -(26206664--26206666) -26206670 -(26206672--26206674) -26206678 -(26206680--26206682) -26206686 -(26206688--26206690) -26206694 -(26206696--26206698) -26206702 -(26206704--26206706) -26206710 -(26206712--26206714) -26206718 -(26206720--26206722) -26206726 -(26206728--26206730) -26206734 -(26206736--26206738) -26206742 -(26206744--26206746) -26206750 -(26206752--26206754) -26206758 -(26206760--26206762) -26206766 -(26206768--26206770) -26206774 -(26206776--26206778) -26206782 -(26206784--26206786) -26206790 -(26206792--26206794) -26206798 -(26206800--26206802) -26206806 -(26206808--26206810) -26206814 -(26206816--26206818) -26206822 -(26206824--26206826) -26206830 -(26206832--26206834) -26206838 -(26206840--26206842) -26206846 -(26206848--26206850) -26206854 -(26206856--26206858) -26206862 -(26206864--26206866) -26206870 -(26206872--26206874) -26206878 -(26206880--26206882) -26206886 -(26206888--26206890) -26206894 -(26206896--26206898) -26206902 -(26206904--26206906) -26206910 -(26206912--26206914) -26206918 -(26206920--26206922) -26206926 -(26206928--26206930) -26206934 -(26206936--26206938) -26206942 -(26206944--26206946) -26206950 -(26206952--26206954) -26206958 -(26206960--26206962) -26206966 -(26206968--26206970) -26206974 -(26206976--26206978) -26206982 -(26206984--26206986) -26206990 -(26206992--26206994) -26206998 -(26207000--26207002) -26207006 -(26207008--26207010) -26207014 -(26207016--26207018) -26207022 -(26207024--26207026) -26207030 -(26207032--26207034) -26207038 -(26207040--26207042) -26207046 -(26207048--26207050) -26207054 -(26207056--26207058) -26207062 -(26207064--26207066) -26207070 -(26207072--26207074) -26207078 -(26207080--26207082) -26207086 -(26207088--26207090) -26207094 -(26207096--26207098) -26207102 -(26207104--26207106) -26207110 -(26207112--26207114) -26207118 -(26207120--26207122) -26207126 -(26207128--26207130) -26207134 -(26207136--26207138) -26207142 -(26207144--26207146) -26207150 ....
>



-- 
Best Wishes
Yongqiang Yang
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH v2 02/15] ext4: add a function which adds a new desc to a fs

[Yongqiang Yang]

This patch adds a function named ext4_add_new_desc() which adds
a new desc to a fs and whose code is copied from ext4_group_add().

The function will be used by new resize implementation.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   42 ++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 42 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 5126aac..b577647 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -735,6 +735,48 @@ exit_err:
 	}
 }
 
+/*
+ * ext4_add_new_desc() adds group descriptor of group @group
+ *
+ * @handle: journal handle
+ * @sb; super block
+ * @group: the group no. of the first group desc to be added
+ * @resize_inode: the resize inode
+ */
+static int ext4_add_new_desc(handle_t *handle, struct super_block *sb,
+			     ext4_group_t group, struct inode *resize_inode)
+{
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	struct ext4_super_block *es = sbi->s_es;
+	struct buffer_head *gdb_bh;
+	int gdb_off, gdb_num, err = 0;
+	int reserved_gdb = ext4_bg_has_super(sb, group) ?
+		le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
+
+	gdb_off = group % EXT4_DESC_PER_BLOCK(sb);
+	gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
+
+	/*
+	 * We will only either add reserved group blocks to a backup group
+	 * or remove reserved blocks for the first group in a new group block.
+	 * Doing both would be mean more complex code, and sane people don't
+	 * use non-sparse filesystems anymore.  This is already checked above.
+	 */
+	if (gdb_off) {
+		gdb_bh = sbi->s_group_desc[gdb_num];
+		err = ext4_journal_get_write_access(handle, gdb_bh);
+		if (err)
+			goto out;
+
+		if (reserved_gdb && ext4_bg_num_gdb(sb, group))
+			err = reserve_backup_gdb(handle, resize_inode, group);
+	} else
+		err = add_new_gdb(handle, resize_inode, group);
+
+out:
+	return err;
+}
+
 /* Add group descriptor data to an existing or new group descriptor block.
  * Ensure we handle all possible error conditions _before_ we start modifying
  * the filesystem, because we cannot abort the transaction and not have it
-- 
1.7.5.1

[PATCH v2 03/15] ext4: add a function which sets up a new group desc

[Yongqiang Yang]

This patch adds a function named ext4_setup_new_desc() which sets
up a new group descriptor and whose code is sopied from ext4_group_add().

The function will be used by new resize implementation.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 54 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index b577647..66ca671 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -777,6 +777,60 @@ out:
 	return err;
 }
 
+/*
+ * ext4_setup_new_desc() sets up group descriptors specified by @input.
+ *
+ * @handle: journal handle
+ * @sb: super block
+ */
+static int ext4_setup_new_desc(handle_t *handle, struct super_block *sb,
+			       struct ext4_new_group_data *input)
+{
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	ext4_group_t group;
+	struct ext4_group_desc *gdp;
+	struct buffer_head *gdb_bh;
+	int gdb_off, gdb_num, err = 0;
+
+	group = input->group;
+
+	gdb_off = group % EXT4_DESC_PER_BLOCK(sb);
+	gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
+
+	/*
+	 * get_write_access() has been called on gdb_bh by ext4_add_new_desc().
+	 */
+	gdb_bh = sbi->s_group_desc[gdb_num];
+	/* Update group descriptor block for new group */
+	gdp = (struct ext4_group_desc *)((char *)gdb_bh->b_data +
+				 gdb_off * EXT4_DESC_SIZE(sb));
+
+	memset(gdp, 0, EXT4_DESC_SIZE(sb));
+	 /* LV FIXME */
+	memset(gdp, 0, EXT4_DESC_SIZE(sb));
+	ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */
+	ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */
+	ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */
+	ext4_free_blks_set(sb, gdp, input->free_blocks_count);
+	ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
+	gdp->bg_flags = cpu_to_le16(EXT4_BG_INODE_ZEROED);
+	gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp);
+
+	err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
+	if (unlikely(err)) {
+		ext4_std_error(sb, err);
+		return err;
+	}
+
+	/*
+	 * We can allocate memory for mb_alloc based on the new group
+	 * descriptor
+	 */
+	err = ext4_mb_add_groupinfo(sb, group, gdp);
+
+	return err;
+}
+
 /* Add group descriptor data to an existing or new group descriptor block.
  * Ensure we handle all possible error conditions _before_ we start modifying
  * the filesystem, because we cannot abort the transaction and not have it
-- 
1.7.5.1

[PATCH v2 04/15] ext4: add a function which updates super block

[Yongqiang Yang]

This patch adds a function named ext4_update_super() which updates
super block and whose code is copied from ext4_group_add().

The function will be used by new resize implementation.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 72 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 66ca671..d20b29c 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -831,6 +831,78 @@ static int ext4_setup_new_desc(handle_t *handle, struct super_block *sb,
 	return err;
 }
 
+/*
+ * ext4_update_super() updates super so that new the added group can be seen
+ *   by the filesystem.
+ *
+ * @sb: super block
+ */
+static void ext4_update_super(struct super_block *sb,
+			      struct ext4_new_group_data *input)
+{
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	struct ext4_super_block *es = sbi->s_es;
+
+	/*
+	 * Make the new blocks and inodes valid next.  We do this before
+	 * increasing the group count so that once the group is enabled,
+	 * all of its blocks and inodes are already valid.
+	 *
+	 * We always allocate group-by-group, then block-by-block or
+	 * inode-by-inode within a group, so enabling these
+	 * blocks/inodes before the group is live won't actually let us
+	 * allocate the new space yet.
+	 */
+	ext4_blocks_count_set(es, ext4_blocks_count(es) +
+		input->blocks_count);
+	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb));
+
+	/*
+	 * We need to protect s_groups_count against other CPUs seeing
+	 * inconsistent state in the superblock.
+	 *
+	 * The precise rules we use are:
+	 *
+	 * * Writers must perform a smp_wmb() after updating all dependent
+	 *   data and before modifying the groups count
+	 *
+	 * * Readers must perform an smp_rmb() after reading the groups count
+	 *   and before reading any dependent data.
+	 *
+	 * NB. These rules can be relaxed when checking the group count
+	 * while freeing data, as we can only allocate from a block
+	 * group after serialising against the group count, and we can
+	 * only then free after serialising in turn against that
+	 * allocation.
+	 */
+	smp_wmb();
+
+	/* Update the global fs size fields */
+	sbi->s_groups_count++;
+
+	/* Update the reserved block counts only once the new group is
+	 * active. */
+	ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
+		input->reserved_blocks);
+
+	/* Update the free space counts */
+	percpu_counter_add(&sbi->s_freeblocks_counter,
+			   input->free_blocks_count);
+	percpu_counter_add(&sbi->s_freeinodes_counter,
+			   EXT4_INODES_PER_GROUP(sb));
+
+	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
+	    sbi->s_log_groups_per_flex) {
+		ext4_group_t flex_group;
+		flex_group = ext4_flex_group(sbi, input->group);
+		atomic_add(input->free_blocks_count,
+			   &sbi->s_flex_groups[flex_group].free_blocks);
+		atomic_add(EXT4_INODES_PER_GROUP(sb),
+			   &sbi->s_flex_groups[flex_group].free_inodes);
+	}
+
+}
+
 /* Add group descriptor data to an existing or new group descriptor block.
  * Ensure we handle all possible error conditions _before_ we start modifying
  * the filesystem, because we cannot abort the transaction and not have it
-- 
1.7.5.1

[PATCH v2 05/15] ext4: add a structure which will be used by 64bit-resize interface

[Yongqiang Yang]

This patch adds a structure which will be used by 64bit-resize interface.
Two functions which allocate and destroy the structure respectively are
added.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 55 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index d20b29c..fb84b48 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -134,6 +134,61 @@ static int verify_group_input(struct super_block *sb,
 	return err;
 }
 
+/*
+ * ext4_new_flex_group_data is used by 64bit-resize interface to add a flex
+ * group each time.
+ */
+struct ext4_new_flex_group_data {
+	struct ext4_new_group_data *groups;	/* new_group_data for groups
+						   in the flex group */
+	__u16 *bg_flags;			/* block group flags of groups
+						   in @groups */
+	ext4_group_t count;			/* number of groups in @groups
+						 */
+};
+
+/*
+ * alloc_flex_gd() allocates a ext4_new_flex_group_data with size of
+ * @flexbg_size.
+ *
+ * Returns NULL on failure otherwise address of the allocated structure.
+ */
+static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size)
+{
+	struct ext4_new_flex_group_data *flex_gd;
+
+	flex_gd = kmalloc(sizeof(*flex_gd), GFP_NOFS);
+	if (flex_gd == NULL)
+		goto out3;
+
+	flex_gd->count = flexbg_size;
+
+	flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) *
+				  flexbg_size, GFP_NOFS);
+	if (flex_gd->groups == NULL)
+		goto out2;
+
+	flex_gd->bg_flags = kmalloc(flexbg_size * sizeof(__u16), GFP_NOFS);
+	if (flex_gd->bg_flags == NULL)
+		goto out1;
+
+	return flex_gd;
+
+out1:
+	kfree(flex_gd->groups);
+out2:
+	kfree(flex_gd);
+out3:
+	return NULL;
+}
+
+void free_flex_gd(struct ext4_new_flex_group_data *flex_gd)
+{
+	kfree(flex_gd->bg_flags);
+	kfree(flex_gd->groups);
+	kfree(flex_gd);
+}
+
 static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
 				  ext4_fsblk_t blk)
 {
-- 
1.7.5.1

[PATCH v2 06/15] ext4: add a function which sets up group blocks of a flex groups

[Yongqiang Yang]

This patch adds a function named setup_new_flex_group_blocks() which
sets up group blocks of a flex groups.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/ext4.h   |    8 ++
 fs/ext4/resize.c |  249 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 257 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index b4bff1a..66260ec 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -490,6 +490,14 @@ struct ext4_new_group_data {
 	__u32 free_blocks_count;
 };
 
+/* Indexes used to index group tables in ext4_new_group_data */
+enum {
+	BLOCK_BITMAP = 0,	/* block bitmap */
+	INODE_BITMAP,		/* inode bitmap */
+	INODE_TABLE,		/* inode tables */
+	GROUP_TABLE_COUNT,
+};
+
 /*
  * Flags used by ext4_map_blocks()
  */
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index fb84b48..7b1b8ac 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -234,6 +234,255 @@ static int extend_or_restart_transaction(handle_t *handle, int thresh)
 }
 
 /*
+ * set_flexbg_block_bitmap() mark @count blocks starting from @block used.
+ *
+ * Helper function for ext4_setup_new_group_blocks() which set .
+ *
+ * @sb: super block
+ * @handle: journal handle
+ * @flex_gd: flex group data
+ */
+static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,
+			struct ext4_new_flex_group_data *flex_gd,
+			ext4_fsblk_t block, ext4_group_t count)
+{
+	ext4_group_t count2;
+
+	ext4_debug("mark blocks [%llu/%u] used\n", block, count);
+	for (count2 = count; count > 0; count -= count2, block += count2) {
+		ext4_fsblk_t start;
+		struct buffer_head *bh;
+		ext4_group_t group;
+		int err;
+
+		ext4_get_group_no_and_offset(sb, block, &group, NULL);
+		start = ext4_group_first_block_no(sb, group);
+		group -= flex_gd->groups[0].group;
+
+		count2 = sb->s_blocksize * 8 - (block - start);
+		if (count2 > count)
+			count2 = count;
+
+		if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) {
+			BUG_ON(flex_gd->count > 1);
+			continue;
+		}
+
+		err = extend_or_restart_transaction(handle, 1);
+		if (err)
+			return err;
+
+		bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap);
+		if (!bh)
+			return -EIO;
+
+		err = ext4_journal_get_write_access(handle, bh);
+		if (err)
+			return err;
+		ext4_debug("mark block bitmap %#04llx (+%llu/%u)\n", block,
+			   block - start, count2);
+		ext4_set_bits(bh->b_data, block - start, count2);
+
+		err = ext4_handle_dirty_metadata(handle, NULL, bh);
+		if (unlikely(err))
+			return err;
+		brelse(bh);
+	}
+
+	return 0;
+}
+
+/*
+ * Set up the block and inode bitmaps, and the inode table for the new groups.
+ * This doesn't need to be part of the main transaction, since we are only
+ * changing blocks outside the actual filesystem.  We still do journaling to
+ * ensure the recovery is correct in case of a failure just after resize.
+ * If any part of this fails, we simply abort the resize.
+ *
+ * setup_new_flex_group_blocks handles a flex group as follow:
+ *  1. copy super block and GDT, and initialize group tables if necessary.
+ *     In this step, we only set bits in blocks bitmaps for blocks taken by
+ *     super block and GDT.
+ *  2. allocate group tables in block bitmaps, that is, set bits in block
+ *     bitmap for blocks taken by group tables.
+ */
+static int setup_new_flex_group_blocks(struct super_block *sb,
+				struct ext4_new_flex_group_data *flex_gd)
+{
+	int group_table_count[] = {1, 1, EXT4_SB(sb)->s_itb_per_group};
+	ext4_fsblk_t start;
+	ext4_fsblk_t block;
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	struct ext4_super_block *es = sbi->s_es;
+	struct ext4_new_group_data *group_data = flex_gd->groups;
+	__u16 *bg_flags = flex_gd->bg_flags;
+	handle_t *handle;
+	ext4_group_t group, count;
+	struct buffer_head *bh = NULL;
+	int reserved_gdb, i, j, err = 0, err2;
+
+	BUG_ON(!flex_gd->count || !group_data ||
+	       group_data[0].group != sbi->s_groups_count);
+
+	reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
+
+	/* This transaction may be extended/restarted along the way */
+	handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
+	if (IS_ERR(handle))
+		return PTR_ERR(handle);
+
+	group = group_data[0].group;
+	for (i = 0; i < flex_gd->count; i++, group++) {
+		unsigned long gdblocks;
+
+		gdblocks = ext4_bg_num_gdb(sb, group);
+		start = ext4_group_first_block_no(sb, group);
+
+		/* Copy all of the GDT blocks into the backup in this group */
+		for (j = 0, block = start + 1; j < gdblocks; j++, block++) {
+			struct buffer_head *gdb;
+
+			ext4_debug("update backup group %#04llx\n", block);
+			err = extend_or_restart_transaction(handle, 1);
+			if (err)
+				goto out;
+
+			gdb = sb_getblk(sb, block);
+			if (!gdb) {
+				err = -EIO;
+				goto out;
+			}
+
+			err = ext4_journal_get_write_access(handle, gdb);
+			if (err) {
+				brelse(gdb);
+				goto out;
+			}
+			memcpy(gdb->b_data, sbi->s_group_desc[j]->b_data,
+			       gdb->b_size);
+			set_buffer_uptodate(gdb);
+
+			err = ext4_handle_dirty_metadata(handle, NULL, gdb);
+			if (unlikely(err)) {
+				brelse(gdb);
+				goto out;
+			}
+			brelse(gdb);
+		}
+
+		/* Zero out all of the reserved backup group descriptor
+		 * table blocks
+		 */
+		if (ext4_bg_has_super(sb, group)) {
+			err = sb_issue_zeroout(sb, gdblocks + start + 1,
+					reserved_gdb, GFP_NOFS);
+			if (err)
+				goto out;
+		}
+
+		/* Initialize group tables of the grop @group */
+		if (!(bg_flags[i] & EXT4_BG_INODE_ZEROED))
+			goto handle_bb;
+
+		/* Zero out all of the inode table blocks */
+		block = group_data[i].inode_table;
+		ext4_debug("clear inode table blocks %#04llx -> %#04lx\n",
+			    block, sbi->s_itb_per_group);
+		err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group,
+				       GFP_NOFS);
+		if (err)
+			goto out;
+
+handle_bb:
+		if (bg_flags[i] & EXT4_BG_BLOCK_UNINIT)
+			goto handle_ib;
+
+		/* Initialize block bitmap of the @group */
+		block = group_data[i].block_bitmap;
+		err = extend_or_restart_transaction(handle, 1);
+		if (err)
+			goto out;
+
+		bh = bclean(handle, sb, block);
+		if (IS_ERR(bh)) {
+			err = PTR_ERR(bh);
+			goto out;
+		}
+		if (ext4_bg_has_super(sb, group)) {
+			ext4_debug("mark backup superblock %#04llx (+0)\n",
+				   start);
+			ext4_set_bits(bh->b_data, 0, gdblocks + reserved_gdb +
+						     1);
+		}
+		ext4_mark_bitmap_end(group_data[0].blocks_count,
+				     sb->s_blocksize * 8, bh->b_data);
+		err = ext4_handle_dirty_metadata(handle, NULL, bh);
+		if (err)
+			goto out;
+		brelse(bh);
+
+handle_ib:
+		if (bg_flags[i] & EXT4_BG_INODE_UNINIT)
+			continue;
+
+		/* Initialize inode bitmap of the @group */
+		block = group_data[i].inode_bitmap;
+		err = extend_or_restart_transaction(handle, 1);
+		if (err)
+			goto out;
+		/* Mark unused entries in inode bitmap used */
+		bh = bclean(handle, sb, block);
+		if (IS_ERR(bh)) {
+			err = PTR_ERR(bh);
+			goto out;
+		}
+		ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb),
+				     sb->s_blocksize * 8, bh->b_data);
+		err = ext4_handle_dirty_metadata(handle, NULL, bh);
+		if (err)
+			goto out;
+		brelse(bh);
+	}
+	bh = NULL;
+
+	/* Mark group tables in block bitmap */
+	for (j = 0; j < GROUP_TABLE_COUNT; j++) {
+		count = group_table_count[j];
+		start = (&group_data[0].block_bitmap)[j];
+		block = start;
+		for (i = 1; i < flex_gd->count; i++) {
+			block += group_table_count[j];
+			if (block == (&group_data[i].block_bitmap)[j]) {
+				count += group_table_count[j];
+				continue;
+			}
+			err = set_flexbg_block_bitmap(sb, handle,
+						flex_gd, start, count);
+			if (err)
+				goto out;
+			count = group_table_count[j];
+			start = group_data[i].block_bitmap;
+			block = start;
+		}
+
+		if (count) {
+			err = set_flexbg_block_bitmap(sb, handle,
+						flex_gd, start, count);
+			if (err)
+				goto out;
+		}
+	}
+
+out:
+	brelse(bh);
+	err2 = ext4_journal_stop(handle);
+	if (err2 && !err)
+		err = err2;
+
+	return err;
+}
+
+/*
  * Set up the block and inode bitmaps, and the inode table for the new group.
  * This doesn't need to be part of the main transaction, since we are only
  * changing blocks outside the actual filesystem.  We still do journaling to
-- 
1.7.5.1

[PATCH v2 07/15] ext4: add a function which adds several group descriptors

[Yongqiang Yang]

This patch adds a functon named ext4_add_new_descs() which adds
several  group descriptors each time.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   25 +++++++++++++++++++++++++
 1 files changed, 25 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 7b1b8ac..53412bf 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1082,6 +1082,31 @@ out:
 }
 
 /*
+ * ext4_add_new_descs() adds @count group descriptor of groups
+ * starting at @group
+ *
+ * @handle: journal handle
+ * @sb; super block
+ * @group: the group no. of the first group desc to be added
+ * @resize_inode: the resize inode
+ * @count: number of group descriptors to be added
+ */
+static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
+			ext4_group_t group, struct inode *resize_inode,
+			ext4_group_t count)
+{
+	int i, err = 0;
+
+	for (i = 0; i < count; i++) {
+		err = ext4_add_new_desc(handle, sb, group + i, resize_inode);
+		if (err)
+			return err;
+	}
+
+	return err;
+}
+
+/*
  * ext4_setup_new_desc() sets up group descriptors specified by @input.
  *
  * @handle: journal handle
-- 
1.7.5.1

[PATCH v2 08/15] ext4: add a function which sets up a flex groups each time

[Yongqiang Yang]

This patch adds a function named ext4_setup_new_descs() which sets up
a flex groups each time.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   25 +++++++++++++++++++++++--
 1 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 53412bf..ce38cef 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1113,7 +1113,8 @@ static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
  * @sb: super block
  */
 static int ext4_setup_new_desc(handle_t *handle, struct super_block *sb,
-			       struct ext4_new_group_data *input)
+			       struct ext4_new_group_data *input,
+			       __u16 bg_flags)
 {
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 	ext4_group_t group;
@@ -1142,7 +1143,7 @@ static int ext4_setup_new_desc(handle_t *handle, struct super_block *sb,
 	ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */
 	ext4_free_blks_set(sb, gdp, input->free_blocks_count);
 	ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
-	gdp->bg_flags = cpu_to_le16(EXT4_BG_INODE_ZEROED);
+	gdp->bg_flags = cpu_to_le16(bg_flags);
 	gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp);
 
 	err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
@@ -1161,6 +1162,26 @@ static int ext4_setup_new_desc(handle_t *handle, struct super_block *sb,
 }
 
 /*
+ * ext4_setup_new_descs setups group descriptors of a flex groups
+ */
+static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,
+				struct ext4_new_flex_group_data *flex_gd)
+{
+	struct ext4_new_group_data *group_data = flex_gd->groups;
+	__u16 *bg_flags = flex_gd->bg_flags;
+	int i, err = 0;
+
+	for (i = 0; i < flex_gd->count; i++) {
+		err = ext4_setup_new_desc(handle, sb, group_data + i,
+					  bg_flags[i]);
+		if (err)
+			return err;
+	}
+
+	return err;
+}
+
+/*
  * ext4_update_super() updates super so that new the added group can be seen
  *   by the filesystem.
  *
-- 
1.7.5.1

[PATCH v2 09/15] ext4: enable ext4_update_super() to handle a flex groups

[Yongqiang Yang]

This patch enables ext4_update_super() to handle a flex groups.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   58 +++++++++++++++++++++++++++++++++++++----------------
 1 files changed, 40 insertions(+), 18 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index ce38cef..4e06cf9 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1182,17 +1182,24 @@ static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,
 }
 
 /*
- * ext4_update_super() updates super so that new the added group can be seen
- *   by the filesystem.
+ * ext4_update_super() updates super block so that new added groups can be seen
+ * by the filesystem.
  *
  * @sb: super block
+ * @flex_gd: new added groups
  */
 static void ext4_update_super(struct super_block *sb,
-			      struct ext4_new_group_data *input)
+			     struct ext4_new_flex_group_data *flex_gd)
 {
+	ext4_fsblk_t blocks_count = 0;
+	ext4_fsblk_t free_blocks = 0;
+	ext4_fsblk_t reserved_blocks = 0;
+	struct ext4_new_group_data *group_data = flex_gd->groups;
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 	struct ext4_super_block *es = sbi->s_es;
+	int i;
 
+	BUG_ON(flex_gd->count == 0 || group_data == NULL);
 	/*
 	 * Make the new blocks and inodes valid next.  We do this before
 	 * increasing the group count so that once the group is enabled,
@@ -1203,9 +1210,19 @@ static void ext4_update_super(struct super_block *sb,
 	 * blocks/inodes before the group is live won't actually let us
 	 * allocate the new space yet.
 	 */
-	ext4_blocks_count_set(es, ext4_blocks_count(es) +
-		input->blocks_count);
-	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb));
+	for (i = 0; i < flex_gd->count; i++) {
+		blocks_count += group_data[i].blocks_count;
+		free_blocks += group_data[i].free_blocks_count;
+	}
+
+	reserved_blocks = ext4_r_blocks_count(es) * 100;
+	do_div(reserved_blocks, ext4_blocks_count(es));
+	reserved_blocks *= blocks_count;
+	do_div(reserved_blocks, 100);
+
+	ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count);
+	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) *
+		     flex_gd->count);
 
 	/*
 	 * We need to protect s_groups_count against other CPUs seeing
@@ -1213,11 +1230,11 @@ static void ext4_update_super(struct super_block *sb,
 	 *
 	 * The precise rules we use are:
 	 *
-	 * * Writers must perform a smp_wmb() after updating all dependent
-	 *   data and before modifying the groups count
+	 * * Writers must perform a smp_wmb() after updating all
+	 *   dependent data and before modifying the groups count
 	 *
-	 * * Readers must perform an smp_rmb() after reading the groups count
-	 *   and before reading any dependent data.
+	 * * Readers must perform an smp_rmb() after reading the groups
+	 *   count and before reading any dependent data.
 	 *
 	 * NB. These rules can be relaxed when checking the group count
 	 * while freeing data, as we can only allocate from a block
@@ -1228,29 +1245,34 @@ static void ext4_update_super(struct super_block *sb,
 	smp_wmb();
 
 	/* Update the global fs size fields */
-	sbi->s_groups_count++;
+	sbi->s_groups_count += flex_gd->count;
 
 	/* Update the reserved block counts only once the new group is
 	 * active. */
 	ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
-		input->reserved_blocks);
+				reserved_blocks);
 
 	/* Update the free space counts */
 	percpu_counter_add(&sbi->s_freeblocks_counter,
-			   input->free_blocks_count);
+			   free_blocks);
 	percpu_counter_add(&sbi->s_freeinodes_counter,
-			   EXT4_INODES_PER_GROUP(sb));
+			   EXT4_INODES_PER_GROUP(sb) * flex_gd->count);
 
-	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
+	if (EXT4_HAS_INCOMPAT_FEATURE(sb,
+				      EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
 	    sbi->s_log_groups_per_flex) {
 		ext4_group_t flex_group;
-		flex_group = ext4_flex_group(sbi, input->group);
-		atomic_add(input->free_blocks_count,
+		flex_group = ext4_flex_group(sbi, group_data[0].group);
+		atomic_add(free_blocks,
 			   &sbi->s_flex_groups[flex_group].free_blocks);
-		atomic_add(EXT4_INODES_PER_GROUP(sb),
+		atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count,
 			   &sbi->s_flex_groups[flex_group].free_inodes);
 	}
 
+	if (test_opt(sb, DEBUG))
+		printk(KERN_DEBUG "EXT4-fs: added group %u:"
+		       "%llu blocks(%llu free %llu reserved)\n", flex_gd->count,
+		       blocks_count, free_blocks, reserved_blocks);
 }
 
 /* Add group descriptor data to an existing or new group descriptor block.
-- 
1.7.5.1

[PATCH v2 10/15] ext4: pass verify_reserved_gdb() the number of group decriptors

[Yongqiang Yang]

The 64bit resizer adds a  flex group each time, so verify_reserved_gdb can
not use s_groups_count directly,  it should use the number of group decriptors
before the added group.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |    7 ++++---
 1 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 4e06cf9..4941869 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -655,10 +655,10 @@ static unsigned ext4_list_backups(struct super_block *sb, unsigned *three,
  * groups in current filesystem that have BACKUPS, or -ve error code.
  */
 static int verify_reserved_gdb(struct super_block *sb,
+			       ext4_group_t end,
 			       struct buffer_head *primary)
 {
 	const ext4_fsblk_t blk = primary->b_blocknr;
-	const ext4_group_t end = EXT4_SB(sb)->s_groups_count;
 	unsigned three = 1;
 	unsigned five = 5;
 	unsigned seven = 7;
@@ -733,7 +733,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
 	if (!gdb_bh)
 		return -EIO;
 
-	gdbackups = verify_reserved_gdb(sb, gdb_bh);
+	gdbackups = verify_reserved_gdb(sb, group, gdb_bh);
 	if (gdbackups < 0) {
 		err = gdbackups;
 		goto exit_bh;
@@ -896,7 +896,8 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
 			err = -EIO;
 			goto exit_bh;
 		}
-		if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) {
+		gdbackups = verify_reserved_gdb(sb, group, primary[res]);
+		if (gdbackups < 0) {
 			brelse(primary[res]);
 			err = gdbackups;
 			goto exit_bh;
-- 
1.7.5.1

[PATCH v2 11/15] ext4: add a new function which allocates bitmaps and inode tables

[Yongqiang Yang]

This patch adds a new function named ext4_allocates_group_table() which
allcoates block bitmaps, inode bitmaps and inode tables for a flex groups and is
used by resize code.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |  111 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 111 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 4941869..22c028c 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -189,6 +189,117 @@ void free_flex_gd(struct ext4_new_flex_group_data *flex_gd)
 	kfree(flex_gd);
 }
 
+/*
+ * ext4_allcoate_group_table() allocates block bitmaps, inode bitmaps and
+ * inode tables for a flex group.
+ *
+ * This function is used by 64bit-resize.  Note that this function allocates
+ * group tables from the 1st group of groups contained by @flexgd, which may
+ * be a partial of a flex group.
+ *
+ * @sb: super block of fs to which the groups belongs
+ */
+static void ext4_alloc_group_tables(struct super_block *sb,
+				struct ext4_new_flex_group_data *flex_gd,
+				int flexbg_size)
+{
+	struct ext4_new_group_data *group_data = flex_gd->groups;
+	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
+	ext4_fsblk_t start_blk;
+	ext4_fsblk_t last_blk;
+	ext4_group_t src_group;
+	ext4_group_t bb_index = 0;
+	ext4_group_t ib_index = 0;
+	ext4_group_t it_index = 0;
+	ext4_group_t group;
+	ext4_group_t last_group;
+	unsigned overhead;
+
+	BUG_ON(flex_gd->count == 0 || group_data == NULL);
+
+	src_group = group_data[0].group;
+	last_group  = src_group + flex_gd->count - 1;
+
+	BUG_ON((flexbg_size > 1) && ((src_group & ~(flexbg_size - 1)) !=
+	       (last_group & ~(flexbg_size - 1))));
+next_group:
+	group = group_data[0].group;
+	start_blk = ext4_group_first_block_no(sb, src_group);
+	last_blk = start_blk + group_data[src_group - group].blocks_count;
+
+	overhead = ext4_bg_has_super(sb, src_group) ?
+		   (1 + ext4_bg_num_gdb(sb, src_group) +
+		    le16_to_cpu(es->s_reserved_gdt_blocks)) : 0;
+
+	start_blk += overhead;
+
+	BUG_ON(src_group >= group_data[0].group + flex_gd->count);
+	/* We collect contiguous blocks as much as possible. */
+	src_group++;
+	for (; src_group <= last_group; src_group++)
+		if (!ext4_bg_has_super(sb, src_group))
+			last_blk += group_data[src_group - group].blocks_count;
+		else
+			break;
+
+	/* Allocate block bitmaps */
+	for (; bb_index < flex_gd->count; bb_index++) {
+		if (start_blk >= last_blk)
+			goto next_group;
+		group_data[bb_index].block_bitmap = start_blk++;
+		ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL);
+		group -= group_data[0].group;
+		group_data[group].free_blocks_count--;
+		if (flexbg_size > 1)
+			flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT;
+	}
+
+	/* Allocate inode bitmaps */
+	for (; ib_index < flex_gd->count; ib_index++) {
+		if (start_blk >= last_blk)
+			goto next_group;
+		group_data[ib_index].inode_bitmap = start_blk++;
+		ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL);
+		group -= group_data[0].group;
+		group_data[group].free_blocks_count--;
+		if (flexbg_size > 1)
+			flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT;
+	}
+
+	/* Allocate inode tables */
+	for (; it_index < flex_gd->count; it_index++) {
+		if (start_blk + EXT4_SB(sb)->s_itb_per_group > last_blk)
+			goto next_group;
+		group_data[it_index].inode_table = start_blk;
+		ext4_get_group_no_and_offset(sb, start_blk, &group, NULL);
+		group -= group_data[0].group;
+		group_data[group].free_blocks_count -=
+					EXT4_SB(sb)->s_itb_per_group;
+		if (flexbg_size > 1)
+			flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT;
+
+		start_blk += EXT4_SB(sb)->s_itb_per_group;
+	}
+
+	if (test_opt(sb, DEBUG)) {
+		int i;
+		group = group_data[0].group;
+
+		printk(KERN_DEBUG "EXT4-fs: adding a flex group with "
+		       "%d groups, flexbg size is %d:\n", flex_gd->count,
+		       flexbg_size);
+
+		for (i = 0; i < flex_gd->count; i++) {
+			printk(KERN_DEBUG "adding %s group %u: %u "
+			       "blocks (%d free)\n",
+			       ext4_bg_has_super(sb, group + i) ? "normal" :
+			       "no-super", group + i,
+			       group_data[i].blocks_count,
+			       group_data[i].free_blocks_count);
+		}
+	}
+}
+
 static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
 				  ext4_fsblk_t blk)
 {
-- 
1.7.5.1

[PATCH v2 12/15] ext4: add a new function which adds a flex group to a fs

[Yongqiang Yang]

This patch adds a new function named ext4_flex_group_add() which adds a
flex group to a fs.  The function is used by 64bit-resize interface.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 82 insertions(+), 0 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 22c028c..253c069 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1387,6 +1387,88 @@ static void ext4_update_super(struct super_block *sb,
 		       blocks_count, free_blocks, reserved_blocks);
 }
 
+/* Add a flex group to an fs. Ensure we handle all possible error conditions
+ * _before_ we start modifying the filesystem, because we cannot abort the
+ * transaction and not have it write the data to disk.
+ */
+static int ext4_flex_group_add(struct super_block *sb,
+			       struct inode *resize_inode,
+			       struct ext4_new_flex_group_data *flex_gd)
+{
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	struct ext4_super_block *es = sbi->s_es;
+	ext4_fsblk_t o_blocks_count;
+	ext4_grpblk_t last;
+	ext4_group_t group;
+	handle_t *handle;
+	unsigned reserved_gdb;
+	int err = 0, err2 = 0, credit;
+
+	BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags);
+
+	reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
+	o_blocks_count = ext4_blocks_count(es);
+	ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
+	BUG_ON(last);
+
+	err = setup_new_flex_group_blocks(sb, flex_gd);
+	if (err)
+		goto exit;
+	/*
+	 * We will always be modifying at least the superblock and  GDT
+	 * block.  If we are adding a group past the last current GDT block,
+	 * we will also modify the inode and the dindirect block.  If we
+	 * are adding a group with superblock/GDT backups  we will also
+	 * modify each of the reserved GDT dindirect blocks.
+	 */
+	credit = flex_gd->count * 4 + reserved_gdb;
+	handle = ext4_journal_start_sb(sb, credit);
+	if (IS_ERR(handle)) {
+		err = PTR_ERR(handle);
+		goto exit;
+	}
+
+	err = ext4_journal_get_write_access(handle, sbi->s_sbh);
+	if (err)
+		goto exit_journal;
+
+	group = flex_gd->groups[0].group;
+	BUG_ON(group != EXT4_SB(sb)->s_groups_count);
+	err = ext4_add_new_descs(handle, sb, group,
+				resize_inode, flex_gd->count);
+	if (err)
+		goto exit_journal;
+
+	err = ext4_setup_new_descs(handle, sb, flex_gd);
+	if (err)
+		goto exit_journal;
+
+	ext4_update_super(sb, flex_gd);
+
+	err = ext4_handle_dirty_super(handle, sb);
+
+exit_journal:
+	err2 = ext4_journal_stop(handle);
+	if (!err)
+		err = err2;
+
+	if (!err) {
+		int i;
+		update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
+			       sizeof(struct ext4_super_block));
+		for (i = 0; i < flex_gd->count; i++, group++) {
+			struct buffer_head *gdb_bh;
+			int gdb_num;
+			gdb_num = group / EXT4_BLOCKS_PER_GROUP(sb);
+			gdb_bh = sbi->s_group_desc[gdb_num];
+			update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data,
+				       gdb_bh->b_size);
+		}
+	}
+exit:
+	return err;
+}
+
 /* Add group descriptor data to an existing or new group descriptor block.
  * Ensure we handle all possible error conditions _before_ we start modifying
  * the filesystem, because we cannot abort the transaction and not have it
-- 
1.7.5.1

[PATCH v2 13/15] ext4: add new online resize interface

[Yongqiang Yang]

This patch adds new online resize interface, whose input argument is a
64-bit integer indicating how many blocks there are in the resized fs.

In new resize impelmentation, all work like allocating group tables are done
by kernel side, so the new resize interface can support flex_bg feature and
prepares ground for suppoting resize with features like bigalloc and exclude
bitmap. Besides these, user-space tools just passes in the new number of blocks.

We delay initializing the bitmaps and inode tables of added groups if possible
and add multi groups (a flex groups) each time, so new resize is very fast like
mkfs.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 Documentation/filesystems/ext4.txt |    7 ++
 fs/ext4/ext4.h                     |    2 +
 fs/ext4/ioctl.c                    |   31 +++++++
 fs/ext4/resize.c                   |  171 ++++++++++++++++++++++++++++++++++++
 4 files changed, 211 insertions(+), 0 deletions(-)

diff --git a/Documentation/filesystems/ext4.txt b/Documentation/filesystems/ext4.txt
index 168242b..765550b 100644
--- a/Documentation/filesystems/ext4.txt
+++ b/Documentation/filesystems/ext4.txt
@@ -592,6 +592,13 @@ Table of Ext4 specific ioctls
 			      behaviour may change in the future as it is
 			      not necessary and has been done this way only
 			      for sake of simplicity.
+
+ EXT4_IOC_RESIZE_FS	      Resize the filesystem to a new size.  The number
+			      of blocks of resized filesystem is passed in via
+			      64 bit integer argument.  The kernel allocates
+			      bitmaps and inode table, the userspace tool thus
+			      just passes the new number of blocks.
+
 ..............................................................................
 
 References
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 66260ec..78f164d 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -561,6 +561,7 @@ enum {
  /* note ioctl 11 reserved for filesystem-independent FIEMAP ioctl */
 #define EXT4_IOC_ALLOC_DA_BLKS		_IO('f', 12)
 #define EXT4_IOC_MOVE_EXT		_IOWR('f', 15, struct move_extent)
+#define EXT4_IOC_RESIZE_FS		_IOW('f', 16, __u64)
 
 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
 /*
@@ -1893,6 +1894,7 @@ extern int ext4_group_add(struct super_block *sb,
 extern int ext4_group_extend(struct super_block *sb,
 				struct ext4_super_block *es,
 				ext4_fsblk_t n_blocks_count);
+extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count);
 
 /* super.c */
 extern void *ext4_kvmalloc(size_t size, gfp_t flags);
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index f18bfe3..eeaa1a4 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -335,6 +335,37 @@ mext_out:
 		return err;
 	}
 
+	case EXT4_IOC_RESIZE_FS: {
+		ext4_fsblk_t n_blocks_count;
+		struct super_block *sb = inode->i_sb;
+		int err = 0, err2 = 0;
+
+		err = ext4_resize_begin(sb);
+		if (err)
+			return err;
+
+		if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
+				   sizeof(__u64)))
+			return -EFAULT;
+
+		err = mnt_want_write(filp->f_path.mnt);
+		if (err)
+			return err;
+
+		err = ext4_resize_fs(sb, n_blocks_count);
+		if (EXT4_SB(sb)->s_journal) {
+			jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
+			err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
+			jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
+		}
+		if (err == 0)
+			err = err2;
+		mnt_drop_write(filp->f_path.mnt);
+		ext4_resize_end(sb);
+
+		return err;
+	}
+
 	case FITRIM:
 	{
 		struct super_block *sb = inode->i_sb;
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 253c069..a7a1d3a 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1469,6 +1469,64 @@ exit:
 	return err;
 }
 
+static int ext4_setup_next_flex_gd(struct super_block *sb,
+				    struct ext4_new_flex_group_data *flex_gd,
+				    ext4_fsblk_t n_blocks_count,
+				    unsigned long flexbg_size)
+{
+	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
+	struct ext4_new_group_data *group_data = flex_gd->groups;
+	ext4_fsblk_t o_blocks_count;
+	ext4_group_t n_group;
+	ext4_group_t group;
+	ext4_group_t last_group;
+	ext4_grpblk_t last;
+	ext4_grpblk_t blocks_per_group;
+	unsigned long i;
+
+	blocks_per_group = EXT4_BLOCKS_PER_GROUP(sb);
+
+	o_blocks_count = ext4_blocks_count(es);
+
+	if (o_blocks_count == n_blocks_count)
+		return 0;
+
+	ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
+	BUG_ON(last);
+	ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last);
+
+	last_group = group | (flexbg_size - 1);
+	if (last_group > n_group)
+		last_group = n_group;
+
+	flex_gd->count = last_group - group + 1;
+
+	for (i = 0; i < flex_gd->count; i++) {
+		int overhead;
+
+		group_data[i].group = group + i;
+		group_data[i].blocks_count = blocks_per_group;
+		overhead = ext4_bg_has_super(sb, group + i) ?
+			   (1 + ext4_bg_num_gdb(sb, group + i) +
+			    le16_to_cpu(es->s_reserved_gdt_blocks)) : 0;
+		group_data[i].free_blocks_count = blocks_per_group - overhead;
+		if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+					       EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
+			flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT |
+					       EXT4_BG_INODE_UNINIT;
+		else
+			flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED;
+	}
+
+	if ((last_group == n_group) && (last != blocks_per_group - 1)) {
+		group_data[i - 1].blocks_count = last + 1;
+		group_data[i - 1].free_blocks_count -= blocks_per_group-
+					last - 1;
+	}
+
+	return 1;
+}
+
 /* Add group descriptor data to an existing or new group descriptor block.
  * Ensure we handle all possible error conditions _before_ we start modifying
  * the filesystem, because we cannot abort the transaction and not have it
@@ -1868,3 +1926,116 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 exit_put:
 	return err;
 } /* ext4_group_extend */
+
+/*
+ * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count
+ *
+ * @sb: super block of the fs to be resized
+ * @n_blocks_count: the number of blocks resides in the resized fs
+ */
+int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)
+{
+	struct ext4_new_flex_group_data *flex_gd = NULL;
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	struct ext4_super_block *es = sbi->s_es;
+	struct buffer_head *bh;
+	struct inode *resize_inode;
+	ext4_fsblk_t o_blocks_count;
+	ext4_group_t o_group;
+	ext4_group_t n_group;
+	ext4_grpblk_t offset;
+	unsigned long n_desc_blocks;
+	unsigned long o_desc_blocks;
+	unsigned long desc_blocks;
+	int err = 0, flexbg_size = 1;
+
+	o_blocks_count = ext4_blocks_count(es);
+
+	if (test_opt(sb, DEBUG))
+		printk(KERN_DEBUG "EXT4-fs: resizing filesystem from %llu "
+		       "upto %llu blocks\n", o_blocks_count, n_blocks_count);
+
+	if (n_blocks_count < o_blocks_count) {
+		/* On-line shrinking not supported */
+		ext4_warning(sb, "can't shrink FS - resize aborted");
+		return -EINVAL;
+	}
+
+	if (n_blocks_count == o_blocks_count)
+		/* Nothing need to do */
+		return 0;
+
+	ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &offset);
+	ext4_get_group_no_and_offset(sb, o_blocks_count, &o_group, &offset);
+
+	n_desc_blocks = (n_group + EXT4_DESC_PER_BLOCK(sb)) /
+			EXT4_DESC_PER_BLOCK(sb);
+	o_desc_blocks = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
+			EXT4_DESC_PER_BLOCK(sb);
+	desc_blocks = n_desc_blocks - o_desc_blocks;
+
+	if (desc_blocks &&
+	    (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE) ||
+	     le16_to_cpu(es->s_reserved_gdt_blocks) < desc_blocks)) {
+		ext4_warning(sb, "No reserved GDT blocks, can't resize");
+		return -EPERM;
+	}
+
+	resize_inode = ext4_iget(sb, EXT4_RESIZE_INO);
+	if (IS_ERR(resize_inode)) {
+		ext4_warning(sb, "Error opening resize inode");
+		return PTR_ERR(resize_inode);
+	}
+
+	/* See if the device is actually as big as what was requested */
+	bh = sb_bread(sb, n_blocks_count - 1);
+	if (!bh) {
+		ext4_warning(sb, "can't read last block, resize aborted");
+		return -ENOSPC;
+	}
+	brelse(bh);
+
+	if (offset != 0) {
+		/* extend the last group */
+		ext4_grpblk_t add;
+		add = EXT4_BLOCKS_PER_GROUP(sb) - offset;
+		err = __ext4_group_extend(sb, o_blocks_count, add);
+		if (err)
+			goto out;
+	}
+
+	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
+	    es->s_log_groups_per_flex)
+		flexbg_size = 1 << es->s_log_groups_per_flex;
+
+	o_blocks_count = ext4_blocks_count(es);
+	if (o_blocks_count == n_blocks_count)
+		goto out;
+
+	flex_gd = alloc_flex_gd(flexbg_size);
+	if (flex_gd == NULL) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	/* Add flex groups. Note that a regular group is a
+	 * flex group with 1 group.
+	 */
+	while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count,
+					      flexbg_size)) {
+		ext4_alloc_group_tables(sb, flex_gd, flexbg_size);
+		err = ext4_flex_group_add(sb, resize_inode, flex_gd);
+		if (unlikely(err))
+			break;
+	}
+
+out:
+	if (flex_gd)
+		free_flex_gd(flex_gd);
+
+	iput(resize_inode);
+	if (test_opt(sb, DEBUG))
+		printk(KERN_DEBUG "EXT4-fs: resized filesystem from %llu "
+		       "upto %llu blocks\n", o_blocks_count, n_blocks_count);
+	return err;
+}
-- 
1.7.5.1

[PATCH v2 14/15] ext4: let ext4_group_extend() use common code

[Yongqiang Yang]

__ext4_group_extend() is moved out from ext4_group_extend(), this patch
lets ext4_group_extend() call __ext4_group_extentd() instead.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |   41 ++---------------------------------------
 1 files changed, 2 insertions(+), 39 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index a7a1d3a..11183a3 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1830,8 +1830,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 	ext4_grpblk_t last;
 	ext4_grpblk_t add;
 	struct buffer_head *bh;
-	handle_t *handle;
-	int err, err2;
+	int err;
 	ext4_group_t group;
 
 	o_blocks_count = ext4_blocks_count(es);
@@ -1887,43 +1886,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 	}
 	brelse(bh);
 
-	/* We will update the superblock, one block bitmap, and
-	 * one group descriptor via ext4_free_blocks().
-	 */
-	handle = ext4_journal_start_sb(sb, 3);
-	if (IS_ERR(handle)) {
-		err = PTR_ERR(handle);
-		ext4_warning(sb, "error %d on journal start", err);
-		goto exit_put;
-	}
-
-	if ((err = ext4_journal_get_write_access(handle,
-						 EXT4_SB(sb)->s_sbh))) {
-		ext4_warning(sb, "error %d on journal write access", err);
-		ext4_journal_stop(handle);
-		goto exit_put;
-	}
-	ext4_blocks_count_set(es, o_blocks_count + add);
-	ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
-		   o_blocks_count + add);
-	/* We add the blocks to the bitmap and set the group need init bit */
-	err = ext4_group_add_blocks(handle, sb, o_blocks_count, add);
-	ext4_handle_dirty_super(handle, sb);
-	ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
-		   o_blocks_count + add);
-	err2 = ext4_journal_stop(handle);
-	if (!err && err2)
-		err = err2;
-
-	if (err)
-		goto exit_put;

[PATCH v2 15/15] ext4: let ext4_group_add() use common code

[Yongqiang Yang]

This patch lets ext4_group_add() call ext4_flex_group_add().

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
---
 fs/ext4/resize.c |  310 ++----------------------------------------------------
 1 files changed, 10 insertions(+), 300 deletions(-)

diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 11183a3..414d06b 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -594,137 +594,6 @@ out:
 }
 
 /*
- * Set up the block and inode bitmaps, and the inode table for the new group.
- * This doesn't need to be part of the main transaction, since we are only
- * changing blocks outside the actual filesystem.  We still do journaling to
- * ensure the recovery is correct in case of a failure just after resize.
- * If any part of this fails, we simply abort the resize.
- */
-static int setup_new_group_blocks(struct super_block *sb,
-				  struct ext4_new_group_data *input)
-{
-	struct ext4_sb_info *sbi = EXT4_SB(sb);
-	ext4_fsblk_t start = ext4_group_first_block_no(sb, input->group);
-	int reserved_gdb = ext4_bg_has_super(sb, input->group) ?
-		le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0;
-	unsigned long gdblocks = ext4_bg_num_gdb(sb, input->group);
-	struct buffer_head *bh;
-	handle_t *handle;
-	ext4_fsblk_t block;
-	ext4_grpblk_t bit;
-	int i;
-	int err = 0, err2;
-
-	/* This transaction may be extended/restarted along the way */
-	handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
-
-	if (IS_ERR(handle))
-		return PTR_ERR(handle);
-
-	BUG_ON(input->group != sbi->s_groups_count);
-
-	/* Copy all of the GDT blocks into the backup in this group */
-	for (i = 0, bit = 1, block = start + 1;
-	     i < gdblocks; i++, block++, bit++) {
-		struct buffer_head *gdb;
-
-		ext4_debug("update backup group %#04llx (+%d)\n", block, bit);
-		err = extend_or_restart_transaction(handle, 1);
-		if (err)
-			goto exit_journal;
-
-		gdb = sb_getblk(sb, block);
-		if (!gdb) {
-			err = -EIO;
-			goto exit_journal;
-		}
-		if ((err = ext4_journal_get_write_access(handle, gdb))) {
-			brelse(gdb);
-			goto exit_journal;
-		}
-		memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size);
-		set_buffer_uptodate(gdb);
-		err = ext4_handle_dirty_metadata(handle, NULL, gdb);
-		if (unlikely(err)) {
-			brelse(gdb);
-			goto exit_journal;
-		}
-		brelse(gdb);
-	}
-
-	/* Zero out all of the reserved backup group descriptor table blocks */
-	ext4_debug("clear inode table blocks %#04llx -> %#04lx\n",
-			block, sbi->s_itb_per_group);
-	err = sb_issue_zeroout(sb, gdblocks + start + 1, reserved_gdb,
-			       GFP_NOFS);
-	if (err)
-		goto exit_journal;
-
-	err = extend_or_restart_transaction(handle, 2);
-	if (err)
-		goto exit_journal;
-
-	bh = bclean(handle, sb, input->block_bitmap);
-	if (IS_ERR(bh)) {
-		err = PTR_ERR(bh);
-		goto exit_journal;
-	}
-
-	if (ext4_bg_has_super(sb, input->group)) {
-		ext4_debug("mark backup group tables %#04llx (+0)\n", start);
-		ext4_set_bits(bh->b_data, 0, gdblocks + reserved_gdb + 1);
-	}
-
-	ext4_debug("mark block bitmap %#04llx (+%llu)\n", input->block_bitmap,
-		   input->block_bitmap - start);
-	ext4_set_bit(input->block_bitmap - start, bh->b_data);
-	ext4_debug("mark inode bitmap %#04llx (+%llu)\n", input->inode_bitmap,
-		   input->inode_bitmap - start);
-	ext4_set_bit(input->inode_bitmap - start, bh->b_data);
-
-	/* Zero out all of the inode table blocks */
-	block = input->inode_table;
-	ext4_debug("clear inode table blocks %#04llx -> %#04lx\n",
-			block, sbi->s_itb_per_group);
-	err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, GFP_NOFS);
-	if (err)
-		goto exit_bh;
-	ext4_set_bits(bh->b_data, input->inode_table - start,
-		      sbi->s_itb_per_group);
-
-
-	ext4_mark_bitmap_end(input->blocks_count, sb->s_blocksize * 8,
-			     bh->b_data);
-	err = ext4_handle_dirty_metadata(handle, NULL, bh);
-	if (unlikely(err)) {
-		ext4_std_error(sb, err);
-		goto exit_bh;
-	}
-	brelse(bh);
-	/* Mark unused entries in inode bitmap used */
-	ext4_debug("clear inode bitmap %#04llx (+%llu)\n",
-		   input->inode_bitmap, input->inode_bitmap - start);
-	if (IS_ERR(bh = bclean(handle, sb, input->inode_bitmap))) {
-		err = PTR_ERR(bh);
-		goto exit_journal;
-	}
-
-	ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
-			     bh->b_data);
-	err = ext4_handle_dirty_metadata(handle, NULL, bh);
-	if (unlikely(err))
-		ext4_std_error(sb, err);
-exit_bh:
-	brelse(bh);
-
-exit_journal:
-	if ((err2 = ext4_journal_stop(handle)) && !err)
-		err = err2;
-
-	return err;
-}
-
-/*
  * Iterate through the groups which hold BACKUP superblock/GDT copies in an
  * ext4 filesystem.  The counters should be initialized to 1, 5, and 7 before
  * calling this for the first time.  In a sparse filesystem it will be the
@@ -1542,16 +1411,15 @@ static int ext4_setup_next_flex_gd(struct super_block *sb,
  */
 int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 {
+	struct ext4_new_flex_group_data flex_gd;
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 	struct ext4_super_block *es = sbi->s_es;
 	int reserved_gdb = ext4_bg_has_super(sb, input->group) ?
 		le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
-	struct buffer_head *primary = NULL;
-	struct ext4_group_desc *gdp;
 	struct inode *inode = NULL;
-	handle_t *handle;
 	int gdb_off, gdb_num;
-	int err, err2;
+	int err;
+	__u16 bg_flags;
 
 	gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb);
 	gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb);
@@ -1589,173 +1457,15 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 		}
 	}
 
-
-	if ((err = verify_group_input(sb, input)))
-		goto exit_put;
-
-	if ((err = setup_new_group_blocks(sb, input)))
-		goto exit_put;
-
-	/*
-	 * We will always be modifying at least the superblock and a GDT
-	 * block.  If we are adding a group past the last current GDT block,
-	 * we will also modify the inode and the dindirect block.  If we
-	 * are adding a group with superblock/GDT backups  we will also
-	 * modify each of the reserved GDT dindirect blocks.
-	 */
-	handle = ext4_journal_start_sb(sb,
-				       ext4_bg_has_super(sb, input->group) ?
-				       3 + reserved_gdb : 4);
-	if (IS_ERR(handle)) {
-		err = PTR_ERR(handle);
-		goto exit_put;
-	}
-
-	if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh)))
-		goto exit_journal;
-
-        /*
-         * We will only either add reserved group blocks to a backup group
-         * or remove reserved blocks for the first group in a new group block.
-         * Doing both would be mean more complex code, and sane people don't
-         * use non-sparse filesystems anymore.  This is already checked above.
-         */
-	if (gdb_off) {
-		primary = sbi->s_group_desc[gdb_num];
-		if ((err = ext4_journal_get_write_access(handle, primary)))
-			goto exit_journal;
-
-		if (reserved_gdb && ext4_bg_num_gdb(sb, input->group)) {
-			err = reserve_backup_gdb(handle, inode, input->group);
-			if (err)
-				goto exit_journal;
-		}
-	} else {
-		/*
-		 * Note that we can access new group descriptor block safely
-		 * only if add_new_gdb() succeeds.
-		 */
-		err = add_new_gdb(handle, inode, input->group);
-		if (err)
-			goto exit_journal;
-		primary = sbi->s_group_desc[gdb_num];
-	}
-
-        /*
-         * OK, now we've set up the new group.  Time to make it active.
-         *
-         * 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.
-         *
-         * The key field here is sbi->s_groups_count: as long as
-         * that retains its old value, nobody is going to access the new
-         * group.
-         *
-         * So first we update all the descriptor metadata for the new
-         * group; then we update the total disk blocks count; then we
-         * update the groups count to enable the group; then finally we
-         * update the free space counts so that the system can start
-         * using the new disk blocks.
-         */
-
-	/* Update group descriptor block for new group */
-	gdp = (struct ext4_group_desc *)((char *)primary->b_data +
-					 gdb_off * EXT4_DESC_SIZE(sb));
-
-	memset(gdp, 0, EXT4_DESC_SIZE(sb));
-	ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */
-	ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */
-	ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */
-	ext4_free_blks_set(sb, gdp, input->free_blocks_count);
-	ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
-	gdp->bg_flags = cpu_to_le16(EXT4_BG_INODE_ZEROED);
-	gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp);
-
-	/*
-	 * We can allocate memory for mb_alloc based on the new group
-	 * descriptor
-	 */
-	err = ext4_mb_add_groupinfo(sb, input->group, gdp);
+	err = verify_group_input(sb, input);
 	if (err)
-		goto exit_journal;
-
-	/*
-	 * Make the new blocks and inodes valid next.  We do this before
-	 * increasing the group count so that once the group is enabled,
-	 * all of its blocks and inodes are already valid.
-	 *
-	 * We always allocate group-by-group, then block-by-block or
-	 * inode-by-inode within a group, so enabling these
-	 * blocks/inodes before the group is live won't actually let us
-	 * allocate the new space yet.
-	 */
-	ext4_blocks_count_set(es, ext4_blocks_count(es) +
-		input->blocks_count);
-	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb));
-
-	/*
-	 * We need to protect s_groups_count against other CPUs seeing
-	 * inconsistent state in the superblock.
-	 *
-	 * The precise rules we use are:
-	 *
-	 * * Writers must perform a smp_wmb() after updating all dependent
-	 *   data and before modifying the groups count
-	 *
-	 * * Readers must perform an smp_rmb() after reading the groups count
-	 *   and before reading any dependent data.
-	 *
-	 * NB. These rules can be relaxed when checking the group count
-	 * while freeing data, as we can only allocate from a block
-	 * group after serialising against the group count, and we can
-	 * only then free after serialising in turn against that
-	 * allocation.
-	 */
-	smp_wmb();
-
-	/* Update the global fs size fields */
-	sbi->s_groups_count++;
-
-	err = ext4_handle_dirty_metadata(handle, NULL, primary);
-	if (unlikely(err)) {
-		ext4_std_error(sb, err);
-		goto exit_journal;
-	}
-
-	/* Update the reserved block counts only once the new group is
-	 * active. */
-	ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
-		input->reserved_blocks);
-
-	/* Update the free space counts */
-	percpu_counter_add(&sbi->s_freeblocks_counter,
-			   input->free_blocks_count);
-	percpu_counter_add(&sbi->s_freeinodes_counter,
-			   EXT4_INODES_PER_GROUP(sb));
-
-	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
-	    sbi->s_log_groups_per_flex) {
-		ext4_group_t flex_group;
-		flex_group = ext4_flex_group(sbi, input->group);
-		atomic_add(input->free_blocks_count,
-			   &sbi->s_flex_groups[flex_group].free_blocks);
-		atomic_add(EXT4_INODES_PER_GROUP(sb),
-			   &sbi->s_flex_groups[flex_group].free_inodes);
-	}

(unknown),

[tirumalareddy marri]

Greetings 


https://goo.gl/zeTgBc





tirumalareddy marri

(unknown),

[editor]

[-- Attachment #1: 6274763896.zip --]
[-- Type: application/zip, Size: 6037 bytes --]

(unknown),

[jeffrey.faulkenberg]

[-- Attachment #1: SHOP-92491235258linux-ext4.zip --]
[-- Type: application/zip, Size: 7271 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 398451844542478.zip --]
[-- Type: application/zip, Size: 7173 bytes --]

(unknown),

[nbensoncole81]

[-- Attachment #1: 3533773208567.zip --]
[-- Type: application/zip, Size: 7192 bytes --]

(unknown),

[rlm85310]

[-- Attachment #1: 42094602.zip --]
[-- Type: application/zip, Size: 7139 bytes --]

(unknown),

[nbensoncole81]

[-- Attachment #1: 7696623.doc --]
[-- Type: application/msword, Size: 67240 bytes --]

(unknown),

[rlm85310]

[-- Attachment #1: 612074162.doc --]
[-- Type: application/msword, Size: 67084 bytes --]

(unknown),

[bfoster]

[-- Attachment #1: 79129942816922.doc --]
[-- Type: application/msword, Size: 39379 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: 6768082.doc --]
[-- Type: application/msword, Size: 39859 bytes --]

(unknown),

[nbensoncole81]

[-- Attachment #1: 624346.doc --]
[-- Type: application/msword, Size: 40147 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: 540585795659.doc --]
[-- Type: application/msword, Size: 41837 bytes --]

(unknown),

[befragung]

[-- Attachment #1: MAIL_9030297428213_linux-ext4.zip --]
[-- Type: application/zip, Size: 72397 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: 78726092.zip --]
[-- Type: application/zip, Size: 10383 bytes --]

(unknown),

[editor]

[-- Attachment #1: 40290366.zip --]
[-- Type: application/zip, Size: 10171 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: 647805231.zip --]
[-- Type: application/zip, Size: 10227 bytes --]

(unknown),

[befragung]

[-- Attachment #1: 6886059214541.zip --]
[-- Type: application/zip, Size: 10117 bytes --]

(unknown),

[editor]

[-- Attachment #1: 0302343835.zip --]
[-- Type: application/zip, Size: 10210 bytes --]

(unknown),

[editor]

[-- Attachment #1: INFO_5549071394372_linux-ext4.zip --]
[-- Type: application/zip, Size: 9754 bytes --]

(unknown),

[Erma]

[-- Attachment #1: EMAIL_61204_linux-ext4.zip --]
[-- Type: application/zip, Size: 2798 bytes --]

(unknown),

[editor]

[-- Attachment #1: EMAIL_5749719396757_linux-ext4.zip --]
[-- Type: application/zip, Size: 2834 bytes --]

(unknown),

[anderslindgaard]

hi 

http://www.evelynverapropiedades.cl/wp-includes/js/tinymce/plugins/tabfocus/reklamapage.php?similar=2s7wb6pxdgd2xfd1b




All Best

anderslindgaard

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: EMAIL_26553892905555_linux-ext4.zip --]
[-- Type: application/zip, Size: 2590 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: EMAIL_797944_linux-ext4.zip --]
[-- Type: application/zip, Size: 5778 bytes --]

(unknown),

[chrisbi_anelyst]

[-- Attachment #1: EMAIL_136876215_linux-ext4.zip --]
[-- Type: application/zip, Size: 5730 bytes --]

(unknown),

[bfoster]

[-- Attachment #1: "EMAIL_08011542258_linux-ext4.zip --]
[-- Type: application/zip, Size: 3282 bytes --]

(unknown),

[befragung]

[-- Attachment #1: "EMAIL_6035315196369_linux-ext4.zip --]
[-- Type: application/zip, Size: 4943 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: 502633130680.zip --]
[-- Type: application/zip, Size: 3686 bytes --]

(unknown),

[koopk]

[-- Attachment #1: MESSAGE-9568447630-linux-ext4.zip --]
[-- Type: application/zip, Size: 2347 bytes --]

(unknown),

[paloma.depping]

[-- Attachment #1: 820702835161.zip --]
[-- Type: application/zip, Size: 3390 bytes --]

(unknown),

[loisc07]

[-- Attachment #1: EMAIL_994612756450_linux-ext4.zip --]
[-- Type: application/zip, Size: 3401 bytes --]

(unknown),

[Anders Lind]

Hi 



http://www.parkenspizza.se/faq_info.php?doesnt=v2b68r8t0abkav



Thanks
Anders Lind

(unknown),

[nbensoncole81]

[-- Attachment #1: EMAIL_2726286_linux-ext4.zip --]
[-- Type: application/zip, Size: 3500 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 0031586918070.zip --]
[-- Type: application/zip, Size: 3419 bytes --]

(unknown),

[jeffrey.faulkenberg]

[-- Attachment #1: 475333248096240.zip --]
[-- Type: application/zip, Size: 2082 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 170045.zip --]
[-- Type: application/zip, Size: 3532 bytes --]

(unknown),

[chrisbi_anelyst]

[-- Attachment #1: 100324712762.zip --]
[-- Type: application/zip, Size: 3475 bytes --]

(unknown),

[editor]

[-- Attachment #1: 2566839.zip --]
[-- Type: application/zip, Size: 3483 bytes --]

(unknown),

[chrisbi_anelyst]

[-- Attachment #1: 9052001159285.zip --]
[-- Type: application/zip, Size: 3174 bytes --]

(unknown),

[jeffrey.faulkenberg]

[-- Attachment #1: 36611.zip --]
[-- Type: application/zip, Size: 5410 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 927328920469.zip --]
[-- Type: application/zip, Size: 3174 bytes --]

(unknown),

[board]

[-- Attachment #1: 2117876976.zip --]
[-- Type: application/zip, Size: 4890 bytes --]

(unknown),

[nbensoncole81]

[-- Attachment #1: 28493054646.zip --]
[-- Type: application/zip, Size: 4963 bytes --]

(unknown),

[board]

[-- Attachment #1: 549426.zip --]
[-- Type: application/zip, Size: 5031 bytes --]

(unknown),

[editor]

[-- Attachment #1: 93304718.zip --]
[-- Type: application/zip, Size: 3186 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 99695261699.zip --]
[-- Type: application/zip, Size: 3169 bytes --]

(unknown),

[From Lori J. Robinson]

Hello,

I am General Lori J. Robinson, I am presently in Afghanistan serving
the UN/NATO military assignment here,i have an important discussion
with you  kindly respond to me through my private  box
lori_robinson.usa@hotmail.com  so that we can know ourselves better. I
hope to read from you if your are also interested. Thanks and hoping
to hear from you soonest.

(unknown),

[nbensoncole81]

[-- Attachment #1: 6713067025.zip --]
[-- Type: application/zip, Size: 3162 bytes --]

(unknown),

[nbensoncole81]

[-- Attachment #1: 208405710.zip --]
[-- Type: application/zip, Size: 3155 bytes --]

(unknown),

[board]

[-- Attachment #1: 17734612411.zip --]
[-- Type: application/zip, Size: 2913 bytes --]

(unknown),

[rlm85310]

[-- Attachment #1: EMAIL_91332296_linux-ext4.zip --]
[-- Type: application/zip, Size: 1186 bytes --]

(unknown),

[rlm85310]

[-- Attachment #1: SALE-78001048-linux-ext4.zip --]
[-- Type: application/zip, Size: 2032 bytes --]

(unknown),

[bkjf]

[-- Attachment #1: EMAIL_4067839100_linux-ext4.zip --]
[-- Type: application/zip, Size: 2019 bytes --]

(unknown),

[bfoster]

[-- Attachment #1: EMAIL_65750003_linux-ext4.zip --]
[-- Type: application/zip, Size: 2002 bytes --]

(unknown),

[befragung]

[-- Attachment #1: EMAIL_61_linux-ext4.zip --]
[-- Type: application/zip, Size: 4892 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 7729073.zip --]
[-- Type: application/zip, Size: 9016 bytes --]

(unknown),

[Anders Lind]

greetings 


http://speechelevated.com/spiderhunt.php?fill=2w3a9a9fgd2h





Anders

(unknown),

[board]

[-- Attachment #1: EBAY-599940970604973-linux-ext4.zip --]
[-- Type: application/zip, Size: 13752 bytes --]

(unknown),

[paloma.depping]

[-- Attachment #1: EMAIL-0964666885-linux-ext4.zip --]
[-- Type: application/zip, Size: 63862 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: EMAIL_53574576_linux-ext4.zip --]
[-- Type: application/zip, Size: 3389 bytes --]

(unknown),

[sterrenplan.kampen]

[-- Attachment #1: EMAIL_937476267145_linux-ext4.zip --]
[-- Type: application/zip, Size: 2795 bytes --]

(unknown),

[koopk]

[-- Attachment #1: 336887.zip --]
[-- Type: application/zip, Size: 44977 bytes --]

(unknown),

[rlm85310]

[-- Attachment #1: ORDER-0278566654930.zip --]
[-- Type: application/zip, Size: 9362 bytes --]

(unknown),

[jeffrey.faulkenberg]

[-- Attachment #1: MESSAGE_4570313393_linux-ext4.zip --]
[-- Type: application/zip, Size: 1458 bytes --]

(unknown),

[paloma.depping]

[-- Attachment #1: EMAIL_8059230588653_linux-ext4.zip --]
[-- Type: application/zip, Size: 4540 bytes --]

(unknown)

[renwu]

[PATCH] fix: print ext4 mountopt data_err=abort correctly

[Ales Novak]

If data_err=abort option is specified for an ext3/ext4 mount,
/proc/mounts does show it as "(null)". This is caused by token2str()
returning NULL for Opt_data_err_abort (due to its pattern containing
'=').

This could be solved by many ways, this one is the conservative and
former ext3 way resembling.

Signed-off-by: Ales Novak <alnovak@suse.cz>
---
 fs/ext4/super.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 3ed01ec..58c203a 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1860,7 +1860,8 @@ static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
 	for (m = ext4_mount_opts; m->token != Opt_err; m++) {
 		int want_set = m->flags & MOPT_SET;
 		if (((m->flags & (MOPT_SET|MOPT_CLEAR)) == 0) ||
-		    (m->flags & MOPT_CLEAR_ERR))
+		    (m->flags & MOPT_CLEAR_ERR) ||
+		    (m->mount_opt & EXT4_MOUNT_DATA_ERR_ABORT))
 			continue;
 		if (!(m->mount_opt & (sbi->s_mount_opt ^ def_mount_opt)))
 			continue; /* skip if same as the default */
@@ -1914,6 +1915,8 @@ static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
 		SEQ_OPTS_PRINT("init_itable=%u", sbi->s_li_wait_mult);
 	if (nodefs || sbi->s_max_dir_size_kb)
 		SEQ_OPTS_PRINT("max_dir_size_kb=%u", sbi->s_max_dir_size_kb);
+	if (test_opt(sb, DATA_ERR_ABORT))
+		SEQ_OPTS_PUTS("data_err=abort");
 
 	ext4_show_quota_options(seq, sb);
 	return 0;
-- 
2.7.0

(unknown),

[Ales Novak]

This is alternative patch to the previous one, taking maybe more
logical approach.

(unknown)

[Forest Sturn]

Success will follow when you have a magnificent timepiece
http://mcfctau.%73%70%65%63%69%61%6c%72%65%70%67%69%66%74%2e%72%75

(unknown),

[Mark Singer]

Do you need an investor?
Our investors fund project and business. We also give out loan/credit to any individual and company at 3% interest rate yearly. For more information, Contact us via Email: devonfps@gmail.com 

If you need an investor or quick funding, forward your response ONLY to this E-mail: devonfps@gmail.com 
....
Haben Sie einen Investor brauchen?
Unsere Investoren Fonds Projekt- und Geschäfts. Wir geben auch Darlehen / Kredite an jeden einzelnen und Unternehmen bei 3% Zinsen jährlich. Für weitere Informationen, kontaktieren Sie uns per E-Mail: devonfps@gmail.com 

Wenn Sie ein Investor oder schnelle Finanzierung benötigen, senden Sie Ihre Antwort nur auf diese E-mail: devonfps@gmail.com --
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[Sasnett_Karen]

Haben Sie einen Investor brauchen?

Haben Sie geschäftliche oder persönliche Darlehen benötigen?

Wir geben Darlehen an eine natürliche Person und Unternehmen bei 3% Zinsen jährlich. Weitere Informationen Kontaktieren Sie uns per E-Mail: omfcreditspa@hotmail.com<mailto:omfcreditspa@hotmail.com>



HINWEIS: Leiten Sie Ihre Antwort nur an diese E-Mail: omfcreditspa@hotmail.com<mailto:omfcreditspa@hotmail.com>
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[pepa6.es]

Proposal,

Respond to my personal email;  mrs.zhangxiao1962@outlook.
com 


Yours Sincerely.
Mrs. Zhang Xiao (Accounts book Keeper)
Angang 
Steel Company Limited
396 Nan Zhong Hua Lu, Tie Dong District Anshan, 
Liaoning 114021, China.

(unknown)

[superplant]

subscribe

(unknown),

[Leanne Armstrong]

You were selected for QATAR Foundation 2015 beneficiaries contact RodFalusi(rodrigofalusi01@yahoo.co.za<mailto:rodrigofalusi01@yahoo.co.za>)

(unknown)

[MRS GRACE MANDA]

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









This is Mrs Grace Manda (  Please I need your Help is Urgent). 

[-- Attachment #2: Mrs Grace Manda.rtf --]
[-- Type: application/rtf, Size: 35796 bytes --]

(unknown),

[Denver colorado loan]

We give loan to those in debt, contact us direct in our head office here
in denver colorado, U.S.A via email singhuah@gmail.com

-- 
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.

(unknown),

[Singapore Loan offer]

We are just been granted a licensed to loan out money to any one in need
all over the world, contact us if you are in need of financial assistance,
at singhuah@gmail.com

-- 
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.

(unknown)

[myrealname]

help

(unknown)

[Ms Teresa Au]

-- 
please can you help me re-profile fund? 100% legit contact me personal  
email: Teresa_Au@yeah.net

(unknown),

[Becki Goodwin]

Although, I am not comfortable discussing the content of my mail on the Internet owing to lots of unsolicited/Spam
mails on the net nowadays.  The fact is I have made up my mind to will my late Husband's funds  to you so you can use it for charity  duties and good work to humanity in your country. please get back to me on my secured email  address ( beckigoodwin@outlook.com<mailto:beckigoodwin@outlook.com> ) for further information.
God bless you.
Mrs.  Becki Goodwin.

(unknown),

[Fiser, Sarah A.]

Fast and urgent funding for you, if interested, contact us via: bevloanservicess@webadicta.org<mailto:bevloanservicess@webadicta.org>
============================================================================================
schnelle und dringende Finanzierung für Sie, bei Interesse, kontaktieren Sie uns per E-Mail: bevloanservicess@webadicta.org<mailto:bevloanservicess@webadicta.org>

________________________________
The information contained in this e-mail message is intended solely for
the recipient(s) and may contain privileged information. Tampering with
or altering the contents of this message is prohibited. This information
is the same as any written document and may be subject to all rules
governing public information according to Florida Statutes. Any message
that falls under Chapter 119 shall not be altered in a manner that
misrepresents the activities of Orange County Public Schools.

[References: Florida State Constitution I.24, Florida State Statutes
Chapter 119, and OCPS Management Directive A-9.] If you have received
this message in error, or are not the named recipient notify the sender
and delete this message from your computer.

--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[christy walton]

Good day i am Mrs christy walton

I brought to you a proposal worth $ 9,000,000,000.00(Nine Billion United
State
Dollars) which i intend to use for CHARITY. Please reply me back if you
are interested.





----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

(unknown),

[Innocent Eleazu]

Loan offer at 3% interest rate,contact:  beverlyloanservices@outlook.com
Note: Reply to this Email Only:  beverlyloanservices@outlook.com
==========================================================================

Darlehen Angebot bei 3% Zins, Kontakt: beverlyloanservices@outlook.com
Hinweis: Antworten Sie auf diese E-Mail nur: beverlyloanservices@outlook.com

(unknown),

[Nagachandra P]

Hi,

Here are some details on the platform

Linux kernel version - 3.4.5
Android - 4.2.2
ext4 mounted with *errors=panic* option.

We see memory allocation failures mostly caused by low memory kill the
ext4 process which is waiting for a allocation on slow path. (below is
one such instance)

select 26413 (AsyncTask #3), score_adj 647, adj 10,size 15287, to kill
send sigkill to 26413 (AsyncTask #3), score_adj 647,adj 10, size 15287
with ofree -450 10896, cfree 27845 984 msa 529 ma 8
AsyncTask #3: page allocation failure: order:0, mode:0x80050
[<c001595c>] (unwind_backtrace+0x0/0x11c) from [<c00dc064>]
(warn_alloc_failed+0xe8/0x110)
[<c00dc064>] (warn_alloc_failed+0xe8/0x110) from [<c00dee54>]
(__alloc_pages_nodemask+0x6d4/0x800)
[<c00dee54>] (__alloc_pages_nodemask+0x6d4/0x800) from [<c05fe250>]
(cache_alloc_refill+0x30c/0x6a4)
[<c05fe250>] (cache_alloc_refill+0x30c/0x6a4) from [<c0104eb4>]
(kmem_cache_alloc+0xa0/0x1b8)
[<c0104eb4>] (kmem_cache_alloc+0xa0/0x1b8) from [<c0192c34>]
(ext4_free_blocks+0x9c4/0xa08)
[<c0192c34>] (ext4_free_blocks+0x9c4/0xa08) from [<c01873bc>]
(ext4_ext_remove_space+0x690/0xd9c)
[<c01873bc>] (ext4_ext_remove_space+0x690/0xd9c) from [<c01897f8>]
(ext4_ext_truncate+0x100/0x1c8)
[<c01897f8>] (ext4_ext_truncate+0x100/0x1c8) from [<c016447c>]
(ext4_truncate+0xf4/0x194)
[<c016447c>] (ext4_truncate+0xf4/0x194) from [<c0166cc0>]
(ext4_setattr+0x36c/0x3f8)
[<c0166cc0>] (ext4_setattr+0x36c/0x3f8) from [<c011f540>]
(notify_change+0x1dc/0x2a8)
[<c011f540>] (notify_change+0x1dc/0x2a8) from [<c0107cc8>]
(do_truncate+0x74/0x90)
[<c0107cc8>] (do_truncate+0x74/0x90) from [<c0107e20>]
(do_sys_ftruncate+0x13c/0x144)
[<c0107e20>] (do_sys_ftruncate+0x13c/0x144) from [<c0108020>]
(sys_ftruncate+0x18/0x1c)
[<c0108020>] (sys_ftruncate+0x18/0x1c) from [<c000e140>]
(ret_fast_syscall+0x0/0x48)

followed by....

SLAB: Unable to allocate memory on node 0 (gfp=0x80050)
  cache: ext4_free_data, object size: 64, order: 0
  node 0: slabs: 0/0, objs: 0/0, free: 0
EXT4-fs error (device mmcblk0p26) in ext4_free_blocks:4700: Out of memory
Aborting journal on device mmcblk0p26-8.
EXT4-fs error (device mmcblk0p26): ext4_journal_start_sb:328: Detected
aborted journal
EXT4-fs (mmcblk0p26): Remounting filesystem read-only
Kernel panic - not syncing: EXT4-fs panic from previous error

[<c001595c>] (unwind_backtrace+0x0/0x11c) from [<c05fc5b4>] (panic+0x80/0x1cc)
[<c05fc5b4>] (panic+0x80/0x1cc) from [<c017ddec>] (__ext4_abort+0xc0/0xe0)
[<c017ddec>] (__ext4_abort+0xc0/0xe0) from [<c017dfa0>]
(ext4_journal_start_sb+0x194/0x1c4)
[<c017dfa0>] (ext4_journal_start_sb+0x194/0x1c4) from [<c0168c60>]
(ext4_dirty_inode+0x14/0x40)
[<c0168c60>] (ext4_dirty_inode+0x14/0x40) from [<c01293c0>]
(__mark_inode_dirty+0x2c/0x1b4)
[<c01293c0>] (__mark_inode_dirty+0x2c/0x1b4) from [<c011d6b8>]
(file_update_time+0xfc/0x11c)
[<c011d6b8>] (file_update_time+0xfc/0x11c) from [<c00d8f34>]
(__generic_file_aio_write+0x2d8/0x40c)
[<c00d8f34>] (__generic_file_aio_write+0x2d8/0x40c) from [<c00d90c8>]
(generic_file_aio_write+0x60/0xc8)
[<c00d90c8>] (generic_file_aio_write+0x60/0xc8) from [<c015f74c>]
(ext4_file_write+0x244/0x2b4)
[<c015f74c>] (ext4_file_write+0x244/0x2b4) from [<c0108a38>]
(do_sync_write+0x9c/0xd8)
[<c0108a38>] (do_sync_write+0x9c/0xd8) from [<c0109304>] (vfs_write+0xb0/0x128)
[<c0109304>] (vfs_write+0xb0/0x128) from [<c010953c>] (sys_write+0x38/0x64)
[<c010953c>] (sys_write+0x38/0x64) from [<c000e140>] (ret_fast_syscall+0x0/0x48)

Is there a way in which we could avoid ext4 panic caused by allocation
failure (a method other than setting errors=continue :-) )? (or is
memory allocation failure considered as fatal as any other IO error)

Thanks
Nagachandra

(unknown),

[maria aguirre]

Hi, I 'm having a problem with some files recently removed from the trash. really do not care much to recover the file. What I need is to know their names (maybe also their extensions). I know the dates of creation and deletion. Could, with this data, search through some sort of "log" of the file system? Is that possible? 		 	   		  

(unknown),

[Somchai Smythe]

Hello,

     I keep getting this (copied by hand):

e2fsck -v -f /dev/blsvg/tmp
e2fsck 1.42.7 (21-Jan-2013)
ext2fs_check_desc: Corrupt group descriptor: bad block for inode table
e2fsck: Group descriptor look bad... trying backup blocks...
/tmp: recovering journal
e2fsck: unable to set superblock flags on /tmp

/tmp: ********** WARNING: Filesystem still has errors **********

I thought '-f' would force things to get fixed.  Is there a 'force
harder' switch?  Since it is /tmp I can just run mke2fs again, but I
would like to know before I do that why e2fsck cannot fix this.  I can
still mount the filesystem and read files on it, but I'm afraid to
really use it.

I'm running vanilla 3.7.8 kernel on an amd64 virtual machine if it matters.

dumpe2fs 1.42.7 (21-Jan-2013)
Filesystem volume name:   /tmp
Last mounted on:          /tmp
Filesystem UUID:          3268058d-455f-4f65-a6ee-72e236e6bff5
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index
filetype extent flex_bg sparse_super large_file huge_file dir_nlink
extra_isize
Filesystem flags:         signed_directory_hash
Default mount options:    user_xattr acl
Filesystem state:         clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              2719744
Block count:              2707456
Reserved block count:     67867
Free blocks:              1473632
Free inodes:              2620790
First block:              0
Block size:               4096
Fragment size:            4096
Reserved GDT blocks:      319
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         32768
Inode blocks per group:   2048
Flex block group size:    16
Filesystem created:       Sun Feb 17 06:26:55 2013
Last mount time:          Sun Feb 17 17:51:13 2013
Last write time:          Sun Feb 17 19:56:52 2013
Mount count:              2
Maximum mount count:      28
Last checked:             Sun Feb 17 12:41:00 2013
Check interval:           15552000 (6 months)
Next check after:         Fri Aug 16 12:41:00 2013
Lifetime writes:          16 GB
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:               256
Required extra isize:     28
Desired extra isize:      28
Journal inode:            8
Default directory hash:   half_md4
Directory Hash Seed:      75b881a3-6a2a-4006-ac6d-943b23c88b73
Journal backup:           inode blocks
Journal features:         journal_incompat_revoke
Journal size:             128M
Journal length:           32768
Journal sequence:         0x00000209
Journal start:            0


Group 0: (Blocks 0-32767)
  Primary superblock at 0, Group descriptors at 1-1
  Reserved GDT blocks at 2-320
  Block bitmap at 321 (+321), Inode bitmap at 337 (+337)
  Inode table at 353-2400 (+353)
  0 free blocks, 30516 free inodes, 131 directories
  Free blocks:
  Free inodes: 2251-2429, 2431-7853, 7855-32768
Group 1: (Blocks 32768-65535)
  Backup superblock at 32768, Group descriptors at 32769-32769
  Reserved GDT blocks at 32770-33088
  Block bitmap at 322 (bg #0 + 322), Inode bitmap at 338 (bg #0 + 338)
  Inode table at 2401-4448 (bg #0 + 2401)
  0 free blocks, 32766 free inodes, 2 directories
  Free blocks:
  Free inodes: 32769-56724, 56726-64383, 64385-65536
Group 2: (Blocks 65536-98303)
  Block bitmap at 323 (bg #0 + 323), Inode bitmap at 339 (bg #0 + 339)
  Inode table at 4449-6496 (bg #0 + 4449)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 65537-98304
Group 3: (Blocks 98304-131071)
  Backup superblock at 98304, Group descriptors at 98305-98305
  Reserved GDT blocks at 98306-98624
  Block bitmap at 324 (bg #0 + 324), Inode bitmap at 340 (bg #0 + 340)
  Inode table at 6497-8544 (bg #0 + 6497)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 98305-131072
Group 4: (Blocks 131072-163839)
  Block bitmap at 325 (bg #0 + 325), Inode bitmap at 341 (bg #0 + 341)
  Inode table at 8545-10592 (bg #0 + 8545)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 131073-163840
Group 5: (Blocks 163840-196607)
  Backup superblock at 163840, Group descriptors at 163841-163841
  Reserved GDT blocks at 163842-164160
  Block bitmap at 326 (bg #0 + 326), Inode bitmap at 342 (bg #0 + 342)
  Inode table at 10593-12640 (bg #0 + 10593)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 163841-196608
Group 6: (Blocks 196608-229375)
  Block bitmap at 327 (bg #0 + 327), Inode bitmap at 343 (bg #0 + 343)
  Inode table at 12641-14688 (bg #0 + 12641)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 196609-229376
Group 7: (Blocks 229376-262143)
  Backup superblock at 229376, Group descriptors at 229377-229377
  Reserved GDT blocks at 229378-229696
  Block bitmap at 328 (bg #0 + 328), Inode bitmap at 344 (bg #0 + 344)
  Inode table at 14689-16736 (bg #0 + 14689)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 229377-262144
Group 8: (Blocks 262144-294911)
  Block bitmap at 329 (bg #0 + 329), Inode bitmap at 345 (bg #0 + 345)
  Inode table at 16737-18784 (bg #0 + 16737)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 262145-294912
Group 9: (Blocks 294912-327679)
  Backup superblock at 294912, Group descriptors at 294913-294913
  Reserved GDT blocks at 294914-295232
  Block bitmap at 330 (bg #0 + 330), Inode bitmap at 346 (bg #0 + 346)
  Inode table at 18785-20832 (bg #0 + 18785)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 294913-327680
Group 10: (Blocks 327680-360447)
  Block bitmap at 331 (bg #0 + 331), Inode bitmap at 347 (bg #0 + 347)
  Inode table at 20833-22880 (bg #0 + 20833)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 327681-360448
Group 11: (Blocks 360448-393215)
  Block bitmap at 332 (bg #0 + 332), Inode bitmap at 348 (bg #0 + 348)
  Inode table at 22881-24928 (bg #0 + 22881)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 360449-393216
Group 12: (Blocks 393216-425983)
  Block bitmap at 333 (bg #0 + 333), Inode bitmap at 349 (bg #0 + 349)
  Inode table at 24929-26976 (bg #0 + 24929)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 393217-425984
Group 13: (Blocks 425984-458751)
  Block bitmap at 334 (bg #0 + 334), Inode bitmap at 350 (bg #0 + 350)
  Inode table at 26977-29024 (bg #0 + 26977)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 425985-458752
Group 14: (Blocks 458752-491519)
  Block bitmap at 335 (bg #0 + 335), Inode bitmap at 351 (bg #0 + 351)
  Inode table at 29025-31072 (bg #0 + 29025)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 458753-491520
Group 15: (Blocks 491520-524287)
  Block bitmap at 336 (bg #0 + 336), Inode bitmap at 352 (bg #0 + 352)
  Inode table at 33089-35136 (bg #1 + 321)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 491521-524288
Group 16: (Blocks 524288-557055)
  Block bitmap at 524288 (+0), Inode bitmap at 524304 (+16)
  Inode table at 524320-526367 (+32)
  0 free blocks, 0 free inodes, 2248 directories
  Free blocks:
  Free inodes:
Group 17: (Blocks 557056-589823)
  Block bitmap at 524289 (bg #16 + 1), Inode bitmap at 524305 (bg #16 + 17)
  Inode table at 526368-528415 (bg #16 + 2080)
  0 free blocks, 0 free inodes, 1640 directories
  Free blocks:
  Free inodes:
Group 18: (Blocks 589824-622591)
  Block bitmap at 524290 (bg #16 + 2), Inode bitmap at 524306 (bg #16 + 18)
  Inode table at 528416-530463 (bg #16 + 4128)
  0 free blocks, 31857 free inodes, 226 directories
  Free blocks:
  Free inodes: 590736-622592
Group 19: (Blocks 622592-655359)
  Block bitmap at 524291 (bg #16 + 3), Inode bitmap at 524307 (bg #16 + 19)
  Inode table at 530464-532511 (bg #16 + 6176)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 622593-655360
Group 20: (Blocks 655360-688127)
  Block bitmap at 524292 (bg #16 + 4), Inode bitmap at 524308 (bg #16 + 20)
  Inode table at 532512-534559 (bg #16 + 8224)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 655361-688128
Group 21: (Blocks 688128-720895)
  Block bitmap at 524293 (bg #16 + 5), Inode bitmap at 524309 (bg #16 + 21)
  Inode table at 534560-536607 (bg #16 + 10272)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 688129-720896
Group 22: (Blocks 720896-753663)
  Block bitmap at 524294 (bg #16 + 6), Inode bitmap at 524310 (bg #16 + 22)
  Inode table at 536608-538655 (bg #16 + 12320)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 720897-753664
Group 23: (Blocks 753664-786431)
  Block bitmap at 524295 (bg #16 + 7), Inode bitmap at 524311 (bg #16 + 23)
  Inode table at 538656-540703 (bg #16 + 14368)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 753665-786432
Group 24: (Blocks 786432-819199)
  Block bitmap at 524296 (bg #16 + 8), Inode bitmap at 524312 (bg #16 + 24)
  Inode table at 540704-542751 (bg #16 + 16416)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 786433-819200
Group 25: (Blocks 819200-851967)
  Backup superblock at 819200, Group descriptors at 819201-819201
  Reserved GDT blocks at 819202-819520
  Block bitmap at 524297 (bg #16 + 9), Inode bitmap at 524313 (bg #16 + 25)
  Inode table at 542752-544799 (bg #16 + 18464)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 819201-851968
Group 26: (Blocks 851968-884735)
  Block bitmap at 524298 (bg #16 + 10), Inode bitmap at 524314 (bg #16 + 26)
  Inode table at 544800-546847 (bg #16 + 20512)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 851969-884736
Group 27: (Blocks 884736-917503)
  Backup superblock at 884736, Group descriptors at 884737-884737
  Reserved GDT blocks at 884738-885056
  Block bitmap at 524299 (bg #16 + 11), Inode bitmap at 524315 (bg #16 + 27)
  Inode table at 546848-548895 (bg #16 + 22560)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 884737-917504
Group 28: (Blocks 917504-950271)
  Block bitmap at 524300 (bg #16 + 12), Inode bitmap at 524316 (bg #16 + 28)
  Inode table at 548896-550943 (bg #16 + 24608)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 917505-950272
Group 29: (Blocks 950272-983039)
  Block bitmap at 524301 (bg #16 + 13), Inode bitmap at 524317 (bg #16 + 29)
  Inode table at 550944-552991 (bg #16 + 26656)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 950273-983040
Group 30: (Blocks 983040-1015807)
  Block bitmap at 524302 (bg #16 + 14), Inode bitmap at 524318 (bg #16 + 30)
  Inode table at 552992-555039 (bg #16 + 28704)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 983041-1015808
Group 31: (Blocks 1015808-1048575)
  Block bitmap at 524303 (bg #16 + 15), Inode bitmap at 524319 (bg #16 + 31)
  Inode table at 555040-557087 (bg #16 + 30752)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1015809-1048576
Group 32: (Blocks 1048576-1081343)
  Block bitmap at 1048576 (+0), Inode bitmap at 1048592 (+16)
  Inode table at 1048608-1050655 (+32)
  0 free blocks, 1176 free inodes, 2492 directories
  Free blocks:
  Free inodes: 1080169-1081344
Group 33: (Blocks 1081344-1114111)
  Block bitmap at 1048577 (bg #32 + 1), Inode bitmap at 1048593 (bg #32 + 17)
  Inode table at 1050656-1052703 (bg #32 + 2080)
  0 free blocks, 32673 free inodes, 95 directories
  Free blocks:
  Free inodes: 1081440-1114112
Group 34: (Blocks 1114112-1146879)
  Block bitmap at 1048578 (bg #32 + 2), Inode bitmap at 1048594 (bg #32 + 18)
  Inode table at 1052704-1054751 (bg #32 + 4128)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1114113-1146880
Group 35: (Blocks 1146880-1179647)
  Block bitmap at 1048579 (bg #32 + 3), Inode bitmap at 1048595 (bg #32 + 19)
  Inode table at 1054752-1056799 (bg #32 + 6176)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1146881-1179648
Group 36: (Blocks 1179648-1212415)
  Block bitmap at 1048580 (bg #32 + 4), Inode bitmap at 1048596 (bg #32 + 20)
  Inode table at 1056800-1058847 (bg #32 + 8224)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1179649-1212416
Group 37: (Blocks 1212416-1245183)
  Block bitmap at 1048581 (bg #32 + 5), Inode bitmap at 1048597 (bg #32 + 21)
  Inode table at 1058848-1060895 (bg #32 + 10272)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1212417-1245184
Group 38: (Blocks 1245184-1277951)
  Block bitmap at 1048582 (bg #32 + 6), Inode bitmap at 1048598 (bg #32 + 22)
  Inode table at 1060896-1062943 (bg #32 + 12320)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1245185-1277952
Group 39: (Blocks 1277952-1310719)
  Block bitmap at 1048583 (bg #32 + 7), Inode bitmap at 1048599 (bg #32 + 23)
  Inode table at 1062944-1064991 (bg #32 + 14368)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1277953-1310720
Group 40: (Blocks 1310720-1343487)
  Block bitmap at 1310720 (+0), Inode bitmap at 1310721 (+1)
  Inode table at 1310722-1312769 (+2)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1310721-1343488
Group 41: (Blocks 1343488-1376255)
  Block bitmap at 1312770 (bg #40 + 2050), Inode bitmap at 1312771 (bg
#40 + 2051)
  Inode table at 1312772-1314819 (bg #40 + 2052)
  0 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1343489-1376256
Group 42: (Blocks 1376256-1409023)
  Block bitmap at 1314820 (bg #40 + 4100), Inode bitmap at 1314821 (bg
#40 + 4101)
  Inode table at 1314822-1316869 (bg #40 + 4102)
  12288 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1396736-1409023
  Free inodes: 1376257-1409024
Group 43: (Blocks 1409024-1441791)
  Block bitmap at 1409024 (+0), Inode bitmap at 1409029 (+5)
  Inode table at 1409034-1411081 (+10)
  22518 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1419274-1441791
  Free inodes: 1409025-1441792
Group 44: (Blocks 1441792-1474559)
  Block bitmap at 1409025 (bg #43 + 1), Inode bitmap at 1409030 (bg #43 + 6)
  Inode table at 1411082-1413129 (bg #43 + 2058)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1441792-1474559
  Free inodes: 1441793-1474560
Group 45: (Blocks 1474560-1507327)
  Block bitmap at 1409026 (bg #43 + 2), Inode bitmap at 1409031 (bg #43 + 7)
  Inode table at 1413130-1415177 (bg #43 + 4106)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1474560-1507327
  Free inodes: 1474561-1507328
Group 46: (Blocks 1507328-1540095)
  Block bitmap at 1409027 (bg #43 + 3), Inode bitmap at 1409032 (bg #43 + 8)
  Inode table at 1415178-1417225 (bg #43 + 6154)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1507328-1540095
  Free inodes: 1507329-1540096
Group 47: (Blocks 1540096-1572863)
  Block bitmap at 1409028 (bg #43 + 4), Inode bitmap at 1409033 (bg #43 + 9)
  Inode table at 1417226-1419273 (bg #43 + 8202)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1540096-1572863
  Free inodes: 1540097-1572864
Group 48: (Blocks 1572864-1605631)
  Block bitmap at 1572864 (+0), Inode bitmap at 1572880 (+16)
  Inode table at 1572896-1574943 (+32)
  65504 free blocks, 32768 free inodes, 0 directories
  Free blocks:
  Free inodes: 1572865-1605632
Group 49: (Blocks 1605632-1638399)
  Backup superblock at 1605632, Group descriptors at 1605633-1605633
  Reserved GDT blocks at 1605634-1605952
  Block bitmap at 1572865 (bg #48 + 1), Inode bitmap at 1572881 (bg #48 + 17)
  Inode table at 1574944-1576991 (bg #48 + 2080)
  32447 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1605953-1638399
  Free inodes: 1605633-1638400
Group 50: (Blocks 1638400-1671167)
  Block bitmap at 1572866 (bg #48 + 2), Inode bitmap at 1572882 (bg #48 + 18)
  Inode table at 1576992-1579039 (bg #48 + 4128)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1638400-1671167
  Free inodes: 1638401-1671168
Group 51: (Blocks 1671168-1703935)
  Block bitmap at 1572867 (bg #48 + 3), Inode bitmap at 1572883 (bg #48 + 19)
  Inode table at 1579040-1581087 (bg #48 + 6176)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1671168-1703935
  Free inodes: 1671169-1703936
Group 52: (Blocks 1703936-1736703)
  Block bitmap at 1572868 (bg #48 + 4), Inode bitmap at 1572884 (bg #48 + 20)
  Inode table at 1581088-1583135 (bg #48 + 8224)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1703936-1736703
  Free inodes: 1703937-1736704
Group 53: (Blocks 1736704-1769471)
  Block bitmap at 1572869 (bg #48 + 5), Inode bitmap at 1572885 (bg #48 + 21)
  Inode table at 1583136-1585183 (bg #48 + 10272)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1736704-1769471
  Free inodes: 1736705-1769472
Group 54: (Blocks 1769472-1802239)
  Block bitmap at 1572870 (bg #48 + 6), Inode bitmap at 1572886 (bg #48 + 22)
  Inode table at 1585184-1587231 (bg #48 + 12320)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1769472-1802239
  Free inodes: 1769473-1802240
Group 55: (Blocks 1802240-1835007)
  Block bitmap at 1572871 (bg #48 + 7), Inode bitmap at 1572887 (bg #48 + 23)
  Inode table at 1587232-1589279 (bg #48 + 14368)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1802240-1835007
  Free inodes: 1802241-1835008
Group 56: (Blocks 1835008-1867775)
  Block bitmap at 1572872 (bg #48 + 8), Inode bitmap at 1572888 (bg #48 + 24)
  Inode table at 1589280-1591327 (bg #48 + 16416)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1835008-1867775
  Free inodes: 1835009-1867776
Group 57: (Blocks 1867776-1900543)
  Block bitmap at 1572873 (bg #48 + 9), Inode bitmap at 1572889 (bg #48 + 25)
  Inode table at 1591328-1593375 (bg #48 + 18464)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1867776-1900543
  Free inodes: 1867777-1900544
Group 58: (Blocks 1900544-1933311)
  Block bitmap at 1572874 (bg #48 + 10), Inode bitmap at 1572890 (bg #48 + 26)
  Inode table at 1593376-1595423 (bg #48 + 20512)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1900544-1933311
  Free inodes: 1900545-1933312
Group 59: (Blocks 1933312-1966079)
  Block bitmap at 1572875 (bg #48 + 11), Inode bitmap at 1572891 (bg #48 + 27)
  Inode table at 1595424-1597471 (bg #48 + 22560)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1933312-1966079
  Free inodes: 1933313-1966080
Group 60: (Blocks 1966080-1998847)
  Block bitmap at 1572876 (bg #48 + 12), Inode bitmap at 1572892 (bg #48 + 28)
  Inode table at 1597472-1599519 (bg #48 + 24608)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1966080-1998847
  Free inodes: 1966081-1998848
Group 61: (Blocks 1998848-2031615)
  Block bitmap at 1572877 (bg #48 + 13), Inode bitmap at 1572893 (bg #48 + 29)
  Inode table at 1599520-1601567 (bg #48 + 26656)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 1998848-2031615
  Free inodes: 1998849-2031616
Group 62: (Blocks 2031616-2064383)
  Block bitmap at 1572878 (bg #48 + 14), Inode bitmap at 1572894 (bg #48 + 30)
  Inode table at 1601568-1603615 (bg #48 + 28704)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2031616-2064383
  Free inodes: 2031617-2064384
Group 63: (Blocks 2064384-2097151)
  Block bitmap at 1572879 (bg #48 + 15), Inode bitmap at 1572895 (bg #48 + 31)
  Inode table at 1603616-1605663 (bg #48 + 30752)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2064384-2097151
  Free inodes: 2064385-2097152
Group 64: (Blocks 2097152-2129919)
  Block bitmap at 2097152 (+0), Inode bitmap at 2097168 (+16)
  Inode table at 2097184-2099231 (+32)
  2016 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2127904-2129919
  Free inodes: 2097153-2129920
Group 65: (Blocks 2129920-2162687)
  Block bitmap at 2097153 (bg #64 + 1), Inode bitmap at 2097169 (bg #64 + 17)
  Inode table at 2099232-2101279 (bg #64 + 2080)
  30720 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2129920-2162687
  Free inodes: 2129921-2162688
Group 66: (Blocks 2162688-2195455)
  Block bitmap at 2097154 (bg #64 + 2), Inode bitmap at 2097170 (bg #64 + 18)
  Inode table at 2101280-2103327 (bg #64 + 4128)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2162688-2195455
  Free inodes: 2162689-2195456
Group 67: (Blocks 2195456-2228223)
  Block bitmap at 2097155 (bg #64 + 3), Inode bitmap at 2097171 (bg #64 + 19)
  Inode table at 2103328-2105375 (bg #64 + 6176)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2195456-2228223
  Free inodes: 2195457-2228224
Group 68: (Blocks 2228224-2260991)
  Block bitmap at 2097156 (bg #64 + 4), Inode bitmap at 2097172 (bg #64 + 20)
  Inode table at 2105376-2107423 (bg #64 + 8224)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2228224-2260991
  Free inodes: 2228225-2260992
Group 69: (Blocks 2260992-2293759)
  Block bitmap at 2097157 (bg #64 + 5), Inode bitmap at 2097173 (bg #64 + 21)
  Inode table at 2107424-2109471 (bg #64 + 10272)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2260992-2293759
  Free inodes: 2260993-2293760
Group 70: (Blocks 2293760-2326527)
  Block bitmap at 2097158 (bg #64 + 6), Inode bitmap at 2097174 (bg #64 + 22)
  Inode table at 2109472-2111519 (bg #64 + 12320)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2293760-2326527
  Free inodes: 2293761-2326528
Group 71: (Blocks 2326528-2359295)
  Block bitmap at 2097159 (bg #64 + 7), Inode bitmap at 2097175 (bg #64 + 23)
  Inode table at 2111520-2113567 (bg #64 + 14368)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2326528-2359295
  Free inodes: 2326529-2359296
Group 72: (Blocks 2359296-2392063)
  Block bitmap at 2097160 (bg #64 + 8), Inode bitmap at 2097176 (bg #64 + 24)
  Inode table at 2113568-2115615 (bg #64 + 16416)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2359296-2392063
  Free inodes: 2359297-2392064
Group 73: (Blocks 2392064-2424831)
  Block bitmap at 2097161 (bg #64 + 9), Inode bitmap at 2097177 (bg #64 + 25)
  Inode table at 2115616-2117663 (bg #64 + 18464)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2392064-2424831
  Free inodes: 2392065-2424832
Group 74: (Blocks 2424832-2457599)
  Block bitmap at 2097162 (bg #64 + 10), Inode bitmap at 2097178 (bg #64 + 26)
  Inode table at 2117664-2119711 (bg #64 + 20512)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2424832-2457599
  Free inodes: 2424833-2457600
Group 75: (Blocks 2457600-2490367)
  Block bitmap at 2097163 (bg #64 + 11), Inode bitmap at 2097179 (bg #64 + 27)
  Inode table at 2119712-2121759 (bg #64 + 22560)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2457600-2490367
  Free inodes: 2457601-2490368
Group 76: (Blocks 2490368-2523135)
  Block bitmap at 2097164 (bg #64 + 12), Inode bitmap at 2097180 (bg #64 + 28)
  Inode table at 2121760-2123807 (bg #64 + 24608)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2490368-2523135
  Free inodes: 2490369-2523136
Group 77: (Blocks 2523136-2555903)
  Block bitmap at 2097165 (bg #64 + 13), Inode bitmap at 2097181 (bg #64 + 29)
  Inode table at 2123808-2125855 (bg #64 + 26656)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2523136-2555903
  Free inodes: 2523137-2555904
Group 78: (Blocks 2555904-2588671)
  Block bitmap at 2097166 (bg #64 + 14), Inode bitmap at 2097182 (bg #64 + 30)
  Inode table at 2125856-2127903 (bg #64 + 28704)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2555904-2588671
  Free inodes: 2555905-2588672
Group 79: (Blocks 2588672-2621439)
  Block bitmap at 2097167 (bg #64 + 15), Inode bitmap at 2097183 (bg #64 + 31)
  Inode table at 2129920-2131967 (bg #65 + 0)
  32768 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2588672-2621439
  Free inodes: 2588673-2621440
Group 80: (Blocks 2621440-2654207)
  Block bitmap at 2621440 (+0), Inode bitmap at 2621443 (+3)
  Inode table at 2621446-2623493 (+6)
  26618 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2627590-2654207
  Free inodes: 2621441-2654208
Group 81: (Blocks 2654208-2686975)
  Backup superblock at 2654208, Group descriptors at 2654209-2654209
  Reserved GDT blocks at 2654210-2654528
  Block bitmap at 2621441 (bg #80 + 1), Inode bitmap at 2621444 (bg #80 + 4)
  Inode table at 2623494-2625541 (bg #80 + 2054)
  32447 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2654529-2686975
  Free inodes: 2654209-2686976
Group 82: (Blocks 2686976-2707455)
  Block bitmap at 2621442 (bg #80 + 2), Inode bitmap at 2621445 (bg #80 + 5)
  Inode table at 2625542-2627589 (bg #80 + 4102)
  20480 free blocks, 32768 free inodes, 0 directories
  Free blocks: 2686976-2707455
  Free inodes: 2686977-2719744

The /tmp is on a LVM which I had resized, and done a resize2fs online
and that's when
I had the trouble.  Basically I was compiling stuff and /tmp hit 100%,
so I did this:

lvextend -l +100%FREE /dev/blsvg/tmp
   (that added about 5GB to the existing 5GB giving a total of 10GB
for /dev/blsvg/tmp)
resize2fs /dev/blsvg/tmp
df -h
  (showed some size negative terrabytes, so I figured something bad happened)
umount /tmp
e2fsck -vfDC0 /dev/blsvg/tmp

That didn't work. so tried just

e2fsck -v -f /dev/blsvg/tmp

Still got the errors, so mounted /tmp again to copy off the files,
then unmounted and tried e2fsck without any luck.  So did the dumpe2fs
and sent this email.

The machine is in a QEMU 1.4 virtual machine if that matters, using
this command line:

qemu-system-x86_64 -enable-kvm -vga cirrus \
   -cpu Nehalem -smp 8,cores=4,threads=2,sockets=1 -m 8192 \
   -vnc :0,password,tls -monitor stdio -localtime \
   -usb -usbdevice mouse -usbdevice keyboard \
   -net nic,vlan=0,model=virtio,macaddr=DE:AD:BE:EF:24:22 \
   -net tap,ifname=tap0,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown \
   -name VM0 \
   -drive file=/dev/mapper/vmland-vmdisk0,if=virtio \
   -boot order=c,menu=on -nodefaults

The host machine also runs vanilla 3.7.8 kernel.  I'm sure I did
something stupid, but I was kind of hoping e2fsck could fix it.

JGH

(unknown)

[darrick.wong]

>From nobody Mon Nov 19 23:51:14 2012
Subject: [PATCH 4/9] xfs: honor the O_SYNC flag for aysnchronous direct I/O
 requests
To: axboe@kernel.dk, tytso@mit.edu, david@fromorbit.com, jmoyer@redhat.com,
 bpm@sgi.com, viro@zeniv.linux.org.uk, jack@suse.cz
From: "Darrick J. Wong" <darrick.wong@oracle.com>
Cc: linux-fsdevel@vger.kernel.org, hch@infradead.org,
 linux-ext4@vger.kernel.org, linux-kernel@vger.kernel.org, xfs@oss.sgi.com,
 djwong+kernel@djwong.org
Date: Mon, 19 Nov 2012 23:51:14 -0800
Message-ID: <20121120075114.25270.40680.stgit@blackbox.djwong.org>
In-Reply-To: <20121120074116.24645.36369.stgit@blackbox.djwong.org>
References: <20121120074116.24645.36369.stgit@blackbox.djwong.org>
User-Agent: StGit/0.15
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit

If a file is opened with O_SYNC|O_DIRECT, the drive cache does not get
flushed after the write completion for AIOs.  This patch attempts to fix
that problem by marking an I/O as requiring a cache flush in endio
processing, and then issuing the cache flush after any unwritten extent
conversion is done.

From: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
[darrick.wong@oracle.com: Rework patch to use per-mount workqueues]
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_aops.c  |   52 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 fs/xfs/xfs_aops.h  |    1 +
 fs/xfs/xfs_mount.h |    1 +
 fs/xfs/xfs_super.c |    8 ++++++++
 4 files changed, 61 insertions(+), 1 deletion(-)


diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index e57e2da..9cebbb7 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -173,6 +173,24 @@ xfs_setfilesize(
 }
 
 /*
+ * In the case of synchronous, AIO, O_DIRECT writes, we need to flush
+ * the disk cache when the I/O is complete.
+ */
+STATIC bool
+xfs_ioend_needs_cache_flush(
+	struct xfs_ioend	*ioend)
+{
+	struct xfs_inode *ip = XFS_I(ioend->io_inode);
+	struct xfs_mount *mp = ip->i_mount;
+
+	if (!(mp->m_flags & XFS_MOUNT_BARRIER))
+		return false;
+
+	return IS_SYNC(ioend->io_inode) ||
+	       (ioend->io_iocb->ki_filp->f_flags & O_DSYNC);
+}
+
+/*
  * Schedule IO completion handling on the final put of an ioend.
  *
  * If there is no work to do we might as well call it a day and free the
@@ -189,11 +207,30 @@ xfs_finish_ioend(
 			queue_work(mp->m_unwritten_workqueue, &ioend->io_work);
 		else if (ioend->io_append_trans)
 			queue_work(mp->m_data_workqueue, &ioend->io_work);
+		else if (ioend->io_needs_fsync)
+			queue_work(mp->m_aio_blkdev_flush_wq, &ioend->io_work);
 		else
 			xfs_destroy_ioend(ioend);
 	}
 }
 
+STATIC int
+xfs_ioend_force_cache_flush(
+	xfs_ioend_t	*ioend)
+{
+	struct xfs_inode *ip = XFS_I(ioend->io_inode);
+	struct xfs_mount *mp = ip->i_mount;
+	int		err = 0;
+	int		datasync;
+
+	datasync = !IS_SYNC(ioend->io_inode) &&
+		!(ioend->io_iocb->ki_filp->f_flags & __O_SYNC);
+	err = do_xfs_file_fsync(ip, mp, datasync);
+	xfs_destroy_ioend(ioend);
+	/* do_xfs_file_fsync returns -errno. our caller expects positive. */
+	return -err;
+}
+
 /*
  * IO write completion.
  */
@@ -250,12 +287,22 @@ xfs_end_io(
 		error = xfs_setfilesize(ioend);
 		if (error)
 			ioend->io_error = -error;
+	} else if (ioend->io_needs_fsync) {
+		error = xfs_ioend_force_cache_flush(ioend);
+		if (error && ioend->io_result > 0)
+			ioend->io_error = -error;
+		ioend->io_needs_fsync = 0;
 	} else {
 		ASSERT(!xfs_ioend_is_append(ioend));
 	}
 
 done:
-	xfs_destroy_ioend(ioend);
+	/* the honoring of O_SYNC has to be done last */
+	if (ioend->io_needs_fsync) {
+		atomic_inc(&ioend->io_remaining);
+		xfs_finish_ioend(ioend);
+	} else
+		xfs_destroy_ioend(ioend);
 }
 
 /*
@@ -292,6 +339,7 @@ xfs_alloc_ioend(
 	atomic_set(&ioend->io_remaining, 1);
 	ioend->io_isasync = 0;
 	ioend->io_isdirect = 0;
+	ioend->io_needs_fsync = 0;
 	ioend->io_error = 0;
 	ioend->io_list = NULL;
 	ioend->io_type = type;
@@ -1409,6 +1457,8 @@ xfs_end_io_direct_write(
 
 	if (is_async) {
 		ioend->io_isasync = 1;
+		if (xfs_ioend_needs_cache_flush(ioend))
+			ioend->io_needs_fsync = 1;
 		xfs_finish_ioend(ioend);
 	} else {
 		xfs_finish_ioend_sync(ioend);
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index c325abb..e48c7c2 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -47,6 +47,7 @@ typedef struct xfs_ioend {
 	atomic_t		io_remaining;	/* hold count */
 	unsigned int		io_isasync : 1;	/* needs aio_complete */
 	unsigned int		io_isdirect : 1;/* direct I/O */
+	unsigned int		io_needs_fsync : 1; /* aio+dio+o_sync */
 	struct inode		*io_inode;	/* file being written to */
 	struct buffer_head	*io_buffer_head;/* buffer linked list head */
 	struct buffer_head	*io_buffer_tail;/* buffer linked list tail */
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index deee09e..ecd3d2e 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -209,6 +209,7 @@ typedef struct xfs_mount {
 	struct workqueue_struct	*m_data_workqueue;
 	struct workqueue_struct	*m_unwritten_workqueue;
 	struct workqueue_struct	*m_cil_workqueue;
+	struct workqueue_struct *m_aio_blkdev_flush_wq;
 } xfs_mount_t;
 
 /*
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 26a09bd..b05b557 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -863,8 +863,15 @@ xfs_init_mount_workqueues(
 			WQ_MEM_RECLAIM, 0, mp->m_fsname);
 	if (!mp->m_cil_workqueue)
 		goto out_destroy_unwritten;
+
+	mp->m_aio_blkdev_flush_wq = alloc_workqueue("xfs-aio-blkdev-flush/%s",
+			WQ_MEM_RECLAIM, 0, mp->m_fsname);
+	if (!mp->m_aio_blkdev_flush_wq)
+		goto out_destroy_cil_queue;
 	return 0;
 
+out_destroy_cil_queue:
+	destroy_workqueue(mp->m_cil_workqueue);
 out_destroy_unwritten:
 	destroy_workqueue(mp->m_unwritten_workqueue);
 out_destroy_data_iodone_queue:
@@ -877,6 +884,7 @@ STATIC void
 xfs_destroy_mount_workqueues(
 	struct xfs_mount	*mp)
 {
+	destroy_workqueue(mp->m_aio_blkdev_flush_wq);
 	destroy_workqueue(mp->m_cil_workqueue);
 	destroy_workqueue(mp->m_data_workqueue);
 	destroy_workqueue(mp->m_unwritten_workqueue);

(unknown)

[darrick.wong]

>From nobody Mon Nov 19 23:51:14 2012
Subject: [PATCH 5/9] btrfs: Use generic handlers of O_SYNC AIO DIO
To: axboe@kernel.dk, tytso@mit.edu, david@fromorbit.com, jmoyer@redhat.com,
 bpm@sgi.com, viro@zeniv.linux.org.uk, jack@suse.cz
From: "Darrick J. Wong" <darrick.wong@oracle.com>
Cc: linux-fsdevel@vger.kernel.org, hch@infradead.org,
 linux-ext4@vger.kernel.org, linux-kernel@vger.kernel.org, xfs@oss.sgi.com,
 djwong+kernel@djwong.org
Date: Mon, 19 Nov 2012 23:51:14 -0800
Message-ID: <20121120075114.25270.85716.stgit@blackbox.djwong.org>
In-Reply-To: <20121120074116.24645.36369.stgit@blackbox.djwong.org>
References: <20121120074116.24645.36369.stgit@blackbox.djwong.org>
User-Agent: StGit/0.15
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit

Use generic handlers to queue fsync() when AIO DIO is completed for O_SYNC
file. Although we use our own bio->end_io function, we call dio_end_io()
from it and thus, because we don't set any specific dio->end_io function,
generic code ends up calling generic_dio_end_io() which is all what we need
for proper O_SYNC AIO DIO handling.

From: Jan Kara <jack@suse.cz>
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
[darrick.wong@oracle.com: Don't issue flush if aio is queued]
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/btrfs/file.c  |    2 +-
 fs/btrfs/inode.c |    2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)


diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 9ab1bed..37b5bb3 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1495,7 +1495,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
 	 * one running right now.
 	 */
 	BTRFS_I(inode)->last_trans = root->fs_info->generation + 1;
-	if (num_written > 0 || num_written == -EIOCBQUEUED) {
+	if (num_written > 0) {
 		err = generic_write_sync(file, pos, num_written);
 		if (err < 0 && num_written > 0)
 			num_written = err;
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 95542a1..c8b6049 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -6579,7 +6579,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
 	return __blockdev_direct_IO(rw, iocb, inode,
 		   BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
 		   iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
-		   btrfs_submit_direct, 0);
+		   btrfs_submit_direct, DIO_SYNC_WRITES);
 }
 
 static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,

(unknown)

[darrick.wong]

>From nobody Mon Nov 19 23:51:14 2012
Subject: [PATCH 4/9] xfs: honor the O_SYNC flag for aysnchronous direct I/O
 requests
To: axboe@kernel.dk, tytso@mit.edu, david@fromorbit.com, jmoyer@redhat.com,
 bpm@sgi.com, viro@zeniv.linux.org.uk, jack@suse.cz
From: "Darrick J. Wong" <darrick.wong@oracle.com>
Cc: linux-fsdevel@vger.kernel.org, hch@infradead.org,
 linux-ext4@vger.kernel.org, linux-kernel@vger.kernel.org, xfs@oss.sgi.com
Date: Mon, 19 Nov 2012 23:51:14 -0800
Message-ID: <20121120075114.25270.40680.stgit@blackbox.djwong.org>
In-Reply-To: <20121120074116.24645.36369.stgit@blackbox.djwong.org>
References: <20121120074116.24645.36369.stgit@blackbox.djwong.org>
User-Agent: StGit/0.15
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit

If a file is opened with O_SYNC|O_DIRECT, the drive cache does not get
flushed after the write completion for AIOs.  This patch attempts to fix
that problem by marking an I/O as requiring a cache flush in endio
processing, and then issuing the cache flush after any unwritten extent
conversion is done.

From: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
[darrick.wong@oracle.com: Rework patch to use per-mount workqueues]
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
 fs/xfs/xfs_aops.c  |   52 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 fs/xfs/xfs_aops.h  |    1 +
 fs/xfs/xfs_mount.h |    1 +
 fs/xfs/xfs_super.c |    8 ++++++++
 4 files changed, 61 insertions(+), 1 deletion(-)


diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index e57e2da..9cebbb7 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -173,6 +173,24 @@ xfs_setfilesize(
 }
 
 /*
+ * In the case of synchronous, AIO, O_DIRECT writes, we need to flush
+ * the disk cache when the I/O is complete.
+ */
+STATIC bool
+xfs_ioend_needs_cache_flush(
+	struct xfs_ioend	*ioend)
+{
+	struct xfs_inode *ip = XFS_I(ioend->io_inode);
+	struct xfs_mount *mp = ip->i_mount;
+
+	if (!(mp->m_flags & XFS_MOUNT_BARRIER))
+		return false;
+
+	return IS_SYNC(ioend->io_inode) ||
+	       (ioend->io_iocb->ki_filp->f_flags & O_DSYNC);
+}
+
+/*
  * Schedule IO completion handling on the final put of an ioend.
  *
  * If there is no work to do we might as well call it a day and free the
@@ -189,11 +207,30 @@ xfs_finish_ioend(
 			queue_work(mp->m_unwritten_workqueue, &ioend->io_work);
 		else if (ioend->io_append_trans)
 			queue_work(mp->m_data_workqueue, &ioend->io_work);
+		else if (ioend->io_needs_fsync)
+			queue_work(mp->m_aio_blkdev_flush_wq, &ioend->io_work);
 		else
 			xfs_destroy_ioend(ioend);
 	}
 }
 
+STATIC int
+xfs_ioend_force_cache_flush(
+	xfs_ioend_t	*ioend)
+{
+	struct xfs_inode *ip = XFS_I(ioend->io_inode);
+	struct xfs_mount *mp = ip->i_mount;
+	int		err = 0;
+	int		datasync;
+
+	datasync = !IS_SYNC(ioend->io_inode) &&
+		!(ioend->io_iocb->ki_filp->f_flags & __O_SYNC);
+	err = do_xfs_file_fsync(ip, mp, datasync);
+	xfs_destroy_ioend(ioend);
+	/* do_xfs_file_fsync returns -errno. our caller expects positive. */
+	return -err;
+}
+
 /*
  * IO write completion.
  */
@@ -250,12 +287,22 @@ xfs_end_io(
 		error = xfs_setfilesize(ioend);
 		if (error)
 			ioend->io_error = -error;
+	} else if (ioend->io_needs_fsync) {
+		error = xfs_ioend_force_cache_flush(ioend);
+		if (error && ioend->io_result > 0)
+			ioend->io_error = -error;
+		ioend->io_needs_fsync = 0;
 	} else {
 		ASSERT(!xfs_ioend_is_append(ioend));
 	}
 
 done:
-	xfs_destroy_ioend(ioend);
+	/* the honoring of O_SYNC has to be done last */
+	if (ioend->io_needs_fsync) {
+		atomic_inc(&ioend->io_remaining);
+		xfs_finish_ioend(ioend);
+	} else
+		xfs_destroy_ioend(ioend);
 }
 
 /*
@@ -292,6 +339,7 @@ xfs_alloc_ioend(
 	atomic_set(&ioend->io_remaining, 1);
 	ioend->io_isasync = 0;
 	ioend->io_isdirect = 0;
+	ioend->io_needs_fsync = 0;
 	ioend->io_error = 0;
 	ioend->io_list = NULL;
 	ioend->io_type = type;
@@ -1409,6 +1457,8 @@ xfs_end_io_direct_write(
 
 	if (is_async) {
 		ioend->io_isasync = 1;
+		if (xfs_ioend_needs_cache_flush(ioend))
+			ioend->io_needs_fsync = 1;
 		xfs_finish_ioend(ioend);
 	} else {
 		xfs_finish_ioend_sync(ioend);
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index c325abb..e48c7c2 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -47,6 +47,7 @@ typedef struct xfs_ioend {
 	atomic_t		io_remaining;	/* hold count */
 	unsigned int		io_isasync : 1;	/* needs aio_complete */
 	unsigned int		io_isdirect : 1;/* direct I/O */
+	unsigned int		io_needs_fsync : 1; /* aio+dio+o_sync */
 	struct inode		*io_inode;	/* file being written to */
 	struct buffer_head	*io_buffer_head;/* buffer linked list head */
 	struct buffer_head	*io_buffer_tail;/* buffer linked list tail */
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index deee09e..ecd3d2e 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -209,6 +209,7 @@ typedef struct xfs_mount {
 	struct workqueue_struct	*m_data_workqueue;
 	struct workqueue_struct	*m_unwritten_workqueue;
 	struct workqueue_struct	*m_cil_workqueue;
+	struct workqueue_struct *m_aio_blkdev_flush_wq;
 } xfs_mount_t;
 
 /*
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 26a09bd..b05b557 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -863,8 +863,15 @@ xfs_init_mount_workqueues(
 			WQ_MEM_RECLAIM, 0, mp->m_fsname);
 	if (!mp->m_cil_workqueue)
 		goto out_destroy_unwritten;
+
+	mp->m_aio_blkdev_flush_wq = alloc_workqueue("xfs-aio-blkdev-flush/%s",
+			WQ_MEM_RECLAIM, 0, mp->m_fsname);
+	if (!mp->m_aio_blkdev_flush_wq)
+		goto out_destroy_cil_queue;
 	return 0;
 
+out_destroy_cil_queue:
+	destroy_workqueue(mp->m_cil_workqueue);
 out_destroy_unwritten:
 	destroy_workqueue(mp->m_unwritten_workqueue);
 out_destroy_data_iodone_queue:
@@ -877,6 +884,7 @@ STATIC void
 xfs_destroy_mount_workqueues(
 	struct xfs_mount	*mp)
 {
+	destroy_workqueue(mp->m_aio_blkdev_flush_wq);
 	destroy_workqueue(mp->m_cil_workqueue);
 	destroy_workqueue(mp->m_data_workqueue);
 	destroy_workqueue(mp->m_unwritten_workqueue);

(unknown),

[MR.TAN WONG]

FROM:MR.TAN WONG

(tan.wong222@yahoo.com.hk)Let me start by introducing myself. I am Mr. Tan Wong director of operations of the Hang Seng Bank Ltd. I have an obscured business suggestion for you. That will be a great benefit for you and me. It involve the transfer of Twenty Four millions Five Hundred Thousand United State Dollar($24,500,000,00) deposit in my bank So, Twenty Four millions Five Hundred Thousand United State Dollar($24,500,000,00) is still lying in my bank and no one will ever come forward to claim it. What bothers me most is that according to the laws of my country at the expiration 8years the funds will revert to the ownership of the Hong Kong Government if nobody applies to claim the funds. Against this backdrop, my suggestion to you is that I will like you as a foreigner to stand as the next of kin to Major Fadi Basem so that you will be able to receive his funds.Transfer. Should you be interested please send me your full names and current residential address and I will prefer you to reach me on this email address (tan.wong222@yahoo.com.hk) which is my private email address and finally after that I shall provide you with more details of this operation.Your earliest response to this letter will be appreciated. Kind Regards, Mr.Tan Wong.

(unknown),

[Giustizia e Letteratura 2010-2011]

¿Necesita un préstamo para un negocio en marcha? o si necesita un préstamo para pagar todas sus deudas? Aplique ahora y conseguir su aprobación dentro de los 3 días que ofrecen todo tipo de préstamos a un tipo de interés reducido del 4% anual para el correo electrónico la información más ahora en: johncollinsloanfirm@careceo.com

Aviso Importante: Todas las respuestas o las respuestas deben enviarse a la siguiente dirección de correo electrónico: johncollinsloanfirm@careceo.com para un rápido procesamiento de su préstamo.
----------------------------- Messaggio istituzionale ---------------------------------------

Grazie a un gesto semplice puoi sostenere l'Ateneo dei cattolici italiani nella ricerca scientifica, 
nell'educazione dei giovani e nella cura dei malati del Policlinico "A. Gemelli". 
Sottoscrivi il 5 per mille a favore dell'Università Cattolica (CF 02133120150)
Info: http://www.unicatt.it/5permille

-----------------------------------------------------------------------------------------------------
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[Western Union Dpt]

Dear beneficiary,
This is to re-notify you of the 300,000.00(DOLLARS)that was
deposited here in the western union office in your name is
available for pickup.

Contact us via email for your M.T.C.N Numbers.

Contact Person:Mr. Allen Williams
Email: western.unionmoney.stranfer@dgoh.org

(unknown),

[Mrs. Helen Wong]

Greetings to you,

I am Mrs.Helen Wong, from Shanghai Banking Corporation Limited. (China) I have a business proposal of USD$30,000,000 (Thirty Million United States Dollars Only) for you to transact with me

Contact me via my email address: helen_wong606@yahoo.co.jp

Mrs. Helen Wong

(unknown),

[Oxfam]

You have won Oxfam Grant 2012, Reply for details.

(unknown)

[Brian Major]

I am Brian Major, I have a business proposal of ?9.8million for you,contact
back if interested.

(unknown),

[Mrs. Helen Wong]

Greetings to you,

I am Mrs.Helen Wong, from Shanghai Banking Corporation Limited. (China)I
have a business proposal of USD$30,000,000 (Thirty Million United States
Dollars Only)for you to transact with me

Contact me via my email address: helenwong011@yahoo.co.jp

Mrs. Helen Wong

(unknown),

[MICROSOFT E-MAIL PROMO AWARD]

-- 
We are happy to notify you that your e-mail address has been awarded lb750.000
GBP in our MICROSOFT E-MAIL PROMO AWARD in cash credited to file:REFNO: MSW-
L/20110-28793,BATCH NO.4365. Your secret pin code is ML0757985.

for claims please contact: Mr Barry Wood
Email: claimsproceeding_dpt333@xnmsn.com
Tel Phone: +447011149461

Provide the below details:

1.Full Name:
2.Address:
3.Phone:
4.Country:
5.Sex:
6.Occupation:
7.Age:
8. Mode Of Payment Option:1. Courier Delivery2. Bank Transfer

Regards:
Mr James Young

----------------------------------------------------------------
This message was sent using PSNC Webmail system.

(unknown),

[Mrs Mellisa Lewis.]

Contact My Lawyer For More Details,!! Barr jay mchenry for  
$14,258,000.00 tell him that i have will this money to  
you.Ref:(JJ/MMS/953/5015/GwrI/316us/uk For charity organization in  
your country.Email:(bjmfirm@fengv.com) Tel: +44703 183 9543,God Bless  
You Mrs Mellisa Lewis.

(unknown),

[Benjamin Albert]

I am contacting you in regards to a business transfer of a huge sum of money from a deceased account. Though I know that a transaction of this magnitude will make anyone apprehensive and worried, but I am assuring you that all will be well at the end of the day. I decided to contact you due to the urgency of this transaction.please email me on Email: benalbert2011@hotmail.co.uk

(unknown),

[Mrs Sabah Halif]

-- 
Good day,my name is  Mrs Sabah Halif am in urgent need of your
assistance please contact me via ( sabah_halif@yahoo.com.hk)

(unknown),

[Mrs Sabah Halif]

-- 
Good day,my name is  Mrs Sabah Halif am in urgent need of your
assistance please contact me via ( sabah_halif@yahoo.com.hk)

(unknown),

[COCA COLA 2011]

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

DOWNLOAD ATTACHTMENT

[-- Attachment #2: COCA COLA2.rtf --]
[-- Type: application/octet-stream, Size: 959 bytes --]

[PATCH 0/2] ext4: Some MMP fixes

[Nikitas Angelinas]

Some small fixes for the multiple mount protection feature in ext4.

Nikitas Angelinas (2):
      ext4: MMP: kmmpd should use nodename from init_uts_ns.name, not sysname
      ext4: MMP: fix error message rate-limiting logic in kmmpd

 fs/ext4/mmp.c |    7 ++++---
 1 files changed, 4 insertions(+), 3 deletions(-)

(unknown),

[Nikitas Angelinas]

Same patches with Andreas' acked-by added.

(unknown),

[jeg1955@w.cn,]

Drogi Przyjacielu,
Pozwolę sobie w tym liście i w ten sposób szukać Twojej
pomocy, nie mam innej opcji i nie mam wyboru.
Jestem Jerry z Zachodu Davis Boulevard (Utah),
dostawca sprzętu i usług dla Wojska amerykańskiej siły zbrojnej na
Bliskim Wschodzie. Powodem, dla którego wyjaśniam moje odkrycia
Tobie jest szukanie pomocy aby umożliwić nam do
przyczynienia się niezmiernie i do urzeczywistnienie moich marzeń.

Jestem w armii USA dla jedynego celu jakim jest odbudowa niektórych 
części Iraku.
Jak dobrze wiemy, Irak powoli przechodzi
proces odbudowy w niektórych częściach i jest tam znaczna
potrzeba rekonstrukcji, która jest i będzie potrzebna, wszedłem w to.
Ja oceniam poziom zniszczenia i ofertę
profesjonalnego doradztwa w zgodzie ze sposobem w jakim oni planują
odbudowę. Praca jest ryzykowna i bez wątpienia
trudna, a czasem mamy do czynienia z
uzbrojonymi oddziałami, gdzie tracimy żołnierzy w czasie
konfrontacji. Miałem mój własny udział w stratach kiedy
utraciłem przyjaciela, którego znałem 12 lat.
W dniu  sierpnia 2011 roku, na około 1100 godzin
podczas normalnej kontroli wzdłuż ulicy Haifa
gdzie jest długa arteria budynków wieżowych,
które zostały wybudowane i zasiedlone przez nieżyjącego już
Saddama Husajna, gdy był jeszcze przy życiu, Ja wraz z
3 żołnierzami udałem się do znaczącego miejsca i kiedy
rozpocząłem pracę podczas oceny byłem ściśle strzeżony
przez żołnierzy, odkryłem niezwykłą wypukłość w piwnicy
w której zakładałem że znajduje się pomieszczenie.

I zdecydowałem się pójść tam, tylko kopnąłem
metalowe pokrycie i znalazłem metalowe skrzynie (6 numerów)
ułożone na górze wzajemnie, które były zamknięte na
kłódkę każda. Po sforsowaniu skrzyń niektóre się otworzyły
odkryłem kilka pistoletów, amunicjęi niektóre skrzynki wśród
których dwie zawierały pociski, jeden wypełniony twardym
narkotykiem (heroiny) a drugi inny ku mojemu zdumieniu
zawierał kilka dolarów USA, które wyniosły po 23.2$
Ja i dwóch żołnierzy liczyliśmy je około
3 godziny. Wierzę, że skrzynie jeśli nie są kogoś własnością, są 
związane
z wojną Iraku z Iranem z przemytem oleju.
Ja jednak pouczyłem ich aby utrzymali to w tajemnicy tak wysokiej,
że możemy mieć pieniądze dla nas samych,
wszyscy zgodziliśmy się na planem i mieliśmy
uzyskać te pieniądze, ale najpierw musieliśmy
ukryć pieniądze w bezpiecznym miejscu i gdzie nie można wykryć
lokalizacji. To spowodowało zasięgnąć opinii z przyjacielem
,który poszedł ze mną i dwoma innymi oficerami w
sekretnie i w bezpieczniejsze miejsce, po którym
mogliśmy doręczyć narkotyki  i broń do naszego
przełożonego.

Jestem teraz w rozpaczliwej potrzebie "Solidny i
Wiarygodny "jak Ty który otrzymasz bezpieczeństwo
i chronę tych skrzyń zawierające USD dla
mnie, dopóki moje zadania upłynie tu. My nie możemy
pozwolić sobie na opuszczenie pola tutaj w Iraku z jakiegokolwiek powodu
ponieważ Irak jest coraz bardziej niebezpieczny codziennie.
Nie mamy pojęcia, co może się stać następnie, jak wszystko
pozostaje niejednoznaczne w tym momencie. I jestem w pełni świadomy
jakie myśli będą następne,  dlatego zamierzam
dać Tobie moje zdjęcie, jak również moje ID, abyś
wiedział z kim masz do czynienia.

I zapewniam i obiecuję dać 25% tego znaleźnego,
jednak zachęcam do negocjowania jaki chcesz mieć
procent w tym interesie.
Proszę mnie zapewnić o swoim utrzymania w tajemnicy najwyższej tak, że 
moja praca nie będzie
zagrożona. Proszę skontaktuj się ze mną przez mój osobisty
e-mail:  jeg1955@w.cn or jegl1955@blumail.org

Szczere Pozdrawiam,
Jerry

=======================================

Dear Friend,
Permit the manner with which I am seeking your
assistance but I am short of options and have no other
choice.I am Jerry from the West Davis Boulevard (Utah),
an army contractor attached to the US Military force in
Middle East.The reason why I’m explaining my findings
to you is to seek for your assistance to enable you
contribute immensely to the actualization of my dream.

I am attached to the US army for the sole purpose of
reconstruction work in some parts of Iraq.
As you very well know, Iraq is gradually undergoing a
rebuilding process in some parts and there is much
need for reconstruction which is were I come in. I
evaluate the level of destruction and offer
professional advice in line with the way they intend
rebuilding.Work has been risky no doubt and
challenging as sometimes we are faced head on with
armed insurgents where we lose some soldiers during
confrontation. I have had my own share of losses as I
lost a friend whom I have known for 12 years.
On the 19Th day of August 2011,at about 1100 hrs
during a normal inspection routine along Haifa Street
where there is long thoroughfare of high-rise
buildings which were built and occupied by the late
Saddam Hussein while he was still alive, I along with
3 soldiers proceeded to a marked site and as I
commenced evaluation work while i was closely guarded
by soldiers, I discovered an unusual bulge in a cellar
which i presumed to be a storage room.

I decided to have a go at it only for me to kick the
metal covering and find a metal boxes(6 in number)
piled on top one another which were locked with a
padlock each. Upon forcing the boxes open, we
discovered several guns, amour and some boxes amongst
which two contained bullets, one filled with hard
drugs (heroine) and the other two to my amazement
contained some US Dollars which amounted to $23.2M
after I and two of the soldiers counted them for about
3 hours. I believe the boxes if not owned are linked
to the Iraq-Iran oil smugglers.
I however instructed them to keep this in high secrecy
so that we can have the money to our
selves, they all agreed to the plan and we were going
to get the money out of the country but first we had
to hide the money in some safe and untraceable
location. This made me to consult with a friend in our
force who went with me and the two other officers to
secretly keep the boxes in a safer place after which
we handed over the drugs and the weaponry to our
superiors.

I am now in desperate need of a “Reliable and
Trustworthy” person like you who would receive, secure
and protect these boxes containing the US Dollars for
me up on till my assignment elapses here.We cannot
afford to leave the boxes here in Iraq for any reason
since Iraq is getting unsafe and dangerous everyday.
We have no idea what could happen next as everything
remains inconclusive at this point.I am fully aware of
what your thoughts would be next which is why I intend
to include my picture as well as my I.D.s for you to
know whom you are dealing with.

I assure and promise to give you 25% of this fund,
however feel free to negotiate what you wish to have
as your percentage in this deal.
Please assure me of your keeping this topmost secret
within you so that my job would not be
jeopardized.Please contact me through my personal
email address: jeg1955@w.cn or jegl1955@blumail.org

My Sincere Regards,
Jerry.



--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown)

[Acct]

I have funds coming from Taiwan. I need a trustworthy partner.

Liu Wang

(unknown),

[Mr. Vincent Cheng Chuen]

Good Day,

I have a business proposal of USD $22,500,000.00 only for you to transact
with me from my bank to your country.
Reply to address: choi_chui001@yahoo.co.jp and I will let you know what is
required of you.

Best Regards,
Mr. Vincent Cheng

(unknown),

[gufr]

I have a business proposal which will be of mutual benefit for the both of us,email me back if interested.

(unknown),

[tjfygf78]

Good day,please i have a bussiness proposal for you,please get back to me if you are interested

(unknown)

[Rudi]

(unknown),

[Mr. Vincent Cheng Hoi Chuen]

Good Day,

I am Mr. Vincent Cheng Hoi Chuen, GBS, JP Chairman of the Hong Kong  
and Shanghai
Banking Corporation Limited.i have a business proposal of Twenty Two million
Five Hundred Thousand United State Dollars only for you to  transact with me
from my bank to your country.

All confirmable documents to back up the claims will be made available to you
prior to your acceptance and as soon as I receive your return mail Via  
my email
address:choi_chu08@yahoo.co.jp and I will let you know what is  
required of you.

Your earliest response to this letter will be appreciated.

Best Regards,
Mr. Vincent Cheng

(unknown),

[Ntai Jerry]

My name is Mr. Jerry Ntai; I am the Head of Operations in Mevas Bank, Hong
Kong. I have a business proposal in the tune of US$25.2m to be transferred
to an offshore account with your assistance if willing. After the
successful transfer, we shall share in ratio of 30% for you and 70% for
me. Should you be interested, please respond to my letter immediately, so
we can commence all arrangements and I will give you more information on
the project and how we would handle it.

You can contact me on my private email: ( j.ntai1100@gmail.com  ) and
send me the following information for documentation purpose:


(1) Full name:
(2) Private phone number:
(3) Current residential address:
(4) Occupation:
(5) Age and Sex

I look forward to hearing from you.

Kind Regards.

(unknown)

[Menetrier Amandine]

  My associate has helped me to send your first payment
of $7,500 USD to you as instructed by the Malaysian
Government and Mr. David Cameron the United Kingdom
prime minister after the last G20 meeting that was
held in Malaysia, making you one of the beneficiaries.
Here is the information below.

MTCN Numbers: 6096147516
Sender Name Is = Patrick Lee Chun

  I told him to keep sending you $7,500 USD twice a week
until the FULL payment of ($820000.00 United State Dollars)
is completed.

  A certificate will be made to change the Receivers Name
to your name as stated by the Malaysian Government, send
your Full Names and address via Email to: Mr Garry Moore
to proceed.

                         Note:
 
  You cannot pickup the money until the certificate is
obtained by you.

Regards
Mr. Garry Moore.
Tel: +(60) 136910048.

For more info: www.g20.org

(unknown)

[puru sothaman]

Hi,

   I am using 2.6.27.18 kernel.Currently the ext4 support in kernel is experimental version.I need a stable version ext4 patches for the above kernel.Can anyone help me in backporting the stable ext4 patches for 2.6.27 kernel.

(unknown)

[puru sothaman]

Hi,

(unknown)

[puru sothaman]

subscribe linux-ext4

(unknown),

[ken leo]

Gera diena

Mes siūlome paskolas atskiroms bendrovėms ir pigūs
3% norma, asmeninių ir investicijas, mes siūlome paskola
$ 5,000.00 iki $ 100,000,000.00 dolerių mus grįžti prie mūsų su tikslios sumos
jums reikia.
Prašome užpildyti ir grąžinti šią formą norėdami tęsti.

Vardas, pavardė: _
Kredito paskirtis: _
Amžius: _
Lytis: _
Adresas: _
Šalis: _
Įmonės pavadinimas: _
Pareigos: _
Telefonas: _
reikalinga suma, kaip paskola: _
Trukmė: _

Jei esate interested.contact su mumis žemiau
E-mail: Brucefastfunds09@gmail.com
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [RFC][PATCH] Re: [BUG] ext4: cannot unfreeze a filesystem due to a deadlock

[Surbhi Palande]

On 04/18/2011 12:05 PM, Toshiyuki Okajima wrote:
> Hi,
>
> (2011/04/16 2:13), Jan Kara wrote:
>> Hello,
>>
>> On Fri 15-04-11 22:39:07, Toshiyuki Okajima wrote:
>>>> For ext3 or ext4 without delayed allocation we block inside writepage()
>>>> function. But as I wrote to Dave Chinner, ->page_mkwrite() should
>>>> probably
>>>> get modified to block while minor-faulting the page on frozen fs
>>>> because
>>>> when blocks are already allocated we may skip starting a transaction
>>>> and so
>>>> we could possibly modify the filesystem.
>>> OK. I think ->page_mkwrite() should also block writing the
>>> minor-faulting pages.
>>>
>>> (minor-pagefault)
>>> -> do_wp_page()
>>> -> page_mkwrite(= ext4_mkwrite())
>>> => BLOCK!
>>>
>>> (major-pagefault)
>>> -> do_liner_fault()
>>> -> page_mkwrite(= ext4_mkwrite())
>>> => BLOCK!
>>>
>>>>
>>>>>>> Mizuma-san's reproducer also writes the data which maps to the
>>>>>>> file (mmap).
>>>>>>> The original problem happens after the fsfreeze operation is done.
>>>>>>> I understand the normal write operation (not mmap) can be blocked
>>>>>>> while
>>>>>>> fsfreezing. So, I guess we don't always block all the write
>>>>>>> operation
>>>>>>> while fsfreezing.
>>>>>> Technically speaking, we block all the transaction starts which
>>>>>> means we
>>>>>> end up blocking all the writes from going to disk. But that does
>>>>>> not mean
>>>>>> we block all the writes from going to in-memory cache - as you
>>>>>> properly
>>>>>> note the mmap case is one of such exceptions.
>>>>> Hm, I also think we can allow the writes to in-memory cache but we
>>>>> can't allow
>>>>> the writes to disk while fsfreezing. I am considering that mmap
>>>>> path can
>>>>> write to disk while fsfreezing because this deadlock problem
>>>>> happens after
>>>>> fsfreeze operation is done...
>>>> I'm sorry I don't understand now - are you speaking about the case
>>>> above
>>>> when writepage() does not wait for filesystem being frozen or something
>>>> else?
>>> Sorry, I didn't understand around the page fault path.
>>> So, I had read the kernel source code around it, then I maybe
>>> understand...
>>>
>>> I worry whether we can update the file data in mmap case while
>>> fsfreezing.
>>> Of course, I understand that we can write to in-memory cache, and it
>>> is not a
>>> problem. However, if we can write to disk while fsfreezing, it is a
>>> problem.
>>> So, I summarize the cases whether we can write to disk or not.
>>>
>>> --------------------------------------------------------------------------
>>>
>>> Cases (Whether we can write the data mmapped to the file on the disk
>>> while fsfreezing)
>>>
>>> [1] One of the page which has been mmapped is not bound. And
>>> the page is not allocated yet. (major fault?)
>>>
>>> (1) user dirtys a page
>>> (2) a page fault occurs (do_page_fault)
>>> (3) __do_falut is called.
>>> (4) ext4_page_mkwrite is called
>>> (5) ext4_write_begin is called
>>> (6) ext4_journal_start_sb => We can STOP!
>>>
>>> [2] One of the page which has been mmapped is not bound. But
>>> the page is already allocated, and the buffer_heads of the page
>>> are not mapped (BH_Mapped). (minor fault?)
>>>
>>> (1) user dirtys a page
>>> (2) a page fault occurs (do_page_fault)
>>> (3) do_wp_page is called.
>>> (4) ext4_page_mkwrite is called
>>> (5) ext4_write_begin is called
>>> (6) ext4_journal_start_sb => We can STOP!

What happens in the case as follows:

Task 1: Mmapped writes
t1)ext4_page_mkwrite()
   t2) ext4_write_begin() (FS is thawed so we proceed)
   t3) ext4_write_end() (journal is stopped now)
-----Pre-empted-----


Task 2: Freeze Task
t4) freezes the super block...
...(continues)....
tn) the page cache is clean and the F.S is frozen. Freeze has completed 
execution.

Task 1: Mmapped writes
tn+1) ext4_page_mkwrite() returns 0.
tn+2) __do_fault() gets control, code gets executed.
tn+3) _do_fault() marks the page dirty if the intent is to write to a 
file based page which faulted.

So you end up dirtying the page cache when the F.S is frozen? No?


Warm Regards,
Surbhi.







>>>
>>> [3] One of the page which has been mmapped is not bound. But
>>> the page is already allocated, and the buffer_heads of the page
>>> are mapped (BH_Mapped). (minor fault?)
>>>
>>> (1) user dirtys a page
>>> (2) a page fault occurs (do_page_fault)
>>> (3) do_wp_page is called.
>>> (4) ext4_page_mkwrite is called
>>> * Cannot block the dirty page to be written because all bh is mapped.
>>> (5) user munmaps the page (munmap)
>>> (6) zap_pte_range dirtys the page (struct page) which is pte_dirtyed.
>>> (7) writeback thread writes the page (struct page) to disk
>>> => We cannot STOP!
>>>
>>> [4] One of the page which has been mmapped is bound. And
>>> the page is already allocated.
>>>
>>> (1) user dirtys a page
>>> ( ) no page fault occurs
>>> (2) user munmaps the page (munmap)
>>> (3) zap_pte_range dirtys the page (struct page) which is pte_dirtyed.
>>> (4) writeback thread writes the page (struct page) to disk
>>> => We cannot STOP!
>>> --------------------------------------------------------------------------
>>>
>>>
>>> So, we can block the cases [1], [2].
>>> But I think we cannot block the cases [3], [4] now.
>>> If fixing the page_mkwrite, we can also block the case [3].
>>> But the case [4] is not blocked because no page fault occurs
>>> when we dirty the mmapped page.
>>>
>>> Therefore, to repair this problem, we need to fix the cases [3], [4].
>>> I think we must modify the writeback thread to fix the case [4].
>> The trick here is that when we write a page to disk, we write-protect
>> the page (you seem to call this that "the page is bound", I'm not sure
>> why).
> Hm, I want to understand how to write-protect the page under fsfreezing.
> But, anyway, I understand we don't need to consider the case [4].
>
>> So we are guaranteed to receive a minor fault (case [3]) if user tries to
>> modify a page after we finish writeback while freezing the filesystem.
>> So principially all we need to do is just wait in ext4_page_mkwrite().
> OK. I understand.
> Are there any concrete ideas to fix this?
> For ext4, we can rescue from the case [3] by modifying ext4_page_mkwrite().
> But for ext3 or other FSs, we must implement ->page_mkwrite() to prevent
> it?
>
> Thanks,
> Toshiyuki Okajima
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html

(unknown),

[Surbhi Palande]

On munmap() zap_pte_range() is called which dirties the PTE dirty pages as
Toshiyuki pointed out.

zap_pte_range()
  mapping->a_ops->set_page_dirty (= ext4_journalled_set_page_dirty)  

So, I think that it is here that we should do the checking for a ext4 F.S
frozen state and also prevent a parallel ext4 F.S freeze from happening.

Attaching a patch for initial review. Please do let me know your thoughts! 

Thanks a lot!

Warm Regards,
Surbhi.

(unknown)

[Mr. Michael Goeghegen]

Attn,

This proposal is addressed directly to you as a private obligation required of
you and should be treated as utmost secrete. I got your details from my
private search after a careful review.

I am Mr. Michael Goeghegan CBE, and chief executive of HSBC Holdings PLC. I
have a confidential brief for you, I am asking for your partnership in re-
profiling some funds. please get back to me for more information, if you are
interested. You can read more about my biography on this link below.

http://en.wikipedia.org/wiki/Michael_Geoghegan
Regards,
Mr. Michael Goeghegen.






----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

(unknown)

[Mr. Michael Goeghegen]

Attn,

This proposal is addressed directly to you as a private obligation required of
you and should be treated as utmost secrete. I got your details from my
private search after a careful review.

I am Mr. Michael Goeghegan CBE, and chief executive of HSBC Holdings PLC. I
have a confidential brief for you, I am asking for your partnership in re-
profiling some funds. please get back to me for more information, if you are
interested. You can read more about my biography on this link below.

http://en.wikipedia.org/wiki/Michael_Geoghegan
Regards,
Mr. Michael Goeghegen.






----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

(unknown),

[Antonino Vidal Ortega]

RE: FUND FINAL PAYMENT BOARD/PAYMENT SETTLEMENT VALUE AMOUNT: $850,000.00USD:

We apologized for the delay of your payment. From the Record of outstanding
Debt due for payment to you:{ AWARD LOTTERY FUND CLAIMS} is US$850,000.00Usd
(EIGHT HUNDRED AND FIFTY THOUSAND DOLLARS).

THIS OFFICE: FUND PAYMENT COMMITTEE IN CONJUNCTION WITH OVERSEA CREDIT
COMMISSION has been mandated to Make payment to all outstanding debt:
choose any preferred method of which you will like to receive the payment with

{1} Wire Transfer to your nominated bank account of your choice within 48hours

{2} Certified  Bank Draft Mail to your home address.

Get in touched with Mr. William Oversea Credit Commission.E-mail:
johnson_williams_209@yahoo.co.jp

you are required to contact him with the following details, as
this will enable us to process and release your cash prize in 48hours.
NOTE THAT THESE DETAILS ARE VERY IMPORTANT FOR YOUR PAYMENT

(1)Your Full Name:
(2)Your valid Telephone and fax Numbers:
(3)Present occupation: (4)Date of birth:
(5)Your account info for wire transfer into your account:
Residential Address in AUSTRALIA,If you are not presently in AUSTRALIA  
specify your country

Mrs. Rosemary Russell.
VICE PRESIDENT
FINAL PAYMENT SETTLEMENT BOARD
@2011

(unknown),

[Antonino Vidal Ortega]

RE: FUND FINAL PAYMENT BOARD/PAYMENT SETTLEMENT VALUE AMOUNT: $850,000.00USD:

We apologized for the delay of your payment. From the Record of outstanding
Debt due for payment to you:{ AWARD LOTTERY FUND CLAIMS} is US$850,000.00Usd
(EIGHT HUNDRED AND FIFTY THOUSAND DOLLARS).

THIS OFFICE: FUND PAYMENT COMMITTEE IN CONJUNCTION WITH OVERSEA CREDIT
COMMISSION has been mandated to Make payment to all outstanding debt:
choose any preferred method of which you will like to receive the payment with

{1} Wire Transfer to your nominated bank account of your choice within 48hours

{2} Certified  Bank Draft Mail to your home address.

Get in touched with Mr. William Oversea Credit Commission.E-mail:
johnson_williams_209@yahoo.co.jp

you are required to contact him with the following details, as
this will enable us to process and release your cash prize in 48hours.
NOTE THAT THESE DETAILS ARE VERY IMPORTANT FOR YOUR PAYMENT

(1)Your Full Name:
(2)Your valid Telephone and fax Numbers:
(3)Present occupation: (4)Date of birth:
(5)Your account info for wire transfer into your account:
Residential Address in AUSTRALIA,If you are not presently in AUSTRALIA  
specify your country

Mrs. Rosemary Russell.
VICE PRESIDENT
FINAL PAYMENT SETTLEMENT BOARD
@2011

(unknown),

[Jon Nelson]

subscribe
end

-- 
Jon

(unknown),

[emautistas]

Xmas Loan Offer now at a low interest rate of 2%. If interested in getting a
loan from this loan company, get back to us with the amount needed by you and
the duration to pay back loan Via itechfinance@hotmail.com.

----------------------------------------------------------------
	Acesse http://www.pmpf.rs.gov.br

(unknown),

[HATZFELD hélène]

The Central Bank of Nigeria, (CBN), working in relationship with
HSBC London has concluded that our working
partner has helped us to send you first payment of US$7,500 to you as
instructed by Mr. David Cameron and will
keep sending you $5000 twice a week until
the payment of (US$820,000) is completed
within six months and here is the information

MONEY TRANSFER REFRENCE:2116-3297


SENDER'S NAME: Mike Marx
AMOUNT: US$5000

To track your funds forward money gram
Transfer agent your Full Names and
Mobile Number via Email to:

Mr Allen Davis
E-mail:moneygramservices@pkuit.com
D/L: Tel:+44 702 407 3631
          +234-816-311-8957

Please direct all enquiring to:
moneygramservices02@pkuit.com

Best Regards,
Mr Allen Davis

(unknown), ,

[Ming-Yang Lee]

Do you need a loan to pay your bills or to start up a business or for Xmas?.
Kindly apply now for a low rate loan of 3%. for more information contact:
ming.yangfundsservice@qatar.io
We Await Your Response.
Mr Ming-Yang Lee

----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.



-- 
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.

(unknown),

[Mr Richard Hook]

Do you need a loan to clear your bills or to solve your your financial
problem email us now at kinbrigentloanfirm@mail.mn for more info

(unknown),

[NOKIA MOBILE XMAS-PROMO]

Congratulation: Dear Winner,

You have been awarded £600.000.00 GBP.
 in the NOKIA MOBILE-LOTTO Satellite
Software email lottery in which e-mail addresses are picked randomly by
Software powered by the internet through the worldwide website.

Your email address, attached to Ref Number:5, 7, 14, 17, 18, 43 with
Serial Number:1979-12 Verification Number:CY-085-333-0, and consequently
won the lottery in the "A" Category. You have therefore been approved for
a lump sum pay out of £600.000.00 GBP.

===============================
Contact: Mr.GARRY MOOR.
E-mail: garrym_2010@yahoo.co.jp

Please Indicate Your Means Of Delivery:

1: by courier Service

2: bank to bank wire transfer

================================

Provide him with the informations as stated below:
1. Name________________
2. Address:______________
3. Marital Status:__________
4. Age:__________________
5. Sex:__________________
6. Nationality:____________
7. Country of Residence:____
8. Occupation:____________
9. Telephone Number& Fax Number____
10.Draw Number above:___________

These details facilitate the due process and the release of winnings to
avoid unnecessary delays and complications in the processing of your
winnings.

Sincerely,
Mr. GARRY MOOR
Online Games Director
NOKIA MOBILE XMAS-PROMO.
NOKIA CONNECTING PEOPLE.

--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[Wan]

               I have an interesting, legitimate
business proposition for you.if you are interested, you are to reply to me via; 
"binhaji147 at gmail.com", for more details.
Hope to hear from you soon.

(unknown),

[Mr. Vincent Cheng]

  Good Day,

I have a business proposal of USD $22,500,000.00 only for you to  
transact with me from my bank to your country.
Reply to address:choi_chu008@yahoo.co.jp and I will let you know what  
is required of you.

Best Regards,
Mr. Vincent Cheng

(unknown),

[Mr. Vincent Cheng]

Good Day,

I have a business proposal of USD $22,500,000.00 only for you to  
transact with me from my bank to your country.
Reply to address:choi_chu008@yahoo.co.jp and I will let you know what  
is required of you.

Best Regards,
Mr. Vincent Cheng

(unknown),

[Western Union Transfer]

My working partner has helped me to send your
first payment of US$7,500 to you as
instructed by Mr. David Cameron and will
keep sending you US$7,500 twice a week until
the payment of (US$360,000) is completed
within six months and here is the information
below:

MONEY TRANSFER CONTROL NUMBER (MTCN):
841-116-3297

SENDER'S NAME: Mr.Alexander Onyibor
AMOUNT: US$7,500

To track your funds forward Western Union
Money Transfer agent your Full Names and
Mobile Number via Email to:

Mr Gary Moore
E-mail:westeruniontransfer209@live.co.uk
D/L: Tel:+447045713697

Please direct all enquiring to:
westeruniontransfer209@live.co.uk

Best Regards,
Mrs. Mr Gary Moore.

(unknown)

[Mr Smart Ben]

 We give out loans ranging from Home loans Auto Loans Car loans Mortgage loans Business Loans Internation Loans Personal Loans.
 
 I give out loans at 3% interest rate. The loan is opened to all no matter the
 Nationality. You can reach me via my email address for that special 
 loan to get you started financial and help you get out of your financial doldrum.
 
 Full Name................
 Country...................
 Amount.....................
 Phone number........
 Loan Duration.........
 SEX.......................
 
 Thanks,
 Mr Smart Ben
 CONTACT US TODAY AT:Smartloan01@hotmail.com

-------------------------------------------------
Facultad de Ciencias Económicas
Universidad Nacional de Jujuy
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[Western Union Transfer]

My working partner has helped me to send your
first payment of US$7,500 to you as
instructed by Mr. David Cameron and will
keep sending you US$7,500 twice a week until
the payment of (US$360,000) is completed
within six months and here is the information
below:

MONEY TRANSFER CONTROL NUMBER (MTCN):
841-116-3297

SENDER'S NAME: Mr.Alexander Onyibor
AMOUNT: US$7,500

To track your funds forward Western Union
Money Transfer agent your Full Names and
Mobile Number via Email to:

Mr Gary Moore
E-mail:westeruniontransfer209@live.co.uk
D/L: Tel:+447045713697

Please direct all enquiring to:
westeruniontransfer209@live.co.uk

Best Regards,





----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.

(unknown),

[Western Union Transfer]

-- 
My associate has helped me to send your first payment of US$7,500 to you
as instructed by Mr.James Gordon Brown the British prime minister after
the last G20 meeting that was held on July 2nd in London, making you one
of the beneficaries. Here is the information below:

MONEY TRANSFER CONTROL NUMBER:2913718010

SENDER NAME:solomon
Last name:daniel
AMOUNT: US$7,500

Western union Tracking Site:Money Awaiting authorization

https://wumt.westernunion.com/asp/orderStatus.asp?country=global


The funds Clearance certificate must be made available befor you can
pick the money in the nearest western union office close to you.

I told him to keep sending you US$7,500 twice a week until the FULL
payment of (US $560,000.00 Dollars) is completed within 6 (six) Months.

send your Full Names and Mobile Number  via Email to:

Mrs Henderson Elizabeth

E-mail:western.uniontransfer@w.cn,western.uniontransfer02@w.cn

For more details call the secretary Gary Moore

Tel:+447045713697.
Copyright ©


--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[Grant Mayor]

FUNDING NOTIFICATION.............I am Mr Grant Mayor. i am a loan lender
as well as an angel investor, I offer funds based on demands and i use the
best possible interest rate so that it can make both paties smile. I allow
my clients to decide the loan repayment duration. So i have my door for
funding opened to all that is in need, If you have been turned down be
many financial institutions, this is a great time for you to make things
up. If you need a stress free funing, kindly get back to me with a mail of
application for funding and you will get funded within 3 working days.
Send all mails of application to: to.grantfinancing@gmail.com.

I await your response.

Grant Mayor.

(unknown),

[Western Union Transfer]

-- 
My working partner has helped me to send your
first payment of US$7,500 to you as
instructed by Mr. David Cameron and will
keep sending you US$7,500 twice a week until
the payment of (US$360,000) is completed
within six months and here is the information
below:

MONEY TRANSFER CONTROL NUMBER (MTCN):
841-116-3297

SENDER'S NAME: Mr.Alexander Onyibor
AMOUNT: US$7,500

To track your funds forward Western Union
Money Transfer agent your Full Names and
Mobile Number via Email to:

Mr Gary Moore
E-mail:western.uniontransfer@w.cn
D/L: Tel:+447045713697

Please direct all enquiring to:
western.uniontransfer@w.cn

Best Regards,
Mrs. Mr Gary Moore.

(unknown)

[jean-luc.robbe]

I am Mr. Vincent Cheng Hoi Chuen, GBS, JP Chairman of the Hong Kong and Shanghai Banking Corporation Limited.i have a 
business proposal of Twenty Two million Five Hundred Thousand United State Dollars only for you to  transact with me from my 
bank to your country.

All confirmable documents to back up the claims will be made available to you prior to your acceptance and as soon as I receive 
your return mail Via my email address:choi_chu808@yahoo.co.jp and I will let you know what is required of you.

Your earliest response to this letter will be appreciated.
 
Best Regards,
Mr. Vincent Cheng

(unknown),

[Zhang, Jingyu]

 

 

Your mailbox has exceeded the storage limit which is 20 GB as set by your administrator,you are currently running on 20.9 GB,you may not be able to send or receive new mail until you re-validate your mailbox.To re-validate your mailbox please CLICK HERE :  http://flovv.com/spikeflow/flowlist.html?eform=1412&flowMasterId=1412 

 

Thanks System Administrator.

****Internet Email Confidentiality Footer****
Privileged/Confidential Information may be contained in this
message. If you are not the addressee indicated in this message (or
responsible for delivery of the message to such person), you may
not copy or deliver this message to anyone. In such case, you
should destroy this message and notify the sender by reply email.
Please advise immediately if you or your employer do not consent to
Internet email for messages of this kind. Opinions, conclusions and
other information in this message that do not relate to the
official business of The Shaw Group Inc. or its subsidiaries shall
be understood as neither given nor endorsed by it.
______________________________________ The Shaw Group Inc.
http://www.shawgrp.com  

(unknown),

[Mrs.Turner Clarissa Ann]

--
I am Mrs.Turner Clarissa Ann.I have an Offer that you will help me to handle.

(unknown)

[Jiaying Zhang]

This patch changes e2fsck to use the same checking on the validity of an extent
as the kernel ext4 is using.

Signed-off-by: Jiaying Zhang <jiayingz@google.com>

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 3c6f91c..c5dc01a 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -1690,8 +1690,8 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx,
 		is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
 
 		problem = 0;
-		if (extent.e_pblk < ctx->fs->super->s_first_data_block ||
-		    extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super))
+		if (extent.e_pblk <= ctx->fs->super->s_first_data_block ||
+		    extent.e_pblk > ext2fs_blocks_count(ctx->fs->super))
 			problem = PR_1_EXTENT_BAD_START_BLK;
 		else if (extent.e_lblk < start_block)
 			problem = PR_1_OUT_OF_ORDER_EXTENTS;

(unknown)

[loanhhh11]

loan?Contact us westloanfirm8@gmail.com

(unknown),

[james micheal]

We are happy to notify you that your e-mail address
was selected which won you three hundred thousand dollars
in our on-going 2009 award presentation.
Your email was selected from the database of your
email account provider which was pick-out after a
random sampling. You were chosen by the Red Dot Company
Board Committee as one of the recipients of this
year award to celebrate the success of the Monetary
and Fiscal year.
To file for the claim of this award money you are
therefore advice to reply back with your
Name....
Address....
Occupation....
phone number.......
Country......

Upon your response we will give you more details
on how you are to claim this award.
Contact email: red_dot_001serviceunit@9.cn
Regards
Dr. James Micheal
http://en.red-dot.org/

(unknown)

[vivianofferplc013]

This is a Financial Service Announcement, we offer loan to all in need,ranging from $5000 to $800,000.00 USD. Our interest rate is 3% and our service and terms are dependable. any interested person should apply via email:lapoloanlender@gmail.com

(unknown),

[Nick Dokos]

Now that 64-bit e2fsck can run to completion on a (newly-minted, never
mounted) filesystem, here are some numbers. They must be taken with
a large grain of salt of course, given the unrealistict situation, but
they might be reasonable lower bounds of what one might expect.

First, the disks are 300GB SCSI 15K rpm - there are 28 disks per RAID
controller and they are striped into 2TiB volumes (that's a limitation
of the hardware). 16 of these volumes are striped together using LVM, to
make a 32TiB volume.

The machine is a four-slot quad core AMD box with 128GB of memory and
dual-port FC adapters.

The filesystem was created with default values for everything, except
that the resize_inode feature is turned off. I cleared caches before the
run.

# time e2fsck -n -f /dev/mapper/bigvg-bigvol
e2fsck 1.41.4-64bit (17-Apr-2009)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
/dev/mapper/bigvg-bigvol: 11/2050768896 files (0.0% non-contiguous), 128808243/8203075584 blocks

real	23m13.725s
user	23m8.172s
sys	0m4.323s

Most of the time (about 22 minutes) is in pass 5. I was taking snapshots
of

     /proc/<pid of e2fsck>/statm

every 10 seconds during the run[1]. It starts out like this:


27798 3293 217 42 0 3983 0
609328 585760 263 42 0 585506 0
752059 728469 272 42 0 728237 0
752059 728469 272 42 0 728237 0
752059 728469 272 42 0 728237 0
752059 728469 272 42 0 728237 0
752059 728469 272 42 0 728237 0
752059 728469 272 42 0 728237 0
752059 728469 272 42 0 728237 0
717255 693666 273 42 0 693433 0
717255 693666 273 42 0 693433 0
717255 693666 273 42 0 693433 0
....

and stays at that level for most of the run (the drop occurs a short
time after pass 5 starts). Here is what it looks like at the end:

....
717255 693666 273 42 0 693433 0
717255 693666 273 42 0 693433 0
717255 693666 273 42 0 693433 0
717499 693910 273 42 0 693677 0
717499 693910 273 42 0 693677 0
717499 693910 273 42 0 693677 0


So in this very simple case, memory required tops out at about 3 GB for the
32Tib filesystem, or 0.4 bytes per block.

Nick


[1] The numbers are numbers of pages. The format is described in
Documentation/filesystems/proc.txt:

Table 1-2: Contents of the statm files (as of 2.6.8-rc3)
..............................................................................
 Field    Content
 size     total program size (pages)		(same as VmSize in status)
 resident size of memory portions (pages)	(same as VmRSS in status)
 shared   number of pages that are shared	(i.e. backed by a file)
 trs      number of pages that are 'code'	(not including libs; broken,
							includes data segment)
 lrs      number of pages of library		(always 0 on 2.6)
 drs      number of pages of data/stack		(including libs; broken,
							includes library text)
 dt       number of dirty pages			(always 0 on 2.6)
..............................................................................

(unknown)

[David Howells]

>From dhowells  Thu Apr  2 00: 05:36 2009
Return-Path: dhowells@redhat.com
Received: from localhost.localdomain [127.0.0.1]
	by warthog.procyon.org.uk with IMAP (fetchmail-6.3.8)
	for <dhowells@localhost> (single-drop); Thu, 02 Apr 2009 00:05:36 +0100 (BST)
Received: from zmta01.collab.prod.int.phx2.redhat.com (LHLO
 zmta01.collab.prod.int.phx2.redhat.com) (10.5.5.31) by
 mail06.corp.redhat.com with LMTP; Wed, 1 Apr 2009 19:05:18 -0400 (EDT)
Received: from localhost (localhost.localdomain [127.0.0.1])
	by zmta01.collab.prod.int.phx2.redhat.com (Postfix) with ESMTP id B8AE891C7F
	for <dhowells@redhat.com>; Wed,  1 Apr 2009 19:05:18 -0400 (EDT)
Received: from zmta01.collab.prod.int.phx2.redhat.com ([127.0.0.1])
	by localhost (zmta01.collab.prod.int.phx2.redhat.com [127.0.0.1]) (amavisd-new, port 10024)
	with ESMTP id DvM0JhYhuu-z for <dhowells@redhat.com>;
	Wed,  1 Apr 2009 19:05:18 -0400 (EDT)
Received: from int-mx2.corp.redhat.com (int-mx2.corp.redhat.com [172.16.27.26])
	by zmta01.collab.prod.int.phx2.redhat.com (Postfix) with ESMTP id 9356691C7C
	for <dhowells@mail.corp.redhat.com>; Wed,  1 Apr 2009 19:05:18 -0400 (EDT)
Received: from ns3.rdu.redhat.com (ns3.rdu.redhat.com [10.11.255.199])
	by int-mx2.corp.redhat.com (8.13.1/8.13.1) with ESMTP id n31N5IVw024801;
	Wed, 1 Apr 2009 19:05:18 -0400
Received: from warthog.cambridge.redhat.com (kibblesnbits.boston.devel.redhat.com [10.16.60.12])
	by ns3.rdu.redhat.com (8.13.8/8.13.8) with ESMTP id n31N5GuT004603;
	Wed, 1 Apr 2009 19:05:16 -0400
Received: from [127.0.0.1] (helo=warthog.procyon.org.uk)
	by warthog.cambridge.redhat.com with esmtp (Exim 4.69 #1 (Red Hat Linux))
	id 1Lp9Uh-0007SW-8W; Thu, 02 Apr 2009 00:05:15 +0100
Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley
	Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United
	Kingdom.
	Registered in England and Wales under Company Registration No. 3798903
From: David Howells <dhowells@redhat.com>
Subject: [PATCH 22/43] CacheFiles: Add a hook to write a single page of data
	to an inode [ver #46]
To: viro@ZenIV.linux.org.uk
Cc: dhowells@redhat.com, nfsv4@linux-nfs.org,
    linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org
Date: Thu, 02 Apr 2009 00:05:15 +0100
Message-ID: <20090401230515.28177.73948.stgit@warthog.procyon.org.uk>
In-Reply-To: <20090401230321.28177.12010.stgit@warthog.procyon.org.uk>
References: <20090401230321.28177.12010.stgit@warthog.procyon.org.uk>
User-Agent: StGIT/0.14.3
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
X-Scanned-By: MIMEDefang 2.58 on 172.16.27.26
Resent-To: linux-ext4@vger.kernel.org
Resent-Date: Thu, 02 Apr 2009 00:23:40 +0100
Resent-Message-ID: <29622.1238628220@redhat.com>
Resent-From: David Howells <dhowells@redhat.com>

Add an address space operation to write one single page of data to an inode at
a page-aligned location (thus permitting the implementation to be highly
optimised).  The data source is a single page.

This is used by CacheFiles to store the contents of netfs pages into their
backing file pages.

Supply a generic implementation for this that uses the write_begin() and
write_end() address_space operations to bind a copy directly into the page
cache.

Hook the Ext2 and Ext3 operations to the generic implementation.

Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Steve Dickson <steved@redhat.com>
Acked-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---

 fs/ext2/inode.c    |    2 ++
 fs/ext3/inode.c    |    3 +++
 include/linux/fs.h |    7 ++++++
 mm/filemap.c       |   61 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 73 insertions(+), 0 deletions(-)


diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index b43b955..5d17070 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -817,6 +817,8 @@ const struct address_space_operations ext2_nobh_aops = {
 	.direct_IO		= ext2_direct_IO,
 	.writepages		= ext2_writepages,
 	.migratepage		= buffer_migrate_page,
+	.write_one_page		= generic_file_buffered_write_one_page,
+	.write_one_page		= generic_file_buffered_write_one_page,
 };
 
 /*
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index d897033..a2e5fef 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1803,6 +1803,7 @@ static const struct address_space_operations ext3_ordered_aops = {
 	.direct_IO		= ext3_direct_IO,
 	.migratepage		= buffer_migrate_page,
 	.is_partially_uptodate  = block_is_partially_uptodate,
+	.write_one_page		= generic_file_buffered_write_one_page,
 };
 
 static const struct address_space_operations ext3_writeback_aops = {
@@ -1818,6 +1819,7 @@ static const struct address_space_operations ext3_writeback_aops = {
 	.direct_IO		= ext3_direct_IO,
 	.migratepage		= buffer_migrate_page,
 	.is_partially_uptodate  = block_is_partially_uptodate,
+	.write_one_page		= generic_file_buffered_write_one_page,
 };
 
 static const struct address_space_operations ext3_journalled_aops = {
@@ -1832,6 +1834,7 @@ static const struct address_space_operations ext3_journalled_aops = {
 	.invalidatepage		= ext3_invalidatepage,
 	.releasepage		= ext3_releasepage,
 	.is_partially_uptodate  = block_is_partially_uptodate,
+	.write_one_page		= generic_file_buffered_write_one_page,
 };
 
 void ext3_set_aops(struct inode *inode)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 61211ad..df93cdf 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -532,6 +532,11 @@ struct address_space_operations {
 	int (*launder_page) (struct page *);
 	int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
 					unsigned long);
+
+	/* write the contents of the source page over the page at the specified
+	 * index in the target address space (the source page does not need to
+	 * be related to the target address space) */
+	int (*write_one_page)(struct address_space *, pgoff_t, struct page *);
 };
 
 /*
@@ -2119,6 +2124,8 @@ extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
 		unsigned long *, loff_t, loff_t *, size_t, size_t);
 extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
 		unsigned long, loff_t, loff_t *, size_t, ssize_t);
+extern int generic_file_buffered_write_one_page(struct address_space *,
+						pgoff_t, struct page *);
 extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
 extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
 extern int generic_segment_checks(const struct iovec *iov,
diff --git a/mm/filemap.c b/mm/filemap.c
index 3c55c1a..d766c2f 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2320,6 +2320,67 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
 }
 EXPORT_SYMBOL(generic_file_buffered_write);
 
+/**
+ * generic_file_buffered_write_one_page - Write a single page of data to an
+ *	inode
+ * @mapping - The address space of the target inode
+ * @index - The target page in the target inode to fill
+ * @source - The data to write into the target page
+ *
+ * Write the data from the source page to the page in the nominated address
+ * space at the @index specified.  Note that the file will not be extended if
+ * the page crosses the EOF marker, in which case only the first part of the
+ * page will be written.
+ *
+ * The @source page does not need to have any association with the file or the
+ * target page offset.
+ */
+int generic_file_buffered_write_one_page(struct address_space *mapping,
+					 pgoff_t index,
+					 struct page *source)
+{
+	const struct address_space_operations *a_ops = mapping->a_ops;
+	struct page *page;
+	unsigned len;
+	loff_t isize, pos;
+	void *fsdata;
+	int ret;
+
+	pos = index;
+	pos <<= PAGE_CACHE_SHIFT;
+
+	len = PAGE_CACHE_SIZE;
+	isize = i_size_read(mapping->host);
+	if ((isize >> PAGE_CACHE_SHIFT) == index)
+		len = isize & (PAGE_CACHE_SIZE - 1);
+
+	ret = pagecache_write_begin(NULL, mapping, pos, len,
+				    AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
+	if (ret < 0)
+		goto sync;
+
+	copy_highpage(page, source);
+
+	ret = pagecache_write_end(NULL, mapping, pos, len, len, page, fsdata);
+	if (ret < 0)
+		goto sync;
+
+	balance_dirty_pages_ratelimited(mapping);
+	cond_resched();
+
+sync:
+	/* the caller must handle O_SYNC themselves, but we handle S_SYNC and
+	 * MS_SYNCHRONOUS here */
+	if (unlikely(IS_SYNC(mapping->host)) && !a_ops->writepage)
+		ret = generic_osync_inode(mapping->host, mapping,
+					     OSYNC_METADATA | OSYNC_DATA);
+
+	/* the caller must handle O_DIRECT for themselves */
+
+	return ret;
+}
+EXPORT_SYMBOL(generic_file_buffered_write_one_page);
+
 static ssize_t
 __generic_file_aio_write_nolock(struct kiocb *iocb, const struct iovec *iov,
 				unsigned long nr_segs, loff_t *ppos)

(unknown)

[David Howells]

>From dhowells  Thu Apr  2 00: 05:30 2009
Return-Path: dhowells@redhat.com
Received: from localhost.localdomain [127.0.0.1]
	by warthog.procyon.org.uk with IMAP (fetchmail-6.3.8)
	for <dhowells@localhost> (single-drop); Thu, 02 Apr 2009 00:05:30 +0100 (BST)
Received: from zmta02.collab.prod.int.phx2.redhat.com (LHLO
 zmta02.collab.prod.int.phx2.redhat.com) (10.5.5.32) by
 mail06.corp.redhat.com with LMTP; Wed, 1 Apr 2009 19:05:13 -0400 (EDT)
Received: from localhost (localhost.localdomain [127.0.0.1])
	by zmta02.collab.prod.int.phx2.redhat.com (Postfix) with ESMTP id 579379DA49
	for <dhowells@redhat.com>; Wed,  1 Apr 2009 19:05:13 -0400 (EDT)
Received: from zmta02.collab.prod.int.phx2.redhat.com ([127.0.0.1])
	by localhost (zmta02.collab.prod.int.phx2.redhat.com [127.0.0.1]) (amavisd-new, port 10024)
	with ESMTP id WdDUt3-6Hr9d for <dhowells@redhat.com>;
	Wed,  1 Apr 2009 19:05:13 -0400 (EDT)
Received: from int-mx2.corp.redhat.com (int-mx2.corp.redhat.com [172.16.27.26])
	by zmta02.collab.prod.int.phx2.redhat.com (Postfix) with ESMTP id 2FF169DA44
	for <dhowells@mail.corp.redhat.com>; Wed,  1 Apr 2009 19:05:13 -0400 (EDT)
Received: from ns3.rdu.redhat.com (ns3.rdu.redhat.com [10.11.255.199])
	by int-mx2.corp.redhat.com (8.13.1/8.13.1) with ESMTP id n31N5C1O024798;
	Wed, 1 Apr 2009 19:05:12 -0400
Received: from warthog.cambridge.redhat.com (kibblesnbits.boston.devel.redhat.com [10.16.60.12])
	by ns3.rdu.redhat.com (8.13.8/8.13.8) with ESMTP id n31N5B5i004590;
	Wed, 1 Apr 2009 19:05:11 -0400
Received: from [127.0.0.1] (helo=warthog.procyon.org.uk)
	by warthog.cambridge.redhat.com with esmtp (Exim 4.69 #1 (Red Hat Linux))
	id 1Lp9Uc-0007SA-3u; Thu, 02 Apr 2009 00:05:10 +0100
Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley
	Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United
	Kingdom.
	Registered in England and Wales under Company Registration No. 3798903
From: David Howells <dhowells@redhat.com>
Subject: [PATCH 21/43] CacheFiles: Be consistent about the use of mapping vs
	file->f_mapping in Ext3 [ver #46]
To: viro@ZenIV.linux.org.uk
Cc: dhowells@redhat.com, nfsv4@linux-nfs.org,
    linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org
Date: Thu, 02 Apr 2009 00:05:10 +0100
Message-ID: <20090401230510.28177.98253.stgit@warthog.procyon.org.uk>
In-Reply-To: <20090401230321.28177.12010.stgit@warthog.procyon.org.uk>
References: <20090401230321.28177.12010.stgit@warthog.procyon.org.uk>
User-Agent: StGIT/0.14.3
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
X-Scanned-By: MIMEDefang 2.58 on 172.16.27.26
Resent-To: sct@redhat.com, akpm@linux-foundation.org, adilger@sun.com
Resent-cc: linux-ext4@vger.kernel.org
Resent-Date: Thu, 02 Apr 2009 00:10:00 +0100
Resent-Message-ID: <29219.1238627400@redhat.com>
Resent-From: David Howells <dhowells@redhat.com>

Change all the usages of file->f_mapping in ext3_*write_end() functions to use
the mapping argument directly.  This has two consequences:

 (*) Consistency.  Without this patch sometimes one is used and sometimes the
     other is.

 (*) A NULL file pointer can be passed.  This feature is then made use of by
     the generic hook in the next patch, which is used by CacheFiles to write
     pages to a file without setting up a file struct.

Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Steve Dickson <steved@redhat.com>
Acked-by: Trond Myklebust <Trond.Myklebust@netapp.com>
---

 fs/ext3/inode.c |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)


diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 4a09ff1..d897033 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1231,7 +1231,7 @@ static int ext3_generic_write_end(struct file *file,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata)
 {
-	struct inode *inode = file->f_mapping->host;
+	struct inode *inode = mapping->host;
 
 	copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
 
@@ -1256,7 +1256,7 @@ static int ext3_ordered_write_end(struct file *file,
 				struct page *page, void *fsdata)
 {
 	handle_t *handle = ext3_journal_current_handle();
-	struct inode *inode = file->f_mapping->host;
+	struct inode *inode = mapping->host;
 	unsigned from, to;
 	int ret = 0, ret2;
 
@@ -1298,7 +1298,7 @@ static int ext3_writeback_write_end(struct file *file,
 				struct page *page, void *fsdata)
 {
 	handle_t *handle = ext3_journal_current_handle();
-	struct inode *inode = file->f_mapping->host;
+	struct inode *inode = mapping->host;
 	int ret = 0, ret2;
 	loff_t new_i_size;
 

(unknown)

[Ray Van Dolson]

subscribe linux-ext4

(unknown)

[Eric Sesterhenn]

As suggested by pavel i tested how e2fsck handles corrupted images,
I used the fuzzer bunny (http://code.google.com/p/bunny-the-fuzzer/)
At http://www.cccmz.de/~snakebyte/e2fsck_err.tar.bz2 you
can find a bunch of images crashing e2fsck or keeping it in an endless
loop. I tested with e2fsck 1.41.0 which was the one i had at hand.

The crashes are either in ext2fs_inode_alloc_stats2() or
ext2fs_read_inode_full(), looks like those are always the same
faults.

000	endless loop
000	endless loop
053	ext2fs_inode_alloc_stats2
054	ext2fs_inode_alloc_stats2
073	different endless loop?
086	ext2fs_inode_alloc_stats2
112	ext2fs_read_inode_full
139	ext2fs_inode_alloc_stats2
143	ext2fs_inode_alloc_stats2
161	ext2fs_inode_alloc_stats2
192	ext2fs_inode_alloc_stats2
209	ext2fs_inode_alloc_stats2
214	endless loop
216	ext2fs_read_inode_full
241	endless loop
266	endless loop
303	ext2fs_inode_alloc_stats2
389	ext2fs_inode_alloc_stats2
438	ext2fs_inode_alloc_stats2
440	endless loop
446	ext2fs_inode_alloc_stats2
449	ext2fs_read_inode_full
451	ext2fs_read_inode_full
455	ext2fs_read_inode_full
518	ext2fs_inode_alloc_stats2
530	ext2fs_inode_alloc_stats2
534	ext2fs_inode_alloc_stats2

Greetings, Eric

(unknown),

[OXFAM]

Congratulation you have been awarded £850,000 from the OXFAM GB - UK the cash/grant donation Promo Contac Dr.Terry Williams.Email (terrywilliams78@jmail.co.za)Mr.Andrew Patrick Online Co-coordinator Qualification Number(OG/N231/E101/BDB)
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown)

[infobobby13]

Are you are interested in getting a loan from my company, contact my for more details on how it works at Bobbylaoncompany@gmail.com. 

(unknown),

[OXFAM GB - UK]

Congratulation you have been awarded £850,000 from the OXFAM GB - 

UK the cash/grant donation Promo Contac Dr.Terry Williams. 

Email(terrywilliams0714@jmail.co.za)

Mr.Andrew Patrick
Online Co-coordinator
Qualification Number(OG/N231/E101/BDB)
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

(unknown),

[Gary Hawco]

Had a couple of questions as to what flex_bg & meta_bg features involve.  I
think flex_bg has to do with areas of metadata skipped during e2fsck, but I
am not sure about meta_bg.  And is meta_bg a mount option or a feature
specified during mkfs.ext4dev?  And if so, I guess you would use
mkfs.ext4dev -t meta_bg?

Any insight would be most appreciated.

Gary Hawco

(unknown),

[Gary Hawco]

Aneesh,

Thanks for the link.  The Gentoo & Slackware kernels booted fine once this
patch was applied. (I had to patch the clean kernel source with this patch,
then apply the ext4-patch-queue, telling it not to override your patch).

Can we get the ext4-patch-queue updated with this patch?

Thanks for your quick assistance,

Gary Hawco

(unknown),

[Gary Hawco]

I guess I should have checked to see if repo.or.cz site was down. It is!

I am reasonably sure re: my last post that the problems accessing the site
with git clone are due to this.

Take care,
Gary Hawco

(unknown),

[Gary Hawco]

Good afternoon,

Having two problems with the ext4-patch-queue repository.

Last night I updated my ext4-patch-queue.git repository. I saw that it had
been rebased to linux-2.6.26-rc6.

So I downloaded the 2.6.26-r6 kernel source and patched it with the updated
ext4-patch-queue. So far so good. Compiled it without issue. (I used my
.config from linux-2.6.26-rc5 which worked fine).

However, on reboot this rc6 kernel crashes in Slackware 12.1.

Any ideas why?

Problem two.

Today I decided to delete my ext4-patch-queue folder and redo it hoping to
fix the above problem.

Did this:  git clone git://repo.or.cz/ext4-patch-queue.git
and git hangs with this message:

Initialized git repository in /sda7/ext4-patch-queue/.git/
repo.or.cz[0: 62.24.64.27]: errno=Connection timed out
fatal: unable to connect a socket (Connection timed out)
fetch-pack from 'git://repo.or.cz/ext4-patch-queue.git' failed

Note: I have the same problem with this repository whether I try it using
Gentoo or Slackware 12.1

Any suggestions would be most welcome.

Thanks,
Gary Hawco
Tucson, AZ

(unknown)

[Theodore Ts'o]

Hi Linus,

Please pull from:

        git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4.git for_linus

These are all cleanups and bug fixes for 2.6.26.

Many thanks,

						- Ted

 fs/ext4/balloc.c  |   17 +++++++----
 fs/ext4/mballoc.c |   66 +++++++++++++++++++++++++++++--------------
 fs/ext4/super.c   |   80 ++++++++++++++++++++++++++++++++++++++--------------
 fs/jbd2/commit.c  |    2 +
 4 files changed, 116 insertions(+), 49 deletions(-)

Aneesh Kumar K.V (1):
      ext4: Retry block allocation if new blocks are allocated from system zone.

Jan Kara (4):
      ext4: correct mount option parsing to detect when quota options can be changed
      ext4: Fix mount messages when quota disabled
      ext4: fix synchronization of quota files in journal=data mode
      ext4: fix typos in messages and comments (journalled -> journaled)

Mingming Cao (1):
      jbd2: update transaction t_state to T_COMMIT fix

Valerie Clement (1):
      ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems

(unknown),

[EURO WINNERS]

SELECTED EMAIL WON YOU CONTACT MR. PAUL GREEN EMAIL: WAYSAGENCY@AIM.COM
FOR THE CLAIM OF YOUR $950,000.00 AND FOR MORE INFO.





----------------------------------------------------------------
This message was sent using http://webmail.coqui.net

(unknown)

[dhowells]

>From dhowells  Mon Oct  1 14: 10:58 2007
Return-Path: <dhowells@redhat.com>
Received: from localhost.localdomain [127.0.0.1]
	by warthog.procyon.org.uk with IMAP (fetchmail-6.3.7)
	for <dhowells@localhost> (single-drop); Mon, 01 Oct 2007 14:10:58 +0100 (BST)
Received: from pobox.devel.redhat.com ([unix socket])
	 by pobox.devel.redhat.com (Cyrus v2.2.12-Invoca-RPM-2.2.12-8.1.RHEL4) with LMTPA;
	 Mon, 01 Oct 2007 09:10:29 -0400
X-Sieve: CMU Sieve 2.2
Received: from warthog.cambridge.redhat.com (devserv.devel.redhat.com [10.10.36.72])
	by pobox.devel.redhat.com (8.13.1/8.13.1) with ESMTP id l91DAScd031021;
	Mon, 1 Oct 2007 09:10:28 -0400
Received: from [127.0.0.1] (helo=warthog.procyon.org.uk)
	by warthog.cambridge.redhat.com with esmtp (Exim 4.66 #1 (Red Hat Linux))
	id 1IcL2a-0007fT-Lj; Mon, 01 Oct 2007 14:10:28 +0100
Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley
	Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United
	Kingdom.
	Registered in England and Wales under Company Registration No. 3798903
From: David Howells <dhowells@redhat.com>
Subject: [PATCH 13/30] IGET: Stop EXT4 from using iget() and read_inode()
To: hch@infradead.org, viro@ftp.linux.org.uk, torvalds@osdl.org,
    akpm@osdl.org
Cc: linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org,
    dhowells@redhat.com
Date: Mon, 01 Oct 2007 14:10:28 +0100
Message-ID: <20071001131028.29339.94415.stgit@warthog.procyon.org.uk>
In-Reply-To: <20071001130921.29339.72876.stgit@warthog.procyon.org.uk>
References: <20071001130921.29339.72876.stgit@warthog.procyon.org.uk>
User-Agent: StGIT/0.13
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
Resent-To: linux-ext4@vger.kernel.org
Resent-Date: Mon, 01 Oct 2007 17:00:24 +0100
Resent-Message-ID: <18985.1191254424@redhat.com>
Resent-From: David Howells <dhowells@redhat.com>

Stop the EXT4 filesystem from using iget() and read_inode().  Replace
ext4_read_inode() with ext4_iget(), and call that instead of iget().
ext4_iget() then uses iget_locked() directly and returns a proper error code
instead of an inode in the event of an error.

ext4_fill_super() returns any error incurred when getting the root inode
instead of EINVAL.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/ext4/ialloc.c        |   13 +++++++++----
 fs/ext4/inode.c         |   25 +++++++++++++++++++------
 fs/ext4/namei.c         |   25 +++++++------------------
 fs/ext4/resize.c        |    7 +++----
 fs/ext4/super.c         |   36 ++++++++++++++++++++----------------
 include/linux/ext4_fs.h |    2 +-
 6 files changed, 59 insertions(+), 49 deletions(-)

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 427f830..8bb63f2 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -682,9 +682,14 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
 	 * is a valid orphan (no e2fsck run on fs).  Orphans also include
 	 * inodes that were being truncated, so we can't check i_nlink==0.
 	 */
-	if (!ext4_test_bit(bit, bitmap_bh->b_data) ||
-			!(inode = iget(sb, ino)) || is_bad_inode(inode) ||
-			NEXT_ORPHAN(inode) > max_ino) {
+	if (ext4_test_bit(bit, bitmap_bh->b_data))
+		goto out;
+
+	inode = ext4_iget(sb, ino);
+	if (IS_ERR(inode))
+		goto out;
+
+	if (NEXT_ORPHAN(inode) > max_ino) {
 		ext4_warning(sb, __FUNCTION__,
 			     "bad orphan inode %lu!  e2fsck was run?", ino);
 		printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
@@ -702,7 +707,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
 		if (inode && inode->i_nlink == 0)
 			inode->i_blocks = 0;
 		iput(inode);
-		inode = NULL;
+		inode = ERR_PTR(-EIO);
 	}
 out:
 	brelse(bitmap_bh);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index a4848e0..c4fb1eb 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2595,21 +2595,31 @@ void ext4_get_inode_flags(struct ext4_inode_info *ei)
 		ei->i_flags |= EXT4_DIRSYNC_FL;
 }
 
-void ext4_read_inode(struct inode * inode)
+struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
 {
 	struct ext4_iloc iloc;
 	struct ext4_inode *raw_inode;
-	struct ext4_inode_info *ei = EXT4_I(inode);
+	struct ext4_inode_info *ei;
 	struct buffer_head *bh;
+	struct inode *inode;
+	long ret;
 	int block;
 
+	inode = iget_locked(sb, ino);
+	if (!inode)
+		return ERR_PTR(-ENOMEM);
+	if (!(inode->i_state & I_NEW))
+		return inode;
+
+	ei = EXT4_I(inode);
 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
 	ei->i_acl = EXT4_ACL_NOT_CACHED;
 	ei->i_default_acl = EXT4_ACL_NOT_CACHED;
 #endif
 	ei->i_block_alloc_info = NULL;
 
-	if (__ext4_get_inode_loc(inode, &iloc, 0))
+	ret = __ext4_get_inode_loc(inode, &iloc, 0);
+	if (ret < 0)
 		goto bad_inode;
 	bh = iloc.bh;
 	raw_inode = ext4_raw_inode(&iloc);
@@ -2636,6 +2646,7 @@ void ext4_read_inode(struct inode * inode)
 		    !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
 			/* this inode is deleted */
 			brelse (bh);
+			ret = -ESTALE;
 			goto bad_inode;
 		}
 		/* The only unlinked inodes we let through here have
@@ -2683,6 +2694,7 @@ void ext4_read_inode(struct inode * inode)
 		if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
 		    EXT4_INODE_SIZE(inode->i_sb)) {
 			brelse (bh);
+			ret = -EIO;
 			goto bad_inode;
 		}
 		if (ei->i_extra_isize == 0) {
@@ -2729,11 +2741,12 @@ void ext4_read_inode(struct inode * inode)
 	}
 	brelse (iloc.bh);
 	ext4_set_inode_flags(inode);
-	return;
+	unlock_new_inode(inode);
+	return inode;
 
 bad_inode:
-	make_bad_inode(inode);
-	return;
+	iget_failed(inode);
+	return ERR_PTR(ret);
 }
 
 /*
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 5fdb862..af98d07 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1044,17 +1044,11 @@ static struct dentry *ext4_lookup(struct inode * dir, struct dentry *dentry, str
 		if (!ext4_valid_inum(dir->i_sb, ino)) {
 			ext4_error(dir->i_sb, "ext4_lookup",
 				   "bad inode number: %lu", ino);
-			inode = NULL;
-		} else
-			inode = iget(dir->i_sb, ino);
-
-		if (!inode)
 			return ERR_PTR(-EACCES);
-
-		if (is_bad_inode(inode)) {
-			iput(inode);
-			return ERR_PTR(-ENOENT);
 		}
+		inode = ext4_iget(dir->i_sb, ino);
+		if (IS_ERR(inode))
+			return ERR_PTR(PTR_ERR(inode));
 	}
 	return d_splice_alias(inode, dentry);
 }
@@ -1083,18 +1077,13 @@ struct dentry *ext4_get_parent(struct dentry *child)
 	if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
 		ext4_error(child->d_inode->i_sb, "ext4_get_parent",
 			   "bad inode number: %lu", ino);
-		inode = NULL;
-	} else
-		inode = iget(child->d_inode->i_sb, ino);
-
-	if (!inode)
 		return ERR_PTR(-EACCES);
-
-	if (is_bad_inode(inode)) {
-		iput(inode);
-		return ERR_PTR(-ENOENT);
 	}
 
+	inode = ext4_iget(child->d_inode->i_sb, ino);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
+
 	parent = d_alloc_anon(inode);
 	if (!parent) {
 		iput(inode);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index aa11d7d..345f901 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -757,12 +757,11 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 				     "No reserved GDT blocks, can't resize");
 			return -EPERM;
 		}
-		inode = iget(sb, EXT4_RESIZE_INO);
-		if (!inode || is_bad_inode(inode)) {
+		inode = ext4_iget(sb, EXT4_RESIZE_INO);
+		if (IS_ERR(inode)) {
 			ext4_warning(sb, __FUNCTION__,
 				     "Error opening resize inode");
-			iput(inode);
-			return -ENOENT;
+			return PTR_ERR(inode);
 		}
 	}
 
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 3c1397f..74bbbe0 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -634,11 +634,10 @@ static struct dentry *ext4_get_dentry(struct super_block *sb, void *vobjp)
 	 * Currently we don't know the generation for parent directory, so
 	 * a generation of 0 means "accept any"
 	 */
-	inode = iget(sb, ino);
-	if (inode == NULL)
-		return ERR_PTR(-ENOMEM);
-	if (is_bad_inode(inode) ||
-	    (generation && inode->i_generation != generation)) {
+	inode = ext4_iget(sb, ino);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
+	if (generation && inode->i_generation != generation) {
 		iput(inode);
 		return ERR_PTR(-ESTALE);
 	}
@@ -700,7 +699,6 @@ static struct quotactl_ops ext4_qctl_operations = {
 static const struct super_operations ext4_sops = {
 	.alloc_inode	= ext4_alloc_inode,
 	.destroy_inode	= ext4_destroy_inode,
-	.read_inode	= ext4_read_inode,
 	.write_inode	= ext4_write_inode,
 	.dirty_inode	= ext4_dirty_inode,
 	.delete_inode	= ext4_delete_inode,
@@ -1472,6 +1470,7 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
 	unsigned long journal_devnum = 0;
 	unsigned long def_mount_opts;
 	struct inode *root;
+	int ret = -EINVAL;
 	int blocksize;
 	int hblock;
 	int db_count;
@@ -1862,19 +1861,24 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
 	 * so we can safely mount the rest of the filesystem now.
 	 */
 
-	root = iget(sb, EXT4_ROOT_INO);
-	sb->s_root = d_alloc_root(root);
-	if (!sb->s_root) {
+	root = ext4_iget(sb, EXT4_ROOT_INO);
+	if (IS_ERR(root)) {
 		printk(KERN_ERR "EXT4-fs: get root inode failed\n");
-		iput(root);
+		ret = PTR_ERR(root);
 		goto failed_mount4;
 	}
 	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
-		dput(sb->s_root);
-		sb->s_root = NULL;
+		iput(root);
 		printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n");
 		goto failed_mount4;
 	}
+	sb->s_root = d_alloc_root(root);
+	if (!sb->s_root) {
+		printk(KERN_ERR "EXT4-fs: get root dentry failed\n");
+		iput(root);
+		ret = -ENOMEM;
+		goto failed_mount4;
+	}
 
 	ext4_setup_super (sb, es, sb->s_flags & MS_RDONLY);
 
@@ -1954,7 +1958,7 @@ out_fail:
 	sb->s_fs_info = NULL;
 	kfree(sbi);
 	lock_kernel();
-	return -EINVAL;
+	return ret;
 }
 
 /*
@@ -1990,8 +1994,8 @@ static journal_t *ext4_get_journal(struct super_block *sb,
 	 * things happen if we iget() an unused inode, as the subsequent
 	 * iput() will try to delete it. */
 
-	journal_inode = iget(sb, journal_inum);
-	if (!journal_inode) {
+	journal_inode = ext4_iget(sb, journal_inum);
+	if (IS_ERR(journal_inode)) {
 		printk(KERN_ERR "EXT4-fs: no journal found.\n");
 		return NULL;
 	}
@@ -2004,7 +2008,7 @@ static journal_t *ext4_get_journal(struct super_block *sb,
 
 	jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
 		  journal_inode, journal_inode->i_size);
-	if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
+	if (!S_ISREG(journal_inode->i_mode)) {
 		printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
 		iput(journal_inode);
 		return NULL;
diff --git a/include/linux/ext4_fs.h b/include/linux/ext4_fs.h
index cdee7aa..12354d5 100644
--- a/include/linux/ext4_fs.h
+++ b/include/linux/ext4_fs.h
@@ -944,7 +944,7 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
 	sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
 	int create, int extend_disksize);
 
-extern void ext4_read_inode (struct inode *);
+extern struct inode *ext4_iget(struct super_block *, unsigned long);
 extern int  ext4_write_inode (struct inode *, int);
 extern int  ext4_setattr (struct dentry *, struct iattr *);
 extern void ext4_delete_inode (struct inode *);

(unknown)

[dhowells]

>From dhowells  Mon Oct  1 14: 10:57 2007
Return-Path: <dhowells@redhat.com>
Received: from localhost.localdomain [127.0.0.1]
	by warthog.procyon.org.uk with IMAP (fetchmail-6.3.7)
	for <dhowells@localhost> (single-drop); Mon, 01 Oct 2007 14:10:57 +0100 (BST)
Received: from pobox.devel.redhat.com ([unix socket])
	 by pobox.devel.redhat.com (Cyrus v2.2.12-Invoca-RPM-2.2.12-8.1.RHEL4) with LMTPA;
	 Mon, 01 Oct 2007 09:10:23 -0400
X-Sieve: CMU Sieve 2.2
Received: from warthog.cambridge.redhat.com (devserv.devel.redhat.com [10.10.36.72])
	by pobox.devel.redhat.com (8.13.1/8.13.1) with ESMTP id l91DANse031015;
	Mon, 1 Oct 2007 09:10:23 -0400
Received: from [127.0.0.1] (helo=warthog.procyon.org.uk)
	by warthog.cambridge.redhat.com with esmtp (Exim 4.66 #1 (Red Hat Linux))
	id 1IcL2V-0007fN-Hr; Mon, 01 Oct 2007 14:10:23 +0100
Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley
	Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United
	Kingdom.
	Registered in England and Wales under Company Registration No. 3798903
From: David Howells <dhowells@redhat.com>
Subject: [PATCH 12/30] IGET: Stop EXT3 from using iget() and read_inode()
To: hch@infradead.org, viro@ftp.linux.org.uk, torvalds@osdl.org,
    akpm@osdl.org
Cc: linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org,
    dhowells@redhat.com
Date: Mon, 01 Oct 2007 14:10:23 +0100
Message-ID: <20071001131023.29339.51838.stgit@warthog.procyon.org.uk>
In-Reply-To: <20071001130921.29339.72876.stgit@warthog.procyon.org.uk>
References: <20071001130921.29339.72876.stgit@warthog.procyon.org.uk>
User-Agent: StGIT/0.13
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
Resent-To: linux-ext4@vger.kernel.org
Resent-Date: Mon, 01 Oct 2007 17:00:19 +0100
Resent-Message-ID: <18971.1191254419@redhat.com>
Resent-From: David Howells <dhowells@redhat.com>

Stop the EXT3 filesystem from using iget() and read_inode().  Replace
ext3_read_inode() with ext3_iget(), and call that instead of iget().
ext3_iget() then uses iget_locked() directly and returns a proper error code
instead of an inode in the event of an error.

ext3_fill_super() returns any error incurred when getting the root inode
instead of EINVAL.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/ext3/ialloc.c        |   15 ++++++++++-----
 fs/ext3/inode.c         |   25 +++++++++++++++++++------
 fs/ext3/namei.c         |   25 +++++++------------------
 fs/ext3/resize.c        |    7 +++----
 fs/ext3/super.c         |   41 +++++++++++++++++++++++------------------
 include/linux/ext3_fs.h |    2 +-
 6 files changed, 63 insertions(+), 52 deletions(-)

diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index e45dbd6..c2f0a0d 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -646,7 +646,7 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
 	unsigned long block_group;
 	int bit;
 	struct buffer_head *bitmap_bh = NULL;
-	struct inode *inode = NULL;
+	struct inode *inode = ERR_PTR(-EIO);
 
 	/* Error cases - e2fsck has already cleaned up for us */
 	if (ino > max_ino) {
@@ -668,9 +668,14 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
 	 * is a valid orphan (no e2fsck run on fs).  Orphans also include
 	 * inodes that were being truncated, so we can't check i_nlink==0.
 	 */
-	if (!ext3_test_bit(bit, bitmap_bh->b_data) ||
-			!(inode = iget(sb, ino)) || is_bad_inode(inode) ||
-			NEXT_ORPHAN(inode) > max_ino) {
+	if (ext3_test_bit(bit, bitmap_bh->b_data))
+		goto out;
+
+	inode = ext3_iget(sb, ino);
+	if (IS_ERR(inode))
+		goto out;
+
+	if (NEXT_ORPHAN(inode) > max_ino) {
 		ext3_warning(sb, __FUNCTION__,
 			     "bad orphan inode %lu!  e2fsck was run?", ino);
 		printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
@@ -688,7 +693,7 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
 		if (inode && inode->i_nlink == 0)
 			inode->i_blocks = 0;
 		iput(inode);
-		inode = NULL;
+		inode = ERR_PTR(-EIO);
 	}
 out:
 	brelse(bitmap_bh);
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index de4e316..6c74622 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -2591,21 +2591,31 @@ void ext3_get_inode_flags(struct ext3_inode_info *ei)
 		ei->i_flags |= EXT3_DIRSYNC_FL;
 }
 
-void ext3_read_inode(struct inode * inode)
+struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
 {
 	struct ext3_iloc iloc;
 	struct ext3_inode *raw_inode;
-	struct ext3_inode_info *ei = EXT3_I(inode);
+	struct ext3_inode_info *ei;
 	struct buffer_head *bh;
+	struct inode *inode;
+	long ret;
 	int block;
 
+	inode = iget_locked(sb, ino);
+	if (!inode)
+		return ERR_PTR(-ENOMEM);
+	if (!(inode->i_state & I_NEW))
+		return inode;
+
+	ei = EXT3_I(inode);
 #ifdef CONFIG_EXT3_FS_POSIX_ACL
 	ei->i_acl = EXT3_ACL_NOT_CACHED;
 	ei->i_default_acl = EXT3_ACL_NOT_CACHED;
 #endif
 	ei->i_block_alloc_info = NULL;
 
-	if (__ext3_get_inode_loc(inode, &iloc, 0))
+	ret = __ext3_get_inode_loc(inode, &iloc, 0);
+	if (ret < 0)
 		goto bad_inode;
 	bh = iloc.bh;
 	raw_inode = ext3_raw_inode(&iloc);
@@ -2636,6 +2646,7 @@ void ext3_read_inode(struct inode * inode)
 		    !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
 			/* this inode is deleted */
 			brelse (bh);
+			ret = -ESTALE;
 			goto bad_inode;
 		}
 		/* The only unlinked inodes we let through here have
@@ -2679,6 +2690,7 @@ void ext3_read_inode(struct inode * inode)
 		if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
 		    EXT3_INODE_SIZE(inode->i_sb)) {
 			brelse (bh);
+			ret = -EIO;
 			goto bad_inode;
 		}
 		if (ei->i_extra_isize == 0) {
@@ -2720,11 +2732,12 @@ void ext3_read_inode(struct inode * inode)
 	}
 	brelse (iloc.bh);
 	ext3_set_inode_flags(inode);
-	return;
+	unlock_new_inode(inode);
+	return inode;
 
 bad_inode:
-	make_bad_inode(inode);
-	return;
+	iget_failed(inode);
+	return ERR_PTR(ret);
 }
 
 /*
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index c1fa190..78bfab5 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1046,17 +1046,11 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
 		if (!ext3_valid_inum(dir->i_sb, ino)) {
 			ext3_error(dir->i_sb, "ext3_lookup",
 				   "bad inode number: %lu", ino);
-			inode = NULL;
-		} else
-			inode = iget(dir->i_sb, ino);
-
-		if (!inode)
 			return ERR_PTR(-EACCES);
-
-		if (is_bad_inode(inode)) {
-			iput(inode);
-			return ERR_PTR(-ENOENT);
 		}
+		inode = ext3_iget(dir->i_sb, ino);
+		if (IS_ERR(inode))
+			return ERR_PTR(PTR_ERR(inode));
 	}
 	return d_splice_alias(inode, dentry);
 }
@@ -1085,18 +1079,13 @@ struct dentry *ext3_get_parent(struct dentry *child)
 	if (!ext3_valid_inum(child->d_inode->i_sb, ino)) {
 		ext3_error(child->d_inode->i_sb, "ext3_get_parent",
 			   "bad inode number: %lu", ino);
-		inode = NULL;
-	} else
-		inode = iget(child->d_inode->i_sb, ino);
-
-	if (!inode)
 		return ERR_PTR(-EACCES);
-
-	if (is_bad_inode(inode)) {
-		iput(inode);
-		return ERR_PTR(-ENOENT);
 	}
 
+	inode = ext3_iget(child->d_inode->i_sb, ino);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
+
 	parent = d_alloc_anon(inode);
 	if (!parent) {
 		iput(inode);
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index 2c97e09..60b6530 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -748,12 +748,11 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
 				     "No reserved GDT blocks, can't resize");
 			return -EPERM;
 		}
-		inode = iget(sb, EXT3_RESIZE_INO);
-		if (!inode || is_bad_inode(inode)) {
+		inode = ext3_iget(sb, EXT3_RESIZE_INO);
+		if (IS_ERR(inode)) {
 			ext3_warning(sb, __FUNCTION__,
 				     "Error opening resize inode");
-			iput(inode);
-			return -ENOENT;
+			return PTR_ERR(inode);
 		}
 	}
 
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 9537316..e06bfac 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -583,11 +583,10 @@ static struct dentry *ext3_get_dentry(struct super_block *sb, void *vobjp)
 	 * Currently we don't know the generation for parent directory, so
 	 * a generation of 0 means "accept any"
 	 */
-	inode = iget(sb, ino);
-	if (inode == NULL)
-		return ERR_PTR(-ENOMEM);
-	if (is_bad_inode(inode) ||
-	    (generation && inode->i_generation != generation)) {
+	inode = ext3_iget(sb, ino);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
+	if (generation && inode->i_generation != generation) {
 		iput(inode);
 		return ERR_PTR(-ESTALE);
 	}
@@ -649,7 +648,6 @@ static struct quotactl_ops ext3_qctl_operations = {
 static const struct super_operations ext3_sops = {
 	.alloc_inode	= ext3_alloc_inode,
 	.destroy_inode	= ext3_destroy_inode,
-	.read_inode	= ext3_read_inode,
 	.write_inode	= ext3_write_inode,
 	.dirty_inode	= ext3_dirty_inode,
 	.delete_inode	= ext3_delete_inode,
@@ -1309,8 +1307,8 @@ static void ext3_orphan_cleanup (struct super_block * sb,
 	while (es->s_last_orphan) {
 		struct inode *inode;
 
-		if (!(inode =
-		      ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
+		inode = ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
+		if (IS_ERR(inode)) {
 			es->s_last_orphan = 0;
 			break;
 		}
@@ -1415,6 +1413,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
 	int db_count;
 	int i;
 	int needs_recovery;
+	int ret = -EINVAL;
 	__le32 features;
 
 	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
@@ -1770,19 +1769,25 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
 	 * so we can safely mount the rest of the filesystem now.
 	 */
 
-	root = iget(sb, EXT3_ROOT_INO);
-	sb->s_root = d_alloc_root(root);
-	if (!sb->s_root) {
+	root = ext3_iget(sb, EXT3_ROOT_INO);
+	if (IS_ERR(root)) {
 		printk(KERN_ERR "EXT3-fs: get root inode failed\n");
-		iput(root);
+		if (PTR_ERR(root) == -ENOMEM)
+			ret = -ENOMEM;
 		goto failed_mount4;
 	}
 	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
-		dput(sb->s_root);
-		sb->s_root = NULL;
+		iput(root);
 		printk(KERN_ERR "EXT3-fs: corrupt root inode, run e2fsck\n");
 		goto failed_mount4;
 	}
+	sb->s_root = d_alloc_root(root);
+	if (!sb->s_root) {
+		printk(KERN_ERR "EXT3-fs: get root dentry failed\n");
+		iput(root);
+		ret = -ENOMEM;
+		goto failed_mount4;
+	}
 
 	ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
 	/*
@@ -1834,7 +1839,7 @@ out_fail:
 	sb->s_fs_info = NULL;
 	kfree(sbi);
 	lock_kernel();
-	return -EINVAL;
+	return ret;
 }
 
 /*
@@ -1870,8 +1875,8 @@ static journal_t *ext3_get_journal(struct super_block *sb,
 	 * things happen if we iget() an unused inode, as the subsequent
 	 * iput() will try to delete it. */
 
-	journal_inode = iget(sb, journal_inum);
-	if (!journal_inode) {
+	journal_inode = ext3_iget(sb, journal_inum);
+	if (IS_ERR(journal_inode)) {
 		printk(KERN_ERR "EXT3-fs: no journal found.\n");
 		return NULL;
 	}
@@ -1884,7 +1889,7 @@ static journal_t *ext3_get_journal(struct super_block *sb,
 
 	jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
 		  journal_inode, journal_inode->i_size);
-	if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
+	if (!S_ISREG(journal_inode->i_mode)) {
 		printk(KERN_ERR "EXT3-fs: invalid journal inode.\n");
 		iput(journal_inode);
 		return NULL;
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index ece49a8..a5ccfea 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -813,7 +813,7 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
 	sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
 	int create, int extend_disksize);
 
-extern void ext3_read_inode (struct inode *);
+extern struct inode *ext3_iget (struct super_block *, unsigned long);
 extern int  ext3_write_inode (struct inode *, int);
 extern int  ext3_setattr (struct dentry *, struct iattr *);
 extern void ext3_delete_inode (struct inode *);

(unknown)

[dhowells]

>From dhowells  Mon Oct  1 14: 10:20 2007
Return-Path: <dhowells@redhat.com>
Received: from localhost.localdomain [127.0.0.1]
	by warthog.procyon.org.uk with IMAP (fetchmail-6.3.7)
	for <dhowells@localhost> (single-drop); Mon, 01 Oct 2007 14:10:20 +0100 (BST)
Received: from pobox.devel.redhat.com ([unix socket])
	 by pobox.devel.redhat.com (Cyrus v2.2.12-Invoca-RPM-2.2.12-8.1.RHEL4) with LMTPA;
	 Mon, 01 Oct 2007 09:10:18 -0400
X-Sieve: CMU Sieve 2.2
Received: from warthog.cambridge.redhat.com (devserv.devel.redhat.com [10.10.36.72])
	by pobox.devel.redhat.com (8.13.1/8.13.1) with ESMTP id l91DAHV9031008;
	Mon, 1 Oct 2007 09:10:18 -0400
Received: from [127.0.0.1] (helo=warthog.procyon.org.uk)
	by warthog.cambridge.redhat.com with esmtp (Exim 4.66 #1 (Red Hat Linux))
	id 1IcL2Q-0007fB-Eh; Mon, 01 Oct 2007 14:10:18 +0100
Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley
	Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United
	Kingdom.
	Registered in England and Wales under Company Registration No. 3798903
From: David Howells <dhowells@redhat.com>
Subject: [PATCH 11/30] IGET: Stop EXT2 from using iget() and read_inode()
To: hch@infradead.org, viro@ftp.linux.org.uk, torvalds@osdl.org,
    akpm@osdl.org
Cc: linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org,
    dhowells@redhat.com
Date: Mon, 01 Oct 2007 14:10:18 +0100
Message-ID: <20071001131018.29339.40931.stgit@warthog.procyon.org.uk>
In-Reply-To: <20071001130921.29339.72876.stgit@warthog.procyon.org.uk>
References: <20071001130921.29339.72876.stgit@warthog.procyon.org.uk>
User-Agent: StGIT/0.13
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
Resent-To: linux-ext4@vger.kernel.org
Resent-Date: Mon, 01 Oct 2007 17:00:14 +0100
Resent-Message-ID: <18957.1191254414@redhat.com>
Resent-From: David Howells <dhowells@redhat.com>

Stop the EXT2 filesystem from using iget() and read_inode().  Replace
ext2_read_inode() with ext2_iget(), and call that instead of iget().
ext2_iget() then uses iget_locked() directly and returns a proper error code
instead of an inode in the event of an error.

ext2_fill_super() returns any error incurred when getting the root inode
instead of EINVAL.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/ext2/ext2.h  |    2 +-
 fs/ext2/inode.c |   26 +++++++++++++++++++-------
 fs/ext2/namei.c |   12 ++++++------
 fs/ext2/super.c |   32 ++++++++++++++++++--------------
 4 files changed, 44 insertions(+), 28 deletions(-)

diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 9fd0ec5..85ca3de 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -123,7 +123,7 @@ extern void ext2_check_inodes_bitmap (struct super_block *);
 extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
 
 /* inode.c */
-extern void ext2_read_inode (struct inode *);
+extern struct inode *ext2_iget (struct super_block *, unsigned long);
 extern int ext2_write_inode (struct inode *, int);
 extern void ext2_put_inode (struct inode *);
 extern void ext2_delete_inode (struct inode *);
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 0079b2c..d8fb795 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1074,18 +1074,28 @@ void ext2_get_inode_flags(struct ext2_inode_info *ei)
 		ei->i_flags |= EXT2_DIRSYNC_FL;
 }
 
-void ext2_read_inode (struct inode * inode)
+struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
 {
-	struct ext2_inode_info *ei = EXT2_I(inode);
-	ino_t ino = inode->i_ino;
+	struct ext2_inode_info *ei;
 	struct buffer_head * bh;
-	struct ext2_inode * raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
+	struct ext2_inode * raw_inode;
+	struct inode *inode;
+	long ret = -EIO;
 	int n;
 
+	inode = iget_locked(sb, ino);
+	if (!inode)
+		return ERR_PTR(-ENOMEM);
+	if (!(inode->i_state & I_NEW))
+		return inode;
+
+	ei = EXT2_I(inode);
 #ifdef CONFIG_EXT2_FS_POSIX_ACL
 	ei->i_acl = EXT2_ACL_NOT_CACHED;
 	ei->i_default_acl = EXT2_ACL_NOT_CACHED;
 #endif
+
+	raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
 	if (IS_ERR(raw_inode))
  		goto bad_inode;
 
@@ -1111,6 +1121,7 @@ void ext2_read_inode (struct inode * inode)
 	if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
 		/* this inode is deleted */
 		brelse (bh);
+		ret = -ESTALE;
 		goto bad_inode;
 	}
 	inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
@@ -1180,11 +1191,12 @@ void ext2_read_inode (struct inode * inode)
 	}
 	brelse (bh);
 	ext2_set_inode_flags(inode);
-	return;
+	unlock_new_inode(inode);
+	return inode;
 	
 bad_inode:
-	make_bad_inode(inode);
-	return;
+	iget_failed(inode);
+	return ERR_PTR(ret);
 }
 
 static int ext2_update_inode(struct inode * inode, int do_sync)
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index e69beed..2dfdeaa 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -63,9 +63,9 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, str
 	ino = ext2_inode_by_name(dir, dentry);
 	inode = NULL;
 	if (ino) {
-		inode = iget(dir->i_sb, ino);
-		if (!inode)
-			return ERR_PTR(-EACCES);
+		inode = ext2_iget(dir->i_sb, ino);
+		if (IS_ERR(inode))
+			return ERR_PTR(PTR_ERR(inode));
 	}
 	return d_splice_alias(inode, dentry);
 }
@@ -83,10 +83,10 @@ struct dentry *ext2_get_parent(struct dentry *child)
 	ino = ext2_inode_by_name(child->d_inode, &dotdot);
 	if (!ino)
 		return ERR_PTR(-ENOENT);
-	inode = iget(child->d_inode->i_sb, ino);
+	inode = ext2_iget(child->d_inode->i_sb, ino);
 
-	if (!inode)
-		return ERR_PTR(-EACCES);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
 	parent = d_alloc_anon(inode);
 	if (!parent) {
 		iput(inode);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 639a32c..78641e3 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -232,7 +232,6 @@ static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *da
 static const struct super_operations ext2_sops = {
 	.alloc_inode	= ext2_alloc_inode,
 	.destroy_inode	= ext2_destroy_inode,
-	.read_inode	= ext2_read_inode,
 	.write_inode	= ext2_write_inode,
 	.put_inode	= ext2_put_inode,
 	.delete_inode	= ext2_delete_inode,
@@ -266,11 +265,10 @@ static struct dentry *ext2_get_dentry(struct super_block *sb, void *vobjp)
 	 * it might be "neater" to call ext2_get_inode first and check
 	 * if the inode is valid.....
 	 */
-	inode = iget(sb, ino);
-	if (inode == NULL)
-		return ERR_PTR(-ENOMEM);
-	if (is_bad_inode(inode) ||
-	    (generation && inode->i_generation != generation)) {
+	inode = ext2_iget(sb, ino);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
+	if (generation && inode->i_generation != generation) {
 		/* we didn't find the right inode.. */
 		iput(inode);
 		return ERR_PTR(-ESTALE);
@@ -649,6 +647,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
 	unsigned long logic_sb_block;
 	unsigned long offset = 0;
 	unsigned long def_mount_opts;
+	long ret = -EINVAL;
 	int blocksize = BLOCK_SIZE;
 	int db_count;
 	int i, j;
@@ -918,19 +917,24 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
 	sb->s_op = &ext2_sops;
 	sb->s_export_op = &ext2_export_ops;
 	sb->s_xattr = ext2_xattr_handlers;
-	root = iget(sb, EXT2_ROOT_INO);
-	sb->s_root = d_alloc_root(root);
-	if (!sb->s_root) {
-		iput(root);
-		printk(KERN_ERR "EXT2-fs: get root inode failed\n");
+	root = ext2_iget(sb, EXT2_ROOT_INO);
+	if (IS_ERR(root)) {
+		ret = PTR_ERR(root);
 		goto failed_mount3;
 	}
 	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
-		dput(sb->s_root);
-		sb->s_root = NULL;
+		iput(root);
 		printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
 		goto failed_mount3;
 	}
+
+	sb->s_root = d_alloc_root(root);
+	if (!sb->s_root) {
+		iput(root);
+		printk(KERN_ERR "EXT2-fs: get root inode failed\n");
+		ret = -ENOMEM;
+		goto failed_mount3;
+	}
 	if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 		ext2_warning(sb, __FUNCTION__,
 			"mounting ext3 filesystem as ext2");
@@ -957,7 +961,7 @@ failed_mount:
 failed_sbi:
 	sb->s_fs_info = NULL;
 	kfree(sbi);
-	return -EINVAL;
+	return ret;
 }
 
 static void ext2_commit_super (struct super_block * sb,

(unknown)

[Thomas Wallrafen]

unsubscribe

(unknown)

[Tomi Ryytti]

subscribe