offline
- beli0135
- Executor
- Pridružio: 03 Jan 2005
- Poruke: 2990
- Gde živiš: Beograd
|
(preuzeto iz SuSE 9 bible)
Filesystems
============
Filesystems provide a base for your files to be stored on the physical disk. A good analogy
is that a disk is like the building that houses your local library, while the filesystem is its
infrastructure—the shelves that hold the books and the card catalog that enable you to find
a particular title. Linux supports many different types of filesystems, each of which has its
own internal structure and access methods. To access a specific type of filesystem, Linux
uses kernel software known as a driver that understands the internal structure of a specific
filesystem. If you are trying to read a disk from another type of system, Linux might also need
to load additional drivers to be able to interpret the disk partition tables used by some types
of disks and associated filesystems.
To provide access to a wide range of different types of filesystems, Linux provides a general
method that is easily extended. Linux provides a virtual filesystem (VFS) layer that a filesystem
driver hooks into to provide file-based access to information. Whether it is listing the
files in a directory, reading the data from a file, or providing other functionality such as direct
file access (not using the filesystem buffers), VFS and the filesystem driver provide a uniform
application program interface (API) to deal with files in different types of filesystems. This is
nothing new, and Unix and all other operating systems that support multiple filesystems provide
this virtual filesystem interface in one way or another.
When you have created partitions, you must usually create a filesystem in that partition to
make use of the newly allocated space. Many different types of filesystems are available for
this purpose, but this section focuses on types of filesystems that are available out of the box
with SUSE Linux.
The most common and preferred filesystem used with SUSE is the Reiser filesystem
(ReiserFS). ReiserFS was the first stable incarnation of a journaling filesystem on Linux. The
development of ReiserFS was partly funded by SUSE as they realized that enterprise class
storage (at least large storage pools) needed a journaling filesystem.
Historically, the most popular Linux filesystem is EXT2, which is a fast, simple filesystem that
does not have a journaling feature. When a system that uses EXT2 filesystems crashes, the
EXT2 metadata must be scanned thoroughly and compared to the data that is actually on the
disk to correct any chance of data corruption. On a large system, this consistency check can
take at best minutes and at worst an hour or two. Journaling filesystems introduce a small
overhead for all write operations, but the greater assurances of data consistency and the fact
that modern drives are very fast make them an attractive choice for use on most modern
Linux systems.
There are certain situations where the use of a journaling filesystem can be a bad idea—
most notably with databases that store their data in a standard Linux filesystem but that
keep their own log of changes to those data files and are able to recover data using their own
internal methods. Oracle is a good example of a database that provides its own methods to
guarantee the consistency of its data files.
EXT2
-----
EXT2 has been the de facto Linux filesystem for many years and is still used for initial
ramdisks and most non-journaling filesystems. Because of its age, EXT2 is considered
extremely stable and is quite lightweight in terms of overhead. The downside to this is that
it does not use any journaling system to maintain integrity of data and metadata.
EXT3
------
EXT3 is a journaling version of the EXT2 filesystem discussed in the previous section. It adds
a journal to the EXT2 filesystem, which can be done to an existing EXT2 filesystem, enabling
easy upgrades. This is not possible with other journaling filesystems because they are internally
very different from other existing filesystems.
EXT3 provides three journaling modes, each of which has different advantages and
disadvantages:
. journal—Logs all filesystem data and metadata changes. The slowest of the three
EXT3 journaling modes, this journaling mode minimizes the chance of losing the
changes you have made to any file in an EXT3 filesystem.
. ordered—Logs only changes to filesystem metadata, but flushes file data updates to
disk before making changes to associated filesystem metadata. This is the default EXT3
journaling mode.
. writeback—Logs only changes to filesystem metadata but relies on the standard
filesystem write process to write file data changes to disk. This is the fastest EXT3 journaling
mode.
What Is a Journaling Filesystem?
---------------------------------
A journal, with respect to filesystems, is an area of the disk that is used to store information
about pending changes to that filesystem. Filesystems contain two general types of information:
the actual files and directories where your data is stored, and filesystem metadata, which is internal
information about the filesystem itself (where the data for each file is physically stored, which
directories contain which files, and so on). When you write to a file in a journaling filesystem, the
changes that you want to make are written to the journal rather than directly to the file. The
filesystem then asynchronously applies those changes to the specified file and updates the
filesystem metadata only when the modified file data has been successfully written to the file in
question. Journaling helps guarantee that a filesystem is always in a consistent state. When you
reboot a Linux system, Linux checks the consistency of each filesystem (using a program called
fsck, for file system consistency check) before mounting it. If a filesystem requires repair
because its consistency cannot be verified, the fsck process can take a long time, especially on
larger disks. Enterprise systems tend to require journaling filesystems to minimize the time it
takes to restart the system because downtime is generally frowned upon.
Chapter 3 . Partitions, Filesystems, and Files 79
Beyond its flexibility and the ease with which EXT2 filesystems can be converted to EXT3
filesystems, another advantage of the EXT3 filesystem is that it is also backward compatible,
meaning that you can mount an EXT3 filesystem as an EXT2 system because the layout on
disk is exactly the same. This enables you to take advantage of all the existing filesystem
repair, tuning, and optimization software that you have always used with EXT2 filesystems
should you ever need to repair an EXT3 filesystem.
ReiserFS
---------
The ReiserFS filesystem was mentioned earlier; this section provides more in-depth information
about its advantages and capabilities. ReiserFS is one of the most stable Linux journaling
filesystems available. Although occasional problems have surfaced in the past, the ReiserFS
filesystem is widely used, and problems are therefore quickly corrected.
ReiserFS does not allocate and access files in the traditional block-by-block manner as do
other filesystems such as EXT2, but instead uses a very fast, balanced b-tree (binary tree)
algorithm to find both free space and existing files on the disk. This b-tree adds a simple but
elegant mechanism for dealing with small files (files that are smaller than the filesystem block
size, generally 4 kilobytes) in ReiserFS. If a file is smaller than a filesystem block, it is actually
stored in the binary tree itself instead of being pointed to. Retrieving the data for these files
therefore takes no more time than is required to locate them in the b-tree, which makes
ReiserFS an excellent choice for filesystems in which large numbers of small files are constantly
being created and deleted, such as mail directories or mail servers.
ReiserFS also provides other optimization that can lead to dramatic space savings compared
to traditional filesystems.
When a file is stored on a filesystem, filesystem blocks are allocated to actually store the data
that the files contain. If you had a block size of 4K, but wished to store a file of 6K on the disk,
you would be wasting 2K of disk space because a block belongs to one file only and in this
case you would have to occupy two, wasting 2K and therefore not optimally using the space.
ReiserFS can also store these fragments in its b-tree by packing them together, which provides
another way of minimizing disk space consumption in a ReiserFS filesystem. Later in the chapter,
we look at some published benchmarks comparing filesystems in different situations.
JFS
JFS is a port of IBM’s Journaling Filesystem to Linux. JFS was originally developed for IBM’s
OS/2 operating system and later adapted for use as the enterprise filesystem used on its
pSeries/AIX-based systems. IBM released the source code for JFS to the open source community
in 2000 and has actively participated in the continuing development and support of this
filesystem for Linux since that time. JFS is similar to ReiserFS in that it uses binary trees to
store information about files. JFS is heavily based on transactions, in much the same way that
databases are, using these as the basis for the records that it maintains in its journal. JFS provides
a very fast method of data allocation based on extents. An extent is a contiguous series
of data blocks that can be allocated, read, written, and managed at one time.
JFS also makes clever use of filesystem data structures such as the inode (information node)
data structure that is associated with each single file or directory in the filesystem. At least
one inode exists for every file in the filesystem, but JFS creates them only when files and
directories are created. In traditional filesystems, the number of inodes (and thus the number
of files) on a filesystem was dictated at filesystem creation time. This could lead to a situation
in which even though there was enough space on the device, no more files could be created
because there was nowhere to store information about the file. Creating inodes as files and
80 Part I . SUSE Linux Basics
directories are allocated means that a JFS filesystem can contain an essentially unlimited
number of files and allows a JFS filesystem to be scalable in the traditional sense. As JFS is a
64-bit filesystem, it is also able to allocate space for extremely large files, unlike existing 32-bit
filesystems that can create files only up to 4GB in size because of addressing issues.
XFS
-------
XFS is SGI’s high-performance 64-bit filesystem, originally developed for use with its IRIX
operating system. SGI machines have traditionally had to work with large data sets on
machines with many processors, which is reflected in the way that XFS works. One of the
best features of XFS is that it offers independent domains of data across the filesystem. This
allows a multiprocessor system to access and change data in different allocation groups
independently of each other. This also means that instead of a single write happening to the
filesystem at one time, multiple reads and writes can take place at the same time. This provides
a significant performance boost for enterprise level data storage. This may not sound
like something that would work in the traditional sense of a single disk on a home PC, but if
you have a storage area network in which multiple data streams are provided by many disks,
the idea works very well.
Like ReiserFS, XFS uses its journal to store information about file metadata and employs
binary trees to handle allocation of data. An added feature of XFS is that it also uses a binary
tree to store information about free space. This helps speed up block allocation for new
information. As you would expect from a filesystem originally developed for machines that
process huge amounts of multimedia data, XFS is especially good at allocating and managing
huge files.
XFS is truly an enterprise filesystem and may not prove overwhelmingly attractive for a home
user, but for large amounts of data and high-end machines, it really is an excellent choice.
VFAT/NTFS
-------------
Virtual File Allocation Table (VFAT) and New Technology File System (NTFS) are the Microsoft
filesystems that are found in Windows 98/95, NT, and 200x operating systems. NTFS filesystems
are readable by Linux systems, although writing NTFS filesystems is a recent addition to
the Linux kernel that is still being developed and debugged. Support for the VFAT filesystem
is quite stable in Linux and enables a user to mount and reliably read and write to VFAT
filesystems, which is especially convenient if you are using a machine that can boot both
Linux and Windows. SUSE Linux is usually quite good at finding a Windows installation and,
depending on its support for the version of NTFS used on your disk(s), will create a mount
point for your Windows filesystems so that you can access your files while running Linux.
Dopuna: 29 Maj 2006 14:56
Benchmark
[Link mogu videti samo ulogovani korisnici]
Verovatno bi najbolja opcija bila ReiserFS za ROOT particiju, a JFS za /home
Na svim testovima, Ext3 je najsporiji, ali sa najmanje pojedene memorije.
|
