0 views collected around this technical thread.
This article explains how Linux processes are created, managed, and replaced using the fork, wait (including waitpid), and exec system calls, covering their prototypes, return values, copy‑on‑write optimization, and practical C code examples that demonstrate their coordinated use in real‑world scenarios.
This article provides a comprehensive overview of Linux process management, covering fundamental concepts such as tasks and states, the internal task_struct representation, process creation via fork/vfork/clone, execution with execve, lifecycle transitions, scheduling policies, copy‑on‑write optimization, resource limits, and practical tools for monitoring and controlling processes.
Researchers from Truffle Security revealed that GitHub's delete function often fails to truly remove data, exposing a new Cross Fork Object Reference (CFOR) vulnerability that allows anyone with a commit hash to access deleted or private repository data, posing serious security risks.
This article explains Redis's three persistence options—Append‑Only File (AOF), Redis DataBase snapshots (RDB), and the hybrid mode—detailing their inner workings, configuration strategies, performance trade‑offs, and how to choose the most reliable solution for a given workload.
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.
The article analyzes a recurring one‑second pause in a Redis 4.0 master‑slave setup, identifies the periodic BGSAVE fork operation as the root cause through metrics like latest_fork_usec, and presents mitigation strategies such as memory limits, activedefrag, and migration to a lower‑RSS instance.
This article explains the copy‑on‑write mechanism in Linux by examining page‑table structures, the fork process, and the page‑fault handling code in Linux 0.11, illustrating how the kernel uses read‑only page mappings and page‑fault interrupts to lazily duplicate memory pages.
This guide explains why GitHub lacks an unfork feature, outlines the problems caused by forked repositories, and provides a step‑by‑step method using GitHub Support (with optional command‑line cloning) to detach a fork while preserving commit history and fork records.
This article analyzes why Linux reports "fork: cannot allocate memory" when the real issue is an excessive number of threads or PID allocation failures, explains the kernel's do_fork and alloc_pid implementations, and offers guidance for diagnosing and fixing such misleading ENOMEM errors.
The article explains why Linux reports "fork: cannot allocate memory" when the real issue is PID allocation failure caused by excessive threads, analyzes the kernel's do_fork and alloc_pid implementations, and shows that newer kernels still return ENOMEM for non‑memory errors.
This article explains PHP's pcntl_fork() function, how it creates child processes on Linux, the return values in parent and child, code examples demonstrating variable copying and process multiplication, and clarifies why a loop with three forks results in seven child processes.
This article explains Redis's two persistence mechanisms—RDB snapshot files and AOF append‑only logs—including their operation, configuration commands, advantages, disadvantages, recovery procedures, and performance recommendations for choosing between them.
The article analyzes a rare blocking issue in a Python Agent where a subprocess created via subprocess.Popen hangs due to an unclosed pipe inherited by a forked child process, demonstrates debugging steps using thread frames and lsof, and provides a reproducible example and mitigation recommendations.
This article explains Bitcoin's transaction‑packaging process, the step‑by‑step mining workflow, the causes of blockchain forks—including both natural and intentional splits—and the criteria used to select the best chain as the main chain, providing a comprehensive technical overview.
This article explains the detailed process of Bitcoin transaction packaging, the steps miners follow to create new blocks, and how both natural and intentional blockchain forks arise, including the criteria for selecting the best chain and the differences between hard and soft forks.
This article provides a clear, beginner‑friendly explanation of blockchain technology, covering its nature as a decentralized database, block structure, hashing, mining difficulty, dynamic adjustment, forks, and practical limitations, while illustrating concepts with diagrams and real‑world examples.
This article explains the differences between code, programs, and processes in Linux, demonstrates how to compile and run a simple program, explores parent‑child relationships, the role of the init process, the process lifecycle, and the copy‑on‑write mechanism.