Add Zig impl from https://github.com/vrmiguel/buztd

Author: vrmiguel

zig/.gitignore

@@ -0,0 +1,2 @@
+zig-cache/
+zig-out/

zig/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Vinícius Miguel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zig/README.md

@@ -0,0 +1,125 @@
+:warning: This will be marged with the original [bustd](https://github.com/vrmiguel/bustd) repository.
+
+# `buztd`: Available memory or bust!
+
+`buztd` is a lightweight process killer daemon for out-of-memory scenarios for Linux!
+
+This particular project is a Zig version of the [original `bustd` project](https://github.com/vrmiguel/bustd).
+
+## Features
+
+### Extremely thin memory usage
+
+The Zig version of `bustd` makes no heap allocations and relies solely on a single 128-byte buffer in the stack for all its allocation needs. 
+
+### Small CPU usage
+
+Much like `earlyoom` and `nohang`, `buztd` uses adaptive sleep times during its memory polling. 
+
+Unlike these two, however, `buztd` does not read from `/proc/meminfo`, instead opting for the `sysinfo` syscall.
+
+This approach has its up- and downsides. The amount of free RAM that `sysinfo` reads does not account for cached memory, while `MemAvailable` in `/proc/meminfo` does.
+
+However, the `sysinfo` syscall is one order of magnitude faster than parsing `/proc/meminfo`, at least according to [this kernel patch](https://sourceware.org/legacy-ml/libc-alpha/2015-08/msg00512.html) (granted, from 2015).
+
+As `buztd` can't solely rely on the free RAM readings of `sysinfo`, we check for memory stress through [Pressure Stall Information](https://www.kernel.org/doc/html/v5.8/accounting/psi.html).
+
+More on that below.
+
+### `buztd` will try to lock all pages mapped into its address space
+
+Much like `earlyoom`, `buztd` uses [`mlockall`](https://www.ibm.com/docs/en/aix/7.2?topic=m-mlockall-munlockall-subroutine) to avoid being sent to swap, which allows the daemon to remain responsive even when the system memory is under heavy load and susceptible to [thrashing](https://en.wikipedia.org/wiki/Thrashing_(computer_science)).
+
+### Checks for Pressure Stall Information
+
+The Linux kernel, since version 4.20 (and built with `CONFIG_PSI=y`), presents canonical new pressure metrics for memory, CPU, and IO.
+In the words of [Facebook Incubator](https://facebookmicrosites.github.io/psi/docs/overview):
+
+```
+PSI stats are like barometers that provide fair warning of impending resource 
+shortages, enabling you to take more proactive, granular, and nuanced steps 
+when resources start becoming scarce.
+```
+
+More specifically, `buztd` checks for how long, in microseconds, processes have stalled in the last 10 seconds. By default, `buztd` will kill a process when processes have stalled for 25 microseconds in the last ten seconds.
+
+Example:
+```
+   some avg10=0.00 avg60=0.00 avg300=0.00 total=11220657
+   full avg10=0.00 avg60=0.00 avg300=0.00 total=10947429
+```
+
+These ratios are percentages of recent trends over ten, sixty, and  three hundred second windows.
+
+The `some` row indicates the percentage of time n that given time frame in which _any_ process has stalled due to memory thrashing.
+
+`buztd` allows you to configure the value of `some avg10` in which, if surpassed, some process will be killed.
+
+The ideal value for this cutoff varies a lot between systems.
+
+Try messing around with `tools/mem-eater.c` to guesstimate a value that works well for you.
+
+## Building
+
+Requirements:
+* [Zig 0.10](https://ziglang.org/)
+* Linux 4.20+ built with `CONFIG_PSI=y`
+
+```shell
+git clone https://github.com/vrmiguel/buztd
+cd buztd
+
+# Choose which compilation mode you'd like:
+zig build -Drelease-fast # Turns on optimization and disables safety checks
+zig build -Drelease-safe # Turns on optimization and keeps safety checks
+zig build -Drelease-small # Turns on size optimizations and disables safety checks
+```
+
+## Configuration
+
+As of the time of writing, this version of `buztd` offers no command-line argument parsing, but allows easy configuration through the `src/config.zig` file.
+
+
+```zig
+/// Sets whether or not buztd should daemonize
+/// itself. Don't use this if running buztd as a systemd
+/// service or something of the sort.
+pub const should_daemonize: bool = false;
+
+/// Free RAM percentage figures below this threshold are considered to be near terminal, meaning 
+/// that buztd will start to check for Pressure Stall Information whenever the
+/// free RAM figures go below this.
+/// However, this free RAM amount is what the sysinfo syscall gives us, which does not take in consideration
+/// reclaimable or cached pages. The true free RAM amount available to the OS is bigger than what it indicates.
+pub const free_ram_threshold: u8 = 15;
+
+/// The Linux kernel presents canonical pressure metrics for memory, found in `/proc/pressure/memory`.
+/// Example:
+///    some avg10=0.00 avg60=0.00 avg300=0.00 total=11220657
+///    full avg10=0.00 avg60=0.00 avg300=0.00 total=10947429
+/// These ratios are percentages of recent trends over ten, sixty, and 
+/// three hundred second windows. The `some` row indicates the percentage of time
+// in that given time frame in which _any_ process has stalled due to memory thrashing.
+///
+/// This value configured here is the value of `some avg10` in which, if surpassed, some 
+/// process will be killed.
+///
+/// The ideal value for this cutoff varies a lot between systems.
+/// Try messing around with `tools/mem-eater.c` to guesstimate a value that works well for you.
+pub const cutoff_psi: f32 = 0.05;
+
+/// Sets processes that buztd must never kill.
+/// The values expected here are the `comm` values of the process you don't want to have terminated.
+/// A comm-value is the filename of the executable truncated to 16 characters..
+pub const unkillables = std.ComptimeStringMap(void, .{
+         .{ "firefox", void },
+         .{ "rustc", void },
+         .{ "electron", void },
+});
+
+
+/// If any error occurs, restarts the monitoring instead of exiting with an unsuccesful status code
+pub const retry: bool = true;
+```
+
+

zig/build.zig

@@ -0,0 +1,35 @@
+const std = @import("std");
+
+pub fn build(b: *std.build.Builder) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard release options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
+    const mode = b.standardReleaseOptions();
+
+    const exe = b.addExecutable("buztd", "src/main.zig");
+    exe.setTarget(target);
+    exe.setBuildMode(mode);
+    exe.linkLibC();
+    exe.install();
+
+    const run_cmd = exe.run();
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_tests = b.addTest("src/main.zig");
+    exe_tests.setTarget(target);
+    exe_tests.setBuildMode(mode);
+
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&exe_tests.step);
+}

zig/src/config.zig

@@ -0,0 +1,47 @@
+//! The configuration file for buztd
+const std = @import("std");
+
+/// Sets whether or not buztd should daemonize
+/// itself. Don't use this if running buztd as a systemd
+/// service or something of the sort.
+pub const should_daemonize: bool = false;
+
+/// Free RAM percentage figures below this threshold are considered to be near terminal, meaning
+/// that buztd will start to check for Pressure Stall Information whenever the
+/// free RAM figures go below this.
+/// However, this free RAM amount is what the sysinfo syscall gives us, which does not take in consideration
+/// reclaimable or cached pages. The true free RAM amount available to the OS is bigger than what it indicates.
+pub const free_ram_threshold: u8 = 15;
+
+/// The Linux kernel presents canonical pressure metrics for memory, found in `/proc/pressure/memory`.
+/// Example:
+///    some avg10=0.00 avg60=0.00 avg300=0.00 total=11220657
+///    full avg10=0.00 avg60=0.00 avg300=0.00 total=10947429
+/// These ratios are percentages of recent trends over ten, sixty, and
+/// three hundred second windows. The `some` row indicates the percentage of time
+// in that given time frame in which _any_ process has stalled due to memory thrashing.
+///
+/// This value configured here is the value of `some avg10` in which, if surpassed, some
+/// process will be killed.
+///
+/// The ideal value for this cutoff varies a lot between systems.
+/// Try messing around with `tools/mem-eater.c` to guesstimate a value that works well for you.
+pub const cutoff_psi: f32 = 0.05;
+
+/// Sets processes that buztd must never kill.
+/// The values expected here are the `comm` values of the process you don't want to have terminated.
+/// A comm-value is the filename of the executable truncated to 16 characters..
+///
+/// Example:
+/// pub const unkillables = std.ComptimeStringMap(void, .{
+///         .{ "firefox", void },
+///         .{ "rustc", void },
+///         .{ "electron", void },
+/// });
+pub const unkillables = std.ComptimeStringMap(void, .{
+    // Ideally, don't kill the oomkiller
+    .{ "buztd", void },
+});
+
+/// If any error occurs, restarts the monitoring instead of exiting with an unsuccesful status code
+pub const retry: bool = true;

zig/src/daemonize.zig

@@ -0,0 +1,104 @@
+const std = @import("std");
+const os = std.os;
+
+const unistd = @cImport({
+    @cInclude("unistd.h");
+});
+
+const signal = @cImport({
+    @cInclude("signal.h");
+});
+
+const stat = @cImport({
+    @cInclude("sys/stat.h");
+});
+
+/// Any error that might come up during process daemonization
+const DaemonizeError = error{FailedToSetSessionId} || os.ForkError;
+
+const SignalHandler = struct {
+    fn ignore(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const anyopaque) callconv(.C) void {
+        // Ignore the signal received
+        _ = sig;
+        _ = ctx_ptr;
+        _ = info;
+        _ = ctx_ptr;
+    }
+};
+
+/// Forks the current process and makes
+/// the parent process quit
+fn fork_and_keep_child() os.ForkError!void {
+    const is_parent_proc = (try os.fork()) != 0;
+    // Exit off of the parent process
+    if (is_parent_proc) {
+        os.exit(0);
+    }
+}
+
+// TODO:
+// * Add logging
+// * Chdir
+/// Daemonizes the calling process
+pub fn daemonize() DaemonizeError!void {
+    try fork_and_keep_child();
+
+    if (unistd.setsid() < 0) {
+        return error.FailedToSetSessionId;
+    }
+
+    // Setup signal handling
+    var act = os.Sigaction{
+        .handler = .{ .sigaction = SignalHandler.ignore },
+        .mask = os.empty_sigset,
+        .flags = (os.SA.SIGINFO | os.SA.RESTART | os.SA.RESETHAND),
+    };
+    os.sigaction(signal.SIGCHLD, &act, null);
+    os.sigaction(signal.SIGHUP, &act, null);
+
+    // Fork yet again and keep only the child process
+    try fork_and_keep_child();
+
+    // Set new file permissions
+    _ = stat.umask(0);
+
+    var fd: u8 = 0;
+    // The maximum number of files a process can have open
+    // at any time
+    const max_files_opened = unistd.sysconf(unistd._SC_OPEN_MAX);
+    while (fd < max_files_opened) : (fd += 1) {
+        _ = unistd.close(fd);
+    }
+}
+
+test "fork_and_keep_child works" {
+    const getpid = os.linux.getpid;
+    const expect = std.testing.expect;
+    const linux = std.os.linux;
+    const fmt = std.fmt;
+
+    const first_pid = getpid();
+    try fork_and_keep_child();
+
+    const new_pid = getpid();
+    // We should now be running on a new process
+    try expect(first_pid != new_pid);
+
+    var stat_buf: linux.Stat = undefined;
+    var buf = [_:0]u8{0} ** 128;
+
+    // Current process is alive (obviously)
+    _ = try fmt.bufPrint(&buf, "/proc/{}/stat", .{new_pid});
+
+    try expect(linux.stat(&buf, &stat_buf) == 0);
+
+    // Old process should now be dead
+    _ = try fmt.bufPrint(&buf, "/proc/{}/stat", .{first_pid});
+
+    // Give the OS some time to reap the old process
+    std.time.sleep(250_000);
+
+    try expect(
+    // Stat should now fail
+    linux.stat(&buf, &stat_buf) != 0);
+}

zig/src/main.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+
+test "imports" {
+    _ = @import("pressure.zig");
+    _ = @import("daemonize.zig");
+    _ = @import("process.zig");
+    _ = @import("memory.zig");
+    _ = @import("monitor.zig");
+    _ = @import("config.zig");
+}
+
+const pressure = @import("pressure.zig");
+const daemon = @import("daemonize.zig");
+const process = @import("process.zig");
+const memory = @import("memory.zig");
+const monitor = @import("monitor.zig");
+const config = @import("config.zig");
+const syscalls = @import("missing_syscalls.zig");
+const MCL = syscalls.MCL;
+
+pub fn startMonitoring() anyerror!void {
+    if (config.should_daemonize) {
+        try daemon.daemonize();
+    }
+
+    var buffer: [128]u8 = undefined;
+
+    if (syscalls.mlockall(MCL.CURRENT | MCL.FUTURE | MCL.ONFAULT)) {
+        std.log.warn("Memory pages locked.", .{});
+    } else |err| {
+        std.log.warn("Failed to lock memory pages: {}. Continuing.", .{err});
+    }
+
+    var m = try monitor.Monitor.new(&buffer);
+    try m.poll();
+}
+
+pub fn main() anyerror!void {
+    startMonitoring() catch |err| {
+        // If config.retry is set, get back up and running
+        if (config.retry) {
+            std.log.err("{s}. Continuing.", .{err});
+            try main();
+        } else {
+            return err;
+        }
+    };
+}