ext4 manpage

Search topic Section

EXT4(5)			      File Formats Manual		       EXT4(5)

       ext2 - the second extended file system
       ext3 - the third extended file system
       ext4 - the fourth extended file system

       The second, third, and fourth extended file systems, or ext2, ext3, and
       ext4 as they are commonly known, are Linux file systems that have  his-
       torically  been	the  default file system for many Linux distributions.
       They are general purpose file  systems  that  have  been	 designed  for
       extensibility and backwards compatibility.  In particular, file systems
       previously intended for use with the ext2 and ext3 file systems can  be
       mounted	using  the  ext4 file system driver, and indeed in many modern
       Linux distributions, the ext4 file system driver has been configured to
       handle mount requests for ext2 and ext3 file systems.

       A  file	system formatted for ext2, ext3, or ext4 can have some collec-
       tion of the following file system feature flags enabled.	 Some of these
       features	 are  not  supported by all implementations of the ext2, ext3,
       and ext4 file system drivers, depending on Linux kernel version in use.
       On  other  operating  systems,  such as the GNU/HURD or FreeBSD, only a
       very restrictive set of file system features may be supported in	 their
       implementations of ext2.

	      Enables  the  file  system  to be larger than 2^32 blocks.  This
	      feature is set automatically, as needed, but it can be useful to
	      specify this feature explicitly if the file system might need to
	      be resized larger than 2^32 blocks, even if it was smaller  than
	      that  threshold  when it was originally created.	Note that some
	      older kernels and older versions of e2fsprogs will  not  support
	      file systems with this ext4 feature enabled.

	      This  ext4  feature  enables clustered block allocation, so that
	      the unit of allocation is a power of two number of blocks.  That
	      is,  each	 bit  in  the what had traditionally been known as the
	      block allocation bitmap now indicates whether a  cluster	is  in
	      use or not, where a cluster is by default composed of 16 blocks.
	      This feature can decrease the time spent on doing block  alloca-
	      tion  and	 brings	 smaller  fragmentation,  especially for large
	      files.  The size can be specified using the mke2fs -C option.

	      Warning: The bigalloc feature is still  under  development,  and
	      may  not be fully supported with your kernel or may have various
	      bugs.    Please	see   the   web	  page	 http://ext4.wiki.ker-
	      nel.org/index.php/Bigalloc  for details.	May clash with delayed
	      allocation (see nodelalloc mount option).

	      This feature requires that the extent feature be enabled.

	      Use hashed b-trees to speed up name lookups  in  large  directo-
	      ries.   This feature is supported by ext3 and ext4 file systems,
	      and is ignored by ext2 file systems.

	      Normally, ext4 allows an inode to have no more than 65,000  hard
	      links.   This  applies  to regular files as well as directories,
	      which means that there can be no more than 64,998 subdirectories
	      in  a  directory	(because  each of the '.' and '..' entries, as
	      well as the directory entry for  the  directory  in  its	parent
	      directory counts as a hard link).	 This feature lifts this limit
	      by causing ext4 to use a link count of 1 to  indicate  that  the
	      number  of  hard links to a directory is not known when the link
	      count might exceed the maximum count limit.

	      This ext4 feature provides file-system level encryption of  data
	      blocks  and  file	 names.	  The inode metadata (timestamps, file
	      size, user/group ownership, etc.) is not encrypted.

	      This feature is most useful on file systems with multiple users,
	      or  where not all files should be encrypted.  In many use cases,
	      especially on  single-user  systems,  encryption	at  the	 block
	      device layer using dm-crypt may provide much better security.

	      This  feature enables the use of extended attributes.  This fea-
	      ture is supported by ext2, ext3, and ext4.

	      This ext4 feature allows the mapping of  logical	block  numbers
	      for  a particular inode to physical blocks on the storage device
	      to be stored using an extent tree, which	is  a  more  efficient
	      data  structure  than the traditional indirect block scheme used
	      by the ext2 and ext3 file systems.  The use of the  extent  tree
	      decreases	 metadata block overhead, improves file system perfor-
	      mance, and decreases the needed to run  e2fsck(8)	 on  the  file
	      system.	(Note:	both  extent and extents are accepted as valid
	      names for this feature  for  historical/backwards	 compatibility

	      This  ext4  feature  reserves a specific amount of space in each
	      inode for extended metadata such as  nanosecond  timestamps  and
	      file  creation  time,  even  if the current kernel does not cur-
	      rently need to reserve this much space.  Without	this  feature,
	      the kernel will reserve the amount of space for features it cur-
	      rently  needs,  and  the	rest  may  be  consumed	 by   extended

	      For  this	 feature to be useful the inode size must be 256 bytes
	      in size or larger.

	      This feature enables the storage of  file	 type  information  in
	      directory entries.  This feature is supported by ext2, ext3, and

	      This ext4 feature allows the per-block group  metadata  (alloca-
	      tion  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  a	 journal  to ensure filesystem consistency even across
	      unclean shutdowns.  Setting the filesystem feature is equivalent
	      to  using the -j option with mke2fs or tune2fs.  This feature is
	      supported by ext3 and ext4, and ignored by the ext2 file	system

	      This  ext4 feature allows files to be larger than 2 terabytes in

	      Allow data to be stored in  the  inode  and  extended  attribute

	      This  feature  is enabled on the superblock found on an external
	      journal device.  The block size for the external journal must be
	      the same as the file system which uses it.

	      The  external  journal  device  can  be used by a file system by
	      specifying the -J device=<external-device> option	 to  mke2fs(8)
	      or tune2fs(8).

	      This  feature flag is set automatically by modern kernels when a
	      file larger than 2 gigabytes is created.	Very old kernels could
	      not  handle  large  files, so this feature flag was used to pro-
	      hibit those kernels from mounting file systems that  they	 could
	      not understand.

	      This  ext4  feature  allows  file	 systems to be resized on-line
	      without explicitly needing to reserve space for  growth  in  the
	      size  of	the block group descriptors.  This scheme is also used
	      to resize file systems which are larger than 2^32 blocks.	 It is
	      not  recommended	that this feature be set when a file system is
	      created, since this alternate method of storing the block	 group
	      descriptors  will	 slow  down  the time needed to mount the file
	      system, and newer kernels can automatically set this feature  as
	      necessary when doing an online resize and no more reserved space
	      is available in the resize inode.

	      This ext4 feature provides multiple mount protection (MMP).  MMP
	      helps  to protect the filesystem from being multiply mounted and
	      is useful in shared storage environments.

	      Causes the quota files (i.e., user.quota and  group.quota	 which
	      existed in the older quota design) to be hidden inodes.

	      This ext4 feature provides project quota support. With this fea-
	      ture, the project ID of inode will be managed when the  filesys-
	      tem is mounted.

	      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

	      This file system feature indicates that space has been  reserved
	      so  that	the block group descriptor table can be extended while
	      resizing a mounted file system.  The online resize operation  is
	      carried  out  by	the  kernel,  triggered	 by  resize2fs(8).  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.

	      This feature requires that the sparse_super feature be enabled.

	      This file system feature is set on all modern  ext2,  ext3,  and
	      ext4  file  systems.   It	 indicates  that  backup copies of the
	      superblock and block group descriptors are present only in a few
	      block groups, not all of them.

	      This  feature  indicates	that  there  will  only be at most two
	      backup superblocks  and  block  group  descriptors.   The	 block
	      groups  used  to	store  the backup superblock(s) and blockgroup
	      descriptor(s) are stored in the superblock, but  typically,  one
	      will  be	located at the beginning of block group #1, and one in
	      the last block group in the file system.	This feature is essen-
	      tially a more extreme version of sparse_super and is designed to
	      allow a much larger percentage of the disk  to  have  contiguous
	      blocks available for data files.

	      This  ext4  file	system	feature indicates that the block group
	      descriptors will be protected using checksums,  making  it  safe
	      for  mke2fs(8)  to create a file system without initializing all
	      of the block groups.  The kernel will keep a high	 watermark  of
	      unused  inodes,  and  initialize inode tables and blocks lazily.
	      This feature speeds up the time to check the file	 system	 using
	      e2fsck(8), and it also speeds up the time required for mke2fs(8)
	      to create the file system.

       This section describes mount options which are specific to ext2,	 ext3,
       and  ext4.   Other  generic  mount  options  may	 be  used as well; see
       mount(8) for details.

Mount options for ext2
       The `ext2' filesystem is the standard Linux  filesystem.	  Since	 Linux
       2.5.46,	for  most  mount  options  the	default	 is  determined by the
       filesystem superblock. Set them with tune2fs(8).

	      Support POSIX Access Control Lists (or  not).   See  the	acl(5)
	      manual page.

	      Set  the behavior for the statfs system call. The minixdf behav-
	      ior is to return in the  f_blocks	 field	the  total  number  of
	      blocks of the filesystem, while the bsddf behavior (which is the
	      default) is to subtract the overhead blocks  used	 by  the  ext2
	      filesystem and not available for file storage. Thus

	      % mount /k -o minixdf; df /k; umount /k

	      Filesystem  1024-blocks	Used  Available	 Capacity  Mounted on
	      /dev/sda6	    2630655    86954   2412169	    3%	   /k

	      % mount /k -o bsddf; df /k; umount /k

	      Filesystem  1024-blocks  Used  Available	Capacity  Mounted on
	      /dev/sda6	    2543714	 13   2412169	   0%	  /k

	      (Note  that  this	 example  shows	 that one can add command line
	      options to the options given in /etc/fstab.)

       check=none or nocheck
	      No checking is done at mount time. This is the default. This  is
	      fast.   It  is wise to invoke e2fsck(8) every now and then, e.g.
	      at  boot	time.  The   non-default   behavior   is   unsupported
	      (check=normal  and check=strict options have been removed). Note
	      that these mount options don't have to be supported if ext4 ker-
	      nel driver is used for ext2 and ext3 filesystems.

       debug  Print debugging info upon each (re)mount.

	      Define  the  behavior  when  an  error  is encountered.  (Either
	      ignore errors and just mark the filesystem  erroneous  and  con-
	      tinue,  or  remount  the filesystem read-only, or panic and halt
	      the system.)  The default is set in the  filesystem  superblock,
	      and can be changed using tune2fs(8).

       grpid|bsdgroups and nogrpid|sysvgroups
	      These  options  define  what group id a newly created file gets.
	      When grpid is set, it takes the group id	of  the	 directory  in
	      which  it is created; otherwise (the default) it takes the fsgid
	      of the current process, unless the directory has the setgid  bit
	      set,  in	which case it takes the gid from the parent directory,
	      and also gets the setgid bit set if it is a directory itself.

	      The usrquota (same as quota) mount  option  enables  user	 quota
	      support  on  the	filesystem. grpquota enables group quotas sup-
	      port. You need the quota utilities to actually enable and manage
	      the quota system.

	      Disables	32-bit	UIDs  and  GIDs.  This is for interoperability
	      with older kernels which only store and expect 16-bit values.

       oldalloc or orlov
	      Use old allocator or Orlov allocator for new  inodes.  Orlov  is

       resgid=n and resuid=n
	      The  ext2 filesystem reserves a certain percentage of the avail-
	      able space (by default 5%, see mke2fs(8) and tune2fs(8)).	 These
	      options  determine  who  can use the reserved blocks.  (Roughly:
	      whoever has the specified	 uid,  or  belongs  to	the  specified

       sb=n   Instead  of  block  1,  use block n as superblock. This could be
	      useful when the filesystem has been damaged.   (Earlier,	copies
	      of  the  superblock would be made every 8192 blocks: in block 1,
	      8193, 16385, ... (and one got  thousands	of  copies  on	a  big
	      filesystem).  Since  version  1.08,  mke2fs  has	a  -s  (sparse
	      superblock) option to reduce the number of  backup  superblocks,
	      and  since  version 1.15 this is the default. Note that this may
	      mean that ext2 filesystems created by a recent mke2fs cannot  be
	      mounted  r/w under Linux 2.0.*.)	The block number here uses 1 k
	      units. Thus, if you  want	 to  use  logical  block  32768	 on  a
	      filesystem with 4 k blocks, use "sb=131072".

	      Support "user." extended attributes (or not).

Mount options for ext3
       The  ext3 filesystem is a version of the ext2 filesystem which has been
       enhanced with journaling.  It supports the same options as ext2 as well
       as the following additions:

	      When  the	 external  journal  device's  major/minor numbers have
	      changed, these options allow the user to specify the new journal
	      location.	  The  journal device is identified either through its
	      new major/minor numbers encoded in devnum, or via a path to  the

	      Don't load the journal on mounting.  Note that if the filesystem
	      was not unmounted cleanly, skipping the journal replay will lead
	      to  the  filesystem  containing inconsistencies that can lead to
	      any number of problems.

	      Specifies the journaling mode for file data.  Metadata is always
	      journaled.  To use modes other than ordered on the root filesys-
	      tem, pass the mode to the kernel as boot parameter,  e.g.	 root-

		     All  data	is  committed  into the journal prior to being
		     written into the main filesystem.

		     This is the default mode.	All data  is  forced  directly
		     out  to  the main file system prior to its metadata being
		     committed to the journal.

		     Data ordering is not preserved - data may be written into
		     the main filesystem after its metadata has been committed
		     to the journal.  This is  rumoured	 to  be	 the  highest-
		     throughput	 option.   It  guarantees  internal filesystem
		     integrity, however it can allow old  data	to  appear  in
		     files after a crash and journal recovery.

	      Just  print  an  error message if an error occurs in a file data
	      buffer in ordered mode.

	      Abort the journal if an error occurs in a file  data  buffer  in
	      ordered mode.

       barrier=0 / barrier=1
	      This  disables  /	 enables  the use of write barriers in the jbd
	      code.  barrier=0 disables,  barrier=1  enables  (default).  This
	      also requires an IO stack which can support barriers, and if jbd
	      gets an error on a barrier write, it will disable barriers again
	      with  a warning.	Write barriers enforce proper on-disk ordering
	      of journal commits, making volatile disk write  caches  safe  to
	      use,  at	some  performance penalty.  If your disks are battery-
	      backed in one way or  another,  disabling	 barriers  may	safely
	      improve performance.

	      Start  a	journal commit every nrsec seconds.  The default value
	      is 5 seconds.  Zero means default.

	      Enable Extended User Attributes. See the attr(5) manual page.

	      Apart from the old quota system (as in  ext2,  jqfmt=vfsold  aka
	      version  1 quota) ext3 also supports journaled quotas (version 2
	      quota). jqfmt=vfsv0 enables journaled quotas. For journaled quo-
	      tas     the     mount    options	  usrjquota=aquota.user	   and
	      grpjquota=aquota.group are required to  tell  the	 quota	system
	      which  quota  database  files  to use. Journaled quotas have the
	      advantage that even after a crash no quota check is required.

Mount options for ext4
       The ext4 filesystem is an advanced level of the ext3  filesystem	 which
       incorporates  scalability  and  reliability enhancements for supporting
       large filesystem.

       The options  journal_dev,  norecovery,  noload,	data,  commit,	orlov,
       oldalloc,   [no]user_xattr  [no]acl,  bsddf,  minixdf,  debug,  errors,
       data_err, grpid, bsdgroups, nogrpid  sysvgroups,	 resgid,  resuid,  sb,
       quota,  noquota,	 nouid32,  grpquota, usrquota usrjquota, grpjquota and
       jqfmt are backwardly compatible with ext3 or ext2.

	      Enable checksumming of  the  journal  transactions.   This  will
	      allow  the recovery code in e2fsck and the kernel to detect cor-
	      ruption in the kernel.  It is a compatible change	 and  will  be
	      ignored by older kernels.

	      Commit block can be written to disk without waiting for descrip-
	      tor blocks. If enabled older kernels cannot  mount  the  device.
	      This will enable 'journal_checksum' internally.

       barrier=0 / barrier=1 / barrier / nobarrier
	      These  mount options have the same effect as in ext3.  The mount
	      options "barrier" and "nobarrier" are added for consistency with
	      other ext4 mount options.

	      The ext4 filesystem enables write barriers by default.

	      This tuning parameter controls the maximum number of inode table
	      blocks that ext4's inode table readahead algorithm will pre-read
	      into  the	 buffer	 cache.	  The  value must be a power of 2. The
	      default value is 32 blocks.

	      Number of filesystem blocks that mballoc will  try  to  use  for
	      allocation  size	and alignment. For RAID5/6 systems this should
	      be the number of data disks *  RAID  chunk  size	in  filesystem

	      Deferring block allocation until write-out time.

	      Disable  delayed	allocation.  Blocks are allocated when data is
	      copied from user to page cache.

	      Maximum amount of time ext4 should wait for additional  filesys-
	      tem  operations  to  be  batch together with a synchronous write
	      operation. Since a synchronous write operation is going to force
	      a	 commit	 and then a wait for the I/O complete, it doesn't cost
	      much, and can be a huge throughput win,  we  wait	 for  a	 small
	      amount of time to see if any other transactions can piggyback on
	      the synchronous write. The algorithm used is designed  to	 auto-
	      matically	 tune  for  the	 speed	of  the disk, by measuring the
	      amount of time (on average) that it takes to finish committing a
	      transaction. Call this time the "commit time".  If the time that
	      the transaction has been running is less than the	 commit	 time,
	      ext4 will try sleeping for the commit time to see if other oper-
	      ations will join the transaction. The commit time is  capped  by
	      the  max_batch_time,  which  defaults  to 15000 us (15 ms). This
	      optimization   can   be	turned	 off   entirely	  by   setting
	      max_batch_time to 0.

	      This  parameter  sets the commit time (as described above) to be
	      at least	min_batch_time.	 It  defaults  to  zero	 microseconds.
	      Increasing  this	parameter may improve the throughput of multi-
	      threaded, synchronous workloads on very fast disks, at the  cost
	      of increasing latency.

	      The  I/O priority (from 0 to 7, where 0 is the highest priority)
	      which should be used for I/O operations submitted by  kjournald2
	      during  a	 commit	 operation.   This  defaults  to 3, which is a
	      slightly higher priority than the default I/O priority.

       abort  Simulate the effects of calling ext4_abort() for debugging  pur-
	      poses.   This  is	 normally  used	 while remounting a filesystem
	      which is already mounted.

	      Many broken applications don't use fsync() when replacing exist-
	      ing files via patterns such as

	      fd  = open("foo.new")/write(fd,...)/close(fd)/ rename("foo.new",

	      or worse yet

	      fd = open("foo", O_TRUNC)/write(fd,...)/close(fd).

	      If auto_da_alloc is enabled, ext4 will detect  the  replace-via-
	      rename  and  replace-via-truncate	 patterns  and	force that any
	      delayed allocation blocks are allocated such that	 at  the  next
	      journal  commit,	in  the	 default  data=ordered	mode, the data
	      blocks of the new file are forced to disk	 before	 the  rename()
	      operation is committed.  This provides roughly the same level of
	      guarantees as ext3, and avoids the  "zero-length"	 problem  that
	      can  happen  when a system crashes before the delayed allocation
	      blocks are forced to disk.

	      Do not initialize any uninitialized inode table  blocks  in  the
	      background.  This	 feature  may  be used by installation CD's so
	      that the install process can complete as	quickly	 as  possible;
	      the  inode  table	 initialization process would then be deferred
	      until the next time the filesystem is mounted.

	      The lazy itable init code will wait n times the number  of  mil-
	      liseconds	 it  took to zero out the previous block group's inode
	      table. This minimizes the impact on system performance while the
	      filesystem's inode table is being initialized.

	      Controls	whether ext4 should issue discard/TRIM commands to the
	      underlying block device when blocks are freed.  This  is	useful
	      for  SSD	devices	 and sparse/thinly-provisioned LUNs, but it is
	      off by default until sufficient testing has been done.

	      This options enables/disables the in-kernel facility for	track-
	      ing  filesystem metadata blocks within internal data structures.
	      This allows multi-block allocator and other routines to  quickly
	      locate  extents  which  might  overlap  with filesystem metadata
	      blocks. This option is intended for debugging purposes and since
	      it negatively affects the performance, it is off by default.

	      Controls whether or not ext4 should use the DIO read locking. If
	      the dioread_nolock option is specified ext4 will allocate unini-
	      tialized	extent	before	buffer write and convert the extent to
	      initialized after IO completes.  This approach allows ext4  code
	      to  avoid	 using inode mutex, which improves scalability on high
	      speed storages. However this does not work with data  journaling
	      and  dioread_nolock  option will be ignored with kernel warning.
	      Note that dioread_nolock code path is only used for extent-based
	      files.  Because of the restrictions this options comprises it is
	      off by default (e.g. dioread_lock).

	      This limits the size of the directories so that any  attempt  to
	      expand  them  beyond the specified limit in kilobytes will cause
	      an ENOSPC error. This is useful in  memory-constrained  environ-
	      ments, where a very large directory can cause severe performance
	      problems or even provoke the Out Of Memory killer. (For example,
	      if there is only 512 MB memory available, a 176 MB directory may
	      seriously cramp the system's style.)

	      Enable 64-bit inode version  support.  This  option  is  off  by

       The ext2, ext3, and ext4 filesystems support setting the following file
       attributes on Linux systems using the chattr(1) utility:

       a - append only

       A - no atime updates

       d - no dump

       D - synchronous directory updates

       i - immutable

       S - synchronous updates

       u - undeletable

       In addition, the ext3 and ext4 filesystems support the following flag:

       j - data journaling

       Finally, the ext4 filesystem also supports the following flag:

       e - extents format

       For  descriptions  of  these  attribute	flags,	please	refer  to  the
       chattr(1) man page.

       This  section lists the file system driver (e.g., ext2, ext3, ext4) and
       upstream kernel version where a particular file system feature was sup-
       ported.	 Note  that  in	 some cases the feature was present in earlier
       kernel versions, but there were known, serious bugs.   In  other	 cases
       the feature may still be considered in an experimental state.  Finally,
       note that some distributions may have backported	 features  into	 older
       kernels;	 in particular the kernel versions in certain "enterprise dis-
       tributions" can be extremely misleading.

       filetype		   ext2, 2.2.0

       sparse_super	   ext2, 2.2.0

       large_file	   ext2, 2.2.0

       has_journal	   ext3, 2.4.15

       ext_attr		   ext2/ext3, 2.6.0

       dir_index	   ext3, 2.6.0

       resize_inode	   ext3, 2.6.10 (online resizing)

       64bit		   ext4, 2.6.28

       dir_nlink	   ext4, 2.6.28

       extent		   ext4, 2.6.28

       extra_isize	   ext4, 2.6.28

       flex_bg		   ext4, 2.6.28

       huge_file	   ext4, 2.6.28

       meta_bg		   ext4, 2.6.28

       uninit_bg	   ext4, 2.6.28

       mmp		   ext4, 3.0

       bigalloc		   ext4, 3.2

       quota		   ext4, 3.6

       inline_data	   ext4, 3.8

       sparse_super2	   ext4, 3.16

       metadata_csum	   ext4, 3.18

       encrypt		   ext4, 4.1

       project		   ext4, 4.5

       mke2fs(8),   mke2fs.conf(5),   e2fsck(8),   dumpe2fs(8),	   tune2fs(8),
       debugfs(8), mount(8), chattr(1)

E2fsprogs version 1.43.5	  August 2017			       EXT4(5)