commit 7560e2d64f2a367c128f4baf76155bc33f13a77d · pyrox.dev/nixpkgs

+1

nixos/modules/rename.nix

···

       221
       221
        
           (mkRemovedOptionModule [ "services" "mysql" "pidDir" ] "Don't wait for pidfiles, describe dependencies through systemd")

     

       222
       222
        
           (mkRemovedOptionModule [ "services" "mysql" "rootPassword" ] "Use socket authentication or set the password outside of the nix store.")

     

       223
       223
        
           (mkRemovedOptionModule [ "services" "zabbixServer" "dbPassword" ] "Use services.zabbixServer.database.passwordFile instead.")

     

       224
       224
       +
           (mkRemovedOptionModule [ "systemd" "generator-packages" ] "Use systemd.packages instead.")

     

       224
       225
        
       

     

       225
       226
        
           # ZSH

     

       226
       227
        
           (mkRenamedOptionModule [ "programs" "zsh" "enableSyntaxHighlighting" ] [ "programs" "zsh" "syntaxHighlighting" "enable" ])

+3 -5

nixos/modules/system/boot/stage-1.nix

···

       217
       217
        
                   --replace ata_id ${extraUtils}/bin/ata_id \

     

       218
       218
        
                   --replace scsi_id ${extraUtils}/bin/scsi_id \

     

       219
       219
        
                   --replace cdrom_id ${extraUtils}/bin/cdrom_id \

     

       220
       220
       -
                   --replace ${pkgs.utillinux}/sbin/blkid ${extraUtils}/bin/blkid \

     

       221
       221
       -
                   --replace /sbin/blkid ${extraUtils}/bin/blkid \

     

       220
       220
       +
                   --replace ${pkgs.coreutils}/bin/basename ${extraUtils}/bin/basename \

     

       221
       221
       +
                   --replace ${pkgs.utillinux}/bin/blkid ${extraUtils}/bin/blkid \

     

       222
       222
        
                   --replace ${pkgs.lvm2}/sbin ${extraUtils}/bin \

     

       223
       223
       -
                   --replace /sbin/mdadm ${extraUtils}/bin/mdadm \

     

       223
       223
       +
                   --replace ${pkgs.mdadm}/sbin ${extraUtils}/sbin \

     

       224
       224
        
                   --replace ${pkgs.bash}/bin/sh ${extraUtils}/bin/sh \

     

       225
       225
       -
                   --replace /usr/bin/readlink ${extraUtils}/bin/readlink \

     

       226
       226
       -
                   --replace /usr/bin/basename ${extraUtils}/bin/basename \

     

       227
       225
        
                   --replace ${udev}/bin/udevadm ${extraUtils}/bin/udevadm

     

       228
       226
        
             done

     

       229
       227

+23 -15

nixos/modules/system/boot/systemd.nix

···

       427
       427
        
           systemd.packages = mkOption {

     

       428
       428
        
             default = [];

     

       429
       429
        
             type = types.listOf types.package;

     

       430
       430
       -
             description = "Packages providing systemd units.";

     

       430
       430
       +
             example = literalExample "[ pkgs.systemd-cryptsetup-generator ]";

     

       431
       431
       +
             description = "Packages providing systemd units and hooks.";

     

       431
       432
        
           };

     

       432
       433
        
       

     

       433
       434
        
           systemd.targets = mkOption {

     
···

       497
       498
        
             '';

     

       498
       499
        
           };

     

       499
       500
        
       

     

       500
       500
       -
           systemd.generator-packages = mkOption {

     

       501
       501
       -
             default = [];

     

       502
       502
       -
             type = types.listOf types.package;

     

       503
       503
       -
             example = literalExample "[ pkgs.systemd-cryptsetup-generator ]";

     

       504
       504
       -
             description = "Packages providing systemd generators.";

     

       501
       501
       +
           systemd.shutdown = mkOption {

     

       502
       502
       +
             type = types.attrsOf types.path;

     

       503
       503
       +
             default = {};

     

       504
       504
       +
             description = ''

     

       505
       505
       +
               Definition of systemd shutdown executables.

     

       506
       506
       +
               For each <literal>NAME = VALUE</literal> pair of the attrSet, a link is generated from

     

       507
       507
       +
               <literal>/etc/systemd/system-shutdown/NAME</literal> to <literal>VALUE</literal>.

     

       508
       508
       +
             '';

     

       505
       509
        
           };

     

       506
       510
        
       

     

       507
       511
        
           systemd.defaultUnit = mkOption {

     
···

       761
       765
        
           environment.systemPackages = [ systemd ];

     

       762
       766
        
       

     

       763
       767
        
           environment.etc = let

     

       764
       764
       -
             # generate contents for /etc/systemd/system-generators from

     

       765
       765
       -
             # systemd.generators and systemd.generator-packages

     

       766
       766
       -
             generators = pkgs.runCommand "system-generators" {

     

       768
       768
       +
             # generate contents for /etc/systemd/system-${type} from attrset of links and packages

     

       769
       769
       +
             hooks = type: links: pkgs.runCommand "system-${type}" {

     

       767
       770
        
                 preferLocalBuild = true;

     

       768
       768
       -
                 packages = cfg.generator-packages;

     

       769
       769
       -
               } ''

     

       771
       771
       +
                 packages = cfg.packages;

     

       772
       772
       +
             } ''

     

       773
       773
       +
               set -e

     

       770
       774
        
               mkdir -p $out

     

       771
       775
        
               for package in $packages

     

       772
       776
        
               do

     

       773
       773
       -
                 ln -s $package/lib/systemd/system-generators/* $out/

     

       774
       774
       -
               done;

     

       775
       775
       -
               ${concatStrings (mapAttrsToList (generator: target: "ln -s ${target} $out/${generator};\n") cfg.generators)}

     

       777
       777
       +
                 for hook in $package/lib/systemd/system-${type}/*

     

       778
       778
       +
                 do

     

       779
       779
       +
                   ln -s $hook $out/

     

       780
       780
       +
                 done

     

       781
       781
       +
               done

     

       782
       782
       +
               ${concatStrings (mapAttrsToList (exec: target: "ln -s ${target} $out/${exec};\n") links)}

     

       776
       783
        
             '';

     

       777
       784
        
           in ({

     

       778
       785
        
             "systemd/system".source = generateUnits "system" cfg.units upstreamSystemUnits upstreamSystemWants;

     
···

       834
       841
        
               ${concatStringsSep "\n" cfg.tmpfiles.rules}

     

       835
       842
        
             '';

     

       836
       843
        
       

     

       837
       837
       -
             "systemd/system-generators" = { source = generators; };

     

       844
       844
       +
             "systemd/system-generators" = { source = hooks "generators" cfg.generators; };

     

       845
       845
       +
             "systemd/system-shutdown" = { source = hooks "shutdown" cfg.shutdown; };

     

       838
       846
        
           });

     

       839
       847
        
       

     

       840
       848
        
           services.dbus.enable = true;

-1

nixos/modules/tasks/filesystems/nfs.nix

···

       56
       56
        
           boot.initrd.kernelModules = mkIf inInitrd [ "nfs" ];

     

       57
       57
        
       

     

       58
       58
        
           systemd.packages = [ pkgs.nfs-utils ];

     

       59
       59
       -
           systemd.generator-packages = [ pkgs.nfs-utils ];

     

       60
       59
        
       

     

       61
       60
        
           environment.etc = {

     

       62
       61
        
             "idmapd.conf".source = idmapdConfFile;

+2 -41

nixos/modules/tasks/swraid.nix

···

       6
       6
        
       

     

       7
       7
        
         services.udev.packages = [ pkgs.mdadm ];

     

       8
       8
        
       

     

       9
       9
       +
         systemd.packages = [ pkgs.mdadm ];

     

       10
       10
       +
       

     

       9
       11
        
         boot.initrd.availableKernelModules = [ "md_mod" "raid0" "raid1" "raid10" "raid456" ];

     

       10
       12
        
       

     

       11
       13
        
         boot.initrd.extraUdevRulesCommands = ''

     

       12
       14
        
           cp -v ${pkgs.mdadm}/lib/udev/rules.d/*.rules $out/

     

       13
       15
        
         '';

     

       14
       16
        
       

     

       15
       15
       -
         systemd.services.mdadm-shutdown = {

     

       16
       16
       -
           wantedBy = [ "final.target"];

     

       17
       17
       -
           after = [ "umount.target" ];

     

       18
       18
       -
       

     

       19
       19
       -
           unitConfig = {

     

       20
       20
       -
             DefaultDependencies = false;

     

       21
       21
       -
           };

     

       22
       22
       -
       

     

       23
       23
       -
           serviceConfig = {

     

       24
       24
       -
             Type = "oneshot";

     

       25
       25
       -
             ExecStart = ''${pkgs.mdadm}/bin/mdadm --wait-clean --scan'';

     

       26
       26
       -
           };

     

       27
       27
       -
         };

     

       28
       28
       -
       

     

       29
       29
       -
         systemd.services."mdmon@" = {

     

       30
       30
       -
           description = "MD Metadata Monitor on /dev/%I";

     

       31
       31
       -
       

     

       32
       32
       -
           unitConfig.DefaultDependencies = false;

     

       33
       33
       -
       

     

       34
       34
       -
           serviceConfig = {

     

       35
       35
       -
             Type = "forking";

     

       36
       36
       -
             Environment = "IMSM_NO_PLATFORM=1";

     

       37
       37
       -
             ExecStart = ''${pkgs.mdadm}/bin/mdmon --offroot --takeover %I'';

     

       38
       38
       -
             KillMode = "none";

     

       39
       39
       -
           };

     

       40
       40
       -
         };

     

       41
       41
       -
       

     

       42
       42
       -
         systemd.services."mdadm-grow-continue@" = {

     

       43
       43
       -
           description = "Manage MD Reshape on /dev/%I";

     

       44
       44
       -
       

     

       45
       45
       -
           unitConfig.DefaultDependencies = false;

     

       46
       46
       -
       

     

       47
       47
       -
           serviceConfig = {

     

       48
       48
       -
             ExecStart = ''${pkgs.mdadm}/bin/mdadm --grow --continue /dev/%I'';

     

       49
       49
       -
             StandardInput = "null";

     

       50
       50
       -
             StandardOutput = "null";

     

       51
       51
       -
             StandardError = "null";

     

       52
       52
       -
             KillMode = "none";

     

       53
       53
       -
           };

     

       54
       54
       -
         };

     

       55
       55
       -
        

     

       56
       17
        
       }

+25 -2

nixos/tests/systemd.nix

···

       1
       1
       -
       import ./make-test.nix {

     

       1
       1
       +
       import ./make-test.nix ({ pkgs, ... }: {

     

       2
       2
        
         name = "systemd";

     

       3
       3
        
       

     

       4
       4
        
         machine = { lib, ... }: {

     
···

       20
       20
        
           systemd.user.extraConfig = "DefaultEnvironment=\"XXX_USER=bar\"";

     

       21
       21
        
           services.journald.extraConfig = "Storage=volatile";

     

       22
       22
        
           services.xserver.displayManager.auto.user = "alice";

     

       23
       23
       +
       

     

       24
       24
       +
           systemd.shutdown.test = pkgs.writeScript "test.shutdown" ''

     

       25
       25
       +
             #!${pkgs.stdenv.shell}

     

       26
       26
       +
             PATH=${lib.makeBinPath (with pkgs; [ utillinux coreutils ])}

     

       27
       27
       +
             mount -t 9p shared -o trans=virtio,version=9p2000.L /tmp/shared

     

       28
       28
       +
             touch /tmp/shared/shutdown-test

     

       29
       29
       +
             umount /tmp/shared

     

       30
       30
       +
           '';

     

       23
       31
        
       

     

       24
       32
        
           systemd.services.testservice1 = {

     

       25
       33
        
             description = "Test Service 1";

     
···

       69
       77
        
             # has a last mount time, because the file system wasn't checked.

     

       70
       78
        
             $machine->fail('dumpe2fs /dev/vdb | grep -q "^Last mount time: *n/a"');

     

       71
       79
        
           };

     

       80
       80
       +
       

     

       81
       81
       +
           # Regression test for https://github.com/NixOS/nixpkgs/issues/35268

     

       82
       82
       +
           subtest "file system with x-initrd.mount is not unmounted", sub {

     

       83
       83
       +
             $machine->shutdown;

     

       84
       84
       +
             $machine->waitForUnit('multi-user.target');

     

       85
       85
       +
             # If the file system was unmounted during the shutdown the file system

     

       86
       86
       +
             # has a last mount time, because the file system wasn't checked.

     

       87
       87
       +
             $machine->fail('dumpe2fs /dev/vdb | grep -q "^Last mount time: *n/a"');

     

       88
       88
       +
           };

     

       89
       89
       +
       

     

       90
       90
       +
           subtest "systemd-shutdown works", sub {

     

       91
       91
       +
             $machine->shutdown;

     

       92
       92
       +
             $machine->waitForUnit('multi-user.target');

     

       93
       93
       +
             $machine->succeed('test -e /tmp/shared/shutdown-test');

     

       94
       94
       +
           };

     

       72
       95
        
         '';

     

       73
       73
       -
       }

     

       96
       96
       +
       })

+18 -7

pkgs/os-specific/linux/mdadm/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, groff, system-sendmail }:

     

       1
       1
       +
       { stdenv, utillinux, coreutils, fetchurl, groff, system-sendmail }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "mdadm-4.1";

     
···

       8
       8
        
           sha256 = "0jjgjgqijpdp7ijh8slzzjjw690kydb1jjadf0x5ilq85628hxmb";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
       -
         # This is to avoid self-references, which causes the initrd to explode

     

       12
       12
       -
         # in size and in turn prevents mdraid systems from booting.

     

       13
       13
       -
         allowedReferences = [ stdenv.cc.libc.out system-sendmail ];

     

       14
       14
       -
       

     

       15
       11
        
         patches = [ ./no-self-references.patch ];

     

       16
       12
        
       

     

       17
       13
        
         makeFlags = [

     

       18
       18
       -
           "NIXOS=1" "INSTALL=install" "INSTALL_BINDIR=$(out)/sbin"

     

       14
       14
       +
           "NIXOS=1" "INSTALL=install" "BINDIR=$(out)/sbin"

     

       15
       15
       +
           "SYSTEMD_DIR=$(out)/lib/systemd/system"

     

       19
       16
        
           "MANDIR=$(out)/share/man" "RUN_DIR=/dev/.mdadm"

     

       20
       17
        
           "STRIP="

     

       21
       18
        
         ] ++ stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [

     

       22
       19
        
           "CROSS_COMPILE=${stdenv.cc.targetPrefix}"

     

       23
       20
        
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         installFlags = [ "install-systemd" ];

     

       23
       23
       +
       

     

       24
       24
       +
         enableParallelBuilding = true;

     

       24
       25
        
       

     

       25
       26
        
         nativeBuildInputs = [ groff ];

     

       26
       27
        
       

     

       27
       27
       -
         preConfigure = ''

     

       28
       28
       +
         postPatch = ''

     

       28
       29
        
           sed -e 's@/lib/udev@''${out}/lib/udev@' \

     

       29
       30
        
               -e 's@ -Werror @ @' \

     

       30
       31
        
               -e 's@/usr/sbin/sendmail@${system-sendmail}@' -i Makefile

     

       32
       32
       +
           sed -i \

     

       33
       33
       +
               -e 's@/usr/bin/basename@${coreutils}/bin/basename@g' \

     

       34
       34
       +
               -e 's@BINDIR/blkid@${utillinux}/bin/blkid@g' \

     

       35
       35
       +
               *.rules

     

       36
       36
       +
         '';

     

       37
       37
       +
       

     

       38
       38
       +
         # This is to avoid self-references, which causes the initrd to explode

     

       39
       39
       +
         # in size and in turn prevents mdraid systems from booting.

     

       40
       40
       +
         postFixup = ''

     

       41
       41
       +
           grep -r $out $out/bin && false || true

     

       31
       42
        
         '';

     

       32
       43
        
       

     

       33
       44
        
         meta = with stdenv.lib; {

+2 -2

pkgs/os-specific/linux/systemd/default.nix

···

       24
       24
        
         src = fetchFromGitHub {

     

       25
       25
        
           owner = "NixOS";

     

       26
       26
        
           repo = "systemd";

     

       27
       27
       -
           rev = "aa4c4d39d75ce52664cb28d569b1ceafda7b4c06";

     

       28
       28
       -
           sha256 = "1ax94gzbdwdcf3wgj7f9cabdkvn2zynnnli7gkbz4isidlpis86g";

     

       27
       27
       +
           rev = "5fb35fbc783516e2014115c3488134a2afb8494c";

     

       28
       28
       +
           sha256 = "0pyjvzzh8nnxv4z58n82lz1mjnzv44sylcjgkvw8sp35vx1ryxfh";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         outputs = [ "out" "lib" "man" "dev" ];