169 lines
7.2 KiB
Markdown
169 lines
7.2 KiB
Markdown
20/11/20
|
|
|
|
## File System Views
|
|
|
|
### User View
|
|
|
|
A **user view** that defines a file system in terms of the **abstractions** that the operating system provides
|
|
|
|
An **implementation view** that defines the file system in terms of its **low-level implementation**
|
|
|
|
**Important aspects of the user view**
|
|
|
|
> - The **file abstraction** which **hides** implementation details from the user
|
|
> - File **naming policies**, user file **attributes** (size, protection, owner etc)
|
|
> - There are also **system attributes** for files (e.g. non-human readable, archive flag, temp flag)
|
|
> - **Directory structures** and organisation
|
|
> - **System calls** to interact with the file system
|
|
>
|
|
> The user view defines how the file system looks to regular users and relates to **abstractions**.
|
|
|
|
#### File Types
|
|
|
|
Many operating systems support several types of file. Both Windows and Unix have regular files and directories:
|
|
|
|
- **Regular files** contain user data in **ASCII** or **binary** format
|
|
- **Directories** group files together (but are files on an implementation level)
|
|
|
|
Unix also has character and block special files:
|
|
|
|
- **Character special files** are used to model **serial I/O devices** (keyboards, printers etc)
|
|
- **Block special files** are used to model drives
|
|
|
|
### System Calls
|
|
|
|
File Control Blocks (FCBs) are kernel data structures (they are protected and only accessible in kernel mode)
|
|
|
|
- Allowing user applications to access them directly could compromise their integrity
|
|
- System calls enable a **user application** to **ask the OS** to carry out an action on its behalf (in kernel mode)
|
|
- There are **two different categories** of **system calls**
|
|
- **File manipulation**: `open()`, `close()`, `read()`, `write()` ...
|
|
- **Directory manipulation**: `create()`, `delete()`, `rename()`, `link()` ...
|
|
|
|
### File Structures
|
|
|
|
**Single level**: all files are in the same directory (good enough for basic consumer electronics)
|
|
|
|
**Two or multiple level directories**: tree structures
|
|
|
|
- **Absolute path name**: from the root of the file system
|
|
- **Relative path name**: the current working directory is used as the starting point
|
|
|
|
**Directed acyclic graph (DAG)**: allows files to be shared (links files or sub-directories) but **cycles are forbidden**
|
|
|
|
**Generic graph structure**: Links and cycles can exist.
|
|
|
|
The use of **DAG** and **generic graph structures** results in **significant complications** in the implementation
|
|
|
|
- Trees are a DAG with the restriction that a child can only have one parent and don't contain cycles.
|
|
|
|
When searching the file system:
|
|
|
|
- Cycles can result in **infinite loops**
|
|
- Sub-trees can be **traversed multiple times**
|
|
- Files have **multiple absolute file names**
|
|
- Deleting files becomes a lot more complicated
|
|
- Links may no longer point to a file
|
|
- Inaccessible cycles may exist
|
|
- A garbage collection scheme may be required to remove files that are no longer accessible from the file system tree.
|
|
|
|
#### Directory Implementations
|
|
|
|
Directories contain a list of **human-readable file names** that are mapped onto **unique identifiers** and **disk locations**
|
|
|
|
- They provide a mapping of the logical file onto the physical location
|
|
|
|
Retrieving a file comes down to **searching the directory file** as fast as possible:
|
|
|
|
- A **simple random order of directory** entries might be insufficient (search time is linear as a function of the number of entries)
|
|
- Indexes or **hash tables** can be used.
|
|
- They can store all **file-related attributes** (file name, disk address - Windows) or they can **contain a pointer** to the data structure that contains the details of the file (Unix)
|
|
|
|
|
|
|
|
##### System Calls
|
|
|
|
Similar to files, **directories** are manipulated using **system calls**
|
|
|
|
- `create/delete`: new directory is created/deleted.
|
|
- `opendir, closeddir`: add/free directory to/from internal tables
|
|
- `readdir`: return the next entry in the directory file
|
|
|
|
**Directories** are **special files** that **group files** together and of which the **structure is defined** by the **file system**
|
|
|
|
- A bit is set to indicate that they are directories
|
|
- In Linux when you create a directory, two files are in that directory that the user has no control over. These files are represented as `.` and `..`
|
|
- `.` - a file dealing with file permissions
|
|
- `..` - represents the parent directory (`cd ..`)
|
|
|
|
##### Implementation
|
|
|
|
> Regardless of the type of file system, a number of **additional considerations** need to be made
|
|
>
|
|
> - **Disk Partitions**, **partition tables**, **boot sectors** etc
|
|
> - Free **space management**
|
|
> - System-wide and per-process **file tables**
|
|
>
|
|
> **Low-level formatting** writes sectors to the disk
|
|
>
|
|
> **High-level formatting** imposes a file system on top of this (using **blocks** that can cover multiple **sectors**)
|
|
|
|
### Partitions
|
|
|
|
Disks are usually divided into **multiple partitions**
|
|
|
|
- An independent file system may exist on each partition
|
|
|
|
**Master Boot Record**
|
|
|
|
- Located at the start of the entire drive
|
|
- Used to boot the computer (BIOS reads and executes MBR)
|
|
- Contains **partition table** at its end with **active partition**.
|
|
- One partition is listed as **active** containing a boot block to load the operating system.
|
|
|
|
|
|
|
|
#### Unix Partition
|
|
|
|
> The partition contains
|
|
>
|
|
> - The partition **boot block**:
|
|
> - Contains code to boot the OS
|
|
> - Every partition has a boot block - even if it does not contain an OS
|
|
> - **Super block** contains the partition's details, e.g. partition size, number of blocks and I-node table
|
|
> - **Free space management** contains a bitmap or linked list that indicates the free blocks.
|
|
> - A linked list of disk blocks (also known as grouping)
|
|
> - We use free blocks to hold the **number of the free blocks**. Since the free list shrinks when the disk becomes full, this is not wasted space
|
|
> - **Blocks are linked together**. The size of the list **grows with the size of the disk** and **shrinks with the size of the blocks**
|
|
> - Linked lists can be modified by **keeping track of the number of consecutive free blocks** for each entry (known as counting)
|
|
> - **I-Nodes**: An array of data structures, one per file, telling all about the files
|
|
> - **Root directory**: the top of the file-system tree
|
|
> - **Data**: files and directories
|
|
|
|
|
|
|
|
|
|
|
|
Free space management with linked list (on the left) and bitmaps (on the right)
|
|
|
|
**Bitmaps**
|
|
|
|
- Require extra space
|
|
- Keeping it in main memory is possible, but only for small disks
|
|
|
|
**Linked lists**
|
|
|
|
- No wasted disk space
|
|
- We only need to keep in memory one block of pointers (load a new block when needed)
|
|
|
|
Apart from the free space memory tables, there are a number of key data structures stored in memory:
|
|
|
|
- An in-memory mount table (table with different partitions that have been mounted)
|
|
- An in-memory directory cache of recently accessed directory information
|
|
- A **system-wide open file table**, containing a copy of the FCB for every currently open file in the system, including location on disk, file size and **open count** (number of processes that use the file)
|
|
- A **per-process open file table**, containing a pointer to the system open file table.
|
|
|
|
|
|
|
|
|