Operating System

The operating system (OS) is the manager of the computer: it shares the CPU, memory and devices among programs, protects them from each other, and gives users a way to work.

This unit introduces what an OS does, the main kinds, and how it handles processes, memory, files and booting. (The Semester IV subject Operating Systems goes much deeper.)

3.1 What an OS does

An OS has two faces:

• Resource manager: allocates CPU time, memory, disk and I/O devices fairly and safely.
• Extended machine: hides ugly hardware details behind simple interfaces ("save this file" instead of "move the disk head to cylinder 213").

Function	Meaning
Process management	create, schedule, suspend and terminate programs in execution
Memory management	give each process memory, keep processes out of each other's space
File management	organise data in files and folders, control access
Device management	drive hardware through device drivers, queue requests, buffer data
Security and protection	user accounts, permissions, isolation
User interface	command line or graphical
Error handling and accounting	detect faults, log resource use

The kernel is the always-resident core of the OS; system calls are the doorway through which programs ask the kernel for services (open a file, create a process).

3.1.1 Eight functions of an operating system

1. Process management. The OS creates processes, decides which one gets the CPU next and ends them when they finish. Without it, a computer could run only one program at a time. When you play music while writing a Word file in a Kathmandu college lab, the scheduler is switching the CPU between the two many times a second.
2. Memory management. The OS gives every program its own part of RAM and stops one program from reading another's data. It also moves rarely used pages to disk when RAM is full (virtual memory). This is why a phone with 4 GB of RAM can keep many apps open.
3. File management. The OS stores data in named files and folders, tracks where each block is on the disk and controls who may read or write. Permissions keep the results folder of a college server safe from students. It also supports copy, move, delete and search.
4. Device management. Keyboards, printers, scanners and disks are controlled through device drivers. The OS queues print jobs (spooling) and buffers data so that a slow printer does not hold up the CPU. Plugging in a pen drive works because the OS loads the right driver.
5. User interface. The OS gives the user a command line (CLI) or a graphical interface (GUI). A GUI with icons and windows lets a first-time user start a program with a click, while the CLI lets an administrator automate hundreds of tasks with a script.
6. Security and protection. Passwords, user accounts, permissions, firewalls and encryption stop unauthorised use. The OS keeps a normal user from changing system files. Keeping the OS updated closes holes that malware would use.
7. Resource allocation and accounting. The OS shares CPU time, memory and disk space fairly among users and records usage. A university server can limit each student's storage quota. Accounting also helps the administrator to see which program slows the machine down.
8. Error detection and networking. The OS detects hardware and software errors, such as a bad disk sector or a program crash, and takes action without stopping the whole system. It also provides the network stack that lets the computer join a LAN or the Internet, so that a lab PC can reach a shared printer or the TU website.

Single-user vs multi-user: DOS was single-user, single-tasking; Linux and Windows Server are multi-user, multitasking.

3.3 Process management

A program is a passive file on disk; a process is a program in execution, with its own memory, registers and program counter. Each process has a process control block (PCB) in the kernel that stores its state, PC, registers, memory limits and open files.

Process states

   admitted        dispatch (scheduler picks it)
 New ─────▶ Ready ◀──────────────────────▶ Running ─────▶ Terminated
              ▲      timeout / pre-emption     │  exit
              │                                │ waits for I/O or event
              └──────── Waiting (Blocked) ◀───┘
                  I/O or event completes → back to Ready

A context switch saves the PCB of the running process and loads that of the next; it is pure overhead, so the OS wants few of them.

CPU scheduling. Several ready processes compete for one CPU; the scheduler chooses. Measures used:

• Turnaround time = completion time − arrival time.
• Waiting time = turnaround time − burst time (time spent in the ready queue).
• Response time = time from arrival to first execution.

Algorithm	Rule	Pre-emptive?	Remark
FCFS	first come, first served	no	simple; short jobs suffer behind a long one (convoy effect)
SJF	shortest burst first	no (SRTF is the pre-emptive form)	gives minimum average waiting time; needs burst estimates; long jobs may starve
Priority	highest priority first	either	starvation fixed by aging
Round robin	each process gets a quantum, then goes to the tail of the queue	yes	fair, good response for time-sharing

Deadlock. Processes are deadlocked when each holds a resource the next one needs, forming a cycle. It needs four conditions together: mutual exclusion, hold-and-wait, no pre-emption, circular wait. Breaking any one prevents it.

3.4 Memory management

Every running program must be in main memory. The OS tracks which parts are free, allocates them and protects them.

• Contiguous allocation: each process gets one block. Fixed partitions waste space inside a partition (internal fragmentation); variable partitions leave scattered holes between processes (external fragmentation) that compaction can merge.
• Paging: logical memory is cut into equal pages, physical memory into equal frames; a page table maps page → frame. It removes external fragmentation; only the last page of a process can be partly empty.
• Segmentation: memory is divided by meaning (code, data, stack) into variable-size segments.
• Virtual memory: only the needed pages are kept in RAM; the rest stay on disk (swap space). A page fault occurs when a page is not in RAM and must be loaded. Too many faults is thrashing. Virtual memory lets programs be larger than physical RAM.

Page replacement. When RAM is full, a victim page must go. FIFO removes the oldest page; LRU removes the least recently used; optimal removes the page not needed for longest (a yardstick, not implementable).

Example, 3 frames, reference string 1 2 3 4 1 2 5: FIFO faults on pages 1, 2, 3 (load), 4 (evict 1), 1 (evict 2), 2 (evict 3), 5 (evict 4) → 7 faults.

3.5 File and device management

A file is a named collection of related data. The OS keeps file attributes (name, type, size, location, owner, permissions, timestamps) and supports operations: create, open, read, write, seek, delete.

• Directory structure: modern systems use a tree with a root (C:\ or /); a path (C:\Users\sita\notes.txt, /home/sita/notes.txt) names a file. Absolute paths start at the root; relative paths start at the current directory.
• File systems: FAT32 (4 GB file limit), NTFS (Windows: permissions, journaling), ext4 (Linux), exFAT (flash drives), APFS (Apple).
• Allocation: contiguous, linked, or indexed (an index block lists the file's disk blocks).
• Access permissions: Linux uses read, write, execute for owner, group, others. rwxr-xr-- is octal 754.

Devices are driven through drivers. The OS uses buffering (temporary storage while data moves between devices of different speeds), caching and spooling (queueing output, e.g. print jobs, on disk so the program does not wait for the slow printer).

3.6 User interfaces and the boot process

• CLI (command line interface): type commands; fast, scriptable, low resource use (Bash, PowerShell, cmd).
• GUI (graphical user interface): windows, icons, menus, pointer (WIMP); easier for beginners.
• Touch/voice interfaces on mobiles and assistants.

Booting is starting the computer:

1. Power on; the CPU starts executing firmware (BIOS/UEFI).
2. POST (power-on self-test) checks CPU, RAM, keyboard and disks.
3. Firmware finds the boot device and loads the boot loader (e.g. Windows Boot Manager, GRUB).
4. The boot loader loads the kernel into RAM.
5. The kernel starts drivers and system services, then the login screen/shell appears.

Cold boot = from power-off; warm boot = restart without cutting power.

(a) CLI: type a command such as DIR, press Enter

(b) GUI (WIMP): windows, icons, menus, pointer

(c) GUI on Linux: launcher, top panel, windows

(d) Touch UI: icons, gestures, notification bar

Useful Linux commands: pwd (where am I), ls -l (list with permissions), cd dir, mkdir d, cp a b, mv a b, rm f, cat f, chmod 754 f, ps (processes), kill PID, sudo (run as administrator).

Formula and fact sheet

• Turnaround = completion − arrival. Waiting = turnaround − burst.
• SJF minimises average waiting time; FCFS is simplest; RR is for time-sharing.
• Physical address = frame × page size + offset; page = address div page size, offset = address mod page size.
• Deadlock needs mutual exclusion, hold-and-wait, no pre-emption, circular wait.
• Boot: power on → POST → boot loader → kernel → login.
• Linux permissions r = 4, w = 2, x = 1.

Chapter summary

• The OS manages processes, memory, files and devices and provides the user interface.
• Multiprogramming keeps the CPU busy; time-sharing gives interactivity; real-time guarantees deadlines.
• Scheduling algorithms trade fairness, throughput and waiting time; SJF is optimal for average wait but needs knowledge of burst lengths.
• Paging maps pages to frames, virtual memory uses disk to extend RAM, and page faults cost time.
• Files live in a directory tree on a file system; booting loads the kernel through firmware and a boot loader.

Practice

A. Short questions

1. Define operating system. State four of its functions.
2. Differentiate multiprogramming and multitasking.
3. What is a real-time OS? Differentiate hard and soft real-time.
4. Differentiate program and process. Draw the process state diagram.
5. What is a context switch?
6. What is virtual memory? What is a page fault?
7. Differentiate CLI and GUI.
8. What is a device driver? What is spooling?

B. Numerical problems

9. Processes P1 = 6, P2 = 2, P3 = 4 ms arrive at 0. Find average waiting time under FCFS and SJF.
10. Page size 2 KB. Find the page number and offset of logical address 9000. If that page is in frame 5, find the physical address.
11. The Linux permission string is rwxr-x---. Give the octal mode.
12. Reference string 7 0 1 2 0 3 with 3 frames; count the page faults for FIFO.

C. Long questions

13. Explain the types of operating systems.
14. Explain the booting process of a computer.
15. Explain paging and virtual memory.

Answers and worked solutions

1. An OS is system software that manages hardware and provides services to programs and users. Functions: process, memory, file, device management, security, user interface.

2. Multiprogramming keeps several programs in memory to keep the CPU busy during I/O waits; multitasking (time-sharing) additionally switches the CPU by time slice so that users get quick, interactive response.

3. An OS that guarantees response within a deadline. Hard: missing a deadline is a failure (airbag); soft: it only reduces quality (video streaming).

4. A program is a passive file; a process is a running instance with a PCB. States: new, ready, running, waiting, terminated (diagram in §3.3).

5. Saving the state of the running process and loading the state of the next one.

6. Virtual memory keeps only the needed pages in RAM and the rest on disk. A page fault is the trap when a referenced page is not in RAM.

7. CLI: typed commands, efficient, scriptable. GUI: windows and icons, easy to learn, uses more resources.

8. A driver is software that lets the OS control a device. Spooling queues output on disk so the CPU need not wait for a slow device such as a printer.

9. FCFS order 6, 2, 4: waits 0, 6, 8 → 14 / 3 = 4.67 ms. SJF order P2, P3, P1: waits 0, 2, 6 → 8 / 3 = 2.67 ms.

10. Page = 9000 div 2048 = 4; offset = 9000 − 8192 = 808. Physical = 5 × 2048 + 808 = 11048.

11. rwx = 7, r-x = 5, --- = 0, so 750.

12. FIFO with 3 frames: 7, 0, 1 load (3 faults); 2 evicts 7 (fault); 0 is a hit; 3 evicts 0 (fault). Total 5 faults.

13. Use the table in §3.2: batch, multiprogramming, time-sharing, multiprocessing, real-time, distributed, network, mobile, embedded, one line and example each.

14. Steps 1–5 in §3.6. 13–15. Full ten-mark answers are in the section Model answers below.

15. Paging: fixed-size pages and frames, page table, translation example in §3.4. Virtual memory: demand loading, page faults, replacement, thrashing.

Model answers: medium (5 marks) and long (10 marks) questions

Q13. Explain the types of operating systems. (10 marks)

Introduction. An operating system (OS) is system software that manages the hardware and gives users and programs a convenient interface (Figure 3.1). Operating systems are classified by how they schedule jobs and serve users.

1. Batch OS: similar jobs are collected and run one after another without user interaction. Advantage: high CPU use for large jobs. Limitation: long waiting time, no interaction. Example: early IBM mainframes, payroll runs.
2. Multiprogramming OS: several programs stay in memory and the CPU switches to another when one waits for I/O, so the CPU is rarely idle.
3. Time-sharing (multitasking) OS: the CPU gives each user or task a short time slice, so many users feel they have the machine alone. Example: UNIX, Linux, Windows.
4. Multiprocessor OS: two or more CPUs share memory and work in parallel for speed and reliability. Example: servers running Linux.
5. Real-time OS (RTOS): responds within a guaranteed time. Hard real time (air-bag, pacemaker) must never miss a deadline; soft real time (video streaming) can tolerate small delays.
6. Distributed OS: many networked computers act as one system and share resources and load. Example: cluster and cloud platforms.
7. Network OS: runs on a server and provides file, print and user sharing to client computers. Example: Windows Server, Linux server.
8. Embedded and mobile OS: small OS for devices with limited resources. Example: Android, iOS, router firmware.

Type	Interaction	Main aim	Example
Batch	none	throughput	old mainframe
Time-sharing	high	fair response	Linux
Real-time	immediate	deadline	RTOS in a car
Distributed	high	resource sharing	cloud cluster
Mobile	touch	battery, apps	Android

Conclusion. Modern desktop and server systems combine multiprogramming, time-sharing and multiprocessing, while special devices use real-time or embedded systems. The best type depends on the workload.

Q14. Explain the booting process of a computer. (10 marks)

Introduction. Booting is the process of starting a computer and loading the operating system from secondary storage into RAM. Because RAM is empty at power-on, a small program stored in ROM must start the process.

Cold boot is a start from power-off, warm boot is a restart.

Steps

1. Power on: the power supply stabilises its voltages and sends a "power good" signal; the CPU starts at a fixed address in the ROM.
2. Firmware (BIOS/UEFI) starts: the code in the ROM chip takes control and reads the settings kept in CMOS memory.
3. POST (power-on self test): checks the CPU, RAM, keyboard, video and drives. A fault gives beep codes or an error message.
4. Find the boot device: the firmware follows the boot order (SSD, USB, network) and looks for a bootable disk (MBR or GPT).
5. Bootloader loads: a small program such as GRUB or the Windows Boot Manager is loaded from the boot sector.
6. Kernel loads: the bootloader copies the OS kernel into RAM and hands over control; drivers are initialised.
7. System services start: the init or service manager starts background services, the network and the file systems.
8. Login and desktop: the login screen or shell appears and the computer is ready for use.

Process flow: power on → firmware → POST → boot device → bootloader → kernel → services → login.

Item	BIOS (legacy)	UEFI
Disk scheme	MBR, up to 2 TB	GPT, very large disks
Interface	text	graphical, mouse
Boot speed	slower	faster, Secure Boot

Conclusion. Booting is a chain of small programs, each loading a bigger one, until the full OS is running in RAM. Knowing the sequence helps to fix start-up problems such as a missing boot device.

Q15-M. Explain the states of a process with a diagram. (5 marks)

A process is a program in execution. During its life it passes through five states (Figure 3.2).

1. New: the process is being created.
2. Ready: it is in memory and waiting for the CPU.
3. Running: the CPU is executing its instructions; only one process per core is running at a time.
4. Waiting (blocked): it waits for I/O or an event, such as disk input.
5. Terminated: it has finished, and its resources are freed.

Transition	Cause
New → Ready	admitted by the scheduler
Ready → Running	dispatched by the CPU scheduler
Running → Ready	time slice expired or higher-priority process arrived
Running → Waiting	needs I/O or an event
Waiting → Ready	I/O or event completed
Running → Terminated	finishes or is killed

Example: while a text editor waits for a key press it is waiting; when the key arrives it becomes ready, then running. The OS keeps this information in a process control block (PCB).

Q15. Explain paging and virtual memory. (10 marks)

Introduction. Main memory is limited, but programs and the number of running programs keep growing.

Paging is a memory management method that removes external fragmentation by cutting memory into equal blocks, and virtual memory uses the disk to give each program the illusion of a very large private memory.

Together they let a 4 GB phone run apps whose total size is much more than 4 GB.

1. Pages and frames: logical memory of a process is divided into equal pages; physical memory is divided into frames of the same size (for example 1 KB or 4 KB). Any page can go into any free frame.
2. Page table: the OS keeps a table for each process mapping page number to frame number, as in Figure 3.4(A).
3. Address translation: a logical address is split into page number = address div page size and offset = address mod page size. For address 3500 and page size 1024 the page is 3 and the offset 428; with page 3 in frame 7 the physical address is 7 x 1024 + 428 = 7596.
4. Fragmentation: there is no external fragmentation; only the last page of a process may be partly empty (internal fragmentation, less than one page).
5. Demand paging: a page is loaded only when it is first used. A valid bit in the page table shows whether the page is in RAM.
6. Page fault: when the page is not in RAM, the hardware traps to the OS, which finds the page on disk, loads it into a free frame, updates the table and restarts the instruction. This costs milliseconds, so too many faults slow the system.
7. Page replacement: if no frame is free the OS selects a victim: FIFO removes the oldest page, LRU the least recently used and optimal the page needed farthest in the future. For the string 1 2 3 4 1 2 5 with three frames FIFO and LRU give 7 faults and optimal gives 5 (Figure 3.4(B)). FIFO can even give more faults with more frames (Belady's anomaly, Figure 3.4(C)).
8. Thrashing: if there are too many processes for the RAM, the system spends most time swapping pages and little time doing work. The cure is to reduce the number of running processes or add RAM.

Point	Paging	Virtual memory
Purpose	remove external fragmentation	run programs larger than RAM
Unit	fixed-size page and frame	pages moved between RAM and swap space
Main structure	page table	page table plus disk swap area
Main cost	table space	page faults and disk time

Example. On a lab PC with 4 GB of RAM, opening a browser, an IDE and a video call together may need more than 4 GB; the OS keeps the active pages in RAM and the rest in swap space, so everything runs, though a little slower.

Conclusion. Paging gives simple, fragmentation-free allocation, and virtual memory built on demand paging gives large, protected address spaces. Their success depends on a low page-fault rate, which is why replacement policy and enough RAM matter.