LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    mke2fs

    
    
    

    SYNOPSIS

           mke2fs [ -c | -l filename ] [ -b block-size ] [ -f fragment-size ] [ -g
           blocks-per-group ] [ -G number-of-groups ] [ -i bytes-per-inode ] [  -I
           inode-size ] [ -j ] [ -J journal-options ] [ -K ] [ -N number-of-inodes
           ] [ -n ] [ -m reserved-blocks-percentage ] [ -o creator-os ] [ -O  fea-
           ture[,...]  ] [ -q ] [ -r fs-revision-level ] [ -E extended-options ] [
           -v ] [ -F ] [ -L volume-label ] [ -M last-mounted-directory ] [ -S ]  [
           -t fs-type ] [ -T usage-type ] [ -U UUID ] [ -V ] device [ blocks-count
           ]
    
           mke2fs -O journal_dev [ -b block-size ] [ -L volume-label ] [ -n ] [ -q
           ] [ -v ] external-journal [ blocks-count ]
    
    
    

    DESCRIPTION

           mke2fs  is used to create an ext2, ext3, or ext4 filesystem, usually in
           a disk partition.  device is the  special  file  corresponding  to  the
           device  (e.g  /dev/hdXX).   blocks-count is the number of blocks on the
           device.  If omitted, mke2fs automagically figures the file system size.
           If  called  as  mkfs.ext3  a journal is created as if the -j option was
           specified.
    
           The defaults of the parameters for the newly created filesystem, if not
           overridden   by  the  options  listed  below,  are  controlled  by  the
           /etc/mke2fs.conf configuration file.   See  the  mke2fs.conf(5)  manual
           page for more details.
    
    
    

    OPTIONS

           -b block-size
                  Specify  the  size  of blocks in bytes.  Valid block-size values
                  are 1024, 2048 and 4096 bytes per block.  If omitted, block-size
                  is  heuristically  determined  by  the  filesystem  size and the
                  expected usage of the filesystem (see the -T option).  If block-
                  size  is  negative, then mke2fs will use heuristics to determine
                  the appropriate block size, with the constraint that  the  block
                  size will be at least block-size bytes.  This is useful for cer-
                  tain hardware devices which require that the blocksize be a mul-
                  tiple of 2k.
    
           -c     Check the device for bad blocks before creating the file system.
                  If this option is specified twice, then a slower read-write test
                  is used instead of a fast read-only test.
    
           -E extended-options
                  Set  extended  options for the filesystem.  Extended options are
                  comma separated, and may take an argument using the equals ('=')
                  sign.   The  -E  option  used  to  be  -R in earlier versions of
                  mke2fs.  The -R option is still accepted for backwards  compati-
                  bility.   The following extended options are supported:
    
                       stride=stride-size
                              Configure  the  filesystem  for  a  RAID  array with
                              stride-size filesystem blocks. This is the number of
                              disks in the array minus 1).  This allows the  block
                              allocator to prevent read-modify-write of the parity
                              in a RAID stripe if possible when the data is  writ-
                              ten.
    
                       resize=max-online-resize
                              Reserve   enough  space  so  that  the  block  group
                              descriptor table can grow to  support  a  filesystem
                              that has max-online-resize blocks.
    
                       lazy_itable_init[= <0 to disable, 1 to enable>]
                              If enabled and the uninit_bg feature is enabled, the
                              inode table will not be fully initialized by mke2fs.
                              This speeds up filesystem initialization noticeably,
                              but it requires the kernel  to  finish  initializing
                              the filesystem in the background when the filesystem
                              is first mounted.  If the option value  is  omitted,
                              it defaults to 1 to enable lazy inode table initial-
                              ization.
    
                       test_fs
                              Set a flag in the filesystem  superblock  indicating
                              that  it  may  be  mounted using experimental kernel
                              code, such as the ext4dev filesystem.
    
                       discard
                              Attempt to discard blocks at mkfs  time  (discarding
                              blocks  initially  is  useful on solid state devices
                              and sparse /  thin-provisioned  storage).  When  the
                              device advertises that discard also zeroes data (any
                              subsequent read after the discard and  before  write
                              returns  zero),  then  mark all not-yet-zeroed inode
                              tables  as  zeroed.  This  significantly  speeds  up
                              filesystem initialization. This is set as default.
    
                       nodiscard
                              Do not attempt to discard blocks at mkfs time.
    
           -f fragment-size
                  Specify the size of fragments in bytes.
    
           -F     Force  mke2fs  to  create  a  filesystem,  even if the specified
                  device is not a partition on a block special device, or if other
                  parameters  do not make sense.  In order to force mke2fs to cre-
                  ate a filesystem even if the filesystem appears to be in use  or
                  is  mounted (a truly dangerous thing to do), this option must be
                  specified twice.
    
           -g blocks-per-group
                  Specify the number of blocks in a block group.  There is  gener-
                  ally  no  reason for the user to ever set this parameter, as the
                  default is optimal for the filesystem.  (For administrators  who
                  Specify  the  bytes/inode  ratio.   mke2fs  creates an inode for
                  every bytes-per-inode bytes of space on the  disk.   The  larger
                  the  bytes-per-inode  ratio,  the  fewer inodes will be created.
                  This value generally shouldn't be smaller than the blocksize  of
                  the  filesystem,  since  in  that case more inodes would be made
                  than can ever be used.  Be warned that it  is  not  possible  to
                  expand the number of inodes on a filesystem after it is created,
                  so be careful deciding the correct value for this parameter.
    
           -I inode-size
                  Specify the  size  of  each  inode  in  bytes.   mke2fs  creates
                  256-byte  inodes  by  default.  In kernels after 2.6.10 and some
                  earlier vendor kernels it is possible to utilize  inodes  larger
                  than 128 bytes to store extended attributes for improved perfor-
                  mance.  The inode-size value must be a  power  of  2  larger  or
                  equal  to  128.   The  larger  the inode-size the more space the
                  inode table will consume, and this reduces the usable  space  in
                  the  filesystem  and  can  also  negatively  impact performance.
                  Extended attributes stored in large inodes are not visible  with
                  older  kernels,  and such filesystems will not be mountable with
                  2.4 kernels at all.  It is not possible  to  change  this  value
                  after the filesystem is created.
    
           -j     Create the filesystem with an ext3 journal.  If the -J option is
                  not specified, the default journal parameters will  be  used  to
                  create  an  appropriately  sized  journal (given the size of the
                  filesystem) stored within the filesystem.  Note that you must be
                  using  a kernel which has ext3 support in order to actually make
                  use of the journal.
    
           -J journal-options
                  Create the ext3 journal using options specified on the  command-
                  line.   Journal  options  are  comma  separated, and may take an
                  argument using the equals ('=')  sign.   The  following  journal
                  options are supported:
    
                       size=journal-size
                              Create  an internal journal (i.e., stored inside the
                              filesystem) of  size  journal-size  megabytes.   The
                              size of the journal must be at least 1024 filesystem
                              blocks (i.e., 1MB if using 1k blocks, 4MB  if  using
                              4k  blocks,  etc.)   and may be no more than 102,400
                              filesystem blocks.
    
                       device=external-journal
                              Attach the filesystem to the  journal  block  device
                              located  on  external-journal.  The external journal
                              must already have been created using the command
    
                              mke2fs -O journal_dev external-journal
    
                              Note that external-journal must  have  been  created
    
                  Only one of the size or  device  options  can  be  given  for  a
                  filesystem.
    
           -K     Keep,  do not attempt to discard blocks at mkfs time (discarding
                  blocks initially is useful on solid state devices and  sparse  /
                  thin-provisioned storage).
    
           -l filename
                  Read  the  bad  blocks  list from filename.  Note that the block
                  numbers in the bad block list must be generated using  the  same
                  block  size  as  used  by mke2fs.  As a result, the -c option to
                  mke2fs is a much simpler and less error-prone method of checking
                  a disk for bad blocks before formatting it, as mke2fs will auto-
                  matically pass the correct parameters to the badblocks  program.
    
           -L new-volume-label
                  Set  the  volume  label  for the filesystem to new-volume-label.
                  The maximum length of the volume label is 16 bytes.
    
           -m reserved-blocks-percentage
                  Specify the percentage of the filesystem blocks reserved for the
                  super-user.   This  avoids  fragmentation, and allows root-owned
                  daemons, such as syslogd(8), to continue to  function  correctly
                  after non-privileged processes are prevented from writing to the
                  filesystem.  The default percentage is 5%.
    
           -M last-mounted-directory
                  Set the last mounted directory for the filesystem.   This  might
                  be  useful  for  the  sake of utilities that key off of the last
                  mounted directory to determine where the  filesystem  should  be
                  mounted.
    
           -n     Causes  mke2fs  to not actually create a filesystem, but display
                  what it would do if it were to create a filesystem.  This can be
                  used  to  determine the location of the backup superblocks for a
                  particular filesystem, so long as  the  mke2fs  parameters  that
                  were  passed when the filesystem was originally created are used
                  again.  (With the -n option added, of course!)
    
           -N number-of-inodes
                  Overrides the default calculation of the number of  inodes  that
                  should  be  reserved  for  the filesystem (which is based on the
                  number of blocks and the bytes-per-inode  ratio).   This  allows
                  the user to specify the number of desired inodes directly.
    
           -o creator-os
                  Overrides  the  default  value of the "creator operating system"
                  field of the filesystem.  The creator field is set by default to
                  the name of the OS the mke2fs executable was compiled for.
    
           -O feature[,...]
                  not  given,  by the default_features relation for the filesystem
                  type being created, or in the [defaults] section of the configu-
                  ration file.
    
                  The  filesystem  feature set is comprised of a list of features,
                  separated by commas, that are to be enabled.  To disable a  fea-
                  ture, simply prefix the feature name with a  caret ('^') charac-
                  ter.   The  pseudo-filesystem  feature  "none"  will  clear  all
                  filesystem features.
    
                       dir_index
                              Use  hashed  b-trees  to  speed  up lookups in large
                              directories.
    
                       extent Instead of using the indirect block scheme for stor-
                              ing  the  location  of  data blocks in an inode, use
                              extents instead.  This  is  a  much  more  efficient
                              encoding  which  speeds  up filesystem access, espe-
                              cially for large files.
    
                       filetype
                              Store file type information in directory entries.
    
                       flex_bg
                              Allow  the  per-block  group  metadata   (allocation
                              bitmaps  and  inode tables) to be placed anywhere on
                              the storage media.  In addition, mke2fs  will  place
                              the  per-block  group  metadata together starting at
                              the first block group of each "flex_bg group".   The
                              size of the flex_bg group can be specified using the
                              -G option.
    
                       has_journal
                              Create an ext3 journal (as if using the -j  option).
    
                       journal_dev
                              Create  an external ext3 journal on the given device
                              instead of a regular  ext2  filesystem.   Note  that
                              external-journal must be created with the same block
                              size as the filesystems that will be using it.
    
                       large_file
                              Filesystem can contain files that are  greater  than
                              2GB.  (Modern kernels set this feature automatically
                              when a file > 2GB is created.)
    
                       resize_inode
                              Reserve space so the block  group  descriptor  table
                              may  grow in the future.  Useful for online resizing
                              using resize2fs.  By default mke2fs will attempt  to
                              reserve enough space so that the filesystem may grow
                              to 1024 times its initial size.  This can be changed
                              in recent Linux kernels.
    
           -q     Quiet execution.  Useful if mke2fs is run in a script.
    
           -r revision
                  Set  the  filesystem revision for the new filesystem.  Note that
                  1.2 kernels only support revision 0 filesystems.  The default is
                  to create revision 1 filesystems.
    
           -S     Write  superblock and group descriptors only.  This is useful if
                  all of the superblock and backup superblocks are corrupted,  and
                  a  last-ditch  recovery  method is desired.  It causes mke2fs to
                  reinitialize the superblock and  group  descriptors,  while  not
                  touching  the  inode table and the block and inode bitmaps.  The
                  e2fsck program should be run immediately after  this  option  is
                  used,  and  there is no guarantee that any data will be salvage-
                  able.  It is critical to specify the correct  filesystem  block-
                  size  when using this option, or there is no chance of recovery.
    
           -t fs-type
                  Specify the filesystem type (i.e., ext2, ext3, ext4, etc.)  that
                  is  to be created.  If this option is not specified, mke2fs will
                  pick a default either via how the command was run (for  example,
                  using  a  name  of the form mkfs.ext2, mkfs.ext3, etc.) or via a
                  default as  defined  by  the  /etc/mke2fs.conf(5)  file.    This
                  option  controls  which  filesystem options are used by default,
                  based    on    the    fstypes    configuration     stanza     in
                  /etc/mke2fs.conf(5).
    
                  If  the -O option is used to explicitly add or remove filesystem
                  options that should be set in the newly created filesystem,  the
                  resulting  filesystem  may not be supported by the requested fs-
                  type.  (e.g., "mke2fs -t ext3 -O extents /dev/sdXX" will  create
                  a filesystem that is not supported by the ext3 implementation as
                  found in the Linux kernel; and "mke2fs -t ext3  -O  ^has_journal
                  /dev/hdXX" will create a filesystem that does not have a journal
                  and hence will not be supported by the ext3 filesystem  code  in
                  the Linux kernel.)
    
           -T usage-type[,...]
                  Specify  how  the filesystem is going to be used, so that mke2fs
                  can choose optimal filesystem  parameters  for  that  use.   The
                  usage  types that are supported are defined in the configuration
                  file /etc/mke2fs.conf(5).  The user  may  specify  one  or  more
                  usage types using a comma separated list.
    
                  If  this  option  is is not specified, mke2fs will pick a single
                  default usage type based on the size of  the  filesystem  to  be
                  created.   If  the  filesystem  size  is less than or equal to 3
                  megabytes, mke2fs will use the filesystem type floppy.   If  the
                  filesystem  size is greater than 3 but less than or equal to 512
                  megabytes, mke2fs(8) will use the filesystem small.   Otherwise,
    
           mke2fs accepts the -f option but currently ignores it because the  sec-
           ond extended file system does not support fragments yet.
           There may be other ones.  Please, report them to the author.
    
    
    

    AVAILABILITY

           mke2fs  is  part  of  the  e2fsprogs  package  and  is  available  from
           http://e2fsprogs.sourceforge.net.
    
    
    

    SEE ALSO

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

    E2fsprogs version 1.41.12 May 2010 MKE2FS(8)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz