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  ex-
       tensibility  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.kernel.org/in-
              dex.php/Bigalloc for details.  May clash with delayed allocation
              (see nodelalloc mount option).

              This feature requires that the extent feature be enabled.

              This ext4 feature provides file system level character  encoding
              support  for  directories  with  the casefold (+F) flag enabled.
              This feature is name-preserving on the disk, but it  allows  ap-
              plications  to lookup for a file in the file system using an en-
              coding equivalent version of the file name.

              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  di-
              rectory  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.

              Normally, a file's extended attributes and  associated  metadata
              must fit within the inode or the inode's associated extended at-
              tribute block. This feature allows the value  of  each  extended
              attribute to be placed in the data blocks of a separate inode if
              necessary, increasing the limit on the size and  number  of  ex-
              tended attributes per file.

              Enables  support for 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 de-
              vice 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 at-

              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 di-
              rectory 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 increases the limit on the number of files per  di-
              rectory  by  raising  the  maximum  size of directories and, for
              hashed b-tree directories (see dir_index), the maximum height of
              the hashed b-tree used to store the directory entries.

              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 enables metadata checksumming.  This feature
              stores checksums for all of the filesystem metadata (superblock,
              group  descriptor  blocks, inode and block bitmaps, directories,
              and extent tree blocks).  The checksum algorithm  used  for  the
              metadata  blocks  is  different  than the one used for group de-
              scriptors with the uninit_bg feature.  These  two  features  are
              incompatible  and  metadata_csum will be used preferentially in-
              stead of uninit_bg.

              This feature allows the filesystem to store the metadata  check-
              sum  seed  in  the superblock, which allows the administrator to
              change the UUID of a filesystem using the metadata_csum  feature
              while it is mounted.

              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.

              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

              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  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 de-
              fault 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  or  sparse_super2
              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  su-
              perblock  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 de-
              scriptor(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 de-
              scriptors  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 un-
              used 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.

              Enables  support  for  verity protected files.  Verity files are
              readonly, and their data is  transparently  verified  against  a
              Merkle  tree  hidden past the end of the file.  Using the Merkle
              tree's root hash, a verity file  can  be  efficiently  authenti-
              cated, independent of the file's size.

              This  feature  is most useful for authenticating important read-
              only files on read-write file systems.  If the file  system  it-
              self  is read-only, then using dm-verity to authenticate the en-
              tire block device may provide much better security.

       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 op-
              tions 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 ig-
              nore errors and just mark the filesystem erroneous and continue,
              or  remount the filesystem read-only, or panic and halt the sys-
              tem.)  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  using the normal superblock, use an alternative su-
              perblock specified by n.  This option is normally used when  the
              primary  superblock  has been corrupted.  The location of backup
              superblocks is dependent on the filesystem's blocksize, the num-
              ber of blocks per group, and features such as sparse_super.

              Additional  backup  superblocks  can  be determined by using the
              mke2fs program using the -n option to print out  where  the  su-
              perblocks  exist,  supposing  mke2fs  is supplied with arguments
              that are consistent with the filesystem's  layout  (e.g.  block-
              size, blocks per group, sparse_super, etc.).

              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

              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 in-
                     tegrity, 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  im-
              prove 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 or  jqfmt=vfsv1  enables  journaled  quotas.
              Journaled  quotas  have the advantage that even after a crash no
              quota check is required. When the quota  filesystem  feature  is
              enabled, journaled quotas are used automatically, and this mount
              option is ignored.

              For journaled quotas (jqfmt=vfsv0 or jqfmt=vfsv1), the mount op-
              tions  usrjquota=aquota.user  and grpjquota=aquota.group are re-
              quired to tell the quota system which quota  database  files  to
              use.  When  the  quota  filesystem feature is enabled, journaled
              quotas are used automatically, and this mount option is ignored.

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, journal_path, norecovery, noload,  data,  com-
       mit,  orlov,  oldalloc, [no]user_xattr, [no]acl, bsddf, minixdf, debug,
       errors, data_err, grpid, bsdgroups, nogrpid,  sysvgroups,  resgid,  re-
       suid,  sb,  quota, noquota, nouid32, grpquota, usrquota, usrjquota, gr-
       pjquota, and jqfmt are backwardly compatible with ext3 or ext2.

       journal_checksum | nojournal_checksum
              The journal_checksum option enables checksumming of the  journal
              transactions.   This  will allow the recovery code in e2fsck and
              the kernel to detect corruption in the kernel. It is a  compati-
              ble 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 de-
              fault value is 32 blocks.

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

              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 op-
              eration. 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 <micro>s  (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. In-
              creasing 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  de-
              layed  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 option enables/disables the in-kernel facility for tracking
              filesystem metadata blocks within internal data structures. This
              allows  multi-block  allocator and other routines to quickly lo-
              cate  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 de-

              This option disables use of mbcache for extended attribute dedu-
              plication.  On  systems  where extended attributes are rarely or
              never shared between files, use  of  mbcache  for  deduplication
              adds unnecessary computational overhead.

              The  prjquota  mount option enables project quota support on the
              filesystem.  You need the quota utilities to actually enable and
              manage the quota system.  This mount option requires the project
              filesystem feature.

       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

       metadata_csum_seed  ext4, 4.4

       project             ext4, 4.5

       ea_inode            ext4, 4.13

       large_dir           ext4, 4.13

       casefold            ext4, 5.2

       verity              ext4, 5.4

       mke2fs(8),  mke2fs.conf(5),  e2fsck(8),  dumpe2fs(8),  tune2fs(8),  de-
       bugfs(8), mount(8), chattr(1)

E2fsprogs version 1.45.5         January 2020                          EXT4(5)
Man Pages Copyright Respective Owners. Site Copyright (C) 1994 - 2024 Hurricane Electric. All Rights Reserved.