Merge branch 'maint' into next

Conflicts:
	lib/ext2fs/initialize.c

diff --cc debugfs/set_fields.c
Simple merge

diff --cc e2fsck/message.c
Simple merge

diff --cc e2fsck/super.c
Simple merge

diff --cc lib/e2p/ls.c
Simple merge

diff --cc lib/ext2fs/ext2_fs.h
Simple merge

diff --cc lib/ext2fs/ext2fs.h
index a204eb7,516eb1a..d3eb31d
--- 1/lib/ext2fs/ext2fs.h
--- 2/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@@ -207,10 -195,10 +207,10 @@@ struct struct_ext2_filsys 
        char *                          device_name;
        struct ext2_super_block *       super;
        unsigned int                    blocksize;
-       int                             fragsize;
+       int                             clustersize;
        dgrp_t                          group_desc_count;
        unsigned long                   desc_blocks;
 -      struct ext2_group_desc *        group_desc;
 +      struct opaque_ext2_group_desc * group_desc;
        int                             inode_blocks_per_group;
        ext2fs_inode_bitmap             inode_map;
        ext2fs_block_bitmap             block_map;

diff --cc lib/ext2fs/initialize.c
index 4cf0863,c109d08..e1f229b
--- 1/lib/ext2fs/initialize.c
--- 2/lib/ext2fs/initialize.c
+++ b/lib/ext2fs/initialize.c
@@@ -190,11 -184,11 +188,11 @@@ errcode_t ext2fs_initialize(const char 
        set_field(s_blocks_per_group, fs->blocksize * 8);
        if (super->s_blocks_per_group > EXT2_MAX_BLOCKS_PER_GROUP(super))
                super->s_blocks_per_group = EXT2_MAX_BLOCKS_PER_GROUP(super);
-       super->s_frags_per_group = super->s_blocks_per_group * frags_per_block;
+       super->s_clusters_per_group = super->s_blocks_per_group;
  
 -      super->s_blocks_count = param->s_blocks_count;
 -      super->s_r_blocks_count = param->s_r_blocks_count;
 -      if (super->s_r_blocks_count >= param->s_blocks_count) {
 +      ext2fs_blocks_count_set(super, ext2fs_blocks_count(param));
 +      ext2fs_r_blocks_count_set(super, ext2fs_r_blocks_count(param));
 +      if (ext2fs_r_blocks_count(super) >= ext2fs_blocks_count(param)) {
                retval = EXT2_ET_INVALID_ARGUMENT;
                goto cleanup;
        }
@@@ -251,10 -236,8 +249,9 @@@ retry
                if (super->s_blocks_per_group >= 256) {
                        /* Try again with slightly different parameters */
                        super->s_blocks_per_group -= 8;
 -                      super->s_blocks_count = param->s_blocks_count;
 +                      ext2fs_blocks_count_set(super,
 +                                              ext2fs_blocks_count(param));
-                       super->s_frags_per_group = super->s_blocks_per_group *
-                               frags_per_block;
+                       super->s_clusters_per_group = super->s_blocks_per_group;
                        goto retry;
                } else {
                        retval = EXT2_ET_TOO_MANY_INODES;

diff --cc lib/ext2fs/openfs.c
Simple merge

diff --cc lib/ext2fs/swapfs.c
Simple merge

diff --cc misc/mke2fs.c
index 23f8c10,eace0d3..7866c2c
--- 1/misc/mke2fs.c
--- 2/misc/mke2fs.c
+++ b/misc/mke2fs.c
@@@ -554,21 -609,27 +554,26 @@@ static void show_stats(ext2_filsys fs
        memset(buf, 0, sizeof(buf));
        strncpy(buf, s->s_volume_name, sizeof(s->s_volume_name));
        printf(_("Filesystem label=%s\n"), buf);
 -      fputs(_("OS type: "), stdout);
 -        os = e2p_os2string(fs->super->s_creator_os);
 -      fputs(os, stdout);
 +      os = e2p_os2string(fs->super->s_creator_os);
 +      if (os)
 +              printf(_("OS type: %s\n"), os);
        free(os);
 -      printf("\n");
        printf(_("Block size=%u (log=%u)\n"), fs->blocksize,
                s->s_log_block_size);
-       printf(_("Fragment size=%u (log=%u)\n"), fs->fragsize,
-               s->s_log_frag_size);
+       if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
+                                      EXT4_FEATURE_RO_COMPAT_BIGALLOC))
+               printf(_("Cluster size=%u (log=%u)\n"),
+                      fs->clustersize, s->s_log_cluster_size);
+       else
+               printf(_("Fragment size=%u (log=%u)\n"), fs->clustersize,
+                      s->s_log_cluster_size);
        printf(_("Stride=%u blocks, Stripe width=%u blocks\n"),
               s->s_raid_stride, s->s_raid_stripe_width);
 -      printf(_("%u inodes, %u blocks\n"), s->s_inodes_count,
 -             s->s_blocks_count);
 -      printf(_("%u blocks (%2.2f%%) reserved for the super user\n"),
 -              s->s_r_blocks_count,
 -             100.0 * s->s_r_blocks_count / s->s_blocks_count);
 +      printf(_("%u inodes, %llu blocks\n"), s->s_inodes_count,
 +             ext2fs_blocks_count(s));
 +      printf(_("%llu blocks (%2.2f%%) reserved for the super user\n"),
 +              ext2fs_r_blocks_count(s),
 +             100.0 *  ext2fs_r_blocks_count(s) / ext2fs_blocks_count(s));
        printf(_("First data block=%u\n"), s->s_first_data_block);
        if (s->s_reserved_gdt_blocks)
                printf(_("Maximum filesystem blocks=%lu\n"),
@@@ -1507,17 -1550,47 +1515,17 @@@ profile_error
                check_plausibility(device_name);
        check_mount(device_name, force, _("filesystem"));
  
-       fs_param.s_log_frag_size = fs_param.s_log_block_size;
+       fs_param.s_log_cluster_size = fs_param.s_log_block_size;
  
 -      if (noaction && fs_param.s_blocks_count) {
 -              dev_size = fs_param.s_blocks_count;
 +      /* Determine the size of the device (if possible) */
 +      if (noaction && fs_blocks_count) {
 +              dev_size = fs_blocks_count;
                retval = 0;
 -      } else {
 -      retry:
 -              retval = ext2fs_get_device_size(device_name,
 -                                              EXT2_BLOCK_SIZE(&fs_param),
 -                                              &dev_size);
 -              if ((retval == EFBIG) &&
 -                  (blocksize == 0) &&
 -                  (fs_param.s_log_block_size == 0)) {
 -                      fs_param.s_log_block_size = 2;
 -                      blocksize = 4096;
 -                      goto retry;
 -              }
 -      }
 -
 -      if (retval == EFBIG) {
 -              blk64_t big_dev_size;
 -
 -              if (blocksize < 4096) {
 -                      fs_param.s_log_block_size = 2;
 -                      blocksize = 4096;
 -              }
 +      } else
                retval = ext2fs_get_device_size2(device_name,
 -                               EXT2_BLOCK_SIZE(&fs_param), &big_dev_size);
 -              if (retval)
 -                      goto get_size_failure;
 -              if (big_dev_size == (1ULL << 32)) {
 -                      dev_size = (blk_t) (big_dev_size - 1);
 -                      goto got_size;
 -              }
 -              fprintf(stderr, _("%s: Size of device %s too big "
 -                                "to be expressed in 32 bits\n\t"
 -                                "using a blocksize of %d.\n"),
 -                      program_name, device_name, EXT2_BLOCK_SIZE(&fs_param));
 -              exit(1);
 -      }
 -get_size_failure:
 +                                               EXT2_BLOCK_SIZE(&fs_param),
 +                                               &dev_size);
 +
        if (retval && (retval != EXT2_ET_UNIMPLEMENTED)) {
                com_err(program_name, retval,
                        _("while trying to determine filesystem size"));