Processes and threads, scheduling, virtual memory and paging, synchronisation, and deadlock handling.
6 questions in CS Fundamentals.
Deadlock needs all four Coffman conditions at once: mutual exclusion, hold and wait, no preemption and circular wait. Breaking any one prevents it, and the practical choice is usually circular wait, by making every thread take locks in one global order.
A process is a running program with its own address space and OS resources; a thread runs inside a process with its own stack and registers but shares its memory and files. In a process vs thread answer, the trap is calling sharing a free win: it makes threads cheap and makes one thread's bug everyone's.
A context switch in an operating system saves one thread's CPU state, runs the scheduler and restores another thread. Application developers care because excessive switches add latency through cache and TLB disruption, lock contention and oversized thread pools. It also connects scheduling to the point an interviewer is testing.
Virtual memory gives each process a private address space and lets the MMU map virtual pages to physical frames. A page fault traps to the kernel; a minor fault maps memory cheaply, while a major fault waits for storage and can dominate performance. It also connects PAGING to the point an interviewer is testing.
Shared memory gives you bytes, not coordination. Process synchronisation needs a mutex inside the region, marked PTHREAD_PROCESS_SHARED and initialised once. If the holder dies, a plain mutex stays locked forever; a robust mutex returns EOWNERDEAD, but repairing half-written data is your job.
Suspect a bounded resource rather than a saturated one: file descriptors, threads, ephemeral ports or the listen queue. Each has a different scope — per process, per user, per cgroup, per system — and each announces itself with a different error, which is how you tell them apart. Use this RLIMIT answer to show the decision, trade-off, and evidence rather than a memorised definition.