CITS2002 Systems Programming  
CITS2002 CITS2002 schedule  

Organisation of File Systems

A clear and obvious requirement of an operating system is the provision of a convenient, efficient, and robust filing system.

The file system is used not only to store users' programs and data, but also to support and represent significant portions of the operating system itself.

Stallings introduces the traditional file system concepts of:

fields
represent the smallest logical item of data "understood" by a file-system: examples including a single integer or string. Fields may be of a fixed length (recorded by the file-system as "part of" each file), or be of variable length, where either the length is stored with the field or a sentinel byte signifies the extent.

records
consist of one or more fields and are treated as a single unit by application programs needing to read or write the record. Again, records may be of fixed or variable length.

files
are familiar collections of identically represented records, and are accessed by unique names. Deleting a file (by name) similarly affects its component records. Access control restricts the forms of operations that may be performed on files by various classes of users and programs.

databases
consist of one or more files whose contents are strongly (logically) related. The on-disk representation of the data is considered optimal with respect to its datatypes and its expected methods of access.

CITS2002 Systems Programming, Lecture 18, p1, 24th September 2019.

 

Organisation of File Systems, continued

Today, nearly all modern operating systems provide relatively simple file systems consisting of byte-addressable, sequential files.

The basic unit of access, the record from Stallings's taxonomy, is the byte, and access to these is simply keyed using the byte's numeric offset from the beginning of each file (the size of the variable holding this offset will clearly limit a file's extent).

The file-systems of modern operating systems, such as Linux's ext2, ext3, and ext4 systems and the Windows-NT File System (NTFS), support volumes with sizes up to 1 exbibyte (EiB) and files with sizes up to 16 tebibytes (TiB).

 

Operating Systems and Databases

More complex arrangements of data and its access modes, such as using search keys to locate individual fixed-length records, have been "relegated" to being supported by run-time libraries and database packages (see Linux's gdbm information).

In commercial systems, such as for a large eCommerce system, a database management system (DBMS) many store and provide access to database information independent of an operating system's representation of files.

The DBMS manages a whole (physical) disk-drive, or a dedicated partition, and effectively assumes much of the operating system's role in managing access, security, and backup facilities.

CITS2002 Systems Programming, Lecture 18, p2, 24th September 2019.

 

The File Management System

The increased simplicity of the file systems provided by modern operating systems has enabled a concentration on efficiency, security and constrained access, and robustness.

Operating systems provide a layer of system-level software, using system-calls, to provide services relating to the provision of files.

The consistent use of system-calls for this task, obviates the need for each application program to manage its own disk (space) allocation and access.

Moreover, using system-calls to enter the kernel permits the OS to use file-system access as an opportunity to schedule processes. As a kernel-level responsibility, the file management system again provides a central role in resource (buffer) allocation and process scheduling.

File-based activity System-calls
File creation, deletion open(), creat(), close(), truncate(), unlink()
Accessing a file's contents read(), write(), lseek()
Accessing a file's attributes chmod(), chown(), stat()
(Some) directory operations mkdir(), rmdir()

From the "viewpoint" of the operating system kernel itself, the file management system has a number of goals:

  • to support the storage, searching, and modification of user data,
  • to guarantee the correctness and integrity of the data,
  • to optimise both the overall throughput (from the operating system's global view) and response time (from the user's view).
  • to provide "transparent" access to many different device types such as hard disks, CD-ROMs, and portable devices (accessed by their file-system),
  • to provide a standardised set of I/O interface routines, perhaps ameliorating the concepts of file, device and network access.

CITS2002 Systems Programming, Lecture 18, p3, 24th September 2019.

 

User Requirements

A further critical requirement in a multi-tasking, multi-user system is that the file management system meet users' requirements in the presence of different users.

Subject to appropriate permissions, important requirements include:

  • the recording of a primary owner of each file (for access controls and accounting),

  • each file should be accessed by (at least) one symbolic name,

  • each user should be able to create, delete, read, and modify files,

  • users should have constrained access to the files of others,

  • a file's owner should be able to modify the types of access that may be performed by others,

  • a facility to copy/backup files to identical or different forms of media,

  • a secure logging and notification system if inappropriate access is attempted (or achieved).

CITS2002 Systems Programming, Lecture 18, p4, 24th September 2019.

 

Components of the File Management System

Stallings provides a generic depiction of the structure of the file management system:

File System Software Architecture

Its components, from the bottom up, include:

  • The device drivers communicate directly with I/O hardware. Device drivers commence I/O requests and receive asynchronous notification of their completion (via DMA).

  • The basic file system exchanges fixed-sized pieces (blocks) of data with the device drivers, buffers those blocks in main memory, and maps blocks to their physical location.

  • The I/O supervisor manages the choice of device, its scheduling and status, and allocates I/O buffers to processes.

  • The logical I/O layer maps I/O requests to blocks, and maintains ownership and access information about files.

CITS2002 Systems Programming, Lecture 18, p5, 24th September 2019.

 

The Role of Directory Structures

All modern operating systems have adopted the hierarchical directory model to represent collections of files.

A directory itself is typically a special type of file storing information about the files (and hence directories) it contains.

Although a directory is "owned" by a user, the directory is truly owned by the operating system itself. The operating system must constrain access to important, and often hidden, information in the directory itself.

Although the "owner" of a directory may examine and (attempt to) modify it, true modification is only permitted through OS system-calls affecting the internal directory structure.

For example, deleting a file involves both deallocating any disk blocks used by that file, and removing that file's information from its container directory.

If direct modification of the directory were possible, the file may become "unlinked" in the hierarchical structure, and thereafter be inaccessible (as it could not be named and found by name).

In general, each directory is stored as a simple file, containing the names of files within it. The directory's "contents" may be read with simple user-level routines (introduced in Lecture 17).

CITS2002 Systems Programming, Lecture 18, p6, 24th September 2019.

 

File Information Structures - inodes

Early operating systems maintained information about each file in the directory entries themselves. However, the use of the hierarchical directory model encourages a separate information structure for each file.

As an example, Unix refers to these information structures as inodes, accessing them by their integral inode number on each device (themselves referred to by two integral device numbers).

Each information structure is accessed by a unique key (unique to the I/O device), and the role of the directory is now simply to provide <filename, inode> pairs.

A distinct file-entry is identified by a <major-device-number, minor-device-number, inode> triple.

Typical information contained within each inode includes:

  • the file's type (plain file, directory, etc),
  • the file's size, in bytes and/or blocks,
  • any limits set on the file's size (implied?),
  • the primary owner of the file,
  • information about other potential users of this file,
  • access constraints on the owner and other users,
  • dates and times of creation, last access and last modification,
  • pointers to the file's actual data blocks.

CITS2002 Systems Programming, Lecture 18, p7, 24th September 2019.

 

File Information Structures - inodes, continued

As a direct consequence, multiple file names (even from different directories) may refer to the same file. These are termed file-system links.

  • Individual processes access open files though their file descriptor table;
  • this table indexes the kernel's global file table; and
  • that table indexes the device's inode table.

CITS2002 Systems Programming, Lecture 18, p8, 24th September 2019.

 

File Allocation Methods - Contiguous

Of particular interest is the method that the basic file system uses to place the logical file blocks onto the physical medium (for example, into the disk's tracks and sectors).

Contiguous File Allocation

The simplest policy (akin to memory partitioning in process management) is the use of a fixed or contiguous allocation. This requires that a file's maximum (ever) size be determined when the file is created, and that the file cannot grow beyond this limit (as in the above figure).

The file allocation table stores, for each file, its starting block and length.

Like simple memory allocation schemes, this method suffers from both internal fragmentation (if the initial allocation is too large) and external fragmentation (as files are deleted over time).

Again, as with memory allocation, a compaction scheme is required to reduce fragmentation ("defragging" your disk).

CITS2002 Systems Programming, Lecture 18, p9, 24th September 2019.

 

File Allocation Methods - Chained

The opposite extreme to contiguous allocation is chained allocation.

Here, the blocks allocated to a file form a linked list (or chain) and, as a file's length is extended (by appending to the file), a new block is allocated and linked to the last block in the file:

Chained File Allocation

A small "pointer" of typically 32 or 64 bits is allocated within each file data block to indicate the next block in the chain. Thus seeking within a file requires a read of each block to follow the pointers.

New blocks may be allocated from any free block on the disk. In particular, a file's blocks need no longer be contiguous.

CITS2002 Systems Programming, Lecture 18, p10, 24th September 2019.

 

File Allocation Methods - Indexed

The file allocation method of choice in both Unix and Windows is the indexed allocation method.

This method was championed by the Multics operating system in 1966. The file-allocation table contains a multi-level index for each file - just as we have seen in the use of inodes, which contain direct pointers to data blocks, and pointers to indirection blocks (which point to more data blocks).

Indexed Allocation with Block Portions

Indirection blocks are introduced each time the total number of blocks "overflows" the previous index allocation.

Typically, the indices are neither stored with the file-allocation table nor with the file, and are retained in memory when the file is opened.

Further Reading on File Systems

CITS2002 Systems Programming, Lecture 18, p11, 24th September 2019.