diff --git a/nixos/modules/system/activation/switch-to-configuration.pl b/nixos/modules/system/activation/switch-to-configuration.pl index aeeb60dcd681..5532cfe6afe2 100755 --- a/nixos/modules/system/activation/switch-to-configuration.pl +++ b/nixos/modules/system/activation/switch-to-configuration.pl @@ -1,7 +1,7 @@ #! @perl@/bin/perl ## no critic(CodeLayout::ProhibitParensWithBuiltins) -## no critic(ValuesAndExpressions::ProhibitInterpolationOfLiterals) +## no critic(ValuesAndExpressions::ProhibitInterpolationOfLiterals, Variables::ProhibitPunctuationVars) use strict; use warnings; @@ -13,14 +13,19 @@ use Net::DBus; use Sys::Syslog qw(:standard :macros); use Cwd "abs_path"; +# System closure path to switch to my $out = "@out@"; - -my $curSystemd = abs_path("/run/current-system/sw/bin"); +# 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. -my $startListFile = "/run/nixos/start-list"; -my $restartListFile = "/run/nixos/restart-list"; -my $reloadListFile = "/run/nixos/reload-list"; +# 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 @@ -32,15 +37,17 @@ my $reloadListFile = "/run/nixos/reload-list"; # 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 $restartByActivationFile = "/run/nixos/activation-restart-list"; -my $reloadByActivationFile = "/run/nixos/activation-reload-list"; -my $dryRestartByActivationFile = "/run/nixos/dry-activation-restart-list"; -my $dryReloadByActivationFile = "/run/nixos/dry-activation-reload-list"; - -make_path("/run/nixos", { mode => oct(755) }); +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@"; } @@ -57,22 +64,21 @@ EOF exit(1); } -$ENV{NIXOS_ACTION} = $action; - # 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"?/s) { 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 $installBootLoader = <<'EOFBOOTLOADER'); + chomp(my $install_boot_loader = <<'EOFBOOTLOADER'); @installBootLoader@ EOFBOOTLOADER - system("$installBootLoader $out") == 0 or exit 1; + system("$install_boot_loader $out") == 0 or exit 1; } # Just in case the new configuration hangs the system, do a sync now. @@ -85,10 +91,10 @@ if ($action eq "boot") { } # Check if we can activate the new configuration. -my $oldVersion = read_file("/run/current-system/init-interface-version", err_mode => "quiet") // ""; -my $newVersion = read_file("$out/init-interface-version"); +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 ($newVersion ne $oldVersion) { +if ($new_init_interface_version ne $cur_init_interface_version) { print STDERR < $path, -allowempty => 1, -allowcontinue => 1)); ## no critic(Miscellanea::ProhibitTies) + tie(my %file_contents, "Config::IniFiles", (-file => $path, -allowempty => 1, -allowcontinue => 1)); ## no critic(Miscellanea::ProhibitTies) # Copy over all sections - foreach my $sectionName (keys(%fileContents)) { - if ($sectionName eq "Install") { + 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 $iniKey (keys(%{$fileContents{$sectionName}})) { + foreach my $ini_key (keys(%{$file_contents{$section_name}})) { # Ensure the value is an array so it's easier to work with - my $iniValue = $fileContents{$sectionName}{$iniKey}; - my @iniValues; - if (ref($iniValue) eq "ARRAY") { - @iniValues = @{$iniValue}; + my $ini_value = $file_contents{$section_name}{$ini_key}; + my @ini_values; + if (ref($ini_value) eq "ARRAY") { + @ini_values = @{$ini_value}; } else { - @iniValues = $iniValue; + @ini_values = $ini_value; } # Go over all values - for my $iniValue (@iniValues) { + for my $ini_value (@ini_values) { # If a value is empty, it's an override that tells us to clean the value - if ($iniValue eq "") { - delete $unitContents->{$sectionName}->{$iniKey}; + if ($ini_value eq "") { + delete $unit_contents->{$section_name}->{$ini_key}; next; } - push(@{$unitContents->{$sectionName}->{$iniKey}}, $iniValue); + push(@{$unit_contents->{$section_name}->{$ini_key}}, $ini_value); } } } @@ -228,17 +234,17 @@ sub parse_unit { # 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 ($unitConfig, $sectionName, $boolName, $default) = @_; + my ($unit_config, $section_name, $bool_name, $default) = @_; - my @values = @{$unitConfig->{$sectionName}{$boolName} // []}; + my @values = @{$unit_config->{$section_name}{$bool_name} // []}; # Return default if value is not set if (scalar(@values) lt 1 || not defined($values[-1])) { return $default; } # If value is defined multiple times, use the last definition - my $last = $values[-1]; + my $last_value = $values[-1]; # These are valid values as of systemd.syntax(7) - return $last eq "1" || $last eq "yes" || $last eq "true" || $last eq "on"; + 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 @@ -268,7 +274,7 @@ sub unrecord_unit { # - 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 { - my ($old_unit, $new_unit) = @_; + my ($cur_unit, $new_unit) = @_; my $ret = 0; # Keys to ignore in the [Unit] section my %unit_section_ignores = map { $_ => 1 } qw( @@ -289,13 +295,13 @@ sub compare_units { # Comparison hash for the sections my %section_cmp = map { $_ => 1 } keys(%{$new_unit}); # Iterate over the sections - foreach my $section_name (keys(%{$old_unit})) { + 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(%{$old_unit->{"Unit"}})) { + foreach my $ini_key (keys(%{$cur_unit->{"Unit"}})) { if (not defined($unit_section_ignores{$ini_key})) { return 1; } @@ -304,7 +310,7 @@ sub compare_units { } else { return 1; } - if ($section_name eq "Unit" and %{$old_unit->{"Unit"}} == 1 and defined(%{$old_unit->{"Unit"}}{"X-Reload-Triggers"})) { + 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; @@ -316,9 +322,9 @@ sub compare_units { # 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(%{$old_unit->{$section_name}})) { + foreach my $ini_key (keys(%{$cur_unit->{$section_name}})) { delete $ini_cmp{$ini_key}; - my @old_value = @{$old_unit->{$section_name}{$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 @@ -329,7 +335,7 @@ sub compare_units { } my @new_value = @{$new_unit->{$section_name}{$ini_key}}; # If the contents are different, the units are different - if (not $comp_array->(\@old_value, \@new_value)) { + 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") { @@ -342,7 +348,7 @@ sub compare_units { return 1; } } - # A key was introduced that was missing in the old unit + # A key was introduced that was missing in the previos unit if (%ini_cmp) { if ($section_name eq "Unit") { foreach my $ini_key (keys(%ini_cmp)) { @@ -359,7 +365,7 @@ sub compare_units { } }; } - # A section was introduced that was missing in the old unit + # A section was introduced that was missing in the previos unit if (%section_cmp) { if (%section_cmp == 1 and defined($section_cmp{"Unit"})) { foreach my $ini_key (keys(%{$new_unit->{"Unit"}})) { @@ -380,7 +386,7 @@ sub compare_units { # 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 { - my ($unit, $baseName, $newUnitFile, $newUnitInfo, $activePrev, $unitsToStop, $unitsToStart, $unitsToReload, $unitsToRestart, $unitsToSkip) = @_; + 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$/ || $unit =~ /\.slice$/) { # Do nothing. These cannot be restarted directly. @@ -391,33 +397,33 @@ sub handle_modified_unit { } elsif ($unit =~ /\.mount$/) { # Reload the changed mount unit to force a remount. # FIXME: only reload when Options= changed, restart otherwise - $unitsToReload->{$unit} = 1; - record_unit($reloadListFile, $unit); + $units_to_reload->{$unit} = 1; + record_unit($reload_list_file, $unit); } elsif ($unit =~ /\.socket$/) { # 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 %unitInfo = $newUnitInfo ? %{$newUnitInfo} : parse_unit($newUnitFile); - if (parse_systemd_bool(\%unitInfo, "Service", "X-ReloadIfChanged", 0) and not $unitsToRestart->{$unit} and not $unitsToStop->{$unit}) { - $unitsToReload->{$unit} = 1; - record_unit($reloadListFile, $unit); + 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(\%unitInfo, "Service", "X-RestartIfChanged", 1) || parse_systemd_bool(\%unitInfo, "Unit", "RefuseManualStop", 0) || parse_systemd_bool(\%unitInfo, "Unit", "X-OnlyManualStart", 0)) { - $unitsToSkip->{$unit} = 1; + 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(\%unitInfo, "Service", "X-StopIfChanged", 1) || $unit !~ /\.service$/) { + if (!parse_systemd_bool(\%new_unit_info, "Service", "X-StopIfChanged", 1) || $unit !~ /\.service$/) { # This unit should be restarted instead of # stopped and started. - $unitsToRestart->{$unit} = 1; - record_unit($restartListFile, $unit); + $units_to_restart->{$unit} = 1; + record_unit($restart_list_file, $unit); # Remove from units to reload so we don't restart and reload - if ($unitsToReload->{$unit}) { - delete $unitsToReload->{$unit}; - unrecord_unit($reloadListFile, $unit); + 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 @@ -425,30 +431,30 @@ sub handle_modified_unit { # socket(s) instead of the service. my $socket_activated = 0; if ($unit =~ /\.service$/) { - my @sockets = split(/ /, join(" ", @{$unitInfo{Service}{Sockets} // []})); + my @sockets = split(/ /, join(" ", @{$new_unit_info{Service}{Sockets} // []})); if (scalar(@sockets) == 0) { - @sockets = ("$baseName.socket"); + @sockets = ("$base_name.socket"); } foreach my $socket (@sockets) { - if (defined($activePrev->{$socket})) { + if (defined($active_cur->{$socket})) { # We can now be sure this is a socket-activate unit - $unitsToStop->{$socket} = 1; + $units_to_stop->{$socket} = 1; # Only restart sockets that actually # exist in new configuration: if (-e "$out/etc/systemd/system/$socket") { - $unitsToStart->{$socket} = 1; - if ($unitsToStart eq $unitsToRestart) { - record_unit($restartListFile, $socket); + $units_to_start->{$socket} = 1; + if ($units_to_start eq $units_to_restart) { + record_unit($restart_list_file, $socket); } else { - record_unit($startListFile, $socket); + record_unit($start_list_file, $socket); } $socket_activated = 1; } # Remove from units to reload so we don't restart and reload - if ($unitsToReload->{$unit}) { - delete $unitsToReload->{$unit}; - unrecord_unit($reloadListFile, $unit); + if ($units_to_reload->{$unit}) { + delete $units_to_reload->{$unit}; + unrecord_unit($reload_list_file, $unit); } } } @@ -459,19 +465,19 @@ sub handle_modified_unit { # We write this to a file to ensure that the # service gets restarted if we're interrupted. if (!$socket_activated) { - $unitsToStart->{$unit} = 1; - if ($unitsToStart eq $unitsToRestart) { - record_unit($restartListFile, $unit); + $units_to_start->{$unit} = 1; + if ($units_to_start eq $units_to_restart) { + record_unit($restart_list_file, $unit); } else { - record_unit($startListFile, $unit); + record_unit($start_list_file, $unit); } } - $unitsToStop->{$unit} = 1; + $units_to_stop->{$unit} = 1; # Remove from units to reload so we don't restart and reload - if ($unitsToReload->{$unit}) { - delete $unitsToReload->{$unit}; - unrecord_unit($reloadListFile, $unit); + if ($units_to_reload->{$unit}) { + delete $units_to_reload->{$unit}; + unrecord_unit($reload_list_file, $unit); } } } @@ -479,46 +485,46 @@ sub handle_modified_unit { } # Figure out what units need to be stopped, started, restarted or reloaded. -my (%unitsToStop, %unitsToSkip, %unitsToStart, %unitsToRestart, %unitsToReload); +my (%units_to_stop, %units_to_skip, %units_to_start, %units_to_restart, %units_to_reload); -my %unitsToFilter; # units not shown +my %units_to_filter; # units not shown -%unitsToStart = map { $_ => 1 } - split("\n", read_file($startListFile, err_mode => "quiet") // ""); +%units_to_start = map { $_ => 1 } + split("\n", read_file($start_list_file, err_mode => "quiet") // ""); -%unitsToRestart = map { $_ => 1 } - split("\n", read_file($restartListFile, err_mode => "quiet") // ""); +%units_to_restart = map { $_ => 1 } + split("\n", read_file($restart_list_file, err_mode => "quiet") // ""); -%unitsToReload = map { $_ => 1 } - split("\n", read_file($reloadListFile, err_mode => "quiet") // ""); +%units_to_reload = map { $_ => 1 } + split("\n", read_file($reload_list_file, err_mode => "quiet") // ""); -my $activePrev = get_active_units(); -while (my ($unit, $state) = each(%{$activePrev})) { - my $baseUnit = $unit; +my $active_cur = get_active_units(); +while (my ($unit, $state) = each(%{$active_cur})) { + my $base_unit = $unit; - my $prevUnitFile = "/etc/systemd/system/$baseUnit"; - my $newUnitFile = "$out/etc/systemd/system/$baseUnit"; + my $cur_unit_file = "/etc/systemd/system/$base_unit"; + my $new_unit_file = "$out/etc/systemd/system/$base_unit"; # Detect template instances. - if (!-e $prevUnitFile && !-e $newUnitFile && $unit =~ /^(.*)@[^\.]*\.(.*)$/) { - $baseUnit = "$1\@.$2"; - $prevUnitFile = "/etc/systemd/system/$baseUnit"; - $newUnitFile = "$out/etc/systemd/system/$baseUnit"; + if (!-e $cur_unit_file && !-e $new_unit_file && $unit =~ /^(.*)@[^\.]*\.(.*)$/) { + $base_unit = "$1\@.$2"; + $cur_unit_file = "/etc/systemd/system/$base_unit"; + $new_unit_file = "$out/etc/systemd/system/$base_unit"; } - my $baseName = $baseUnit; - $baseName =~ s/\.[a-z]*$//; + my $base_name = $base_unit; + $base_name =~ s/\.[a-z]*$//; - if (-e $prevUnitFile && ($state->{state} eq "active" || $state->{state} eq "activating")) { - if (! -e $newUnitFile || abs_path($newUnitFile) eq "/dev/null") { - my %unitInfo = parse_unit($prevUnitFile); - if (parse_systemd_bool(\%unitInfo, "Unit", "X-StopOnRemoval", 1)) { - $unitsToStop{$unit} = 1; + 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$/) { - my %unitInfo = parse_unit($newUnitFile); + 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 @@ -527,11 +533,11 @@ while (my ($unit, $state) = each(%{$activePrev})) { # 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(\%unitInfo, "Unit", "RefuseManualStart", 0) || parse_systemd_bool(\%unitInfo, "Unit", "X-OnlyManualStart", 0))) { - $unitsToStart{$unit} = 1; - record_unit($startListFile, $unit); + 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. - $unitsToFilter{$unit} = 1; + $units_to_filter{$unit} = 1; } } @@ -546,20 +552,20 @@ while (my ($unit, $state) = each(%{$activePrev})) { # 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(\%unitInfo, "Unit", "X-StopOnReconfiguration", 0)) { - $unitsToStop{$unit} = 1; + if (parse_systemd_bool(\%new_unit_info, "Unit", "X-StopOnReconfiguration", 0)) { + $units_to_stop{$unit} = 1; } } else { - my %old_unit_info = parse_unit($prevUnitFile); - my %new_unit_info = parse_unit($newUnitFile); - my $diff = compare_units(\%old_unit_info, \%new_unit_info); + 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, $baseName, $newUnitFile, \%new_unit_info, $activePrev, \%unitsToStop, \%unitsToStart, \%unitsToReload, \%unitsToRestart, \%unitsToSkip); - } elsif ($diff == 2 and not $unitsToRestart{$unit}) { - $unitsToReload{$unit} = 1; - record_unit($reloadListFile, $unit); + 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); } } } @@ -570,7 +576,7 @@ while (my ($unit, $state) = each(%{$activePrev})) { sub path_to_unit_name { my ($path) = @_; # Use current version of systemctl binary before daemon is reexeced. - open(my $cmd, "-|", "$curSystemd/systemd-escape", "--suffix=mount", "-p", $path) + open(my $cmd, "-|", "$cur_systemd/systemd-escape", "--suffix=mount", "-p", $path) or die "Unable to escape $path!\n"; my $escaped = join("", <$cmd>); chomp($escaped); @@ -583,31 +589,31 @@ sub path_to_unit_name { # 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 ($prevFss, $prevSwaps) = parse_fstab("/etc/fstab"); -my ($newFss, $newSwaps) = parse_fstab("$out/etc/fstab"); -foreach my $mountPoint (keys(%$prevFss)) { - my $prev = $prevFss->{$mountPoint}; - my $new = $newFss->{$mountPoint}; - my $unit = path_to_unit_name($mountPoint); +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. - $unitsToStop{$unit} = 1; - } elsif ($prev->{fsType} ne $new->{fsType} || $prev->{device} ne $new->{device}) { + $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. - $unitsToStop{$unit} = 1; - $unitsToStart{$unit} = 1; - record_unit($startListFile, $unit); - } elsif ($prev->{options} ne $new->{options}) { + $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. - $unitsToReload{$unit} = 1; - record_unit($reloadListFile, $unit); + $units_to_reload{$unit} = 1; + record_unit($reload_list_file, $unit); } } # Also handles swap devices. -foreach my $device (keys(%$prevSwaps)) { - my $prev = $prevSwaps->{$device}; - my $new = $newSwaps->{$device}; +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 @@ -625,14 +631,14 @@ foreach my $device (keys(%$prevSwaps)) { # Should we have systemd re-exec itself? -my $prevSystemd = abs_path("/proc/1/exe") // "/unknown"; -my $prevSystemdSystemConfig = abs_path("/etc/systemd/system.conf") // "/unknown"; -my $newSystemd = abs_path("@systemd@/lib/systemd/systemd") or die; -my $newSystemdSystemConfig = abs_path("$out/etc/systemd/system.conf") // "/unknown"; +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 $restartSystemd = $prevSystemd ne $newSystemd; -if ($prevSystemdSystemConfig ne $newSystemdSystemConfig) { - $restartSystemd = 1; +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, @@ -641,75 +647,75 @@ sub filter_units { my ($units) = @_; my @res; foreach my $unit (sort(keys(%{$units}))) { - if (!defined($unitsToFilter{$unit})) { + if (!defined($units_to_filter{$unit})) { push(@res, $unit); } } return @res; } -my @unitsToStopFiltered = filter_units(\%unitsToStop); +my @units_to_stop_filtered = filter_units(\%units_to_stop); # Show dry-run actions. if ($action eq "dry-activate") { - if (scalar(@unitsToStopFiltered) > 0) { - print STDERR "would stop the following units: ", join(", ", @unitsToStopFiltered), "\n"; + if (scalar(@units_to_stop_filtered) > 0) { + print STDERR "would stop the following units: ", join(", ", @units_to_stop_filtered), "\n"; } - if (scalar(keys(%unitsToSkip)) > 0) { - print STDERR "would NOT stop the following changed units: ", join(", ", sort(keys(%unitsToSkip))), "\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", read_file($dryRestartByActivationFile, err_mode => "quiet") // "")) { + foreach (split("\n", read_file($dry_restart_by_activation_file, err_mode => "quiet") // "")) { my $unit = $_; - my $baseUnit = $unit; - my $newUnitFile = "$out/etc/systemd/system/$baseUnit"; + my $base_unit = $unit; + my $new_unit_file = "$out/etc/systemd/system/$base_unit"; # Detect template instances. - if (!-e $newUnitFile && $unit =~ /^(.*)@[^\.]*\.(.*)$/) { - $baseUnit = "$1\@.$2"; - $newUnitFile = "$out/etc/systemd/system/$baseUnit"; + if (!-e $new_unit_file && $unit =~ /^(.*)@[^\.]*\.(.*)$/) { + $base_unit = "$1\@.$2"; + $new_unit_file = "$out/etc/systemd/system/$base_unit"; } - my $baseName = $baseUnit; - $baseName =~ s/\.[a-z]*$//; + my $base_name = $base_unit; + $base_name =~ s/\.[a-z]*$//; # Start units if they were not active previously - if (not defined($activePrev->{$unit})) { - $unitsToStart{$unit} = 1; + if (not defined($active_cur->{$unit})) { + $units_to_start{$unit} = 1; next; } - handle_modified_unit($unit, $baseName, $newUnitFile, undef, $activePrev, \%unitsToRestart, \%unitsToRestart, \%unitsToReload, \%unitsToRestart, \%unitsToSkip); + 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($dryRestartByActivationFile); + unlink($dry_restart_by_activation_file); - foreach (split("\n", read_file($dryReloadByActivationFile, err_mode => "quiet") // "")) { + foreach (split("\n", read_file($dry_reload_by_activation_file, err_mode => "quiet") // "")) { my $unit = $_; - if (defined($activePrev->{$unit}) and not $unitsToRestart{$unit} and not $unitsToStop{$unit}) { - $unitsToReload{$unit} = 1; - record_unit($reloadListFile, $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($dryReloadByActivationFile); + unlink($dry_reload_by_activation_file); - if ($restartSystemd) { + if ($restart_systemd) { print STDERR "would restart systemd\n"; } - if (scalar(keys(%unitsToReload)) > 0) { - print STDERR "would reload the following units: ", join(", ", sort(keys(%unitsToReload))), "\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(%unitsToRestart)) > 0) { - print STDERR "would restart the following units: ", join(", ", sort(keys(%unitsToRestart))), "\n"; + if (scalar(keys(%units_to_restart)) > 0) { + print STDERR "would restart the following units: ", join(", ", sort(keys(%units_to_restart))), "\n"; } - my @unitsToStartFiltered = filter_units(\%unitsToStart); - if (scalar(@unitsToStartFiltered)) { - print STDERR "would start the following units: ", join(", ", @unitsToStartFiltered), "\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; } @@ -717,16 +723,16 @@ if ($action eq "dry-activate") { syslog(LOG_NOTICE, "switching to system configuration $out"); -if (scalar(keys(%unitsToStop)) > 0) { - if (scalar(@unitsToStopFiltered)) { - print STDERR "stopping the following units: ", join(", ", @unitsToStopFiltered), "\n"; +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("$curSystemd/systemctl", "stop", "--", sort(keys(%unitsToStop))); + system("$cur_systemd/systemctl", "stop", "--", sort(keys(%units_to_stop))); } -if (scalar(keys(%unitsToSkip)) > 0) { - print STDERR "NOT restarting the following changed units: ", join(", ", sort(keys(%unitsToSkip))), "\n"; +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, @@ -736,60 +742,60 @@ 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", read_file($restartByActivationFile, err_mode => "quiet") // "")) { +foreach (split("\n", read_file($restart_by_activation_file, err_mode => "quiet") // "")) { my $unit = $_; - my $baseUnit = $unit; - my $newUnitFile = "$out/etc/systemd/system/$baseUnit"; + my $base_unit = $unit; + my $new_unit_file = "$out/etc/systemd/system/$base_unit"; # Detect template instances. - if (!-e $newUnitFile && $unit =~ /^(.*)@[^\.]*\.(.*)$/) { - $baseUnit = "$1\@.$2"; - $newUnitFile = "$out/etc/systemd/system/$baseUnit"; + if (!-e $new_unit_file && $unit =~ /^(.*)@[^\.]*\.(.*)$/) { + $base_unit = "$1\@.$2"; + $new_unit_file = "$out/etc/systemd/system/$base_unit"; } - my $baseName = $baseUnit; - $baseName =~ s/\.[a-z]*$//; + my $base_name = $base_unit; + $base_name =~ s/\.[a-z]*$//; # Start units if they were not active previously - if (not defined($activePrev->{$unit})) { - $unitsToStart{$unit} = 1; - record_unit($startListFile, $unit); + if (not defined($active_cur->{$unit})) { + $units_to_start{$unit} = 1; + record_unit($start_list_file, $unit); next; } - handle_modified_unit($unit, $baseName, $newUnitFile, undef, $activePrev, \%unitsToRestart, \%unitsToRestart, \%unitsToReload, \%unitsToRestart, \%unitsToSkip); + 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($restartByActivationFile); +unlink($restart_by_activation_file); -foreach (split("\n", read_file($reloadByActivationFile, err_mode => "quiet") // "")) { +foreach (split("\n", read_file($reload_by_activation_file, err_mode => "quiet") // "")) { my $unit = $_; - if (defined($activePrev->{$unit}) and not $unitsToRestart{$unit} and not $unitsToStop{$unit}) { - $unitsToReload{$unit} = 1; - record_unit($reloadListFile, $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($reloadByActivationFile); +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 ($restartSystemd) { +if ($restart_systemd) { print STDERR "restarting systemd...\n"; - system("$curSystemd/systemctl", "daemon-reexec") == 0 or $res = 2; + system("$cur_systemd/systemctl", "daemon-reexec") == 0 or $res = 2; } # Forget about previously failed services. -system("@systemd@/bin/systemctl", "reset-failed"); +system("$new_systemd/bin/systemctl", "reset-failed"); # Make systemd reload its units. -system("@systemd@/bin/systemctl", "daemon-reload") == 0 or $res = 3; +system("$new_systemd/bin/systemctl", "daemon-reload") == 0 or $res = 3; # Reload user units -open(my $listActiveUsers, "-|", "@systemd@/bin/loginctl", "list-users", "--no-legend"); -while (my $f = <$listActiveUsers>) { +open(my $list_active_users, "-|", "$new_systemd/bin/loginctl", "list-users", "--no-legend"); +while (my $f = <$list_active_users>) { if ($f !~ /^\s*(?\d+)\s+(?\S+)/) { next; } @@ -798,48 +804,48 @@ while (my $f = <$listActiveUsers>) { system("@su@", "-s", "@shell@", "-l", $name, "-c", "export XDG_RUNTIME_DIR=/run/user/$uid; " . - "$curSystemd/systemctl --user daemon-reexec; " . - "@systemd@/bin/systemctl --user start nixos-activation.service"); + "$cur_systemd/systemctl --user daemon-reexec; " . + "$new_systemd/bin/systemctl --user start nixos-activation.service"); } -close($listActiveUsers); +close($list_active_users); # Set the new tmpfiles print STDERR "setting up tmpfiles\n"; -system("@systemd@/bin/systemd-tmpfiles", "--create", "--remove", "--exclude-prefix=/dev") == 0 or $res = 3; +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(%unitsToReload)) > 0) { - for my $unit (keys(%unitsToReload)) { +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))) { - $unitsToStart{$unit} = 1; - record_unit($startListFile, $unit); + $units_to_start{$unit} = 1; + record_unit($start_list_file, $unit); } # Don't reload the unit, reloading would fail - delete %unitsToReload{$unit}; - unrecord_unit($reloadListFile, $unit); + 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(%unitsToReload)) > 0) { - print STDERR "reloading the following units: ", join(", ", sort(keys(%unitsToReload))), "\n"; - system("@systemd@/bin/systemctl", "reload", "--", sort(keys(%unitsToReload))) == 0 or $res = 4; - unlink($reloadListFile); +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(%unitsToRestart)) > 0) { - print STDERR "restarting the following units: ", join(", ", sort(keys(%unitsToRestart))), "\n"; - system("@systemd@/bin/systemctl", "restart", "--", sort(keys(%unitsToRestart))) == 0 or $res = 4; - unlink($restartListFile); +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. @@ -848,18 +854,18 @@ if (scalar(keys(%unitsToRestart)) > 0) { # 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 @unitsToStartFiltered = filter_units(\%unitsToStart); -if (scalar(@unitsToStartFiltered)) { - print STDERR "starting the following units: ", join(", ", @unitsToStartFiltered), "\n" +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("@systemd@/bin/systemctl", "start", "--", sort(keys(%unitsToStart))) == 0 or $res = 4; -unlink($startListFile); +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 $activeNew = get_active_units(); -while (my ($unit, $state) = each(%{$activeNew})) { +my $active_new = get_active_units(); +while (my ($unit, $state) = each(%{$active_new})) { if ($state->{state} eq "failed") { push(@failed, $unit); next; @@ -867,7 +873,7 @@ while (my ($unit, $state) = each(%{$activeNew})) { if ($state->{substate} eq "auto-restart") { # A unit in auto-restart substate is a failure *if* it previously failed to start - my $main_status = `@systemd@/bin/systemctl show --value --property=ExecMainStatus '$unit'`; + my $main_status = `$new_systemd/bin/systemctl show --value --property=ExecMainStatus '$unit'`; chomp($main_status); if ($main_status ne "0") { @@ -879,7 +885,7 @@ while (my ($unit, $state) = each(%{$activeNew})) { # 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($activePrev->{$unit}) && $unit !~ /\.scope$/msx) { + if ($state->{state} ne "failed" && !defined($active_cur->{$unit}) && $unit !~ /\.scope$/msx) { push(@new, $unit); } } @@ -891,7 +897,7 @@ if (scalar(@new) > 0) { if (scalar(@failed) > 0) { my @failed_sorted = sort(@failed); print STDERR "warning: the following units failed: ", join(", ", @failed_sorted), "\n\n"; - system("@systemd@/bin/systemctl status --no-pager --full '" . join("' '", @failed_sorted) . "' >&2"); + system("$new_systemd/bin/systemctl status --no-pager --full '" . join("' '", @failed_sorted) . "' >&2"); $res = 4; }