Adding Files, Modifying Files, Readers-Writers, Deadlock Prevention, Kernel and User Spaces, Cache Misses, TLB Lookups, Disk Access

Adding Files

/usr/src/test_kernel/SystemCalls/test_call.c: Creates sys call pointer, Exports the pointer so that syscall module can access it, Define sys call wrapper. /usr/src/test_kernel/SystemCalls/Makefile: obj-y :=test_call.o compiles files directly into kernel.

Modifying Files

/usr/src/test_kernel/SystemModule/syscallModule.c: Holds module code, Implements sys call behaviour Registers syscall pointer to the proper syscall handler. /usr/src/test_kernel/SystemModule/Makefile obj-m :=syscallmodule.o Compiles file as a module.

/usr/src/test_kernel/arch/x86/entry/syscalls/syscall_64.tbl: Add system call to the table. /usr/src/test_kernel/include/linux/syscalls.h: Define the sys call prototype. /usr/src/test_kernel/Makefile: Add the SystemCalls directory to the list. Adding a new system call requires recompiling and reinstalling the whole kernel.

Readers-Writers

Reader: Wait until no writers, Access database, Wake up waiting writers

Writer: Wait until no active readers or writers, Access database, Wake up any waiting readers or writers.

activeReaders = 0; activeWriters = 0; waitingReaders = 0; waitingWriters = 0; Condition okToRead = NULL; Condition okToWrite = NULL; Lock lock = FREE; Condition okToRead = NULL; Condition okToWrite = NULL; Lock lock = FREE;

Reader() {lock.Acquire(); while (activeWriters > 0 || waitingWriters > 0) { ++waitingReaders; okToRead.Wait(&lock); --waitingReaders; } ++activeReaders;lock.Release(); // access database lock.Acquire(); --activeReaders; if (activeReaders == 0 && waitingWriters > 0) { okToWrite.Signal(&lock); }}

Writer() {lock.Acquire(); while (activeWriters > 0 || activeReaders > 0) { ++waitingWriters; okToWrite.Wait(&lock); --waitingWriters; } ++activeWriters; lock.Release(); // access database lock.Acquire(); --activeWriters; if (waitingWriters > 0) {okToWrite.Signal(&lock);} else if (waitingReaders > 0) { okToRead.Broadcast(&lock); } lock.Release();}

Four Conditions for Deadlocks

Limited access, No preemption, Wait while holding, Circular chain request. Remove one of the four conditions, (all four conditions must be true in order to deadlock)

Deadlock Prevention Techniques

Infinite resource No sharing, independent threads allocate all the resources at the beginning, if you need both grab them at the same time. Make everyone use the same ordering in accessing resource no waiting (phone company) preempt resources (copy memory content to disk) Bankers algorithm combination of techniques.

Steps to Switch Between Kernel and User Spaces

Kernel to the user mode: (1) Creates a process (2) Initializes the address space (3) Loads the program into the memory (4) Initializes translation tables (5) Sets the hardware pointer to the translation table (6) Sets the CPU to user mode (7) Jumps to the entry point of the program.

User To Kernel the user to kernel mode either through voluntary or involuntary mechanisms. The voluntary mechanism is through the use of system calls, where a user application asks the operating system to do something on the user’s behalf. Involuntary: by hardware interrupts (e.g., I/O) and program exceptions (e.g., segmentation fault).

Four Types of Cache Misses

Compulsory misses: data brought into the cache for the first time e.g., booting Capacity misses: caused by the limited size of a cache Misses due to competing cache entries: a cache entry assigned to two pieces of data When both activeEach will preempt the other Policy misses: caused by cache replacement policy, which chooses which cache entry to replace when the cache is full

Ways to Perform TLB Lookups

Sequential search of the TLB table, Direct mapping: assigns each virtual page to a specific slot in the TLB. Set associativity: uses N TLB banks to perform lookups in parallel Fully associative cache: allows looking up all TLB entries in parallel

Disk access time: Seek time + rotational delay + transfer time Latency: Seek time + rotational delay Bandwidth: Bytes transferred / disk access time