CS 3733 Operating Systems

Reading: Chapter 4 of Tanenbaum

• A brief look at the proc file system and discussion of the next assignment.

• Requirements for long-term storage:
  • Must be able to store a large amount of info.
  • Info must survive after termination of process using it.
  • Multiple processes must be able to access info concurrently.

• Issues:
  • Naming (upper-lower case, fixed-variable length, qualified)
  • Type (regular, directory, character special, block special)
  • Access (sequential, random)
  • Attributes (see Tanenbaum Figure 4-4)
  • Operations on files (create, delete, open, close, read, write, append, seek, get attributes, set attributes, rename).
  • Operations on directories (create, delete, opendir, closedir, readdir, rename, link, unlink).
  • Name versus handle.

• Memory-mapped files (the opposite of the proc file system).

• To map a file:

       #include 
       #include 
  
       caddr_t mmap(caddr_t addr, size_t len, int prot, int flags,
            int fildes, off_t off);
  

  Here is an example:

            fildes = open(...)
            address = mmap((caddr_t) 0, len, (PROT_READ | PROT_WRITE),
                           MAP_PRIVATE, fildes, offset)
            /* use data at address */
  
  

• Possible file implementations:
  • Contiguous
  • Linked list
  • Indexed

• Directory implementation
  • Current systems have tree-structured directories.
  • What info should be stored with the file and what info should be in the directory?
  • How should multiple filesystems be handled?

• Disk space management
  • Block size - trade off between disk utilization and data rate (see Figure 4-19 of Tanenbaum) - is a multiple of the sector size (usually a power of two multiple).

  • Free list - trade-offs
    • Keep as a linked list.
    • Keep as a bit map.

  • Disk Quotas

  • Reliability
    • Bad block management (dedicate a sector or use bad block list)
    • Backups (full versus incremental dumps)
    • Consistency:
      • Block consistency:
        • Counter for how many times block is in a file.
        • Counter for how many times block is in free list.

      • Directory consistency:
        • Counter for each file.
        • Traverse the directory and count how many times a file appears in a directory.

      • Performance
        • Buffer cache to speed up accesses (write-through versus write-back).
        • Placement of blocks from same file on the same or nearby cylinders.
        • Putting inodes and blocks together.

SKILL: Understand basics of filesystem management