commit eb831f759bc2c98ef84a0a97c60e5ab0b73f309c · pyrox.dev/nixpkgs

+5 -2

nixos/doc/manual/development/unit-handling.section.md

···

       25
       25
        
           since changes in their values are applied by systemd when systemd is

     

       26
       26
        
           reloaded.

     

       27
       27
        
       

     

       28
       28
       -
         - `.mount` units are **reload**ed. These mostly come from the `/etc/fstab`

     

       29
       29
       -
           parser.

     

       28
       28
       +
         - `.mount` units are **reload**ed if only their `Options` changed. If anything

     

       29
       29
       +
           else changed (like `What`), they are **restart**ed unless they are the mount

     

       30
       30
       +
           unit for `/` or `/nix` in which case they are reloaded to prevent the system

     

       31
       31
       +
           from crashing. Note that this is the case for `.mount` units and not for

     

       32
       32
       +
           mounts from `/etc/fstab`. These are explained in [](#sec-switching-systems).

     

       30
       33
        
       

     

       31
       34
        
         - `.socket` units are currently ignored. This is to be fixed at a later

     

       32
       35
        
           point.

+19 -5

nixos/modules/system/activation/switch-to-configuration.pl

···

       313
       313
        
       # needs to be restarted or reloaded. If the units differ, the service

     

       314
       314
        
       # is restarted unless the only difference is `X-Reload-Triggers` in the

     

       315
       315
        
       # `Unit` section. If this is the only modification, the unit is reloaded

     

       316
       316
       -
       # instead of restarted.

     

       316
       316
       +
       # instead of restarted. If the only difference is `Options` in the

     

       317
       317
       +
       # `[Mount]` section, the unit is reloaded rather than restarted.

     

       317
       318
        
       # Returns:

     

       318
       319
        
       # - 0 if the units are equal

     

       319
       320
        
       # - 1 if the units are different and a restart action is required

     
···

       390
       391
        
                               next;

     

       391
       392
        
                           }

     

       392
       393
        
                       }

     

       394
       394
       +
                       # If this is a mount unit, check if it was only `Options`

     

       395
       395
       +
                       if ($section_name eq "Mount" and $ini_key eq "Options") {

     

       396
       396
       +
                           $ret = 2;

     

       397
       397
       +
                           next;

     

       398
       398
       +
                       }

     

       393
       399
        
                       return 1;

     

       394
       400
        
                   }

     

       395
       401
        
               }

     
···

       440
       446
        
               # properties (resource limits and inotify watches)

     

       441
       447
        
               # seem to get applied on daemon-reload.

     

       442
       448
        
           } elsif ($unit =~ /\.mount$/msx) {

     

       443
       443
       -
               # Reload the changed mount unit to force a remount.

     

       444
       444
       -
               # FIXME: only reload when Options= changed, restart otherwise

     

       445
       445
       -
               $units_to_reload->{$unit} = 1;

     

       446
       446
       -
               record_unit($reload_list_file, $unit);

     

       449
       449
       +
               # Just restart the unit. We wouldn't have gotten into this subroutine

     

       450
       450
       +
               # if only `Options` was changed, in which case the unit would be reloaded.

     

       451
       451
       +
               # The only exception is / and /nix because it's very unlikely we can safely

     

       452
       452
       +
               # unmount them so we reload them instead. This means that we may not get

     

       453
       453
       +
               # all changes into the running system but it's better than crashing it.

     

       454
       454
       +
               if ($unit eq "-.mount" or $unit eq "nix.mount") {

     

       455
       455
       +
                   $units_to_reload->{$unit} = 1;

     

       456
       456
       +
                   record_unit($reload_list_file, $unit);

     

       457
       457
       +
               } else {

     

       458
       458
       +
                   $units_to_restart->{$unit} = 1;

     

       459
       459
       +
                   record_unit($restart_list_file, $unit);

     

       460
       460
       +
               }

     

       447
       461
        
           } elsif ($unit =~ /\.socket$/msx) {

     

       448
       462
        
               # FIXME: do something?

     

       449
       463
        
               # Attempt to fix this: https://github.com/NixOS/nixpkgs/pull/141192

+27 -2

nixos/tests/switch-test.nix

···

       450
       450
        
                 ];

     

       451
       451
        
               };

     

       452
       452
        
       

     

       453
       453
       -
               mountModified.configuration = {

     

       453
       453
       +
               mountOptionsModified.configuration = {

     

       454
       454
        
                 systemd.mounts = [

     

       455
       455
        
                   {

     

       456
       456
        
                     description = "Testmount";

     

       457
       457
        
                     what = "tmpfs";

     

       458
       458
        
                     type = "tmpfs";

     

       459
       459
       +
                     where = "/testmount";

     

       460
       460
       +
                     options = "size=10M";

     

       461
       461
       +
                     wantedBy = [ "local-fs.target" ];

     

       462
       462
       +
                   }

     

       463
       463
       +
                 ];

     

       464
       464
       +
               };

     

       465
       465
       +
       

     

       466
       466
       +
               mountModified.configuration = {

     

       467
       467
       +
                 systemd.mounts = [

     

       468
       468
       +
                   {

     

       469
       469
       +
                     description = "Testmount";

     

       470
       470
       +
                     what = "ramfs";

     

       471
       471
       +
                     type = "ramfs";

     

       459
       472
        
                     where = "/testmount";

     

       460
       473
        
                     options = "size=10M";

     

       461
       474
        
                     wantedBy = [ "local-fs.target" ];

     
···

       1137
       1150
        
               switch_to_specialisation("${machine}", "mount")

     

       1138
       1151
        
               out = machine.succeed("mount | grep 'on /testmount'")

     

       1139
       1152
        
               assert_contains(out, "size=1024k")

     

       1140
       1140
       -
               out = switch_to_specialisation("${machine}", "mountModified")

     

       1153
       1153
       +
               # Changing options reloads the unit

     

       1154
       1154
       +
               out = switch_to_specialisation("${machine}", "mountOptionsModified")

     

       1141
       1155
        
               assert_lacks(out, "stopping the following units:")

     

       1142
       1156
        
               assert_lacks(out, "NOT restarting the following changed units:")

     

       1143
       1157
        
               assert_contains(out, "reloading the following units: testmount.mount\n")

     
···

       1147
       1161
        
               # It changed

     

       1148
       1162
        
               out = machine.succeed("mount | grep 'on /testmount'")

     

       1149
       1163
        
               assert_contains(out, "size=10240k")

     

       1164
       1164
       +
               # Changing anything but `Options=` restarts the unit

     

       1165
       1165
       +
               out = switch_to_specialisation("${machine}", "mountModified")

     

       1166
       1166
       +
               assert_lacks(out, "stopping the following units:")

     

       1167
       1167
       +
               assert_lacks(out, "NOT restarting the following changed units:")

     

       1168
       1168
       +
               assert_lacks(out, "reloading the following units:")

     

       1169
       1169
       +
               assert_contains(out, "\nrestarting the following units: testmount.mount\n")

     

       1170
       1170
       +
               assert_lacks(out, "\nstarting the following units:")

     

       1171
       1171
       +
               assert_lacks(out, "the following new units were started:")

     

       1172
       1172
       +
               # It changed

     

       1173
       1173
       +
               out = machine.succeed("mount | grep 'on /testmount'")

     

       1174
       1174
       +
               assert_contains(out, "ramfs")

     

       1150
       1175
        
       

     

       1151
       1176
        
           with subtest("timers"):

     

       1152
       1177
        
               switch_to_specialisation("${machine}", "timer")