1.7 I/o devices and file systems  (Page 9/9)

Directories

As with other modern file systems, a directory in NTFS is a file whose data contains a collection of name/file mappings.

• A directory entry contains the name of the file and file reference. The file references identify the file on this volume. In other words,it is an internal name for the file.

A reference is a (file number, sequence number) pair. The file number is the offset of the file's entry in the MFT table. It issimilar to the Unix inumber (Inode number).

• The list of file names in the directories is not stored in a simple list, but rather as a lexigraphically-sorted tree, called a B+ tree (thiswill be familiar to those with a database background). The data structure is called an index in NFTS (again, following the terminology from databases).
• The NTFS design specifies that an index can be constructed for any attribute, but currently only file name indices are supported.
• The name for a file appears both in its directory entry and in the MFT entry for the file itself.
• As with regular files, if the directory is small enough, it can fit entirely within the MFT entry.

If the directory is larger, then the top part of (the B+ tree of) the directory is in the MFT entry, which points to extents thatcontain the rest of the name/file mappings.

File system crash recovery

Unix file system crash recovery

Computers can crash at any time, and we want the file system to behave sensibly in the face of crashes. The key idea is calledconsistency:

• The file data and the various control structures (descriptors, bitmaps) must be in agreement.
• Since crashes can occur at any time, not all updates to the disk may be completed.
• We must insure that when the system reboots, it can return its file system to some sensible state.
• The key constraint is that any file system write operation, in progress at the time of the crash, either completely finishes or appears as ifit never happened. This is called atomicity by the database folks.

Insuring consistency requires two things:

• Updates to the file system data structures must be done in the write order (and there is only one right order)!
• The proper steps must be taken at reboot time to bring the system back in to a consistent state.

There are three basic updates that happen when data is written to a file.

1. A block (or blocks) is allocated from the free list (bit map).
2. Data is written to the newly allocated block.
3. The inode is updated to include the new data.

These operations must be done in the above order. If they are not, then it is possible to have a data block included in a filethat might have garbage (uninitialized data) in the block.

After rebooting, the recovery utility program on Unix, called "fsck", is going to traverse the entire directory structure of thedisk to insure that all free blocks are in the free list.

Recovery after a crash follows these steps:

1. Allocate a temporary bit map, initialized to indicate that all disk blocks are free.
2. Start at the inode for the root directory.
3. Traverse the directory:
   • For each disk data block in the directory file, marks its blocks as "allocated" in the bit map.
   • For each data file in this directory, marks its data blocks as "allocated" in the bit map.
   • For each directory in this directory, perform the "Traverse the directory" stepsabove.

At the completion of the algorithm, you can compare the actual bit map to the temporary one to find blocks that were allocated, butnever made it into a file.

Windows file system crash recovery

NTFS assures that the file system will remain consistent by use of a write log. This technique is similar to that used in adatabase system.

As in other file systems, consistency means that a write (or group of writes) to a file either complete or do not happen at all. Itis not possible for a data block to be in an undefined state (e.g., allocated, but not written).

• The log is one of those standard files stored at the beginning of the MFT. It is called, cleverly enough, the log file.
• A simplified version of the steps to write data to a file look like:
  • A file update is written to the in-memory log buffer.
  • Updates to the in-memory file data and associated file system structures are made.
  • The log changes are flushed to disk.
  • The file data and structure changes are flushed to disk.
• If the system crashes during a file update, it is sufficient to go through the log an re-do each operation specified in the log.
• The system occasionally creates checkpoints, so that it does not have to back to the beginning of the log for recovery. Checkpoints have two mainbenefits:

• Log files can be truncated, reducing the space needed for the log.
• Recovery time is faster if fewer log records need to be processed.

Disk scheduling

Disk scheduling: in a system with many processes running, it can often be the case that there are several disk I/O's requested atthe same time. The order in which the requests are serviced may have a strong effect on the overall performance of the disk.

First come first served (FIFO, FCFS): may result in a lot of unnecessary disk arm motion under heavy loads.

Shortest seek time first (SSTF): handle nearest request first. This can reduce arm movement and result in greateroverall disk efficiency, but some requests may have to wait a long time.

Scan: like an elevator. Move arm back and forth, handling requests as they are passed. This algorithm does notget hung up in any one place for very long. It works well under heavy load, but not as well in the middle (about 1/2 the time it will not get the shortestseek).

Minor variant: C-SCAN , which goes all the way back to front of disk when it hits the end, sort of like araster scan in a display.

LOOK algorithm. Like scan, but reverse direction when hit the last request in the current direction. C-LOOK isthe circular variant of LOOK. What most systems use in practice.