Operating Systems interview questions

A bootloader is a small program that runs after the computer's firmware starts, loads the operating system kernel into memory, and hands control over to it.

BIOS and UEFI are firmware stored on the motherboard that start the hardware and then launch the bootloader. The bootloader is software on the disk that loads the operating system kernel.

GRUB, the GRand Unified Bootloader, is the most common bootloader for Linux. It can boot several operating systems and lets you pick a kernel or edit boot options from a menu at startup.

On phones and some other devices, the bootloader normally starts only operating systems signed by the manufacturer. Unlocking it removes that restriction so you can install a custom operating system, usually after the device erases its data for security.

A command line interface (CLI) is a text-based way of using a computer: you type a command with options and arguments, press Enter, and read its output.

A CLI is operated by typing text commands; a GUI, a graphical user interface, by clicking windows, buttons and menus. CLIs are easier to automate and script, while GUIs are easier to discover for new users.

It is faster for many tasks, works the same on remote servers, can be scripted and automated, and many developer tools offer their full functionality only through a CLI.

A number a program returns when it finishes. Zero means success and any other value signals an error, which scripts and CI pipelines check to decide what to do next.

A context switch is when the operating system saves the state of the running thread or process and restores another one's state so it can use the CPU.

Saving and loading registers is quick, but the new task finds the CPU caches and address translation buffers filled with the previous task's data. Until they warm up again, memory accesses are much slower.

A voluntary switch happens when a thread gives up the CPU itself, for example to wait for I/O or a lock. An involuntary switch happens when the scheduler preempts a thread that still wanted to run, usually because its time slice ended.

Yes. Threads in the same process share one address space, so the kernel does not need to switch page tables, and more of the cached data stays useful.

A CPU (central processing unit) is the processor that executes a program's instructions, doing the arithmetic, logic and control work all software runs on.

A CPU has a few powerful cores designed for varied, sequential work with lots of decisions. A GPU has thousands of simpler cores designed to do the same operation on large amounts of data in parallel, such as graphics or neural network math.

An independent processing unit inside the CPU that can run its own stream of instructions. A processor with eight cores can work on eight threads truly at the same time, or more with simultaneous multithreading.

They are different instruction set architectures. x86 is used by Intel and AMD in most PCs and servers. ARM designs are licensed to many manufacturers and are known for energy efficiency, which is why they power phones and many newer laptops and servers.

A CPU cache is a small, very fast memory on the processor that keeps copies of recently used data from RAM, so the CPU spends less time waiting for memory.

They are levels of cache that trade size for speed. L1 is the smallest and fastest and belongs to one core, L2 is larger and a little slower, and L3 is the largest and slowest cache level, usually shared by all cores.

A cache miss happens when the data the CPU needs is not in the cache, so it has to be fetched from a slower cache level or from RAM. Frequent misses can make a program several times slower.

It matters for workloads whose active data almost fits in the cache, such as games, databases, and scientific code. A larger cache means fewer trips to RAM, but access patterns in the code often matter more than raw size.

CPU scheduling is how an operating system decides which ready process or thread runs on each CPU core next, and for how long, so the processor is shared fairly.

A context switch is when the CPU stops running one thread or process, saves its registers and state, and loads the saved state of another. It lets many tasks share a core, but each switch costs time, so too many switches can hurt performance.

In preemptive scheduling the operating system can interrupt a running task to give the CPU to another one. In non-preemptive, or cooperative, scheduling a task keeps the CPU until it finishes or voluntarily gives it up.

Round robin gives each ready task the same small time slice in turn, cycling through the queue repeatedly. It is simple and fair, which makes it a common building block in real schedulers.

A daemon is a program that runs in the background without a user interface, usually started at boot, to provide a service such as logging, scheduling, or SSH.

The name was coined by programmers at MIT in the 1960s, inspired by Maxwell's demon, an imaginary being in physics that works tirelessly in the background. It has nothing to do with evil spirits.

They mean nearly the same thing. Daemon is the traditional Unix term for a background process, while service is the Windows term and is also used for daemons managed by systemd on Linux.

systemd is the init system and service manager used by most Linux distributions. It is the first process started by the kernel, and it starts, supervises, and logs the system's daemons.

A deadlock is a situation where two or more threads or processes wait forever for each other to release resources, so none of them can make progress.

Most relational databases detect deadlocks automatically by looking for cycles among waiting transactions. They then abort one of the transactions and return an error, so the application can retry it.

Acquire multiple locks in the same fixed order everywhere, hold locks for as short a time as possible, and use timeouts when acquiring them. Higher-level tools such as queues or immutable data can also reduce the need for locks.

In a deadlock, threads block forever waiting for each other, so the program stops making progress. In a race condition, threads access shared data without proper coordination, so the program keeps running but may produce wrong results.