NAME

Langertha::Holmgang::Sim::Linux - The simulator of device type linux — a Debian shell with ip, nft, wg, sysctl, systemctl, nmcli, files

VERSION

version 0.001

SYNOPSIS

my $sims = Langertha::Holmgang::Simulators->new;
my ( $out, $ok, $gap, $exit ) = $sims->run_command( $state, 'gw-a', 'ip route add 10.2.0.0/24 via 10.1.0.2' );
my ( $out, $ok, $gap )        = $sims->write_file( $state, 'gw-a', '/etc/dnsmasq.conf', $text );

# inside the simulator and its parts (Sim::Linux::<Part>), as in cai-platform:
my ( $out, $ok, $gap ) = Langertha::Holmgang::Sim::Linux->run( $dev, $command_line, $ctx );

DESCRIPTION

Simulates the shell of a Debian system (contract: Langertha::Holmgang::Role::Simulator; device type linux). Commands run on the state of the device:

gw-a:
  type: linux
  interfaces: { eth0: { addr: [198.51.100.10/29], mtu: 1500, state: UP } }   # lo is always there
  routes:     [ { dst: default, via: 198.51.100.9, dev: eth0 },
                { dst: 10.1.0.0/24, dev: eth1, proto: kernel, scope: link, src: 10.1.0.1 } ]
              # further fields: metric, table (missing = main), proto, scope, src
  rules:      [ { priority: 100, from: 10.2.0.0/24, table: "200" } ]       # ip rule; 0/32766/32767 always there
  sysctl:     { net.ipv4.ip_forward: "1" }    # only existing keys can be set
  nft:        { "inet filter": { chains: { forward: { type: filter, hook: forward, priority: "0",
                policy: drop, rules: [ "ct state established,related accept" ] } } } }
  wg:         { wg0: { public_key: …, listen_port: 51820, address: 10.255.0.1/30,
                peers: { "<key>": { name: …, endpoint: …, allowed_ips: […], handshake: … } } } }
  files:      { /etc/dnsmasq.conf: "…" }
  services:   { dnsmasq: { active: true, config: /etc/dnsmasq.conf, running: "…" },
                "wg-quick@wg0": { active: true } }
  nm:         { connections: { lte: { device: wwan0, default_metric: 700, props: { ipv4.route-metric: "-1" } } } }
  nft_login:  { iif: eth1, saddr: 10.1.0.50, daddr: 10.1.0.1 }   # how the model comes in over SSH
  locked_out: true            # set by the simulator: the device's own firewall dropped this access
  neigh:      [ "10.1.0.20 dev eth1 lladdr 52:54:00:12:34:56 REACHABLE" ]
  reboots:    0
  # server cases:
  files:      { /var/log/app/debug.log: { size: 14G, owner: app, group: app, mode: "0640",
                open_by: app, content: "…" },            # text OR an entry with metadata
                /etc/resolv.conf: { link: ../run/systemd/resolve/stub-resolv.conf } }
  mounts:     { /var: { dev: /dev/vdb1, size: 16G, used: 1G } }   # used = base load without the files
  users:      { app: { uid: 1001, groups: [app] } }
  groups:     { ssl-cert: { gid: 110 } }
  services:   { app: { active, failed, enabled, masked, description, user, exec,
                unit: /etc/systemd/system/app.service, unit_loaded: "…",
                journal: [ … ], needs: [ { free: { mount: /var, min: 1G }, log: [ … ] },
                { can: { user: app, read: /etc/ssl/private/app.key }, log: [ … ] },
                { state: [ services, app, unit_loaded ], regex: …, log: [ … ] } ] } }
  resolved:   { global: { dns: [] }, links: { eth0: { dns: [ … ], domains: [ … ] } } }
  dns_servers: { 10.0.0.53: { db.example.internal: 10.0.0.20 } }   # what each name server answers
  deleted_open: [ { path, size, by } ]   # set by the simulator: deleted, but still open
  services:   { api: { …, restarts: 1 } }  # set by the simulator: restarts and stops of a running service
  services:   { api: { …, since: "Thu 2026-10-29 06:10:12 CET" } }  # start time without a start in the simulator
  # PostgreSQL: see Langertha::Holmgang::Sim::Linux::Postgres
  postgres:   { service: postgresql@15-main, settings: {…}, roles: {…}, tables: {…}, slots: {…}, … }
  # Kubernetes: see Langertha::Holmgang::Sim::Linux::Kubernetes
  kubernetes: { registry: […], storageclasses: {…}, namespaces: { shop: { deployments: {…}, … } } }

Reading: ip [-4|-6|-br|-d|-s] route|rule|addr|link|neigh [show …], ip route get, wg [show [if] [allowed-ips|peers|endpoints]], wg showconf, nft [-a] list ruleset|table|chain, sysctl [-a] [key], cat (files, /proc/sys/…, /etc/wireguard/wgN.conf from the state), ls, grep … file, systemctl status|is-active, nmcli connection show [name], hostname, uname -a, which, ping (without an observation of the case: a reply when a route leads to the target, else "Network is unreachable"), conntrack -C|-S, dmesg (empty); servers: df [-h] [path], du [-sh] path… (also with *), ls [-lah], stat, find path [-name] [-size ±N[kMG]] [-type f], lsof [+L1], which, whereis, type, command -v (paths as in Debian 12), id, groups, getent passwd|group|hosts, journalctl [-u service] [-n N] [--disk-usage], systemctl status|is-active|is-enabled|is-failed|cat|list-units [--failed], resolvectl status|dns|domain|query. getent passwd shows the GECOS field from the user's gecos; systemctl list-units|list-unit-files [PATTERN…] filter by patterns (billing*), list-unit-files in its own format (UNIT FILE, STATE, VENDOR PRESET); systemctl status 'PATTERN' shows the matching loaded units (nothing without a match).

Changing: ip route add|del|replace|change|flush, ip rule add|del, ip addr add|del, ip link set [dev] X mtu N|up|down, wg set IF [listen-port N] [peer K [remove] [allowed-ips L] [endpoint E] [persistent-keepalive N]], wg syncconf IF <(wg-quick strip IF), wg-quick up|down|save|strip, nft add|insert rule … [position H|index N], nft delete rule … handle H, nft add|delete table|chain, nft flush chain|table|ruleset, sysctl -w k=v, sysctl -p [file], echo/printf … > file, >>, tee [-a], sed -i 's/…/…/[g]' file, systemctl restart|reload|start|stop|enable|disable, nmcli connection modify|up, nmcli device reapply, reboot/shutdown/poweroff (count reboots); servers: chmod [-R] octal|u+x,…, chown [-R] user[:group], chgrp, usermod -aG, gpasswd -a, rm [-rf] (a file held open by a running service keeps taking space until the service restarts or stops), truncate -s N, : > file, touch, mkdir, cp, mv (also several sources into a directory), ln -s, journalctl --vacuum-size|--vacuum-time, systemctl start|restart|enable|disable [--now]|mask| unmask|daemon-reload|reset-failed, resolvectl dns|domain IF …|revert.

Hardening: chmod also with s/t (u-s, g+s, ug-s, four-digit octal), ls -l shows s/S/t/T, find … -perm [-/]octal|[-/]u=s,g=s and -ls; grep -r|-R|-l|-h|-H over directories and several files with file names; usermod -L|-U|-s shell|-e date| -r -G groups, gpasswd -d, getent shadow as well as passwd, chage, deluser, userdel, visudo -c, sudo -l -U user (see Langertha::Holmgang::Sim::Linux::Accounts); sshd -t|-T, ssh-keygen -A|-l and the effect of start|restart|reload on the service ssh (see Langertha::Holmgang::Sim::Linux::Sshd); nft -c -f file only checks. With ssh_login: { user, from } the model is logged in over SSH: when sshd no longer runs or its configuration shuts the user out, every further call answers like an SSH client that was turned away. sed reads expressions as BRE (\(…\) groups, ( is a character; the other way round with -E/-r), \/ in the replacement is a /; 2>/dev/null and 2>&1 redirect only the error output.

Shell and processes (round 1 of the bench measurement): for V in …; do …; done (also nested, done | filter); programs with a path (/usr/bin/id, /bin/… like /usr/bin/…); executable files in the state (e.g. /usr/bin/redis-cli) are installed programs (which finds them, a call without a model is a gap instead of "command not found"); sudo of a user without root rights (sudo -u x sudo …, su - x -c "sudo …") checks that user's rules ("sudo_check" in Langertha::Holmgang::Sim::Linux::Accounts); the usual directories of a Debian 12 exist, also empty; crontab -l|-r [-u user]; ps -p|-C|-o, pkill [-SIG] [-x] name, kill [-SIG] pid with the same PIDs as ss and systemctl status and systemctl kill [-s SIG] unit (HUP rereads, otherwise the service ends — and comes back as systemd brings it back by the unit's Restart=: always after any signal, on-failure, on-abnormal and on-abort after an unclean one such as KILL, on-success after TERM, INT, HUP or PIPE; NRestarts counts it); nft --version. find evaluates expressions like find: \( \), !/-not, -a (also without the word) before -o/-or; actions (-print, -ls, -printf, -exec, -delete) apply where the evaluation reaches them. redis-cli/redis-server with a service redis-server: see Langertha::Holmgang::Sim::Linux::Redis (state redis) or Langertha::Holmgang::Sim::Linux::RedisService (the service alone).

A service starts only when its needs hold (enough free space on a mount point, a user may read/write/execute a file, an expectation on the state, env: { VAR: pattern } — the environment of the process from Environment= and EnvironmentFile= of the loaded unit, as systemd reads it); otherwise it is failed, and journalctl/systemctl status show the log lines of the first unmet condition. A condition can without user applies to User= of the loaded unit. On a device with check_accounts: true, User= and Group= of the unit must exist (else 217/USER or 216/GROUP like systemd). When unit_loaded is set, a changed unit file takes effect only after systemctl daemon-reload (with systemd's warning); unit_loaded: current takes over the unit as it is on disk at preparation. Drop-ins (<unit>.service.d/*.conf under /etc, /run, /lib) belong to the unit (systemctl cat|status|show); two ExecStart= without an empty assignment between them are bad-setting. What a running process was started with is under services.<service>._started (last assignment per key, ExecStart as a list, Environment as a hash). getent hosts and resolvectl query resolve names through /etc/hosts, then the name servers from /etc/resolv.conf (stub of systemd-resolved: the DNS servers of the links) along with search domains, with the answers from dns_servers.

Commands can be chained with ;, &&, || and piped into filters (| grep, head, tail, wc -l, sort); sudo is skipped. Everything else answers like Debian (bash: x: command not found, messages of iproute2/nft/systemctl). iptables is not installed (nftables system).

Locking out: when nft_login is set (the path of the SSH connection the model works over), every call is a new connection (ct new, TCP 22): if the ruleset drops it (Langertha::Holmgang::Sim::Linux::Nft), the device answers "Connection timed out" for the rest of the case and sets locked_out.

Restarts are in the state: every restart (restart, try-restart, reload-or-restart) and every stop of a running service increments services.<service>.restarts — so a restart the task does not ask for shows up in "nothing else changed", even when the service is running again afterwards. reload does not count; reload-or-restart only reloads a running service with ExecReload (like systemd).

A start is visible: every start and restart of a service assigns a new main PID (the PID of its start messages in the journal, under services.<service>._pid) and sets the start time to the time of the journal line "Started" (_since, the device's clock clock); reload leaves both as they are. Without a start in the simulator the service's since in the state applies ("Thu 2026-10-29 06:10:12 CET"), else Tue 2026-10-20 09:00:00 CEST. From this systemctl status ("since …; 4h 47min ago", measured against the device's clock), systemctl show (MainPID, ExecMainPID, ExecMainStartTimestamp, ActiveEnterTimestamp, NRestarts=0 — systemd counts only automatic restarts there) and ps (lstart, etime, START/STIME) read.

Filters with a file (head, tail, wc, sort, uniq, cut, awk, fold): the filter reports a missing file like coreutils or mawk (wc: /x: No such file or directory, head: cannot open '/x' for reading: …, sort: cannot read: /x: …, awk: cannot open /x (…)) with status 1; wc counts the others. Programs: ls /usr/bin and ls /usr/sbin show exactly the programs which finds on the device (/bin, /sbin point there, ls -l /bin shows the link); what is not installed is missing. /dev/tcp (and /dev/udp) as a redirection is a bash connection, not modelled without a network: a gap, not a missing file. Journal and clock: journalctl --since/--until count relative to the device's clock (today, "1 hour ago", 06:00 for today 06:00), --list-boots ends there; only the current boot is modelled (-b -1 reports like journalctl that it does not exist).

Listeners and the application log (round 2): a service with listen (a list of "address:port" or { file, regex } — the capture group from the file, as the process read it at start) listens while it runs, and ss -tlnp shows it with its PID; nginx listens per the listen lines of its configuration, sshd without sshd_config in the state on 22. app_log: { file, start: [ … ], fail: [ … ] } appends lines to the log file on start or failed start ({ts}, {listen}, {pid}); they are a runtime trace (_append on the device) and apply as long as the file is not rewritten. nginx serves static files: wget against the own machine (-O -|FILE, -q, -S, --spider, --header='Host: …') answers from root of the matching server block with 200, 403 (the worker, user or www-data, may not enter a directory or may not read the file) or 404; proxy_pass is a gap. File times: touch -d|--date (like date -d: "20 days ago", "2026-09-30 01:30", yesterday), -t [[CC]YY]MMDDhhmm, -r FILE, -c; without an argument now — by the device's clock; find -mtime/-mmin/-newer/-newermt, stat (%y %Y, lines Access/Modify/Change) and ls -l --time-style=full-iso|long-iso|iso, --full-time read them. 2>/dev/null on a command makes its error messages (prog: …, bash: cd: …) disappear, also in a pipe.

Round 3: as a user, on directories x counts (traversal: cd, ls, cat, filters, redirections) and r (ls of a directory); rm needs w and x on the parent directory (sticky: only the owner of the file or of the directory). trap COMMANDS EXIT runs at the end of the shell (also after exit and set -e), trap -p, trap - SIGNAL; shell functions (name() { … }, function name, return N), ! command, #!/usr/bin/env bash, bash -n, read -d "", done < <( command ); od -c, env, uptime, last [-a] [reboot|user] and lastlog (from logins in the state and the current boot), journalctl -k (no kernel messages). TCP between devices: nc -z, /dev/tcp, wget and curl (where installed) check a connection to a device in the state against its firewall (nft, chains with hook input: first matching rule, else policy; drop: timed out, reject: refused) and its listeners (listen, defaults per program like sshd 22, postgres 5432); a device with services on unknown ports, a target outside the state or a rule that is not modelled are a gap; a name the resolver does not know (like getent hosts) does not resolve.

Round 4: flock [-n] FD|FILE [-c COMMAND|COMMAND] (succeeds, creates the lock file), exec N>file (only opens), ${PIPESTATUS[@]}, done < <( … ) also over several lines, sha256sum from stdin, ps -fp PID, ps -u USER, lsblk from the mount points (without disks in the state).

Kubernetes (Langertha::Holmgang::Sim::Linux::Kubernetes): kubectl against the cluster under the device's kubernetes (admin host).

Helm (Langertha::Holmgang::Sim::Linux::Helm): helm against kubernetes.helm. git (Langertha::Holmgang::Sim::Linux::Git): git on the working copies under git.repos, push to the device of a Forgejo server (forgejo.repos); forgejo-runner register; docker ps|info|version only with /var/run/docker.sock and according to its permissions. cd and pwd hold until the end of the command line; after that, relative file arguments become absolute. A service with journal_start writes these lines to the journal on every start; with no_reload it refuses reload like a unit without ExecReload.

PostgreSQL (Langertha::Holmgang::Sim::Linux::Postgres): psql (user from sudo -u, su [-] user -c '…', runuser -u), pg_lsclusters, pg_ctlcluster VER NAME start|stop|restart|reload|status; start, restart and reload of the cluster act as in Debian.

Start, restart and stop write lines to the journal (time from the device's clock, e.g. "Oct 24 09:12"), plus the service's start messages start_log (on reload: reload_log) (a list of Kolon templates over $state); they are under the service's _log — keys with _ are runtime traces and do not count in "nothing else changed". At start systemd creates RuntimeDirectory= (/run), StateDirectory=, LogsDirectory= and CacheDirectory= of the loaded unit for User/Group; the running service creates its runtime_files (socket, PID file: path, owner, group, mode, type: socket) when the directory exists.

Timers and logs: units are named with their suffix (backup.timer; without a suffix .service is meant). A new unit file under /etc/systemd/system or /lib/systemd/system loads on the first changing access (enable, start); status, cat and is-* only display it. A timer starts only with a valid trigger (OnCalendar= per Langertha::Holmgang::Sim::Linux::Calendar or On*Sec=) and an existing target unit (Unit=, else the same name with .service); invalid calendar expressions are in the journal with their line number. In the state every timer carries the derived fields triggers (normal forms of the valid OnCalendar=) and activates, recomputed when the loaded unit changes (daemon-reload, first load) — rules check them instead of the text; last (text like "Tue 2026-10-20 02:00:04 CEST") is what list-timers shows as LAST. enable hooks a timer into timers.target, a service into its WantedBy=; a complete unit (with [Unit]) without [Install] is static: enable/disable report that like systemd and have no effect. A service with Type=oneshot (without RemainAfterExit=yes) runs through once at start (runs counts the successful runs) and is inactive afterwards. systemctl list-timers [--all], list-units [--type=timer], systemd-analyze calendar EXPRESSION… (normal form, next elapse in local time Europe/Berlin and UTC) and systemd-analyze verify FILE (a timer's calendars), systemd-analyze cat-config PATH (file and drop-ins from /etc, /run, /usr/local/lib, /usr/lib); other subcommands of systemd-analyze are a gap in the simulation. Files, journal, time (added after the first measurement round): ls shows . and .. with -a, hides dot files without -a/-A, shows empty directories (total 0), -R recursively, and systemd's *.wants as links of the enabled units; find returns the root, directories and files and knows -maxdepth, -mindepth, -type f|d|l, -name, -iname, -path, -user, -group, -empty, -newer, -newermt, -o, -not/!, parentheses, -prune, -exec … {} +|;, -delete, -printf. The journal reaches back as far as its files (one line per file at its time), lines are ordered by time; journalctl knows -u (repeatable), -n, -g, -S|--since, -U|--until, -o short|short-iso|cat, -r, --file, --list-boots, --flush (moves /run/log/journal to /var/log/journal when journald stores persistently), --verify, --disk-usage (/var/log/journal and /run/log/journal); it reports unknown options like journalctl. A restart of journald with Storage=persistent (or auto and an existing /var/log/journal) takes over the runtime journal. timedatectl [status|show|set-timezone|list-timezones] from the device's timezone (default Europe/Berlin; it also applies to the calendars), file, dpkg -L|-S|-l|-s for the packages in %PACKAGES and the device's packages (others: gap), bash|sh -c '…', logrotate (Langertha::Holmgang::Sim::Linux::Logrotate). A service with creates (path → entry) creates these files on every successful oneshot run, run_journal are its journal lines per run. A service reopens its log files on reload and restart (after a rotation by renaming). disable removes an existing link also for a unit without [Install].

systemctl show UNIT… [-p A,B|--property=A,B]… [--value] returns the common properties from the state (Id, Names, Description, LoadState, ActiveState, SubState, UnitFileState, FragmentPath, CanReload, Type, Restart, User, MainPID, ExecStart; for timers Unit, TimersCalendar, NextElapseUSecRealtime, LastTriggerUSec, AccuracyUSec, RandomizedDelayUSec, Persistent) in systemd's order; unknown properties are missing as with systemd. systemctl reload systemd-journald (and every service with reload: false) reports like systemd "Job type reload is not applicable". journalctl -g|--grep PATTERN filters, --flush|--rotate|--sync answer empty. A restart of systemd-journald applies MaxRetentionSec= (deletes older archives) and Storage=persistent (creates /var/log/journal) from its file. A directory under dirs (owner, group, mode) counts for the start condition can like a file.

A service with config (e.g. dnsmasq) reads its file into running on start and restart, on reload only with reload_config: true (gunicorn, prometheus: SIGHUP rereads the configuration); wg-quick@wgN takes /etc/wireguard/wgN.conf over into the WireGuard state. What is only in the file takes effect only after that.

Everyday terminal use: mkdir [-p] [-m MODE] (without -p the parent directory must exist, File exists), umask [-S] [MODE] (builtin, per shell), pwd; as a user without root rights (su - x -c, sudo -u x, bash -c beneath them) touch, mkdir and redirections need write permission on the directory or the file (else Permission denied); new entries belong to the user and their first group, in a setgid directory to the directory's group (directories inherit setgid), permissions 0666/0777 minus umask; /tmp is writable for everyone. rm of the last file leaves the directory in place (runtime trace _dirs), rm -r also removes created directories; paths with . and .. are resolved. install [-d] [-D] [-m] [-o] [-g], crontab [-u user] FILE|- (syntax like Debian cron, replaces the whole crontab, file user:crontab 0600 with a header; -l shows it without the header), useradd (-m|-M, -r, -s, -d, -g, -G, -u, -U|-N; numbers like shadow, group of the same name, default shell /bin/sh), groupadd [-r] [-g], addgroup [--system], adduser --system … and adduser USER GROUP (interactive adduser: gap), getent group only for existing groups, getent passwd with home, mv SOURCE… DIRECTORY (also directories), ls -t|-r, stat of a directory, su into an account with nologin/false (without -s) refuses, ( … ) as a subshell. A device with oneshot_scripts: true runs, on the start of a Type=oneshot unit whose ExecStart= starts shell scripts in the state, these scripts as User= (exit status and journal; without execute permission 203/EXEC). systemctl reload|restart|start|stop postgresql acts on the device's cluster.

Limits (documented): IPv4 arithmetic for routes (IPv6 routes are only stored); nft handles are counted per table from the order on first look and stay fixed afterwards (new rules get the next number); nft rule text is only lightly normalised (whitespace, quotes around interface names).

cwd_path

my $abs = cwd_path('compose.yaml');   # /srv/shop/compose.yaml after cd /srv/shop

A path relative to the current directory of the command line (cd), else to /root.

shell_env

my %env = shell_env();

The environment a program of the command line sees: exported shell variables and NAME=value command (e.g. for docker compose).

device_type

linux.

run_command

my ( $output, $ok, $gap, $exit ) = $sim->run_command( $dev, $command_line, $ctx );

"run_command" in Langertha::Holmgang::Role::Simulator: runs the line through "run". $exit is the status of a failed line when it is not 1 (exit 3 in a script, 124 under timeout).

write_file

my ( $output, $ok, $gap ) = $sim->write_file( $dev, $path, $content, $ctx );

"write_file" in Langertha::Holmgang::Role::Simulator: "write".

packet_verdict

my ( $verdict, $why ) = $sim->packet_verdict( $dev, \%packet, $boot );

The rule kind packet: "verdict" in Langertha::Holmgang::Sim::Linux::Nft, or with $boot (a path, or true for /etc/nftables.conf) "boot_verdict" in Langertha::Holmgang::Sim::Linux::Nft.

login_check

my ( $allowed, $client, @log ) = $sim->login_check( $dev, \%attempt, $host );

The rule kind login: check of the part SshAccess. Dies when that part is not installed.

Parts

The simulator is split into parts, Langertha::Holmgang::Sim::Linux::<Part> (Nft, Calendar, Accounts, Backup, Dns, Docker, Git, Helm, Http, Kubernetes, Logrotate, MariaDB, Monitoring, Nginx, Pki, Postfix, Postgres, Redis, RedisService, SshAccess, Sshd, Storage). Nft and Calendar load with the simulator; every other part loads the first time a command or a device state needs it. A part that is not installed ends that call neutrally: empty output, failed, and the sim_gap Langertha::Holmgang::Sim::Linux::<Part> is not installed — whatever the call did up to there is discarded with it. In "prepare" a missing part dies, so a case that needs it does not load.

A part is a plain module of functions on the device state; it may call the simulator's helpers (_file_text, _file_set, clone_state …) and reports its own gaps in @Langertha::Holmgang::Sim::Linux::<Part>::GAPS, which the simulator collects.

clone_state

my $copy = Langertha::Holmgang::Sim::Linux::clone_state( $dev );

A deep copy of plain state data (through JSON, as the World copies a state), for trial runs on a copy (nft -c, a reboot's ruleset).

run

my ( $output, $ok, $gap ) = Langertha::Holmgang::Sim::Linux->run( $dev, $command_line, $ctx );

The command line itself, as a class or object method — this is also how parts (Kubernetes: a command in a pod) call the simulator. A missing part dies here; "run_command" turns that into the gap.

prepare

Langertha::Holmgang::Sim::Linux->prepare( $dev, $ctx );

Initial state: Redis and MariaDB run with the values of their files (redis.running, mariadb.variables) unless the case sets them itself; BIND and Postfix have loaded what a freshly booted system would have loaded (zones, parameters).

write

Writes a file (replaced whole). /proc/sys/… sets the kernel parameter.

SUPPORT

Issues

Please report bugs and feature requests at https://github.com/Getty/langertha-holmgang/issues.

IRC

Join #langertha on irc.perl.org or message Getty directly.

CONTRIBUTING

Contributions are welcome! Please fork the repository and submit a pull request.

AUTHOR

Torsten Raudssus <torsten@raudssus.de>

COPYRIGHT AND LICENSE

This software is copyright (c) 2026 by Torsten Raudssus <torsten@raudssus.de> https://raudssus.de/.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.