mke2fs
create an ext2/ext3/ext4 filesystem
see also :
badblocks - dumpe2fs - e2fsck - tune2fs
Synopsis
mke2fs [
-c | -l filename ] [
-b block-size ] [ -D ] [
-f fragment-size ] [ -g
blocks-per-group ] [ -G
number-of-groups ] [ -i
bytes-per-inode ] [ -I inode-size
] [ -j ] [ -J
journal-options ] [ -N
number-of-inodes ] [ -n ] [
-m reserved-blocks-percentage ] [
-o creator-os ] [ -O
feature[,...] ] [ -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 ]
add an example, a script, a trick and tips
examples
source
mke2fs -F -j /dev/sdh
mkdir /ebs
mount /dev/sdh /ebs
source
sudo fdisk /dev/sdb
sudo fdisk /dev/sdc
sudo fdisk /dev/sdd
sudo fdisk /dev/sde
sudo mke2fs -jv /dev/sdb1
sudo mke2fs -jv /dev/sdc1
sudo mke2fs -jv /dev/sde1
source
insmod ./kramdrv.ko
sleep 1
mke2fs /dev/kramdrv
mount /dev/kramdrv ./mount
printf "LOAD Done ...
\n"
source
mke2fs /dev/ram0
mount /dev/ram0 db/memory
cp db/test.sqlite3 db/memory
chown -R sylvain db/memory
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 preceded by a negative sign
(’-’), 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 certain hardware devices which
require that the blocksize be a multiple 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.
-D
Use direct I/O when writing to the disk. This avoids
mke2fs dirtying a lot of buffer cache memory, which may
impact other applications running on a busy server. This
option will cause mke2fs to run much more slowly, however,
so there is a tradeoff to using direct I/O.
-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 compatibility. The
following extended options are supported:
mmp_update_interval=interval
Adjust the initial MMP update
interval to interval seconds. Specifying an
interval of 0 means to use the default interval. The
specified interval must be less than 300 seconds. Requires
that the mmp feature be enabled.
stride=stride-size
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 the next disk, which is sometimes referred to as
the chunk size. This mostly affects placement of
filesystem metadata like bitmaps at mke2fs time to
avoid placing them on a single disk, which can hurt
performance. It may also be used by the block allocator.
stripe_width=stripe-width
Configure the filesystem for a
RAID array with stripe-width filesystem blocks per
stripe. This is typically stride-size * N, where N is the
number of data-bearing disks in the RAID (e.g. for RAID 5
there is one parity disk, so N will be 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 written.
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
zeroing.
lazy_journal_init[=
<0 to disable, 1 to enable>]
If enabled, the journal inode
will not be fully zeroed out by mke2fs. This speeds
up filesystem initialization noticeably, but carries some
small risk if the system crashes before the journal has been
overwritten entirely one time. If the option value is
omitted, it defaults to 1 to enable lazy journal inode
zeroing.
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.
quotatype
Specify which quota type
(’usr’ or ’grp’) is to be
initialized. This option has any effect only if quota
feature is set. Without this extended option, the default
behavior is to initialize both user and group quotas.
-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 create 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 generally no reason for the user to
ever set this parameter, as the default is optimal for the
filesystem. (For administrators who are creating filesystems
on RAID arrays, it is preferable to use the stride
RAID parameter as part of the -E option rather
than manipulating the number of blocks per group.) This
option is generally used by developers who are developing
test cases.
-G
number-of-groups
Specify the number of block
groups that will be packed together to create a larger
virtual block group (or "flex_bg group") in an
ext4 filesystem. This improves meta-data locality and
performance on meta-data heavy workloads. The number of
groups must be a power of 2 and may only be specified if the
flex_bg filesystem feature is enabled.
-i
bytes-per-inode
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 performance. 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 10,240,000 filesystem blocks or half the total file
system size (whichever is smaller)
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 with the same
block size as the new filesystem. 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
tune2fs(8).
Only one of the
size or device options can be given for a
filesystem.
-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 automatically 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[,...]
Create a filesystem with the
given features (filesystem options), overriding the default
filesystem options. The features that are enabled by default
are specified by the base_features relation, either
in the [defaults] section in the
/etc/mke2fs.conf configuration file, or in the
[fs_types] subsections for the usage types as
specified by the -T option, further modified by
the features relation found in the [fs_types]
subsections for the filesystem and usage types. See the
mke2fs.conf(5) manual page for more details. The
filesystem type-specific configuration setting found in the
[fs_types] section will override the global default
found in [defaults].
The filesystem
feature set will be further edited using either the feature
set specified by this option, or if this option is not
given, by the default_features relation for the
filesystem type being created, or in the [defaults]
section of the configuration file.
The filesystem
feature set is comprised of a list of features, separated by
commas, that are to be enabled. To disable a feature, simply
prefix the feature name with a caret (’^’)
character. 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 storing
the location of data blocks in an inode, use extents
instead. This is a much more efficient encoding which speeds
up filesystem access, especially 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.)
quota
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 mounted.
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 using the resize extended option.
sparse_super
Create a filesystem with fewer
superblock backup copies (saves space on large
filesystems).
uninit_bg
Create a filesystem without
initializing all of the block groups. This feature also
enables checksums and highest-inode-used statistics in each
blockgroup. This feature can speed up filesystem creation
time noticeably (if lazy_itable_init is enabled), and can
also reduce e2fsck time dramatically. It is only
supported by the ext4 filesystem 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 salvageable. It
is critical to specify the correct filesystem blocksize 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 extent /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 type small. If the filesystem size
is greater than or equal to 4 terabytes but less than 16
terabytes, mke2fs(8) will use the filesystem type
big. If the filesystem size is greater than or equal
to 16 terabytes, mke2fs(8) will use the filesystem
type huge. Otherwise, mke2fs(8) will use the
default filesystem type default.
-U UUID
Create the filesystem with the
specified UUID.
-v
Verbose execution.
-V
Print the version number of mke2fs and exit.
availability
mke2fs is part of the e2fsprogs package and is available
from http://e2fsprogs.sourceforge.net.
environment
MKE2FS_SYNC
If set to non-zero integer value, its value is used to determine
how often sync(2) is called during inode table
initialization.
MKE2FS_CONFIG
Determines the location of the configuration file (see
mke2fs.conf(5)).
MKE2FS_FIRST_META_BG
If set to non-zero integer value, its value is used to determine
first meta block group. This is mostly for debugging purposes.
MKE2FS_DEVICE_SECTSIZE
If set to non-zero integer value, its value is used to determine
physical sector size of the device.
MKE2FS_SKIP_CHECK_MSG
If set, do not show the message of filesystem automatic check
caused by mount count or check interval.
bugs
mke2fs
accepts the -f option but currently ignores it
because the second extended file system does not support
fragments yet.
There may be other ones. Please, report them to the
author.
see also
mke2fs.conf,
badblocks , dumpe2fs , e2fsck ,
tune2fs
author
This version of
mke2fs has been written by Theodore Ts’o
<tytso[:at:]mit[:dot:]edu>.