commit a8ab8b59a75a4bf0675fb3785e76c54873044f9e · pyrox.dev/nixpkgs

+10 -1

nixos/modules/system/boot/loader/systemd-boot/systemd-boot-builder.py

···

       43
        
           system: str

     

       44
        
           toplevel: str

     

       45
        
           specialisations: Dict[str, "BootSpec"]

     

       0
        
       
     

       46
        
           initrdSecrets: str | None = None

     

       47
        
       

     

       48
        
       

     
···

       73
        
               return d

     

       74
        
       

     

       75
        
       BOOT_ENTRY = """title {title}

     

       0
        
       
     

       76
        
       version Generation {generation} {description}

     

       77
        
       linux {kernel}

     

       78
        
       initrd {initrd}

     
···

       123
        
       def bootspec_from_json(bootspec_json: Dict) -> BootSpec:

     

       124
        
           specialisations = bootspec_json['org.nixos.specialisation.v1']

     

       125
        
           specialisations = {k: bootspec_from_json(v) for k, v in specialisations.items()}

     

       126
       -
           return BootSpec(**bootspec_json['org.nixos.bootspec.v1'], specialisations=specialisations)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       127
        
       

     

       128
        
       

     

       129
        
       def copy_from_file(file: str, dry_run: bool = False) -> str:

     
···

       170
        
       

     

       171
        
           with open(tmp_path, 'w') as f:

     

       172
        
               f.write(BOOT_ENTRY.format(title=title,

     

       0
        
       
     

       173
        
                           generation=generation,

     

       174
        
                           kernel=kernel,

     

       175
        
                           initrd=initrd,

···

       43
        
           system: str

     

       44
        
           toplevel: str

     

       45
        
           specialisations: Dict[str, "BootSpec"]

     

       46
       +
           sortKey: str

     

       47
        
           initrdSecrets: str | None = None

     

       48
        
       

     

       49
        
       

     
···

       74
        
               return d

     

       75
        
       

     

       76
        
       BOOT_ENTRY = """title {title}

     

       77
       +
       sort-key {sort_key}

     

       78
        
       version Generation {generation} {description}

     

       79
        
       linux {kernel}

     

       80
        
       initrd {initrd}

     
···

       125
        
       def bootspec_from_json(bootspec_json: Dict) -> BootSpec:

     

       126
        
           specialisations = bootspec_json['org.nixos.specialisation.v1']

     

       127
        
           specialisations = {k: bootspec_from_json(v) for k, v in specialisations.items()}

     

       128
       +
           systemdBootExtension = bootspec_json.get('org.nixos.systemd-boot', {})

     

       129
       +
           sortKey = systemdBootExtension.get('sortKey', 'nixos')

     

       130
       +
           return BootSpec(

     

       131
       +
               **bootspec_json['org.nixos.bootspec.v1'],

     

       132
       +
               specialisations=specialisations,

     

       133
       +
               sortKey=sortKey

     

       134
       +
           )

     

       135
        
       

     

       136
        
       

     

       137
        
       def copy_from_file(file: str, dry_run: bool = False) -> str:

     
···

       178
        
       

     

       179
        
           with open(tmp_path, 'w') as f:

     

       180
        
               f.write(BOOT_ENTRY.format(title=title,

     

       181
       +
                           sort_key=bootspec.sortKey,

     

       182
        
                           generation=generation,

     

       183
        
                           kernel=kernel,

     

       184
        
                           initrd=initrd,

+62 -11

nixos/modules/system/boot/loader/systemd-boot/systemd-boot.nix

···

       87
        
       

     

       88
        
         imports =

     

       89
        
           [ (mkRenamedOptionModule [ "boot" "loader" "gummiboot" "enable" ] [ "boot" "loader" "systemd-boot" "enable" ])

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       90
        
           ];

     

       91
        
       

     

       92
        
         options.boot.loader.systemd-boot = {

     
···

       102
        
             '';

     

       103
        
           };

     

       104
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       105
        
           editor = mkOption {

     

       106
        
             default = true;

     

       107
        
       

     
···

       184
        
               '';

     

       185
        
             };

     

       186
        
       

     

       187
       -
             entryFilename = mkOption {

     

       188
       -
               default = "memtest86.conf";

     

       189
        
               type = types.str;

     

       190
        
               description = lib.mdDoc ''

     

       191
       -
                 `systemd-boot` orders the menu entries by the config file names,

     

       192
        
                 so if you want something to appear after all the NixOS entries,

     

       193
        
                 it should start with {file}`o` or onwards.

     

       0
        
       
     

       0
        
       
     

       194
        
               '';

     

       195
        
             };

     

       196
        
           };

     
···

       207
        
               '';

     

       208
        
             };

     

       209
        
       

     

       210
       -
             entryFilename = mkOption {

     

       211
       -
               default = "o_netbootxyz.conf";

     

       212
        
               type = types.str;

     

       213
        
               description = lib.mdDoc ''

     

       214
       -
                 `systemd-boot` orders the menu entries by the config file names,

     

       215
        
                 so if you want something to appear after all the NixOS entries,

     

       216
        
                 it should start with {file}`o` or onwards.

     

       0
        
       
     

       0
        
       
     

       217
        
               '';

     

       218
        
             };

     

       219
        
           };

     
···

       225
        
               { "memtest86.conf" = '''

     

       226
        
                 title Memtest86+

     

       227
        
                 efi /efi/memtest86/memtest.efi

     

       0
        
       
     

       228
        
               '''; }

     

       229
        
             '';

     

       230
        
             description = lib.mdDoc ''

     
···

       233
        
               Each attribute name denotes the destination file name,

     

       234
        
               and the corresponding attribute value is the contents of the entry.

     

       235
        
       

     

       236
       -
               `systemd-boot` orders the menu entries by the config file names,

     

       237
       -
               so if you want something to appear after all the NixOS entries,

     

       238
       -
               it should start with {file}`o` or onwards.

     

       0
        
       
     

       239
        
             '';

     

       240
        
           };

     

       241
        
       

     
···

       328
        
       

     

       329
        
           boot.loader.systemd-boot.extraEntries = mkMerge [

     

       330
        
             (mkIf cfg.memtest86.enable {

     

       331
       -
               "${cfg.memtest86.entryFilename}" = ''

     

       332
        
                 title  Memtest86+

     

       333
        
                 efi    /efi/memtest86/memtest.efi

     

       0
        
       
     

       334
        
               '';

     

       335
        
             })

     

       336
        
             (mkIf cfg.netbootxyz.enable {

     

       337
       -
               "${cfg.netbootxyz.entryFilename}" = ''

     

       338
        
                 title  netboot.xyz

     

       339
        
                 efi    /efi/netbootxyz/netboot.xyz.efi

     

       0
        
       
     

       340
        
               '';

     

       341
        
             })

     

       342
        
           ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       343
        
       

     

       344
        
           system = {

     

       345
        
             build.installBootLoader = finalSystemdBootBuilder;

···

       87
        
       

     

       88
        
         imports =

     

       89
        
           [ (mkRenamedOptionModule [ "boot" "loader" "gummiboot" "enable" ] [ "boot" "loader" "systemd-boot" "enable" ])

     

       90
       +
             (lib.mkChangedOptionModule

     

       91
       +
               [ "boot" "loader" "systemd-boot" "memtest86" "entryFilename" ]

     

       92
       +
               [ "boot" "loader" "systemd-boot" "memtest86" "sortKey" ]

     

       93
       +
               (config: lib.strings.removeSuffix ".conf" config.boot.loader.systemd-boot.memtest86.entryFilename)

     

       94
       +
             )

     

       95
       +
             (lib.mkChangedOptionModule

     

       96
       +
               [ "boot" "loader" "systemd-boot" "netbootxyz" "entryFilename" ]

     

       97
       +
               [ "boot" "loader" "systemd-boot" "netbootxyz" "sortKey" ]

     

       98
       +
               (config: lib.strings.removeSuffix ".conf" config.boot.loader.systemd-boot.netbootxyz.entryFilename)

     

       99
       +
             )

     

       100
        
           ];

     

       101
        
       

     

       102
        
         options.boot.loader.systemd-boot = {

     
···

       112
        
             '';

     

       113
        
           };

     

       114
        
       

     

       115
       +
           sortKey = mkOption {

     

       116
       +
             default = "nixos";

     

       117
       +
             type = lib.types.str;

     

       118
       +
             description = ''

     

       119
       +
               The sort key used for the NixOS bootloader entries.

     

       120
       +
               This key determines sorting relative to non-NixOS entries.

     

       121
       +
               See also https://uapi-group.org/specifications/specs/boot_loader_specification/#sorting

     

       122
       +
       

     

       123
       +
               This option can also be used to control the sorting of NixOS specialisations.

     

       124
       +
       

     

       125
       +
               By default, specialisations inherit the sort key of their parent generation

     

       126
       +
               and will have the same value for both the sort-key and the version (i.e. the generation number),

     

       127
       +
               systemd-boot will therefore sort them based on their file name, meaning that

     

       128
       +
               in your boot menu you will have each main generation directly followed by

     

       129
       +
               its specialisations sorted alphabetically by their names.

     

       130
       +
       

     

       131
       +
               If you want a different ordering for a specialisation, you can override

     

       132
       +
               its sort-key which will cause the specialisation to be uncoupled from its

     

       133
       +
               parent generation. It will then be sorted by its new sort-key just like

     

       134
       +
               any other boot entry.

     

       135
       +
       

     

       136
       +
               The sort-key is stored in the generation's bootspec, which means that

     

       137
       +
               generations keep their sort-keys even if the original definition of the

     

       138
       +
               generation was removed from the NixOS configuration.

     

       139
       +
               It also means that updating the sort-key will only affect new generations,

     

       140
       +
               while old ones will keep the sort-key that they were originally built with.

     

       141
       +
             '';

     

       142
       +
           };

     

       143
       +
       

     

       144
        
           editor = mkOption {

     

       145
        
             default = true;

     

       146
        
       

     
···

       223
        
               '';

     

       224
        
             };

     

       225
        
       

     

       226
       +
             sortKey = mkOption {

     

       227
       +
               default = "o_memtest86";

     

       228
        
               type = types.str;

     

       229
        
               description = lib.mdDoc ''

     

       230
       +
                 `systemd-boot` orders the menu entries by their sort keys,

     

       231
        
                 so if you want something to appear after all the NixOS entries,

     

       232
        
                 it should start with {file}`o` or onwards.

     

       233
       +
       

     

       234
       +
                 See also {option}`boot.loader.systemd-boot.sortKey`.

     

       235
        
               '';

     

       236
        
             };

     

       237
        
           };

     
···

       248
        
               '';

     

       249
        
             };

     

       250
        
       

     

       251
       +
             sortKey = mkOption {

     

       252
       +
               default = "o_netbootxyz";

     

       253
        
               type = types.str;

     

       254
        
               description = lib.mdDoc ''

     

       255
       +
                 `systemd-boot` orders the menu entries by their sort keys,

     

       256
        
                 so if you want something to appear after all the NixOS entries,

     

       257
        
                 it should start with {file}`o` or onwards.

     

       258
       +
       

     

       259
       +
                 See also {option}`boot.loader.systemd-boot.sortKey`.

     

       260
        
               '';

     

       261
        
             };

     

       262
        
           };

     
···

       268
        
               { "memtest86.conf" = '''

     

       269
        
                 title Memtest86+

     

       270
        
                 efi /efi/memtest86/memtest.efi

     

       271
       +
                 sort-key z_memtest

     

       272
        
               '''; }

     

       273
        
             '';

     

       274
        
             description = lib.mdDoc ''

     
···

       277
        
               Each attribute name denotes the destination file name,

     

       278
        
               and the corresponding attribute value is the contents of the entry.

     

       279
        
       

     

       280
       +
               To control the ordering of the entry in the boot menu, use the sort-key

     

       281
       +
               field, see

     

       282
       +
               https://uapi-group.org/specifications/specs/boot_loader_specification/#sorting

     

       283
       +
               and {option}`boot.loader.systemd-boot.sortKey`.

     

       284
        
             '';

     

       285
        
           };

     

       286
        
       

     
···

       373
        
       

     

       374
        
           boot.loader.systemd-boot.extraEntries = mkMerge [

     

       375
        
             (mkIf cfg.memtest86.enable {

     

       376
       +
               "memtest86.conf" = ''

     

       377
        
                 title  Memtest86+

     

       378
        
                 efi    /efi/memtest86/memtest.efi

     

       379
       +
                 sort-key ${cfg.memtest86.sortKey}

     

       380
        
               '';

     

       381
        
             })

     

       382
        
             (mkIf cfg.netbootxyz.enable {

     

       383
       +
               "netbootxyz.conf" = ''

     

       384
        
                 title  netboot.xyz

     

       385
        
                 efi    /efi/netbootxyz/netboot.xyz.efi

     

       386
       +
                 sort-key ${cfg.netbootxyz.sortKey}

     

       387
        
               '';

     

       388
        
             })

     

       389
        
           ];

     

       390
       +
       

     

       391
       +
           boot.bootspec.extensions."org.nixos.systemd-boot" = {

     

       392
       +
             inherit (config.boot.loader.systemd-boot) sortKey;

     

       393
       +
           };

     

       394
        
       

     

       395
        
           system = {

     

       396
        
             build.installBootLoader = finalSystemdBootBuilder;

+16 -12

nixos/tests/systemd-boot.nix

···

       93
        
             machine.wait_for_unit("multi-user.target")

     

       94
        
       

     

       95
        
             machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       0
        
       
     

       96
        
       

     

       97
        
             # Ensure we actually booted using systemd-boot

     

       98
        
             # Magic number is the vendor UUID used by systemd-boot.

     
···

       164
        
       

     

       165
        
           nodes.machine = { pkgs, lib, ... }: {

     

       166
        
             imports = [ common ];

     

       167
       -
             specialisation.something.configuration = {};

     

       0
        
       
     

       0
        
       
     

       168
        
           };

     

       169
        
       

     

       170
        
           testScript = ''

     
···

       177
        
             machine.succeed(

     

       178
        
                 "grep -q 'title NixOS (something)' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       179
        
             )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180
        
           '';

     

       181
        
         };

     

       182
        
       

     
···

       254
        
           };

     

       255
        
       

     

       256
        
           testScript = ''

     

       257
       -
             machine.succeed("test -e /boot/loader/entries/o_netbootxyz.conf")

     

       258
        
             machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       259
        
           '';

     

       260
        
         };

     

       261
        
       

     

       262
       -
         entryFilename = makeTest {

     

       263
       -
           name = "systemd-boot-entry-filename";

     

       264
        
           meta.maintainers = with pkgs.lib.maintainers; [ Enzime julienmalka ];

     

       265
        
       

     

       266
        
           nodes.machine = { pkgs, lib, ... }: {

     

       267
        
             imports = [ common ];

     

       268
        
             boot.loader.systemd-boot.memtest86.enable = true;

     

       269
       -
             boot.loader.systemd-boot.memtest86.entryFilename = "apple.conf";

     

       270
        
           };

     

       271
        
       

     

       272
        
           testScript = ''

     

       273
       -
             machine.fail("test -e /boot/loader/entries/memtest86.conf")

     

       274
       -
             machine.succeed("test -e /boot/loader/entries/apple.conf")

     

       275
        
             machine.succeed("test -e /boot/efi/memtest86/memtest.efi")

     

       0
        
       
     

       276
        
           '';

     

       277
        
         };

     

       278
        
       

     
···

       283
        
           nodes.machine = { pkgs, lib, ... }: {

     

       284
        
             imports = [ commonXbootldr ];

     

       285
        
             boot.loader.systemd-boot.memtest86.enable = true;

     

       286
       -
             boot.loader.systemd-boot.memtest86.entryFilename = "apple.conf";

     

       287
        
           };

     

       288
        
       

     

       289
        
           testScript = { nodes, ... }: ''

     
···

       293
        
             machine.wait_for_unit("multi-user.target")

     

       294
        
       

     

       295
        
             machine.succeed("test -e /efi/EFI/systemd/systemd-bootx64.efi")

     

       296
       -
             machine.fail("test -e /boot/loader/entries/memtest86.conf")

     

       297
       -
             machine.succeed("test -e /boot/loader/entries/apple.conf")

     

       298
        
             machine.succeed("test -e /boot/EFI/memtest86/memtest.efi")

     

       299
        
           '';

     

       300
        
         };

     
···

       386
        
                 machine.succeed("${finalSystem}/bin/switch-to-configuration boot")

     

       387
        
                 machine.fail("test -e /boot/efi/fruits/tomato.efi")

     

       388
        
                 machine.fail("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       389
       -
                 machine.succeed("test -e /boot/loader/entries/o_netbootxyz.conf")

     

       390
        
                 machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       391
       -
                 machine.succeed("test -e /boot/efi/nixos/.extra-files/loader/entries/o_netbootxyz.conf")

     

       392
        
                 machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/netbootxyz/netboot.xyz.efi")

     

       393
        
           '';

     

       394
        
         };

···

       93
        
             machine.wait_for_unit("multi-user.target")

     

       94
        
       

     

       95
        
             machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       96
       +
             machine.succeed("grep 'sort-key nixos' /boot/loader/entries/nixos-generation-1.conf")

     

       97
        
       

     

       98
        
             # Ensure we actually booted using systemd-boot

     

       99
        
             # Magic number is the vendor UUID used by systemd-boot.

     
···

       165
        
       

     

       166
        
           nodes.machine = { pkgs, lib, ... }: {

     

       167
        
             imports = [ common ];

     

       168
       +
             specialisation.something.configuration = {

     

       169
       +
               boot.loader.systemd-boot.sortKey = "something";

     

       170
       +
             };

     

       171
        
           };

     

       172
        
       

     

       173
        
           testScript = ''

     
···

       180
        
             machine.succeed(

     

       181
        
                 "grep -q 'title NixOS (something)' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       182
        
             )

     

       183
       +
             machine.succeed(

     

       184
       +
                 "grep 'sort-key something' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       185
       +
             )

     

       186
        
           '';

     

       187
        
         };

     

       188
        
       

     
···

       260
        
           };

     

       261
        
       

     

       262
        
           testScript = ''

     

       263
       +
             machine.succeed("test -e /boot/loader/entries/netbootxyz.conf")

     

       264
        
             machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       265
        
           '';

     

       266
        
         };

     

       267
        
       

     

       268
       +
         memtestSortKey = makeTest {

     

       269
       +
           name = "systemd-boot-memtest-sortkey";

     

       270
        
           meta.maintainers = with pkgs.lib.maintainers; [ Enzime julienmalka ];

     

       271
        
       

     

       272
        
           nodes.machine = { pkgs, lib, ... }: {

     

       273
        
             imports = [ common ];

     

       274
        
             boot.loader.systemd-boot.memtest86.enable = true;

     

       275
       +
             boot.loader.systemd-boot.memtest86.sortKey = "apple";

     

       276
        
           };

     

       277
        
       

     

       278
        
           testScript = ''

     

       279
       +
             machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       0
        
       
     

       280
        
             machine.succeed("test -e /boot/efi/memtest86/memtest.efi")

     

       281
       +
             machine.succeed("grep 'sort-key apple' /boot/loader/entries/memtest86.conf")

     

       282
        
           '';

     

       283
        
         };

     

       284
        
       

     
···

       289
        
           nodes.machine = { pkgs, lib, ... }: {

     

       290
        
             imports = [ commonXbootldr ];

     

       291
        
             boot.loader.systemd-boot.memtest86.enable = true;

     

       0
        
       
     

       292
        
           };

     

       293
        
       

     

       294
        
           testScript = { nodes, ... }: ''

     
···

       298
        
             machine.wait_for_unit("multi-user.target")

     

       299
        
       

     

       300
        
             machine.succeed("test -e /efi/EFI/systemd/systemd-bootx64.efi")

     

       301
       +
             machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       0
        
       
     

       302
        
             machine.succeed("test -e /boot/EFI/memtest86/memtest.efi")

     

       303
        
           '';

     

       304
        
         };

     
···

       390
        
                 machine.succeed("${finalSystem}/bin/switch-to-configuration boot")

     

       391
        
                 machine.fail("test -e /boot/efi/fruits/tomato.efi")

     

       392
        
                 machine.fail("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       393
       +
                 machine.succeed("test -e /boot/loader/entries/netbootxyz.conf")

     

       394
        
                 machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       395
       +
                 machine.succeed("test -e /boot/efi/nixos/.extra-files/loader/entries/netbootxyz.conf")

     

       396
        
                 machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/netbootxyz/netboot.xyz.efi")

     

       397
        
           '';

     

       398
        
         };