···

       
73
       
73
       
 
       
  defaultPkgs =

     

       
74
       
74
       
 
       
    if opt.hostPlatform.isDefined then

     

       
75
       
75
       
 
       
      let

     

       
76
       
76
       
-
       
        isCross =

     

       
77
       
77
       
-
       
          !(lib.systems.equals (lib.systems.elaborate cfg.buildPlatform) (

     

       
78
       
78
       
-
       
            lib.systems.elaborate cfg.hostPlatform

     

       
79
       
79
       
-
       
          ));

     

       
76
       
76
       
+
       
        isCross = cfg.buildPlatform != cfg.hostPlatform;

     

       
80
       
77
       
 
       
        systemArgs =

     

       
81
       
78
       
 
       
          if isCross then

     

       
82
       
79
       
 
       
            {

     
···

       
198
       
195
       
 
       
    };

     

       
199
       
196
       
 
       


     

       
200
       
197
       
 
       
    hostPlatform = lib.mkOption {

     

       
201
       
201
       
-
       
      type = lib.types.either lib.types.str lib.types.attrs;

     

       
198
       
198
       
+
       
      type = lib.types.either lib.types.str lib.types.attrs; # TODO utilize lib.systems.parsedPlatform

     

       
202
       
199
       
 
       
      example = {

     

       
203
       
200
       
 
       
        system = "aarch64-linux";

     

       
204
       
201
       
 
       
      };

     

       
202
       
202
       
+
       
      # Make sure that the final value has all fields for sake of other modules

     

       
203
       
203
       
+
       
      # referring to this. TODO make `lib.systems` itself use the module system.

     

       
204
       
204
       
+
       
      apply = lib.systems.elaborate;

     

       
205
       
205
       
 
       
      defaultText = lib.literalExpression ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       
206
       
206
       
 
       
      description = ''

     

       
207
       
207
       
 
       
        Specifies the platform where the NixOS configuration will run.

     
···

       
213
       
213
       
 
       
    };

     

       
214
       
214
       
 
       


     

       
215
       
215
       
 
       
    buildPlatform = lib.mkOption {

     

       
216
       
216
       
-
       
      type = lib.types.either lib.types.str lib.types.attrs;

     

       
216
       
216
       
+
       
      type = lib.types.either lib.types.str lib.types.attrs; # TODO utilize lib.systems.parsedPlatform

     

       
217
       
217
       
 
       
      default = cfg.hostPlatform;

     

       
218
       
218
       
 
       
      example = {

     

       
219
       
219
       
 
       
        system = "x86_64-linux";

     

       
220
       
220
       
 
       
      };

     

       
221
       
221
       
 
       
      # Make sure that the final value has all fields for sake of other modules

     

       
222
       
222
       
 
       
      # referring to this.

     

       
223
       
223
       
+
       
      apply =

     

       
224
       
224
       
+
       
        inputBuildPlatform:

     

       
225
       
225
       
+
       
        let

     

       
226
       
226
       
+
       
          elaborated = lib.systems.elaborate inputBuildPlatform;

     

       
227
       
227
       
+
       
        in

     

       
228
       
228
       
+
       
        if lib.systems.equals elaborated cfg.hostPlatform then

     

       
229
       
229
       
+
       
          cfg.hostPlatform # make identical, so that `==` equality works; see https://github.com/NixOS/nixpkgs/issues/278001

     

       
230
       
230
       
+
       
        else

     

       
231
       
231
       
+
       
          elaborated;

     

       
223
       
232
       
 
       
      defaultText = lib.literalExpression ''config.nixpkgs.hostPlatform'';

     

       
224
       
233
       
 
       
      description = ''

     

       
225
       
234
       
 
       
        Specifies the platform on which NixOS should be built.

     
···

       
236
       
245
       
 
       
    };

     

       
237
       
246
       
 
       


     

       
238
       
247
       
 
       
    localSystem = lib.mkOption {

     

       
239
       
239
       
-
       
      type = lib.types.attrs;

     

       
248
       
248
       
+
       
      type = lib.types.attrs; # TODO utilize lib.systems.parsedPlatform

     

       
240
       
249
       
 
       
      default = { inherit (cfg) system; };

     

       
241
       
250
       
 
       
      example = {

     

       
242
       
251
       
 
       
        system = "aarch64-linux";

     

       
243
       
252
       
 
       
      };

     

       
253
       
253
       
+
       
      # Make sure that the final value has all fields for sake of other modules

     

       
254
       
254
       
+
       
      # referring to this. TODO make `lib.systems` itself use the module system.

     

       
255
       
255
       
+
       
      apply = lib.systems.elaborate;

     

       
244
       
256
       
 
       
      defaultText = lib.literalExpression ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       
245
       
257
       
 
       
      description = ''

     

       
246
       
258
       
 
       
        Systems with a recently generated `hardware-configuration.nix`

     
···

       
268
       
280
       
 
       
    #      is a relation between at least 2 systems in the context of a

     

       
269
       
281
       
 
       
    #      specific build step, not a single system.

     

       
270
       
282
       
 
       
    crossSystem = lib.mkOption {

     

       
271
       
271
       
-
       
      type = lib.types.nullOr lib.types.attrs;

     

       
283
       
283
       
+
       
      type = lib.types.nullOr lib.types.attrs; # TODO utilize lib.systems.parsedPlatform

     

       
272
       
284
       
 
       
      default = null;

     

       
273
       
285
       
 
       
      example = {

     

       
274
       
286
       
 
       
        system = "aarch64-linux";

     
···

       
402
       
414
       
 
       


     

       
403
       
415
       
 
       
            Defined in:

     

       
404
       
416
       
 
       
            ${lib.concatMapStringsSep "\n" (file: "  - ${file}") opt.config.files}

     

       
405
       
405
       
-
       
          '';

     

       
406
       
406
       
-
       
        }

     

       
407
       
407
       
-
       
        {

     

       
408
       
408
       
-
       
          assertion =

     

       
409
       
409
       
-
       
            (opt.hostPlatform.isDefined -> builtins.isAttrs cfg.buildPlatform -> !(cfg.buildPlatform ? parsed))

     

       
410
       
410
       
-
       
            && (opt.hostPlatform.isDefined -> builtins.isAttrs cfg.hostPlatform -> !(cfg.hostPlatform ? parsed))

     

       
411
       
411
       
-
       
            && (builtins.isAttrs cfg.localSystem -> !(cfg.localSystem ? parsed))

     

       
412
       
412
       
-
       
            && (builtins.isAttrs cfg.crossSystem -> !(cfg.crossSystem ? parsed));

     

       
413
       
413
       
-
       
          message = ''

     

       
414
       
414
       
-
       
            Passing fully elaborated systems to `nixpkgs.localSystem`, `nixpkgs.crossSystem`, `nixpkgs.buildPlatform`

     

       
415
       
415
       
-
       
            or `nixpkgs.hostPlatform` will break composability of package sets in nixpkgs. For example, pkgs.pkgsStatic

     

       
416
       
416
       
-
       
            would not work in modules anymore.

     

       
417
       
417
       
 
       
          '';

     

       
418
       
418
       
 
       
        }

     

       
419
       
419
       
 
       
      ];

     

···

       
40
       
40
       
 
       
          The Nixpkgs overlays that `pkgs` was initialized with.

     

       
41
       
41
       
 
       
        '';

     

       
42
       
42
       
 
       
      };

     

       
43
       
43
       
-
       
      # buildPlatform and hostPlatform left out on purpose:

     

       
44
       
44
       
-
       
      # - They are not supposed to be changed with this read-only module.

     

       
45
       
45
       
-
       
      # - They are not supposed to be read either, according to the description

     

       
46
       
46
       
-
       
      #   of "system" in the traditional nixpkgs module.

     

       
47
       
47
       
-
       
      #

     

       
43
       
43
       
+
       
      hostPlatform = mkOption {

     

       
44
       
44
       
+
       
        internal = true;

     

       
45
       
45
       
+
       
        readOnly = true;

     

       
46
       
46
       
+
       
        description = ''

     

       
47
       
47
       
+
       
          The platform of the machine that is running the NixOS configuration.

     

       
48
       
48
       
+
       
        '';

     

       
49
       
49
       
+
       
      };

     

       
50
       
50
       
+
       
      buildPlatform = mkOption {

     

       
51
       
51
       
+
       
        internal = true;

     

       
52
       
52
       
+
       
        readOnly = true;

     

       
53
       
53
       
+
       
        description = ''

     

       
54
       
54
       
+
       
          The platform of the machine that built the NixOS configuration.

     

       
55
       
55
       
+
       
        '';

     

       
56
       
56
       
+
       
      };

     

       
48
       
57
       
 
       
      # NOTE: do not add the legacy options such as localSystem here. Let's keep

     

       
49
       
58
       
 
       
      #       this module simple and let module authors upgrade their code instead.

     

       
50
       
59
       
 
       
    };

     
···

       
52
       
61
       
 
       
  config = {

     

       
53
       
62
       
 
       
    _module.args.pkgs =

     

       
54
       
63
       
 
       
      # find mistaken definitions

     

       
55
       
55
       
-
       
      builtins.seq cfg.config builtins.seq cfg.overlays cfg.pkgs;

     

       
64
       
64
       
+
       
      builtins.seq cfg.config builtins.seq cfg.overlays builtins.seq cfg.hostPlatform builtins.seq

     

       
65
       
65
       
+
       
        cfg.buildPlatform

     

       
66
       
66
       
+
       
        cfg.pkgs;

     

       
56
       
67
       
 
       
    nixpkgs.config = cfg.pkgs.config;

     

       
57
       
68
       
 
       
    nixpkgs.overlays = cfg.pkgs.overlays;

     

       
69
       
69
       
+
       
    nixpkgs.hostPlatform = cfg.pkgs.stdenv.hostPlatform;

     

       
70
       
70
       
+
       
    nixpkgs.buildPlatform = cfg.pkgs.stdenv.buildPlatform;

     

       
58
       
71
       
 
       
  };

     

       
59
       
72
       
 
       
}

     

···

       
506
       
506
       
 
       
                        config = {

     

       
507
       
507
       
 
       
                          nixpkgs =

     

       
508
       
508
       
 
       
                            if options.nixpkgs?hostPlatform

     

       
509
       
509
       
-
       
                            then {

     

       
510
       
510
       
-
       
                              hostPlatform =

     

       
511
       
511
       
-
       
                                if host.options.nixpkgs.hostPlatform.isDefined

     

       
512
       
512
       
-
       
                                then host.config.nixpkgs.hostPlatform

     

       
513
       
513
       
-
       
                                else lib.defaultTo host.config.nixpkgs.localSystem host.config.nixpkgs.crossSystem;

     

       
514
       
514
       
-
       
                            } else { localSystem = lib.defaultTo host.config.nixpkgs.localSystem host.config.nixpkgs.crossSystem; }

     

       
509
       
509
       
+
       
                            then { inherit (host.pkgs.stdenv) hostPlatform; }

     

       
510
       
510
       
+
       
                            else { localSystem = host.pkgs.stdenv.hostPlatform; }

     

       
515
       
511
       
 
       
                          ;

     

       
516
       
512
       
 
       
                          boot.isContainer = true;

     

       
517
       
513
       
 
       
                          networking.hostName = mkDefault name;

     

···

       
40
       
40
       
 
       
        verityStore = {

     

       
41
       
41
       
 
       
          enable = true;

     

       
42
       
42
       
 
       
          # by default the module works with systemd-boot, for simplicity this test directly boots the UKI

     

       
43
       
43
       
-
       
          ukiPath = "/EFI/BOOT/BOOT${lib.toUpper pkgs.stdenv.hostPlatform.efiArch}.EFI";

     

       
43
       
43
       
+
       
          ukiPath = "/EFI/BOOT/BOOT${lib.toUpper config.nixpkgs.hostPlatform.efiArch}.EFI";

     

       
44
       
44
       
 
       
        };

     

       
45
       
45
       
 
       


     

       
46
       
46
       
 
       
        name = "appliance-verity-store-image";

     
···

       
51
       
51
       
 
       
            repartConfig = {

     

       
52
       
52
       
 
       
              Type = "esp";

     

       
53
       
53
       
 
       
              Format = "vfat";

     

       
54
       
54
       
-
       
              SizeMinBytes = if pkgs.stdenv.hostPlatform.isx86_64 then "64M" else "96M";

     

       
54
       
54
       
+
       
              SizeMinBytes = if config.nixpkgs.hostPlatform.isx86_64 then "64M" else "96M";

     

       
55
       
55
       
 
       
            };

     

       
56
       
56
       
 
       
          };

     

       
57
       
57
       
 
       
          ${partitionIds.store-verity}.repartConfig = {

     

···

       
53
       
53
       
 
       
          "esp" = {

     

       
54
       
54
       
 
       
            contents =

     

       
55
       
55
       
 
       
              let

     

       
56
       
56
       
-
       
                efiArch = pkgs.stdenv.hostPlatform.efiArch;

     

       
56
       
56
       
+
       
                efiArch = config.nixpkgs.hostPlatform.efiArch;

     

       
57
       
57
       
 
       
              in

     

       
58
       
58
       
 
       
              {

     

       
59
       
59
       
 
       
                "/EFI/BOOT/BOOT${lib.toUpper efiArch}.EFI".source =

     
···

       
70
       
70
       
 
       
              # aarch64 kernel seems to generally be a little bigger than the

     

       
71
       
71
       
 
       
              # x86_64 kernel. To stay on the safe side, leave some more slack

     

       
72
       
72
       
 
       
              # for every platform other than x86_64.

     

       
73
       
73
       
-
       
              SizeMinBytes = if pkgs.stdenv.hostPlatform.isx86_64 then "64M" else "96M";

     

       
73
       
73
       
+
       
              SizeMinBytes = if config.nixpkgs.hostPlatform.isx86_64 then "64M" else "96M";

     

       
74
       
74
       
 
       
            };

     

       
75
       
75
       
 
       
          };

     

       
76
       
76
       
 
       
          "swap" = {

     

···

       
17721
       
17721
       
 
       
                [(

     

       
17722
       
17722
       
 
       
                  { lib, ... }: {

     

       
17723
       
17723
       
 
       
                    config.nixpkgs.pkgs = lib.mkDefault pkgs;

     

       
17724
       
17724
       
-
       
                    config.nixpkgs.localSystem = lib.mkDefault ({ config = lib.systems.parse.tripleFromSystem stdenv.hostPlatform; });

     

       
17724
       
17724
       
+
       
                    config.nixpkgs.localSystem = lib.mkDefault stdenv.hostPlatform;

     

       
17725
       
17725
       
 
       
                  }

     

       
17726
       
17726
       
 
       
                )] ++ (

     

       
17727
       
17727
       
 
       
                  if builtins.isList configuration