From c20b40f353b6659a13b11d93ea93dd3a6450a2e8 Mon Sep 17 00:00:00 2001
From: AI Dev <ai@openipc.org>
Date: Fri, 9 Oct 2026 01:31:22 +0000
Subject: [PATCH 1/3] Club: majestic's own crashes, symbolized against its CI's
 debuginfo

majestic now leaves /etc/crash/majestic.dump when it dies of a fatal
signal: the registers at the fault, a slice of the stack, the memory map
and each module's build-id. A bundle carrying one is filed as class
'user', kind 'signal' (migration 032), maintainers' only: never on
/crashes, and its sender is told the signal, not where.

It arrives under a provisional signature (module and offset), with its
dump in crash_dumps. The firmware role's new symbolize package, woken by
NOTIFY crash_symbolize, writes an ELF core from the dump and unwinds it
with gdb-multiarch against the executable and debuginfo majestic's CI
publishes by build-id. Library frames are named from the firmware build's
own rootfs, unsquashed from its release tarball. Where gdb stops (most
camera libraries have no unwind tables) a scan of the stack for return
addresses that follow a call finds the probable callers. The event is
then refiled under its backtrace's signature and the dump, being
majestic's memory, is deleted.

Tested against dumps of a stand-in program that faulted on a gk7205v300
and on x86_64: in its own code, in a stripped library and in libc.
The service image and CI gain gdb-multiarch and squashfs-tools.
---
 .github/workflows/build.yml                   |   8 +-
 CLAUDE.md                                     |  15 +
 data/locales/boards.en.yml                    |   5 +
 data/locales/boards.ru.yml                    |   5 +
 .../site/src/components/club/CrashTriage.tsx  |  45 +-
 .../site/src/components/club/Crashes.test.tsx |  15 +
 .../apps/site/src/components/club/Crashes.tsx |   9 +-
 frontend/apps/site/src/i18n/boards.en.json    |   5 +
 frontend/apps/site/src/i18n/boards.ru.json    |   5 +
 frontend/apps/site/src/lib/crashes.ts         |  29 +-
 service/Dockerfile                            |   7 +-
 service/cmd/openipc/main.go                   |  10 +
 service/internal/config/config.go             |   4 +
 service/internal/crashes/CRASH.md             |  21 +
 service/internal/crashes/api.go               |  29 +-
 service/internal/crashes/dump.go              | 442 ++++++++++++++++++
 service/internal/crashes/dump_test.go         | 382 +++++++++++++++
 service/internal/crashes/parse.go             |  98 +++-
 service/internal/crashes/store.go             |  55 ++-
 service/internal/crashes/symbolize/core.go    | 239 ++++++++++
 service/internal/crashes/symbolize/frames.py  |  56 +++
 service/internal/crashes/symbolize/gdb.go     | 165 +++++++
 .../internal/crashes/symbolize/rootfs_test.go | 114 +++++
 service/internal/crashes/symbolize/scan.go    | 133 ++++++
 service/internal/crashes/symbolize/sources.go | 339 ++++++++++++++
 .../internal/crashes/symbolize/symbolize.go   | 312 +++++++++++++
 .../crashes/symbolize/symbolize_test.go       | 364 +++++++++++++++
 service/internal/crashes/symbolize/worker.go  | 161 +++++++
 service/internal/crashes/symbolized.go        | 238 ++++++++++
 .../crashes/testdata/dump/arm-lib.dump        | Bin 0 -> 2199 bytes
 .../crashes/testdata/dump/arm-libc.dump       | Bin 0 -> 2199 bytes
 .../crashes/testdata/dump/arm-own.dump        | Bin 0 -> 2191 bytes
 .../crashes/testdata/dump/arm-sent.dump       | Bin 0 -> 2343 bytes
 .../crashes/testdata/dump/arm/libtoy.so       | Bin 0 -> 5280 bytes
 .../internal/crashes/testdata/dump/arm/toy    | Bin 0 -> 9848 bytes
 .../crashes/testdata/dump/arm/toy.debug       | Bin 0 -> 16828 bytes
 service/internal/crashes/testdata/dump/gen.sh |  38 ++
 .../internal/crashes/testdata/dump/libtoy.c   |   9 +
 service/internal/crashes/testdata/dump/toy.c  | 208 +++++++++
 .../crashes/testdata/dump/x86_64-lib.dump     | Bin 0 -> 12000 bytes
 .../crashes/testdata/dump/x86_64-libc.dump    | Bin 0 -> 5816 bytes
 .../crashes/testdata/dump/x86_64-own.dump     | Bin 0 -> 5752 bytes
 .../crashes/testdata/dump/x86_64-sent.dump    | Bin 0 -> 6874 bytes
 .../crashes/testdata/dump/x86_64/libtoy.so    | Bin 0 -> 14160 bytes
 .../internal/crashes/testdata/dump/x86_64/toy | Bin 0 -> 14768 bytes
 .../crashes/testdata/dump/x86_64/toy.debug    | Bin 0 -> 27152 bytes
 .../migrations/032_crash_symbolizations.sql   |  47 ++
 47 files changed, 3559 insertions(+), 53 deletions(-)
 create mode 100644 service/internal/crashes/dump.go
 create mode 100644 service/internal/crashes/dump_test.go
 create mode 100644 service/internal/crashes/symbolize/core.go
 create mode 100644 service/internal/crashes/symbolize/frames.py
 create mode 100644 service/internal/crashes/symbolize/gdb.go
 create mode 100644 service/internal/crashes/symbolize/rootfs_test.go
 create mode 100644 service/internal/crashes/symbolize/scan.go
 create mode 100644 service/internal/crashes/symbolize/sources.go
 create mode 100644 service/internal/crashes/symbolize/symbolize.go
 create mode 100644 service/internal/crashes/symbolize/symbolize_test.go
 create mode 100644 service/internal/crashes/symbolize/worker.go
 create mode 100644 service/internal/crashes/symbolized.go
 create mode 100644 service/internal/crashes/testdata/dump/arm-lib.dump
 create mode 100644 service/internal/crashes/testdata/dump/arm-libc.dump
 create mode 100644 service/internal/crashes/testdata/dump/arm-own.dump
 create mode 100644 service/internal/crashes/testdata/dump/arm-sent.dump
 create mode 100755 service/internal/crashes/testdata/dump/arm/libtoy.so
 create mode 100755 service/internal/crashes/testdata/dump/arm/toy
 create mode 100755 service/internal/crashes/testdata/dump/arm/toy.debug
 create mode 100755 service/internal/crashes/testdata/dump/gen.sh
 create mode 100644 service/internal/crashes/testdata/dump/libtoy.c
 create mode 100644 service/internal/crashes/testdata/dump/toy.c
 create mode 100644 service/internal/crashes/testdata/dump/x86_64-lib.dump
 create mode 100644 service/internal/crashes/testdata/dump/x86_64-libc.dump
 create mode 100644 service/internal/crashes/testdata/dump/x86_64-own.dump
 create mode 100644 service/internal/crashes/testdata/dump/x86_64-sent.dump
 create mode 100755 service/internal/crashes/testdata/dump/x86_64/libtoy.so
 create mode 100755 service/internal/crashes/testdata/dump/x86_64/toy
 create mode 100755 service/internal/crashes/testdata/dump/x86_64/toy.debug
 create mode 100644 service/internal/db/migrations/032_crash_symbolizations.sql

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index b4088fe8..97fece42 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -41,11 +41,13 @@ jobs:
       - uses: actions/checkout@v4
 
       # The keyframe and variants tests decode with ffmpeg, as the service does
-      # in its image. They fail rather than skip when CI is set and it is missing.
-      - name: Install ffmpeg
+      # in its image; the crash symbolizer's unwind with gdb-multiarch and
+      # unpack firmware with unsquashfs. They fail rather than skip when CI is
+      # set and one is missing.
+      - name: Install ffmpeg, gdb-multiarch and squashfs-tools
         run: |
           sudo apt-get update -qq
-          sudo apt-get install -y --no-install-recommends ffmpeg
+          sudo apt-get install -y --no-install-recommends ffmpeg gdb-multiarch squashfs-tools
 
       # --- the Go service (#287) ---------------------------------------------
       - uses: actions/setup-go@v5
diff --git a/CLAUDE.md b/CLAUDE.md
index f328b0ec..b3f34e8f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -234,6 +234,21 @@ restores the image but never the schema, so keep migrations additive.
   merges: `bogus` takes back what a bug and the signatures merged into it
   paid, and undoing it lets the settlement pay again. A crash with a MAC is
   the camera's linked owner's, whoever sent it.
+  **majestic's own crashes** come the same way, as `/etc/crash/majestic.dump`
+  (class `user`, kind `signal`, migration 032), and are the maintainers'
+  only: never on `/crashes`, and a member is shown the signal, not where.
+  One arrives filed under a provisional signature (module and offset of the
+  faulting instruction) with its dump in `crash_dumps`; the firmware role's
+  `internal/crashes/symbolize` (woken by `NOTIFY crash_symbolize`) builds an
+  ELF core from it and unwinds it with `gdb-multiarch` against the
+  executable and debuginfo majestic's CI publishes by build-id
+  (`MAJESTIC_SYMBOLS_BASE`), naming library frames from the firmware build's
+  own rootfs (`unsquashfs` of its release tarball), and scanning the stack
+  for probable callers where gdb stops. Then the event is refiled under its
+  backtrace's signature (the crashes package's one change to an event) and
+  the dump -- majestic's memory -- is deleted. Retried for days when the
+  debuginfo is not there, then given up on. Cache under
+  `RELEASE_CACHE_ROOT/symbols`, swept after 30 days unused.
 - `internal/tools`, `internal/nfsro` — **ipctool for stock firmware**, which
   has no curl and no TLS. ipctool's release job pushes each build to
   `PUT /api/v1/tools/{name}` (OIDC, `internal/tools/PUSH.md`); nginx serves
diff --git a/data/locales/boards.en.yml b/data/locales/boards.en.yml
index 8ac9ea28..794ae2b6 100644
--- a/data/locales/boards.en.yml
+++ b/data/locales/boards.en.yml
@@ -632,6 +632,7 @@ en:
       kind_oops: 'Oops'
       kind_bug: 'BUG'
       kind_warning: 'Warning'
+      kind_signal: 'majestic crashed'
       in_irq: 'in an interrupt'
       status_open: 'Not yet looked at'
       status_confirmed: 'Confirmed'
@@ -691,3 +692,7 @@ en:
       d_cmdline: 'Command line'
       d_anomalies: 'Before it'
       d_before: 'Warnings'
+      d_backtrace: 'Backtrace'
+      sym_pending: 'Waiting for its backtrace (tried {n} times)'
+      sym_failed: 'No backtrace'
+      probable: 'probable'
diff --git a/data/locales/boards.ru.yml b/data/locales/boards.ru.yml
index e9d6fc33..5da4d7c0 100644
--- a/data/locales/boards.ru.yml
+++ b/data/locales/boards.ru.yml
@@ -673,6 +673,7 @@ ru:
       kind_oops: 'Oops'
       kind_bug: 'BUG'
       kind_warning: 'Предупреждение'
+      kind_signal: 'Сбой majestic'
       in_irq: 'в прерывании'
       status_open: 'Ещё не разобрано'
       status_confirmed: 'Подтверждено'
@@ -736,3 +737,7 @@ ru:
       d_cmdline: 'Командная строка'
       d_anomalies: 'Перед этим'
       d_before: 'Предупреждения'
+      d_backtrace: 'Стек вызовов'
+      sym_pending: 'Ждёт стека вызовов (попыток: {n})'
+      sym_failed: 'Стека вызовов нет'
+      probable: 'вероятно'
diff --git a/frontend/apps/site/src/components/club/CrashTriage.tsx b/frontend/apps/site/src/components/club/CrashTriage.tsx
index aa444a75..6eb9ed3e 100644
--- a/frontend/apps/site/src/components/club/CrashTriage.tsx
+++ b/frontend/apps/site/src/components/club/CrashTriage.tsx
@@ -1,8 +1,9 @@
 /**
- * /club/crashes: the maintainers' triage of kernel crashes. Every signature,
- * worst first; one opens to what it takes to reproduce it -- the chips,
- * sensors and builds it was seen on, the firmware builds whose time matches
- * its kernel, and each crash's redacted log, warnings and lead-up.
+ * /club/crashes: the maintainers' triage of kernel crashes and majestic's.
+ * Every signature, worst first; one opens to what it takes to reproduce it --
+ * the chips, sensors and builds it was seen on, the firmware builds whose time
+ * matches its kernel, and each crash's redacted log, warnings and lead-up, or
+ * for majestic's, its backtrace from the debuginfo of its build.
  *
  * Confirming a bug pays its first reporter, fixing it pays them again;
  * bogus takes back every star it paid. The same is `openipc crashes status`.
@@ -12,7 +13,8 @@ import { useBoardsTranslations, type BoardsT } from '../../lib/boards-i18n';
 import { pathFor, type Locale } from '../../lib/i18n';
 import { ClubError, fetchMe } from '../../lib/club';
 import {
-  decideCrash, fetchCrashDetail, fetchTriage, frame, KIND_TONE, STATUS_TONE, type Combo, type Detail, type Signature, type Status,
+  decideCrash, fetchCrashDetail, fetchTriage, frame, frameAt, KIND_TONE, STATUS_TONE, type Combo, type Detail, type Frame, type Signature,
+  type Status,
 } from '../../lib/crashes';
 
 type Load = { state: 'loading' } | { state: 'ok'; list: Signature[] } | { state: 'forbidden' } | { state: 'error' };
@@ -81,9 +83,7 @@ function Open({ g, t, onDone }: { g: Signature; t: BoardsT; onDone: () => void }
   const field = 'min-w-0 rounded-md border border-hairline px-2 py-1 text-sm';
   return (
     <div class="grid gap-3 border-t border-hairline pt-3 text-[13px]">
-      <pre class="m-0 overflow-x-auto rounded-md bg-surface-alt p-2.5 font-mono text-[12px] leading-relaxed">
-        {g.frames.slice(0, 10).map((f, i) => `${i === 0 ? '' : '← '}${frame(f)}`).join('\n')}
-      </pre>
+      <Backtrace frames={g.frames.slice(0, 10)} t={t} />
       <form class="grid gap-2 sm:grid-cols-2" onSubmit={save}>
         <label class="grid gap-1">{t('crashes.f_status')}
           <select class={field} value={status} onChange={(e) => setStatus((e.target as HTMLSelectElement).value as Status)}>
@@ -125,6 +125,15 @@ function Open({ g, t, onDone }: { g: Signature; t: BoardsT; onDone: () => void }
   );
 }
 
+/** A backtrace, innermost first; the scan's probable callers marked so. */
+function Backtrace({ frames, t }: { frames: Frame[]; t: BoardsT }) {
+  return (
+    <pre class="m-0 overflow-x-auto rounded-md bg-surface-alt p-2.5 font-mono text-[12px] leading-relaxed">
+      {frames.map((f, i) => `${i === 0 ? '' : '← '}${frameAt(f)}${f.probable ? `  (${t('crashes.probable')})` : ''}`).join('\n')}
+    </pre>
+  );
+}
+
 function Crash({ d, t }: { d: Detail; t: BoardsT }) {
   const anomalies = Object.entries(d.anomalies ?? {});
   return (
@@ -136,19 +145,35 @@ function Crash({ d, t }: { d: Detail; t: BoardsT }) {
       <dl class="m-0 mt-2 grid gap-x-3 gap-y-0.5 sm:grid-cols-[max-content_1fr]">
         <dt class="text-body-secondary">{t('crashes.d_hardware')}</dt><dd class="m-0 font-mono">{[d.soc, d.sensor, d.board, d.machine].filter(Boolean).join(' · ')}</dd>
         <dt class="text-body-secondary">{t('crashes.d_firmware')}</dt><dd class="m-0 font-mono">{[d.firmware, d.majestic && `majestic ${d.majestic}`].filter(Boolean).join(' · ') || '?'}</dd>
-        <dt class="text-body-secondary">{t('crashes.d_kernel')}</dt><dd class="m-0 font-mono">{d.kernel} {d.kernel_build}</dd>
+        {d.kernel && <><dt class="text-body-secondary">{t('crashes.d_kernel')}</dt><dd class="m-0 font-mono">{d.kernel} {d.kernel_build}</dd></>}
         {d.builds && d.builds.length > 0 && (
           <><dt class="text-body-secondary">{t('crashes.d_builds')}</dt><dd class="m-0 font-mono">{d.builds.map((b) => `${b.release} (${b.sha.slice(0, 7)})`).join(', ')}</dd></>
         )}
         <dt class="text-body-secondary">{t('crashes.d_task')}</dt><dd class="m-0 font-mono">{d.fatal.comm ?? '?'}{d.fatal.interrupted?.length ? ` · ${t('crashes.d_interrupted')} ${d.fatal.interrupted.map(frame).join(' ← ')}` : ''}</dd>
         {d.uptime != null && <><dt class="text-body-secondary">{t('crashes.d_uptime')}</dt><dd class="m-0 tabular-nums">{Math.round(d.uptime)} s</dd></>}
-        <dt class="text-body-secondary">{t('crashes.d_cmdline')}</dt><dd class="m-0 font-mono break-all">{d.cmdline}</dd>
+        {d.cmdline && <><dt class="text-body-secondary">{t('crashes.d_cmdline')}</dt><dd class="m-0 font-mono break-all">{d.cmdline}</dd></>}
         {anomalies.length > 0 && <><dt class="text-body-secondary">{t('crashes.d_anomalies')}</dt><dd class="m-0 font-mono">{anomalies.map(([k, v]) => `${k} ×${v}`).join(', ')}</dd></>}
         {d.before.length > 0 && <><dt class="text-body-secondary">{t('crashes.d_before')}</dt><dd class="m-0 font-mono">{d.before.map((b) => `${b.reason} (${b.comm ?? '?'}) ${b.frames.slice(0, 3).map(frame).join(' ← ')}`).join('; ')}</dd></>}
       </dl>
+      {d.symbolization && <Symbolized s={d.symbolization} t={t} />}
       {d.leadup.length > 0 && <pre class="mt-2 mb-0 overflow-x-auto rounded bg-surface-alt p-2 font-mono text-[11.5px]">{d.leadup.join('\n')}</pre>}
       {d.meta != null && <pre class="mt-2 mb-0 max-h-60 overflow-auto rounded bg-surface-alt p-2 font-mono text-[11.5px]">{JSON.stringify(d.meta, null, 2)}</pre>}
       {d.log && <pre class="mt-2 mb-0 max-h-96 overflow-auto rounded bg-ink p-2 font-mono text-[11.5px] text-white">{d.log}</pre>}
     </details>
   );
 }
+
+/** How a majestic crash's dump was unwound: its backtrace, or why not yet. */
+function Symbolized({ s, t }: { s: NonNullable<Detail['symbolization']>; t: BoardsT }) {
+  return (
+    <div class="mt-2 grid gap-1">
+      <span class="text-body-secondary">
+        {t('crashes.d_backtrace')}
+        {s.status === 'pending' && ` · ${t('crashes.sym_pending', { n: s.attempts })}`}
+        {s.status === 'failed' && ` · ${t('crashes.sym_failed')}`}
+        {s.error && <span class="font-mono"> · {s.error}</span>}
+      </span>
+      {s.frames.length > 0 && <Backtrace frames={s.frames} t={t} />}
+    </div>
+  );
+}
diff --git a/frontend/apps/site/src/components/club/Crashes.test.tsx b/frontend/apps/site/src/components/club/Crashes.test.tsx
index cfeabea6..53578d03 100644
--- a/frontend/apps/site/src/components/club/Crashes.test.tsx
+++ b/frontend/apps/site/src/components/club/Crashes.test.tsx
@@ -42,3 +42,18 @@ test('a crash log is sent and filed under its bug', async () => {
   // The list reloads: the crash is there too, under its bug.
   await waitFor(() => expect(getAllByText(/RGN_PutRegion/).length).toBe(2));
 });
+
+test("a crash of majestic's is named by its signal, and not linked to the public list", async () => {
+  vi.stubGlobal('fetch', vi.fn(async (url: string) => {
+    if (url === '/api/v1/club/crashes') {
+      return new Response(JSON.stringify({ crashes: [{ id: 'c-majestic2', signature: '0123456789ac', title: 'SIGSEGV (NULL pointer)',
+        kind: 'signal', status: 'open', soc: 'gk7205v300', sensor: 'imx335', received_at: '2026-10-09T01:00:00Z', self_inflicted: false,
+        camera: true }], stars: 0, rules: { report: 1, first: 3, fixed: 5, month_cap: 10 } }));
+    }
+    return new Response('{}', { status: 404 });
+  }));
+  const { findByText } = render(<Harness />);
+  const title = await findByText('SIGSEGV (NULL pointer)');
+  expect(title.closest('a')).toBeNull();
+  expect(await findByText('majestic crashed')).toBeTruthy();
+});
diff --git a/frontend/apps/site/src/components/club/Crashes.tsx b/frontend/apps/site/src/components/club/Crashes.tsx
index 5ec29760..1a8dba32 100644
--- a/frontend/apps/site/src/components/club/Crashes.tsx
+++ b/frontend/apps/site/src/components/club/Crashes.tsx
@@ -70,7 +70,9 @@ export default function Crashes({ locale, t, onChange }: { locale: Locale; t: Bo
         {state.s === 'sent' && (
           <p class="m-0 rounded-md bg-[#e7f5ee] px-3 py-2 text-sm text-[#1f7a4d]" role="status">
             {t(state.r.self_inflicted ? 'crashes.sent_self' : state.r.duplicate ? 'crashes.sent_again' : 'crashes.sent')}{' '}
-            <a href={`${pathFor(locale, '/crashes')}#${state.r.signature}`} class="font-mono">{state.r.title}</a>
+            {state.r.kind === 'signal'
+              ? <span class="font-mono">{state.r.title}</span>
+              : <a href={`${pathFor(locale, '/crashes')}#${state.r.signature}`} class="font-mono">{state.r.title}</a>}
           </p>
         )}
         {state.s === 'error' && <p class="m-0 text-sm text-[#a3262e]" role="alert">{state.error}</p>}
@@ -87,7 +89,10 @@ export default function Crashes({ locale, t, onChange }: { locale: Locale; t: Bo
                 {c.self_inflicted && <span class="text-[12px] text-body-secondary">{t('crashes.self_inflicted')}</span>}
                 <span class="text-[12px] text-body-secondary">{c.received_at.slice(0, 10)} · {[c.soc, c.sensor].filter(Boolean).join(' · ').toUpperCase()}</span>
               </span>
-              <a class="font-mono break-words" href={`${pathFor(locale, '/crashes')}#${c.signature}`}>{c.title}</a>
+              {/* majestic's crashes are not on the public list. */}
+              {c.kind === 'signal'
+                ? <span class="font-mono break-words">{c.title}</span>
+                : <a class="font-mono break-words" href={`${pathFor(locale, '/crashes')}#${c.signature}`}>{c.title}</a>}
             </li>
           ))}
         </ul>
diff --git a/frontend/apps/site/src/i18n/boards.en.json b/frontend/apps/site/src/i18n/boards.en.json
index 98c6845e..3a923779 100644
--- a/frontend/apps/site/src/i18n/boards.en.json
+++ b/frontend/apps/site/src/i18n/boards.en.json
@@ -251,6 +251,7 @@
       "col_soc": "SoC",
       "current": "In current firmware",
       "d_anomalies": "Before it",
+      "d_backtrace": "Backtrace",
       "d_before": "Warnings",
       "d_builds": "Matching builds",
       "d_cmdline": "Command line",
@@ -285,6 +286,7 @@
       "kind_bug": "BUG",
       "kind_oops": "Oops",
       "kind_panic": "Kernel panic",
+      "kind_signal": "majestic crashed",
       "kind_warning": "Warning",
       "last_seen": "last {date}",
       "list_label": "Kernel crashes, worst first",
@@ -293,6 +295,7 @@
       "mine_empty": "No crash sent yet, from you or your linked cameras.",
       "mine_lede": "Each bug a camera of yours hits earns {report} ★ once settled; if you were the first to send it, {first} ★ more when a maintainer confirms it and {fixed} ★ when it is fixed. At most {cap} ★ a month from crashes; a crash you caused on purpose earns nothing.",
       "mine_title": "My crash reports",
+      "probable": "probable",
       "saved": "Saved.",
       "self_inflicted": "caused on purpose",
       "send": "Send the crash log",
@@ -305,6 +308,8 @@
       "status_fixed": "Fixed",
       "status_open": "Not yet looked at",
       "status_wontfix": "Will not be fixed",
+      "sym_failed": "No backtrace",
+      "sym_pending": "Waiting for its backtrace (tried {n} times)",
       "taken_back": "Saved; {n} ★ taken back.",
       "triage_forbidden": "Only OpenIPC's maintainers triage crashes.",
       "triage_link": "Crash triage"
diff --git a/frontend/apps/site/src/i18n/boards.ru.json b/frontend/apps/site/src/i18n/boards.ru.json
index 6d45fe60..febe4efa 100644
--- a/frontend/apps/site/src/i18n/boards.ru.json
+++ b/frontend/apps/site/src/i18n/boards.ru.json
@@ -255,6 +255,7 @@
       "col_soc": "SoC",
       "current": "В текущей прошивке",
       "d_anomalies": "Перед этим",
+      "d_backtrace": "Стек вызовов",
       "d_before": "Предупреждения",
       "d_builds": "Подходящие сборки",
       "d_cmdline": "Командная строка",
@@ -291,6 +292,7 @@
       "kind_bug": "BUG",
       "kind_oops": "Oops",
       "kind_panic": "Kernel panic",
+      "kind_signal": "Сбой majestic",
       "kind_warning": "Предупреждение",
       "last_seen": "последнее {date}",
       "list_label": "Падения ядра, сначала самые тяжёлые",
@@ -299,6 +301,7 @@
       "mine_empty": "Пока ни одного падения — ни от вас, ни от привязанных камер.",
       "mine_lede": "Каждая ошибка, на которую попала ваша камера, приносит {report} ★ после расчёта; если вы прислали её первым — ещё {first} ★, когда мейнтейнер подтвердит, и {fixed} ★, когда её исправят. Не больше {cap} ★ в месяц за падения; падение, вызванное нарочно, ничего не приносит.",
       "mine_title": "Мои отчёты о падениях",
+      "probable": "вероятно",
       "saved": "Сохранено.",
       "self_inflicted": "вызвано нарочно",
       "send": "Отправить лог падения",
@@ -311,6 +314,8 @@
       "status_fixed": "Исправлено",
       "status_open": "Ещё не разобрано",
       "status_wontfix": "Исправлено не будет",
+      "sym_failed": "Стека вызовов нет",
+      "sym_pending": "Ждёт стека вызовов (попыток: {n})",
       "taken_back": "Сохранено; списано {n} ★.",
       "triage_forbidden": "Разбирать падения могут только мейнтейнеры OpenIPC.",
       "triage_link": "Разбор падений"
diff --git a/frontend/apps/site/src/lib/crashes.ts b/frontend/apps/site/src/lib/crashes.ts
index 250e8fdd..90b6d223 100644
--- a/frontend/apps/site/src/lib/crashes.ts
+++ b/frontend/apps/site/src/lib/crashes.ts
@@ -3,18 +3,24 @@
  * (service/internal/crashes): the public list of signatures at
  * /api/v1/crashes, and under /api/v1/club the member's own crashes and the
  * maintainers' triage. A signature is the top of a crash's backtrace: one bug,
- * however many cameras sent it.
+ * however many cameras sent it. majestic's own crashes (kind signal, class
+ * user) are the maintainers' only: the public list never has them.
  */
 import { ClubError } from './club';
 
-export type Kind = 'bootloop' | 'panic' | 'oops' | 'bug' | 'warning';
+export type Kind = 'bootloop' | 'panic' | 'oops' | 'bug' | 'signal' | 'warning';
 export type Status = 'open' | 'confirmed' | 'fixed' | 'wontfix' | 'bogus';
 
-export interface Frame { fn: string; module?: string }
+/**
+ * A function in a backtrace. A frame of majestic's says where in its source;
+ * a probable one was found by scanning the stack past where the unwinder
+ * stopped.
+ */
+export interface Frame { fn: string; module?: string; file?: string; line?: number; probable?: boolean }
 
 export interface Signature {
   id: string;
-  class: 'fatal' | 'warning';
+  class: 'fatal' | 'warning' | 'user';
   kind: Kind;
   title: string;
   frames: Frame[];
@@ -84,6 +90,17 @@ export interface Detail {
   meta?: unknown;
   log?: string;
   builds?: { id: string; release: string; sha: string; built_at: string }[];
+  /** A majestic crash's backtrace, or why it has none yet. */
+  symbolization?: Symbolization;
+}
+
+export interface Symbolization {
+  status: 'pending' | 'done' | 'failed';
+  attempts: number;
+  frames: Frame[];
+  sources?: Record<string, unknown>;
+  error?: string;
+  at: string;
 }
 
 export interface Mine {
@@ -145,11 +162,15 @@ export const decideCrash = (id: string, t: Triage) =>
 /** A frame as a backtrace prints it: fn [module]. */
 export const frame = (f: Frame) => (f.module ? `${f.fn} [${f.module}]` : f.fn);
 
+/** A frame with where in the source it is, when that is known. */
+export const frameAt = (f: Frame) => (f.file ? `${frame(f)}  ${f.file}:${f.line ?? 0}` : frame(f));
+
 export const KIND_TONE: Record<Kind, string> = {
   bootloop: 'bg-[#fbe9ea] text-[#a3262e]',
   panic: 'bg-[#fbe9ea] text-[#a3262e]',
   oops: 'bg-[#fff4e2] text-[#8a4b00]',
   bug: 'bg-[#fff4e2] text-[#8a4b00]',
+  signal: 'bg-[#fff4e2] text-[#8a4b00]',
   warning: 'bg-surface-alt text-body-secondary',
 };
 
diff --git a/service/Dockerfile b/service/Dockerfile
index 163945b2..38c2c618 100644
--- a/service/Dockerfile
+++ b/service/Dockerfile
@@ -6,7 +6,10 @@
 # The runtime is Debian bookworm. The wall publishes what cameras send without
 # re-encoding it, and ffmpeg is here only to decode each uploaded keyframe once
 # before it is published (internal/keyframe.Check): those bytes go to visitors'
-# decoders untouched. The binary itself is static (CGO_ENABLED=0).
+# decoders untouched. gdb-multiarch and squashfs-tools are the crash
+# symbolizer's (internal/crashes/symbolize): it unwinds majestic's crash dumps
+# with gdb, and takes the libraries the camera ran out of its firmware's
+# rootfs. The binary itself is static (CGO_ENABLED=0).
 
 FROM golang:1.27.1 AS build
 WORKDIR /src/service
@@ -18,7 +21,7 @@ RUN CGO_ENABLED=0 go build -trimpath -ldflags "-s -w -X main.version=${REVISION}
 
 FROM debian:bookworm-slim
 RUN apt-get update -qq \
- && apt-get install -y --no-install-recommends ca-certificates curl git ffmpeg \
+ && apt-get install -y --no-install-recommends ca-certificates curl git ffmpeg gdb-multiarch squashfs-tools \
  && rm -rf /var/lib/apt/lists/* \
  && groupadd --gid 1000 openipc \
  && useradd --uid 1000 --gid 1000 --no-create-home --shell /usr/sbin/nologin openipc
diff --git a/service/cmd/openipc/main.go b/service/cmd/openipc/main.go
index 12bc4fd4..c4a4f5fd 100644
--- a/service/cmd/openipc/main.go
+++ b/service/cmd/openipc/main.go
@@ -29,6 +29,7 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"strings"
 	"syscall"
 	"time"
@@ -41,6 +42,7 @@ import (
 	"github.com/OpenIPC/website/service/internal/club"
 	"github.com/OpenIPC/website/service/internal/config"
 	"github.com/OpenIPC/website/service/internal/crashes"
+	"github.com/OpenIPC/website/service/internal/crashes/symbolize"
 	"github.com/OpenIPC/website/service/internal/db"
 	"github.com/OpenIPC/website/service/internal/downloads"
 	"github.com/OpenIPC/website/service/internal/drift"
@@ -625,8 +627,16 @@ func firmwareRole(ctx context.Context, cfg *config.Config, log *slog.Logger, poo
 		}
 	}
 
+	// majestic's crash dumps, unwound here because the release tarballs
+	// their libraries come from are (internal/crashes/symbolize).
+	sym := &symbolize.Worker{Pool: pool, Log: log, KeepFor: 30 * 24 * time.Hour, Symbolizer: &symbolize.Symbolizer{
+		Symbols: &symbolize.Symbols{Root: filepath.Join(cfg.ReleaseCacheRoot, "symbols"), Base: cfg.SymbolsBase},
+		Rootfs:  &symbolize.Rootfs{Root: filepath.Join(cfg.ReleaseCacheRoot, "symbols"), DB: pool, Releases: releases},
+	}}
+
 	bg, cancel := context.WithCancel(context.WithoutCancel(ctx))
 	go index.Run(bg)
+	go sym.Run(bg)
 	return cancel, nil
 }
 
diff --git a/service/internal/config/config.go b/service/internal/config/config.go
index 65dc850e..563803eb 100644
--- a/service/internal/config/config.go
+++ b/service/internal/config/config.go
@@ -68,6 +68,9 @@ type Config struct {
 	BuildsPerMinute     int
 	DownloadBase        string
 	BuilderBase         string
+	// SymbolsBase is where majestic's CI publishes each build's executable
+	// and debuginfo by build-id, for symbolizing its crashes.
+	SymbolsBase string
 
 	// Share role.
 	ShareOrigins    []string // SHARE_ORIGINS: host patterns a page's WebSocket may come from
@@ -116,6 +119,7 @@ func Load() (*Config, error) {
 		BuildsPerMinute:     num("FIRMWARE_BUILDS_PER_MINUTE", 6),
 		DownloadBase:        str("RELEASE_DOWNLOAD_BASE", "https://github.com/OpenIPC/firmware/releases/download"),
 		BuilderBase:         str("BUILDER_DOWNLOAD_BASE", "https://github.com/OpenIPC/builder/releases/download"),
+		SymbolsBase:         str("MAJESTIC_SYMBOLS_BASE", "https://openipc.s3.eu-west-1.amazonaws.com/buildid"),
 		ShareOrigins:        listOr("SHARE_ORIGINS", []string{"*.share.openipc.cloud"}),
 		ShareSTUN:           listOr("SHARE_STUN_URLS", []string{"stun:stun.cloudflare.com:3478"}),
 		ShareTURN:           list("SHARE_TURN_URLS"),
diff --git a/service/internal/crashes/CRASH.md b/service/internal/crashes/CRASH.md
index d8d94271..027ca23c 100644
--- a/service/internal/crashes/CRASH.md
+++ b/service/internal/crashes/CRASH.md
@@ -62,6 +62,27 @@ Public: the signature, the chips and sensors it was seen on, and its status.
 A crash asked for -- `echo c > /proc/sysrq-trigger` -- is kept but never
 listed and never pays: send real ones.
 
+## majestic's own crashes
+
+When majestic itself dies of SIGSEGV, SIGBUS, SIGILL, SIGFPE or SIGABRT it
+leaves `/etc/crash/majestic.dump` (the previous one as `majestic.dump.1`):
+the registers at the fault, a slice of the faulting thread's stack, its
+memory map, and the build-id of every module it had loaded. Send each dump
+as its own bundle -- a tar.gz holding `majestic.dump`, and `meta.json` when
+the firmware wrote one, or the dump alone as the body -- to the same
+address, with the same fields. The answer is the same, with `kind`
+`signal`, a title that names only the signal, and a `url` to `/club/crashes`.
+
+These are the maintainers' only. The stack slice is majestic's memory at
+the crash and can hold what it was handling (a request, its environment):
+it is kept only until the dump is symbolized -- unwound with gdb against
+the executable and debuginfo majestic's CI publishes for the build-id, and
+the libraries of the firmware build `meta.json` names -- and then deleted,
+leaving the backtrace. Never served, never public: no signature of
+majestic's appears on `/crashes`. A signal another process sent (a `kill`)
+is kept as caused on purpose and pays nothing; majestic aborting itself is
+a bug like a fault.
+
 ## Sending automatically
 
 Only with the owner's consent: a setting the owner turns on, after which
diff --git a/service/internal/crashes/api.go b/service/internal/crashes/api.go
index 3eef1957..60fcad96 100644
--- a/service/internal/crashes/api.go
+++ b/service/internal/crashes/api.go
@@ -122,12 +122,23 @@ func (a *API) Submit(w http.ResponseWriter, r *http.Request, member, channel str
 		return
 	}
 	redactCrash(c, mac, key)
-	sum := sha256.Sum256(in.bundle)
+	// majestic's dump is kept as sent only until it is symbolized
+	// (crash_dumps); what is kept for good is the dump without its stack.
+	kept := in.bundle
+	if c.Dump != nil {
+		d, err := ReadDump(c.Dump)
+		if err != nil {
+			a.refuse(w, http.StatusUnprocessableEntity, err.Error())
+			return
+		}
+		kept = d.stripped(c.Dump)
+	}
+	sum := sha256.Sum256(kept)
 	e := &Event{
 		ID: NewID(), Channel: channel, MACKey: macKey, Member: member, ClientKey: client,
-		Firmware: in.fields["firmware"], Majestic: in.fields["majestic"],
+		Firmware: in.fields["firmware"], Majestic: orDefault(in.fields["majestic"], c.Majestic),
 		SoC: orDefault(soc, c.SoC), Sensor: orDefault(sensor, c.Sensor),
-		Crash: c, Bundle: in.bundle, BundleSHA256: hex.EncodeToString(sum[:]),
+		Crash: c, Bundle: kept, BundleSHA256: hex.EncodeToString(sum[:]),
 		SignatureID: c.Fatal.Signature(),
 		Redacted:    Redact(c.Text, mac, key),
 	}
@@ -176,10 +187,18 @@ func (a *API) Submit(w http.ResponseWriter, r *http.Request, member, channel str
 	if dup {
 		code = http.StatusOK
 	}
+	// majestic's crashes are the maintainers': the public list never has
+	// them, and the sender is told the signal, not where in majestic.
+	link := strings.TrimRight(a.SiteURL, "/") + "/crashes/#" + sig
+	title := c.Fatal.Title()
+	if Class(c.Kind) == "user" {
+		link = strings.TrimRight(a.SiteURL, "/") + "/club/crashes/"
+		title = c.Fatal.Reason
+	}
 	writeJSON(w, code, map[string]any{
-		"id": id, "signature": sig, "title": c.Fatal.Title(), "kind": c.Kind, "duplicate": dup,
+		"id": id, "signature": sig, "title": title, "kind": c.Kind, "duplicate": dup,
 		"self_inflicted": c.SelfInflicted,
-		"url":            strings.TrimRight(a.SiteURL, "/") + "/crashes/#" + sig,
+		"url":            link,
 	})
 }
 
diff --git a/service/internal/crashes/dump.go b/service/internal/crashes/dump.go
new file mode 100644
index 00000000..e2d6e7d6
--- /dev/null
+++ b/service/internal/crashes/dump.go
@@ -0,0 +1,442 @@
+package crashes
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"path"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// majestic's crash dump, /etc/crash/majestic.dump: what majestic writes from
+// its fatal-signal handler, because a release build carries no unwind tables
+// and cannot say where it crashed itself. The symbolizer (the symbolize
+// package, in the firmware role) unwinds it against the debuginfo majestic's
+// CI publishes for the build-id.
+//
+//	"MJCD"  u8 version (1)  u8 0  u8 arch  u8 0
+//	then sections until END: 4-byte tag, u32 length (little-endian), bytes
+//
+//	HDR   text, key=value lines: signal, code (si_code), sender (the sender's
+//	      pid, for a signal sent), addr, pid, tid, thread, wall, uptime,
+//	      version
+//	REGS  the faulting thread's uc_mcontext, raw, in the target's byte order
+//	STAK  u64 (little-endian) address, then the stack's bytes from it up
+//	MAPS  /proc/self/maps
+//	AUXV  /proc/self/auxv
+//	MODS  text, per loaded object: build-id in hex or -, start, load bias, path
+//	THRD  text, "tid name" per thread
+//	END   empty
+//
+// Unknown sections are skipped, so the format grows by adding them.
+
+// Architectures, as the header's arch byte says.
+const (
+	ArchARM     = 1
+	ArchMIPSLE  = 2
+	ArchMIPSBE  = 3
+	ArchX86_64  = 4
+	ArchAArch64 = 5
+)
+
+// Dump is a majestic crash dump, read.
+type Dump struct {
+	Version int
+	Arch    int
+	Header  map[string]string
+	Regs    []byte
+	// StackAt is where Stack begins: the stack pointer at the fault.
+	StackAt uint64
+	Stack   []byte
+	Maps    []Mapping
+	Auxv    []byte
+	Modules []Module
+	Threads string
+	// Sections: every section's bytes by tag, the ones read above too.
+	Sections map[string][]byte
+}
+
+// Mapping is one line of /proc/self/maps.
+type Mapping struct {
+	Start, End uint64
+	Perms      string
+	Offset     uint64
+	Path       string
+}
+
+// Exec says whether the mapping holds code.
+func (m Mapping) Exec() bool { return strings.Contains(m.Perms, "x") }
+
+// Module is a loaded object: where it is and which build it is.
+type Module struct {
+	BuildID string // hex, "" when it has none
+	Start   uint64
+	Bias    uint64
+	Path    string
+}
+
+// Name is the module's file name.
+func (m Module) Name() string { return path.Base(m.Path) }
+
+// ErrNotADump is bytes that are not majestic's dump.
+var ErrNotADump = errors.New("majestic.dump is not a crash dump majestic wrote (no MJCD header)")
+
+// ReadDump reads a dump.
+func ReadDump(b []byte) (*Dump, error) {
+	if len(b) < 8 || string(b[:4]) != "MJCD" {
+		return nil, ErrNotADump
+	}
+	d := &Dump{Version: int(b[4]), Arch: int(b[6]), Header: map[string]string{}, Sections: map[string][]byte{}}
+	if d.Version != 1 {
+		return nil, fmt.Errorf("majestic.dump is version %d; this site reads version 1", d.Version)
+	}
+	switch d.Arch {
+	case ArchARM, ArchMIPSLE, ArchMIPSBE, ArchX86_64, ArchAArch64:
+	default:
+		return nil, fmt.Errorf("majestic.dump is for an unknown architecture (%d)", d.Arch)
+	}
+	ended := false
+	for off := 8; off+8 <= len(b); {
+		tag := string(b[off : off+4])
+		n := int(binary.LittleEndian.Uint32(b[off+4:]))
+		if n < 0 || off+8+n > len(b) {
+			return nil, fmt.Errorf("majestic.dump is cut short in section %q", tag)
+		}
+		d.Sections[tag] = b[off+8 : off+8+n]
+		off += 8 + n
+		if tag == "END " {
+			ended = true
+			break
+		}
+	}
+	if !ended {
+		return nil, errors.New("majestic.dump is cut short: it has no END section")
+	}
+	for _, l := range strings.Split(string(d.Sections["HDR "]), "\n") {
+		if k, v, ok := strings.Cut(l, "="); ok {
+			d.Header[k] = v
+		}
+	}
+	d.Regs = d.Sections["REGS"]
+	if s := d.Sections["STAK"]; len(s) >= 8 {
+		d.StackAt = binary.LittleEndian.Uint64(s)
+		d.Stack = s[8:]
+	}
+	d.Maps = parseMaps(string(d.Sections["MAPS"]))
+	d.Auxv = d.Sections["AUXV"]
+	d.Modules = parseModules(string(d.Sections["MODS"]))
+	d.Threads = string(d.Sections["THRD"])
+	if d.Header["signal"] == "" || len(d.Regs) == 0 {
+		return nil, errors.New("majestic.dump has no signal or no registers")
+	}
+	if _, err := d.PC(); err != nil {
+		return nil, err
+	}
+	return d, nil
+}
+
+func parseMaps(s string) []Mapping {
+	var out []Mapping
+	for _, l := range strings.Split(s, "\n") {
+		f := strings.Fields(l)
+		if len(f) < 5 {
+			continue
+		}
+		lo, hi, ok := strings.Cut(f[0], "-")
+		if !ok {
+			continue
+		}
+		a, err1 := strconv.ParseUint(lo, 16, 64)
+		z, err2 := strconv.ParseUint(hi, 16, 64)
+		off, err3 := strconv.ParseUint(f[2], 16, 64)
+		if err1 != nil || err2 != nil || err3 != nil {
+			continue
+		}
+		m := Mapping{Start: a, End: z, Perms: f[1], Offset: off}
+		if len(f) >= 6 {
+			m.Path = strings.Join(f[5:], " ")
+		}
+		out = append(out, m)
+	}
+	return out
+}
+
+func parseModules(s string) []Module {
+	var out []Module
+	seen := map[string]bool{}
+	for _, l := range strings.Split(s, "\n") {
+		f := strings.SplitN(l, " ", 4)
+		if len(f) != 4 {
+			continue
+		}
+		start, err1 := strconv.ParseUint(strings.TrimPrefix(f[1], "0x"), 16, 64)
+		bias, err2 := strconv.ParseUint(strings.TrimPrefix(f[2], "0x"), 16, 64)
+		if err1 != nil || err2 != nil || f[3] == "" {
+			continue
+		}
+		// A library mapped twice (opened again by a dlopen) is one module.
+		if seen[f[3]] {
+			continue
+		}
+		seen[f[3]] = true
+		id := f[0]
+		if id == "-" || !hexRe(id) {
+			id = ""
+		}
+		out = append(out, Module{BuildID: id, Start: start, Bias: bias, Path: f[3]})
+	}
+	return out
+}
+
+func hexRe(s string) bool {
+	if len(s) == 0 || len(s) > 64 {
+		return false
+	}
+	_, err := hex.DecodeString(s)
+	return err == nil
+}
+
+// Order is the target's byte order.
+func (d *Dump) Order() binary.ByteOrder {
+	if d.Arch == ArchMIPSBE {
+		return binary.BigEndian
+	}
+	return binary.LittleEndian
+}
+
+// Is64 says whether the target's words are 64 bits.
+func (d *Dump) Is64() bool { return d.Arch == ArchX86_64 || d.Arch == ArchAArch64 }
+
+// Where each architecture's uc_mcontext keeps the program counter, the stack
+// pointer and the return address (the kernel's struct sigcontext, which the
+// C libraries' mcontext_t mirror):
+//
+//	ARM      u32 trap_no, error_code, oldmask, r0..r10, fp, ip, sp, lr, pc, cpsr, fault_address
+//	MIPS     u32 regmask, status; u64 pc; u64 regs[32] (sp is 29, ra 31)
+//	x86_64   u64 gregs[23]: r8..r15, rdi, rsi, rbp, rbx, rdx, rax, rcx, rsp, rip, ...
+//	AArch64  u64 fault_address, regs[31] (x30 is the link register), sp, pc, pstate
+func (d *Dump) reg(i, size int) (uint64, error) {
+	if i+size > len(d.Regs) {
+		return 0, fmt.Errorf("majestic.dump's registers are cut short (%d bytes)", len(d.Regs))
+	}
+	if size == 4 {
+		return uint64(d.Order().Uint32(d.Regs[i:])), nil
+	}
+	v := d.Order().Uint64(d.Regs[i:])
+	if d.Arch == ArchMIPSLE || d.Arch == ArchMIPSBE {
+		v &= 0xffffffff // o32: 32-bit registers, kept in 64-bit slots
+	}
+	return v, nil
+}
+
+// PC is the program counter at the fault.
+func (d *Dump) PC() (uint64, error) {
+	switch d.Arch {
+	case ArchARM:
+		return d.reg(18*4, 4)
+	case ArchMIPSLE, ArchMIPSBE:
+		return d.reg(8, 8)
+	case ArchX86_64:
+		return d.reg(16*8, 8)
+	default:
+		return d.reg(33*8, 8)
+	}
+}
+
+// SP is the stack pointer at the fault.
+func (d *Dump) SP() (uint64, error) {
+	switch d.Arch {
+	case ArchARM:
+		return d.reg(16*4, 4)
+	case ArchMIPSLE, ArchMIPSBE:
+		return d.reg(16+29*8, 8)
+	case ArchX86_64:
+		return d.reg(15*8, 8)
+	default:
+		return d.reg(32*8, 8)
+	}
+}
+
+// LR is the return address register at the fault (none on x86_64, whose
+// return address is on the stack).
+func (d *Dump) LR() (uint64, bool) {
+	var v uint64
+	var err error
+	switch d.Arch {
+	case ArchARM:
+		v, err = d.reg(17*4, 4)
+	case ArchMIPSLE, ArchMIPSBE:
+		v, err = d.reg(16+31*8, 8)
+	case ArchAArch64:
+		v, err = d.reg(31*8, 8)
+	default:
+		return 0, false
+	}
+	return v, err == nil
+}
+
+// ModuleAt is the module whose code holds addr, and addr's offset from its
+// load bias: what the debuginfo calls the address.
+func (d *Dump) ModuleAt(addr uint64) (Module, uint64, bool) {
+	for _, m := range d.Maps {
+		if addr < m.Start || addr >= m.End || !m.Exec() {
+			continue
+		}
+		for _, mod := range d.Modules {
+			if mod.Path == m.Path {
+				return mod, addr - mod.Bias, true
+			}
+		}
+		// Mapped but not in the module table: a library the table was read
+		// before (it is read again after each dlopen, but not after one a
+		// library makes itself). Its first mapping is its bias, for a
+		// library built at 0.
+		first := m
+		for _, o := range d.Maps {
+			if o.Path == m.Path && o.Start < first.Start {
+				first = o
+			}
+		}
+		return Module{Path: m.Path, Start: first.Start, Bias: first.Start - first.Offset}, addr - (first.Start - first.Offset), true
+	}
+	return Module{}, 0, false
+}
+
+// Main is the majestic executable's module: the first in the table.
+func (d *Dump) Main() (Module, bool) {
+	if len(d.Modules) == 0 {
+		return Module{}, false
+	}
+	return d.Modules[0], true
+}
+
+// Signals' names, for the titles. The numbers are Linux's, the same on every
+// architecture majestic runs on but MIPS, whose SIGBUS is 10.
+func (d *Dump) SignalName() string {
+	n, _ := strconv.Atoi(d.Header["signal"])
+	mips := d.Arch == ArchMIPSLE || d.Arch == ArchMIPSBE
+	switch {
+	case n == 11:
+		return "SIGSEGV"
+	case n == 6:
+		return "SIGABRT"
+	case n == 4:
+		return "SIGILL"
+	case n == 8:
+		return "SIGFPE"
+	case n == 7 && !mips, n == 10 && mips:
+		return "SIGBUS"
+	}
+	return "signal " + strconv.Itoa(n)
+}
+
+// Sent says whether something sent the signal (si_code zero or negative)
+// rather than the CPU raising it at a fault.
+func (d *Dump) Sent() bool {
+	code, err := strconv.Atoi(d.Header["code"])
+	return err == nil && code <= 0
+}
+
+// SelfInflicted is a signal another process sent: a kill -SEGV, not a bug.
+// majestic sending itself one is a bug -- abort() is how an assert ends --
+// so a SIGABRT whose sender is not known is taken for majestic's own.
+func (d *Dump) SelfInflicted() bool {
+	if !d.Sent() {
+		return false
+	}
+	sender, ok := d.Header["sender"]
+	if !ok {
+		return d.SignalName() != "SIGABRT"
+	}
+	return sender != d.Header["pid"]
+}
+
+// stripped is the dump without its stack: what is kept of it once it is
+// symbolized.
+func (d *Dump) stripped(raw []byte) []byte {
+	var out bytes.Buffer
+	out.Write(raw[:8])
+	for off := 8; off+8 <= len(raw); {
+		tag := string(raw[off : off+4])
+		n := int(binary.LittleEndian.Uint32(raw[off+4:]))
+		if tag != "STAK" {
+			out.Write(raw[off : off+8+n])
+		}
+		off += 8 + n
+		if tag == "END " {
+			break
+		}
+	}
+	return out.Bytes()
+}
+
+// ModuleName is a library's name without its version, so a frame in it
+// names the same thing on the next firmware: libevent_core-2.2.so.1.0.1 is
+// libevent_core-2.2.so.
+func ModuleName(p string) string {
+	n := path.Base(p)
+	if i := strings.Index(n, ".so"); i > 0 {
+		return n[:i+3]
+	}
+	return n
+}
+
+// parseUserCrash reads a bundle with majestic's dump: a crash of the
+// streamer, filed provisionally under the module and offset of the faulting
+// instruction until the symbolizer files it under its backtrace.
+func parseUserCrash(raw []byte) (*Crash, *Dump, error) {
+	if len(raw) > MaxBundle {
+		return nil, nil, fmt.Errorf("majestic.dump is larger than %d bytes", MaxBundle)
+	}
+	d, err := ReadDump(raw)
+	if err != nil {
+		return nil, nil, err
+	}
+	pc, _ := d.PC()
+	where := fmt.Sprintf("0x%x", pc)
+	frame := Frame{Fn: where}
+	build := ""
+	if mod, off, ok := d.ModuleAt(pc); ok {
+		frame = Frame{Fn: fmt.Sprintf("%s+0x%x", ModuleName(mod.Path), off)}
+		if main, ok := d.Main(); ok && main.Path == mod.Path {
+			build = main.BuildID
+		} else if mod.BuildID != "" {
+			build = mod.BuildID
+		}
+	}
+	reason := d.SignalName()
+	if addr, err := strconv.ParseUint(strings.TrimPrefix(d.Header["addr"], "0x"), 16, 64); err == nil &&
+		!d.Sent() && reason == "SIGSEGV" && addr < 4096 {
+		reason += " (NULL pointer)"
+	}
+	if d.Sent() {
+		reason += " (sent)"
+	}
+	t := &Trace{Kind: KindSignal, Reason: reason, Comm: d.Header["thread"], PC: frame.Fn,
+		Frames: []Frame{frame}, Provisional: true, Build: build}
+	c := &Crash{Kind: KindSignal, Fatal: t, Records: 1, SelfInflicted: d.SelfInflicted(),
+		Anomalies: map[string]int{}, Majestic: d.Header["version"]}
+	if up, err := strconv.ParseFloat(d.Header["uptime"], 64); err == nil {
+		c.Uptime = up
+	}
+	var mods []string
+	for _, m := range d.Modules {
+		mods = append(mods, ModuleName(m.Path))
+	}
+	sort.Strings(mods)
+	c.Modules = mods
+	// What maintainers read, as the log is for a kernel crash: the header,
+	// the threads and the memory map. Never the stack.
+	c.Text = "==> majestic.dump <==\n" + string(d.Sections["HDR "]) +
+		"\n==> threads <==\n" + d.Threads +
+		"\n==> modules <==\n" + string(d.Sections["MODS"]) +
+		"\n==> maps <==\n" + string(d.Sections["MAPS"])
+	sum := sha256.Sum256(raw)
+	c.ContentSum = hex.EncodeToString(sum[:])
+	return c, d, nil
+}
diff --git a/service/internal/crashes/dump_test.go b/service/internal/crashes/dump_test.go
new file mode 100644
index 00000000..7e84ea5b
--- /dev/null
+++ b/service/internal/crashes/dump_test.go
@@ -0,0 +1,382 @@
+package crashes
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// The dumps in testdata/dump are of a stand-in for majestic (toy.c) that
+// faulted on a gk7205v300 (arm-*) and on a PC (x86_64-*).
+func dumpFixture(t *testing.T, name string) []byte {
+	t.Helper()
+	b, err := os.ReadFile(filepath.Join("testdata", "dump", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return b
+}
+
+func TestReadDump(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		arch      int
+		reason    string
+		sent      bool
+		module    string
+		selfInfl  bool
+		frameHead string
+	}{
+		{"arm-own.dump", ArchARM, "SIGSEGV (NULL pointer)", false, "toy", false, "toy+0x"},
+		{"arm-lib.dump", ArchARM, "SIGSEGV (NULL pointer)", false, "libtoy.so", false, "libtoy.so+0x"},
+		{"arm-libc.dump", ArchARM, "SIGSEGV (NULL pointer)", false, "libc.so", false, "libc.so+0x"},
+		// raise() from inside: sent, by itself -- a bug, as abort() is.
+		{"arm-sent.dump", ArchARM, "SIGSEGV (sent)", true, "", false, ""},
+		{"x86_64-own.dump", ArchX86_64, "SIGSEGV (NULL pointer)", false, "toy", false, "toy+0x"},
+		{"x86_64-sent.dump", ArchX86_64, "SIGSEGV (sent)", true, "", false, ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			raw := dumpFixture(t, tc.name)
+			d, err := ReadDump(raw)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if d.Arch != tc.arch || d.Sent() != tc.sent || d.SelfInflicted() != tc.selfInfl {
+				t.Fatalf("arch %d sent %v self-inflicted %v", d.Arch, d.Sent(), d.SelfInflicted())
+			}
+			main, ok := d.Main()
+			if !ok || len(main.BuildID) != 40 || !strings.HasSuffix(main.Path, "/toy") {
+				t.Fatalf("main module %+v", main)
+			}
+			sp, _ := d.SP()
+			if sp != d.StackAt || len(d.Stack) < 256 {
+				t.Fatalf("stack at %#x (sp %#x), %d bytes", d.StackAt, sp, len(d.Stack))
+			}
+			pc, _ := d.PC()
+			if tc.module != "" {
+				mod, _, ok := d.ModuleAt(pc)
+				if !ok || ModuleName(mod.Path) != tc.module {
+					t.Fatalf("pc %#x is in %+v", pc, mod)
+				}
+			}
+			c, _, err := parseUserCrash(raw)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if c.Kind != KindSignal || c.Fatal.Reason != tc.reason || !c.Fatal.Provisional {
+				t.Fatalf("%+v", c.Fatal)
+			}
+			if tc.frameHead != "" && !strings.HasPrefix(c.Fatal.Frames[0].Fn, tc.frameHead) {
+				t.Fatalf("provisional frame %q", c.Fatal.Frames[0].Fn)
+			}
+			// What maintainers read is never the stack.
+			if strings.Contains(c.Text, "LD_LIBRARY_PATH") || !strings.Contains(c.Text, "signal=11") {
+				t.Fatalf("text:\n%s", c.Text)
+			}
+		})
+	}
+}
+
+func TestADumpSentByAnotherProcessIsSelfInflicted(t *testing.T) {
+	raw := dumpFixture(t, "arm-sent.dump")
+	d, _ := ReadDump(raw)
+	// The same signal, from a kill: another sender.
+	hdr := strings.Replace(string(d.Sections["HDR "]), "sender="+d.Header["pid"], "sender=1", 1)
+	other := rebuild(t, raw, "HDR ", []byte(hdr))
+	o, err := ReadDump(other)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !o.SelfInflicted() {
+		t.Fatalf("header:\n%s", hdr)
+	}
+	// An old dump without the sender: a sent SIGSEGV is someone's kill; a
+	// SIGABRT is abort()'s.
+	noSender := strings.Replace(hdr, "sender=1\n", "", 1)
+	if o, _ := ReadDump(rebuild(t, raw, "HDR ", []byte(noSender))); !o.SelfInflicted() {
+		t.Fatal("a sent SIGSEGV without a sender is not self-inflicted")
+	}
+	abrt := strings.Replace(noSender, "signal=11", "signal=6", 1)
+	if o, _ := ReadDump(rebuild(t, raw, "HDR ", []byte(abrt))); o.SelfInflicted() {
+		t.Fatal("abort() without a sender is self-inflicted")
+	}
+}
+
+// rebuild replaces one section of a dump.
+func rebuild(t *testing.T, raw []byte, tag string, with []byte) []byte {
+	t.Helper()
+	var out bytes.Buffer
+	out.Write(raw[:8])
+	for off := 8; off+8 <= len(raw); {
+		n := int(uint32(raw[off+4]) | uint32(raw[off+5])<<8 | uint32(raw[off+6])<<16 | uint32(raw[off+7])<<24)
+		cur := string(raw[off : off+4])
+		body := raw[off+8 : off+8+n]
+		if cur == tag {
+			body = with
+		}
+		out.WriteString(cur)
+		l := len(body)
+		out.Write([]byte{byte(l), byte(l >> 8), byte(l >> 16), byte(l >> 24)})
+		out.Write(body)
+		off += 8 + n
+		if cur == "END " {
+			break
+		}
+	}
+	return out.Bytes()
+}
+
+func TestReadDumpRefusesWhatIsNotOne(t *testing.T) {
+	raw := dumpFixture(t, "arm-own.dump")
+	for name, b := range map[string][]byte{
+		"empty":     nil,
+		"text":      []byte("hello"),
+		"cut":       raw[:len(raw)/2],
+		"no end":    raw[:len(raw)-8],
+		"version 9": append([]byte("MJCD\x09\x00\x01\x00"), raw[8:]...),
+		"arch 77":   append([]byte("MJCD\x01\x00\x4d\x00"), raw[8:]...),
+	} {
+		if _, err := ReadDump(b); err == nil {
+			t.Errorf("%s: read as a dump", name)
+		}
+	}
+}
+
+func TestUnpackKeepsMajesticsDump(t *testing.T) {
+	raw := dumpFixture(t, "arm-own.dump")
+	for name, b := range map[string][]byte{
+		"tar.gz": tgz(t, map[string]string{"majestic.dump": string(raw), "meta.json": `{"soc":"gk7205v300"}`}),
+		"bare":   raw,
+	} {
+		files, err := Unpack(b)
+		if err != nil {
+			t.Fatalf("%s: %v", name, err)
+		}
+		c, err := Parse(files)
+		if err != nil {
+			t.Fatalf("%s: %v", name, err)
+		}
+		if c.Kind != KindSignal || !bytes.Equal(c.Dump, raw) {
+			t.Fatalf("%s: kind %s, dump %d bytes", name, c.Kind, len(c.Dump))
+		}
+	}
+}
+
+func TestAMajesticCrashIsTheMaintainersOnly(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	raw := dumpFixture(t, "arm-own.dump")
+	meta := `{"firmware":{"build_id":"nightly-20261009-0000000","platform":"gk7205v300_lite"},"soc":"gk7205v300"}`
+	code, out := e.send(tgz(t, map[string]string{"majestic.dump": string(raw), "meta.json": meta}),
+		map[string]string{"mac": labMAC}, "10.0.0.5")
+	if code != 201 || out["kind"] != KindSignal || out["self_inflicted"] != false {
+		t.Fatalf("%d %v", code, out)
+	}
+	// The sender is told the signal; where in majestic is the maintainers'.
+	if !strings.HasSuffix(out["url"].(string), "/club/crashes/") || out["title"] != "SIGSEGV (NULL pointer)" {
+		t.Fatalf("url %v, title %v", out["url"], out["title"])
+	}
+	provisional := out["signature"].(string)
+	id := out["id"].(string)
+
+	// Not on the public list, not by its address.
+	if list := e.get("/api/v1/crashes")["signatures"].([]any); len(list) != 0 {
+		t.Fatalf("public list: %v", list)
+	}
+	rec := e.status("/api/v1/crashes/" + provisional)
+	if rec != 404 {
+		t.Fatalf("public signature: %d", rec)
+	}
+	// The maintainers see it.
+	st := e.api.Store()
+	all, err := st.Ranked(ctx, true, e.now)
+	if err != nil || len(all) != 1 || all[0].Class != "user" || all[0].Kind != KindSignal {
+		t.Fatalf("%v %+v", err, all)
+	}
+
+	// Kept: the dump until it is symbolized, and for good only the dump
+	// without its stack.
+	var dump, kept []byte
+	if err := e.pool.QueryRow(ctx, `SELECT d.bytes, b.bytes FROM crash_dumps d JOIN crash_events e ON e.id = d.event_id
+		JOIN crash_bundles b ON b.sha256 = e.bundle_sha256`).Scan(&dump, &kept); err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(dump, raw) {
+		t.Fatal("the dump is not the one sent")
+	}
+	k, err := ReadDump(kept)
+	if err != nil || len(k.Stack) != 0 || k.Sections["MAPS"] == nil || bytes.Contains(kept, []byte("LD_LIBRARY_PATH")) {
+		t.Fatalf("kept bundle: %v, stack %d bytes", err, len(k.Stack))
+	}
+
+	// Due, with what meta.json says the camera ran.
+	due, err := st.DueDumps(ctx, e.now, 10)
+	if err != nil || len(due) != 1 || due[0].EventID != id || !strings.Contains(string(due[0].Meta), "nightly-20261009") {
+		t.Fatalf("%v %+v", err, due)
+	}
+
+	// Symbolized: refiled under its backtrace; the provisional signature
+	// goes, and the dump with it.
+	frames := []Frame{{Fn: "store", File: "toy.c", Line: 175}, {Fn: "parse_level", File: "toy.c", Line: 179},
+		{Fn: "main", File: "toy.c", Line: 207}}
+	sig, err := st.Symbolized(ctx, id, frames, map[string]any{"build_id": "x"}, e.now.Add(time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sig == provisional {
+		t.Fatal("the signature did not change")
+	}
+	var n int
+	e.pool.QueryRow(ctx, `SELECT count(*) FROM crash_dumps`).Scan(&n)
+	if n != 0 {
+		t.Fatal("the dump outlived its symbolization")
+	}
+	e.pool.QueryRow(ctx, `SELECT count(*) FROM crash_signatures WHERE id = $1`, provisional).Scan(&n)
+	if n != 0 {
+		t.Fatal("the provisional signature is still there")
+	}
+	g, err := st.Get(ctx, sig, true, e.now)
+	if err != nil || g.Title != "SIGSEGV (NULL pointer) in store" || g.Events != 1 {
+		t.Fatalf("%v %+v", err, g)
+	}
+	details, err := st.Details(ctx, sig)
+	if err != nil || len(details) != 1 || details[0].Symbolization == nil || details[0].Symbolization.Status != "done" ||
+		details[0].Symbolization.Frames[0].Line != 175 {
+		t.Fatalf("%v %+v", err, details)
+	}
+	if _, err := st.Symbolized(ctx, id, frames, nil, e.now); err == nil {
+		t.Fatal("symbolized twice")
+	}
+
+	// The same bug from another camera: filed under the same backtrace.
+	other := rebuild(t, raw, "THRD", []byte("1 toy\n2 other\n"))
+	code, out = e.send(other, map[string]string{"mac": "02:00:00:00:00:02"}, "10.0.0.6")
+	if code != 201 {
+		t.Fatalf("%d %v", code, out)
+	}
+	if again, err := st.Symbolized(ctx, out["id"].(string), frames, nil, e.now); err != nil || again != sig {
+		t.Fatalf("%v: %s, want %s", err, again, sig)
+	}
+	if g, _ := st.Get(ctx, sig, true, e.now); g.Cameras != 2 {
+		t.Fatalf("%+v", g)
+	}
+}
+
+func (e *env) status(path string) int {
+	e.t.Helper()
+	rec := httptest.NewRecorder()
+	e.mux.ServeHTTP(rec, httptest.NewRequest("GET", path, nil))
+	return rec.Code
+}
+
+func TestASymbolizationThatKeepsFailingIsGivenUp(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	code, out := e.send(dumpFixture(t, "x86_64-own.dump"), nil, "10.0.0.7")
+	if code != 201 {
+		t.Fatalf("%d %v", code, out)
+	}
+	id := out["id"].(string)
+	st := e.api.Store()
+	now := e.now
+	for i := 0; ; i++ {
+		due, err := st.DueDumps(ctx, now, 10)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(due) != 1 {
+			t.Fatalf("try %d: %d due", i, len(due))
+		}
+		gaveUp, err := st.SymbolizeFailed(ctx, id, "no executable and debuginfo are published", now)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Not due again until its wait is over.
+		if due, _ := st.DueDumps(ctx, now, 10); len(due) != 0 {
+			t.Fatalf("try %d: due again at once", i)
+		}
+		if gaveUp {
+			if i != len(retryAfter) {
+				t.Fatalf("gave up after %d tries", i+1)
+			}
+			break
+		}
+		now = now.Add(retryAfter[i])
+	}
+	var dumps int
+	var status string
+	e.pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM crash_dumps)::int, status FROM crash_symbolizations`).Scan(&dumps, &status)
+	if dumps != 0 || status != "failed" {
+		t.Fatalf("dumps %d, status %s", dumps, status)
+	}
+	// Still a crash, under its provisional signature, for the maintainers.
+	if list, _ := st.Ranked(ctx, true, e.now); len(list) != 1 || !strings.Contains(list[0].Title, "toy+0x") {
+		t.Fatalf("%+v", list)
+	}
+}
+
+func TestStarsBookedUnderAProvisionalSignatureFollowTheBug(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	e.member("m-owner00000", "Owner")
+	e.link(labMAC, "m-owner00000")
+	code, out := e.send(dumpFixture(t, "arm-own.dump"), map[string]string{"mac": labMAC}, "10.0.0.8")
+	if code != 201 {
+		t.Fatalf("%d %v", code, out)
+	}
+	// The settlement ran before the symbolizer did: the report is paid
+	// under the provisional signature.
+	e.settle()
+	if e.stars("m-owner00000") != ReportStars {
+		t.Fatalf("stars %d", e.stars("m-owner00000"))
+	}
+	provisional := out["signature"].(string)
+	sig, err := e.api.Store().Symbolized(ctx, out["id"].(string), []Frame{{Fn: "store"}, {Fn: "parse_level"}}, nil, e.now)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var merged string
+	if err := e.pool.QueryRow(ctx, `SELECT coalesce(merged_into, '') FROM crash_signatures WHERE id = $1`, provisional).Scan(&merged); err != nil {
+		t.Fatal(err)
+	}
+	if merged != sig {
+		t.Fatalf("provisional merged into %q, want %q", merged, sig)
+	}
+	// Held under the bug: nothing is paid twice.
+	e.settle()
+	if e.stars("m-owner00000") != ReportStars {
+		t.Fatalf("stars %d after symbolizing", e.stars("m-owner00000"))
+	}
+	// The owner sees the crash, named by its signal, never by majestic's
+	// functions.
+	mine, err := e.api.Store().Mine(ctx, "m-owner00000")
+	if err != nil || len(mine) != 1 || mine[0].Title != "SIGSEGV (NULL pointer)" || mine[0].Signature != sig {
+		t.Fatalf("%v %+v", err, mine)
+	}
+}
+
+func TestUserSignatureFrames(t *testing.T) {
+	// abort's frames, unnamed library frames and probable ones are not the
+	// bug; two named frames of its own are enough.
+	frames := []Frame{{Fn: "raise", Module: "libc.so"}, {Fn: "abort", Module: "libc.so"}, {Fn: "?", Module: "libevent_core-2.2.so"},
+		{Fn: "toy_handler"}, {Fn: "toy_dispatch"}, {Fn: "main", Probable: true}}
+	got, _ := json.Marshal(userSigFrames(frames))
+	if string(got) != `[{"fn":"toy_handler"},{"fn":"toy_dispatch"}]` {
+		t.Fatalf("%s", got)
+	}
+	// One of its own: the probable callers fill in.
+	frames = []Frame{{Fn: "memcpy", Module: "libc.so"}, {Fn: "?", Module: "libx.so"}, {Fn: "a", Probable: true}, {Fn: "b", Probable: true}}
+	got, _ = json.Marshal(userSigFrames(frames))
+	if string(got) != `[{"fn":"memcpy","module":"libc.so"},{"fn":"a","probable":true},{"fn":"b","probable":true}]` {
+		t.Fatalf("%s", got)
+	}
+	if title := userTitle("SIGSEGV", userSigFrames(frames)); title != "SIGSEGV in memcpy [libc.so] ← a" {
+		t.Fatalf("%q", title)
+	}
+}
diff --git a/service/internal/crashes/parse.go b/service/internal/crashes/parse.go
index 3cd1fbd2..7b8af97f 100644
--- a/service/internal/crashes/parse.go
+++ b/service/internal/crashes/parse.go
@@ -40,17 +40,37 @@ const (
 	KindOops     = "oops"
 	KindBug      = "bug"
 	KindWarning  = "warning"
+	// KindSignal is majestic's own crash, from its dump (dump.go): the
+	// streamer died, the camera did not.
+	KindSignal = "signal"
 )
 
-var kindRank = map[string]int{KindBootloop: 5, KindPanic: 4, KindOops: 3, KindBug: 2, KindWarning: 1}
+var kindRank = map[string]int{KindBootloop: 6, KindPanic: 5, KindOops: 4, KindBug: 3, KindSignal: 2, KindWarning: 1}
+
+// Class is the signatures' class a kind is filed under: the kernel's fatal
+// crashes and its warnings, and majestic's (user), which only maintainers see.
+func Class(kind string) string {
+	switch kind {
+	case KindWarning:
+		return "warning"
+	case KindSignal:
+		return "user"
+	}
+	return "fatal"
+}
 
 // Worse says whether kind a is worse than b.
 func Worse(a, b string) bool { return kindRank[a] > kindRank[b] }
 
-// Frame is one function in a backtrace.
+// Frame is one function in a backtrace. A frame of majestic's also says
+// where in its source; Probable is one found by scanning the stack past where
+// the unwinder stopped, likely but not certain.
 type Frame struct {
-	Fn     string `json:"fn"`
-	Module string `json:"module,omitempty"`
+	Fn       string `json:"fn"`
+	Module   string `json:"module,omitempty"`
+	File     string `json:"file,omitempty"`
+	Line     int    `json:"line,omitempty"`
+	Probable bool   `json:"probable,omitempty"`
 }
 
 func (f Frame) String() string {
@@ -72,24 +92,32 @@ type Trace struct {
 	Frames []Frame `json:"frames"`
 	// Interrupted: what the CPU was doing when the interrupt that crashed came.
 	Interrupted []Frame `json:"interrupted,omitempty"`
-	end         string  // the "end trace" id, to tell the same trace in two records
+	// Provisional: a majestic crash not yet symbolized, whose one frame is
+	// the faulting instruction's module and offset in Build (the build-id).
+	Provisional bool   `json:"provisional,omitempty"`
+	Build       string `json:"build,omitempty"`
+	end         string // the "end trace" id, to tell the same trace in two records
 }
 
 // Signature is the trace's identity: the same bug on any build gives the same.
 func (t *Trace) Signature() string {
-	class := "fatal"
-	if t.Kind == KindWarning {
-		class = "warning"
-	}
 	var b strings.Builder
-	b.WriteString(class)
-	for i, f := range t.Frames {
+	b.WriteString(Class(t.Kind))
+	// An offset means something only in its build.
+	if t.Provisional {
+		b.WriteString("\nbuild " + t.Build)
+	}
+	frames := t.Frames
+	if t.Kind == KindSignal && !t.Provisional {
+		frames = userSigFrames(frames)
+	}
+	for i, f := range frames {
 		if i == sigFrames {
 			break
 		}
 		b.WriteString("\n" + f.String())
 	}
-	if len(t.Frames) == 0 {
+	if len(frames) == 0 {
 		b.WriteString("\n" + t.Reason)
 	}
 	sum := sha256.Sum256([]byte(b.String()))
@@ -101,6 +129,12 @@ func (t *Trace) Title() string {
 	if len(t.Frames) == 0 {
 		return t.Reason
 	}
+	if t.Kind == KindSignal {
+		if t.Provisional {
+			return t.Reason + " in " + t.Frames[0].String()
+		}
+		return userTitle(t.Reason, userSigFrames(t.Frames))
+	}
 	where := t.Frames[0].Fn
 	// The first frame in a vendor module says more than a kernel helper,
 	// unless it is the module everything calls through.
@@ -115,6 +149,24 @@ func (t *Trace) Title() string {
 	return t.Reason + " in " + where
 }
 
+// userTitle names where majestic crashed: the function, and when that is in
+// a library, the first of majestic's own that called it.
+func userTitle(reason string, frames []Frame) string {
+	if len(frames) == 0 {
+		return reason
+	}
+	where := frames[0].String()
+	if frames[0].Module != "" {
+		for _, f := range frames[1:] {
+			if f.Module == "" {
+				where += " ← " + f.Fn
+				break
+			}
+		}
+	}
+	return reason + " in " + where
+}
+
 func wrapperModule(m string) bool {
 	return strings.HasSuffix(m, "osal") || strings.HasSuffix(m, "_base")
 }
@@ -148,6 +200,10 @@ type Crash struct {
 	// firmware's note that the bootlimit ran out.
 	Records  int  `json:"records"`
 	Failsafe bool `json:"failsafe,omitempty"`
+	// Majestic: the version majestic's own dump says it was.
+	Majestic string `json:"majestic,omitempty"`
+	// Dump: majestic's dump, for a crash of majestic.
+	Dump []byte `json:"-"`
 
 	// Text is every record, as sent; ContentSum identifies the crash
 	// whatever tar or gzip carried it.
@@ -156,7 +212,7 @@ type Crash struct {
 }
 
 // ErrNotACrash is a bundle with nothing a crash leaves.
-var ErrNotACrash = errors.New("the bundle has no pstore record (dmesg-*) and no failsafe note: nothing crashed")
+var ErrNotACrash = errors.New("the bundle has no pstore record (dmesg-*), no failsafe note and no majestic.dump: nothing crashed")
 
 // Unpack reads a crash bundle -- a tar.gz, a plain tar, or a single record
 // as text -- into its records by name.
@@ -195,7 +251,8 @@ func Unpack(data []byte) (map[string]string, error) {
 				continue
 			}
 			name := h.Name[strings.LastIndex(h.Name, "/")+1:]
-			if !strings.HasPrefix(name, "dmesg-") && name != "failsafe" && name != "pending" && name != "meta.json" {
+			if !strings.HasPrefix(name, "dmesg-") && name != "failsafe" && name != "pending" && name != "meta.json" &&
+				name != "majestic.dump" {
 				continue
 			}
 			// The limit is on records; failsafe, pending and meta.json are one
@@ -212,6 +269,8 @@ func Unpack(data []byte) (map[string]string, error) {
 			}
 			out[name] = string(b)
 		}
+	} else if bytes.HasPrefix(raw, []byte("MJCD")) {
+		out["majestic.dump"] = string(raw)
 	} else if printable(raw) {
 		out["dmesg-0"] = string(raw)
 	} else {
@@ -233,8 +292,17 @@ func printable(b []byte) bool {
 	return bad*100 < len(b)
 }
 
-// Parse reads the records a bundle unpacked to.
+// Parse reads the records a bundle unpacked to. A bundle with majestic's dump
+// is a crash of majestic, whatever else it carries.
 func Parse(files map[string]string) (*Crash, error) {
+	if raw, ok := files["majestic.dump"]; ok {
+		c, _, err := parseUserCrash([]byte(raw))
+		if err != nil {
+			return nil, err
+		}
+		c.Dump = []byte(raw)
+		return c, nil
+	}
 	var names []string
 	for n := range files {
 		if strings.HasPrefix(n, "dmesg-") {
diff --git a/service/internal/crashes/store.go b/service/internal/crashes/store.go
index 6a9bf5a0..6cc7b2aa 100644
--- a/service/internal/crashes/store.go
+++ b/service/internal/crashes/store.go
@@ -50,7 +50,7 @@ func NewID() string {
 }
 
 // kindOrder is the kinds, mildest first, for SQL's array_position.
-const kindOrder = `ARRAY['warning','bug','oops','panic','bootloop']`
+const kindOrder = `ARRAY['warning','signal','bug','oops','panic','bootloop']`
 
 // ErrQuota is a client address or a camera past its daily limit.
 var ErrQuota = errors.New("the daily limit is reached")
@@ -70,10 +70,7 @@ func (s *Store) Insert(ctx context.Context, e *Event, at time.Time) (id, signatu
 	anomalies, _ := json.Marshal(c.Anomalies)
 	leadup, _ := json.Marshal(orEmpty(c.Leadup))
 	frames, _ := json.Marshal(orEmpty(c.Fatal.Frames))
-	class := "fatal"
-	if c.Fatal.Kind == KindWarning {
-		class = "warning"
-	}
+	class := Class(c.Fatal.Kind)
 	var built *time.Time
 	if !c.KernelBuilt.IsZero() {
 		built = &c.KernelBuilt
@@ -135,6 +132,19 @@ func (s *Store) Insert(ctx context.Context, e *Event, at time.Time) (id, signatu
 			c.SelfInflicted, c.Fatal.Title(), e.Firmware, e.Majestic, e.SoC, e.Sensor, c.Board, c.Machine, c.Kernel,
 			c.KernelBuild, built, c.Cmdline, uptime, c.Records, orEmpty(c.Modules), fatal, before, anomalies, leadup,
 			meta, e.Redacted, e.BundleSHA256, at)
+		if err != nil || c.Dump == nil {
+			return err
+		}
+		// majestic's dump waits for the symbolizer, which the notice wakes.
+		if _, err := tx.Exec(ctx, `INSERT INTO crash_dumps (event_id, bytes, received_at) VALUES ($1, $2, $3)`,
+			e.ID, c.Dump, at); err != nil {
+			return err
+		}
+		if _, err := tx.Exec(ctx, `INSERT INTO crash_symbolizations (event_id, status, next_try, provisional, at)
+			VALUES ($1, 'pending', $2, $3, $2)`, e.ID, at, e.SignatureID); err != nil {
+			return err
+		}
+		_, err = tx.Exec(ctx, `SELECT pg_notify('crash_symbolize', $1)`, e.ID)
 		return err
 	})
 	return id, signature, dup, err
@@ -201,6 +211,10 @@ func base(kind string, irq bool) float64 {
 		return 25
 	case KindBug:
 		return 20
+	case KindSignal:
+		// No video until majestic is back: the firmware restarts it, and
+		// stops trying when it keeps crashing.
+		return 15
 	}
 	return 3
 }
@@ -210,7 +224,8 @@ func base(kind string, irq bool) float64 {
 const CurrentWindow = 14 * 24 * time.Hour
 
 // Ranked is the signatures, worst first. maintainers also see the bogus,
-// the merged and the self-inflicted (which public lists leave out).
+// the merged, the self-inflicted and majestic's crashes (which public lists
+// leave out).
 func (s *Store) Ranked(ctx context.Context, maintainers bool, now time.Time) ([]*Signature, error) {
 	return s.ranked(ctx, maintainers, "", now)
 }
@@ -232,7 +247,7 @@ func (s *Store) ranked(ctx context.Context, maintainers bool, only string, now t
 		       coalesce(array_agg(DISTINCT ev.firmware) FILTER (WHERE ev.firmware <> ''), '{}'),
 		       max(ev.kernel_built)
 		FROM crash_signatures r LEFT JOIN ev ON ev.root = r.id
-		WHERE ($1 OR (r.merged_into IS NULL AND r.status <> 'bogus')) AND ($2 = '' OR r.id = $2)
+		WHERE ($1 OR (r.merged_into IS NULL AND r.status <> 'bogus' AND r.class <> 'user')) AND ($2 = '' OR r.id = $2)
 		GROUP BY r.id
 		HAVING $1 OR count(ev.id) > 0`, maintainers, only)
 	if err != nil {
@@ -383,6 +398,8 @@ type Detail struct {
 	// Builds: the firmware builds whose time matches the kernel's, newest
 	// guess first -- the build to flash to reproduce it.
 	Builds []Build `json:"builds,omitempty"`
+	// Symbolization: a majestic crash's backtrace, or why there is none yet.
+	Symbolization *Symbolization `json:"symbolization,omitempty"`
 }
 
 // Build is a pushed firmware build.
@@ -401,8 +418,10 @@ func (s *Store) Details(ctx context.Context, id string) ([]Detail, error) {
 	rows, err := s.DB.Query(ctx, `
 		SELECT e.id, e.signature_id, e.received_at, e.channel, e.kind, e.self_inflicted, e.firmware, e.majestic,
 		       e.soc, e.sensor, e.board, e.machine, e.kernel, e.kernel_build, e.kernel_built, e.cmdline, e.uptime,
-		       e.modules, e.fatal, e.before, e.anomalies, e.leadup, e.meta, e.redacted
+		       e.modules, e.fatal, e.before, e.anomalies, e.leadup, e.meta, e.redacted,
+		       y.status, y.attempts, y.frames, y.sources, y.error, y.at
 		FROM crash_events e JOIN crash_signatures sig ON sig.id = e.signature_id
+		LEFT JOIN crash_symbolizations y ON y.event_id = e.id
 		WHERE coalesce(sig.merged_into, sig.id) = $1
 		ORDER BY e.received_at DESC LIMIT $2`, id, MaxDetails)
 	if err != nil {
@@ -410,13 +429,22 @@ func (s *Store) Details(ctx context.Context, id string) ([]Detail, error) {
 	}
 	out, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (Detail, error) {
 		var d Detail
-		var meta []byte
+		var meta, frames, sources []byte
+		var status, symErr *string
+		var attempts *int
+		var at *time.Time
 		err := r.Scan(&d.ID, &d.Signature, &d.ReceivedAt, &d.Channel, &d.Kind, &d.SelfInflicted, &d.Firmware, &d.Majestic,
 			&d.SoC, &d.Sensor, &d.Board, &d.Machine, &d.Kernel, &d.KernelBuild, &d.KernelBuilt, &d.Cmdline, &d.Uptime,
-			&d.Modules, &d.Fatal, &d.Before, &d.Anomalies, &d.Leadup, &meta, &d.Log)
+			&d.Modules, &d.Fatal, &d.Before, &d.Anomalies, &d.Leadup, &meta, &d.Log,
+			&status, &attempts, &frames, &sources, &symErr, &at)
 		if len(meta) > 0 {
 			d.Meta = meta
 		}
+		if status != nil {
+			y := &Symbolization{Status: *status, Attempts: *attempts, Sources: sources, Error: *symErr, At: *at}
+			_ = json.Unmarshal(frames, &y.Frames)
+			d.Symbolization = y
+		}
 		return d, err
 	})
 	if err != nil {
@@ -462,10 +490,13 @@ type Mine struct {
 	Camera        bool `json:"camera"`
 }
 
-// Mine is the crashes the member sent or their linked cameras did.
+// Mine is the crashes the member sent or their linked cameras did. A crash
+// of majestic's is named by its signal alone: where in majestic's source it
+// happened is for the maintainers.
 func (s *Store) Mine(ctx context.Context, member string) ([]Mine, error) {
 	rows, err := s.DB.Query(ctx, `
-		SELECT e.id, coalesce(sig.merged_into, sig.id), e.title, e.kind, root.status, e.soc, e.sensor, e.received_at,
+		SELECT e.id, coalesce(sig.merged_into, sig.id), CASE WHEN e.kind = 'signal' THEN e.fatal->>'reason' ELSE e.title END,
+		       e.kind, root.status, e.soc, e.sensor, e.received_at,
 		       e.self_inflicted, l.member_id IS NOT NULL
 		FROM crash_events e
 		JOIN crash_signatures sig ON sig.id = e.signature_id
diff --git a/service/internal/crashes/symbolize/core.go b/service/internal/crashes/symbolize/core.go
new file mode 100644
index 00000000..5a87451b
--- /dev/null
+++ b/service/internal/crashes/symbolize/core.go
@@ -0,0 +1,239 @@
+// Package symbolize turns majestic's crash dumps into backtraces, in the
+// firmware role: the dump (crashes.Dump) becomes a small ELF core, which
+// gdb-multiarch unwinds against the executable and debuginfo majestic's CI
+// publishes for the build-id, with the firmware build's own libraries for the
+// frames outside majestic. Where gdb stops -- a library with no unwind
+// tables, which is most of them on a camera -- a scan of the stack for return
+// addresses that follow a call finds the probable callers.
+package symbolize
+
+import (
+	"bytes"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"os"
+
+	"github.com/OpenIPC/website/service/internal/crashes"
+)
+
+// Segment is memory to put in the core: the stack, or a module's code read
+// from its file, so gdb and the scan can read the instructions.
+type Segment struct {
+	Addr  uint64
+	Data  []byte
+	Flags elf.ProgFlag
+}
+
+// The ELF core is the least gdb unwinds from: NT_PRSTATUS with the
+// registers in the kernel's elf_gregset_t order, NT_AUXV (AT_PHDR and
+// AT_ENTRY place a PIE), and a PT_LOAD per segment.
+func machine(arch int) (elf.Machine, uint32, error) {
+	switch arch {
+	case crashes.ArchARM:
+		return elf.EM_ARM, 0x05000000, nil // EABI5
+	case crashes.ArchMIPSLE, crashes.ArchMIPSBE:
+		return elf.EM_MIPS, 0, nil
+	case crashes.ArchX86_64:
+		return elf.EM_X86_64, 0, nil
+	case crashes.ArchAArch64:
+		return elf.EM_AARCH64, 0, nil
+	}
+	return 0, 0, fmt.Errorf("no core for architecture %d", arch)
+}
+
+// prstatus is the struct elf_prstatus for the architecture: what the kernel
+// writes in a core, only pr_reg filled in.
+func prstatus(d *crashes.Dump) ([]byte, error) {
+	o := d.Order()
+	r := d.Regs
+	need := func(n int) error {
+		if len(r) < n {
+			return fmt.Errorf("the dump's registers are %d bytes, not the %d its architecture has", len(r), n)
+		}
+		return nil
+	}
+	switch d.Arch {
+	case crashes.ArchARM:
+		// pr_reg at 72: r0..r15, cpsr, orig_r0; from the sigcontext's
+		// trap_no, error_code, oldmask, r0..r15, cpsr.
+		if err := need(20 * 4); err != nil {
+			return nil, err
+		}
+		pr := make([]byte, 148)
+		for i := 0; i < 17; i++ {
+			o.PutUint32(pr[72+4*i:], o.Uint32(r[(3+i)*4:]))
+		}
+		o.PutUint32(pr[72+17*4:], o.Uint32(r[3*4:]))
+		return pr, nil
+	case crashes.ArchMIPSLE, crashes.ArchMIPSBE:
+		// pr_reg at 72: 45 words, r0..r31 from the sixth, then lo, hi, epc,
+		// badvaddr, status, cause; from the sigcontext's regmask, status,
+		// u64 pc, u64 regs[32], u64 fpregs[32], five words, u64 hi, u64 lo.
+		if err := need(568); err != nil {
+			return nil, err
+		}
+		pr := make([]byte, 256)
+		w := func(i int, v uint64) { o.PutUint32(pr[72+4*i:], uint32(v)) }
+		for i := 0; i < 32; i++ {
+			w(6+i, o.Uint64(r[16+8*i:]))
+		}
+		w(38, o.Uint64(r[560:]))
+		w(39, o.Uint64(r[552:]))
+		w(40, o.Uint64(r[8:]))
+		w(42, uint64(o.Uint32(r[4:])))
+		return pr, nil
+	case crashes.ArchX86_64:
+		// pr_reg at 112, user_regs_struct: r15 r14 r13 r12 rbp rbx r11 r10
+		// r9 r8 rax rcx rdx rsi rdi orig_rax rip cs eflags rsp ss fs_base
+		// gs_base ds es fs gs; from gregs: r8..r15, rdi, rsi, rbp, rbx, rdx,
+		// rax, rcx, rsp, rip, eflags, csgsfs.
+		if err := need(19 * 8); err != nil {
+			return nil, err
+		}
+		g := func(i int) uint64 { return o.Uint64(r[8*i:]) }
+		user := []uint64{g(7), g(6), g(5), g(4), g(10), g(11), g(3), g(2), g(1), g(0), g(13), g(14), g(12),
+			g(9), g(8), 0, g(16), g(18) & 0xffff, g(17), g(15), 0x2b, 0, 0, 0, 0, 0, 0}
+		pr := make([]byte, 336)
+		for i, v := range user {
+			o.PutUint64(pr[112+8*i:], v)
+		}
+		return pr, nil
+	case crashes.ArchAArch64:
+		// pr_reg at 112: x0..x30, sp, pc, pstate; from the sigcontext's
+		// fault_address, regs[31], sp, pc, pstate.
+		if err := need(35 * 8); err != nil {
+			return nil, err
+		}
+		pr := make([]byte, 392)
+		copy(pr[112:112+34*8], r[8:8+34*8])
+		return pr, nil
+	}
+	return nil, fmt.Errorf("no core for architecture %d", d.Arch)
+}
+
+func note(o binary.ByteOrder, typ uint32, desc []byte) []byte {
+	var b bytes.Buffer
+	name := []byte("CORE\x00\x00\x00\x00") // "CORE\0", padded to 4
+	hdr := make([]byte, 12)
+	o.PutUint32(hdr, 5)
+	o.PutUint32(hdr[4:], uint32(len(desc)))
+	o.PutUint32(hdr[8:], typ)
+	b.Write(hdr)
+	b.Write(name)
+	b.Write(desc)
+	for b.Len()%4 != 0 {
+		b.WriteByte(0)
+	}
+	return b.Bytes()
+}
+
+// Core is the dump as an ELF core: its registers and its stack, and segs
+// beside them.
+func Core(d *crashes.Dump, segs []Segment) ([]byte, error) {
+	mach, flags, err := machine(d.Arch)
+	if err != nil {
+		return nil, err
+	}
+	pr, err := prstatus(d)
+	if err != nil {
+		return nil, err
+	}
+	o := d.Order()
+	notes := append(note(o, uint32(elf.NT_PRSTATUS), pr), note(o, 6 /* NT_AUXV */, d.Auxv)...)
+	all := append([]Segment{{Addr: d.StackAt, Data: d.Stack, Flags: elf.PF_R | elf.PF_W}}, segs...)
+
+	is64 := d.Is64()
+	ehsize, phsize := 52, 32
+	if is64 {
+		ehsize, phsize = 64, 56
+	}
+	phnum := 1 + len(all)
+	off := uint64(ehsize + phsize*phnum)
+	var hdr, ph, body bytes.Buffer
+
+	ident := [16]byte{0x7f, 'E', 'L', 'F'}
+	ident[elf.EI_CLASS] = byte(elf.ELFCLASS32)
+	if is64 {
+		ident[elf.EI_CLASS] = byte(elf.ELFCLASS64)
+	}
+	ident[elf.EI_DATA] = byte(elf.ELFDATA2LSB)
+	if o == binary.BigEndian {
+		ident[elf.EI_DATA] = byte(elf.ELFDATA2MSB)
+	}
+	ident[elf.EI_VERSION] = byte(elf.EV_CURRENT)
+	hdr.Write(ident[:])
+	put := func(b *bytes.Buffer, size int, v uint64) {
+		switch size {
+		case 2:
+			_ = binary.Write(b, o, uint16(v))
+		case 4:
+			_ = binary.Write(b, o, uint32(v))
+		default:
+			_ = binary.Write(b, o, v)
+		}
+	}
+	word := 4
+	if is64 {
+		word = 8
+	}
+	put(&hdr, 2, uint64(elf.ET_CORE))
+	put(&hdr, 2, uint64(mach))
+	put(&hdr, 4, 1)
+	put(&hdr, word, 0)              // entry
+	put(&hdr, word, uint64(ehsize)) // phoff
+	put(&hdr, word, 0)              // shoff
+	put(&hdr, 4, uint64(flags))
+	put(&hdr, 2, uint64(ehsize))
+	put(&hdr, 2, uint64(phsize))
+	put(&hdr, 2, uint64(phnum))
+	put(&hdr, 2, 0)
+	put(&hdr, 2, 0)
+	put(&hdr, 2, 0)
+
+	phdr := func(typ elf.ProgType, fl elf.ProgFlag, offset, addr, size, align uint64) {
+		put(&ph, 4, uint64(typ))
+		if is64 {
+			put(&ph, 4, uint64(fl))
+		}
+		put(&ph, word, offset)
+		put(&ph, word, addr)
+		put(&ph, word, 0)
+		put(&ph, word, size)
+		put(&ph, word, size)
+		if !is64 {
+			put(&ph, 4, uint64(fl))
+		}
+		put(&ph, word, align)
+	}
+	phdr(elf.PT_NOTE, 0, off, 0, uint64(len(notes)), 4)
+	body.Write(notes)
+	for _, s := range all {
+		phdr(elf.PT_LOAD, s.Flags, off+uint64(body.Len()), s.Addr, uint64(len(s.Data)), 1)
+		body.Write(s.Data)
+	}
+	return append(append(hdr.Bytes(), ph.Bytes()...), body.Bytes()...), nil
+}
+
+// CodeOf is a module's code, read from its file and placed at its load
+// bias: the executable segments only, which are what gdb's and the scan's
+// reading of instructions needs.
+func CodeOf(path string, bias uint64) ([]Segment, error) {
+	f, err := elf.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	var out []Segment
+	for _, p := range f.Progs {
+		if p.Type != elf.PT_LOAD || p.Flags&elf.PF_X == 0 || p.Off+p.Filesz > uint64(len(raw)) {
+			continue
+		}
+		out = append(out, Segment{Addr: bias + p.Vaddr, Data: raw[p.Off : p.Off+p.Filesz], Flags: p.Flags})
+	}
+	return out, nil
+}
diff --git a/service/internal/crashes/symbolize/frames.py b/service/internal/crashes/symbolize/frames.py
new file mode 100644
index 00000000..b3a997d2
--- /dev/null
+++ b/service/internal/crashes/symbolize/frames.py
@@ -0,0 +1,56 @@
+# Run inside gdb by the symbolize package: the backtrace of the core loaded,
+# and what a list of addresses are, as one JSON line each. gdb's own `bt` is
+# for people; this is for a parser. Frame arguments are never read: they are
+# majestic's memory, and the stack slice is enough to unwind.
+import gdb
+import json
+
+
+def _where(pc, frame=None):
+    out = {"pc": int(pc), "fn": "", "file": "", "line": 0}
+    try:
+        block = frame.block() if frame is not None else gdb.block_for_pc(int(pc))
+        while block is not None and block.function is None:
+            block = block.superblock
+        if block is not None and block.function is not None:
+            out["fn"] = block.function.name
+    except RuntimeError:
+        pass
+    if not out["fn"] and frame is not None and frame.name():
+        out["fn"] = frame.name()
+    if not out["fn"]:
+        sym = gdb.execute("info symbol 0x%x" % int(pc), to_string=True).strip()
+        if sym and not sym.startswith("No symbol"):
+            out["fn"] = sym.split(" ")[0]
+    sal = frame.find_sal() if frame is not None else gdb.find_pc_line(int(pc))
+    if sal is not None and sal.symtab is not None:
+        out["file"] = sal.symtab.filename
+        out["line"] = sal.line
+    return out
+
+
+def unwind(limit=64):
+    frames = []
+    stop = ""
+    f = gdb.newest_frame()
+    while f is not None and len(frames) < limit:
+        w = _where(f.pc(), f)
+        try:
+            w["sp"] = int(f.read_register("sp"))
+        except (gdb.error, ValueError):
+            w["sp"] = 0
+        w["inline"] = f.type() == gdb.INLINE_FRAME
+        frames.append(w)
+        try:
+            older = f.older()
+        except gdb.error as e:
+            stop = str(e)
+            break
+        if older is None:
+            stop = gdb.frame_stop_reason_string(f.unwind_stop_reason())
+        f = older
+    print("@@FRAMES " + json.dumps({"frames": frames, "stop": stop}))
+
+
+def resolve(addrs):
+    print("@@RESOLVED " + json.dumps([_where(a) for a in addrs]))
diff --git a/service/internal/crashes/symbolize/gdb.go b/service/internal/crashes/symbolize/gdb.go
new file mode 100644
index 00000000..35e9c911
--- /dev/null
+++ b/service/internal/crashes/symbolize/gdb.go
@@ -0,0 +1,165 @@
+package symbolize
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	_ "embed"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+//go:embed frames.py
+var framesPy []byte
+
+// GDB is the gdb-multiarch that unwinds: its path, and how long one run may
+// take.
+type GDB struct {
+	Path    string
+	Timeout time.Duration
+}
+
+// ErrNoGDB is a host without gdb-multiarch.
+var ErrNoGDB = errors.New("gdb-multiarch is not installed")
+
+// RawFrame is a frame as gdb unwound it.
+type RawFrame struct {
+	PC     uint64 `json:"pc"`
+	SP     uint64 `json:"sp"`
+	Fn     string `json:"fn"`
+	File   string `json:"file"`
+	Line   int    `json:"line"`
+	Inline bool   `json:"inline"`
+}
+
+// Where is what an address is, as gdb resolves it.
+type Where struct {
+	PC   uint64 `json:"pc"`
+	Fn   string `json:"fn"`
+	File string `json:"file"`
+	Line int    `json:"line"`
+}
+
+// Session is what one gdb run loads: majestic's executable, the directory
+// its debuginfo is found in by build-id, and the core.
+type Session struct {
+	Executable string
+	DebugDir   string
+	Core       string
+}
+
+func (g *GDB) path() (string, error) {
+	p := g.Path
+	if p == "" {
+		p = "gdb-multiarch"
+	}
+	found, err := exec.LookPath(p)
+	if err != nil {
+		return "", ErrNoGDB
+	}
+	return found, nil
+}
+
+// run loads the session and runs the python call, and returns the JSON the
+// line marked with tag carries.
+func (g *GDB) run(ctx context.Context, s Session, call, tag string) ([]byte, error) {
+	bin, err := g.path()
+	if err != nil {
+		return nil, err
+	}
+	dir, err := os.MkdirTemp("", "symbolize-")
+	if err != nil {
+		return nil, err
+	}
+	defer os.RemoveAll(dir)
+	script := filepath.Join(dir, "frames.py")
+	if err := os.WriteFile(script, framesPy, 0o600); err != nil {
+		return nil, err
+	}
+	timeout := g.Timeout
+	if timeout == 0 {
+		timeout = time.Minute
+	}
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	// Nothing from the host: no init files, no debuginfod, no auto-loaded
+	// scripts, no libraries from the host's own root.
+	args := []string{"-batch", "-nx", "-nh", "-q",
+		"-iex", "set debuginfod enabled off",
+		"-iex", "set auto-load off",
+		"-iex", "set sysroot /nonexistent",
+		"-iex", "set pagination off",
+		"-iex", "set print frame-arguments none",
+		"-ex", "set debug-file-directory " + s.DebugDir,
+		"-ex", "file " + s.Executable,
+		"-ex", "core-file " + s.Core,
+		"-ex", "source " + script,
+		"-ex", "python " + call,
+	}
+	cmd := exec.CommandContext(ctx, bin, args...)
+	cmd.Env = []string{"HOME=" + dir, "PATH=/usr/bin:/bin", "LC_ALL=C"}
+	var out, stderr bytes.Buffer
+	cmd.Stdout, cmd.Stderr = &out, &stderr
+	err = cmd.Run()
+	sc := bufio.NewScanner(&out)
+	sc.Buffer(make([]byte, 1<<20), 8<<20)
+	for sc.Scan() {
+		if v, ok := strings.CutPrefix(sc.Text(), tag+" "); ok {
+			return []byte(v), nil
+		}
+	}
+	if err == nil {
+		err = errors.New("no result")
+	}
+	return nil, fmt.Errorf("gdb: %w: %s", err, lastLines(stderr.String()+out.String(), 6))
+}
+
+func lastLines(s string, n int) string {
+	lines := strings.Split(strings.TrimSpace(s), "\n")
+	if len(lines) > n {
+		lines = lines[len(lines)-n:]
+	}
+	return strings.Join(lines, " | ")
+}
+
+// Unwind is the backtrace gdb makes of the core, and why it stopped.
+func (g *GDB) Unwind(ctx context.Context, s Session) ([]RawFrame, string, error) {
+	b, err := g.run(ctx, s, "unwind()", "@@FRAMES")
+	if err != nil {
+		return nil, "", err
+	}
+	var v struct {
+		Frames []RawFrame `json:"frames"`
+		Stop   string     `json:"stop"`
+	}
+	if err := json.Unmarshal(b, &v); err != nil {
+		return nil, "", fmt.Errorf("gdb's frames: %w", err)
+	}
+	return v.Frames, v.Stop, nil
+}
+
+// Resolve names addresses in majestic: function, file and line.
+func (g *GDB) Resolve(ctx context.Context, s Session, addrs []uint64) ([]Where, error) {
+	if len(addrs) == 0 {
+		return nil, nil
+	}
+	list := make([]string, len(addrs))
+	for i, a := range addrs {
+		list[i] = fmt.Sprintf("%d", a)
+	}
+	b, err := g.run(ctx, s, "resolve(["+strings.Join(list, ",")+"])", "@@RESOLVED")
+	if err != nil {
+		return nil, err
+	}
+	var out []Where
+	if err := json.Unmarshal(b, &out); err != nil {
+		return nil, fmt.Errorf("gdb's addresses: %w", err)
+	}
+	return out, nil
+}
diff --git a/service/internal/crashes/symbolize/rootfs_test.go b/service/internal/crashes/symbolize/rootfs_test.go
new file mode 100644
index 00000000..bd31be23
--- /dev/null
+++ b/service/internal/crashes/symbolize/rootfs_test.go
@@ -0,0 +1,114 @@
+package symbolize
+
+import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/OpenIPC/website/service/internal/db/dbtest"
+	"github.com/OpenIPC/website/service/internal/firmware"
+)
+
+// A firmware build's tarball, as the release cache already holds it: the
+// rootfs is found by the build and platform meta.json names, unpacked, and a
+// library the camera mapped is read from it -- musl's libc.so through its
+// absolute link, as the image has it.
+func TestRootfsUnpacksTheBuildsLibraries(t *testing.T) {
+	mksquashfs, err := exec.LookPath("mksquashfs")
+	if err != nil {
+		if os.Getenv("CI") != "" {
+			t.Fatal("squashfs-tools is not installed, and CI is set")
+		}
+		t.Skip("squashfs-tools is not installed")
+	}
+	pool := dbtest.New(t)
+	ctx := context.Background()
+
+	img := t.TempDir()
+	lib := filepath.Join(img, "lib")
+	if err := os.MkdirAll(lib, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	libtoy, _ := os.ReadFile(filepath.Join(fixtures, "arm", "libtoy.so"))
+	if err := os.WriteFile(filepath.Join(lib, "ld-musl-arm.so.1"), libtoy, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink("/lib/ld-musl-arm.so.1", filepath.Join(lib, "libc.so")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Join(img, "etc"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(img, "etc", "shadow"), []byte("root:x"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	squash := filepath.Join(t.TempDir(), "rootfs.squashfs")
+	if out, err := exec.Command(mksquashfs, img, squash, "-noappend", "-quiet", "-all-root").CombinedOutput(); err != nil {
+		t.Fatalf("mksquashfs: %v %s", err, out)
+	}
+	sq, _ := os.ReadFile(squash)
+	var tgz bytes.Buffer
+	zw := gzip.NewWriter(&tgz)
+	tw := tar.NewWriter(zw)
+	for name, body := range map[string][]byte{"uImage.toy": []byte("kernel"), "rootfs.squashfs.toy": sq} {
+		tw.WriteHeader(&tar.Header{Name: name, Mode: 0o644, Size: int64(len(body)), Typeflag: tar.TypeReg})
+		tw.Write(body)
+	}
+	tw.Close()
+	zw.Close()
+	sum := sha256.Sum256(tgz.Bytes())
+	digest := hex.EncodeToString(sum[:])
+
+	now := time.Date(2026, 10, 9, 0, 0, 0, 0, time.UTC)
+	if _, err := pool.Exec(ctx, `INSERT INTO builds (id, source, release, sha, built_at, published_at, pushed_by)
+		VALUES ('nightly-20261009-0000000', 'firmware', 'nightly-20261009-0000000', $1, $2, $2, 'test')`,
+		"0000000000000000000000000000000000000000", now); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `INSERT INTO build_assets (build_id, name, size, sha256, board, storage, edition)
+		VALUES ('nightly-20261009-0000000', 'openipc.toy-nor-lite.tgz', $1, $2, 'toy', 'nor', 'lite')`,
+		tgz.Len(), digest); err != nil {
+		t.Fatal(err)
+	}
+	cache := t.TempDir()
+	rel := &firmware.Releases{Root: cache, Base: "http://127.0.0.1:1/never"}
+	blob := rel.Path(firmware.Asset{Name: "openipc.toy-nor-lite.tgz", Size: int64(tgz.Len()), Digest: "sha256:" + digest})
+	if err := os.MkdirAll(filepath.Dir(blob), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(blob, tgz.Bytes(), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	r := &Rootfs{Root: filepath.Join(cache, "symbols"), DB: pool, Releases: rel}
+	dir, err := r.Dir(ctx, "nightly-20261009-0000000", "toy_lite")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := Library(dir, "/lib/libc.so")
+	if b, _ := os.ReadFile(got); !bytes.Equal(b, libtoy) {
+		t.Fatalf("libc.so is %q", got)
+	}
+	// Only the libraries are unpacked.
+	if _, err := os.Stat(filepath.Join(dir, "etc", "shadow")); err == nil {
+		t.Fatal("unpacked /etc")
+	}
+	// Unpacked once: the second ask is the directory already there.
+	if again, err := r.Dir(ctx, "nightly-20261009-0000000", "toy_lite"); err != nil || again != dir {
+		t.Fatalf("%v %s", err, again)
+	}
+	if _, err := r.Dir(ctx, "nightly-20990101-0000000", "toy_lite"); err == nil {
+		t.Fatal("a build the site does not have was unpacked")
+	}
+	if _, err := r.Dir(ctx, "../../etc", "toy_lite"); err == nil {
+		t.Fatal("a build named as a path was looked up")
+	}
+}
diff --git a/service/internal/crashes/symbolize/scan.go b/service/internal/crashes/symbolize/scan.go
new file mode 100644
index 00000000..1c59da57
--- /dev/null
+++ b/service/internal/crashes/symbolize/scan.go
@@ -0,0 +1,133 @@
+package symbolize
+
+import (
+	"encoding/binary"
+
+	"github.com/OpenIPC/website/service/internal/crashes"
+)
+
+// Memory is the code the scan may read: the modules' executable segments.
+type Memory []Segment
+
+// read is n bytes at addr, or nil where no segment holds them all.
+func (m Memory) read(addr uint64, n int) []byte {
+	for _, s := range m {
+		// addr-4 of a small word wraps around: compared by offset, never by
+		// a sum that can overflow.
+		if addr >= s.Addr && n <= len(s.Data) && addr-s.Addr <= uint64(len(s.Data)-n) {
+			return s.Data[addr-s.Addr : addr-s.Addr+uint64(n)]
+		}
+	}
+	return nil
+}
+
+// Candidate is a return address found on the stack.
+type Candidate struct {
+	Slot uint64 // where on the stack it was
+	Call uint64 // an address inside the call instruction before it
+}
+
+// maxCandidates is how many callers a scan reports.
+const maxCandidates = 24
+
+// Scan reads the stack from `from` up for words that are return addresses:
+// they point into code, and the instruction before each is a call. A stack
+// holds more than live frames -- locals, saved registers, the leftovers of
+// calls that returned -- so this is what was probably calling, not a
+// certainty: dead frames below the live ones are why the scan starts where
+// the unwinder stopped, not at the fault.
+func Scan(d *crashes.Dump, from uint64, code Memory) []Candidate {
+	if from < d.StackAt {
+		from = d.StackAt
+	}
+	size := 4
+	if d.Is64() {
+		size = 8
+	}
+	o := d.Order()
+	var out []Candidate
+	start := int(from - d.StackAt)
+	start += (size - start%size) % size
+	for i := start; i+size <= len(d.Stack) && len(out) < maxCandidates; i += size {
+		var w uint64
+		if size == 4 {
+			w = uint64(o.Uint32(d.Stack[i:]))
+		} else {
+			w = o.Uint64(d.Stack[i:])
+		}
+		call, ok := callBefore(d.Arch, o, w, code)
+		if !ok {
+			continue
+		}
+		if n := len(out); n > 0 && out[n-1].Call == call {
+			continue
+		}
+		out = append(out, Candidate{Slot: d.StackAt + uint64(i), Call: call})
+	}
+	return out
+}
+
+// callBefore says whether the instruction before return address ra is a
+// call, and gives an address inside it: the call site, which is the line a
+// caller's frame names.
+func callBefore(arch int, o binary.ByteOrder, ra uint64, code Memory) (uint64, bool) {
+	switch arch {
+	case crashes.ArchARM:
+		if ra&1 == 1 {
+			// Thumb: BL or BLX (immediate), 32 bits; BLX (register), 16.
+			ra &^= 1
+			if b := code.read(ra-4, 4); b != nil {
+				h1, h2 := o.Uint16(b), o.Uint16(b[2:])
+				if h1&0xf800 == 0xf000 && (h2&0xd000 == 0xd000 || h2&0xd001 == 0xc000) {
+					return ra - 2, true
+				}
+			}
+			if b := code.read(ra-2, 2); b != nil && o.Uint16(b)&0xff87 == 0x4780 {
+				return ra - 2, true
+			}
+			return 0, false
+		}
+		// ARM: BL, BLX (immediate), BLX (register).
+		if b := code.read(ra-4, 4); b != nil {
+			i := o.Uint32(b)
+			if (i&0x0f000000 == 0x0b000000 && i>>28 != 0xf) || i&0xfe000000 == 0xfa000000 || i&0x0ffffff0 == 0x012fff30 {
+				return ra - 4, true
+			}
+		}
+	case crashes.ArchMIPSLE, crashes.ArchMIPSBE:
+		// The return address is past the call and its delay slot: JAL, JALX,
+		// JALR, BAL/BGEZAL/BLTZAL.
+		if ra&3 != 0 {
+			return 0, false
+		}
+		if b := code.read(ra-8, 4); b != nil {
+			i := o.Uint32(b)
+			op := i >> 26
+			rt := (i >> 16) & 0x1f
+			if op == 3 || op == 29 || (op == 0 && i&0x3f == 9) || (op == 1 && (rt == 0x11 || rt == 0x10)) {
+				return ra - 8, true
+			}
+		}
+	case crashes.ArchX86_64:
+		// CALL rel32, or CALL r/m (FF /2) in its register, memory and
+		// displacement forms, with or without a REX prefix.
+		if b := code.read(ra-5, 5); b != nil && b[0] == 0xe8 {
+			return ra - 1, true
+		}
+		for _, n := range []int{2, 3, 4, 6, 7} {
+			b := code.read(ra-uint64(n), 2)
+			if b != nil && b[0] == 0xff && (b[1]>>3)&7 == 2 {
+				return ra - 1, true
+			}
+		}
+	case crashes.ArchAArch64:
+		// BL, BLR.
+		if b := code.read(ra-4, 4); b != nil {
+			i := o.Uint32(b)
+			if i&0xfc000000 == 0x94000000 || i&0xfffffc1f == 0xd63f0000 {
+				return ra - 4, true
+			}
+		}
+	}
+	return 0, false
+}
diff --git a/service/internal/crashes/symbolize/sources.go b/service/internal/crashes/symbolize/sources.go
new file mode 100644
index 00000000..e42f1b3f
--- /dev/null
+++ b/service/internal/crashes/symbolize/sources.go
@@ -0,0 +1,339 @@
+package symbolize
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"golang.org/x/sync/singleflight"
+
+	"github.com/OpenIPC/website/service/internal/firmware"
+)
+
+// Symbols is majestic's executable and debuginfo by build-id, from where
+// majestic's CI publishes them (<Base>/<build-id>/executable and
+// /debuginfo), kept under Root:
+//
+//	Root/buildid/<id>/executable
+//	Root/debug/.build-id/<id[:2]>/<id[2:]>.debug   (where gdb looks)
+type Symbols struct {
+	Root string
+	Base string // https://openipc.s3.eu-west-1.amazonaws.com/buildid
+	HTTP *http.Client
+
+	flight singleflight.Group
+}
+
+// ErrNotPublished is a build-id CI has not published: a build of someone's
+// own, or one whose upload has not landed yet.
+var ErrNotPublished = errors.New("no executable and debuginfo are published for this build-id")
+
+var buildIDRe = regexp.MustCompile(`^[0-9a-f]{16,64}$`)
+
+// maxSymbolFile bounds what one file of them may be.
+const maxSymbolFile = 128 << 20
+
+// DebugDir is the directory gdb finds debuginfo in by build-id.
+func (s *Symbols) DebugDir() string { return filepath.Join(s.Root, "debug") }
+
+// Get is the executable's path, its debuginfo in DebugDir, fetched once.
+func (s *Symbols) Get(ctx context.Context, id string) (string, error) {
+	if !buildIDRe.MatchString(id) {
+		return "", fmt.Errorf("%q is not a build-id", id)
+	}
+	exe := filepath.Join(s.Root, "buildid", id, "executable")
+	dbg := filepath.Join(s.DebugDir(), ".build-id", id[:2], id[2:]+".debug")
+	if have(exe) && have(dbg) {
+		touch(exe, dbg)
+		return exe, nil
+	}
+	_, err, _ := s.flight.Do(id, func() (any, error) {
+		if err := s.fetch(ctx, id+"/executable", exe); err != nil {
+			return nil, err
+		}
+		return nil, s.fetch(ctx, id+"/debuginfo", dbg)
+	})
+	if err != nil {
+		return "", err
+	}
+	return exe, nil
+}
+
+func have(p string) bool {
+	st, err := os.Stat(p)
+	return err == nil && st.Mode().IsRegular() && st.Size() > 0
+}
+
+// touch marks files used, for Sweep.
+func touch(paths ...string) {
+	now := time.Now()
+	for _, p := range paths {
+		_ = os.Chtimes(p, now, now)
+	}
+}
+
+func (s *Symbols) fetch(ctx context.Context, name, dest string) error {
+	if have(dest) {
+		return nil
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(s.Base, "/")+"/"+name, nil)
+	if err != nil {
+		return err
+	}
+	client := s.HTTP
+	if client == nil {
+		client = &http.Client{Timeout: 5 * time.Minute}
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	// S3 answers a key it does not have 403 to an anonymous reader.
+	if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusForbidden {
+		return ErrNotPublished
+	}
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("%s answered %d", name, resp.StatusCode)
+	}
+	return writeAtomic(dest, io.LimitReader(resp.Body, maxSymbolFile+1), maxSymbolFile)
+}
+
+func writeAtomic(dest string, r io.Reader, limit int64) error {
+	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		return err
+	}
+	var b [4]byte
+	_, _ = rand.Read(b[:])
+	tmp := dest + ".tmp-" + hex.EncodeToString(b[:])
+	defer os.Remove(tmp)
+	f, err := os.OpenFile(tmp, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
+	if err != nil {
+		return err
+	}
+	n, err := io.Copy(f, r)
+	if err == nil && n > limit {
+		err = fmt.Errorf("%s is larger than %d bytes", filepath.Base(dest), limit)
+	}
+	if err == nil {
+		err = f.Sync()
+	}
+	if cerr := f.Close(); err == nil {
+		err = cerr
+	}
+	if err != nil {
+		return err
+	}
+	return os.Rename(tmp, dest)
+}
+
+// Rootfs is the libraries of the firmware build a camera ran, from that
+// build's release tarball: its rootfs's /lib and /usr/lib, unpacked once
+// under Root/rootfs/<build>/<platform>.
+type Rootfs struct {
+	Root     string
+	DB       *pgxpool.Pool
+	Releases *firmware.Releases
+	// Unsquashfs is the path to unsquashfs; "" looks it up.
+	Unsquashfs string
+
+	flight singleflight.Group
+}
+
+// ErrNoBuild is a firmware build the site does not know or no longer keeps.
+var ErrNoBuild = errors.New("the firmware build is not among the pushed builds")
+
+var safeName = regexp.MustCompile(`^[A-Za-z0-9._-]{1,128}$`)
+
+// Dir is the unpacked rootfs of the build (meta.json's firmware.build_id)
+// for the platform (its firmware.platform, as gk7205v300_lite).
+func (r *Rootfs) Dir(ctx context.Context, build, platform string) (string, error) {
+	if !safeName.MatchString(build) || !safeName.MatchString(platform) {
+		return "", ErrNoBuild
+	}
+	dir := filepath.Join(r.Root, "rootfs", build, platform)
+	if have(filepath.Join(dir, ".done")) {
+		touch(filepath.Join(dir, ".done"))
+		return dir, nil
+	}
+	_, err, _ := r.flight.Do(build+"/"+platform, func() (any, error) {
+		return nil, r.unpack(ctx, build, platform, dir)
+	})
+	if err != nil {
+		return "", err
+	}
+	return dir, nil
+}
+
+func (r *Rootfs) unpack(ctx context.Context, build, platform, dir string) error {
+	board, edition := platform, ""
+	if i := strings.LastIndex(platform, "_"); i > 0 {
+		board, edition = platform[:i], platform[i+1:]
+	}
+	var a firmware.Asset
+	var sha string
+	// The NOR image's rootfs: the NAND one's holds the same files.
+	err := r.DB.QueryRow(ctx, `
+		SELECT a.name, a.size, a.sha256, b.release FROM build_assets a JOIN builds b ON b.id = a.build_id
+		WHERE b.source = 'firmware' AND b.id = $1 AND a.board = $2 AND coalesce(a.edition, '') = $3
+		ORDER BY a.storage = 'nor' DESC, a.name LIMIT 1`, build, board, edition).Scan(&a.Name, &a.Size, &sha, &a.Release)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return ErrNoBuild
+	}
+	if err != nil {
+		return err
+	}
+	a.Digest = "sha256:" + sha
+	tgz, err := r.Releases.Get(ctx, a)
+	if err != nil {
+		return err
+	}
+	tmp := dir + ".tmp"
+	_ = os.RemoveAll(tmp)
+	defer os.RemoveAll(tmp)
+	if err := os.MkdirAll(tmp, 0o755); err != nil {
+		return err
+	}
+	squash := filepath.Join(tmp, "rootfs.squashfs")
+	if err := rootfsOf(tgz, squash); err != nil {
+		return err
+	}
+	bin := r.Unsquashfs
+	if bin == "" {
+		if bin, err = exec.LookPath("unsquashfs"); err != nil {
+			return errors.New("unsquashfs is not installed")
+		}
+	}
+	cctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+	out, err := exec.CommandContext(cctx, bin, "-no-xattrs", "-no-progress", "-d", filepath.Join(tmp, "root"),
+		squash, "lib", "usr/lib").CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("unsquashfs: %w: %s", err, lastLines(string(out), 3))
+	}
+	_ = os.Remove(squash)
+	if err := os.WriteFile(filepath.Join(tmp, "root", ".done"), nil, 0o644); err != nil {
+		return err
+	}
+	_ = os.RemoveAll(dir)
+	if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil {
+		return err
+	}
+	return os.Rename(filepath.Join(tmp, "root"), dir)
+}
+
+// rootfsOf copies the rootfs image out of a firmware tarball:
+// rootfs.squashfs.<soc> beside uImage.<soc>.
+func rootfsOf(tgz, dest string) error {
+	f, err := os.Open(tgz)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	z, err := gzip.NewReader(f)
+	if err != nil {
+		return err
+	}
+	tr := tar.NewReader(z)
+	for {
+		h, err := tr.Next()
+		if errors.Is(err, io.EOF) {
+			return errors.New("the firmware tarball has no rootfs.squashfs")
+		}
+		if err != nil {
+			return err
+		}
+		if h.Typeflag == tar.TypeReg && strings.HasPrefix(filepath.Base(h.Name), "rootfs.squashfs") {
+			return writeAtomic(dest, tr, 256<<20)
+		}
+	}
+}
+
+// Library is the file in the unpacked rootfs that a path on the camera
+// names, its symlinks followed as the camera would follow them -- inside the
+// image, never into the host's own /lib; "" when there is none. The path
+// comes from the camera's memory map, so it is not trusted to stay inside.
+func Library(root, camPath string) string {
+	return library(root, camPath, 0)
+}
+
+func library(root, camPath string, depth int) string {
+	if root == "" || depth > 8 || !strings.HasPrefix(camPath, "/") {
+		return ""
+	}
+	rel := filepath.Clean(camPath)
+	// Every directory on the way is the image's own, not a link out of it.
+	dir := root
+	parts := strings.Split(strings.TrimPrefix(rel, "/"), "/")
+	for i, part := range parts {
+		p := filepath.Join(dir, part)
+		st, err := os.Lstat(p)
+		if err != nil {
+			return ""
+		}
+		if st.Mode()&os.ModeSymlink != 0 {
+			target, err := os.Readlink(p)
+			if err != nil {
+				return ""
+			}
+			if !strings.HasPrefix(target, "/") {
+				target = filepath.Join("/", strings.Join(parts[:i], "/"), target)
+			}
+			return library(root, filepath.Join(target, strings.Join(parts[i+1:], "/")), depth+1)
+		}
+		if i < len(parts)-1 && !st.IsDir() {
+			return ""
+		}
+		dir = p
+	}
+	if !have(dir) {
+		return ""
+	}
+	return dir
+}
+
+// Sweep removes what nothing has used for maxAge: builds of majestic and
+// rootfs images of firmware no camera has crashed on lately.
+func Sweep(root string, maxAge time.Duration) (removed int) {
+	cut := time.Now().Add(-maxAge)
+	old := func(p string) bool {
+		st, err := os.Stat(p)
+		return err == nil && st.ModTime().Before(cut)
+	}
+	ids, _ := filepath.Glob(filepath.Join(root, "buildid", "*"))
+	for _, d := range ids {
+		exe := filepath.Join(d, "executable")
+		if old(exe) || !have(exe) {
+			id := filepath.Base(d)
+			if len(id) > 2 {
+				_ = os.Remove(filepath.Join(root, "debug", ".build-id", id[:2], id[2:]+".debug"))
+			}
+			if os.RemoveAll(d) == nil {
+				removed++
+			}
+		}
+	}
+	builds, _ := filepath.Glob(filepath.Join(root, "rootfs", "*", "*"))
+	for _, d := range builds {
+		if strings.HasSuffix(d, ".tmp") && old(d) || !strings.HasSuffix(d, ".tmp") && old(filepath.Join(d, ".done")) {
+			if os.RemoveAll(d) == nil {
+				removed++
+			}
+		}
+	}
+	return removed
+}
diff --git a/service/internal/crashes/symbolize/symbolize.go b/service/internal/crashes/symbolize/symbolize.go
new file mode 100644
index 00000000..a60420c1
--- /dev/null
+++ b/service/internal/crashes/symbolize/symbolize.go
@@ -0,0 +1,312 @@
+package symbolize
+
+import (
+	"context"
+	"debug/elf"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/OpenIPC/website/service/internal/crashes"
+)
+
+// Symbolizer makes backtraces of majestic's dumps.
+type Symbolizer struct {
+	Symbols *Symbols
+	// Rootfs is the firmware builds' libraries; nil names library frames
+	// by nothing but their module.
+	Rootfs Libraries
+	GDB    GDB
+}
+
+// Libraries is where a firmware build's root filesystem is unpacked.
+type Libraries interface {
+	Dir(ctx context.Context, build, platform string) (string, error)
+}
+
+// Firmware is what meta.json says the camera ran: the build and its platform.
+type Firmware struct {
+	Build    string
+	Platform string
+}
+
+// Result is a dump's backtrace, innermost first, and what made it.
+type Result struct {
+	Frames  []crashes.Frame
+	Sources map[string]any
+}
+
+// maxProbable is how many callers the scan adds past where gdb stopped.
+const maxProbable = 12
+
+// outermost are the frames a thread's stack ends in: past them there is
+// nothing to look for.
+var outermost = map[string]bool{
+	"main": true, "_start": true, "_start_c": true, "__libc_start_main": true, "libc_start_main_stage2": true,
+	"start_thread": true, "__clone": true, "clone": true, "thread_start": true,
+}
+
+// Symbolize unwinds a dump. ErrNotPublished means majestic's build is not
+// one CI published (yet); anything else may be worth trying again.
+func (s *Symbolizer) Symbolize(ctx context.Context, raw []byte, fw Firmware) (*Result, error) {
+	d, err := crashes.ReadDump(raw)
+	if err != nil {
+		return nil, err
+	}
+	main, ok := d.Main()
+	if !ok || main.BuildID == "" {
+		return nil, fmt.Errorf("%w: the dump names no build-id for majestic", ErrNotPublished)
+	}
+	sources := map[string]any{"build_id": main.BuildID}
+	exe, err := s.Symbols.Get(ctx, main.BuildID)
+	if err != nil {
+		return nil, err
+	}
+
+	// The libraries the camera ran, from its firmware build's rootfs.
+	libs := map[string]string{}
+	if s.Rootfs != nil && fw.Build != "" {
+		root, err := s.Rootfs.Dir(ctx, fw.Build, fw.Platform)
+		if err != nil {
+			sources["libraries_error"] = err.Error()
+		} else {
+			sources["firmware"] = fw.Build + "/" + fw.Platform
+			var found []string
+			for _, m := range d.Modules[1:] {
+				if p := Library(root, m.Path); p != "" && sameBuild(p, m.BuildID) {
+					libs[m.Path] = p
+					found = append(found, crashes.ModuleName(m.Path))
+				}
+			}
+			sort.Strings(found)
+			sources["libraries"] = found
+		}
+	}
+
+	code, err := CodeOf(exe, main.Bias)
+	if err != nil {
+		return nil, fmt.Errorf("majestic's executable: %w", err)
+	}
+	for _, m := range d.Modules[1:] {
+		if p := libs[m.Path]; p != "" {
+			if segs, err := CodeOf(p, m.Bias); err == nil {
+				code = append(code, segs...)
+			}
+		}
+	}
+	core, err := Core(d, code)
+	if err != nil {
+		return nil, err
+	}
+	dir, err := os.MkdirTemp("", "crash-core-")
+	if err != nil {
+		return nil, err
+	}
+	defer os.RemoveAll(dir)
+	corePath := filepath.Join(dir, "core")
+	if err := os.WriteFile(corePath, core, 0o600); err != nil {
+		return nil, err
+	}
+	sess := Session{Executable: exe, DebugDir: s.Symbols.DebugDir(), Core: corePath}
+
+	raws, stop, err := s.GDB.Unwind(ctx, sess)
+	if err != nil {
+		return nil, err
+	}
+	raws = clean(d, raws)
+	if len(raws) == 0 {
+		return nil, errors.New("gdb unwound no frame")
+	}
+	if stop != "" {
+		sources["gdb_stopped"] = stop
+	}
+	names := &namer{d: d, main: main, libs: libs}
+	var frames []crashes.Frame
+	for i, r := range raws {
+		// A caller's address is where its call returns to, which for a call
+		// that ends a function is the next one's first instruction.
+		at := r.PC
+		if i > 0 && !r.Inline {
+			at--
+		}
+		frames = append(frames, names.frame(at, r.Fn, r.File, r.Line, false))
+	}
+
+	// Past where gdb stopped, the probable callers.
+	last := raws[len(raws)-1]
+	if !outermost[last.Fn] {
+		from := last.SP
+		if from == 0 {
+			from = d.StackAt
+		}
+		cands := Scan(d, from, Memory(code))
+		var inMain []uint64
+		for _, c := range cands {
+			if mod, _, ok := d.ModuleAt(c.Call); ok && mod.Path == main.Path {
+				inMain = append(inMain, c.Call)
+			}
+		}
+		resolved := map[uint64]Where{}
+		if ws, err := s.GDB.Resolve(ctx, sess, inMain); err == nil {
+			for _, w := range ws {
+				resolved[w.PC] = w
+			}
+		} else {
+			sources["resolve_error"] = err.Error()
+		}
+		n := 0
+		for _, c := range cands {
+			if n == maxProbable {
+				break
+			}
+			w := resolved[c.Call]
+			f := names.frame(c.Call, w.Fn, w.File, w.Line, true)
+			frames = append(frames, f)
+			n++
+			if outermost[f.Fn] {
+				break
+			}
+		}
+		sources["scanned"] = n
+	}
+	return &Result{Frames: frames, Sources: sources}, nil
+}
+
+// clean drops what gdb reports that is not a frame: an address outside any
+// code (the x86_64 unwinder's guess past a frame without unwind tables), and
+// a frame repeated (ARM's unwinder reports the caller once from the link
+// register, then again from the unwind tables).
+func clean(d *crashes.Dump, in []RawFrame) []RawFrame {
+	var out []RawFrame
+	for i, r := range in {
+		if i > 0 {
+			if _, _, ok := d.ModuleAt(r.PC); !ok {
+				continue
+			}
+		}
+		if n := len(out); n > 0 && out[n-1].PC == r.PC && out[n-1].Fn == r.Fn && !r.Inline {
+			continue
+		}
+		out = append(out, r)
+	}
+	return out
+}
+
+// sameBuild says whether a library in the rootfs is the one the camera
+// loaded, when the camera's has a build-id to say so.
+func sameBuild(path, id string) bool {
+	if id == "" {
+		return true
+	}
+	f, err := elf.Open(path)
+	if err != nil {
+		return false
+	}
+	defer f.Close()
+	return buildID(f) == id
+}
+
+func buildID(f *elf.File) string {
+	for _, p := range f.Progs {
+		if p.Type != elf.PT_NOTE {
+			continue
+		}
+		b := make([]byte, p.Filesz)
+		if _, err := p.ReadAt(b, 0); err != nil {
+			continue
+		}
+		o := f.ByteOrder
+		for len(b) >= 12 {
+			nsz, dsz, typ := o.Uint32(b), o.Uint32(b[4:]), o.Uint32(b[8:])
+			name := 12 + (nsz+3)&^3
+			end := name + (dsz+3)&^3
+			if uint32(len(b)) < end {
+				break
+			}
+			if typ == 3 && nsz == 4 && string(b[12:15]) == "GNU" {
+				return fmt.Sprintf("%x", b[name:name+dsz])
+			}
+			b = b[end:]
+		}
+	}
+	return ""
+}
+
+// namer names frames: majestic's from its debuginfo, a library's from its
+// symbols (the dynamic ones, on a camera), anything else by its module.
+type namer struct {
+	d    *crashes.Dump
+	main crashes.Module
+	libs map[string]string
+	syms map[string][]elf.Symbol
+}
+
+func (n *namer) frame(pc uint64, fn, file string, line int, probable bool) crashes.Frame {
+	mod, off, ok := n.d.ModuleAt(pc)
+	if !ok {
+		return crashes.Frame{Fn: "?", Probable: probable}
+	}
+	if mod.Path == n.main.Path {
+		if fn == "" {
+			fn = "?"
+		}
+		return crashes.Frame{Fn: fn, File: sourcePath(file), Line: line, Probable: probable}
+	}
+	f := crashes.Frame{Fn: "?", Module: crashes.ModuleName(mod.Path), Probable: probable}
+	if p := n.libs[mod.Path]; p != "" {
+		if name := n.symbol(p, off); name != "" {
+			f.Fn = name
+		}
+	}
+	return f
+}
+
+// symbol is the function of a library that holds off, by its size: a static
+// function has no dynamic symbol, and the export before it is not its name.
+func (n *namer) symbol(path string, off uint64) string {
+	if n.syms == nil {
+		n.syms = map[string][]elf.Symbol{}
+	}
+	list, ok := n.syms[path]
+	if !ok {
+		if f, err := elf.Open(path); err == nil {
+			list, _ = f.Symbols()
+			dyn, _ := f.DynamicSymbols()
+			list = append(list, dyn...)
+			f.Close()
+		}
+		n.syms[path] = list
+	}
+	for _, s := range list {
+		if elf.ST_TYPE(s.Info) != elf.STT_FUNC || s.Size == 0 {
+			continue
+		}
+		start := s.Value &^ 1 // a Thumb function's address has bit 0 set
+		if off >= start && off < start+s.Size {
+			return s.Name
+		}
+	}
+	return ""
+}
+
+// sourcePath is a source file as majestic's tree names it: the build
+// machine's directories dropped.
+func sourcePath(p string) string {
+	if p == "" {
+		return ""
+	}
+	p = filepath.ToSlash(filepath.Clean(p))
+	cut := -1
+	for _, root := range []string{"/src/", "/include/", "/thirdparty/"} {
+		if i := strings.Index(p, root); i >= 0 && (cut < 0 || i < cut) {
+			cut = i
+		}
+	}
+	if cut >= 0 {
+		return p[cut+1:]
+	}
+	return strings.TrimPrefix(p, "./")
+}
diff --git a/service/internal/crashes/symbolize/symbolize_test.go b/service/internal/crashes/symbolize/symbolize_test.go
new file mode 100644
index 00000000..9fd4471a
--- /dev/null
+++ b/service/internal/crashes/symbolize/symbolize_test.go
@@ -0,0 +1,364 @@
+package symbolize
+
+import (
+	"context"
+	"debug/elf"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/OpenIPC/website/service/internal/crashes"
+)
+
+// The fixtures are a stand-in for majestic (../testdata/dump/toy.c) that
+// faulted on real hardware -- a gk7205v300 for arm, a PC for x86_64 -- and
+// wrote the dump majestic writes: in its own code (own), inside a library
+// with no unwind tables (lib), inside the C library (libc).
+const fixtures = "../testdata/dump"
+
+func fixture(t *testing.T, name string) []byte {
+	t.Helper()
+	b, err := os.ReadFile(filepath.Join(fixtures, name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return b
+}
+
+// needGDB skips without gdb-multiarch, as the keyframe tests do without
+// ffmpeg -- but fails in CI, where a symbolizer test that skipped would prove
+// nothing.
+func needGDB(t *testing.T) {
+	t.Helper()
+	if _, err := exec.LookPath("gdb-multiarch"); err != nil {
+		if os.Getenv("CI") != "" {
+			t.Fatal("gdb-multiarch is not installed, and CI is set")
+		}
+		t.Skip("gdb-multiarch is not installed")
+	}
+}
+
+// published lays the toy's executable and debuginfo out as Symbols keeps
+// what CI publishes, under the build-id the dump names.
+func published(t *testing.T, arch string, raw []byte) *Symbols {
+	t.Helper()
+	d, err := crashes.ReadDump(raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	main, _ := d.Main()
+	root := t.TempDir()
+	s := &Symbols{Root: root, Base: "http://127.0.0.1:1/never"}
+	copyFile(t, filepath.Join(fixtures, arch, "toy"), filepath.Join(root, "buildid", main.BuildID, "executable"))
+	copyFile(t, filepath.Join(fixtures, arch, "toy.debug"),
+		filepath.Join(s.DebugDir(), ".build-id", main.BuildID[:2], main.BuildID[2:]+".debug"))
+	return s
+}
+
+func copyFile(t *testing.T, from, to string) {
+	t.Helper()
+	b, err := os.ReadFile(from)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Dir(to), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(to, b, 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// rootfs is a firmware image holding the toy's library where the camera had
+// it, as Rootfs unpacks one.
+type rootfs string
+
+func (r rootfs) Dir(context.Context, string, string) (string, error) { return string(r), nil }
+
+func withLibrary(t *testing.T, arch string) rootfs {
+	t.Helper()
+	root := t.TempDir()
+	copyFile(t, filepath.Join(fixtures, arch, "libtoy.so"), filepath.Join(root, "tmp", "toy", "libtoy.so"))
+	return rootfs(root)
+}
+
+// at is "toy.c:<n>" for the line of toy.c that holds text: the fixtures'
+// lines, found by what they say.
+func at(t *testing.T, text string) string {
+	t.Helper()
+	b, err := os.ReadFile(filepath.Join(fixtures, "toy.c"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, l := range strings.Split(string(b), "\n") {
+		if strings.Contains(l, text) {
+			return fmt.Sprintf("toy.c:%d", i+1)
+		}
+	}
+	t.Fatalf("toy.c has no line with %q", text)
+	return ""
+}
+
+func describe(frames []crashes.Frame) string {
+	var b strings.Builder
+	for _, f := range frames {
+		s := f.String()
+		if f.File != "" {
+			s += fmt.Sprintf(" %s:%d", f.File, f.Line)
+		}
+		if f.Probable {
+			s += " (probable)"
+		}
+		b.WriteString(s + "\n")
+	}
+	return b.String()
+}
+
+func TestSymbolizeUnwindsTheFaultThroughMajesticsOwnFrames(t *testing.T) {
+	needGDB(t)
+	for _, arch := range []string{"arm", "x86_64"} {
+		t.Run(arch, func(t *testing.T) {
+			raw := fixture(t, arch+"-own.dump")
+			s := &Symbolizer{Symbols: published(t, arch, raw)}
+			res, err := s.Symbolize(context.Background(), raw, Firmware{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := describe(res.Frames)
+			// The faulting store, at its line; then its callers, each at the
+			// line of its call -- unwound from .debug_frame, nothing guessed.
+			want := []string{"store " + at(t, "{ *p = v; }"), "parse_level " + at(t, "store(slot,"),
+				"main " + at(t, "return parse_level(mode)")}
+			lines := strings.Split(strings.TrimSpace(got), "\n")
+			if len(lines) < len(want) {
+				t.Fatalf("frames:\n%s", got)
+			}
+			for i, w := range want {
+				if lines[i] != w {
+					t.Fatalf("frame %d is %q, want %q; frames:\n%s", i, lines[i], w, got)
+				}
+			}
+			// main is where a thread's stack ends: nothing is scanned past it.
+			if strings.Contains(got, "probable") {
+				t.Fatalf("scanned past main:\n%s", got)
+			}
+		})
+	}
+}
+
+func TestSymbolizeNamesALibraryFrameFromTheFirmwaresOwnLibrary(t *testing.T) {
+	needGDB(t)
+	for _, arch := range []string{"arm", "x86_64"} {
+		t.Run(arch, func(t *testing.T) {
+			raw := fixture(t, arch+"-lib.dump")
+			s := &Symbolizer{Symbols: published(t, arch, raw), Rootfs: withLibrary(t, arch)}
+			res, err := s.Symbolize(context.Background(), raw, Firmware{Build: "nightly-20261009-0000000", Platform: "toy_lite"})
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := describe(res.Frames)
+			// libtoy.so is stripped and has no unwind tables: its frame is
+			// named by its dynamic symbol, and majestic's caller is still
+			// found under it.
+			if !strings.HasPrefix(got, "toy_lib_fault [libtoy.so]\nthrough_library "+at(t, "return toy_lib_fault(")+"\n") {
+				t.Fatalf("frames:\n%s", got)
+			}
+			if libs, _ := res.Sources["libraries"].([]string); len(libs) != 1 || libs[0] != "libtoy.so" {
+				t.Fatalf("libraries used: %v", res.Sources["libraries"])
+			}
+		})
+	}
+}
+
+func TestSymbolizeWithoutTheLibraryNamesItsModule(t *testing.T) {
+	needGDB(t)
+	raw := fixture(t, "arm-libc.dump")
+	s := &Symbolizer{Symbols: published(t, "arm", raw)}
+	res, err := s.Symbolize(context.Background(), raw, Firmware{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := describe(res.Frames)
+	// strlen(NULL) inside the C library, which the test does not have: the
+	// camera maps musl's loader as /lib/libc.so.
+	if !strings.HasPrefix(got, "? [libc.so]\nname_length "+at(t, "return (int)strlen(name)")+"\n") {
+		t.Fatalf("frames:\n%s", got)
+	}
+}
+
+func TestSymbolizeWithoutPublishedSymbolsWaits(t *testing.T) {
+	raw := fixture(t, "arm-own.dump")
+	s := &Symbolizer{Symbols: &Symbols{Root: t.TempDir(), Base: "http://127.0.0.1:1"}}
+	if _, err := s.Symbolize(context.Background(), raw, Firmware{}); err == nil {
+		t.Fatal("symbolized without the executable")
+	}
+}
+
+func TestScanFindsTheCallersOnTheStack(t *testing.T) {
+	// From the fault's stack pointer, before any unwinding: the return
+	// addresses into parse_level and main are on the stack, each after a
+	// call instruction in the toy's own code.
+	for _, arch := range []string{"arm", "x86_64"} {
+		t.Run(arch, func(t *testing.T) {
+			d, err := crashes.ReadDump(fixture(t, arch+"-own.dump"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			main, _ := d.Main()
+			code, err := CodeOf(filepath.Join(fixtures, arch, "toy"), main.Bias)
+			if err != nil {
+				t.Fatal(err)
+			}
+			cands := Scan(d, d.StackAt, code)
+			syms := symbolsOf(t, filepath.Join(fixtures, arch, "toy.debug"))
+			var names []string
+			for _, c := range cands {
+				names = append(names, syms(c.Call-main.Bias))
+			}
+			joined := strings.Join(names, " ")
+			if !strings.Contains(joined, "parse_level") || !strings.Contains(joined, "main") {
+				t.Fatalf("scan found %v", names)
+			}
+		})
+	}
+}
+
+func symbolsOf(t *testing.T, path string) func(uint64) string {
+	t.Helper()
+	f, err := elf.Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	list, _ := f.Symbols()
+	return func(off uint64) string {
+		for _, s := range list {
+			start := s.Value &^ 1
+			if elf.ST_TYPE(s.Info) == elf.STT_FUNC && off >= start && off < start+s.Size {
+				return s.Name
+			}
+		}
+		return "?"
+	}
+}
+
+func TestScanSkipsWordsThatFollowNoCall(t *testing.T) {
+	d, err := crashes.ReadDump(fixture(t, "arm-own.dump"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	main, _ := d.Main()
+	code, err := CodeOf(filepath.Join(fixtures, "arm", "toy"), main.Bias)
+	if err != nil {
+		t.Fatal(err)
+	}
+	real := Scan(d, d.StackAt, code)
+	if len(real) == 0 {
+		t.Fatal("no return address on the fixture's stack")
+	}
+	// A pointer to a function -- its first instruction, Thumb bit set, as a
+	// callback on the stack is -- looks like code and follows no call; the
+	// return address beside it does.
+	f, err := elf.Open(filepath.Join(fixtures, "arm", "toy.debug"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	syms, _ := f.Symbols()
+	var fn uint64
+	for _, s := range syms {
+		if s.Name == "parse_level" {
+			fn = main.Bias + s.Value
+		}
+	}
+	ret := real[0].Call + 2 + 1
+	stack := make([]byte, 8)
+	d.Order().PutUint32(stack, uint32(fn|1))
+	d.Order().PutUint32(stack[4:], uint32(ret))
+	d.Stack = stack
+	got := Scan(d, d.StackAt, code)
+	if len(got) != 1 || got[0].Call != real[0].Call || got[0].Slot != d.StackAt+4 {
+		t.Fatalf("scan of [function pointer, return address] found %+v", got)
+	}
+}
+
+func TestCoreCarriesTheRegistersAndTheStack(t *testing.T) {
+	for _, arch := range []string{"arm", "x86_64"} {
+		t.Run(arch, func(t *testing.T) {
+			d, err := crashes.ReadDump(fixture(t, arch+"-own.dump"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			b, err := Core(d, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			path := filepath.Join(t.TempDir(), "core")
+			if err := os.WriteFile(path, b, 0o600); err != nil {
+				t.Fatal(err)
+			}
+			f, err := elf.Open(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer f.Close()
+			if f.Type != elf.ET_CORE {
+				t.Fatalf("type %v", f.Type)
+			}
+			var stack *elf.Prog
+			for _, p := range f.Progs {
+				if p.Type == elf.PT_LOAD && p.Vaddr == d.StackAt {
+					stack = p
+				}
+			}
+			if stack == nil || stack.Filesz != uint64(len(d.Stack)) {
+				t.Fatalf("no stack segment at %#x", d.StackAt)
+			}
+		})
+	}
+}
+
+func TestLibraryStaysInsideTheImage(t *testing.T) {
+	root := t.TempDir()
+	copyFile(t, filepath.Join(fixtures, "arm", "libtoy.so"), filepath.Join(root, "lib", "ld-musl-arm.so.1"))
+	// musl's libc.so is an absolute link to the loader: inside the image.
+	if err := os.Symlink("/lib/ld-musl-arm.so.1", filepath.Join(root, "lib", "libc.so")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(filepath.Join(root, "usr"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	// A link that would leave it, by an absolute path or by climbing.
+	if err := os.Symlink("/etc", filepath.Join(root, "usr", "etc")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink("../../../../../../etc/hostname", filepath.Join(root, "lib", "up.so")); err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(root, "lib", "ld-musl-arm.so.1")
+	if got := Library(root, "/lib/libc.so"); got != want {
+		t.Fatalf("libc.so is %q, want %q", got, want)
+	}
+	for _, p := range []string{"/usr/etc/hostname", "/lib/up.so", "/../../etc/hostname", "lib/libc.so", "/lib/none.so"} {
+		if got := Library(root, p); got != "" {
+			t.Fatalf("%s resolved to %q", p, got)
+		}
+	}
+}
+
+func TestSourcePathDropsTheBuildMachinesDirectories(t *testing.T) {
+	for in, want := range map[string]string{
+		"/home/runner/work/toy/toy/src/a/x.c":  "src/a/x.c",
+		"/build/toy/thirdparty/lib/src/y.c":    "thirdparty/lib/src/y.c",
+		"./toy.c":                              "toy.c",
+		"toy.c":                                "toy.c",
+		"/opt/r/_work/toy/toy/include/toy/z.h": "include/toy/z.h",
+	} {
+		if got := sourcePath(in); got != want {
+			t.Errorf("sourcePath(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
diff --git a/service/internal/crashes/symbolize/worker.go b/service/internal/crashes/symbolize/worker.go
new file mode 100644
index 00000000..ea87e23e
--- /dev/null
+++ b/service/internal/crashes/symbolize/worker.go
@@ -0,0 +1,161 @@
+package symbolize
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"github.com/OpenIPC/website/service/internal/crashes"
+)
+
+// Worker symbolizes the dumps that wait, one at a time: woken by an upload's
+// NOTIFY, and every few minutes for the ones waiting to be tried again.
+type Worker struct {
+	Pool       *pgxpool.Pool
+	Log        *slog.Logger
+	Symbolizer *Symbolizer
+	Now        func() time.Time
+	// Every is how often it looks without being woken.
+	Every time.Duration
+	// KeepFor is how long symbols and rootfs images nothing has used stay.
+	KeepFor time.Duration
+}
+
+func (w *Worker) now() time.Time {
+	if w.Now != nil {
+		return w.Now()
+	}
+	return time.Now()
+}
+
+// Run works until ctx ends.
+func (w *Worker) Run(ctx context.Context) {
+	every := w.Every
+	if every == 0 {
+		every = 10 * time.Minute
+	}
+	wake := make(chan struct{}, 1)
+	go w.listen(ctx, wake)
+	t := time.NewTicker(every)
+	defer t.Stop()
+	swept := time.Time{}
+	for {
+		w.Drain(ctx)
+		if keep := w.KeepFor; keep > 0 && time.Since(swept) > 24*time.Hour {
+			if n := Sweep(w.Symbolizer.Symbols.Root, keep); n > 0 {
+				w.Log.Info("crashes: swept unused symbols", "removed", n)
+			}
+			swept = time.Now()
+		}
+		select {
+		case <-ctx.Done():
+			return
+		case <-wake:
+		case <-t.C:
+		}
+	}
+}
+
+func (w *Worker) listen(ctx context.Context, wake chan<- struct{}) {
+	backoff := time.Second
+	for ctx.Err() == nil {
+		err := func() error {
+			conn, err := w.Pool.Acquire(ctx)
+			if err != nil {
+				return err
+			}
+			defer conn.Release()
+			if _, err := conn.Exec(ctx, "LISTEN "+crashes.SymbolizeChannel); err != nil {
+				return err
+			}
+			backoff = time.Second
+			for {
+				if _, err := conn.Conn().WaitForNotification(ctx); err != nil {
+					return err
+				}
+				select {
+				case wake <- struct{}{}:
+				default:
+				}
+			}
+		}()
+		if ctx.Err() != nil {
+			return
+		}
+		w.Log.Warn("crashes: symbolize notifications lost, reconnecting", "err", err, "in", backoff)
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(backoff):
+		}
+		backoff = min(backoff*2, time.Minute)
+		// What arrived while it was down is found by the next drain.
+		select {
+		case wake <- struct{}{}:
+		default:
+		}
+	}
+}
+
+// Drain symbolizes every dump whose turn it is.
+func (w *Worker) Drain(ctx context.Context) {
+	st := &crashes.Store{DB: w.Pool}
+	for ctx.Err() == nil {
+		due, err := st.DueDumps(ctx, w.now(), 8)
+		if err != nil {
+			w.Log.Error("crashes: dumps to symbolize", "err", err)
+			return
+		}
+		if len(due) == 0 {
+			return
+		}
+		for _, d := range due {
+			w.one(ctx, st, d)
+		}
+	}
+}
+
+func (w *Worker) one(ctx context.Context, st *crashes.Store, d crashes.Due) {
+	fw := firmwareOf(d.Meta)
+	res, err := w.Symbolizer.Symbolize(ctx, d.Dump, fw)
+	if err == nil {
+		sig, err := st.Symbolized(ctx, d.EventID, res.Frames, res.Sources, w.now())
+		if err != nil {
+			w.Log.Error("crashes: symbolized, not stored", "id", d.EventID, "err", err)
+			return
+		}
+		w.Log.Info("crashes: symbolized", "id", d.EventID, "signature", sig, "frames", len(res.Frames))
+		return
+	}
+	if ctx.Err() != nil {
+		return
+	}
+	gaveUp, ferr := st.SymbolizeFailed(ctx, d.EventID, err.Error(), w.now())
+	if ferr != nil {
+		w.Log.Error("crashes: symbolize failure not stored", "id", d.EventID, "err", ferr)
+		return
+	}
+	level := slog.LevelWarn
+	if errors.Is(err, ErrNotPublished) {
+		level = slog.LevelInfo
+	}
+	w.Log.Log(ctx, level, "crashes: not symbolized", "id", d.EventID, "attempt", d.Attempts+1, "gave_up", gaveUp, "err", err)
+}
+
+// firmwareOf is the build meta.json names.
+func firmwareOf(meta json.RawMessage) Firmware {
+	var m struct {
+		Firmware struct {
+			BuildID  string `json:"build_id"`
+			Platform string `json:"platform"`
+		} `json:"firmware"`
+	}
+	if len(meta) == 0 || json.Unmarshal(meta, &m) != nil {
+		return Firmware{}
+	}
+	return Firmware{Build: m.Firmware.BuildID, Platform: m.Firmware.Platform}
+}
diff --git a/service/internal/crashes/symbolized.go b/service/internal/crashes/symbolized.go
new file mode 100644
index 00000000..a266e339
--- /dev/null
+++ b/service/internal/crashes/symbolized.go
@@ -0,0 +1,238 @@
+package crashes
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// majestic's crashes wait for the symbolizer (the symbolize package, in the
+// firmware role): a crash arrives filed under the module and offset of the
+// faulting instruction, and once its dump is unwound it is filed under its
+// backtrace, and the dump -- a slice of majestic's memory -- is deleted.
+
+// SymbolizeChannel is what an upload NOTIFYs to wake the symbolizer.
+const SymbolizeChannel = "crash_symbolize"
+
+// Due is a dump waiting to be symbolized.
+type Due struct {
+	EventID  string
+	Dump     []byte
+	Meta     json.RawMessage
+	Attempts int
+	Received time.Time
+}
+
+// DueDumps is the dumps whose turn it is, oldest first.
+func (s *Store) DueDumps(ctx context.Context, now time.Time, limit int) ([]Due, error) {
+	rows, err := s.DB.Query(ctx, `
+		SELECT d.event_id, d.bytes, e.meta, y.attempts, d.received_at
+		FROM crash_symbolizations y
+		JOIN crash_dumps d ON d.event_id = y.event_id
+		JOIN crash_events e ON e.id = y.event_id
+		WHERE y.status = 'pending' AND (y.next_try IS NULL OR y.next_try <= $1)
+		ORDER BY y.next_try NULLS FIRST, d.received_at LIMIT $2`, now, limit)
+	if err != nil {
+		return nil, err
+	}
+	return pgx.CollectRows(rows, func(r pgx.CollectableRow) (Due, error) {
+		var d Due
+		var meta []byte
+		err := r.Scan(&d.EventID, &d.Dump, &meta, &d.Attempts, &d.Received)
+		if len(meta) > 0 {
+			d.Meta = meta
+		}
+		return d, err
+	})
+}
+
+// Glue in a majestic crash: the C library's frames every abort and every
+// thread has, which say how it ended, never what went wrong.
+var userGlue = map[string]bool{
+	"raise": true, "abort": true, "__assert_fail": true, "__assert_fail_base": true, "a_crash": true,
+	"pthread_kill": true, "__pthread_kill_implementation": true, "__pthread_kill_internal": true,
+	"gsignal": true, "__restore_rt": true, "__restore": true, "__libc_start_main": true,
+	"libc_start_main_stage2": true, "__libc_start_call_main": true, "start_thread": true,
+	"__clone": true, "clone": true, "_start": true, "_start_c": true,
+}
+
+// userSigFrames are the frames a symbolized majestic crash's signature is
+// made of: the unwound ones with a name, glue left out; and when that leaves
+// fewer than two, the scan's probable callers after them.
+func userSigFrames(frames []Frame) []Frame {
+	var out []Frame
+	for _, f := range frames {
+		if f.Probable || f.Fn == "?" || userGlue[f.Fn] {
+			continue
+		}
+		out = append(out, f)
+	}
+	if len(out) < 2 {
+		for _, f := range frames {
+			if !f.Probable || f.Fn == "?" || userGlue[f.Fn] {
+				continue
+			}
+			out = append(out, f)
+			if len(out) == 3 {
+				break
+			}
+		}
+	}
+	if len(out) > sigFrames {
+		out = out[:sigFrames]
+	}
+	return out
+}
+
+// maxFrames is how many frames of a backtrace are kept.
+const maxFrames = 48
+
+// Symbolized files the event under the signature its backtrace makes, keeps
+// the backtrace and deletes the dump. The provisional signature it leaves is
+// deleted when nothing else is filed under it, or merged into the new one
+// when a triage or stars were booked under it meanwhile.
+func (s *Store) Symbolized(ctx context.Context, eventID string, frames []Frame, sources map[string]any, now time.Time) (string, error) {
+	if len(frames) > maxFrames {
+		frames = frames[:maxFrames]
+	}
+	src, _ := json.Marshal(sources)
+	all, _ := json.Marshal(orEmpty(frames))
+	var sig string
+	err := pgx.BeginFunc(ctx, s.DB, func(tx pgx.Tx) error {
+		// The only change an event ever has: the crashes package refiling it.
+		if _, err := tx.Exec(ctx, `SET LOCAL openipc.crashes_guard = 'off'`); err != nil {
+			return err
+		}
+		var provisional string
+		var fatal []byte
+		err := tx.QueryRow(ctx, `SELECT e.signature_id, e.fatal FROM crash_events e
+			JOIN crash_symbolizations y ON y.event_id = e.id
+			WHERE e.id = $1 AND y.status = 'pending' FOR UPDATE OF e, y`, eventID).Scan(&provisional, &fatal)
+		if errors.Is(err, pgx.ErrNoRows) {
+			return fmt.Errorf("crash %s is not waiting to be symbolized", eventID)
+		}
+		if err != nil {
+			return err
+		}
+		var t Trace
+		if err := json.Unmarshal(fatal, &t); err != nil {
+			return err
+		}
+		t.Frames, t.Provisional, t.Build = frames, false, ""
+		sig = t.Signature()
+		title := t.Title()
+		trace, _ := json.Marshal(&t)
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO crash_signatures (id, class, kind, title, frames, first_seen)
+			SELECT $1, 'user', $2, $3, $4, received_at FROM crash_events WHERE id = $5
+			ON CONFLICT (id) DO UPDATE SET first_seen = least(crash_signatures.first_seen, EXCLUDED.first_seen)`,
+			sig, KindSignal, title, all, eventID); err != nil {
+			return err
+		}
+		if _, err := tx.Exec(ctx, `UPDATE crash_events SET signature_id = $2, title = $3, fatal = $4 WHERE id = $1`,
+			eventID, sig, title, trace); err != nil {
+			return err
+		}
+		if provisional != sig {
+			if err := leave(ctx, tx, provisional, sig); err != nil {
+				return err
+			}
+		}
+		if _, err := tx.Exec(ctx, `UPDATE crash_symbolizations SET status = 'done', frames = $2, sources = $3,
+			error = '', attempts = attempts + 1, next_try = NULL, at = $4 WHERE event_id = $1`,
+			eventID, all, src, now); err != nil {
+			return err
+		}
+		_, err = tx.Exec(ctx, `DELETE FROM crash_dumps WHERE event_id = $1`, eventID)
+		return err
+	})
+	return sig, err
+}
+
+// leave tidies the provisional signature an event was refiled from.
+func leave(ctx context.Context, tx pgx.Tx, provisional, sig string) error {
+	var events int
+	var booked bool
+	if err := tx.QueryRow(ctx, `SELECT
+			(SELECT count(*) FROM crash_events WHERE signature_id = $1)::int,
+			EXISTS (SELECT 1 FROM crash_triage WHERE signature_id = $1)
+			OR EXISTS (SELECT 1 FROM crash_stars WHERE signature_id = $1)
+			OR EXISTS (SELECT 1 FROM crash_signatures WHERE merged_into = $1)`, provisional).Scan(&events, &booked); err != nil {
+		return err
+	}
+	if events > 0 {
+		return nil
+	}
+	if !booked {
+		_, err := tx.Exec(ctx, `DELETE FROM crash_signatures WHERE id = $1`, provisional)
+		return err
+	}
+	// Stars paid under it stay held under the bug they were for.
+	var root string
+	if err := tx.QueryRow(ctx, `SELECT coalesce(merged_into, id) FROM crash_signatures WHERE id = $1`, sig).Scan(&root); err != nil {
+		return err
+	}
+	if root == provisional {
+		return nil
+	}
+	if _, err := tx.Exec(ctx, `UPDATE crash_signatures SET merged_into = $2, updated_at = now() WHERE merged_into = $1`,
+		provisional, root); err != nil {
+		return err
+	}
+	_, err := tx.Exec(ctx, `UPDATE crash_signatures SET merged_into = $2, updated_at = now() WHERE id = $1`, provisional, root)
+	return err
+}
+
+// Tries: how often a dump is tried, and how long after each failure.
+var retryAfter = []time.Duration{
+	5 * time.Minute, 30 * time.Minute, 2 * time.Hour, 6 * time.Hour, 24 * time.Hour, 24 * time.Hour, 48 * time.Hour,
+}
+
+// SymbolizeFailed records a try that did not work. A dump is tried again
+// later, until the tries run out; then it is given up on and deleted, and
+// the crash stays under its provisional signature.
+func (s *Store) SymbolizeFailed(ctx context.Context, eventID, reason string, now time.Time) (gaveUp bool, err error) {
+	if len(reason) > 2000 {
+		reason = reason[:2000]
+	}
+	reason = strings.ToValidUTF8(reason, "?")
+	err = pgx.BeginFunc(ctx, s.DB, func(tx pgx.Tx) error {
+		var attempts int
+		err := tx.QueryRow(ctx, `SELECT attempts FROM crash_symbolizations WHERE event_id = $1 AND status = 'pending' FOR UPDATE`,
+			eventID).Scan(&attempts)
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		if attempts >= len(retryAfter) {
+			gaveUp = true
+			if _, err := tx.Exec(ctx, `UPDATE crash_symbolizations SET status = 'failed', attempts = attempts + 1,
+				error = $2, next_try = NULL, at = $3 WHERE event_id = $1`, eventID, reason, now); err != nil {
+				return err
+			}
+			_, err := tx.Exec(ctx, `DELETE FROM crash_dumps WHERE event_id = $1`, eventID)
+			return err
+		}
+		_, err = tx.Exec(ctx, `UPDATE crash_symbolizations SET attempts = attempts + 1, error = $2, next_try = $3, at = $4
+			WHERE event_id = $1`, eventID, reason, now.Add(retryAfter[attempts]), now)
+		return err
+	})
+	return gaveUp, err
+}
+
+// Symbolization is how a majestic crash was symbolized, for the maintainers.
+type Symbolization struct {
+	Status   string          `json:"status"`
+	Attempts int             `json:"attempts"`
+	Frames   []Frame         `json:"frames"`
+	Sources  json.RawMessage `json:"sources"`
+	Error    string          `json:"error,omitempty"`
+	At       time.Time       `json:"at"`
+}
diff --git a/service/internal/crashes/testdata/dump/arm-lib.dump b/service/internal/crashes/testdata/dump/arm-lib.dump
new file mode 100644
index 0000000000000000000000000000000000000000..e964a09376d3d28b263dd12c52a6a7f74f5453cc
GIT binary patch
literal 2199
zcmd5-%}*0S6dx2nSW)qW=z%33bzx>{yIqn-t0jPfnzk4%X>j(V&{$~GmI8^U2NM4P
z!_~xtXCxlDNr(qeCgR1LiSeojV+=7GKi-?!Ews_XO(%K#-rIS<_c8Cy?%3r^u@=%o
zhGTJcfe=#4PR;UMgfYd=J8pz2+;NH#x<Hje)`^7708`2}VY=vYCsNKYD)T%CAj4!q
zic6U*l(RDc2eIN7OWFJ^nw=G!l%7*{s)sa2HEODq4uDmBa43<4_{V?_0Qu`dPpXP?
z4(R2R<@GNs%j^3=ZUy=4_oe%|=dav_RP`|IKkH6a2Oe*&Q9^FxULqO2LiQ1Yd#Ixy
zw0Q;m*U40MBPwGMIERO)eHktP&1!{IF*4SP^^QZ1_ZGjc*+8GX8a^)nT)PYVb6u(G
zYp4b7+d5NKv_+c{c#rrOP$Sm634}IpJ>G-L>gIX}us5sc$wAaXIRVT8LTsQTRfSxL
z3WPnuqz(a*&8;<&Ac$>13}PL@_psU}BS$@s{lwKN8R-K46mmG_>D|D$KtB%rxtE)_
z1?+wH%#WdsrGe>ud+1$hY^7r4NN*oZ63JyP(pR1-pwfrRXl!zH<YGJ;zcqP1njDV!
zo1Q)T9E)C0e1^h|OpwE5QVoTE5Y(c!P=G;{OH8Dz>L$#nDwgjHgDE~ppaT-ENi;g$
z0~$dBjh96&&U<KmZ)gM|+6vX7L6NcHDYM4s#I(x`Y0O!e3!H(Ln&w5_6^G^m7e-ty
z+om`xlnHUfp<oHzUryMNxz<h?S_y~TTgodwRQRx^kH(y3mzw)PsPN$kAO2}K^s2cJ
zgrW~uoL&92u*?AMS9Ml9bsR?|+p9u=1lru0fg!Zr(P$>n@*MsA;q7+670WesdEl-Y
zXku8KjEPd2+jr6cbf}B~0($tvU8tWZ_(K%<lq;cLOow_+ZfsCJv{K<ki9>S@V|$Hl
zynYQhr<6}C8CY1ghJt8ceIvw=q;B{tu3gR-OKBxKe)Gm7_yYXzU%jzwvBU?+)7A~U
zpBq8TFoHa22E##WS|$&>)Ufa_2dEj=O~X>@0)CF<EN_do+l1dM4UGKzxKpedZC^Rx
zRNNGa5~7@FN1K@|<uqQLfx+%&3S~?WFwSYnbeYRdma)UOWi#qhhwDxtVA#~w^&kd?
cPKycIAx>08SChl>82)^iipdUMjj5oJ-#8ubaR2}S

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/arm-libc.dump b/service/internal/crashes/testdata/dump/arm-libc.dump
new file mode 100644
index 0000000000000000000000000000000000000000..653dbdc818a5cdc6e537ebae7d797dde333b1a74
GIT binary patch
literal 2199
zcmd6oJ8u&~5P&zlbG#c+XgF%PWcT9p`65|hFd{$#k?o*EQ3QJr6N3|5w&R$WTp;l;
zkf1~~R4x#T0-~Y-(a=#KN+_ZT1rjKj*}Ze@kT~gJrM;QGoo{w_XZCLR!kJ_j=^}&4
zlv*Q%lyf(xcs|aU;ubtV&J^x>r8uoorI_>LQ7h7~RGP{}$>(0YQn;<m@H{}K#SDr~
znJ!jxlYoO-^-JYkVG7NTi%CjPs5;f78lxJuR7wZHDs}c;Is@zPgT5X5TJ7!SAG6;t
z{g~YfliNW5`Rl>MRy+H#UEc-s&+2x4{`F#m5^@UX)0xCYvV{<w!!i0nn|C0;)a?4)
z6T6P@37o^DyP+=M{EO!{2o=}Ged2ycA;$YXiwzh0e6WXak>$ocn4i9F*FV5s(7t=d
zuA?p5oQL<wzkxmCe&0h!n@@o}hJ)+Nvj;$Ye14Mbz%dLCg7Bat8!6g#h=r)oF((+*
zPUxh#&=3KF+6|q-TD$Q*v^`Rgy@AAhVmmAa=>hp1VmK0vkAhr;@qUnVL2SVk`Tg|H
z(kOd*=<{;<)zZzS7gaM)di$V`NIvJdq^~kr#8ICZ4JEG)oj;vQq^@2YNn{4&;cP&l
z&*8*KdI2_OW{sE$rKq7|fufeQS`i9SHc^qjs#{Q_s%W7vTulifL32rKl7@1po1hUA
zv?J)5fYvuhBZRc&w$U(<Yr|7UjnA<OpBKk5W??Qk4=pt<Sam}V%?0NpR|=!;$T`uh
z9zhNj{3NV<!lsP1dBTuOION`PK?zaeBPxBYj#*}@vkydt4@~(={Ht=+*@vhW2#5=+
zy;@jyfcC38Yo0pRqo~PX7Xrcvcz<gIrl`D)X@mqV&vDK3R~$cU$OHGYW(UJ&WsH?8
z+`To9AP+&lPNv!`3jPp9e#4h25*qqgCqeCKwaQD9lSu(iCgrc|w~F)1g>fYd4VI%C
zDr+P{{7Bl0zv{b{La98iBu4EkkKqgOzkl_HFDKJqAx>8}-F|Kwj%ga)u#A{NEyv<9
zpPCNbWhX+dm~NSlN^AHz5{KBLHg6MtuQV{iyM$S8RhvdDS1vRS{2?V&S<#+0IbF_c
zyfg`g-OCipm>yxA)2QV$pIa>J#$3l`)TbWTy-37#sjKS-E*e%yi#k>nS<MWllKAss
NDh7M@Qc{Hh`2(yr^3nhR

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/arm-own.dump b/service/internal/crashes/testdata/dump/arm-own.dump
new file mode 100644
index 0000000000000000000000000000000000000000..b8a10b8c053a66ef0f7713b1f9412c7b9c44e6cc
GIT binary patch
literal 2191
zcmd5-O-vI(6dnSItO}Tz_;YbR>(be!+wGDxrdlE>C@Ektw87b*LSsvt{$ir(!NjBS
zrp6eFH*dxRM}izYdC-eDFCM%o2{DQo5BlEBZlTEEO(&Us@6EjL{mq-%p^N8ZO{9tR
z$KvuVA*7g|nqirUs!DdwaU-h49H$VWvsB8bok+;+F{M(SnJ&1@iIj3Tr7Ft+$S_r%
z;*iSuQaTH8U@LB+n9j|h+G)N?=^0t0T1Zi;LQR>{UeJp7T^Jb!{~a(}_rnK9vmoSc
z=jsBoZ-9R5SY5#N7U0)@-MQ<ja5BD_sCB{qyQhiT5==_Sb=(*kjb2)7A_VtPMmuef
z61Bxwi5kiT@_+K!=f%pu__h$jGspZe&#{Mz+U=h!^ES*CFZM4-zR%x+{W8Rld19RH
z4-z%hMV$dyNBnEZ5%ctG_W^j+J%yjSwS_Jq?_ZoH`%nhqFc1eOVuSY+HHd}CFk4|_
zP;D^D@bbKOG^8Cw6?`4Qbr=T)A%{GQ=ZNE|AmljEmk`4VPd*8B735B!OI~c=7LaG3
z%FR<Bf9TJb2l{{CJ65e28PXkq4kEeg3<;F7c@zRD48|r02hPQ#@oSUA(b4{hzv=0t
z&7tV<$X7_rNa?l-EvO)40V5Zb**r9$7`zi*Su>$GWj=gc=uGlK9Bm7<BGAz0bPs3*
zakRtHRS&K04UHf~J8lCS1mPRLB5M3jOuH<f#F)7{$E8qHQ9Q4^;!quN=ng97N4q1=
z3b_uZqaf46aobeb5V6)PoJm_y<nCfl@}b;DP}tZUvpA)lZ6K7}z$a-v{!M4KvkioT
zjZ~1=uCZIxR4?t3HML&#0OWwv7Fh@oqIK@mub_b~DDR5qAdVJw+_L_X<)$!C2+~c3
z8r<OOR*g|CG5bamf#I+R4D*N@v*WLFLr1}%A<w2<0p-^SZ7}pw*rll|6;=>9RL5Au
z+g!iKCayTeTvAHG02oz}5jp<VRGV<FUCI@TNhvxuesvCBfdBo~8@du3`3!N|nql`a
zL$?e=XS%6}b!u8B3%k^?;3`@{YKAq_uw*(5B7e*_vh~}9@09{O{(aoY)|J+;oUh7n
zia>EzbhM*n%f*bs3R!6EZdIbHss&ZXXvlO`mziqH4%?QkQkObRbAmy`rnaW(=+y6!
Y4eW$C)zSWV41YeVjKTI@j>#a9Ki9nQQvd(}

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/arm-sent.dump b/service/internal/crashes/testdata/dump/arm-sent.dump
new file mode 100644
index 0000000000000000000000000000000000000000..1cad5df61ed5efe2d356515db036450c6eec1aff
GIT binary patch
literal 2343
zcmd5-&1)1%6tAf9qt}gkP|=Gm>}6RyQ`PC7o)!j~b;KBrhDj8c5T!q=b=XN}=;@3R
zcA15R#eZVK|G=E)wlSa!yP~KUH3Z4UgD}C5#a)EG_+C|aXEG9#lUPvw-m7}Q_fhp;
z_3+T~Vh`ydgT<11gAh_LUzu_$dBzm4>hrvoRUF?B^K^!}I#X(8KcBS?Q;AaMYRDZw
zA62g_*PIFfEt{DXhcaD@%9A|LfNk)wUan4|+IM1;(j%%)^{mFIMs1bSqo7siQ$7!+
zgVKqUqhk<H_qg%L(j2aBk2g@>4E!ya@Bjbxw|H5QEw`8EaDVUV<yJJb+@kU3=vd+O
zFPjKSY;|H1{wrXjSFc;$Ht)y&Z|`fjeqVH(TL{@{gY5)|6yxdbTmT;JeKRLx$GE=T
z-)?oT-GjAvu>ath+nn$5niAea&_|c4&n`la;<zy{jPX3g`13-$<-vRt=d}Fpb?YbC
zpI&gAkC$Z3JD$2t)J2_Bu#Wh<kSFH)5GE$_Jf??HApg$ohVPTvV`M9eAnXC+!$hp{
zNSrrOfyeX3ptivz^kpllhaDg?@P%iKW2YqK>zMY%bbm|_0G)*x4#x5!p#Ooq3+Q|t
zTf9a7e%`y-{_D-q?4K{*-nrE7YgiT1pMjbtP`MGwM3Xg?GD132ynN==_oYJVhsz^{
zvB7+@8za!>aA9QhA4tp!vbqm#p&=6hqlVf{4Vpp@(H&gXZRi(OjKmgtQxXuO2M_^h
zO`@Uo==x{@5@?|xUW?KC#?S~tv?26UG^|SB@Rd>Hcl;`MY7-c<P!~A#uWCum>*7#d
z;0(lV%%7X(IW(*xBePuNge@6sdcu{m3y0iauPO;t*pRt?6tldgPuoDKup#nJ<L|nw
zPumb@009M9HeJ=if}?am)meJ#8OQ;r7iS?r7(pOwExvEdMqBHn5d`RfuC5kXUAb??
z<-YF<MeYY4Zl#H?QcNpjydF8;j}rh43@(9zu|_Yft|<6p)toC_LS=9~5Wk?6Mp(mV
zqv3=CC)73YZLU!qt6etydUZkxV4z_QnT_GN7gfXhgi<(v@xo1b0lxHCZ}?nsv<-23
zy5$Wxmg!oS>6o^eGpX&`PL5N{wF1*MsGZYo%T?(NK1ZS|JJ__F@V(MN342N2$qJh)
zt+ZUCDmq1?1S>1r*Cway70n4Jp|JazLK)Ky<~THKbH*K;1zyf`Jw`e89o;t!%cGvI
do9I8OkPdcS-s;$3sfa%xred%s&K6Y=$Okc68Grx)

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/arm/libtoy.so b/service/internal/crashes/testdata/dump/arm/libtoy.so
new file mode 100755
index 0000000000000000000000000000000000000000..b6ef1ca8b608c4144aa5ca30bc174ce16f2780a8
GIT binary patch
literal 5280
zcmeHLO=uid9DlPP*-hMTw=rpB5^+eQZfiPhOf)Dc`It6IH-R>U67aChW+%zYW_OvL
zz~%$Ac<^AgQ1B#Tq3WRrF+vUnV?23~9s=#5LJy%PSQHvP*no)Z?>95AtZ5aGJ?vwD
z^Z)w2|Gatc&G7#F*2%F`ilPYF{30%-)eC3h5H3Cu>=mjAB6e6bKZwgdc2EccKOthm
ziN_BL5r4)-1PS9nofr2(CJ;{`PHe&^7!LqvckB$rLyd8y7ZZqA=f4FX!M+^3ABX_;
zz!RPg@lYe5V{QOKUX=F;1I)qx%;!8;XWe<Ij*t9n@BbG4`NnRv=icQH=-=N0On~P1
zGAC5WgndX1xvF#Rz;&X^R-qr;XCK&SSKqJ^u{Za{oiXG7oaaW|pU*aohjr}+@iy#N
zU`L%eo-&oqXKj(1fe@+D$?;Uiw9MIT$u_OY@u6HHZ%!KNoax3M9Z5}>4JI&h*(DIG
zGNfiKW8TCqW(x4j-ql{au$ana)2SI_A!mz{ZRO0ofMZ%K6);3+A02`0!d{`|TvE0}
zHsd)}N<2>|B^E1AiG}Q<#9~Gu4}%w@1h0t_lhQ(oxU#l>SLrVf2ewY^1hzieiEdro
z3jg}e&UU*H;=7A?l<zOx+5YqE9jV{0(r;Gj*P+*qgpy@Fbb48TXK+dPZw8Y$ru?fd
z!^L5-aU1z=0hfU|Qin(C!CltdTEnM*IH>$`MOo5EWB=^)CAePzd7u-0qRH6WvK}34
zE3fERt{q7JICXS2l3dnX<|=zvcPo1vl?M3QR_jN~dS&nP-EdOrSk_yMv30Srf*gYY
zeqsg}74i}`%NX?VS}4g;e>C;NYTamPWKn1TOS|iL!~Iu(5*zp0FrVPJgFAsfv9&<C
zvbVCk{gtZ6*5wQe@j5sI0N+1Kem*Fl_vFi-#Bw-(zHf{-dlH`o$L8Lo|2a=S=}EpD
z^m8v$KIKWileGE1Q_A+ZjYp2FCTlZLn}OO4)MlVI1GO2b%|LAi9`6~bN8PZBL#u*e
zehBb<8-&f;jI|Zdp{#dtOm^zfR!G(>JZmHD;3nkne^m-CNWz*jfI}?LzdCH5Uq1$T
zer1iz^RZCfb1sBv0(h2Y-Ls8;)IWt}{nrohe9XG_k4mNB^o9O^8tZS_BIsBR>93Xv
z70){~^r{*kT*&4!R-s_4CuS3U-F=zvzGG^4kJh6l!~p*~Fiazz70Pj_!M<}RMO{N^
zAgt8;8iEmDW1vZCR*v{vlvZDda$M>1>3*S==1~0EMp|gI`2}sxD9s5ivzRX}&b!jK
zgl3sJ`dp=mdQo$VSIsud(47)ivkDo*HiTx*xn-uyNg0-9EV>-2Ba<<ooyH9d=<W7O
zmr6pLF3iuHdH4n<#x=vXt!#S1HcQo0@t->D7_KpvNO0W=9gu4y_XOAbKGuvp?hAr-
z)_xxABXY^(ej&bv&OGE&a^F1d+2nD55!_d@p_|j5#TAvmlaKp|=!ac>U+yOjAa4-Z
z28U3glgIn<zU1`*%+3AG|2_!%WkWZoy@;#i$-Sm~F$(4*UIQfW3~~|o;ggLVwjn_B
zPQgh$>b|2MkK;H44xzH6*I+vBEUt8uSHuDmGDd>b-+;~<6~l7>=fZ-^7+j7{dlukc
zAdlaJu7BZiXL0VxbN&|tZxg!ANy+D00XRPLgbH9064bp$9&sL!JifCD@MJE89_a5v
zXI|#(RRQq$&5}*_xc~?A$$OF4AxU10aef<-t0+U~z<Ws=kmRt*vALEI?}7K3G`u*?
FzX7^4RGR<*

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/arm/toy b/service/internal/crashes/testdata/dump/arm/toy
new file mode 100755
index 0000000000000000000000000000000000000000..4b51c7bc7943f3d5da8759516bc8b1b02596de99
GIT binary patch
literal 9848
zcmeHNdvH|c760z;CfU4G2oe*-n->I@Y&L)(BAq-gH~Rol2)g1U*<=^))=hTZ-Qebd
zg4)q4DlbtUwOSvgB5mjt3#}N2K8CR}!=u(0wizo87&Z?THx`@Q-?_V2FX^=7Kb`5c
z`DT9iob#RYo$r12e)rq^7B3Mwj$>-lvoc0fWh!HHK@S$;p<_vN8PAN+<*~^u8Cj%L
zp%g$N1M&!Z(m_^n1!My0$TvZoEE5<bBvEEgT%U6_*ortd>KN;uz$x{T9wN(wJ`Z}r
zImiTRm)eFUs6<5x@(HT$rn6x;#D7Xu9`4z4=(Y6^A&)@isqGa$Z&QWOUEb0b@|C-S
zE#{ElT$#}4f>QtMZdl2Vc3s!@i?$b^{BG)@J-wax-B$JVjLvUCR|rrt0#ku0z?A@{
ztAIR!2MU0EfD-wg1WW`nfq$2jaZDIco2fl&N>dpP%}Vg;2}<LT0Z?00fXM)cn`Hwu
zkC-Zk<)Mrf%?0UbT$FlC*ang*9eiv!tN-+%>OP*CcpAwul3ww|*fxtQPh^8}R(Vog
zi^zE*k$g%OK&g!tWAv|S^klD5Gg{8MnhesXjFI<_DgWje`N=Udtr<1(V9HbhRFTK{
z|45^!`ZLGqN5<%DG%^qVw;Gws&l^*oA0sawBi}iuyl#x%qtWx=U)0D{-}y1}Lu2Gl
z$f=lLS{oBEzZ*bLV)4XftgMEH=7_6dwYSyf^LBV3x;;V98gD4<2{x<_x>`I9-qzKA
z)?lk&+Mp`xm)83Ht)6;UlMf|G^L3%ibfIw2=V^sgwd7?ky{+CbqpH0u>~C+tPHtH3
zYV(De+t=Vl{jRX5At1Sftl8%eQPV<USMyyB&C*@4^ZHoO<8u4Ft#`2&PfN%XX7>b9
z>N2x6ZLXkOv137(7d}F*fuOfFyqbl)Yh2A?ufLV~18AWy<nbtenp*;j&KFiHW1+9@
zF+yyOCmis)8TzFdwuhQsJ|C(?+ncF*!Ei&1%L{+rCUgnGh`45=NEAb9|K=uW1pAES
zhZA&Tg3|t@`~c`AY~(Oe1gI{e*um?GVh$f9ieR*fC<0Ul=oJVsIYbd`a)}~<<PpUh
zm_ihOc%ldzB}5T~%7`N1%p!^<VIhjZHkT;syOwAUW7iYKCa)rj#U~I&5VR6SKwLr;
zLFq=K=s-PD1W+eY1l8M#B8WB;MSI;u5pX4<2(~_=2*TWf!{@lFK%Jqt{H&q(2WPW-
zpXfCXy?(ZrHuLYE_)z!8#t(Z(UOTJu?`ZfF8vdAuKce9eYWQvqzXyDz?(co7-`yJB
zHVwZ~!#}9uyEJ@Q!}~P6Tf^V3;p;X05)ChC`0F+NTn#@<!<T6IDd2Twfdk3nOWm1b
z>IXBeCVND9R5DmPgk_(tzgvzu2d7){6Ic=v<k%yFrH(?8+a`&f0^17x9NktqwtDd4
zqC(NIM~*!+IMq=k>VKThcMAHgS2#+beSDBJU-5xYy3)pr?eMW>Fy~M@FUJlJPD<oF
zGH5-dHy`UcC$S;drD@%P!#PX3gu%Y-guY`i?+`DtA?Kx`KBA46SPz!2(So_o#Tva2
z>woSH#)c8FevP&JDzF9E1uPq4=|Gm=)-FgQKa`zu79MmX@0H?r@IbmF-QFqebn3RG
z*>^hiTUZgdCDp#msk@48)$QUW{nK(x98BuIW5j?uU!KNTg!Uq^5lFVCI3hv{JUmd-
zA?QyeIZiwE`}67ob*#r&hW8J^jWQ3y)@V(IZKqI>Z?wOg&GkRebqKbc%gdaZ&e(gv
zY?N7#GFgtC1D!(Fl7dK=@cf}n$6uVq`!gJ!LY^eYUK)^NJ#rfI3ihX3X>N`V7#&<u
zr;s1WIm~+Yz)v##gyH9L&@Rvk7>@|@jR#U3)aqSM)Ba>zinU#!@*fQxK4+|YxsUby
z3}dqi_Ey-QO2KcwBTeKm<5cg4*I7?K{7pQNA#z&`g>r02HWX&|b4-r)%iIoLlw*Ce
zt~=-OeEWPyhfscgsBYiI`&&*sb^9_zHmyK9K9VsPGom*Xnj7WVNx8zt6|=3Zs9j*i
zM${k-tQWJzGLd{Am3gre9ybjbre?gKIh>J-HP>Vlsg|1ulBb%_5cl}N)l1?&y5Ix8
z(|Gvd2ab=hXKTcT;s%kIvS61tU??mDeM%;c9l3KLWenulGttu1&V1<uv~5)twJ!C9
z97`Uk6s@qhPc}(&1XJUYzD)Gw@VTLfSkDa@qX5R}m!NBb7fKjIUzbf5@3rr{c<Z`#
zj*M42giP_zBSRaK#naAZpKZUp!_JE%LV@)5R;s}`Y|wXL-1kJ6eRe8X^+|Oh^<~OH
z(3ZCM7+xvzv0E}P{v=|QY?A({u`mzX>*Tl2>vqbqol%3>i#@a{y2d_7JbqqRMZ1;V
zT?L*&e{XcJWDuFjc&5>Q<RZJfU+NI5P**T&5bm%Rp;h7i)nY_2zH$k<SIVob^+hSe
zxm@OONm@ie>rzwp$+1j%rPWZ_*<zd?5sDk%7-5^_*cYQ1=_1Tm@%w0_9BYjlHa#p>
zG{#5v<Ix4m-28R4P%4(*8(}<IO}xlzYlfL_M@@UbPM3P>joPE1rt6Y6bF<~x?a`zi
ztn8LE3ooC+RGPu6s9|TVh`HMI0Oslu^nYG7UeBwel)DPKE08-YT5c;(tm5B{&a%x)
z@UM@W941?*V6x^*@iqR!=nPwO(Ts%t`=ezxyI7WxwvSSsQq(3|;Ik-7&(+aFdwODR
zyuB;FGLo?}MlP5nPS9gbJc>1O>pHB7Cs@yoSOc^s{s6k&z}WLijNJkHDzFa_N*LP>
z`WW!@V#WsWJNzXO1Co$;KlBflaBKwfFz`9B1Be0-7r~eP&iIa6_Ez_4r}3vp25)2q
z(h6lYl@~8;Ox=4tnwehvMRr=|aJAkb9*<^|lyZ}UP3shrwm$d0{WXR&tawLF?MXJx
z(fgbf;<$cs!tb316L*4}H_*2kv$ouuF6jGpM*VOGt6Kc&JNeS-5yPgprj!oplQOQk
zO4udoO-UzGhxPj6A-&!teB5W489SM@Lym2`z{);3d1yE{d+?oWY%hzc{Ym;?VHK}f
z+;<{>gfltCl&$H*y7c7Da%}sB56&k~9PWEoTE(&c+DZ32xtR-2PLuXZQ-$dcm((es
z*7e3=PPeM@;4sTBKUr*@xNn9i7g4O@FYq7t24;v!BW(TDrBm(egbtxh(rqr5j$B-S
zQ^6AKg61w^p~%B_q~9dv+4Zn6HD)0~=SwRRGnt8*%)P+PS=%>be|m(O-aVO(Ux`2V
zW#M_ckMS$J<MaAuVSHXEV;-KvZ_JyRi<?280bK^VrHErkd7NqSUj89qJRrwrU*Igp
z!^Q*ph|gr~Vc4splEaD%8s$Hc1%Cl;lhyZ_Z)4q519-JkD4ml?MhI5uyaYuP6gfFT
z>5NHsc-2!V9o|Srh*l__KS{>Vqe9VKh0^(z^67j@l+Kbw)l?d)XmNeV6AF8q&F;4N
z3ol-77nQoxn*DAMQJ32tTx5xq`XXs~-=&-|5g({TuicCAcAIt&-hCHU&R<Y@jfGNL
zTOjOh@hqwYyVes7;pLjlOp4NCnZ?hx%$`?XX(_iX;4PNxV8ue7R-7EjJ+lhSdA59U
z-3qp%zS_Ym0zrRsMabh@jkX3tY-#n4E3}!ew#Zsmz0!FzTe?hG!76!b5UaN?7uez(
z1fJct)*bTSp&b27EwdxqqMnF{m4<kwcZp|dD2@5=X+<_QDXhG-(}OLw*9sgRTL0VT
zP@T(hIz9s9BQQP!<0CLW0^=hvJ_6$-Fg^m~BQQP!{|h6q7zfxWz5(O-#csias0$A|
zN7J1a-M!LX7M*wLZiVh>@u@|*r=>d<y2~Y*5J0($qq4sWhh%)ZVPRy_Iol1H&dFZr
z>71Mc(7BruoyVCaephx3EZzIk*`4lYs!*8tUO1zBxJH1^<M<5AF3GZ=*uQ~N9p5z3
z{kfWQ(7*pQ)VgRawP__fLE}nk8~QIJnd9RB?X#}7_By_-rp@bf2mSsqU%tjNzjD62
za{dgya*lb9*}|%?#o)L+t|l+zXta{%mshjow3KQim#Rxk%Fs<POyqL8N!(<89+$71
zYAE7na<g=To|!`uE)>JACT7Onq$e0)=2m~$V_wtRW^SSy%W>tXNRlfgF|)h9HPqe`
zr{N$o2R%N@i!%Y-pTZ4pR?T5g1W)CD)g1J@U11k9d!+akY}}^76%4xC<2EV}Pp%ek
zGb;3>bi7nkD8$Uo{+1T{IAX3|zSQgrhlAdxwy-Dk&6fo2FWSTOol5(E6x9RiDA7Km
zB}sPL|BXOY676S7GXdJmWJmj(a3YZh^3~p_?`5B3FOppq9)uF`RF)F?BVeg3F@WqS
zE)a46+QSqJ$R-D%i6)usD2@;)eyB-htB`^4rPxuNAT&bO)=Tli29RA1KyigY@rLXu
zwotufw;Ukf)E@fJh63<vqV`Z)3aEB!48d2duM+tqI04nJ9u*L}G_ineDA9iuRJ#+1
z3j}J9n$&vT$RInC-+>LGUR5Gb_2<*r%|ZtWst&5J__g5an<tGm#drE2&{#W??*~wo
zVn=a5_g~mO4jXkYmH#Wj?pz`dMDb1idJ3R^P`%2c;1LIjPb8|7up3bAC{AwUF)oym
zNNQVu2$}qnzulEUA=Y2c*M_RykD#YqT8EU#t|-nbPtp;(0r(0inRvVoy9KHMN;Z^;
SDt%BS+(p3dNP;J#+WiAB%8B*>

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/arm/toy.debug b/service/internal/crashes/testdata/dump/arm/toy.debug
new file mode 100755
index 0000000000000000000000000000000000000000..f972a5c4c57bf0df327f34b512505a9de6a89f25
GIT binary patch
literal 16828
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
E0f!Qe9smFU

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/gen.sh b/service/internal/crashes/testdata/dump/gen.sh
new file mode 100755
index 00000000..efd0c4c9
--- /dev/null
+++ b/service/internal/crashes/testdata/dump/gen.sh
@@ -0,0 +1,38 @@
+#!/bin/sh
+# How the fixtures in this directory were made. Not run by the tests: the
+# dumps are of real faults on real hardware, so they are committed.
+#
+#   gen.sh arm <toolchain prefix>   e.g. .../bin/arm-openipc-linux-musleabi-
+#   gen.sh x86_64
+#
+# Then, on the target, in an empty environment -- the stack slice reaches
+# the top of the stack, where the environment and argv are:
+#   cd /tmp/toy && env -i LD_LIBRARY_PATH=/tmp/toy ./toy <mode> /tmp/toy/<mode>
+# for each mode (own, lib, libc, sent), and keep each majestic.dump as
+# <arch>-<mode>.dump.
+set -eu
+arch=$1
+cc=${2:-}gcc
+objcopy=${2:-}objcopy
+strip=${2:-}strip
+# Paths in the debuginfo say nothing about where it was built.
+map="-fdebug-prefix-map=$(pwd)=."
+sysroot=$($cc -print-sysroot)
+[ -n "$sysroot" ] && map="$map -fdebug-prefix-map=$sysroot=/sysroot"
+case $arch in
+  arm) flags="-mthumb -Os $map" ;;
+  *) flags="-Os $map" ;;
+esac
+out=$arch
+mkdir -p "$out"
+# libtoy.so: no unwind tables, stripped -- a vendor library.
+$cc $flags -fPIC -shared -fno-asynchronous-unwind-tables -fno-unwind-tables \
+  -Wl,--build-id=none -o "$out/libtoy.so" libtoy.c
+$strip "$out/libtoy.so"
+# toy: a PIE with .debug_frame and DWARF lines in its debuginfo, none in the
+# executable -- majestic's release build.
+$cc $flags -g -fPIE -pie -fno-asynchronous-unwind-tables -fno-unwind-tables \
+  -Wl,--build-id=sha1 -o "$out/toy.full" toy.c -L"$out" -ltoy
+$objcopy --only-keep-debug "$out/toy.full" "$out/toy.debug"
+$strip -o "$out/toy" "$out/toy.full"
+rm "$out/toy.full"
diff --git a/service/internal/crashes/testdata/dump/libtoy.c b/service/internal/crashes/testdata/dump/libtoy.c
new file mode 100644
index 00000000..bb0b127a
--- /dev/null
+++ b/service/internal/crashes/testdata/dump/libtoy.c
@@ -0,0 +1,9 @@
+/* A vendor library's stand-in: built without unwind tables and stripped, so
+ * nothing but its dynamic symbols names a frame in it. */
+#include <string.h>
+
+int toy_lib_fault(const char *s) {
+    volatile const char *p = s;
+    int first = p[0];
+    return first + (int)strlen(s);
+}
diff --git a/service/internal/crashes/testdata/dump/toy.c b/service/internal/crashes/testdata/dump/toy.c
new file mode 100644
index 00000000..15e3e637
--- /dev/null
+++ b/service/internal/crashes/testdata/dump/toy.c
@@ -0,0 +1,208 @@
+/* A stand-in for majestic in the crashes package's tests: a PIE that dies of
+ * SIGSEGV and writes the dump majestic writes (MJCD, docs in ../../dump.go),
+ * so the symbolizer is tested against a real fault on a real camera without
+ * majestic's own binary. gen.sh builds it and says how the fixtures were made.
+ *
+ *   toy own     -- a NULL store in this program: frames gdb can unwind
+ *   toy lib     -- a NULL load inside libtoy.so, which has no unwind tables,
+ *                  like the vendor libraries a camera's majestic loads
+ *   toy libc    -- strlen(NULL): a fault inside the C library
+ *   toy sent    -- raise(SIGSEGV): a signal sent, not a fault */
+#define _GNU_SOURCE
+#include <elf.h>
+#include <fcntl.h>
+#include <link.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+int toy_lib_fault(const char *s); /* libtoy.so */
+
+#if defined(__arm__)
+#define ARCH 1
+#define SP(m) ((m)->arm_sp)
+#elif defined(__mips__) && defined(__MIPSEL__)
+#define ARCH 2
+#define SP(m) ((m)->gregs[29])
+#elif defined(__mips__)
+#define ARCH 3
+#define SP(m) ((m)->gregs[29])
+#elif defined(__x86_64__)
+#define ARCH 4
+#define SP(m) ((m)->gregs[REG_RSP])
+#elif defined(__aarch64__)
+#define ARCH 5
+#define SP(m) ((m)->sp)
+#endif
+
+static char dir[256] = ".";
+static char mods[4096];
+static size_t modslen;
+
+static int out = -1;
+
+static void put(const void *p, size_t n) {
+    if (write(out, p, n) < 0) {
+    }
+}
+
+static void section(const char *tag, const void *p, uint32_t n) {
+    put(tag, 4);
+    put(&n, 4);
+    put(p, n);
+}
+
+/* A file copied into a section: its length is patched in afterwards. */
+static void file_section(const char *tag, const char *path) {
+    char buf[1024];
+    uint32_t n = 0;
+    put(tag, 4);
+    off_t at = lseek(out, 0, SEEK_CUR);
+    put(&n, 4);
+    int fd = open(path, O_RDONLY);
+    ssize_t r;
+    while (fd >= 0 && (r = read(fd, buf, sizeof buf)) > 0) {
+        put(buf, r);
+        n += r;
+    }
+    if (fd >= 0)
+        close(fd);
+    off_t end = lseek(out, 0, SEEK_CUR);
+    lseek(out, at, SEEK_SET);
+    put(&n, 4);
+    lseek(out, end, SEEK_SET);
+}
+
+static int module(struct dl_phdr_info *info, size_t size, void *arg) {
+    (void)size;
+    (void)arg;
+    char id[41] = "-";
+    for (int i = 0; i < info->dlpi_phnum; i++) {
+        const ElfW(Phdr) *ph = &info->dlpi_phdr[i];
+        if (ph->p_type != PT_NOTE)
+            continue;
+        const uint8_t *p = (const uint8_t *)(info->dlpi_addr + ph->p_vaddr);
+        const uint8_t *end = p + ph->p_memsz;
+        while (p + 12 <= end) {
+            uint32_t nsz, dsz, type;
+            memcpy(&nsz, p, 4);
+            memcpy(&dsz, p + 4, 4);
+            memcpy(&type, p + 8, 4);
+            const uint8_t *desc = p + 12 + ((nsz + 3) & ~3u);
+            if (type == NT_GNU_BUILD_ID && nsz == 4 && !memcmp(p + 12, "GNU", 4) && dsz <= 20) {
+                for (uint32_t j = 0; j < dsz; j++)
+                    sprintf(id + 2 * j, "%02x", desc[j]);
+            }
+            p = desc + ((dsz + 3) & ~3u);
+        }
+    }
+    uintptr_t start = 0;
+    for (int i = 0; i < info->dlpi_phnum; i++)
+        if (info->dlpi_phdr[i].p_type == PT_LOAD) {
+            start = info->dlpi_addr + info->dlpi_phdr[i].p_vaddr;
+            break;
+        }
+    /* The first is the program (named "" by glibc, argv[0] by musl); a later
+     * one without a name is the vdso. */
+    static int seen;
+    const char *name = info->dlpi_name;
+    char self[256];
+    if (!seen++) {
+        ssize_t n = readlink("/proc/self/exe", self, sizeof self - 1);
+        self[n > 0 ? n : 0] = '\0';
+        name = self;
+    } else if (!name || !*name) {
+        name = "[vdso]";
+    }
+    modslen += snprintf(mods + modslen, sizeof mods - modslen, "%s 0x%lx 0x%lx %s\n", id,
+                        (unsigned long)start, (unsigned long)info->dlpi_addr, name);
+    return 0;
+}
+
+static void on_fault(int sig, siginfo_t *si, void *ctx) {
+    ucontext_t *uc = ctx;
+    char path[300];
+    snprintf(path, sizeof path, "%s/majestic.dump", dir);
+    out = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    const uint8_t head[8] = {'M', 'J', 'C', 'D', 1, 0, ARCH, 0};
+    put(head, 8);
+
+    char hdr[512];
+    int n = snprintf(hdr, sizeof hdr,
+                     "signal=%d\ncode=%d\naddr=0x%lx\npid=%d\ntid=%ld\nthread=toy\nwall=1791500000\n"
+                     "uptime=100\nversion=toy+0000000, 2026-10-09 00:00\n",
+                     sig, si->si_code, (unsigned long)si->si_addr, (int)getpid(), (long)syscall(SYS_gettid));
+    if (si->si_code <= 0)
+        n += snprintf(hdr + n, sizeof hdr - n, "sender=%d\n", (int)si->si_pid);
+    section("HDR ", hdr, n);
+    section("REGS", &uc->uc_mcontext, sizeof uc->uc_mcontext);
+
+    /* The stack from sp to its mapping's end, at most 32 KiB: write() says
+     * EFAULT where it stops. */
+    uint64_t sp = (uintptr_t)SP(&uc->uc_mcontext);
+    put("STAK", 4);
+    off_t at = lseek(out, 0, SEEK_CUR);
+    uint32_t len = 8;
+    put(&len, 4);
+    put(&sp, 8);
+    for (uintptr_t p = sp; p < sp + 32768;) {
+        uintptr_t next = (p | 4095) + 1;
+        ssize_t w = write(out, (const void *)p, next - p);
+        if (w <= 0)
+            break;
+        len += w;
+        p += w;
+    }
+    off_t end = lseek(out, 0, SEEK_CUR);
+    lseek(out, at, SEEK_SET);
+    put(&len, 4);
+    lseek(out, end, SEEK_SET);
+
+    file_section("MAPS", "/proc/self/maps");
+    file_section("AUXV", "/proc/self/auxv");
+    section("MODS", mods, modslen);
+    section("THRD", "1 toy\n", 6);
+    section("END ", "", 0);
+    close(out);
+    signal(sig, SIG_DFL);
+    raise(sig);
+}
+
+__attribute__((noinline)) static void store(volatile int *p, int v) { *p = v; }
+
+__attribute__((noinline)) static int parse_level(const char *arg) {
+    volatile int *slot = NULL;
+    store(slot, (int)strlen(arg));
+    return 0;
+}
+
+__attribute__((noinline)) static int name_length(const char *name) {
+    return (int)strlen(name) + 1;
+}
+
+__attribute__((noinline)) static int through_library(const char *arg) {
+    return toy_lib_fault(arg[0] == 'l' ? NULL : arg) + 1;
+}
+
+int main(int argc, char **argv) {
+    if (argc > 2)
+        snprintf(dir, sizeof dir, "%s", argv[2]);
+    dl_iterate_phdr(module, NULL);
+    static char alt[65536];
+    stack_t ss = {.ss_sp = alt, .ss_size = sizeof alt};
+    sigaltstack(&ss, NULL);
+    struct sigaction sa = {.sa_sigaction = on_fault, .sa_flags = SA_SIGINFO | SA_ONSTACK};
+    sigaction(SIGSEGV, &sa, NULL);
+    const char *mode = argc > 1 ? argv[1] : "own";
+    if (!strcmp(mode, "sent"))
+        raise(SIGSEGV);
+    if (!strcmp(mode, "libc"))
+        return name_length(argc > 3 ? argv[3] : NULL);
+    if (!strcmp(mode, "lib"))
+        return through_library(mode);
+    return parse_level(mode);
+}
diff --git a/service/internal/crashes/testdata/dump/x86_64-lib.dump b/service/internal/crashes/testdata/dump/x86_64-lib.dump
new file mode 100644
index 0000000000000000000000000000000000000000..1672f594edff812801c09e97af7428512cf5cab5
GIT binary patch
literal 12000
zcmeHNy>A>v6dxzy>-Y*45D;t-6kyIbGrK#xYh+;uCnO{W%T6Lfh@Aa8W5uzLyYs~%
z5(FwFXz0=)(EusvQK}#$PzwG5x=0{|2o)_zVcyKVz1urG#Nph{7T$e3Z+`FX?|sai
zJTtGoGCe|ek%QB7&ijOr*3#liygb2JC0)((308@-tT{o~X{E80O)!sz5fhbm@AEs&
zJkBQCtLH1{;$=BCh?q~|s;o8IOJ^mBeC*`S*3#+<sEw*YN?&w1<)X@Hl|~Mw<5FvG
z|Eu$4M7q&;-D~6nJM_a&BjcS+cIc%GgzP?bWB>SD-N~a<TE6_udmsMu0U_63*7vSP
z`RSsg$DjJ_U4?gGhjzwQYNL`TeLYm3R!H9+|FdMj7}(;&{L!hyA3se9`h$KSda3+<
zyF4ueEzj@#bnnHuJWdRmi=zMi79ARry5tW-sS$tq()so9wNDV<F>%6pjeNCF#o=_{
zd(vo9i2Zf0zw7#59k(ApZ!3MoyW(AbVdv@E2;yy)FIT+ZtDtwq`{=pmj^FNs`H(N0
zU5H1F{}+vakA1EEy=G+0NAwfl_v2C%$1lvh{&AF#8NEwJFEj)AUEiDh#(epyFW-Oe
zllLO<Y*X>3^PCWB5`4EAzxnr#tMGU?>YIT_jGUP}`Z4L~xM01YpLZEOte<-jPsS7K
zx11b=s6a>^<mY~)|A#U3K%e}ek#CrBw1e`aW*l#in}<Ws>ipSbWYcDdEJ1bsWq5no
z$R~{c6GlcJpEUBMxewfaFbUKC_5wR|^X)zBp;!>!fSP?_8L$jk1}p=X0n318z%pPN
zunbrRECZGS%YbFTGGH073|Iy%1C{~HfMvikU>UFs+=_v*nml<xmX{JzYoBd^Py^w}
z^um!t`{t(RPAtq$9X&XKgGB2i;>^_Se4|2$AG@*V=Lwfb7^*0^QgE8pYC|4k&=;I$
z;M8}xV1Y-S4KB0;j#PSq3RF*{u4`0zgo557DgYIza4@6mD}2Tsq5@EXDu#s$Km}@`
zP|q1&70Y+VD*z#C8kSI{pcsI^P9;d9(4|0_oL~g5CzQg=s5>sh>-(-72+9WITU%>2
zA-`(+|GU-YrIoey>f*{8yiCVht78I<DSTthPr<T`kB+)FJw#&~-xw1#*TxjVOq(8}
zF^!MLn94O%C0v^xrZI(I7}Le0Q-^EQLp7#qN+*cmsy3ULrz(Q#G*dUD0vgHJ#=C$5
z)y}OaFvvQbz+iT_YNb%F+6@xWaf%KjGfp-cnR6!N0tHuK#~ORHKC@M9fGe;QjcqD;
zpxbN}8{i6TO(K@%|HcNm0y|TFV?+l!&sO~gxB|Og!j{57{|OlA-~_($@&eNa`wqT2
z+3Cd1Qy6dsQQ(!AfRY0^ec-O}7CPzjYI>#%tJVNr1p(LH+H@{J?S9t)9KJZ&$y%#j
zJk_TW??2kEABBk0y>HTTGt+-%Gp-5`x-T!N>8&%r{0*wEd)vm4Y$`Jt4$<2eDa4vO
z+h9|fDQxQYXlln*Rk|HEd%9#GblRDka#e+Ght1xc6nbBRbzI8HN>Hz-Aq(Vs54EO+
zxOd$E_1j9~Ry&5Os23NQm7s-OmwN<&s@`68ob0sDw^DhO_Ecr+*qg^2@(3!PFC+Gx
zo;t_7-RJaX-k6^MM)FSULCicqa}$r|q8_C|9CJ4eSr}81<UAGiJPlLNq3gJb*DFz3
zEY@P!?Z+PT^T?H(uY{(|i$(0a0rf=Yr?E_#B&Tk|xyvOc_Ci%VeWKn{LIZ_{#wyjW
zzS=zWi-ix}{Qwoh=RxkdG<JC)!Yt&0$H1|W<$02@I1D(C;On#}P##bcW$|`4yCUIr
zFR7=APm?5a>%L2K7DYS><0xZ{%l43DaUK-dW<fzyMuY}0yxQ_c9sTIRxoJ3`${b*M
L|LfBZ{CfKryglKh

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/x86_64-libc.dump b/service/internal/crashes/testdata/dump/x86_64-libc.dump
new file mode 100644
index 0000000000000000000000000000000000000000..923c90a23e0e9cb023aed4dacb81b9817872de63
GIT binary patch
literal 5816
zcmeHLJ!~9B6dor8$P&QN@GG$?K#IcoW@i6`PO{+=48#!mCjv#5nf)_o9N+2AzMK(C
zqR=8F8l)6RsYnVUghWAsgbNfQXpj&ET{;ly(j*c{Fh6hRymvO(=G=LU+j%>0zVFSO
z_ujs}iC15$4xxL{cy-b~j}U6r=9k!Fg%B&Lr&)zqEKQpg+`(3(mR5*M!ia>{^7`>R
z&5Wg$<@&01jxF+~K}0+(E^DQ+TszA__^_QdTebR<P&+CoF@D~rnEEAxOE|JIKE|~s
zkH0*HhPW9$*Zm-$*rx{jLDqMKzPwv*AT&IC@aJnY-Nnz1Df#>NzN-9n0ihcg)V-@w
z99`?E`A@H2mUtiRQ^q(_?I`z?x*jSnGt$~=tH5t2wmF!Z9((QW`w-IhgfA5L^_!z)
z;f^EwKRkSq73UE+ao+EJzD+|0q|W`Ok5C~V`sK=<%irA5@S|`(`kaP7yCnU8vFAC$
z*YAomze!<V`dnwfkop>L!LnDYx1ar3<82lv3)ao^LT|zP;l`29rH{mV5ht5n8V`Z}
zSAhTVtIFQrLDq4o?bOeEaj~oRu?FjU=e0ZodS8QH2ori=YY^8uzJKhA^Iv=9!y0(_
zy7ZfhZ-g)e_At!<{pYQ3#qeIEuLh5RoWfn(F>0&*=seMO9soU^H$1e}#m`gZZ810y
zI;f{%-w%NN2M`_Vksk#47R+lNEk6eH`t}42YVWIje-dOUFX$PNZ-d_+26+|qp8{F?
z@oA7p;of(96awa_6Q6vy6nF<Zp+D!leQJ9T_B^oXfvtOBq|EyXv{;K1R9-&Y5K>u6
zC#!QOUwLtIZ1SzSQ)AQP6+Mg83e7Mvc513&A>?^1OdT9i-kOxO;BdiimP!rYoTy85
zDHMA)^-17jdxJ~!2urN>KnB%Ss2zpMTO+(fQ~_jAMZ?v#RcvF2r~=5K`h!9hKn69C
zsOP}1(#t#Zs{qodEG(dML3%*^+E##Ro`*t%F93n61%=}!*g3|J*Yg}F@G<E>-||YU
zDFUpl>UU|ewzSeI%`dIUs2ge3M|@2t@qsK#1T#M$b?S<GfMg0E$QaHPnRGBw)B_|_
z_?nE!Sc5E~ih7V_65o)i<WZqR74<;LWKO97VN~X3Q^%=1LHU)^jVKn&bb$r&e}^DT
z)-xo<tkn#r!fX(Lwrwg54?|vLc+5e>F$t$#l|b%pR%f=0Ei)K4ny3ucsnb_&wu>$E
zSYsE{@_%CsIOCH@CWb!IzRI&*y9J!Vjtkga=&L_05jti;E*EGg78dju9(Z!5-Db^M
zbKn9(<E1KGcYrt7P8RFQy9QPw8CZA=LL6<?%(PYS;t2?Yr&73J=K2)&qOgDWo0QxX
z>Mt+GCEpd*mulCf>+&qd#XU$z4W3icz&_(b5tasEdp9^mt=F7lW8E&mkrBBIoRY?H
zs<4Bca#CTzZg2`3!>QgmI*;Y9yOlZ56DN(SDk@5F|D`hbN1M*I)-n@Wk(*1@KyHPR
zbKWEH2X+bG>vCH3T_X4UanH0{tF46pMK)`V&AfTK!T(y)-;ZeTJ6!%hx7*+06K_<f
zKIeYNdBBM4rB3YP%+I4FV2nCpNJ57FIHQT5XGxg2Hty&qUcHHmqInmKZlAft%OZy-
zWQ-HyGM{-)fL%ZJ62?O&&ae|x>QIge?>beodqmYzws`>+1&vsxuD)y@dPQSHw;#a1
z@6jN09n2gW_+c8-z$L=4kYrgL6BY)PMq+o$5|JJvW{cuhnq5Dpxf|yRZ-nAFa&phX
z8Hpkqhb&47p+0|}vMeyzjDKdWqXJPBc;78AZdB2y$0w`e|0iM#FCTxsYKyP8e*k-1
B1KI!p

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/x86_64-own.dump b/service/internal/crashes/testdata/dump/x86_64-own.dump
new file mode 100644
index 0000000000000000000000000000000000000000..9e00307ee1bd0df69f7d3e6b52fa4ea71f31ca5a
GIT binary patch
literal 5752
zcmeHL-D_M$6rZ%U)~(Uj7r*i5O-*liX6|<}km$BXZEQ(Wv6K?#er$|xvtc*cq)}}C
z0RM@C9|$6XDEMTsP<$xV2VVriASFoRi;@SyhdLkU+}+$HwM|ldu=io_J#*&%&Y5$5
z=giz4diAAB7uiP!E5p|NgplUM_@t=yF;+_IY1YR|B2628bdHv$Cel9UvM^$9X}a_I
ztwtu&zUlhK(yXY-SA&RoR9&T+sp*Le5=1_>vPN^FKB=blY9*ydEKa#^GiuYwqV$-Y
zHGKT#5z-~yC|n0XKC#C<>;)O`<cp84+?XfiQ1_7+evS#j@!mgrwS3^+g|jy=5%T?|
z^>;K=gNNVdjQ-TBdGEv?<BX&Ay<|Vkdk9}F+!y!T+FoJ!j>VDDf!D122|<6x!5>`L
z!5hXu6^`fje$caU*sQy4$oM_JZ05Dc|C^_MgkTDd1Ldc$^*r+V@953Kyoo#Jsq5od
z=X0?zPL?iTQ88Hh)vT)@^jEt-)bkN<d2QkCFMnxTh=*}2@??3fzozCbudV#pTB$s*
z-d8-?>OwpM{x5<3$38LsJ_|fU9-^N(Uc{x4M*{B^^(dc#d4GYu5EQts?+U!W1~R_?
zQ$g-Q#o}chH^Xm2C=mM)=x_eL`mK6I-V;z927L;5^rQa=lNXt9eW9QCfsAz{sckNq
zPgS?;$w9~ipvL$d1bGDvJy?*tL0$zt+ClkI(BtiKc=+@^!@DOyhW0|90r^je+ruD#
z1M{B*8RPgA$o+8NaQg}fvv~dN*H`P!`MJ;^^W6>8?hV|F!2c@(N6Yd=K<cxTq&$6L
zN(p5poUDwUeC5UAf#I`brw2v{`%p>De2mf1!0C~x5+OcM6DQ$uDvuU63YiqFhHX#D
z!-cujDT7nb;yw#pYHf0%9py-=6DUWm8q_(1DvvgFo2Uv1Q4{4~+gHAAR1K7)YVYz0
z>;P2(<)|8`F$-~Zw(qL~Lex~_<fu}k<EnnGQXn!naeOsMZ4h{<rsRuLDvMF)m`tzd
zIZohHwlTlunP#J0n~2M%|Jt>Q$(cEOd~!w&CP$m~qdpqb_+Tu+{Ftm8)4OQQ;DfP{
zb`qBv)4OQQ;G;2SvT3S>8`HaKOylRqT%9vR9d1nTsxgI+#<*cW@>CN<e`T~8CDb6k
zAn3nSP*7d9hJr#FC{nPq!)!u8%gQ^9WSnd=l5@Z~0|(v<2DQ6YpSe?PUBT#gXU-|r
z(oX!=b&S|1h}d;^jIH4Em~_&Insn{N?+&&Irn-xD%l>2L<jyGa6#5U+Yh&Yqk#nt<
zXq?Xzt{`$eRp{Ho8*3%Cdh$*iRw3oE&`f|wQq%6Mw{SCU*4uarBFBUMuX9)JEMYGS
zH^Oewa#QHPvKiaHtGX}GL(^Gj?)o+8%D4+QwHaKe7pX|$_M%w0etX%ab!s!Y&3K(n
zE!~B6dI~tVX=n#s(oqMfb=&A}t+SJpp0=`8tyQa4FAB0iJE?_`n!SG0R=$yKSZmE`
zp{hbczy${g6suKvMo{au?c1u3bFJpZW+MOMI$s(%^X3~<@-G(r{v-FkqxJu5cl$ef
z=u~CoGZ}YU4Fq$&)QMf1`PC>1gy2pXvQSVz&UoTivm{Jhi_YO8UURM>=6kU^?F*NA
zS>(uG6Vrsb!WW(sP}fhrL`cfS8FgaL9WF6(uhX?t5Y3UYB^#(}Xsl$n=j+2mQOtd4
zp9iS#dpyWohYE)Wewc<laG7!}WLXx+OoRdFky@Sc#1OkE-p*myk9pONt4Zw9IF6jE
z=g^Er5syO=rHpZ3j;A6Ea%`dekXuL|11+is@4MyNW*vQWaJZuWKVp`O^6}Rzmil`8
E2mK8fD*ylh

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/x86_64-sent.dump b/service/internal/crashes/testdata/dump/x86_64-sent.dump
new file mode 100644
index 0000000000000000000000000000000000000000..5db60568f33a98541ce79a1e55fa60e605f92bb2
GIT binary patch
literal 6874
zcmeHMON^975N?D893S8V#7E-K$rv1_`+pB)k{uWn5p=T)s3BzYKVjmsJDJ%Xmc*bN
z<IQ9}c<^H6gvO9~@#0B{3C3_C-aJV(@gN)wS7WrRyQ=54i!APXFw>Ww>gxW!>gwwH
zyL*lt+Fx78Hn4-WaqDBoSgU?&I-05oQAlRetWxv~QJOX@eBQ|-&V?8GQCMiy(~59K
zShjg#w)^+#W)`KD*_m^Nv(c193ChCbPzrO6+4`BRBIM6@)@;>hrlH#|rR4kt%jULU
z6uijG7Uz3puU0mlW=%sge&D4EwvMsw(#Gzx8HE?`(?1?Sc|CO+eZTcwo3X8xpGQ85
z8T<U=Hl?BZ#)ezB{(Ps?PUC6#rRb0ve*ycEOni>&xQn_kTVM8nQT)qxxJ$*v(dsLw
zrIBRM$a3SpaBhEDdVQ}Y_0nyO=0$#?nvLlBpFdGk^JM6+t6OyYj!nA$_A%{0aP#x)
zKiK(hRm)Pu0xXQ3+TP!e>i@Xfz!-&wW=4OI86R%!o!`2P`_%le_qDUeLJNF#<54}Y
zG1OoE<UQ>#1gtMET*%+Pc7^<9{M#3Q^~LH%=vQC7_UqpL=YN3V5P!=R!eeOv?_}R+
z+TIY?hvJ*;r1pMX{<xmURvg!_C;1rm+l>7}RM5OGV|-AYTtk`0|JWz*B*oZ*@|)f_
zjPZxHVk_$Z`s3y|@N*-|3>A-{oMKIOj50kRx!$UfowP3yo^3)stS97y-r!*De$<nH
zXutf1L=U2#<cCnciF)E8`3d5~`bn(6-mK&9DU>m7v1d`fjegsL^7q*PX_U#2&!9Yt
z^+2@^1LpeipT>85`qg*yp+D)n1KoxVLk|o+F!aFC149q|A3d<UB(E7vUM6N)Y4%J5
zq>_>j*Cr3Yyl=cZ{^sOZ_2|J0X_+2DzBp1Hn`jgm^X;<Bz08ISOOXV5o8eZoSZv5U
zi!N|^vAJj2z6e}yEm4REEGcvY8C2kqsPh_Caoig!02x$AqoS>f<K9pK$e_Bbg$h6h
z74D2y^DNq`EWbBf0f<l?zXw$cTwgUUZWRLG4gv>^kONS#L+H}Gyn;J><nnr+;{-kz
zgX>$GYc)$#^|++ZTg9pR^xS;$)bt!QCc9fRyL}>4_(<j@z-(4sQ?DYK#z!)rXI(QB
zntBz<G(M3DjAyl)wx(W9GKFu*bU^CRu{HIolBqb=0pi<w|5Kc*6_jxbaYYdo<Yn26
z)&)7Zx)az-4G1|z9S#UNjP47;?wzni09uyGFf!s~l94fo5vSn{wtUa&L>wQ;Gb_ag
zID;Mc*gcSKR*DU923tFkvhKge1~`MAD!XY#2Qtq}?FKl5o%di%VIcp69Qx1z(VMb+
z1`H-1Y&p?xN6nM8;0nUv>9k6YTLIo=JDHkE-s-@rysCFWC<2&?`Ci>EY}%UX-~og&
z^B>Z#R}Kefzf8(aG5^YBT=ZSYzP52q_daub=b-jNciLDbPDMlW^t$sRhqdO`8gMEa
z!>Q9FhJd4X=~{4hWy#R%`I<Xwhph!?cT9SB{MP4rnkDd@4MC@c<PNEPFxqIZwPqvO
z6}c%uD?yE%%QJ#(u!?k=1GPDI3;>^Kx6ZW^`Eq`;P(Aj>@rHa-rS~2-d^c0?^lSZY
zcI36%#3ku>o(GX|z0`?ap80t>38Kh$!cc?}_v6e?{5(s-#I^W59pd%c_KN0P45$6b
z6<$_$<l!skiE!m#DV`H>*H679k|7gk+=*@5u_Y$uR<(EfM17=e%LEDuO%#fq{_611
zFB%&<=K=2fo*iVa!z0HI{4fpez!hLvD6%Y$MHB|Myzv+)*w7HUXc&rjbJ+D`J9pze
zi9H_2WheI>o{4hVj>D*&3Ss-QJ&m%!VB-gcs8ECi@4Ka`r84@_gX1-LFBTSf`M|3+
I3vO?J1M$uKL;wH)

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/x86_64/libtoy.so b/service/internal/crashes/testdata/dump/x86_64/libtoy.so
new file mode 100755
index 0000000000000000000000000000000000000000..5ad91d906ddb154ed12ca2e5b09f5c4703b219df
GIT binary patch
literal 14160
zcmeHOPiP!f7=N2Iy3y2)rPZWbvxt#a+cAkGv_jgo(Pn~esWv$knM{&Nva)}|?5t+J
z7zl!;R6G@r(u3&5tDYpG5=!+D!9$NhD5M~zAWG~Z>-Ww3ezTJ?k?NsPcrRpr@B8z6
z@6B)C?6S-^AH8|{R8uOY(3;h8)v%PxNua$K8SFc%TItxSI>OvtjnF@O^AZHAcAdg=
zv~XAKBp#DR01;<*IAoT|)Ux3*!h>Q0<Ge>GwsAx!Yz%J2jwWqq1;JyJd1*_>)5o{s
zlB^S$*5PoCyv}r1@)Ia#w0!W+-wLMw5ASW_@jCCfLH2iKzMXVQiylBZT?Jj(Zp^zY
zh5oB|zWDUt*242=w@H{J-=1y!JWqBT|KT0{r^x^OHu+=Z+oRf4=aV`ppp@gx6w4*2
z61aZgILa9rJ>yJyzBiMv1fD;7W~fjud86(`!PBwrBhKW!>rCfMZXy4nr-E|LDdZ=d
zX}4MkR3-2WUP+N-(yElL0X2Mj<m8akXZ2bA;bOGZO^VMoMSt%R;yP9L=UWx29_VE&
z>|gAgcAN<Ir{t~50O_1|ARqSi6WY($jps#Mjrp75B)l2(%dH(o*JA$gz6K|!JC72`
zRzk#}QNSo*6fg=H1&jhl0i%FXz$oy575F{#+&z2ox3qn!W%(7Q?2ng%ruwSA_(S?y
zxRQGR4RY7Jf1+ciE2lVrmLs=+t=H?*pRrx<zCzLIOxGJKjMuxrjBNYz;MZi>ms_qf
z9NP%?(Nt%-PgAwl*D_rTJlr)w%CCj_{XWB?P5a_qd-=`@dwHYTPOaEKZw7m5fCDl>
zy1u681)tZmFxXFFRegEPUL3r~Kiut$w}LkN(%@6%Umu}`uTRlorDZqSsdtGR&CmSX
zA5f4x=QH1Tt-nM@>gENKgI%FkkvhC`(~JT}0i%FXz$jo8FbWt2i~>dhqkvJsDDdzo
zz|ZpdQ6WFO8$LV6&+3-g7k~CgrfEh2qkvJsC}0#Y3K#{90!9I&fKk9G@Q^8hdQsGe
zqV|((PPw&dhzd}5i+xz?OgqI!9qKb;qrP-M_)?GhY$E>0X1&a=qf!)#n$fiU;6xqq
zxWpe5{(|7+f*peRow_b{sHinXe6Qqj9V)k{HK=hZVuk-Z83^a`mE=+JZP+m0W?irU
zbIGTN#Nqis$Gc*GBJsb(#yVxV2L`BHPfpmAs1F_<8hR~zaBQMl3aZ)OeyUCGInp~&
z4ej1T;!(<~%u+dX;7%xOrc||N-O8-8rfQ{1t*9~Zb>w}|ujI?6Ervre-z&IGklq~C
zM_c()o{rSDX3Em3c$3Nsym>OIsyeSMZ`PUi-J++gQaSL#$>;p?oaYBMJ%Ho-zDs>h
zN1x_#i+LJ}#^v#8iEiL3Yobz7)?~R@^h&6!PU`btZQhrE(zV9^!~O=oAOj+feTI4V
zQHRGs9Qz-L{mA=>_Zs-vmj}qlG4OFe0T(D1Z`iN!byJ7;GWgiPz$YXT@g(+9obL_z
zaen}_!cVSW-0F4e@GS{G?nfZbAMxb*za{*WG9d16Aar6re<mdP{C)syg3q6*0AKDC
ze9loy*yQ5_raDKxI6o`A2%}8hk#IE4g#<q*2|(my7}&t61pk}_fXLg4Urg}Fg#f$(
zqF{2oN`jB?3n0EnFicXvn(%RbRaP<ulli!QlBE`@6Mxqr`TmUzgY@Y7!*PW=yvKQe
za>Mr<-j7Mn2OD^mI2rl}pI)cZjmwazAx~Qk8~$%7z<UpTd~W0Yqb1&4@whe>u7g81
zr+|<5JFZiu6Sr)5Y#cBz@LLMS`S?Cvzfb;Bf{*u1(mi@k%%iQw`NLkJ4(DL~?KvH3
p-+?c3=p;J+NdN4U^vDnXi;+inz>g#5j;9XDfWO3@)CUjlzX5slV%7iv

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/x86_64/toy b/service/internal/crashes/testdata/dump/x86_64/toy
new file mode 100755
index 0000000000000000000000000000000000000000..f2d66522c93417dc41b71ade59a899d183e5a2d5
GIT binary patch
literal 14768
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

literal 0
HcmV?d00001

diff --git a/service/internal/crashes/testdata/dump/x86_64/toy.debug b/service/internal/crashes/testdata/dump/x86_64/toy.debug
new file mode 100755
index 0000000000000000000000000000000000000000..a9c7c64671acdce1241ca2f7310c482636a1f5ee
GIT binary patch
literal 27152
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
Q%(|~x#r-7=B~9^v0M<u?&;S4c

literal 0
HcmV?d00001

diff --git a/service/internal/db/migrations/032_crash_symbolizations.sql b/service/internal/db/migrations/032_crash_symbolizations.sql
new file mode 100644
index 00000000..6a22bad0
--- /dev/null
+++ b/service/internal/db/migrations/032_crash_symbolizations.sql
@@ -0,0 +1,47 @@
+-- majestic's own crashes beside the kernel's (internal/crashes): the dump
+-- majestic writes when it dies of a fatal signal (/etc/crash/majestic.dump),
+-- sent the way the kernel's records are. They are class 'user', kind
+-- 'signal', and only maintainers see them: a frame of majestic names a
+-- function and a line of its source, which the public lists never show.
+ALTER TABLE crash_signatures DROP CONSTRAINT crash_signatures_class_check;
+ALTER TABLE crash_signatures ADD CONSTRAINT crash_signatures_class_check
+    CHECK (class IN ('fatal', 'warning', 'user'));
+ALTER TABLE crash_signatures DROP CONSTRAINT crash_signatures_kind_check;
+ALTER TABLE crash_signatures ADD CONSTRAINT crash_signatures_kind_check
+    CHECK (kind IN ('bootloop', 'panic', 'oops', 'bug', 'warning', 'signal'));
+
+-- A dump as the camera wrote it, until it is symbolized. Its stack slice is
+-- majestic's memory at the crash and can hold what it was handling -- a
+-- request, the environment -- so it is never served, and it is deleted once
+-- the backtrace is made (or given up on). The bundle kept in crash_bundles
+-- for a majestic crash is the dump without its stack.
+CREATE TABLE crash_dumps (
+    event_id    text PRIMARY KEY REFERENCES crash_events ON DELETE CASCADE,
+    bytes       bytea NOT NULL CHECK (length(bytes) <= 262144),
+    received_at timestamptz NOT NULL DEFAULT now()
+);
+
+-- What the symbolizer (the firmware role) made of a dump: the backtrace from
+-- the debuginfo majestic's CI publishes for the build-id, and the callers a
+-- scan of the stack found past where it stopped. One row per event, updated
+-- by the symbolizer only: pending while it retries (debuginfo not published
+-- yet, a firmware build not fetched), then done or failed.
+--
+-- A symbolized crash is filed under the signature its backtrace makes;
+-- provisional is the one it was filed under when it arrived, made of the
+-- module and offset of the faulting instruction.
+CREATE TABLE crash_symbolizations (
+    event_id     text PRIMARY KEY REFERENCES crash_events ON DELETE CASCADE,
+    status       text NOT NULL CHECK (status IN ('pending', 'done', 'failed')),
+    attempts     int NOT NULL DEFAULT 0,
+    next_try     timestamptz,
+    provisional  text NOT NULL,
+    -- [{fn, module, file, line, offset, probable}], innermost first
+    frames       jsonb NOT NULL DEFAULT '[]',
+    -- what was used: the majestic build-id, the firmware build, the
+    -- libraries found
+    sources      jsonb NOT NULL DEFAULT '{}',
+    error        text NOT NULL DEFAULT '' CHECK (length(error) <= 2000),
+    at           timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX crash_symbolizations_pending ON crash_symbolizations (next_try) WHERE status = 'pending';

From a4365d5cd0e02e9bc75633c20ff73defce48657f Mon Sep 17 00:00:00 2001
From: AI Dev <ai@openipc.org>
Date: Fri, 9 Oct 2026 01:46:53 +0000
Subject: [PATCH 2/3] Crashes: address the review of majestic's symbolizer

- The public list and a signature's public page never count majestic's
  events, whatever they are merged into; a kernel signature and majestic's
  cannot be merged.
- A triage decided under a provisional signature goes with the crash to
  the bug it is refiled under when that one is undecided; a crash found
  bogus while it waited is not refiled.
- A backtrace with no frame of majestic's own leaves the crash under its
  provisional signature: strlen alone would make every caller one bug.
- Events leaving one provisional signature lock it, so the last one out
  deletes it.
- What gdb, unsquashfs or a library's symbols say is stripped of NULs and
  invalid UTF-8 before PostgreSQL sees it; a dump whose result cannot be
  stored counts as a failed try, and the drain stops until the next tick.
- A scan start off the stack returns nothing (a crafted SP panicked it),
  and a panic in the symbolizer is that dump's failure, not the role's.
- A firmware build that cannot be had right now is waited for; the last
  try makes the backtrace without its libraries.
- The rootfs image is rootfs.squashfs[.<soc>], never its .md5sum.
---
 service/internal/crashes/dump_test.go         | 125 ++++++++++++++++++
 service/internal/crashes/store.go             |  17 ++-
 service/internal/crashes/symbolize/scan.go    |   4 +
 service/internal/crashes/symbolize/sources.go |   5 +-
 .../internal/crashes/symbolize/symbolize.go   |  14 +-
 .../crashes/symbolize/symbolize_test.go       |  55 +++++++-
 service/internal/crashes/symbolize/worker.go  |  43 ++++--
 service/internal/crashes/symbolized.go        | 122 +++++++++++++----
 8 files changed, 337 insertions(+), 48 deletions(-)

diff --git a/service/internal/crashes/dump_test.go b/service/internal/crashes/dump_test.go
index 7e84ea5b..d31a1869 100644
--- a/service/internal/crashes/dump_test.go
+++ b/service/internal/crashes/dump_test.go
@@ -4,10 +4,13 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
@@ -380,3 +383,125 @@ func TestUserSignatureFrames(t *testing.T) {
 		t.Fatalf("%q", title)
 	}
 }
+
+func TestMajesticsCrashesNeverCountOnThePublicList(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	st := e.api.Store()
+	code, kernel := e.send(oops(1), map[string]string{"mac": "02:00:00:00:00:31"}, "10.0.1.1")
+	if code != 201 {
+		t.Fatalf("%d %v", code, kernel)
+	}
+	code, user := e.send(dumpFixture(t, "arm-own.dump"), map[string]string{"mac": "02:00:00:00:00:32", "soc": "gk7205v300"}, "10.0.1.2")
+	if code != 201 {
+		t.Fatalf("%d %v", code, user)
+	}
+	// A maintainer cannot make them one bug, either way.
+	for _, pair := range [][2]string{{user["signature"].(string), kernel["signature"].(string)}, {kernel["signature"].(string), user["signature"].(string)}} {
+		if _, err := st.Decide(ctx, pair[0], "m-maint00000", Triage{Status: "open", MergeInto: ptr(pair[1])}); !errors.Is(err, ErrInvalid) {
+			t.Fatalf("merging %s into %s: %v", pair[0], pair[1], err)
+		}
+	}
+	// And were they one row, the public list still counts the kernel's alone.
+	e.exec(`UPDATE crash_signatures SET merged_into = $2 WHERE id = $1`, user["signature"], kernel["signature"])
+	list := e.get("/api/v1/crashes")["signatures"].([]any)
+	if len(list) != 1 || list[0].(map[string]any)["cameras"].(float64) != 1 {
+		t.Fatalf("%v", list)
+	}
+	raw, _ := json.Marshal(e.get("/api/v1/crashes/" + kernel["signature"].(string)))
+	if bytes.Contains(raw, []byte("gk7205v300")) {
+		t.Fatalf("the public signature shows the majestic crash's chip: %s", raw)
+	}
+}
+
+func TestATriageGoesWithTheCrashToItsBacktrace(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	st := e.api.Store()
+	frames := []Frame{{Fn: "store"}, {Fn: "parse_level"}}
+
+	// Confirmed while it waited: the bug it is refiled under is confirmed.
+	_, out := e.send(dumpFixture(t, "arm-own.dump"), nil, "10.0.2.1")
+	if _, err := st.Decide(ctx, out["signature"].(string), "m-maint00000", Triage{Status: "confirmed", IssueURL: ptr("https://github.com/OpenIPC/majestic/issues/1")}); err != nil {
+		t.Fatal(err)
+	}
+	sig, err := st.Symbolized(ctx, out["id"].(string), frames, nil, e.now)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g, _ := st.Get(ctx, sig, true, e.now)
+	if sig == out["signature"] || g.Status != "confirmed" || g.IssueURL == "" {
+		t.Fatalf("%s: %+v", sig, g)
+	}
+
+	// Found bogus while it waited: it stays where the maintainer put it.
+	_, out = e.send(dumpFixture(t, "x86_64-own.dump"), nil, "10.0.2.2")
+	if _, err := st.Decide(ctx, out["signature"].(string), "m-maint00000", Triage{Status: "bogus"}); err != nil {
+		t.Fatal(err)
+	}
+	if sig, err := st.Symbolized(ctx, out["id"].(string), frames, nil, e.now); err != nil || sig != out["signature"] {
+		t.Fatalf("%v: refiled a bogus crash under %s", err, sig)
+	}
+}
+
+func TestABacktraceWithoutMajesticsFramesKeepsTheProvisionalSignature(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	_, out := e.send(dumpFixture(t, "arm-libc.dump"), nil, "10.0.3.1")
+	// strlen, and nothing of majestic's: every caller of strlen would be
+	// this one bug.
+	frames := []Frame{{Fn: "strlen", Module: "libc.so"}, {Fn: "?", Module: "libevent_core-2.2.so"}}
+	sig, err := e.api.Store().Symbolized(ctx, out["id"].(string), frames, nil, e.now)
+	if err != nil || sig != out["signature"] {
+		t.Fatalf("%v: filed under %s, want %s", err, sig, out["signature"])
+	}
+	var status string
+	e.pool.QueryRow(ctx, `SELECT status FROM crash_symbolizations`).Scan(&status)
+	if status != "done" {
+		t.Fatalf("status %s", status)
+	}
+}
+
+func TestWhatGDBSaysIsStoredWhateverBytesItHolds(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	st := e.api.Store()
+	_, out := e.send(dumpFixture(t, "arm-own.dump"), nil, "10.0.4.1")
+	if _, err := st.SymbolizeFailed(ctx, out["id"].(string), "unsquashfs: \x00bad \xff", e.now); err != nil {
+		t.Fatal(err)
+	}
+	frames := []Frame{{Fn: "sto\x00re", File: "toy\xff.c"}, {Fn: "parse_level"}}
+	if _, err := st.Symbolized(ctx, out["id"].(string), frames, map[string]any{"gdb_stopped": "x\x00y", "libraries": []string{"a\x00"}}, e.now); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestEventsLeavingOneProvisionalSignatureTogetherTidyIt(t *testing.T) {
+	e := newEnv(t)
+	ctx := context.Background()
+	st := e.api.Store()
+	raw := dumpFixture(t, "arm-own.dump")
+	var ids []string
+	var provisional string
+	for i, thrd := range []string{"1 a\n", "1 b\n", "1 c\n", "1 d\n"} {
+		_, out := e.send(rebuild(t, raw, "THRD", []byte(thrd)), nil, fmt.Sprintf("10.0.5.%d", i+1))
+		ids = append(ids, out["id"].(string))
+		provisional = out["signature"].(string)
+	}
+	var wg sync.WaitGroup
+	for _, id := range ids {
+		wg.Add(1)
+		go func(id string) {
+			defer wg.Done()
+			if _, err := st.Symbolized(ctx, id, []Frame{{Fn: "store"}, {Fn: "parse_level"}}, nil, e.now); err != nil {
+				t.Error(err)
+			}
+		}(id)
+	}
+	wg.Wait()
+	var n int
+	e.pool.QueryRow(ctx, `SELECT count(*) FROM crash_signatures WHERE id = $1`, provisional).Scan(&n)
+	if n != 0 {
+		t.Fatal("the provisional signature outlived its last event")
+	}
+}
diff --git a/service/internal/crashes/store.go b/service/internal/crashes/store.go
index 6cc7b2aa..59a565ee 100644
--- a/service/internal/crashes/store.go
+++ b/service/internal/crashes/store.go
@@ -235,7 +235,9 @@ func (s *Store) ranked(ctx context.Context, maintainers bool, only string, now t
 		WITH ev AS (
 			SELECT coalesce(sig.merged_into, sig.id) AS root, e.*
 			FROM crash_events e JOIN crash_signatures sig ON sig.id = e.signature_id
-			WHERE $1 OR NOT e.self_inflicted
+			-- majestic's crashes count only for maintainers, whatever they
+			-- are merged into
+			WHERE $1 OR (NOT e.self_inflicted AND e.kind <> 'signal')
 		)
 		SELECT r.id, r.class,
 		       coalesce((`+kindOrder+`)[max(array_position(`+kindOrder+`, ev.kind))], r.kind), r.title, r.frames, r.status, r.fixed_in, r.issue_url, r.first_seen,
@@ -357,8 +359,8 @@ func (s *Store) Combos(ctx context.Context, id string, detailed bool) ([]Combo,
 	rows, err := s.DB.Query(ctx, `
 		SELECT `+cols+`, count(*)::int, count(DISTINCT `+fmt.Sprintf(camera, "e.")+`)::int
 		FROM crash_events e JOIN crash_signatures sig ON sig.id = e.signature_id
-		WHERE coalesce(sig.merged_into, sig.id) = $1 AND NOT e.self_inflicted
-		GROUP BY 1, 2, 3, 4, 5, 6 ORDER BY 8 DESC, 7 DESC, 1, 2`, id)
+		WHERE coalesce(sig.merged_into, sig.id) = $1 AND NOT e.self_inflicted AND ($2 OR e.kind <> 'signal')
+		GROUP BY 1, 2, 3, 4, 5, 6 ORDER BY 8 DESC, 7 DESC, 1, 2`, id, detailed)
 	if err != nil {
 		return nil, err
 	}
@@ -571,7 +573,9 @@ func (s *Store) Decide(ctx context.Context, id, by string, t Triage) (taken int,
 			merged = nil
 			if *t.MergeInto != "" {
 				var target string
-				err := tx.QueryRow(ctx, `SELECT coalesce(merged_into, id) FROM crash_signatures WHERE id = $1`, *t.MergeInto).Scan(&target)
+				var sameClass bool
+				err := tx.QueryRow(ctx, `SELECT coalesce(t.merged_into, t.id), t.class = s.class FROM crash_signatures t, crash_signatures s
+					WHERE t.id = $1 AND s.id = $2`, *t.MergeInto, id).Scan(&target, &sameClass)
 				if errors.Is(err, pgx.ErrNoRows) {
 					return fmt.Errorf("merge_into: %w", ErrNoSignature)
 				}
@@ -581,6 +585,11 @@ func (s *Store) Decide(ctx context.Context, id, by string, t Triage) (taken int,
 				if target == id {
 					return fmt.Errorf("%w: %s is already merged into this one", ErrInvalid, *t.MergeInto)
 				}
+				// A kernel crash and majestic's are never one bug, and
+				// majestic's must not be counted on the public list.
+				if !sameClass {
+					return fmt.Errorf("%w: %s is a crash of another kind (kernel or majestic)", ErrInvalid, *t.MergeInto)
+				}
 				merged = &target
 				if _, err := tx.Exec(ctx, `UPDATE crash_signatures SET merged_into = $2, updated_at = now() WHERE merged_into = $1`, id, target); err != nil {
 					return err
diff --git a/service/internal/crashes/symbolize/scan.go b/service/internal/crashes/symbolize/scan.go
index 1c59da57..52b560d2 100644
--- a/service/internal/crashes/symbolize/scan.go
+++ b/service/internal/crashes/symbolize/scan.go
@@ -40,6 +40,10 @@ func Scan(d *crashes.Dump, from uint64, code Memory) []Candidate {
 	if from < d.StackAt {
 		from = d.StackAt
 	}
+	// An address gdb read off a crafted or broken stack can be anything.
+	if from-d.StackAt >= uint64(len(d.Stack)) {
+		return nil
+	}
 	size := 4
 	if d.Is64() {
 		size = 8
diff --git a/service/internal/crashes/symbolize/sources.go b/service/internal/crashes/symbolize/sources.go
index e42f1b3f..b618b66b 100644
--- a/service/internal/crashes/symbolize/sources.go
+++ b/service/internal/crashes/symbolize/sources.go
@@ -159,6 +159,9 @@ var ErrNoBuild = errors.New("the firmware build is not among the pushed builds")
 
 var safeName = regexp.MustCompile(`^[A-Za-z0-9._-]{1,128}$`)
 
+// rootfsName is the image, never its rootfs.squashfs.<soc>.md5sum beside it.
+var rootfsName = regexp.MustCompile(`^rootfs\.squashfs(\.[A-Za-z0-9_-]+)?$`)
+
 // Dir is the unpacked rootfs of the build (meta.json's firmware.build_id)
 // for the platform (its firmware.platform, as gk7205v300_lite).
 func (r *Rootfs) Dir(ctx context.Context, build, platform string) (string, error) {
@@ -257,7 +260,7 @@ func rootfsOf(tgz, dest string) error {
 		if err != nil {
 			return err
 		}
-		if h.Typeflag == tar.TypeReg && strings.HasPrefix(filepath.Base(h.Name), "rootfs.squashfs") {
+		if h.Typeflag == tar.TypeReg && rootfsName.MatchString(filepath.Base(h.Name)) {
 			return writeAtomic(dest, tr, 256<<20)
 		}
 	}
diff --git a/service/internal/crashes/symbolize/symbolize.go b/service/internal/crashes/symbolize/symbolize.go
index a60420c1..affba528 100644
--- a/service/internal/crashes/symbolize/symbolize.go
+++ b/service/internal/crashes/symbolize/symbolize.go
@@ -50,8 +50,11 @@ var outermost = map[string]bool{
 }
 
 // Symbolize unwinds a dump. ErrNotPublished means majestic's build is not
-// one CI published (yet); anything else may be worth trying again.
-func (s *Symbolizer) Symbolize(ctx context.Context, raw []byte, fw Firmware) (*Result, error) {
+// one CI published (yet); anything else may be worth trying again. A
+// firmware build that cannot be had right now is worth waiting for, unless
+// lastTry says this is the last try: then the backtrace is made without its
+// libraries rather than not at all.
+func (s *Symbolizer) Symbolize(ctx context.Context, raw []byte, fw Firmware, lastTry bool) (*Result, error) {
 	d, err := crashes.ReadDump(raw)
 	if err != nil {
 		return nil, err
@@ -70,9 +73,12 @@ func (s *Symbolizer) Symbolize(ctx context.Context, raw []byte, fw Firmware) (*R
 	libs := map[string]string{}
 	if s.Rootfs != nil && fw.Build != "" {
 		root, err := s.Rootfs.Dir(ctx, fw.Build, fw.Platform)
-		if err != nil {
+		switch {
+		case err != nil && !errors.Is(err, ErrNoBuild) && !lastTry:
+			return nil, fmt.Errorf("the firmware's libraries: %w", err)
+		case err != nil:
 			sources["libraries_error"] = err.Error()
-		} else {
+		default:
 			sources["firmware"] = fw.Build + "/" + fw.Platform
 			var found []string
 			for _, m := range d.Modules[1:] {
diff --git a/service/internal/crashes/symbolize/symbolize_test.go b/service/internal/crashes/symbolize/symbolize_test.go
index 9fd4471a..bc116bf3 100644
--- a/service/internal/crashes/symbolize/symbolize_test.go
+++ b/service/internal/crashes/symbolize/symbolize_test.go
@@ -123,7 +123,7 @@ func TestSymbolizeUnwindsTheFaultThroughMajesticsOwnFrames(t *testing.T) {
 		t.Run(arch, func(t *testing.T) {
 			raw := fixture(t, arch+"-own.dump")
 			s := &Symbolizer{Symbols: published(t, arch, raw)}
-			res, err := s.Symbolize(context.Background(), raw, Firmware{})
+			res, err := s.Symbolize(context.Background(), raw, Firmware{}, false)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -155,7 +155,7 @@ func TestSymbolizeNamesALibraryFrameFromTheFirmwaresOwnLibrary(t *testing.T) {
 		t.Run(arch, func(t *testing.T) {
 			raw := fixture(t, arch+"-lib.dump")
 			s := &Symbolizer{Symbols: published(t, arch, raw), Rootfs: withLibrary(t, arch)}
-			res, err := s.Symbolize(context.Background(), raw, Firmware{Build: "nightly-20261009-0000000", Platform: "toy_lite"})
+			res, err := s.Symbolize(context.Background(), raw, Firmware{Build: "nightly-20261009-0000000", Platform: "toy_lite"}, false)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -177,7 +177,7 @@ func TestSymbolizeWithoutTheLibraryNamesItsModule(t *testing.T) {
 	needGDB(t)
 	raw := fixture(t, "arm-libc.dump")
 	s := &Symbolizer{Symbols: published(t, "arm", raw)}
-	res, err := s.Symbolize(context.Background(), raw, Firmware{})
+	res, err := s.Symbolize(context.Background(), raw, Firmware{}, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -192,7 +192,7 @@ func TestSymbolizeWithoutTheLibraryNamesItsModule(t *testing.T) {
 func TestSymbolizeWithoutPublishedSymbolsWaits(t *testing.T) {
 	raw := fixture(t, "arm-own.dump")
 	s := &Symbolizer{Symbols: &Symbols{Root: t.TempDir(), Base: "http://127.0.0.1:1"}}
-	if _, err := s.Symbolize(context.Background(), raw, Firmware{}); err == nil {
+	if _, err := s.Symbolize(context.Background(), raw, Firmware{}, false); err == nil {
 		t.Fatal("symbolized without the executable")
 	}
 }
@@ -362,3 +362,50 @@ func TestSourcePathDropsTheBuildMachinesDirectories(t *testing.T) {
 		}
 	}
 }
+
+func TestScanIgnoresAStartOffTheStack(t *testing.T) {
+	d, err := crashes.ReadDump(fixture(t, "x86_64-own.dump"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, from := range []uint64{d.StackAt + uint64(len(d.Stack)), d.StackAt + 1<<63 + 8, ^uint64(0)} {
+		if got := Scan(d, from, nil); got != nil {
+			t.Fatalf("from %#x: %v", from, got)
+		}
+	}
+}
+
+// failing is a firmware build that cannot be had right now.
+type failing struct{}
+
+func (failing) Dir(context.Context, string, string) (string, error) {
+	return "", fmt.Errorf("release asset unavailable: github.com answered 502")
+}
+
+func TestAFirmwareBuildThatCannotBeHadIsWaitedFor(t *testing.T) {
+	needGDB(t)
+	raw := fixture(t, "arm-lib.dump")
+	s := &Symbolizer{Symbols: published(t, "arm", raw), Rootfs: failing{}}
+	fw := Firmware{Build: "nightly-20261009-0000000", Platform: "toy_lite"}
+	if _, err := s.Symbolize(context.Background(), raw, fw, false); err == nil {
+		t.Fatal("symbolized without the libraries it could have later")
+	}
+	// The last try keeps what it can make.
+	res, err := s.Symbolize(context.Background(), raw, fw, true)
+	if err != nil || res.Sources["libraries_error"] == nil {
+		t.Fatalf("%v %v", err, res)
+	}
+}
+
+func TestRootfsNameIsTheImage(t *testing.T) {
+	for name, want := range map[string]bool{
+		"rootfs.squashfs":                   true,
+		"rootfs.squashfs.gk7205v300":        true,
+		"rootfs.squashfs.gk7205v300.md5sum": false,
+		"rootfs.ubi.gk7205v300":             false,
+	} {
+		if rootfsName.MatchString(name) != want {
+			t.Errorf("%s: %v", name, !want)
+		}
+	}
+}
diff --git a/service/internal/crashes/symbolize/worker.go b/service/internal/crashes/symbolize/worker.go
index ea87e23e..f725f601 100644
--- a/service/internal/crashes/symbolize/worker.go
+++ b/service/internal/crashes/symbolize/worker.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"log/slog"
 	"time"
 
@@ -114,36 +115,54 @@ func (w *Worker) Drain(ctx context.Context) {
 			return
 		}
 		for _, d := range due {
-			w.one(ctx, st, d)
+			// What cannot be stored is left for the next tick, not tried
+			// again at once: the same dump would only fail the same way.
+			if !w.one(ctx, st, d) {
+				return
+			}
 		}
 	}
 }
 
-func (w *Worker) one(ctx context.Context, st *crashes.Store, d crashes.Due) {
-	fw := firmwareOf(d.Meta)
-	res, err := w.Symbolizer.Symbolize(ctx, d.Dump, fw)
+// symbolize runs the symbolizer, a panic in it -- the dumps come from
+// anyone -- being one more failure of that dump's.
+func (w *Worker) symbolize(ctx context.Context, d crashes.Due) (res *Result, err error) {
+	defer func() {
+		if p := recover(); p != nil {
+			res, err = nil, fmt.Errorf("symbolizer panicked: %v", p)
+		}
+	}()
+	return w.Symbolizer.Symbolize(ctx, d.Dump, firmwareOf(d.Meta), crashes.LastTry(d.Attempts))
+}
+
+// one symbolizes a dump, and says whether what came of it was stored.
+func (w *Worker) one(ctx context.Context, st *crashes.Store, d crashes.Due) bool {
+	res, err := w.symbolize(ctx, d)
 	if err == nil {
-		sig, err := st.Symbolized(ctx, d.EventID, res.Frames, res.Sources, w.now())
-		if err != nil {
-			w.Log.Error("crashes: symbolized, not stored", "id", d.EventID, "err", err)
-			return
+		sig, serr := st.Symbolized(ctx, d.EventID, res.Frames, res.Sources, w.now())
+		if serr == nil {
+			w.Log.Info("crashes: symbolized", "id", d.EventID, "signature", sig, "frames", len(res.Frames))
+			return true
 		}
-		w.Log.Info("crashes: symbolized", "id", d.EventID, "signature", sig, "frames", len(res.Frames))
-		return
+		w.Log.Error("crashes: symbolized, not stored", "id", d.EventID, "err", serr)
+		// Counted as a failed try, so a backtrace that cannot be stored is
+		// given up on like any other.
+		err = serr
 	}
 	if ctx.Err() != nil {
-		return
+		return false
 	}
 	gaveUp, ferr := st.SymbolizeFailed(ctx, d.EventID, err.Error(), w.now())
 	if ferr != nil {
 		w.Log.Error("crashes: symbolize failure not stored", "id", d.EventID, "err", ferr)
-		return
+		return false
 	}
 	level := slog.LevelWarn
 	if errors.Is(err, ErrNotPublished) {
 		level = slog.LevelInfo
 	}
 	w.Log.Log(ctx, level, "crashes: not symbolized", "id", d.EventID, "attempt", d.Attempts+1, "gave_up", gaveUp, "err", err)
+	return true
 }
 
 // firmwareOf is the build meta.json names.
diff --git a/service/internal/crashes/symbolized.go b/service/internal/crashes/symbolized.go
index a266e339..0f5e9f1f 100644
--- a/service/internal/crashes/symbolized.go
+++ b/service/internal/crashes/symbolized.go
@@ -89,18 +89,62 @@ func userSigFrames(frames []Frame) []Frame {
 	return out
 }
 
+// ownFrame says whether a signature's frames hold one of majestic's own:
+// without one -- a crash in a library function that every caller reaches,
+// or in nothing anyone could name -- the backtrace would file unrelated
+// crashes as one bug, and the module and offset it arrived under say more.
+func ownFrame(frames []Frame) bool {
+	for _, f := range frames {
+		if f.Module == "" {
+			return true
+		}
+	}
+	return false
+}
+
 // maxFrames is how many frames of a backtrace are kept.
 const maxFrames = 48
 
-// Symbolized files the event under the signature its backtrace makes, keeps
-// the backtrace and deletes the dump. The provisional signature it leaves is
-// deleted when nothing else is filed under it, or merged into the new one
-// when a triage or stars were booked under it meanwhile.
+// storable makes what came from gdb, a library's symbols or an error storable:
+// PostgreSQL takes neither a NUL nor invalid UTF-8, in text or in jsonb.
+func storable(s string) string {
+	return strings.ReplaceAll(strings.ToValidUTF8(s, "?"), "\x00", "")
+}
+
+func cleanAny(v any) any {
+	switch x := v.(type) {
+	case string:
+		return storable(x)
+	case []string:
+		out := make([]string, len(x))
+		for i, s := range x {
+			out[i] = storable(s)
+		}
+		return out
+	case map[string]any:
+		out := make(map[string]any, len(x))
+		for k, e := range x {
+			out[storable(k)] = cleanAny(e)
+		}
+		return out
+	}
+	return v
+}
+
+// Symbolized keeps the backtrace, deletes the dump, and files the event
+// under the signature its backtrace makes -- unless that would say less than
+// the provisional one (no frame of majestic's own), or a maintainer has found
+// the crash bogus already. The provisional signature it leaves is deleted
+// when nothing else is filed under it, or merged into the new one, with its
+// triage, when a decision or stars were booked under it meanwhile.
 func (s *Store) Symbolized(ctx context.Context, eventID string, frames []Frame, sources map[string]any, now time.Time) (string, error) {
 	if len(frames) > maxFrames {
 		frames = frames[:maxFrames]
 	}
-	src, _ := json.Marshal(sources)
+	for i := range frames {
+		frames[i].Fn, frames[i].Module, frames[i].File = storable(frames[i].Fn), storable(frames[i].Module), storable(frames[i].File)
+	}
+	src, _ := json.Marshal(cleanAny(map[string]any(sources)))
 	all, _ := json.Marshal(orEmpty(frames))
 	var sig string
 	err := pgx.BeginFunc(ctx, s.DB, func(tx pgx.Tx) error {
@@ -119,26 +163,37 @@ func (s *Store) Symbolized(ctx context.Context, eventID string, frames []Frame,
 		if err != nil {
 			return err
 		}
+		// Events leaving one provisional signature, one at a time: the last
+		// to leave is the one that tidies it.
+		var status string
+		if err := tx.QueryRow(ctx, `SELECT root.status FROM crash_signatures p
+			JOIN crash_signatures root ON root.id = coalesce(p.merged_into, p.id)
+			WHERE p.id = $1 FOR UPDATE OF p`, provisional).Scan(&status); err != nil {
+			return err
+		}
 		var t Trace
 		if err := json.Unmarshal(fatal, &t); err != nil {
 			return err
 		}
 		t.Frames, t.Provisional, t.Build = frames, false, ""
-		sig = t.Signature()
-		title := t.Title()
-		trace, _ := json.Marshal(&t)
-		if _, err := tx.Exec(ctx, `
-			INSERT INTO crash_signatures (id, class, kind, title, frames, first_seen)
-			SELECT $1, 'user', $2, $3, $4, received_at FROM crash_events WHERE id = $5
-			ON CONFLICT (id) DO UPDATE SET first_seen = least(crash_signatures.first_seen, EXCLUDED.first_seen)`,
-			sig, KindSignal, title, all, eventID); err != nil {
-			return err
-		}
-		if _, err := tx.Exec(ctx, `UPDATE crash_events SET signature_id = $2, title = $3, fatal = $4 WHERE id = $1`,
-			eventID, sig, title, trace); err != nil {
-			return err
+		sig = provisional
+		if status != "bogus" && ownFrame(userSigFrames(frames)) {
+			sig = t.Signature()
 		}
-		if provisional != sig {
+		if sig != provisional {
+			title := t.Title()
+			trace, _ := json.Marshal(&t)
+			if _, err := tx.Exec(ctx, `
+				INSERT INTO crash_signatures (id, class, kind, title, frames, first_seen)
+				SELECT $1, 'user', $2, $3, $4, received_at FROM crash_events WHERE id = $5
+				ON CONFLICT (id) DO UPDATE SET first_seen = least(crash_signatures.first_seen, EXCLUDED.first_seen)`,
+				sig, KindSignal, title, all, eventID); err != nil {
+				return err
+			}
+			if _, err := tx.Exec(ctx, `UPDATE crash_events SET signature_id = $2, title = $3, fatal = $4 WHERE id = $1`,
+				eventID, sig, title, trace); err != nil {
+				return err
+			}
 			if err := leave(ctx, tx, provisional, sig); err != nil {
 				return err
 			}
@@ -172,14 +227,31 @@ func leave(ctx context.Context, tx pgx.Tx, provisional, sig string) error {
 		_, err := tx.Exec(ctx, `DELETE FROM crash_signatures WHERE id = $1`, provisional)
 		return err
 	}
-	// Stars paid under it stay held under the bug they were for.
-	var root string
-	if err := tx.QueryRow(ctx, `SELECT coalesce(merged_into, id) FROM crash_signatures WHERE id = $1`, sig).Scan(&root); err != nil {
+	// Stars paid under it stay held under the bug they were for, and what a
+	// maintainer decided about it goes with it to a bug nobody has decided
+	// about yet.
+	var root, rootStatus string
+	if err := tx.QueryRow(ctx, `SELECT r.id, r.status FROM crash_signatures s JOIN crash_signatures r ON r.id = coalesce(s.merged_into, s.id)
+		WHERE s.id = $1 FOR UPDATE OF r`, sig).Scan(&root, &rootStatus); err != nil {
 		return err
 	}
 	if root == provisional {
 		return nil
 	}
+	if rootStatus == "open" {
+		tag, err := tx.Exec(ctx, `UPDATE crash_signatures r SET status = p.status, fixed_in = p.fixed_in, issue_url = p.issue_url,
+				note = p.note, updated_at = now()
+			FROM crash_signatures p WHERE r.id = $2 AND p.id = $1 AND p.status <> 'open'`, provisional, root)
+		if err != nil {
+			return err
+		}
+		if tag.RowsAffected() > 0 {
+			if _, err := tx.Exec(ctx, `INSERT INTO crash_triage (signature_id, by_member, status, fixed_in, issue_url, merged_into, note)
+				SELECT id, 'symbolizer', status, fixed_in, issue_url, NULL, note FROM crash_signatures WHERE id = $1`, root); err != nil {
+				return err
+			}
+		}
+	}
 	if _, err := tx.Exec(ctx, `UPDATE crash_signatures SET merged_into = $2, updated_at = now() WHERE merged_into = $1`,
 		provisional, root); err != nil {
 		return err
@@ -188,6 +260,10 @@ func leave(ctx context.Context, tx pgx.Tx, provisional, sig string) error {
 	return err
 }
 
+// LastTry says whether a dump that has been tried attempts times is on its
+// last try: what can be made of it then is kept, whatever is missing.
+func LastTry(attempts int) bool { return attempts >= len(retryAfter) }
+
 // Tries: how often a dump is tried, and how long after each failure.
 var retryAfter = []time.Duration{
 	5 * time.Minute, 30 * time.Minute, 2 * time.Hour, 6 * time.Hour, 24 * time.Hour, 24 * time.Hour, 48 * time.Hour,
@@ -200,7 +276,7 @@ func (s *Store) SymbolizeFailed(ctx context.Context, eventID, reason string, now
 	if len(reason) > 2000 {
 		reason = reason[:2000]
 	}
-	reason = strings.ToValidUTF8(reason, "?")
+	reason = storable(reason)
 	err = pgx.BeginFunc(ctx, s.DB, func(tx pgx.Tx) error {
 		var attempts int
 		err := tx.QueryRow(ctx, `SELECT attempts FROM crash_symbolizations WHERE event_id = $1 AND status = 'pending' FOR UPDATE`,

From 60d94a9861b1d54f402c224f2fb371402fc7a2e5 Mon Sep 17 00:00:00 2001
From: AI Dev <ai@openipc.org>
Date: Fri, 9 Oct 2026 04:14:57 +0000
Subject: [PATCH 3/3] Crashes: a firmware version is not an IP address

The redactor took OpenIPC's own version, 2.6.10.05, for a dotted quad and
replaced it in meta.json with a keyed hash, so a maintainer could not read
which firmware a camera ran. An octet is never written with a leading
zero; now the pattern refuses one. The triage page also says it holds
majestic's crashes beside the kernel's.
---
 data/locales/boards.en.yml             | 2 +-
 data/locales/boards.ru.yml             | 2 +-
 frontend/apps/site/src/i18n/en.json    | 2 +-
 frontend/apps/site/src/i18n/ru.json    | 2 +-
 service/internal/crashes/api.go        | 5 +++--
 service/internal/crashes/store_test.go | 5 +++--
 6 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/data/locales/boards.en.yml b/data/locales/boards.en.yml
index 794ae2b6..5ec6c8f5 100644
--- a/data/locales/boards.en.yml
+++ b/data/locales/boards.en.yml
@@ -49,7 +49,7 @@ en:
     club_crashes:
       eyebrow: 'OpenIPC Club'
       title: 'Crash triage'
-      lede: 'Kernel crashes cameras sent, worst first, with what it takes to reproduce each one.'
+      lede: 'Crashes cameras sent, the kernel''s and majestic''s, worst first, with what it takes to reproduce each one.'
     crashes:
       eyebrow: 'OpenIPC firmware'
       title: 'Kernel crashes from the field'
diff --git a/data/locales/boards.ru.yml b/data/locales/boards.ru.yml
index 5da4d7c0..c1b4fc0a 100644
--- a/data/locales/boards.ru.yml
+++ b/data/locales/boards.ru.yml
@@ -49,7 +49,7 @@ ru:
     club_crashes:
       eyebrow: 'Клуб OpenIPC'
       title: 'Разбор падений'
-      lede: 'Падения ядра, присланные камерами, — сначала самые тяжёлые, с тем, что нужно, чтобы воспроизвести каждое.'
+      lede: 'Падения ядра и majestic, присланные камерами, — сначала самые тяжёлые, с тем, что нужно, чтобы воспроизвести каждое.'
     crashes:
       eyebrow: 'Прошивка OpenIPC'
       title: 'Падения ядра с реальных камер'
diff --git a/frontend/apps/site/src/i18n/en.json b/frontend/apps/site/src/i18n/en.json
index e7e4c5bb..536e80d8 100644
--- a/frontend/apps/site/src/i18n/en.json
+++ b/frontend/apps/site/src/i18n/en.json
@@ -164,7 +164,7 @@
     },
     "club_crashes": {
       "eyebrow": "OpenIPC Club",
-      "lede": "Kernel crashes cameras sent, worst first, with what it takes to reproduce each one.",
+      "lede": "Crashes cameras sent, the kernel's and majestic's, worst first, with what it takes to reproduce each one.",
       "title": "Crash triage"
     },
     "club_leaderboard": {
diff --git a/frontend/apps/site/src/i18n/ru.json b/frontend/apps/site/src/i18n/ru.json
index dd14b61c..ac75d0f8 100644
--- a/frontend/apps/site/src/i18n/ru.json
+++ b/frontend/apps/site/src/i18n/ru.json
@@ -164,7 +164,7 @@
     },
     "club_crashes": {
       "eyebrow": "Клуб OpenIPC",
-      "lede": "Падения ядра, присланные камерами, — сначала самые тяжёлые, с тем, что нужно, чтобы воспроизвести каждое.",
+      "lede": "Падения ядра и majestic, присланные камерами, — сначала самые тяжёлые, с тем, что нужно, чтобы воспроизвести каждое.",
       "title": "Разбор падений"
     },
     "club_leaderboard": {
diff --git a/service/internal/crashes/api.go b/service/internal/crashes/api.go
index 60fcad96..86a2081a 100644
--- a/service/internal/crashes/api.go
+++ b/service/internal/crashes/api.go
@@ -363,8 +363,9 @@ func isHex(c byte) bool {
 
 var (
 	// ipv4 is a dotted quad; replace refuses one inside a longer dotted
-	// number (a version, 4.9.37.1.2).
-	ipv4 = regexp.MustCompile(`(?:25[0-5]|2[0-4]\d|1?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3}`)
+	// number (a version, 4.9.37.1.2). An octet is never written with a
+	// leading zero, and a version often is: OpenIPC's own are 2.6.10.05.
+	ipv4 = regexp.MustCompile(`(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}`)
 	// ipv6: eight groups, or fewer with "::". Never a time (17:57:19) or a
 	// register dump (9dc0:), which have neither.
 	ipv6 = regexp.MustCompile(`(?i)(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|(?:[0-9a-f]{1,4}:){1,7}:(?:[0-9a-f]{1,4}(?::[0-9a-f]{1,4}){0,6})?|::(?:[0-9a-f]{1,4}(?::[0-9a-f]{1,4}){0,6})?`)
diff --git a/service/internal/crashes/store_test.go b/service/internal/crashes/store_test.go
index 81aebbf8..04b06842 100644
--- a/service/internal/crashes/store_test.go
+++ b/service/internal/crashes/store_test.go
@@ -358,14 +358,15 @@ func TestRankingAndMerge(t *testing.T) {
 // separator apart are both found.
 func TestRedact(t *testing.T) {
 	in := "ip=10.0.0.2:10.0.0.1:10.0.0.254:255.255.255.0 then 1.2.3.4 5.6.7.8, v6 fe80::1ff:fe23:4567:890a and 2001:db8:0:0:0:0:2:1, " +
-		"cisco 0012.3456.789a, colon aa:bb:cc:dd:ee:ff, kept: Linux version 4.9.37.1.2, 17:57:19, 9dc0: bf12bef8, ::1, 127.0.0.1"
+		"cisco 0012.3456.789a, colon aa:bb:cc:dd:ee:ff, kept: Linux version 4.9.37.1.2, 17:57:19, 9dc0: bf12bef8, ::1, 127.0.0.1, " +
+		"\"version\": \"2.6.10.05\""
 	out := Redact(in, "", "k")
 	for _, leak := range []string{"10.0.0.2", "10.0.0.1", "10.0.0.254", "1.2.3.4", "5.6.7.8", "fe80::", "2001:db8", "0012.3456", "aa:bb:cc"} {
 		if strings.Contains(out, leak) {
 			t.Errorf("%q survived: %s", leak, out)
 		}
 	}
-	for _, kept := range []string{"255.255.255.0", "4.9.37.1.2", "17:57:19", "9dc0: bf12bef8", "::1", "127.0.0.1"} {
+	for _, kept := range []string{"255.255.255.0", "4.9.37.1.2", "17:57:19", "9dc0: bf12bef8", "::1", "127.0.0.1", "2.6.10.05"} {
 		if !strings.Contains(out, kept) {
 			t.Errorf("%q was redacted: %s", kept, out)
 		}