Lightpanda: the headless browser designed for AI and automation
feat: add LIGHTPANDA_DISABLE_CORE_DUMP to suppress crash core dumps
Scott Taylorf7f149c9c019
diff --git a/src/core_dump.zig b/src/core_dump.zignew file mode 100644index 000000000..cdbb12f8b--- /dev/null+++ b/src/core_dump.zig@@ -0,0 +1,82 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// Francis Bouvier <[email protected]>+// Pierre Tachoire <[email protected]>+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as+// published by the Free Software Foundation, either version 3 of the+// License, or (at your option) any later version.+//+// This program 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 Affero General Public License for more details.+//+// You should have received a copy of the GNU Affero General Public License+// along with this program. If not, see <https://www.gnu.org/licenses/>.++//! Opt-in core-dump suppression.+//!+//! Lightpanda has no SIGSEGV handler, so a segfault (or the `abort()` in the+//! panic path) falls through to the kernel and writes a core dump. When many+//! instances run under a shared `core_pattern` crash reporter — e.g. a+//! containerized crawl fleet — those dumps become pure storage and alert+//! noise, and a browser core can capture the contents of arbitrary pages.+//! Crashes are already reported via telemetry, so `LIGHTPANDA_DISABLE_CORE_DUMP`+//! lets an operator drop the cores while leaving the default behavior+//! (and local debugging) untouched.++const std = @import("std");+const builtin = @import("builtin");+const lp = @import("lightpanda.zig");++const log = lp.log;++pub fn disableIfRequested() void {+ if (!shouldDisable()) return;+ disable() catch |err| {+ log.warn(.app, "could not disable core dumps", .{ .err = err });+ };+}++fn shouldDisable() bool {+ if (builtin.os.tag == .windows) return false;+ return std.process.hasEnvVarConstant("LIGHTPANDA_DISABLE_CORE_DUMP");+}++// Zeroes only the soft limit; that is what the kernel consults when deciding+// whether to dump (including the piped-`core_pattern` opt-out), and keeping the+// hard limit lets the process raise it again if it ever needs to.+fn disable() !void {+ var limit = try std.posix.getrlimit(.CORE);+ limit.cur = 0;+ try std.posix.setrlimit(.CORE, limit);+}++const testing = @import("testing.zig");++extern fn setenv(name: [*:0]u8, value: [*:0]u8, override: c_int) c_int;+extern fn unsetenv(name: [*:0]u8) c_int;++test "core_dump: disabled only when the env var is set" {+ _ = unsetenv(@constCast("LIGHTPANDA_DISABLE_CORE_DUMP"));+ try testing.expectEqual(false, shouldDisable());++ _ = setenv(@constCast("LIGHTPANDA_DISABLE_CORE_DUMP"), @constCast(""), 1);+ defer _ = unsetenv(@constCast("LIGHTPANDA_DISABLE_CORE_DUMP"));+ try testing.expectEqual(true, shouldDisable());+}++test "core_dump: disable zeroes the soft RLIMIT_CORE" {+ if (builtin.os.tag == .windows) return;++ const original = try std.posix.getrlimit(.CORE);+ defer std.posix.setrlimit(.CORE, original) catch {};++ try disable();++ const after = try std.posix.getrlimit(.CORE);+ try testing.expectEqual(@as(@TypeOf(after.cur), 0), after.cur);+ try testing.expectEqual(original.max, after.max);+}diff --git a/src/lightpanda.zig b/src/lightpanda.zigindex 7c078d26a..4dfdbc437 100644--- a/src/lightpanda.zig+++ b/src/lightpanda.zig@@ -54,6 +54,7 @@ pub const Schema = @import("script/Schema.zig");pub const cookies = @import("cookies.zig");pub const build_config = @import("build_config");pub const crash_handler = @import("crash_handler.zig");+pub const core_dump = @import("core_dump.zig");pub const FetchOpts = struct {wait_ms: u32 = 5000,diff --git a/src/main.zig b/src/main.zigindex 439c3a36b..3541e4c41 100644--- a/src/main.zig+++ b/src/main.zig@@ -54,6 +54,8 @@ pub fn main() !void {}fn run(allocator: Allocator, main_arena: Allocator) !void {+ lp.core_dump.disableIfRequested();+const args = try Config.parseArgs(main_arena);defer args.deinit(main_arena);