Provided by: e2fsprogs_1.40.8-2ubuntu2_i386 bug


       mke2fs - create an ext2/ext3 filesystem


       mke2fs [ -c | -l filename ] [ -b block-size ] [ -f fragment-size ] [ -g
       blocks-per-group ] [ -i bytes-per-inode ] [ -I inode-size ] [ -j ] [ -J
       journal-options  ] [ -N number-of-inodes ] [ -n ] [ -m reserved-blocks-
       percentage ] [ -o creator-os ] [ -O feature[,...]  ] [ -q ]  [  -r  fs-
       revision-level  ]  [  -E  extended-options ] [ -v ] [ -F ] [ -L volume-
       label ] [ -M last-mounted-directory ] [ -S ] [ -T filesystem-type  ]  [
       -V ] device [ blocks-count ]

       mke2fs -O journal_dev [ -b block-size ] [ -L volume-label ] [ -n ] [ -q
       ] [ -v ] external-journal [ blocks-count ]


       mke2fs is used to create an ext2/ext3 filesystem  (usually  in  a  disk
       partition).   device  is  the  special file corresponding to the device
       (e.g /dev/hdXX).  blocks-count is the number of blocks on  the  device.
       If  omitted,  mke2fs  automagically  figures  the file system size.  If
       called as mkfs.ext3 a journal is  created  as  if  the  -j  option  was


       -b block-size
              Specify the size of blocks in bytes.  Valid block size vales are
              1024, 2048 and 4096 bytes per block.  If omitted, mke2fs  block-
              size is heuristically determined by the file system size and the
              expected usage of the filesystem (see the -T option).  If block-
              size  is  negative, then mke2fs will use heuristics to determine
              the appropriate block size, with the constraint that  the  block
              size  will  be  at  least  block-size bytes.  This is useful for
              certain hardware devices which require that the blocksize  be  a
              multiple of 2k.

       -c     Check the device for bad blocks before creating the file system.
              If this option is specified twice,  then  a  slower,  read-write
              test is used instead of a fast read-only test.

       -E extended-options
              Set  extended  options for the filesystem.  Extended options are
              comma separated, and may take an argument using the equals (’=’)
              sign.   The  -E  option  used  to  be  -R in earlier versions of
              mke2fs.   The  -R  option  is  still  accepted   for   backwards
              compatibility.   The following extended options are supported:

                          Configure  the  filesystem  for  a  RAID  array with
                          stride-size filesystem blocks. This is the number of
                          blocks read or written to disk before moving to next
                          disk. This mostly affects  placement  of  filesystem
                          metadata  like  bitmaps  at  mke2fs(2) time to avoid
                          placing them on a single disk, which  can  hurt  the
                          performanace.    It   may  also  be  used  by  block

                          Configure the  filesystem  for  a  RAID  array  with
                          stripe-width  filesystem  blocks per stripe. This is
                          typically be stride-size * N, where N is the  number
                          of  data  disks in the RAID (e.g. RAID 5 N+1, RAID 6
                          N+2).  This allows the block  allocator  to  prevent
                          read-modify-write  of the parity in a RAID stripe if
                          possible when the data is written.

                          Reserve  enough  space  so  that  the  block   group
                          descriptor  table  can  grow to support a filesystem
                          that has max-online-resize blocks.

                          Set a flag in the filesystem  superblock  indicating
                          that  it  may  be  mounted using experimental kernel
                          code, such as the ext4dev filesystem.

       -f fragment-size
              Specify the size of fragments in bytes.

       -F     Force mke2fs to create  a  filesystem,  even  if  the  specified
              device is not a partition on a block special device, or if other
              parameters do not make sense.   In  order  to  force  mke2fs  to
              create  a filesystem even if the filesystem appears to be in use
              or is mounted (a truly dangerous thing to do), this option  must
              be specified twice.

       -g blocks-per-group
              Specify  the  number  of  blocks  in  a  block  group.  There is
              generally no reason the user to ever set this parameter, as  the
              default  is optimal for the filesystem.  (For administrators who
              are creating filesystems on RAID arrays, it is preferable to use
              the  stride  RAID parameter as part of the -R option rather than
              manipulating the number of blocks per group.)   This  option  is
              generally used by developers who are developing test cases.

       -i bytes-per-inode
              Specify  the  bytes/inode  ratio.   mke2fs  creates an inode for
              every bytes-per-inode bytes of space on the  disk.   The  larger
              the  bytes-per-inode  ratio,  the  fewer inodes will be created.
              This value generally shouldn’t be smaller than the blocksize  of
              the  filesystem,  since  then  too many inodes will be made.  Be
              warned that is not possible to expand the number of inodes on  a
              filesystem  after  it  is  created,  so  be careful deciding the
              correct value for this parameter.

       -I inode-size
              Specify the  size  of  each  inode  in  bytes.   mke2fs  creates
              256-byte  inodes  by  default.  In kernels after 2.6.10 and some
              earlier vendor kernels it is possible to utilize  inodes  larger
              than   128-bytes  to  store  extended  attributes  for  improved
              performance.  The inode-size value must be a power of two larger
              or  equal  to 128.  The larger the inode-size the more space the
              inode table will consume, and this reduces the usable  space  in
              the  filesystem  and  can  also  negatively  impact performance.
              Extended attributes stored in large inodes are not visible  with
              older  kernels,  and such filesystems will not be mountable with
              2.4 kernels at all.  It is not possible  to  change  this  value
              after the filesystem is created.

       -j     Create the filesystem with an ext3 journal.  If the -J option is
              not specified, the default journal parameters will  be  used  to
              create  an  appropriately  sized  journal (given the size of the
              filesystem) stored within the filesystem.  Note that you must be
              using  a kernel which has ext3 support in order to actually make
              use of the journal.

       -J journal-options
              Create the ext3 journal using options specified on the  command-
              line.   Journal  options  are  comma  separated, and may take an
              argument using the equals (’=’)  sign.   The  following  journal
              options are supported:

                          Create  an internal journal (i.e., stored inside the
                          filesystem) of  size  journal-size  megabytes.   The
                          size of the journal must be at least 1024 filesystem
                          blocks (i.e., 1MB if using 1k blocks, 4MB  if  using
                          4k  blocks,  etc.)   and may be no more than 102,400
                          filesystem blocks.

                          Attach the filesystem to the  journal  block  device
                          located  on  external-journal.  The external journal
                          must already have been created using the command

                          mke2fs -O journal_dev external-journal

                          Note that external-journal must  have  been  created
                          with  the same block size as the new filesystem.  In
                          addition,  while  there  is  support  for  attaching
                          multiple  filesystems  to a single external journal,
                          the Linux kernel  and  e2fsck(8)  do  not  currently
                          support shared external journals yet.

                          Instead   of  specifying  a  device  name  directly,
                          external-journal can also  be  specified  by  either
                          LABEL=label  or  UUID=UUID  to  locate  the external
                          journal by either the volume label or UUID stored in
                          the  ext2  superblock  at  the start of the journal.
                          Use dumpe2fs(8) to display a journal device’s volume
                          label   and   UUID.   See  also  the  -L  option  of

              Only one of the size or  device  options  can  be  given  for  a

       -l filename
              Read  the  bad  blocks  list from filename.  Note that the block
              numbers in the bad block list must be generated using  the  same
              block  size  as  used  by mke2fs.  As a result, the -c option to
              mke2fs is a much simpler and less error-prone method of checking
              a  disk  for  bad  blocks  before  formatting it, as mke2fs will
              automatically pass  the  correct  parameters  to  the  badblocks

       -L new-volume-label
              Set  the  volume  label  for the filesystem to new-volume-label.
              The maximum length of the volume label is 16 bytes.

       -m reserved-blocks-percentage
              Specify the percentage of the filesystem blocks reserved for the
              super-user.   This  avoids  fragmentation, and allows root-owned
              daemons, such as syslogd(8), to continue to  function  correctly
              after non-privileged processes are prevented from writing to the
              filesystem.  The default percentage is 5%.

       -M     Set the last mounted directory for the filesystem.   This  might
              be  useful  for  the  sake of utilities that key off of the last
              mounted directory to determine where the  filesystem  should  be

       -n     causes  mke2fs  to not actually create a filesystem, but display
              what it would do if it were to create a filesystem.  This can be
              used  to  determine the location of the backup superblocks for a
              particular filesystem, so long as  the  mke2fs  parameters  that
              were  passed when the filesystem was originally created are used
              again.  (With the -n option added, of course!)

       -N number-of-inodes
              overrides the default calculation of the number of  inodes  that
              should  be  reserved  for  the filesystem (which is based on the
              number of blocks and the bytes-per-inode  ratio).   This  allows
              the user to specify the number of desired inodes directly.

       -o creator-os
              Manually override the default value of the "creator os" field of
              the filesystem.  Normally the creator field is set by default to
              the native OS of the mke2fs executable.

       -O feature[,...]
              Create  filesystem  with  given  features  (filesystem options),
              overriding the default filesystem options.  The default features
              which  are enabled by default are specified by the base_features
              relation,  either  in   the   [libdefaults]   section   in   the
              /etc/mke2fs.conf configuration file, or in the subsection of the
              [fs_types] section for the filesystem type as specified  by  the
              -T  option.   The filesystem type-specific configuration setting
              found in the [fs_types] section will override the global default
              found in [libdefaults].

              The  filesystem  feature set will be further edited using either
              the feature set specification specified by this  option,  or  if
              this  option  is not specified, by the default_features relation
              for the filesystem type being created, or in  the  [libdefaults]
              section of the configuration file.

              The  filesystem  feature set is comprised of a list of features,
              separated by commas, that are  to  be  enabled.   To  disable  a
              feature,  simply  prefix  the  feature  name with a  caret (’^’)
              character.  The pseudo-filesystem feature "none" will clear  all
              filesystem features.

                          Filesystem  can  contain files that are greater than
                          2GB.  (Modern kernels set this feature automatically
                          when a file > 2GB is created.)

                          Use  hashed  b-trees  to  speed  up lookups in large

                          Store file type information in directory entries.

                          Create an ext3 journal (as if using the -j  option).

                          Create  an external ext3 journal on the given device
                          instead of a regular  ext2  filesystem.   Note  that
                          external-journal must be created with the same block
                          size as the filesystems that will be using it.

                          Reserve space so the block  group  descriptor  table
                          may  grow in the future.  Useful for online resizing
                          using resize2fs.  By default mke2fs will attempt  to
                          reserve enough space so that the filesystem may grow
                          to 1024 times its initial size.  This can be changed
                          using resize extended option.

                          Create  a  filesystem  with  fewer superblock backup
                          copies (saves space on large filesystems).

       -q     Quiet execution.  Useful if mke2fs is run in a script.

       -r revision
              Set the filesystem revision for the new filesystem.   Note  that
              1.2 kernels only support revision 0 filesystems.  The default is
              to create revision 1 filesystems.

       -S     Write superblock and group descriptors only.  This is useful  if
              all  of the superblock and backup superblocks are corrupted, and
              a last-ditch recovery method is desired.  It  causes  mke2fs  to
              reinitialize  the  superblock  and  group descriptors, while not
              touching the inode table and the block and inode  bitmaps.   The
              e2fsck  program  should  be run immediately after this option is
              used,  and  there  is  no  guarantee  that  any  data  will   be
              salvageable.   It  is critical to specify the correct filesystem
              blocksize when using this option,  or  there  is  no  chance  of

       -T fs-type
              Specify  how  the filesystem is going to be used, so that mke2fs
              can choose optimal filesystem  parameters  for  that  use.   The
              filesystem  types  that  are can be supported are defined in the
              configuration    file    /etc/mke2fs.conf(5).     The    default
              configuration  file  contains  definitions  for  the  filesystem
              types: small, floppy, news, largefile, and largefile4.

       -v     Verbose execution.

       -V     Print the version number of mke2fs and exit.


       This  version  of  mke2fs   has   been   written   by   Theodore   Ts’o


       mke2fs  accepts  the  -f  option  but  currently ignores it because the
       second extended file system does not support fragments yet.
       There may be other ones.  Please, report them to the author.


       mke2fs  is  part  of  the  e2fsprogs  package  and  is  available  from


       mke2fs.conf(5), badblocks(8), dumpe2fs(8), e2fsck(8), tune2fs(8)