nixos/modules/virtualisation/xen-dom0.nix

   1 # Xen Project Hypervisor (Dom0) support.
   2
   3 {
   4   config,
   5   lib,
   6   pkgs,
   7   ...
   8 }:
   9
  10 let
  11   inherit (builtins) readFile;
  12   inherit (lib.modules) mkRemovedOptionModule mkRenamedOptionModule mkIf;
  13   inherit (lib.options)
  14     mkOption
  15     mkEnableOption
  16     literalExpression
  17     mkPackageOption
  18     ;
  19   inherit (lib.types)
  20     listOf
  21     str
  22     ints
  23     lines
  24     enum
  25     path
  26     submodule
  27     addCheck
  28     float
  29     bool
  30     int
  31     nullOr
  32     ;
  33   inherit (lib.lists) optional optionals;
  34   inherit (lib.strings) hasSuffix optionalString;
  35   inherit (lib.meta) getExe;
  36   inherit (lib.attrsets) optionalAttrs;
  37   inherit (lib.trivial) boolToString;
  38   inherit (lib.teams.xen) members;
  39
  40   cfg = config.virtualisation.xen;
  41
  42   xenBootBuilder = pkgs.writeShellApplication {
  43     name = "xenBootBuilder";
  44     runtimeInputs =
  45       (with pkgs; [
  46         binutils
  47         coreutils
  48         findutils
  49         gawk
  50         gnugrep
  51         gnused
  52         jq
  53       ])
  54       ++ optionals (cfg.efi.bootBuilderVerbosity == "info") (
  55         with pkgs;
  56         [
  57           bat
  58           diffutils
  59         ]
  60       );
  61     runtimeEnv = {
  62       efiMountPoint = config.boot.loader.efi.efiSysMountPoint;
  63     };
  64
  65     # We disable SC2016 because we don't want to expand the regexes in the sed commands.
  66     excludeShellChecks = [ "SC2016" ];
  67
  68     text = readFile ./xen-boot-builder.sh;
  69   };
  70 in
  71
  72 {
  73   imports = [
  74     (mkRemovedOptionModule
  75       [
  76         "virtualisation"
  77         "xen"
  78         "bridge"
  79         "name"
  80       ]
  81       "The Xen Network Bridge options are currently unavailable. Please set up your own bridge manually."
  82     )
  83     (mkRemovedOptionModule
  84       [
  85         "virtualisation"
  86         "xen"
  87         "bridge"
  88         "address"
  89       ]
  90       "The Xen Network Bridge options are currently unavailable. Please set up your own bridge manually."
  91     )
  92     (mkRemovedOptionModule
  93       [
  94         "virtualisation"
  95         "xen"
  96         "bridge"
  97         "prefixLength"
  98       ]
  99       "The Xen Network Bridge options are currently unavailable. Please set up your own bridge manually."
 100     )
 101     (mkRemovedOptionModule
 102       [
 103         "virtualisation"
 104         "xen"
 105         "bridge"
 106         "forwardDns"
 107       ]
 108       "The Xen Network Bridge options are currently unavailable. Please set up your own bridge manually."
 109     )
 110     (mkRenamedOptionModule
 111       [
 112         "virtualisation"
 113         "xen"
 114         "qemu-package"
 115       ]
 116       [
 117         "virtualisation"
 118         "xen"
 119         "qemu"
 120         "package"
 121       ]
 122     )
 123     (mkRenamedOptionModule
 124       [
 125         "virtualisation"
 126         "xen"
 127         "package-qemu"
 128       ]
 129       [
 130         "virtualisation"
 131         "xen"
 132         "qemu"
 133         "package"
 134       ]
 135     )
 136     (mkRenamedOptionModule
 137       [
 138         "virtualisation"
 139         "xen"
 140         "stored"
 141       ]
 142       [
 143         "virtualisation"
 144         "xen"
 145         "store"
 146         "path"
 147       ]
 148     )
 149   ];
 150
 151   ## Interface ##
 152
 153   options.virtualisation.xen = {
 154
 155     enable = mkEnableOption "the Xen Project Hypervisor, a virtualisation technology defined as a *type-1 hypervisor*, which allows multiple virtual machines, known as *domains*, to run concurrently on the physical machine. NixOS runs as the privileged *Domain 0*. This option requires a reboot into a Xen kernel to take effect";
 156
 157     debug = mkEnableOption "Xen debug features for Domain 0. This option enables some hidden debugging tests and features, and should not be used in production";
 158
 159     trace = mkOption {
 160       type = bool;
 161       default = cfg.debug;
 162       defaultText = literalExpression "false";
 163       example = true;
 164       description = "Whether to enable Xen debug tracing and logging for Domain 0.";
 165     };
 166
 167     package = mkPackageOption pkgs "Xen Hypervisor" { default = [ "xen" ]; };
 168
 169     qemu = {
 170       package = mkPackageOption pkgs "QEMU (with Xen Hypervisor support)" {
 171         default = [ "qemu_xen" ];
 172       };
 173       pidFile = mkOption {
 174         type = path;
 175         default = "/run/xen/qemu-dom0.pid";
 176         example = "/var/run/xen/qemu-dom0.pid";
 177         description = "Path to the QEMU PID file.";
 178       };
 179     };
 180
 181     bootParams = mkOption {
 182       default = [ ];
 183       example = ''
 184         [
 185           "iommu=force:true,qinval:true,debug:true"
 186           "noreboot=true"
 187           "vga=ask"
 188         ]
 189       '';
 190       type = listOf str;
 191       description = ''
 192         Xen Command Line parameters passed to Domain 0 at boot time.
 193         Note: these are different from `boot.kernelParams`. See
 194         the [Xen documentation](https://xenbits.xenproject.org/docs/unstable/misc/xen-command-line.html) for more information.
 195       '';
 196     };
 197
 198     efi = {
 199       bootBuilderVerbosity = mkOption {
 200         type = enum [
 201           "default"
 202           "info"
 203           "debug"
 204           "quiet"
 205         ];
 206         default = "default";
 207         example = "info";
 208         description = ''
 209           The EFI boot entry builder script should be called with exactly one of the following arguments in order to specify its verbosity:
 210
 211           - `quiet` supresses all messages.
 212
 213           - `default` adds a simple "Installing Xen Project Hypervisor boot entries...done." message to the script.
 214
 215           - `info` is the same as `default`, but it also prints a diff with information on which generations were altered.
 216             - This option adds two extra dependencies to the script: `diffutils` and `bat`.
 217
 218           - `debug` prints information messages for every single step of the script.
 219
 220           This option does not alter the actual functionality of the script, just the number of messages printed when rebuilding the system.
 221         '';
 222       };
 223
 224       path = mkOption {
 225         type = path;
 226         default = "${cfg.package.boot}/${cfg.package.efi}";
 227         defaultText = literalExpression "\${config.virtualisation.xen.package.boot}/\${config.virtualisation.xen.package.efi}";
 228         example = literalExpression "\${config.virtualisation.xen.package}/boot/efi/efi/nixos/xen-\${config.virtualisation.xen.package.version}.efi";
 229         description = ''
 230           Path to xen.efi. `pkgs.xen` is patched to install the xen.efi file
 231           on `$boot/boot/xen.efi`, but an unpatched Xen build may install it
 232           somewhere else, such as `$out/boot/efi/efi/nixos/xen.efi`. Unless
 233           you're building your own Xen derivation, you should leave this
 234           option as the default value.
 235         '';
 236       };
 237     };
 238
 239     dom0Resources = {
 240       maxVCPUs = mkOption {
 241         default = 0;
 242         example = 4;
 243         type = ints.unsigned;
 244         description = ''
 245           Amount of virtual CPU cores allocated to Domain 0 on boot.
 246           If set to 0, all cores are assigned to Domain 0, and
 247           unprivileged domains will compete with Domain 0 for CPU time.
 248         '';
 249       };
 250
 251       memory = mkOption {
 252         default = 0;
 253         example = 512;
 254         type = ints.unsigned;
 255         description = ''
 256           Amount of memory (in MiB) allocated to Domain 0 on boot.
 257           If set to 0, all memory is assigned to Domain 0, and
 258           unprivileged domains will compete with Domain 0 for free RAM.
 259         '';
 260       };
 261
 262       maxMemory = mkOption {
 263         default = cfg.dom0Resources.memory;
 264         defaultText = literalExpression "config.virtualisation.xen.dom0Resources.memory";
 265         example = 1024;
 266         type = ints.unsigned;
 267         description = ''
 268           Maximum amount of memory (in MiB) that Domain 0 can
 269           dynamically allocate to itself. Does nothing if set
 270           to the same amount as virtualisation.xen.memory, or
 271           if that option is set to 0.
 272         '';
 273       };
 274     };
 275
 276     domains = {
 277       extraConfig = mkOption {
 278         type = lines;
 279         default = "";
 280         example = ''
 281           XENDOMAINS_SAVE=/persist/xen/save
 282           XENDOMAINS_RESTORE=false
 283           XENDOMAINS_CREATE_USLEEP=10000000
 284         '';
 285         description = ''
 286           Options defined here will override the defaults for xendomains.
 287           The default options can be seen in the file included from
 288           /etc/default/xendomains.
 289         '';
 290       };
 291     };
 292
 293     store = {
 294       path = mkOption {
 295         type = path;
 296         default = "${cfg.package}/bin/oxenstored";
 297         defaultText = literalExpression "\${config.virtualisation.xen.package}/bin/oxenstored";
 298         example = literalExpression "\${config.virtualisation.xen.package}/bin/xenstored";
 299         description = ''
 300           Path to the Xen Store Daemon. This option is useful to
 301           switch between the legacy C-based Xen Store Daemon, and
 302           the newer OCaml-based Xen Store Daemon, `oxenstored`.
 303         '';
 304       };
 305       type = mkOption {
 306         type = enum [
 307           "c"
 308           "ocaml"
 309         ];
 310         default = if (hasSuffix "oxenstored" cfg.store.path) then "ocaml" else "c";
 311         internal = true;
 312         readOnly = true;
 313         description = "Helper internal option that determines the type of the Xen Store Daemon based on cfg.store.path.";
 314       };
 315       settings = mkOption {
 316         default = { };
 317         example = {
 318           enableMerge = false;
 319           quota.maxWatchEvents = 2048;
 320           quota.enable = true;
 321           conflict.maxHistorySeconds = 0.12;
 322           conflict.burstLimit = 15.0;
 323           xenstored.log.file = "/dev/null";
 324           xenstored.log.level = "info";
 325         };
 326         description = ''
 327           The OCaml-based Xen Store Daemon configuration. This
 328           option does nothing with the C-based `xenstored`.
 329         '';
 330         type = submodule {
 331           options = {
 332             pidFile = mkOption {
 333               default = "/run/xen/xenstored.pid";
 334               example = "/var/run/xen/xenstored.pid";
 335               type = path;
 336               description = "Path to the Xen Store Daemon PID file.";
 337             };
 338             testEAGAIN = mkOption {
 339               default = cfg.debug;
 340               defaultText = literalExpression "config.virtualisation.xen.debug";
 341               example = true;
 342               type = bool;
 343               visible = false;
 344               description = "Randomly fail a transaction with EAGAIN. This option is used for debugging purposes only.";
 345             };
 346             enableMerge = mkOption {
 347               default = true;
 348               example = false;
 349               type = bool;
 350               description = "Whether to enable transaction merge support.";
 351             };
 352             conflict = {
 353               burstLimit = mkOption {
 354                 default = 5.0;
 355                 example = 15.0;
 356                 type = addCheck (
 357                   float
 358                   // {
 359                     name = "nonnegativeFloat";
 360                     description = "nonnegative floating point number, meaning >=0";
 361                     descriptionClass = "nonRestrictiveClause";
 362                   }
 363                 ) (n: n >= 0);
 364                 description = ''
 365                   Limits applied to domains whose writes cause other domains' transaction
 366                   commits to fail. Must include decimal point.
 367
 368                   The burst limit is the number of conflicts a domain can cause to
 369                   fail in a short period; this value is used for both the initial and
 370                   the maximum value of each domain's conflict-credit, which falls by
 371                   one point for each conflict caused, and when it reaches zero the
 372                   domain's requests are ignored.
 373                 '';
 374               };
 375               maxHistorySeconds = mkOption {
 376                 default = 5.0e-2;
 377                 example = 1.0;
 378                 type = addCheck (float // { description = "nonnegative floating point number, meaning >=0"; }) (
 379                   n: n >= 0
 380                 );
 381                 description = ''
 382                   Limits applied to domains whose writes cause other domains' transaction
 383                   commits to fail. Must include decimal point.
 384
 385                   The conflict-credit is replenished over time:
 386                   one point is issued after each conflict.maxHistorySeconds, so this
 387                   is the minimum pause-time during which a domain will be ignored.
 388                 '';
 389               };
 390               rateLimitIsAggregate = mkOption {
 391                 default = true;
 392                 example = false;
 393                 type = bool;
 394                 description = ''
 395                   If the conflict.rateLimitIsAggregate option is `true`, then after each
 396                   tick one point of conflict-credit is given to just one domain: the
 397                   one at the front of the queue. If `false`, then after each tick each
 398                   domain gets a point of conflict-credit.
 399
 400                   In environments where it is known that every transaction will
 401                   involve a set of nodes that is writable by at most one other domain,
 402                   then it is safe to set this aggregate limit flag to `false` for better
 403                   performance. (This can be determined by considering the layout of
 404                   the xenstore tree and permissions, together with the content of the
 405                   transactions that require protection.)
 406
 407                   A transaction which involves a set of nodes which can be modified by
 408                   multiple other domains can suffer conflicts caused by any of those
 409                   domains, so the flag must be set to `true`.
 410                 '';
 411               };
 412             };
 413             perms = {
 414               enable = mkOption {
 415                 default = true;
 416                 example = false;
 417                 type = bool;
 418                 description = "Whether to enable the node permission system.";
 419               };
 420               enableWatch = mkOption {
 421                 default = true;
 422                 example = false;
 423                 type = bool;
 424                 description = ''
 425                   Whether to enable the watch permission system.
 426
 427                   When this is set to `true`, unprivileged guests can only get watch events
 428                   for xenstore entries that they would've been able to read.
 429
 430                   When this is set to `false`, unprivileged guests may get watch events
 431                   for xenstore entries that they cannot read. The watch event contains
 432                   only the entry name, not the value.
 433                   This restores behaviour prior to [XSA-115](https://xenbits.xenproject.org/xsa/advisory-115.html).
 434                 '';
 435               };
 436             };
 437             quota = {
 438               enable = mkOption {
 439                 default = true;
 440                 example = false;
 441                 type = bool;
 442                 description = "Whether to enable the quota system.";
 443               };
 444               maxEntity = mkOption {
 445                 default = 1000;
 446                 example = 1024;
 447                 type = ints.positive;
 448                 description = "Entity limit for transactions.";
 449               };
 450               maxSize = mkOption {
 451                 default = 2048;
 452                 example = 4096;
 453                 type = ints.positive;
 454                 description = "Size limit for transactions.";
 455               };
 456               maxWatch = mkOption {
 457                 default = 100;
 458                 example = 256;
 459                 type = ints.positive;
 460                 description = "Maximum number of watches by the Xenstore Watchdog.";
 461               };
 462               transaction = mkOption {
 463                 default = 10;
 464                 example = 50;
 465                 type = ints.positive;
 466                 description = "Maximum number of transactions.";
 467               };
 468               maxRequests = mkOption {
 469                 default = 1024;
 470                 example = 1024;
 471                 type = ints.positive;
 472                 description = "Maximum number of requests per transaction.";
 473               };
 474               maxPath = mkOption {
 475                 default = 1024;
 476                 example = 1024;
 477                 type = ints.positive;
 478                 description = "Path limit for the quota system.";
 479               };
 480               maxOutstanding = mkOption {
 481                 default = 1024;
 482                 example = 1024;
 483                 type = ints.positive;
 484                 description = "Maximum outstanding requests, i.e. in-flight requests / domain.";
 485               };
 486               maxWatchEvents = mkOption {
 487                 default = 1024;
 488                 example = 2048;
 489                 type = ints.positive;
 490                 description = "Maximum number of outstanding watch events per watch.";
 491               };
 492             };
 493             persistent = mkOption {
 494               default = false;
 495               example = true;
 496               type = bool;
 497               description = "Whether to activate the filed base backend.";
 498             };
 499             xenstored = {
 500               log = {
 501                 file = mkOption {
 502                   default = "/var/log/xen/xenstored.log";
 503                   example = "/dev/null";
 504                   type = path;
 505                   description = "Path to the Xen Store log file.";
 506                 };
 507                 level = mkOption {
 508                   default = if cfg.trace then "debug" else null;
 509                   defaultText = literalExpression "if (config.virtualisation.xen.trace == true) then \"debug\" else null";
 510                   example = "error";
 511                   type = nullOr (enum [
 512                     "debug"
 513                     "info"
 514                     "warn"
 515                     "error"
 516                   ]);
 517                   description = "Logging level for the Xen Store.";
 518                 };
 519                 # The hidden options below have no upstream documentation whatsoever.
 520                 # The nb* options appear to alter the log rotation behaviour, and
 521                 # the specialOps option appears to affect the Xenbus logging logic.
 522                 nbFiles = mkOption {
 523                   default = 10;
 524                   example = 16;
 525                   type = int;
 526                   visible = false;
 527                   description = "Set `xenstored-log-nb-files`.";
 528                 };
 529               };
 530               accessLog = {
 531                 file = mkOption {
 532                   default = "/var/log/xen/xenstored-access.log";
 533                   example = "/var/log/security/xenstored-access.log";
 534                   type = path;
 535                   description = "Path to the Xen Store access log file.";
 536                 };
 537                 nbLines = mkOption {
 538                   default = 13215;
 539                   example = 16384;
 540                   type = int;
 541                   visible = false;
 542                   description = "Set `access-log-nb-lines`.";
 543                 };
 544                 nbChars = mkOption {
 545                   default = 180;
 546                   example = 256;
 547                   type = int;
 548                   visible = false;
 549                   description = "Set `acesss-log-nb-chars`.";
 550                 };
 551                 specialOps = mkOption {
 552                   default = false;
 553                   example = true;
 554                   type = bool;
 555                   visible = false;
 556                   description = "Set `access-log-special-ops`.";
 557                 };
 558               };
 559               xenfs = {
 560                 kva = mkOption {
 561                   default = "/proc/xen/xsd_kva";
 562                   example = cfg.store.settings.xenstored.xenfs.kva;
 563                   type = path;
 564                   visible = false;
 565                   description = ''
 566                     Path to the Xen Store Daemon KVA location inside the XenFS pseudo-filesystem.
 567                     While it is possible to alter this value, some drivers may be hardcoded to follow the default paths.
 568                   '';
 569                 };
 570                 port = mkOption {
 571                   default = "/proc/xen/xsd_port";
 572                   example = cfg.store.settings.xenstored.xenfs.port;
 573                   type = path;
 574                   visible = false;
 575                   description = ''
 576                     Path to the Xen Store Daemon userspace port inside the XenFS pseudo-filesystem.
 577                     While it is possible to alter this value, some drivers may be hardcoded to follow the default paths.
 578                   '';
 579                 };
 580               };
 581             };
 582             ringScanInterval = mkOption {
 583               default = 20;
 584               example = 30;
 585               type = addCheck (
 586                 int
 587                 // {
 588                   name = "nonzeroInt";
 589                   description = "nonzero signed integer, meaning !=0";
 590                   descriptionClass = "nonRestrictiveClause";
 591                 }
 592               ) (n: n != 0);
 593               description = ''
 594                 Perodic scanning for all the rings as a safenet for lazy clients.
 595                 Define the interval in seconds; set to a negative integer to disable.
 596               '';
 597             };
 598           };
 599         };
 600       };
 601     };
 602   };
 603
 604   ## Implementation ##
 605
 606   config = mkIf cfg.enable {
 607     assertions = [
 608       {
 609         assertion = pkgs.stdenv.hostPlatform.isx86_64;
 610         message = "Xen is currently not supported on ${pkgs.stdenv.hostPlatform.system}.";
 611       }
 612       {
 613         assertion =
 614           config.boot.loader.systemd-boot.enable
 615           || (config.boot ? lanzaboote) && config.boot.lanzaboote.enable;
 616         message = "Xen only supports booting on systemd-boot or Lanzaboote.";
 617       }
 618       {
 619         assertion = config.boot.initrd.systemd.enable;
 620         message = "Xen does not support the legacy script-based Stage 1 initrd.";
 621       }
 622       {
 623         assertion = cfg.dom0Resources.maxMemory >= cfg.dom0Resources.memory;
 624         message = ''
 625           You have allocated more memory to dom0 than virtualisation.xen.dom0Resources.maxMemory
 626           allows for. Please increase the maximum memory limit, or decrease the default memory allocation.
 627         '';
 628       }
 629       {
 630         assertion = cfg.debug -> cfg.trace;
 631         message = "Xen's debugging features are enabled, but logging is disabled. This is most likely not what you want.";
 632       }
 633       {
 634         assertion = cfg.store.settings.quota.maxWatchEvents >= cfg.store.settings.quota.maxOutstanding;
 635         message = ''
 636           Upstream Xen recommends that maxWatchEvents be equal to or greater than maxOutstanding,
 637           in order to mitigate denial of service attacks from malicious frontends.
 638         '';
 639       }
 640     ];
 641
 642     virtualisation.xen.bootParams =
 643       optionals cfg.trace [
 644         "loglvl=all"
 645         "guest_loglvl=all"
 646       ]
 647       ++
 648         optional (cfg.dom0Resources.memory != 0)
 649           "dom0_mem=${toString cfg.dom0Resources.memory}M${
 650             optionalString (
 651               cfg.dom0Resources.memory != cfg.dom0Resources.maxMemory
 652             ) ",max:${toString cfg.dom0Resources.maxMemory}M"
 653           }"
 654       ++ optional (
 655         cfg.dom0Resources.maxVCPUs != 0
 656       ) "dom0_max_vcpus=${toString cfg.dom0Resources.maxVCPUs}";
 657
 658     boot = {
 659       kernelModules = [
 660         "xen-evtchn"
 661         "xen-gntdev"
 662         "xen-gntalloc"
 663         "xen-blkback"
 664         "xen-netback"
 665         "xen-pciback"
 666         "evtchn"
 667         "gntdev"
 668         "netbk"
 669         "blkbk"
 670         "xen-scsibk"
 671         "usbbk"
 672         "pciback"
 673         "xen-acpi-processor"
 674         "blktap2"
 675         "tun"
 676         "netxen_nic"
 677         "xen_wdt"
 678         "xen-acpi-processor"
 679         "xen-privcmd"
 680         "xen-scsiback"
 681         "xenfs"
 682       ];
 683
 684       # The xenfs module is needed to mount /proc/xen.
 685       initrd.kernelModules = [ "xenfs" ];
 686
 687       # Increase the number of loopback devices from the default (8),
 688       # which is way too small because every VM virtual disk requires a
 689       # loopback device.
 690       extraModprobeConfig = ''
 691         options loop max_loop=64
 692       '';
 693
 694       # Xen Bootspec extension. This extension allows NixOS bootloaders to
 695       # fetch the `xen.efi` path and access the `cfg.bootParams` option.
 696       bootspec.extensions = {
 697         "org.xenproject.bootspec.v1" = {
 698           xen = cfg.efi.path;
 699           xenParams = cfg.bootParams;
 700         };
 701       };
 702
 703       # See the `xenBootBuilder` script in the main `let...in` statement of this file.
 704       loader.systemd-boot.extraInstallCommands = ''
 705         ${getExe xenBootBuilder} ${cfg.efi.bootBuilderVerbosity}
 706       '';
 707     };
 708
 709     # Domain 0 requires a pvops-enabled kernel.
 710     # All NixOS kernels come with this enabled by default; this is merely a sanity check.
 711     system.requiredKernelConfig = with config.lib.kernelConfig; [
 712       (isYes "XEN")
 713       (isYes "X86_IO_APIC")
 714       (isYes "ACPI")
 715       (isYes "XEN_DOM0")
 716       (isYes "PCI_XEN")
 717       (isYes "XEN_DEV_EVTCHN")
 718       (isYes "XENFS")
 719       (isYes "XEN_COMPAT_XENFS")
 720       (isYes "XEN_SYS_HYPERVISOR")
 721       (isYes "XEN_GNTDEV")
 722       (isYes "XEN_BACKEND")
 723       (isModule "XEN_NETDEV_BACKEND")
 724       (isModule "XEN_BLKDEV_BACKEND")
 725       (isModule "XEN_PCIDEV_BACKEND")
 726       (isYes "XEN_BALLOON")
 727       (isYes "XEN_SCRUB_PAGES")
 728     ];
 729
 730     environment = {
 731       systemPackages = [
 732         cfg.package
 733         cfg.qemu.package
 734       ];
 735       etc =
 736         # Set up Xen Domain 0 configuration files.
 737         {
 738           "xen/xl.conf".source = "${cfg.package}/etc/xen/xl.conf"; # TODO: Add options to configure xl.conf declaratively. It's worth considering making a new "xl value" type, as it could be reused to produce xl.cfg (domain definition) files.
 739           "xen/scripts-xen" = {
 740             source = "${cfg.package}/etc/xen/scripts/*";
 741             target = "xen/scripts";
 742           };
 743           "default/xencommons".text = ''
 744             source ${cfg.package}/etc/default/xencommons
 745
 746             XENSTORED="${cfg.store.path}"
 747             QEMU_XEN="${cfg.qemu.package}/${cfg.qemu.package.qemu-system-i386}"
 748             ${optionalString cfg.trace ''
 749               XENSTORED_TRACE=yes
 750               XENCONSOLED_TRACE=all
 751             ''}
 752           '';
 753           "default/xendomains".text = ''
 754             source ${cfg.package}/etc/default/xendomains
 755
 756             ${cfg.domains.extraConfig}
 757           '';
 758         }
 759         # The OCaml-based Xen Store Daemon requires /etc/xen/oxenstored.conf to start.
 760         // optionalAttrs (cfg.store.type == "ocaml") {
 761           "xen/oxenstored.conf".text = ''
 762             pid-file = ${cfg.store.settings.pidFile}
 763             test-eagain = ${boolToString cfg.store.settings.testEAGAIN}
 764             merge-activate = ${toString cfg.store.settings.enableMerge}
 765             conflict-burst-limit = ${toString cfg.store.settings.conflict.burstLimit}
 766             conflict-max-history-seconds = ${toString cfg.store.settings.conflict.maxHistorySeconds}
 767             conflict-rate-limit-is-aggregate = ${toString cfg.store.settings.conflict.rateLimitIsAggregate}
 768             perms-activate = ${toString cfg.store.settings.perms.enable}
 769             perms-watch-activate = ${toString cfg.store.settings.perms.enableWatch}
 770             quota-activate = ${toString cfg.store.settings.quota.enable}
 771             quota-maxentity = ${toString cfg.store.settings.quota.maxEntity}
 772             quota-maxsize = ${toString cfg.store.settings.quota.maxSize}
 773             quota-maxwatch = ${toString cfg.store.settings.quota.maxWatch}
 774             quota-transaction = ${toString cfg.store.settings.quota.transaction}
 775             quota-maxrequests = ${toString cfg.store.settings.quota.maxRequests}
 776             quota-path-max = ${toString cfg.store.settings.quota.maxPath}
 777             quota-maxoutstanding = ${toString cfg.store.settings.quota.maxOutstanding}
 778             quota-maxwatchevents = ${toString cfg.store.settings.quota.maxWatchEvents}
 779             persistent = ${boolToString cfg.store.settings.persistent}
 780             xenstored-log-file = ${cfg.store.settings.xenstored.log.file}
 781             xenstored-log-level = ${
 782               if isNull cfg.store.settings.xenstored.log.level then
 783                 "null"
 784               else
 785                 cfg.store.settings.xenstored.log.level
 786             }
 787             xenstored-log-nb-files = ${toString cfg.store.settings.xenstored.log.nbFiles}
 788             access-log-file = ${cfg.store.settings.xenstored.accessLog.file}
 789             access-log-nb-lines = ${toString cfg.store.settings.xenstored.accessLog.nbLines}
 790             acesss-log-nb-chars = ${toString cfg.store.settings.xenstored.accessLog.nbChars}
 791             access-log-special-ops = ${boolToString cfg.store.settings.xenstored.accessLog.specialOps}
 792             ring-scan-interval = ${toString cfg.store.settings.ringScanInterval}
 793             xenstored-kva = ${cfg.store.settings.xenstored.xenfs.kva}
 794             xenstored-port = ${cfg.store.settings.xenstored.xenfs.port}
 795           '';
 796         };
 797     };
 798
 799     # Xen provides udev rules.
 800     services.udev.packages = [ cfg.package ];
 801
 802     systemd = {
 803       # Xen provides systemd units.
 804       packages = [ cfg.package ];
 805
 806       mounts = [
 807         {
 808           description = "Mount /proc/xen files";
 809           what = "xenfs";
 810           where = "/proc/xen";
 811           type = "xenfs";
 812           unitConfig = {
 813             ConditionPathExists = "/proc/xen";
 814             RefuseManualStop = "true";
 815           };
 816         }
 817       ];
 818
 819       services = {
 820
 821         # While this service is installed by the `xen` package, it shouldn't be used in dom0.
 822         xendriverdomain.enable = false;
 823
 824         xenstored = {
 825           wantedBy = [ "multi-user.target" ];
 826           preStart = ''
 827             export XENSTORED_ROOTDIR="/var/lib/xenstored"
 828             rm -f "$XENSTORED_ROOTDIR"/tdb* &>/dev/null
 829             mkdir -p /var/{run,log,lib}/xen
 830           '';
 831         };
 832
 833         xen-init-dom0 = {
 834           restartIfChanged = false;
 835           wantedBy = [ "multi-user.target" ];
 836         };
 837
 838         xen-qemu-dom0-disk-backend = {
 839           wantedBy = [ "multi-user.target" ];
 840           serviceConfig = {
 841             PIDFile = cfg.qemu.pidFile;
 842             ExecStart = ''
 843               ${cfg.qemu.package}/${cfg.qemu.package.qemu-system-i386} \
 844               -xen-domid 0 -xen-attach -name dom0 -nographic -M xenpv \
 845               -daemonize -monitor /dev/null -serial /dev/null -parallel \
 846               /dev/null -nodefaults -no-user-config -pidfile \
 847               ${cfg.qemu.pidFile}
 848             '';
 849           };
 850         };
 851
 852         xenconsoled.wantedBy = [ "multi-user.target" ];
 853
 854         xen-watchdog = {
 855           wantedBy = [ "multi-user.target" ];
 856           serviceConfig = {
 857             RestartSec = "1";
 858             Restart = "on-failure";
 859           };
 860         };
 861
 862         xendomains = {
 863           restartIfChanged = false;
 864           path = [
 865             cfg.package
 866             cfg.qemu.package
 867           ];
 868           preStart = "mkdir -p /var/lock/subsys -m 755";
 869           wantedBy = [ "multi-user.target" ];
 870         };
 871       };
 872     };
 873   };
 874   meta.maintainers = members;
 875 }