mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-20 16:31:57 +09:00
Step three of CONTRACT-P6 5.2, the funnel's whole point: instead of the peer
reading a bare EOF and guessing, the session publishes a SessionFault frame
that names the family before it aborts.
THE WIRE CHANGE IS D2's, exactly: `table Fatal` appends `family: string`,
append-only, so an older peer still reads `code` and `message`. `code` stays
the coarse seven-value projection; `family` carries the full word.
SessionFail publishes it before the abort, on whichever session's control
plane is active - the client has a ClientSession, the server a ServerSession,
so under spawn the frame reaches the far side whichever role is dying. Under
inproc both exist and it goes to an in-process transport the aborting process
will never read, which is harmless and cheaper than a special case that would
then be the untested one. Best-effort by nature: this thread is about to die,
so a send that blocks or fails changes nothing.
seq/op from the prose are NOT threaded through the 90 sites: the message
already names the op where it matters, so the frame carries what it can name
honestly (code, family, message) rather than a field that is always zero.
The client recognizes it: RunRemoteSurfaceControlFrame's reply loop, which
already demuxes CapsSnapshot from SurfaceReply, gains a Fatal arm that logs the
family and detail, latches device-lost from it, and returns transport-closed.
A server that DETECTS a fatal condition and aborts itself now tells the client
why; a kill -9 still bypasses abort entirely and is caught by dl's hangup
witness instead - the two cover the two ways a server can die.
The census learns SessionFail: a SessionFail call, like a WireLogFatal call,
must carry a Fatal{ word in its string, so the enum and the string cannot
disagree. FatalFunnel.{h,cpp} join the funnel exemption. Baseline is 4 aborts.
FatalFamilyTest gains the wire round-trip: every family's frame carries its
word and its projected code across encode/verify/decode.
G1 re-measured after the schema change: 0 symbol diff, .text unchanged at
0xa52203. Unit 2359 (one pre-existing environmental failure), integration-split
186/186, integration-spawn 102/102, retrace 6/6, census 0 unmarked.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
97 lines
4.4 KiB
C++
97 lines
4.4 KiB
C++
// MobileGL - MobileGL/MG_Remote/FatalFunnel.cpp
|
|
// Copyright (c) 2025-2026 MobileGL-Dev
|
|
// Licensed under the GNU Lesser General Public License v3.0:
|
|
// https://www.gnu.org/licenses/gpl-3.0.txt
|
|
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// End of Source File Header
|
|
|
|
#include <MG_Remote/FatalFunnel.h>
|
|
|
|
#include "../Includes.h" // MGLOG_F and the umbrella; a .cpp may pull it, a Transport/ header may not
|
|
#include "Client/ClientSession.h"
|
|
#include "Protocol/generated/protocol_generated.h"
|
|
#include "Server/ServerSession.h"
|
|
#include "Transport/ITransport.h"
|
|
|
|
#include <atomic>
|
|
#include <cstdarg>
|
|
#include <cstdio>
|
|
|
|
#include <flatbuffers/flatbuffers.h>
|
|
|
|
namespace MobileGL::MG_Remote {
|
|
|
|
namespace {
|
|
// One telemetry point (5.2). Bumped exactly once per death, before the abort, so a test
|
|
// that forks a child and reads it back sees the increment even though the child is gone -
|
|
// it reads its OWN process's counter for the funnel it drove, not the child's.
|
|
std::atomic<std::uint64_t> g_sessionFaultCount{0};
|
|
} // namespace
|
|
|
|
std::uint64_t SessionFaultCount() {
|
|
return g_sessionFaultCount.load(std::memory_order_relaxed);
|
|
}
|
|
|
|
void SessionFail(MGFatalFamily family, const char* fmt, ...) {
|
|
// The line, formatted exactly as the site's old MGLOG_F would have. Same buffer size and
|
|
// same fallback as WireLogFatal, so a death that used either path reads identically.
|
|
char line[512];
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
const int written = std::vsnprintf(line, sizeof(line), fmt, args);
|
|
va_end(args);
|
|
if (written < 0) {
|
|
std::snprintf(line, sizeof(line),
|
|
"MG_Remote: unformattable Fatal diagnostic (format=%s)", fmt);
|
|
}
|
|
|
|
g_sessionFaultCount.fetch_add(1, std::memory_order_relaxed);
|
|
|
|
MGLOG_F("%s", line);
|
|
// The stderr echo is the half a death test can see: Defines.h builds the logger with the
|
|
// console sink off, so an MGLOG line reaches only the file - and a gtest death matcher
|
|
// reads the child's stderr. Flushed because abort() does not flush stdio.
|
|
std::fputs(line, stderr);
|
|
std::fputc('\n', stderr);
|
|
std::fflush(stderr);
|
|
|
|
// A SessionFault frame to the peer, BEFORE the abort, so the other side's log names the
|
|
// family instead of reading a bare EOF (5.2). Best-effort by nature: this thread is about
|
|
// to die, so a send that blocks or fails changes nothing it could have changed anyway.
|
|
//
|
|
// WHICHEVER ROLE THIS PROCESS IS. Under spawn only one session is active per process -
|
|
// the client has ClientSession, the server has ServerSession - so publishing on whatever
|
|
// control plane exists reaches the far side. Under inproc both exist and the frame goes
|
|
// to an in-process transport the aborting process will never read; harmless, and not
|
|
// worth a special case that would then be the untested one.
|
|
//
|
|
// `code` is the coarse seven-value projection; `family` carries the full word; `message`
|
|
// is the same line just logged. seq/op are not threaded through the 90 call sites and the
|
|
// message already names the op where it matters, so the frame carries what it can name
|
|
// honestly rather than a field that is always zero.
|
|
Transport::ITransport* control = nullptr;
|
|
if (Client::ClientSession* client = Client::ClientSession::Active()) {
|
|
control = client->Control_Plane();
|
|
}
|
|
if (control == nullptr) {
|
|
if (Server::ServerSession* server = Server::ServerSession::Active()) {
|
|
control = server->Control_Plane();
|
|
}
|
|
}
|
|
if (control != nullptr) {
|
|
::flatbuffers::FlatBufferBuilder builder(256);
|
|
const auto fatal = ::MobileGL::Wire::CreateFatalDirect(
|
|
builder, FatalCodeForFamily(family), line, FatalFamilyName(family));
|
|
const auto root = ::MobileGL::Wire::CreateCtrlEnvelope(
|
|
builder, ::MobileGL::Wire::CtrlMsg::Fatal, fatal.Union());
|
|
::MobileGL::Wire::FinishCtrlEnvelopeBuffer(builder, root);
|
|
(void)control->SendFrame(
|
|
MobileGLByteSpan{builder.GetBufferPointer(), builder.GetSize()});
|
|
}
|
|
|
|
std::abort();
|
|
}
|
|
|
|
} // namespace MobileGL::MG_Remote
|