Minix File System

CSC3150
Dr. John C.S. Lui

Abstract
Introduction to Minix File System

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui

 Supplementary Note: The Minix FS

Overview of Minix FS

Minix FS is just a big C program runs in a user
space.

user processes send messages to the FS telling what
they want done. The FS does the work and sends
back a reply. It can be used as a network le server!

Overview of Minix FS 1) messages, 2) FS layout, 3)
i-nodes, 4) block cache, 5) bit maps, 6) directories
and path names, 7) the process table, 8) pipe les,
9) integration.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 1

Messages

The FS accepts 29 types of messages requesting work.
Message Input parameters Reply value
type
ACCESS File name, access mode status
CHDIR Name of new working directory status
CHMOD File name, new mode status
CHOWN File name, new owner, new group status
CHROOT Name of new root directory status
CLOSE File descriptor of le to close status
CREAT Name of le to be created, mode File descriptor
DUP File descriptor (for DUP2, two of them) New File descriptor
FSTAT Name of le whose status is wanted, buer status
IOCTL File descriptor, function code, argument status
LINK Name of le to link to, name of link status
LSEEK File descriptor, oset, whence new position
MKNOD Name of dir or special le, mode, address status
MOUNT Special le, where to mount it, ro-ag status
OPEN Name of le to open, read/write ag File descriptor
PIPE (None) File descriptor
READ File descriptor, buer, how many bytes bytes read
STAT File name, status buer status
STIME Pointer to current time status
SYNC (None) Always OK
TIME Pointer to place where current time goes Real time
TIMES Pointer to buer for process and child times status
UMASK Complement of mode mask Always OK
UMOUNT Name of special le to unmount status
UNLINK Name of le to unlink status
UTIME File name, le times Always OK
WRITE File descriptor, buer, how many bytes bytes written
REVIVE Process to revive (no reply)
UNPAUSE Process to check (see text)

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 2


FS has a main loop that waits for a message to
arrive, message type will be extracted and used as an
index into a table containing pointers to procedures
within the FS that handle the request. When done,
return status.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 3

FS layout

The Minix FS is a logical, self-contained entity with
i-nodes, directories and data blocks. Example of a
360K layout with 127 i-nodes and 1K block size.
Figure 5.30.
Boot Super
block block I-nodes one disk block

~
~
~
~
I-node Zone
Data
bit map bit map

Figure 5.30: Minix FS Layout

Boot block. When a computer is turned on, the

hardware reads the boot block into memory and
jump to it.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 4


super-block contains information about le system
layout. Figure 5.31.
Numer of nodes
I-node bit map
Number of zones
Present Number of i-node bit map blocks
01011011
on disk Number of zone bit map blocks 10110111
and in First data zone 00110110
memory 11101110
Log 2(zone size/block size)

.......
Maximum file size
Magic number
Pointer to i-node bit map block
Zone bit map
....

Pointer to zone bit map block 11011011

....

10110111
Super-block’s device number 00110110
Present 11101111
in memory I-node of mounted file system

.......
but not I-node mounted on
on disk Time of last update
Read-only flag/Dirty flag

Figure 5.31: The MINIX super-block

Given block size and number of i-nodes. It is easy

to compute the size of i-node bit map and number
of blocks for i-nodes. For example, with 1K block
size, each block of bit maps can indicate status of
8191 i-nodes. If i-nodes are of 32-bytes, each block
holds 32 i-nodes, therefore, 127 i-nodes need 4 disk
blocks.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 5

disk storage is allocated in units (zones) of 1,2,4,8
or in general, 2n blocks.

mapping from zone to block or vice versa can be
done by algorithm. For example, with 8 blocks per
zone, to nd zone containing block 128, just shift
128 right by 3 bits.

when Minix is booted, the super-block for the root
device is read into a table called super-blocks table.
New parameters are then derived and stored in this
table like whether it has been mounted read-only,
modied status eld.

To enforce a known structure, the utility program
mkfs is provided to build a le system.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 6

Bit Maps

i-nodes and zone bit maps keep track of status.

upon boot up, super-block and bit maps for the
root device are loaded into memory.

to remove a le, based on the i-node number, we
will know which pointer in in the super-block to go
to and access the i-node bit map and then clear the
corresponding bit.

to create a le, sequentially search through the bit
map blocks until it nds a free i-node. This i-node
is then allocated for the new le. If no available
i-node, return 0.

Rational for zone is to improve performance so that
disk blocks that belong to the same le are located
on the same cylinder as much as possible.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 7

I-nodes

in Minix, i-node is a 32-bytes structure. Figure
5.32.
Mode File type and RWX bit
Uid Identifies the user who owns the file
File Size Number of bytes in the file
Time of last
modification In seconds, since Jan. 1, 1970
32 bytes

Link Gid Directories listing this i-node/owner’s group

Zone 0 number
Zone 1 number
Zone numbers for
Zone 2 number
the first 7 data
Zone 3 number
sones in the file
Zone 4 number
Zone 5 number
Zone 6 number
Indirect
Double Indirect
Only used for files larger than 7 zones

Figure 5.32: The MINIX i-node

mode indicates the type of le (regular, directory,

block special, character special or pipe), protection
bits.

It is dierent from traditional unix 1) number of
time eld, 2) link and gid sizes, 3) fewer disk block
pointers.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 8

When a le is opened, its i-node is located and
brought into the inode table in memory. It remains
there until the le is closed.

the inode table has several parameters which is not
in disk, 1) i-node's device number so system knows
where to write back the i-node, 2) a counter for each
i-node to indicate the number of process opening
the le. When the counter is zero, the i-node is
removed from the table and written to disk if it has
been modied.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 9

Block Cache

block cache is used to improve FS performance.

Each block buer is implemented as a node with

1) pointers 2) counters, 3) ags, 4) room for a disk
block.

buers are chained together in a double-link list

with most recently used (MRU) to least recently
used (LRU). Figure 5.33.
Hash table Rear (MRU) Front (LRU)

Figure 5.33: The linked lists used by the block cache

How can we quickly accessed a given block? Take

advantage of hashing technique by hashing the low-
order n bits of the block number. All blocks that
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 10
 have the same lower-order bits are linked together
on a single-linked list.

When the FS needs a block, it calls a procedure
get block. Base on hashing and searches the
appropriate list. If the block is found, a counter
in the block's header is incremented and a pointer
is returned. If block is not found, the LRU list is
searched to nd a block to evict (assuming there is a
xed block cache). If the block at front has counter
value of zero. That block is chosen for eviction,
otherwise, next block is inspected (what happen if
you cannot nd any block to evict?). When a block
is chosen for eviction, the system checks has the
block been modied (the modication ag is stored
in the header). For modied block, write it out to
disk. At this point, system can bring in another
block by sending a message to the disk task. FS
is suspended until the block arrives, then it returns
the block pointer to the caller.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 11


Another procedure put block is to decide where
to put the block. Blocks that are not likely to be
needed again (ex: double indirect blocks) go to the
front of the list. Blocks that are likely to be needed
go to the rear of the list. Data block that has been
modied is not rewritten back to disk unless 1) it
reaches the front of the list, 2) a SYNC system
call is made. For all those operations, remember to
chain back the hashed singled link list.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 12

Directories and Path

as mentioned before, when the system wants to
open a le, it is actually accessing an i-node.

le name look up is the same as we described
before. The important thing is to nd the root
directory i-node, which is located in the xed
position of the disk.

When user types in command
% mount /def/fd1 /user
this implies to mount the le system on top of /user.
Figure 5.34
Root file system Unmounted FS After mounting
/ / /

/lib /bin /user /bal /jim /ast /lib /bin /user

.....

/ast/f1 /ast/f2

/user/bal /user/ast

/user/ast/f2

(a) (b) (c)

Figure 5.34: (a) Root file system. (b) An unmounted file system.
(c) The result of mounting the file system of (b) on /user

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 13


What does it really mean for mounting? That is,
during le name lookup, how does the system know
when and where to switch?

OS has to 1) set a ag in "/user" to indicate
a successful mount, 2) load the super-block
and i-node of the newly mounted le system
into super-block table and i-node table (this
is accomplished by MOUNT call), 3) set the
i-node-of-the-mounted-le-system to point to the
root i-node of the newly mounted system, 4) set
the i-node-mounted-on to point to the i-node of
"/user".

to answer the previous question, it is straight
forward.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 14

File Descriptors

when a le has been open, a le descriptor is

returned to user. This implies the OS has to
manage le descriptor.

FS maintains part of the process table within its

address space. There are 3 interesting elds in
the process table, 1) pointer to the i-node of the
root directory, 2) pointer to the current working
directory for that process, 3) is an array "indexed"
by the le descriptor. It is used to locate the proper
le when a le descriptor is used by the process.
The interesting question is can we just put a pointer
of the le's i-node in the array?

To answer that, we rst have to understand in Unix,

les can be shared. For each le, there is a 32-bits
number indicates the le position (so process know
where to read or write the next time). where can
we put this number?
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 15

If we put it as part of the i-node eld, then dierent
processes might open the same le and they might
have dierent le positions. So we CANNOT put
the le position as part of the i-node.

Then can we put the le-position in the process
table? In this way, each process can have dierent
le-position even they are accessing the same le.
Problem during forking! So we cannot put the
le-position in the process table.

Solution: is to introduce a shared table, lp. Figure
5.35.
Process table I-node table

Parent File position

i-node pointer
Child

~
~ ~
~

~
~ ~
~
~
~ ~
~

Figure 5.35: How file positions are shared between a parent and a child

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 16


In this way, parent-child processes can be shared
using the same lp entry while dierent processes
point to dierent lp entry for sharing same le.
The lp entry has a counter to check number of
processes using it. It can be deallocated when it
reaches zero.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 17

Pipes and special les

If process tries to read or write from a disk, it is
certain that, at worst, it takes several disk access
to get the information. But when reading a pipe,
it is quite dierent because the reader of the pipe
may have to wait for the other process to put data
in the pipe.

when process tries to read or write from a pipe,
the FS can check the state of the pipe rst to see
if the operation is possible. If yes, proceed. Else,
FS records the parameters of the system call in the
process table for later restart of process and then
suspend the process.

In suspending process, FS just have to refrain from
sending a reply back to the calling process and then
the FS goes back to the main loop. Eventually,
other process will modify the state of the pipe so
the suspended process can proceed when the FS
service the process.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 18

For other special les like terminals and other
character special les. The i-node of this special
le has two numbers, the major and minor device
number. The major device number is to indicate
which class of device (e.g., RAM disk, oppy disk,
hard disk, terminal). It is also used to index into
a le system table so the proper I/O driver can be
called. Minor device number is used to specify the
specic device, for example, you might have several
oppy disk drive.

Once we know the I/O driver task number, the le

system sends the task a message including 1) minor
device number, 2) operation to be performed, 3)
caller's process number, 4) caller's buer address,
5) number of bytes to be transferred.

If the driver can carry out the work immediately,

it copies data from its internal buer to the user's
buer space, sends the FS a reply saying work is
done, then the FS can reply back to the calling
process.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 19

If driver is not able to carry out work, it records the
message parameters in its internal tables, reply to
the FS saying that the call could not be completed.
Then FS records the fact that the process is
suspended and waits for next message. Eventually
the driver can nish the work, it sends message back
to FS, the FS can reply back to the calling process.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 20

READ system call
% n = read(fd, buer, nbytes)

send read message to FS.

FS decodes message and jumps to the appropriate
function.

procedure extracts le descriptor and then locate
the lp entry and then the i-node for the le to
read.

request is then broken into pieces such that each
piece ts within a block. For example, if the le
position is at 600 and 1K bytes heave requested.
Request is split into two parts, for 600 to 1023, and
1024 to 1623.

for each piece, check to see if the relevant block is
in cache. If it is not, FS picks the least recently used
buer not currently in used and claims it. Sending
a message to the disk task to rewrite if the block is
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 21
 dirty. Then the disk task is asked to fetch the block
to be read.

once a block is in cache, the FS sends a message
to the system task asking it to copy the data to the
appropriate place in user's buer.

After the copy has been done, the FS sends a reply
message to the user specifying how many bytes have
been copied.

the library function read extracts the reply code
and returns it as the function value to the caller.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 22

Minix header les

le "fs/const.h" denes fs constants.

NR BUFS (number of blocks in buer cache),
NR BUF HASH (size of buer hash table),
NR FDS (max le descriptors per process),
NR FILPS (maximum number of slots in lp table),
can be changed to tune the system's performance.

Also denes position like BOOT BLOCK and
SUPER BLOCK.

buf.h denes the disk block buer cache. the
"b counts" holds the number of users of this buer
and "there are various pointers for LRU double link
list and hashed link.

buf.h also dened the type of block when FS calls
the put block(). Some blocks have to be written
out to disk immediately (e.g., i-node block, directory
block).
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 23

le.h contains the intermediate table to hold
current le position, i-node pointer, how many le
descriptors are currently pointing to this entry.

fproc.h is the FS's part of the process table. Again,
it has i-node pointers to working directory and root
directory as well as lp pointer. It also has two
elds fp suspended and fp revived to suspend and
revive a process.

inode.h denes the i-node table. Remember, when
a le is opened, its i-node is read into memory and
kept in the inode table. It has eld "i dirt" (is it
dirty), "i pipe" (if inode is a pipe), "i mount" (set
if other le system can be mounted on this inode,
"i seek" is for performance for pre-fetching. It is
set to inhibit read ahead.

super.h denes the super block table. Note that
the second half of the super-block is derived once it
is in the memory.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 24

Block Management

cache.c manages the block cache. It has six

procedures. Figure 5.36.
get_block Fetch a block for reading or writing
put_block Return a block previously requested with get_block
alloc_zone Allocate a new zone (to make a file longer)
free_zone Release a zone (when a file is removed)
rw_block Transfer a block between disk and cache
invalidate Purge all the cache blocks for some device

Figure 5.36: Procedures used for block management

when you need a data block, use get block() with

device an d block number. Buer chosen for eviction
is removed from hash chain and if it is dirty, write
it out on disk.

the procedure put block takes cares of putting the

newly returned block on the LRU list, and in some
cases, rewriting it back to the disk (e.g., directory
block).
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 25

invalidate() is called when a disk is unmounted so
that all blocks in the cache belonging to that le
system will be removed (as possible written out).

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 26

I-node management

inode.c manages i-node table. It has the following

supporting procedures. Figure 5.37.
get_inode Fetch an i-node into memory
put_inode Return an i-node that is no longer needed
alloc_inode Allocate a new i-node (for a new file)
wipe_inode Clear some fields in an i-node
free_inode Release an i-node (when a file is removed)
rw_inode Transfer an i-node between memory and disk
dup_inode Indicate that someone else is using an i-node

Figure 5.37: Procedures used for i-node management

get inode() searches the inode table to see if

the inode is already present (we need both device
number and inode number specify a system inode).
If so, increment the usage counter and returns a
pointer, else, called rw inode().

inode is returned by calling put inode, which

decrements the usage i cout. If the count is zero,
i-node is removed from i-node table. If it is dirty,
write it out to disk.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 27

alloc inode() will allocate a free i-node on a given
device.

free inode(), corresponding i-node bit-map is set
to zero.

dup inode() increment the usage count of the i-
node.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 28

Super-block management

super.c contains procedures to manage super-block
table and bit maps. Figure 5.38.
get_inode Fetch an i-node into memory
put_inode Return an i-node that is no longer needed
alloc_inode Allocate a new i-node (for a new file)
wipe_inode Clear some fields in an i-node
free_inode Release an i-node (when a file is removed)
rw_inode Transfer an i-node between memory and disk
dup_inode Indicate that someone else is using an i-node

Figure 5.37: Procedures used for i-node management

load bit maps() loads all bit map blocks, set up

super-block to point to them.

unload bit maps() is called when the le system is
unmounted and bit maps are copied back to disk.

get super() is used to search the super-block table
for a specic device. For example, when a le
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 29
 system is mounted, you need to check that it is not
already mounted.

scale factor() looks up the zone-to-block
conversion factor. It is dierent for each le system.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 30

File descriptor management

ledes.c manages the le descriptors and lp table.

get fd() looks for free le descriptor and free lp
slots.

get lp() looks up the lp entry for a given le
descriptor.

nd lp() nds a lp slot that points to a given
inode. We need this function, for example, when a
process is writing on a broken pipe. It uses a brute
force search of the lp table.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 31

FS main program

FS is always in an innite loop.

the call to get work() waits for the next request
message to arrive. It set global variable, who (the
caller's process table slot number) and fs call ( the
number of system call to be carried out).

Three ags is set: fp points to the caller's process
table slot, super user tells whether the caller is the
super-user and dont reply is set to FALSE. Then
call the appropriate system call routine.

When control comes back to the main loop. If
dont reply is set, reply is inhibited (e.g, process
has been blocked to read from an empty pipe).
Otherwise, reply is sent.

At the end of the loop, try to see if the le is being
read sequentially and to load the next block into
the cache before it is requested.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 32

get work() checks to see if any previously blocked
procedures have now been revived. They have
HIGHER PRIORITY over new messages. If no
internal work to perform, the FS call the kernel to
get a message.

reply() is basically a reply back to a user process.

fs init() is called for initialization before the FS
innite loop. It builds the block cache, initializes
the super-block tables, read in root i-node for the
root device, load i-node and zone bit maps.

table.c contains the pointer array used in the FS
main loop for determining which procedure handles
to call.

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 33

Creating, opening, and closing les

creating a le involves 1) allocating and initializing

an i-node for the new le, 2) entering the new le
in the proper directory, 3) setting up and returning
a le descriptor for the new le.

le creation is handled by procedure do creat().

It starts out by fetching the le name, makes sure
the le descriptor and lp table slots are available.
It these are o.k, call new node() to allocate new
i-node. Then claims the le descriptor and lp
entry.

MKNOD system call is handled by domknod. It is

similar to do create except that it creates the i-node
and makes a directory entry for it. If i-node already
exits, the call terminates with an error.

procedure new node() handles i-node allocation

and entering the pathname into the le system.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 34
 After inode allocation, make sure to write it back
to disk for consistency.

do open() is to open a le. It parses the given

lename and make all necessary check (e.g., is it
readable) Then it loads in the le inode into the
memory and le descriptor is returned.

closing a le is performed by do close(). If it is

a regular le, decrement the lp counter. If it is
zero, return the i-node by calling put inode(), which
implies decrementing the the counter in the inode
table.

reading and writing a le is done by calling

do read() and do write(). Both of these routines
call read write() with appropriate parameter.

Inside readwrite() routine, there is a special code

for the memory manager to READ the entire FS into
memory. The logical structure is in Figure 5.40.
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 35
 Entry point

do_read do_write

read_write Main procedure for reading/writing

Special dev_io pipe_check rw_chunk

files Read or Write one block

read_map get_block rw_user put_block

Look up User-FS Return block

disk address transfer to cache
rw_block
Search the cache

dev_io

rw_dev List in dmap table

sendrec Sends message to the kernel

Figure 5.40: Some of the procedures involved in reading a file

writing a le is similar to reading one except

that writing requires allocating new disk block.
Procedure write map, which is similar to read map,
instead looking up a physical block in the i-node
and its indirect blocks, it enters new block in inode
or in the indirect blocks.

pathname look up is done in le path.c, which
CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 36
 has several components. Note that pathnames may
be absolute or relative, this can be detected by
examining the rst component of the pathname
argument. For absolute address, point to the root
i-node, for relative address, point to the working
directory inode. Figure 5.42.
dev_io Convert path to i-node

Get final Process one component

dev_io directory dev_io

dev_io dev_io dev_io Load

i-node

dev_io dev_io dev_io

Look up Find block Return block

disk address in cache to cache

Figure 5.42: Some of the procedures used in looking up path names

mounting and unmounting is handled in

le mount.c by two routines, do mount and
do unmount. Again, there are many error checking
codes (e.g., checking if the FS to be mounted is a
block device or not).

CSC3150: Introduction to Operating Systems. Prepared by Dr. John C.S. Lui 37