commit b29c2f97c37f7cb4a1b3411ff9888a49873597d2 · pyrox.dev/nixpkgs

+5 -5

nixos/lib/build-vms.nix

···

       4
       4
        
       , # Ignored

     

       5
       5
        
         config ? null

     

       6
       6
        
       , # Nixpkgs, for qemu, lib and more

     

       7
       7
       -
         pkgs

     

       7
       7
       +
         pkgs, lib

     

       8
       8
        
       , # !!! See comment about args in lib/modules.nix

     

       9
       9
        
         specialArgs ? {}

     

       10
       10
        
       , # NixOS configuration to add to the VMs

     

       11
       11
        
         extraConfigurations ? []

     

       12
       12
        
       }:

     

       13
       13
        
       

     

       14
       14
       -
       with pkgs.lib;

     

       15
       15
       -
       with import ../lib/qemu-flags.nix { inherit pkgs; };

     

       14
       14
       +
       with lib;

     

       16
       15
        
       

     

       17
       16
        
       rec {

     

       18
       17
        
       

     
···

       93
       92
        
                                "${config.networking.hostName}\n"));

     

       94
       93
        
       

     

       95
       94
        
                         virtualisation.qemu.options =

     

       96
       96
       -
                           flip concatMap interfacesNumbered

     

       97
       97
       -
                             ({ fst, snd }: qemuNICFlags snd fst m.snd);

     

       95
       95
       +
                           let qemu-common = import ../lib/qemu-common.nix { inherit lib pkgs; };

     

       96
       96
       +
                           in flip concatMap interfacesNumbered

     

       97
       97
       +
                             ({ fst, snd }: qemu-common.qemuNICFlags snd fst m.snd);

     

       98
       98
        
                       };

     

       99
       99
        
                   }

     

       100
       100
        
                 )

+4 -4

nixos/lib/qemu-flags.nix nixos/lib/qemu-common.nix

···

       1
       1
       -
       # QEMU flags shared between various Nix expressions.

     

       2
       2
       -
       { pkgs }:

     

       1
       1
       +
       # QEMU-related utilities shared between various Nix expressions.

     

       2
       2
       +
       { lib, pkgs }:

     

       3
       3
        
       

     

       4
       4
        
       let

     

       5
       5
        
         zeroPad = n:

     

       6
       6
       -
           pkgs.lib.optionalString (n < 16) "0" +

     

       6
       6
       +
           lib.optionalString (n < 16) "0" +

     

       7
       7
        
             (if n > 255

     

       8
       8
        
              then throw "Can't have more than 255 nets or nodes!"

     

       9
       9
       -
              else pkgs.lib.toHexString n);

     

       9
       9
       +
              else lib.toHexString n);

     

       10
       10
        
       in

     

       11
       11
        
       

     

       12
       12
        
       rec {

+1 -2

nixos/lib/testing-python.nix

···

       217
       217
        
             nodes = qemu_pkg:

     

       218
       218
        
               let

     

       219
       219
        
                 build-vms = import ./build-vms.nix {

     

       220
       220
       -
                   inherit system pkgs minimal specialArgs;

     

       220
       220
       +
                   inherit system lib pkgs minimal specialArgs;

     

       221
       221
        
                   extraConfigurations = extraConfigurations ++ [(

     

       222
       222
        
                     {

     

       223
       223
        
                       virtualisation.qemu.package = qemu_pkg;

     
···

       256
       256
        
             test // {

     

       257
       257
        
               inherit test driver driverInteractive nodes;

     

       258
       258
        
             };

     

       259
       259
       -
       

     

       260
       259
        
       

     

       261
       260
        
         abortForFunction = functionName: abort ''The ${functionName} function was

     

       262
       261
        
           removed because it is not an essential part of the NixOS testing

+10 -7

nixos/modules/testing/test-instrumentation.nix

···

       4
       4
        
       { options, config, lib, pkgs, ... }:

     

       5
       5
        
       

     

       6
       6
        
       with lib;

     

       7
       7
       -
       with import ../../lib/qemu-flags.nix { inherit pkgs; };

     

       7
       7
       +
       

     

       8
       8
       +
       let

     

       9
       9
       +
         qemu-common = import ../../lib/qemu-common.nix { inherit lib pkgs; };

     

       10
       10
       +
       in

     

       8
       11
        
       

     

       9
       12
        
       {

     

       10
       13
        
       

     
···

       12
       15
        
       

     

       13
       16
        
           systemd.services.backdoor =

     

       14
       17
        
             { wantedBy = [ "multi-user.target" ];

     

       15
       15
       -
               requires = [ "dev-hvc0.device" "dev-${qemuSerialDevice}.device" ];

     

       16
       16
       -
               after = [ "dev-hvc0.device" "dev-${qemuSerialDevice}.device" ];

     

       18
       18
       +
               requires = [ "dev-hvc0.device" "dev-${qemu-common.qemuSerialDevice}.device" ];

     

       19
       19
       +
               after = [ "dev-hvc0.device" "dev-${qemu-common.qemuSerialDevice}.device" ];

     

       17
       20
        
               script =

     

       18
       21
        
                 ''

     

       19
       22
        
                   export USER=root

     
···

       30
       33
        
       

     

       31
       34
        
                   cd /tmp

     

       32
       35
        
                   exec < /dev/hvc0 > /dev/hvc0

     

       33
       33
       -
                   while ! exec 2> /dev/${qemuSerialDevice}; do sleep 0.1; done

     

       36
       36
       +
                   while ! exec 2> /dev/${qemu-common.qemuSerialDevice}; do sleep 0.1; done

     

       34
       37
        
                   echo "connecting to host..." >&2

     

       35
       38
        
                   stty -F /dev/hvc0 raw -echo # prevent nl -> cr/nl conversion

     

       36
       39
        
                   echo

     
···

       42
       45
        
           # Prevent agetty from being instantiated on the serial device, since it

     

       43
       46
        
           # interferes with the backdoor (writes to it will randomly fail

     

       44
       47
        
           # with EIO).  Likewise for hvc0.

     

       45
       45
       -
           systemd.services."serial-getty@${qemuSerialDevice}".enable = false;

     

       48
       48
       +
           systemd.services."serial-getty@${qemu-common.qemuSerialDevice}".enable = false;

     

       46
       49
        
           systemd.services."serial-getty@hvc0".enable = false;

     

       47
       50
        
       

     

       48
       51
        
           # Only set these settings when the options exist. Some tests (e.g. those

     
···

       57
       60
        
               #       we avoid defining consoles if not possible.

     

       58
       61
        
               # TODO: refactor such that test-instrumentation can import qemu-vm

     

       59
       62
        
               #       or declare virtualisation.qemu.console option in a module that's always imported

     

       60
       60
       -
               consoles = [ qemuSerialDevice ];

     

       63
       63
       +
               consoles = [ qemu-common.qemuSerialDevice ];

     

       61
       64
        
               package  = lib.mkDefault pkgs.qemu_test;

     

       62
       65
        
             };

     

       63
       66
        
           };

     
···

       88
       91
        
           # Panic if an error occurs in stage 1 (rather than waiting for

     

       89
       92
        
           # user intervention).

     

       90
       93
        
           boot.kernelParams =

     

       91
       91
       -
             [ "console=${qemuSerialDevice}" "panic=1" "boot.panic_on_fail" ];

     

       94
       94
       +
             [ "console=${qemu-common.qemuSerialDevice}" "panic=1" "boot.panic_on_fail" ];

     

       92
       95
        
       

     

       93
       96
        
           # `xwininfo' is used by the test driver to query open windows.

     

       94
       97
        
           environment.systemPackages = [ pkgs.xorg.xwininfo ];

+3 -3

nixos/modules/virtualisation/qemu-vm.nix

···

       10
       10
        
       { config, lib, pkgs, options, ... }:

     

       11
       11
        
       

     

       12
       12
        
       with lib;

     

       13
       13
       -
       with import ../../lib/qemu-flags.nix { inherit pkgs; };

     

       14
       13
        
       

     

       15
       14
        
       let

     

       16
       15
        
       

     

       16
       16
       +
         qemu-common = import ../../lib/qemu-common.nix { inherit lib pkgs; };

     

       17
       17
        
       

     

       18
       18
        
         cfg = config.virtualisation;

     

       19
       19
        
       

     
···

       152
       152
        
             '')}

     

       153
       153
        
       

     

       154
       154
        
             # Start QEMU.

     

       155
       155
       -
             exec ${qemuBinary qemu} \

     

       155
       155
       +
             exec ${qemu-common.qemuBinary qemu} \

     

       156
       156
        
                 -name ${config.system.name} \

     

       157
       157
        
                 -m ${toString config.virtualisation.memorySize} \

     

       158
       158
        
                 -smp ${toString config.virtualisation.cores} \

     
···

       549
       549
        
             consoles = mkOption {

     

       550
       550
        
               type = types.listOf types.str;

     

       551
       551
        
               default = let

     

       552
       552
       -
                 consoles = [ "${qemu-flags.qemuSerialDevice},115200n8" "tty0" ];

     

       552
       552
       +
                 consoles = [ "${qemu-common.qemuSerialDevice},115200n8" "tty0" ];

     

       553
       553
        
               in if cfg.graphics then consoles else reverseList consoles;

     

       554
       554
        
               example = [ "console=tty1" ];

     

       555
       555
        
               description = ''

+2 -2

nixos/tests/networking.nix

···

       8
       8
        
       with pkgs.lib;

     

       9
       9
        
       

     

       10
       10
        
       let

     

       11
       11
       -
         qemu-flags = import ../lib/qemu-flags.nix { inherit pkgs; };

     

       11
       11
       +
         qemu-common = import ../lib/qemu-common.nix { inherit (pkgs) lib pkgs; };

     

       12
       12
        
       

     

       13
       13
        
         router = { config, pkgs, lib, ... }:

     

       14
       14
        
           with pkgs.lib;

     
···

       42
       42
        
               machines = flip map vlanIfs (vlan:

     

       43
       43
        
                 {

     

       44
       44
        
                   hostName = "client${toString vlan}";

     

       45
       45
       -
                   ethernetAddress = qemu-flags.qemuNicMac vlan 1;

     

       45
       45
       +
                   ethernetAddress = qemu-common.qemuNicMac vlan 1;

     

       46
       46
        
                   ipAddress = "192.168.${toString vlan}.2";

     

       47
       47
        
                 }

     

       48
       48
        
               );

+4 -4

pkgs/build-support/vm/default.nix

···

       9
       9
        
       }:

     

       10
       10
        
       

     

       11
       11
        
       with pkgs;

     

       12
       12
       -
       with import ../../../nixos/lib/qemu-flags.nix { inherit pkgs; };

     

       13
       12
        
       

     

       14
       13
        
       rec {

     

       14
       14
       +
         qemu-common = import ../../../nixos/lib/qemu-common.nix { inherit lib pkgs; };

     

       15
       15
        
       

     

       16
       16
        
         qemu = pkgs.qemu_kvm;

     

       17
       17
        
       

     
···

       192
       192
        
             export PATH=/bin:/usr/bin:${coreutils}/bin

     

       193
       193
        
             echo "Starting interactive shell..."

     

       194
       194
        
             echo "(To run the original builder: \$origBuilder \$origArgs)"

     

       195
       195
       -
             exec ${busybox}/bin/setsid ${bashInteractive}/bin/bash < /dev/${qemuSerialDevice} &> /dev/${qemuSerialDevice}

     

       195
       195
       +
             exec ${busybox}/bin/setsid ${bashInteractive}/bin/bash < /dev/${qemu-common.qemuSerialDevice} &> /dev/${qemu-common.qemuSerialDevice}

     

       196
       196
        
           fi

     

       197
       197
        
         '';

     

       198
       198
        
       

     

       199
       199
        
       

     

       200
       200
        
         qemuCommandLinux = ''

     

       201
       201
       -
           ${qemuBinary qemu} \

     

       201
       201
       +
           ${qemu-common.qemuBinary qemu} \

     

       202
       202
        
             -nographic -no-reboot \

     

       203
       203
        
             -device virtio-rng-pci \

     

       204
       204
        
             -virtfs local,path=${storeDir},security_model=none,mount_tag=store \

     
···

       206
       206
        
             ''${diskImage:+-drive file=$diskImage,if=virtio,cache=unsafe,werror=report} \

     

       207
       207
        
             -kernel ${kernel}/${img} \

     

       208
       208
        
             -initrd ${initrd}/initrd \

     

       209
       209
       -
             -append "console=${qemuSerialDevice} panic=1 command=${stage2Init} out=$out mountDisk=$mountDisk loglevel=4" \

     

       209
       209
       +
             -append "console=${qemu-common.qemuSerialDevice} panic=1 command=${stage2Init} out=$out mountDisk=$mountDisk loglevel=4" \

     

       210
       210
        
             $QEMU_OPTS

     

       211
       211
        
         '';

     

       212
       212