commit dd392d7c7694c762812f84b4d0a3ba8157ac8a73 · pyrox.dev/nixpkgs

-11

nixos/modules/services/hardware/udev.nix

···

       16
       16
        
         '';

     

       17
       17
        
       

     

       18
       18
        
       

     

       19
       19
       -
         # networkd link files are used early by udev to set up interfaces early.

     

       20
       20
       -
         # This must be done in stage 1 to avoid race conditions between udev and

     

       21
       21
       -
         # network daemons.

     

       22
       22
       -
         # TODO move this into the initrd-network module when it exists

     

       23
       23
       -
         initrdLinkUnits = pkgs.runCommand "initrd-link-units" {} ''

     

       24
       24
       -
           mkdir -p $out

     

       25
       25
       -
           ln -s ${udev}/lib/systemd/network/*.link $out/

     

       26
       26
       -
           ${lib.concatMapStringsSep "\n" (file: "ln -s ${file} $out/") (lib.mapAttrsToList (n: v: "${v.unit}/${n}") (lib.filterAttrs (n: _: hasSuffix ".link" n) config.systemd.network.units))}

     

       27
       27
       -
         '';

     

       28
       28
       -
       

     

       29
       19
        
         extraUdevRules = pkgs.writeTextFile {

     

       30
       20
        
           name = "extra-udev-rules";

     

       31
       21
        
           text = cfg.extraRules;

     
···

       398
       388
        
               systemd = config.boot.initrd.systemd.package;

     

       399
       389
        
               binPackages = config.boot.initrd.services.udev.binPackages ++ [ config.boot.initrd.systemd.contents."/bin".source ];

     

       400
       390
        
             };

     

       401
       401
       -
             "/etc/systemd/network".source = initrdLinkUnits;

     

       402
       391
        
           };

     

       403
       392
        
           # Insert initrd rules

     

       404
       393
        
           boot.initrd.services.udev.packages = [

+107 -25

nixos/modules/system/boot/networkd.nix

···

       6
       6
        
       

     

       7
       7
        
       let

     

       8
       8
        
       

     

       9
       9
       -
         cfg = config.systemd.network;

     

       10
       10
       -
       

     

       11
       9
        
         check = {

     

       12
       10
        
       

     

       13
       11
        
           global = {

     
···

       2941
       2939
        
               + def.extraConfig;

     

       2942
       2940
        
           };

     

       2943
       2941
        
       

     

       2944
       2944
       -
         unitFiles = listToAttrs (map (name: {

     

       2945
       2945
       -
           name = "systemd/network/${name}";

     

       2942
       2942
       +
         mkUnitFiles = prefix: cfg: listToAttrs (map (name: {

     

       2943
       2943
       +
           name = "${prefix}systemd/network/${name}";

     

       2946
       2944
        
           value.source = "${cfg.units.${name}.unit}/${name}";

     

       2947
       2945
        
         }) (attrNames cfg.units));

     

       2948
       2948
       -
       in

     

       2949
       2946
        
       

     

       2950
       2950
       -
       {

     

       2951
       2951
       -
         options = {

     

       2947
       2947
       +
         commonOptions = {

     

       2952
       2948
        
       

     

       2953
       2949
        
           systemd.network.enable = mkOption {

     

       2954
       2950
        
             default = false;

     
···

       3051
       3047
        
       

     

       3052
       3048
        
         };

     

       3053
       3049
        
       

     

       3054
       3054
       -
         config = mkMerge [

     

       3050
       3050
       +
         commonConfig = config: let cfg = config.systemd.network; in mkMerge [

     

       3055
       3051
        
       

     

       3056
       3052
        
           # .link units are honored by udev, no matter if systemd-networkd is enabled or not.

     

       3057
       3053
        
           {

     

       3058
       3054
        
             systemd.network.units = mapAttrs' (n: v: nameValuePair "${n}.link" (linkToUnit n v)) cfg.links;

     

       3059
       3059
       -
             environment.etc = unitFiles;

     

       3060
       3055
        
       

     

       3061
       3056
        
             systemd.network.wait-online.extraArgs =

     

       3062
       3057
        
               [ "--timeout=${toString cfg.wait-online.timeout}" ]

     
···

       3066
       3061
        
       

     

       3067
       3062
        
           (mkIf config.systemd.network.enable {

     

       3068
       3063
        
       

     

       3069
       3069
       -
             users.users.systemd-network.group = "systemd-network";

     

       3070
       3070
       -
       

     

       3071
       3071
       -
             systemd.additionalUpstreamSystemUnits = [

     

       3072
       3072
       -
               "systemd-networkd-wait-online.service"

     

       3073
       3073
       -
               "systemd-networkd.service"

     

       3074
       3074
       -
               "systemd-networkd.socket"

     

       3075
       3075
       -
             ];

     

       3076
       3076
       -
       

     

       3077
       3064
        
             systemd.network.units = mapAttrs' (n: v: nameValuePair "${n}.netdev" (netdevToUnit n v)) cfg.netdevs

     

       3078
       3065
        
               // mapAttrs' (n: v: nameValuePair "${n}.network" (networkToUnit n v)) cfg.networks;

     

       3079
       3066
        
       

     
···

       3082
       3069
        
             # networkd.

     

       3083
       3070
        
             systemd.sockets.systemd-networkd.wantedBy = [ "sockets.target" ];

     

       3084
       3071
        
       

     

       3085
       3085
       -
             systemd.services.systemd-networkd = {

     

       3086
       3086
       -
               wantedBy = [ "multi-user.target" ];

     

       3087
       3087
       -
               aliases = [ "dbus-org.freedesktop.network1.service" ];

     

       3088
       3088
       -
               restartTriggers = map (x: x.source) (attrValues unitFiles) ++ [

     

       3089
       3089
       -
                 config.environment.etc."systemd/networkd.conf".source

     

       3090
       3090
       -
               ];

     

       3091
       3091
       -
             };

     

       3092
       3092
       -
       

     

       3093
       3072
        
             systemd.services.systemd-networkd-wait-online = {

     

       3094
       3073
        
               inherit (cfg.wait-online) enable;

     

       3095
       3074
        
               wantedBy = [ "network-online.target" ];

     
···

       3111
       3090
        
               };

     

       3112
       3091
        
             };

     

       3113
       3092
        
       

     

       3093
       3093
       +
           })

     

       3094
       3094
       +
         ];

     

       3095
       3095
       +
       

     

       3096
       3096
       +
         stage2Config = let

     

       3097
       3097
       +
           cfg = config.systemd.network;

     

       3098
       3098
       +
           unitFiles = mkUnitFiles "" cfg;

     

       3099
       3099
       +
         in mkMerge [

     

       3100
       3100
       +
           (commonConfig config)

     

       3101
       3101
       +
       

     

       3102
       3102
       +
           { environment.etc = unitFiles; }

     

       3103
       3103
       +
       

     

       3104
       3104
       +
           (mkIf config.systemd.network.enable {

     

       3105
       3105
       +
       

     

       3106
       3106
       +
             users.users.systemd-network.group = "systemd-network";

     

       3107
       3107
       +
       

     

       3108
       3108
       +
             systemd.additionalUpstreamSystemUnits = [

     

       3109
       3109
       +
               "systemd-networkd-wait-online.service"

     

       3110
       3110
       +
               "systemd-networkd.service"

     

       3111
       3111
       +
               "systemd-networkd.socket"

     

       3112
       3112
       +
             ];

     

       3113
       3113
       +
       

     

       3114
       3114
        
             environment.etc."systemd/networkd.conf" = renderConfig cfg.config;

     

       3115
       3115
        
       

     

       3116
       3116
       +
             systemd.services.systemd-networkd = {

     

       3117
       3117
       +
               wantedBy = [ "multi-user.target" ];

     

       3118
       3118
       +
               restartTriggers = map (x: x.source) (attrValues unitFiles) ++ [

     

       3119
       3119
       +
                 config.environment.etc."systemd/networkd.conf".source

     

       3120
       3120
       +
               ];

     

       3121
       3121
       +
               aliases = [ "dbus-org.freedesktop.network1.service" ];

     

       3122
       3122
       +
             };

     

       3123
       3123
       +
       

     

       3116
       3124
        
             networking.iproute2 = mkIf (cfg.config.addRouteTablesToIPRoute2 && cfg.config.routeTables != { }) {

     

       3117
       3125
        
               enable = mkDefault true;

     

       3118
       3126
        
               rttablesExtraConfig = ''

     
···

       3123
       3131
        
             };

     

       3124
       3132
        
       

     

       3125
       3133
        
             services.resolved.enable = mkDefault true;

     

       3134
       3134
       +
       

     

       3135
       3135
       +
           })

     

       3136
       3136
       +
         ];

     

       3137
       3137
       +
       

     

       3138
       3138
       +
         stage1Config = let

     

       3139
       3139
       +
           cfg = config.boot.initrd.systemd.network;

     

       3140
       3140
       +
         in mkMerge [

     

       3141
       3141
       +
           (commonConfig config.boot.initrd)

     

       3142
       3142
       +
       

     

       3143
       3143
       +
           {

     

       3144
       3144
       +
             systemd.network.enable = mkDefault config.boot.initrd.network.enable;

     

       3145
       3145
       +
             systemd.contents = mkUnitFiles "/etc/" cfg;

     

       3146
       3146
       +
       

     

       3147
       3147
       +
             # Networkd link files are used early by udev to set up interfaces early.

     

       3148
       3148
       +
             # This must be done in stage 1 to avoid race conditions between udev and

     

       3149
       3149
       +
             # network daemons.

     

       3150
       3150
       +
             systemd.network.units = lib.filterAttrs (n: _: hasSuffix ".link" n) config.systemd.network.units;

     

       3151
       3151
       +
             systemd.storePaths = ["${config.boot.initrd.systemd.package}/lib/systemd/network/99-default.link"];

     

       3152
       3152
       +
           }

     

       3153
       3153
       +
       

     

       3154
       3154
       +
           (mkIf cfg.enable {

     

       3155
       3155
       +
       

     

       3156
       3156
       +
             systemd.package = pkgs.systemdStage1Network;

     

       3157
       3157
       +
       

     

       3158
       3158
       +
             systemd.additionalUpstreamUnits = [

     

       3159
       3159
       +
               "systemd-networkd-wait-online.service"

     

       3160
       3160
       +
               "systemd-networkd.service"

     

       3161
       3161
       +
               "systemd-networkd.socket"

     

       3162
       3162
       +
               "systemd-network-generator.service"

     

       3163
       3163
       +
               "network-online.target"

     

       3164
       3164
       +
               "network-pre.target"

     

       3165
       3165
       +
               "network.target"

     

       3166
       3166
       +
               "nss-lookup.target"

     

       3167
       3167
       +
               "nss-user-lookup.target"

     

       3168
       3168
       +
               "remote-fs-pre.target"

     

       3169
       3169
       +
               "remote-fs.target"

     

       3170
       3170
       +
             ];

     

       3171
       3171
       +
             systemd.users.systemd-network = {};

     

       3172
       3172
       +
             systemd.groups.systemd-network = {};

     

       3173
       3173
       +
       

     

       3174
       3174
       +
             systemd.contents."/etc/systemd/networkd.conf" = renderConfig cfg.config;

     

       3175
       3175
       +
       

     

       3176
       3176
       +
             systemd.services.systemd-networkd.wantedBy = [ "initrd.target" ];

     

       3177
       3177
       +
             systemd.services.systemd-network-generator.wantedBy = [ "sysinit.target" ];

     

       3178
       3178
       +
       

     

       3179
       3179
       +
             systemd.storePaths = [

     

       3180
       3180
       +
               "${config.boot.initrd.systemd.package}/lib/systemd/systemd-networkd"

     

       3181
       3181
       +
               "${config.boot.initrd.systemd.package}/lib/systemd/systemd-networkd-wait-online"

     

       3182
       3182
       +
               "${config.boot.initrd.systemd.package}/lib/systemd/systemd-network-generator"

     

       3183
       3183
       +
             ];

     

       3184
       3184
       +
             kernelModules = [ "af_packet" ];

     

       3185
       3185
       +
       

     

       3186
       3186
       +
           })

     

       3187
       3187
       +
         ];

     

       3188
       3188
       +
       

     

       3189
       3189
       +
       in

     

       3190
       3190
       +
       

     

       3191
       3191
       +
       {

     

       3192
       3192
       +
         options = commonOptions // {

     

       3193
       3193
       +
           boot.initrd = commonOptions;

     

       3194
       3194
       +
         };

     

       3195
       3195
       +
       

     

       3196
       3196
       +
         config = mkMerge [

     

       3197
       3197
       +
           stage2Config

     

       3198
       3198
       +
           (mkIf config.boot.initrd.systemd.enable {

     

       3199
       3199
       +
             assertions = [{

     

       3200
       3200
       +
               assertion = config.boot.initrd.network.udhcpc.extraArgs == [];

     

       3201
       3201
       +
               message = ''

     

       3202
       3202
       +
                 boot.initrd.network.udhcpc.extraArgs is not supported when

     

       3203
       3203
       +
                 boot.initrd.systemd.enable is enabled

     

       3204
       3204
       +
               '';

     

       3205
       3205
       +
             }];

     

       3206
       3206
       +
       

     

       3207
       3207
       +
             boot.initrd = stage1Config;

     

       3126
       3208
        
           })

     

       3127
       3209
        
         ];

     

       3128
       3210
        
       }

-9

nixos/modules/system/boot/systemd/initrd.nix

···

       72
       72
        
           "systemd-tmpfiles-setup.service"

     

       73
       73
        
           "timers.target"

     

       74
       74
        
           "umount.target"

     

       75
       75
       -
       

     

       76
       76
       -
           # TODO: Networking

     

       77
       77
       -
           # "network-online.target"

     

       78
       78
       -
           # "network-pre.target"

     

       79
       79
       -
           # "network.target"

     

       80
       80
       -
           # "nss-lookup.target"

     

       81
       81
       -
           # "nss-user-lookup.target"

     

       82
       82
       -
           # "remote-fs-pre.target"

     

       83
       83
       -
           # "remote-fs.target"

     

       84
       75
        
         ] ++ cfg.additionalUpstreamUnits;

     

       85
       76
        
       

     

       86
       77
        
         upstreamWants = [

nixos/tests/all-tests.nix

···

       677
       677
        
         systemd-initrd-simple = handleTest ./systemd-initrd-simple.nix {};

     

       678
       678
        
         systemd-initrd-swraid = handleTest ./systemd-initrd-swraid.nix {};

     

       679
       679
        
         systemd-initrd-vconsole = handleTest ./systemd-initrd-vconsole.nix {};

     

       680
       680
       +
         systemd-initrd-networkd = handleTest ./systemd-initrd-networkd.nix {};

     

       680
       681
        
         systemd-journal = handleTest ./systemd-journal.nix {};

     

       681
       682
        
         systemd-machinectl = handleTest ./systemd-machinectl.nix {};

     

       682
       683
        
         systemd-networkd = handleTest ./systemd-networkd.nix {};

+31 -8

nixos/tests/predictable-interface-names.nix

···

       8
       8
        
         testCombinations = pkgs.lib.cartesianProductOfSets {

     

       9
       9
        
           predictable = [true false];

     

       10
       10
        
           withNetworkd = [true false];

     

       11
       11
       +
           systemdStage1 = [true false];

     

       11
       12
        
         };

     

       12
       12
       -
       in pkgs.lib.listToAttrs (builtins.map ({ predictable, withNetworkd }: {

     

       13
       13
       +
       in pkgs.lib.listToAttrs (builtins.map ({ predictable, withNetworkd, systemdStage1 }: {

     

       13
       14
        
         name = pkgs.lib.optionalString (!predictable) "un" + "predictable"

     

       14
       14
       -
              + pkgs.lib.optionalString withNetworkd "Networkd";

     

       15
       15
       +
              + pkgs.lib.optionalString withNetworkd "Networkd"

     

       16
       16
       +
              + pkgs.lib.optionalString systemdStage1 "SystemdStage1";

     

       15
       17
        
         value = makeTest {

     

       16
       16
       -
           name = "${pkgs.lib.optionalString (!predictable) "un"}predictableInterfaceNames${pkgs.lib.optionalString withNetworkd "-with-networkd"}";

     

       18
       18
       +
           name = pkgs.lib.optionalString (!predictable) "un" + "predictableInterfaceNames"

     

       19
       19
       +
                + pkgs.lib.optionalString withNetworkd "-with-networkd"

     

       20
       20
       +
                + pkgs.lib.optionalString systemdStage1 "-systemd-stage-1";

     

       17
       21
        
           meta = {};

     

       18
       22
        
       

     

       19
       19
       -
           nodes.machine = { lib, ... }: {

     

       23
       23
       +
           nodes.machine = { lib, ... }: let

     

       24
       24
       +
             script = ''

     

       25
       25
       +
               ip link

     

       26
       26
       +
               if ${lib.optionalString predictable "!"} ip link show eth0; then

     

       27
       27
       +
                 echo Success

     

       28
       28
       +
               else

     

       29
       29
       +
                 exit 1

     

       30
       30
       +
               fi

     

       31
       31
       +
             '';

     

       32
       32
       +
           in {

     

       20
       33
        
             networking.usePredictableInterfaceNames = lib.mkForce predictable;

     

       21
       34
        
             networking.useNetworkd = withNetworkd;

     

       22
       35
        
             networking.dhcpcd.enable = !withNetworkd;

     

       23
       36
        
             networking.useDHCP = !withNetworkd;

     

       24
       37
        
       

     

       25
       38
        
             # Check if predictable interface names are working in stage-1

     

       26
       26
       -
             boot.initrd.postDeviceCommands = ''

     

       27
       27
       -
               ip link

     

       28
       28
       -
               ip link show eth0 ${if predictable then "&&" else "||"} exit 1

     

       29
       29
       -
             '';

     

       39
       39
       +
             boot.initrd.postDeviceCommands = script;

     

       40
       40
       +
       

     

       41
       41
       +
             boot.initrd.systemd = lib.mkIf systemdStage1 {

     

       42
       42
       +
               enable = true;

     

       43
       43
       +
               initrdBin = [ pkgs.iproute2 ];

     

       44
       44
       +
               services.systemd-udev-settle.wantedBy = ["initrd.target"];

     

       45
       45
       +
               services.check-interfaces = {

     

       46
       46
       +
                 requiredBy = ["initrd.target"];

     

       47
       47
       +
                 after = ["systemd-udev-settle.service"];

     

       48
       48
       +
                 serviceConfig.Type = "oneshot";

     

       49
       49
       +
                 path = [ pkgs.iproute2 ];

     

       50
       50
       +
                 inherit script;

     

       51
       51
       +
               };

     

       52
       52
       +
             };

     

       30
       53
        
           };

     

       31
       54
        
       

     

       32
       55
        
           testScript = ''

+45

nixos/tests/systemd-initrd-networkd.nix

···

       1
       1
       +
       import ./make-test-python.nix ({ pkgs, lib, ... }: {

     

       2
       2
       +
         name = "systemd-initrd-network";

     

       3
       3
       +
         meta.maintainers = [ lib.maintainers.elvishjerricco ];

     

       4
       4
       +
       

     

       5
       5
       +
         nodes = {

     

       6
       6
       +
           basic = { ... }: {

     

       7
       7
       +
             boot.initrd.network.enable = true;

     

       8
       8
       +
       

     

       9
       9
       +
             boot.initrd.systemd = {

     

       10
       10
       +
               enable = true;

     

       11
       11
       +
               network.networks."99-eth0" = {

     

       12
       12
       +
                 matchConfig.Name = "eth0";

     

       13
       13
       +
                 DHCP = "yes";

     

       14
       14
       +
               };

     

       15
       15
       +
               network.wait-online.timeout = 10;

     

       16
       16
       +
               # Drop the boot into emergency mode if we timeout

     

       17
       17
       +
               targets.network-online.requiredBy = [ "initrd.target" ];

     

       18
       18
       +
               services.systemd-networkd-wait-online.requiredBy =

     

       19
       19
       +
                 [ "network-online.target" ];

     

       20
       20
       +
       

     

       21
       21
       +
                 initrdBin = [ pkgs.iproute2 pkgs.iputils pkgs.gnugrep ];

     

       22
       22
       +
                 services.check = {

     

       23
       23
       +
                   requiredBy = [ "initrd.target" ];

     

       24
       24
       +
                   before = [ "initrd.target" ];

     

       25
       25
       +
                   after = [ "network-online.target" ];

     

       26
       26
       +
                   serviceConfig.Type = "oneshot";

     

       27
       27
       +
                   path = [ pkgs.iproute2 pkgs.iputils pkgs.gnugrep ];

     

       28
       28
       +
                   script = ''

     

       29
       29
       +
                     ip addr | grep 10.0.2.15 || exit 1

     

       30
       30
       +
                     ping -c1 10.0.2.2 || exit 1

     

       31
       31
       +
                   '';

     

       32
       32
       +
                 };

     

       33
       33
       +
             };

     

       34
       34
       +
           };

     

       35
       35
       +
         };

     

       36
       36
       +
       

     

       37
       37
       +
         testScript = ''

     

       38
       38
       +
           start_all()

     

       39
       39
       +
           basic.wait_for_unit("multi-user.target")

     

       40
       40
       +
           # Make sure the systemd-network user was set correctly in initrd

     

       41
       41
       +
           basic.succeed("[ $(stat -c '%U,%G' /run/systemd/netif/links) = systemd-network,systemd-network ]")

     

       42
       42
       +
           basic.succeed("ip addr show >&2")

     

       43
       43
       +
           basic.succeed("ip route show >&2")

     

       44
       44
       +
         '';

     

       45
       45
       +
       })