Top Linux Interview Questions and Answers

Here are top Linux interview questions,

1. What is a system call in Linux?

A system call is a mechanism that allows a user-level program to request a service from the kernel, such as creating a new process or reading from a file. It provides an interface between user space and kernel space.

System calls are essential for interacting with the underlying hardware and managing resources in an operating system. Examples of system calls include `fork()`, `exec()`, `open()`, `read()`, `write()`, and `exit()`.

 

2. How does process scheduling work in Linux?

Linux uses a priority-based scheduling algorithm with time-sharing. The scheduler assigns each process a priority value, and the process with the highest priority gets CPU time. Linux uses the Completely Fair Scheduler (CFS) by default.

The CFS aims to provide each process with a fair share of the CPU time. It maintains a red-black tree of processes sorted by their virtual run-time. The process with the least virtual run-time is given CPU time. This ensures that no process is starved of resources for too long.

 

3. Explain the concept of virtual memory in Linux.

Virtual memory is a memory management technique that allows processes to use more memory than physically available. It involves paging memory between RAM and disk, providing the illusion of a larger memory space.

Linux uses virtual memory to map a process's virtual address space to physical memory or swap space. This enables efficient memory utilization and isolation between processes. The Memory Management Unit (MMU) handles address translation.

 

4. What is the difference between a process and a thread?

A process is an independent program with its own memory space, whereas a thread is a lightweight execution unit within a process that shares the same memory space.

Threads within a process share the same memory space, allowing for efficient communication between them. Processes, on the other hand, are isolated from each other and require inter-process communication mechanisms.

 

5. How can you create a new process in Linux?

The `fork()` system call is used to create a new process. It duplicates the existing process, creating a parent-child relationship. When `fork()` is called, a new process (child) is created as a copy of the calling process (parent). The child process inherits the parent's memory, file descriptors, and other resources.

 

6. What is a daemon process?

A daemon process is a background process that runs independently of user interactions and typically provides services like web servers, print spoolers, etc.

Daemon processes are detached from the terminal and run as background tasks. They are usually started during system boot and are managed by init or systemd.

 

7. Explain the purpose of the `exec()` family of functions.

The `exec()` functions are used to replace the current process with a new process image, typically for running a different program.

`exec()` functions load a new program into the current process's memory space, overwriting its contents. This allows processes to switch to different tasks without creating a new process.

 

8. How can you pass information between parent and child processes?

Inter-process communication (IPC) mechanisms like pipes, sockets, shared memory, and signals can be used to exchange data between parent and child processes.

Pipes allow one-way communication, while sockets provide bidirectional communication over a network. Shared memory allows processes to share a common memory region, and signals are used to notify processes about events.

 

9. What is a race condition in Linux programming?

A race condition occurs when two or more processes or threads access shared resources concurrently, leading to unexpected and undesirable behavior.

Race conditions can result in data corruption, crashes, or incorrect outputs. To mitigate them, synchronization mechanisms like locks, semaphores, and mutexes are used to ensure mutual exclusion.

 

10. What is the Linux kernel? Explain the process of compiling and installing a new Linux kernel.

The Linux kernel is the core component of the Linux operating system. It is responsible for managing hardware resources, providing essential services to user-space programs, and facilitating communication between software and hardware.

• Compiling and installing a new Linux kernel involves:

• Downloading the kernel source code.

• Configuring kernel options using `make menuconfig` or similar tools.

• Compiling the kernel using `make`.

• Installing the compiled kernel using `make install`.

• Updating bootloader configurations.

• The `chmod` command is used to change file permissions, specifying read, write, and execute permissions for the owner, group, and others.

• The `grep` command is used to search for specific text patterns in files or streams. `grep` searches for a specified pattern in a given input and outputs the lines containing the pattern. It supports regular expressions for more complex pattern matching.

• The `top` command provides real-time monitoring of system processes, including memory usage. Additionally, the `ps` command with options like `ps aux` can display detailed memory usage information.

• The `mount` command is used to attach a filesystem, such as a disk partition or network share, to a directory in the Linux filesystem hierarchy. For e.g., `mount /dev/sda1 /mnt` mounts the filesystem on the `/dev/sda1` partition to the `/mnt` directory.

• The `kill` command is used to send signals to processes, allowing you to control their behavior or terminate them. The default signal sent by `kill` is SIGTERM, which asks the process to gracefully terminate. To forcefully terminate a process, you can use `kill -9 <PID>` with SIGKILL.

• The `netstat` command can be used to list network connections, ports, and related information. For example, `netstat -tuln`.

11. What is a shell in Linux?

A shell is a command-line interface that allows users to interact with the operating system by executing commands.

Linux shells, such as Bash (Bourne Again SHell), interpret user commands and execute them by interacting with the kernel. They provide features like scripting, piping, and redirection.

 

12. How can you find the process ID (PID) of a running process?

The `ps` command is used to list processes, and it can be combined with other options to filter the output and find a specific process.

Running `ps aux | grep <process_name>` displays a list of processes containing the specified process name along with their corresponding PIDs.

 

13. Explain the role of the "init" process in the Linux kernel.

The "init" process is the first process started by the kernel during the boot process. It serves as the parent process for all other user and system processes. In modern systems, "init" has been replaced by init systems like Systemd.

 

14. What is a symbolic link (symlink) in Linux?

A symbolic link is a special type of file that points to another file or directory, similar to a shortcut in Windows.

Symbolic links provide a flexible way to reference files or directories across different locations. They can be used to create shorter paths or to reference files that might be moved or renamed.

 

15. What is a kernel module?

A kernel module is a piece of code that can be loaded and unloaded into the running Linux kernel without requiring a system reboot. Modules can add new functionality to the kernel or extend existing features dynamically.

Kernel modules can be loaded using the `insmod` command and unloaded using the `rmmod` command. These commands interact with the kernel's module management system.

 

16. What are few important Linux commands?

Few important commands are,

17. How does the Linux kernel handle signals?

Signals are used to notify processes of various events. The Linux kernel allows processes to register signal handlers, which are functions that execute when a specific signal is received by the process.

 

18. Explain the role of the VFS (Virtual File System) in the Linux kernel.

The VFS abstracts various file systems and provides a uniform interface for applications to access files, regardless of the underlying storage type. It allows different file systems to coexist and be mounted at various points in the directory hierarchy.

 

19. Describe the process of handling a page fault in the Linux kernel.

A page fault occurs when a process accesses a memory page that is not currently in physical memory. The Linux kernel's page fault handler manages this by fetching the page from disk if necessary, updating the page tables, and resuming the interrupted process.

 

20. How does the Linux kernel support multi-core and multi-processor systems?

The Linux kernel supports multi-core and multi-processor systems through its scheduling and synchronization mechanisms. It divides workloads among available cores, handles concurrency issues using locks and atomic operations, and provides tools for efficient parallel programming.

 

Above are few top Linux interview questions. Remember to prepare and expand on these answers.

Good luck with your interview!  👍