commit 65d26c4dc12f8f0113b6b128573f18492ac5b6f6 · pyrox.dev/nixpkgs

+5

nixos/lib/utils.nix

···

       2
       2
        
       

     

       3
       3
        
       rec {

     

       4
       4
        
       

     

       5
       5
       +
         # Check whenever `b` depends on `a` as a fileSystem

     

       6
       6
       +
         # FIXME: it's incorrect to simply use hasPrefix here: "/dev/a" is not a parent of "/dev/ab"

     

       7
       7
       +
         fsBefore = a: b: ((any (x: elem x [ "bind" "move" ]) b.options) && (a.mountPoint == b.device))

     

       8
       8
       +
                       || (hasPrefix a.mountPoint b.mountPoint);

     

       9
       9
       +
       

     

       5
       10
        
         # Escape a path according to the systemd rules, e.g. /dev/xyzzy

     

       6
       11
        
         # becomes dev-xyzzy.  FIXME: slow.

     

       7
       12
        
         escapeSystemdPath = s:

+1 -1

nixos/modules/security/grsecurity.nix

···

       12
       12
        
           (fs: (fs.neededForBoot

     

       13
       13
        
                 || elem fs.mountPoint [ "/" "/nix" "/nix/store" "/var" "/var/log" "/var/lib" "/etc" ])

     

       14
       14
        
                 && fs.fsType == "zfs")

     

       15
       15
       -
           (attrValues config.fileSystems) != [];

     

       15
       15
       +
           config.system.build.fileSystems != [];

     

       16
       16
        
       

     

       17
       17
        
         # Ascertain whether NixOS container support is required

     

       18
       18
        
         containerSupportRequired =

+11 -12

nixos/modules/system/boot/stage-1.nix

···

       3
       3
        
       # the modules necessary to mount the root file system, then calls the

     

       4
       4
        
       # init in the root file system to start the second boot stage.

     

       5
       5
        
       

     

       6
       6
       -
       { config, lib, pkgs, ... }:

     

       6
       6
       +
       { config, lib, utils, pkgs, ... }:

     

       7
       7
        
       

     

       8
       8
        
       with lib;

     

       9
       9
        
       

     
···

       21
       21
        
           kernel = modulesTree;

     

       22
       22
        
           allowMissing = true;

     

       23
       23
        
         };

     

       24
       24
       +
       

     

       25
       25
       +
       

     

       26
       26
       +
         # The initrd only has to mount `/` or any FS marked as necessary for

     

       27
       27
       +
         # booting (such as the FS containing `/nix/store`, or an FS needed for

     

       28
       28
       +
         # mounting `/`, like `/` on a loopback).

     

       29
       29
       +
         fileSystems = filter

     

       30
       30
       +
           (fs: fs.neededForBoot || elem fs.mountPoint [ "/" "/nix" "/nix/store" "/var" "/var/log" "/var/lib" "/etc" ])

     

       31
       31
       +
           config.system.build.fileSystems;

     

       24
       32
        
       

     

       25
       33
        
       

     

       26
       34
        
         # Some additional utilities needed in stage 1, like mount, lvm, fsck

     
···

       71
       79
        
             ln -sf kmod $out/bin/modprobe

     

       72
       80
        
       

     

       73
       81
        
             # Copy resize2fs if needed.

     

       74
       74
       -
             ${optionalString (any (fs: fs.autoResize) (attrValues config.fileSystems)) ''

     

       82
       82
       +
             ${optionalString (any (fs: fs.autoResize) config.system.build.fileSystems) ''

     

       75
       83
        
               # We need mke2fs in the initrd.

     

       76
       84
        
               copy_bin_and_libs ${pkgs.e2fsprogs}/sbin/resize2fs

     

       77
       85
        
             ''}

     
···

       126
       134
        
       

     

       127
       135
        
             ${config.boot.initrd.extraUtilsCommandsTest}

     

       128
       136
        
           ''; # */

     

       129
       129
       -
       

     

       130
       130
       -
       

     

       131
       131
       -
         # The initrd only has to mount / or any FS marked as necessary for

     

       132
       132
       -
         # booting (such as the FS containing /nix/store, or an FS needed for

     

       133
       133
       -
         # mounting /, like / on a loopback).

     

       134
       134
       -
         fileSystems = filter

     

       135
       135
       -
           (fs: fs.neededForBoot || elem fs.mountPoint [ "/" "/nix" "/nix/store" "/var" "/var/log" "/var/lib" "/etc" ])

     

       136
       136
       -
           (attrValues config.fileSystems);

     

       137
       137
        
       

     

       138
       138
        
       

     

       139
       139
        
         udevRules = pkgs.stdenv.mkDerivation {

     
···

       398
       398
        
         };

     

       399
       399
        
       

     

       400
       400
        
         config = mkIf (!config.boot.isContainer) {

     

       401
       401
       -
       

     

       402
       401
        
           assertions = [

     

       403
       403
       -
             { assertion = any (fs: fs.mountPoint == "/") (attrValues config.fileSystems);

     

       402
       402
       +
             { assertion = any (fs: fs.mountPoint == "/") fileSystems;

     

       404
       403
        
               message = "The ‘fileSystems’ option does not specify your root file system.";

     

       405
       404
        
             }

     

       406
       405
        
             { assertion = let inherit (config.boot) resumeDevice; in

+1 -1

nixos/modules/tasks/encrypted-devices.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         fileSystems = attrValues config.fileSystems ++ config.swapDevices;

     

       6
       6
       +
         fileSystems = config.system.build.fileSystems ++ config.swapDevices;

     

       7
       7
        
         encDevs = filter (dev: dev.encrypted.enable) fileSystems;

     

       8
       8
        
         keyedEncDevs = filter (dev: dev.encrypted.keyFile != null) encDevs;

     

       9
       9
        
         keylessEncDevs = filter (dev: dev.encrypted.keyFile == null) encDevs;

+23 -3

nixos/modules/tasks/filesystems.nix

···

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
       

     

       8
       8
       -
         fileSystems = attrValues config.fileSystems;

     

       8
       8
       +
         fileSystems' = toposort fsBefore (attrValues config.fileSystems);

     

       9
       9
       +
       

     

       10
       10
       +
         fileSystems = if fileSystems' ? "result"

     

       11
       11
       +
                       then # use topologically sorted fileSystems everywhere

     

       12
       12
       +
                            fileSystems'.result

     

       13
       13
       +
                       else # the assertion below will catch this,

     

       14
       14
       +
                            # but we fall back to the original order

     

       15
       15
       +
                            # anyway so that other modules could check

     

       16
       16
       +
                            # their assertions too

     

       17
       17
       +
                            (attrValues config.fileSystems);

     

       9
       18
        
       

     

       10
       19
        
         prioOption = prio: optionalString (prio != null) " pri=${toString prio}";

     

       11
       20
        
       

     
···

       162
       171
        
       

     

       163
       172
        
         config = {

     

       164
       173
        
       

     

       174
       174
       +
           assertions = let

     

       175
       175
       +
             ls = sep: concatMapStringsSep sep (x: x.mountPoint);

     

       176
       176
       +
           in [

     

       177
       177
       +
             { assertion = ! (fileSystems' ? "cycle");

     

       178
       178
       +
               message = "The ‘fileSystems’ option can't be topologically sorted: mountpoint dependency path ${ls " -> " fileSystems'.cycle} loops to ${ls ", " fileSystems'.loops}";

     

       179
       179
       +
             }

     

       180
       180
       +
           ];

     

       181
       181
       +
       

     

       182
       182
       +
           # Export for use in other modules

     

       183
       183
       +
           system.build.fileSystems = fileSystems;

     

       184
       184
       +
       

     

       165
       185
        
           boot.supportedFilesystems = map (fs: fs.fsType) fileSystems;

     

       166
       186
        
       

     

       167
       187
        
           # Add the mount helpers to the system path so that `mount' can find them.

     
···

       177
       197
        
               # This is a generated file.  Do not edit!

     

       178
       198
        
       

     

       179
       199
        
               # Filesystems.

     

       180
       180
       -
               ${flip concatMapStrings fileSystems (fs:

     

       200
       200
       +
               ${concatMapStrings (fs:

     

       181
       201
        
                   (if fs.device != null then fs.device

     

       182
       202
        
                    else if fs.label != null then "/dev/disk/by-label/${fs.label}"

     

       183
       203
        
                    else throw "No device specified for mount point ‘${fs.mountPoint}’.")

     
···

       188
       208
        
                   + " " + (if skipCheck fs then "0" else

     

       189
       209
        
                            if fs.mountPoint == "/" then "1" else "2")

     

       190
       210
        
                   + "\n"

     

       191
       191
       -
               )}

     

       211
       211
       +
               ) fileSystems}

     

       192
       212
        
       

     

       193
       213
        
               # Swap devices.

     

       194
       214
        
               ${flip concatMapStrings config.swapDevices (sw:

+2 -2

nixos/modules/tasks/filesystems/zfs.nix

···

       36
       36
        
       

     

       37
       37
        
         fsToPool = fs: datasetToPool fs.device;

     

       38
       38
        
       

     

       39
       39
       -
         zfsFilesystems = filter (x: x.fsType == "zfs") (attrValues config.fileSystems);

     

       39
       39
       +
         zfsFilesystems = filter (x: x.fsType == "zfs") config.system.build.fileSystems;

     

       40
       40
        
       

     

       41
       41
        
         isRoot = fs: fs.neededForBoot || elem fs.mountPoint [ "/" "/nix" "/nix/store" "/var" "/var/log" "/var/lib" "/etc" ];

     

       42
       42
        
       

     
···

       277
       277
        
       

     

       278
       278
        
             systemd.services = let

     

       279
       279
        
               getPoolFilesystems = pool:

     

       280
       280
       -
                 filter (x: x.fsType == "zfs" && (fsToPool x) == pool) (attrValues config.fileSystems);

     

       280
       280
       +
                 filter (x: x.fsType == "zfs" && (fsToPool x) == pool) config.system.build.fileSystems;

     

       281
       281
        
       

     

       282
       282
        
               getPoolMounts = pool:

     

       283
       283
        
                 let