Unix/Linux Go Back    

man page for mkfs.ext4 (all section 8)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

MKE2FS(8) 										  MKE2FS(8) 

       mke2fs - create an ext2/ext3/ext4 filesystem

       mke2fs [ -c | -l filename ] [ -b block-size ] [ -f fragment-size ] [ -g blocks-per-group ]
       [ -G number-of-groups ] [ -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 fs-type ] [ -T usage-
       type ] [ -U UUID ] [ -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, or ext4 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  speci-

       The  defaults of the parameters for the newly created filesystem, if not overridden by the
       options listed below, are controlled by the /etc/mke2fs.conf configuration file.  See  the
         mke2fs.conf(5)  manual page for more details.

       -b block-size
	      Specify  the  size  of blocks in bytes.  Valid block-size values are 1024, 2048 and
	      4096 bytes per block.  If omitted, block-size is heuristically  determined  by  the
	      filesystem  size	and the expected usage of the filesystem (see the -T option).  If
	      block-size is preceded by a negative sign ('-'), 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

       -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 compati-
	      bility.	The following extended options are supported:

			  Adjust the initial MMP update interval to interval seconds.  Specifying
			  an  interval	of  0  means  to use the default interval.  The specified
			  interval must be less than 300 seconds.  Requires that the mmp  feature
			  be enabled.

			  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  the  next disk, which is sometimes referred to as the chunk
			  size.  This mostly affects placement of filesystem metadata  like  bit-
			  maps	at  mke2fs time to avoid placing them on a single disk, which can
			  hurt performance.  It may also be used by the block allocator.

			  Configure the filesystem for a RAID array with stripe-width  filesystem
			  blocks  per  stripe.	This is typically stride-size * N, where N is the
			  number of data-bearing disks in the RAID (e.g. for RAID 5 there is  one
			  parity  disk,  so  N will be the number of disks in the array minus 1).
			  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.

		   lazy_itable_init[= <0 to disable, 1 to enable>]
			  If enabled and the uninit_bg feature is enabled, the inode  table  will
			  not be fully initialized by mke2fs.  This speeds up filesystem initial-
			  ization noticeably, but it requires the kernel to  finish  initializing
			  the  filesystem in the background when the filesystem is first mounted.
			  If the option value is omitted, it defaults to 1 to enable  lazy  inode
			  table zeroing.

		   lazy_journal_init[= <0 to disable, 1 to enable>]
			  If  enabled,	the journal inode will not be fully zeroed out by mke2fs.
			  This speeds up filesystem initialization noticeably, but  carries  some
			  small  risk if the system crashes before the journal has been overwrit-
			  ten entirely one time.  If the option value is omitted, it defaults  to
			  1 to enable lazy journal inode zeroing.

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

			  Attempt to discard blocks at mkfs time (discarding blocks initially  is
			  useful  on  solid state devices and sparse / thin-provisioned storage).
			  When the device advertises that discard also zeroes  data  (any  subse-
			  quent  read after the discard and before write returns zero), then mark
			  all not-yet-zeroed inode tables as zeroed. This significantly speeds up
			  filesystem initialization. This is set as default.

			  Do not attempt to discard blocks at mkfs time.

			  Specify  which  quota  type ('usr' or 'grp') is to be initialized. This
			  option has any effect only  if  quota  feature  is  set.  Without  this
			  extended  option,  the  default behavior is to initialize both user and
			  group quotas.

       -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  parti-
	      tion 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 for
	      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 -E option rather than  manipulating
	      the  number  of blocks per group.)  This option is generally used by developers who
	      are developing test cases.

       -G number-of-groups
	      Specify the number of block groups that will be packed together to create a  larger
	      virtual  block  group  (or  "flex_bg  group") in an ext4 filesystem.  This improves
	      meta-data locality and performance on meta-data heavy  workloads.   The  number  of
	      groups  must  be	a  power of 2 and may only be specified if the flex_bg filesystem
	      feature is enabled.

       -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 in that case more inodes would be made than can ever be used.
	      Be warned that it 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 per-
	      formance.  The inode-size value must be a power of 2 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

       -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 10,240,000 filesystem blocks  or
			  half the total file system size (whichever is smaller)

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

			  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

			  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
			    tune2fs(8) .

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

       -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 program.

       -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  con-
	      tinue to function correctly after non-privileged processes are prevented from writ-
	      ing to the filesystem.  The default percentage is 5%.

       -M last-mounted-directory
	      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 mounted.

       -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
	      Overrides the default value of the "creator operating system" field of the filesys-
	      tem.   The  creator  field  is set by default to the name of the OS the mke2fs exe-
	      cutable was compiled for.

       -O feature[,...]
	      Create a filesystem with the given features (filesystem  options),  overriding  the
	      default filesystem options.  The features that are enabled by default are specified
	      by  the  base_features  relation,  either  in  the  [defaults]   section	 in   the
	      /etc/mke2fs.conf configuration file, or in the [fs_types] subsections for the usage
	      types as specified by the -T option, further  modified  by  the  features  relation
	      found  in  the  [fs_types] subsections for the filesystem and usage types.  See the
	        mke2fs.conf(5)  manual page for more details.  The filesystem type-specific configu-
	      ration  setting  found  in  the [fs_types] section will override the global default
	      found in [defaults].

	      The filesystem feature set will be further edited  using	either	the  feature  set
	      specified  by  this option, or if this option is not given, by the default_features
	      relation for the filesystem type being created, or in the [defaults] 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.

			  Use hashed b-trees to speed up lookups in large directories.

		   extent Instead of using the indirect block scheme for storing the location  of
			  data	blocks	in  an	inode,	use extents instead.  This is a much more
			  efficient encoding which speeds up filesystem  access,  especially  for
			  large files.

			  Store file type information in directory entries.

			  Allow  the  per-block  group	metadata  (allocation  bitmaps	and inode
			  tables) to be placed anywhere  on  the  storage  media.   In	addition,
			  mke2fs will place the per-block group metadata together starting at the
			  first block group of each "flex_bg group".   The size  of  the  flex_bg
			  group can be specified using the -G option.

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

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

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

		   quota  Create quota inodes (inode# 3 for userquota  and  inode#  4  for  group
			  quota)  and  set them in the superblock.  With this feature, the quotas
			  will be enabled automatically when the filesystem is mounted.

			  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 the resize
			  extended option.

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

			  Create a filesystem without initializing all of the block groups.  This
			  feature also enables checksums  and  highest-inode-used  statistics  in
			  each	blockgroup.   This  feature can speed up filesystem creation time
			  noticeably (if lazy_itable_init is enabled), and can also reduce e2fsck
			  time	dramatically.	It  is	only  supported by the ext4 filesystem in
			  recent Linux kernels.

       -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 guar-
	      antee 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 recovery.

       -t fs-type
	      Specify  the  filesystem type (i.e., ext2, ext3, ext4, etc.) that is to be created.
	      If this option is not specified, mke2fs will pick a default either via how the com-
	      mand  was run (for example, using a name of the form mkfs.ext2, mkfs.ext3, etc.) or
	      via a default as defined by the /etc/  mke2fs.conf(5)  file.    This  option  controls
	      which  filesystem  options  are used by default, based on the fstypes configuration
	      stanza in /etc/  mke2fs.conf(5) .

	      If the -O option is used to explicitly add or remove filesystem options that should
	      be  set  in  the newly created filesystem, the resulting filesystem may not be sup-
	      ported by the requested fs-type.	(e.g., "mke2fs -t ext3 -O extent /dev/sdXX"  will
	      create  a  filesystem  that is not supported by the ext3 implementation as found in
	      the Linux kernel; and "mke2fs -t ext3 -O	^has_journal  /dev/hdXX"  will	create	a
	      filesystem that does not have a journal and hence will not be supported by the ext3
	      filesystem code in the Linux kernel.)

       -T usage-type[,...]
	      Specify how the filesystem is going to be used, so that mke2fs can  choose  optimal
	      filesystem parameters for that use.  The usage types that are supported are defined
	      in the configuration file /etc/  mke2fs.conf(5) .  The user may specify  one  or  more
	      usage types using a comma separated list.

	      If  this	option	is is not specified, mke2fs will pick a single default usage type
	      based on the size of the filesystem to be created.  If the filesystem size is  less
	      than  or	equal to 3 megabytes, mke2fs will use the filesystem type floppy.  If the
	      filesystem size is greater than  3  but  less  than  or  equal  to  512  megabytes,
	        mke2fs(8)   will  use  the filesystem type small.	If the filesystem size is greater
	      than or equal to 4 terabytes but less than 16 terabytes,	  mke2fs(8)   will  use  the
	      filesystem  type	big.   If the filesystem size is greater than or equal to 16 ter-
	      abytes,   mke2fs(8)  will use the filesystem type huge.  Otherwise,   mke2fs(8)  will use
	      the default filesystem type default.

       -U UUID
	      Create the filesystem with the specified UUID.

       -v     Verbose execution.

       -V     Print the version number of mke2fs and exit.

	      If  set to non-zero integer value, its value is used to determine how often   sync(2) 
	      is called during inode table initialization.

	      Determines the location of the configuration file (see   mke2fs.conf(5) ).

	      If set to non-zero integer value, its value is used to determine first  meta  block
	      group. This is mostly for debugging purposes.

	      If  set  to  non-zero integer value, its value is used to determine physical sector
	      size of the device.

	      If set, do not show the message of filesystem automatic check caused by mount count
	      or check interval.

       This version of mke2fs has been written by Theodore Ts'o <tytso@mit.edu>.

       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  http://e2fsprogs.source-

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

E2fsprogs version 1.42			  November 2011 				  MKE2FS(8)
Unix & Linux Commands & Man Pages : ©2000 - 2017 Unix and Linux Forums

All times are GMT -4. The time now is 11:55 PM.