commit 2633e82e1a1cb73e83f7d8d6c70fbe125d182005 · pyrox.dev/nixpkgs

+27 -6

nixos/modules/tasks/lvm.nix

···

       21
        
           boot.vdo.enable = mkEnableOption "support for booting from VDOLVs";

     

       22
        
         };

     

       23
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
         config = mkMerge [

     

       25
        
           ({

     

       26
        
             # minimal configuration file to make lvmconfig/lvm2-activation-generator happy

     
···

       31
        
             environment.systemPackages = [ cfg.package ];

     

       32
        
             systemd.packages = [ cfg.package ];

     

       33
        
       

     

       34
       -
             # TODO: update once https://github.com/NixOS/nixpkgs/pull/93006 was merged

     

       35
        
             services.udev.packages = [ cfg.package.out ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36
        
           })

     

       37
        
           (mkIf cfg.dmeventd.enable {

     

       38
        
             systemd.sockets."dm-event".wantedBy = [ "sockets.target" ];

     
···

       47
        
             boot.initrd = {

     

       48
        
               kernelModules = [ "dm-snapshot" "dm-thin-pool" ];

     

       49
        
       

     

       50
       -
               extraUtilsCommands = ''

     

       0
        
       
     

       0
        
       
     

       51
        
                 for BIN in ${pkgs.thin-provisioning-tools}/bin/*; do

     

       52
        
                   copy_bin_and_libs $BIN

     

       53
        
                 done

     

       54
        
               '';

     

       55
        
       

     

       56
       -
               extraUtilsCommandsTest = ''

     

       57
        
                 ls ${pkgs.thin-provisioning-tools}/bin/ | grep -v pdata_tools | while read BIN; do

     

       58
        
                   $out/bin/$(basename $BIN) --help > /dev/null

     

       59
        
                 done

     
···

       71
        
               initrd = {

     

       72
        
                 kernelModules = [ "kvdo" ];

     

       73
        
       

     

       74
       -
                 extraUtilsCommands = ''

     

       0
        
       
     

       0
        
       
     

       75
        
                   ls ${pkgs.vdo}/bin/ | grep -v adaptLVMVDO | while read BIN; do

     

       76
        
                     copy_bin_and_libs ${pkgs.vdo}/bin/$BIN

     

       77
        
                   done

     

       78
        
                 '';

     

       79
        
       

     

       80
       -
                 extraUtilsCommandsTest = ''

     

       81
        
                   ls ${pkgs.vdo}/bin/ | grep -v adaptLVMVDO | while read BIN; do

     

       82
        
                     $out/bin/$(basename $BIN) --help > /dev/null

     

       83
        
                   done

     
···

       91
        
             environment.systemPackages = [ pkgs.vdo ];

     

       92
        
           })

     

       93
        
           (mkIf (cfg.dmeventd.enable || cfg.boot.thin.enable) {

     

       94
       -
             boot.initrd.preLVMCommands = ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       95
        
                 mkdir -p /etc/lvm

     

       96
        
                 cat << EOF >> /etc/lvm/lvm.conf

     

       97
        
                 ${optionalString cfg.boot.thin.enable (

···

       21
        
           boot.vdo.enable = mkEnableOption "support for booting from VDOLVs";

     

       22
        
         };

     

       23
        
       

     

       24
       +
         options.boot.initrd.services.lvm.enable = (mkEnableOption "enable booting from LVM2 in the initrd") // {

     

       25
       +
           visible = false;

     

       26
       +
         };

     

       27
       +
       

     

       28
        
         config = mkMerge [

     

       29
        
           ({

     

       30
        
             # minimal configuration file to make lvmconfig/lvm2-activation-generator happy

     
···

       35
        
             environment.systemPackages = [ cfg.package ];

     

       36
        
             systemd.packages = [ cfg.package ];

     

       37
        
       

     

       0
        
       
     

       38
        
             services.udev.packages = [ cfg.package.out ];

     

       39
       +
       

     

       40
       +
             # We need lvm2 for the device-mapper rules

     

       41
       +
             boot.initrd.services.udev.packages = lib.mkIf config.boot.initrd.services.lvm.enable [ cfg.package ];

     

       42
       +
             # The device-mapper rules want to call tools from lvm2

     

       43
       +
             boot.initrd.systemd.initrdBin = lib.mkIf config.boot.initrd.services.lvm.enable [ cfg.package ];

     

       44
       +
             boot.initrd.services.udev.binPackages = lib.mkIf config.boot.initrd.services.lvm.enable [ cfg.package ];

     

       45
        
           })

     

       46
        
           (mkIf cfg.dmeventd.enable {

     

       47
        
             systemd.sockets."dm-event".wantedBy = [ "sockets.target" ];

     
···

       56
        
             boot.initrd = {

     

       57
        
               kernelModules = [ "dm-snapshot" "dm-thin-pool" ];

     

       58
        
       

     

       59
       +
               systemd.initrdBin = lib.mkIf config.boot.initrd.services.lvm.enable [ pkgs.thin-provisioning-tools ];

     

       60
       +
       

     

       61
       +
               extraUtilsCommands = mkIf (!config.boot.initrd.systemd.enable) ''

     

       62
        
                 for BIN in ${pkgs.thin-provisioning-tools}/bin/*; do

     

       63
        
                   copy_bin_and_libs $BIN

     

       64
        
                 done

     

       65
        
               '';

     

       66
        
       

     

       67
       +
               extraUtilsCommandsTest = mkIf (!config.boot.initrd.systemd.enable) ''

     

       68
        
                 ls ${pkgs.thin-provisioning-tools}/bin/ | grep -v pdata_tools | while read BIN; do

     

       69
        
                   $out/bin/$(basename $BIN) --help > /dev/null

     

       70
        
                 done

     
···

       82
        
               initrd = {

     

       83
        
                 kernelModules = [ "kvdo" ];

     

       84
        
       

     

       85
       +
                 systemd.initrdBin = lib.mkIf config.boot.initrd.services.lvm.enable [ pkgs.vdo ];

     

       86
       +
       

     

       87
       +
                 extraUtilsCommands = mkIf (!config.boot.initrd.systemd.enable)''

     

       88
        
                   ls ${pkgs.vdo}/bin/ | grep -v adaptLVMVDO | while read BIN; do

     

       89
        
                     copy_bin_and_libs ${pkgs.vdo}/bin/$BIN

     

       90
        
                   done

     

       91
        
                 '';

     

       92
        
       

     

       93
       +
                 extraUtilsCommandsTest = mkIf (!config.boot.initrd.systemd.enable)''

     

       94
        
                   ls ${pkgs.vdo}/bin/ | grep -v adaptLVMVDO | while read BIN; do

     

       95
        
                     $out/bin/$(basename $BIN) --help > /dev/null

     

       96
        
                   done

     
···

       104
        
             environment.systemPackages = [ pkgs.vdo ];

     

       105
        
           })

     

       106
        
           (mkIf (cfg.dmeventd.enable || cfg.boot.thin.enable) {

     

       107
       +
             boot.initrd.systemd.contents."/etc/lvm/lvm.conf".text = optionalString (config.boot.initrd.services.lvm.enable && cfg.boot.thin.enable) (concatMapStringsSep "\n"

     

       108
       +
                 (bin: "global/${bin}_executable = /bin/${bin}")

     

       109
       +
                 [ "thin_check" "thin_dump" "thin_repair" "cache_check" "cache_dump" "cache_repair" ]

     

       110
       +
               ) + "\n" + optionalString cfg.dmeventd.enable ''

     

       111
       +
                 dmeventd/executable = /bin/false

     

       112
       +
                 activation/monitoring = 0

     

       113
       +
               '';

     

       114
       +
       

     

       115
       +
             boot.initrd.preLVMCommands = mkIf (!config.boot.initrd.systemd.enable) ''

     

       116
        
                 mkdir -p /etc/lvm

     

       117
        
                 cat << EOF >> /etc/lvm/lvm.conf

     

       118
        
                 ${optionalString cfg.boot.thin.enable (

+19 -1

nixos/tests/lvm2/default.nix

···

       11
        
           thinpool = { test = callTest ./thinpool.nix; kernelFilter = lib.id; };

     

       12
        
           # we would like to test all versions, but the kernel module currently does not compile against the other versions

     

       13
        
           vdo = { test = callTest ./vdo.nix; kernelFilter = lib.filter (v: v == "5.15"); };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
         };

     

       15
        
       in

     

       16
        
       lib.listToAttrs (

     
···

       20
        
               v' = lib.replaceStrings [ "." ] [ "_" ] version;

     

       21
        
             in

     

       22
        
             lib.flip lib.mapAttrsToList tests (name: t:

     

       23
       -
               lib.nameValuePair "lvm-${name}-linux-${v'}" (lib.optionalAttrs (builtins.elem version (t.kernelFilter kernelVersionsToTest)) (t.test { kernelPackages = pkgs."linuxPackages_${v'}"; }))

     

       24
        
             )

     

       25
        
           )

     

       26
        
         )

···

       11
        
           thinpool = { test = callTest ./thinpool.nix; kernelFilter = lib.id; };

     

       12
        
           # we would like to test all versions, but the kernel module currently does not compile against the other versions

     

       13
        
           vdo = { test = callTest ./vdo.nix; kernelFilter = lib.filter (v: v == "5.15"); };

     

       14
       +
       

     

       15
       +
       

     

       16
       +
           # systemd in stage 1

     

       17
       +
           raid-sd-stage-1 = {

     

       18
       +
             test = callTest ./systemd-stage-1.nix;

     

       19
       +
             kernelFilter = lib.id;

     

       20
       +
             flavour = "raid";

     

       21
       +
           };

     

       22
       +
           thinpool-sd-stage-1 = {

     

       23
       +
             test = callTest ./systemd-stage-1.nix;

     

       24
       +
             kernelFilter = lib.id;

     

       25
       +
             flavour = "thinpool";

     

       26
       +
           };

     

       27
       +
           vdo-sd-stage-1 = {

     

       28
       +
             test = callTest ./systemd-stage-1.nix;

     

       29
       +
             kernelFilter = lib.filter (v: v == "5.15");

     

       30
       +
             flavour = "vdo";

     

       31
       +
           };

     

       32
        
         };

     

       33
        
       in

     

       34
        
       lib.listToAttrs (

     
···

       38
        
               v' = lib.replaceStrings [ "." ] [ "_" ] version;

     

       39
        
             in

     

       40
        
             lib.flip lib.mapAttrsToList tests (name: t:

     

       41
       +
               lib.nameValuePair "lvm-${name}-linux-${v'}" (lib.optionalAttrs (builtins.elem version (t.kernelFilter kernelVersionsToTest)) (t.test ({ kernelPackages = pkgs."linuxPackages_${v'}"; } // builtins.removeAttrs t [ "test" "kernelFilter" ])))

     

       42
        
             )

     

       43
        
           )

     

       44
        
         )

+104

nixos/tests/lvm2/systemd-stage-1.nix

···

       1
       +
       { kernelPackages ? null, flavour }: let

     

       2
       +
         preparationCode = {

     

       3
       +
           raid = ''

     

       4
       +
             machine.succeed("vgcreate test_vg /dev/vdc /dev/vdd")

     

       5
       +
             machine.succeed("lvcreate -L 512M --type raid0 test_vg -n test_lv")

     

       6
       +
           '';

     

       7
       +
       

     

       8
       +
           thinpool = ''

     

       9
       +
             machine.succeed("vgcreate test_vg /dev/vdc")

     

       10
       +
             machine.succeed("lvcreate -L 512M -T test_vg/test_thin_pool")

     

       11
       +
             machine.succeed("lvcreate -n test_lv -V 16G --thinpool test_thin_pool test_vg")

     

       12
       +
           '';

     

       13
       +
       

     

       14
       +
           vdo = ''

     

       15
       +
             machine.succeed("vgcreate test_vg /dev/vdc")

     

       16
       +
             machine.succeed("lvcreate --type vdo -n test_lv -L 6G -V 12G test_vg/vdo_pool_lv")

     

       17
       +
           '';

     

       18
       +
         }.${flavour};

     

       19
       +
       

     

       20
       +
         extraConfig = {

     

       21
       +
           raid = {

     

       22
       +
             boot.initrd.kernelModules = [

     

       23
       +
               "dm-raid"

     

       24
       +
               "raid0"

     

       25
       +
             ];

     

       26
       +
           };

     

       27
       +
       

     

       28
       +
           thinpool = {

     

       29
       +
             services.lvm = {

     

       30
       +
               boot.thin.enable = true;

     

       31
       +
               dmeventd.enable = true;

     

       32
       +
             };

     

       33
       +
           };

     

       34
       +
       

     

       35
       +
           vdo = {

     

       36
       +
             services.lvm = {

     

       37
       +
               boot.vdo.enable = true;

     

       38
       +
               dmeventd.enable = true;

     

       39
       +
             };

     

       40
       +
           };

     

       41
       +
         }.${flavour};

     

       42
       +
       

     

       43
       +
         extraCheck = {

     

       44
       +
           raid = ''

     

       45
       +
             "test_lv" in machine.succeed("lvs --select segtype=raid0")

     

       46
       +
           '';

     

       47
       +
       

     

       48
       +
           thinpool = ''

     

       49
       +
             "test_lv" in machine.succeed("lvs --select segtype=thin-pool")

     

       50
       +
           '';

     

       51
       +
       

     

       52
       +
           vdo = ''

     

       53
       +
             "test_lv" in machine.succeed("lvs --select segtype=vdo")

     

       54
       +
           '';

     

       55
       +
         }.${flavour};

     

       56
       +
       

     

       57
       +
       in import ../make-test-python.nix ({ pkgs, ... }: {

     

       58
       +
         name = "lvm2-${flavour}-systemd-stage-1";

     

       59
       +
         meta.maintainers = with pkgs.lib.maintainers; [ das_j ];

     

       60
       +
       

     

       61
       +
         nodes.machine = { pkgs, lib, ... }: {

     

       62
       +
           imports = [ extraConfig ];

     

       63
       +
           # Use systemd-boot

     

       64
       +
           virtualisation = {

     

       65
       +
             emptyDiskImages = [ 8192 8192 ];

     

       66
       +
             useBootLoader = true;

     

       67
       +
             useEFIBoot = true;

     

       68
       +
           };

     

       69
       +
           boot.loader.systemd-boot.enable = true;

     

       70
       +
           boot.loader.efi.canTouchEfiVariables = true;

     

       71
       +
       

     

       72
       +
           environment.systemPackages = with pkgs; [ e2fsprogs ]; # for mkfs.ext4

     

       73
       +
           boot = {

     

       74
       +
             initrd.systemd = {

     

       75
       +
               enable = true;

     

       76
       +
               emergencyAccess = true;

     

       77
       +
             };

     

       78
       +
             initrd.services.lvm.enable = true;

     

       79
       +
             kernelPackages = lib.mkIf (kernelPackages != null) kernelPackages;

     

       80
       +
           };

     

       81
       +
       

     

       82
       +
           specialisation.boot-lvm.configuration.virtualisation.bootDevice = "/dev/test_vg/test_lv";

     

       83
       +
         };

     

       84
       +
       

     

       85
       +
         testScript = ''

     

       86
       +
           machine.wait_for_unit("multi-user.target")

     

       87
       +
           # Create a VG for the root

     

       88
       +
           ${preparationCode}

     

       89
       +
           machine.succeed("mkfs.ext4 /dev/test_vg/test_lv")

     

       90
       +
           machine.succeed("mkdir -p /mnt && mount /dev/test_vg/test_lv /mnt && echo hello > /mnt/test && umount /mnt")

     

       91
       +
       

     

       92
       +
           # Boot from LVM

     

       93
       +
           machine.succeed("bootctl set-default nixos-generation-1-specialisation-boot-lvm.conf")

     

       94
       +
           machine.succeed("sync")

     

       95
       +
           machine.crash()

     

       96
       +
           machine.wait_for_unit("multi-user.target")

     

       97
       +
       

     

       98
       +
           # Ensure we have successfully booted from LVM

     

       99
       +
           assert "(initrd)" in machine.succeed("systemd-analyze")  # booted with systemd in stage 1

     

       100
       +
           assert "/dev/mapper/test_vg-test_lv on / type ext4" in machine.succeed("mount")

     

       101
       +
           assert "hello" in machine.succeed("cat /test")

     

       102
       +
           ${extraCheck}

     

       103
       +
         '';

     

       104
       +
       })