What is an operating system?

Making it easy to run programs Allowing programs to share memory Enabling programs to interact with devices And other fun, interesting things

Process

</ox-hugo/2022-06-23_17-41-04_PX82iOPpRSy_Nojj6cUsog_ba42e04ce1e84c528ee5866abaf69df1_intro-to-os-1–virtualization-processes-and-execution-processes.pdf.pdf>

What is process?

A process is just a running application.

Memory Registers

Time-sharing

allows users to run as many concurrent programs as they like but at the risk of performance loss.

Process API

operating system controls processes using the process api

• create
• destroy
• wait
• miscellaneous control: pause, resume, …
• status

common way to reate a new process in unix-based os: fork(), exec()

fork()

creates a new process every process has a PID(process identifier)

wait()

exec()

runs a completely different program

Virtualization

os transforms a physical resource into a more general, pwoerful, and user-friendly virtual form.

• how can you virtualize wihtout slowing down the system?
• how can you maintain control while running processes effectively?

user & kernel mode

user mode

limits what the code can do

kernel mode

where the os runs. code in this mode can freely perform privileged operations

system call

programs running in user mode use system calls to ask for privileged operations from the kernel.

• working with file systems
• starting and terminating processes
• talking with the other processes
• setting aside more memory

trap

the trap instruction jumps into the kernel and switches to kernel mode.

trap table: a trap table is created during the boot process. machines start in kernel mode so they can perform sensitive tasks. the kernel lets the hardware know about the location of trap handlers

A trap table tells the hardware what code to run when specific events occur.

A trap instruction jumps into the kernel and raises the privilege level to kernel-mode, and calls return-from-trap to go back into user-mode.

switching between processes

cooperative approach: waiting for system calls

waiting for system calls: a cooperative approach. trusting system processes to occasionally give up control of the CPU in order to perform other tasks.

non-cooperative approach: the os takes over

A timer-interrupt is a built-in timer that raises an interrupt after a specified number of milliseconds. This signal will stop the current process. The interval is long enough for tasks to complete except for things like an infinite loop.

Context Switch

• The timer interrupts Process A
• Registers are saved to the kernel stack
• The OS switches to Process B
• The system then calls the switch() routine which does three things:
  • Saves incoming register values (into the process structure of Process A)
  • Restores the registers of Process B (from its process structure)
  • Switches context by switching between B and A stacks
• The OS exits the trap and restores Process B’s registers and launching the process

During all of this, there are two types of register saving and restoration that happen:

• With a timer interrupt, the hardware saves the current process’s registers to the kernel stack.
• When the OS switches from A to B, the system saves the kernel registers into memory in the process structure.

limited direct execution

• Creating trap handlers at boot time
  • Programs cannot alter the trap table
  • Use a system call to trap request services from the kernel
  • Trap calls save register state as they switch processes
  • A return-from-trap instruction is issued after the kernel service is complete
• Implementing an interrupt timer
  • Hardware timer that can interrupt a process after a specified time
  • This is a non-cooperative way to share the CPU
  • Context-switching is a result of an interrupt
• Running sensitive tasks in a restricted mode
  • User mode is restricted as to what a process can do
  • Kernel mode gives the process limited access to sensitive tasks
  • The modes are changed during trap handling

</ox-hugo/2022-06-29_21-02-28_RyM3OGniSOCjNzhp4ojg0w_5080c5e0d33b4c5ca8d90d0b08c8a8f1_intro-to-os-1–virtualization-processes-and-execution-direct-execution.pdf.pdf>