Software Lab Simulation 21-1: Linux File System

Software Lab Simulation 21‑1: Linux File System

The software lab simulation 21‑1 linux file system provides a hands‑on environment where learners can explore the hierarchical structure, permissions, and core concepts that underlie every Linux distribution. By navigating directories, inspecting inode information, and manipulating file attributes, students gain practical insight into how the operating system organizes data, enforces security, and supports multi‑user workflows. This article walks through the purpose of the simulation, outlines the step‑by‑step procedure, explains the underlying theory, and answers common questions that arise during the lab.

Introduction

Linux’s file system is more than a simple folder tree; it is a sophisticated abstraction that treats everything—devices, processes, and even kernel interfaces—as files. Understanding this model is essential for system administrators, developers, and anyone who works with Linux‑based servers or embedded devices. The software lab simulation 21‑1 recreates a typical Linux environment inside a virtual machine, allowing users to experiment without risking a production system. The simulation focuses on core tasks such as listing directory contents, checking file types, changing permissions, and examining inode metadata. By the end of the lab, participants should be able to:

• Describe the Linux directory hierarchy (starting at /).
• Explain the role of inodes and how they store file metadata.
• Interpret and modify file permissions using symbolic and numeric notation.
• Locate special filesystems like /proc, /sys, and /dev.
• Use essential commands (ls, stat, chmod, chown, find) to troubleshoot and manage files.

Overview of the Linux File System

Before diving into the simulation steps, it helps to review the key concepts that the lab will reinforce.

Hierarchical Structure

Linux adopts a single‑root tree where all paths originate from the root directory (/). Major standard directories include:

Inodes and Metadata

Every file and directory is represented by an inode (index node). An inode stores:

• File type and permissions (mode).
• Number of hard links.
• Owner UID and GID.
• File size.
• Timestamps (access, modification, change).
• Pointers to data blocks (direct, indirect, double‑indirect, triple‑indirect).

The inode number is unique within a filesystem; you can view it with ls -i or stat <filename>.

Permissions Model

Linux uses a discretionary access control model based on three classes (user, group, others) and three permission bits (read, write, execute). Permissions are displayed as a ten‑character string, e.g., -rw-r--r--. The first character indicates the file type (- for regular file, d for directory, l for symbolic link, etc.). Changing permissions is done with chmod, either symbolically (u+x) or numerically (755).

Lab Simulation 21‑1 Objectives The simulation is designed to achieve the following learning outcomes:

1. Navigate the Linux directory tree using absolute and relative paths.
2. Identify file types and inode numbers for various objects.
3. Interpret the output of ls -l and stat.
4. Modify file ownership and permissions safely.
5. Locate special filesystems and understand their purpose.
6. Apply the find command to locate files based on criteria (name, size, time).

Step‑by‑Step Procedure

Below is the typical workflow you will follow in the software lab simulation 21‑1 linux file system. Each step includes the command to run, a brief explanation of what to expect, and what you should observe.

1. Start the Simulation

Launch the virtual machine provided by the lab environment. Once you have a shell prompt, you are logged in as a regular user (often student).

$ whoami
student

2. Examine the Root Directory List the contents of / to see the standard hierarchy.

$ ls -l /
total 92
drwxr-xr-x   2 root root  4096 Apr 10 08:12 bin
drwxr-xr-x   4 root root  4096 Apr 10 08:12 boot
drwxr-xr-x   5 root root  4096 Apr 10 08:12 dev
drwxr-xr-x   7 root root  4096 Apr 10 08:12 etc
drwxr-xr-x   5 root root  4096 Apr 10 08:12 home
lrwxrwxrwx   1 root root    7 Apr 10 08:12 lib -> usr/lib
drwxr-xr-x   2 root root  4096 Apr 10 08:12 lib64
drwxr-xr-x   3 root root  4096 Apr 10 08:12 media
drwxr-xr-x   2 root root  4096 Apr 10 08:12 mnt
drwxr-xr-x   2 root root  4096 Apr 10 08:12 opt
dr-xr-xr-x  139 root root    0 Apr 10 08:12 proc
drwx------   3 root root  4096 Apr 10 08:12 root
drwxr-xr-x   2 root root  4096 Apr 10 08:12 sbin

drwxr-xr-x   3 root root  4096 Apr 10 08:12 srv
dr-xr-xr-x  13 root root    0 Apr 10 08:12 sys
drwxrwxrwt   2 root root  4096 Apr 10 08:12 tmp
drwxr-xr-x  13 root root  4096 Apr 10 08:12 usr
drwxr-xr-x  14 root root  4096 Apr 10 08:12 var

Notice the file types (d for directories, l for symlinks, - for regular files). Also observe the permissions and ownership.

3. Inspect the /etc Directory

Change to /etc and list its contents with detailed information.

$ cd /etc
$ ls -l
total 1456
-rw-r--r--  1 root root   2893 Apr 10 08:12 acpi
drwxr-xr-x  2 root root   4096 Apr 10 08:12 acpid
-rw-r--r--  1 root root   2726 Apr 10 08:12 adduser.conf
...

Look for files that are configuration files (often ending in .conf or .cfg). Use file <filename> to see the file type.

4. Create a Test File and Observe Its Metadata

Create a simple text file in your home directory.

$ cd ~
$ echo "Hello, Linux!" > testfile.txt
$ ls -l testfile.txt
-rw-r--r-- 1 student student 13 Apr 10 08:30 testfile.txt
$ stat testfile.txt
  File: testfile.txt
  Size: 13          Blocks: 8          IO Block: 4096   regular file
Device: 10h/16d Inode: 123456      Links: 1
Access: (0644/-rw-r--r-- ) Uid: ( 1000/ student) Gid: ( 1000/ student)
Access: 2025-04-10 08:30:00.000000000 +0000
Modify: 2025-04-10 08:30:00.000000000 +0000
Change: 2025-04-10 08:30:00.000000000 +0000
 Birth: -

Observe the inode number, permissions, ownership, and timestamps.

5. Change Permissions and Ownership

Make the file executable only by the owner and change its group.

$ chmod 750 testfile.txt
$ ls -l testfile.txt
-rwxr-x--- 1 student student 13 Apr 10 08:30 testfile.txt
$ sudo chown root:root testfile.txt
[sudo] password for student:
$ ls -l testfile.txt
-rwxr-x--- 1 root root 13 Apr 10 08:30 testfile.txt

Note how chmod and chown affect the metadata.

6. Explore Special Filesystems

Mount points like /proc and /sys are virtual filesystems. List their contents to see pseudo-files.

$ ls -l /proc
total 0
dr-xr-xr-x 9 root root 0 Apr 10 08:12 1
dr-xr-xr-x 9 root root 0 Apr 10 08:12 2
...
$ cat /proc/version
Linux version 5.10.0-12-amd64 (debian-kernel@lists.debian.org) ...

These are not stored on disk but generated on-the-fly by the kernel.

7. Use find to Locate Files

Search for files by name, size, or modification time.

$ find /etc -name "*.conf"
$ find /usr -size +10M
$ find ~ -mtime -7

This demonstrates how the directory tree can be queried efficiently.

Conclusion

The software lab simulation 21‑1 linux file system provides a hands-on environment to understand how Linux organizes, stores, and protects data. By navigating the directory tree, inspecting file metadata, manipulating permissions, and exploring special filesystems, you gain practical insight into the underlying structure that makes Linux both powerful and secure. Mastery of these concepts is essential for system administration, software development, and cybersecurity tasks.