commit 3d4fbb874cbc3d5d179e9fab0f7099e95b34d960 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/module-list.nix

···

       432
       432
        
         ./virtualisation/openvswitch.nix

     

       433
       433
        
         ./virtualisation/parallels-guest.nix

     

       434
       434
        
         ./virtualisation/virtualbox-guest.nix

     

       435
       435
       -
         #./virtualisation/xen-dom0.nix

     

       435
       435
       +
         ./virtualisation/xen-dom0.nix

     

       436
       436
        
       ]

+177 -66

nixos/modules/virtualisation/xen-dom0.nix

···

       5
       5
        
       with lib;

     

       6
       6
        
       

     

       7
       7
        
       let

     

       8
       8
       -
       

     

       9
       8
        
         cfg = config.virtualisation.xen;

     

       10
       10
       -
       

     

       11
       9
        
         xen = pkgs.xen;

     

       12
       12
       -
       

     

       13
       13
       -
         xendConfig = pkgs.writeText "xend-config.sxp"

     

       14
       14
       -
           ''

     

       15
       15
       -
             (loglevel DEBUG)

     

       16
       16
       -
             (network-script network-bridge)

     

       17
       17
       -
             (vif-script vif-bridge)

     

       18
       18
       -
           '';

     

       19
       19
       -
       

     

       20
       10
        
       in

     

       21
       11
        
       

     

       22
       12
        
       {

     
···

       58
       48
        
                 '';

     

       59
       49
        
             };

     

       60
       50
        
       

     

       51
       51
       +
           virtualisation.xen.bridge =

     

       52
       52
       +
             mkOption {

     

       53
       53
       +
               default = "xenbr0";

     

       54
       54
       +
               description =

     

       55
       55
       +
                 ''

     

       56
       56
       +
                   Create a bridge for the Xen domUs to connect to.

     

       57
       57
       +
                 '';

     

       58
       58
       +
             };

     

       59
       59
       +
       

     

       60
       60
       +
           virtualisation.xen.stored =

     

       61
       61
       +
             mkOption {

     

       62
       62
       +
               default = "${pkgs.xen}/bin/oxenstored";

     

       63
       63
       +
               description =

     

       64
       64
       +
                 ''

     

       65
       65
       +
                   Xen Store daemon to use.

     

       66
       66
       +
                 '';

     

       67
       67
       +
             };

     

       68
       68
       +
       

     

       69
       69
       +
           virtualisation.xen.trace =

     

       70
       70
       +
             mkOption {

     

       71
       71
       +
               default = false;

     

       72
       72
       +
               description =

     

       73
       73
       +
                 ''

     

       74
       74
       +
                   Enable Xen tracing.

     

       75
       75
       +
                 '';

     

       76
       76
       +
             };

     

       61
       77
        
         };

     

       62
       78
        
       

     

       63
       79
        
       

     

       64
       80
        
         ###### implementation

     

       65
       81
        
       

     

       66
       82
        
         config = mkIf cfg.enable {

     

       83
       83
       +
           assertions = [ {

     

       84
       84
       +
             assertion = pkgs.stdenv.isx86_64;

     

       85
       85
       +
             message = "Xen currently not supported on ${pkgs.stdenv.system}";

     

       86
       86
       +
           } {

     

       87
       87
       +
             assertion = config.boot.loader.grub.enable && (config.boot.loader.grub.efiSupport == false);

     

       88
       88
       +
             message = "Xen currently does not support EFI boot";

     

       89
       89
       +
           } ];

     

       67
       90
        
       

     

       68
       91
        
           environment.systemPackages = [ xen ];

     

       69
       92
        
       

     

       70
       70
       -
           # Domain 0 requires a pvops-enabled kernel.

     

       71
       71
       -
           boot.kernelPackages = pkgs.linuxPackages_3_2_xen;

     

       93
       93
       +
           # Make sure Domain 0 gets the required configuration

     

       94
       94
       +
           #boot.kernelPackages = pkgs.boot.kernelPackages.override { features={xen_dom0=true;}; };

     

       72
       95
        
       

     

       73
       96
        
           boot.kernelModules =

     

       74
       74
       -
             [ "xen_evtchn" "xen_gntdev" "xen_blkback" "xen_netback" "xen_pciback"

     

       75
       75
       -
               "blktap" "tun"

     

       97
       97
       +
             [ "xen-evtchn" "xen-gntdev" "xen-gntalloc" "xen-blkback" "xen-netback"

     

       98
       98
       +
               "xen-pciback" "evtchn" "gntdev" "netbk" "blkbk" "xen-scsibk"

     

       99
       99
       +
               "usbbk" "pciback" "xen-acpi-processor" "blktap2" "tun" "netxen_nic"

     

       100
       100
       +
               "xen_wdt" "xen-acpi-processor" "xen-privcmd" "xen-scsiback"

     

       101
       101
       +
               "xenfs"

     

       76
       102
        
             ];

     

       77
       103
        
       

     

       104
       104
       +
       

     

       78
       105
        
           # The radeonfb kernel module causes the screen to go black as soon

     

       79
       106
        
           # as it's loaded, so don't load it.

     

       80
       107
        
           boot.blacklistedKernelModules = [ "radeonfb" ];

     
···

       87
       114
        
               options loop max_loop=64

     

       88
       115
        
             '';

     

       89
       116
        
       

     

       90
       90
       -
           virtualisation.xen.bootParams =

     

       91
       91
       -
             [ "loglvl=all" "guest_loglvl=all" ] ++

     

       117
       117
       +
           virtualisation.xen.bootParams = [] ++

     

       118
       118
       +
             optionals cfg.trace [ "loglvl=all" "guest_loglvl=all" ] ++

     

       92
       119
        
             optional (cfg.domain0MemorySize != 0) "dom0_mem=${toString cfg.domain0MemorySize}M";

     

       93
       120
        
       

     

       94
       121
        
           system.extraSystemBuilderCmds =

     
···

       101
       128
        
           system.activationScripts.xen =

     

       102
       129
        
             ''

     

       103
       130
        
               if [ -d /proc/xen ]; then

     

       104
       104
       -
                   ${pkgs.sysvtools}/bin/mountpoint -q /proc/xen || \

     

       131
       131
       +
                   ${pkgs.kmod}/bin/modprobe xenfs 2> /dev/null

     

       132
       132
       +
                   ${pkgs.utillinux}/bin/mountpoint -q /proc/xen || \

     

       105
       133
        
                       ${pkgs.utillinux}/bin/mount -t xenfs none /proc/xen

     

       106
       134
        
               fi

     

       107
       135
        
             '';

     

       108
       136
        
       

     

       109
       109
       -
           jobs.xend =

     

       110
       110
       -
             { description = "Xen Control Daemon";

     

       137
       137
       +
           # Domain 0 requires a pvops-enabled kernel.

     

       138
       138
       +
           system.requiredKernelConfig = with config.lib.kernelConfig;

     

       139
       139
       +
             [ (isYes "XEN")

     

       140
       140
       +
               (isYes "X86_IO_APIC")

     

       141
       141
       +
               (isYes "ACPI")

     

       142
       142
       +
               (isYes "XEN_DOM0")

     

       143
       143
       +
               (isYes "PCI_XEN")

     

       144
       144
       +
               (isYes "XEN_DEV_EVTCHN")

     

       145
       145
       +
               (isYes "XENFS")

     

       146
       146
       +
               (isYes "XEN_COMPAT_XENFS")

     

       147
       147
       +
               (isYes "XEN_SYS_HYPERVISOR")

     

       148
       148
       +
               (isYes "XEN_GNTDEV")

     

       149
       149
       +
               (isYes "XEN_BACKEND")

     

       150
       150
       +
               (isModule "XEN_NETDEV_BACKEND")

     

       151
       151
       +
               (isModule "XEN_BLKDEV_BACKEND")

     

       152
       152
       +
               (isModule "XEN_PCIDEV_BACKEND")

     

       153
       153
       +
               (isYes "XEN_BALLOON")

     

       154
       154
       +
               (isYes "XEN_SCRUB_PAGES")

     

       155
       155
       +
             ];

     

       111
       156
        
       

     

       112
       112
       -
               startOn = "stopped udevtrigger";

     

       157
       157
       +
       

     

       158
       158
       +
           environment.etc =

     

       159
       159
       +
             [ { source = "${xen}/etc/xen/xl.conf";

     

       160
       160
       +
                 target = "xen/xl.conf";

     

       161
       161
       +
               }

     

       162
       162
       +
             ];

     

       113
       163
        
       

     

       114
       114
       -
               path =

     

       115
       115
       -
                 [ pkgs.bridge-utils pkgs.gawk pkgs.iproute pkgs.nettools

     

       116
       116
       -
                   pkgs.utillinux pkgs.bash xen pkgs.pciutils pkgs.procps

     

       117
       117
       -
                 ];

     

       164
       164
       +
           # Xen provides udev rules.

     

       165
       165
       +
           services.udev.packages = [ xen ];

     

       118
       166
        
       

     

       119
       119
       -
               environment.XENCONSOLED_TRACE = "hv";

     

       167
       167
       +
           services.udev.path = [ pkgs.bridge-utils pkgs.iproute ];

     

       120
       168
        
       

     

       121
       121
       -
               preStart =

     

       122
       122
       -
                 ''

     

       123
       123
       -
                   mkdir -p /var/log/xen/console -m 0700

     

       169
       169
       +
           systemd.services.xen-store = {

     

       170
       170
       +
             description = "Xen Store Daemon";

     

       171
       171
       +
             wantedBy = [ "multi-user.target" ];

     

       172
       172
       +
             after = [ "network.target" "xen-store.socket" ];

     

       173
       173
       +
             requires = [ "xen-store.socket" ];

     

       174
       174
       +
             preStart = ''

     

       175
       175
       +
               export XENSTORED_ROOTDIR="/var/lib/xenstored"

     

       176
       176
       +
               rm -f "$XENSTORED_ROOTDIR"/tdb* &>/dev/null

     

       124
       177
        
       

     

       125
       125
       -
                   ${xen}/sbin/xend start

     

       178
       178
       +
               mkdir -p /var/run

     

       179
       179
       +
               ${optionalString cfg.trace "mkdir -p /var/log/xen"}

     

       180
       180
       +
               grep -q control_d /proc/xen/capabilities

     

       181
       181
       +
               '';

     

       182
       182
       +
             serviceConfig.ExecStart = ''

     

       183
       183
       +
               ${cfg.stored}${optionalString cfg.trace " -T /var/log/xen/xenstored-trace.log"} --no-fork

     

       184
       184
       +
               '';

     

       185
       185
       +
             postStart = ''

     

       186
       186
       +
               time=0

     

       187
       187
       +
               timeout=30

     

       188
       188
       +
               # Wait for xenstored to actually come up, timing out after 30 seconds

     

       189
       189
       +
               while [ $time -lt $timeout ] && ! `${pkgs.xen}/bin/xenstore-read -s / >/dev/null 2>&1` ; do

     

       190
       190
       +
                   time=$(($time+1))

     

       191
       191
       +
                   sleep 1

     

       192
       192
       +
               done

     

       126
       193
        
       

     

       127
       127
       -
                   # Wait until Xend is running.

     

       128
       128
       -
                   for ((i = 0; i < 60; i++)); do echo "waiting for xend..."; ${xen}/sbin/xend status && break; done

     

       194
       194
       +
               # Exit if we timed out

     

       195
       195
       +
               if ! [ $time -lt $timeout ] ; then

     

       196
       196
       +
                   echo "Could not start Xenstore Daemon"

     

       197
       197
       +
                   exit 1

     

       198
       198
       +
               fi

     

       129
       199
        
       

     

       130
       130
       -
                   ${xen}/sbin/xend status || exit 1

     

       131
       131
       -
                 '';

     

       200
       200
       +
               ${pkgs.xen}/bin/xenstore-write "/local/domain/0/name" "Domain-0"

     

       201
       201
       +
               ${pkgs.xen}/bin/xenstore-write "/local/domain/0/domid" 0

     

       202
       202
       +
               '';

     

       203
       203
       +
           };

     

       132
       204
        
       

     

       133
       133
       -
               postStop = "${xen}/sbin/xend stop";

     

       205
       205
       +
           systemd.sockets.xen-store = {

     

       206
       206
       +
             description = "XenStore Socket for userspace API";

     

       207
       207
       +
             wantedBy = [ "sockets.target" ];

     

       208
       208
       +
             socketConfig = {

     

       209
       209
       +
               ListenStream = [ "/var/run/xenstored/socket" "/var/run/xenstored/socket_ro" ];

     

       210
       210
       +
               SocketMode = "0660";

     

       211
       211
       +
               SocketUser = "root";

     

       212
       212
       +
               SocketGroup = "root";

     

       134
       213
        
             };

     

       214
       214
       +
           };

     

       135
       215
        
       

     

       136
       136
       -
           jobs.xendomains =

     

       137
       137
       -
             { description = "Automatically starts, saves and restores Xen domains on startup/shutdown";

     

       138
       216
        
       

     

       139
       139
       -
               startOn = "started xend";

     

       217
       217
       +
           systemd.services.xen-console = {

     

       218
       218
       +
             description = "Xen Console Daemon";

     

       219
       219
       +
             wantedBy = [ "multi-user.target" ];

     

       220
       220
       +
             after = [ "xen-store.service" ];

     

       221
       221
       +
             preStart = ''

     

       222
       222
       +
               mkdir -p /var/run/xen

     

       223
       223
       +
               ${optionalString cfg.trace "mkdir -p /var/log/xen"}

     

       224
       224
       +
               grep -q control_d /proc/xen/capabilities

     

       225
       225
       +
               '';

     

       226
       226
       +
             serviceConfig = {

     

       227
       227
       +
               ExecStart = ''

     

       228
       228
       +
                 ${pkgs.xen}/bin/xenconsoled${optionalString cfg.trace " --log=all --log-dir=/var/log/xen"}

     

       229
       229
       +
                 '';

     

       230
       230
       +
             };

     

       231
       231
       +
           };

     

       140
       232
        
       

     

       141
       141
       -
               stopOn = "starting shutdown and stopping xend";

     

       142
       233
        
       

     

       143
       143
       -
               restartIfChanged = false;

     

       144
       144
       -
               

     

       145
       145
       -
               path = [ pkgs.xen ];

     

       234
       234
       +
           systemd.services.xen-qemu = {

     

       235
       235
       +
             description = "Xen Qemu Daemon";

     

       236
       236
       +
             wantedBy = [ "multi-user.target" ];

     

       237
       237
       +
             after = [ "xen-console.service" ];

     

       238
       238
       +
             serviceConfig.ExecStart = ''

     

       239
       239
       +
               ${pkgs.xen}/lib/xen/bin/qemu-system-i386 -xen-domid 0 -xen-attach -name dom0 -nographic -M xenpv \

     

       240
       240
       +
                  -monitor /dev/null -serial /dev/null -parallel /dev/null

     

       241
       241
       +
               '';

     

       242
       242
       +
           };

     

       146
       243
        
       

     

       147
       147
       -
               environment.XENDOM_CONFIG = "${xen}/etc/sysconfig/xendomains";

     

       148
       244
        
       

     

       149
       149
       -
               preStart =

     

       150
       150
       -
                 ''

     

       151
       151
       -
                   mkdir -p /var/lock/subsys -m 755

     

       152
       152
       -
                   ${xen}/etc/init.d/xendomains start

     

       153
       153
       -
                 '';

     

       154
       154
       -
       

     

       155
       155
       -
               postStop = "${xen}/etc/init.d/xendomains stop";

     

       156
       156
       -
             };

     

       157
       157
       -
       

     

       158
       158
       -
           # To prevent a race between dhcpcd and xend's bridge setup script

     

       159
       159
       -
           # (which renames eth* to peth* and recreates eth* as a virtual

     

       160
       160
       -
           # device), start dhcpcd after xend.

     

       161
       161
       -
           jobs.dhcpcd.startOn = mkOverride 50 "started xend";

     

       245
       245
       +
           systemd.services.xen-watchdog = {

     

       246
       246
       +
             description = "Xen Watchdog Daemon";

     

       247
       247
       +
             wantedBy = [ "multi-user.target" ];

     

       248
       248
       +
             after = [ "xen-qemu.service" ];

     

       249
       249
       +
             serviceConfig.ExecStart = "${pkgs.xen}/bin/xenwatchdogd 30 15";

     

       250
       250
       +
             serviceConfig.Type = "forking";

     

       251
       251
       +
             serviceConfig.RestartSec = "1";

     

       252
       252
       +
             serviceConfig.Restart = "on-failure";

     

       253
       253
       +
           };

     

       162
       254
        
       

     

       163
       163
       -
           environment.etc =

     

       164
       164
       -
             [ { source = xendConfig;

     

       165
       165
       -
                 target = "xen/xend-config.sxp";

     

       166
       166
       -
               }

     

       167
       167
       -
               { source = "${xen}/etc/xen/scripts";

     

       168
       168
       -
                 target = "xen/scripts";

     

       169
       169
       -
               }

     

       170
       170
       -
             ];

     

       171
       255
        
       

     

       172
       172
       -
           # Xen provides udev rules.

     

       173
       173
       -
           services.udev.packages = [ xen ];

     

       256
       256
       +
           systemd.services.xen-bridge = {

     

       257
       257
       +
             description = "Xen bridge";

     

       258
       258
       +
             wantedBy = [ "multi-user.target" ];

     

       259
       259
       +
             before = [ "xen-domains.service" ];

     

       260
       260
       +
             serviceConfig.RemainAfterExit = "yes";

     

       261
       261
       +
             serviceConfig.ExecStart = ''

     

       262
       262
       +
               ${pkgs.bridge-utils}/bin/brctl addbr ${cfg.bridge}

     

       263
       263
       +
               ${pkgs.inetutils}/bin/ifconfig ${cfg.bridge} up

     

       264
       264
       +
               '';

     

       265
       265
       +
             serviceConfig.ExecStop = ''

     

       266
       266
       +
               ${pkgs.inetutils}/bin/ifconfig ${cfg.bridge} down

     

       267
       267
       +
               ${pkgs.bridge-utils}/bin/brctl delbr ${cfg.bridge}

     

       268
       268
       +
               '';

     

       269
       269
       +
           };

     

       174
       270
        
       

     

       175
       175
       -
           services.udev.path = [ pkgs.bridge-utils pkgs.iproute ];

     

       271
       271
       +
           systemd.services.xen-domains = {

     

       272
       272
       +
             description = "Xen domains - automatically starts, saves and restores Xen domains";

     

       273
       273
       +
             wantedBy = [ "multi-user.target" ];

     

       274
       274
       +
             after = [ "xen-bridge.service" "xen-qemu.service" ];

     

       275
       275
       +
             ## To prevent a race between dhcpcd and xend's bridge setup script

     

       276
       276
       +
             ## (which renames eth* to peth* and recreates eth* as a virtual

     

       277
       277
       +
             ## device), start dhcpcd after xend.

     

       278
       278
       +
             before = [ "dhcpd.service" ];

     

       279
       279
       +
             restartIfChanged = false;

     

       280
       280
       +
             serviceConfig.RemainAfterExit = "yes";

     

       281
       281
       +
             path = [ pkgs.xen ];

     

       282
       282
       +
             environment.XENDOM_CONFIG = "${pkgs.xen}/etc/sysconfig/xendomains";

     

       283
       283
       +
             preStart = "mkdir -p /var/lock/subsys -m 755";

     

       284
       284
       +
             serviceConfig.ExecStart = "${pkgs.xen}/etc/init.d/xendomains start";

     

       285
       285
       +
             serviceConfig.ExecStop = "${pkgs.xen}/etc/init.d/xendomains stop";

     

       286
       286
       +
           };

     

       176
       287
        
       

     

       177
       288
        
         };

     

       178
       289

+4 -1

nixos/modules/virtualisation/xen-domU.nix

···

       9
       9
        
         boot.loader.grub.device = "nodev";

     

       10
       10
        
         boot.loader.grub.extraPerEntryConfig = "root (hd0)";

     

       11
       11
        
       

     

       12
       12
       -
         boot.initrd.kernelModules = [ "xen-blkfront" ];

     

       12
       12
       +
         boot.initrd.kernelModules =

     

       13
       13
       +
           [ "xen-blkfront" "xen-tpmfront" "xen-kbdfront" "xen-fbfront"

     

       14
       14
       +
             "xen-netfront" "xen-pcifront" "xen-scsifront"

     

       15
       15
       +
           ];

     

       13
       16
        
       

     

       14
       17
        
         # Send syslog messages to the Xen console.

     

       15
       18
        
         services.syslogd.tty = "hvc0";

+46

pkgs/applications/virtualization/xen/4.4.1.nix

···

       1
       1
       +
       { callPackage, fetchurl, ... } @ args:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         # Xen 4.4.1

     

       5
       5
       +
         xenConfig = {

     

       6
       6
       +
           name = "xen-4.4.1";

     

       7
       7
       +
           version = "4.4.1";

     

       8
       8
       +
       

     

       9
       9
       +
           src = fetchurl {

     

       10
       10
       +
             url = "http://bits.xensource.com/oss-xen/release/4.4.1/xen-4.4.1.tar.gz";

     

       11
       11
       +
             sha256 = "09gaqydqmy64s5pqnwgjyzhd3wc61xyghpqjfl97kmvm8ly9vd2m";

     

       12
       12
       +
           };

     

       13
       13
       +
       

     

       14
       14
       +
           # Sources needed to build the xen tools and tools/firmware.

     

       15
       15
       +
           toolsGits =

     

       16
       16
       +
             [ # tag qemu-xen-4.4.1

     

       17
       17
       +
               { name = "qemu-xen";

     

       18
       18
       +
                 url = git://xenbits.xen.org/qemu-upstream-4.4-testing.git;

     

       19
       19
       +
                 rev = "65fc9b78ba3d868a26952db0d8e51cecf01d47b4";

     

       20
       20
       +
                 sha256 = "e24fb58f773fd9134c5aae6d3ca7e9f754dc9822de92b1eb2cedc76faf911f18";

     

       21
       21
       +
               }

     

       22
       22
       +
               # tag xen-4.4.1

     

       23
       23
       +
               {  name = "qemu-xen-traditional";

     

       24
       24
       +
                 url = git://xenbits.xen.org/qemu-xen-4.4-testing.git;

     

       25
       25
       +
                 rev = "6ae4e588081620b141071eb010ec40aca7e12876";

     

       26
       26
       +
                 sha256 = "b1ed1feb92fbe658273a8d6d38d6ea60b79c1658413dd93979d6d128d8554ded";

     

       27
       27
       +
               }

     

       28
       28
       +
             ];

     

       29
       29
       +
       

     

       30
       30
       +
           firmwareGits =

     

       31
       31
       +
             [ # tag 1.7.3.1

     

       32
       32
       +
               { name = "seabios";

     

       33
       33
       +
                 url = git://xenbits.xen.org/seabios.git;

     

       34
       34
       +
                 rev = "7d9cbe613694924921ed1a6f8947d711c5832eee";

     

       35
       35
       +
                 sha256 = "c071282bbcb1dd0d98536ef90cd1410f5d8da19648138e0e3863bc540d954a87";

     

       36
       36
       +
               }

     

       37
       37
       +
               { name = "ovmf";

     

       38
       38
       +
                 url = git://xenbits.xen.org/ovmf.git;

     

       39
       39
       +
                 rev = "447d264115c476142f884af0be287622cd244423";

     

       40
       40
       +
                 sha256 = "7086f882495a8be1497d881074e8f1005dc283a5e1686aec06c1913c76a6319b";

     

       41
       41
       +
               }

     

       42
       42
       +
             ];

     

       43
       43
       +
       

     

       44
       44
       +
         };

     

       45
       45
       +
       

     

       46
       46
       +
       in callPackage ./generic.nix (args // { xenConfig=xenConfig; })

+58

pkgs/applications/virtualization/xen/4.5.0.nix

···

       1
       1
       +
       { callPackage, fetchurl, fetchgit, ... } @ args:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         # Xen 4.5.0

     

       5
       5
       +
         xenConfig = {

     

       6
       6
       +
           name = "xen-4.5.0";

     

       7
       7
       +
           version = "4.5.0";

     

       8
       8
       +
       

     

       9
       9
       +
           src = fetchurl {

     

       10
       10
       +
             url = "http://bits.xensource.com/oss-xen/release/4.5.0/xen-4.5.0.tar.gz";

     

       11
       11
       +
             sha256 = "0fvg00d596gh6cfm51xr8kj2mghcyivrf6np3dafnbldnbi41nsv";

     

       12
       12
       +
           };

     

       13
       13
       +
       

     

       14
       14
       +
           # Sources needed to build the xen tools and tools/firmware.

     

       15
       15
       +
           firmwareGits =

     

       16
       16
       +
             [ # tag 1.7.5

     

       17
       17
       +
               { name = "seabios";

     

       18
       18
       +
                 url = git://xenbits.xen.org/seabios.git;

     

       19
       19
       +
                 rev = "e51488c5f8800a52ac5c8da7a31b85cca5cc95d2";

     

       20
       20
       +
                 sha256 = "b96a0b9f31cab0f3993d007dcbe5f1bd69ad02b0a23eb2dc8a3ed1aafe7985cb";

     

       21
       21
       +
               }

     

       22
       22
       +
               { name = "ovmf";

     

       23
       23
       +
                 url = git://xenbits.xen.org/ovmf.git;

     

       24
       24
       +
                 rev = "447d264115c476142f884af0be287622cd244423";

     

       25
       25
       +
                 sha256 = "7086f882495a8be1497d881074e8f1005dc283a5e1686aec06c1913c76a6319b";

     

       26
       26
       +
               }

     

       27
       27
       +
             ];

     

       28
       28
       +
       

     

       29
       29
       +
           toolsGits =

     

       30
       30
       +
             [ # tag qemu-xen-4.5.0

     

       31
       31
       +
               { name = "qemu-xen";

     

       32
       32
       +
                 url = git://xenbits.xen.org/qemu-upstream-4.5-testing.git;

     

       33
       33
       +
                 rev = "1ebb75b1fee779621b63e84fefa7b07354c43a99";

     

       34
       34
       +
                 sha256 = "1j312q2mqvkvby9adkkxf7f1pn3nz85g5mr9nbg4qpf2y9cg122z";

     

       35
       35
       +
               }

     

       36
       36
       +
               # tag xen-4.5.0

     

       37
       37
       +
               { name = "qemu-xen-traditional";

     

       38
       38
       +
                 url = git://xenbits.xen.org/qemu-xen-4.5-testing.git;

     

       39
       39
       +
                 rev = "b0d42741f8e9a00854c3b3faca1da84bfc69bf22";

     

       40
       40
       +
                 sha256 = "ce52b5108936c30ab85ec0c9554f88d5e7b34896f3acb666d56765b49c86f2af";

     

       41
       41
       +
               }

     

       42
       42
       +
             ];

     

       43
       43
       +
       

     

       44
       44
       +
           xenserverPatches = let

     

       45
       45
       +
             patches = {

     

       46
       46
       +
               url = https://github.com/ts468/xen-4.5.pg.git;

     

       47
       47
       +
               rev = "3442b65b490f43c817cbc53369220d0b1ab9b785";

     

       48
       48
       +
               sha256 = "31436c15def0a300b3ea1a63b2208c4a3bcbb143db5c6488d4db370b3ceeb845";

     

       49
       49
       +
             };

     

       50
       50
       +
             in ''

     

       51
       51
       +
               cp -r ${fetchgit patches}/master patches

     

       52
       52
       +
               quilt push -a

     

       53
       53
       +
               substituteInPlace tools/xenguest/Makefile --replace "_BSD_SOURCE" "_DEFAULT_SOURCE"

     

       54
       54
       +
               '';

     

       55
       55
       +
         };

     

       56
       56
       +
       

     

       57
       57
       +
       in callPackage ./generic.nix (args // { xenConfig=xenConfig; })

     

       58
       58
       +

+43 -44

pkgs/applications/virtualization/xen/default.nix pkgs/applications/virtualization/xen/generic.nix

···

       3
       3
        
       , lvm2, utillinux, procps, texinfo, perl, pythonPackages

     

       4
       4
        
       , glib, bridge-utils, xlibs, pixman, iproute, udev, bison

     

       5
       5
        
       , flex, cmake, ocaml, ocamlPackages, figlet, libaio, yajl

     

       6
       6
       -
       , checkpolicy, transfig, glusterfs, fetchgit, xz }:

     

       6
       6
       +
       , checkpolicy, transfig, glusterfs, fetchgit, xz, spice

     

       7
       7
       +
       , spice_protocol, usbredir, alsaLib, quilt

     

       8
       8
       +
       , coreutils, gawk, gnused, gnugrep, diffutils, multipath_tools

     

       9
       9
       +
       , inetutils, iptables, openvswitch, nbd, drbd, xenConfig

     

       10
       10
       +
       , xenserverPatched ? false, ... }:

     

       7
       11
        
       

     

       8
       12
        
       with stdenv.lib;

     

       9
       13
        
       

     

       10
       14
        
       let

     

       11
       11
       -
         version = "4.4.1";

     

       12
       15
        
       

     

       13
       16
        
         libDir = if stdenv.is64bit then "lib64" else "lib";

     

       14
       17
        
       

     

       15
       15
       -
         # Sources needed to build the xen tools and tools/firmware.

     

       16
       16
       -
         toolsGits =

     

       17
       17
       -
           [ # tag qemu-xen-4.4.1

     

       18
       18
       -
             #{ name = "qemu-xen";

     

       19
       19
       -
             #  url = git://xenbits.xen.org/qemu-upstream-4.4-testing.git;

     

       20
       20
       -
             #  rev = "65fc9b78ba3d868a26952db0d8e51cecf01d47b4";

     

       21
       21
       -
             #  sha256 = "e7abaf0e927f7a2bba4c59b6dad6ae19e77c92689c94fa0384e2c41742f8cdb6";

     

       22
       22
       -
             #}

     

       23
       23
       -
             # tag xen-4.4.1

     

       24
       24
       -
             {  name = "qemu-xen-traditional";

     

       25
       25
       -
               url = git://xenbits.xen.org/qemu-xen-4.4-testing.git;

     

       26
       26
       -
               rev = "6ae4e588081620b141071eb010ec40aca7e12876";

     

       27
       27
       -
               sha256 = "b1ed1feb92fbe658273a8d6d38d6ea60b79c1658413dd93979d6d128d8554ded";

     

       28
       28
       -
             }

     

       29
       29
       -
           ];

     

       30
       30
       -
         firmwareGits =

     

       31
       31
       -
           [ # tag 1.7.3.1

     

       32
       32
       -
             { name = "seabios";

     

       33
       33
       -
               url = git://xenbits.xen.org/seabios.git;

     

       34
       34
       -
               rev = "7d9cbe613694924921ed1a6f8947d711c5832eee";

     

       35
       35
       -
               sha256 = "c071282bbcb1dd0d98536ef90cd1410f5d8da19648138e0e3863bc540d954a87";

     

       36
       36
       -
             }

     

       37
       37
       -
             { name = "ovmf";

     

       38
       38
       -
               url = git://xenbits.xen.org/ovmf.git;

     

       39
       39
       -
               rev = "447d264115c476142f884af0be287622cd244423";

     

       40
       40
       -
               sha256 = "7086f882495a8be1497d881074e8f1005dc283a5e1686aec06c1913c76a6319b";

     

       41
       41
       -
             }

     

       42
       42
       -
           ];

     

       43
       43
       -
       

     

       44
       44
       -
       

     

       45
       18
        
         # Sources needed to build the stubdoms and tools

     

       19
       19
       +
         # These sources are already rather old and probably do not change frequently

     

       46
       20
        
         xenExtfiles = [

     

       47
       21
        
             { url = http://xenbits.xensource.com/xen-extfiles/lwip-1.3.0.tar.gz;

     

       48
       22
        
               sha256 = "13wlr85s1hnvia6a698qpryyy12lvmqw0a05xmjnd0h71ralsbkp";

     
···

       76
       50
        
             }

     

       77
       51
        
           ];

     

       78
       52
        
       

     

       53
       53
       +
         scriptEnvPath = stdenv.lib.concatStrings (stdenv.lib.intersperse ":" (map (x: "${x}/bin")

     

       54
       54
       +
           [ coreutils gawk gnused gnugrep which perl diffutils utillinux multipath_tools

     

       55
       55
       +
             iproute inetutils iptables bridge_utils openvswitch nbd drbd ]));

     

       79
       56
        
       in

     

       80
       57
        
       

     

       58
       58
       +
       

     

       59
       59
       +
       

     

       81
       60
        
       stdenv.mkDerivation {

     

       82
       82
       -
         name = "xen-${version}";

     

       83
       83
       -
       

     

       84
       84
       -
         src = fetchurl {

     

       85
       85
       -
           url = "http://bits.xensource.com/oss-xen/release/${version}/xen-${version}.tar.gz";

     

       86
       86
       -
           sha256 = "09gaqydqmy64s5pqnwgjyzhd3wc61xyghpqjfl97kmvm8ly9vd2m";

     

       87
       87
       -
         };

     

       61
       61
       +
         inherit (xenConfig) name version src;

     

       88
       62
        
       

     

       89
       63
        
         dontUseCmakeConfigure = true;

     

       90
       64
        
       

     
···

       95
       69
        
             glib bridge-utils pixman iproute udev bison xlibs.libX11

     

       96
       70
        
             flex ocaml ocamlPackages.findlib figlet libaio

     

       97
       71
        
             checkpolicy pythonPackages.markdown transfig

     

       98
       98
       -
             glusterfs cmake

     

       72
       72
       +
             glusterfs cmake spice spice_protocol usbredir

     

       73
       73
       +
             alsaLib quilt

     

       99
       74
        
           ];

     

       100
       75
        
       

     

       101
       76
        
         pythonPath = [ pythonPackages.curses ];

     

       102
       77
        
       

     

       78
       78
       +
         patchPhase = if ((xenserverPatched == true) && (builtins.hasAttr "xenserverPatches" xenConfig))

     

       79
       79
       +
           then xenConfig.xenserverPatches

     

       80
       80
       +
           else "";

     

       103
       81
        
       

     

       104
       82
        
         preConfigure = ''

     

       105
       83
        
           # Fake wget: copy prefetched downloads instead

     
···

       111
       89
        
           export PATH=$PATH:$PWD/wget

     

       112
       90
        
         '';

     

       113
       91
        
       

     

       92
       92
       +
         # TODO: If multiple arguments are given with with-extra-qemuu,

     

       93
       93
       +
         #       then the configuration aborts; the reason is unclear.

     

       94
       94
       +
         #       If you know how to fix it, please let me know! :)

     

       95
       95
       +
         #configureFlags = "--with-extra-qemuu-configure-args='--enable-spice --enable-usb-redir --enable-linux-aio'";

     

       96
       96
       +
       

     

       97
       97
       +
         # TODO: Flask needs more testing before enabling it by default.

     

       98
       98
       +
         #makeFlags = "XSM_ENABLE=y FLASK_ENABLE=y PREFIX=$(out) CONFIG_DIR=/etc XEN_EXTFILES_URL=\\$(XEN_ROOT)/xen_ext_files ";

     

       114
       99
        
         makeFlags = "PREFIX=$(out) CONFIG_DIR=/etc XEN_EXTFILES_URL=\\$(XEN_ROOT)/xen_ext_files ";

     

       115
       100
        
       

     

       116
       101
        
         buildFlags = "xen tools stubdom";

     
···

       136
       121
        
             substituteInPlace tools/ioemu-qemu-xen/xen-hooks.mak \

     

       137
       122
        
               --replace /usr/include/pci ${pciutils}/include/pci

     

       138
       123
        
       

     

       124
       124
       +
             substituteInPlace tools/hotplug/Linux/xen-backend.rules \

     

       125
       125
       +
               --replace /etc/xen/scripts $out/etc/xen/scripts

     

       126
       126
       +
       

     

       127
       127
       +
             # blktap is not provided by xen, but by xapi

     

       128
       128
       +
             sed -i '/blktap/d' tools/hotplug/Linux/xen-backend.rules

     

       129
       129
       +
       

     

       139
       130
        
             # Work around a bug in our GCC wrapper: `gcc -MF foo -v' doesn't

     

       140
       131
        
             # print the GCC version number properly.

     

       141
       132
        
             substituteInPlace xen/Makefile \

     
···

       157
       148
        
             # overriden at runtime.

     

       158
       149
        
             substituteInPlace tools/hotplug/Linux/init.d/xendomains \

     

       159
       150
        
               --replace 'XENDOM_CONFIG=/etc/sysconfig/xendomains' "" \

     

       151
       151
       +
               --replace 'XENDOM_CONFIG=/etc/default/xendomains' "" \

     

       152
       152
       +
               --replace /etc/xen/scripts/hotplugpath.sh $out/etc/xen/scripts/hotplugpath.sh \

     

       160
       153
        
               --replace /bin/ls ls

     

       161
       154
        
       

     

       162
       155
        
             # Xen's tools and firmares need various git repositories that it

     

       163
       156
        
             # usually checks out at time using git.  We can't have that.

     

       164
       164
       -
             ${flip concatMapStrings toolsGits (x: let src = fetchgit x; in ''

     

       157
       157
       +
             ${flip concatMapStrings xenConfig.toolsGits (x: let src = fetchgit x; in ''

     

       165
       158
        
               cp -r ${src} tools/${src.name}-dir-remote

     

       166
       159
        
               chmod +w tools/${src.name}-dir-remote

     

       167
       160
        
             '')}

     

       168
       168
       -
             ${flip concatMapStrings firmwareGits (x: let src = fetchgit x; in ''

     

       161
       161
       +
             ${flip concatMapStrings xenConfig.firmwareGits (x: let src = fetchgit x; in ''

     

       169
       162
        
               cp -r ${src} tools/firmware/${src.name}-dir-remote

     

       170
       163
        
               chmod +w tools/firmware/${src.name}-dir-remote

     

       171
       164
        
             '')}

     
···

       189
       182
        
       

     

       190
       183
        
         installPhase =

     

       191
       184
        
           ''

     

       192
       192
       -
             mkdir -p $out

     

       185
       185
       +
             mkdir -p $out $out/share

     

       193
       186
        
             cp -prvd dist/install/nix/store/*/* $out/

     

       194
       187
        
             cp -prvd dist/install/boot $out/boot

     

       195
       195
       -
             cp -prvd dist/install/etc $out/etc

     

       188
       188
       +
             cp -prvd dist/install/etc $out

     

       196
       189
        
             cp -dR docs/man1 docs/man5 $out/share/man/

     

       197
       190
        
             wrapPythonPrograms

     

       198
       198
       -
           ''; # */

     

       191
       191
       +
             substituteInPlace $out/etc/xen/scripts/hotplugpath.sh --replace SBINDIR=\"$out/sbin\" SBINDIR=\"$out/bin\"

     

       192
       192
       +
       

     

       193
       193
       +
             shopt -s extglob

     

       194
       194
       +
             for i in $out/etc/xen/scripts/!(*.sh); do

     

       195
       195
       +
               sed -i '2s@^@export PATH=$out/bin:${scriptEnvPath}@' $i

     

       196
       196
       +
             done

     

       197
       197
       +
           '';

     

       199
       198
        
       

     

       200
       199
        
         meta = {

     

       201
       200
        
           homepage = http://www.xen.org/;

+4 -3

pkgs/top-level/all-packages.nix

···

       12008
       12008
        
       

     

       12009
       12009
        
         xdotool = callPackage ../tools/X11/xdotool { };

     

       12010
       12010
        
       

     

       12011
       12011
       -
         xen = callPackage ../applications/virtualization/xen {

     

       12012
       12012
       -
           stdenv = overrideCC stdenv gcc45;

     

       12013
       12013
       -
         };

     

       12011
       12011
       +
         xen_4_4_1 = callPackage ../applications/virtualization/xen/4.4.1.nix { };

     

       12012
       12012
       +
         xen_4_5_0 = callPackage ../applications/virtualization/xen/4.5.0.nix { };

     

       12013
       12013
       +
         xen_xenServer = callPackage ../applications/virtualization/xen/4.5.0.nix { xenserverPatched = true; };

     

       12014
       12014
       +
         xen = xen_4_5_0;

     

       12014
       12015
        
       

     

       12015
       12016
        
         xfe = callPackage ../applications/misc/xfe {

     

       12016
       12017
        
           fox = fox_1_6;