Lecture 24

Properties of the traditional file system

• I/O buffered by kernel, no alignment requirements, all transfers appears synchronous.

• All transfers in 512 byte blocks.

• Poor throughput for data intensive applications.

• Disk divided into multiple partitions, each of which can contain one file sysem.

• Each file system has a superblock which contains the file system parameters necessary to store and retrieve information (number of data blocks in the fs, count of max number of files, pointer to the free list (linked list of all unused blocks).

• Some files contain data, others are directories (contianing pointers to files)

• Each file has an inode descriptor contining information about
  • file ownership,

  • last modification time,

  • last access time,

  • Pointers to the first 8 (actually 5-13) blocks of data in the file (the direct blocks).

  • Reference to indirect blocks containing data block indices. (In a 512 byte block system, an indirect block can contain 128 block addresses (65,536 bytes).

  • A doubly indirect block contains 128 references to indirect blocks (8,388,608 bytes).

  • A triply indirect block contains 128 references to doubly indirect blocks (1,067,341,824 bytes)

• Consider a 150MB file system:
  • 4 MB of inodes, 146MB of data.

  • Inodes are separate from data, so long seeks from inode to data must occur.

  • Files in a directory are allocated anywhere on disk

• The traditional file system combines small block size, limited read-ahead, many seeks.

The old Berkeley file system

• Block size was increased to 1024, leading to a doubling of throughput.

• Two factors influencing this:

  1. Half as many writes needed to be performed.

  2. Most files could be described without need to access indirect blocks, since the direct blocks contained twice as much data.

• Old file system problems:
  • Only used 4% of available disk bandwidth

  • Free list was initially ordered, but quickly became unordered, causing files blocks to be randomly placed around the disk forcing more seeks than might be necessary.

  • Initially, transfer rates would reach 175 kB/s. After a few weeks, transfer rates of 30 kB/s could be experienced.

  • Only way to restructure file system: dump, rebuild, and restore.

The new file system (FFS)

• Superblocks are replicated to protect against inability to rebuild file system after catastrophic failure. Superblock data doesn't change, so this needs to be done only once.

• Block size increased to 4096 (or a power of two higher). This permits 2^23 (1024*1024*4096, 4,294,967,296) bytes to be stored using doubly indirect blocks. Block size is chosen on file system initialization.

• Disk partitions divided into cylinder groups, which are colections of contiguous cylinders on the disk.

• Each cylinder group includes:
  • One superblock

  • Space for inodes

  • A bit map identifying available/used blocks within the cylinder. (This replaces the linked free list.)

  • Summary information telling about usage of blocks in the group.

• Bookkeeping info begins at varying offsets from the beginning of the cylinder group. The offset is calculated to cause the information location to spiral down into the disk as it goes. (As I understand it, it varies both by platter and sector position.) Thus, physical damage to any single sector, track, cylinder, or platter, could not destroy the integrity of the entire file system. (Under the old file system, destroying the top platter of the disk could completely ruin the file system).

• Except for the first cylinder (which must contain a boot record), the first cylinder of each group contains data blocks rather than summary information.

How to get better storage utilization with big blocks

• If large blocks are used, there is a problem representing small files. (Internal fragmentation.)

  Space used MBytes	% Waste	Organization
  775.2	0.0	Data only, no separation between files
  807.8	4.2	Data only, each file starts on 512-byte boundary
  828.7	6.9	Data + inodes, 512-byte block UNIX file system
  866.5	11.8	Data + inodes, 1024-byte block UNIX file system
  948.5	22.4	Data + inodes, 2048-byte block UNIX file system
  1128.3	45.6	Data + inodes, 4096-byte block UNIX file system

  Files measured to calculate the above data were taken from a an active filesystem with 920 MB of formatted space. Wasted space is the percentage of space in active blocks on the disk not containing any user data.

• Clearly the FFS must do something to store small files and fragments of files in a better way.

• Each entry in the block map contains the same number of entries per block (either 2, 4, or 8, a factor determined at file system creation time). Discussion that follows assumes 4096/1024 block/subblock sizes.

• If the block map contains an X (1) for the subblock, then that subblock is allocated. If it contains an O (0) that subblock is free. Fragments of adjoining blocks may not be coalesced to form new full blocks. All writes (fragment or full block) must occur within a single block.

• Each file is represented by 0 or more 4096 blocks and zero (0) to three (3) subblocks. If a file contains an n subblock fragment and the bit map contains no occurrences of n contiguous subblocks within a block, then a block is split, allowing three fragments to be written contiguously and providing one fragment for future use in another file.

• When extending a file, one of the following conditions can exist:

  1. The disk contains enough space to accomodate the information to be written, in an already allocated block or fragment on the disk.

  2. The file contains no fragments but must be extended to contain new blocks or fragments. First fill the last block. Then repeatedly allocate a full blocks if 3073 bytes or more of data remain and write the data, until 3072 bytes or fewer remain. Finally, if necessary, either find existing contiguous fragment blocks or divide a block into fragment blocks and fill the appropriate number of fragment blocks with data.

  3. The file already contains one or more fragments. If the data can be written to the current fragment blocks, or to the current fragment blocks and unused contiguous blocks within the same full block, write it. Otherwise, allocate a new full block. Copy the existing fragments into the new full block, then append the rest of the data as described above.

• This can be inefficient if a file is repeatedly extended by one fragment increments. Thus, the file system buffers reads and writes in units of block size that are optimal for the device being written. Different block sizes may be maintained for different devices.

• Wasted space in a new 4096/1024 file system is identical to that in an old 1024 file system (about 11.8%).

• Layout policies (to be discussed later) won't work if the file system is full. Each file system has a free-space reserve percentage.

File System Parameterization

• The old Berkeley file system operated completely independent of any processor- or disk-specific parameters.

• The Fast File System (FFS) customizes its behavior based on the values of the following parameters:
  • Processor speed.
  • Hardware support for mass storage transfer
  • Mass storage device characteristics (may differ for each file system on a given machine)

• FFS was designed based on the disk technology of the mid 1980s. At that time, most disks had very little on-board processing and their device drivers had relatively transparent access to their physical layout.

• FFS tries to allocate further blocks for a file in the same cylinder as the previous block for a file.

  Why?

• The allocation routines consider the number of blocks per track, the disk rotational speed, and the expected time for the processor to service an interrupt and schedule a new disk transfer. When a block is allocatd to a file, the filesystem calculates the location of the block that will be under the head when the next disk transfer operation starts.

  What disk operations will benefit from such a strategy?

• The cylinder group summary block contains the number of available blocks in 8 different rotational positions. The superblock contains a rotational layout table, identifying the position in the block map for each of the rotational positions. When a write happens, the appropriate index in the rotational layout table is consulted so the search for a new block will occur in the best rotational block group.

• The parameter defining the delay between end of one data transfer and beginning of another can be changed at any time. This accomodates the moving of a disk from one system to another slower or faster system.

Layout Policies

• Two levels of policy:
  • Global: uses file-system-wide summary information to decide the placement of new inodes and data.
  • Local: Use locally optimal schemes to lay out data blocks.

• Improve file system performance by increasing locality of reference and improving layout to make larger transfers possible.

• Layout policy tries to place all inodes corresponding to files in a given directory in the same cylinder group.

  Can you think of any properties of the Unix file system that make this goal impossible?

• The policies attempt to place all data blocks for a file in the same cylinder group at rotationally optimal positions in that cylinder. Unfortunately, a few large files can use up all the space in a cylinder group. Block allocation is forced to another cylinder group whenever a file will require an indirect block. and whenever a file has used up 25% of the space in the current cylinder group.

  The cylinder group chosen for new blocks is chosen from those having a larger than average number of free blocks.

• The local allocation routines are exercised by the global allocation routines. Whenever possible, they return the exact block being asked for. Where not possible, they will allocate a free block that is rotationally closest to the one requested. The local allocator uses this four-level allocation strategy:
  1. Use the next free block rotationally closest to the requested block in the same cylinder.
  2. If no blocaks are available on the same cylinder, use one in the same cylinder group.
  3. If the cylinder group is entirely filled, choose another cylinder group using a quadratic hash to yeild the new cylinder group.
  4. If the hash fails, search all cylinder groups for one that can accomodate a new block.
  File systems keeping 10% free space rarely need to use the hashing mechanism.