M2: Operating Systems Overview

Question 1

Kernel

Answer 1

one of two core components of OSs (with the file system)

Question 2

File management system

Answer 2

one of two core components of OSs (with the
kernel). All data in a computer is stored in the form of a file, and the OS helps
maintain the file sizes, names, locations, directory structures, and file access
rights.

Question 3

CPU

Answer 3

the Computer Processing Unit. Circuitry to execute program

instructions.

Question 4

CPU cycle

Answer 4

the cycle performed by the CPU to read a program instruction,
execute it, and repeat.

Question 5

User mode

Answer 5

applications in user mode can only run instructions that affect its
own application. Executing functions in the application’s code

Question 6

Kernel mode

Answer 6

allows privileged machine instructions to run. This mode is entered by flipping a bit on the CPU

Question 7

Privileged machine instructions

Answer 7

have global effects on your whole computer and external devices. 
Examples include (1) writing data to disks and (2) running the logic that makes one application stop running, and instead start running another application.

Question 8

Process

Answer 8

a program in execution. Because there are limited CPU cycles and the OS needs to perform many tasks, the process concept allows OSs to switch between executing different tasks.

Question 9

Process context

Answer 9

the snapshotted state of a process, which includes its data, memory utilization, and execution progress.
The process context must be saved when the OS wants to stop running a process, and it gets reloaded when the OS resumes running the process.

Question 10

Process management

Answer 10

a function of the OS kernel that manages applications

using an abstraction called a process

Question 11

Address space

Answer 11

the memory organization model for processes. Each process has its own address space = virtual address space, to distinguish it from physical address. Consists of five segments, including (1) Code, (2) Data, (3) Heap, (4) Stack, and (5) Kernel space.

Question 12

Code

Answer 12

a segment of the process address space that is, by convention, stored
in the memory locations specified by the lowest addresses. Consists of the
instructions being executed for the process.

Question 13

Program counter

Answer 13

register value stored in the CPU. It points to the address of
the next instruction to execute in the Code segment.

Question 14

Data

Answer 14

segment of the process address space that, by convention, is stored
in the memory locations just above the Code segment. Stores
statically-defined variables.

Question 15

Heap

Answer 15

a segment of the process address space that, by convention, is stored
in the memory locations just above the Data segment. Stores dynamically
allocated memory. Grows and shrinks at runtime during program execution,
for example using malloc() and free() system calls in C.

Question 16

Stack

Answer 16

a segment of the process address space that, by convention, is stored
in the memory locations just above the Heap segment. Stores temporary
values required during function calls and pops them off once the function
completes.

Question 17

Kernel space:

Answer 17

a segment of the process address space that, by convention,
is stored in the memory locations just above the Stack segment. Reserved
space for the OS and privileged code.

Question 18

Process Identification Number (PID):

Answer 18

unique number assigned to each process by the OS.

Question 19

Process table

Answer 19

contains an array of process control blocks, and is maintained by the OS.

Question 20

Process Control Block (PCB):

Answer 20

each PCB stores the context of a single process.

Question 21

Init process

Answer 21

the only process that exists when the OS is booted. All other
processes are child processes of init.

Question 22

Parent and child processes:

Answer 22

processes are managed in a hierarchical

structure. A parent process creates child processes.

Question 23

PPID

Answer 23

PID of the process’s parent

Question 24

File descriptors:

Answer 24

handles to open files used by processes.

Question 25

Copy-on-write:

Answer 25

On the creation of a new process, the child shares the
parent’s memory address space until a modification is required. On a
modification, a distinct memory page is then created for the child.

Question 26

Fork()

Answer 26

system call that creates a new process and gives an integer return
value, which is used to differentiate between the child and parent processes
that are simultaneously running the same code after the call

Question 27

Exec()

Answer 27

accepts a path name to a code file as an input, and allows the child to
execute this new piece of code

Question 28

Wait():

Answer 28

allows a process to wait for another process to finish completing, to
give a signal, or to perform some other specified condition. The settings are
specified in the Linux man-pages.

Question 29

Exit()

Answer 29

terminates the process in which the exit() command is invoked.

Question 30

Process state: running, blocking, or ready

Answer 30

○ Running: instructions for this process are being executed by the CPU.
○ Blocked: process is waiting on I/O access, user input, or some other condition required to continue executing.
○ Ready: the process has all it needs to run and is waiting for CPU
access.

Question 31

Signals

Answer 31

software interrupts sent from process A to process B to
communicate an event that took place in process A. Process B can be set up to watch for certain signals and respond accordingly, depending on the
application being run.

Question 32

Superuser

Answer 32

an account with special permissions on a machine. The exact permissions vary depending on the machine’s OS.

Question 33

Orphan process:

Answer 33

process A is an orphan process if process A is the child of process B, B has terminated, but A is still running.
Reclaimed by init

Question 34

Zombie process:

Answer 34

process A is a zombie process if process A is the child of process B, but B has not called wait on A.
process A has completed but its PCB is still in the process table

Question 35

Daemon process:

Answer 35

system-level processes that are started to run OS-specific management tasks.
system-level process or background jobs owned by init process

Question 36

Shell

Answer 36

an interface allowing the user to enter OS commands

Question 37

Snapshot of Process Memory

Answer 37

Program Counter, Code, Stack, data (e.g. global variable), Heap, Program Counter, Stack Pointer

Question 38

Data Segement

Answer 38

Will not grow during the lifetime of a process, since it only deals with statically defined variables

Question 39

What is updated in memory whenever a process is executing

Answer 39

only the hardware registers are updated. But when the operating system decides to stop running the process, its register values including the stack pointer and program counter are stored in the PCB.

Question 40

Which of the elements of a process are stored in a process control block (PCB)?

Answer 40

• Stack Pointer
• Register Values
• Program Counter
• File Descriptors
• Memory Context: Pointer to page table

While the PCB of a process stores file descriptors of files in use by the process, the PCB does not store the files themselves.

Question 41

OS

Answer 41

Interface bw. user applications and computer hardware

Charge multiple tasks of varying priorities and allocating system memory

Question 42

OS Functions:

Answer 42

• Provides abstraction of the hardware – hide messy implementation details
• Resource Manager: Manage CPU Time and Memory

Question 43

Advantage of Limiting the transition to a small set of system calls

Answer 43

protects the operating system from being corrupted by applications either through software errors or malicious attacks.

Question 44

Resources shared bw. child and parent usually not shared bw. processes

Answer 44

open file descriptors, semaphores, pipes,

Question 45

Copy on Write

Answer 45

A child’s memory space is nearly identical to that of its parent. In a fork() operation, if we blindly create a child that is a replica of the parent, it is a lot of wasted work especially if the child address space is going to be overwritten later on through an exec() call. A lazy copy-on-write mechanism is used instead. If the child process modifies a piece of the memory, then a new copy of it is created.