Prev Next

Interrupt and Exception Handling

`wait()`/`exit()`

We often consider wait() and exit() together, since they combine to remove any trace of a process from the system.
Until a process both calls exit() and has its exit code collected via wait() traces of it remain on the system:
- Its return code is retained by the kernel.
- Its process ID (or PID) is also retained. Why?
Processes that have exit()ed but not had their exit code collected are called zombies. (Ooh, scary!)

wait()/exit() also present an interesting synchronization problem you will solve for ASST2.
- Calls to wait() (by the parent) and exit() (by the child) may interleave in the kernel.
- You must guarantee that the parent can retrieve the exit code successfully.

`wait()`/`exit()` Issues

What happens if a process’s parent exits before it does?
- The "orphaned" process is assigned the init process as a parent, which will collect its exit code when it exits. Referred to as reparenting.
How do we prevent zombies from taking over the machine?
- A processes parent receives the SIGCHLD signal when a child calls exit(), alerting it to the chance to retrieve the child’s exit status.
- On some systems a process can choose to have its children automatically reaped by ignoring this signal.
- On bash the relevant command is the appropriately-named disown. This allows children to continue running as daemons even after bash exits.

What If I Don’t Want to `wait()`?

Parent may want to peek at the exit status of its child, just to check on it. (Are you dead yet? Are you dead yet?)
Systems support a non-blocking wait() for this purpose:
- Blocking wait() will block until the child exits, unless it has already exited in which case it returns immediately.
- Non-Blocking wait() will not block. Instead, its return status indicates if the child has exited and, if so, what the exit code was.

Our Simple Shell

Disclaimer: this is C-like pseudo-code. It will not compile or run! (But it’s not far off.)

while (1) {
  input = readLine();
  returnCode = fork();
  if (returnCode == 0) {
    exec(input);
  } else {
    wait(returnCode);
  }
}

Aside: `errno`

Where’s exit()?

There is potential confusion between kernel system calls and wrappers implemented by libc:
- _exit() (system call) v. exit() (C library function call).
The C library wraps system calls and changes their return codes.
The C library is what sets errno, not the kernel.

Multiplexing and Abstracting the CPU

For the next several weeks we’ll be looking at how the operating system manages the processor:

What are the limitations or problems with the hardware resource that the operating system is trying to address? There is only one (or at least, no that many) processor(s)!
What are the mechanisms necessary to allow the processor to be shared? Interrupts and context switching.
What are the consequences for programmers of processor multiplexing? Concurrency and synchronization.
How do we design good policies ensuring that processor sharing meets the needs of the user? Processor scheduling.

Today: Operating System Privilege

Earlier we alluded to the fact that the operating system is like a normal program with some special privileges.
In fact, implementing most of the process-related system calls we discussed last week does not require these special privileges!
- If you don’t believe me, look at user-space threading libraries. They provide functionality very similar to the fork(), exec(), exit() and wait() system calls we discussed.
So why does the operating system need special privileges?

Multiplexing Requires Privilege

In many cases implementing abstractions does not require special privileges.
However, the operating systems other task—multiplexing resources—does.

In order to divide resources between processes the system needs a trusted and privileged entity that can:
- divide the resources, and
- enforce the division.

No Trusto Processo

Why can’t processes share resources without a privileged arbiter?
Some processes are:
- malicious—"Hey, I’d like some more memory, so I’ll use yours!"
- buggy—"Um, is this my memory or your memory? I’m not sure but I’ll just use it and hope things turn out OK…"

Privileged Execution

CPUs implement a mechanism allowing the operating system to manage resources: kernel (or privileged) mode.
Being in kernel mode may mean that the executing code
- has access to special instructions, and
- has a different view of memory.

Special Instructions

When the CPU is in kernel mode there are special instructions that can be executed.
- These instructions usually modify important global state controlling how resources are shared.
When the CPU is not in kernel mode it does not allow these instructions to be executed.
- We will see what happens when an unprivileged process tries to execute a privileged instruction in a minute.

Protection Boundaries

The goal:
- only trusted kernel code runs in kernel mode;
- untrusted user code always runs in user mode.
The CPU implements mechanisms to transition between user and kernel mode which we will discuss during the rest of today’s class.

Aside: Fine-Grained Protection

Many modern CPUs implement more than two protection modes.
x86 processors actually have four protection "rings" from Ring 0 (most privileged) to Ring 3 (least privileged).
For many years operating systems running on x86 architectures only used Ring 0 (kernel mode) and Ring 3 (user mode).
Recently this has become more interesting because of operating system virtualization, so we will return to this.
- But for now, you can think of processors as having two privilege modes: kernel mode and user mode.

Terminology

When we say "application" we refer to code running without privileges or in unprivileged or "user" mode.
When we say "kernel" we mean code running in privileged or kernel mode.
What makes the kernel special? It is the one application allowed to executed code in kernel mode!

Bootstrapping Privilege

Why is the operating system allowed to run in kernel mode?

You installed your machine that way! This is what it means to install an operating system: choose a particular application to grant special privileges to.

On boot the CPU starts out executing the kernel code in privileged mode, which is how privilege is bootstrapped.
The kernel is responsible for lowering the privilege level before executing user code.

More Terminology: Traps

When a normal application does something that causes the system to enter kernel mode we sometimes refer to this as trapping into the kernel.
I frequently think about the thread that trapped into the kernel as running in the kernel after the trap occurs.
- On some level this is accurate: it is the same stream of instructions.
- On some level this is not accurate: the kernel thread has its own stack and has saved the state of the trapping user thread, so in a way the user thread has been paused while the kernel performs some task on its behalf.
Decide the way to think about this that is the most effective for you.

Privilege Transitions

The transition into the kernel or into privileged mode typically occurs for one of three reasons:
- a hardware device requests attention—hardware interrupt
- software requests attention—software interrupt or system call
- software needs attention—software exception
What is the difference between requesting and needing attention?

Hardware Interrupts

Hardware interrupts are used to signal that a particular device needs attention:
- a disk read completed, or
- a network packet was received, or
- a timer fired.
Processors implement multiple interrupt lines, input wires on which a logic transition (or level) will trigger an interrupt.

Interrupt Handling

When an interrupt is triggered (interrupt request, or IRQ), the processor:

enters privileged mode,
records state necessary to process the interrupt,
jumps to a pre-determined memory location and begins executing instructions.

The instructions that the processor executes when an interrupt fires are called the interrupt service routine (ISR).