Linux, Windows and Distributed Operating Systems

NET's Unit 5 names Linux and Windows as real operating systems to know by their own design decisions, beyond the general kernel theory of the course's Operating Systems chapters, and separately names Distributed Systems (network-based operating systems, robustness, distributed file systems) as its own topic. This chapter covers all three.

Linux Design Principles, Kernel Modules and Process Management

  • Linux follows the classic UNIX philosophy: 'everything is a file' (devices, pipes and sockets are all accessed through the same file-descriptor interface as ordinary files), monolithic-but-modular kernel design (most services run in kernel space for speed, but kernel modules can be loaded and unloaded at run time without a reboot, avoiding the all-or-nothing rebuild a purely monolithic kernel would need), and small composable tools connected by pipes rather than one large do-everything program.
  • Linux process management uses fork() to create a near-identical copy of the calling process (parent and child then diverge, typically via exec() in the child to load a new program image) and organises processes in a tree rooted at init/systemd (PID 1); scheduling is priority-based with dynamic priority adjustment, and standard POSIX scheduling classes (real-time FIFO/round-robin alongside the normal time-shared class) let latency-critical processes pre-empt ordinary ones.
  • Linux's file systems (ext4 and others) sit under a common Virtual File System (VFS) abstraction layer, which is what lets user programs and utilities work identically regardless of the underlying file system in use — the same open/read/write calls work whether the file is on ext4, a network mount, or even a virtual /proc entry exposing kernel information.

Windows Design Principles and System Components

Windows NT's design (the lineage underlying modern Windows) is deliberately layered: a small HAL (Hardware Abstraction Layer) isolates the rest of the OS from device-specific details; the KERNEL implements the most fundamental primitives (thread scheduling, interrupt/exception dispatching, multiprocessor synchronisation); and the EXECUTIVE, running in kernel mode above that, provides higher-level services (object manager, process/thread manager, memory manager, I/O manager, security reference monitor) each exposed to user mode through a well-defined set of system calls — a layered, more modular design than a classic monolithic UNIX kernel, at some cost in the overhead of crossing layer boundaries.

  • File system: NTFS (the standard modern Windows file system) supports per-file/folder access control lists, journaling (logging metadata changes so the file system can recover cleanly after a crash), and transparent compression/encryption — capabilities the older FAT file system lacks entirely.
  • Networking: Windows networking historically centred on SMB/CIFS for file/printer sharing within a Windows-native network, alongside standard TCP/IP for general connectivity — the course's Computer Networks chapters cover the protocol layer itself, while this sub-item's own concern is which stack Windows specifically uses for its native sharing services.

Distributed Systems: Network-Based OS Types and Robustness

Network OS versus distributed OS
TypeWhat the user sees
Network operating systemEach machine keeps its own independent OS and identity; the user is explicitly aware of which machine they are using and must explicitly log in/copy files across machines (e.g. via ssh, ftp).
Distributed operating systemMultiple physical machines are made to appear as ONE single coherent system to the user (single-system image) — the OS itself, not the user, decides which machine actually runs a given process or holds a given file.

Robustness in a distributed system means continuing to provide (at least degraded) service despite partial failure — a single site or link going down should not bring the whole system down, which is fundamentally different from a centralised system, where the one machine failing IS total failure. This is achieved by REDUNDANCY (no single point of failure) and by design choices such as replication and quorum-based agreement.

Distributed File Systems and Communication Structure

A distributed file system lets processes on many machines access files through a single, location-transparent naming scheme, without the user needing to know which physical server actually stores a given file. This is exactly why distributed file systems (e.g. the Google File System / HDFS lineage) replicate every block across multiple machines rather than storing it once — replication provides both robustness against a single machine's failure and, as a side benefit, faster reads by letting a client fetch from whichever replica is closest or least loaded. The communication structure underlying all of this is typically message-passing over the network (rather than shared memory, which is not physically possible across separate machines), so a distributed OS's protocols must additionally handle message loss, reordering and duplication that a single-machine OS never needs to consider.

Key takeaways

  • Linux follows 'everything is a file', loads/unloads kernel modules without rebooting, and unifies file systems under a common VFS layer.
  • Windows NT layers a small HAL, a minimal kernel and a fuller executive above it, each exposed to user mode via defined system calls — more layered than a classic monolithic kernel.
  • NTFS adds ACLs, journaling and compression/encryption that FAT lacks; Windows sharing historically uses SMB/CIFS alongside TCP/IP.
  • A network OS keeps each machine's independent identity visible to the user; a distributed OS presents many machines as one single-system image.
  • Robustness in a distributed system means surviving partial failure via redundancy, unlike a centralised system where one machine's failure is total failure.

Practice questions (8)

Attempt each one before opening the answer. Every explanation names the tempting wrong option as well as the right one, because that is where marks are lost.

  1. Linux's 'everything is a file' philosophy means:

    1. Devices, pipes and sockets are accessed through the same file-descriptor interface as ordinary files
    2. Only text files can exist on a Linux system
    3. The kernel cannot be modified at run time
    4. There is no file system at all
    Show answer

    Answer: A — Devices, pipes and sockets are accessed through the same file-descriptor interface as ordinary files

    This unifying abstraction lets the same open/read/write-style operations work uniformly across ordinary files and very different kinds of resources like devices and inter-process communication endpoints.

  2. A Linux kernel module can be loaded and unloaded at run time, which chiefly means:

    1. New functionality can be added without a full kernel rebuild and reboot
    2. The kernel must always be rebuilt from source for any change
    3. Linux has no kernel at all
    4. Modules run only in user mode, never kernel mode
    Show answer

    Answer: A — New functionality can be added without a full kernel rebuild and reboot

    Loadable kernel modules avoid the all-or-nothing rebuild a purely monolithic kernel would need, letting drivers and features be added or removed dynamically.

  3. In Windows NT's layered design, the component that isolates the rest of the OS from device-specific hardware details is the:

    1. HAL (Hardware Abstraction Layer)
    2. NTFS
    3. SMB/CIFS
    4. The security reference monitor
    Show answer

    Answer: A — HAL (Hardware Abstraction Layer)

    The HAL sits at the very bottom of the layered design specifically to abstract hardware differences away from the kernel and executive above it; NTFS is a file system, SMB/CIFS a sharing protocol, and the security reference monitor an executive-level access-control component.

  4. The key difference between a network operating system and a distributed operating system is:

    1. A distributed OS presents many machines as one single-system image; a network OS keeps each machine's identity separately visible to the user
    2. A network OS has no machines connected at all
    3. The two terms are exact synonyms
    4. A distributed OS cannot run more than one process
    Show answer

    Answer: A — A distributed OS presents many machines as one single-system image; a network OS keeps each machine's identity separately visible to the user

    In a network OS the user explicitly knows and manages which machine they are using; a distributed OS instead hides this, deciding on the user's behalf which machine actually runs a process or holds a file.

  5. Robustness in a distributed system chiefly refers to:

    1. Continuing to provide at least degraded service despite the partial failure of some site or link
    2. Being completely immune to any failure whatsoever
    3. Requiring exactly one machine to function
    4. Having no redundancy at all
    Show answer

    Answer: A — Continuing to provide at least degraded service despite the partial failure of some site or link

    Robustness is about graceful degradation under partial failure, achieved through redundancy and the absence of a single point of failure — not an impossible claim of total immunity to failure.

  6. Which of the following are true of NTFS compared to the older FAT file system? (More than one option may be correct.)

    1. NTFS supports per-file access control lists
    2. NTFS supports journaling for crash recovery
    3. NTFS supports transparent compression and encryption
    4. FAT and NTFS are identical in every capability
    Show answer

    Answer: A — NTFS supports per-file access control lists; B — NTFS supports journaling for crash recovery; C — NTFS supports transparent compression and encryption

    NTFS adds ACLs, journaling and transparent compression/encryption, none of which the older, simpler FAT file system supports.

  7. Name the Linux system call used to create a near-identical copy of the calling process, after which the child typically calls exec() to load a new program image.

    Numerical answer — type the value.

    Show answer

    Answer: fork

    fork() is the classic UNIX/Linux process-creation primitive; the fork-then-exec pattern is how a shell, for instance, launches a new program in a child process.

  8. A distributed file system replicating every data block across multiple machines gains chiefly:

    1. Robustness against a single machine's failure, plus potentially faster reads from a nearby replica
    2. Guaranteed loss of all data
    3. No change in behaviour compared to storing one copy
    4. The elimination of any need for a network at all
    Show answer

    Answer: A — Robustness against a single machine's failure, plus potentially faster reads from a nearby replica

    Replication is the standard technique for surviving individual machine failure without data loss, and as a side benefit lets a client read from whichever replica is closest or least loaded.