commit 2a0754ccbc0e2c4f01803ab1824930c6276a331a · pyrox.dev/nixpkgs

+29 -5

nixos/modules/system/boot/loader/grub/grub.nix

···

       6
       6
        
       

     

       7
       7
        
         cfg = config.boot.loader.grub;

     

       8
       8
        
       

     

       9
       9
       +
         efi = config.boot.loader.efi;

     

       10
       10
       +
       

     

       9
       11
        
         realGrub = if cfg.version == 1 then pkgs.grub

     

       10
       12
        
           else pkgs.grub2.override { zfsSupport = cfg.zfsSupport; };

     

       11
       13
        
       

     
···

       16
       18
        
           then null

     

       17
       19
        
           else realGrub;

     

       18
       20
        
       

     

       21
       21
       +
         grubEfi =

     

       22
       22
       +
           # EFI version of Grub v2

     

       23
       23
       +
           if (cfg.devices != ["nodev"]) && cfg.efiSupport && (cfg.version == 2)

     

       24
       24
       +
           then pkgs.grub2.override { zfsSupport = cfg.zfsSupport; efiSupport = cfg.efiSupport; }

     

       25
       25
       +
           else null;

     

       26
       26
       +
       

     

       19
       27
        
         f = x: if x == null then "" else "" + x;

     

       20
       28
        
       

     

       21
       29
        
         grubConfig = pkgs.writeText "grub-config.xml" (builtins.toXML

     

       22
       30
        
           { splashImage = f config.boot.loader.grub.splashImage;

     

       23
       31
        
             grub = f grub;

     

       32
       32
       +
             grubTarget = f grub.grubTarget;

     

       24
       33
        
             shell = "${pkgs.stdenv.shell}";

     

       25
       34
        
             fullVersion = (builtins.parseDrvName realGrub.name).version;

     

       35
       35
       +
             grubEfi = f grubEfi;

     

       36
       36
       +
             grubTargetEfi = if cfg.efiSupport && (cfg.version == 2) then f grubEfi.grubTarget else "";

     

       37
       37
       +
             inherit (efi) efiSysMountPoint canTouchEfiVariables;

     

       26
       38
        
             inherit (cfg)

     

       27
       39
        
               version extraConfig extraPerEntryConfig extraEntries

     

       28
       40
        
               extraEntriesBeforeNixOS extraPrepareConfig configurationLimit copyKernels timeout

     

       29
       29
       -
               default devices fsIdentifier;

     

       30
       30
       -
             path = (makeSearchPath "bin" [

     

       41
       41
       +
               default devices fsIdentifier efiSupport;

     

       42
       42
       +
             path = (makeSearchPath "bin" ([

     

       31
       43
        
               pkgs.coreutils pkgs.gnused pkgs.gnugrep pkgs.findutils pkgs.diffutils pkgs.btrfsProgs

     

       32
       32
       -
               pkgs.utillinux

     

       33
       33
       -
             ]) + ":" + (makeSearchPath "sbin" [

     

       44
       44
       +
               pkgs.utillinux ] ++ (if cfg.efiSupport && (cfg.version == 2) then [pkgs.efibootmgr ] else [])

     

       45
       45
       +
             )) + ":" + (makeSearchPath "sbin" [

     

       34
       46
        
               pkgs.mdadm pkgs.utillinux

     

       35
       47
        
             ]);

     

       36
       48
        
           });

     
···

       231
       243
        
               type = types.bool;

     

       232
       244
        
               description = ''

     

       233
       245
        
                 Whether grub should be build against libzfs.

     

       246
       246
       +
                 ZFS support is only available for GRUB v2.

     

       247
       247
       +
                 This option is ignored for GRUB v1.

     

       248
       248
       +
               '';

     

       249
       249
       +
             };

     

       250
       250
       +
       

     

       251
       251
       +
             efiSupport = mkOption {

     

       252
       252
       +
               default = false;

     

       253
       253
       +
               type = types.bool;

     

       254
       254
       +
               description = ''

     

       255
       255
       +
                 Whether grub should be build with EFI support.

     

       256
       256
       +
                 EFI support is only available for GRUB v2.

     

       257
       257
       +
                 This option is ignored for GRUB v1.

     

       234
       258
        
               '';

     

       235
       259
        
             };

     

       236
       260
        
       

     
···

       269
       293
        
               if cfg.devices == [] then

     

       270
       294
        
                 throw "You must set the option ‘boot.loader.grub.device’ to make the system bootable."

     

       271
       295
        
               else

     

       272
       272
       -
                 "PERL5LIB=${makePerlPath (with pkgs.perlPackages; [ FileSlurp XMLLibXML XMLSAX ])} " +

     

       296
       296
       +
                 "PERL5LIB=${makePerlPath (with pkgs.perlPackages; [ FileSlurp XMLLibXML XMLSAX ListCompare ])} " +

     

       273
       297
        
                 (if cfg.enableCryptodisk then "GRUB_ENABLE_CRYPTODISK=y " else "") +

     

       274
       298
        
                 "${pkgs.perl}/bin/perl ${./install-grub.pl} ${grubConfig}";

     

       275
       299

+113 -7

nixos/modules/system/boot/loader/grub/install-grub.pl

···

       7
       7
        
       use File::stat;

     

       8
       8
        
       use File::Copy;

     

       9
       9
        
       use File::Slurp;

     

       10
       10
       +
       require List::Compare;

     

       10
       11
        
       use POSIX;

     

       11
       12
        
       use Cwd;

     

       12
       13
        
       

     
···

       39
       40
        
       

     

       40
       41
        
       my $grub = get("grub");

     

       41
       42
        
       my $grubVersion = int(get("version"));

     

       43
       43
       +
       my $grubTarget = get("grubTarget");

     

       42
       44
        
       my $extraConfig = get("extraConfig");

     

       43
       45
        
       my $extraPrepareConfig = get("extraPrepareConfig");

     

       44
       46
        
       my $extraPerEntryConfig = get("extraPerEntryConfig");

     
···

       50
       52
        
       my $timeout = int(get("timeout"));

     

       51
       53
        
       my $defaultEntry = int(get("default"));

     

       52
       54
        
       my $fsIdentifier = get("fsIdentifier");

     

       55
       55
       +
       my $grubEfi = get("grubEfi");

     

       56
       56
       +
       my $grubTargetEfi = get("grubTargetEfi");

     

       57
       57
       +
       my $canTouchEfiVariables = get("canTouchEfiVariables");

     

       58
       58
       +
       my $efiSysMountPoint = get("efiSysMountPoint");

     

       53
       59
        
       $ENV{'PATH'} = get("path");

     

       54
       60
        
       

     

       55
       61
        
       die "unsupported GRUB version\n" if $grubVersion != 1 && $grubVersion != 2;

     
···

       103
       109
        
       

     

       104
       110
        
               # Skip the read-only bind-mount on /nix/store.

     

       105
       111
        
               next if $mountPoint eq "/nix/store" && (grep { $_ eq "rw" } @superOptions) && (grep { $_ eq "ro" } @mountOptions);

     

       112
       112
       +
               # Skip mount point generated by systemd-efi-boot-generator?

     

       113
       113
       +
               next if $fsType eq "autofs";

     

       106
       114
        
       

     

       107
       115
        
               # Ensure this matches the intended directory

     

       108
       116
        
               next unless PathInMount($dir, $mountPoint);

     
···

       402
       410
        
       }

     

       403
       411
        
       

     

       404
       412
        
       

     

       405
       405
       -
       # Install GRUB if the version changed from the last time we installed

     

       406
       406
       -
       # it.  FIXME: shouldn't we reinstall if ‘devices’ changed?

     

       407
       407
       -
       my $prevVersion = readFile("/boot/grub/version") // "";

     

       408
       408
       -
       if (($ENV{'NIXOS_INSTALL_GRUB'} // "") eq "1" || get("fullVersion") ne $prevVersion) {

     

       413
       413
       +
       #

     

       414
       414
       +
       # Install GRUB if the parameters changed from the last time we installed it.

     

       415
       415
       +
       #

     

       416
       416
       +
       

     

       417
       417
       +
       struct(GrubState => {

     

       418
       418
       +
           version => '$',

     

       419
       419
       +
           efi => '$',

     

       420
       420
       +
           devices => '$',

     

       421
       421
       +
           efiMountPoint => '$',

     

       422
       422
       +
       });

     

       423
       423
       +
       sub readGrubState {

     

       424
       424
       +
           my $defaultGrubState = GrubState->new(version => "", efi => "", devices => "", efiMountPoint => "" );

     

       425
       425
       +
           open FILE, "</boot/grub/state" or return $defaultGrubState;

     

       426
       426
       +
           local $/ = "\n";

     

       427
       427
       +
           my $version = <FILE>;

     

       428
       428
       +
           chomp($version);

     

       429
       429
       +
           my $efi = <FILE>;

     

       430
       430
       +
           chomp($efi);

     

       431
       431
       +
           my $devices = <FILE>;

     

       432
       432
       +
           chomp($devices);

     

       433
       433
       +
           my $efiMountPoint = <FILE>;

     

       434
       434
       +
           chomp($efiMountPoint);

     

       435
       435
       +
           close FILE;

     

       436
       436
       +
           my $grubState = GrubState->new(version => $version, efi => $efi, devices => $devices, efiMountPoint => $efiMountPoint );

     

       437
       437
       +
           return $grubState

     

       438
       438
       +
       }

     

       439
       439
       +
       

     

       440
       440
       +
       sub getDeviceTargets {

     

       441
       441
       +
           my @devices = ();

     

       409
       442
        
           foreach my $dev ($dom->findnodes('/expr/attrs/attr[@name = "devices"]/list/string/@value')) {

     

       410
       443
        
               $dev = $dev->findvalue(".") or die;

     

       444
       444
       +
               push(@devices, $dev);

     

       445
       445
       +
           }

     

       446
       446
       +
           return @devices;

     

       447
       447
       +
       }

     

       448
       448
       +
       

     

       449
       449
       +
       # check whether to install GRUB EFI or not

     

       450
       450
       +
       sub getEfiTarget {

     

       451
       451
       +
           if (($grub ne "") && ($grubEfi ne "")) {

     

       452
       452
       +
               # EFI can only be installed when target is set;

     

       453
       453
       +
               # A target is also required then for non-EFI grub

     

       454
       454
       +
               if (($grubTarget eq "") || ($grubTargetEfi eq "")) { die }

     

       455
       455
       +
               else { return "both" }

     

       456
       456
       +
           } elsif (($grub ne "") && ($grubEfi eq "")) {

     

       457
       457
       +
               # TODO: It would be safer to disallow non-EFI grub installation if no taget is given.

     

       458
       458
       +
               #       If no target is given, then grub auto-detects the target which can lead to errors.

     

       459
       459
       +
               #       E.g. it seems as if grub would auto-detect a EFI target based on the availability

     

       460
       460
       +
               #       of a EFI partition.

     

       461
       461
       +
               #       However, it seems as auto-detection is currently relied on for non-x86_64 and non-i386

     

       462
       462
       +
               #       architectures in NixOS. That would have to be fixed in the nixos modules first.

     

       463
       463
       +
               return "no"

     

       464
       464
       +
           } elsif (($grub eq "") && ($grubEfi ne "")) {

     

       465
       465
       +
               # EFI can only be installed when target is set;

     

       466
       466
       +
               if ($grubTargetEfi eq "") { die }

     

       467
       467
       +
               else {return "only" }

     

       468
       468
       +
           } else {

     

       469
       469
       +
               # at least one grub target has to be given

     

       470
       470
       +
               die

     

       471
       471
       +
           }

     

       472
       472
       +
       }

     

       473
       473
       +
       

     

       474
       474
       +
       my @deviceTargets = getDeviceTargets();

     

       475
       475
       +
       my $efiTarget = getEfiTarget();

     

       476
       476
       +
       my $prevGrubState = readGrubState();

     

       477
       477
       +
       my @prevDeviceTargets = split/:/, $prevGrubState->devices;

     

       478
       478
       +
       

     

       479
       479
       +
       my $devicesDiffer = scalar (List::Compare->new( '-u', '-a', \@deviceTargets, \@prevDeviceTargets)->get_symmetric_difference() );

     

       480
       480
       +
       my $versionDiffer = (get("fullVersion") eq \$prevGrubState->version);

     

       481
       481
       +
       my $efiDiffer = ($efiTarget eq \$prevGrubState->efi);

     

       482
       482
       +
       my $efiMountPointDiffer = ($efiSysMountPoint eq \$prevGrubState->efiMountPoint);

     

       483
       483
       +
       my $requireNewInstall = $devicesDiffer || $versionDiffer || $efiDiffer || $efiMountPointDiffer || (($ENV{'NIXOS_INSTALL_GRUB'} // "") eq "1");

     

       484
       484
       +
       

     

       485
       485
       +
       

     

       486
       486
       +
       # install non-EFI GRUB

     

       487
       487
       +
       if (($requireNewInstall != 0) && ($efiTarget eq "no" || $efiTarget eq "both")) {

     

       488
       488
       +
           foreach my $dev (@deviceTargets) {

     

       411
       489
        
               next if $dev eq "nodev";

     

       412
       490
        
               print STDERR "installing the GRUB $grubVersion boot loader on $dev...\n";

     

       413
       413
       -
               system("$grub/sbin/grub-install", "--recheck", Cwd::abs_path($dev)) == 0

     

       414
       414
       -
                   or die "$0: installation of GRUB on $dev failed\n";

     

       491
       491
       +
               if ($grubTarget eq "") {

     

       492
       492
       +
                   system("$grub/sbin/grub-install", "--recheck", Cwd::abs_path($dev)) == 0

     

       493
       493
       +
                       or die "$0: installation of GRUB on $dev failed\n";

     

       494
       494
       +
               } else {

     

       495
       495
       +
                   system("$grub/sbin/grub-install", "--recheck", "--target=$grubTarget", Cwd::abs_path($dev)) == 0

     

       496
       496
       +
                       or die "$0: installation of GRUB on $dev failed\n";

     

       497
       497
       +
               }

     

       415
       498
        
           }

     

       416
       416
       -
           writeFile("/boot/grub/version", get("fullVersion"));

     

       499
       499
       +
       }

     

       500
       500
       +
       

     

       501
       501
       +
       

     

       502
       502
       +
       # install EFI GRUB

     

       503
       503
       +
       if (($requireNewInstall != 0) && ($efiTarget eq "only" || $efiTarget eq "both")) {

     

       504
       504
       +
           print STDERR "installing the GRUB $grubVersion EFI boot loader into $efiSysMountPoint...\n";

     

       505
       505
       +
           if ($canTouchEfiVariables eq "true") {

     

       506
       506
       +
               system("$grubEfi/sbin/grub-install", "--recheck", "--target=$grubTargetEfi", "--efi-directory=$efiSysMountPoint") == 0

     

       507
       507
       +
                       or die "$0: installation of GRUB EFI into $efiSysMountPoint failed\n";

     

       508
       508
       +
           } else {

     

       509
       509
       +
               system("$grubEfi/sbin/grub-install", "--recheck", "--target=$grubTargetEfi", "--efi-directory=$efiSysMountPoint", "--no-nvram") == 0

     

       510
       510
       +
                       or die "$0: installation of GRUB EFI into $efiSysMountPoint failed\n";

     

       511
       511
       +
           }

     

       512
       512
       +
       }

     

       513
       513
       +
       

     

       514
       514
       +
       

     

       515
       515
       +
       # update GRUB state file

     

       516
       516
       +
       if ($requireNewInstall != 0) {

     

       517
       517
       +
           open FILE, ">/boot/grub/state" or die "cannot create /boot/grub/state: $!\n";

     

       518
       518
       +
           print FILE get("fullVersion"), "\n" or die;

     

       519
       519
       +
           print FILE $efiTarget, "\n" or die;

     

       520
       520
       +
           print FILE join( ":", @deviceTargets ), "\n" or die;

     

       521
       521
       +
           print FILE $efiSysMountPoint, "\n" or die;

     

       522
       522
       +
           close FILE or die;

     

       417
       523
        
       }

+13

pkgs/tools/misc/grub/2.0x.nix

···

       7
       7
        
       

     

       8
       8
        
       with stdenv.lib;

     

       9
       9
        
       let

     

       10
       10
       +
         pcSystems = {

     

       11
       11
       +
           "i686-linux".target = "i386";

     

       12
       12
       +
           "x86_64-linux".target = "i386";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       10
       15
        
         efiSystems = {

     

       11
       16
        
           "i686-linux".target = "i386";

     

       12
       17
        
           "x86_64-linux".target = "x86_64";

     

       13
       18
        
         };

     

       14
       19
        
       

     

       15
       20
        
         canEfi = any (system: stdenv.system == system) (mapAttrsToList (name: _: name) efiSystems);

     

       21
       21
       +
         inPCSystems = any (system: stdenv.system == system) (mapAttrsToList (name: _: name) pcSystems);

     

       16
       22
        
       

     

       17
       23
        
         version = "2.02-git-1de3a4";

     

       18
       24
        
       

     
···

       79
       85
        
       

     

       80
       86
        
         configureFlags = optional zfsSupport "--enable-libzfs"

     

       81
       87
        
           ++ optionals efiSupport [ "--with-platform=efi" "--target=${efiSystems.${stdenv.system}.target}" "--program-prefix=" ];

     

       88
       88
       +
       

     

       89
       89
       +
         # save target that grub is compiled for

     

       90
       90
       +
         grubTarget = if efiSupport

     

       91
       91
       +
                      then "${efiSystems.${stdenv.system}.target}-efi"

     

       92
       92
       +
                      else if inPCSystems

     

       93
       93
       +
                           then "${pcSystems.${stdenv.system}.target}-pc"

     

       94
       94
       +
                           else "";

     

       82
       95
        
       

     

       83
       96
        
         doCheck = false;

     

       84
       97
        
         enableParallelBuilding = true;

pkgs/top-level/perl-packages.nix

···

       227
       227
        
           };

     

       228
       228
        
         };

     

       229
       229
        
       

     

       230
       230
       +
         ListCompare = buildPerlPackage {

     

       231
       231
       +
           name = "List-Compare-1.18";

     

       232
       232
       +
           src = fetchurl {

     

       233
       233
       +
             url = mirror://cpan/authors/id/J/JK/JKEENAN/List-Compare-0.39.tar.gz;

     

       234
       234
       +
             sha256 = "1v4gn176faanzf1kr9axdp1220da7nkvz0d66mnk34nd0skjjxcl";

     

       235
       235
       +
           };

     

       236
       236
       +
         };

     

       237
       237
       +
       

     

       230
       238
        
         ArchiveCpio = buildPerlPackage {

     

       231
       239
        
           name = "Archive-Cpio-0.09";

     

       232
       240
        
           src = fetchurl {