Design In-Memory File System
What is an In-Memory File System?
An In-Memory File System is a simplified version of a real file system (like NTFS, ext4, or APFS), designed to run entirely in memory.
Loading simulation...
It mimics the hierarchical structure of directories and files, enabling operations like:
- Creating and managing folders
- Adding, reading, and updating file content
- Navigating between directories
- Listing folder contents
- Deleting files or directories
In this chapter, we will explore the low-level design of file system in detail.
Let's start by clarifying the requirements:
1. Clarifying Requirements
Before starting the design, it's important to ask thoughtful questions to uncover hidden assumptions, clarify ambiguities, and define the system's scope more precisely.
Here is an example of how a conversation between the candidate and the interviewer might unfold:
Candidate: Should the file system support both files and directories in a hierarchical structure?
Interviewer: : Yes. The system should model a typical UNIX-style file system with nested files and directories.
Candidate: How will a user interact with this file system? Should I design a GUI, or a command-line interface?
Interviewer: A command-line interface (CLI) is the way to go. The system should be able to parse and execute a set of basic shell commands.
Candidate: What are the primary commands it should support?
Interviewer: Let's implement the core navigation and manipulation commands: mkdir (make directory), cd (change directory), ls (list contents), pwd (print working directory), touch (create an empty file), and cat (view file content). It would also be great to support writing content to a file, perhaps through a simplified echo 'text' > file syntax.
Candidate: Regarding the ls command, should it just list names, or should it support options like ls -l for a more detailed view?
Interviewer: That's an excellent feature to include. The design should be flexible enough to support both a simple listing of names and a detailed format that shows metadata, like whether an entry is a file or a directory and its creation time.
Candidate: How should the system handle paths? Does it need to support both absolute paths (starting from the root '/') and relative paths (from the current directory)?
Interviewer: Yes, that's a key requirement. The system must maintain a concept of a "current working directory" and correctly resolve both absolute and relative paths, including . (current directory) and .. (parent directory).
Candidate: What about advanced file system features like user permissions, ownership, symbolic links, or file locking?
Interviewer: Let's keep those out of scope. The primary focus is on the hierarchical data structure and the command execution framework. We'll assume a single-user environment with no permission constraints.
After gathering the details, we can summarize the key system requirements.
1.1 Functional Requirements
- Support creation of files and directories organized in a hierarchical structure.
- The entire file system state, including all files and directories, must be stored in memory.
- Interaction with the file system will be through a shell that parses and executes string-based commands.
- The following commands must be supported:
mkdir,cd,touch,ls,pwd,cat, andecho? -
lscommand should support a simple format and a detailed (-l) format. - The system must correctly handle both absolute (e.g., /home/user) and relative (e.g., documents, ../) paths.
- Files should be able to store simple string-based content.
1.2 Non-Functional Requirements
- Modularity: The system should follow object-oriented principles with clear separation of concerns across components.
- Maintainability: Code should be clean, testable, and easy to extend or debug.
- Extensibility: It should be easy to add new commands to the shell or new listing strategies for the ls command without modifying existing core logic.
- Error Handling: The system should provide clear error messages for invalid operations, such as trying to cd into a file or accessing a non-existent path.
- Usability: The system should expose an intuitive API for common file system operations.