mirror of
https://github.com/qelectrotech/qelectrotech-source-mirror.git
synced 2026-08-13 10:04:13 +02:00
ispyisail
5dec36cb29
Stacked on the steps 1-3 branch (feature-diagnostic-logging, PR #646). Kept as its own PR rather than folded into that one, matching the discussion's own framing: step 4 is explicitly "the highest-risk piece ... lands last, behind its own switch." ## Step 4 -- crash-time ring flush (CrashHandler) Installs a handler for SIGSEGV/SIGABRT/SIGBUS/SIGFPE/SIGILL (POSIX) / SetUnhandledExceptionFilter (Windows) that flushes the in-memory ring to a fixed crash_dump.log before the process dies. This required reworking LogRing (step 3) to be genuinely lock-free, not just mutex-protected: a signal handler that blocks on a lock the crashing thread (or another thread) already holds turns a clean crash into a hang -- no ring dump *and* no core dump, worse than doing nothing. append() now claims a slot with a single atomic fetch-add; dumpToFd() reads the preallocated entries directly and writes them with write(2) only, looping on EINTR/short writes. Accepted tradeoff: at most one entry can be read torn if a crash lands mid-append into that exact slot -- documented in logring.h, and the alternative (a seqlock to detect and retry) wasn't judged worth the complexity for that window. Other invariants implemented per the discussion: - sigaltstack with a static 64 KiB buffer, SA_ONSTACK -- a stack- overflow SIGSEGV has no usable stack for a handler without one. - Nothing under the actual handler touches Qt, QString or the allocator: the dump path and a small header (version/git/OS/Qt) are precomputed into fixed char buffers by install(), which runs once at startup in normal context. - Atomic test-and-set so only the first crash writes a dump; a second concurrent/nested fault goes straight to restore-and-re-raise. - After writing, the handler restores SIG_DFL and re-raises (POSIX) / returns EXCEPTION_CONTINUE_SEARCH (Windows) so the OS's own crash path -- core dump, Windows Error Reporting -- still runs. A handler that "fixed" the crash by swallowing the signal would destroy exactly the post-mortem evidence this whole design exists to preserve. Tested in this environment: POSIX/Linux only, all five signals. Sent each directly to a running process and confirmed (a) crash_dump.log is written with the correct header and ring contents, mode 0600, and (b) the process still terminates via the signal with the kernel's own "core dumped" flag set (exit code 128+signal, confirmed for all five). The Windows path is implemented per the discussion's guidance but is untested -- no Windows build available in this sandbox. ## Step 5 -- getting the data back out - QETApp::checkCrashDump(), called from checkBackupFiles() only when there's no stale project file to recover this run (so the two prompts never both show, per the discussion), offers an unretrieved crash dump via DiagnosticsReportDialog and then deletes it regardless of the user's choice -- offered exactly once. - A new "Aide > Enregistrer un rapport de diagnostic..." action (QETMainWindow) builds the same kind of report from the *current* session (QetLogger::buildDiagnosticsReport(): header + this session's log file) for a manual "attach this to a bug report" flow, not tied to a crash. - Both go through QetLogger::redact() before ever reaching the user: the one redaction implemented is a literal replace of the home directory with "~", since an absolute path under it leaks the account name. The discussion's fancier "optionally redact project filenames too" isn't attempted -- reliably telling a project path apart from arbitrary log text is a much fuzzier problem than a literal prefix match. - DiagnosticsReportDialog shows the full (already-redacted) content before saving, per the discussion: "the user is about to attach this to a public tracker." Verified in a real GUI session (Xvfb): triggered a SIGSEGV, relaunched, confirmed the crash-report dialog appears with the right header/content, confirmed it does not reappear on a second relaunch, and confirmed the manual "Save report" action produces a correctly-formatted report and saves it to a chosen path. Built clean, no new warnings. ## Build systems Registered in both: cmake/qet_compilation_vars.cmake, and qelectrotech.pro. The .pro needed explicit globs for the new sources/logging/ui/ subfolder -- sources/logging/*.{h,cpp} was already globbed, but unlike the other ui/ subfolders that one had no entry of its own, so diagnosticsreportdialog.{h,cpp} would not have been built under qmake.
86 lines
3.7 KiB
C++
86 lines
3.7 KiB
C++
/*
|
|
Copyright 2006-2026 The QElectroTech Team
|
|
This file is part of QElectroTech.
|
|
|
|
QElectroTech is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
QElectroTech is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#ifndef CRASHHANDLER_H
|
|
#define CRASHHANDLER_H
|
|
|
|
#include <QString>
|
|
|
|
class LogRing;
|
|
|
|
/**
|
|
@brief The CrashHandler class
|
|
Discussion #644, step 4: on a fatal crash, flush the in-memory
|
|
LogRing to a fixed file before the process dies, so the last N log
|
|
lines leading up to the crash survive it -- today they only exist in
|
|
memory and are lost with the process.
|
|
|
|
This is the highest-risk piece of the whole logging rework (the
|
|
discussion's own words: "lands last, behind its own switch"), so its
|
|
invariants are worth restating plainly:
|
|
|
|
1. The handler must never block. It takes no locks -- LogRing itself
|
|
is lock-free for exactly this reason (see logring.h). A handler
|
|
that can hang is worse than no handler: it turns a clean crash
|
|
(which at least produces a core dump) into a hung process that has
|
|
to be force-killed, producing neither a core dump nor a ring dump.
|
|
2. The handler must never allocate. Under heap corruption -- a
|
|
plausible *cause* of the very crash being handled -- malloc may
|
|
itself deadlock or fault. Every buffer this code touches at crash
|
|
time (the dump path, the header, the ring's own storage) is
|
|
preallocated by install(), which runs once at startup in normal
|
|
(non-signal) context.
|
|
3. The handler must not swallow the crash. After writing the dump it
|
|
restores the default disposition for the signal and re-raises, so
|
|
the OS still produces a core dump (POSIX) / Windows Error
|
|
Reporting still sees the exception. A handler that "fixed" the
|
|
crash by not re-raising would destroy the post-mortem evidence a
|
|
core dump provides.
|
|
4. Only the *first* crash writes a dump. An atomic test-and-set
|
|
guards against two threads faulting simultaneously (or the handler
|
|
itself faulting while dumping) producing an interleaved or
|
|
truncated file; every crash after the first goes straight to
|
|
restore-and-re-raise.
|
|
|
|
Tested in this environment: POSIX/Linux only (sigaction, sigaltstack,
|
|
SIGSEGV/SIGABRT/SIGBUS/SIGFPE/SIGILL). The Windows path
|
|
(SetUnhandledExceptionFilter) and macOS-specific behaviour (signal
|
|
handling itself is POSIX and shares the Linux code path, but sandbox
|
|
profiles can affect where the dump file may be written) are
|
|
implemented per the discussion's guidance but could not be exercised
|
|
here -- there is no Windows or macOS build available in this sandbox.
|
|
Please sanity-check both before relying on them in the field.
|
|
*/
|
|
class CrashHandler
|
|
{
|
|
public:
|
|
/// Installs the crash handler. Must be called from normal
|
|
/// (non-signal) startup code, after the LogRing it will dump
|
|
/// exists, and only once. `ring` must outlive the process (in
|
|
/// practice: the LogRing owned by QetLogger's function-local
|
|
/// static instance, which is never destroyed before exit).
|
|
/// `dump_path` is resolved and copied into a fixed-size internal
|
|
/// buffer here; nothing under the actual signal/exception path
|
|
/// touches QString.
|
|
static void install(const LogRing *ring, const QString &dump_path);
|
|
|
|
private:
|
|
CrashHandler() = delete;
|
|
};
|
|
|
|
#endif // CRASHHANDLER_H
|