commit 65cc198539f7c78f13c6003339ed2928ce0ac6f0 · pyrox.dev/nixpkgs

+100 -22

nixos/modules/services/hardware/udev.nix

···

       29
       29
        
         '';

     

       30
       30
        
       

     

       31
       31
        
         # Perform substitutions in all udev rules files.

     

       32
       32
       -
         udevRules = pkgs.runCommand "udev-rules"

     

       32
       32
       +
         udevRulesFor = { name, udevPackages, udevPath, udev, systemd, binPackages, initrdBin ? null }: pkgs.runCommand name

     

       33
       33
        
           { preferLocalBuild = true;

     

       34
       34
        
             allowSubstitutes = false;

     

       35
       35
       -
             packages = unique (map toString cfg.packages);

     

       35
       35
       +
             packages = unique (map toString udevPackages);

     

       36
       36
        
           }

     

       37
       37
        
           ''

     

       38
       38
        
             mkdir -p $out

     
···

       60
       60
        
                 --replace \"/bin/mount \"${pkgs.util-linux}/bin/mount \

     

       61
       61
        
                 --replace /usr/bin/readlink ${pkgs.coreutils}/bin/readlink \

     

       62
       62
        
                 --replace /usr/bin/basename ${pkgs.coreutils}/bin/basename

     

       63
       63
       +
             ${optionalString (initrdBin != null) ''

     

       64
       64
       +
               substituteInPlace $i --replace '/run/current-system/systemd' "${removeSuffix "/bin" initrdBin}"

     

       65
       65
       +
             ''}

     

       63
       66
        
             done

     

       64
       67
        
       

     

       65
       68
        
             echo -n "Checking that all programs called by relative paths in udev rules exist in ${udev}/lib/udev... "

     
···

       84
       87
        
             for i in $import_progs $run_progs; do

     

       85
       88
        
               # if the path refers to /run/current-system/systemd, replace with config.systemd.package

     

       86
       89
        
               if [[ $i == /run/current-system/systemd* ]]; then

     

       87
       87
       -
                 i="${config.systemd.package}/''${i#/run/current-system/systemd/}"

     

       90
       90
       +
                 i="${systemd}/''${i#/run/current-system/systemd/}"

     

       88
       91
        
               fi

     

       92
       92
       +
       

     

       89
       93
        
               if [[ ! -x $i ]]; then

     

       90
       94
        
                 echo "FAIL"

     

       91
       95
        
                 echo "$i is called in udev rules but is not executable or does not exist"

     
···

       102
       106
        
               echo "Consider fixing the following udev rules:"

     

       103
       107
        
               echo "$filesToFixup" | while read localFile; do

     

       104
       108
        
                 remoteFile="origin unknown"

     

       105
       105
       -
                 for i in ${toString cfg.packages}; do

     

       109
       109
       +
                 for i in ${toString binPackages}; do

     

       106
       110
        
                   for j in "$i"/*/udev/rules.d/*; do

     

       107
       111
        
                     [ -e "$out/$(basename "$j")" ] || continue

     

       108
       112
        
                     [ "$(basename "$j")" = "$(basename "$localFile")" ] || continue

     
···

       125
       129
        
             ${optionalString (!config.boot.hardwareScan) ''

     

       126
       130
        
               ln -s /dev/null $out/80-drivers.rules

     

       127
       131
        
             ''}

     

       128
       128
       -
           ''; # */

     

       132
       132
       +
           '';

     

       129
       133
        
       

     

       130
       134
        
         hwdbBin = pkgs.runCommand "hwdb.bin"

     

       131
       135
        
           { preferLocalBuild = true;

     
···

       201
       205
        
               '';

     

       202
       206
        
             };

     

       203
       207
        
       

     

       204
       204
       -
             initrdRules = mkOption {

     

       205
       205
       -
               default = "";

     

       206
       206
       -
               example = ''

     

       207
       207
       -
                 SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:1D:60:B9:6D:4F", KERNEL=="eth*", NAME="my_fast_network_card"

     

       208
       208
       -
               '';

     

       209
       209
       -
               type = types.lines;

     

       210
       210
       -
               description = ''

     

       211
       211
       -
                 <command>udev</command> rules to include in the initrd

     

       212
       212
       -
                 <emphasis>only</emphasis>. They'll be written into file

     

       213
       213
       -
                 <filename>99-local.rules</filename>. Thus they are read and applied

     

       214
       214
       -
                 after the essential initrd rules.

     

       215
       215
       -
               '';

     

       216
       216
       -
             };

     

       217
       217
       -
       

     

       218
       208
        
             extraRules = mkOption {

     

       219
       209
        
               default = "";

     

       220
       210
        
               example = ''

     
···

       282
       272
        
             '';

     

       283
       273
        
           };

     

       284
       274
        
       

     

       275
       275
       +
           boot.initrd.services.udev = {

     

       276
       276
       +
       

     

       277
       277
       +
             packages = mkOption {

     

       278
       278
       +
               type = types.listOf types.path;

     

       279
       279
       +
               default = [];

     

       280
       280
       +
               visible = false;

     

       281
       281
       +
               description = ''

     

       282
       282
       +
                 <emphasis>This will only be used when systemd is used in stage 1.</emphasis>

     

       283
       283
       +
       

     

       284
       284
       +
                 List of packages containing <command>udev</command> rules that will be copied to stage 1.

     

       285
       285
       +
                 All files found in

     

       286
       286
       +
                 <filename><replaceable>pkg</replaceable>/etc/udev/rules.d</filename> and

     

       287
       287
       +
                 <filename><replaceable>pkg</replaceable>/lib/udev/rules.d</filename>

     

       288
       288
       +
                 will be included.

     

       289
       289
       +
               '';

     

       290
       290
       +
             };

     

       291
       291
       +
       

     

       292
       292
       +
             binPackages = mkOption {

     

       293
       293
       +
               type = types.listOf types.path;

     

       294
       294
       +
               default = [];

     

       295
       295
       +
               visible = false;

     

       296
       296
       +
               description = ''

     

       297
       297
       +
                 <emphasis>This will only be used when systemd is used in stage 1.</emphasis>

     

       298
       298
       +
       

     

       299
       299
       +
                 Packages to search for binaries that are referenced by the udev rules in stage 1.

     

       300
       300
       +
                 This list always contains /bin of the initrd.

     

       301
       301
       +
               '';

     

       302
       302
       +
               apply = map getBin;

     

       303
       303
       +
             };

     

       304
       304
       +
       

     

       305
       305
       +
             rules = mkOption {

     

       306
       306
       +
               default = "";

     

       307
       307
       +
               example = ''

     

       308
       308
       +
                 SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:1D:60:B9:6D:4F", KERNEL=="eth*", NAME="my_fast_network_card"

     

       309
       309
       +
               '';

     

       310
       310
       +
               type = types.lines;

     

       311
       311
       +
               description = ''

     

       312
       312
       +
                 <command>udev</command> rules to include in the initrd

     

       313
       313
       +
                 <emphasis>only</emphasis>. They'll be written into file

     

       314
       314
       +
                 <filename>99-local.rules</filename>. Thus they are read and applied

     

       315
       315
       +
                 after the essential initrd rules.

     

       316
       316
       +
               '';

     

       317
       317
       +
             };

     

       318
       318
       +
       

     

       319
       319
       +
           };

     

       320
       320
       +
       

     

       285
       321
        
         };

     

       286
       322
        
       

     

       287
       323
        
       

     
···

       297
       333
        
       

     

       298
       334
        
           boot.kernelParams = mkIf (!config.networking.usePredictableInterfaceNames) [ "net.ifnames=0" ];

     

       299
       335
        
       

     

       300
       300
       -
           boot.initrd.extraUdevRulesCommands = optionalString (cfg.initrdRules != "")

     

       336
       336
       +
           boot.initrd.extraUdevRulesCommands = optionalString (!config.boot.initrd.systemd.enable && config.boot.initrd.services.udev.rules != "")

     

       301
       337
        
             ''

     

       302
       338
        
               cat <<'EOF' > $out/99-local.rules

     

       303
       303
       -
               ${cfg.initrdRules}

     

       339
       339
       +
               ${config.boot.initrd.services.udev.rules}

     

       304
       340
        
               EOF

     

       305
       341
        
             '';

     

       306
       342
        
       

     

       343
       343
       +
           boot.initrd.systemd.additionalUpstreamUnits = [

     

       344
       344
       +
             # TODO: "initrd-udevadm-cleanup-db.service" is commented out because of https://github.com/systemd/systemd/issues/12953

     

       345
       345
       +
             "systemd-udevd-control.socket"

     

       346
       346
       +
             "systemd-udevd-kernel.socket"

     

       347
       347
       +
             "systemd-udevd.service"

     

       348
       348
       +
             "systemd-udev-settle.service"

     

       349
       349
       +
             "systemd-udev-trigger.service"

     

       350
       350
       +
           ];

     

       351
       351
       +
           boot.initrd.systemd.storePaths = [

     

       352
       352
       +
             "${config.boot.initrd.systemd.package}/lib/systemd/systemd-udevd"

     

       353
       353
       +
             "${config.boot.initrd.systemd.package}/lib/udev"

     

       354
       354
       +
           ] ++ map (x: "${x}/bin") config.boot.initrd.services.udev.binPackages;

     

       355
       355
       +
       

     

       356
       356
       +
           # Generate the udev rules for the initrd

     

       357
       357
       +
           boot.initrd.systemd.contents = {

     

       358
       358
       +
             "/etc/udev/rules.d".source = udevRulesFor {

     

       359
       359
       +
               name = "initrd-udev-rules";

     

       360
       360
       +
               initrdBin = config.boot.initrd.systemd.contents."/bin".source;

     

       361
       361
       +
               udevPackages = config.boot.initrd.services.udev.packages;

     

       362
       362
       +
               udevPath = config.boot.initrd.systemd.contents."/bin".source;

     

       363
       363
       +
               udev = config.boot.initrd.systemd.package;

     

       364
       364
       +
               systemd = config.boot.initrd.systemd.package;

     

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

     

       366
       366
       +
             };

     

       367
       367
       +
           };

     

       368
       368
       +
           # Insert custom rules

     

       369
       369
       +
           boot.initrd.services.udev.packages = mkIf (config.boot.initrd.services.udev.rules != "") (pkgs.writeTextFile {

     

       370
       370
       +
             name = "initrd-udev-rules";

     

       371
       371
       +
             destination = "/etc/udev/rules.d/99-local.rules";

     

       372
       372
       +
             text = config.boot.initrd.services.udev.rules;

     

       373
       373
       +
           });

     

       374
       374
       +
       

     

       307
       375
        
           environment.etc =

     

       308
       376
        
             {

     

       309
       309
       -
               "udev/rules.d".source = udevRules;

     

       377
       377
       +
               "udev/rules.d".source = udevRulesFor {

     

       378
       378
       +
                 name = "udev-rules";

     

       379
       379
       +
                 udevPackages = cfg.packages;

     

       380
       380
       +
                 systemd = config.systemd.package;

     

       381
       381
       +
                 binPackages = cfg.packages;

     

       382
       382
       +
                 inherit udevPath udev;

     

       383
       383
       +
               };

     

       310
       384
        
               "udev/hwdb.bin".source = hwdbBin;

     

       311
       385
        
             };

     

       312
       386
        
       

     
···

       337
       411
        
             };

     

       338
       412
        
       

     

       339
       413
        
         };

     

       414
       414
       +
       

     

       415
       415
       +
         imports = [

     

       416
       416
       +
           (mkRenamedOptionModule [ "services" "udev" "initrdRules" ] [ "boot" "initrd" "services" "udev" "rules" ])

     

       417
       417
       +
         ];

     

       340
       418
        
       }

+5 -9

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

···

       34
       34
        
           "initrd-switch-root.service"

     

       35
       35
        
           "initrd-switch-root.target"

     

       36
       36
        
           "initrd.target"

     

       37
       37
       -
           "initrd-udevadm-cleanup-db.service"

     

       38
       37
        
           "kexec.target"

     

       39
       38
        
           "kmod-static-nodes.service"

     

       40
       39
        
           "local-fs-pre.target"

     
···

       71
       70
        
           "systemd-sysctl.service"

     

       72
       71
        
           "systemd-tmpfiles-setup-dev.service"

     

       73
       72
        
           "systemd-tmpfiles-setup.service"

     

       74
       74
       -
           "systemd-udevd-control.socket"

     

       75
       75
       -
           "systemd-udevd-kernel.socket"

     

       76
       76
       -
           "systemd-udevd.service"

     

       77
       77
       -
           "systemd-udev-settle.service"

     

       78
       78
       -
           "systemd-udev-trigger.service"

     

       79
       79
       -
           "systemd-vconsole-setup.service"

     

       80
       73
        
           "timers.target"

     

       81
       74
        
           "umount.target"

     

       82
       75
        
       

     
···

       385
       378
        
       

     

       386
       379
        
               "/etc/sysctl.d/nixos.conf".text = "kernel.modprobe = /sbin/modprobe";

     

       387
       380
        
               "/etc/modprobe.d/systemd.conf".source = "${cfg.package}/lib/modprobe.d/systemd.conf";

     

       381
       381
       +
               "/etc/modprobe.d/ubuntu.conf".source = pkgs.runCommand "initrd-kmod-blacklist-ubuntu" { } ''

     

       382
       382
       +
                 ${pkgs.buildPackages.perl}/bin/perl -0pe 's/## file: iwlwifi.conf(.+?)##/##/s;' $src > $out

     

       383
       383
       +
               '';

     

       384
       384
       +
               "/etc/modprobe.d/debian.conf".source = pkgs.kmod-debian-aliases;

     

       385
       385
       +
       

     

       388
       386
        
             };

     

       389
       387
        
       

     

       390
       388
        
             storePaths = [

     
···

       400
       398
        
               "${cfg.package}/lib/systemd/systemd-shutdown"

     

       401
       399
        
               "${cfg.package}/lib/systemd/systemd-sulogin-shell"

     

       402
       400
        
               "${cfg.package}/lib/systemd/systemd-sysctl"

     

       403
       403
       -
               "${cfg.package}/lib/systemd/systemd-udevd"

     

       404
       401
        
               "${cfg.package}/lib/systemd/systemd-vconsole-setup"

     

       405
       402
        
       

     

       406
       403
        
               # additional systemd directories

     

       407
       404
        
               "${cfg.package}/lib/systemd/system-generators"

     

       408
       408
       -
               "${cfg.package}/lib/udev"

     

       409
       405
        
       

     

       410
       406
        
               # utilities needed by systemd

     

       411
       407
        
               "${cfg.package.util-linux}/bin/mount"

+1 -1

nixos/tests/networking.nix

···

       878
       878
        
                       linkConfig.Name = "custom_name";

     

       879
       879
        
                     };

     

       880
       880
        
                   }

     

       881
       881
       -
              else { services.udev.initrdRules = ''

     

       881
       881
       +
              else { boot.initrd.services.udev.rules = ''

     

       882
       882
        
                      SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="52:54:00:12:01:01", KERNEL=="eth*", NAME="custom_name"

     

       883
       883
        
                     '';

     

       884
       884
        
                   });