nixos/tests/storage: Pass storage config as XML.

We're internally calling nix-instantiate to get the required options
from the configuration, so let's pass it through an option that skips
this step.

Signed-off-by: aszlig <aszlig@redmoonstudios.org>

nixos/modules/config/swap.nix

@@ -15,6 +15,16 @@ let
         description = "Path of the device.";
       };
 
+      storage = mkOption {
+        default = null;
+        example = "partition.swap";
+        type = types.nullOr types.str;
+        description = ''
+          Storage device from <option>storage.*</option> to use for
+          this swap device.
+        '';
+      };
+
       label = mkOption {
         example = "swap";
         type = types.str;
@@ -98,8 +108,9 @@ in
         The swap devices and swap files.  These must have been
         initialised using <command>mkswap</command>.  Each element
         should be an attribute set specifying either the path of the
-        swap device or file (<literal>device</literal>) or the label
-        of the swap device (<literal>label</literal>, see
+        swap device or file (<literal>device</literal>), the device
+        from the storage configuration (<option>storage.*</option>) or
+        the label of the swap device (<literal>label</literal>, see
         <command>mkswap -L</command>).  Using a label is
         recommended.
       '';
@@ -152,7 +163,7 @@ in
             serviceConfig.ExecStop = optionalString sw.randomEncryption "cryptsetup luksClose ${sw.deviceName}";
           };
 
-      in listToAttrs (map createSwapDevice (filter (sw: sw.size != null || sw.randomEncryption) config.swapDevices));
+      in listToAttrs (map createSwapDevice (filter (sw: sw.device == null && (sw.size != null || sw.randomEncryption)) config.swapDevices));
 
   };
 

nixos/modules/module-list.nix

@@ -494,6 +494,7 @@
   ./tasks/network-interfaces-systemd.nix
   ./tasks/network-interfaces-scripted.nix
   ./tasks/scsi-link-power-management.nix
+  ./tasks/storage.nix
   ./tasks/swraid.nix
   ./tasks/trackpoint.nix
   ./testing/service-runner.nix

nixos/modules/tasks/filesystems.nix

@@ -26,6 +26,16 @@ let
         description = "Location of the device.";
       };
 
+      storage = mkOption {
+        default = null;
+        example = "partition.root";
+        type = types.nullOr types.str;
+        description = ''
+          Storage device from <option>storage.*</option> to use for
+          this file system.
+        '';
+      };
+
       label = mkOption {
         default = null;
         example = "root-partition";
@@ -129,10 +139,10 @@ in
         (the mount options passed to <command>mount</command> using the
         <option>-o</option> flag; defaults to <literal>"defaults"</literal>).
 
-        Instead of specifying <literal>device</literal>, you can also
+        Instead of specifying <literal>device</literal>, you can also either
         specify a volume label (<literal>label</literal>) for file
         systems that support it, such as ext2/ext3 (see <command>mke2fs
-        -L</command>).
+        -L</command>) or reference a device from <option>storage.*</option>.
       '';
     };
 

nixos/modules/tasks/storage.nix

@@ -0,0 +1,185 @@
+{ lib, ... }:
+
+with lib;
+
+let
+  sizeType = types.either types.int types.str;
+  deviceType = types.str;
+  volgroupType = types.str;
+
+  commonOptions = {
+    grow = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Grow the partition to the remaining size of the target device.
+      '';
+    };
+
+    size = mkOption {
+      type = types.nullOr sizeType;
+      default = null;
+      description = ''
+        Size of the partition either as an integer in megabytes or
+        as a string with a size multiplier suffix (M, G, T, ...).
+      '';
+    };
+
+    before = mkOption {
+      type = types.listOf deviceType;
+      default = [];
+      description = ''
+        List of devices/partitions that will be created
+        after this partition.
+      '';
+    };
+
+    after = mkOption {
+      type = types.listOf deviceType;
+      default = [];
+      description = ''
+        List of devices/partitions that will be created
+        prior to this partition.
+      '';
+    };
+  };
+
+  partitionOptions.options = commonOptions // {
+    targetDevice = mkOption {
+      type = deviceType;
+      description = ''
+        The target device of this partition.
+      '';
+    };
+  };
+
+  mdraidOptions.options = commonOptions // {
+    level = mkOption {
+      type = types.int;
+      default = 1;
+      description = ''
+        RAID level, default is 1 for mirroring.
+      '';
+    };
+
+    devices = mkOption {
+      type = types.listOf deviceType;
+      description = ''
+        List of devices that will be part of this array.
+      '';
+    };
+  };
+
+  volgroupOptions.options = commonOptions // {
+    devices = mkOption {
+      type = types.listOf deviceType;
+      description = ''
+        List of devices that will be part of this volume group.
+      '';
+    };
+  };
+
+  logvolOptions.options = commonOptions // {
+    group = mkOption {
+      type = volgroupType;
+      description = ''
+        The volume group this volume should be part of.
+      '';
+    };
+  };
+
+  btrfsOptions.options = commonOptions // {
+    devices = mkOption {
+      type = types.listOf deviceType;
+      description = ''
+        List of devices that will be part of this BTRFS volume.
+      '';
+    };
+
+    data = mkOption {
+      type = types.nullOr types.int;
+      default = null;
+      description = ''
+        RAID level to use for filesystem data.
+      '';
+    };
+
+    metadata = mkOption {
+      type = types.nullOr types.int;
+      default = null;
+      description = ''
+        RAID level to use for filesystem metadata.
+      '';
+    };
+  };
+
+  diskOptions.options = {
+    clear = mkOption {
+      type = types.bool;
+      description = ''
+        Clear the partition table of this device.
+      '';
+    };
+
+    initlabel = mkOption {
+      type = types.bool;
+      description = ''
+        Create a new disk label for this device (implies
+        <option>clear</option>).
+      '';
+    };
+  };
+
+in
+
+{
+  options.storage = {
+    partition = mkOption {
+      type = types.attrsOf (types.submodule partitionOptions);
+      default = {};
+      description = ''
+        Storage configuration for a disk partition.
+      '';
+    };
+
+    mdraid = mkOption {
+      type = types.attrsOf (types.submodule mdraidOptions);
+      default = {};
+      description = ''
+        Storage configuration for a RAID device.
+      '';
+    };
+
+    volgroup = mkOption {
+      type = types.attrsOf (types.submodule volgroupOptions);
+      default = {};
+      description = ''
+        Storage configuration for a LVM volume group.
+      '';
+    };
+
+    logvol = mkOption {
+      type = types.attrsOf (types.submodule logvolOptions);
+      default = {};
+      description = ''
+        Storage configuration for a LVM logical volume.
+      '';
+    };
+
+    btrfs = mkOption {
+      type = types.attrsOf (types.submodule btrfsOptions);
+      default = {};
+      description = ''
+        Storage configuration for a BTRFS volume.
+      '';
+    };
+
+    disk = mkOption {
+      type = types.attrsOf (types.submodule diskOptions);
+      default = {};
+      description = ''
+        Storage configuration for a disk.
+      '';
+    };
+  };
+}

nixos/release.nix

@@ -287,6 +287,7 @@ in rec {
   tests.runInMachine = callTest tests/run-in-machine.nix {};
   tests.sddm = callTest tests/sddm.nix {};
   tests.simple = callTest tests/simple.nix {};
+  tests.storage = callTest tests/storage.nix {};
   tests.tomcat = callTest tests/tomcat.nix {};
   tests.udisks2 = callTest tests/udisks2.nix {};
   tests.virtualbox = hydraJob (import tests/virtualbox.nix { system = "x86_64-linux"; });

nixos/tests/partition.nix

@@ -1,247 +0,0 @@
-import ./make-test.nix ({ pkgs, ... }:
-
-with pkgs.lib;
-
-let
-  ksExt = pkgs.writeText "ks-ext4" ''
-    clearpart --all --initlabel --drives=vdb
-
-    part /boot --recommended --label=boot --fstype=ext2 --ondisk=vdb
-    part swap --recommended --label=swap --fstype=swap --ondisk=vdb
-    part /nix --size=500 --label=nix --fstype=ext3 --ondisk=vdb
-    part / --recommended --label=root --fstype=ext4 --ondisk=vdb
-  '';
-
-  ksBtrfs = pkgs.writeText "ks-btrfs" ''
-    clearpart --all --initlabel --drives=vdb,vdc
-
-    part swap1 --recommended --label=swap1 --fstype=swap --ondisk=vdb
-    part swap2 --recommended --label=swap2 --fstype=swap --ondisk=vdc
-
-    part btrfs.1 --grow --ondisk=vdb
-    part btrfs.2 --grow --ondisk=vdc
-
-    btrfs / --data=0 --metadata=1 --label=root btrfs.1 btrfs.2
-  '';
-
-  ksF2fs = pkgs.writeText "ks-f2fs" ''
-    clearpart --all --initlabel --drives=vdb
-
-    part swap  --recommended --label=swap --fstype=swap --ondisk=vdb
-    part /boot --recommended --label=boot --fstype=f2fs --ondisk=vdb
-    part /     --recommended --label=root --fstype=f2fs --ondisk=vdb
-  '';
-
-  ksRaid = pkgs.writeText "ks-raid" ''
-    clearpart --all --initlabel --drives=vdb,vdc
-
-    part raid.01 --size=200 --ondisk=vdb
-    part raid.02 --size=200 --ondisk=vdc
-
-    part swap1 --size=500 --label=swap1 --fstype=swap --ondisk=vdb
-    part swap2 --size=500 --label=swap2 --fstype=swap --ondisk=vdc
-
-    part raid.11 --grow --ondisk=vdb
-    part raid.12 --grow --ondisk=vdc
-
-    raid /boot --level=1 --fstype=ext3 --device=md0 raid.01 raid.02
-    raid / --level=1 --fstype=xfs --device=md1 raid.11 raid.12
-  '';
-
-  ksRaidLvmCrypt = pkgs.writeText "ks-lvm-crypt" ''
-    clearpart --all --initlabel --drives=vdb,vdc
-
-    part raid.1 --grow --ondisk=vdb
-    part raid.2 --grow --ondisk=vdc
-
-    raid pv.0 --level=1 --encrypted --passphrase=x --device=md0 raid.1 raid.2
-
-    volgroup nixos pv.0
-
-    logvol /boot --size=200 --fstype=ext3 --name=boot --vgname=nixos
-    logvol swap --size=500 --fstype=swap --name=swap --vgname=nixos
-    logvol / --size=1000 --grow --fstype=ext4 --name=root --vgname=nixos
-  '';
-in {
-  name = "partitiion";
-
-  machine = { config, pkgs, ... }: {
-    environment.systemPackages = [
-      pkgs.pythonPackages.nixpart0
-      pkgs.file pkgs.btrfsProgs pkgs.xfsprogs pkgs.lvm2
-    ];
-    virtualisation.emptyDiskImages = [ 4096 4096 ];
-  };
-
-  testScript = ''
-    my $diskStart;
-    my @mtab;
-
-    sub getMtab {
-      my $mounts = $machine->succeed("cat /proc/mounts");
-      chomp $mounts;
-      return map [split], split /\n/, $mounts;
-    }
-
-    sub parttest {
-      my ($desc, $code) = @_;
-      $machine->start;
-      $machine->waitForUnit("default.target");
-
-      # Gather mounts and superblock
-      @mtab = getMtab;
-      $diskStart = $machine->succeed("dd if=/dev/vda bs=512 count=1");
-
-      subtest($desc, $code);
-      $machine->shutdown;
-    }
-
-    sub ensureSanity {
-      # Check whether the filesystem in /dev/vda is still intact
-      my $newDiskStart = $machine->succeed("dd if=/dev/vda bs=512 count=1");
-      if ($diskStart ne $newDiskStart) {
-        $machine->log("Something went wrong, the partitioner wrote " .
-                      "something into the first 512 bytes of /dev/vda!");
-        die;
-      }
-
-      # Check whether nixpart has unmounted anything
-      my @currentMtab = getMtab;
-      for my $mount (@mtab) {
-        my $path = $mount->[1];
-        unless (grep { $_->[1] eq $path } @currentMtab) {
-          $machine->log("The partitioner seems to have unmounted $path.");
-          die;
-        }
-      }
-    }
-
-    sub checkMount {
-      my $mounts = $machine->succeed("cat /proc/mounts");
-
-    }
-
-    sub kickstart {
-      $machine->copyFileFromHost($_[0], "/kickstart");
-      $machine->succeed("nixpart -v /kickstart");
-      ensureSanity;
-    }
-
-    sub ensurePartition {
-      my ($name, $match) = @_;
-      my $path = $name =~ /^\// ? $name : "/dev/disk/by-label/$name";
-      my $out = $machine->succeed("file -Ls $path");
-      my @matches = grep(/^$path: .*$match/i, $out);
-      if (!@matches) {
-        $machine->log("Partition on $path was expected to have a " .
-                      "file system that matches $match, but instead has: $out");
-        die;
-      }
-    }
-
-    sub ensureNoPartition {
-      $machine->succeed("test ! -e /dev/$_[0]");
-    }
-
-    sub ensureMountPoint {
-      $machine->succeed("mountpoint $_[0]");
-    }
-
-    sub remountAndCheck {
-      $machine->nest("Remounting partitions:", sub {
-        # XXX: "findmnt -ARunl -oTARGET /mnt" seems to NOT print all mounts!
-        my $getmounts_cmd = "cat /proc/mounts | cut -d' ' -f2 | grep '^/mnt'";
-        # Insert canaries first
-        my $canaries = $machine->succeed($getmounts_cmd . " | while read p;" .
-                                         " do touch \"\$p/canary\";" .
-                                         " echo \"\$p/canary\"; done");
-        # Now unmount manually
-        $machine->succeed($getmounts_cmd . " | tac | xargs -r umount");
-        # /mnt should be empty or non-existing
-        my $found = $machine->succeed("find /mnt -mindepth 1");
-        chomp $found;
-        if ($found) {
-          $machine->log("Cruft found in /mnt:\n$found");
-          die;
-        }
-        # Try to remount with nixpart
-        $machine->succeed("nixpart -vm /kickstart");
-        ensureMountPoint("/mnt");
-        # Check if our beloved canaries are dead
-        chomp $canaries;
-        $machine->nest("Checking canaries:", sub {
-          for my $canary (split /\n/, $canaries) {
-            $machine->succeed("test -e '$canary'");
-          }
-        });
-      });
-    }
-
-    parttest "ext2, ext3 and ext4 filesystems", sub {
-      kickstart("${ksExt}");
-      ensurePartition("boot", "ext2");
-      ensurePartition("swap", "swap");
-      ensurePartition("nix", "ext3");
-      ensurePartition("root", "ext4");
-      ensurePartition("/dev/vdb4", "boot sector");
-      ensureNoPartition("vdb6");
-      ensureNoPartition("vdc1");
-      remountAndCheck;
-      ensureMountPoint("/mnt/boot");
-      ensureMountPoint("/mnt/nix");
-    };
-
-    parttest "btrfs filesystem", sub {
-      $machine->succeed("modprobe btrfs");
-      kickstart("${ksBtrfs}");
-      ensurePartition("swap1", "swap");
-      ensurePartition("swap2", "swap");
-      ensurePartition("/dev/vdb2", "btrfs");
-      ensurePartition("/dev/vdc2", "btrfs");
-      ensureNoPartition("vdb3");
-      ensureNoPartition("vdc3");
-      remountAndCheck;
-    };
-
-    parttest "f2fs filesystem", sub {
-      $machine->succeed("modprobe f2fs");
-      kickstart("${ksF2fs}");
-      ensurePartition("swap", "swap");
-      ensurePartition("boot", "f2fs");
-      ensurePartition("root", "f2fs");
-      remountAndCheck;
-      ensureMountPoint("/mnt/boot", "f2fs");
-    };
-
-    parttest "RAID1 with XFS", sub {
-      kickstart("${ksRaid}");
-      ensurePartition("swap1", "swap");
-      ensurePartition("swap2", "swap");
-      ensurePartition("/dev/md0", "ext3");
-      ensurePartition("/dev/md1", "xfs");
-      ensureNoPartition("vdb4");
-      ensureNoPartition("vdc4");
-      ensureNoPartition("md2");
-      remountAndCheck;
-      ensureMountPoint("/mnt/boot");
-    };
-
-    parttest "RAID1 with LUKS and LVM", sub {
-      kickstart("${ksRaidLvmCrypt}");
-      ensurePartition("/dev/vdb1", "data");
-      ensureNoPartition("vdb2");
-      ensurePartition("/dev/vdc1", "data");
-      ensureNoPartition("vdc2");
-
-      ensurePartition("/dev/md0", "luks");
-      ensureNoPartition("md1");
-
-      ensurePartition("/dev/nixos/boot", "ext3");
-      ensurePartition("/dev/nixos/swap", "swap");
-      ensurePartition("/dev/nixos/root", "ext4");
-
-      remountAndCheck;
-      ensureMountPoint("/mnt/boot");
-    };
-  '';
-})

nixos/tests/storage.nix

@@ -0,0 +1,396 @@
+import ./make-test.nix ({ pkgs, ... }:
+
+with pkgs.lib;
+
+let
+  mkConf = cfg: let
+    config = (import <nixpkgs/nixos/lib/eval-config.nix> {
+      modules = singleton cfg;
+    }).config;
+  in pkgs.writeText "storage.xml" (builtins.toXML {
+    inherit (config) storage fileSystems swapDevices;
+  });
+
+  ext = {
+    storage = {
+      disk.vdb.clear = true;
+      disk.vdb.initlabel = true;
+
+      partition.boot.size = "100M";
+      partition.boot.targetDevice = "disk.vdb";
+      partition.swap.size = "500M";
+      partition.swap.targetDevice = "disk.vdb";
+      partition.nix.size = "500M";
+      partition.nix.targetDevice = "disk.vdb";
+      partition.root.grow = true;
+      partition.root.targetDevice = "disk.vdb";
+    };
+
+    fileSystems."/boot" = {
+      label = "boot";
+      fsType = "ext2";
+      storage = "partition.boot";
+    };
+
+    fileSystems."/nix" = {
+      label = "nix";
+      fsType = "ext3";
+      storage = "partition.nix";
+    };
+
+    fileSystems."/" = {
+      label = "root";
+      fsType = "ext4";
+      storage = "partition.root";
+    };
+
+    swapDevices = [
+      { label = "swap"; storage = "partition.swap"; }
+    ];
+  };
+
+  btrfs = {
+    storage = {
+      disk.vdb.clear = true;
+      disk.vdb.initlabel = true;
+
+      partition.swap1.size = "500M";
+      partition.swap1.targetDevice = "disk.vdb";
+      partition.btrfs1.grow = true;
+      partition.btrfs1.targetDevice = "disk.vdb";
+
+      disk.vdc.clear = true;
+      disk.vdc.initlabel = true;
+
+      partition.swap2.size = "500M";
+      partition.swap2.targetDevice = "disk.vdc";
+      partition.btrfs2.grow = true;
+      partition.btrfs2.targetDevice = "disk.vdc";
+
+      btrfs.root.data = 0;
+      btrfs.root.metadata = 1;
+      btrfs.root.devices = [ "partition.btrfs1" "partition.btrfs2" ];
+    };
+
+    fileSystems."/" = {
+      label = "root";
+      storage = "btrfs.root";
+    };
+
+    swapDevices = [
+      { label = "swap1"; storage = "partition.swap1"; }
+      { label = "swap2"; storage = "partition.swap2"; }
+    ];
+  };
+
+  f2fs = {
+    storage = {
+      disk.vdb.clear = true;
+      disk.vdb.initlabel = true;
+
+      partition.swap.size = "500M";
+      partition.swap.targetDevice = "disk.vdb";
+      partition.boot.size = "100M";
+      partition.boot.targetDevice = "disk.vdb";
+      partition.root.grow = true;
+      partition.root.targetDevice = "disk.vdb";
+    };
+
+    fileSystems."/boot" = {
+      label = "boot";
+      fsType = "f2fs";
+      storage = "partition.boot";
+    };
+
+    fileSystems."/" = {
+      label = "root";
+      fsType = "f2fs";
+      storage = "partition.root";
+    };
+
+    swapDevices = [
+      { label = "swap"; storage = "partition.swap"; }
+    ];
+  };
+
+  raid = {
+    storage = {
+      disk.vdb.clear = true;
+      disk.vdb.initlabel = true;
+
+      partition.raid01.size = "200M";
+      partition.raid01.targetDevice = "disk.vdb";
+      partition.swap1.size = "500M";
+      partition.swap1.targetDevice = "disk.vdb";
+      partition.raid11.grow = true;
+      partition.raid11.targetDevice = "disk.vdb";
+
+      disk.vdc.clear = true;
+      disk.vdc.initlabel = true;
+
+      partition.raid02.size = "200M";
+      partition.raid02.targetDevice = "disk.vdc";
+      partition.swap2.size = "500M";
+      partition.swap2.targetDevice = "disk.vdc";
+      partition.raid12.grow = true;
+      partition.raid12.targetDevice = "disk.vdc";
+
+      mdraid.boot.level = 1;
+      mdraid.boot.devices = [ "partition.raid01" "partition.raid02" ];
+
+      mdraid.root.level = 1;
+      mdraid.root.devices = [ "partition.raid11" "partition.raid12" ];
+    };
+
+    fileSystems."/boot" = {
+      label = "boot";
+      fsType = "ext3";
+      storage = "mdraid.boot";
+    };
+
+    fileSystems."/" = {
+      label = "root";
+      fsType = "xfs";
+      storage = "mdraid.root";
+    };
+
+    swapDevices = [
+      { label = "swap1"; storage = "partition.swap1"; }
+      { label = "swap2"; storage = "partition.swap2"; }
+    ];
+  };
+
+  raidLvmCrypt = {
+    storage = {
+      disk.vdb.clear = true;
+      disk.vdb.initlabel = true;
+
+      partition.raid1.grow = true;
+      partition.raid1.targetDevice = "disk.vdb";
+
+      disk.vdc.clear = true;
+      disk.vdc.initlabel = true;
+
+      partition.raid2.grow = true;
+      partition.raid2.targetDevice = "disk.vdc";
+
+      mdraid.raid.level = 1;
+      mdraid.raid.devices = [ "partition.raid1" "partition.raid2" ];
+
+      /* TODO!
+      luks.volroot.passphrase = "x";
+      luks.volroot.targetDevice = "mdraid.raid";
+      */
+
+      volgroup.nixos.devices = [ "luks.volroot" ];
+
+      logvol.boot.size = "200M";
+      logvol.boot.group = "volgroup.nixos";
+
+      logvol.swap.size = "500M";
+      logvol.swap.group = "volgroup.nixos";
+
+      logvol.root.grow = true;
+      logvol.root.group = "volgroup.nixos";
+    };
+
+    fileSystems."/boot" = {
+      label = "boot";
+      fsType = "ext3";
+      storage = "logvol.boot";
+    };
+
+    fileSystems."/" = {
+      label = "root";
+      fsType = "ext4";
+      storage = "logvol.root";
+    };
+
+    swapDevices = [
+      { label = "swap"; storage = "logvol.swap"; }
+    ];
+  };
+
+in {
+  name = "partitiion";
+
+  machine = { config, pkgs, ... }: {
+    environment.systemPackages = [
+      pkgs.pythonPackages.nixpart
+      pkgs.file pkgs.btrfsProgs pkgs.xfsprogs pkgs.lvm2
+    ];
+    virtualisation.emptyDiskImages = [ 4096 4096 ];
+  };
+
+  testScript = ''
+    my $diskStart;
+    my @mtab;
+
+    sub getMtab {
+      my $mounts = $machine->succeed("cat /proc/mounts");
+      chomp $mounts;
+      return map [split], split /\n/, $mounts;
+    }
+
+    sub parttest {
+      my ($desc, $code) = @_;
+      $machine->start;
+      $machine->waitForUnit("default.target");
+
+      # Gather mounts and superblock
+      @mtab = getMtab;
+      $diskStart = $machine->succeed("dd if=/dev/vda bs=512 count=1");
+
+      subtest($desc, $code);
+      $machine->shutdown;
+    }
+
+    sub ensureSanity {
+      # Check whether the filesystem in /dev/vda is still intact
+      my $newDiskStart = $machine->succeed("dd if=/dev/vda bs=512 count=1");
+      if ($diskStart ne $newDiskStart) {
+        $machine->log("Something went wrong, the partitioner wrote " .
+                      "something into the first 512 bytes of /dev/vda!");
+        die;
+      }
+
+      # Check whether nixpart has unmounted anything
+      my @currentMtab = getMtab;
+      for my $mount (@mtab) {
+        my $path = $mount->[1];
+        unless (grep { $_->[1] eq $path } @currentMtab) {
+          $machine->log("The partitioner seems to have unmounted $path.");
+          die;
+        }
+      }
+    }
+
+    sub checkMount {
+      my $mounts = $machine->succeed("cat /proc/mounts");
+
+    }
+
+    sub nixpart {
+      $machine->copyFileFromHost($_[0], "/storage.xml");
+      $machine->succeed("nixpart -v --from-xml /storage.xml");
+      ensureSanity;
+    }
+
+    sub ensurePartition {
+      my ($name, $match) = @_;
+      my $path = $name =~ /^\// ? $name : "/dev/disk/by-label/$name";
+      my $out = $machine->succeed("file -Ls $path");
+      my @matches = grep(/^$path: .*$match/i, $out);
+      if (!@matches) {
+        $machine->log("Partition on $path was expected to have a " .
+                      "file system that matches $match, but instead has: $out");
+        die;
+      }
+    }
+
+    sub ensureNoPartition {
+      $machine->succeed("test ! -e /dev/$_[0]");
+    }
+
+    sub ensureMountPoint {
+      $machine->succeed("mountpoint $_[0]");
+    }
+
+    sub remountAndCheck {
+      $machine->nest("Remounting partitions:", sub {
+        # XXX: "findmnt -ARunl -oTARGET /mnt" seems to NOT print all mounts!
+        my $getmounts_cmd = "cat /proc/mounts | cut -d' ' -f2 | grep '^/mnt'";
+        # Insert canaries first
+        my $canaries = $machine->succeed($getmounts_cmd . " | while read p;" .
+                                         " do touch \"\$p/canary\";" .
+                                         " echo \"\$p/canary\"; done");
+        # Now unmount manually
+        $machine->succeed($getmounts_cmd . " | tac | xargs -r umount");
+        # /mnt should be empty or non-existing
+        my $found = $machine->succeed("find /mnt -mindepth 1");
+        chomp $found;
+        if ($found) {
+          $machine->log("Cruft found in /mnt:\n$found");
+          die;
+        }
+        # Try to remount with nixpart
+        $machine->succeed("nixpart -vm --from-xml /storage.xml");
+        ensureMountPoint("/mnt");
+        # Check if our beloved canaries are dead
+        chomp $canaries;
+        $machine->nest("Checking canaries:", sub {
+          for my $canary (split /\n/, $canaries) {
+            $machine->succeed("test -e '$canary'");
+          }
+        });
+      });
+    }
+
+    parttest "ext2, ext3 and ext4 filesystems", sub {
+      nixpart("${mkConf ext}");
+      ensurePartition("boot", "ext2");
+      ensurePartition("swap", "swap");
+      ensurePartition("nix", "ext3");
+      ensurePartition("root", "ext4");
+      ensurePartition("/dev/vdb4", "boot sector");
+      ensureNoPartition("vdb6");
+      ensureNoPartition("vdc1");
+      remountAndCheck;
+      ensureMountPoint("/mnt/boot");
+      ensureMountPoint("/mnt/nix");
+    };
+
+    parttest "btrfs filesystem", sub {
+      $machine->succeed("modprobe btrfs");
+      nixpart("${mkConf btrfs}");
+      ensurePartition("swap1", "swap");
+      ensurePartition("swap2", "swap");
+      ensurePartition("/dev/vdb2", "btrfs");
+      ensurePartition("/dev/vdc2", "btrfs");
+      ensureNoPartition("vdb3");
+      ensureNoPartition("vdc3");
+      remountAndCheck;
+    };
+
+    parttest "f2fs filesystem", sub {
+      $machine->succeed("modprobe f2fs");
+      nixpart("${mkConf f2fs}");
+      ensurePartition("swap", "swap");
+      ensurePartition("boot", "f2fs");
+      ensurePartition("root", "f2fs");
+      remountAndCheck;
+      ensureMountPoint("/mnt/boot", "f2fs");
+    };
+
+    parttest "RAID1 with XFS", sub {
+      nixpart("${mkConf raid}");
+      ensurePartition("swap1", "swap");
+      ensurePartition("swap2", "swap");
+      ensurePartition("/dev/md0", "ext3");
+      ensurePartition("/dev/md1", "xfs");
+      ensureNoPartition("vdb4");
+      ensureNoPartition("vdc4");
+      ensureNoPartition("md2");
+      remountAndCheck;
+      ensureMountPoint("/mnt/boot");
+    };
+
+    parttest "RAID1 with LUKS and LVM", sub {
+      nixpart("${mkConf raidLvmCrypt}");
+      ensurePartition("/dev/vdb1", "data");
+      ensureNoPartition("vdb2");
+      ensurePartition("/dev/vdc1", "data");
+      ensureNoPartition("vdc2");
+
+      ensurePartition("/dev/md0", "luks");
+      ensureNoPartition("md1");
+
+      ensurePartition("/dev/nixos/boot", "ext3");
+      ensurePartition("/dev/nixos/swap", "swap");
+      ensurePartition("/dev/nixos/root", "ext4");
+
+      remountAndCheck;
+      ensureMountPoint("/mnt/boot");
+    };
+  '';
+})