File Systems in Linux

chinahhucai

File
Systems in Linux
A good article introducing the file systems in Linux.
Since Linux appeared on the scene in the early 90's, ext2 has
been the default file system. Though Linux systems are extremely
robust and less prone to crashes, you never can tell when a power
outage is going to bring your system down suddenly. Though ext2 is
a hardy filesystem, there is a risk of data loss when these sudden
crashes occur. For this reason, two projects have come up with
alternatives known as 'journaling' filesystems. These are ext3 and
ReiserFs.
ext2
ext2 is the "traditional" filesystem on Linux.By traditional, I
mean that it has the longest run as being the most popular
filesystem. From 1992, when it was developed by Remy Card, until
2002 or so, it was considered the 'default' Linux filesystem.
ext2 stands for 'second extended file system'. It replaced the
original 'extended file system', which was in itself, a replacement
for the Minix filesystem, which was Linux's first 'default'
filesystem. Minix only allowed 14 character file names and had a
maximum of 64 megabytes for
[color="blue"]file size
. The first ext filesystem
overcame these limitations (255 char. file names and 2 GB file
size), but still suffered from other problems related to file
access. ext2 corrected these problems and raised the file size bar
to 4 gigabytes.
The main advantage to the ext2 filesystem is its speed. It's
considered fast and other filesystems use its speed as a base for
doing benchmarks. It's also extremely robust. However, the main
problem is when your system crashes. ext2 need integrity checks
that, depending on your hard disk size, may take an extremely long
time. You may also end up with some
[color="blue"]corrupt files
. An attempt to
take advantage of the positive points of ext2 and add some data
loss protection and
[color="blue"]recovery
speed led to the development of
journaling file system. Let's have a look at those.
Journaling Filesystems
As we mentioned, journaling file systems came about as a way to
overcome problems with
[color="blue"]data corruption
after a crash. Basically, a
journaling filesystem logs changes you make to your files to a
'journal'. This is a file that resides in a separate portion of
your hard disk. Instead of doing a lengthy filesystem check, a
journaling filesystem just reads the contents of the journal to
make sure that the files are in the state that they're supposed to
be. This saves time and prevents file corruption. Let's look at the
two most popular journaling filesystems used with Linux, ext3 and
ReiserFS.
ext3
ext3 was developed by Dr.Stephen Tweedie in 1999. ext3 is
essentially ext2 with a journal. The rationale behind creating a
filesystem can be best summed up by Dr. Tweedie himself he gave at
the Ottawa Linux Symposium in July of 2000.

... there are a rather lot of users out there who have got
existing EXT2 filesystems. And more every day. And some of these
EXT2 filesystems are getting really rather big. Even 24 months ago,
there were people building 500 gigabyte EXT2 filesystems. They take
a long time to fsck. I mean, really. These are filesystems that can
take three or four hours just to mkfs. Doing a consistency check on
them is a serious down time. So the real objective in EXT3 was this
simple thing: availability. When something goes down in EXT3, we
don't want to have to go through a fsck. We want to be able to
reboot the machine instantly and have everything nice and
consistent.

--Dr. Stephen Tweedie

With ext3, the user gets just this. A robust and fast filesystem
with a minimum of downtime. There is one disadvantage with the ext3
filesystem as compared with ext2. With ext3,
[color="blue"]deleted files
are, for
all intents and purposes, unrecoverable.
Converting from
ext2 to ext3
Systems running the ext3 filesystem are much more common than
they were. Nevertheless, you may be running a system that may be
considered a quasi-legacy system and you want to make the move from
ext2 to ext3. The procedure is fairly straightforward. You simply
need to run the following command:
tune2fs -c 0 -i 30 -j /dev/hda1
This command will convert your partition on hda1 to ext3 and
also make sure that the system is checked every 30 days. This is a
good idea because a journaling filesystem doesn't preclude the
possibility of corruption.
You also need to edit your /etc/fstab and change ext2 to ext3
for every partition you've converted. After this, just reboot the
machine.

Remember: Your kernel needs to support the ext3 filesystem. This
is important especially if you've got a custom-made kernel. If you
haven't included ext3 in it, upon reboot, you'll be in for a rather
unpleasant surprise.
After rebooting, running the command 'df
-T' should confirm that you've been successful:
Filesystem    Type   1K-blocks      Used Available Use% Mounted on
/dev/hda2     ext3     4032124    275088   3552208   8% /
/dev/hda3     ext3     9677928   1902404   7284004  21% /home
/dev/hda5     ext3     4032092   1424956   2402312  38% /usr
ReiserFS
As we mentioned, the other popular journaling fileystem is the
ReiserFS. It was originally developed by Hans Reiser with the help
of SuSE. Now, development is carried on under the auspices of
Namesys with the sponsorship of Linspire. DARPA has also provided
grants to help with its development. At present, there are
essentially two versions of the ReiserFS: version 3, which is in
most widespread use and version 4, which is a complete re-write of
version 3, is, at the time of this writing, in development and not
considered stable.
ext3 and ReiserFS are similar in that they both use a journal.
However, the ReiserFS journal concept is a bit different. ReiserFS
stores both the file names and the file itself in a database where
ext3 stores the file name but only its location. On the downside,
ReiserFS needs a clean install to use whereas an ext2 filesystem
can be converted to an ext3 fairly easily on a working system.
Other Filesystems under Linux
Though ext2, ext3 and Reiser are the most popular, there are
also other filesystems in use in the Linux world.
Journaled File System
(JFS)
JFS was originally developed by IBM for their AIX operating
system. Worked started in 1999 to port JFS to Linux and the code
was released under the GPL. As its name implies, it is a journaling
filesystem.
JFS is like ReiserFS in that it provides a journaling filesystem
from the start, unlike ext3, which is essentially a 'converted'
ext2 filesystem. To use JFS under Linux, all one needs to do is
enable Linux kernel support for it, by either adding it as a module
or compiling it into the kernel itself. You will also need to
install the package jfsutils.
Once you have JFS support in the kernel, the easiest way to
convert your systems partition to JFS is to, first, create a new
root partition from an empty partition. Take this empty partition
and format it. Let's say your empty partition is /hda5:
mkfs.jfs -c /dev/hda5
This will convert it to jfs and check for bad blocks in the
meantime (which is always a good idea). Once you've formatted, then
you can copy your root partitions files over to the new partition.
The easiest way is to create a temporary directory and then mount
it. When you copy the root partition files there, make sure you
don't copy /proc. Remember, those are
running processes and aren't actual files.
The last thing you need to do is change either your lilo.conf or
grub.conf (depending on the bootloader you're using) and your
/etc/fstab. Now, with the old root filesystem you can create the
/home partition for example. That can also be JFS if you want.
XFS
XFS is another journaling filesystem for use on Linux systems.
It was initially developed by Silicon Graphics for use on their
high-end Irix Unix systems. One of the most notable features of XFS
is that it is designed to handle a filesystem as large as a million
terabytes. A filesystem on a 32 bit Linux system needs to be much
smaller, but weighs in at a still considerable maximum size of 16
terabytes.
Though less popular than ext3 and ReiserFS, it's in the same
league as JFS. It's somewhat of a minority filesystem, but is
considered popular enough to be offered as an option by major Linux
distribution developers like RedHat, the Debian project and
Mandriva.
Networked and Other Filesystems
With the ubiquitousness of Microsoft in the world of computing,
it would be impossible for us to ignore the filesystems that work
under Windows. In most offices, there's usually a need for a Linux
machine to interact with them.
Using NTFS
under Linux
NTFS is the file system used on Windows server-type operating
systems starting with Windows NT (hence the name) and continuing
with Windows 2000, Windows XP and Windows Server 2003. Linux
support for mounting NTFS read-only has existed since the 2.4
kernels. This support was greatly improved in the 2.6 kernels, but
the ability to write to an NTFS partition is still somewhat
experimental and therefore risky at the time of this writing.
Microsoft, the epitome of the proprietary software development
company, has never divulged the inner workings of the filesystem.
This has made NTFS driver development extremely hard and accounts
for the difficulties in providing full read-write support. For this
reason, most Linux distribution companies are reluctant to provide
kernels with NTFS support built-in. That means that, in most cases,
you'll need to either load a module for NTFS support into a running
kernel or compile NTFS support into a home-made kernel.
If you have a dual-boot system, then it's likely that you need
to mount the Windows partition from time to time. Assuming you have
NTFS support in the kernel, you would mount the partition like
this:
mount -t ntfs /dev/hda1 /mnt/
Creating a
Dual-Boot System
Let's say that you've bought a new system and you've paid the
Microsoft tax - which means that you've had to pay for Windows XP
because the OEM has left you with no alternative. In most cases
(and probably all of them), these machines have taken up the entire
hard disk. If you're going to install Linux, you need to free up
some space. Fortunately, you can use freely available Linux
utilities to get the job done.
SystemRescueCd
includes all the tools you need to
resize and NTFS partition.
Common Internet File
System
The Common Internet File System or CIFS is a network filesystem
based on protocols developed by Microsoft. Since this system was
developed by Microsoft, it's naturally difficult to explain how it
works with 100% accuracy. Microsoft is famous for keeping
secrets.
CIFS started out as the Server Message Block (SMB) protocol.
That's how Linux users know it best. The best known Linux software
to emulate a server running this protocol is known as Samba. It's
fairly easy to get a Samba server running on Linux. If you're
interested in this, please see our section [LINK] on Samba.
As far as client software goes, any Linux desktop running KDE
can use Konqueror as a client. By entering:
smb://server
in the URL field, you can open up a remote samba server.
You might be interested in mounting a remote file system. That
is also fairly easy with 'smbmount'. Simply create a subdirectory
called 'samba' in your /mnt directory and issue the following
command:
smbmount //server/directory /mnt/samba -o "uid=username,gid=username,fmask=664,dmask=775"
and you can use the remove samba share as a local directory,
creating files in it, writing to them or whatever you wish.
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/73521/showart_2116178.html