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 comprehensive tutorial walks you through installing VSCode and GDB on Linux, macOS, and Windows, configuring launch.json and tasks.json, mastering basic and advanced debugging techniques such as breakpoints, watchpoints, multithreaded and remote debugging, and troubleshooting common issues for C/C++ development.
This practical guide walks you through Linux kernel stack backtracing, covering GDB installation, core dump analysis, handling corrupted stacks, and advanced tracing techniques using ftrace and eBPF, with step‑by‑step commands, code examples, and troubleshooting tips to pinpoint the root cause of crashes.
This guide explains how to set hardware watchpoints in GDB to monitor specific memory addresses, demonstrates the technique with a simple C++ program that modifies a variable via a thread, and shows how GDB reports the exact location and values of the change.
This tutorial shows how C arrays are stored in the stack, global segment, and heap on a 64‑bit Linux system, using gcc compilation, gdb inspection, and concrete memory addresses to illustrate the exact layout of each region.
This comprehensive guide walks Linux kernel developers through KGDB fundamentals, installation, configuration, and practical debugging techniques—including serial and network setups, kernel patching, boot‑parameter tuning, and common pitfalls—enabling precise source‑level debugging of multi‑core kernel issues.
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 article provides a comprehensive guide to C++ debugging, covering the installation, core commands, and practical examples of GDB and Valgrind, along with advanced techniques, common pitfalls, and best‑practice recommendations to help developers efficiently locate and fix memory and segmentation errors.
This comprehensive guide explores GDB as a powerful debugging tool for memory analysis, covering installation, startup methods, core commands, breakpoint strategies, memory inspection, stack tracing, advanced features, remote debugging, and best practices for production environments, complete with practical code examples and step‑by‑step instructions.
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 comprehensive guide explains what GDB is, how to launch it, its core functions, essential debugging commands, multithreaded debugging strategies, and practical code examples, helping developers efficiently locate and fix bugs in C/C++ programs.
This guide explains why deadlocks occur in Linux C++ multithreaded programs, demonstrates how to reproduce them with sample code, and shows step‑by‑step how to use shell commands and GDB to identify and resolve the deadlock, ensuring stable and efficient execution.
This comprehensive tutorial walks C/C++ developers through setting up VSCode with GDB, configuring launch and tasks files, mastering basic and advanced debugging techniques—including breakpoints, watchpoints, multithreading, and remote debugging—while providing step‑by‑step commands and practical examples to boost debugging efficiency.
This comprehensive guide explains what Linux kernel Oops errors are, why they occur, and provides step‑by‑step debugging techniques—including environment setup, kernel configuration, printk usage, BUG macros, GDB, objdump, and memory‑checking tools—to help developers quickly locate and fix Oops issues in custom kernel modules.
This article explains how to troubleshoot and resolve the MySQL "Too many connections" error by using GDB to modify the max_connections parameter on a running MySQL 5.7 instance without restarting, including step‑by‑step commands, sysbench load testing, and two practical methods.
This article provides an in-depth tutorial on the GNU Debugger (GDB), covering its purpose, installation, basic and advanced commands, remote debugging, memory analysis, and practical tips for efficiently debugging C/C++ applications on Linux and Windows platforms.
This guide explains how to use GDB watchpoints to monitor specific memory addresses, detect unexpected modifications caused by bugs such as wild pointers or multithreaded writes, and pinpoint the exact code responsible, illustrated with a C++ example that spawns a thread modifying a variable.
This article explains how to identify and resolve multithreaded deadlocks in Linux C++ programs by using shell utilities such as ps and top for initial diagnosis, then attaching GDB to inspect thread stacks and pinpoint the exact lock contention causing the freeze.
This article explains how to set hardware and software watchpoints in GDB to monitor specific memory addresses, demonstrates the technique with a multithreaded C++ example, and describes the underlying CPU debug registers that enable precise detection of reads and writes.
This article explains what memory out-of-bounds errors are, why they are dangerous in Linux C programs, and provides step‑by‑step debugging methods using logs, GDB, Valgrind, core dumps, mprotect, static analysis, and preventive coding practices.
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.
This guide explains how GDB's dynamic printf feature lets you insert formatted print statements at any point in a running program without modifying source code or rebuilding, covering basic usage, command syntax, saving/loading breakpoints, and practical examples for efficient debugging.
This article explains how to locate OBServer crash logs, extract stack traces from observer.log, map memory addresses to source code using addr2line and gdb, identify the faulty function ObMPStmtExecute::copy_or_convert_str, and verify the issue through the OceanBase knowledge base, providing a systematic five‑step approach for rapid crash diagnosis.
This article provides a thorough introduction to the GNU Debugger (GDB), covering its core capabilities, startup methods, compilation requirements, a wide range of debugging techniques—including breakpoints, memory inspection, disassembly, reverse execution—and detailed guidance for multithreaded debugging on Linux systems.
This article walks through C++ object memory layout using concrete examples, covering basic data members, methods, private and static members, inheritance (with and without virtual functions), compiler optimizations, and address‑space layout randomization, all demonstrated with GDB inspections and code snippets.
An amusing yet instructive narrative shows how a C program that crashes with a segmentation fault can appear to work after inserting a printf, explaining that uninitialized local variables contain leftover stack data and that debugging tools like GDB reveal the true cause.
This guide shows how to compile a C program, use GDB to pretty‑print complex structures, enable indexed array printing, suppress startup banners, and automate these settings with a .gdbinit script for a clearer, more efficient debugging experience.
The article analyzes how private keys for workloads uploaded via Istio Ingress gateways can be exposed in plaintext, stored in memory, and extracted using tools like OpenSSL and GDB, and discusses mitigation strategies such as Intel SGX‑based protection.
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 explains how C++ implements runtime polymorphism through virtual function tables, analyzes the memory layout of single‑ and multiple‑inheritance classes using gcc and gdb, and clarifies the role of thunks and offset adjustments for correct virtual calls.
This article provides a comprehensive, step‑by‑step tutorial on setting up a local VSCode environment, configuring remote GDB, building and deploying the OceanBase observer, and performing source‑level debugging of the observer binary on Linux servers.
The article introduces Alibaba Cloud's Graph Database (GDB), detailing its product features, supported query languages, high‑performance and high‑availability architecture, parallel execution engine based on the Volcano model and Morsel‑driven parallelism, and showcases real‑world use cases such as DingTalk friend recommendation and Hema Fresh recommendation.
The article explains how to integrate Alibaba's Graph Database (GDB) with TinkerPop, compares it to other graph databases, details challenges such as string‑based script construction and missing transaction APIs, and demonstrates two DAO implementations and explicit transaction handling using GdbClient.
This guide shows how to set up an Ubuntu 16.04 virtual machine on Windows, install QEMU, fetch a modernized Linux 0.11 source tree, and use VSCode Remote‑SSH together with GDB to debug the historic kernel without rebuilding outdated toolchains.
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 demonstrates how to use MySQL error logs and gdb to trace a crash‑related bug, identify the affected function in the source code, compare version histories on GitHub, and confirm that the issue was fixed in MySQL 8.0.20.
This article documents the author's first experience debugging ClickHouse source code with GDB, explains the memory‑limit issue encountered when importing large MySQL tables, shows how to inspect stack frames, adjust the max_block_size setting, and verify the fix with a test insert.
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 tutorial walks through PHP 7.4’s internal zend_string and zval structures, explains their role in binary‑safe strings and copy‑on‑write memory management, and demonstrates step‑by‑step debugging with GDB to inspect variable states and reference counts.
This article demonstrates how to use a GDB script to monitor the exact moments MySQL checks for a killed DDL operation, identifies the internal InnoDB functions involved, and explains why kill may not take effect immediately.
This guide explains how to enable core dumps on Linux, examine the generated core file, and pinpoint the exact source line of a crash using dmesg, addr2line, gdb, and strace, with concrete command examples and code snippets.
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 investigates why MySQL 5.7 crash recovery can take hours on a development instance with thousands of tables, detailing stack‑frame analysis, GDB debugging, InnoDB source inspection of validation logic, performance testing, and methods to bypass the table‑space verification step.
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 recounts a real‑world incident where a simple JSON.parse() try‑catch block triggered a massive memory leak in a Node.js 12 application, explains how the V8 engine’s script_list retained orphaned script objects, and shows how tools like gdb, llnode and heapdump can be used to locate and fix the issue.
This guide walks you through Linux process fundamentals and equips you with practical commands—ps, strace, pstack, pstree, gdb, and /proc file inspection—to diagnose, trace, and debug running programs step by step.
This guide introduces ten fundamental Linux commands—file, ldd, ltrace, strace, hexdump, strings, readelf, objdump, nm, and gdb—explaining how each tool reveals a binary's type, dependencies, function calls, raw bytes, symbols, and runtime behavior for effective reverse‑engineering and debugging.
This guide introduces a collection of classic Linux debugging utilities—including file, ldd, ltrace, hexdump, strings, readelf, objdump, strace, nm, and gdb—explaining their purpose, typical usage, and providing concrete command‑line examples to help developers troubleshoot binaries and libraries efficiently.
This article explains how to create a simple breakpoint mechanism by using GDB for illustration and then reproducing the same behavior with the Linux ptrace system call, covering required knowledge about the RIP register, ELF symbols, and step‑by‑step implementation details.
This article explains MySQL thread fundamentals, distinguishes PID, LWP ID and Thread TID, shows a small C program to observe these IDs, demonstrates how to map MySQL threads to LWP IDs using system tools and SQL, and provides a step‑by‑step guide to set up a GDB‑based debugging environment on Linux.
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.
Learn how to efficiently debug grpc C++ addons on a server using gdb, covering preparation, launching Node.js under gdb, running tests, inspecting segmentation faults, setting breakpoints, and useful gdb commands to examine variables and call stacks.
A detailed investigation reveals that a futex bug in Linux kernel 2.6.32-504 causes Java programs on Hadoop and xtrabackup processes to hang, and the issue can be resolved by upgrading to a newer kernel version.
This article explains the concept of deadlocks, outlines the four necessary conditions, and provides a step‑by‑step guide using pstack and gdb on Linux to identify, analyze, and fix thread deadlocks, along with practical prevention techniques.
This guide walks through a systematic troubleshooting workflow for a Linux gateway that spikes to 891% CPU, using top to locate the offending process, inspecting thread usage, capturing stack traces with gstack, dumping core files, tracing system calls with strace, and analyzing the core dump in gdb to pinpoint the poll() call causing the load.
This article explains the concept of deadlocks, outlines the four necessary conditions, and demonstrates a step‑by‑step Linux workflow using pstack and gdb together with a sample pthread program to identify, analyze, and fix cross‑locking deadlock scenarios.
A MySQL 5.5 server on CentOS 6.7 hung because two internal mutexes (LOCK_index and LOCK_thread_count) deadlocked during concurrent purge binlog and reset master commands, and the issue was resolved by upgrading to a version where the bug is fixed.
This article provides a comprehensive tutorial on configuring KGDB on Linux, covering target and host machine preparation, kernel recompilation with debugging options, module installation, boot‑loader adjustments, and detailed remote‑gdb debugging procedures for both the kernel image and loadable modules.
This article explains what a deadlock is, outlines its four necessary conditions, provides a sample pthread program that deadlocks, and shows step‑by‑step how to use pstack and gdb on Linux to identify the stuck threads and understand the root cause.
This article walks through a real‑world remote debugging session where a high‑CPU issue in a gateway service was reproduced, analyzed with top, gstack, gcore, strace and gdb, and traced to a buffer overflow causing an infinite loop, then fixed.
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 explains how to set up and use Vim together with Ctags and Cscope, configure Doxygen for documentation generation, and employ GDB for debugging, providing Linux developers with a comprehensive toolkit for efficiently navigating and understanding large codebases.
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.
When a PHP process suddenly consumes near‑100% CPU, this guide shows how to locate the exact file, function and line causing the spike by inspecting Zend executor globals with GDB, using both manual commands and a ready‑made .gdbinit script.
This article describes how Baidu's QA team identified and resolved a memory‑leak issue in the Bigpipe Broker backend by analyzing a live process with pmap and GDB, extracting reference‑count problems, and fixing the atomic_add misuse that caused the leak.
