Please enable JavaScript.

Coggle requires JavaScript to display documents.

File Systems (Files and Directories (File (File Interface (Creating a file…

- - - - A linear array of byes of which one can read and write to
      - File may change size over time
      - Meta-Data
        
        Owner
        
        Access controls
        
        File Type
        
        Creation and Access timestamps
        
        Low-level name (Inode)
        
        Current offset
    - - Creating a file
        
        Files are created using the open() system call and passing the O_CREAT flag
        int fd = open("foo", O_CREAT, S_IRUSR | S_IWUSR)
        param1 -> filename
        param2 -> creates the file
        param3 -> permissions
        returns -> file descriptor - an int used to read or write the file
      - Reading a file
        
        Files are read using the read() system call
        int bytes = read(3, vaddr, 4096)
        param1 -> the file descriptor
        param2 -> the buffer where the result is stored
        param3 -> the size of the buffer
        return -> returns the number of bytes it read
      - Writing a file
        
        Files are written using the write() system call
        int size = write(1, vaddr, 4096)
        param1 -> location to write to
        param2 -> location of the buffer to write from
        param3 -> the amount to write
        return -> the number of bytes written
      - Moving the cursor pointer
        
        Every file has a current offset that is the point where the next read/write call will start at. We can use the "lseek" method to explicitly move the offset to a specific location
        off_t lseek(int fildes, off_t offset, int whence);
        param1 -> file descriptor
        param2 -> offset which positions the file offset to a particular location
        param3 -> options to change how the seek is performed
  - - - A link between a name and an inode. If I add a hardlink between a file then both the link and the original filename refer to the same file. Changes made to one are seen by both
    - - Unlinking removes one pair of (pathname, inode). If the unlink removes the last pair of pathname associated with an inode then it also deletes the file.
- - - - How does it map the calls made by a process (open, read, write
        Which structures are read during the execution of a particular system call
    - - What data structures are used by the file system to organize its data and metadata
  - - - Divide the disk into blocks.
        Example:
        Suppose we have a disk space of 64 blocks.
        Suppose each block is 4 KB.
    - - The portion of on-disk memory that is allocated for user data
    - - Portion of on-disk memory that is allocated for inodes
    - - VSFS uses bitmaps to track allocation. Bitmaps are structures that indicate 1- the block is allocated 0 - the block is not
    - - Contains information about the entire file system.
        (How many inodes and blocks are in the system, where the inode begins etc)
  - - - A pointer that points to a disk block containing user data
    - - Pointer that points to a data block of direct pointers
  - - - Example: If i wanted to read the file /foo/bar.txt
        
        Read the root i-node (finds the foo i-node)
        
        Read the foo i-node (finds the bar i-node)
        
        Read the bar i-node
        
        Check the permissions
        
        Allocate a file descriptor in the per-process descriptor table
        
        Increment the counter for this i-number in the global open file table
        
        Find the block using direct/indirect pointers and read the data
        
        Update the bar i-node with new access time
        
        Update file position in per-process descriptor table
        
        Close the file. Deallocate file descriptor and decrement counter for bar i-number
- - - - Incredibly slow as disk size increases
  - - - Before every write we have to write to the log first. This will increase the time of every write INS
    - - Leads to a better recovery state