commit a8ab8b59a75a4bf0675fb3785e76c54873044f9e · pyrox.dev/nixpkgs

+10 -1

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

···

       43
       43
        
           system: str

     

       44
       44
        
           toplevel: str

     

       45
       45
        
           specialisations: Dict[str, "BootSpec"]

     

       46
       46
       +
           sortKey: str

     

       46
       47
        
           initrdSecrets: str | None = None

     

       47
       48
        
       

     

       48
       49
        
       

     
···

       73
       74
        
               return d

     

       74
       75
        
       

     

       75
       76
        
       BOOT_ENTRY = """title {title}

     

       77
       77
       +
       sort-key {sort_key}

     

       76
       78
        
       version Generation {generation} {description}

     

       77
       79
        
       linux {kernel}

     

       78
       80
        
       initrd {initrd}

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       130
       130
       +
           return BootSpec(

     

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

     

       132
       132
       +
               specialisations=specialisations,

     

       133
       133
       +
               sortKey=sortKey

     

       134
       134
       +
           )

     

       127
       135
        
       

     

       128
       136
        
       

     

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

     
···

       170
       178
        
       

     

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

     

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

     

       181
       181
       +
                           sort_key=bootspec.sortKey,

     

       173
       182
        
                           generation=generation,

     

       174
       183
        
                           kernel=kernel,

     

       175
       184
        
                           initrd=initrd,

+62 -11

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

···

       87
       87
        
       

     

       88
       88
        
         imports =

     

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

     

       90
       90
       +
             (lib.mkChangedOptionModule

     

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

     

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

     

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

     

       94
       94
       +
             )

     

       95
       95
       +
             (lib.mkChangedOptionModule

     

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

     

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

     

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

     

       99
       99
       +
             )

     

       90
       100
        
           ];

     

       91
       101
        
       

     

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

     
···

       102
       112
        
             '';

     

       103
       113
        
           };

     

       104
       114
        
       

     

       115
       115
       +
           sortKey = mkOption {

     

       116
       116
       +
             default = "nixos";

     

       117
       117
       +
             type = lib.types.str;

     

       118
       118
       +
             description = ''

     

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

     

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

     

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

     

       122
       122
       +
       

     

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

     

       124
       124
       +
       

     

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

     

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

     

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

     

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

     

       129
       129
       +
               its specialisations sorted alphabetically by their names.

     

       130
       130
       +
       

     

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

     

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

     

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

     

       134
       134
       +
               any other boot entry.

     

       135
       135
       +
       

     

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

     

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

     

       138
       138
       +
               generation was removed from the NixOS configuration.

     

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

     

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

     

       141
       141
       +
             '';

     

       142
       142
       +
           };

     

       143
       143
       +
       

     

       105
       144
        
           editor = mkOption {

     

       106
       145
        
             default = true;

     

       107
       146
        
       

     
···

       184
       223
        
               '';

     

       185
       224
        
             };

     

       186
       225
        
       

     

       187
       187
       -
             entryFilename = mkOption {

     

       188
       188
       -
               default = "memtest86.conf";

     

       226
       226
       +
             sortKey = mkOption {

     

       227
       227
       +
               default = "o_memtest86";

     

       189
       228
        
               type = types.str;

     

       190
       229
        
               description = lib.mdDoc ''

     

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

     

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

     

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

     

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

     

       233
       233
       +
       

     

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

     

       194
       235
        
               '';

     

       195
       236
        
             };

     

       196
       237
        
           };

     
···

       207
       248
        
               '';

     

       208
       249
        
             };

     

       209
       250
        
       

     

       210
       210
       -
             entryFilename = mkOption {

     

       211
       211
       -
               default = "o_netbootxyz.conf";

     

       251
       251
       +
             sortKey = mkOption {

     

       252
       252
       +
               default = "o_netbootxyz";

     

       212
       253
        
               type = types.str;

     

       213
       254
        
               description = lib.mdDoc ''

     

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

     

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

     

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

     

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

     

       258
       258
       +
       

     

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

     

       217
       260
        
               '';

     

       218
       261
        
             };

     

       219
       262
        
           };

     
···

       225
       268
        
               { "memtest86.conf" = '''

     

       226
       269
        
                 title Memtest86+

     

       227
       270
        
                 efi /efi/memtest86/memtest.efi

     

       271
       271
       +
                 sort-key z_memtest

     

       228
       272
        
               '''; }

     

       229
       273
        
             '';

     

       230
       274
        
             description = lib.mdDoc ''

     
···

       233
       277
        
               Each attribute name denotes the destination file name,

     

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

     

       235
       279
        
       

     

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

     

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

     

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

     

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

     

       281
       281
       +
               field, see

     

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

     

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

     

       239
       284
        
             '';

     

       240
       285
        
           };

     

       241
       286
        
       

     
···

       328
       373
        
       

     

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

     

       330
       375
        
             (mkIf cfg.memtest86.enable {

     

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

     

       376
       376
       +
               "memtest86.conf" = ''

     

       332
       377
        
                 title  Memtest86+

     

       333
       378
        
                 efi    /efi/memtest86/memtest.efi

     

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

     

       334
       380
        
               '';

     

       335
       381
        
             })

     

       336
       382
        
             (mkIf cfg.netbootxyz.enable {

     

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

     

       383
       383
       +
               "netbootxyz.conf" = ''

     

       338
       384
        
                 title  netboot.xyz

     

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

     

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

     

       340
       387
        
               '';

     

       341
       388
        
             })

     

       342
       389
        
           ];

     

       390
       390
       +
       

     

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

     

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

     

       393
       393
       +
           };

     

       343
       394
        
       

     

       344
       395
        
           system = {

     

       345
       396
        
             build.installBootLoader = finalSystemdBootBuilder;

+16 -12

nixos/tests/systemd-boot.nix

···

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

     

       94
       94
        
       

     

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

     

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

     

       96
       97
        
       

     

       97
       98
        
             # Ensure we actually booted using systemd-boot

     

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

     
···

       164
       165
        
       

     

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

     

       166
       167
        
             imports = [ common ];

     

       167
       167
       -
             specialisation.something.configuration = {};

     

       168
       168
       +
             specialisation.something.configuration = {

     

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

     

       170
       170
       +
             };

     

       168
       171
        
           };

     

       169
       172
        
       

     

       170
       173
        
           testScript = ''

     
···

       177
       180
        
             machine.succeed(

     

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

     

       179
       182
        
             )

     

       183
       183
       +
             machine.succeed(

     

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

     

       185
       185
       +
             )

     

       180
       186
        
           '';

     

       181
       187
        
         };

     

       182
       188
        
       

     
···

       254
       260
        
           };

     

       255
       261
        
       

     

       256
       262
        
           testScript = ''

     

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

     

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

     

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

     

       259
       265
        
           '';

     

       260
       266
        
         };

     

       261
       267
        
       

     

       262
       262
       -
         entryFilename = makeTest {

     

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

     

       268
       268
       +
         memtestSortKey = makeTest {

     

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

     

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

     

       265
       271
        
       

     

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

     

       267
       273
        
             imports = [ common ];

     

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

     

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

     

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

     

       270
       276
        
           };

     

       271
       277
        
       

     

       272
       278
        
           testScript = ''

     

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

     

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

     

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

     

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

     

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

     

       276
       282
        
           '';

     

       277
       283
        
         };

     

       278
       284
        
       

     
···

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

     

       284
       290
        
             imports = [ commonXbootldr ];

     

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

     

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

     

       287
       292
        
           };

     

       288
       293
        
       

     

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

     
···

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

     

       294
       299
        
       

     

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

     

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

     

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

     

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

     

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

     

       299
       303
        
           '';

     

       300
       304
        
         };

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       393
       397
        
           '';

     

       394
       398
        
         };