fsck
check and repair a Linux filesystem
see also :
mkfs - fsck.ext2 - fsck.ext3 - e2fsck - fsck.minix - fsck.msdos - fsck.nfs - fsck.vfat
Synopsis
fsck
[-lsAVRTMNP] [-C [fd]]
[-t fstype] [filesys...]
[--] [fs-specific-options]
add an example, a script, a trick and tips
examples
source
What is the difference between fsck and e2fsck?
fsck is just the original name. When they came out with new file
systems they would need a specific tool for each one, efsck for
ext, e2fsck for ext2, dosfsck, fsckvfat. So they made fsck the
front end that just calls whichever is the appropriate tool.
source
fsck an ntfs drive in Linux
Yes. This is handled by fsck on recent releases. If
the partition is not listed in /etc/fstab, then you
will likely need to tell it the partition type. I've used this
from a Linux CD to recover a partition Windows wouldn't boot
from.
source
fsck: Options for most thorough disk check
You want the -f option to fsck (Force checking even if the file
system seems clean.)
You should run fsck in single user mode. One easy way to do this
without a live cdrom boot is to reboot with the -F option.
shutdown -rF now
source
break out of e2fsck on boot
While it does not directly address your question of how to abort
a running fsck, if you know in advance that you will need a fast
boot (such as if you are planning to give a presentation) then
you can certainly run fsck manually at some earlier time. This
will give you a new 30 days before the next automated file system
check without touching any system configuration.
source
How do I prevent a memory card from mounting as read-only in Ubuntu Linux?
I ran sudo fsck -a ... on the offending device.
After fixing the file system corruption it mounts read-write. I
had the problem again, and fixed it again with fsck. Will have to
be more careful about always ejecting properly.
source
Filesystem corruption (?) and appropriate use of fsck
The RAID system (MD) knows nothing about the filesystem, so if it
fails to rebuild it's not because of filesystem corruption, but
more likely due to hardware error. Possibly one of your disks
failing. Check for S.M.A.R.T.-errors using smartmontools and run
a self-test.
When you run fsck -yf, this will try its best to fix the
filesystem and in the process it may delete problematic inodes
(files) (some files may be moved to the lost+found folder). Maybe
the boxes you saw on graphical login was due to required files
that were deleted by fsck. Not being able to log in via console
or SSH may also point to missing files. Are you able to get shell
access if you boot to recovery mode? You could attempt to fix
things by restoring OS-files from backup, or force reinstalling
software packages.
However, at this point, maybe changing the disks and do a clean
reinstall would be better.
source
Ext3 drive will not mount after power failure; how to recover files?
Backtrack is a linux distro that comes packaged
with a host of tools for things like this. It is also, however,
aimed squarely at the upper echelon of power users. Their website
may have some good tutorials for using their tools, so that may
be of use to you.
source
Can't recover hard drive
It looks like your partition table got screwed up. Since you have
a disk larger than 2TB, you need to use GPT, but fdisk thinks the
disk is using a dos partition table. You will need to create a
new gpt disk label and recreate the partition using the full
space, and finally fsck it.
source
Hard drive partition size wrong. How do I resize without loss of data?
You can use Gparted which can do this job very easily and
you will not lost your data any way.
The best way to access all of the features of the GParted
application is by using the GParted Live bootable image.
GParted Live enables you to use GParted on GNU/Linux as well as
other operating systems, such as Windows or Mac OS X.
source
Why does linux check disks during boot instead of shutdown?
Yes, but only every so often. It is configurable how many boots
(or time) have to elapse until the next check.
I guess you would have to wait also at shutdown, and may be you
would be eager to go home far more than you are eager to start
working at boot time -:)
source
Does the number of files affect fsck's performance?
That depends on the file system and the switches you use with
fsck.
What fsck Checks and Tries to Repair gives a
pretty detailed explanation of what fsck does when invoked
without switches.
Some of the checks take a constant amount of time (e.g., super
block check), many of them depend on the number of inodes fsck
has to process (e.g., link count checks), others on the file
system's size (e.g., regular data block checks).
Without the -c switch, fsck does not check the
contents of regular files, so the size of the files is
irrelevant. Even when checking for bad blocks, the execution time
only increases with the file system's size. Which portion of the
of the partition is occupied does not affect the execution
time.1
The number of inodes of a file system
is constant, i.e., decided upon at creation time. Each file's
metadata is stored in one of such inodes. According to ext4, unused inodes are
marked as such in ext4, but not in ext3. Thus, fsck's execution
time increases with the file count in ext4, but is constant (and
high) in ext3.
The following figure illustrates this:
Observe that the different file counts are represented by
different colors. The graphs for ext3 with 2.1 million, 100
thousand and even zero files are identical. The graph for ext4
with 2.1M and 100k files respectively show a significant
difference.
In contrast, execution time increases with the number of inodes
with ext3, while unused inode do not impact execution time with
ext4.
1 Verified empirically by running
fsck -c on an empty partition.
source
Is it safe to disable fsck on boot?
I wouldn't. You can disable it if you have a policy for manually
running fsck periodically, and use a fully journaling file
system, but otherwise it is important for long term file system
health. With boot checking disabled, you will only have fsck run
automatically if your journal is marked as dirty, but it will not
do things like bad sector checks, or manually look for file
system issues that have not already been recorded.
source
Prevent e2fsck from running out of memory?
I'm not sure which version of e2utils Ubuntu 11.10 has, however
if it's fairly recent you can create
/etc/e2fsck.conf file with something like this:
[scratch_files]
directory = /tmp/e2fs_scratch
Create that directory first, then run e2fsck. Using scratch file
will greatly reduce memory use, however e2fsck will run very very
slowly.
Of course if you need to check your root fs, you'll need to boot
into another root, as the scratch directory will need to be
writable.
source
Perform bad blocks scan on root partition in Linux
See Can I run fsck or e2fsck when Linux file system is
mounted?, which notes that running any fsck on a mounted
filesystem can result in disk or data corruption.
It suggests the following solutions:
A. Take down system to single user mode, unmount
system, then run e2fsck
init 1
umount /dev/sda
e2fsck -y /dev/sda3
B. Boot from the installation CD into rescue
mode
boot: linux rescue nomount<br/>
mknod /dev/sda
mknod /dev/sda3
fsck /dev/sda3
Another solution would be to use fsck to check the entire disk
(except swap) on boot time, as root:
shutdown -Fr now
where -F stands for force fsck check and -r for reboot.
description
fsck is
used to check and optionally repair one or more Linux
filesystems. filesys can be a device name (e.g.
/dev/hdc1, /dev/sdb2), a mount point (e.g.
/, /usr, /home), or an ext2 label or
UUID specifier (e.g.
UUID=8868abf6-88c5-4a83-98b8-bfc24057f7bd or LABEL=root).
Normally, the fsck program will try to handle
filesystems on different physical disk drives in parallel to
reduce the total amount of time needed to check all of
them.
If no
filesystems are specified on the command line, and the
-A option is not specified, fsck will
default to checking filesystems in /etc/fstab
serially. This is equivalent to the -As
options.
The exit code
returned by fsck is the sum of the following
conditions:
0
- No errors
1
- Filesystem errors corrected
2
- System should be rebooted
4
- Filesystem errors left uncorrected
8
- Operational error
16
- Usage or syntax error
32
- Fsck canceled by user request
128
- Shared-library error
The exit code returned when
multiple filesystems are checked is the bit-wise OR of the
exit codes for each filesystem that is checked.
In actuality,
fsck is simply a front-end for the various filesystem
checkers (fsck.fstype) available under Linux.
The filesystem-specific checker is searched for in
/sbin first, then in /etc/fs and /etc,
and finally in the directories listed in the PATH
environment variable. Please see the filesystem-specific
checker manual pages for further details.
options
-l
Lock the whole-disk device by an
exclusive flock(2). This option can be used with one
device only (this means that -A and -l are
mutually exclusive). This option is recommended when more
fsck (8) instances are executed in the same time. The
option is ignored when used for multiple devices or for
non-rotating disks. fsck does not lock underlying
devices when executed to check stacked devices (e.g. MD or
DM) -- this feature is not implemented yet.
-s
Serialize fsck operations. This is a good idea if
you are checking multiple filesystems and the checkers are
in an interactive mode. (Note: e2fsck(8) runs in an
interactive mode by default. To make e2fsck(8) run in
a non-interactive mode, you must either specify the
-p or -a option, if you wish for
errors to be corrected automatically, or the -n
option if you do not.)
-t
fslist
Specifies the type(s) of
filesystem to be checked. When the -A flag is
specified, only filesystems that match fslist are
checked. The fslist parameter is a comma-separated
list of filesystems and options specifiers. All of the
filesystems in this comma-separated list may be prefixed by
a negation operator ’no’ or
’!’, which requests that only those
filesystems not listed in fslist will be checked. If
none of the filesystems in fslist is prefixed by a
negation operator, then only those listed filesystems will
be checked.
Options
specifiers may be included in the comma-separated
fslist. They must have the format
opts=fs-option. If an options specifier is
present, then only filesystems which contain
fs-option in their mount options field of
/etc/fstab will be checked. If the options specifier
is prefixed by a negation operator, then only those
filesystems that do not have fs-option in their mount
options field of /etc/fstab will be checked.
For example, if
opts=ro appears in fslist, then only
filesystems listed in /etc/fstab with the ro
option will be checked.
For
compatibility with Mandrake distributions whose boot scripts
depend upon an unauthorized UI change to the fsck
program, if a filesystem type of loop is found in
fslist, it is treated as if opts=loop were
specified as an argument to the -t option.
Normally, the
filesystem type is deduced by searching for filesys
in the /etc/fstab file and using the corresponding
entry. If the type can not be deduced, and there is only a
single filesystem given as an argument to the
-t option, fsck will use the specified
filesystem type. If this type is not available, then the
default filesystem type (currently ext2) is used.
-A
Walk through the /etc/fstab file and try to check
all filesystems in one run. This option is typically used
from the /etc/rc system initialization file, instead
of multiple commands for checking a single filesystem.
The root
filesystem will be checked first unless the -P
option is specified (see below). After that, filesystems
will be checked in the order specified by the
fs_passno (the sixth) field in the /etc/fstab
file. Filesystems with a fs_passno value of 0 are
skipped and are not checked at all. Filesystems with a
fs_passno value of greater than zero will be checked
in order, with filesystems with the lowest fs_passno
number being checked first. If there are multiple
filesystems with the same pass number, fsck will attempt to
check them in parallel, although it will avoid running
multiple filesystem checks on the same physical disk.
fsck
does not check stacked devices (RAIDs, dm-crypt, ...) in
parallel with any other device. See below for
FSCK_FORCE_ALL_PARALLEL setting. The /sys filesystem is used
to detemine dependencies between devices.
Hence, a very
common configuration in /etc/fstab files is to set
the root filesystem to have a fs_passno value of 1
and to set all other filesystems to have a fs_passno
value of 2. This will allow fsck to automatically run
filesystem checkers in parallel if it is advantageous to do
so. System administrators might choose not to use this
configuration if they need to avoid multiple filesystem
checks running in parallel for some reason --- for example,
if the machine in question is short on memory so that
excessive paging is a concern.
fsck
normally does not check whether the device actually exists
before calling a filesystem specific checker. Therefore
non-existing devices may cause the system to enter
filesystem repair mode during boot if the filesystem
specific checker returns a fatal error. The
/etc/fstab mount option nofail may be used to
have fsck skip non-existing devices. fsck also
skips non-existing devices that have the special filesystem
type auto
-C [ fd
]
Display completion/progress
bars for those filesystem checkers (currently only for ext2
and ext3) which support them. Fsck will manage the
filesystem checkers so that only one of them will display a
progress bar at a time. GUI front-ends may specify a file
descriptor fd, in which case the progress bar
information will be sent to that file descriptor.
-M
Do not check mounted filesystems and return an exit code
of 0 for mounted filesystems.
-N
Don’t execute, just show what would be done.
-P
When the -A flag is set, check the root
filesystem in parallel with the other filesystems. This is
not the safest thing in the world to do, since if the root
filesystem is in doubt things like the e2fsck(8)
executable might be corrupted! This option is mainly
provided for those sysadmins who don’t want to
repartition the root filesystem to be small and compact
(which is really the right solution).
-R
When checking all filesystems with the -A
flag, skip the root filesystem. (This is useful in case the
root filesystem has already been mounted read-write.)
-T
Don’t show the title on startup.
-V
Produce verbose output, including all
filesystem-specific commands that are executed.
fs-specific-options
Options which are not
understood by fsck are passed to the
filesystem-specific checker. These arguments must not
take arguments, as there is no way for fsck to be
able to properly guess which options take arguments and
which don’t.
Options and
arguments which follow the -- are treated
as filesystem-specific options to be passed to the
filesystem-specific checker.
Please note
that fsck is not designed to pass arbitrarily complicated
options to filesystem-specific checkers. If you’re
doing something complicated, please just execute the
filesystem-specific checker directly. If you pass
fsck some horribly complicated options and arguments,
and it doesn’t do what you expect, don’t
bother reporting it as a bug. You’re almost
certainly doing something that you shouldn’t be doing
with fsck.
Options to
different filesystem-specific fsck’s are not
standardized. If in doubt, please consult the man pages of
the filesystem-specific checker. Although not guaranteed,
the following options are supported by most filesystem
checkers:
-a
Automatically repair the filesystem without any
questions (use this option with caution). Note that
e2fsck(8) supports -a for backward
compatibility only. This option is mapped to
e2fsck’s -p option which is safe
to use, unlike the -a option that some
filesystem checkers support.
-n
For some filesystem-specific checkers, the
-n option will cause the fs-specific fsck to
avoid attempting to repair any problems, but simply report
such problems to stdout. This is however not true for all
filesystem-specific checkers. In particular,
fsck.reiserfs(8) will not report any corruption if
given this option. fsck.minix(8) does not support the
-n option at all.
-r
Interactively repair the filesystem (ask for
confirmations). Note: It is generally a bad idea to use this
option if multiple fsck’s are being run in parallel.
Also note that this is e2fsck’s default
behavior; it supports this option for backward compatibility
reasons only.
-y
For some filesystem-specific checkers, the
-y option will cause the fs-specific fsck to
always attempt to fix any detected filesystem corruption
automatically. Sometimes an expert may be able to do better
driving the fsck manually. Note that not all
filesystem-specific checkers implement this option. In
particular fsck.minix(8) and fsck.cramfs(8) do
not support the -y option as of this writing.
availability
The fsck command is part of the util-linux package and is
available from ftp://ftp.kernel.org/pub/linux/utils/util-linux/.
environment variables
The fsck program’s behavior is affected by the following
environment variables:
FSCK_FORCE_ALL_PARALLEL
If this environment variable is set, fsck will attempt to
check all of the specified filesystems in parallel, regardless of
whether the filesystems appear to be on the same device. (This is
useful for RAID systems or high-end storage systems such as those
sold by companies such as IBM or EMC.) Note that the fs_passno
value is still used.
FSCK_MAX_INST
This environment variable will limit the maximum number of
filesystem checkers that can be running at one time. This allows
configurations which have a large number of disks to avoid
fsck starting too many filesystem checkers at once, which
might overload CPU and memory resources available on the system.
If this value is zero, then an unlimited number of processes can
be spawned. This is currently the default, but future versions of
fsck may attempt to automatically determine how many
filesystem checks can be run based on gathering accounting data
from the operating system.
PATH
The PATH environment variable is used to find filesystem
checkers. A set of system directories are searched first:
/sbin, /sbin/fs.d, /sbin/fs, /etc/fs,
and /etc. Then the set of directories found in the
PATH environment are searched.
FSTAB_FILE
This environment variable allows the system administrator to
override the standard location of the /etc/fstab file. It
is also useful for developers who are testing fsck.
files
/etc/fstab.
see also
fstab,
mkfs , fsck.ext2 or fsck.ext3
or e2fsck , cramfsck,
fsck.minix , fsck.msdos ,
fsck.jfs, fsck.nfs , fsck.vfat ,
fsck.xfs, fsck.xiafs,
reiserfsck.
author
Theodore
Ts’o (tytso[:at:]mit[:dot:]edu)
