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
       handle mount requests for ext2 and ext3 file systems.

       A file system formated for ext2, ext3, or ext4 can be have some collec-
       tion of the follow 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 alloca-
                          tion, 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 allocation and brings smaller fragmenta-
                          tion,  especially  for large files.  The size can be
                          specified using the -C option.

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

                          This  feature  requires  that the extent features be

                          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 struc-
                          ture 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 performance, 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  compati-
                          bility reasons.)

                          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  current  need  to
                          reserve  this much space.  Without this feature, the
                          kernel will reserve the amount of space for features
                          currently  it  currently  needs, and the rest may be
                          consumed by extended attributes.

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

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

                          This feature enables the storage file type  informa-
                          tion  in  directory  entries.   This feature is sup-
                          ported by ext2, ext3, and ext4.

                          This ext4 feature allows the per-block  group  meta-
                          data  (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 a journal to  ensure  filesystem  consistency
                          even across unclean shutdowns.  Setting the filesys-
                          tem feature is equivalent to using  the  -j  option.
                          This  feature  is  supported  by  ext3 and ext4, and
                          ignored by the ext2 file system driver.

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

                          kernels  when a file larger than 2 gigabytes is cre-
                          ated.  Very  old  kernels  could  not  handle  large
                          files,  so  this  feature  flag was used to prohibit
                          those kernels from mounting file systems  that  they
                          could not understand.

                          This  feature indicates that there will only at most
                          two backup superblock and block  group  descriptors.
                          The block groups used to store the backup superblock
                          and  blockgroup  descriptors  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 is feature is
                          essentially a more extreme version  of  sparse_super
                          and  is designed to allow the a much larger percent-
                          age of the disk to have contiguous blocks  available
                          for data files.

                          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 descrip-
                          tors.  This scheme is also used to resize file  sys-
                          tems  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 descriptor  will  slow  down
                          the  time needed to mount the file system, and newer
                          kernels can automatically set this feature as neces-
                          sary  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 stor-
                          age environments.

                          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

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

                          This  file  system  feature indicates that space has
                          been reserved so the block  group  descriptor  table
                          can  be extended by the file system is resized while
                          ext3,  and  ext4  file  system.   It  indicates that
                          backup copies of  the  superblock  and  block  group
                          descriptors  be  present only on a few block groups,
                          and not all of them.

                          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 block
                          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).

              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

       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:

              Update the ext3 filesystem's journal to the current format.


              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.

              Sync  all  data  and  metadata  every nrsec seconds. The default
              value is 5 seconds. Zero means default.


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,  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

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

              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:
Man Pages Copyright Respective Owners. Site Copyright (C) 1994 - 2019 Hurricane Electric. All Rights Reserved.