Exceptions

Prev: Exceptional Control Flow
TOC: Exceptional Control Flow
Next: Processes

Pasted image 20260428114420.png

Exceptions are a form of exceptional control flow (ECF) that are implemented partly by hardware and partly by the operating system, with details that can vary from system to system.

It's an abrupt change in the processor's control flow in response to some change in processor's state.

In the figure above as the processor is executing some current instruction I_curr when a significant change in processor's state occurs, the state is encoded in bits and signals, and the change of state is known as event.

The even could be related to the execution of current instruction like page fault or it could be unrelated to current instruction execution like some system timer going off or some I/O request's completing.

When processor detects that some event has occurred, it makes an indirect procedure class (exception) through a jump table called exception table, to an operating system subroutine (the exceptional handler) that is specifically designed to process this particular event.

When the exception handler is done processing, one of these three things can happen:

the handler returns control to the current instruction I_curr, the instruction that was executing when thee vent occurred.

The handler returns control to Inext, the instruction that would have executed next had thee exception not occurred.

The handler aborts the interrupted program.

Exception Handling

Pasted image 20260428170640.png

Exception handling involves close cooperation between hardware and software.
EACH type of possible exception in a system is assigned a unique non-negative integer exception number, some assigned by processor designer, some by the OS kernel designers.
Example of processor assigned exceptions: divide by zero, page faults, memory access violations, break points and arithmetic overflow.
Examples of kernel assigned exceptions: sys calls and signals form external I/O devices.
At system boot time, the OS allocates and initializes a jump table called exception table, so that entry k contains he address of handler for exception k.
Might look smthing like this:
At run time when the processor detects some event, it triggers exception by making an indirect procedure call through entry k of exception table to the corresponding handler.
The exception number is just an index INTO the exception table whose address IS CONTAINED IN A SPECIAL CPU REGISTER CALLED EXCEPTION HANDLER BASE REGISTER.
Exception handling is like procedure call in the sense that processors pushes return address into the stack, however depending on the type of exception, it is either for the current or next instruction.
The processor also pushes some the EFLAGS register containing the current condition code amongs other things
NOTE that as control is being transferred into kernel from the user program, these items are pushed ot kernel stack rather than on user's.
Exception handler run on kernel mode and have complete access to CPU resources.
Once the hardware triggers the exception, the handling is done by the software which optionally returns to interrupted program by executing "return from interrupt" instruction which pops the appropriate state back into the processor's control and data registers restroing the state into user mode.

Classes of Exceptions

Pasted image 20260428190851.png

Interrupts:

Pasted image 20260428192326.png

They occur asynchronously as a result of signals from I/O devices that are external to the processor, and they are async in the sense that they are not caused by the execution of any particular instruction.
Exceptions handler for interrupts are known as interrupt handlers.
The I/O devices might include network adapters, disk controllers and timer chips
The I/O device triggers this interrupt by signalling a pin on the processor chip and placing onto the system bus the exception number that identifies the decide that caused the interrupt
After the current instruction finishes executing, the processor notices the interrupt pin has gone high, reads the exception number from the system bus and calls the appropriate interrupt handler.
After the handling is finished the control is returned back to the next instruction.

Sync/Async Exceptions

Exceptions that occur as a result of executing current instruction are synchronous, traps, faults and aborts are such. Interrupts are asynchronous because they happen as a result of external I/O stuff.

Traps and System Calls

Pasted image 20260428210446.png

Are intentional exception that happen as a result of executing an instruction, and like interrupts it also returns control to next instruction.
Used in requesting kernels services through syscall. Syscall n instruction can be used to request service n form the kernel
Executing the syscall instruction causes a trap to an exceptional handler that decodes the argument and calls the appropriate kernel routine.
Syscalls are different from regular function calls in the sense that unlike regular function which is run time allocated and run at user stack (mode) syscall level function's stack are pre-allocated in the kernel and are done in kernel mode.
After the syscall is handled the control flow is returned to the next instruction

Faults

Pasted image 20260428210821.png

They result form error conditions that the handler might be able to correct (like page faults)
If the handler's able to correct the error, then the control flow is returned to the FAULTING INSTRUCTION that casued the error in the first place (I_curr).
In case of failure the handler returns an abort routine in the kernel which terminates the application causing the fault.

Aborts

Pasted image 20260428211001.png

Results when some unrecoverable fatal error happen, usually hardware like party error that occur due to corrupted blocks in DRAM/SRAM.
The control flow is not returned back to the application, it's just terminated.

Exceptions in Linux/x86-64 Systems

There are upto 256 different exceptions types, 0-31 correspond to exceptions defined by Intel architects, and the rest (32-255) corresponds to interrupts and taraps that are defined by the operating system.

OS generally DOES NOT define Faults and Aborts, but they are responsible for handling them

In x86-64 systems:

Pasted image 20260428211122.png

Divide zero fault:
- occurs when an application attempts to divide by zero or when the result of a divide instruction is too big for the destination operand.
- Although it is a fault at hardware level, neither Unix or Linux tries to recover form that error. Unix instead aborts it and Linux just aborts after reporting divide error as "Floating exceptions"
General protection fault:
- Usually happens when a program references an undefined area of virtual memory or if it attempts to write to some read only text segment.
- Just like prev one, Linux does not try recover form this and just aborts after reporting it as "Segmentation Fault"
Page Fault:
- Happens when the page the process wants is not in the memory.
- The OS attempts to recover from it by loading the appropriate page from the disk into the physical memory and then restarting the faulting process
Machine check:
- Happens as a result of a fatal hardware error that is detected during execution of the faulting instruction.
- Never returns control to the application program and results in direct abortion.

Linux/x86-64 System Calls:

Pasted image 20260428215400.png

There are hundreds of them that application programs use when requesting services from the kernel.
Each system call has unique set of integer number that corresponds to an offset in a jump table in the kernel.
C program can invoke any of the Linux provided sys calls but is rarely necessary in practice cuz C standard provides convenient set of wrapper functions for most syscalls.
All arguments to Linux system calls are passed through general purpose registers rather than the stack, and by convention register %rax contains the syscall number, with upto 6 args in %rdi, %rsi, %rdx, %r10, %r8 and %r9.
%rcx is used to store the address of the instruction next to the sys call, basically the return address and %r11 is used to store the RFLAGS, the state of the cpu flags before the syscall was executed, and since this is automatic, whatever was in there is basically destroyed.
On returning, %rcx and %r11 are destroyed %rax contains the return value. Negative value between -4095 and -1 indicates an error corresponding to negative errno.
Example usage:
In C:

The corresponding assembly:

Prev: Exceptional Control Flow
TOC: Exceptional Control Flow
Next: Processes