Top Embedded Linux Driver Interview Questions for Major Tech Companies

Technical Questions

Linux kernel space and user space communication methods System calls, ioctl, netlink, mmap shared memory, pipes / named pipes, message queues, signals, sockets.

Why can't an interrupt sleep? Interrupt context lacks a task_struct, so it cannot be scheduled to wake up; sleeping would hang the system. Moreover, interrupts must execute quickly, and sleeping would occupy interrupt resources.

Kernel memory allocation methods (buddy system, slab, etc.)

Buddy system: manages physical page frames, allocates large memory, solves fragmentation.

slab/slub/slob: built on the buddy system, allocates small objects and caches frequently used objects.

vmalloc: allocates virtually contiguous but physically non‑contiguous memory.

kmem_cache: dedicated object cache pool for slab.

kmalloc minimum allocation – request 128 bytes, what is actually allocated? According to kernel block‑size alignment rules, the actual allocation is 128 bytes (on some architectures the minimum block may be 256 bytes, but the allocation remains 128 bytes without extra waste).

Difference between #define and const, and when each takes effect

#define: replaced during the preprocessing stage (before compilation), no type checking, occupies code segment.

const: effective during compilation, has type checking, occupies data segment, cannot be modified directly.

Endianness – what are the differences?

Little‑endian: low‑order byte stored at low address (default on ARM/x86).

Big‑endian: low‑order byte stored at high address (used in network protocols and some peripherals).

Cache coherence? In multi‑core CPUs, cache coherence ensures that copies of the same physical address stay consistent, maintained automatically by hardware protocols such as MESI/MOESI or assisted by software barriers like dmb/dsb.

Three‑level cache hierarchy

L1: core‑private, fastest and smallest, split into I‑Cache and D‑Cache.

L2: core‑private or shared, medium speed and size.

L3: shared across cores, slowest and largest, reduces memory access latency.

Stack vs. heap differences

Stack: automatically allocated and freed, LIFO, stores local variables and parameters, small and contiguous.

Heap: manually allocated and freed, unordered, stores dynamic data, large and non‑contiguous, prone to fragmentation.

Explain DMA – how does it work? DMA (Direct Memory Access) allows peripherals to transfer data to/from memory without CPU involvement. The CPU configures the DMA controller with address, length, and direction; the controller performs the transfer autonomously and notifies the CPU via an interrupt upon completion.

Virtual‑to‑physical address translation

Split the virtual address into page‑directory index, page‑table index, and offset.

Use multi‑level page tables to look up the physical page‑frame number.

Combine the frame number with the offset to form the physical address.

If translation fails, a page‑fault exception is raised.

MMU workflow and page‑table size Workflow: receive virtual address → TLB lookup (on miss, walk page tables) → address translation + permission check → output physical address. Page‑table size: on a 32‑bit system with 4 KB pages, a two‑level page table occupies 2 KB; on 64‑bit systems the size varies with the number of levels.

What does a process context contain? Process execution environment includes user‑mode context (registers, PC, stack pointer, memory mappings) and kernel‑mode context (task_struct, kernel stack, page tables, file descriptors, signal mask).

Characteristics of a const char * pointer – does its address change? The pointed‑to string is immutable, but the pointer itself can be modified (e.g., p++, or point to another string).

Effects of static and volatile

static: extends lifetime of a local variable to the whole program; at file scope limits visibility to the translation unit.

volatile: tells the compiler the variable may change asynchronously, preventing optimization and forcing each access to read/write actual memory.

Difference between struct and union; knowledge of bit‑fields?

Struct members occupy independent memory; total size = sum of members plus alignment padding.

Union members share the same memory; total size = size of the largest member.

Bit‑fields: specify the number of bits for a member inside a struct (e.g., uint8_t a:4) to save space, useful for registers or compressed data, but require careful handling of cross‑byte alignment.

Difference between #define and typedef

#define: textual substitution performed by the preprocessor, no type checking, can define constants or macro functions.

typedef: creates a type alias during compilation, subject to type checking, only affects types.

How are function arguments passed in C? By default arguments are placed on the stack; on ARMv8/x86‑64 the first few arguments are passed in registers, with remaining arguments on the stack.

System call transition from user to kernel mode Triggers a software interrupt → saves user‑mode context → switches to kernel stack and page tables → executes the system‑call handler → restores user‑mode context and returns.

Linux inter‑process communication methods Unnamed pipes (parent‑child), named pipes (no relationship), signals, message queues, shared memory, semaphores, sockets (cross‑machine or local).

How does the kernel obtain a user‑mode PID? Use current->pid for the current process PID, current->tgid for the thread‑group (user‑mode) PID; other processes' PIDs can be found by traversing the task list.

Linux kernel scheduling mechanisms Normal processes use the Completely Fair Scheduler (CFS) which schedules based on virtual runtime. Real‑time processes use SCHED_FIFO or SCHED_RR, with higher‑priority tasks pre‑empting lower‑priority ones.

How does the first driver function get executed? Why do init and exit cause their functions to run? The macros module_init() and module_exit() register the driver’s initialization and cleanup functions; the kernel calls the init function when the module is loaded and the exit function when it is removed (rmmod).

32‑bit Linux virtual memory layout and high‑mem mapping region User space: 0x00000000‑0xBFFFFFFF (3 GB). Kernel space: 0xC0000000‑0xFFFFFFFF (1 GB). High‑mem mapping: kernel region 0xF8000000‑0xFFFFFFFF, maps the top 896 MB of physical memory to overcome direct‑address limitations.

What happens to the user‑mode stack during a system call? The user‑mode stack itself remains unchanged; the CPU saves the user‑mode stack pointer, PC, and other registers onto the kernel stack, and restores them after the call returns.

ARMv8 registers, modes, exception levels, and reset state 31 general‑purpose 64‑bit registers plus PC and PSTATE. Modes: EL1h/t, EL2h/t, EL3h/t (h = handler, t = thread). Exception levels: EL0‑EL3 (four levels). Working modes: secure and non‑secure. After power‑on reset the CPU enters EL3 (secure monitor mode).

Debugging methods and common gdb commands

Tools: gdb, kdb, printk, kmemleak, ftrace, crash, serial console.

Call a function: call func(arg) Print a 16‑bit variable: p/x (uint16_t)var Watch a variable: watch var (write) or rwatch var (read)

Set a breakpoint: b line_number or b function_name After a crash: analyze core dump, dmesg logs, or use the crash utility.

Using ftrace Mount the tracer: echo function > current_tracer → enable tracing: echo 1 > tracing_on → perform operations → stop tracing → view results with cat trace .

Three major components of a Linux operating system Kernel (process, memory, I/O management), root filesystem (user programs, configuration, libraries), bootloader (U‑Boot/GRUB, loads the kernel).

Designing a voice‑recognition project – key steps and considerations Steps: requirement analysis → technology selection (model, framework, platform) → data collection & preprocessing → model training & optimization → deployment & testing → iteration. Considerations: accuracy, real‑time performance, hardware resources, power consumption, data privacy, compatibility, stability.

English Questions

When will you graduate? I will graduate in June 202X.

When can you start after graduation? I can join the company immediately after graduation, or as early as mid‑June 202X if required.

There are many candidates – why should we give you the offer? First, I have solid professional knowledge (Linux kernel, embedded development) and rich project experience to quickly adapt to the job. Second, I have strong problem‑solving ability in technical issues like driver stability. Third, I am eager to learn and can bring long‑term value to the team.

Summary

Technical questions focus on Linux kernel, C fundamentals, hardware architecture, and debugging; answers must address principles and practical scenarios.

English questions should be concise and sincere, highlighting professional competence, problem‑solving skills, and learning potential.

The overall responses meet the depth required for a major tech company interview while remaining clear and accurate.