commit 8d092270d28d82aa5623bcde55a2ee85129ac1f1 · pyrox.dev/nixpkgs

+10 -3

nixos/lib/make-iso9660-image.nix

···

       1
       1
       -
       { stdenv, perl, cdrkit, pathsFromGraph

     

       1
       1
       +
       { stdenv, perl, pathsFromGraph, xorriso, syslinux

     

       2
       2
        
       

     

       3
       3
        
       , # The file name of the resulting ISO image.

     

       4
       4
        
         isoName ? "cd.iso"

     
···

       22
       22
        
       , # Whether this should be an efi-bootable El-Torito CD.

     

       23
       23
        
         efiBootable ? false

     

       24
       24
        
       

     

       25
       25
       +
       , # Wheter this should be an hybrid CD (bootable from USB as well as CD).

     

       26
       26
       +
         usbBootable ? false

     

       27
       27
       +
       

     

       25
       28
        
       , # The path (in the ISO file system) of the boot image.

     

       26
       29
        
         bootImage ? ""

     

       27
       30
        
       

     

       28
       31
        
       , # The path (in the ISO file system) of the efi boot image.

     

       29
       32
        
         efiBootImage ? ""

     

       30
       33
        
       

     

       34
       34
       +
       , # The path (outside the ISO file system) of the isohybrid-mbr image.

     

       35
       35
       +
         isohybridMbrImage ? ""

     

       36
       36
       +
       

     

       31
       37
        
       , # Whether to compress the resulting ISO image with bzip2.

     

       32
       38
        
         compressImage ? false

     

       33
       39
        
       

     
···

       38
       44
        
       

     

       39
       45
        
       assert bootable -> bootImage != "";

     

       40
       46
        
       assert efiBootable -> efiBootImage != "";

     

       47
       47
       +
       assert usbBootable -> isohybridMbrImage != "";

     

       41
       48
        
       

     

       42
       49
        
       stdenv.mkDerivation {

     

       43
       50
        
         name = "iso9660-image";

     

       44
       51
        
         builder = ./make-iso9660-image.sh;

     

       45
       45
       -
         buildInputs = [perl cdrkit];

     

       52
       52
       +
         buildInputs = [perl xorriso syslinux];

     

       46
       53
        
       

     

       47
       47
       -
         inherit isoName bootable bootImage compressImage volumeID pathsFromGraph efiBootImage efiBootable;

     

       54
       54
       +
         inherit isoName bootable bootImage compressImage volumeID pathsFromGraph efiBootImage efiBootable isohybridMbrImage usbBootable;

     

       48
       55
        
       

     

       49
       56
        
         # !!! should use XML.

     

       50
       57
        
         sources = map (x: x.source) contents;

+40 -8

nixos/lib/make-iso9660-image.sh

···

       31
       31
        
               fi

     

       32
       32
        
           done

     

       33
       33
        
       

     

       34
       34
       -
           bootFlags="-b $bootImage -c .boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table"

     

       34
       34
       +
           isoBootFlags="-eltorito-boot ${bootImage}

     

       35
       35
       +
                         -eltorito-catalog .boot.cat

     

       36
       36
       +
                         -no-emul-boot -boot-load-size 4 -boot-info-table"

     

       37
       37
       +
       fi

     

       38
       38
       +
       

     

       39
       39
       +
       if test -n "$usbBootable"; then

     

       40
       40
       +
           usbBootFlags="-isohybrid-mbr ${isohybridMbrImage}"

     

       35
       41
        
       fi

     

       36
       42
        
       

     

       37
       43
        
       if test -n "$efiBootable"; then

     

       38
       38
       -
           bootFlags="$bootFlags -eltorito-alt-boot -e $efiBootImage -no-emul-boot"

     

       44
       44
       +
           efiBootFlags="-eltorito-alt-boot

     

       45
       45
       +
                         -e $efiBootImage

     

       46
       46
       +
                         -no-emul-boot

     

       47
       47
       +
                         -isohybrid-gpt-basdat"

     

       39
       48
        
       fi

     

       40
       49
        
       

     

       41
       50
        
       touch pathlist

     
···

       74
       83
        
           fi

     

       75
       84
        
       done

     

       76
       85
        
       

     

       77
       77
       -
       # !!! what does this do?

     

       86
       86
       +
       # Escape filenames that contain '='.

     

       87
       87
       +
       # TODO: Handle this properly. This fails for filenames

     

       88
       88
       +
       #       that contain multiple '=' symbols.

     

       78
       89
        
       cat pathlist | sed -e 's/=\(.*\)=\(.*\)=/\\=\1=\2\\=/' | tee pathlist.safer

     

       79
       90
        
       

     

       80
       91
        
       

     

       81
       92
        
       mkdir -p $out/iso

     

       82
       82
       -
       genCommand="genisoimage -iso-level 4 -r -J $bootFlags -hide-rr-moved -graft-points -path-list pathlist.safer ${volumeID:+-V $volumeID}"

     

       83
       83
       -
       if test -z "$compressImage"; then

     

       84
       84
       -
           $genCommand -o $out/iso/$isoName

     

       85
       85
       -
       else

     

       86
       86
       -
           $genCommand | bzip2 > $out/iso/$isoName.bz2

     

       93
       93
       +
       

     

       94
       94
       +
       xorriso="xorriso

     

       95
       95
       +
        -as mkisofs

     

       96
       96
       +
        -iso-level 3

     

       97
       97
       +
        -volid ${volumeID}

     

       98
       98
       +
        -appid nixos

     

       99
       99
       +
        -publisher nixos

     

       100
       100
       +
        -graft-points

     

       101
       101
       +
        -full-iso9660-filenames

     

       102
       102
       +
        ${isoBootFlags}

     

       103
       103
       +
        ${usbBootFlags}

     

       104
       104
       +
        ${efiBootFlags}

     

       105
       105
       +
        -r

     

       106
       106
       +
        -path-list pathlist.safer

     

       107
       107
       +
        --sort-weight 0 /

     

       108
       108
       +
        --sort-weight 1 /isolinux" # Make sure isolinux is near the beginning of the ISO

     

       109
       109
       +
       

     

       110
       110
       +
       $xorriso -output $out/iso/$isoName

     

       111
       111
       +
       

     

       112
       112
       +
       if test -n "$usbBootable"; then

     

       113
       113
       +
           echo "Making image hybrid..."

     

       114
       114
       +
           isohybrid --uefi $out/iso/$isoName

     

       87
       115
        
       fi

     

       88
       116
        
       

     

       117
       117
       +
       if test -n "$compressImage"; then

     

       118
       118
       +
           echo "Compressing image..."

     

       119
       119
       +
           bzip2 $out/iso/$isoName

     

       120
       120
       +
       fi

     

       89
       121
        
       

     

       90
       122
        
       mkdir -p $out/nix-support

     

       91
       123
        
       echo $system > $out/nix-support/system

nixos/modules/installer/cd-dvd/installation-cd-base.nix

···

       36
       36
        
         # EFI booting

     

       37
       37
        
         isoImage.makeEfiBootable = true;

     

       38
       38
        
       

     

       39
       39
       +
         # USB booting

     

       40
       40
       +
         isoImage.makeUsbBootable = true;

     

       41
       41
       +
       

     

       39
       42
        
         # Add Memtest86+ to the CD.

     

       40
       43
        
         boot.loader.grub.memtest86.enable = true;

     

       41
       44

+59 -65

nixos/modules/installer/cd-dvd/iso-image.nix

···

       8
       8
        
       

     

       9
       9
        
       let

     

       10
       10
        
       

     

       11
       11
       -
         # The Grub image.

     

       12
       12
       -
         grubImage = pkgs.runCommand "grub_eltorito" {}

     

       11
       11
       +
         # The configuration file for syslinux.

     

       12
       12
       +
         baseIsolinuxCfg =

     

       13
       13
        
           ''

     

       14
       14
       -
             ${pkgs.grub2}/bin/grub-mkimage -p /boot/grub -O i386-pc -o tmp biosdisk iso9660 help linux linux16 chain png jpeg echo gfxmenu reboot

     

       15
       15
       -
             cat ${pkgs.grub2}/lib/grub/*/cdboot.img tmp > $out

     

       16
       16
       -
           ''; # */

     

       17
       17
       -
       

     

       18
       18
       -
       

     

       19
       19
       -
         # The configuration file for Grub.

     

       20
       20
       -
         grubCfg =

     

       21
       21
       -
           ''

     

       22
       22
       -
             set default=${builtins.toString config.boot.loader.grub.default}

     

       23
       23
       -
             set timeout=${builtins.toString config.boot.loader.grub.timeout}

     

       14
       14
       +
           SERIAL 0 38400

     

       15
       15
       +
           UI vesamenu.c32

     

       16
       16
       +
           MENU TITLE NixOS

     

       17
       17
       +
           MENU BACKGROUND /isolinux/background.png

     

       24
       18
        
       

     

       25
       25
       -
             if loadfont /boot/grub/unicode.pf2; then

     

       26
       26
       -
               set gfxmode=640x480

     

       27
       27
       -
               insmod gfxterm

     

       28
       28
       -
               insmod vbe

     

       29
       29
       -
               terminal_output gfxterm

     

       19
       19
       +
           LABEL boot

     

       20
       20
       +
           MENU LABEL Boot NixOS

     

       21
       21
       +
           LINUX /boot/bzImage init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}

     

       22
       22
       +
           INITRD /boot/initrd

     

       30
       23
        
       

     

       31
       31
       -
               insmod png

     

       32
       32
       -
               if background_image /boot/grub/splash.png; then

     

       33
       33
       -
                 set color_normal=white/black

     

       34
       34
       -
                 set color_highlight=black/white

     

       35
       35
       -
               else

     

       36
       36
       -
                 set menu_color_normal=cyan/blue

     

       37
       37
       -
                 set menu_color_highlight=white/blue

     

       38
       38
       -
               fi

     

       24
       24
       +
           LABEL chain

     

       25
       25
       +
           MENU LABEL Boot existing OS

     

       26
       26
       +
           COM32 chain.c32

     

       27
       27
       +
           APPEND hd0 0

     

       39
       28
        
       

     

       40
       40
       -
             fi

     

       29
       29
       +
           LABEL reboot

     

       30
       30
       +
           MENU LABEL Reboot

     

       31
       31
       +
           COM32 reboot.c32

     

       41
       32
        
       

     

       42
       42
       -
             ${config.boot.loader.grub.extraEntries}

     

       33
       33
       +
           LABEL poweroff

     

       34
       34
       +
           MENU LABEL Power Off

     

       35
       35
       +
           COM32 poweroff.c32

     

       43
       36
        
           '';

     

       44
       37
        
       

     

       38
       38
       +
         isolinuxCfg = baseIsolinuxCfg + (optionalString config.boot.loader.grub.memtest86.enable isolinuxMemtest86Entry);

     

       45
       39
        
       

     

       46
       40
        
         # The efi boot image

     

       47
       41
        
         efiDir = pkgs.runCommand "efi-directory" {} ''

     

       48
       48
       -
           mkdir -p $out/efi/boot

     

       49
       49
       -
           cp -v ${pkgs.gummiboot}/lib/gummiboot/gummiboot${targetArch}.efi $out/efi/boot/boot${targetArch}.efi

     

       42
       42
       +
           mkdir -p $out/EFI/boot

     

       43
       43
       +
           cp -v ${pkgs.gummiboot}/lib/gummiboot/gummiboot${targetArch}.efi $out/EFI/boot/boot${targetArch}.efi

     

       50
       44
        
           mkdir -p $out/loader/entries

     

       51
       45
        
           echo "title NixOS LiveCD" > $out/loader/entries/nixos-livecd.conf

     

       52
       46
        
           echo "linux /boot/bzImage" >> $out/loader/entries/nixos-livecd.conf

     
···

       152
       146
        
             '';

     

       153
       147
        
           };

     

       154
       148
        
       

     

       149
       149
       +
           isoImage.makeUsbBootable = mkOption {

     

       150
       150
       +
             default = false;

     

       151
       151
       +
             description = ''

     

       152
       152
       +
               Whether the ISO image should be bootable from CD as well as USB.

     

       153
       153
       +
             '';

     

       154
       154
       +
           };

     

       155
       155
       +
       

     

       156
       156
       +
           isoImage.splashImage = mkOption {

     

       157
       157
       +
             default = pkgs.fetchurl {

     

       158
       158
       +
                 url = https://raw.githubusercontent.com/NixOS/nixos-artwork/5729ab16c6a5793c10a2913b5a1b3f59b91c36ee/ideas/grub-splash/grub-nixos-1.png;

     

       159
       159
       +
                 sha256 = "43fd8ad5decf6c23c87e9026170a13588c2eba249d9013cb9f888da5e2002217";

     

       160
       160
       +
               };

     

       161
       161
       +
             description = ''

     

       162
       162
       +
               The splash image to use in the bootloader.

     

       163
       163
       +
             '';

     

       164
       164
       +
           };

     

       155
       165
        
       

     

       156
       166
        
         };

     

       157
       167
        
       

     
···

       166
       176
        
       

     

       167
       177
        
           # !!! Hack - attributes expected by other modules.

     

       168
       178
        
           system.boot.loader.kernelFile = "bzImage";

     

       169
       169
       -
           environment.systemPackages = [ pkgs.grub2 ];

     

       179
       179
       +
           environment.systemPackages = [ pkgs.grub2 pkgs.syslinux ];

     

       170
       180
        
       

     

       171
       181
        
           # In stage 1 of the boot, mount the CD as the root FS by label so

     

       172
       182
        
           # that we don't need to know its device.  We pass the label of the

     
···

       216
       226
        
               options = "allow_other,cow,nonempty,chroot=/mnt-root,max_files=32768,hide_meta_files,dirs=/nix/.rw-store=rw:/nix/.ro-store=ro";

     

       217
       227
        
             };

     

       218
       228
        
       

     

       219
       219
       -
           boot.initrd.availableKernelModules = [ "squashfs" "iso9660" ];

     

       229
       229
       +
           boot.initrd.availableKernelModules = [ "squashfs" "iso9660" "usb-storage" ];

     

       220
       230
        
       

     

       221
       231
        
           boot.initrd.kernelModules = [ "loop" ];

     

       222
       232
        
       

     
···

       236
       246
        
           # Individual files to be included on the CD, outside of the Nix

     

       237
       247
        
           # store on the CD.

     

       238
       248
        
           isoImage.contents =

     

       239
       239
       -
             [ { source = grubImage;

     

       240
       240
       -
                 target = "/boot/grub/grub_eltorito";

     

       241
       241
       -
               }

     

       242
       242
       -
               { source = pkgs.substituteAll  {

     

       243
       243
       -
                   name = "grub.cfg";

     

       244
       244
       -
                   src = pkgs.writeText "grub.cfg-in" grubCfg;

     

       249
       249
       +
             [ { source = pkgs.substituteAll  {

     

       250
       250
       +
                   name = "isolinux.cfg";

     

       251
       251
       +
                   src = pkgs.writeText "isolinux.cfg-in" isolinuxCfg;

     

       245
       252
        
                   bootRoot = "/boot";

     

       246
       253
        
                 };

     

       247
       247
       -
                 target = "/boot/grub/grub.cfg";

     

       254
       254
       +
                 target = "/isolinux/isolinux.cfg";

     

       248
       255
        
               }

     

       249
       256
        
               { source = config.boot.kernelPackages.kernel + "/bzImage";

     

       250
       257
        
                 target = "/boot/bzImage";

     
···

       252
       259
        
               { source = config.system.build.initialRamdisk + "/initrd";

     

       253
       260
        
                 target = "/boot/initrd";

     

       254
       261
        
               }

     

       255
       255
       -
               { source = "${pkgs.grub2}/share/grub/unicode.pf2";

     

       256
       256
       -
                 target = "/boot/grub/unicode.pf2";

     

       257
       257
       -
               }

     

       258
       258
       -
               { source = config.boot.loader.grub.splashImage;

     

       259
       259
       -
                 target = "/boot/grub/splash.png";

     

       260
       260
       -
               }

     

       261
       262
        
               { source = config.system.build.squashfsStore;

     

       262
       263
        
                 target = "/nix-store.squashfs";

     

       263
       264
        
               }

     

       265
       265
       +
               { source = "${pkgs.syslinux}/share/syslinux";

     

       266
       266
       +
                 target = "/isolinux";

     

       267
       267
       +
               }

     

       268
       268
       +
               { source = config.isoImage.splashImage;

     

       269
       269
       +
                 target = "/isolinux/background.png";

     

       270
       270
       +
               }

     

       264
       271
        
             ] ++ optionals config.isoImage.makeEfiBootable [

     

       265
       272
        
               { source = efiImg;

     

       266
       273
        
                 target = "/boot/efi.img";

     

       267
       274
        
               }

     

       268
       268
       -
               { source = "${efiDir}/efi";

     

       269
       269
       -
                 target = "/efi";

     

       275
       275
       +
               { source = "${efiDir}/EFI";

     

       276
       276
       +
                 target = "/EFI";

     

       270
       277
        
               }

     

       271
       278
        
               { source = "${efiDir}/loader";

     

       272
       279
        
                 target = "/loader";

     

       273
       280
        
               }

     

       274
       274
       -
             ] ++ mapAttrsToList (n: v: { source = v; target = "/boot/${n}"; }) config.boot.loader.grub.extraFiles;

     

       275
       275
       -
       

     

       276
       276
       -
           # The Grub menu.

     

       277
       277
       -
           boot.loader.grub.extraEntries =

     

       278
       278
       -
             ''

     

       279
       279
       -
               menuentry "NixOS ${config.system.nixosVersion} Installer" {

     

       280
       280
       -
                 linux /boot/bzImage init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}

     

       281
       281
       -
                 initrd /boot/initrd

     

       282
       282
       -
               }

     

       283
       283
       -
       

     

       284
       284
       -
               menuentry "Boot from hard disk" {

     

       285
       285
       -
                 set root=(hd0)

     

       286
       286
       -
                 chainloader +1

     

       287
       287
       -
               }

     

       288
       288
       -
             '';

     

       289
       289
       -
       

     

       290
       290
       -
           boot.loader.grub.timeout = 10;

     

       281
       281
       +
             ];

     

       291
       282
        
       

     

       292
       283
        
           # Create the ISO image.

     

       293
       284
        
           system.build.isoImage = import ../../../lib/make-iso9660-image.nix ({

     

       294
       294
       -
             inherit (pkgs) stdenv perl cdrkit pathsFromGraph;

     

       285
       285
       +
             inherit (pkgs) stdenv perl pathsFromGraph xorriso syslinux;

     

       295
       286
        
       

     

       296
       287
        
             inherit (config.isoImage) isoName compressImage volumeID contents;

     

       297
       288
        
       

     

       298
       289
        
             bootable = true;

     

       299
       299
       -
             bootImage = "/boot/grub/grub_eltorito";

     

       290
       290
       +
             bootImage = "/isolinux/isolinux.bin";

     

       291
       291
       +
           } // optionalAttrs config.isoImage.makeUsbBootable {

     

       292
       292
       +
             usbBootable = true;

     

       293
       293
       +
             isohybridMbrImage = "${pkgs.syslinux}/share/syslinux/isohdpfx.bin";

     

       300
       294
        
           } // optionalAttrs config.isoImage.makeEfiBootable {

     

       301
       295
        
             efiBootable = true;

     

       302
       296
        
             efiBootImage = "boot/efi.img";