File system

Document Sample
File system Powered By Docstoc
					File Systems
   All Computer applications need to store and
    retrieve information
   While a process is running, it can store a
    limited amount of information within its
    address space.
   For some applications file size is adequate
    but for most of the applications like banking,
    corporate record keeping, it is very small.
   Apart from this there are other problems with
    keeping information within a process address
    1.   When the process terminates the information is
         lost, while the database applications require that
         information need to be retained
    2.   It is frequently necessary for multiple processes
         to access the information at the same time, but if
         information is stored inside the address space
         then only that process can access that
3.       Process can store limited amount of information in
         its address space
        Thus we have three essential requirements for
         long-term information storage:
          It must be possible to store a very large amount of
          The information must survive the termination of the
           process using it
          Multiple processes must be able to access the information
        The usual solution to all these problems is to store
         information on disks and other external media is called
   A file is a named collection of related information
    that is recorded on the secondary storage.
   Information stored in files must be persistent i.e.
    not to be affected by process creation or
   Files are managed by OS. How they are
    structured, named, accessed, used, protected
    and implemented are major topics in OS design
   Part of the OS deals with file is known as file
File Naming
   Files are abstraction mechanism
     They provide a way to store information on the

       disk and read it back later.
     How and where the information is stored, and how
       the disks actually work, is hidden from the user.
   The most important of any mechanism is naming.
   When a process creates a file, it gives the file a
   When the process terminates, the file continues to
    exist, and can be accessed by other processes
    using its name.
   Rules vary from system to system
       1 to 8 letters as legal file names
       Digits and special characters are also permitted
       Some file systems differentiate between upper
        case letters and lower case letters
           UNIX
               URGENT, urgent, Urgent, URgent, UrGent are treated as
                different file names
           MS-DOS does not differentiate
               All are same

   Many OS supports two-part file names,
    separated by a period ‘.’
   Part following the period is called file
       In MS-DOS file name are 1-8 character , plus
        optional 1-3 characters for extension
File Structure

Three kinds of files. (a) Byte sequence.
    (b) Record sequence. (c) Tree.
   3 commons structures: byte sequence (typically used), record
    sequence (no longer used), tree (still around on a few
   (a) is an unstructured sequence of bytes.
     The OS does not know what is in the file.

     All it sees are bytes.

     UNIX and MS-DOS both uses this approaches

     User programs can put anything they want in files and
       name them any way that is convenient.
   (b) a file is a sequence of fixed length records each with some
    internal structure.
     Read Operation requires one record and write operation
       overwrites one record.
   Punched cards with 80-columns punched on it and
    132 column printer
   CP/M used such type of fixed length record files
   (C) a file consists of a tree of records, not
    necessarily all the same length, each containing a
    key field in a fixed position in the record.
       The tree is sorted on the key field to allow rapid searching for a
        particular key.
       Widely used on the large mainframe computers in commercial
        data processing
File Types
   Many OS supports several types of files
   UNIX & MS-DOS supports
       Regular Files
           Ones that contain user information
           Last EX all are regular files
       Directories
           System files for maintaining the structure of the file systems
       Character Special Files
           Related to i/p –o/p devices such as terminals, printers and
       Block Special Files
           Used for disks
        Regular files are generally either
    1.    ASCII files or
    2.    binary files
        ASCII files consists of lines of text.
        The great advantage of ASCII files is that they
         can be displayed and printed as is, and they
         can be edited with an ordinary text editor
        Binary files means that they are not ASCII
         types. Technically it is just a sequence of
         bytes, the OS will only execute a file if it has
         the proper format.
File Types

 Figure 4-3. (a) An executable file. (b) An archive.
An Executable File
   It has five sections
     Header, text, data, relocation bits and symbol table

   The header starts with a magic number, identifying the file
    as an executable file ( to prevent the accidental execution
    of a file not in this format.)
   Then come 16-bit integers giving the sizes of the various
    pieces of the file, the address it starts execution at, and
    some flag bits.
   Following the header are the text and data of the program
   These are loaded into memory, and relocated using the
    relocation bits.
   The Symbol table used for debugging
An archive
   Another type of binary file is archive from UNIX
   It consists of a collection of library procedures (modules)
    compiled but not linked.
   Each one prefaced by the header telling its name, creation
    date, owner, protection code and size.
   Many PC based OS associate file types with the specific
    applications that generate them
   In Windows for ex the file created by notepad has different
    icon and adobe has different icon (environment in which the
    file was created) and extensions
File Access
   File stores information
   When it is used, this information must be accessed
    and read into computer memory.
   There are several ways that the information in the
    file can be accessed.
       Sequential Access
           A process could read all the bytes or records in a file in order,
            starting at the beginning, but could not skip around and read
            them out of order
           It can be rewound and read as often as needed
           Ex magnetic tape
           Variable length and fixed length
           Used for batch systems
           Ex editors and compilers , LIC forms processing etc
File Access
    Direct Access/ Random Access
        Files whose bytes or records can be read in any order are
         called random access files.
        Disks are used for such type of access
        Database applications
        Basically used to retrieve the immediate information to large
         amount of information
    Index Sequential Access
        Index for the file is constructed
        Index contains pointers to various records
        Index file contains record key and the record numbers
        First index file is searched using binary search and then
         secondary again using binary search
        Finally block found is read sequentially
File Attributes
   Every file has a name and its data
   In addition, all OS associate other information with
    each file i.e. date and time, size etc
   These extra items are called file’s attribute
   Attributes may vary from OS to OS
File Attributes

        Some possible file attributes
File Attributes
   The first four attributes relate to the file’s protection and
    tell who may access it and who may not.
   In some systems user must specify the password in
    order to access the file
   Flags are the bits or short fields that control or enable
    some specific property.
   Hidden files, do not appear in the listings of all the files
   The archive flag is a bit that keeps track of whether the
    file has been backed up.
   The temporary flag allows a file to be marked for
    automatic deletion when the process that created it
File Attributes
   The record length, key position, key length fields
    are only present in the files whose records can be
    looked up using a key
   The various times keep track of when the file was
    created , most recently accessed and most recently
   The current size tells how big the file is at present
   Some mainframe OS needs maximum size to be
    specified when the file is created
File Operations
   File exist to store information and allow it to be
    retrieved later
   Different systems provide different operations to
    allow storage and retrieval
   The most common system calls relating to files:

    •   Create            •   Append
    •   Delete            •   Seek
    •   Open              •   Get Attributes
    •   Close             •   Set Attributes
    •   Read              •   Rename
    •   Write
File Operations
   Create The file is created with no data
   Delete When the file is no longer needed, it has to
    be deleted to free up disk space
   Open Before using a file, a process must open it.
     The purpose of open call is to allow the system to
       fetch the attributes and list of disk addresses into
       main memory for rapid access on subsequent
   Close when all the accesses are finished, the
    attributes and disk addresses are no longer needed,
    file should be closed to free up internal table space.
   Read Data are read from file. Usually the bytes
    come from the current position
File Operations
   Write Data are written to the file, again, usually at
    the current position.
   Append This call is a restricted form of WRTIE
       It can only add data to the end of the file.
   Seek For random access files, a method is needed
    to specify from where to take the data.
       System call SEEK, repositions the pointer to the current
        position to a specific place in the file
       After this call has completed, data can be read from or
        written to, that position
   Get Attributes Process often needs to read file
    attributes to do their work
File Operations
   Set Attributes some of the attributes are user-
    settable and can be changed after the file has been
   Rename It frequently happens that a user needs to
    change the name of an existing file. This system call
    does this
Example Program Using File System Calls (1)

 A simple program to copy a file.
Example Program Using File System Calls (2)

A simple program to copy a file.
Memory-Mapped Files
   Many people feel that File access methods,
    are     cumbersome      and      inconvenient,
    especially when compared to accessing
    ordinary memory.
    MAP & UNMAP is used for this
   File mapping works best in a system that
    supports segmentation
   Each file can be mapped onto its own
    segment so that byte k in the file is also byte
    k in the segment.
Memory-Mapped Files
   Two segmentation text and data,
   Suppose for file copying
   First it maps source file onto the destination file

       Program          Program
       Text             Text             abc

                 Data             Data         xyz

    Then it creates an empty segment and maps it
     onto the destination file, xyz
Memory-Mapped Files
   Process can copy the source segment into
    the destination segment using an ordinary
    copy loop
   No READ or WRITE system calls are needed
   When it is done will call UNMAP system call
    to remove the files from the address space,
    then exit
Memory-Mapped Files

   File mapping eliminates the need for I/O calls and so
    programming is easier
   It introduces some of the problems like
   1st it is hard for the system to know the exact length
    of the output file, xyz, in our example
   It can easily tell the number of the highest page
    written, but it has no way of knowing how many
    bytes in that page were written
   All OS can do is the length of the file is equal to the
    page size.
   2nd Problem is if a file is mapped in by one
    process and opened for conventional reading
    by another.
   If the file is modified by one process and that
    change will not be reflected in the file on disk
    until the page is evicted.
   System has to take care that two processes
    do not see inconsistent versions of the file
   3rd problem with mapping is that a file may be
    larger than a segment, or even larger than
    the entire virtual address space.
   Only way out is to arrange the MAP system
    call to be able to map a portion of a file,
    rather than the entire file.

   To keep track of file system directory
   Their organization, their properties, and the
    operations that can be performed on them.
   Directory contains a number of entries , one per file
games   attributes
mail    attributes
news    attributes
work    attributes


                      Data Structure
                      containing the
   When a file is opened, the OS searches its
    directory until it finds the name of the file to
    be opened.
   It then extracts the attributes and disk
    addresses, either directly from the directory
    entry or from the data structure pointed to,
    and puts them in a table in main memory.
   All subsequent references to the file use the
    information in main memory.

   The number of
    directories varies from
    system to system.
   The simplest design is
    for the system to
    maintain a single
    directory containing all
    the files of all the users,
    as shown in fig
One directory system.
A hierarchical directory system.
Path Names

   When the file system is organized as a
    directory tree, some way is needed for
    specifying file names.
   Two methods are commonly used.
       Absolute Path Name
       Relative Path Name
Absolute Path Name

   Consisting of the path from the root directory
    to the file
   /usr/ast/mailbox
   usr directory, ast directory, mailbox filename
   Absolute path names always start at the root
Relative Path Name
   This is used in conjunction with the concept of the
    working directory (also called the current directory)
   User can designate one directory as the current
    working directory, in which case all path names not
    beginning at the root directory are taken relative to
    the working directory
   Ex if the current working directory is /usr/ast
   Then file with /usr/ast/mailbox is referred as just
   Relative is more convenient compare to absolute
    Path Names

A UNIX directory tree.

   Most OS that support a hierarchical directory
    system have two special entries in every
    directory, “.” and “..”
   “.” means current directory
   “..” means parent directory
Directory Operations
1.   Create
2.   Delete
3.   Opendir
4.   Closedir
5.   Readdir
6.   Rename
7.   Link
8.   Unlink
   Create : A directory is created. It is empty
    except for . And .. (automatically system puts it)
    delete : A directory is deleted. only an empty
    directory can be deleted. . And .. Can not be
   Opendir: directories can be read. Ex. to list all
    the files in a directory, a listing program opens
    the directory to read out the names of all the files
    it contains.
   Closedir : When a directory has been read, it
    should be closed to free up internal table space.
   Readdir: This call returns the next entry in
    an open dir.
   Rename: to rename a directory
   Link : Linking is a technique that allows a file
    to appear in more than one directory
   Unlink: removes the directory entry
File System implementation
   It’s time to turn from user’s point of view to
    the implementer’s point of view
    users are concerned with how files are
    named, what operations are allowed on them,
    what the directory tree looks like, etc.
   Implementers are interested in how files and
    directories are stored, how disk space is
    managed, and how to make everything work
    efficiently and reliably.
Implementing Files

   The key issue in implementing file storage is
    keeping track of which disk blocks go with
    which file.
       Contiguous allocation
       Linked list allocation
       Linked list allocation using an Index
       I-nodes
Contiguous allocation
   The simplest allocation scheme
   Store each file as a contiguous block of data
    on the disk
   With 1k block 50k file would be allocated 50
    consecutive blocks.
   Two advantages
       1st it is simple to implement because keeping track
        of where a file’s blocks are is reduced to
        remembering one number, the disk address of the
        first block.
Contiguous allocation
   2nd the performance is excellent because the entire
    file can be read from the disk in a single operation.
   No other allocation method even comes close
   Disadvantages
     1st it is not feasible unless the maximum file size is

       known at the time the file is created. W/O this
       information OS does not know how much disk
       space to reserve.
     2nd is the fragmentation of the disk that results

       from this allocation policy. Space is wasted that
       might otherwise have been used.
Contiguous allocation

 (a) Contiguous allocation of disk space for 7 files.
(b) The state of the disk after files D and F have been removed.
Linked List Allocation
   The second method for storing files is to keep
    each one as a linked list of disk blocks
   The first word of each block is used as a
    pointer to the next one, the rest of the block is
    for data.
Linked List Allocation

      Storing a file as a linked list of disk blocks.
   Unlike, contiguous allocation, every disk
    block can be used in this method.
   No space is lost to disk fragmentation.
   It is sufficient to store the disk address of the
    first block, the rest can be found using that.
   It is slow
   Space required for pointer in a block
Linked List Allocation using an Index
   Disadvantages of linked list allocation can be
    eliminated by taking the pointer word from
    each disk block and putting it in a table or
    index in memory.
   File A uses disk blocks 4,7,2,10,12
   File B uses disk blocks 6,3,11,14
   Start with first block in order and follow the
    chain all the way to the end.
Linked List Allocation using an Index

   Entire block is available for data
   The chain is entirely in table, pointers are in
   Disadvantage is that table occupies memory
    space and it has to be in memory for all the
Linked List Allocation using an Index

Linked list allocation using a file allocation table in main memory.
   To associate with each file a little table called an
   The first few disk addresses are stored in the i-
    node itself, so for small files, all the necessary
    information is right in the i-node
   For somewhat larger files, one of the addresses
    in the i-node is the address of a disk block called
    a single indirect block.
   If still not enough, another address in the i-node,
    called a double indirect block, contains the
    address of a list of single indirect blocks
   Each of these single indirect blocks points to
    a few hundred data blocks.
   If even this is not enough, a triple indirect
    block can also be used. UNIX uses this

An example i-node.
Implementing Directories
   The directory entry provides the information
    needed to find the disk blocks.
   The main aim to map the file name to locate
    the data
       Directories in CP/M
       Directories in MS-DOS
       Directories in UNIX
   In CP/M there is only one directory
   All the file system has to do to look up a file
    name is search the one and only directory.
   When it finds the entry, it also has the disk
    block numbers, since they are stored right in
    the directory entry, as are all the attributes
   If file uses more disk blocks than fit in one
    entry, the file is allocated additional directory
Directories in CP/M

  Directory entry that contains the disk block numbers for each file
   The user code field keeps track of which user owns the
   The next two fields gives name and extension of the file
   The Extent field is needed because a file larger than 16
    blocks occupies multiple directory entries
   The Block Count field tells how many of the 16 disk block
    entries are in use.
   The final 16 fields contain the disk block numbers
   The last block may not be full so system has no way to
    determine the exact size of the file (file sizes are in blocks,
    not in bytes)
Directories in MS/DOS

       The Directory entry in MS-DOS
   32 bytes long and contains the file name,
    attributes, and the number of the first disk
   The first disk block is used as an index into a
    table of the type, linked list allocation using
   Using chain one can get all the blocks
Directories in UNIX

   Directory Entry in Unix is simple
   It contains just the file name and an i-node number
   All the information about the type, size, times, ownership, disk
    blocks is contained in the i-node.
   How to find /user/ast/mailbox shown in the next figure

                 The Directory entry in UNIX
The steps in looking up /usr/ast/mailbox
Shared Files
   When several users are working together on a project,
    they often need to share files.
   So it is convenient for a shared file to appear
    simultaneously in different directories belonging to
    different users.
   Ex C’s file shared by B.
   The connection between B’s directory and the shared file
    is called a link.
   The file system itself is now a directed acyclic graph,
Shared Files
    It also has some problems
1.    Like CP/M if directory contains disk block addresses,
      then B’s directory must copy this addresses
2.    If B or C later on appends to the file, the new blocks will
      be listed only in the directory which appends not visible
      to other directory user.
    Solutions is
1.    Disk blocks are not listed in directories only the data
      structure like unix must be associated with file itself.
2.    B can share C’s file using link command also called
      symbolic linking
File System with Shared Files
Disk Space Management
   Files are stored on disks so management of disk space is a
    major concern to file system designers.
   Two general strategies for storing an n byte file:
     n consecutive bytes of disk space are allocated

     Or the file is split up into a number of blocks

   Storing file as a contiguous sequence of bytes has the
    obvious problem that if a file grows, it will probably have to be
    moved on the disk.
   The same problem with segments also but moving segments
    in memory is faster compare to moving a file from one disk
    position to another
   So all file systems chop files up into fixed-size blocks
    that need not be adjacent
Disk Space Management
   Block Size
   Once it has been decided to store files in
    fixed-size blocks, the question arises of how
    big the block should be
   The usual compromise is to choose a block
    size of 512, 1K or 2K bytes
Disk Space Management
   Keeping track of free Blocks
   Once the block size has been chosen, the
    next issue is how to keep track of free blocks.
   Two methods used
       One consists of using a linked list of disk blocks,
        with each block holding as many free disk block
        numbers as will fit.
       Second technique is bit map, a disk with n blocks
        requires a bit map with n bits.
           Free blocks are represented by 1s and allocated by 0s
            in the map
Free block management techniques

         (a) Linked List   (b) bit-map
Disk Space Management
   Disk Quotas
   To prevent people from hogging too much
    disk space, multiuser operating systems,
    such as unix, often provides a mechanism for
    enforcing disk quotas.
   The idea is that the system administrator
    assigns each user a maximum allotment of
    files and blocks, and the OS make sure that
    the users do not exceed their quotas.
File System Reliability
   Destruction of a file system is often a far greater disaster
   If a file system is irrevocably lost, due to hardware,
    software or any problem, restoring all the information will
    be difficult, time consuming, in many cases, impossible.
   People whose programs, documents, customer files, tax
    records, data bases, marketing plans any other data are
    gone forever, the consequences can be catastrophic
   File system can not protect against physical destruction,
    but it can help protecting the information
   Some issues involved in safeguarding the file system.
File System Reliability
   Bad block management
   Disks often have bad blocks.
   disks are perfect but while using it develops
    bad blocks
   Hard disk already has bad block at the start
   Two solutions for the bad block problem
       Hard ware
       Soft ware
File System Reliability
   Hard ware solution is that to dedicate a
    sector on the disk to the bad block list
   When the controller is first initialized, reads
    the bad block list and picks a spare block to
    replace the defective ones, recording the
    mapping in the bad block list
   Henceforth, all the bad block request will use
    the spare
File System Reliability

   Software solution requires the user or file
    system to carefully construct a file containing
    all the bad blocks
   This technique removes them from the free
    list, so they will never occur in the data files.
   Care has to be take to avoid reading this file
    while taking back ups
File System Reliability
   Backups even with a cleaver strategy for
    dealing with bad blocks, it is important to backup
    the files frequently
   The small disks can be backed up by just
    copying it entirely on another disk/ CD
   For hard disks entire drive can be copied on
    another hard disk, means computer with two
    hard drives
   Incremental dumping periodically, weekly,
    monthly, daily and only modified files to be
File System Reliability
   Another area where reliability is an issue is file
    system consistency.
   Many file systems read blocks, modify them, and write
    them later.
   If system crashes before modified blocks have been
    written out, the file system can be left in inconsistent
   To deal with the problem of inconsistent file system,
    most computers have a utility program that checks file
    system consistency.
   It can be run whenever the system is booted,
    particularly after a crash
    File system Performance
   Access to disk is much slower than access to memory
   Reading memory word required nanoseconds where as reading disk
    blocks requires tens of milliseconds
   A factor of 100,000 slower.
   As a result of this difference in access time, many file systems have
    been designed to reduce the number of disk accesses needed.
   The most common technique used to reduce disk accesses is the block
    cache or buffer cache
   Another important technique is to reduce the amount of disk arm
    motion by putting blocks that are likely to be accessed in sequence
    close to each other , preferably in the same cylinder
   Third put the i-node in the middle of the disk, rather than at the start,
    thus reducing the average seek between the i-node and the first block
    by a factor of two

Shared By:
Description: file system (or filesystem) is a means to organize data expected to be retained after a program terminates by providing procedures to store, retrieve and update data, as well as manage the available space on the device(s) which contain it. A file system organizes data in an efficient manner and is tuned to the specific characteristics of the device. There is usually a tight coupling between the operating system and the file system. Some filesystems provide mechanisms to control access to the data and metadata. Ensuring reliability is a major responsibility of a filesystem. Some filesystems provide a means for multiple programs to update data in the same file at nearly the same time.