commit 94205f5f21c4d9942bb4205c06229438051b6853 · pyrox.dev/nixpkgs

-21

nixos/modules/installer/tools/nixos-generate-config.pl

···

       20
       20
        
           return @res;

     

       21
       21
        
       }

     

       22
       22
        
       

     

       23
       23
       -
       sub runCommand {

     

       24
       24
       -
           my ($cmd) = @_;

     

       25
       25
       -
           open FILE, "$cmd 2>/dev/null |" or die "Failed to execute: $cmd\n";

     

       26
       26
       -
           my @ret = <FILE>;

     

       27
       27
       -
           close FILE;

     

       28
       28
       -
           return ($?, @ret);

     

       29
       29
       -
       }

     

       30
       23
        
       

     

       31
       24
        
       # Process the command line.

     

       32
       25
        
       my $outDir = "/etc/nixos";

     
···

       341
       334
        
                   chomp $backer;

     

       342
       335
        
                   $device = $backer;

     

       343
       336
        
                   push @extraOptions, "loop";

     

       344
       344
       -
               }

     

       345
       345
       -
           }

     

       346
       346
       -
       

     

       347
       347
       -
           # Is this a btrfs filesystem?

     

       348
       348
       -
           if ($fsType eq "btrfs") {

     

       349
       349
       -
               my ($status, @info) = runCommand("btrfs subvol show $rootDir$mountPoint");

     

       350
       350
       -
               if ($status != 0) {

     

       351
       351
       -
                   die "Failed to retreive subvolume info for $mountPoint";

     

       352
       352
       -
               }

     

       353
       353
       -
               my @subvols = join("", @info) =~ m/Name:[ \t\n]*([^ \t\n]*)/;

     

       354
       354
       -
               if ($#subvols > 0) {

     

       355
       355
       -
                   die "Btrfs subvol name for $mountPoint listed multiple times in mount\n"

     

       356
       356
       -
               } elsif ($#subvols == 0) {

     

       357
       357
       -
                   push @extraOptions, "subvol=$subvols[0]";

     

       358
       337
        
               }

     

       359
       338
        
           }

     

       360
       339

-1

nixos/modules/installer/tools/tools.nix

···

       38
       38
        
         nixos-generate-config = makeProg {

     

       39
       39
        
           name = "nixos-generate-config";

     

       40
       40
        
           src = ./nixos-generate-config.pl;

     

       41
       41
       -
           path = [ pkgs.btrfsProgs ];

     

       42
       41
        
           perl = "${pkgs.perl}/bin/perl -I${pkgs.perlPackages.FileSlurp}/lib/perl5/site_perl";

     

       43
       42
        
         };

     

       44
       43

-3

nixos/modules/installer/virtualbox-demo.nix

···

       10
       10
        
             ../profiles/clone-config.nix

     

       11
       11
        
           ];

     

       12
       12
        
       

     

       13
       13
       -
         # FIXME: UUID detection is currently broken

     

       14
       14
       -
         boot.loader.grub.fsIdentifier = "provided";

     

       15
       15
       -
       

     

       16
       13
        
         # Allow mounting of shared folders.

     

       17
       14
        
         users.extraUsers.demo.extraGroups = [ "vboxsf" ];

     

       18
       15

+9 -28

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

···

       6
       6
        
       

     

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

     

       8
       8
        
       

     

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

     

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

     

       9
       9
       +
         realGrub = if cfg.version == 1 then pkgs.grub else pkgs.grub2;

     

       11
       10
        
       

     

       12
       11
        
         grub =

     

       13
       12
        
           # Don't include GRUB if we're only generating a GRUB menu (e.g.,

     
···

       26
       25
        
             inherit (cfg)

     

       27
       26
        
               version extraConfig extraPerEntryConfig extraEntries

     

       28
       27
        
               extraEntriesBeforeNixOS extraPrepareConfig configurationLimit copyKernels timeout

     

       29
       29
       -
               default devices fsIdentifier;

     

       28
       28
       +
               default devices explicitBootRoot;

     

       30
       29
        
             path = (makeSearchPath "bin" [

     

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

     

       32
       32
       -
               pkgs.utillinux

     

       30
       30
       +
               pkgs.coreutils pkgs.gnused pkgs.gnugrep pkgs.findutils pkgs.diffutils

     

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

     

       34
       34
       -
               pkgs.mdadm pkgs.utillinux

     

       32
       32
       +
               pkgs.mdadm

     

       35
       33
        
             ]);

     

       36
       34
        
           });

     

       37
       35
        
       

     
···

       211
       209
        
               '';

     

       212
       210
        
             };

     

       213
       211
        
       

     

       214
       214
       -
             fsIdentifier = mkOption {

     

       215
       215
       -
               default = "uuid";

     

       216
       216
       -
               type = types.addCheck types.str

     

       217
       217
       -
                 (type: type == "uuid" || type == "label" || type == "provided");

     

       218
       218
       -
               description = ''

     

       219
       219
       -
                 Determines how grub will identify devices when generating the

     

       220
       220
       -
                 configuration file. A value of uuid / label signifies that grub

     

       221
       221
       -
                 will always resolve the uuid or label of the device before using

     

       222
       222
       -
                 it in the configuration. A value of provided means that grub will

     

       223
       223
       -
                 use the device name as show in <command>df</command> or

     

       224
       224
       -
                 <command>mount</command>. Note, zfs zpools / datasets are ignored

     

       225
       225
       -
                 and will always be mounted using their labels.

     

       226
       226
       -
               '';

     

       227
       227
       -
             };

     

       228
       228
       -
       

     

       229
       229
       -
             zfsSupport = mkOption {

     

       230
       230
       -
               default = false;

     

       231
       231
       -
               type = types.bool;

     

       212
       212
       +
             explicitBootRoot = mkOption {

     

       213
       213
       +
               default = "";

     

       214
       214
       +
               type = types.str;

     

       232
       215
        
               description = ''

     

       233
       233
       -
                 Whether grub should be build against libzfs.

     

       216
       216
       +
                 The relative path of /boot within the parent volume. Leave empty

     

       217
       217
       +
                 if /boot is not a btrfs subvolume.

     

       234
       218
        
               '';

     

       235
       219
        
             };

     

       236
       220
        
       

     
···

       275
       259
        
               concatStrings (mapAttrsToList (n: v: ''

     

       276
       260
        
                 ${pkgs.coreutils}/bin/cp -pf "${v}" "/boot/${n}"

     

       277
       261
        
               '') config.boot.loader.grub.extraFiles);

     

       278
       278
       -
       

     

       279
       279
       -
           assertions = [{ assertion = !cfg.zfsSupport || cfg.version == 2;

     

       280
       280
       -
                           message = "Only grub version 2 provides zfs support";}];

     

       281
       262
        
       

     

       282
       263
        
           })

     

       283
       264

+21 -115

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

···

       1
       1
        
       use strict;

     

       2
       2
        
       use warnings;

     

       3
       3
       -
       use Class::Struct;

     

       4
       3
        
       use XML::LibXML;

     

       5
       4
        
       use File::Basename;

     

       6
       5
        
       use File::Path;

     
···

       26
       25
        
           open FILE, ">$fn" or die "cannot create $fn: $!\n";

     

       27
       26
        
           print FILE $s or die;

     

       28
       27
        
           close FILE or die;

     

       29
       29
       -
       }

     

       30
       30
       -
       

     

       31
       31
       -
       sub runCommand {

     

       32
       32
       -
           my ($cmd) = @_;

     

       33
       33
       -
           open FILE, "$cmd 2>/dev/null |" or die "Failed to execute: $cmd\n";

     

       34
       34
       -
           my @ret = <FILE>;

     

       35
       35
       -
           close FILE;

     

       36
       36
       -
           return ($?, @ret);

     

       37
       28
        
       }

     

       38
       29
        
       

     

       39
       30
        
       my $grub = get("grub");

     
···

       48
       39
        
       my $copyKernels = get("copyKernels") eq "true";

     

       49
       40
        
       my $timeout = int(get("timeout"));

     

       50
       41
        
       my $defaultEntry = int(get("default"));

     

       51
       51
       -
       my $fsIdentifier = get("fsIdentifier");

     

       42
       42
       +
       my $explicitBootRoot = get("explicitBootRoot");

     

       52
       43
        
       $ENV{'PATH'} = get("path");

     

       53
       44
        
       

     

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

     
···

       57
       48
        
       

     

       58
       49
        
       mkpath("/boot/grub", 0, 0700);

     

       59
       50
        
       

     

       51
       51
       +
       

     

       60
       52
        
       # Discover whether /boot is on the same filesystem as / and

     

       61
       53
        
       # /nix/store.  If not, then all kernels and initrds must be copied to

     

       62
       62
       -
       # /boot.

     

       63
       63
       -
       if (stat("/boot")->dev != stat("/nix/store")->dev) {

     

       54
       54
       +
       # /boot, and all paths in the GRUB config file must be relative to the

     

       55
       55
       +
       # root of the /boot filesystem.  `$bootRoot' is the path to be

     

       56
       56
       +
       # prepended to paths under /boot.

     

       57
       57
       +
       my $bootRoot = "/boot";

     

       58
       58
       +
       if (stat("/")->dev != stat("/boot")->dev) {

     

       59
       59
       +
           $bootRoot = "";

     

       64
       60
        
           $copyKernels = 1;

     

       65
       65
       -
       }

     

       66
       66
       -
       

     

       67
       67
       -
       # Discover information about the location of /boot

     

       68
       68
       -
       struct(Fs => {

     

       69
       69
       -
           device => '$',

     

       70
       70
       -
           type => '$',

     

       71
       71
       -
           mount => '$',

     

       72
       72
       -
       });

     

       73
       73
       -
       sub GetFs {

     

       74
       74
       -
           my ($dir) = @_;

     

       75
       75
       -
           my ($status, @dfOut) = runCommand("df -T $dir");

     

       76
       76
       -
           if ($status != 0 || $#dfOut != 1) {

     

       77
       77
       -
               die "Failed to retrieve output about $dir from `df`";

     

       78
       78
       -
           }

     

       79
       79
       -
           my @boot = split(/[ \n\t]+/, $dfOut[1]);

     

       80
       80
       -
           return Fs->new(device => $boot[0], type => $boot[1], mount => $boot[6]);

     

       81
       81
       -
       }

     

       82
       82
       -
       struct (Grub => {

     

       83
       83
       -
           path => '$',

     

       84
       84
       -
           search => '$',

     

       85
       85
       -
       });

     

       86
       86
       -
       my $driveid = 1;

     

       87
       87
       -
       sub GrubFs {

     

       88
       88
       -
           my ($dir) = @_;

     

       89
       89
       -
           my $fs = GetFs($dir);

     

       90
       90
       -
           my $path = "/" . substr($dir, length($fs->mount));

     

       91
       91
       -
           my $search = "";

     

       92
       92
       -
       

     

       93
       93
       -
           if ($grubVersion > 1) {

     

       94
       94
       -
               # ZFS is completely separate logic as zpools are always identified by a label

     

       95
       95
       -
               # or custom UUID

     

       96
       96
       -
               if ($fs->type eq 'zfs') {

     

       97
       97
       -
                   my $sid = index($fs->device, '/');

     

       98
       98
       -
       

     

       99
       99
       -
                   if ($sid < 0) {

     

       100
       100
       -
                       $search = '--label ' . $fs->device;

     

       101
       101
       -
                       $path = '/@' . $path;

     

       102
       102
       -
                   } else {

     

       103
       103
       -
                       $search = '--label ' . substr($fs->device, 0, $sid);

     

       104
       104
       -
                       $path = '/' . substr($fs->device, $sid) . '/@' . $path;

     

       105
       105
       -
                   }

     

       106
       106
       -
               } else {

     

       107
       107
       -
                   my %types = ('uuid' => '--fs-uuid', 'label' => '--label');

     

       108
       108
       -
       

     

       109
       109
       -
                   if ($fsIdentifier eq 'provided') {

     

       110
       110
       -
                       # If the provided dev is identifying the partition using a label or uuid,

     

       111
       111
       -
                       # we should get the label / uuid and do a proper search

     

       112
       112
       -
                       my @matches = $fs->device =~ m/\/dev\/disk\/by-(label|uuid)\/(.*)/;

     

       113
       113
       -
                       if ($#matches > 1) {

     

       114
       114
       -
                           die "Too many matched devices"

     

       115
       115
       -
                       } elsif ($#matches == 1) {

     

       116
       116
       -
                           $search = "$types{$matches[0]} $matches[1]"

     

       117
       117
       -
                       }

     

       118
       118
       -
                   } else {

     

       119
       119
       -
                       # Determine the identifying type

     

       120
       120
       -
                       $search = $types{$fsIdentifier} . ' ';

     

       121
       121
       -
       

     

       122
       122
       -
                       # Based on the type pull in the identifier from the system

     

       123
       123
       -
                       my ($status, @devInfo) = runCommand("blkid -o export @{[$fs->device]}");

     

       124
       124
       -
                       if ($status != 0) {

     

       125
       125
       -
                           die "Failed to get blkid info for @{[$fs->device]}";

     

       126
       126
       -
                       }

     

       127
       127
       -
                       my @matches = join("", @devInfo) =~ m/@{[uc $fsIdentifier]}=([^\n]*)/;

     

       128
       128
       -
                       if ($#matches != 0) {

     

       129
       129
       -
                           die "Couldn't find a $types{$fsIdentifier} for @{[$fs->device]}\n"

     

       130
       130
       -
                       }

     

       131
       131
       -
                       $search .= $matches[0];

     

       132
       132
       -
                   }

     

       133
       133
       -
       

     

       134
       134
       -
                   # BTRFS is a special case in that we need to fix the referrenced path based on subvolumes

     

       135
       135
       -
                   if ($fs->type eq 'btrfs') {

     

       136
       136
       -
                       my ($status, @info) = runCommand("btrfs subvol show @{[$fs->mount]}");

     

       137
       137
       -
                       if ($status != 0) {

     

       138
       138
       -
                           die "Failed to retreive subvolume info for @{[$fs->mount]}";

     

       139
       139
       -
                       }

     

       140
       140
       -
                       my @subvols = join("", @info) =~ m/Name:[ \t\n]*([^ \t\n]*)/;

     

       141
       141
       -
                       if ($#subvols > 0) {

     

       142
       142
       -
                           die "Btrfs subvol name for @{[$fs->device]} listed multiple times in mount\n"

     

       143
       143
       -
                       } elsif ($#subvols == 0) {

     

       144
       144
       -
                           $path = "/$subvols[0]$path";

     

       145
       145
       -
                       }

     

       146
       146
       -
                   }

     

       147
       147
       -
               }

     

       148
       148
       -
               if (not $search eq "") {

     

       149
       149
       -
                   $search = "search --set=drive$driveid " . $search;

     

       150
       150
       -
                   $path = "(\$drive$driveid)$path";

     

       151
       151
       -
                   $driveid += 1;

     

       152
       152
       -
               }

     

       153
       153
       -
           }

     

       154
       154
       -
           return Grub->new(path => $path, search => $search);

     

       61
       61
       +
       } elsif (stat("/boot")->dev != stat("/nix/store")->dev) {

     

       62
       62
       +
           $copyKernels = 1;

     

       155
       63
        
       }

     

       156
       156
       -
       my $grubBoot = GrubFs("/boot");

     

       157
       157
       -
       my $grubStore = GrubFs("/nix");

     

       158
       64
        
       

     

       159
       159
       -
       # We don't need to copy if we can read the kernels directly

     

       160
       160
       -
       if ($grubStore->search ne "") {

     

       161
       161
       -
           $copyKernels = 0;

     

       65
       65
       +
       if ($explicitBootRoot ne "") {

     

       66
       66
       +
           $bootRoot = $explicitBootRoot;

     

       162
       67
        
       }

     

       163
       68
        
       

     

       164
       69
        
       # Generate the header.

     
···

       171
       76
        
           ";

     

       172
       77
        
           if ($splashImage) {

     

       173
       78
        
               copy $splashImage, "/boot/background.xpm.gz" or die "cannot copy $splashImage to /boot\n";

     

       174
       174
       -
               $conf .= "splashimage " . $grubBoot->path . "/background.xpm.gz\n";

     

       79
       79
       +
               $conf .= "splashimage $bootRoot/background.xpm.gz\n";

     

       175
       80
        
           }

     

       176
       81
        
       }

     

       177
       82
        
       

     

       178
       83
        
       else {

     

       179
       84
        
           $conf .= "

     

       180
       180
       -
               " . $grubBoot->search . "

     

       181
       181
       -
               " . $grubStore->search . "

     

       182
       85
        
               if [ -s \$prefix/grubenv ]; then

     

       183
       86
        
                 load_env

     

       184
       87
        
               fi

     
···

       199
       102
        
                 set timeout=$timeout

     

       200
       103
        
               fi

     

       201
       104
        
       

     

       202
       202
       -
               if loadfont " . $grubBoot->path . "/grub/fonts/unicode.pf2; then

     

       105
       105
       +
               if loadfont $bootRoot/grub/fonts/unicode.pf2; then

     

       203
       106
        
                 set gfxmode=640x480

     

       204
       107
        
                 insmod gfxterm

     

       205
       108
        
                 insmod vbe

     
···

       213
       116
        
               copy $splashImage, "/boot/background.png" or die "cannot copy $splashImage to /boot\n";

     

       214
       117
        
               $conf .= "

     

       215
       118
        
                   insmod png

     

       216
       216
       -
                   if background_image " . $grubBoot->path . "/background.png; then

     

       119
       119
       +
                   if background_image $bootRoot/background.png; then

     

       217
       120
        
                     set color_normal=white/black

     

       218
       121
        
                     set color_highlight=black/white

     

       219
       122
        
                   else

     
···

       235
       138
        
       

     

       236
       139
        
       sub copyToKernelsDir {

     

       237
       140
        
           my ($path) = @_;

     

       238
       238
       -
           return $grubStore->path . substr($path, length("/nix")) unless $copyKernels;

     

       141
       141
       +
           return $path unless $copyKernels;

     

       239
       142
        
           $path =~ /\/nix\/store\/(.*)/ or die;

     

       240
       143
        
           my $name = $1; $name =~ s/\//-/g;

     

       241
       144
        
           my $dst = "/boot/kernels/$name";

     
···

       248
       151
        
               rename $tmp, $dst or die "cannot rename $tmp to $dst\n";

     

       249
       152
        
           }

     

       250
       153
        
           $copied{$dst} = 1;

     

       251
       251
       -
           return $grubBoot->path . "/kernels/$name";

     

       154
       154
       +
           return "$bootRoot/kernels/$name";

     

       252
       155
        
       }

     

       253
       156
        
       

     

       254
       157
        
       sub addEntry {

     
···

       275
       178
        
               $conf .= "  " . ($xen ? "module" : "initrd") . " $initrd\n\n";

     

       276
       179
        
           } else {

     

       277
       180
        
               $conf .= "menuentry \"$name\" {\n";

     

       181
       181
       +
       <<<<<<< HEAD

     

       278
       182
        
               $conf .= $grubBoot->search . "\n";

     

       279
       183
        
               $conf .= $grubStore->search . "\n";

     

       184
       184
       +
       =======

     

       185
       185
       +
       >>>>>>> parent of 469f22d... Merge pull request #2449 from wkennington/master.grub

     

       280
       186
        
               $conf .= "  $extraPerEntryConfig\n" if $extraPerEntryConfig;

     

       281
       187
        
               $conf .= "  multiboot $xen $xenParams\n" if $xen;

     

       282
       188
        
               $conf .= "  " . ($xen ? "module" : "linux") . " $kernel $kernelParams\n";

     
···

       294
       200
        
       $conf .= "$extraEntries\n" unless $extraEntriesBeforeNixOS;

     

       295
       201
        
       

     

       296
       202
        
       # extraEntries could refer to @bootRoot@, which we have to substitute

     

       297
       297
       -
       $conf =~ s/\@bootRoot\@/$grubBoot->path/g;

     

       203
       203
       +
       $conf =~ s/\@bootRoot\@/$bootRoot/g;

     

       298
       204
        
       

     

       299
       205
        
       # Emit submenus for all system profiles.

     

       300
       206
        
       sub addProfile {

+1 -5

nixos/modules/tasks/filesystems/zfs.nix

···

       133
       133
        
             };

     

       134
       134
        
       

     

       135
       135
        
             boot.initrd = mkIf inInitrd {

     

       136
       136
       -
               kernelModules = [ "spl" "zfs" ];

     

       136
       136
       +
               kernelModules = [ "spl" "zfs" ] ;

     

       137
       137
        
               extraUtilsCommands =

     

       138
       138
        
                 ''

     

       139
       139
        
                   cp -v ${zfsPkg}/sbin/zfs $out/bin

     
···

       146
       146
        
                 ''

     

       147
       147
        
                   zpool import -f -a

     

       148
       148
        
                 '';

     

       149
       149
       -
             };

     

       150
       150
       -
       

     

       151
       151
       -
             boot.loader.grub = mkIf inInitrd {

     

       152
       152
       -
               zfsSupport = true;

     

       153
       149
        
             };

     

       154
       150
        
       

     

       155
       151
        
             systemd.services."zpool-import" = {

-4

nixos/release-combined.nix

···

       52
       52
        
               (all nixos.tests.installer.lvm)

     

       53
       53
        
               (all nixos.tests.installer.separateBoot)

     

       54
       54
        
               (all nixos.tests.installer.simple)

     

       55
       55
       -
               (all nixos.tests.installer.simpleLabels)

     

       56
       56
       -
               (all nixos.tests.installer.simpleProvided)

     

       57
       57
       -
               (all nixos.tests.installer.btrfsSimple)

     

       58
       58
       -
               (all nixos.tests.installer.btrfsSubvols)

     

       59
       55
        
               (all nixos.tests.ipv6)

     

       60
       56
        
               (all nixos.tests.kde4)

     

       61
       57
        
               (all nixos.tests.login)

+1 -1

nixos/release.nix

···

       231
       231
        
         tests.installer.simpleLabels = forAllSystems (system: (import tests/installer.nix { inherit system; }).simpleLabels.test);

     

       232
       232
        
         tests.installer.simpleProvided = forAllSystems (system: (import tests/installer.nix { inherit system; }).simpleProvided.test);

     

       233
       233
        
         tests.installer.btrfsSimple = forAllSystems (system: (import tests/installer.nix { inherit system; }).btrfsSimple.test);

     

       234
       234
       -
         tests.installer.btrfsSubvols = forAllSystems (system: (import tests/installer.nix { inherit system; }).btrfsSubvols.test);

     

       234
       234
       +
         #tests.installer.btrfsSubvols = forAllSystems (system: (import tests/installer.nix { inherit system; }).btrfsSubvols.test);

     

       235
       235
        
         tests.influxdb = callTest tests/influxdb.nix {};

     

       236
       236
        
         tests.ipv6 = callTest tests/ipv6.nix {};

     

       237
       237
        
         tests.jenkins = callTest tests/jenkins.nix {};

+6 -7

nixos/tests/installer.nix

···

       35
       35
        
       

     

       36
       36
        
       

     

       37
       37
        
         # The configuration to install.

     

       38
       38
       -
         makeConfig = { testChannel, useEFI, grubVersion, grubDevice, grubIdentifier }:

     

       39
       39
       -
           pkgs.writeText "configuration.nix" ''

     

       38
       38
       +
         makeConfig = { testChannel, useEFI, grubVersion, grubDevice }: pkgs.writeText "configuration.nix"

     

       39
       39
       +
           ''

     

       40
       40
        
             { config, pkgs, modulesPath, ... }:

     

       41
       41
        
       

     

       42
       42
        
             { imports =

     
···

       54
       54
        
                 ''}

     

       55
       55
        
                 boot.loader.grub.device = "${grubDevice}";

     

       56
       56
        
                 boot.loader.grub.extraConfig = "serial; terminal_output.serial";

     

       57
       57
       -
                 boot.loader.grub.fsIdentifier = "${grubIdentifier}";

     

       58
       57
        
               ''}

     

       59
       58
        
       

     

       60
       59
        
               environment.systemPackages = [ ${optionalString testChannel "pkgs.rlwrap"} ];

     
···

       94
       93
        
         # disk, and then reboot from the hard disk.  It's parameterized with

     

       95
       94
        
         # a test script fragment `createPartitions', which must create

     

       96
       95
        
         # partitions and filesystems.

     

       97
       97
       -
         testScriptFun = { createPartitions, testChannel, useEFI, grubVersion, grubDevice, grubIdentifier }:

     

       96
       96
       +
         testScriptFun = { createPartitions, testChannel, useEFI, grubVersion, grubDevice }:

     

       98
       97
        
           let

     

       99
       98
        
             # FIXME: OVMF doesn't boot from virtio http://www.mail-archive.com/edk2-devel@lists.sourceforge.net/msg01501.html

     

       100
       99
        
             iface = if useEFI || grubVersion == 1 then "scsi" else "virtio";

     
···

       162
       161
        
             $machine->succeed("cat /mnt/etc/nixos/hardware-configuration.nix >&2");

     

       163
       162
        
       

     

       164
       163
        
             $machine->copyFileFromHost(

     

       165
       165
       -
                 "${ makeConfig { inherit testChannel useEFI grubVersion grubDevice grubIdentifier; } }",

     

       164
       164
       +
                 "${ makeConfig { inherit testChannel useEFI grubVersion grubDevice; } }",

     

       166
       165
        
                 "/mnt/etc/nixos/configuration.nix");

     

       167
       166
        
       

     

       168
       167
        
             # Perform the installation.

     
···

       217
       216
        
       

     

       218
       217
        
       

     

       219
       218
        
         makeInstallerTest = name:

     

       220
       220
       -
           { createPartitions, testChannel ? false, useEFI ? false, grubVersion ? 2, grubDevice ? "/dev/vda", grubIdentifier ? "uuid" }:

     

       219
       219
       +
           { createPartitions, testChannel ? false, useEFI ? false, grubVersion ? 2, grubDevice ? "/dev/vda" }:

     

       221
       220
        
           makeTest {

     

       222
       221
        
             inherit iso;

     

       223
       222
        
             name = "installer-" + name;

     

       224
       223
        
             nodes = if testChannel then { inherit webserver; } else { };

     

       225
       224
        
             testScript = testScriptFun {

     

       226
       226
       -
               inherit createPartitions testChannel useEFI grubVersion grubDevice grubIdentifier;

     

       225
       225
       +
               inherit createPartitions testChannel useEFI grubVersion grubDevice;

     

       227
       226
        
             };

     

       228
       227
        
           };

     

       229
       228

+28 -32

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

···

       1
       1
       -
       { stdenv, fetchurl, autogen, flex, bison, python, autoconf, automake

     

       2
       2
       -
       , gettext, ncurses, libusb, freetype, qemu, devicemapper

     

       3
       3
       -
       , linuxPackages ? null

     

       4
       4
       -
       , efiSupport ? false

     

       5
       5
       -
       , zfsSupport ? false

     

       6
       6
       -
       }:

     

       1
       1
       +
       { fetchurl, stdenv, flex, bison, gettext, ncurses, libusb, freetype, qemu

     

       2
       2
       +
       , devicemapper, EFIsupport ? false }:

     

       7
       3
        
       

     

       8
       8
       -
       with stdenv.lib;

     

       9
       4
        
       let

     

       10
       10
       -
         efiSystems = {

     

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

     

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

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

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

     

       16
       5
        
       

     

       17
       17
       -
         prefix = "grub${if efiSupport then "-efi" else ""}";

     

       6
       6
       +
         prefix = "grub${if EFIsupport then "-efi" else ""}";

     

       18
       7
        
       

     

       19
       19
       -
         version = "2.02-beta2";

     

       8
       8
       +
         version = "2.00";

     

       20
       9
        
       

     

       21
       10
        
         unifont_bdf = fetchurl {

     

       22
       11
        
           url = "http://unifoundry.com/unifont-5.1.20080820.bdf.gz";

     

       23
       12
        
           sha256 = "0s0qfff6n6282q28nwwblp5x295zd6n71kl43xj40vgvdqxv0fxx";

     

       24
       13
        
         };

     

       25
       25
       -
       in (

     

       26
       14
        
       

     

       27
       27
       -
       assert efiSupport -> canEfi;

     

       28
       28
       -
       assert zfsSupport -> linuxPackages != null && linuxPackages.zfs != null;

     

       15
       15
       +
       in

     

       29
       16
        
       

     

       30
       17
        
       stdenv.mkDerivation rec {

     

       31
       18
        
         name = "${prefix}-${version}";

     

       32
       19
        
       

     

       33
       20
        
         src = fetchurl {

     

       34
       34
       -
           name = "grub-2.02-beta2.tar.xz";

     

       35
       35
       -
           url = "http://alpha.gnu.org/gnu/grub/grub-2.02~beta2.tar.xz";

     

       36
       36
       -
           sha256 = "13a13fhc0wf473dn73zhga15mjvkg6vqp4h25dxg4n7am2r05izn";

     

       21
       21
       +
           url = "mirror://gnu/grub/grub-${version}.tar.xz";

     

       22
       22
       +
           sha256 = "0n64hpmsccvicagvr0c6v0kgp2yw0kgnd3jvsyd26cnwgs7c6kkq";

     

       37
       23
        
         };

     

       38
       24
        
       

     

       39
       39
       -
         nativeBuildInputs = [ autogen flex bison python autoconf automake ];

     

       25
       25
       +
         nativeBuildInputs = [ flex bison ];

     

       40
       26
        
         buildInputs = [ ncurses libusb freetype gettext devicemapper ]

     

       41
       41
       -
           ++ optional doCheck qemu

     

       42
       42
       -
           ++ optional zfsSupport linuxPackages.zfs;

     

       27
       27
       +
           ++ stdenv.lib.optional doCheck qemu;

     

       43
       28
        
       

     

       44
       29
        
         preConfigure =

     

       45
       30
        
           '' for i in "tests/util/"*.in

     
···

       58
       43
        
              # See <http://www.mail-archive.com/qemu-devel@nongnu.org/msg22775.html>.

     

       59
       44
        
              sed -i "tests/util/grub-shell.in" \

     

       60
       45
        
                  -e's/qemu-system-i386/qemu-system-x86_64 -nodefaults/g'

     

       46
       46
       +
       

     

       47
       47
       +
              # Fix for building on Glibc 2.16.  Won't be needed once the

     

       48
       48
       +
              # gnulib in grub is updated.

     

       49
       49
       +
              sed -i '/gets is a security hole/d' grub-core/gnulib/stdio.in.h

     

       61
       50
        
           '';

     

       62
       51
        
       

     

       63
       52
        
         prePatch =

     

       64
       64
       -
           '' sh autogen.sh

     

       65
       65
       -
              gunzip < "${unifont_bdf}" > "unifont.bdf"

     

       53
       53
       +
           '' gunzip < "${unifont_bdf}" > "unifont.bdf"

     

       66
       54
        
              sed -i "configure" \

     

       67
       55
        
                  -e "s|/usr/src/unifont.bdf|$PWD/unifont.bdf|g"

     

       68
       56
        
           '';

     

       69
       57
        
       

     

       70
       58
        
         patches = [ ./fix-bash-completion.patch ];

     

       71
       59
        
       

     

       72
       72
       -
         configureFlags = optional zfsSupport "--enable-libzfs"

     

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

     

       60
       60
       +
         configureFlags =

     

       61
       61
       +
           let arch = if stdenv.system == "i686-linux" then "i386"

     

       62
       62
       +
                      else if stdenv.system == "x86_64-linux" then "x86_64"

     

       63
       63
       +
                      else throw "unsupported EFI firmware architecture";

     

       64
       64
       +
           in

     

       65
       65
       +
             stdenv.lib.optionals EFIsupport

     

       66
       66
       +
               [ "--with-platform=efi" "--target=${arch}" "--program-prefix=" ];

     

       74
       67
        
       

     

       75
       68
        
         doCheck = false;

     

       76
       69
        
         enableParallelBuilding = true;

     
···

       79
       72
        
           paxmark pms $out/sbin/grub-{probe,bios-setup}

     

       80
       73
        
         '';

     

       81
       74
        
       

     

       82
       82
       -
         meta = with stdenv.lib; {

     

       75
       75
       +
         meta = {

     

       83
       76
        
           description = "GNU GRUB, the Grand Unified Boot Loader (2.x beta)";

     

       84
       77
        
       

     

       85
       78
        
           longDescription =

     
···

       96
       89
        
       

     

       97
       90
        
           homepage = http://www.gnu.org/software/grub/;

     

       98
       91
        
       

     

       99
       99
       -
           license = licenses.gpl3Plus;

     

       92
       92
       +
           license = stdenv.lib.licenses.gpl3Plus;

     

       100
       93
        
       

     

       101
       101
       -
           platforms = platforms.gnu;

     

       94
       94
       +
           platforms = if EFIsupport then

     

       95
       95
       +
             [ "i686-linux" "x86_64-linux" ]

     

       96
       96
       +
           else

     

       97
       97
       +
             stdenv.lib.platforms.gnu;

     

       102
       98
        
         };

     

       103
       103
       -
       })

     

       99
       99
       +
       }

+2 -4

pkgs/top-level/all-packages.nix

···

       1226
       1226
        
           buggyBiosCDSupport = config.grub.buggyBiosCDSupport or true;

     

       1227
       1227
        
         };

     

       1228
       1228
        
       

     

       1229
       1229
       -
         grub2 = callPackage ../tools/misc/grub/2.0x.nix { };

     

       1230
       1230
       -
       

     

       1231
       1231
       -
         grub2_efi = grub2.override { efiSupport = true; };

     

       1229
       1229
       +
         grub2 = callPackage ../tools/misc/grub/2.0x.nix { libusb = libusb1; flex = flex_2_5_35; };

     

       1232
       1230
        
       

     

       1233
       1233
       -
         grub2_zfs = grub2.override { zfsSupport = true; };

     

       1231
       1231
       +
         grub2_efi = grub2.override { EFIsupport = true; };

     

       1234
       1232
        
       

     

       1235
       1233
        
         gssdp = callPackage ../development/libraries/gssdp {

     

       1236
       1234
        
           inherit (gnome) libsoup;