uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead
https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948 this can do it nicely. Signed-off-by: Anton Arapov <anton@deadbeef.mx>
This commit is contained in:
Anton Arapov
Alan Daniels
commit
56de2bcd43
30691 changed files with 3076956 additions and 0 deletions
272
nixos/modules/system/activation/activation-script.nix
Normal file
272
nixos/modules/system/activation/activation-script.nix
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
# generate the script used to activate the configuration.
|
||||
{ config, lib, pkgs, ... }:
|
||||
|
||||
with lib;
|
||||
|
||||
let
|
||||
|
||||
addAttributeName = mapAttrs (a: v: v // {
|
||||
text = ''
|
||||
#### Activation script snippet ${a}:
|
||||
_localstatus=0
|
||||
${v.text}
|
||||
|
||||
if (( _localstatus > 0 )); then
|
||||
printf "Activation script snippet '%s' failed (%s)\n" "${a}" "$_localstatus"
|
||||
fi
|
||||
'';
|
||||
});
|
||||
|
||||
systemActivationScript = set: onlyDry: let
|
||||
set' = mapAttrs (_: v: if isString v then (noDepEntry v) // { supportsDryActivation = false; } else v) set;
|
||||
withHeadlines = addAttributeName set';
|
||||
# When building a dry activation script, this replaces all activation scripts
|
||||
# that do not support dry mode with a comment that does nothing. Filtering these
|
||||
# activation scripts out so they don't get generated into the dry activation script
|
||||
# does not work because when an activation script that supports dry mode depends on
|
||||
# an activation script that does not, the dependency cannot be resolved and the eval
|
||||
# fails.
|
||||
withDrySnippets = mapAttrs (a: v: if onlyDry && !v.supportsDryActivation then v // {
|
||||
text = "#### Activation script snippet ${a} does not support dry activation.";
|
||||
} else v) withHeadlines;
|
||||
in
|
||||
''
|
||||
#!${pkgs.runtimeShell}
|
||||
|
||||
systemConfig='@out@'
|
||||
|
||||
export PATH=/empty
|
||||
for i in ${toString path}; do
|
||||
PATH=$PATH:$i/bin:$i/sbin
|
||||
done
|
||||
|
||||
_status=0
|
||||
trap "_status=1 _localstatus=\$?" ERR
|
||||
|
||||
# Ensure a consistent umask.
|
||||
umask 0022
|
||||
|
||||
${textClosureMap id (withDrySnippets) (attrNames withDrySnippets)}
|
||||
|
||||
'' + optionalString (!onlyDry) ''
|
||||
# Make this configuration the current configuration.
|
||||
# The readlink is there to ensure that when $systemConfig = /system
|
||||
# (which is a symlink to the store), /run/current-system is still
|
||||
# used as a garbage collection root.
|
||||
ln -sfn "$(readlink -f "$systemConfig")" /run/current-system
|
||||
|
||||
# Prevent the current configuration from being garbage-collected.
|
||||
mkdir -p /nix/var/nix/gcroots
|
||||
ln -sfn /run/current-system /nix/var/nix/gcroots/current-system
|
||||
|
||||
exit $_status
|
||||
'';
|
||||
|
||||
path = with pkgs; map getBin
|
||||
[ coreutils
|
||||
gnugrep
|
||||
findutils
|
||||
getent
|
||||
stdenv.cc.libc # nscd in update-users-groups.pl
|
||||
shadow
|
||||
nettools # needed for hostname
|
||||
util-linux # needed for mount and mountpoint
|
||||
];
|
||||
|
||||
scriptType = withDry: with types;
|
||||
let scriptOptions =
|
||||
{ deps = mkOption
|
||||
{ type = types.listOf types.str;
|
||||
default = [ ];
|
||||
description = "List of dependencies. The script will run after these.";
|
||||
};
|
||||
text = mkOption
|
||||
{ type = types.lines;
|
||||
description = "The content of the script.";
|
||||
};
|
||||
} // optionalAttrs withDry {
|
||||
supportsDryActivation = mkOption
|
||||
{ type = types.bool;
|
||||
default = false;
|
||||
description = ''
|
||||
Whether this activation script supports being dry-activated.
|
||||
These activation scripts will also be executed on dry-activate
|
||||
activations with the environment variable
|
||||
<literal>NIXOS_ACTION</literal> being set to <literal>dry-activate
|
||||
</literal>. it's important that these activation scripts don't
|
||||
modify anything about the system when the variable is set.
|
||||
'';
|
||||
};
|
||||
};
|
||||
in either str (submodule { options = scriptOptions; });
|
||||
|
||||
in
|
||||
|
||||
{
|
||||
|
||||
###### interface
|
||||
|
||||
options = {
|
||||
|
||||
system.activationScripts = mkOption {
|
||||
default = {};
|
||||
|
||||
example = literalExpression ''
|
||||
{ stdio.text =
|
||||
'''
|
||||
# Needed by some programs.
|
||||
ln -sfn /proc/self/fd /dev/fd
|
||||
ln -sfn /proc/self/fd/0 /dev/stdin
|
||||
ln -sfn /proc/self/fd/1 /dev/stdout
|
||||
ln -sfn /proc/self/fd/2 /dev/stderr
|
||||
''';
|
||||
}
|
||||
'';
|
||||
|
||||
description = ''
|
||||
A set of shell script fragments that are executed when a NixOS
|
||||
system configuration is activated. Examples are updating
|
||||
/etc, creating accounts, and so on. Since these are executed
|
||||
every time you boot the system or run
|
||||
<command>nixos-rebuild</command>, it's important that they are
|
||||
idempotent and fast.
|
||||
'';
|
||||
|
||||
type = types.attrsOf (scriptType true);
|
||||
apply = set: set // {
|
||||
script = systemActivationScript set false;
|
||||
};
|
||||
};
|
||||
|
||||
system.dryActivationScript = mkOption {
|
||||
description = "The shell script that is to be run when dry-activating a system.";
|
||||
readOnly = true;
|
||||
internal = true;
|
||||
default = systemActivationScript (removeAttrs config.system.activationScripts [ "script" ]) true;
|
||||
defaultText = literalDocBook "generated activation script";
|
||||
};
|
||||
|
||||
system.userActivationScripts = mkOption {
|
||||
default = {};
|
||||
|
||||
example = literalExpression ''
|
||||
{ plasmaSetup = {
|
||||
text = '''
|
||||
''${pkgs.libsForQt5.kservice}/bin/kbuildsycoca5"
|
||||
''';
|
||||
deps = [];
|
||||
};
|
||||
}
|
||||
'';
|
||||
|
||||
description = ''
|
||||
A set of shell script fragments that are executed by a systemd user
|
||||
service when a NixOS system configuration is activated. Examples are
|
||||
rebuilding the .desktop file cache for showing applications in the menu.
|
||||
Since these are executed every time you run
|
||||
<command>nixos-rebuild</command>, it's important that they are
|
||||
idempotent and fast.
|
||||
'';
|
||||
|
||||
type = with types; attrsOf (scriptType false);
|
||||
|
||||
apply = set: {
|
||||
script = ''
|
||||
unset PATH
|
||||
for i in ${toString path}; do
|
||||
PATH=$PATH:$i/bin:$i/sbin
|
||||
done
|
||||
|
||||
_status=0
|
||||
trap "_status=1 _localstatus=\$?" ERR
|
||||
|
||||
${
|
||||
let
|
||||
set' = mapAttrs (n: v: if isString v then noDepEntry v else v) set;
|
||||
withHeadlines = addAttributeName set';
|
||||
in textClosureMap id (withHeadlines) (attrNames withHeadlines)
|
||||
}
|
||||
|
||||
exit $_status
|
||||
'';
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
environment.usrbinenv = mkOption {
|
||||
default = "${pkgs.coreutils}/bin/env";
|
||||
defaultText = literalExpression ''"''${pkgs.coreutils}/bin/env"'';
|
||||
example = literalExpression ''"''${pkgs.busybox}/bin/env"'';
|
||||
type = types.nullOr types.path;
|
||||
visible = false;
|
||||
description = ''
|
||||
The env(1) executable that is linked system-wide to
|
||||
<literal>/usr/bin/env</literal>.
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
###### implementation
|
||||
|
||||
config = {
|
||||
|
||||
system.activationScripts.stdio = ""; # obsolete
|
||||
|
||||
system.activationScripts.var =
|
||||
''
|
||||
# Various log/runtime directories.
|
||||
|
||||
mkdir -m 1777 -p /var/tmp
|
||||
|
||||
# Empty, immutable home directory of many system accounts.
|
||||
mkdir -p /var/empty
|
||||
# Make sure it's really empty
|
||||
${pkgs.e2fsprogs}/bin/chattr -f -i /var/empty || true
|
||||
find /var/empty -mindepth 1 -delete
|
||||
chmod 0555 /var/empty
|
||||
chown root:root /var/empty
|
||||
${pkgs.e2fsprogs}/bin/chattr -f +i /var/empty || true
|
||||
'';
|
||||
|
||||
system.activationScripts.usrbinenv = if config.environment.usrbinenv != null
|
||||
then ''
|
||||
mkdir -m 0755 -p /usr/bin
|
||||
ln -sfn ${config.environment.usrbinenv} /usr/bin/.env.tmp
|
||||
mv /usr/bin/.env.tmp /usr/bin/env # atomically replace /usr/bin/env
|
||||
''
|
||||
else ''
|
||||
rm -f /usr/bin/env
|
||||
rmdir --ignore-fail-on-non-empty /usr/bin /usr
|
||||
'';
|
||||
|
||||
system.activationScripts.specialfs =
|
||||
''
|
||||
specialMount() {
|
||||
local device="$1"
|
||||
local mountPoint="$2"
|
||||
local options="$3"
|
||||
local fsType="$4"
|
||||
|
||||
if mountpoint -q "$mountPoint"; then
|
||||
local options="remount,$options"
|
||||
else
|
||||
mkdir -m 0755 -p "$mountPoint"
|
||||
fi
|
||||
mount -t "$fsType" -o "$options" "$device" "$mountPoint"
|
||||
}
|
||||
source ${config.system.build.earlyMountScript}
|
||||
'';
|
||||
|
||||
systemd.user = {
|
||||
services.nixos-activation = {
|
||||
description = "Run user-specific NixOS activation";
|
||||
script = config.system.userActivationScripts.script;
|
||||
unitConfig.ConditionUser = "!@system";
|
||||
serviceConfig.Type = "oneshot";
|
||||
wantedBy = [ "default.target" ];
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
8
nixos/modules/system/activation/no-clone.nix
Normal file
8
nixos/modules/system/activation/no-clone.nix
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
{ lib, ... }:
|
||||
|
||||
with lib;
|
||||
|
||||
{
|
||||
boot.loader.grub.device = mkOverride 0 "nodev";
|
||||
specialisation = mkOverride 0 {};
|
||||
}
|
||||
932
nixos/modules/system/activation/switch-to-configuration.pl
Executable file
932
nixos/modules/system/activation/switch-to-configuration.pl
Executable file
|
|
@ -0,0 +1,932 @@
|
|||
#! @perl@/bin/perl
|
||||
|
||||
# Issue #166838 uncovered a situation in which a configuration not suitable
|
||||
# for the target architecture caused a cryptic error message instead of
|
||||
# a clean failure. Due to this mismatch, the perl interpreter in the shebang
|
||||
# line wasn't able to be executed, causing this script to be misinterpreted
|
||||
# as a shell script.
|
||||
#
|
||||
# Let's detect this situation to give a more meaningful error
|
||||
# message. The following two lines are carefully written to be both valid Perl
|
||||
# and Bash.
|
||||
printf "Perl script erroneously interpreted as shell script,\ndoes target platform match nixpkgs.crossSystem platform?\n" && exit 1
|
||||
if 0;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
use Config::IniFiles;
|
||||
use File::Path qw(make_path);
|
||||
use File::Basename;
|
||||
use File::Slurp qw(read_file write_file edit_file);
|
||||
use Net::DBus;
|
||||
use Sys::Syslog qw(:standard :macros);
|
||||
use Cwd qw(abs_path);
|
||||
|
||||
## no critic(ControlStructures::ProhibitDeepNests)
|
||||
## no critic(ErrorHandling::RequireCarping)
|
||||
## no critic(CodeLayout::ProhibitParensWithBuiltins)
|
||||
## no critic(Variables::ProhibitPunctuationVars, Variables::RequireLocalizedPunctuationVars)
|
||||
## no critic(InputOutput::RequireCheckedSyscalls, InputOutput::RequireBracedFileHandleWithPrint, InputOutput::RequireBriefOpen)
|
||||
## no critic(ValuesAndExpressions::ProhibitNoisyQuotes, ValuesAndExpressions::ProhibitMagicNumbers, ValuesAndExpressions::ProhibitEmptyQuotes, ValuesAndExpressions::ProhibitInterpolationOfLiterals)
|
||||
## no critic(RegularExpressions::ProhibitEscapedMetacharacters)
|
||||
|
||||
# System closure path to switch to
|
||||
my $out = "@out@";
|
||||
# Path to the directory containing systemd tools of the old system
|
||||
my $cur_systemd = abs_path("/run/current-system/sw/bin");
|
||||
# Path to the systemd store path of the new system
|
||||
my $new_systemd = "@systemd@";
|
||||
|
||||
# To be robust against interruption, record what units need to be started etc.
|
||||
# We read these files again every time this script starts to make sure we continue
|
||||
# where the old (interrupted) script left off.
|
||||
my $start_list_file = "/run/nixos/start-list";
|
||||
my $restart_list_file = "/run/nixos/restart-list";
|
||||
my $reload_list_file = "/run/nixos/reload-list";
|
||||
|
||||
# Parse restart/reload requests by the activation script.
|
||||
# Activation scripts may write newline-separated units to the restart
|
||||
# file and switch-to-configuration will handle them. While
|
||||
# `stopIfChanged = true` is ignored, switch-to-configuration will
|
||||
# handle `restartIfChanged = false` and `reloadIfChanged = true`.
|
||||
# This is the same as specifying a restart trigger in the NixOS module.
|
||||
#
|
||||
# The reload file asks the script to reload a unit. This is the same as
|
||||
# specifying a reload trigger in the NixOS module and can be ignored if
|
||||
# the unit is restarted in this activation.
|
||||
my $restart_by_activation_file = "/run/nixos/activation-restart-list";
|
||||
my $reload_by_activation_file = "/run/nixos/activation-reload-list";
|
||||
my $dry_restart_by_activation_file = "/run/nixos/dry-activation-restart-list";
|
||||
my $dry_reload_by_activation_file = "/run/nixos/dry-activation-reload-list";
|
||||
|
||||
# The action that is to be performed (like switch, boot, test, dry-activate)
|
||||
# Also exposed via environment variable from now on
|
||||
my $action = shift(@ARGV);
|
||||
$ENV{NIXOS_ACTION} = $action;
|
||||
|
||||
# Expose the locale archive as an environment variable for systemctl and the activation script
|
||||
if ("@localeArchive@" ne "") {
|
||||
$ENV{LOCALE_ARCHIVE} = "@localeArchive@";
|
||||
}
|
||||
|
||||
if (!defined($action) || ($action ne "switch" && $action ne "boot" && $action ne "test" && $action ne "dry-activate")) {
|
||||
print STDERR <<"EOF";
|
||||
Usage: $0 [switch|boot|test]
|
||||
|
||||
switch: make the configuration the boot default and activate now
|
||||
boot: make the configuration the boot default
|
||||
test: activate the configuration, but don\'t make it the boot default
|
||||
dry-activate: show what would be done if this configuration were activated
|
||||
EOF
|
||||
exit(1);
|
||||
}
|
||||
|
||||
# This is a NixOS installation if it has /etc/NIXOS or a proper
|
||||
# /etc/os-release.
|
||||
if (!-f "/etc/NIXOS" && (read_file("/etc/os-release", err_mode => "quiet") // "") !~ /^ID="?nixos"?/msx) {
|
||||
die("This is not a NixOS installation!\n");
|
||||
}
|
||||
|
||||
make_path("/run/nixos", { mode => oct(755) });
|
||||
openlog("nixos", "", LOG_USER);
|
||||
|
||||
# Install or update the bootloader.
|
||||
if ($action eq "switch" || $action eq "boot") {
|
||||
chomp(my $install_boot_loader = <<'EOFBOOTLOADER');
|
||||
@installBootLoader@
|
||||
EOFBOOTLOADER
|
||||
system("$install_boot_loader $out") == 0 or exit 1;
|
||||
}
|
||||
|
||||
# Just in case the new configuration hangs the system, do a sync now.
|
||||
if (($ENV{"NIXOS_NO_SYNC"} // "") ne "1") {
|
||||
system("@coreutils@/bin/sync", "-f", "/nix/store");
|
||||
}
|
||||
|
||||
if ($action eq "boot") {
|
||||
exit(0);
|
||||
}
|
||||
|
||||
# Check if we can activate the new configuration.
|
||||
my $cur_init_interface_version = read_file("/run/current-system/init-interface-version", err_mode => "quiet") // "";
|
||||
my $new_init_interface_version = read_file("$out/init-interface-version");
|
||||
|
||||
if ($new_init_interface_version ne $cur_init_interface_version) {
|
||||
print STDERR <<'EOF';
|
||||
Warning: the new NixOS configuration has an ‘init’ that is
|
||||
incompatible with the current configuration. The new configuration
|
||||
won't take effect until you reboot the system.
|
||||
EOF
|
||||
exit(100);
|
||||
}
|
||||
|
||||
# Ignore SIGHUP so that we're not killed if we're running on (say)
|
||||
# virtual console 1 and we restart the "tty1" unit.
|
||||
$SIG{PIPE} = "IGNORE";
|
||||
|
||||
# Asks the currently running systemd instance via dbus which units are active.
|
||||
# Returns a hash where the key is the name of each unit and the value a hash
|
||||
# of load, state, substate.
|
||||
sub get_active_units {
|
||||
my $mgr = Net::DBus->system->get_service("org.freedesktop.systemd1")->get_object("/org/freedesktop/systemd1");
|
||||
my $units = $mgr->ListUnitsByPatterns([], []);
|
||||
my $res = {};
|
||||
for my $item (@{$units}) {
|
||||
my ($id, $description, $load_state, $active_state, $sub_state,
|
||||
$following, $unit_path, $job_id, $job_type, $job_path) = @{$item};
|
||||
if ($following ne "") {
|
||||
next;
|
||||
}
|
||||
if ($job_id == 0 and $active_state eq "inactive") {
|
||||
next;
|
||||
}
|
||||
$res->{$id} = { load => $load_state, state => $active_state, substate => $sub_state };
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
|
||||
# Asks the currently running systemd instance whether a unit is currently active.
|
||||
# Takes the name of the unit as an argument and returns a bool whether the unit is active or not.
|
||||
sub unit_is_active {
|
||||
my ($unit_name) = @_;
|
||||
|
||||
my $mgr = Net::DBus->system->get_service("org.freedesktop.systemd1")->get_object("/org/freedesktop/systemd1");
|
||||
my $units = $mgr->ListUnitsByNames([$unit_name]);
|
||||
if (scalar(@{$units}) == 0) {
|
||||
return 0;
|
||||
}
|
||||
my $active_state = $units->[0]->[3];
|
||||
return $active_state eq "active" || $active_state eq "activating";
|
||||
}
|
||||
|
||||
# Parse a fstab file, given its path.
|
||||
# Returns a tuple of filesystems and swaps.
|
||||
#
|
||||
# Filesystems is a hash of mountpoint and { device, fsType, options }
|
||||
# Swaps is a hash of device and { options }
|
||||
sub parse_fstab {
|
||||
my ($filename) = @_;
|
||||
my ($fss, $swaps);
|
||||
foreach my $line (read_file($filename, err_mode => "quiet")) {
|
||||
chomp($line);
|
||||
$line =~ s/^\s*\#.*//msx;
|
||||
if ($line =~ /^\s*$/msx) {
|
||||
next;
|
||||
}
|
||||
my @xs = split(/\s+/msx, $line);
|
||||
if ($xs[2] eq "swap") {
|
||||
$swaps->{$xs[0]} = { options => $xs[3] // "" };
|
||||
} else {
|
||||
$fss->{$xs[1]} = { device => $xs[0], fsType => $xs[2], options => $xs[3] // "" };
|
||||
}
|
||||
}
|
||||
return ($fss, $swaps);
|
||||
}
|
||||
|
||||
# This subroutine takes a single ini file that specified systemd configuration
|
||||
# like unit configuration and parses it into a hash where the keys are the sections
|
||||
# of the unit file and the values are hashes themselves. These hashes have the unit file
|
||||
# keys as their keys (left side of =) and an array of all values that were set as their
|
||||
# values. If a value is empty (for example `ExecStart=`), then all current definitions are
|
||||
# removed.
|
||||
#
|
||||
# Instead of returning the hash, this subroutine takes a hashref to return the data in. This
|
||||
# allows calling the subroutine multiple times with the same hash to parse override files.
|
||||
sub parse_systemd_ini {
|
||||
my ($unit_contents, $path) = @_;
|
||||
# Tie the ini file to a hash for easier access
|
||||
tie(my %file_contents, "Config::IniFiles", (-file => $path, -allowempty => 1, -allowcontinue => 1)); ## no critic(Miscellanea::ProhibitTies)
|
||||
|
||||
# Copy over all sections
|
||||
foreach my $section_name (keys(%file_contents)) {
|
||||
if ($section_name eq "Install") {
|
||||
# Skip the [Install] section because it has no relevant keys for us
|
||||
next;
|
||||
}
|
||||
# Copy over all keys
|
||||
foreach my $ini_key (keys(%{$file_contents{$section_name}})) {
|
||||
# Ensure the value is an array so it's easier to work with
|
||||
my $ini_value = $file_contents{$section_name}{$ini_key};
|
||||
my @ini_values;
|
||||
if (ref($ini_value) eq "ARRAY") {
|
||||
@ini_values = @{$ini_value};
|
||||
} else {
|
||||
@ini_values = $ini_value;
|
||||
}
|
||||
# Go over all values
|
||||
for my $ini_value (@ini_values) {
|
||||
# If a value is empty, it's an override that tells us to clean the value
|
||||
if ($ini_value eq "") {
|
||||
delete $unit_contents->{$section_name}->{$ini_key};
|
||||
next;
|
||||
}
|
||||
push(@{$unit_contents->{$section_name}->{$ini_key}}, $ini_value);
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
# This subroutine takes the path to a systemd configuration file (like a unit configuration),
|
||||
# parses it, and returns a hash that contains the contents. The contents of this hash are
|
||||
# explained in the `parse_systemd_ini` subroutine. Neither the sections nor the keys inside
|
||||
# the sections are consistently sorted.
|
||||
#
|
||||
# If a directory with the same basename ending in .d exists next to the unit file, it will be
|
||||
# assumed to contain override files which will be parsed as well and handled properly.
|
||||
sub parse_unit {
|
||||
my ($unit_path) = @_;
|
||||
|
||||
# Parse the main unit and all overrides
|
||||
my %unit_data;
|
||||
# Replace \ with \\ so glob() still works with units that have a \ in them
|
||||
# Valid characters in unit names are ASCII letters, digits, ":", "-", "_", ".", and "\"
|
||||
$unit_path =~ s/\\/\\\\/gmsx;
|
||||
foreach (glob("${unit_path}{,.d/*.conf}")) {
|
||||
parse_systemd_ini(\%unit_data, "$_")
|
||||
}
|
||||
return %unit_data;
|
||||
}
|
||||
|
||||
# Checks whether a specified boolean in a systemd unit is true
|
||||
# or false, with a default that is applied when the value is not set.
|
||||
sub parse_systemd_bool {
|
||||
my ($unit_config, $section_name, $bool_name, $default) = @_;
|
||||
|
||||
my @values = @{$unit_config->{$section_name}{$bool_name} // []};
|
||||
# Return default if value is not set
|
||||
if ((scalar(@values) < 1) || (not defined($values[-1]))) {
|
||||
return $default;
|
||||
}
|
||||
# If value is defined multiple times, use the last definition
|
||||
my $last_value = $values[-1];
|
||||
# These are valid values as of systemd.syntax(7)
|
||||
return $last_value eq "1" || $last_value eq "yes" || $last_value eq "true" || $last_value eq "on";
|
||||
}
|
||||
|
||||
# Writes a unit name into a given file to be more resilient against
|
||||
# crashes of the script. Does nothing when the action is dry-activate.
|
||||
sub record_unit {
|
||||
my ($fn, $unit) = @_;
|
||||
if ($action ne "dry-activate") {
|
||||
write_file($fn, { append => 1 }, "$unit\n");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
# The opposite of record_unit, removes a unit name from a file
|
||||
sub unrecord_unit {
|
||||
my ($fn, $unit) = @_;
|
||||
if ($action ne "dry-activate") {
|
||||
edit_file(sub { s/^$unit\n//msx }, $fn);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
# Compare the contents of two unit files and return whether the unit
|
||||
# needs to be restarted or reloaded. If the units differ, the service
|
||||
# is restarted unless the only difference is `X-Reload-Triggers` in the
|
||||
# `Unit` section. If this is the only modification, the unit is reloaded
|
||||
# instead of restarted.
|
||||
# Returns:
|
||||
# - 0 if the units are equal
|
||||
# - 1 if the units are different and a restart action is required
|
||||
# - 2 if the units are different and a reload action is required
|
||||
sub compare_units { ## no critic(Subroutines::ProhibitExcessComplexity)
|
||||
my ($cur_unit, $new_unit) = @_;
|
||||
my $ret = 0;
|
||||
# Keys to ignore in the [Unit] section
|
||||
my %unit_section_ignores = map { $_ => 1 } qw(
|
||||
X-Reload-Triggers
|
||||
Description Documentation
|
||||
OnFailure OnSuccess OnFailureJobMode
|
||||
IgnoreOnIsolate StopWhenUnneeded
|
||||
RefuseManualStart RefuseManualStop
|
||||
AllowIsolate CollectMode
|
||||
SourcePath
|
||||
);
|
||||
|
||||
my $comp_array = sub {
|
||||
my ($a, $b) = @_;
|
||||
return join("\0", @{$a}) eq join("\0", @{$b});
|
||||
};
|
||||
|
||||
# Comparison hash for the sections
|
||||
my %section_cmp = map { $_ => 1 } keys(%{$new_unit});
|
||||
# Iterate over the sections
|
||||
foreach my $section_name (keys(%{$cur_unit})) {
|
||||
# Missing section in the new unit?
|
||||
if (not exists($section_cmp{$section_name})) {
|
||||
# If the [Unit] section was removed, make sure that only keys
|
||||
# were in it that are ignored
|
||||
if ($section_name eq "Unit") {
|
||||
foreach my $ini_key (keys(%{$cur_unit->{"Unit"}})) {
|
||||
if (not defined($unit_section_ignores{$ini_key})) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
next; # check the next section
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
if ($section_name eq "Unit" and %{$cur_unit->{"Unit"}} == 1 and defined(%{$cur_unit->{"Unit"}}{"X-Reload-Triggers"})) {
|
||||
# If a new [Unit] section was removed that only contained X-Reload-Triggers,
|
||||
# do nothing.
|
||||
next;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
delete $section_cmp{$section_name};
|
||||
# Comparison hash for the section contents
|
||||
my %ini_cmp = map { $_ => 1 } keys(%{$new_unit->{$section_name}});
|
||||
# Iterate over the keys of the section
|
||||
foreach my $ini_key (keys(%{$cur_unit->{$section_name}})) {
|
||||
delete $ini_cmp{$ini_key};
|
||||
my @cur_value = @{$cur_unit->{$section_name}{$ini_key}};
|
||||
# If the key is missing in the new unit, they are different...
|
||||
if (not $new_unit->{$section_name}{$ini_key}) {
|
||||
# ... unless the key that is now missing is one of the ignored keys
|
||||
if ($section_name eq "Unit" and defined($unit_section_ignores{$ini_key})) {
|
||||
next;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
my @new_value = @{$new_unit->{$section_name}{$ini_key}};
|
||||
# If the contents are different, the units are different
|
||||
if (not $comp_array->(\@cur_value, \@new_value)) {
|
||||
# Check if only the reload triggers changed or one of the ignored keys
|
||||
if ($section_name eq "Unit") {
|
||||
if ($ini_key eq "X-Reload-Triggers") {
|
||||
$ret = 2;
|
||||
next;
|
||||
} elsif (defined($unit_section_ignores{$ini_key})) {
|
||||
next;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
# A key was introduced that was missing in the previous unit
|
||||
if (%ini_cmp) {
|
||||
if ($section_name eq "Unit") {
|
||||
foreach my $ini_key (keys(%ini_cmp)) {
|
||||
if ($ini_key eq "X-Reload-Triggers") {
|
||||
$ret = 2;
|
||||
} elsif (defined($unit_section_ignores{$ini_key})) {
|
||||
next;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
}
|
||||
# A section was introduced that was missing in the previous unit
|
||||
if (%section_cmp) {
|
||||
if (%section_cmp == 1 and defined($section_cmp{"Unit"})) {
|
||||
foreach my $ini_key (keys(%{$new_unit->{"Unit"}})) {
|
||||
if (not defined($unit_section_ignores{$ini_key})) {
|
||||
return 1;
|
||||
} elsif ($ini_key eq "X-Reload-Triggers") {
|
||||
$ret = 2;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
# Called when a unit exists in both the old systemd and the new system and the units
|
||||
# differ. This figures out of what units are to be stopped, restarted, reloaded, started, and skipped.
|
||||
sub handle_modified_unit { ## no critic(Subroutines::ProhibitManyArgs, Subroutines::ProhibitExcessComplexity)
|
||||
my ($unit, $base_name, $new_unit_file, $new_unit_info, $active_cur, $units_to_stop, $units_to_start, $units_to_reload, $units_to_restart, $units_to_skip) = @_;
|
||||
|
||||
if ($unit eq "sysinit.target" || $unit eq "basic.target" || $unit eq "multi-user.target" || $unit eq "graphical.target" || $unit =~ /\.path$/msx || $unit =~ /\.slice$/msx) {
|
||||
# Do nothing. These cannot be restarted directly.
|
||||
|
||||
# Slices and Paths don't have to be restarted since
|
||||
# properties (resource limits and inotify watches)
|
||||
# seem to get applied on daemon-reload.
|
||||
} elsif ($unit =~ /\.mount$/msx) {
|
||||
# Reload the changed mount unit to force a remount.
|
||||
# FIXME: only reload when Options= changed, restart otherwise
|
||||
$units_to_reload->{$unit} = 1;
|
||||
record_unit($reload_list_file, $unit);
|
||||
} elsif ($unit =~ /\.socket$/msx) {
|
||||
# FIXME: do something?
|
||||
# Attempt to fix this: https://github.com/NixOS/nixpkgs/pull/141192
|
||||
# Revert of the attempt: https://github.com/NixOS/nixpkgs/pull/147609
|
||||
# More details: https://github.com/NixOS/nixpkgs/issues/74899#issuecomment-981142430
|
||||
} else {
|
||||
my %new_unit_info = $new_unit_info ? %{$new_unit_info} : parse_unit($new_unit_file);
|
||||
if (parse_systemd_bool(\%new_unit_info, "Service", "X-ReloadIfChanged", 0) and not $units_to_restart->{$unit} and not $units_to_stop->{$unit}) {
|
||||
$units_to_reload->{$unit} = 1;
|
||||
record_unit($reload_list_file, $unit);
|
||||
}
|
||||
elsif (!parse_systemd_bool(\%new_unit_info, "Service", "X-RestartIfChanged", 1) || parse_systemd_bool(\%new_unit_info, "Unit", "RefuseManualStop", 0) || parse_systemd_bool(\%new_unit_info, "Unit", "X-OnlyManualStart", 0)) {
|
||||
$units_to_skip->{$unit} = 1;
|
||||
} else {
|
||||
# It doesn't make sense to stop and start non-services because
|
||||
# they can't have ExecStop=
|
||||
if (!parse_systemd_bool(\%new_unit_info, "Service", "X-StopIfChanged", 1) || $unit !~ /\.service$/msx) {
|
||||
# This unit should be restarted instead of
|
||||
# stopped and started.
|
||||
$units_to_restart->{$unit} = 1;
|
||||
record_unit($restart_list_file, $unit);
|
||||
# Remove from units to reload so we don't restart and reload
|
||||
if ($units_to_reload->{$unit}) {
|
||||
delete $units_to_reload->{$unit};
|
||||
unrecord_unit($reload_list_file, $unit);
|
||||
}
|
||||
} else {
|
||||
# If this unit is socket-activated, then stop the
|
||||
# socket unit(s) as well, and restart the
|
||||
# socket(s) instead of the service.
|
||||
my $socket_activated = 0;
|
||||
if ($unit =~ /\.service$/msx) {
|
||||
my @sockets = split(/\s+/msx, join(" ", @{$new_unit_info{Service}{Sockets} // []}));
|
||||
if (scalar(@sockets) == 0) {
|
||||
@sockets = ("$base_name.socket");
|
||||
}
|
||||
foreach my $socket (@sockets) {
|
||||
if (defined($active_cur->{$socket})) {
|
||||
# We can now be sure this is a socket-activate unit
|
||||
|
||||
$units_to_stop->{$socket} = 1;
|
||||
# Only restart sockets that actually
|
||||
# exist in new configuration:
|
||||
if (-e "$out/etc/systemd/system/$socket") {
|
||||
$units_to_start->{$socket} = 1;
|
||||
if ($units_to_start eq $units_to_restart) {
|
||||
record_unit($restart_list_file, $socket);
|
||||
} else {
|
||||
record_unit($start_list_file, $socket);
|
||||
}
|
||||
$socket_activated = 1;
|
||||
}
|
||||
# Remove from units to reload so we don't restart and reload
|
||||
if ($units_to_reload->{$unit}) {
|
||||
delete $units_to_reload->{$unit};
|
||||
unrecord_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# If the unit is not socket-activated, record
|
||||
# that this unit needs to be started below.
|
||||
# We write this to a file to ensure that the
|
||||
# service gets restarted if we're interrupted.
|
||||
if (!$socket_activated) {
|
||||
$units_to_start->{$unit} = 1;
|
||||
if ($units_to_start eq $units_to_restart) {
|
||||
record_unit($restart_list_file, $unit);
|
||||
} else {
|
||||
record_unit($start_list_file, $unit);
|
||||
}
|
||||
}
|
||||
|
||||
$units_to_stop->{$unit} = 1;
|
||||
# Remove from units to reload so we don't restart and reload
|
||||
if ($units_to_reload->{$unit}) {
|
||||
delete $units_to_reload->{$unit};
|
||||
unrecord_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
# Figure out what units need to be stopped, started, restarted or reloaded.
|
||||
my (%units_to_stop, %units_to_skip, %units_to_start, %units_to_restart, %units_to_reload);
|
||||
|
||||
my %units_to_filter; # units not shown
|
||||
|
||||
%units_to_start = map { $_ => 1 }
|
||||
split(/\n/msx, read_file($start_list_file, err_mode => "quiet") // "");
|
||||
|
||||
%units_to_restart = map { $_ => 1 }
|
||||
split(/\n/msx, read_file($restart_list_file, err_mode => "quiet") // "");
|
||||
|
||||
%units_to_reload = map { $_ => 1 }
|
||||
split(/\n/msx, read_file($reload_list_file, err_mode => "quiet") // "");
|
||||
|
||||
my $active_cur = get_active_units();
|
||||
while (my ($unit, $state) = each(%{$active_cur})) {
|
||||
my $base_unit = $unit;
|
||||
|
||||
my $cur_unit_file = "/etc/systemd/system/$base_unit";
|
||||
my $new_unit_file = "$out/etc/systemd/system/$base_unit";
|
||||
|
||||
# Detect template instances.
|
||||
if (!-e $cur_unit_file && !-e $new_unit_file && $unit =~ /^(.*)@[^\.]*\.(.*)$/msx) {
|
||||
$base_unit = "$1\@.$2";
|
||||
$cur_unit_file = "/etc/systemd/system/$base_unit";
|
||||
$new_unit_file = "$out/etc/systemd/system/$base_unit";
|
||||
}
|
||||
|
||||
my $base_name = $base_unit;
|
||||
$base_name =~ s/\.[[:lower:]]*$//msx;
|
||||
|
||||
if (-e $cur_unit_file && ($state->{state} eq "active" || $state->{state} eq "activating")) {
|
||||
if (! -e $new_unit_file || abs_path($new_unit_file) eq "/dev/null") {
|
||||
my %cur_unit_info = parse_unit($cur_unit_file);
|
||||
if (parse_systemd_bool(\%cur_unit_info, "Unit", "X-StopOnRemoval", 1)) {
|
||||
$units_to_stop{$unit} = 1;
|
||||
}
|
||||
}
|
||||
|
||||
elsif ($unit =~ /\.target$/msx) {
|
||||
my %new_unit_info = parse_unit($new_unit_file);
|
||||
|
||||
# Cause all active target units to be restarted below.
|
||||
# This should start most changed units we stop here as
|
||||
# well as any new dependencies (including new mounts and
|
||||
# swap devices). FIXME: the suspend target is sometimes
|
||||
# active after the system has resumed, which probably
|
||||
# should not be the case. Just ignore it.
|
||||
if ($unit ne "suspend.target" && $unit ne "hibernate.target" && $unit ne "hybrid-sleep.target") {
|
||||
if (!(parse_systemd_bool(\%new_unit_info, "Unit", "RefuseManualStart", 0) || parse_systemd_bool(\%new_unit_info, "Unit", "X-OnlyManualStart", 0))) {
|
||||
$units_to_start{$unit} = 1;
|
||||
record_unit($start_list_file, $unit);
|
||||
# Don't spam the user with target units that always get started.
|
||||
$units_to_filter{$unit} = 1;
|
||||
}
|
||||
}
|
||||
|
||||
# Stop targets that have X-StopOnReconfiguration set.
|
||||
# This is necessary to respect dependency orderings
|
||||
# involving targets: if unit X starts after target Y and
|
||||
# target Y starts after unit Z, then if X and Z have both
|
||||
# changed, then X should be restarted after Z. However,
|
||||
# if target Y is in the "active" state, X and Z will be
|
||||
# restarted at the same time because X's dependency on Y
|
||||
# is already satisfied. Thus, we need to stop Y first.
|
||||
# Stopping a target generally has no effect on other units
|
||||
# (unless there is a PartOf dependency), so this is just a
|
||||
# bookkeeping thing to get systemd to do the right thing.
|
||||
if (parse_systemd_bool(\%new_unit_info, "Unit", "X-StopOnReconfiguration", 0)) {
|
||||
$units_to_stop{$unit} = 1;
|
||||
}
|
||||
}
|
||||
|
||||
else {
|
||||
my %cur_unit_info = parse_unit($cur_unit_file);
|
||||
my %new_unit_info = parse_unit($new_unit_file);
|
||||
my $diff = compare_units(\%cur_unit_info, \%new_unit_info);
|
||||
if ($diff == 1) {
|
||||
handle_modified_unit($unit, $base_name, $new_unit_file, \%new_unit_info, $active_cur, \%units_to_stop, \%units_to_start, \%units_to_reload, \%units_to_restart, \%units_to_skip);
|
||||
} elsif ($diff == 2 and not $units_to_restart{$unit}) {
|
||||
$units_to_reload{$unit} = 1;
|
||||
record_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# Converts a path to the name of a systemd mount unit that would be responsible
|
||||
# for mounting this path.
|
||||
sub path_to_unit_name {
|
||||
my ($path) = @_;
|
||||
# Use current version of systemctl binary before daemon is reexeced.
|
||||
open(my $cmd, "-|", "$cur_systemd/systemd-escape", "--suffix=mount", "-p", $path)
|
||||
or die "Unable to escape $path!\n";
|
||||
my $escaped = do { local $/ = undef; <$cmd> };
|
||||
chomp($escaped);
|
||||
close($cmd) or die("Unable to close systemd-escape pipe");
|
||||
return $escaped;
|
||||
}
|
||||
|
||||
# Compare the previous and new fstab to figure out which filesystems
|
||||
# need a remount or need to be unmounted. New filesystems are mounted
|
||||
# automatically by starting local-fs.target. FIXME: might be nicer if
|
||||
# we generated units for all mounts; then we could unify this with the
|
||||
# unit checking code above.
|
||||
my ($cur_fss, $cur_swaps) = parse_fstab("/etc/fstab");
|
||||
my ($new_fss, $new_swaps) = parse_fstab("$out/etc/fstab");
|
||||
foreach my $mount_point (keys(%{$cur_fss})) {
|
||||
my $cur = $cur_fss->{$mount_point};
|
||||
my $new = $new_fss->{$mount_point};
|
||||
my $unit = path_to_unit_name($mount_point);
|
||||
if (!defined($new)) {
|
||||
# Filesystem entry disappeared, so unmount it.
|
||||
$units_to_stop{$unit} = 1;
|
||||
} elsif ($cur->{fsType} ne $new->{fsType} || $cur->{device} ne $new->{device}) {
|
||||
# Filesystem type or device changed, so unmount and mount it.
|
||||
$units_to_stop{$unit} = 1;
|
||||
$units_to_start{$unit} = 1;
|
||||
record_unit($start_list_file, $unit);
|
||||
} elsif ($cur->{options} ne $new->{options}) {
|
||||
# Mount options changes, so remount it.
|
||||
$units_to_reload{$unit} = 1;
|
||||
record_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
|
||||
# Also handles swap devices.
|
||||
foreach my $device (keys(%{$cur_swaps})) {
|
||||
my $cur = $cur_swaps->{$device};
|
||||
my $new = $new_swaps->{$device};
|
||||
if (!defined($new)) {
|
||||
# Swap entry disappeared, so turn it off. Can't use
|
||||
# "systemctl stop" here because systemd has lots of alias
|
||||
# units that prevent a stop from actually calling
|
||||
# "swapoff".
|
||||
if ($action ne "dry-activate") {
|
||||
print STDERR "would stop swap device: $device\n";
|
||||
} else {
|
||||
print STDERR "stopping swap device: $device\n";
|
||||
system("@utillinux@/sbin/swapoff", $device);
|
||||
}
|
||||
}
|
||||
# FIXME: update swap options (i.e. its priority).
|
||||
}
|
||||
|
||||
|
||||
# Should we have systemd re-exec itself?
|
||||
my $cur_pid1_path = abs_path("/proc/1/exe") // "/unknown";
|
||||
my $cur_systemd_system_config = abs_path("/etc/systemd/system.conf") // "/unknown";
|
||||
my $new_pid1_path = abs_path("$new_systemd/lib/systemd/systemd") or die;
|
||||
my $new_systemd_system_config = abs_path("$out/etc/systemd/system.conf") // "/unknown";
|
||||
|
||||
my $restart_systemd = $cur_pid1_path ne $new_pid1_path;
|
||||
if ($cur_systemd_system_config ne $new_systemd_system_config) {
|
||||
$restart_systemd = 1;
|
||||
}
|
||||
|
||||
# Takes an array of unit names and returns an array with the same elements,
|
||||
# except all units that are also in the global variable `unitsToFilter`.
|
||||
sub filter_units {
|
||||
my ($units) = @_;
|
||||
my @res;
|
||||
foreach my $unit (sort(keys(%{$units}))) {
|
||||
if (!defined($units_to_filter{$unit})) {
|
||||
push(@res, $unit);
|
||||
}
|
||||
}
|
||||
return @res;
|
||||
}
|
||||
|
||||
my @units_to_stop_filtered = filter_units(\%units_to_stop);
|
||||
|
||||
|
||||
# Show dry-run actions.
|
||||
if ($action eq "dry-activate") {
|
||||
if (scalar(@units_to_stop_filtered) > 0) {
|
||||
print STDERR "would stop the following units: ", join(", ", @units_to_stop_filtered), "\n";
|
||||
}
|
||||
if (scalar(keys(%units_to_skip)) > 0) {
|
||||
print STDERR "would NOT stop the following changed units: ", join(", ", sort(keys(%units_to_skip))), "\n";
|
||||
}
|
||||
|
||||
print STDERR "would activate the configuration...\n";
|
||||
system("$out/dry-activate", "$out");
|
||||
|
||||
# Handle the activation script requesting the restart or reload of a unit.
|
||||
foreach (split(/\n/msx, read_file($dry_restart_by_activation_file, err_mode => "quiet") // "")) {
|
||||
my $unit = $_;
|
||||
my $base_unit = $unit;
|
||||
my $new_unit_file = "$out/etc/systemd/system/$base_unit";
|
||||
|
||||
# Detect template instances.
|
||||
if (!-e $new_unit_file && $unit =~ /^(.*)@[^\.]*\.(.*)$/msx) {
|
||||
$base_unit = "$1\@.$2";
|
||||
$new_unit_file = "$out/etc/systemd/system/$base_unit";
|
||||
}
|
||||
|
||||
my $base_name = $base_unit;
|
||||
$base_name =~ s/\.[[:lower:]]*$//msx;
|
||||
|
||||
# Start units if they were not active previously
|
||||
if (not defined($active_cur->{$unit})) {
|
||||
$units_to_start{$unit} = 1;
|
||||
next;
|
||||
}
|
||||
|
||||
handle_modified_unit($unit, $base_name, $new_unit_file, undef, $active_cur, \%units_to_restart, \%units_to_restart, \%units_to_reload, \%units_to_restart, \%units_to_skip);
|
||||
}
|
||||
unlink($dry_restart_by_activation_file);
|
||||
|
||||
foreach (split(/\n/msx, read_file($dry_reload_by_activation_file, err_mode => "quiet") // "")) {
|
||||
my $unit = $_;
|
||||
|
||||
if (defined($active_cur->{$unit}) and not $units_to_restart{$unit} and not $units_to_stop{$unit}) {
|
||||
$units_to_reload{$unit} = 1;
|
||||
record_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
unlink($dry_reload_by_activation_file);
|
||||
|
||||
if ($restart_systemd) {
|
||||
print STDERR "would restart systemd\n";
|
||||
}
|
||||
if (scalar(keys(%units_to_reload)) > 0) {
|
||||
print STDERR "would reload the following units: ", join(", ", sort(keys(%units_to_reload))), "\n";
|
||||
}
|
||||
if (scalar(keys(%units_to_restart)) > 0) {
|
||||
print STDERR "would restart the following units: ", join(", ", sort(keys(%units_to_restart))), "\n";
|
||||
}
|
||||
my @units_to_start_filtered = filter_units(\%units_to_start);
|
||||
if (scalar(@units_to_start_filtered)) {
|
||||
print STDERR "would start the following units: ", join(", ", @units_to_start_filtered), "\n";
|
||||
}
|
||||
exit 0;
|
||||
}
|
||||
|
||||
|
||||
syslog(LOG_NOTICE, "switching to system configuration $out");
|
||||
|
||||
if (scalar(keys(%units_to_stop)) > 0) {
|
||||
if (scalar(@units_to_stop_filtered)) {
|
||||
print STDERR "stopping the following units: ", join(", ", @units_to_stop_filtered), "\n";
|
||||
}
|
||||
# Use current version of systemctl binary before daemon is reexeced.
|
||||
system("$cur_systemd/systemctl", "stop", "--", sort(keys(%units_to_stop)));
|
||||
}
|
||||
|
||||
if (scalar(keys(%units_to_skip)) > 0) {
|
||||
print STDERR "NOT restarting the following changed units: ", join(", ", sort(keys(%units_to_skip))), "\n";
|
||||
}
|
||||
|
||||
# Activate the new configuration (i.e., update /etc, make accounts,
|
||||
# and so on).
|
||||
my $res = 0;
|
||||
print STDERR "activating the configuration...\n";
|
||||
system("$out/activate", "$out") == 0 or $res = 2;
|
||||
|
||||
# Handle the activation script requesting the restart or reload of a unit.
|
||||
foreach (split(/\n/msx, read_file($restart_by_activation_file, err_mode => "quiet") // "")) {
|
||||
my $unit = $_;
|
||||
my $base_unit = $unit;
|
||||
my $new_unit_file = "$out/etc/systemd/system/$base_unit";
|
||||
|
||||
# Detect template instances.
|
||||
if (!-e $new_unit_file && $unit =~ /^(.*)@[^\.]*\.(.*)$/msx) {
|
||||
$base_unit = "$1\@.$2";
|
||||
$new_unit_file = "$out/etc/systemd/system/$base_unit";
|
||||
}
|
||||
|
||||
my $base_name = $base_unit;
|
||||
$base_name =~ s/\.[[:lower:]]*$//msx;
|
||||
|
||||
# Start units if they were not active previously
|
||||
if (not defined($active_cur->{$unit})) {
|
||||
$units_to_start{$unit} = 1;
|
||||
record_unit($start_list_file, $unit);
|
||||
next;
|
||||
}
|
||||
|
||||
handle_modified_unit($unit, $base_name, $new_unit_file, undef, $active_cur, \%units_to_restart, \%units_to_restart, \%units_to_reload, \%units_to_restart, \%units_to_skip);
|
||||
}
|
||||
# We can remove the file now because it has been propagated to the other restart/reload files
|
||||
unlink($restart_by_activation_file);
|
||||
|
||||
foreach (split(/\n/msx, read_file($reload_by_activation_file, err_mode => "quiet") // "")) {
|
||||
my $unit = $_;
|
||||
|
||||
if (defined($active_cur->{$unit}) and not $units_to_restart{$unit} and not $units_to_stop{$unit}) {
|
||||
$units_to_reload{$unit} = 1;
|
||||
record_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
# We can remove the file now because it has been propagated to the other reload file
|
||||
unlink($reload_by_activation_file);
|
||||
|
||||
# Restart systemd if necessary. Note that this is done using the
|
||||
# current version of systemd, just in case the new one has trouble
|
||||
# communicating with the running pid 1.
|
||||
if ($restart_systemd) {
|
||||
print STDERR "restarting systemd...\n";
|
||||
system("$cur_systemd/systemctl", "daemon-reexec") == 0 or $res = 2;
|
||||
}
|
||||
|
||||
# Forget about previously failed services.
|
||||
system("$new_systemd/bin/systemctl", "reset-failed");
|
||||
|
||||
# Make systemd reload its units.
|
||||
system("$new_systemd/bin/systemctl", "daemon-reload") == 0 or $res = 3;
|
||||
|
||||
# Reload user units
|
||||
open(my $list_active_users, "-|", "$new_systemd/bin/loginctl", "list-users", "--no-legend") || die("Unable to call loginctl");
|
||||
while (my $f = <$list_active_users>) {
|
||||
if ($f !~ /^\s*(?<uid>\d+)\s+(?<user>\S+)/msx) {
|
||||
next;
|
||||
}
|
||||
my ($uid, $name) = ($+{uid}, $+{user});
|
||||
print STDERR "reloading user units for $name...\n";
|
||||
|
||||
system("@su@", "-s", "@shell@", "-l", $name, "-c",
|
||||
"export XDG_RUNTIME_DIR=/run/user/$uid; " .
|
||||
"$cur_systemd/systemctl --user daemon-reexec; " .
|
||||
"$new_systemd/bin/systemctl --user start nixos-activation.service");
|
||||
}
|
||||
|
||||
close($list_active_users) || die("Unable to close the file handle to loginctl");
|
||||
|
||||
# Set the new tmpfiles
|
||||
print STDERR "setting up tmpfiles\n";
|
||||
system("$new_systemd/bin/systemd-tmpfiles", "--create", "--remove", "--exclude-prefix=/dev") == 0 or $res = 3;
|
||||
|
||||
# Before reloading we need to ensure that the units are still active. They may have been
|
||||
# deactivated because one of their requirements got stopped. If they are inactive
|
||||
# but should have been reloaded, the user probably expects them to be started.
|
||||
if (scalar(keys(%units_to_reload)) > 0) {
|
||||
for my $unit (keys(%units_to_reload)) {
|
||||
if (!unit_is_active($unit)) {
|
||||
# Figure out if we need to start the unit
|
||||
my %unit_info = parse_unit("$out/etc/systemd/system/$unit");
|
||||
if (!(parse_systemd_bool(\%unit_info, "Unit", "RefuseManualStart", 0) || parse_systemd_bool(\%unit_info, "Unit", "X-OnlyManualStart", 0))) {
|
||||
$units_to_start{$unit} = 1;
|
||||
record_unit($start_list_file, $unit);
|
||||
}
|
||||
# Don't reload the unit, reloading would fail
|
||||
delete %units_to_reload{$unit};
|
||||
unrecord_unit($reload_list_file, $unit);
|
||||
}
|
||||
}
|
||||
}
|
||||
# Reload units that need it. This includes remounting changed mount
|
||||
# units.
|
||||
if (scalar(keys(%units_to_reload)) > 0) {
|
||||
print STDERR "reloading the following units: ", join(", ", sort(keys(%units_to_reload))), "\n";
|
||||
system("$new_systemd/bin/systemctl", "reload", "--", sort(keys(%units_to_reload))) == 0 or $res = 4;
|
||||
unlink($reload_list_file);
|
||||
}
|
||||
|
||||
# Restart changed services (those that have to be restarted rather
|
||||
# than stopped and started).
|
||||
if (scalar(keys(%units_to_restart)) > 0) {
|
||||
print STDERR "restarting the following units: ", join(", ", sort(keys(%units_to_restart))), "\n";
|
||||
system("$new_systemd/bin/systemctl", "restart", "--", sort(keys(%units_to_restart))) == 0 or $res = 4;
|
||||
unlink($restart_list_file);
|
||||
}
|
||||
|
||||
# Start all active targets, as well as changed units we stopped above.
|
||||
# The latter is necessary because some may not be dependencies of the
|
||||
# targets (i.e., they were manually started). FIXME: detect units
|
||||
# that are symlinks to other units. We shouldn't start both at the
|
||||
# same time because we'll get a "Failed to add path to set" error from
|
||||
# systemd.
|
||||
my @units_to_start_filtered = filter_units(\%units_to_start);
|
||||
if (scalar(@units_to_start_filtered)) {
|
||||
print STDERR "starting the following units: ", join(", ", @units_to_start_filtered), "\n"
|
||||
}
|
||||
system("$new_systemd/bin/systemctl", "start", "--", sort(keys(%units_to_start))) == 0 or $res = 4;
|
||||
unlink($start_list_file);
|
||||
|
||||
|
||||
# Print failed and new units.
|
||||
my (@failed, @new);
|
||||
my $active_new = get_active_units();
|
||||
while (my ($unit, $state) = each(%{$active_new})) {
|
||||
if ($state->{state} eq "failed") {
|
||||
push(@failed, $unit);
|
||||
next;
|
||||
}
|
||||
|
||||
if ($state->{substate} eq "auto-restart") {
|
||||
# A unit in auto-restart substate is a failure *if* it previously failed to start
|
||||
open(my $main_status_fd, "-|", "$new_systemd/bin/systemctl", "show", "--value", "--property=ExecMainStatus", $unit) || die("Unable to call 'systemctl show'");
|
||||
my $main_status = do { local $/ = undef; <$main_status_fd> };
|
||||
close($main_status_fd) || die("Unable to close 'systemctl show' fd");
|
||||
chomp($main_status);
|
||||
|
||||
if ($main_status ne "0") {
|
||||
push(@failed, $unit);
|
||||
next;
|
||||
}
|
||||
}
|
||||
|
||||
# Ignore scopes since they are not managed by this script but rather
|
||||
# created and managed by third-party services via the systemd dbus API.
|
||||
# This only lists units that are not failed (including ones that are in auto-restart but have not failed previously)
|
||||
if ($state->{state} ne "failed" && !defined($active_cur->{$unit}) && $unit !~ /\.scope$/msx) {
|
||||
push(@new, $unit);
|
||||
}
|
||||
}
|
||||
|
||||
if (scalar(@new) > 0) {
|
||||
print STDERR "the following new units were started: ", join(", ", sort(@new)), "\n"
|
||||
}
|
||||
|
||||
if (scalar(@failed) > 0) {
|
||||
my @failed_sorted = sort(@failed);
|
||||
print STDERR "warning: the following units failed: ", join(", ", @failed_sorted), "\n\n";
|
||||
system("$new_systemd/bin/systemctl status --no-pager --full '" . join("' '", @failed_sorted) . "' >&2");
|
||||
$res = 4;
|
||||
}
|
||||
|
||||
if ($res == 0) {
|
||||
syslog(LOG_NOTICE, "finished switching to system configuration $out");
|
||||
} else {
|
||||
syslog(LOG_ERR, "switching to system configuration $out failed (status $res)");
|
||||
}
|
||||
|
||||
exit($res);
|
||||
362
nixos/modules/system/activation/top-level.nix
Normal file
362
nixos/modules/system/activation/top-level.nix
Normal file
|
|
@ -0,0 +1,362 @@
|
|||
{ config, lib, pkgs, extendModules, noUserModules, ... }:
|
||||
|
||||
with lib;
|
||||
|
||||
let
|
||||
|
||||
|
||||
# This attribute is responsible for creating boot entries for
|
||||
# child configuration. They are only (directly) accessible
|
||||
# when the parent configuration is boot default. For example,
|
||||
# you can provide an easy way to boot the same configuration
|
||||
# as you use, but with another kernel
|
||||
# !!! fix this
|
||||
children =
|
||||
mapAttrs
|
||||
(childName: childConfig: childConfig.configuration.system.build.toplevel)
|
||||
config.specialisation;
|
||||
|
||||
systemBuilder =
|
||||
let
|
||||
kernelPath = "${config.boot.kernelPackages.kernel}/" +
|
||||
"${config.system.boot.loader.kernelFile}";
|
||||
initrdPath = "${config.system.build.initialRamdisk}/" +
|
||||
"${config.system.boot.loader.initrdFile}";
|
||||
in ''
|
||||
mkdir $out
|
||||
|
||||
# Containers don't have their own kernel or initrd. They boot
|
||||
# directly into stage 2.
|
||||
${optionalString (!config.boot.isContainer) ''
|
||||
if [ ! -f ${kernelPath} ]; then
|
||||
echo "The bootloader cannot find the proper kernel image."
|
||||
echo "(Expecting ${kernelPath})"
|
||||
false
|
||||
fi
|
||||
|
||||
ln -s ${kernelPath} $out/kernel
|
||||
ln -s ${config.system.modulesTree} $out/kernel-modules
|
||||
${optionalString (config.hardware.deviceTree.package != null) ''
|
||||
ln -s ${config.hardware.deviceTree.package} $out/dtbs
|
||||
''}
|
||||
|
||||
echo -n "$kernelParams" > $out/kernel-params
|
||||
|
||||
ln -s ${initrdPath} $out/initrd
|
||||
|
||||
ln -s ${config.system.build.initialRamdiskSecretAppender}/bin/append-initrd-secrets $out
|
||||
|
||||
ln -s ${config.hardware.firmware}/lib/firmware $out/firmware
|
||||
''}
|
||||
|
||||
echo "$activationScript" > $out/activate
|
||||
echo "$dryActivationScript" > $out/dry-activate
|
||||
substituteInPlace $out/activate --subst-var out
|
||||
substituteInPlace $out/dry-activate --subst-var out
|
||||
chmod u+x $out/activate $out/dry-activate
|
||||
unset activationScript dryActivationScript
|
||||
|
||||
${if config.boot.initrd.systemd.enable then ''
|
||||
cp ${config.system.build.bootStage2} $out/prepare-root
|
||||
substituteInPlace $out/prepare-root --subst-var-by systemConfig $out
|
||||
# This must not be a symlink or the abs_path of the grub builder for the tests
|
||||
# will resolve the symlink and we end up with a path that doesn't point to a
|
||||
# system closure.
|
||||
cp "$systemd/lib/systemd/systemd" $out/init
|
||||
'' else ''
|
||||
cp ${config.system.build.bootStage2} $out/init
|
||||
substituteInPlace $out/init --subst-var-by systemConfig $out
|
||||
''}
|
||||
|
||||
ln -s ${config.system.build.etc}/etc $out/etc
|
||||
ln -s ${config.system.path} $out/sw
|
||||
ln -s "$systemd" $out/systemd
|
||||
|
||||
echo -n "$configurationName" > $out/configuration-name
|
||||
echo -n "systemd ${toString config.systemd.package.interfaceVersion}" > $out/init-interface-version
|
||||
echo -n "$nixosLabel" > $out/nixos-version
|
||||
echo -n "${config.boot.kernelPackages.stdenv.hostPlatform.system}" > $out/system
|
||||
|
||||
mkdir $out/specialisation
|
||||
${concatStringsSep "\n"
|
||||
(mapAttrsToList (name: path: "ln -s ${path} $out/specialisation/${name}") children)}
|
||||
|
||||
mkdir $out/bin
|
||||
export localeArchive="${config.i18n.glibcLocales}/lib/locale/locale-archive"
|
||||
substituteAll ${./switch-to-configuration.pl} $out/bin/switch-to-configuration
|
||||
chmod +x $out/bin/switch-to-configuration
|
||||
${optionalString (pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform) ''
|
||||
if ! output=$($perl/bin/perl -c $out/bin/switch-to-configuration 2>&1); then
|
||||
echo "switch-to-configuration syntax is not valid:"
|
||||
echo "$output"
|
||||
exit 1
|
||||
fi
|
||||
''}
|
||||
|
||||
echo -n "${toString config.system.extraDependencies}" > $out/extra-dependencies
|
||||
|
||||
${config.system.extraSystemBuilderCmds}
|
||||
'';
|
||||
|
||||
# Putting it all together. This builds a store path containing
|
||||
# symlinks to the various parts of the built configuration (the
|
||||
# kernel, systemd units, init scripts, etc.) as well as a script
|
||||
# `switch-to-configuration' that activates the configuration and
|
||||
# makes it bootable.
|
||||
baseSystem = pkgs.stdenvNoCC.mkDerivation {
|
||||
name = "nixos-system-${config.system.name}-${config.system.nixos.label}";
|
||||
preferLocalBuild = true;
|
||||
allowSubstitutes = false;
|
||||
buildCommand = systemBuilder;
|
||||
|
||||
inherit (pkgs) coreutils;
|
||||
systemd = config.systemd.package;
|
||||
shell = "${pkgs.bash}/bin/sh";
|
||||
su = "${pkgs.shadow.su}/bin/su";
|
||||
utillinux = pkgs.util-linux;
|
||||
|
||||
kernelParams = config.boot.kernelParams;
|
||||
installBootLoader = config.system.build.installBootLoader;
|
||||
activationScript = config.system.activationScripts.script;
|
||||
dryActivationScript = config.system.dryActivationScript;
|
||||
nixosLabel = config.system.nixos.label;
|
||||
|
||||
configurationName = config.boot.loader.grub.configurationName;
|
||||
|
||||
# Needed by switch-to-configuration.
|
||||
perl = pkgs.perl.withPackages (p: with p; [ ConfigIniFiles FileSlurp NetDBus ]);
|
||||
};
|
||||
|
||||
# Handle assertions and warnings
|
||||
|
||||
failedAssertions = map (x: x.message) (filter (x: !x.assertion) config.assertions);
|
||||
|
||||
baseSystemAssertWarn = if failedAssertions != []
|
||||
then throw "\nFailed assertions:\n${concatStringsSep "\n" (map (x: "- ${x}") failedAssertions)}"
|
||||
else showWarnings config.warnings baseSystem;
|
||||
|
||||
# Replace runtime dependencies
|
||||
system = foldr ({ oldDependency, newDependency }: drv:
|
||||
pkgs.replaceDependency { inherit oldDependency newDependency drv; }
|
||||
) baseSystemAssertWarn config.system.replaceRuntimeDependencies;
|
||||
|
||||
/* Workaround until https://github.com/NixOS/nixpkgs/pull/156533
|
||||
Call can be replaced by argument when that's merged.
|
||||
*/
|
||||
tmpFixupSubmoduleBoundary = subopts:
|
||||
lib.mkOption {
|
||||
type = lib.types.submoduleWith {
|
||||
modules = [ { options = subopts; } ];
|
||||
};
|
||||
};
|
||||
|
||||
in
|
||||
|
||||
{
|
||||
imports = [
|
||||
../build.nix
|
||||
(mkRemovedOptionModule [ "nesting" "clone" ] "Use `specialisation.«name» = { inheritParentConfig = true; configuration = { ... }; }` instead.")
|
||||
(mkRemovedOptionModule [ "nesting" "children" ] "Use `specialisation.«name».configuration = { ... }` instead.")
|
||||
];
|
||||
|
||||
options = {
|
||||
|
||||
specialisation = mkOption {
|
||||
default = {};
|
||||
example = lib.literalExpression "{ fewJobsManyCores.configuration = { nix.settings = { core = 0; max-jobs = 1; }; }; }";
|
||||
description = ''
|
||||
Additional configurations to build. If
|
||||
<literal>inheritParentConfig</literal> is true, the system
|
||||
will be based on the overall system configuration.
|
||||
|
||||
To switch to a specialised configuration
|
||||
(e.g. <literal>fewJobsManyCores</literal>) at runtime, run:
|
||||
|
||||
<screen>
|
||||
<prompt># </prompt>sudo /run/current-system/specialisation/fewJobsManyCores/bin/switch-to-configuration test
|
||||
</screen>
|
||||
'';
|
||||
type = types.attrsOf (types.submodule (
|
||||
local@{ ... }: let
|
||||
extend = if local.config.inheritParentConfig
|
||||
then extendModules
|
||||
else noUserModules.extendModules;
|
||||
in {
|
||||
options.inheritParentConfig = mkOption {
|
||||
type = types.bool;
|
||||
default = true;
|
||||
description = "Include the entire system's configuration. Set to false to make a completely differently configured system.";
|
||||
};
|
||||
|
||||
options.configuration = mkOption {
|
||||
default = {};
|
||||
description = ''
|
||||
Arbitrary NixOS configuration.
|
||||
|
||||
Anything you can add to a normal NixOS configuration, you can add
|
||||
here, including imports and config values, although nested
|
||||
specialisations will be ignored.
|
||||
'';
|
||||
visible = "shallow";
|
||||
inherit (extend { modules = [ ./no-clone.nix ]; }) type;
|
||||
};
|
||||
})
|
||||
);
|
||||
};
|
||||
|
||||
system.boot.loader.id = mkOption {
|
||||
internal = true;
|
||||
default = "";
|
||||
description = ''
|
||||
Id string of the used bootloader.
|
||||
'';
|
||||
};
|
||||
|
||||
system.boot.loader.kernelFile = mkOption {
|
||||
internal = true;
|
||||
default = pkgs.stdenv.hostPlatform.linux-kernel.target;
|
||||
defaultText = literalExpression "pkgs.stdenv.hostPlatform.linux-kernel.target";
|
||||
type = types.str;
|
||||
description = ''
|
||||
Name of the kernel file to be passed to the bootloader.
|
||||
'';
|
||||
};
|
||||
|
||||
system.boot.loader.initrdFile = mkOption {
|
||||
internal = true;
|
||||
default = "initrd";
|
||||
type = types.str;
|
||||
description = ''
|
||||
Name of the initrd file to be passed to the bootloader.
|
||||
'';
|
||||
};
|
||||
|
||||
system.build = tmpFixupSubmoduleBoundary {
|
||||
installBootLoader = mkOption {
|
||||
internal = true;
|
||||
# "; true" => make the `$out` argument from switch-to-configuration.pl
|
||||
# go to `true` instead of `echo`, hiding the useless path
|
||||
# from the log.
|
||||
default = "echo 'Warning: do not know how to make this configuration bootable; please enable a boot loader.' 1>&2; true";
|
||||
description = ''
|
||||
A program that writes a bootloader installation script to the path passed in the first command line argument.
|
||||
|
||||
See <literal>nixos/modules/system/activation/switch-to-configuration.pl</literal>.
|
||||
'';
|
||||
type = types.unique {
|
||||
message = ''
|
||||
Only one bootloader can be enabled at a time. This requirement has not
|
||||
been checked until NixOS 22.05. Earlier versions defaulted to the last
|
||||
definition. Change your configuration to enable only one bootloader.
|
||||
'';
|
||||
} (types.either types.str types.package);
|
||||
};
|
||||
|
||||
toplevel = mkOption {
|
||||
type = types.package;
|
||||
readOnly = true;
|
||||
description = ''
|
||||
This option contains the store path that typically represents a NixOS system.
|
||||
|
||||
You can read this path in a custom deployment tool for example.
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
system.copySystemConfiguration = mkOption {
|
||||
type = types.bool;
|
||||
default = false;
|
||||
description = ''
|
||||
If enabled, copies the NixOS configuration file
|
||||
(usually <filename>/etc/nixos/configuration.nix</filename>)
|
||||
and links it from the resulting system
|
||||
(getting to <filename>/run/current-system/configuration.nix</filename>).
|
||||
Note that only this single file is copied, even if it imports others.
|
||||
'';
|
||||
};
|
||||
|
||||
system.extraSystemBuilderCmds = mkOption {
|
||||
type = types.lines;
|
||||
internal = true;
|
||||
default = "";
|
||||
description = ''
|
||||
This code will be added to the builder creating the system store path.
|
||||
'';
|
||||
};
|
||||
|
||||
system.extraDependencies = mkOption {
|
||||
type = types.listOf types.package;
|
||||
default = [];
|
||||
description = ''
|
||||
A list of packages that should be included in the system
|
||||
closure but not otherwise made available to users. This is
|
||||
primarily used by the installation tests.
|
||||
'';
|
||||
};
|
||||
|
||||
system.replaceRuntimeDependencies = mkOption {
|
||||
default = [];
|
||||
example = lib.literalExpression "[ ({ original = pkgs.openssl; replacement = pkgs.callPackage /path/to/openssl { }; }) ]";
|
||||
type = types.listOf (types.submodule (
|
||||
{ ... }: {
|
||||
options.original = mkOption {
|
||||
type = types.package;
|
||||
description = "The original package to override.";
|
||||
};
|
||||
|
||||
options.replacement = mkOption {
|
||||
type = types.package;
|
||||
description = "The replacement package.";
|
||||
};
|
||||
})
|
||||
);
|
||||
apply = map ({ original, replacement, ... }: {
|
||||
oldDependency = original;
|
||||
newDependency = replacement;
|
||||
});
|
||||
description = ''
|
||||
List of packages to override without doing a full rebuild.
|
||||
The original derivation and replacement derivation must have the same
|
||||
name length, and ideally should have close-to-identical directory layout.
|
||||
'';
|
||||
};
|
||||
|
||||
system.name = mkOption {
|
||||
type = types.str;
|
||||
default =
|
||||
if config.networking.hostName == ""
|
||||
then "unnamed"
|
||||
else config.networking.hostName;
|
||||
defaultText = literalExpression ''
|
||||
if config.networking.hostName == ""
|
||||
then "unnamed"
|
||||
else config.networking.hostName;
|
||||
'';
|
||||
description = ''
|
||||
The name of the system used in the <option>system.build.toplevel</option> derivation.
|
||||
</para><para>
|
||||
That derivation has the following name:
|
||||
<literal>"nixos-system-''${config.system.name}-''${config.system.nixos.label}"</literal>
|
||||
'';
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
|
||||
config = {
|
||||
|
||||
system.extraSystemBuilderCmds =
|
||||
optionalString
|
||||
config.system.copySystemConfiguration
|
||||
''ln -s '${import ../../../lib/from-env.nix "NIXOS_CONFIG" <nixos-config>}' \
|
||||
"$out/configuration.nix"
|
||||
'';
|
||||
|
||||
system.build.toplevel = system;
|
||||
|
||||
};
|
||||
|
||||
# uses extendModules to generate a type
|
||||
meta.buildDocsInSandbox = false;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue