This guide explains what a Core Dump is, why it is essential for Linux crash analysis, how the kernel creates it, common signals that trigger it, typical causes of crashes, and step‑by‑step configuration and GDB techniques to capture and debug Core Dump files effectively.
This article explains what a Core Dump is, how Linux generates the ELF‑based snapshot when a program crashes, common causes such as memory errors or signal mishandling, essential system configurations, and step‑by‑step GDB techniques for analyzing and fixing the underlying bugs.
This comprehensive guide explains why debugging stripped binaries is crucial, walks through installing GDB, shows how to disassemble code, set address‑based breakpoints, inspect memory, handle signals, use advanced features like backtraces, conditional breakpoints, watchpoints, remote debugging, and even basic heap analysis for C/C++ programs.
This article investigates a recurring crash in Percona XtraDB Cluster 8.0.41 caused by the removal of the wsrep_group_commit_queue component, analyzes error logs and core dumps with GDB, reveals a circular deadlock among internal threads, and provides reproducible steps and debugging tips for DBAs.
This article explains Linux core dump generation, common causes such as null pointer dereference and array overflow, configuration steps, and demonstrates how to analyze core files using GDB with practical code examples and multi‑threaded case studies.
A detailed post‑mortem explains how a special request caused an Nginx‑based data‑collection gateway to spike memory usage, trigger OOM‑killer termination, and crash, and walks through the debugging steps, core‑dump analysis, root‑cause discovery, and the eventual fix.
An Nginx‑based data collection gateway began crashing with OOM kills, prompting a detailed investigation that uncovered memory spikes caused by aggressive batch processing, oversized protobuf payloads, and insufficient memory‑pool management, leading to a custom core‑dump solution and several mitigation strategies.
A special request caused memory usage to spike dramatically, leading to an OOM‑killer termination of an Nginx‑based data‑collection gateway, and the investigation uncovered a compression‑bomb style payload and coarse memory‑pool allocation as the root causes.
This article details a MySQL 8.0.35 crash caused by an InnoDB assertion that a VARCHAR length exceeds 65,535 bytes, explains the error‑log and core‑dump analysis, shows how to reproduce the bug, and notes its resolution in MySQL 8.0.35.
This article walks through the anatomy of a Java Virtual Machine crash, explains how to read the generated hs_err_pid log and core dump, and provides practical debugging steps—including code examples, signal analysis, register context, and GDB commands—to pinpoint and resolve the root cause.
Learn step‑by‑step how to capture a Linux core dump with kdump, install the crash utility and debuginfo packages, and use commands like sys, bt, ps, files, and sym to trace the root cause of kernel panics, illustrated with a real‑world case study.
This article introduces the OpenCoreAnalysisKit project, an open‑source suite for offline analysis of Android Core memory files across multiple architectures, detailing its components, build requirements, usage guides for kernel‑ and user‑mode debugging, and various command‑line tools and code snippets for comprehensive reverse‑engineering and memory‑analysis workflows.
This article introduces the art‑parser tool for offline Android core‑dump analysis, detailing its origin, project structure, core‑file acquisition methods, page‑repair techniques, object inspection commands, and the challenges of open‑sourcing the utility for mobile developers.
This guide explains what core dump files are, how to configure foreground and background processes to generate them on embedded Linux, and provides step‑by‑step commands and sample code for enabling core dumps and analyzing them with arm‑linux‑gnueabihf‑gdb.
This article investigates a Node.js V8 heap snapshot crash, tracing the segmentation fault to a faulty context extension slot, detailing the assembly analysis, reproducing the issue, and presenting a backported fix for Node‑v14.
This guide explains essential Node.js diagnostic techniques—including generating core dumps, capturing heap snapshots, profiling CPU usage, leveraging trace events, and using Diagnostic Reports—providing step‑by‑step commands, flag configurations, and example code to help developers troubleshoot crashes and performance issues in production environments.
This article explains what program core dumps are, how to interpret core‑dump files, and provides detailed GDB debugging techniques—including register inspection, stack frame analysis, variable printing, memory dumping, and handling optimized code—to locate and resolve the root causes of crashes.
The article explains how to analyze core‑dump files with GDB by examining the function call stack, key registers, and memory contents, classifying crash causes, using GDB commands to inspect variables and addresses, reconstructing corrupted stacks, handling optimized‑away data and vtable errors, and following a systematic debugging workflow.
This guide explains how to enable core dumps on Linux, examine the generated core file, and pinpoint the exact source line that caused a crash using dmesg, addr2line, gdb, and strace, with step‑by‑step commands and example code.
This article explains how to investigate a MySQL crash when core dumps are disabled by extracting the crash address from the error log, obtaining the matching binary, using GDB to map the address to source code, and decoding encoded function signatures to pinpoint the underlying bug.
This article explains core dumps, their history, generation, impact on services, and provides a detailed Linux PHP case study with step‑by‑step debugging using strace, gdb, and ulimit, culminating in root‑cause analysis and remediation recommendations.
This article presents a comprehensive analysis of real-world C/C++ core dump cases, categorizing common causes such as stack integrity, memory leaks, multithreading issues, and misuse of system libraries, and offers practical debugging strategies and code examples to help developers prevent and resolve such crashes.
This article explains why C/C++ applications managed by Supervisor on CentOS 6.5 fail to generate core dump files, analyzes the environment differences that set the core file size limit to zero, and provides both temporary and permanent fixes by adjusting ulimit settings and modifying Supervisor's options.py.
This guide explains what core dumps are, how to enable their generation on Linux, where the core file is created, and step‑by‑step usage of GDB to pinpoint the exact location of a segmentation fault in C programs.
This article details a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx/OpenSSL stack, covering debugging strategies, custom traffic‑control testing, distributed load generation, use of valgrind and AddressSanitizer, performance profiling with perf, and the mindset needed to solve such high‑concurrency bugs.
The article describes a real‑world investigation of extremely rare core‑dump bugs and memory‑leak issues in a heavily modified Nginx+OpenSSL stack under high‑concurrency, detailing the debugging workflow, custom stress‑test tools, use of gdb, valgrind, AddressSanitizer, perf, flame graphs and performance‑tuning lessons.
This article walks through a real‑world investigation of intermittent core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack under extreme QPS, detailing debugging strategies, custom load‑testing tools, and performance‑profiling techniques that helped pinpoint and fix the root causes.
This article shares a detailed post‑mortem of debugging extremely rare core dumps and memory leaks in a high‑concurrency Nginx HTTPS implementation, covering root‑cause analysis, custom stress‑test frameworks, and the use of tools such as gdb, valgrind, AddressSanitizer, perf and flame graphs to locate and fix the issues.
The article describes a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack, detailing the debugging workflow, custom high‑concurrency test harness, use of tools such as GDB, perf, Valgrind, AddressSanitizer, and the performance‑hotspot analysis that ultimately resolved the issues.
This article categorizes typical reasons why C/C++ programs generate core dumps, such as unreasonable program design, misuse of system libraries, memory leaks, type errors, thread ID handling, infinite loops, and improper initialization or cleanup, and provides illustrative case analyses for each scenario.
This article classifies the typical reasons why C/C++ programs generate core dumps, explains how to use gdb and other techniques to locate the faults, and provides concrete case studies covering error handling, multithreading issues, and third‑party library pitfalls.
This guide explains practical techniques for diagnosing Node.js production issues, covering request‑latency analysis, CPU profiling with perf and FlameGraph, crash investigation via Core Dumps and mdb_v8, and memory‑leak detection using gcore and mdb_v8 diff tools.
