Tagged articles
core dump
33 articles · Page 1 of 1
This guide explains how to enable core dumps, preserve debug symbols, and use GDB to analyze C++ memory crashes like null pointer dereferences, heap overflows, and stack overflows, with practical code examples and step-by-step commands.
C++ debuggingStack Overflowcore dump
0 likes · 15 min read

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.
ELFSignal Handlingcore dump
0 likes · 37 min read

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.
System Configurationcore dumpgdb
0 likes · 35 min read

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.
c-programmingcore dumpdebugging
0 likes · 40 min read

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.
Group CommitMySQLPercona XtraDB Cluster
0 likes · 27 min read

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.
LinuxSystem Programmingcore dump
0 likes · 24 min read

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.
Nginxcore dumpdata batching
0 likes · 15 min read


ITPUBNov 1, 2024 · Backend Development
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.
Backend DebuggingMemory LeakOOM
0 likes · 16 min read

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.
Backend Debuggingcompression bombcore dump
0 likes · 14 min read

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.
Database DebuggingInnoDBMySQL
0 likes · 21 min read

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.
JVMJavaLinux
0 likes · 37 min read

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.
KDUMPLinuxcore dump
0 likes · 14 min read

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.
Androidcore dumpdebugging
0 likes · 20 min read

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.
AndroidNative Crashart-parser
0 likes · 18 min read

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.
Embedded Linuxcore dumpdaemon
0 likes · 9 min read

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.
Node.jsV8core dump
0 likes · 15 min read

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.
CPU profilingDiagnostic ReportsHeap Dump
0 likes · 11 min read

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.
C++LinuxRegisters
0 likes · 16 min read

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.
LinuxRegistersc++
0 likes · 17 min read

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.
Linuxaddr2linecore dump
0 likes · 7 min read

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.
BackendMySQLcore dump
0 likes · 3 min read

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.
LinuxPHPcore dump
0 likes · 31 min read

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.
Multithreadingcore dumpmemory issues
0 likes · 17 min read

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.
LinuxResource Limitscore dump
0 likes · 6 min read


ITPUBNov 4, 2016 · Fundamentals
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.
core dumpgdblinux debugging
0 likes · 4 min read

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.
Nginxaddresssanitizercore dump
0 likes · 21 min read

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.
asancore dumphigh concurrency
0 likes · 20 min read


ITPUBJun 21, 2016 · Backend Development
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.
Memory LeakNginxOpenSSL
0 likes · 23 min read


21CTOJun 18, 2016 · Backend Development
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.
asancore dumpdebugging
0 likes · 21 min read

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.
Memory LeakNginxOpenSSL
0 likes · 19 min read

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.
C++Linuxcore dump
0 likes · 6 min read

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.
C++Multithreadingcore dump
0 likes · 11 min read


Aotu LabFeb 25, 2016 · Backend Development
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.
CPU FlameGraphMemory LeakNode.js
0 likes · 11 min read
