This document discusses various aspects of file system implementation in operating systems. It covers file system structures, directory implementation methods, allocation techniques like contiguous, linked and indexed allocation, free space management using bitmaps and linked lists, performance optimization using caching, and recovery methods like journaling. It also describes network file systems like NFS, which allow remote access to files across networked machines in a transparent manner using client-server architecture and remote procedure calls.

1. File-System Implementation

2. | (OS: Operating Systems) | (File-System Implementation) | 2
Chapter 12: File System Implementation
File System Structure
File System Implementation
Directory Implementation
Allocation Methods
Free-Space Management
Efficiency and Performance
Recovery
Log-Structured File Systems
NFS

3. | (OS: Operating Systems) | (File-System Implementation) | 3
File-System Structure
File structure
 (Logical storage unit)

-(secondary storage-disks)
File control block –

4. | (OS: Operating Systems) | (File-System Implementation) | 4
Layered File System

5. | (OS: Operating Systems) | (File-System Implementation) | 5
A Typical File Control Block

6. | (OS: Operating Systems) | (File-System Implementation) | 6
In-Memory File System Structures
OS
Figure 12-3(a)
Figure 12-3(b)

7. | (OS: Operating Systems) | (File-System Implementation) | 7
In-Memory File System Structures

8. | (OS: Operating Systems) | (File-System Implementation) | 8
Virtual File Systems
Virtual File Systems (VFS)
VFS (Application Program Interface-API)
API (VFS interface),

9. | (OS: Operating Systems) | (File-System Implementation) | 9
Schematic View of Virtual File
System

10. | (OS: Operating Systems) | (File-System Implementation) | 10
Directory Implementation
(Linear list) (data blocks)

 execute
(Hash Table) – (hash data structure)
 directory
 (collisions) – 2
 (fixed size)

11. | (OS: Operating Systems) | (File-System Implementation) | 11
Allocation Methods
(Contiguous allocation)
(Linked allocation)
(Indexed allocation)

12. | (OS: Operating Systems) | (File-System Implementation) | 12
Contiguous Allocation
– (block #) (number of blocks)
(Random access)
(dynamic storage-allocation problem)
(Files cannot grow)

13. | (OS: Operating Systems) | (File-System Implementation) | 13
Contiguous Allocation of Disk
Space

14. | (OS: Operating Systems) | (File-System Implementation) | 14
Extent-Based Systems
(I.e. Veritas File System)
Extent-based file systems (extents)
(extent) (extents)

15. | (OS: Operating Systems) | (File-System Implementation) | 15
Linked Allocation
(linked list)
pointerblock =

16. | (OS: Operating Systems) | (File-System Implementation) | 16
Linked Allocation (Cont.)
– (starting address)
(Free-space management system) –
(random access)
(Mapping)
Qth block
Displacement into block = R + 1
File-allocation table (FAT) – (disk-space allocation) MS-DOS
OS/2.
LA/511
Q
R

17. | (OS: Operating Systems) | (File-System Implementation) | 17
Linked Allocation

18. | (OS: Operating Systems) | (File-System Implementation) | 18
File-Allocation Table

19. | (OS: Operating Systems) | (File-System Implementation) | 19
Indexed Allocation
pointers index block.
(Logical view)
index table

20. | (OS: Operating Systems) | (File-System Implementation) | 20
Example of Indexed Allocation

21. | (OS: Operating Systems) | (File-System Implementation) | 21
Indexed Allocation (Cont.)
(index table)
(Random access)
(Dynamic access) (external fragmentation), overhead
index block
Mapping 256K words block size of 512 words 1 block
index table
LA/512
Q
R
Q = displacement into index table
R = displacement into block

22. | (OS: Operating Systems) | (File-System Implementation) | 22
Indexed Allocation – Mapping
(Cont.)
Mapping (block size of 512 words)
(Linked scheme) – Link blocks index table ()
LA / (512 x 511)
Q1
R1
Q1 = block of index table
R1 is used as follows:
R1 / 512
Q2
R2
Q2 = displacement into block of index table
R2 displacement into block of file:

23. | (OS: Operating Systems) | (File-System Implementation) | 23
Indexed Allocation – Mapping
(Cont.)
2 (Two-level index) 5123
LA / (512 x 512)
Q1
R1
Q1 = displacement into outer-index
R1 is used as follows:
R1 / 512
Q2
R2
Q2 = displacement into block of index table
R2 displacement into block of file:

24. | (OS: Operating Systems) | (File-System Implementation) | 24
Indexed Allocation – Mapping
(Cont.)

outer-index
index table file

25. | (OS: Operating Systems) | (File-System Implementation) | 25
Combined Scheme: UNIX (4K bytes per
block)

26. | (OS: Operating Systems) | (File-System Implementation) | 26
Free-Space Management
Bit vector (n blocks)
…
0 1 2 n-1
bit[i] =

0 ⇒ block[i] free
1 ⇒ block[i] occupied
Block number calculation
(number of bits per word) *
(number of 0-value words) +
offset of first 1 bit

27. | (OS: Operating Systems) | (File-System Implementation) | 27
Free-Space Management (Cont.)
Bit map Example:
block size = 212
bytes
disk size = 230
bytes (1 gigabyte)
n = 230
/212
= 218
bits (or 32K bytes)
Linked list (free list)


Grouping
Counting

28. | (OS: Operating Systems) | (File-System Implementation) | 28
Free-Space Management (Cont.)
(protect)
 Pointer (free list)
 Bit map


 block[i] bit[i] = 1 bit[i] = 0
 Solution:
 Set bit[i] = 1 in disk.
 Allocate block[i]
 Set bit[i] = 1 in memory

29. | (OS: Operating Systems) | (File-System Implementation) | 29
Linked Free Space List on Disk

30. | (OS: Operating Systems) | (File-System Implementation) | 30
Efficiency and Performance
(Efficiency) :

 (file’s directory entry)
(Performance)
 (disk cache) –
 free-behind and read-ahead – (optimize sequential access)
 dedicating section (virtual disk, or RAM disk)

31. | (OS: Operating Systems) | (File-System Implementation) | 31
Various Disk-Caching Locations

32. | (OS: Operating Systems) | (File-System Implementation) | 32
Page Cache
(page cache) virtual memory
Memory-mapped I/O page cache
Routine I/O file system buffer (disk) cache

33. | (OS: Operating Systems) | (File-System Implementation) | 33
I/O Without a Unified Buffer Cache

34. | (OS: Operating Systems) | (File-System Implementation) | 34
Unified Buffer Cache
A unified buffer cache memory-mapped pages ordinary
file system I/O

35. | (OS: Operating Systems) | (File-System Implementation) | 35
I/O Using a Unified Buffer Cache

36. | (OS: Operating Systems) | (File-System Implementation) | 36
Recovery
(Consistency checking) –
system programs back up (floppy disk, magnetic tape).
restoring

37. | (OS: Operating Systems) | (File-System Implementation) | 37
Log Structured File Systems
Log structured ( journaling) (transaction)
log (committed) log file system
log (asynchronously written) file system file system log
(crashes) log

38. | (OS: Operating Systems) | (File-System Implementation) | 38
The Sun Network File System
(NFS)
An implementation and a specification of a software
system for accessing remote files across LANs (or
WANs).
The implementation is part of the Solaris and SunOS
operating systems running on Sun workstations using an
unreliable datagram protocol (UDP/IP protocol and
Ethernet.

39. | (OS: Operating Systems) | (File-System Implementation) | 39
NFS (Cont.)
Interconnected workstations viewed as a set of
independent machines with independent file systems,
which allows sharing among these file systems in a
transparent manner.
 A remote directory is mounted over a local file system
directory. The mounted directory looks like an integral
subtree of the local file system, replacing the subtree
descending from the local directory.
 Specification of the remote directory for the mount operation
is nontransparent; the host name of the remote directory
has to be provided. Files in the remote directory can then
be accessed in a transparent manner.
 Subject to access-rights accreditation, potentially any file
system (or directory within a file system), can be mounted
remotely on top of any local directory.

40. | (OS: Operating Systems) | (File-System Implementation) | 40
NFS (Cont.)
NFS is designed to operate in a heterogeneous
environment of different machines, operating systems,
and network architectures; the NFS specifications
independent of these media.
This independence is achieved through the use of RPC
primitives built on top of an External Data Representation
(XDR) protocol used between two implementation-
independent interfaces.
The NFS specification distinguishes between the services
provided by a mount mechanism and the actual remote-
file-access services.

41. | (OS: Operating Systems) | (File-System Implementation) | 41
Three Independent File Systems

42. | (OS: Operating Systems) | (File-System Implementation) | 42
Mounting in NFS
Mounts Cascading mounts

43. | (OS: Operating Systems) | (File-System Implementation) | 43
NFS Mount Protocol
Establishes initial logical connection between server and
client.
Mount operation includes name of remote directory to be
mounted and name of server machine storing it.
 Mount request is mapped to corresponding RPC and forwarded
to mount server running on server machine.
 Export list – specifies local file systems that server exports for
mounting, along with names of machines that are permitted to
mount them.
Following a mount request that conforms to its export list,
the server returns a file handle—a key for further accesses.
File handle – a file-system identifier, and an inode number to
identify the mounted directory within the exported file
system.
The mount operation changes only the user’s view and does
not affect the server side.

44. | (OS: Operating Systems) | (File-System Implementation) | 44
NFS Protocol
Provides a set of remote procedure calls for remote file
operations. The procedures support the following operations:
 searching for a file within a directory
 reading a set of directory entries
 manipulating links and directories
 accessing file attributes
 reading and writing files
NFS servers are stateless; each request has to provide a full set
of arguments.
Modified data must be committed to the server’s disk before
results are returned to the client (lose advantages of caching).
The NFS protocol does not provide concurrency-control
mechanisms.

45. | (OS: Operating Systems) | (File-System Implementation) | 45
Three Major Layers of NFS
Architecture
UNIX file-system interface (based on the open, read,
write, and close calls, and file descriptors).
Virtual File System (VFS) layer – distinguishes local files
from remote ones, and local files are further distinguished
according to their file-system types.
 The VFS activates file-system-specific operations to handle
local requests according to their file-system types.
 Calls the NFS protocol procedures for remote requests.
NFS service layer – bottom layer of the architecture;
implements the NFS protocol.

46. | (OS: Operating Systems) | (File-System Implementation) | 46
Schematic View of NFS
Architecture

47. | (OS: Operating Systems) | (File-System Implementation) | 47
NFS Path-Name Translation
Performed by breaking the path into component names
and performing a separate NFS lookup call for every pair
of component name and directory vnode.
To make lookup faster, a directory name lookup cache on
the client’s side holds the vnodes for remote directory
names.

48. | (OS: Operating Systems) | (File-System Implementation) | 48
NFS Remote Operations
Nearly one-to-one correspondence between regular UNIX
system calls and the NFS protocol RPCs (except opening and
closing files).
NFS adheres to the remote-service paradigm, but employs
buffering and caching techniques for the sake of performance.
File-blocks cache – when a file is opened, the kernel checks
with the remote server whether to fetch or revalidate the cached
attributes. Cached file blocks are used only if the corresponding
cached attributes are up to date.
File-attribute cache – the attribute cache is updated whenever
new attributes arrive from the server.
Clients do not free delayed-write blocks until the server confirms
that the data have been written to disk.