Segmentation Fault

A synchronous protection fault reported when an executing thread references a virtual address that is unmapped or uses a mapped address contrary to its access permissions.

Version

v2 · 2026-09-06 · History

Domain-specific #

2740

Origin domain

computer science

Subdomain

operating systems and systems programming

Aliases

Segfault, Segmentation violation

Core Idea

A segmentation fault is a synchronous protection failure that occurs when an executing thread attempts a memory reference the system's virtual-memory rules do not permit. The target address may have no mapping in the process address space, or a mapping may exist but forbid the attempted operation—for example, writing a read-only page or executing a non-executable page. Hardware detects the faulting access, transfers control to privileged fault-handling code, and the operating system converts an unresolvable user-mode violation into a process-visible event.

Scope of Application

The abstraction belongs to operating systems, computer architecture, systems programming, native-code debugging, runtime implementation, and software security. Kernel developers use it to classify the terminal branch of virtual-memory fault handling. Debuggers use the synchronous event to stop at the faulting instruction, inspect registers, mappings, stack state, and the fault address, and recover a causal chain.

Systems programmers use the category to separate root cause from manifestation. A write to a read-only mapping points toward permission misuse; an access just beyond a guard page may indicate stack overflow; a fault at a small address often suggests a null base plus field offset; a changing address across runs can suggest lifetime corruption.

Clarity

A segmentation-fault report should answer:

1. Which platform, architecture, process, and thread produced the event? 2. What signal or exception code was reported? 3. What instruction faulted and what operation did it attempt? 4. What virtual address was referenced? 5. Was the address unmapped, or did a mapping deny read, write, or execute access? 6. Could the underlying page fault have been resolved, and why was it not?

Manages Complexity

The concept compresses many low-level translation and protection states into a stable diagnostic branch: the instruction attempted an address operation; hardware checked a mapping and permissions; the kernel could not legitimize the access; the process received a synchronous protection event. This is more informative than undifferentiated “crash” while remaining independent of the many possible source defects.

Abstract Reasoning

Let an access request be a=(v,o,m): virtual address v, operation o, and current machine/process context m. Translation and protection define a predicate P(a) that is true only if a present mapping covers v and grants o in context m. If P(a) is true, the access proceeds. If false, hardware traps.

Knowledge Transfer

Within computing, the mechanism transfers across Unix-like signals, Windows structured exceptions, debugger stops, emulators, language runtimes, and sandboxed execution. The names and metadata differ, but the roles remain: attempted virtual-memory operation, mapping/permission predicate, hardware trap, kernel classification, and process disposition.

It transfers from debugging to security analysis. A reproducible crash input supplies a concrete failed access; exploitability analysis then asks whether the attacker controls the address, value, operation, or control flow and whether mitigations constrain them. The segmentation fault is evidence at the enforcement boundary, not the security conclusion itself.

Relationships to Other Abstractions

Current abstraction Segmentation Fault Domain-specific

Parents (1) — more general patterns this builds on

• Segmentation Fault presupposes Access Control Prime

  Access Control is the minimal prospective parent by composition.

Hierarchy paths (3) — routes to 3 parentless roots

• Segmentation Fault → Access Control → Authority

Show alternative paths (2)

Neighborhood in Abstraction Space

Segmentation Fault sits in a sparse region of the domain-specific corpus (92^nd percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Unclustered & Miscellaneous (1565 abstractions)

Nearest neighbors

• Far Pointer — 0.79
• Virtual memory — 0.78
• Controlled Computer Shutdown — 0.78
• Router Alert Label — 0.77
• Static Variable — 0.77

Computed from structural-signature embeddings · 2026-09-08