Man Linux: Main Page and Category List


       tune2fs  -  adjust  tunable  filesystem  parameters  on  ext2/ext3/ext4


       tune2fs [ -l ] [ -c max-mount-counts ] [ -e errors-behavior ] [ -f ]  [
       -i  interval-between-checks  ]  [  -j  ]  [  -J  journal-options ] [ -m
       reserved-blocks-percentage  ]  [  -o  [^]mount-options[,...]   ]  [  -r
       reserved-blocks-count ] [ -s sparse-super-flag ] [ -u user ] [ -g group
       ] [ -C mount-count ] [ -E extended-options ] [ -L volume-name  ]  [  -M
       last-mounted-directory  ]  [  -O  [^]feature[,...]   ]  [ -T time-last-
       checked ] [ -U UUID ] device


       tune2fs allows the  system  administrator  to  adjust  various  tunable
       filesystem  parameters  on  Linux ext2, ext3, or ext4 filesystems.  The
       current values of these options can be displayed by using the -l option
       to tune2fs(8) program, or by using the dumpe2fs(8) program.


       -c max-mount-counts
              Adjust  the  number of mounts after which the filesystem will be
              checked by e2fsck(8).  If  max-mount-counts  is  0  or  -1,  the
              number of times the filesystem is mounted will be disregarded by
              e2fsck(8) and the kernel.

              Staggering the mount-counts at which  filesystems  are  forcibly
              checked  will  avoid  all  filesystems being checked at one time
              when using journaled filesystems.

              You should  strongly  consider  the  consequences  of  disabling
              mount-count-dependent   checking  entirely.   Bad  disk  drives,
              cables, memory, and kernel bugs could all corrupt  a  filesystem
              without  marking  the  filesystem dirty or in error.  If you are
              using journaling on your filesystem, your filesystem will  never
              be  marked  dirty,  so  it  will  not  normally  be  checked.  A
              filesystem error detected by the kernel will still force an fsck
              on  the  next  reboot, but it may already be too late to prevent
              data loss at that point.

              See also the -i option for time-dependent checking.

       -C mount-count
              Set the number of times the filesystem has been mounted.  If set
              to  a  greater  value than the max-mount-counts parameter set by
              the -c option, e2fsck(8) will check the filesystem at  the  next

       -e error-behavior
              Change the behavior of the kernel code when errors are detected.
              In all cases, a filesystem error will cause e2fsck(8)  to  check
              the  filesystem  on the next boot.  error-behavior can be one of
              the following:

                   continue    Continue normal execution.

                   remount-ro  Remount filesystem read-only.

                   panic       Cause a kernel panic.

       -E extended-options
              Set extended options for the filesystem.  Extended  options  are
              comma separated, and may take an argument using the equals ('=')
              sign.  The following extended options are supported:

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

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

                          Set  the default hash algorithm used for filesystems
                          with hashed b-tree  directories.   Valid  algorithms
                          accepted are: legacy, half_md4, and tea.

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

                          Clear  the  test_fs  flag, indicating the filesystem
                          should  only  be  mounted   using   production-level
                          filesystem code.

       -f     Force  the  tune2fs  operation  to  complete even in the face of
              errors.  This option is useful  when  removing  the  has_journal
              filesystem  feature  from  a  filesystem  which  has an external
              journal (or is  corrupted  such  that  it  appears  to  have  an
              external journal), but that external journal is not available.

              WARNING:  Removing  an  external journal from a filesystem which
              was not cleanly unmounted without first replaying  the  external
              journal   can   result   in  severe  data  loss  and  filesystem

       -g group
              Set the group which can use the reserved filesystem blocks.  The
              group  parameter  can  be a numerical gid or a group name.  If a
              group name is given, it is converted to a numerical  gid  before
              it is stored in the superblock.

       -i  interval-between-checks[d|m|w]
              Adjust  the  maximal  time  between  two  filesystem checks.  No
              suffix or d will interpret the number interval-between-checks as
              days, m as months, and w as weeks.  A value of zero will disable
              the time-dependent checking.

              It  is  strongly  recommended  that  either   -c   (mount-count-
              dependent)  or  -i (time-dependent) checking be enabled to force
              periodic full e2fsck(8) checking of the filesystem.  Failure  to
              do  so  may  lead  to  filesystem  corruption (due to bad disks,
              cables, memory, or  kernel  bugs)  going  unnoticed,  ultimately
              resulting in data loss or corruption.

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

              If this option  is  used  to  create  a  journal  on  a  mounted
              filesystem,  an immutable file, .journal, will be created in the
              top-level directory of the filesystem, as it is  the  only  safe
              way to create the journal inode while the filesystem is mounted.
              While the ext3 journal is visible, it is not safe to delete  it,
              or  modify  it  while the filesystem is mounted; for this reason
              the  file  is  marked  immutable.   While   checking   unmounted
              filesystems, e2fsck(8) will automatically move .journal files to
              the invisible, reserved  journal  inode.   For  all  filesystems
              except   for   the   root   filesystem,    this   should  happen
              automatically and naturally during the next reboot cycle.  Since
              the  root filesystem is mounted read-only, e2fsck(8) must be run
              from a rescue floppy in order to effect this transition.

              On some distributions, such as Debian, if an initial ramdisk  is
              used, the initrd scripts will automatically convert an ext2 root
              filesystem to ext3 if the /etc/fstab  file  specifies  the  ext3
              filesystem  for  the root filesystem in order to avoid requiring
              the use of a rescue floppy to add an ext3 journal  to  the  root

       -J journal-options
              Override  the  default  ext3 journal parameters. Journal options
              are comma separated, and may take an argument using  the  equals
              ('=')  sign.  The following journal options are supported:

                          Create  a  journal  stored in the filesystem of size
                          journal-size megabytes.   The size  of  the  journal
                          must  be  at least 1024 filesystem blocks (i.e., 1MB
                          if using 1k blocks, 4MB if using  4k  blocks,  etc.)
                          and  may  be no more than 102,400 filesystem blocks.
                          There must be enough free space in the filesystem to
                          create a journal of that size.

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

                          mke2fs -O journal_dev external-journal

                          Note  that  external-journal  must be formatted with
                          the same block size as  filesystems  which  will  be
                          using  it.   In addition, while there is support for
                          attaching multiple filesystems to a single  external
                          journal,  the  Linux  kernel  and  e2fsck(8)  do not
                          currently support shared external journals yet.

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

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

       -l     List the contents of the filesystem  superblock,  including  the
              current  values  of  the  parameters  that  can  be set via this

       -L volume-label
              Set the volume label of the filesystem.  Ext2 filesystem  labels
              can  be  at  most  16 characters long; if volume-label is longer
              than 16  characters,  tune2fs  will  truncate  it  and  print  a
              warning.  The volume label can be used by mount(8), fsck(8), and
              /etc/fstab(5)    (and    possibly    others)    by    specifying
              LABEL=volume_label  instead  of a block special device name like

       -m reserved-blocks-percentage
              Set the percentage of the filesystem which may only be allocated
              by  privileged  processes.   Reserving some number of filesystem
              blocks  for  use  by  privileged  processes  is  done  to  avoid
              filesystem  fragmentation,  and to allow system daemons, such as
              syslogd(8),  to  continue  to  function  correctly  after   non-
              privileged   processes   are   prevented  from  writing  to  the
              filesystem.  Normally, the default percentage of reserved blocks
              is 5%.

       -M last-mounted-directory
              Set the last-mounted directory for the filesystem.

       -o [^]mount-option[,...]
              Set  or  clear  the  indicated  default  mount  options  in  the
              filesystem.  Default mount options can be  overridden  by  mount
              options specified either in /etc/fstab(5) or on the command line
              arguments to mount(8).   Older  kernels  may  not  support  this
              feature; in particular, kernels which predate 2.4.20 will almost
              certainly  ignore  the  default  mount  options  field  in   the

              More  than  one mount option can be cleared or set by separating
              features with commas.   Mount  options  prefixed  with  a  caret
              character  ('^') will be cleared in the filesystem's superblock;
              mount options without a prefix character or prefixed with a plus
              character ('+') will be added to the filesystem.

              The following mount options can be set or cleared using tune2fs:

                   debug  Enable debugging code for this filesystem.

                          Emulate BSD behaviour when creating new files:  they
                          will  take  the  group-id  of the directory in which
                          they were created.  The standard System V  behaviour
                          is  the  default,  where newly created files take on
                          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.

                          Enable user-specified extended attributes.

                   acl    Enable Posix Access Control Lists.

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

                          When the  filesystem  is  mounted  with  journalling
                          enabled,  all  data (not just metadata) is committed
                          into the journal prior to  being  written  into  the
                          main filesystem.

                          When  the  filesystem  is  mounted  with journalling
                          enabled, all data is forced directly out to the main
                          file system prior to its metadata being committed to
                          the journal.

                          When the  filesystem  is  mounted  with  journalling
                          enabled,   data   may   be  written  into  the  main
                          filesystem after its metadata has been committed  to
                          the journal.  This may increase throughput, however,
                          it may allow old data to appear  in  files  after  a
                          crash and journal recovery.

       -O [^]feature[,...]
              Set  or clear the indicated filesystem features (options) in the
              filesystem.  More than one filesystem feature can be cleared  or
              set  by  separating  features  with commas.  Filesystem features
              prefixed with a caret character ('^') will  be  cleared  in  the
              filesystem's  superblock;  filesystem  features without a prefix
              character or prefixed with a plus character ('+') will be  added
              to the filesystem.

              The  following  filesystem  features can be set or cleared using

                          Use hashed b-trees to  speed  up  lookups  in  large

                          Store file type information in directory entries.

                          Allow  bitmaps and inode tables for a block group to
                          be placed anywhere on the  storage  media.   Tune2fs
                          will not reorganize the location of the inode tables
                          and allocation bitmaps, as mke2fs(8) will do when it
                          creates  a freshly formated file system with flex_bg

                          Use a journal to ensure filesystem consistency  even
                          across  unclean  shutdowns.   Setting the filesystem
                          feature is equivalent to using the -j option.

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

                          Reserve space so the block  group  descriptor  table
                          may  grow  in  the  future.   Tune2fs  only supports
                          clearing this filesystem feature.

                          Limit the number of backup superblocks to save space
                          on large filesystems.

                          Allow  the  kernel  to  initialize bitmaps and inode
                          tables and keep a  high  watermark  for  the  unused
                          inodes  in  a  filesystem, to reduce e2fsck(8) time.
                          This first e2fsck run after  enabling  this  feature
                          will  take the full time, but subsequent e2fsck runs
                          will take only a  fraction  of  the  original  time,
                          depending on how full the file system is.

              After  setting or clearing sparse_super, uninit_bg, filetype, or
              resize_inode filesystem features, e2fsck(8) must be run  on  the
              filesystem  to  return  the  filesystem  to  a consistent state.
              Tune2fs  will  print  a  message  requesting  that  the   system
              administrator  run  e2fsck(8)  if  necessary.  After setting the
              dir_index feature, e2fsck -D can  be  run  to  convert  existing
              directories  to  the  hashed  B-tree  format.   Enabling certain
              filesystem  features  may  prevent  the  filesystem  from  being
              mounted  by  kernels  which  do  not support those features.  In
              particular,  the  uninit_bg  and  flex_bg  features   are   only
              supported by the ext4 filesystem.

       -r reserved-blocks-count
              Set the number of reserved filesystem blocks.

       -T time-last-checked
              Set  the time the filesystem was last checked using e2fsck.  The
              time is interpreted using the current  (local)  timezone.   This
              can  be  useful in scripts which use a Logical Volume Manager to
              make a consistent snapshot of a filesystem, and then  check  the
              filesystem  during  off  hours  to  make  sure  it  hasn't  been
              corrupted due to hardware problems, etc.  If the filesystem  was
              clean, then this option can be used to set the last checked time
              on the original filesystem.  The format of time-last-checked  is
              the  international date format, with an optional time specifier,
              i.e.  YYYYMMDD[HH[MM[SS]]].   The keyword now is also  accepted,
              in  which  case the last checked time will be set to the current

       -u user
              Set the user who can use the reserved filesystem  blocks.   user
              can be a numerical uid or a user name.  If a user name is given,
              it is converted to a numerical uid before it is  stored  in  the

       -U UUID
              Set  the  universally unique identifier (UUID) of the filesystem
              to UUID.  The format of the UUID  is  a  series  of  hex  digits
              separated         by         hyphens,         like         this:
              "c1b9d5a2-f162-11cf-9ece-0020afc76f16".  The UUID parameter  may
              also be one of the following:

                   clear  clear the filesystem UUID

                   random generate a new randomly-generated UUID

                   time   generate a new time-based UUID

              The  UUID  may  be  used by mount(8), fsck(8), and /etc/fstab(5)
              (and possibly others) by specifying UUID=uuid instead of a block
              special device name like /dev/hda1.

              See  uuidgen(8)  for  more  information.  If the system does not
              have a good random  number  generator  such  as  /dev/random  or
              /dev/urandom,  tune2fs  will automatically use a time-based UUID
              instead of a randomly-generated UUID.


       We haven't found any bugs yet.  That doesn't mean there aren't any...


       tune2fs  was  written  by  Remy  Card  <>.   It   is
       currently  being  maintained  by  Theodore  Ts'o  <>.
       tune2fs  uses   the   ext2fs   library   written   by   Theodore   Ts'o
       <>.   This  manual  page  was  written  by Christian Kuhtz
       <chk@data-hh.Hanse.DE>.  Time-dependent checking was added by Uwe  Ohse


       tune2fs  is  part  of  the  e2fsprogs  package  and  is  available from


       debugfs(8), dumpe2fs(8), e2fsck(8), mke2fs(8)