Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199const std = @import("std");const builtin = @import("builtin");
const log = std.log.scoped(.systemd);
/// Returns true if the program was launched as a systemd service.////// On Linux, this returns true if the program was launched as a systemd/// service. It will return false if Ghostty was launched any other way.////// For other platforms and app runtimes, this returns false.pub fn launchedBySystemd() bool { return switch (builtin.os.tag) { .linux => linux: { // On Linux, systemd sets the `INVOCATION_ID` (v232+) and the // `JOURNAL_STREAM` (v231+) environment variables. If these // environment variables are not present we were not launched by // systemd. if (std.posix.getenv("INVOCATION_ID") == null) break :linux false; if (std.posix.getenv("JOURNAL_STREAM") == null) break :linux false;
// If `INVOCATION_ID` and `JOURNAL_STREAM` are present, check to make sure // that our parent process is actually `systemd`, not some other terminal // emulator that doesn't clean up those environment variables. const ppid = std.os.linux.getppid(); if (ppid == 1) break :linux true;
// If the parent PID is not 1 we need to check to see if we were launched by // a user systemd daemon. Do that by checking the `/proc/<ppid>/comm` // to see if it ends with `systemd`. var comm_path_buf: [std.fs.max_path_bytes]u8 = undefined; const comm_path = std.fmt.bufPrint(&comm_path_buf, "/proc/{d}/comm", .{ppid}) catch { log.err("unable to format comm path for pid {d}", .{ppid}); break :linux false; }; const comm_file = std.fs.openFileAbsolute(comm_path, .{ .mode = .read_only }) catch { log.err("unable to open '{s}' for reading", .{comm_path}); break :linux false; }; defer comm_file.close();
// The maximum length of the command name is defined by // `TASK_COMM_LEN` in the Linux kernel. This is usually 16 // bytes at the time of writing (Jun 2025) so its set to that. // Also, since we only care to compare to "systemd", anything // longer can be assumed to not be systemd. const TASK_COMM_LEN = 16; var comm_data_buf: [TASK_COMM_LEN]u8 = undefined; const comm_size = comm_file.readAll(&comm_data_buf) catch { log.err("problems reading from '{s}'", .{comm_path}); break :linux false; }; const comm_data = comm_data_buf[0..comm_size];
break :linux std.mem.eql( u8, std.mem.trimRight(u8, comm_data, "\n"), "systemd", ); },
// No other system supports systemd so always return false. else => false, };}
/// systemd notifications. Used by Ghostty to inform systemd of the state of the/// process. Currently only used to notify systemd that we are ready and that/// configuration reloading has started.////// See: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html////// These functions were re-implemented in Zig instead of using the `libsystemd`/// library to avoid the complexity of another external dependency, as well as/// to take advantage of Zig features like `comptime` to ensure minimal impact/// on non-Linux systems (like FreeBSD) that will never support `systemd`.////// Linux systems that do not use `systemd` should not be impacted as they/// should never start Ghostty with the `NOTIFY_SOCKET` environment variable set/// and these functions essentially become a no-op.////// See `systemd`'s [Interface Portability and Stability Promise](https://systemd.io/PORTABILITY_AND_STABILITY/)/// for assurances that the interfaces used here will be supported and stable for/// the long term.pub const notify = struct { /// Send the given message to the UNIX socket specified in the NOTIFY_SOCKET /// environment variable. If there NOTIFY_SOCKET environment variable does /// not exist then no message is sent. fn send(message: []const u8) void { // systemd is Linux-only so this is a no-op anywhere else if (comptime builtin.os.tag != .linux) return;
// Get the socket address that should receive notifications. const socket_path = std.posix.getenv("NOTIFY_SOCKET") orelse return;
// If the socket address is an empty string return. if (socket_path.len == 0) return;
// The socket address must be a path or an abstract socket. if (socket_path[0] != '/' and socket_path[0] != '@') { log.warn("only AF_UNIX sockets with path or abstract namespace addresses are supported!", .{}); return; }
var socket_address: std.os.linux.sockaddr.un = undefined;
// Error out if the supplied socket path is too long. if (socket_address.path.len < socket_path.len) { log.warn("NOTIFY_SOCKET path is too long!", .{}); return; }
socket_address.family = std.os.linux.AF.UNIX;
@memcpy(socket_address.path[0..socket_path.len], socket_path); socket_address.path[socket_path.len] = 0;
const socket: std.os.linux.socket_t = socket: { const rc = std.os.linux.socket( std.os.linux.AF.UNIX, std.os.linux.SOCK.DGRAM | std.os.linux.SOCK.CLOEXEC, 0, ); switch (std.os.linux.E.init(rc)) { .SUCCESS => break :socket @intCast(rc), else => |e| { log.warn("creating socket failed: {s}", .{@tagName(e)}); return; }, } };
defer _ = std.os.linux.close(socket);
connect: { const rc = std.os.linux.connect( socket, &socket_address, @offsetOf(std.os.linux.sockaddr.un, "path") + socket_address.path.len, ); switch (std.os.linux.E.init(rc)) { .SUCCESS => break :connect, else => |e| { log.warn("unable to connect to notify socket: {s}", .{@tagName(e)}); return; }, } }
write: { const rc = std.os.linux.write(socket, message.ptr, message.len); switch (std.os.linux.E.init(rc)) { .SUCCESS => { const written = rc; if (written < message.len) { log.warn("short write to notify socket: {d} < {d}", .{ rc, message.len }); return; } break :write; }, else => |e| { log.warn("unable to write to notify socket: {s}", .{@tagName(e)}); return; }, } } }
/// Tell systemd that we are ready or that we are finished reloading. /// See: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html#READY=1 pub fn ready() void { if (comptime builtin.os.tag != .linux) return;
send("READY=1"); }
/// Tell systemd that we have started reloading our configuration. /// See: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html#RELOADING=1 /// and: https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html#MONOTONIC_USEC=%E2%80%A6 pub fn reloading() void { if (comptime builtin.os.tag != .linux) return;
const ts = std.posix.clock_gettime(.MONOTONIC) catch |err| { log.err("unable to get MONOTONIC clock: {}", .{err}); return; };
const now = ts.sec * std.time.us_per_s + @divFloor(ts.nsec, std.time.ns_per_us);
var buffer: [64]u8 = undefined; const message = std.fmt.bufPrint(&buffer, "RELOADING=1\nMONOTONIC_USEC={d}", .{now}) catch |err| { log.err("unable to format reloading message: {}", .{err}); return; };
send(message); }};