commit 6eb620ace7d78f64ba6c18d9abe7b5775b5c6358 · pyrox.dev/nixpkgs

+47 -15

nixos/lib/qemu-common.nix

···

       4
        
       let

     

       5
        
         zeroPad = n:

     

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

     

       7
       -
             (if n > 255

     

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

     

       9
       -
              else lib.toHexString n);

     

       10
        
       in

     

       11
        
       

     

       12
        
       rec {

     

       13
        
         qemuNicMac = net: machine: "52:54:00:12:${zeroPad net}:${zeroPad machine}";

     

       14
        
       

     

       15
        
         qemuNICFlags = nic: net: machine:

     

       16
       -
           [ "-device virtio-net-pci,netdev=vlan${toString nic},mac=${qemuNicMac net machine}"

     

       0
        
       
     

       17
        
             ''-netdev vde,id=vlan${toString nic},sock="$QEMU_VDE_SOCKET_${toString net}"''

     

       18
        
           ];

     

       19
        
       

     

       20
       -
         qemuSerialDevice = if pkgs.stdenv.hostPlatform.isx86 || pkgs.stdenv.hostPlatform.isRiscV then "ttyS0"

     

       21
       -
               else if (with pkgs.stdenv.hostPlatform; isAarch || isPower) then "ttyAMA0"

     

       22
       -
               else throw "Unknown QEMU serial device for system '${pkgs.stdenv.hostPlatform.system}'";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
       

     

       24
       -
         qemuBinary = qemuPkg: {

     

       25
       -
           x86_64-linux = "${qemuPkg}/bin/qemu-kvm -cpu max";

     

       26
       -
           armv7l-linux = "${qemuPkg}/bin/qemu-system-arm -machine virt,accel=kvm:tcg -cpu max";

     

       27
       -
           aarch64-linux = "${qemuPkg}/bin/qemu-system-aarch64 -machine virt,gic-version=max,accel=kvm:tcg -cpu max";

     

       28
       -
           powerpc64le-linux = "${qemuPkg}/bin/qemu-system-ppc64 -machine powernv";

     

       29
       -
           powerpc64-linux = "${qemuPkg}/bin/qemu-system-ppc64 -machine powernv";

     

       30
       -
           x86_64-darwin = "${qemuPkg}/bin/qemu-kvm -cpu max";

     

       31
       -
         }.${pkgs.stdenv.hostPlatform.system} or "${qemuPkg}/bin/qemu-kvm";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       }

···

       4
        
       let

     

       5
        
         zeroPad = n:

     

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

     

       7
       +
           (if n > 255

     

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

     

       9
       +
           else lib.toHexString n);

     

       10
        
       in

     

       11
        
       

     

       12
        
       rec {

     

       13
        
         qemuNicMac = net: machine: "52:54:00:12:${zeroPad net}:${zeroPad machine}";

     

       14
        
       

     

       15
        
         qemuNICFlags = nic: net: machine:

     

       16
       +
           [

     

       17
       +
             "-device virtio-net-pci,netdev=vlan${toString nic},mac=${qemuNicMac net machine}"

     

       18
        
             ''-netdev vde,id=vlan${toString nic},sock="$QEMU_VDE_SOCKET_${toString net}"''

     

       19
        
           ];

     

       20
        
       

     

       21
       +
         qemuSerialDevice =

     

       22
       +
           if pkgs.stdenv.hostPlatform.isx86 || pkgs.stdenv.hostPlatform.isRiscV then "ttyS0"

     

       23
       +
           else if (with pkgs.stdenv.hostPlatform; isAarch || isPower) then "ttyAMA0"

     

       24
       +
           else throw "Unknown QEMU serial device for system '${pkgs.stdenv.hostPlatform.system}'";

     

       25
       +
       

     

       26
       +
         qemuBinary = qemuPkg:

     

       27
       +
           let

     

       28
       +
             hostStdenv = qemuPkg.stdenv;

     

       29
       +
             hostSystem = hostStdenv.system;

     

       30
       +
             guestSystem = pkgs.stdenv.hostPlatform.system;

     

       31
        
       

     

       32
       +
             linuxHostGuestMatrix = {

     

       33
       +
               x86_64-linux = "${qemuPkg}/bin/qemu-kvm -cpu max";

     

       34
       +
               armv7l-linux = "${qemuPkg}/bin/qemu-system-arm -machine virt,accel=kvm:tcg -cpu max";

     

       35
       +
               aarch64-linux = "${qemuPkg}/bin/qemu-system-aarch64 -machine virt,gic-version=max,accel=kvm:tcg -cpu max";

     

       36
       +
               powerpc64le-linux = "${qemuPkg}/bin/qemu-system-ppc64 -machine powernv";

     

       37
       +
               powerpc64-linux = "${qemuPkg}/bin/qemu-system-ppc64 -machine powernv";

     

       38
       +
               x86_64-darwin = "${qemuPkg}/bin/qemu-kvm -cpu max";

     

       39
       +
             };

     

       40
       +
             otherHostGuestMatrix = {

     

       41
       +
               aarch64-darwin = {

     

       42
       +
                 aarch64-linux = "${qemuPkg}/bin/qemu-system-aarch64 -machine virt,gic-version=2,accel=hvf:tcg -cpu max";

     

       43
       +
               };

     

       44
       +
               x86_64-darwin = {

     

       45
       +
                 x86_64-linux = "${qemuPkg}/bin/qemu-system-x86_64 -machine type=q35,accel=hvf:tcg -cpu max";

     

       46
       +
               };

     

       47
       +
             };

     

       48
       +
       

     

       49
       +
             throwUnsupportedHostSystem =

     

       50
       +
               let

     

       51
       +
                 supportedSystems = [ "linux" ] ++ (lib.attrNames otherHostGuestMatrix);

     

       52
       +
               in

     

       53
       +
               throw "Unsupported host system ${hostSystem}, supported: ${lib.concatStringsSep ", " supportedSystems}";

     

       54
       +
             throwUnsupportedGuestSystem = guestMap:

     

       55
       +
               throw "Unsupported guest system ${guestSystem} for host ${hostSystem}, supported: ${lib.concatStringsSep ", " (lib.attrNames guestMap)}";

     

       56
       +
           in

     

       57
       +
           if hostStdenv.isLinux then

     

       58
       +
             linuxHostGuestMatrix.${guestSystem} or "${qemuPkg}/bin/qemu-kvm"

     

       59
       +
           else

     

       60
       +
             let

     

       61
       +
               guestMap = (otherHostGuestMatrix.${hostSystem} or throwUnsupportedHostSystem);

     

       62
       +
             in

     

       63
       +
             (guestMap.${guestSystem} or (throwUnsupportedGuestSystem guestMap));

     

       64
        
       }

+19 -4

nixos/modules/virtualisation/qemu-vm.nix

···

       102
        
         # Shell script to start the VM.

     

       103
        
         startVM =

     

       104
        
           ''

     

       105
       -
             #! ${pkgs.runtimeShell}

     

       0
        
       
     

       0
        
       
     

       106
        
       

     

       107
        
             set -e

     

       108
        
       

     
···

       574
        
               description = "Primary IP address used in /etc/hosts.";

     

       575
        
             };

     

       576
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       577
        
           virtualisation.qemu = {

     

       578
        
             package =

     

       579
        
               mkOption {

     

       580
        
                 type = types.package;

     

       581
       -
                 default = pkgs.qemu_kvm;

     

       582
        
                 example = "pkgs.qemu_test";

     

       583
        
                 description = lib.mdDoc "QEMU package to use.";

     

       584
        
               };

     
···

       1075
        
       

     

       1076
        
           services.qemuGuest.enable = cfg.qemu.guestAgent.enable;

     

       1077
        
       

     

       1078
       -
           system.build.vm = pkgs.runCommand "nixos-vm" {

     

       1079
        
             preferLocalBuild = true;

     

       1080
        
             meta.mainProgram = "run-${config.system.name}-vm";

     

       1081
        
           }

     

       1082
        
             ''

     

       1083
        
               mkdir -p $out/bin

     

       1084
        
               ln -s ${config.system.build.toplevel} $out/system

     

       1085
       -
               ln -s ${pkgs.writeScript "run-nixos-vm" startVM} $out/bin/run-${config.system.name}-vm

     

       1086
        
             '';

     

       1087
        
       

     

       1088
        
           # When building a regular system configuration, override whatever

···

       102
        
         # Shell script to start the VM.

     

       103
        
         startVM =

     

       104
        
           ''

     

       105
       +
             #! ${cfg.host.pkgs.runtimeShell}

     

       106
       +
       

     

       107
       +
             export PATH=${makeBinPath [ cfg.host.pkgs.coreutils ]}''${PATH:+:}$PATH

     

       108
        
       

     

       109
        
             set -e

     

       110
        
       

     
···

       576
        
               description = "Primary IP address used in /etc/hosts.";

     

       577
        
             };

     

       578
        
       

     

       579
       +
           virtualisation.host.pkgs = mkOption {

     

       580
       +
             type = options.nixpkgs.pkgs.type;

     

       581
       +
             default = pkgs;

     

       582
       +
             defaultText = "pkgs";

     

       583
       +
             example = literalExpression ''

     

       584
       +
               import pkgs.path { system = "x86_64-darwin"; }

     

       585
       +
             '';

     

       586
       +
             description = ''

     

       587
       +
               pkgs set to use for the host-specific packages of the vm runner.

     

       588
       +
               Changing this to e.g. a Darwin package set allows running NixOS VMs on Darwin.

     

       589
       +
             '';

     

       590
       +
           };

     

       591
       +
       

     

       592
        
           virtualisation.qemu = {

     

       593
        
             package =

     

       594
        
               mkOption {

     

       595
        
                 type = types.package;

     

       596
       +
                 default = cfg.host.pkgs.qemu_kvm;

     

       597
        
                 example = "pkgs.qemu_test";

     

       598
        
                 description = lib.mdDoc "QEMU package to use.";

     

       599
        
               };

     
···

       1090
        
       

     

       1091
        
           services.qemuGuest.enable = cfg.qemu.guestAgent.enable;

     

       1092
        
       

     

       1093
       +
           system.build.vm = cfg.host.pkgs.runCommand "nixos-vm" {

     

       1094
        
             preferLocalBuild = true;

     

       1095
        
             meta.mainProgram = "run-${config.system.name}-vm";

     

       1096
        
           }

     

       1097
        
             ''

     

       1098
        
               mkdir -p $out/bin

     

       1099
        
               ln -s ${config.system.build.toplevel} $out/system

     

       1100
       +
               ln -s ${cfg.host.pkgs.writeScript "run-nixos-vm" startVM} $out/bin/run-${config.system.name}-vm

     

       1101
        
             '';

     

       1102
        
       

     

       1103
        
           # When building a regular system configuration, override whatever