Download Linux Kernel—File Systems

Survey
yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts

Object storage wikipedia, lookup

Linux adoption wikipedia, lookup

Berkeley Software Distribution wikipedia, lookup

MTS system architecture wikipedia, lookup

Smallfoot wikipedia, lookup

Library (computing) wikipedia, lookup

Security-focused operating system wikipedia, lookup

RSTS/E wikipedia, lookup

Plan 9 from Bell Labs wikipedia, lookup

OS 2200 wikipedia, lookup

Commodore DOS wikipedia, lookup

Batch file wikipedia, lookup

CP/M wikipedia, lookup

DNIX wikipedia, lookup

VS/9 wikipedia, lookup

Spring (operating system) wikipedia, lookup

Burroughs MCP wikipedia, lookup

Computer file wikipedia, lookup

File locking wikipedia, lookup

Unix security wikipedia, lookup

Transcript
Linux file systems
Name: Peijun Li
Student ID: 0100276
Prof. Morteza Anvari
Introduction to Linux








Unix-like operating system
Free for everyone to use
Multi-user
Multi-tasking
Internet ready
Robust
Multi platform
Symmetrical Multi
Processors
History of Linux file systems
Minux FS--VFS--Ext FS--Xia FS--Ext 2 FS



In the early days, Linux was developed
under the Minix operating system
Linus Torvalds implemented support for the
Minux filesystem in Linux.
Limitations:
block addresses are stored in 16 bits
integers.
maximal filesystem size is 64 MB
maximal file name is 14 characters
History of Linux file systems
Minux FS--VFS--Ext FS--Xia FS--Ext 2 FS

In order to ease the addition of new
filesystem into the Linux kernal, a
Virtual File System layer(VFS) was
developed and integrated into the
Linux kernel.
History of Linux file systems
Minux FS--VFS--Ext



FS--Xia FS--Ext 2 FS
In April 1992, a new filesystem called
“Extended File System” was implemented
and added to Linux 0.96c
Maximal size is 2 GB and maximal file name
size is 255 characters
Limitations: No support for the separate
access, inode modification, and data
modification timestamps. Performance is too
bad.
History of Linux file systems
Minux FS--VFS--Ext FS--Xia
FS--Ext 2 FS
Released in Jan 1993
 Heavily based on the Minux FS Kernel
code. Very stable. Provide long file
names, support for bigger partitions
and the three timestamps.
 Limitation: not extensible

History of Linux file systems
Minux FS--VFS--Ext FS--Xia FS--Ext
2 FS
Released in Jan, 1993
 Based on Ext FS code with many
improvements.
 Was not stable. Right now is very
stable with the improvements and
integrated new features.

Summery of features of
different file system
Minix
FS
Ext
FS
Xia
FS
2GB
2GB
Ext2
FS
4TB
2GB
Max FS size
Max file size
64 MB
64MB
Max file name
3 times support
Extensible
Var. block size
Maintained
16/30 c
NO
NO
NO
YES
255c
NO
NO
NO
NO
255c
YES
YES
YES
YES
248c
YES
NO
NO
?
2GB
64MB
Basic File System
Concept
Inodes
 Directories
 Links
 Devices

Basic FS concept
--Inodes
Each file is represented by an Inode
 Each inode contains the description of
the file: file type, access rights,
owners, timestamps, size, pointers to
data blocks
 The addresses of data blocks
allocated to a file are stored in its
inode

Inode structure
:
Basic FS concept
--Directories



Directories are structured in a hierarchical
tree. Each directory can contain files and
subdirectories
A directory is a file containing a list of
entries. Each entry contains an inode
number and a file name
When a process uses a pathname, the
kernel code searches in the directories to
find the corresponding inode number, the
Inode is loaded into memory for requests.
Directories
Inode table
directory
i1
name1
i2
name2
i1
name3
i4
name4
Basic FS concept
--links


Hard link
can only be used to create a single file
system; can only point on files
Symbolic link
Does not point to an inode;
It is possible to create cross-file systems
symbolic links
Point to any type of file, even on
nonexistent files.
Basic FS concept
--Device special files



Character special files
I/o operations in character mode
Block special files
requires data to be written in block mode
When an I/O request is made on a special
file, it is forwarded to a (pseudo) device
driver. A special file is referenced by a major
number, which identifies the device type,
and a minor number, which identifies the
unit.
Virtual File System



Is used during system calls acting on files
The VFS is an indirection layer which
handles the file oriented system calls and
calls the necessary functions in the physical
file system code to do the I/O.
Knows about filesystem types supported in
the kernel. It uses a table defined during the
kernel configuration. Each entry in this table
describes a filesystem type
User process
System call
System call interface
VFS
Ext2 FS (etc.)
Linux kernel
Buffer Cache
Device drivers
I/O request
Disk controller
Hardware
VFS structure



A mounted filesystem descriptor
contains information common to filesystem
types, pointers for functions provided by
physical filesystem kernel code, and private
data maintained by the physical filesystem
code
An inode descriptor
contains pointers to functions that can be
used to act on any file
An open file descriptor
contains pointer to functions which can only
The Second Extended File
System(Ext2fs)





supports standard Unix file types: regular
files, directories, device special files and
symbolic links
allows the users to modify the kernel
behavior Can set attributes on a file or on a
directory
Can select System V or BSD semantics at
mount time.
Allows the administrator to choose the
logical block size(1024, 2048, 4096 bytes).
Implements fast symbolic links and keeps
Physical structure
A file system is made up of block
groups. Block groups are not tied to
the physical layout of the blocks on the
disk.
Block
Boot
selector Group 1
Block
Group2
… Block
… Group N
The structure of a block group
Contains a redundant copy of crucial
filesystem control informations and
also contains a part of filesystem.
Super
Block
Block
FS
descriptors Bitmap
Inode
Btmap
Inode
Table
Data
Blocks
Variable length entry
In Ext2fs, directories are managed as linked
lists of variable length entries. Each entry
contains : inode number, entry length, file
name and file length
Inode
number
Entry
length
Name
length
i1
16
05
File1
i2
40
09
Long_name
i3
12
02
f2
File
name
Performance optimization



Use buffer cache management by
performing readaheads: when a block has
to be read, the kernel code requests the I/O
on several contiguous blocks.
Block groups are used to cluster together
related inodes and data. This will reduce the
disk head seeks made when the kernel
reads an inode and its data blocks.
When writing data to a file, Ext2fs
preallocates up to 8 adjacent blocks when
allocating a new block. This will speed up
future sequential read.
The Ext2fs library




Provides routines which can be used to
examine and modify the data of an Ext2
filesystem.
Many of the Ext2 utilities use the Ext2fs
library. This greatly simplifies the
maintainance of these utilities.
Since the interfaces of the Ext2 library are
abstract and general, new programs can be
very easily written to access the Ext2fs
Provides access to several class of
operations: filesystem, directories, inodes
The Ext2fs tools




The mke2fs program: to initialize a partition
to contain an empty Ext2 File system
The tune2fs program: to modify the
filesystem parameters
The E2fsck program: to repair filesystem
inconsistencies after an unclean shutdown
of the system. It is designed to run as
quickly as possible.
The Debugfs program: to examine and
change the state of a filesystem. Read-only
by default.
Performance measurement

Use Bonnie benchmark to measure
filesystem performance(Remy Card 1993):
Bonnie Benchmark have been made on a
middle-end PC, based on a i486DX2
processor, using 16MB of memory and two
420MB IDE disks. The tests were run on
Ext2 fs , Xia fs and on the BSD fast
filesystem in asynchronous and
synchronous mode
Results of Bonnie
benchmark
Char
Write
(KB/s)
Block
Write
(KB/s)
Rewite
(KB/s)
Char
Read
(KB/s)
Block
Read
(KB/s)
BSD Async 710
684
401
721
888
BSD sync
699
677
400
710
878
Ext2 fs
452
1237 536
397
1033
Xia fs
440
704
366
895
380
Reference




[Williaim Stallings 1998] Operating Systems
3rd edition 1998
[David A. Rustuling 1999] The Linux kernel
1999
[Remy Card 1993] Design and
Implementation of the second Extended
Filesystem 1993
http://e2fsprogs.sourceforge.net/ext2.html
Thank you!