commit 07ed5f418cf6aace306f2caa424bf5a066b95ad7 · pyrox.dev/nixpkgs

+40 -16

nixos/modules/virtualisation/qemu-vm.nix

···

       20
       20
        
       

     

       21
       21
        
         cfg = config.virtualisation;

     

       22
       22
        
       

     

       23
       23
       -
         opt = options.virtualisation;

     

       24
       24
       -
       

     

       25
       23
        
         qemu = cfg.qemu.package;

     

       26
       24
        
       

     

       27
       25
        
         hostPkgs = cfg.host.pkgs;

     

       28
       26
        
       

     

       29
       27
        
         consoles = lib.concatMapStringsSep " " (c: "console=${c}") cfg.qemu.consoles;

     

       30
       28
        
       

     

       31
       31
       -
         driveOpts =

     

       29
       29
       +
         driveOptions =

     

       32
       30
        
           { ... }:

     

       33
       31
        
           {

     

       34
       32
        
       

     

       35
       33
        
             options = {

     

       36
       36
       -
       

     

       37
       37
       -
               file = mkOption {

     

       38
       38
       -
                 type = types.str;

     

       39
       39
       -
                 description = "The file image used for this drive.";

     

       40
       40
       -
               };

     

       41
       41
       -
       

     

       42
       34
        
               driveExtraOpts = mkOption {

     

       43
       35
        
                 type = types.attrsOf types.str;

     

       44
       36
        
                 default = { };

     
···

       299
       291
        
       

     

       300
       292
        
           ${lib.pipe cfg.emptyDiskImages [

     

       301
       293
        
             (lib.imap0 (

     

       302
       302
       -
               idx: size: ''

     

       294
       294
       +
               idx:

     

       295
       295
       +
               { size, ... }:

     

       296
       296
       +
               ''

     

       303
       297
        
                 test -e "empty${builtins.toString idx}.qcow2" || ${qemu}/bin/qemu-img create -f qcow2 "empty${builtins.toString idx}.qcow2" "${builtins.toString size}M"

     

       304
       298
        
               ''

     

       305
       299
        
             ))

     
···

       477
       471
        
           };

     

       478
       472
        
       

     

       479
       473
        
           virtualisation.emptyDiskImages = mkOption {

     

       480
       480
       -
             type = types.listOf types.ints.positive;

     

       474
       474
       +
             type = types.listOf (

     

       475
       475
       +
               types.coercedTo types.ints.positive (size: { inherit size; }) (

     

       476
       476
       +
                 types.submodule {

     

       477
       477
       +
                   options.size = mkOption {

     

       478
       478
       +
                     type = types.ints.positive;

     

       479
       479
       +
                     description = "The size of the disk in MiB";

     

       480
       480
       +
                   };

     

       481
       481
       +
                   options.driveConfig = mkOption {

     

       482
       482
       +
                     type = lib.types.submodule driveOptions;

     

       483
       483
       +
                     description = "Drive configuration to pass to {option}`virtualisation.qemu.drives`";

     

       484
       484
       +
                   };

     

       485
       485
       +
                 }

     

       486
       486
       +
               )

     

       487
       487
       +
             );

     

       481
       488
        
             default = [ ];

     

       482
       489
        
             description = ''

     

       483
       490
        
               Additional disk images to provide to the VM. The value is

     
···

       829
       836
        
             };

     

       830
       837
        
       

     

       831
       838
        
             drives = mkOption {

     

       832
       832
       -
               type = types.listOf (types.submodule driveOpts);

     

       839
       839
       +
               type = types.listOf (

     

       840
       840
       +
                 types.submodule {

     

       841
       841
       +
                   imports = [ driveOptions ];

     

       842
       842
       +
       

     

       843
       843
       +
                   options = {

     

       844
       844
       +
                     file = mkOption {

     

       845
       845
       +
                       type = types.str;

     

       846
       846
       +
                       description = "The file image used for this drive.";

     

       847
       847
       +
                     };

     

       848
       848
       +
                   };

     

       849
       849
       +
                 }

     

       850
       850
       +
               );

     

       833
       851
        
               description = "Drives passed to qemu.";

     

       834
       852
        
             };

     

       835
       853
        
       

     
···

       1310
       1328
        
                 driveExtraOpts.format = "raw";

     

       1311
       1329
        
               }

     

       1312
       1330
        
             ])

     

       1313
       1313
       -
             (imap0 (idx: _: {

     

       1314
       1314
       -
               file = "$(pwd)/empty${toString idx}.qcow2";

     

       1315
       1315
       -
               driveExtraOpts.werror = "report";

     

       1316
       1316
       -
             }) cfg.emptyDiskImages)

     

       1331
       1331
       +
             (imap0 (

     

       1332
       1332
       +
               idx: imgCfg:

     

       1333
       1333
       +
               lib.mkMerge [

     

       1334
       1334
       +
                 {

     

       1335
       1335
       +
                   file = "$(pwd)/empty${toString idx}.qcow2";

     

       1336
       1336
       +
                   driveExtraOpts.werror = "report";

     

       1337
       1337
       +
                 }

     

       1338
       1338
       +
                 imgCfg.driveConfig

     

       1339
       1339
       +
               ]

     

       1340
       1340
       +
             ) cfg.emptyDiskImages)

     

       1317
       1341
        
           ];

     

       1318
       1342
        
       

     

       1319
       1343
        
           # By default, use mkVMOverride to enable building test VMs (e.g. via

+13 -9

nixos/tests/bees.nix

···

       5
       5
        
         nodes.machine =

     

       6
       6
        
           { config, pkgs, ... }:

     

       7
       7
        
           {

     

       8
       8
       -
             boot.initrd.postDeviceCommands = ''

     

       9
       9
       -
               ${pkgs.btrfs-progs}/bin/mkfs.btrfs -f -L aux1 /dev/vdb

     

       10
       10
       -
               ${pkgs.btrfs-progs}/bin/mkfs.btrfs -f -L aux2 /dev/vdc

     

       11
       11
       -
             '';

     

       12
       8
        
             virtualisation.emptyDiskImages = [

     

       13
       13
       -
               4096

     

       14
       14
       -
               4096

     

       9
       9
       +
               {

     

       10
       10
       +
                 size = 4096;

     

       11
       11
       +
                 driveConfig.deviceExtraOpts.serial = "aux1";

     

       12
       12
       +
               }

     

       13
       13
       +
               {

     

       14
       14
       +
                 size = 4096;

     

       15
       15
       +
                 driveConfig.deviceExtraOpts.serial = "aux2";

     

       16
       16
       +
               }

     

       15
       17
        
             ];

     

       16
       18
        
             virtualisation.fileSystems = {

     

       17
       19
        
               "/aux1" = {

     

       18
       20
        
                 # filesystem configured to be deduplicated

     

       19
       19
       -
                 device = "/dev/disk/by-label/aux1";

     

       21
       21
       +
                 device = "/dev/disk/by-id/virtio-aux1";

     

       20
       22
        
                 fsType = "btrfs";

     

       23
       23
       +
                 autoFormat = true;

     

       21
       24
        
               };

     

       22
       25
        
               "/aux2" = {

     

       23
       26
        
                 # filesystem not configured to be deduplicated

     

       24
       24
       -
                 device = "/dev/disk/by-label/aux2";

     

       27
       27
       +
                 device = "/dev/disk/by-id/virtio-aux2";

     

       25
       28
        
                 fsType = "btrfs";

     

       29
       29
       +
                 autoFormat = true;

     

       26
       30
        
               };

     

       27
       31
        
             };

     

       28
       32
        
             services.beesd.filesystems = {

     

       29
       33
        
               aux1 = {

     

       30
       30
       -
                 spec = "LABEL=aux1";

     

       34
       34
       +
                 spec = "/dev/disk/by-id/virtio-aux1";

     

       31
       35
        
                 hashTableSizeMB = 16;

     

       32
       36
        
                 verbosity = "debug";

     

       33
       37
        
               };

+8 -7

nixos/tests/glusterfs.nix

···

       19
       19
        
             networking.firewall.enable = false;

     

       20
       20
        
             services.glusterfs.enable = true;

     

       21
       21
        
       

     

       22
       22
       -
             # create a mount point for the volume

     

       23
       23
       -
             boot.initrd.postDeviceCommands = ''

     

       24
       24
       -
               ${pkgs.e2fsprogs}/bin/mkfs.ext4 -L data /dev/vdb

     

       25
       25
       -
             '';

     

       26
       26
       -
       

     

       27
       27
       -
             virtualisation.emptyDiskImages = [ 1024 ];

     

       22
       22
       +
             virtualisation.emptyDiskImages = [

     

       23
       23
       +
               {

     

       24
       24
       +
                 size = 1024;

     

       25
       25
       +
                 driveConfig.deviceExtraOpts.serial = "data";

     

       26
       26
       +
               }

     

       27
       27
       +
             ];

     

       28
       28
        
       

     

       29
       29
        
             virtualisation.fileSystems = {

     

       30
       30
        
               "/data" = {

     

       31
       31
       -
                 device = "/dev/disk/by-label/data";

     

       31
       31
       +
                 device = "/dev/disk/by-id/virtio-data";

     

       32
       32
        
                 fsType = "ext4";

     

       33
       33
       +
                 autoFormat = true;

     

       33
       34
        
               };

     

       34
       35
        
             };

     

       35
       36
        
           };

+12 -10

nixos/tests/hardened.nix

···

       24
       24
        
             imports = [ ../modules/profiles/hardened.nix ];

     

       25
       25
        
             environment.memoryAllocator.provider = "graphene-hardened";

     

       26
       26
        
             nix.settings.sandbox = false;

     

       27
       27
       -
             virtualisation.emptyDiskImages = [ 4096 ];

     

       28
       28
       -
             boot.initrd.postDeviceCommands = ''

     

       29
       29
       -
               ${pkgs.dosfstools}/bin/mkfs.vfat -n EFISYS /dev/vdb

     

       30
       30
       -
             '';

     

       27
       27
       +
             virtualisation.emptyDiskImages = [

     

       28
       28
       +
               {

     

       29
       29
       +
                 size = 4096;

     

       30
       30
       +
                 driveConfig.deviceExtraOpts.serial = "deferred";

     

       31
       31
       +
               }

     

       32
       32
       +
             ];

     

       31
       33
        
             virtualisation.fileSystems = {

     

       32
       32
       -
               "/efi" = {

     

       33
       33
       -
                 device = "/dev/disk/by-label/EFISYS";

     

       34
       34
       +
               "/deferred" = {

     

       35
       35
       +
                 device = "/dev/disk/by-id/virtio-deferred";

     

       34
       36
        
                 fsType = "vfat";

     

       37
       37
       +
                 autoFormat = true;

     

       35
       38
        
                 options = [ "noauto" ];

     

       36
       39
        
               };

     

       37
       40
        
             };

     
···

       87
       90
        
       

     

       88
       91
        
             # Test deferred mount

     

       89
       92
        
             with subtest("Deferred mounts work"):

     

       90
       90
       -
                 machine.fail("mountpoint -q /efi")  # was deferred

     

       91
       91
       -
                 machine.execute("mkdir -p /efi")

     

       92
       92
       -
                 machine.succeed("mount /dev/disk/by-label/EFISYS /efi")

     

       93
       93
       -
                 machine.succeed("mountpoint -q /efi")  # now mounted

     

       93
       93
       +
                 machine.fail("mountpoint -q /deferred")  # was deferred

     

       94
       94
       +
                 machine.systemctl("start deferred.mount")

     

       95
       95
       +
                 machine.succeed("mountpoint -q /deferred")  # now mounted

     

       94
       96
        
       

     

       95
       97
        
       

     

       96
       98
        
             # Test Nix dæmon usage

+8 -5

nixos/tests/moosefs.nix

···

       22
       22
        
         chunkserver =

     

       23
       23
        
           { pkgs, ... }:

     

       24
       24
        
           {

     

       25
       25
       -
             virtualisation.emptyDiskImages = [ 4096 ];

     

       26
       26
       -
             boot.initrd.postDeviceCommands = ''

     

       27
       27
       -
               ${pkgs.e2fsprogs}/bin/mkfs.ext4 -L data /dev/vdb

     

       28
       28
       -
             '';

     

       25
       25
       +
             virtualisation.emptyDiskImages = [

     

       26
       26
       +
               {

     

       27
       27
       +
                 size = 4096;

     

       28
       28
       +
                 driveConfig.deviceExtraOpts.serial = "data";

     

       29
       29
       +
               }

     

       30
       30
       +
             ];

     

       29
       31
        
       

     

       30
       32
        
             fileSystems = pkgs.lib.mkVMOverride {

     

       31
       33
        
               "/data" = {

     

       32
       32
       -
                 device = "/dev/disk/by-label/data";

     

       34
       34
       +
                 device = "/dev/disk/by-id/virtio-data";

     

       33
       35
        
                 fsType = "ext4";

     

       36
       36
       +
                 autoFormat = true;

     

       34
       37
        
               };

     

       35
       38
        
             };

     

       36
       39

+8 -5

nixos/tests/orangefs.nix

···

       5
       5
        
           { pkgs, ... }:

     

       6
       6
        
           {

     

       7
       7
        
             networking.firewall.allowedTCPPorts = [ 3334 ];

     

       8
       8
       -
             boot.initrd.postDeviceCommands = ''

     

       9
       9
       -
               ${pkgs.e2fsprogs}/bin/mkfs.ext4 -L data /dev/vdb

     

       10
       10
       -
             '';

     

       11
       8
        
       

     

       12
       12
       -
             virtualisation.emptyDiskImages = [ 4096 ];

     

       9
       9
       +
             virtualisation.emptyDiskImages = [

     

       10
       10
       +
               {

     

       11
       11
       +
                 size = 4096;

     

       12
       12
       +
                 driveConfig.deviceExtraOpts.serial = "data";

     

       13
       13
       +
               }

     

       14
       14
       +
             ];

     

       13
       15
        
       

     

       14
       16
        
             virtualisation.fileSystems = {

     

       15
       17
        
               "/data" = {

     

       16
       16
       -
                 device = "/dev/disk/by-label/data";

     

       18
       18
       +
                 device = "/dev/disk/by-id/virtio-data";

     

       17
       19
        
                 fsType = "ext4";

     

       20
       20
       +
                 autoFormat = true;

     

       18
       21
        
               };

     

       19
       22
        
             };

     

       20
       23

+8 -5

nixos/tests/saunafs.nix

···

       20
       20
        
         chunkserver =

     

       21
       21
        
           { pkgs, ... }:

     

       22
       22
        
           {

     

       23
       23
       -
             virtualisation.emptyDiskImages = [ 4096 ];

     

       24
       24
       -
             boot.initrd.postDeviceCommands = ''

     

       25
       25
       -
               ${pkgs.e2fsprogs}/bin/mkfs.ext4 -L data /dev/vdb

     

       26
       26
       -
             '';

     

       23
       23
       +
             virtualisation.emptyDiskImages = [

     

       24
       24
       +
               {

     

       25
       25
       +
                 size = 4096;

     

       26
       26
       +
                 driveConfig.deviceExtraOpts.serial = "data";

     

       27
       27
       +
               }

     

       28
       28
       +
             ];

     

       27
       29
        
       

     

       28
       30
        
             fileSystems = pkgs.lib.mkVMOverride {

     

       29
       31
        
               "/data" = {

     

       30
       30
       -
                 device = "/dev/disk/by-label/data";

     

       32
       32
       +
                 device = "/dev/disk/by-id/virtio-data";

     

       31
       33
        
                 fsType = "ext4";

     

       34
       34
       +
                 autoFormat = true;

     

       32
       35
        
               };

     

       33
       36
        
             };

     

       34
       37

+8 -6

nixos/tests/snapper.nix

···

       5
       5
        
         nodes.machine =

     

       6
       6
        
           { pkgs, lib, ... }:

     

       7
       7
        
           {

     

       8
       8
       -
             boot.initrd.postDeviceCommands = ''

     

       9
       9
       -
               ${pkgs.btrfs-progs}/bin/mkfs.btrfs -f -L aux /dev/vdb

     

       10
       10
       -
             '';

     

       11
       11
       -
       

     

       12
       12
       -
             virtualisation.emptyDiskImages = [ 4096 ];

     

       8
       8
       +
             virtualisation.emptyDiskImages = [

     

       9
       9
       +
               {

     

       10
       10
       +
                 size = 4096;

     

       11
       11
       +
                 driveConfig.deviceExtraOpts.serial = "aux";

     

       12
       12
       +
               }

     

       13
       13
       +
             ];

     

       13
       14
        
       

     

       14
       15
        
             virtualisation.fileSystems = {

     

       15
       16
        
               "/home" = {

     

       16
       16
       -
                 device = "/dev/disk/by-label/aux";

     

       17
       17
       +
                 device = "/dev/disk/by-id/virtio-aux";

     

       17
       18
        
                 fsType = "btrfs";

     

       19
       19
       +
                 autoFormat = true;

     

       18
       20
        
               };

     

       19
       21
        
             };

     

       20
       22
        
             services.snapper.configs.home.SUBVOLUME = "/home";

+4 -6

nixos/tests/swap-file-btrfs.nix

···

       5
       5
        
         meta.maintainers = with lib.maintainers; [ oxalica ];

     

       6
       6
        
       

     

       7
       7
        
         nodes.machine =

     

       8
       8
       -
           { pkgs, ... }:

     

       8
       8
       +
           { config, pkgs, ... }:

     

       9
       9
        
           {

     

       10
       10
        
             virtualisation.useDefaultFilesystems = false;

     

       11
       11
        
       

     

       12
       12
        
             virtualisation.rootDevice = "/dev/vda";

     

       13
       13
        
       

     

       14
       14
       -
             boot.initrd.postDeviceCommands = ''

     

       15
       15
       -
               ${pkgs.btrfs-progs}/bin/mkfs.btrfs --label root /dev/vda

     

       16
       16
       -
             '';

     

       17
       17
       -
       

     

       14
       14
       +
             boot.initrd.systemd.enable = true;

     

       18
       15
        
             virtualisation.fileSystems = {

     

       19
       16
        
               "/" = {

     

       20
       20
       -
                 device = "/dev/disk/by-label/root";

     

       17
       17
       +
                 device = config.virtualisation.rootDevice;

     

       21
       18
        
                 fsType = "btrfs";

     

       19
       19
       +
                 autoFormat = true;

     

       22
       20
        
               };

     

       23
       21
        
             };

     

       24
       22