1. Overview of UNIX File and Directory Architecture

In UNIX and Linux systems, the filesystem organizes persistent storage into a hierarchical tree starting from the root directory (/). A foundational architectural principle of UNIX is that "everything is a file", representing regular files, directories, symbolic links, pipes, sockets, and character/block devices through a uniform file abstraction.

Unlike other operating systems where a file's name and its metadata are tightly coupled in directory tables, UNIX separates the file's metadata and data blocks from its directory entry name via Inodes.

2. Inodes and Inode Numbers

An inode (index node) is an internal kernel data structure that stores all metadata about a filesystem object, except for its name and its actual data content. Each inode has a unique numeric identifier within its filesystem partition, known as the inode number (i-number).

struct stat {
    dev_t     st_dev;     /* ID of device containing file */
    ino_t     st_ino;     /* Inode number */
    mode_t    st_mode;    /* File type and mode (permissions) */
    nlink_t   st_nlink;   /* Number of hard links */
    uid_t     st_uid;     /* User ID of owner */
    gid_t     st_gid;     /* Group ID of owner */
    dev_t     st_rdev;    /* Device ID (if special file) */
    off_t     st_size;    /* Total size in bytes */
    blksize_t st_blksize; /* Block size for filesystem I/O */
    blkcnt_t  st_blocks;  /* Number of 512B blocks allocated */
    struct timespec st_atim;  /* Time of last access */
    struct timespec st_mtim;  /* Time of last modification */
    struct timespec st_ctim;  /* Time of last status change */
};

3. Hard Links vs. Symbolic (Soft) Links

A directory in UNIX is simply a special file containing a list of directory entries (struct dirent), mapping human-readable filenames to inode numbers.

• Hard Links (link()): A hard link creates an additional directory entry pointing directly to an existing inode. Both entries are completely equal; modifying content through one immediately updates the other. A file's storage is only freed when its link count (st_nlink) reaches zero and no processes hold open file descriptors. Hard links cannot span across different filesystem partitions or link directories (to prevent infinite loops).
• Symbolic Links (symlink()): A symbolic link is a distinct file with its own inode and type (S_IFLNK) whose data content is simply a pathname string pointing to target file or directory. Symlinks can cross filesystem boundaries and point to nonexistent paths (dangling links).

4. Directory Operations: opendir(), readdir(), closedir()

Reading a directory cannot be performed with raw read() in modern POSIX systems to protect filesystem integrity. Instead, applications use standard directory stream functions:

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>

int main(void) {
    DIR *dir = opendir(".");
    if (!dir) {
        perror("opendir");
        return 1;
    }

    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        printf("Inode: %-8lu  Name: %s\n", entry->d_ino, entry->d_name);
    }

    closedir(dir);
    return 0;
}

5. Removing Files: unlink() and rmdir()

In UNIX, files are not directly "deleted"; rather, directory entries are unlinked using the unlink() system call. The kernel decrements the inode's link count. If the link count drops to zero and no active process has the file open, the kernel frees the allocated data blocks and inode back to the filesystem free-list.

For directories, the rmdir() system call removes an empty directory entry, failing with ENOTEMPTY if files or subdirectories remain inside.