commit c6f7d4367894047592cc412740f0c1f5b2ca2b59 · pyrox.dev/nixpkgs

+2 -2

lib/systems/parse.nix

···

       201
       201
        
       

     

       202
       202
        
         ################################################################################

     

       203
       203
        
       

     

       204
       204
       -
         types.system = mkOptionType {

     

       204
       204
       +
         types.parsedPlatform = mkOptionType {

     

       205
       205
        
           name = "system";

     

       206
       206
        
           description = "fully parsed representation of llvm- or nix-style platform tuple";

     

       207
       207
        
           merge = mergeOneOption;

     
···

       215
       215
        
         isSystem = isType "system";

     

       216
       216
        
       

     

       217
       217
        
         mkSystem = components:

     

       218
       218
       -
           assert types.system.check components;

     

       218
       218
       +
           assert types.parsedPlatform.check components;

     

       219
       219
        
           setType "system" components;

     

       220
       220
        
       

     

       221
       221
        
         mkSkeletonFromList = l: {

+3 -3

nixos/doc/manual/man-nixos-build-vms.xml

···

       40
       40
        
         test1 = {pkgs, config, ...}:

     

       41
       41
        
           {

     

       42
       42
        
             services.openssh.enable = true;

     

       43
       43
       -
             nixpkgs.system = "i686-linux";

     

       43
       43
       +
             nixpkgs.localSystem.system = "i686-linux";

     

       44
       44
        
             deployment.targetHost = "test1.example.net";

     

       45
       45
        
       

     

       46
       46
        
             # Other NixOS options

     
···

       51
       51
        
             services.openssh.enable = true;

     

       52
       52
        
             services.httpd.enable = true;

     

       53
       53
        
             environment.systemPackages = [ pkgs.lynx ];

     

       54
       54
       -
             nixpkgs.system = "x86_64-linux";

     

       54
       54
       +
             nixpkgs.localSystem.system = "x86_64-linux";

     

       55
       55
        
             deployment.targetHost = "test2.example.net";

     

       56
       56
        
       

     

       57
       57
        
             # Other NixOS options

     
···

       66
       66
        
       The <varname>deployment.targetHost</varname> specifies the address

     

       67
       67
        
       (domain name or IP address)

     

       68
       68
        
       of the system which is used by <command>ssh</command> to perform

     

       69
       69
       -
       remote deployment operations. The <varname>nixpkgs.system</varname>

     

       69
       69
       +
       remote deployment operations. The <varname>nixpkgs.localSystem.system</varname>

     

       70
       70
        
       attribute can be used to specify an architecture for the target machine,

     

       71
       71
        
       such as <varname>i686-linux</varname> which builds a 32-bit NixOS

     

       72
       72
        
       configuration. Omitting this property will build the configuration

+2 -2

nixos/lib/eval-config.nix

···

       26
       26
        
       , lib ? import ../../lib

     

       27
       27
        
       }:

     

       28
       28
        
       

     

       29
       29
       -
       let extraArgs_ = extraArgs; pkgs_ = pkgs; system_ = system;

     

       29
       29
       +
       let extraArgs_ = extraArgs; pkgs_ = pkgs;

     

       30
       30
        
           extraModules = let e = builtins.getEnv "NIXOS_EXTRA_MODULE_PATH";

     

       31
       31
        
                          in if e == "" then [] else [(import (builtins.toPath e))];

     

       32
       32
        
       in

     
···

       36
       36
        
           _file = ./eval-config.nix;

     

       37
       37
        
           key = _file;

     

       38
       38
        
           config = {

     

       39
       39
       -
             nixpkgs.system = lib.mkDefault system_;

     

       39
       39
       +
             nixpkgs.localSystem = lib.mkDefault { inherit system; };

     

       40
       40
        
             _module.args.pkgs = lib.mkIf (pkgs_ != null) (lib.mkForce pkgs_);

     

       41
       41
        
           };

     

       42
       42
        
         };

+53 -12

nixos/modules/misc/nixpkgs.nix

···

       58
       58
        
           pkgs = mkOption {

     

       59
       59
        
             defaultText = literalExample

     

       60
       60
        
               ''import "''${nixos}/.." {

     

       61
       61
       -
                   inherit (config.nixpkgs) config overlays system;

     

       61
       61
       +
                   inherit (config.nixpkgs) config overlays localSystem crossSystem;

     

       62
       62
        
                 }

     

       63
       63
        
               '';

     

       64
       64
       -
             default = import ../../.. { inherit (cfg) config overlays system crossSystem; };

     

       64
       64
       +
             default = import ../../.. {

     

       65
       65
       +
               localSystem = { inherit (cfg) system; } // cfg.localSystem;

     

       66
       66
       +
               inherit (cfg) config overlays crossSystem;

     

       67
       67
       +
             };

     

       65
       68
        
             type = pkgsType;

     

       66
       69
        
             example = literalExample ''import <nixpkgs> {}'';

     

       67
       70
        
             description = ''

     
···

       73
       76
        
               relative to the location of this NixOS module, because

     

       74
       77
        
               NixOS and Nixpkgs are distributed together for consistency,

     

       75
       78
        
               so the <code>nixos</code> in the default value is in fact a

     

       76
       76
       -
               relative path. The <code>config</code>, <code>overlays</code>

     

       77
       77
       -
               and <code>system</code> come from this option's siblings.

     

       79
       79
       +
               relative path. The <code>config</code>, <code>overlays</code>,

     

       80
       80
       +
               <code>localSystem</code>, and <code>crossSystem</code> come

     

       81
       81
       +
               from this option's siblings.

     

       78
       82
        
       

     

       79
       83
        
               This option can be used by applications like NixOps to increase

     

       80
       84
        
               the performance of evaluation, or to create packages that depend

     
···

       130
       134
        
             '';

     

       131
       135
        
           };

     

       132
       136
        
       

     

       137
       137
       +
           localSystem = mkOption {

     

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

     

       139
       139
       +
             default = { system = builtins.currentSystem; };

     

       140
       140
       +
             example = { system = "aarch64-linux"; config = "aarch64-unknown-linux-gnu"; };

     

       141
       141
       +
             defaultText = literalExample

     

       142
       142
       +
               ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       143
       143
       +
             description = ''

     

       144
       144
       +
               Specifies the platform on which NixOS should be built. When

     

       145
       145
       +
               <code>nixpkgs.crossSystem</code> is unset, it also specifies

     

       146
       146
       +
               the platform <emphasis>for</emphasis> which NixOS should be

     

       147
       147
       +
               built.  If this option is unset, it defaults to the platform

     

       148
       148
       +
               type of the machine where evaluation happens. Specifying this

     

       149
       149
       +
               option is useful when doing distributed multi-platform

     

       150
       150
       +
               deployment, or when building virtual machines. See its

     

       151
       151
       +
               description in the Nixpkgs manual for more details.

     

       152
       152
       +
       

     

       153
       153
       +
               Ignored when <code>nixpkgs.pkgs</code> is set.

     

       154
       154
       +
             '';

     

       155
       155
       +
           };

     

       156
       156
       +
       

     

       133
       157
        
           crossSystem = mkOption {

     

       134
       134
       -
             type = types.nullOr types.attrs;

     

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

     

       135
       159
        
             default = null;

     

       160
       160
       +
             example = { system = "aarch64-linux"; config = "aarch64-unknown-linux-gnu"; };

     

       161
       161
       +
             defaultText = literalExample

     

       162
       162
       +
               ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       136
       163
        
             description = ''

     

       137
       137
       -
               The description of the system we're cross-compiling to, or null

     

       138
       138
       -
               if this isn't a cross-compile. See the description of the

     

       139
       139
       -
               crossSystem argument in the nixpkgs manual.

     

       164
       164
       +
               Specifies the platform for which NixOS should be

     

       165
       165
       +
               built. Specify this only if it is different from

     

       166
       166
       +
               <code>nixpkgs.localSystem</code>, the platform

     

       167
       167
       +
               <emphasis>on</emphasis> which NixOS should be built. In other

     

       168
       168
       +
               words, specify this to cross-compile NixOS. Otherwise it

     

       169
       169
       +
               should be set as null, the default. See its description in the

     

       170
       170
       +
               Nixpkgs manual for more details.

     

       140
       171
        
       

     

       141
       172
        
               Ignored when <code>nixpkgs.pkgs</code> is set.

     

       142
       173
        
             '';

     
···

       146
       177
        
             type = types.str;

     

       147
       178
        
             example = "i686-linux";

     

       148
       179
        
             description = ''

     

       149
       149
       -
               Specifies the Nix platform type for which NixOS should be built.

     

       150
       150
       -
               If unset, it defaults to the platform type of your host system.

     

       151
       151
       -
               Specifying this option is useful when doing distributed

     

       152
       152
       -
               multi-platform deployment, or when building virtual machines.

     

       180
       180
       +
               Specifies the Nix platform type on which NixOS should be built.

     

       181
       181
       +
               It is better to specify <code>nixpkgs.localSystem</code> instead.

     

       182
       182
       +
               <programlisting>

     

       183
       183
       +
               {

     

       184
       184
       +
                 nixpkgs.system = ..;

     

       185
       185
       +
               }

     

       186
       186
       +
               </programlisting>

     

       187
       187
       +
               is the same as

     

       188
       188
       +
               <programlisting>

     

       189
       189
       +
               {

     

       190
       190
       +
                 nixpkgs.localSystem.system = ..;

     

       191
       191
       +
               }

     

       192
       192
       +
               </programlisting>

     

       193
       193
       +
               See <code>nixpkgs.localSystem</code> for more information.

     

       153
       194
        
       

     

       154
       195
        
               Ignored when <code>nixpkgs.pkgs</code> is set.

     

       155
       196
        
             '';

+1 -1

nixos/modules/services/misc/dysnomia.nix

···

       158
       158
        
       

     

       159
       159
        
           services.dysnomia.properties = {

     

       160
       160
        
             hostname = config.networking.hostName;

     

       161
       161
       -
             system = if config.nixpkgs.system == "" then builtins.currentSystem else config.nixpkgs.system;

     

       161
       161
       +
             inherit (config.nixpkgs.localSystem) system;

     

       162
       162
        
       

     

       163
       163
        
             supportedTypes = (import "${pkgs.stdenv.mkDerivation {

     

       164
       164
        
               name = "supportedtypes";

+1 -1

nixos/modules/services/misc/nixos-manual.nix

···

       23
       23
        
           options =

     

       24
       24
        
             let

     

       25
       25
        
               scrubbedEval = evalModules {

     

       26
       26
       -
                 modules = [ { nixpkgs.system = config.nixpkgs.system; } ] ++ baseModules;

     

       26
       26
       +
                 modules = [ { nixpkgs.localSystem = config.nixpkgs.localSystem; } ] ++ baseModules;

     

       27
       27
        
                 args = (config._module.args) // { modules = [ ]; };

     

       28
       28
        
                 specialArgs = { pkgs = scrubDerivations "pkgs" pkgs; };

     

       29
       29
        
               };

+2 -2

nixos/modules/virtualisation/containers.nix

···

       112
       112
        
       

     

       113
       113
        
             # If the host is 64-bit and the container is 32-bit, add a

     

       114
       114
        
             # --personality flag.

     

       115
       115
       -
             ${optionalString (config.nixpkgs.system == "x86_64-linux") ''

     

       115
       115
       +
             ${optionalString (config.nixpkgs.localSystem.system == "x86_64-linux") ''

     

       116
       116
        
               if [ "$(< ''${SYSTEM_PATH:-/nix/var/nix/profiles/per-container/$INSTANCE/system}/system)" = i686-linux ]; then

     

       117
       117
        
                 extraFlags+=" --personality=x86"

     

       118
       118
        
               fi

     
···

       255
       255
        
         };

     

       256
       256
        
       

     

       257
       257
        
       

     

       258
       258
       -
         system = config.nixpkgs.system;

     

       258
       258
       +
         system = config.nixpkgs.localSystem.system;

     

       259
       259
        
       

     

       260
       260
        
         bindMountOpts = { name, config, ... }: {

     

       261
       261

+1 -1

pkgs/stdenv/generic/check-meta.nix

···

       144
       144
        
           license = either (listOf lib.types.attrs) (either lib.types.attrs str);

     

       145
       145
        
           maintainers = listOf (attrsOf str);

     

       146
       146
        
           priority = int;

     

       147
       147
       -
           platforms = listOf (either str lib.systems.parsed.types.system);

     

       147
       147
       +
           platforms = listOf (either str lib.systems.parsedPlatform.types.system);

     

       148
       148
        
           hydraPlatforms = listOf str;

     

       149
       149
        
           broken = bool;

     

       150
       150