push sheeet

nixos/tests/lvm2/default.nix

@@ -0,0 +1,80 @@
+{
+  system ? builtins.currentSystem,
+  config ? { },
+  pkgs ? import ../../.. { inherit system config; },
+  lib ? pkgs.lib,
+  kernelVersionsToTest ? [
+    "5.4"
+    "5.10"
+    "5.15"
+    "6.1"
+    "6.6"
+    "latest"
+  ],
+}:
+
+# For quickly running a test, the nixosTests.lvm2.lvm-thinpool-linux-latest attribute is recommended
+let
+  tests =
+    let
+      callTest = p: lib.flip (import p) { inherit system pkgs; };
+    in
+    {
+      thinpool = {
+        test = callTest ./thinpool.nix;
+        kernelFilter = lib.id;
+      };
+      # we would like to test all versions, but the kernel module currently does not compile against the other versions
+      vdo = {
+        test = callTest ./vdo.nix;
+        kernelFilter = lib.filter (v: v == "latest");
+      };
+
+      # systemd in stage 1
+      raid-sd-stage-1 = {
+        test = callTest ./systemd-stage-1.nix;
+        kernelFilter = lib.filter (v: v != "5.15");
+        flavour = "raid";
+      };
+      thinpool-sd-stage-1 = {
+        test = callTest ./systemd-stage-1.nix;
+        kernelFilter = lib.id;
+        flavour = "thinpool";
+      };
+      vdo-sd-stage-1 = {
+        test = callTest ./systemd-stage-1.nix;
+        kernelFilter = lib.filter (v: v == "latest");
+        flavour = "vdo";
+      };
+    };
+in
+lib.listToAttrs (
+  lib.filter (x: x.value != { }) (
+    lib.flip lib.concatMap kernelVersionsToTest (
+      version:
+      let
+        v' = lib.replaceStrings [ "." ] [ "_" ] version;
+        mkXfsFlags =
+          lib.optionalString (lib.versionOlder version "5.10") " -m bigtime=0 -m inobtcount=0 "
+          + lib.optionalString (lib.versionOlder version "5.19") " -i nrext64=0 ";
+      in
+      lib.flip lib.mapAttrsToList tests (
+        name: t:
+        lib.nameValuePair "lvm-${name}-linux-${v'}" (
+          lib.optionalAttrs (builtins.elem version (t.kernelFilter kernelVersionsToTest)) (
+            t.test (
+              {
+                kernelPackages = pkgs."linuxPackages_${v'}";
+                inherit mkXfsFlags;
+              }
+              // builtins.removeAttrs t [
+                "test"
+                "kernelFilter"
+              ]
+            )
+          )
+        )
+      )
+    )
+  )
+)

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

@@ -0,0 +1,136 @@
+{
+  kernelPackages ? null,
+  flavour,
+  mkXfsFlags ? "",
+}:
+let
+  preparationCode =
+    {
+      raid = ''
+        machine.succeed("vgcreate test_vg /dev/vdb /dev/vdc")
+        machine.succeed("lvcreate -L 512M --type raid0 test_vg -n test_lv")
+      '';
+
+      thinpool = ''
+        machine.succeed("vgcreate test_vg /dev/vdb")
+        machine.succeed("lvcreate -L 512M -T test_vg/test_thin_pool")
+        machine.succeed("lvcreate -n test_lv -V 16G --thinpool test_thin_pool test_vg")
+      '';
+
+      vdo = ''
+        machine.succeed("vgcreate test_vg /dev/vdb")
+        machine.succeed("lvcreate --type vdo -n test_lv -L 6G -V 12G test_vg/vdo_pool_lv")
+      '';
+    }
+    .${flavour};
+
+  extraConfig =
+    {
+      raid = {
+        boot.initrd.kernelModules = [
+          "dm-raid"
+          "raid0"
+        ];
+      };
+
+      thinpool = {
+        services.lvm = {
+          boot.thin.enable = true;
+          dmeventd.enable = true;
+        };
+      };
+
+      vdo = {
+        services.lvm = {
+          boot.vdo.enable = true;
+          dmeventd.enable = true;
+        };
+      };
+    }
+    .${flavour};
+
+  extraCheck =
+    {
+      raid = ''
+        "test_lv" in machine.succeed("lvs --select segtype=raid0")
+      '';
+
+      thinpool = ''
+        "test_lv" in machine.succeed("lvs --select segtype=thin-pool")
+      '';
+
+      vdo = ''
+        "test_lv" in machine.succeed("lvs --select segtype=vdo")
+      '';
+    }
+    .${flavour};
+
+in
+import ../make-test-python.nix (
+  { pkgs, lib, ... }:
+  {
+    name = "lvm2-${flavour}-systemd-stage-1";
+    meta.maintainers = lib.teams.helsinki-systems.members;
+
+    nodes.machine =
+      { pkgs, lib, ... }:
+      {
+        imports = [ extraConfig ];
+        # Use systemd-boot
+        virtualisation = {
+          emptyDiskImages = [
+            8192
+            8192
+          ];
+          useBootLoader = true;
+          useEFIBoot = true;
+          # To boot off the LVM disk, we need to have a init script which comes from the Nix store.
+          mountHostNixStore = true;
+        };
+        boot.loader.systemd-boot.enable = true;
+        boot.loader.efi.canTouchEfiVariables = true;
+
+        environment.systemPackages = with pkgs; [ xfsprogs ];
+        boot = {
+          initrd.systemd = {
+            enable = true;
+            emergencyAccess = true;
+          };
+          initrd.services.lvm.enable = true;
+          kernelPackages = lib.mkIf (kernelPackages != null) kernelPackages;
+        };
+
+        specialisation.boot-lvm.configuration.virtualisation = {
+          useDefaultFilesystems = false;
+          fileSystems = {
+            "/" = {
+              device = "/dev/test_vg/test_lv";
+              fsType = "xfs";
+            };
+          };
+
+          rootDevice = "/dev/test_vg/test_lv";
+        };
+      };
+
+    testScript = ''
+      machine.wait_for_unit("multi-user.target")
+      # Create a VG for the root
+      ${preparationCode}
+      machine.succeed("mkfs.xfs ${mkXfsFlags} /dev/test_vg/test_lv")
+      machine.succeed("mkdir -p /mnt && mount /dev/test_vg/test_lv /mnt && echo hello > /mnt/test && umount /mnt")
+
+      # Boot from LVM
+      machine.succeed("bootctl set-default nixos-generation-1-specialisation-boot-lvm.conf")
+      machine.succeed("sync")
+      machine.crash()
+      machine.wait_for_unit("multi-user.target")
+
+      # Ensure we have successfully booted from LVM
+      assert "(initrd)" in machine.succeed("systemd-analyze")  # booted with systemd in stage 1
+      assert "/dev/mapper/test_vg-test_lv on / type xfs" in machine.succeed("mount")
+      assert "hello" in machine.succeed("cat /test")
+      ${extraCheck}
+    '';
+  }
+)

nixos/tests/lvm2/thinpool.nix

@@ -0,0 +1,46 @@
+{
+  kernelPackages ? null,
+  mkXfsFlags ? "",
+}:
+import ../make-test-python.nix (
+  { pkgs, lib, ... }:
+  {
+    name = "lvm2-thinpool";
+    meta.maintainers = lib.teams.helsinki-systems.members;
+
+    nodes.machine =
+      { pkgs, lib, ... }:
+      {
+        virtualisation.emptyDiskImages = [ 4096 ];
+        services.lvm = {
+          boot.thin.enable = true;
+          dmeventd.enable = true;
+        };
+        environment.systemPackages = with pkgs; [ xfsprogs ];
+        environment.etc."lvm/lvm.conf".text = ''
+          activation/thin_pool_autoextend_percent = 10
+          activation/thin_pool_autoextend_threshold = 80
+        '';
+        boot = lib.mkIf (kernelPackages != null) { inherit kernelPackages; };
+      };
+
+    testScript =
+      let
+        mkXfsFlags =
+          lib.optionalString (lib.versionOlder kernelPackages.kernel.version "5.10") " -m bigtime=0 -m inobtcount=0 "
+          + lib.optionalString (lib.versionOlder kernelPackages.kernel.version "5.19") " -i nrext64=0 ";
+      in
+      ''
+        machine.succeed("vgcreate test_vg /dev/vdb")
+        machine.succeed("lvcreate -L 512M -T test_vg/test_thin_pool")
+        machine.succeed("lvcreate -n test_lv -V 16G --thinpool test_thin_pool test_vg")
+        machine.succeed("mkfs.xfs ${mkXfsFlags} /dev/test_vg/test_lv")
+        machine.succeed("mkdir /mnt; mount /dev/test_vg/test_lv /mnt")
+        assert "/dev/mapper/test_vg-test_lv" == machine.succeed("findmnt -no SOURCE /mnt").strip()
+        machine.succeed("dd if=/dev/zero of=/mnt/empty.file bs=1M count=1024")
+        machine.succeed("journalctl -u dm-event.service | grep \"successfully resized\"")
+        machine.succeed("umount /mnt")
+        machine.succeed("vgchange -a n")
+      '';
+  }
+)

nixos/tests/lvm2/vdo.nix

@@ -0,0 +1,35 @@
+{
+  kernelPackages ? null,
+  mkXfsFlags ? "",
+}:
+import ../make-test-python.nix (
+  { pkgs, lib, ... }:
+  {
+    name = "lvm2-vdo";
+    meta.maintainers = [ ];
+
+    nodes.machine =
+      { pkgs, lib, ... }:
+      {
+        # Minimum required size for VDO volume: 5063921664 bytes
+        virtualisation.emptyDiskImages = [ 8192 ];
+        services.lvm = {
+          boot.vdo.enable = true;
+          dmeventd.enable = true;
+        };
+        environment.systemPackages = with pkgs; [ xfsprogs ];
+        boot = lib.mkIf (kernelPackages != null) { inherit kernelPackages; };
+      };
+
+    testScript = ''
+      machine.succeed("vgcreate test_vg /dev/vdb")
+      machine.succeed("lvcreate --type vdo -n vdo_lv -L 6G -V 12G test_vg/vdo_pool_lv")
+      machine.succeed("mkfs.xfs ${mkXfsFlags} -K /dev/test_vg/vdo_lv")
+      machine.succeed("mkdir /mnt; mount /dev/test_vg/vdo_lv /mnt")
+      assert "/dev/mapper/test_vg-vdo_lv" == machine.succeed("findmnt -no SOURCE /mnt").strip()
+      machine.succeed("umount /mnt")
+      machine.succeed("vdostats")
+      machine.succeed("vgchange -a n")
+    '';
+  }
+)