This article provides a comprehensive overview of the Linux kernel's task_struct structure, detailing its key fields, process and thread identification, state definitions, memory and credential handling, kernel stack layout, and includes a practical kernel module example for iterating over all processes.
The author, with over two decades of development experience, argues that many learners treat Linux kernel code as a rote exercise instead of mapping real‑world scheduling problems to code, and outlines essential questions about task_struct management, scheduling policies, CPU placement, fairness, and universal scheduler design.
The author, with over two decades of development experience, argues that learning the Linux kernel requires understanding real-world scheduling problems rather than merely copying kernel code, and outlines key questions about task_struct management, priority, preemption, CPU placement, fairness, and universal scheduler design.
This article provides a comprehensive analysis of the Linux kernel's task_struct data structure, detailing its members such as task IDs, parent‑child relationships, state flags, credentials, scheduling information, signal handling, memory and file management, kernel stack layout, and its role in process creation via system calls like fork.
An in‑depth guide explains what a program and a process are, details the Linux task_struct fields, describes process states, creation functions like fork, vfork, clone, kthread_create, the do_fork core, copy‑on‑write, termination methods, and the roles of zombie, orphan, and init processes.
This article provides a comprehensive overview of Linux's task_struct, explaining how the kernel represents and manages processes and threads, detailing its internal fields, state handling, scheduling, credentials, memory layout, and special mechanisms such as hung‑task detection.
This article introduces the core Linux kernel data structures involved in process management and scheduling—task_struct, sched_entity, rq, and sched_avg—explaining their key fields, relationships, and how they enable the kernel to track process state, timing, memory, and load‑balancing decisions.
This article provides a deep, step‑by‑step exploration of Linux process creation, using Nginx’s worker forking as a concrete example, and walks through the task_struct layout, process states, PID management, address‑space handling, file system structures, namespaces, and the internal logic of the fork system call.
This article explains how Linux implements processes and threads, showing that both are represented by the same task_struct structure, detailing thread creation via pthread_create and clone, and comparing the kernel‑level steps—including flag handling, copy_process, and resource sharing—that differentiate threads from full processes.
This article explains why Linux treats every thread as a process, describes the core kernel data structures task_struct, thread_info and the kernel stack, details the clone‑based creation path, and clarifies virtual address spaces, page tables, and the differences between user processes and kernel threads.
This article dissects the Linux kernel’s fork implementation, explaining why the child receives a return value of 0, how parent and child share code execution, the internal steps of sys_fork, kernel_clone, copy_process, thread handling, scheduling initialization, and the final insertion of the new task into the run‑queue.
Learn how Linux selects the next process for CPU execution by exploring key scheduler structures such as task_struct, sched_class, runqueue, the various scheduling policies (CFS, RT, Deadline, etc.), the scheduling flow, and the low‑level context_switch mechanism that swaps address spaces and registers.
This article explains the true nature of a file descriptor (fd) in Linux, tracing how the kernel represents open files through task_struct, files_struct, fdtable, and inode structures, and shows how these layers interact with system calls like open, read, write, dup, and fork.
This article explains how a user‑level program becomes a Linux process, how the kernel views it through ELF loading, the role of the task_struct data structure, its key fields, task state transitions, and how the kernel stores the descriptor in memory.
This article explains the POSIX requirements for signals in multithreaded Linux programs, details the kernel structures such as task_struct and signal_struct that enable shared signal handling, and walks through the key code paths—including copy_signal, copy_sighand, __send_signal, tkill/tgkill, and group exit—that manage signal delivery and thread‑group termination.
This article explains how Linux implements POSIX signal handling in multithreaded applications, detailing the relationship between signals and threads, the kernel structures like task_struct, signal_struct, and how signals are delivered, blocked, and cause group exits within a thread group.
