commit 4e8c2f0ff91c19065f44fd66c9d869b920631557 · pyrox.dev/nixpkgs

+1 -1

nixos/doc/manual/configuration.xml

···

       935
       935
        
       </programlisting>

     

       936
       936
        
       where <filename>my-hello.nix</filename> contains:

     

       937
       937
        
       <programlisting>

     

       938
       938
       -
       with &lt;nixpkgs> {}; # bring all of Nixpkgs into scope

     

       938
       938
       +
       with import &lt;nixpkgs> {}; # bring all of Nixpkgs into scope

     

       939
       939
        
       

     

       940
       940
        
       stdenv.mkDerivation rec {

     

       941
       941
        
         name = "hello-2.8";

+1 -1

nixos/lib/eval-config.nix

···

       58
       58
        
                 inherit system extraArgs modules prefix;

     

       59
       59
        
                 # For efficiency, leave out most NixOS modules; they don't

     

       60
       60
        
                 # define nixpkgs.config, so it's pointless to evaluate them.

     

       61
       61
       -
                 baseModules = [ ../modules/misc/nixpkgs.nix ];

     

       61
       61
       +
                 baseModules = [ ../modules/misc/nixpkgs.nix ../modules/config/no-x-libs.nix ];

     

       62
       62
        
                 pkgs = import ./nixpkgs.nix { system = system_; config = {}; };

     

       63
       63
        
                 check = false;

     

       64
       64
        
               }).config.nixpkgs;

+1 -1

nixos/lib/test-driver/Machine.pm

···

       495
       495
        
           my ($self, $regexp) = @_;

     

       496
       496
        
           $self->nest("waiting for the X11 server", sub {

     

       497
       497
        
               retry sub {

     

       498
       498
       -
                   my ($status, $out) = $self->execute("journalctl -bu systemd-logind | grep Linked");

     

       498
       498
       +
                   my ($status, $out) = $self->execute("journalctl -b SYSLOG_IDENTIFIER=systemd | grep 'session opened'");

     

       499
       499
        
                   return 0 if $status != 0;

     

       500
       500
        
                   ($status, $out) = $self->execute("xwininfo -root > /dev/null 2>&1");

     

       501
       501
        
                   return 1 if $status == 0;

+1 -1

nixos/modules/config/gnu.nix

···

       36
       36
        
           # GNU lsh.

     

       37
       37
        
           services.openssh.enable = false;

     

       38
       38
        
           services.lshd.enable = true;

     

       39
       39
       -
           services.xserver.startOpenSSHAgent = false;

     

       39
       39
       +
           programs.ssh.startAgent = false;

     

       40
       40
        
           services.xserver.startGnuPGAgent = true;

     

       41
       41
        
       

     

       42
       42
        
           # TODO: GNU dico.

+6 -1

nixos/modules/config/i18n.nix

···

       76
       76
        
       

     

       77
       77
        
           environment.systemPackages = [ glibcLocales ];

     

       78
       78
        
       

     

       79
       79
       -
           environment.variables.LANG = config.i18n.defaultLocale;

     

       79
       79
       +
           environment.variables =

     

       80
       80
       +
             { LANG = config.i18n.defaultLocale;

     

       81
       81
       +
               LOCALE_ARCHIVE = "/run/current-system/sw/lib/locale/locale-archive";

     

       82
       82
       +
             };

     

       83
       83
       +
       

     

       84
       84
       +
           systemd.globalEnvironment.LOCALE_ARCHIVE = "${glibcLocales}/lib/locale/locale-archive";

     

       80
       85
        
       

     

       81
       86
        
           # ‘/etc/locale.conf’ is used by systemd.

     

       82
       87
        
           environment.etc = singleton

+14 -7

nixos/modules/config/no-x-libs.nix

···

       1
       1
       +
       # This module gets rid of all dependencies on X11 client libraries

     

       2
       2
       +
       # (including fontconfig).

     

       3
       3
       +
       

     

       1
       4
        
       { config, lib, pkgs, ... }:

     

       2
       5
        
       

     

       3
       6
        
       with lib;

     
···

       8
       11
        
             type = types.bool;

     

       9
       12
        
             default = false;

     

       10
       13
        
             description = ''

     

       11
       11
       -
               Switch off the options in the default configuration that require X libraries.

     

       12
       12
       -
               Currently this includes: ssh X11 forwarding, dbus, fonts.enableCoreFonts,

     

       13
       13
       -
               fonts.enableFontConfig

     

       14
       14
       +
               Switch off the options in the default configuration that

     

       15
       15
       +
               require X11 libraries. This includes client-side font

     

       16
       16
       +
               configuration and SSH forwarding of X11 authentication

     

       17
       17
       +
               in. Thus, you probably do not want to enable this option if

     

       18
       18
       +
               you want to run X11 programs on this machine via SSH.

     

       14
       19
        
             '';

     

       15
       20
        
           };

     

       16
       21
        
         };

     

       17
       22
        
       

     

       18
       23
        
         config = mkIf config.environment.noXlibs {

     

       19
       24
        
           programs.ssh.setXAuthLocation = false;

     

       20
       20
       -
           fonts = {

     

       21
       21
       -
             enableCoreFonts = false;

     

       22
       22
       -
             enableFontConfig = false;

     

       23
       23
       -
           };

     

       25
       25
       +
           security.pam.services.su.forwardXAuth = lib.mkForce false;

     

       26
       26
       +
       

     

       27
       27
       +
           fonts.enableFontConfig = false;

     

       28
       28
       +
       

     

       29
       29
       +
           nixpkgs.config.packageOverrides = pkgs:

     

       30
       30
       +
             { dbus = pkgs.dbus.override { useX11 = false; }; };

     

       24
       31
        
         };

     

       25
       32
        
       }

+1 -5

nixos/modules/config/power-management.nix

···

       65
       65
        
       

     

       66
       66
        
         config = mkIf cfg.enable {

     

       67
       67
        
       

     

       68
       68
       -
           boot.kernelModules =

     

       69
       69
       -
             [ "acpi_cpufreq" "powernow-k8" "cpufreq_performance" "cpufreq_powersave" "cpufreq_ondemand"

     

       70
       70
       -
               "cpufreq_conservative"

     

       71
       71
       -
             ];

     

       72
       72
       -
       

     

       68
       68
       +
           # FIXME: Implement powersave governor for sandy bridge or later Intel CPUs

     

       73
       69
        
           powerManagement.cpuFreqGovernor = mkDefault "ondemand";

     

       74
       70
        
           powerManagement.scsiLinkPolicy = mkDefault "min_power";

     

       75
       71

+1 -12

nixos/modules/config/sysctl.nix

···

       45
       45
        
             ) config.boot.kernel.sysctl);

     

       46
       46
        
       

     

       47
       47
        
           systemd.services.systemd-sysctl =

     

       48
       48
       -
             { description = "Apply Kernel Variables";

     

       49
       49
       -
               before = [ "sysinit.target" "shutdown.target" ];

     

       50
       50
       -
               wantedBy = [ "sysinit.target" "multi-user.target" ];

     

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

     

       51
       49
        
               restartTriggers = [ config.environment.etc."sysctl.d/nixos.conf".source ];

     

       52
       52
       -
               unitConfig = {

     

       53
       53
       -
                 DefaultDependencies = false; # needed to prevent a cycle

     

       54
       54
       -
                 ConditionPathIsReadWrite = "/proc/sys/"; # prevent systemd-sysctl in containers

     

       55
       55
       -
               };

     

       56
       56
       -
               serviceConfig = {

     

       57
       57
       -
                 Type = "oneshot";

     

       58
       58
       -
                 RemainAfterExit = true;

     

       59
       59
       -
                 ExecStart = "${config.systemd.package}/lib/systemd/systemd-sysctl";

     

       60
       60
       -
               };

     

       61
       50
        
             };

     

       62
       51
        
       

     

       63
       52
        
           # Enable hardlink and symlink restrictions.  See

nixos/modules/installer/tools/nixos-rebuild.sh

···

       1
       1
        
       #! @shell@

     

       2
       2
        
       

     

       3
       3
       +
       if [ -x "@shell@" ]; then export SHELL="@shell@"; fi;

     

       4
       4
       +
       

     

       3
       5
        
       set -e

     

       4
       6
        
       

     

       5
       7
        
       showSyntax() {

+2 -5

nixos/modules/profiles/minimal.nix

···

       1
       1
        
       # This module defines a small NixOS configuration.  It does not

     

       2
       2
        
       # contain any graphical stuff.

     

       3
       3
        
       

     

       4
       4
       -
       { config, pkgs, ... }:

     

       4
       4
       +
       { config, lib, pkgs, ... }:

     

       5
       5
        
       

     

       6
       6
        
       {

     

       7
       7
       -
         # Don't include X libraries.

     

       8
       8
       -
         programs.ssh.setXAuthLocation = false;

     

       9
       9
       -
         fonts.enableFontConfig = false;

     

       10
       10
       -
         fonts.enableCoreFonts = false;

     

       7
       7
       +
         environment.noXlibs = true;

     

       11
       8
        
       }

+1 -2

nixos/modules/programs/environment.nix

···

       17
       17
        
         config = {

     

       18
       18
        
       

     

       19
       19
        
           environment.variables =

     

       20
       20
       -
             { LOCALE_ARCHIVE = "/run/current-system/sw/lib/locale/locale-archive";

     

       21
       21
       -
               LOCATE_PATH = "/var/cache/locatedb";

     

       20
       20
       +
             { LOCATE_PATH = "/var/cache/locatedb";

     

       22
       21
        
               NIXPKGS_CONFIG = "/etc/nix/nixpkgs-config.nix";

     

       23
       22
        
               NIX_PATH =

     

       24
       23
        
                 [ "/nix/var/nix/profiles/per-user/root/channels/nixos"

+36

nixos/modules/programs/ssh.nix

···

       47
       47
        
                 for help.

     

       48
       48
        
               '';

     

       49
       49
        
             };

     

       50
       50
       +
       

     

       51
       51
       +
             startAgent = mkOption {

     

       52
       52
       +
               type = types.bool;

     

       53
       53
       +
               default = true;

     

       54
       54
       +
               description = ''

     

       55
       55
       +
                 Whether to start the OpenSSH agent when you log in.  The OpenSSH agent

     

       56
       56
       +
                 remembers private keys for you so that you don't have to type in

     

       57
       57
       +
                 passphrases every time you make an SSH connection.  Use

     

       58
       58
       +
                 <command>ssh-add</command> to add a key to the agent.

     

       59
       59
       +
               '';

     

       60
       60
       +
             };

     

       61
       61
       +
       

     

       50
       62
        
           };

     

       63
       63
       +
       

     

       51
       64
        
         };

     

       52
       65
        
       

     

       53
       66
        
         config = {

     
···

       71
       84
        
                 target = "ssh/ssh_config";

     

       72
       85
        
               }

     

       73
       86
        
             ];

     

       87
       87
       +
       

     

       88
       88
       +
           # FIXME: this should really be socket-activated for über-awesomeness.

     

       89
       89
       +
           systemd.user.services.ssh-agent =

     

       90
       90
       +
             { enable = cfg.startAgent;

     

       91
       91
       +
               description = "SSH Agent";

     

       92
       92
       +
               wantedBy = [ "default.target" ];

     

       93
       93
       +
               serviceConfig =

     

       94
       94
       +
                 { ExecStartPre = "${pkgs.coreutils}/bin/rm -f %t/ssh-agent";

     

       95
       95
       +
                   ExecStart = "${pkgs.openssh}/bin/ssh-agent -a %t/ssh-agent";

     

       96
       96
       +
                   StandardOutput = "null";

     

       97
       97
       +
                   Type = "forking";

     

       98
       98
       +
                   Restart = "on-failure";

     

       99
       99
       +
                   SuccessExitStatus = "0 2";

     

       100
       100
       +
                 };

     

       101
       101
       +
             };

     

       102
       102
       +
       

     

       103
       103
       +
           environment.extraInit = optionalString cfg.startAgent

     

       104
       104
       +
             ''

     

       105
       105
       +
               if [ -z "$SSH_AUTH_SOCK" -a -n "$XDG_RUNTIME_DIR" ]; then

     

       106
       106
       +
                 export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent"

     

       107
       107
       +
               fi

     

       108
       108
       +
             '';

     

       109
       109
       +
       

     

       74
       110
        
         };

     

       75
       111
        
       }

+3 -2

nixos/modules/rename.nix

···

       17
       17
        
           inherit from to;

     

       18
       18
        
           name = "Obsolete name";

     

       19
       19
        
           use = x: builtins.trace "Obsolete option `${showOption from}' is used. It was renamed to `${showOption to}'." x;

     

       20
       20
       -
           define = x: builtins.trace "Obsolete option `${showOption from}' is used. It was renamed to  `${showOption to}'." x;

     

       20
       20
       +
           define = x: builtins.trace "Obsolete option `${showOption from}' is used. It was renamed to `${showOption to}'." x;

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         # abort if deprecated option is used

     
···

       25
       25
        
           inherit from to;

     

       26
       26
        
           name = "Deprecated name";

     

       27
       27
        
           use = x: abort "Deprecated option `${showOption from}' is used. It was renamed to `${showOption to}'.";

     

       28
       28
       -
           define = x: abort "Deprecated option `${showOption from}' is used. It was renamed to  `${showOption to}'.";

     

       28
       28
       +
           define = x: abort "Deprecated option `${showOption from}' is used. It was renamed to `${showOption to}'.";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         showOption = concatStringsSep ".";

     
···

       103
       103
        
       ++ obsolete [ "services" "sshd" "gatewayPorts" ] [ "services" "openssh" "gatewayPorts" ]

     

       104
       104
        
       ++ obsolete [ "services" "sshd" "permitRootLogin" ] [ "services" "openssh" "permitRootLogin" ]

     

       105
       105
        
       ++ obsolete [ "services" "xserver" "startSSHAgent" ] [ "services" "xserver" "startOpenSSHAgent" ]

     

       106
       106
       +
       ++ obsolete [ "services" "xserver" "startOpenSSHAgent" ] [ "programs" "ssh" "startAgent" ]

     

       106
       107
        
       ++ obsolete [ "services" "xserver" "windowManager" "xbmc" ] [ "services" "xserver" "desktopManager" "xbmc" ]

     

       107
       108
        
       

     

       108
       109
        
       # KDE

+2 -2

nixos/modules/security/pam.nix

···

       187
       187
        
       

     

       188
       188
        
                 # Session management.

     

       189
       189
        
                 session required pam_unix.so

     

       190
       190
       +
                 ${optionalString cfg.setLoginUid

     

       191
       191
       +
                     "session required pam_loginuid.so"}

     

       190
       192
        
                 ${optionalString cfg.updateWtmp

     

       191
       193
        
                     "session required ${pkgs.pam}/lib/security/pam_lastlog.so silent"}

     

       192
       194
        
                 ${optionalString config.users.ldap.enable

     
···

       197
       199
        
                     "session optional ${pkgs.otpw}/lib/security/pam_otpw.so"}

     

       198
       200
        
                 ${optionalString cfg.startSession

     

       199
       201
        
                     "session optional ${pkgs.systemd}/lib/security/pam_systemd.so"}

     

       200
       200
       -
                 ${optionalString cfg.setLoginUid

     

       201
       201
       -
                     "session required pam_loginuid.so"}

     

       202
       202
        
                 ${optionalString cfg.forwardXAuth

     

       203
       203
        
                     "session optional pam_xauth.so xauthpath=${pkgs.xorg.xauth}/bin/xauth systemuser=99"}

     

       204
       204
        
                 ${optionalString (cfg.limits != [])

nixos/modules/security/polkit.nix

···

       63
       63
        
       

     

       64
       64
        
           systemd.packages = [ pkgs.polkit ];

     

       65
       65
        
       

     

       66
       66
       +
           systemd.services.polkit.restartTriggers = [ config.system.path ];

     

       67
       67
       +
           systemd.services.polkit.unitConfig.X-StopIfChanged = false;

     

       68
       68
       +
       

     

       66
       69
        
           # The polkit daemon reads action/rule files

     

       67
       70
        
           environment.pathsToLink = [ "/share/polkit-1" ];

     

       68
       71

+7 -7

nixos/modules/security/setuid-wrapper.c

···

       30
       30
        
              creating hard link `X' from some other location, along with a

     

       31
       31
        
              false `X.real' file, to allow arbitrary programs from being

     

       32
       32
        
              executed setuid.  */

     

       33
       33
       -
           assert ((strncmp(self, wrapperDir, sizeof(wrapperDir)) == 0) &&

     

       34
       34
       -
       	    (self[strlen(wrapperDir)] == '/'));

     

       33
       33
       +
           assert ((strncmp(self, wrapperDir, strlen(wrapperDir)) == 0) &&

     

       34
       34
       +
                   (self[strlen(wrapperDir)] == '/'));

     

       35
       35
        
       

     

       36
       36
        
           /* Make *really* *really* sure that we were executed as `self',

     

       37
       37
        
              and not, say, as some other setuid program.  That is, our

     
···

       42
       42
        
           assert (lstat(self, &st) != -1);

     

       43
       43
        
       

     

       44
       44
        
           //printf("%d %d\n", st.st_uid, st.st_gid);

     

       45
       45
       -
           

     

       45
       45
       +
       

     

       46
       46
        
           assert ((st.st_mode & S_ISUID) == 0 ||

     

       47
       47
       -
       	    (st.st_uid == geteuid()));

     

       47
       47
       +
                   (st.st_uid == geteuid()));

     

       48
       48
        
       

     

       49
       49
        
           assert ((st.st_mode & S_ISGID) == 0 ||

     

       50
       50
       -
       	    st.st_gid == getegid());

     

       50
       50
       +
                   st.st_gid == getegid());

     

       51
       51
        
       

     

       52
       52
        
           /* And, of course, we shouldn't be writable. */

     

       53
       53
        
           assert (!(st.st_mode & (S_IWGRP | S_IWOTH)));

     
···

       69
       69
        
           real[len] = 0;

     

       70
       70
        
       

     

       71
       71
        
           close(fdSelf);

     

       72
       72
       -
           

     

       72
       72
       +
       

     

       73
       73
        
           //printf("real = %s, len = %d\n", real, len);

     

       74
       74
        
       

     

       75
       75
        
           execve(real, argv, environ);

     

       76
       76
        
       

     

       77
       77
        
           fprintf(stderr, "%s: cannot run `%s': %s\n",

     

       78
       78
        
               argv[0], real, strerror(errno));

     

       79
       79
       -
           

     

       79
       79
       +
       

     

       80
       80
        
           exit(1);

     

       81
       81
        
       }

+5 -5

nixos/modules/security/setuid-wrappers.nix

···

       9
       9
        
         setuidWrapper = pkgs.stdenv.mkDerivation {

     

       10
       10
        
           name = "setuid-wrapper";

     

       11
       11
        
           buildCommand = ''

     

       12
       12
       -
             ensureDir $out/bin

     

       12
       12
       +
             mkdir -p $out/bin

     

       13
       13
       +
             cp ${./setuid-wrapper.c} setuid-wrapper.c

     

       13
       14
        
             gcc -Wall -O2 -DWRAPPER_DIR=\"${wrapperDir}\" \

     

       14
       14
       -
                 ${./setuid-wrapper.c} -o $out/bin/setuid-wrapper

     

       15
       15
       -
             strip -s $out/bin/setuid-wrapper

     

       15
       15
       +
                 setuid-wrapper.c -o $out/bin/setuid-wrapper

     

       16
       16
       +
             strip -S $out/bin/setuid-wrapper

     

       16
       17
        
           '';

     

       17
       18
        
         };

     

       18
       19
        
       

     
···

       116
       117
        
                 # programs to be wrapped.

     

       117
       118
        
                 SETUID_PATH=${config.system.path}/bin:${config.system.path}/sbin

     

       118
       119
        
       

     

       119
       119
       -
                 if test -d ${wrapperDir}; then rm -f ${wrapperDir}/*; fi # */

     

       120
       120
       -
                 mkdir -p ${wrapperDir}

     

       120
       120
       +
                 rm -f ${wrapperDir}/* # */

     

       121
       121
        
       

     

       122
       122
        
                 ${concatMapStrings makeSetuidWrapper setuidPrograms}

     

       123
       123
        
               '';

+1 -1

nixos/modules/services/databases/postgresql.nix

···

       215
       215
        
                   # Shut down Postgres using SIGINT ("Fast Shutdown mode").  See

     

       216
       216
        
                   # http://www.postgresql.org/docs/current/static/server-shutdown.html

     

       217
       217
        
                   KillSignal = "SIGINT";

     

       218
       218
       -
                   KillMode = "process"; # FIXME: this may cause processes to be left behind in the cgroup even after the final SIGKILL

     

       218
       218
       +
                   KillMode = "mixed";

     

       219
       219
        
       

     

       220
       220
        
                   # Give Postgres a decent amount of time to clean up after

     

       221
       221
        
                   # receiving systemd's SIGINT.

+13

nixos/modules/services/hardware/80-net-name-slot.rules

···

       1
       1
       +
       # Copied from systemd 203.

     

       2
       2
       +
       ACTION=="remove", GOTO="net_name_slot_end"

     

       3
       3
       +
       SUBSYSTEM!="net", GOTO="net_name_slot_end"

     

       4
       4
       +
       NAME!="", GOTO="net_name_slot_end"

     

       5
       5
       +
       

     

       6
       6
       +
       IMPORT{cmdline}="net.ifnames"

     

       7
       7
       +
       ENV{net.ifnames}=="0", GOTO="net_name_slot_end"

     

       8
       8
       +
       

     

       9
       9
       +
       NAME=="", ENV{ID_NET_NAME_ONBOARD}!="", NAME="$env{ID_NET_NAME_ONBOARD}"

     

       10
       10
       +
       NAME=="", ENV{ID_NET_NAME_SLOT}!="", NAME="$env{ID_NET_NAME_SLOT}"

     

       11
       11
       +
       NAME=="", ENV{ID_NET_NAME_PATH}!="", NAME="$env{ID_NET_NAME_PATH}"

     

       12
       12
       +
       

     

       13
       13
       +
       LABEL="net_name_slot_end"

+6 -2

nixos/modules/services/hardware/udev.nix

···

       83
       83
        
               grep -l '\(RUN+\|IMPORT{program}\)="\(/usr\)\?/s\?bin' $i/*/udev/rules.d/* || true

     

       84
       84
        
             done

     

       85
       85
        
       

     

       86
       86
       -
             ${optionalString (!config.networking.usePredictableInterfaceNames) ''

     

       87
       87
       -
               ln -s /dev/null $out/80-net-name-slot.rules

     

       86
       86
       +
             ${optionalString config.networking.usePredictableInterfaceNames ''

     

       87
       87
       +
               cp ${./80-net-name-slot.rules} $out/80-net-name-slot.rules

     

       88
       88
        
             ''}

     

       89
       89
        
       

     

       90
       90
        
             # If auto-configuration is disabled, then remove

     
···

       242
       242
        
                 ${config.systemd.package}/bin/udevadm hwdb --update && ln -sfn ${config.systemd.package} /var/lib/udev/prev-systemd

     

       243
       243
        
               fi

     

       244
       244
        
             '';

     

       245
       245
       +
       

     

       246
       246
       +
           systemd.services.systemd-udevd =

     

       247
       247
       +
             { environment.MODULE_DIR = "/run/booted-system/kernel-modules/lib/modules";

     

       248
       248
       +
             };

     

       245
       249
        
       

     

       246
       250
        
         };

     

       247
       251
        
       }

+1 -1

nixos/modules/services/hardware/udisks2.nix

···

       14
       14
        
       

     

       15
       15
        
             enable = mkOption {

     

       16
       16
        
               type = types.bool;

     

       17
       17
       -
               default = false;

     

       17
       17
       +
               default = true;

     

       18
       18
        
               description = ''

     

       19
       19
        
                 Whether to enable Udisks, a DBus service that allows

     

       20
       20
        
                 applications to query and manipulate storage devices.

+6 -17

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

···

       275
       275
        
                 ) cfg.buildMachines;

     

       276
       276
        
             };

     

       277
       277
        
       

     

       278
       278
       -
           systemd.sockets."nix-daemon" =

     

       279
       279
       -
             { description = "Nix Daemon Socket";

     

       280
       280
       -
               wantedBy = [ "sockets.target" ];

     

       281
       281
       -
               before = [ "multi-user.target" ];

     

       282
       282
       -
               unitConfig.ConditionPathIsReadWrite = "/nix/var/nix/daemon-socket/";

     

       283
       283
       -
               socketConfig.ListenStream = "/nix/var/nix/daemon-socket/socket";

     

       284
       284
       -
             };

     

       278
       278
       +
           systemd.packages = [ nix ];

     

       285
       279
        
       

     

       286
       286
       -
           systemd.services."nix-daemon" =

     

       287
       287
       -
             { description = "Nix Daemon";

     

       280
       280
       +
           systemd.sockets.nix-daemon.wantedBy = [ "sockets.target" ];

     

       288
       281
        
       

     

       289
       289
       -
               path = [ nix pkgs.openssl pkgs.utillinux pkgs.openssh ]

     

       282
       282
       +
           systemd.services.nix-daemon =

     

       283
       283
       +
             { path = [ nix pkgs.openssl pkgs.utillinux pkgs.openssh ]

     

       290
       284
        
                 ++ optionals cfg.distributedBuilds [ pkgs.gzip ];

     

       291
       285
        
       

     

       292
       286
        
               environment = cfg.envVars // { CURL_CA_BUNDLE = "/etc/ssl/certs/ca-bundle.crt"; };

     

       293
       287
        
       

     

       294
       294
       -
               unitConfig.ConditionPathIsReadWrite = "/nix/var/nix/daemon-socket/";

     

       295
       295
       -
       

     

       296
       288
        
               serviceConfig =

     

       297
       297
       -
                 { ExecStart = "@${nix}/bin/nix-daemon nix-daemon --daemon";

     

       298
       298
       -
                   KillMode = "process";

     

       299
       299
       -
                   Nice = cfg.daemonNiceLevel;

     

       289
       289
       +
                 { Nice = cfg.daemonNiceLevel;

     

       300
       290
        
                   IOSchedulingPriority = cfg.daemonIONiceLevel;

     

       301
       291
        
                   LimitNOFILE = 4096;

     

       302
       292
        
                 };

     
···

       352
       342
        
                 /nix/var/nix/profiles \

     

       353
       343
        
                 /nix/var/nix/db \

     

       354
       344
        
                 /nix/var/log/nix/drvs \

     

       355
       355
       -
                 /nix/var/nix/channel-cache \

     

       356
       356
       -
                 /nix/var/nix/chroots

     

       345
       345
       +
                 /nix/var/nix/channel-cache

     

       357
       346
        
               mkdir -m 1777 -p \

     

       358
       347
        
                 /nix/var/nix/gcroots/per-user \

     

       359
       348
        
                 /nix/var/nix/profiles/per-user \

+4 -1

nixos/modules/services/networking/dhcpcd.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
       

     

       7
       7
       -
         dhcpcd =  if !config.boot.isContainer then pkgs.dhcpcd else pkgs.dhcpcd_without_udev;

     

       7
       7
       +
         dhcpcd = if !config.boot.isContainer then pkgs.dhcpcd else pkgs.dhcpcd.override { udev = null; };

     

       8
       8
        
       

     

       9
       9
        
         # Don't start dhcpcd on explicitly configured interfaces or on

     

       10
       10
        
         # interfaces that are part of a bridge.

     
···

       80
       80
        
         options = {

     

       81
       81
        
       

     

       82
       82
        
           networking.dhcpcd.denyInterfaces = mkOption {

     

       83
       83
       +
             type = types.listOf types.str;

     

       83
       84
        
             default = [];

     

       84
       85
        
             description = ''

     

       85
       86
        
                Disable the DHCP client for any interface whose name matches

     
···

       90
       91
        
           };

     

       91
       92
        
       

     

       92
       93
        
           networking.dhcpcd.extraConfig = mkOption {

     

       94
       94
       +
             type = types.lines;

     

       93
       95
        
             default = "";

     

       94
       96
        
             description = ''

     

       95
       97
        
                Literal string to append to the config file generated for dhcpcd.

     
···

       107
       109
        
             { description = "DHCP Client";

     

       108
       110
        
       

     

       109
       111
        
               wantedBy = [ "network.target" ];

     

       112
       112
       +
               after = [ "systemd-udev-settle.service" ]; # FIXME

     

       110
       113
        
       

     

       111
       114
        
               # Stopping dhcpcd during a reconfiguration is undesirable

     

       112
       115
        
               # because it brings down the network interfaces configured by

+12 -5

nixos/modules/services/networking/firewall.nix

···

       18
       18
        
       

     

       19
       19
        
       */

     

       20
       20
        
       

     

       21
       21
       -
       

     

       22
       22
       -
       

     

       23
       21
        
       { config, lib, pkgs, ... }:

     

       24
       22
        
       

     

       25
       23
        
       with lib;

     
···

       266
       264
        
                            message = "This kernel does not support disabling conntrack helpers"; }

     

       267
       265
        
                        ];

     

       268
       266
        
       

     

       269
       269
       -
           jobs.firewall =

     

       267
       267
       +
           systemd.services.firewall =

     

       270
       268
        
             { description = "Firewall";

     

       271
       269
        
       

     

       272
       272
       -
               startOn = "started network-interfaces";

     

       270
       270
       +
               wantedBy = [ "network.target" ];

     

       271
       271
       +
               after = [ "network-interfaces.target" "systemd-modules-load.service" ];

     

       273
       272
        
       

     

       274
       273
        
               path = [ pkgs.iptables ];

     

       275
       274
        
       

     

       276
       276
       -
               preStart =

     

       275
       275
       +
               # FIXME: this module may also try to load kernel modules, but

     

       276
       276
       +
               # containers don't have CAP_SYS_MODULE. So the host system had

     

       277
       277
       +
               # better have all necessary modules already loaded.

     

       278
       278
       +
               unitConfig.ConditionCapability = "CAP_NET_ADMIN";

     

       279
       279
       +
       

     

       280
       280
       +
               serviceConfig.Type = "oneshot";

     

       281
       281
       +
               serviceConfig.RemainAfterExit = true;

     

       282
       282
       +
       

     

       283
       283
       +
               script =

     

       277
       284
        
                 ''

     

       278
       285
        
                   ${helpers}

     

       279
       286

-1

nixos/modules/services/networking/ssh/sshd.nix

···

       258
       258
        
               path = [ pkgs.openssh pkgs.gawk ];

     

       259
       259
        
       

     

       260
       260
        
               environment.LD_LIBRARY_PATH = nssModulesPath;

     

       261
       261
       -
               environment.LOCALE_ARCHIVE = "/run/current-system/sw/lib/locale/locale-archive";

     

       262
       261
        
       

     

       263
       262
        
               preStart =

     

       264
       263
        
                 ''

+9 -11

nixos/modules/services/ttys/agetty.nix

···

       49
       49
        
         config = {

     

       50
       50
        
       

     

       51
       51
        
           systemd.services."getty@" =

     

       52
       52
       -
             { baseUnit = pkgs.runCommand "getty.service" {}

     

       53
       53
       -
                 ''

     

       54
       54
       -
                   sed '/ExecStart/ d' < ${config.systemd.package}/example/systemd/system/getty@.service > $out

     

       55
       55
       -
                 '';

     

       56
       56
       -
               serviceConfig.ExecStart = "@${pkgs.utillinux}/sbin/agetty agetty --noclear --login-program ${pkgs.shadow}/bin/login %I 38400";

     

       52
       52
       +
             { serviceConfig.ExecStart = "@${pkgs.utillinux}/sbin/agetty agetty --noclear --login-program ${pkgs.shadow}/bin/login --keep-baud %I 115200,38400,9600 $TERM";

     

       57
       53
        
               restartIfChanged = false;

     

       58
       54
        
             };

     

       59
       55
        
       

     

       60
       56
        
           systemd.services."serial-getty@" =

     

       61
       61
       -
             { baseUnit = pkgs.runCommand "serial-getty.service" {}

     

       62
       62
       -
                 ''

     

       63
       63
       -
                   sed '/ExecStart/ d' < ${config.systemd.package}/example/systemd/system/serial-getty@.service > $out

     

       64
       64
       -
                 '';

     

       65
       65
       -
               serviceConfig.ExecStart =

     

       57
       57
       +
             { serviceConfig.ExecStart =

     

       66
       58
        
                 let speeds = concatStringsSep "," (map toString config.services.mingetty.serialSpeed);

     

       67
       67
       -
                 in "@${pkgs.utillinux}/sbin/agetty agetty --login-program ${pkgs.shadow}/bin/login %I ${speeds}";

     

       59
       59
       +
                 in "@${pkgs.utillinux}/sbin/agetty agetty --login-program ${pkgs.shadow}/bin/login %I ${speeds} $TERM";

     

       60
       60
       +
               restartIfChanged = false;

     

       61
       61
       +
             };

     

       62
       62
       +
       

     

       63
       63
       +
           systemd.services."container-getty@" =

     

       64
       64
       +
             { unitConfig.ConditionPathExists = "/dev/pts/%I"; # Work around being respawned when "machinectl login" exits.

     

       65
       65
       +
               serviceConfig.ExecStart = "@${pkgs.utillinux}/sbin/agetty agetty --noclear --login-program ${pkgs.shadow}/bin/login --keep-baud pts/%I 115200,38400,9600 $TERM";

     

       68
       66
        
               restartIfChanged = false;

     

       69
       67
        
             };

     

       70
       68

+7 -4

nixos/modules/services/ttys/gpm.nix

···

       40
       40
        
       

     

       41
       41
        
         config = mkIf cfg.enable {

     

       42
       42
        
       

     

       43
       43
       -
           jobs.gpm =

     

       44
       44
       -
             { description = "General purpose mouse";

     

       43
       43
       +
           systemd.services.gpm =

     

       44
       44
       +
             { description = "Console Mouse Daemon";

     

       45
       45
        
       

     

       46
       46
       -
               startOn = "started udev";

     

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

     

       47
       47
       +
               requires = [ "getty.target" ];

     

       47
       48
        
       

     

       48
       48
       -
               exec = "${pkgs.gpm}/sbin/gpm -m /dev/input/mice -t ${cfg.protocol} -D &>/dev/null";

     

       49
       49
       +
               serviceConfig.ExecStart = "@${pkgs.gpm}/sbin/gpm gpm -m /dev/input/mice -t ${cfg.protocol}";

     

       50
       50
       +
               serviceConfig.Type = "forking";

     

       51
       51
       +
               serviceConfig.PIDFile = "/run/gpm.pid";

     

       49
       52
        
             };

     

       50
       53
        
       

     

       51
       54
        
         };

+1 -1

nixos/modules/services/web-servers/apache-httpd/default.nix

···

       450
       450
        
             extraModules = mkOption {

     

       451
       451
        
               type = types.listOf types.unspecified;

     

       452
       452
        
               default = [];

     

       453
       453
       -
               example = literalExample ''[ "proxy_connect" { name = "php5"; path = "''${php}/modules/libphp5.so"; } ]'';

     

       453
       453
       +
               example = literalExample ''[ "proxy_connect" { name = "php5"; path = "''${pkgs.php}/modules/libphp5.so"; } ]'';

     

       454
       454
        
               description = ''

     

       455
       455
        
                 Additional Apache modules to be used.  These can be

     

       456
       456
        
                 specified as a string in the case of modules distributed

+1 -1

nixos/modules/services/x11/desktop-managers/kde4.nix

···

       159
       159
        
       

     

       160
       160
        
           # Enable helpful DBus services.

     

       161
       161
        
           services.udisks.enable = ! wantsUdisks2;

     

       162
       162
       -
           services.udisks2.enable = wantsUdisks2;

     

       162
       162
       +
           services.udisks2.enable = true;

     

       163
       163
        
           services.upower.enable = config.powerManagement.enable;

     

       164
       164
        
       

     

       165
       165
        
           security.pam.services.kde = { allowNullPassword = true; };

-11

nixos/modules/services/x11/display-managers/default.nix

···

       51
       51
        
       

     

       52
       52
        
             ''}

     

       53
       53
        
       

     

       54
       54
       -
             ${optionalString cfg.startOpenSSHAgent ''

     

       55
       55
       -
               if test -z "$SSH_AUTH_SOCK"; then

     

       56
       56
       -
                   # Restart this script as a child of the SSH agent.  (It is

     

       57
       57
       -
                   # also possible to start the agent as a child that prints

     

       58
       58
       -
                   # the required environment variabled on stdout, but in

     

       59
       59
       -
                   # that mode ssh-agent is not terminated when we log out.)

     

       60
       60
       -
                   export SSH_ASKPASS=${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass

     

       61
       61
       -
                   exec ${pkgs.openssh}/bin/ssh-agent "$0" "$sessionType"

     

       62
       62
       -
               fi

     

       63
       63
       -
             ''}

     

       64
       64
       -
       

     

       65
       54
        
             ${optionalString cfg.startGnuPGAgent ''

     

       66
       55
        
               if test -z "$SSH_AUTH_SOCK"; then

     

       67
       56
        
                   # Restart this script as a child of the GnuPG agent.

+3 -14

nixos/modules/services/x11/xserver.nix

···

       201
       201
        
               '';

     

       202
       202
        
             };

     

       203
       203
        
       

     

       204
       204
       -
             startOpenSSHAgent = mkOption {

     

       205
       205
       -
               type = types.bool;

     

       206
       206
       -
               default = true;

     

       207
       207
       -
               description = ''

     

       208
       208
       -
                 Whether to start the OpenSSH agent when you log in.  The OpenSSH agent

     

       209
       209
       -
                 remembers private keys for you so that you don't have to type in

     

       210
       210
       -
                 passphrases every time you make an SSH connection.  Use

     

       211
       211
       -
                 <command>ssh-add</command> to add a key to the agent.

     

       212
       212
       -
               '';

     

       213
       213
       -
             };

     

       214
       214
       -
       

     

       215
       204
        
             startGnuPGAgent = mkOption {

     

       216
       205
        
               type = types.bool;

     

       217
       206
        
               default = false;

     
···

       400
       389
        
           hardware.opengl.videoDrivers = mkIf (cfg.videoDriver != null) [ cfg.videoDriver ];

     

       401
       390
        
       

     

       402
       391
        
           assertions =

     

       403
       403
       -
             [ { assertion = !(cfg.startOpenSSHAgent && cfg.startGnuPGAgent);

     

       392
       392
       +
             [ { assertion = !(config.programs.ssh.startAgent && cfg.startGnuPGAgent);

     

       404
       393
        
                 message =

     

       405
       394
        
                   ''

     

       406
       406
       -
                     The OpenSSH agent and GnuPG agent cannot be started both.

     

       407
       407
       -
                     Choose between `startOpenSSHAgent' and `startGnuPGAgent'.

     

       395
       395
       +
                     The OpenSSH agent and GnuPG agent cannot be started both. Please

     

       396
       396
       +
                     choose between ‘programs.ssh.startAgent’ and ‘services.xserver.startGnuPGAgent’.

     

       408
       397
        
                   '';

     

       409
       398
        
               }

     

       410
       399
        
               { assertion = config.security.polkit.enable;

+18 -8

nixos/modules/system/activation/switch-to-configuration.pl

···

       65
       65
        
       sub getActiveUnits {

     

       66
       66
        
           # FIXME: use D-Bus or whatever to query this, since parsing the

     

       67
       67
        
           # output of list-units is likely to break.

     

       68
       68
       -
           my $lines = `@systemd@/bin/systemctl list-units --full`;

     

       68
       68
       +
           my $lines = `LANG= @systemd@/bin/systemctl list-units --full`;

     

       69
       69
        
           my $res = {};

     

       70
       70
        
           foreach my $line (split '\n', $lines) {

     

       71
       71
        
               chomp $line;

     

       72
       72
        
               last if $line eq "";

     

       73
       73
       -
               $line =~ /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s/ or next;

     

       73
       73
       +
               $line =~ /^\*?\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s/ or next;

     

       74
       74
        
               next if $1 eq "UNIT";

     

       75
       75
        
               $res->{$1} = { load => $2, state => $3, substate => $4 };

     

       76
       76
        
           }

     
···

       96
       96
        
       

     

       97
       97
        
       sub parseUnit {

     

       98
       98
        
           my ($filename) = @_;

     

       99
       99
       -
           parseKeyValues(read_file($filename));

     

       99
       99
       +
           my $info = {};

     

       100
       100
       +
           parseKeyValues($info, read_file($filename));

     

       101
       101
       +
           parseKeyValues($info, read_file("${filename}.d/overrides.conf")) if -f "${filename}.d/overrides.conf";

     

       102
       102
       +
           return $info;

     

       100
       103
        
       }

     

       101
       104
        
       

     

       102
       105
        
       sub parseKeyValues {

     

       103
       103
       -
           my @lines = @_;

     

       104
       104
       -
           my $info = {};

     

       106
       106
       +
           my $info = shift;

     

       105
       107
        
           foreach my $line (@_) {

     

       106
       108
        
               # FIXME: not quite correct.

     

       107
       109
        
               $line =~ /^([^=]+)=(.*)$/ or next;

     

       108
       110
        
               $info->{$1} = $2;

     

       109
       111
        
           }

     

       110
       110
       -
           return $info;

     

       111
       112
        
       }

     

       112
       113
        
       

     

       113
       114
        
       sub boolIsTrue {

     

       114
       115
        
           my ($s) = @_;

     

       115
       116
        
           return $s eq "yes" || $s eq "true";

     

       117
       117
       +
       }

     

       118
       118
       +
       

     

       119
       119
       +
       # As a fingerprint for determining whether a unit has changed, we use

     

       120
       120
       +
       # its absolute path. If it has an override file, we append *its*

     

       121
       121
       +
       # absolute path as well.

     

       122
       122
       +
       sub fingerprintUnit {

     

       123
       123
       +
           my ($s) = @_;

     

       124
       124
       +
           return abs_path($s) . (-f "${s}.d/overrides.conf" ? " " . abs_path "${s}.d/overrides.conf" : "");

     

       116
       125
        
       }

     

       117
       126
        
       

     

       118
       127
        
       # Stop all services that no longer exist or have changed in the new

     
···

       166
       175
        
                   }

     

       167
       176
        
               }

     

       168
       177
        
       

     

       169
       169
       -
               elsif (abs_path($prevUnitFile) ne abs_path($newUnitFile)) {

     

       178
       178
       +
               elsif (fingerprintUnit($prevUnitFile) ne fingerprintUnit($newUnitFile)) {

     

       170
       179
        
                   if ($unit eq "sysinit.target" || $unit eq "basic.target" || $unit eq "multi-user.target" || $unit eq "graphical.target") {

     

       171
       180
        
                       # Do nothing.  These cannot be restarted directly.

     

       172
       181
        
                   } elsif ($unit =~ /\.mount$/) {

     
···

       354
       363
        
           elsif ($state->{state} eq "auto-restart") {

     

       355
       364
        
               # A unit in auto-restart state is a failure *if* it previously failed to start

     

       356
       365
        
               my $lines = `@systemd@/bin/systemctl show '$unit'`;

     

       357
       357
       -
               my $info = parseKeyValues(split "\n", $lines);

     

       366
       366
       +
               my $info = {};

     

       367
       367
       +
               parseKeyValues($info, split("\n", $lines));

     

       358
       368
        
       

     

       359
       369
        
               if ($info->{ExecMainStatus} ne '0') {

     

       360
       370
        
                   push @failed, $unit;

nixos/modules/system/activation/top-level.nix

···

       68
       68
        
             echo -n "$configurationName" > $out/configuration-name

     

       69
       69
        
             echo -n "systemd ${toString config.systemd.package.interfaceVersion}" > $out/init-interface-version

     

       70
       70
        
             echo -n "$nixosVersion" > $out/nixos-version

     

       71
       71
       +
             echo -n "$system" > $out/system

     

       71
       72
        
       

     

       72
       73
        
             mkdir $out/fine-tune

     

       73
       74
        
             childCount=0

+8 -19

nixos/modules/system/boot/kernel.nix

···

       218
       218
        
       

     

       219
       219
        
           # Create /etc/modules-load.d/nixos.conf, which is read by

     

       220
       220
        
           # systemd-modules-load.service to load required kernel modules.

     

       221
       221
       -
           # FIXME: ensure that systemd-modules-load.service is restarted if

     

       222
       222
       -
           # this file changes.

     

       223
       221
        
           environment.etc = singleton

     

       224
       222
        
             { target = "modules-load.d/nixos.conf";

     

       225
       223
        
               source = kernelModulesConf;

     

       226
       224
        
             };

     

       227
       225
        
       

     

       228
       228
       -
           # Sigh.  This overrides systemd's systemd-modules-load.service

     

       229
       229
       -
           # just so we can set a restart trigger.  Also make

     

       230
       230
       -
           # multi-user.target pull it in so that it gets started if it

     

       231
       231
       -
           # failed earlier.

     

       232
       226
        
           systemd.services."systemd-modules-load" =

     

       233
       233
       -
             { description = "Load Kernel Modules";

     

       234
       234
       -
               wantedBy = [ "sysinit.target" "multi-user.target" ];

     

       235
       235
       -
               before = [ "sysinit.target" "shutdown.target" ];

     

       236
       236
       -
               conflicts = [ "shutdown.target" ];

     

       237
       237
       -
               unitConfig =

     

       238
       238
       -
                 { DefaultDependencies = false;

     

       239
       239
       -
                   ConditionCapability = "CAP_SYS_MODULE";

     

       240
       240
       -
                 };

     

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

     

       228
       228
       +
               restartTriggers = [ kernelModulesConf ];

     

       229
       229
       +
               environment.MODULE_DIR = "/run/booted-system/kernel-modules/lib/modules";

     

       241
       230
        
               serviceConfig =

     

       242
       242
       -
                 { Type = "oneshot";

     

       243
       243
       -
                   RemainAfterExit = true;

     

       244
       244
       -
                   ExecStart = "${config.systemd.package}/lib/systemd/systemd-modules-load";

     

       245
       245
       -
                   # Ignore failed module loads.  Typically some of the

     

       231
       231
       +
                 { # Ignore failed module loads.  Typically some of the

     

       246
       232
        
                   # modules in ‘boot.kernelModules’ are "nice to have but

     

       247
       233
        
                   # not required" (e.g. acpi-cpufreq), so we don't want to

     

       248
       234
        
                   # barf on those.

     

       249
       235
        
                   SuccessExitStatus = "0 1";

     

       250
       236
        
                 };

     

       251
       251
       -
               restartTriggers = [ kernelModulesConf ];

     

       237
       237
       +
             };

     

       238
       238
       +
       

     

       239
       239
       +
           systemd.services.kmod-static-nodes =

     

       240
       240
       +
             { environment.MODULE_DIR = "/run/booted-system/kernel-modules/lib/modules";

     

       252
       241
        
             };

     

       253
       242
        
       

     

       254
       243
        
           lib.kernelConfig = {

-2

nixos/modules/system/boot/stage-1-init.sh

···

       139
       139
        
       systemd-udevd --daemon

     

       140
       140
        
       udevadm trigger --action=add

     

       141
       141
        
       udevadm settle || true

     

       142
       142
       -
       modprobe scsi_wait_scan || true

     

       143
       143
       -
       udevadm settle || true

     

       144
       142
        
       

     

       145
       143
        
       

     

       146
       144
        
       # Load boot-time keymap before any LVM/LUKS initialization

+1 -1

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

···

       74
       74
        
             cp -v ${pkgs.lvm2}/sbin/dmsetup $out/bin/dmsetup

     

       75
       75
        
             cp -v ${pkgs.lvm2}/sbin/lvm $out/bin/lvm

     

       76
       76
        
             cp -v ${pkgs.lvm2}/lib/libdevmapper.so.*.* $out/lib

     

       77
       77
       -
             cp -v ${pkgs.systemd}/lib/libsystemd-daemon.so.* $out/lib

     

       77
       77
       +
             cp -v ${pkgs.systemd}/lib/libsystemd.so.* $out/lib

     

       78
       78
        
       

     

       79
       79
        
             # Add RAID mdadm tool.

     

       80
       80
        
             cp -v ${pkgs.mdadm}/sbin/mdadm $out/bin/mdadm

+15 -15

nixos/modules/system/boot/stage-2-init.sh

···

       82
       82
        
       

     

       83
       83
        
       # More special file systems, initialise required directories.

     

       84
       84
        
       mkdir -m 0755 /dev/shm

     

       85
       85
       -
       mount -t tmpfs -o "rw,nosuid,nodev,size=@devShmSize@" tmpfs /dev/shm

     

       85
       85
       +
       mount -t tmpfs -o "rw,nosuid,nodev,size=@devShmSize@" none /dev/shm

     

       86
       86
        
       mkdir -m 0755 -p /dev/pts

     

       87
       87
        
       [ -e /proc/bus/usb ] && mount -t usbfs none /proc/bus/usb # UML doesn't have USB by default

     

       88
       88
        
       mkdir -m 01777 -p /tmp

     
···

       96
       96
        
       

     

       97
       97
        
       # Miscellaneous boot time cleanup.

     

       98
       98
        
       rm -rf /var/run /var/lock

     

       99
       99
       -
       rm -f /etc/resolv.conf

     

       100
       100
       -
       touch /etc/resolv.conf

     

       101
       99
        
       rm -f /etc/{group,passwd,shadow}.lock

     

       102
       100
        
       

     

       103
       101
        
       if test -n "@cleanTmpDir@"; then

     

       104
       102
        
           echo -n "cleaning \`/tmp'..."

     

       105
       103
        
           find /tmp -maxdepth 1 -mindepth 1 -print0 | xargs -0r rm -rf --one-file-system

     

       106
       104
        
           echo " done"

     

       107
       107
       -
       else

     

       108
       108
       -
           # Get rid of ICE locks...

     

       109
       109
       -
           rm -rf /tmp/.ICE-unix

     

       110
       105
        
       fi

     

       111
       111
       -
       

     

       112
       112
       -
       # ... and ensure that it's owned by root.

     

       113
       113
       -
       mkdir -m 1777 /tmp/.ICE-unix

     

       114
       114
       -
       

     

       115
       115
       -
       # This is a good time to clean up /nix/var/nix/chroots.  Doing an `rm

     

       116
       116
       -
       # -rf' on it isn't safe in general because it can contain bind mounts

     

       117
       117
       -
       # to /nix/store and other places.  But after rebooting these are all

     

       118
       118
       -
       # gone, of course.

     

       119
       119
       -
       rm -rf /nix/var/nix/chroots # recreated in activate-configuration.sh

     

       120
       106
        
       

     

       121
       107
        
       

     

       122
       108
        
       # Also get rid of temporary GC roots.

     
···

       153
       139
        
       if test -n "$resumeDevice"; then

     

       154
       140
        
           mkswap "$resumeDevice" || echo 'Failed to clear saved image.'

     

       155
       141
        
       fi

     

       142
       142
       +
       

     

       143
       143
       +
       

     

       144
       144
       +
       # Use /etc/resolv.conf supplied by systemd-nspawn, if applicable.

     

       145
       145
       +
       if [ -n "@useHostResolvConf@" -a -e /etc/resolv.conf ]; then

     

       146
       146
       +
           cat /etc/resolv.conf | resolvconf -m 1000 -a host

     

       147
       147
       +
       else

     

       148
       148
       +
           touch /etc/resolv.conf

     

       149
       149
       +
       fi

     

       150
       150
       +
       

     

       151
       151
       +
       

     

       152
       152
       +
       # Create /var/setuid-wrappers as a tmpfs.

     

       153
       153
       +
       rm -rf /var/setuid-wrappers

     

       154
       154
       +
       mkdir -m 0755 -p /var/setuid-wrappers

     

       155
       155
       +
       mount -t tmpfs -o "mode=0755" none /var/setuid-wrappers

     

       156
       156
        
       

     

       157
       157
        
       

     

       158
       158
        
       # Run the script that performs all configuration activation that does

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

···

       19
       19
        
           isExecutable = true;

     

       20
       20
        
           inherit (config.boot) devShmSize runSize cleanTmpDir;

     

       21
       21
        
           inherit (config.nix) readOnlyStore;

     

       22
       22
       +
           inherit (config.networking) useHostResolvConf;

     

       22
       23
        
           ttyGid = config.ids.gids.tty;

     

       23
       24
        
           path =

     

       24
       25
        
             [ pkgs.coreutils

     

       25
       26
        
               pkgs.utillinux

     

       26
       27
        
               pkgs.sysvtools

     

       28
       28
       +
               pkgs.openresolv

     

       27
       29
        
             ] ++ (optional config.boot.cleanTmpDir pkgs.findutils)

     

       28
       30
        
             ++ optional config.nix.readOnlyStore readonlyMountpoint;

     

       29
       31
        
           postBootCommands = pkgs.writeText "local-cmds"

     
···

       79
       81
        
               '';

     

       80
       82
        
             };

     

       81
       83
        
       

     

       84
       84
       +
             # FIXME: should replace this with something that uses systemd-tmpfiles.

     

       82
       85
        
             cleanTmpDir = mkOption {

     

       83
       86
        
               type = types.bool;

     

       84
       87
        
               default = false;

+37 -22

nixos/modules/system/boot/systemd-unit-options.nix

···

       28
       28
        
       

     

       29
       29
        
       in rec {

     

       30
       30
        
       

     

       31
       31
       -
         unitOptions = {

     

       31
       31
       +
         sharedOptions = {

     

       32
       32
        
       

     

       33
       33
        
           enable = mkOption {

     

       34
       34
        
             default = true;

     
···

       41
       41
        
             '';

     

       42
       42
        
           };

     

       43
       43
        
       

     

       44
       44
       -
           baseUnit = mkOption {

     

       45
       45
       -
             type = types.nullOr types.path;

     

       44
       44
       +
           requiredBy = mkOption {

     

       45
       45
       +
             default = [];

     

       46
       46
       +
             type = types.listOf types.string;

     

       47
       47
       +
             description = "Units that require (i.e. depend on and need to go down with) this unit.";

     

       48
       48
       +
           };

     

       49
       49
       +
       

     

       50
       50
       +
           wantedBy = mkOption {

     

       51
       51
       +
             default = [];

     

       52
       52
       +
             type = types.listOf types.string;

     

       53
       53
       +
             description = "Units that want (i.e. depend on) this unit.";

     

       54
       54
       +
           };

     

       55
       55
       +
       

     

       56
       56
       +
         };

     

       57
       57
       +
       

     

       58
       58
       +
         concreteUnitOptions = sharedOptions // {

     

       59
       59
       +
       

     

       60
       60
       +
           text = mkOption {

     

       61
       61
       +
             type = types.nullOr types.str;

     

       46
       62
        
             default = null;

     

       47
       47
       -
             description = "Path to an upstream unit file on which the NixOS unit configuration will be based.";

     

       63
       63
       +
             description = "Text of this systemd unit.";

     

       64
       64
       +
           };

     

       65
       65
       +
       

     

       66
       66
       +
           unit = mkOption {

     

       67
       67
       +
             internal = true;

     

       68
       68
       +
             description = "The generated unit.";

     

       48
       69
        
           };

     

       49
       70
        
       

     

       71
       71
       +
         };

     

       72
       72
       +
       

     

       73
       73
       +
         commonUnitOptions = sharedOptions // {

     

       74
       74
       +
       

     

       50
       75
        
           description = mkOption {

     

       51
       76
        
             default = "";

     

       52
       77
        
             type = types.str;

     
···

       113
       138
        
               If the specified units are started, then this unit is stopped

     

       114
       139
        
               and vice versa.

     

       115
       140
        
             '';

     

       116
       116
       -
           };

     

       117
       117
       -
       

     

       118
       118
       -
           requiredBy = mkOption {

     

       119
       119
       -
             default = [];

     

       120
       120
       -
             type = types.listOf types.str;

     

       121
       121
       -
             description = "Units that require (i.e. depend on and need to go down with) this unit.";

     

       122
       122
       -
           };

     

       123
       123
       -
       

     

       124
       124
       -
           wantedBy = mkOption {

     

       125
       125
       -
             default = [];

     

       126
       126
       -
             type = types.listOf types.str;

     

       127
       127
       -
             description = "Units that want (i.e. depend on) this unit.";

     

       128
       141
        
           };

     

       129
       142
        
       

     

       130
       143
        
           unitConfig = mkOption {

     
···

       152
       165
        
         };

     

       153
       166
        
       

     

       154
       167
        
       

     

       155
       155
       -
         serviceOptions = unitOptions // {

     

       168
       168
       +
         serviceOptions = commonUnitOptions // {

     

       156
       169
        
       

     

       157
       170
        
           environment = mkOption {

     

       158
       171
        
             default = {};

     
···

       286
       299
        
         };

     

       287
       300
        
       

     

       288
       301
        
       

     

       289
       289
       -
         socketOptions = unitOptions // {

     

       302
       302
       +
         socketOptions = commonUnitOptions // {

     

       290
       303
        
       

     

       291
       304
        
           listenStreams = mkOption {

     

       292
       305
        
             default = [];

     
···

       313
       326
        
         };

     

       314
       327
        
       

     

       315
       328
        
       

     

       316
       316
       -
         timerOptions = unitOptions // {

     

       329
       329
       +
         timerOptions = commonUnitOptions // {

     

       317
       330
        
       

     

       318
       331
        
           timerConfig = mkOption {

     

       319
       332
        
             default = {};

     
···

       332
       345
        
         };

     

       333
       346
        
       

     

       334
       347
        
       

     

       335
       335
       -
         pathOptions = unitOptions // {

     

       348
       348
       +
         pathOptions = commonUnitOptions // {

     

       336
       349
        
       

     

       337
       350
        
           pathConfig = mkOption {

     

       338
       351
        
             default = {};

     
···

       349
       362
        
         };

     

       350
       363
        
       

     

       351
       364
        
       

     

       352
       352
       -
         mountOptions = unitOptions // {

     

       365
       365
       +
         mountOptions = commonUnitOptions // {

     

       353
       366
        
       

     

       354
       367
        
           what = mkOption {

     

       355
       368
        
             example = "/dev/sda1";

     
···

       393
       406
        
           };

     

       394
       407
        
         };

     

       395
       408
        
       

     

       396
       396
       -
         automountOptions = unitOptions // {

     

       409
       409
       +
         automountOptions = commonUnitOptions // {

     

       397
       410
        
       

     

       398
       411
        
           where = mkOption {

     

       399
       412
        
             example = "/mnt";

     
···

       416
       429
        
             '';

     

       417
       430
        
           };

     

       418
       431
        
         };

     

       432
       432
       +
       

     

       433
       433
       +
         targetOptions = commonUnitOptions;

     

       419
       434
        
       

     

       420
       435
        
       }

+171 -107

nixos/modules/system/boot/systemd.nix

···

       24
       24
        
                 ln -s /dev/null $out/${name}

     

       25
       25
        
               '';

     

       26
       26
        
       

     

       27
       27
       -
         upstreamUnits =

     

       27
       27
       +
         upstreamSystemUnits =

     

       28
       28
        
           [ # Targets.

     

       29
       29
        
             "basic.target"

     

       30
       30
        
             "sysinit.target"

     

       31
       31
        
             "sockets.target"

     

       32
       32
        
             "graphical.target"

     

       33
       33
        
             "multi-user.target"

     

       34
       34
       -
             "getty.target"

     

       35
       34
        
             "network.target"

     

       36
       35
        
             "network-online.target"

     

       37
       36
        
             "nss-lookup.target"

     
···

       41
       40
        
             "sigpwr.target"

     

       42
       41
        
             "timers.target"

     

       43
       42
        
             "paths.target"

     

       43
       43
       +
             "rpcbind.target"

     

       44
       44
        
       

     

       45
       45
        
             # Rescue mode.

     

       46
       46
        
             "rescue.target"

     
···

       53
       53
        
             "systemd-udev-settle.service"

     

       54
       54
        
             "systemd-udev-trigger.service"

     

       55
       55
        
       

     

       56
       56
       +
             # Consoles.

     

       57
       57
       +
             "getty.target"

     

       58
       58
       +
             "getty@.service"

     

       59
       59
       +
             "serial-getty@.service"

     

       60
       60
       +
             "container-getty@.service"

     

       61
       61
       +
             "systemd-vconsole-setup.service"

     

       62
       62
       +
       

     

       56
       63
        
             # Hardware (started by udev when a relevant device is plugged in).

     

       57
       64
        
             "sound.target"

     

       58
       65
        
             "bluetooth.target"

     
···

       65
       72
        
             #"systemd-vconsole-setup.service"

     

       66
       73
        
             "systemd-user-sessions.service"

     

       67
       74
        
             "dbus-org.freedesktop.login1.service"

     

       75
       75
       +
             "dbus-org.freedesktop.machine1.service"

     

       68
       76
        
             "user@.service"

     

       69
       77
        
       

     

       70
       78
        
             # Journal.

     

       71
       79
        
             "systemd-journald.socket"

     

       72
       80
        
             "systemd-journald.service"

     

       73
       81
        
             "systemd-journal-flush.service"

     

       82
       82
       +
             "systemd-journal-gatewayd.socket"

     

       83
       83
       +
             "systemd-journal-gatewayd.service"

     

       74
       84
        
             "syslog.socket"

     

       75
       85
        
       

     

       76
       86
        
             # SysV init compatibility.

     
···

       78
       88
        
             "systemd-initctl.service"

     

       79
       89
        
       

     

       80
       90
        
             # Kernel module loading.

     

       81
       81
       -
             #"systemd-modules-load.service"

     

       91
       91
       +
             "systemd-modules-load.service"

     

       92
       92
       +
             "kmod-static-nodes.service"

     

       82
       93
        
       

     

       83
       94
        
             # Filesystems.

     

       84
       95
        
             "systemd-fsck@.service"

     
···

       91
       102
        
             "swap.target"

     

       92
       103
        
             "dev-hugepages.mount"

     

       93
       104
        
             "dev-mqueue.mount"

     

       105
       105
       +
             "proc-sys-fs-binfmt_misc.mount"

     

       94
       106
        
             "sys-fs-fuse-connections.mount"

     

       95
       107
        
             "sys-kernel-config.mount"

     

       96
       108
        
             "sys-kernel-debug.mount"

     

       97
       109
        
       

     

       110
       110
       +
             # Maintaining state across reboots.

     

       111
       111
       +
             "systemd-random-seed.service"

     

       112
       112
       +
             "systemd-backlight@.service"

     

       113
       113
       +
             "systemd-rfkill@.service"

     

       114
       114
       +
       

     

       98
       115
        
             # Hibernate / suspend.

     

       99
       116
        
             "hibernate.target"

     

       100
       117
        
             "suspend.target"

     
···

       119
       136
        
             "final.target"

     

       120
       137
        
             "kexec.target"

     

       121
       138
        
             "systemd-kexec.service"

     

       139
       139
       +
             "systemd-update-utmp.service"

     

       122
       140
        
       

     

       123
       141
        
             # Password entry.

     

       124
       142
        
             "systemd-ask-password-console.path"

     

       125
       143
        
             "systemd-ask-password-console.service"

     

       126
       144
        
             "systemd-ask-password-wall.path"

     

       127
       145
        
             "systemd-ask-password-wall.service"

     

       146
       146
       +
       

     

       147
       147
       +
             # Slices / containers.

     

       148
       148
       +
             "slices.target"

     

       149
       149
       +
             "-.slice"

     

       150
       150
       +
             "system.slice"

     

       151
       151
       +
             "user.slice"

     

       152
       152
       +
             "machine.slice"

     

       153
       153
       +
             "systemd-machined.service"

     

       154
       154
       +
       

     

       155
       155
       +
             # Temporary file creation / cleanup.

     

       156
       156
       +
             "systemd-tmpfiles-clean.service"

     

       157
       157
       +
             "systemd-tmpfiles-clean.timer"

     

       158
       158
       +
             "systemd-tmpfiles-setup.service"

     

       159
       159
       +
             "systemd-tmpfiles-setup-dev.service"

     

       160
       160
       +
       

     

       161
       161
       +
             # Misc.

     

       162
       162
       +
             "systemd-sysctl.service"

     

       128
       163
        
           ]

     

       129
       164
        
       

     

       130
       165
        
           ++ optionals cfg.enableEmergencyMode [

     

       131
       166
        
             "emergency.target"

     

       132
       167
        
             "emergency.service"

     

       133
       133
       -
           ]

     

       134
       134
       -
       

     

       135
       135
       -
           ++ optionals config.services.journald.enableHttpGateway [

     

       136
       136
       -
             "systemd-journal-gatewayd.socket"

     

       137
       137
       -
             "systemd-journal-gatewayd.service"

     

       138
       168
        
           ];

     

       139
       169
        
       

     

       140
       140
       -
         upstreamWants =

     

       170
       170
       +
         upstreamSystemWants =

     

       141
       171
        
           [ #"basic.target.wants"

     

       142
       172
        
             "sysinit.target.wants"

     

       143
       173
        
             "sockets.target.wants"

     

       144
       174
        
             "local-fs.target.wants"

     

       145
       175
        
             "multi-user.target.wants"

     

       146
       146
       -
             "shutdown.target.wants"

     

       147
       176
        
             "timers.target.wants"

     

       148
       177
        
           ];

     

       149
       178
        
       

     

       179
       179
       +
         upstreamUserUnits =

     

       180
       180
       +
           [ "basic.target"

     

       181
       181
       +
             "default.target"

     

       182
       182
       +
             "exit.target"

     

       183
       183
       +
             "paths.target"

     

       184
       184
       +
             "shutdown.target"

     

       185
       185
       +
             "sockets.target"

     

       186
       186
       +
             "systemd-exit.service"

     

       187
       187
       +
             "timers.target"

     

       188
       188
       +
           ];

     

       189
       189
       +
       

     

       150
       190
        
         makeJobScript = name: text:

     

       151
       191
        
           let x = pkgs.writeTextFile { name = "unit-script"; executable = true; destination = "/bin/${name}"; inherit text; };

     

       152
       192
        
           in "${x}/bin/${name}";

     
···

       178
       218
        
       

     

       179
       219
        
         serviceConfig = { name, config, ... }: {

     

       180
       220
        
           config = mkMerge

     

       181
       181
       -
             [ (mkIf (config.baseUnit == null) { # Default path for systemd services.  Should be quite minimal.

     

       221
       221
       +
             [ { # Default path for systemd services.  Should be quite minimal.

     

       182
       222
        
                 path =

     

       183
       223
        
                   [ pkgs.coreutils

     

       184
       224
        
                     pkgs.findutils

     
···

       187
       227
        
                     systemd

     

       188
       228
        
                   ];

     

       189
       229
        
                 environment.PATH = config.path;

     

       190
       190
       -
               })

     

       230
       230
       +
               }

     

       191
       231
        
               (mkIf (config.preStart != "")

     

       192
       232
        
                 { serviceConfig.ExecStartPre = makeJobScript "${name}-pre-start" ''

     

       193
       233
        
                     #! ${pkgs.stdenv.shell} -e

     
···

       255
       295
        
               (if isList value then value else [value]))

     

       256
       296
        
               as));

     

       257
       297
        
       

     

       258
       258
       -
         commonUnitText = def:

     

       259
       259
       -
           optionalString (def.baseUnit != null) ''

     

       260
       260
       -
             .include ${def.baseUnit}

     

       261
       261
       -
           '' + ''

     

       298
       298
       +
         commonUnitText = def: ''

     

       262
       299
        
             [Unit]

     

       263
       300
        
             ${attrsToSection def.unitConfig}

     

       264
       301
        
           '';

     
···

       335
       372
        
               '';

     

       336
       373
        
           };

     

       337
       374
        
       

     

       338
       338
       -
         units = pkgs.runCommand "units" { preferLocalBuild = true; }

     

       339
       339
       -
           ''

     

       375
       375
       +
         generateUnits = type: units: upstreamUnits: upstreamWants:

     

       376
       376
       +
           pkgs.runCommand "${type}-units" { preferLocalBuild = true; } ''

     

       340
       377
        
             mkdir -p $out

     

       378
       378
       +
       

     

       379
       379
       +
             # Copy the upstream systemd units we're interested in.

     

       341
       380
        
             for i in ${toString upstreamUnits}; do

     

       342
       342
       -
               fn=${systemd}/example/systemd/system/$i

     

       381
       381
       +
               fn=${systemd}/example/systemd/${type}/$i

     

       343
       382
        
               if ! [ -e $fn ]; then echo "missing $fn"; false; fi

     

       344
       383
        
               if [ -L $fn ]; then

     

       345
       345
       -
                 cp -pd $fn $out/

     

       384
       384
       +
                 target="$(readlink "$fn")"

     

       385
       385
       +
                 if [ ''${target:0:3} = ../ ]; then

     

       386
       386
       +
                   ln -s "$(readlink -f "$fn")" $out/

     

       387
       387
       +
                 else

     

       388
       388
       +
                   cp -pd $fn $out/

     

       389
       389
       +
                 fi

     

       346
       390
        
               else

     

       347
       391
        
                 ln -s $fn $out/

     

       348
       392
        
               fi

     

       349
       393
        
             done

     

       350
       394
        
       

     

       395
       395
       +
             # Copy .wants links, but only those that point to units that

     

       396
       396
       +
             # we're interested in.

     

       351
       397
        
             for i in ${toString upstreamWants}; do

     

       352
       352
       -
               fn=${systemd}/example/systemd/system/$i

     

       398
       398
       +
               fn=${systemd}/example/systemd/${type}/$i

     

       353
       399
        
               if ! [ -e $fn ]; then echo "missing $fn"; false; fi

     

       354
       400
        
               x=$out/$(basename $fn)

     

       355
       401
        
               mkdir $x

     

       356
       402
        
               for i in $fn/*; do

     

       357
       403
        
                 y=$x/$(basename $i)

     

       358
       404
        
                 cp -pd $i $y

     

       359
       359
       -
                 if ! [ -e $y ]; then rm -v $y; fi

     

       405
       405
       +
                 if ! [ -e $y ]; then rm $y; fi

     

       360
       406
        
               done

     

       361
       407
        
             done

     

       362
       408
        
       

     

       363
       363
       -
             for i in ${toString (mapAttrsToList (n: v: v.unit) cfg.units)}; do

     

       364
       364
       -
               ln -fs $i/* $out/

     

       409
       409
       +
             # Symlink all units provided listed in systemd.packages.

     

       410
       410
       +
             for i in ${toString cfg.packages}; do

     

       411
       411
       +
               files=$(echo $i/etc/systemd/${type}/* $i/lib/systemd/${type}/*)

     

       412
       412
       +
               if [ -n "$files" ]; then

     

       413
       413
       +
                 ln -s $files $out/

     

       414
       414
       +
               fi

     

       365
       415
        
             done

     

       366
       416
        
       

     

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

     

       368
       368
       -
               ln -s $i/etc/systemd/system/* $out/

     

       417
       417
       +
             # Symlink all units defined by systemd.units. If these are also

     

       418
       418
       +
             # provided by systemd or systemd.packages, then add them as

     

       419
       419
       +
             # <unit-name>.d/overrides.conf, which makes them extend the

     

       420
       420
       +
             # upstream unit.

     

       421
       421
       +
             for i in ${toString (mapAttrsToList (n: v: v.unit) units)}; do

     

       422
       422
       +
               fn=$(basename $i/*)

     

       423
       423
       +
               if [ -e $out/$fn ]; then

     

       424
       424
       +
                 if [ "$(readlink -f $i/$fn)" = /dev/null ]; then

     

       425
       425
       +
                   ln -sfn /dev/null $out/$fn

     

       426
       426
       +
                 else

     

       427
       427
       +
                   mkdir $out/$fn.d

     

       428
       428
       +
                   ln -s $i/$fn $out/$fn.d/overrides.conf

     

       429
       429
       +
                 fi

     

       430
       430
       +
              else

     

       431
       431
       +
                 ln -fs $i/$fn $out/

     

       432
       432
       +
               fi

     

       369
       433
        
             done

     

       370
       434
        
       

     

       435
       435
       +
             # Created .wants and .requires symlinks from the wantedBy and

     

       436
       436
       +
             # requiredBy options.

     

       371
       437
        
             ${concatStrings (mapAttrsToList (name: unit:

     

       372
       438
        
                 concatMapStrings (name2: ''

     

       373
       439
        
                   mkdir -p $out/'${name2}.wants'

     

       374
       440
        
                   ln -sfn '../${name}' $out/'${name2}.wants'/

     

       375
       375
       -
                 '') unit.wantedBy) cfg.units)}

     

       441
       441
       +
                 '') unit.wantedBy) units)}

     

       376
       442
        
       

     

       377
       443
        
             ${concatStrings (mapAttrsToList (name: unit:

     

       378
       444
        
                 concatMapStrings (name2: ''

     

       379
       445
        
                   mkdir -p $out/'${name2}.requires'

     

       380
       446
        
                   ln -sfn '../${name}' $out/'${name2}.requires'/

     

       381
       381
       -
                 '') unit.requiredBy) cfg.units)}

     

       382
       382
       -
       

     

       383
       383
       -
             ln -s ${cfg.defaultUnit} $out/default.target

     

       447
       447
       +
                 '') unit.requiredBy) units)}

     

       384
       448
        
       

     

       385
       385
       -
             ln -s rescue.target $out/kbrequest.target

     

       449
       449
       +
             ${optionalString (type == "system") ''

     

       450
       450
       +
               # Stupid misc. symlinks.

     

       451
       451
       +
               ln -s ${cfg.defaultUnit} $out/default.target

     

       386
       452
        
       

     

       387
       387
       -
             mkdir -p $out/getty.target.wants/

     

       388
       388
       -
             ln -s ../autovt@tty1.service $out/getty.target.wants/

     

       453
       453
       +
               ln -s rescue.target $out/kbrequest.target

     

       389
       454
        
       

     

       390
       390
       -
             ln -s ../local-fs.target ../remote-fs.target ../network.target ../nss-lookup.target \

     

       391
       391
       -
                   ../nss-user-lookup.target ../swap.target $out/multi-user.target.wants/

     

       455
       455
       +
               mkdir -p $out/getty.target.wants/

     

       456
       456
       +
               ln -s ../autovt@tty1.service $out/getty.target.wants/

     

       392
       457
        
       

     

       393
       393
       -
             ${ optionalString config.services.journald.enableHttpGateway ''

     

       394
       394
       -
             ln -s ../systemd-journal-gatewayd.service $out/multi-user-target.wants/

     

       458
       458
       +
               ln -s ../local-fs.target ../remote-fs.target ../network.target ../nss-lookup.target \

     

       459
       459
       +
                     ../nss-user-lookup.target ../swap.target $out/multi-user.target.wants/

     

       395
       460
        
             ''}

     

       396
       461
        
           ''; # */

     

       397
       462
        
       

     
···

       414
       479
        
             default = {};

     

       415
       480
        
             type = types.attrsOf types.optionSet;

     

       416
       481
        
             options = { name, config, ... }:

     

       417
       417
       -
               { options = {

     

       418
       418
       -
                   text = mkOption {

     

       419
       419
       -
                     type = types.nullOr types.str;

     

       420
       420
       -
                     default = null;

     

       421
       421
       -
                     description = "Text of this systemd unit.";

     

       422
       422
       -
                   };

     

       423
       423
       -
                   enable = mkOption {

     

       424
       424
       -
                     default = true;

     

       425
       425
       -
                     type = types.bool;

     

       426
       426
       -
                     description = ''

     

       427
       427
       -
                       If set to false, this unit will be a symlink to

     

       428
       428
       -
                       /dev/null. This is primarily useful to prevent specific

     

       429
       429
       -
                       template instances (e.g. <literal>serial-getty@ttyS0</literal>)

     

       430
       430
       -
                       from being started.

     

       431
       431
       -
                     '';

     

       432
       432
       -
                   };

     

       433
       433
       -
                   requiredBy = mkOption {

     

       434
       434
       -
                     default = [];

     

       435
       435
       -
                     type = types.listOf types.string;

     

       436
       436
       -
                     description = "Units that require (i.e. depend on and need to go down with) this unit.";

     

       437
       437
       -
                   };

     

       438
       438
       -
                   wantedBy = mkOption {

     

       439
       439
       -
                     default = [];

     

       440
       440
       -
                     type = types.listOf types.string;

     

       441
       441
       -
                     description = "Units that want (i.e. depend on) this unit.";

     

       442
       442
       -
                   };

     

       443
       443
       -
                   unit = mkOption {

     

       444
       444
       -
                     internal = true;

     

       445
       445
       -
                     description = "The generated unit.";

     

       446
       446
       -
                   };

     

       447
       447
       -
                 };

     

       482
       482
       +
               { options = concreteUnitOptions;

     

       448
       483
        
                 config = {

     

       449
       484
        
                   unit = mkDefault (makeUnit name config);

     

       450
       485
        
                 };

     
···

       460
       495
        
           systemd.targets = mkOption {

     

       461
       496
        
             default = {};

     

       462
       497
        
             type = types.attrsOf types.optionSet;

     

       463
       463
       -
             options = [ unitOptions unitConfig ];

     

       498
       498
       +
             options = [ targetOptions unitConfig ];

     

       464
       499
        
             description = "Definition of systemd target units.";

     

       465
       500
        
           };

     

       466
       501
        
       

     
···

       583
       618
        
             default = false;

     

       584
       619
        
             type = types.bool;

     

       585
       620
        
             description = ''

     

       586
       586
       -
               Enable journal http gateway

     

       621
       621
       +
               Whether to enable the HTTP gateway to the journal.

     

       587
       622
        
             '';

     

       588
       623
        
           };

     

       589
       624
        
       

     
···

       610
       645
        
             '';

     

       611
       646
        
           };

     

       612
       647
        
       

     

       648
       648
       +
           systemd.tmpfiles.rules = mkOption {

     

       649
       649
       +
             type = types.listOf types.str;

     

       650
       650
       +
             default = [];

     

       651
       651
       +
             example = [ "d /tmp 1777 root root 10d" ];

     

       652
       652
       +
             description = ''

     

       653
       653
       +
               Rules for creating and cleaning up temporary files

     

       654
       654
       +
               automatically. See

     

       655
       655
       +
               <citerefentry><refentrytitle>tmpfiles.d</refentrytitle><manvolnum>5</manvolnum></citerefentry>

     

       656
       656
       +
               for the exact format. You should not use this option to create

     

       657
       657
       +
               files required by systemd services, since there is no

     

       658
       658
       +
               guarantee that <command>systemd-tmpfiles</command> runs when

     

       659
       659
       +
               the system is reconfigured using

     

       660
       660
       +
               <command>nixos-rebuild</command>.

     

       661
       661
       +
             '';

     

       662
       662
       +
           };

     

       663
       663
       +
       

     

       664
       664
       +
           systemd.user.units = mkOption {

     

       665
       665
       +
             description = "Definition of systemd per-user units.";

     

       666
       666
       +
             default = {};

     

       667
       667
       +
             type = types.attrsOf types.optionSet;

     

       668
       668
       +
             options = { name, config, ... }:

     

       669
       669
       +
               { options = concreteUnitOptions;

     

       670
       670
       +
                 config = {

     

       671
       671
       +
                   unit = mkDefault (makeUnit name config);

     

       672
       672
       +
                 };

     

       673
       673
       +
               };

     

       674
       674
       +
           };

     

       675
       675
       +
       

     

       676
       676
       +
           systemd.user.services = mkOption {

     

       677
       677
       +
             default = {};

     

       678
       678
       +
             type = types.attrsOf types.optionSet;

     

       679
       679
       +
             options = [ serviceOptions unitConfig serviceConfig ];

     

       680
       680
       +
             description = "Definition of systemd per-user service units.";

     

       681
       681
       +
           };

     

       682
       682
       +
       

     

       613
       683
        
         };

     

       614
       684
        
       

     

       615
       685
        
       

     
···

       617
       687
        
       

     

       618
       688
        
         config = {

     

       619
       689
        
       

     

       620
       620
       -
           system.build.units = units;

     

       690
       690
       +
           assertions = mapAttrsToList (name: service: {

     

       691
       691
       +
             assertion = service.serviceConfig.Type or "" == "oneshot" -> service.serviceConfig.Restart or "no" == "no";

     

       692
       692
       +
             message = "${name}: Type=oneshot services must have Restart=no";

     

       693
       693
       +
           }) cfg.services;

     

       694
       694
       +
       

     

       695
       695
       +
           system.build.units = cfg.units;

     

       621
       696
        
       

     

       622
       697
        
           environment.systemPackages = [ systemd ];

     

       623
       698
        
       

     

       624
       624
       -
           environment.etc."systemd/system".source = units;

     

       699
       699
       +
           environment.etc."systemd/system".source =

     

       700
       700
       +
             generateUnits "system" cfg.units upstreamSystemUnits upstreamSystemWants;

     

       701
       701
       +
       

     

       702
       702
       +
           environment.etc."systemd/user".source =

     

       703
       703
       +
             generateUnits "user" cfg.user.units upstreamUserUnits [];

     

       625
       704
        
       

     

       626
       705
        
           environment.etc."systemd/system.conf".text =

     

       627
       706
        
             ''

     
···

       685
       764
        
                          (v: let n = escapeSystemdPath v.where;

     

       686
       765
        
                              in nameValuePair "${n}.automount" (automountToUnit n v)) cfg.automounts);

     

       687
       766
        
       

     

       767
       767
       +
           systemd.user.units =

     

       768
       768
       +
             mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.user.services;

     

       769
       769
       +
       

     

       688
       770
        
           system.requiredKernelConfig = map config.lib.kernelConfig.isEnabled [

     

       689
       771
        
             "CGROUPS" "AUTOFS4_FS" "DEVTMPFS"

     

       690
       772
        
           ];

     
···

       708
       790
        
               })

     

       709
       791
        
               (filterAttrs (name: service: service.startAt != "") cfg.services);

     

       710
       792
        
       

     

       711
       711
       -
           # FIXME: These are borrowed from upstream systemd.

     

       712
       712
       -
           systemd.services."systemd-update-utmp" =

     

       713
       713
       -
             { description = "Update UTMP about System Reboot/Shutdown";

     

       714
       714
       -
               wantedBy = [ "sysinit.target" ];

     

       715
       715
       -
               after = [ "systemd-remount-fs.service" ];

     

       716
       716
       -
               before = [ "sysinit.target" "shutdown.target" ];

     

       717
       717
       -
               conflicts = [ "shutdown.target" ];

     

       718
       718
       -
               unitConfig = {

     

       719
       719
       -
                 DefaultDependencies = false;

     

       720
       720
       -
                 RequiresMountsFor = "/var/log";

     

       721
       721
       -
               };

     

       722
       722
       -
               serviceConfig = {

     

       723
       723
       -
                 Type = "oneshot";

     

       724
       724
       -
                 RemainAfterExit = true;

     

       725
       725
       -
                 ExecStart = "${systemd}/lib/systemd/systemd-update-utmp reboot";

     

       726
       726
       -
                 ExecStop = "${systemd}/lib/systemd/systemd-update-utmp shutdown";

     

       727
       727
       -
               };

     

       728
       728
       -
               restartIfChanged = false;

     

       793
       793
       +
           systemd.sockets.systemd-journal-gatewayd.wantedBy =

     

       794
       794
       +
             optional config.services.journald.enableHttpGateway "sockets.target";

     

       795
       795
       +
       

     

       796
       796
       +
           # Provide the systemd-user PAM service, required to run systemd

     

       797
       797
       +
           # user instances.

     

       798
       798
       +
           security.pam.services.systemd-user =

     

       799
       799
       +
             { # Ensure that pam_systemd gets included. This is special-cased

     

       800
       800
       +
               # in systemd to provide XDG_RUNTIME_DIR.

     

       801
       801
       +
               startSession = true;

     

       729
       802
        
             };

     

       730
       803
        
       

     

       731
       731
       -
           systemd.services."systemd-random-seed" =

     

       732
       732
       -
             { description = "Load/Save Random Seed";

     

       733
       733
       -
               wantedBy = [ "sysinit.target" "multi-user.target" ];

     

       734
       734
       -
               after = [ "systemd-remount-fs.service" ];

     

       735
       735
       -
               before = [ "sysinit.target" "shutdown.target" ];

     

       736
       736
       -
               conflicts = [ "shutdown.target" ];

     

       737
       737
       -
               unitConfig = {

     

       738
       738
       -
                 DefaultDependencies = false;

     

       739
       739
       -
                 RequiresMountsFor = "/var/lib";

     

       740
       740
       -
               };

     

       741
       741
       -
               serviceConfig = {

     

       742
       742
       -
                 Type = "oneshot";

     

       743
       743
       -
                 RemainAfterExit = true;

     

       744
       744
       -
                 ExecStart = "${systemd}/lib/systemd/systemd-random-seed load";

     

       745
       745
       -
                 ExecStop = "${systemd}/lib/systemd/systemd-random-seed save";

     

       746
       746
       -
               };

     

       747
       747
       -
             };

     

       804
       804
       +
           environment.etc."tmpfiles.d/x11.conf".source = "${systemd}/example/tmpfiles.d/x11.conf";

     

       805
       805
       +
       

     

       806
       806
       +
           environment.etc."tmpfiles.d/nixos.conf".text =

     

       807
       807
       +
             ''

     

       808
       808
       +
               # This file is created automatically and should not be modified.

     

       809
       809
       +
               # Please change the option ‘systemd.tmpfiles.rules’ instead.

     

       810
       810
       +
               ${concatStringsSep "\n" cfg.tmpfiles.rules}

     

       811
       811
       +
             '';

     

       748
       812
        
       

     

       749
       813
        
         };

     

       750
       814
        
       }

+1 -1

nixos/modules/system/upstart/upstart.nix

···

       93
       93
        
                   if job.daemonType == "fork" || job.daemonType == "daemon" then { Type = "forking"; GuessMainPID = true; } else

     

       94
       94
        
                   if job.daemonType == "none" then { } else

     

       95
       95
        
                   throw "invalid daemon type `${job.daemonType}'")

     

       96
       96
       -
               // optionalAttrs (!job.task && job.respawn)

     

       96
       96
       +
               // optionalAttrs (!job.task && !(job.script == "" && job.exec == "") && job.respawn)

     

       97
       97
        
                 { Restart = "always"; }

     

       98
       98
        
               // optionalAttrs job.task

     

       99
       99
        
                 { Type = "oneshot"; RemainAfterExit = false; };

+24 -22

nixos/modules/tasks/cpu-freq.nix

···

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cpupower = config.boot.kernelPackages.cpupower;

     

       7
       7
       +
         cfg = config.powerManagement;

     

       8
       8
       +
       in

     

       9
       9
       +
       

     

       5
       10
        
       {

     

       6
       11
        
         ###### interface

     

       7
       12
        
       

     
···

       23
       28
        
       

     

       24
       29
        
         ###### implementation

     

       25
       30
        
       

     

       26
       26
       -
         config = mkIf (config.powerManagement.cpuFreqGovernor != null) {

     

       27
       27
       -
       

     

       28
       28
       -
           environment.systemPackages = [ pkgs.cpufrequtils ];

     

       29
       29
       -
       

     

       30
       30
       -
           jobs.cpufreq =

     

       31
       31
       -
             { description = "CPU Frequency Governor Setup";

     

       32
       32
       -
       

     

       33
       33
       -
               after = [ "systemd-modules-load.service" ];

     

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

     

       31
       31
       +
         config = mkIf (!config.boot.isContainer && config.powerManagement.cpuFreqGovernor != null) {

     

       35
       32
        
       

     

       36
       36
       -
               unitConfig.ConditionPathIsReadWrite = "/sys/devices/";

     

       33
       33
       +
           boot.kernelModules = [ "acpi-cpufreq" "speedstep-lib" "pcc-cpufreq"

     

       34
       34
       +
             "cpufreq_${cfg.cpuFreqGovernor}"

     

       35
       35
       +
           ];

     

       37
       36
        
       

     

       38
       38
       -
               path = [ pkgs.cpufrequtils ];

     

       37
       37
       +
           environment.systemPackages = [ cpupower ];

     

       39
       38
        
       

     

       40
       40
       -
               preStart = ''

     

       41
       41
       -
                 for i in $(seq 0 $(($(nproc) - 1))); do

     

       42
       42
       -
                   for gov in $(cpufreq-info -c $i -g); do

     

       43
       43
       -
                     if [ "$gov" = ${config.powerManagement.cpuFreqGovernor} ]; then

     

       44
       44
       -
                       echo "<6>setting governor on CPU $i to ‘$gov’"

     

       45
       45
       -
                       cpufreq-set -c $i -g $gov

     

       46
       46
       -
                     fi

     

       47
       47
       -
                   done

     

       48
       48
       -
                 done

     

       49
       49
       -
               '';

     

       39
       39
       +
           systemd.services.cpufreq = {

     

       40
       40
       +
             description = "CPU Frequency Governor Setup";

     

       41
       41
       +
             after = [ "systemd-modules-load.service" ];

     

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

     

       43
       43
       +
             path = [ cpupower ];

     

       44
       44
       +
             script = ''

     

       45
       45
       +
               cpupower frequency-set -g ${cfg.cpuFreqGovernor}

     

       46
       46
       +
             '';

     

       47
       47
       +
             unitConfig.ConditionVirtualization = false;

     

       48
       48
       +
             serviceConfig = {

     

       49
       49
       +
               Type = "oneshot";

     

       50
       50
       +
               RemainAfterExit = "yes";

     

       50
       51
        
             };

     

       51
       51
       -
         };

     

       52
       52
       +
           };

     

       52
       53
        
       

     

       54
       54
       +
         };

     

       53
       55
        
       }

+1 -13

nixos/modules/tasks/kbd.nix

···

       52
       52
        
           # /dev/tty0 to prevent putting the X server in non-raw mode, and

     

       53
       53
        
           # it has a restart trigger.

     

       54
       54
        
           systemd.services."systemd-vconsole-setup" =

     

       55
       55
       -
             { description = "Setup Virtual Console";

     

       56
       56
       -
               wantedBy = [ "sysinit.target" "multi-user.target" ];

     

       57
       57
       -
               before = [ "sysinit.target" "shutdown.target" ];

     

       58
       58
       -
               conflicts = [ "shutdown.target" ];

     

       59
       59
       -
               unitConfig =

     

       60
       60
       -
                 { DefaultDependencies = "no";

     

       61
       61
       -
                   ConditionPathExists = "/dev/tty1";

     

       62
       62
       -
                 };

     

       63
       63
       -
               serviceConfig =

     

       64
       64
       -
                 { Type = "oneshot";

     

       65
       65
       -
                   RemainAfterExit = true;

     

       66
       66
       -
                   ExecStart = "${config.systemd.package}/lib/systemd/systemd-vconsole-setup /dev/tty1";

     

       67
       67
       -
                 };

     

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

     

       68
       56
        
               restartTriggers = [ vconsoleConf ];

     

       69
       57
        
             };

     

       70
       58

+4 -2

nixos/modules/tasks/lvm.nix

···

       1
       1
       -
       { config, pkgs, ... }:

     

       1
       1
       +
       { config, lib, pkgs, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       2
       4
        
       

     

       3
       5
        
       {

     

       4
       6
        
       

     

       5
       7
        
         ###### implementation

     

       6
       8
        
       

     

       7
       7
       -
         config = {

     

       9
       9
       +
         config = mkIf (!config.boot.isContainer) {

     

       8
       10
        
       

     

       9
       11
        
           environment.systemPackages = [ pkgs.lvm2 ];

     

       10
       12

nixos/modules/tasks/network-interfaces.nix

···

       191
       191
        
             '';

     

       192
       192
        
           };

     

       193
       193
        
       

     

       194
       194
       +
           networking.useHostResolvConf = mkOption {

     

       195
       195
       +
             type = types.bool;

     

       196
       196
       +
             default = false;

     

       197
       197
       +
             description = ''

     

       198
       198
       +
               In containers, whether to use the

     

       199
       199
       +
               <filename>resolv.conf</filename> supplied by the host.

     

       200
       200
       +
             '';

     

       201
       201
       +
           };

     

       202
       202
       +
       

     

       194
       203
        
           networking.localCommands = mkOption {

     

       195
       204
        
             default = "";

     

       196
       205
        
             example = "text=anything; echo You can put $text here.";

nixos/modules/testing/test-instrumentation.nix

···

       86
       86
        
             (isEnabled "VIRTIO_CONSOLE")

     

       87
       87
        
           ];

     

       88
       88
        
       

     

       89
       89
       +
           networking.usePredictableInterfaceNames = false;

     

       90
       90
       +
       

     

       89
       91
        
         };

     

       90
       92
        
       

     

       91
       93
        
       }

+10 -26

nixos/modules/virtualisation/container-config.nix

···

       6
       6
        
       

     

       7
       7
        
         config = mkIf config.boot.isContainer {

     

       8
       8
        
       

     

       9
       9
       -
           # Provide a login prompt on /var/lib/login.socket.  On the host,

     

       10
       10
       -
           # you can connect to it by running ‘socat

     

       11
       11
       -
           # unix:<path-to-container>/var/lib/login.socket -,echo=0,raw’.

     

       12
       12
       -
           systemd.sockets.login =

     

       13
       13
       -
             { description = "Login Socket";

     

       14
       14
       -
               wantedBy = [ "sockets.target" ];

     

       15
       15
       -
               socketConfig =

     

       16
       16
       -
                 { ListenStream = "/var/lib/login.socket";

     

       17
       17
       -
                   SocketMode = "0666";

     

       18
       18
       -
                   Accept = true;

     

       19
       19
       -
                 };

     

       20
       20
       -
             };

     

       9
       9
       +
           # Disable some features that are not useful in a container.

     

       10
       10
       +
           sound.enable = mkDefault false;

     

       11
       11
       +
           services.udisks2.enable = mkDefault false;

     

       21
       12
        
       

     

       22
       22
       -
           systemd.services."login@" =

     

       23
       23
       -
             { description = "Login %i";

     

       24
       24
       -
               environment.TERM = "linux";

     

       25
       25
       -
               serviceConfig =

     

       26
       26
       -
                 { Type = "simple";

     

       27
       27
       -
                   StandardInput = "socket";

     

       28
       28
       -
                   ExecStart = "${pkgs.socat}/bin/socat -t0 - exec:${pkgs.shadow}/bin/login,pty,setsid,setpgid,stderr,ctty";

     

       29
       29
       -
                   TimeoutStopSec = 1; # FIXME

     

       30
       30
       -
                 };

     

       31
       31
       -
               restartIfChanged = false;

     

       32
       32
       -
             };

     

       13
       13
       +
           networking.useHostResolvConf = true;

     

       33
       14
        
       

     

       34
       34
       -
           # Also provide a root login prompt on /var/lib/root-login.socket

     

       35
       35
       -
           # that doesn't ask for a password. This socket can only be used by

     

       36
       36
       -
           # root on the host.

     

       15
       15
       +
           # Shut up warnings about not having a boot loader.

     

       16
       16
       +
           system.build.installBootLoader = "${pkgs.coreutils}/bin/true";

     

       17
       17
       +
       

     

       18
       18
       +
           # Provide a root login prompt on /var/lib/root-login.socket that

     

       19
       19
       +
           # doesn't ask for a password. This socket can only be used by root

     

       20
       20
       +
           # on the host.

     

       37
       21
        
           systemd.sockets.root-login =

     

       38
       22
        
             { description = "Root Login Socket";

     

       39
       23
        
               wantedBy = [ "sockets.target" ];

+11 -17

nixos/modules/virtualisation/containers.nix

···

       176
       176
        
                     "/nix/var/nix/profiles/per-container/$INSTANCE" \

     

       177
       177
        
                     "/nix/var/nix/gcroots/per-container/$INSTANCE"

     

       178
       178
        
       

     

       179
       179
       -
                   SYSTEM_PATH=/nix/var/nix/profiles/system

     

       180
       179
        
                   if [ -f "/etc/containers/$INSTANCE.conf" ]; then

     

       181
       180
        
                     . "/etc/containers/$INSTANCE.conf"

     

       182
       181
        
                   fi

     
···

       212
       211
        
                     extraFlags="--capability=CAP_NET_ADMIN"

     

       213
       212
        
                   fi

     

       214
       213
        
       

     

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

     

       215
       215
       +
                   # --personality flag.

     

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

     

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

     

       218
       218
       +
                       extraFlags+=" --personality=x86"

     

       219
       219
       +
                     fi

     

       220
       220
       +
                   ''}

     

       221
       221
       +
       

     

       215
       222
        
                   exec $runInNetNs ${config.systemd.package}/bin/systemd-nspawn \

     

       216
       216
       -
                     -M "$INSTANCE" -D "/var/lib/containers/$INSTANCE" $extraFlags \

     

       223
       223
       +
                     -M "$INSTANCE" -D "$root" $extraFlags \

     

       217
       224
        
                     --bind-ro=/nix/store \

     

       218
       225
        
                     --bind-ro=/nix/var/nix/db \

     

       219
       226
        
                     --bind-ro=/nix/var/nix/daemon-socket \

     

       220
       227
        
                     --bind="/nix/var/nix/profiles/per-container/$INSTANCE:/nix/var/nix/profiles" \

     

       221
       228
        
                     --bind="/nix/var/nix/gcroots/per-container/$INSTANCE:/nix/var/nix/gcroots" \

     

       222
       222
       -
                     "$SYSTEM_PATH/init"

     

       229
       229
       +
                     "''${SYSTEM_PATH:-/nix/var/nix/profiles/system}/init"

     

       223
       230
        
                 '';

     

       224
       231
        
       

     

       225
       232
        
               postStart =

     
···

       233
       240
        
       

     

       234
       241
        
               preStop =

     

       235
       242
        
                 ''

     

       236
       236
       -
                   pid="$(cat /sys/fs/cgroup/systemd/machine/$INSTANCE.nspawn/system/tasks 2> /dev/null)"

     

       237
       237
       -
                   if [ -n "$pid" ]; then

     

       238
       238
       -
                     # Send the RTMIN+3 signal, which causes the container

     

       239
       239
       -
                     # systemd to start halt.target.

     

       240
       240
       -
                     echo "killing container systemd, PID = $pid"

     

       241
       241
       -
                     kill -RTMIN+3 $pid

     

       242
       242
       -
                     # Wait for the container to exit.  We can't let systemd

     

       243
       243
       -
                     # do this because it will send a signal to the entire

     

       244
       244
       -
                     # cgroup.

     

       245
       245
       -
                     for ((n = 0; n < 180; n++)); do

     

       246
       246
       -
                       if ! kill -0 $pid 2> /dev/null; then break; fi

     

       247
       247
       -
                       sleep 1

     

       248
       248
       -
                     done

     

       249
       249
       -
                   fi

     

       243
       243
       +
                   machinectl poweroff "$INSTANCE"

     

       250
       244
        
                 '';

     

       251
       245
        
       

     

       252
       246
        
               restartIfChanged = false;

+1 -1

nixos/modules/virtualisation/nixos-container.pl

···

       203
       203
        
       }

     

       204
       204
        
       

     

       205
       205
        
       elsif ($action eq "login") {

     

       206
       206
       -
           exec($socat, "unix:$root/var/lib/login.socket", "-,echo=0,raw");

     

       206
       206
       +
           exec("machinectl", "login", "--", $containerName);

     

       207
       207
        
       }

     

       208
       208
        
       

     

       209
       209
        
       elsif ($action eq "root-login") {

nixos/modules/virtualisation/qemu-vm.nix

···

       399
       399
        
           # Wireless won't work in the VM.

     

       400
       400
        
           networking.wireless.enable = mkVMOverride false;

     

       401
       401
        
       

     

       402
       402
       +
           # Speed up booting by not waiting for ARP.

     

       403
       403
       +
           networking.dhcpcd.extraConfig = "noarp";

     

       404
       404
       +
       

     

       405
       405
       +
           networking.usePredictableInterfaceNames = false;

     

       406
       406
       +
       

     

       402
       407
        
           system.requiredKernelConfig = with config.lib.kernelConfig;

     

       403
       408
        
             [ (isEnabled "VIRTIO_BLK")

     

       404
       409
        
               (isEnabled "VIRTIO_PCI")

nixos/release-combined.nix

···

       61
       61
        
               (all nixos.tests.printing)

     

       62
       62
        
               (all nixos.tests.proxy)

     

       63
       63
        
               (all nixos.tests.udisks)

     

       64
       64
       +
               (all nixos.tests.udisks2)

     

       64
       65
        
               (all nixos.tests.xfce)

     

       65
       66
        
       

     

       66
       67
        
               nixpkgs.tarball

nixos/release.nix

···

       245
       245
        
         tests.simple = callTest tests/simple.nix {};

     

       246
       246
        
         tests.tomcat = callTest tests/tomcat.nix {};

     

       247
       247
        
         tests.udisks = callTest tests/udisks.nix {};

     

       248
       248
       +
         tests.udisks2 = callTest tests/udisks2.nix {};

     

       248
       249
        
         tests.xfce = callTest tests/xfce.nix {};

     

       249
       250
        
       

     

       250
       251
        
       }

+2 -2

nixos/tests/containers.nix

···

       25
       25
        
       

     

       26
       26
        
         testScript =

     

       27
       27
        
           ''

     

       28
       28
       -
             $machine->succeed("nixos-container list") =~ /webserver/;

     

       28
       28
       +
             $machine->succeed("nixos-container list") =~ /webserver/ or die;

     

       29
       29
        
       

     

       30
       30
        
             # Start the webserver container.

     

       31
       31
        
             $machine->succeed("nixos-container start webserver");

     
···

       65
       65
        
             $machine->succeed("nixos-container start $id1");

     

       66
       66
        
       

     

       67
       67
        
             # Execute commands via the root shell.

     

       68
       68
       -
             $machine->succeed("nixos-container run $id1 -- uname") =~ /Linux/;

     

       68
       68
       +
             $machine->succeed("nixos-container run $id1 -- uname") =~ /Linux/ or die;

     

       69
       69
        
             $machine->succeed("nixos-container set-root-password $id1 foobar");

     

       70
       70
        
       

     

       71
       71
        
             # Destroy the containers.

+4 -1

nixos/tests/login.nix

···

       9
       9
        
       

     

       10
       10
        
         testScript =

     

       11
       11
        
           ''

     

       12
       12
       -
             $machine->waitForUnit("default.target");

     

       12
       12
       +
             $machine->waitForUnit('multi-user.target');

     

       13
       13
       +
             $machine->waitUntilSucceeds("pgrep -f 'agetty.*tty1'");

     

       13
       14
        
             $machine->screenshot("postboot");

     

       14
       15
        
       

     

       15
       16
        
             subtest "create user", sub {

     
···

       19
       20
        
       

     

       20
       21
        
             # Check whether switching VTs works.

     

       21
       22
        
             subtest "virtual console switching", sub {

     

       23
       23
       +
                 $machine->fail("pgrep -f 'agetty.*tty2'");

     

       22
       24
        
                 $machine->sendKeys("alt-f2");

     

       23
       25
        
                 $machine->waitUntilSucceeds("[ \$(fgconsole) = 2 ]");

     

       24
       26
        
                 $machine->waitForUnit('getty@tty2.service');

     

       27
       27
       +
                 $machine->waitUntilSucceeds("pgrep -f 'agetty.*tty2'");

     

       25
       28
        
             };

     

       26
       29
        
       

     

       27
       30
        
             # Log in as alice on a virtual console.

+17

nixos/tests/misc.nix

···

       8
       8
        
               [ { device = "/root/swapfile"; size = 128; } ];

     

       9
       9
        
             environment.variables.EDITOR = pkgs.lib.mkOverride 0 "emacs";

     

       10
       10
        
             services.nixosManual.enable = pkgs.lib.mkOverride 0 true;

     

       11
       11
       +
             systemd.tmpfiles.rules = [ "d /tmp 1777 root root 10d" ];

     

       11
       12
        
           };

     

       12
       13
        
       

     

       13
       14
        
         testScript =

     
···

       62
       63
        
             subtest "hostname", sub {

     

       63
       64
        
                 $machine->succeed('[ "`hostname`" = machine ]');

     

       64
       65
        
                 $machine->succeed('[ "`hostname -s`" = machine ]');

     

       66
       66
       +
             };

     

       67
       67
       +
       

     

       68
       68
       +
             # Test whether systemd-udevd automatically loads modules for our hardware.

     

       69
       69
       +
             subtest "udev-auto-load", sub {

     

       70
       70
       +
                 $machine->waitForUnit('systemd-udev-settle.service');

     

       71
       71
       +
                 $machine->succeed('lsmod | grep psmouse');

     

       72
       72
       +
             };

     

       73
       73
       +
       

     

       74
       74
       +
             # Test whether systemd-tmpfiles-clean works.

     

       75
       75
       +
             subtest "tmpfiles", sub {

     

       76
       76
       +
                 $machine->succeed('touch /tmp/foo');

     

       77
       77
       +
                 $machine->succeed('systemctl start systemd-tmpfiles-clean');

     

       78
       78
       +
                 $machine->succeed('[ -e /tmp/foo ]');

     

       79
       79
       +
                 $machine->succeed('date -s "@$(($(date +%s) + 1000000))"'); # move into the future

     

       80
       80
       +
                 $machine->succeed('systemctl start systemd-tmpfiles-clean');

     

       81
       81
       +
                 $machine->fail('[ -e /tmp/foo ]');

     

       65
       82
        
             };

     

       66
       83
        
           '';

     

       67
       84

nixos/tests/printing.nix

···

       31
       31
        
       

     

       32
       32
        
             # Make sure that cups is up on both sides.

     

       33
       33
        
             $server->waitForUnit("cupsd.service");

     

       34
       34
       +
             $server->waitForUnit("network.target");

     

       34
       35
        
             $client->waitForUnit("cupsd.service");

     

       36
       36
       +
             $client->waitForUnit("network.target");

     

       35
       37
        
             $client->succeed("lpstat -r") =~ /scheduler is running/ or die;

     

       36
       38
        
             $client->succeed("lpstat -H") =~ "/var/run/cups/cups.sock" or die;

     

       37
       39
        
             $client->succeed("curl --fail http://localhost:631/");

+1 -1

nixos/tests/udisks.nix

···

       40
       40
        
             # Mount the stick as a non-root user and do some stuff with it.

     

       41
       41
        
             $machine->succeed("su - alice -c 'udisks --enumerate | grep /org/freedesktop/UDisks/devices/sda1'");

     

       42
       42
        
             $machine->succeed("su - alice -c 'udisks --mount /dev/sda1'");

     

       43
       43
       -
             $machine->succeed("su - alice -c 'cat /media/USBSTICK/test.txt'") =~ /Hello World/;

     

       43
       43
       +
             $machine->succeed("su - alice -c 'cat /media/USBSTICK/test.txt'") =~ /Hello World/ or die;

     

       44
       44
        
             $machine->succeed("su - alice -c 'echo foo > /media/USBSTICK/bar.txt'");

     

       45
       45
        
       

     

       46
       46
        
             # Unmounting the stick should make the mountpoint disappear.

+56

nixos/tests/udisks2.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
       

     

       5
       5
       +
         stick = pkgs.fetchurl {

     

       6
       6
       +
           url = http://nixos.org/~eelco/nix/udisks-test.img.xz;

     

       7
       7
       +
           sha256 = "0was1xgjkjad91nipzclaz5biv3m4b2nk029ga6nk7iklwi19l8b";

     

       8
       8
       +
         };

     

       9
       9
       +
       

     

       10
       10
       +
       in

     

       11
       11
       +
       

     

       12
       12
       +
       {

     

       13
       13
       +
       

     

       14
       14
       +
         machine =

     

       15
       15
       +
           { config, pkgs, ... }:

     

       16
       16
       +
           { services.udisks2.enable = true;

     

       17
       17
       +
             imports = [ ./common/user-account.nix ];

     

       18
       18
       +
       

     

       19
       19
       +
             security.polkit.extraConfig =

     

       20
       20
       +
               ''

     

       21
       21
       +
                 polkit.addRule(function(action, subject) {

     

       22
       22
       +
                   if (subject.user == "alice") return "yes";

     

       23
       23
       +
                 });

     

       24
       24
       +
               '';

     

       25
       25
       +
           };

     

       26
       26
       +
       

     

       27
       27
       +
         testScript =

     

       28
       28
       +
           ''

     

       29
       29
       +
             my $stick = $machine->stateDir . "/usbstick.img";

     

       30
       30
       +
             system("xz -d < ${stick} > $stick") == 0 or die;

     

       31
       31
       +
       

     

       32
       32
       +
             $machine->succeed("udisksctl info -b /dev/vda >&2");

     

       33
       33
       +
             $machine->fail("udisksctl info -b /dev/sda1");

     

       34
       34
       +
       

     

       35
       35
       +
             # Attach a USB stick and wait for it to show up.

     

       36
       36
       +
             $machine->sendMonitorCommand("usb_add disk:$stick");

     

       37
       37
       +
             $machine->waitUntilSucceeds("udisksctl info -b /dev/sda1");

     

       38
       38
       +
             $machine->succeed("udisksctl info -b /dev/sda1 | grep 'IdLabel:.*USBSTICK'");

     

       39
       39
       +
       

     

       40
       40
       +
             # Mount the stick as a non-root user and do some stuff with it.

     

       41
       41
       +
             $machine->succeed("su - alice -c 'udisksctl info -b /dev/sda1'");

     

       42
       42
       +
             $machine->succeed("su - alice -c 'udisksctl mount -b /dev/sda1'");

     

       43
       43
       +
             $machine->succeed("su - alice -c 'cat /run/media/alice/USBSTICK/test.txt'") =~ /Hello World/ or die;

     

       44
       44
       +
             $machine->succeed("su - alice -c 'echo foo > /run/media/alice/USBSTICK/bar.txt'");

     

       45
       45
       +
       

     

       46
       46
       +
             # Unmounting the stick should make the mountpoint disappear.

     

       47
       47
       +
             $machine->succeed("su - alice -c 'udisksctl unmount -b /dev/sda1'");

     

       48
       48
       +
             $machine->fail("[ -d /run/media/alice/USBSTICK ]");

     

       49
       49
       +
       

     

       50
       50
       +
             # Remove the USB stick.

     

       51
       51
       +
             $machine->sendMonitorCommand("usb_del 0.3"); # FIXME

     

       52
       52
       +
             $machine->waitUntilFails("udisksctl info -b /dev/sda1");

     

       53
       53
       +
             $machine->fail("[ -e /dev/sda ]");

     

       54
       54
       +
           '';

     

       55
       55
       +
       

     

       56
       56
       +
       })

+5 -18

pkgs/development/libraries/dbus/default.nix

···

       67
       67
        
       

     

       68
       68
        
         } merge ]);

     

       69
       69
        
       

     

       70
       70
       -
         libs = dbus_drv "libs" "dbus" ({

     

       70
       70
       +
         libs = dbus_drv "libs" "dbus" {

     

       71
       71
        
           # Enable X11 autolaunch support in libdbus. This doesn't actually depend on X11

     

       72
       72
        
           # (it just execs dbus-launch in dbus.tools), contrary to what the configure script demands.

     

       73
       73
        
           NIX_CFLAGS_COMPILE = "-DDBUS_ENABLE_X11_AUTOLAUNCH=1";

     

       74
       74
       -
         } // stdenv.lib.optionalAttrs (systemdOrEmpty != []) {

     

       75
       75
       -
           buildInputs = [ systemd.headers ];

     

       76
       76
       -
           patches = [ ./systemd.patch ]; # bypass systemd detection

     

       77
       77
       -
         });

     

       74
       74
       +
           buildInputs = [ systemdOrEmpty ];

     

       75
       75
       +
         };

     

       78
       76
        
       

     

       79
       77
        
       

     

       80
       78
        
         attrs = rec {

     
···

       83
       81
        
         # This package has been split because most applications only need dbus.lib

     

       84
       82
        
         # which serves as an interface to a *system-wide* daemon,

     

       85
       83
        
         # see e.g. http://en.wikipedia.org/wiki/D-Bus#Architecture .

     

       86
       86
       -
         # Also some circular dependencies get split by this (like with systemd).

     

       87
       84
        
       

     

       88
       85
        
         inherit libs;

     

       89
       86
        
       

     

       90
       87
        
         tools = dbus_drv "tools" "tools" {

     

       91
       88
        
           configureFlags = [ "--with-dbus-daemondir=${daemon}/bin" ];

     

       92
       92
       -
           buildInputs = buildInputsX ++ systemdOrEmpty ++ [ libs daemon dbus_glib ];

     

       93
       93
       -
           NIX_CFLAGS_LINK = 

     

       89
       89
       +
           buildInputs = buildInputsX ++ systemdOrEmpty ++ [ libs daemon ];

     

       90
       90
       +
           NIX_CFLAGS_LINK =

     

       94
       91
        
             stdenv.lib.optionalString (!stdenv.isDarwin) "-Wl,--as-needed "

     

       95
       92
        
             + "-ldbus-1";

     

       96
       93
        
       

     
···

       100
       97
        
         daemon = dbus_drv "daemon" "bus" {

     

       101
       98
        
           preBuild = makeInternalLib;

     

       102
       99
        
           buildInputs = systemdOrEmpty;

     

       103
       103
       -
         };

     

       104
       104
       -
       

     

       105
       105
       -
         # Some of the tests don't work yet; in fact, @vcunat tried several packages

     

       106
       106
       -
         # containing dbus testing, and all of them have some test failure.

     

       107
       107
       -
         tests = dbus_drv "tests" "test" {

     

       108
       108
       -
           preBuild = makeInternalLib;

     

       109
       109
       -
           buildInputs = buildInputsX ++ systemdOrEmpty ++ [ libs tools daemon dbus_glib python ];

     

       110
       110
       -
           NIX_CFLAGS_LINK = 

     

       111
       111
       -
             stdenv.lib.optionalString (!stdenv.isDarwin) "-Wl,--as-needed "

     

       112
       112
       -
             + "-ldbus-1";

     

       113
       100
        
         };

     

       114
       101
        
       

     

       115
       102
        
         docs = dbus_drv "docs" "doc" {

+42

pkgs/os-specific/linux/cpupower/default.nix

···

       1
       1
       +
       { stdenv, fetchurl, kernel, coreutils, pciutils, gettext }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation {

     

       4
       4
       +
         name = "cpupower-${kernel.version}";

     

       5
       5
       +
       

     

       6
       6
       +
         src = kernel.src;

     

       7
       7
       +
       

     

       8
       8
       +
         buildInputs = [ coreutils pciutils gettext ];

     

       9
       9
       +
       

     

       10
       10
       +
         configurePhase = ''

     

       11
       11
       +
           cd tools/power/cpupower

     

       12
       12
       +
           sed -i 's,/bin/true,${coreutils}/bin/true,' Makefile

     

       13
       13
       +
           sed -i 's,/bin/pwd,${coreutils}/bin/pwd,' Makefile

     

       14
       14
       +
           sed -i 's,/usr/bin/install,${coreutils}/bin/install,' Makefile

     

       15
       15
       +
         '';

     

       16
       16
       +
       

     

       17
       17
       +
         buildPhase = ''

     

       18
       18
       +
           make

     

       19
       19
       +
         '';

     

       20
       20
       +
       

     

       21
       21
       +
         installPhase = ''

     

       22
       22
       +
           make \

     

       23
       23
       +
             bindir="$out/bin" \

     

       24
       24
       +
             sbindir="$out/sbin" \

     

       25
       25
       +
             mandir="$out/share/man" \

     

       26
       26
       +
             includedir="$out/include" \

     

       27
       27
       +
             libdir="$out/lib" \

     

       28
       28
       +
             localedir="$out/share/locale" \

     

       29
       29
       +
             docdir="$out/share/doc/cpupower" \

     

       30
       30
       +
             confdir="$out/etc" \

     

       31
       31
       +
             install install-man

     

       32
       32
       +
         '';

     

       33
       33
       +
       

     

       34
       34
       +
         enableParallelBuilding = true;

     

       35
       35
       +
       

     

       36
       36
       +
         meta = with stdenv.lib; {

     

       37
       37
       +
           description = "Tool to examine and tune power saving features.";

     

       38
       38
       +
           homepage = https://www.kernel.org.org/;

     

       39
       39
       +
           license = licenses.gpl2;

     

       40
       40
       +
           platforms = platforms.linux;

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+19 -18

pkgs/os-specific/linux/firmware/firmware-linux-nonfree/default.nix

···

       6
       6
        
       { stdenv, fetchurl, dpkg }:

     

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
       -
         version = "0.40";

     

       9
       9
       +
         version = "0.41";

     

       10
       10
        
       

     

       11
       11
        
         packages = [

     

       12
       12
       -
           { name = "adi"; sha256 = "0wwks9ff4n772435s57z1fjrffi4xl9nxnfn3v7xfcwdjb395d88"; }

     

       13
       13
       -
           { name = "atheros"; sha256 = "1gj7hfnyclzgyq06scynaclnfajhs6lw5i51j1w1hikv4yh20djz"; }

     

       14
       14
       -
           { name = "bnx2"; sha256 = "15qjj0sfjin5cbkpby29r5czn11xyiyyc4fmhwlqvgfgrnbp0aqk"; }

     

       15
       15
       -
           { name = "bnx2x"; sha256 = "08nvbln94ff47b2q0avxj1aa2wx4qih8sq8knbq54lp46kjf3k0h"; }

     

       16
       16
       -
           { name = "brcm80211"; sha256 = "1ndsw3s6xkr1n39nf9ig1xhnaglx5qvvvm8rh6ah41v644lzha79"; }

     

       17
       17
       -
           { name = "intelwimax"; sha256 = "1qwxmykh90v92asn4ivq0fak761hs7hd2zmz1dpkjidwsycrfyqn"; }

     

       18
       18
       -
           { name = "ipw2x00"; sha256 = "0a2nb17b5n3k1b6y4dbi5i8k1fm19ba2abq2jh2hjjmyyl3y388m"; }

     

       19
       19
       -
           { name = "ivtv"; sha256 = "1239gsjq16f4kd1yn77iq3ar8ndx3pzd16kpqafr1h2y0zwh452r"; }

     

       20
       20
       -
           { name = "iwlwifi"; sha256 = "03kmh5szd02pkbm1nlyz99fr2njhg88wiv73f1fz485m9rvgga43"; }

     

       21
       21
       -
           { name = "libertas"; sha256 = "0qjziwmwqbp83hxrjw7x3ralxg4ib9y23bcbn1g8yb5b6m84ca6b"; }

     

       22
       22
       -
           { name = "linux"; sha256 = "0ypidsrrfx4kvbfisdpgx2fzbil7g2jixgqhnv960iy5l348amrl"; }

     

       23
       23
       -
           { name = "linux-nonfree"; sha256 = "0p9ql3cdxljflh48r6z40kpyisbzp3s3g1qjb9f64n6cppllwjfr"; }

     

       24
       24
       -
           { name = "myricom"; sha256 = "12spfaq7z2bb93cy15zldlic1wx2v6h9sn7ny09nkzy4m26zds4q"; }

     

       25
       25
       -
           { name = "netxen"; sha256 = "03gmda16bdqw8a4x8x11ph41ksjh48hxydv0f0z3gi3czgbh7sn3"; }

     

       26
       26
       -
           { name = "qlogic"; sha256 = "1ah8rrwzi44p1l4q8qkql18djmn5kihsiinpy204xklm1csf3vs1"; }

     

       27
       27
       -
           { name = "ralink"; sha256 = "005549jk0wnyfnb247awv2wncsx5is05m1hdwcd33iq0dlbmm39b"; }

     

       28
       28
       -
           { name = "realtek"; sha256 = "1ai1klzrql8qxmb7945xiqlkfkyz8admrpb10b3r4ixvclkrvfi2"; }

     

       12
       12
       +
           { name = "adi"; sha256 = "19dm96djp34g6l84g9shwbmqbmfd15c24frcy1zh5nz8x12phgm4"; }

     

       13
       13
       +
           { name = "atheros"; sha256 = "0vrdyxiq7nx89h6ykdrs8s3l9frn3hmcfb9vsz68i12975y8ib5n"; }

     

       14
       14
       +
           { name = "bnx2"; sha256 = "12l3l54q69n1ky8lp7bmzscfqysabjrgmswwj57ryc6l82s7081y"; }

     

       15
       15
       +
           { name = "bnx2x"; sha256 = "10m9p479dq2ylpj5mw6d5vyfh9hybmh5xgs5sxma065v7r3c3v31"; }

     

       16
       16
       +
           { name = "brcm80211"; sha256 = "0l2lg5pshb1kb829hfq9w791scwa8biikrfzsx9wvlvkyxfdh187"; }

     

       17
       17
       +
           { name = "intelwimax"; sha256 = "13jqm8ik0mm8vnsskbbp63idpjqazzp2x4gaq7786jg5yj3zh1cf"; }

     

       18
       18
       +
           { name = "ipw2x00"; sha256 = "1hvxrzqbc75phxdbmqfh7ky36m0qna2pncwxpfdircy9i6fx7ipy"; }

     

       19
       19
       +
           { name = "ivtv"; sha256 = "0ckw1ynzfqnkwlmwpzfbdfx4s6bsl4nwp097g8khaavqxk94n88v"; }

     

       20
       20
       +
           { name = "iwlwifi"; sha256 = "1djazi2qsi5z6q0izirprxgfpg8vh55skab2nijyfl66drlcha72"; }

     

       21
       21
       +
           { name = "libertas"; sha256 = "1yj9dd9pwd98gknx5mvblfcbr6k347xzi8l6bk0pr4570j8ss8y3"; }

     

       22
       22
       +
           { name = "linux"; sha256 = "0vc4cbrq73y5hibx5k3gbfqaqxvaa3g8rv9kzwks2zl3hdxm6xaq"; }

     

       23
       23
       +
           { name = "linux-nonfree"; sha256 = "05vv8yq7kix5cw9s4agz4vgya6i3ff88jp3rxln1ssznhvzrjzx9"; }

     

       24
       24
       +
           { name = "myricom"; sha256 = "1idfvdfw7z4jbbjyq40hd2bpllvw7jz0ah7k3iwljxp8l2lf2nmf"; }

     

       25
       25
       +
           { name = "netxen"; sha256 = "0fdgllv8i7j9qbk5hi14zvw6fcn4nd1isr1486d8fv7nf2bf1mxx"; }

     

       26
       26
       +
           { name = "qlogic"; sha256 = "12w1qnqhs24am2psdfmv0ligczzxh9crllmp7r4y3vqghyvwax7i"; }

     

       27
       27
       +
           { name = "ralink"; sha256 = "1ryplg9shi7nam79zd86z7a0qzp0f9m7q89nq989z57qiysbrra4"; }

     

       28
       28
       +
           { name = "realtek"; sha256 = "1l867724qrw7nwksdv4k0hkz7nrjjs9vq2s3937wyaa0r2r66mg6"; }

     

       29
       29
       +
           { name = "ti-connectivity"; sha256 = "00cl9gyxa7795a57zwcvl26kxfl4qzppi4z8ksg5friv3db8sm1p"; }

     

       29
       30
        
         ];

     

       30
       31
        
       

     

       31
       32
        
         fetchPackage =

-61

pkgs/os-specific/linux/kernel-headers/2.6.28.nix

···

       1
       1
       -
       {stdenv, fetchurl, perl, cross ? null}:

     

       2
       2
       -
       

     

       3
       3
       -
       assert cross == null -> stdenv.isLinux;

     

       4
       4
       -
       

     

       5
       5
       -
       let version = "2.6.28.5"; in

     

       6
       6
       -
       

     

       7
       7
       -
       stdenv.mkDerivation {

     

       8
       8
       -
         name = "linux-headers-${version}";

     

       9
       9
       -
       

     

       10
       10
       -
         src = fetchurl {

     

       11
       11
       -
           url = "mirror://kernel/linux/kernel/v2.6/linux-${version}.tar.bz2";

     

       12
       12
       -
           sha256 = "0hifjh75sinifr5138v22zwbpqln6lhn65k8b57a1dyzlqca7cl9";

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

       15
       15
       -
         targetConfig = if cross != null then cross.config else null;

     

       16
       16
       -
       

     

       17
       17
       -
         platform =

     

       18
       18
       -
           if cross != null then cross.arch else

     

       19
       19
       -
           if stdenv.system == "i686-linux" then "i386" else

     

       20
       20
       -
           if stdenv.system == "x86_64-linux" then "x86_64" else

     

       21
       21
       -
           if stdenv.system == "powerpc-linux" then "powerpc" else

     

       22
       22
       -
           if stdenv.isArm then "arm" else

     

       23
       23
       -
           if stdenv.system == "mips64el-linux" then "mips" else

     

       24
       24
       -
           abort "don't know what the kernel include directory is called for this platform";

     

       25
       25
       -
       

     

       26
       26
       -
         buildInputs = [perl];

     

       27
       27
       -
       

     

       28
       28
       -
         extraIncludeDirs =

     

       29
       29
       -
           if cross != null then

     

       30
       30
       -
       	(if cross.arch == "powerpc" then ["ppc"] else [])

     

       31
       31
       -
           else if stdenv.system == "powerpc-linux" then ["ppc"] else [];

     

       32
       32
       -
       

     

       33
       33
       -
         patchPhase = ''

     

       34
       34
       -
           patch --verbose -p1 < "${./unifdef-getline.patch}"

     

       35
       35
       -
           sed -i '/scsi/d' include/Kbuild

     

       36
       36
       -
           sed -i 's|/ %/: prepare scripts FORCE|%/: prepare scripts FORCE|' Makefile

     

       37
       37
       -
         '';

     

       38
       38
       -
       

     

       39
       39
       -
         buildPhase = ''

     

       40
       40
       -
           if test -n "$targetConfig"; then

     

       41
       41
       -
              export ARCH=$platform

     

       42
       42
       -
           fi

     

       43
       43
       -
           make mrproper headers_check

     

       44
       44
       -
         '';

     

       45
       45
       -
       

     

       46
       46
       -
         installPhase = ''

     

       47
       47
       -
           make INSTALL_HDR_PATH=$out headers_install

     

       48
       48
       -
       

     

       49
       49
       -
           # Some builds (e.g. KVM) want a kernel.release.

     

       50
       50
       -
           mkdir -p $out/include/config

     

       51
       51
       -
           echo "${version}-default" > $out/include/config/kernel.release

     

       52
       52
       -
         '';

     

       53
       53
       -
       

     

       54
       54
       -
         # !!! hacky

     

       55
       55
       -
         fixupPhase = ''

     

       56
       56
       -
           ln -s asm $out/include/asm-$platform

     

       57
       57
       -
           if test "$platform" = "i386" -o "$platform" = "x86_64"; then

     

       58
       58
       -
             ln -s asm $out/include/asm-x86

     

       59
       59
       -
           fi

     

       60
       60
       -
         '';

     

       61
       61
       -
       }

+71

pkgs/os-specific/linux/kernel-headers/3.14.nix

···

       1
       1
       +
       { stdenv, fetchurl, perl, cross ? null }:

     

       2
       2
       +
       

     

       3
       3
       +
       assert cross == null -> stdenv.isLinux;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
       

     

       7
       7
       +
         version = "3.14.1";

     

       8
       8
       +
       

     

       9
       9
       +
         kernelHeadersBaseConfig =

     

       10
       10
       +
           if cross == null

     

       11
       11
       +
           then stdenv.platform.kernelHeadersBaseConfig

     

       12
       12
       +
           else cross.platform.kernelHeadersBaseConfig;

     

       13
       13
       +
       

     

       14
       14
       +
       in

     

       15
       15
       +
       

     

       16
       16
       +
       stdenv.mkDerivation {

     

       17
       17
       +
         name = "linux-headers-${version}";

     

       18
       18
       +
       

     

       19
       19
       +
         src = fetchurl {

     

       20
       20
       +
           url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";

     

       21
       21
       +
           sha256 = "1njm8gvlj7cq0m1051yxszl4f63383a7sv1na13hkqkv36kipgqx";

     

       22
       22
       +
         };

     

       23
       23
       +
       

     

       24
       24
       +
         targetConfig = if cross != null then cross.config else null;

     

       25
       25
       +
       

     

       26
       26
       +
         platform =

     

       27
       27
       +
           if cross != null then cross.platform.kernelArch else

     

       28
       28
       +
           if stdenv.system == "i686-linux" then "i386" else

     

       29
       29
       +
           if stdenv.system == "x86_64-linux" then "x86_64" else

     

       30
       30
       +
           if stdenv.system == "powerpc-linux" then "powerpc" else

     

       31
       31
       +
           if stdenv.isArm then "arm" else

     

       32
       32
       +
           if stdenv.platform ? kernelArch then stdenv.platform.kernelArch else

     

       33
       33
       +
           abort "don't know what the kernel include directory is called for this platform";

     

       34
       34
       +
       

     

       35
       35
       +
         buildInputs = [perl];

     

       36
       36
       +
       

     

       37
       37
       +
         extraIncludeDirs =

     

       38
       38
       +
           if cross != null then

     

       39
       39
       +
               (if cross.arch == "powerpc" then ["ppc"] else [])

     

       40
       40
       +
           else if stdenv.system == "powerpc-linux" then ["ppc"] else [];

     

       41
       41
       +
       

     

       42
       42
       +
         buildPhase = ''

     

       43
       43
       +
           if test -n "$targetConfig"; then

     

       44
       44
       +
              export ARCH=$platform

     

       45
       45
       +
           fi

     

       46
       46
       +
           make ${kernelHeadersBaseConfig} SHELL=bash

     

       47
       47
       +
           make mrproper headers_check SHELL=bash

     

       48
       48
       +
         '';

     

       49
       49
       +
       

     

       50
       50
       +
         installPhase = ''

     

       51
       51
       +
           make INSTALL_HDR_PATH=$out headers_install

     

       52
       52
       +
       

     

       53
       53
       +
           # Some builds (e.g. KVM) want a kernel.release.

     

       54
       54
       +
           mkdir -p $out/include/config

     

       55
       55
       +
           echo "${version}-default" > $out/include/config/kernel.release

     

       56
       56
       +
         '';

     

       57
       57
       +
       

     

       58
       58
       +
         # !!! hacky

     

       59
       59
       +
         fixupPhase = ''

     

       60
       60
       +
           ln -s asm $out/include/asm-$platform

     

       61
       61
       +
           if test "$platform" = "i386" -o "$platform" = "x86_64"; then

     

       62
       62
       +
             ln -s asm $out/include/asm-x86

     

       63
       63
       +
           fi

     

       64
       64
       +
         '';

     

       65
       65
       +
       

     

       66
       66
       +
         meta = with stdenv.lib; {

     

       67
       67
       +
           description = "Header files and scripts for Linux kernel";

     

       68
       68
       +
           license = licenses.gpl2;

     

       69
       69
       +
           platforms = platforms.linux;

     

       70
       70
       +
         };

     

       71
       71
       +
       }

pkgs/os-specific/linux/kernel/common-config.nix

···

       114
       114
        
         VGA_SWITCHEROO y

     

       115
       115
        
       

     

       116
       116
        
         # Sound.

     

       117
       117
       +
         SND_DYNAMIC_MINORS y

     

       117
       118
        
         SND_AC97_POWER_SAVE y # AC97 Power-Saving Mode

     

       118
       119
        
         SND_HDA_INPUT_BEEP y # Support digital beep via input layer

     

       119
       120
        
         SND_USB_CAIAQ_INPUT y

+2 -2

pkgs/os-specific/linux/kmod/default.nix

···

       1
       1
        
       { stdenv, fetchurl, xz, zlib, pkgconfig, libxslt }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "kmod-16";

     

       4
       4
       +
         name = "kmod-17";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "mirror://kernel/linux/utils/kernel/kmod/${name}.tar.xz";

     

       8
       8
       -
           sha256 = "63412efab37c70459ccef167556965c93fd4f56af5986cd3750542a684c613c5";

     

       8
       8
       +
           sha256 = "1yid3a9b64a60ybj66fk2ysrq5klnl0ijl4g624cl16y8404g9rv";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         # Disable xz/zlib support to prevent needing them in the initrd.

+41 -5

pkgs/os-specific/linux/kmod/module-dir.patch

···

       1
       1
       -
       diff -Naur kmod-7-orig/libkmod/libkmod.c kmod-7/libkmod/libkmod.c

     

       2
       2
       -
       --- kmod-7-orig/libkmod/libkmod.c	2012-03-15 08:19:16.750010226 -0400

     

       3
       3
       -
       +++ kmod-7/libkmod/libkmod.c	2012-04-04 15:21:29.532074313 -0400

     

       4
       4
       -
       @@ -200,7 +200,7 @@

     

       1
       1
       +
       diff -ru -x '*~' kmod-17-orig/libkmod/libkmod.c kmod-17/libkmod/libkmod.c

     

       2
       2
       +
       --- kmod-17-orig/libkmod/libkmod.c	2014-04-01 12:40:37.161940089 +0200

     

       3
       3
       +
       +++ kmod-17/libkmod/libkmod.c	2014-04-17 13:47:15.871441987 +0200

     

       4
       4
       +
       @@ -201,7 +201,7 @@

     

       5
       5
        
        static char *get_kernel_release(const char *dirname)

     

       6
       6
        
        {

     

       7
       7
        
        	struct utsname u;

     
···

       10
       10
        
        

     

       11
       11
        
        	if (dirname != NULL)

     

       12
       12
        
        		return path_make_absolute_cwd(dirname);

     

       13
       13
       -
       @@ -208,7 +208,10 @@

     

       13
       13
       +
       @@ -209,7 +209,10 @@

     

       14
       14
        
        	if (uname(&u) < 0)

     

       15
       15
        
        		return NULL;

     

       16
       16
        
        

     
···

       22
       22
        
        		return NULL;

     

       23
       23
        
        

     

       24
       24
        
        	return p;

     

       25
       25
       +
       diff -ru -x '*~' kmod-17-orig/tools/static-nodes.c kmod-17/tools/static-nodes.c

     

       26
       26
       +
       --- kmod-17-orig/tools/static-nodes.c	2013-12-17 22:05:42.159047316 +0100

     

       27
       27
       +
       +++ kmod-17/tools/static-nodes.c	2014-04-17 13:51:17.945974320 +0200

     

       28
       28
       +
       @@ -159,6 +159,7 @@

     

       29
       29
       +
        	FILE *in = NULL, *out = NULL;

     

       30
       30
       +
        	const struct static_nodes_format *format = &static_nodes_format_human;

     

       31
       31
       +
        	int r, ret = EXIT_SUCCESS;

     

       32
       32
       +
       +	char *dirname_prefix;

     

       33
       33
       +
        

     

       34
       34
       +
        	for (;;) {

     

       35
       35
       +
        		int c, idx = 0, valid;

     

       36
       36
       +
       @@ -211,16 +212,19 @@

     

       37
       37
       +
        		goto finish;

     

       38
       38
       +
        	}

     

       39
       39
       +
        

     

       40
       40
       +
       -	snprintf(modules, sizeof(modules), "/lib/modules/%s/modules.devname", kernel.release);

     

       41
       41
       +
       +	if ((dirname_prefix = getenv("MODULE_DIR")) == NULL)

     

       42
       42
       +
       +		dirname_prefix = "/lib/modules";

     

       43
       43
       +
       +

     

       44
       44
       +
       +	snprintf(modules, sizeof(modules), "%s/%s/modules.devname", dirname_prefix, kernel.release);

     

       45
       45
       +
        	in = fopen(modules, "re");

     

       46
       46
       +
        	if (in == NULL) {

     

       47
       47
       +
        		if (errno == ENOENT) {

     

       48
       48
       +
       -			fprintf(stderr, "Warning: /lib/modules/%s/modules.devname not found - ignoring\n",

     

       49
       49
       +
       -				kernel.release);

     

       50
       50
       +
       +			fprintf(stderr, "Warning: %s/%s/modules.devname not found - ignoring\n",

     

       51
       51
       +
       +				dirname_prefix, kernel.release);

     

       52
       52
       +
        			ret = EXIT_SUCCESS;

     

       53
       53
       +
        		} else {

     

       54
       54
       +
       -			fprintf(stderr, "Error: could not open /lib/modules/%s/modules.devname - %m\n",

     

       55
       55
       +
       -				kernel.release);

     

       56
       56
       +
       +			fprintf(stderr, "Error: could not open %s/%s/modules.devname - %m\n",

     

       57
       57
       +
       +				dirname_prefix, kernel.release);

     

       58
       58
       +
        			ret = EXIT_FAILURE;

     

       59
       59
       +
        		}

     

       60
       60
       +
        		goto finish;

+4 -2

pkgs/os-specific/linux/lvm2/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, udev, utillinux, coreutils }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         v = "2.02.104";

     

       4
       4
       +
         v = "2.02.106";

     

       5
       5
        
       in

     

       6
       6
        
       

     

       7
       7
        
       stdenv.mkDerivation {

     
···

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "ftp://sources.redhat.com/pub/lvm2/releases/LVM2.${v}.tgz";

     

       12
       12
       -
           sha256 = "1xa7hvp8bsx96nncgksxrqxaqcgipfmmpr8aysayb8aisyjvas0d";

     

       12
       12
       +
           sha256 = "0nr833bl0q4zq52drjxmmpf7bs6kqxwa5kahwwxm9411khkxz0vc";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         configureFlags =

     
···

       28
       28
        
             sed -i /DEFAULT_SYS_DIR/d Makefile.in

     

       29
       29
        
             sed -i /DEFAULT_PROFILE_DIR/d conf/Makefile.in

     

       30
       30
        
           '';

     

       31
       31
       +
       

     

       32
       32
       +
         enableParallelBuilding = true;

     

       31
       33
        
       

     

       32
       34
        
         #patches = [ ./purity.patch ];

     

       33
       35

+3 -3

pkgs/os-specific/linux/nvidia-x11/default.nix

···

       12
       12
        
       

     

       13
       13
        
       let

     

       14
       14
        
       

     

       15
       15
       -
         versionNumber = "331.49";

     

       15
       15
       +
         versionNumber = "331.67";

     

       16
       16
        
       

     

       17
       17
        
       in

     

       18
       18
        
       

     
···

       27
       27
        
           if stdenv.system == "i686-linux" then

     

       28
       28
        
             fetchurl {

     

       29
       29
        
               url = "http://us.download.nvidia.com/XFree86/Linux-x86/${versionNumber}/NVIDIA-Linux-x86-${versionNumber}.run";

     

       30
       30
       -
               sha256 = "00d7bq8cfxk52qd4y226fz8m9m3mjq45fbgr3q7k08jyy9qmswmn";

     

       30
       30
       +
               sha256 = "1imc66yxnm01i58xwqrwqc612h0rhdz8x170hqr2pjyk99bllsv9";

     

       31
       31
        
             }

     

       32
       32
        
           else if stdenv.system == "x86_64-linux" then

     

       33
       33
        
             fetchurl {

     

       34
       34
        
               url = "http://us.download.nvidia.com/XFree86/Linux-x86_64/${versionNumber}/NVIDIA-Linux-x86_64-${versionNumber}-no-compat32.run";

     

       35
       35
       -
               sha256 = "0q3lvl1lypi33i847nqz4k3161ackh2n9kgyjn6v2c480f405hfk";

     

       35
       35
       +
               sha256 = "0qxd4jd25ymcr6w97f71kfn549x6wgg4g3vixd3sqlczknn85f47";

     

       36
       36
        
             }

     

       37
       37
        
           else throw "nvidia-x11 does not support platform ${stdenv.system}";

     

       38
       38

+3 -3

pkgs/os-specific/linux/pam/default.nix

···

       1
       1
        
       { stdenv, fetchurl, flex, cracklib }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "linux-pam-1.1.6";

     

       4
       4
       +
         name = "linux-pam-1.1.8";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
       -
           url = https://fedorahosted.org/releases/l/i/linux-pam/Linux-PAM-1.1.6.tar.bz2;

     

       8
       8
       -
           sha256 = "1hlz2kqvbjisvwyicdincq7nz897b9rrafyzccwzqiqg53b8gf5s";

     

       7
       7
       +
           url = http://www.linux-pam.org/library/Linux-PAM-1.1.8.tar.bz2;

     

       8
       8
       +
           sha256 = "0m8ygb40l1c13nsd4hkj1yh4p1ldawhhg8pyjqj9w5kd4cxg5cf4";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         nativeBuildInputs = [ flex ];

+23 -28

pkgs/os-specific/linux/systemd/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, intltool, gperf, libcap, dbus, kmod

     

       2
       2
        
       , xz, pam, acl, cryptsetup, libuuid, m4, utillinux

     

       3
       3
        
       , glib, kbd, libxslt, coreutils, libgcrypt, sysvtools, docbook_xsl

     

       4
       4
       -
       , kexectools, libmicrohttpd

     

       4
       4
       +
       , kexectools, libmicrohttpd, linuxHeaders

     

       5
       5
        
       , python ? null, pythonSupport ? false

     

       6
       6
        
       }:

     

       7
       7
        
       

     
···

       10
       10
        
       assert pythonSupport -> python != null;

     

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

     

       13
       13
       -
         version = "203";

     

       13
       13
       +
         version = "212";

     

       14
       14
        
         name = "systemd-${version}";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchurl {

     

       17
       17
        
           url = "http://www.freedesktop.org/software/systemd/${name}.tar.xz";

     

       18
       18
       -
           sha256 = "07gvn3rpski8sh1nz16npjf2bvj0spsjdwc5px9685g2pi6kxcb1";

     

       18
       18
       +
           sha256 = "1hpjcc42svrs06q3isjm3m5aphgkpfdylmvpnif71zh46ys0cab5";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         patches =

     

       22
       22
        
           [ # These are all changes between upstream and

     

       23
       23
       -
             # https://github.com/edolstra/systemd/tree/nixos-v203.

     

       23
       23
       +
             # https://github.com/edolstra/systemd/tree/nixos-v212.

     

       24
       24
        
             ./fixes.patch

     

       25
       25
       -
             ./fix_console_in_containers.patch

     

       26
       26
       -
           ]

     

       27
       27
       -
           ++ stdenv.lib.optional stdenv.isArm ./libc-bug-accept4-arm.patch;

     

       25
       25
       +
           ];

     

       28
       26
        
       

     

       29
       27
        
         buildInputs =

     

       30
       30
       -
           [ pkgconfig intltool gperf libcap dbus.libs kmod xz pam acl

     

       28
       28
       +
           [ pkgconfig intltool gperf libcap kmod xz pam acl

     

       31
       29
        
             /* cryptsetup */ libuuid m4 glib libxslt libgcrypt docbook_xsl

     

       32
       32
       -
             libmicrohttpd

     

       30
       30
       +
             libmicrohttpd linuxHeaders

     

       33
       31
        
           ] ++ stdenv.lib.optional pythonSupport python;

     

       34
       32
        
       

     

       35
       33
        
         configureFlags =

     
···

       45
       43
        
             "--with-dbussessionservicedir=$(out)/share/dbus-1/services"

     

       46
       44
        
             "--with-firmware-path=/root/test-firmware:/run/current-system/firmware"

     

       47
       45
        
             "--with-tty-gid=3" # tty in NixOS has gid 3

     

       46
       46
       +
             "--disable-networkd" # enable/use eventually

     

       47
       47
       +
             "--enable-compat-libs" # get rid of this eventually

     

       48
       48
        
           ];

     

       49
       49
        
       

     

       50
       50
        
         preConfigure =

     

       51
       51
        
           ''

     

       52
       52
        
             # FIXME: patch this in systemd properly (and send upstream).

     

       53
       53
        
             # FIXME: use sulogin from util-linux once updated.

     

       54
       54
       -
             for i in src/remount-fs/remount-fs.c src/core/mount.c src/core/swap.c src/fsck/fsck.c units/emergency.service.in units/rescue.service.m4.in src/journal/cat.c src/core/shutdown.c; do

     

       54
       54
       +
             for i in src/remount-fs/remount-fs.c src/core/mount.c src/core/swap.c src/fsck/fsck.c units/emergency.service.in units/rescue.service.m4.in src/journal/cat.c src/core/shutdown.c src/nspawn/nspawn.c; do

     

       55
       55
        
               test -e $i

     

       56
       56
        
               substituteInPlace $i \

     

       57
       57
       +
                 --replace /usr/bin/getent ${stdenv.glibc}/bin/getent \

     

       57
       58
        
                 --replace /bin/mount ${utillinux}/bin/mount \

     

       58
       59
        
                 --replace /bin/umount ${utillinux}/bin/umount \

     

       59
       60
        
                 --replace /sbin/swapon ${utillinux}/sbin/swapon \

     
···

       69
       70
        
               --replace /usr/lib/systemd/catalog/ $out/lib/systemd/catalog/

     

       70
       71
        
           '';

     

       71
       72
        
       

     

       73
       73
       +
         # This is needed because systemd uses the gold linker, which doesn't

     

       74
       74
       +
         # yet have the wrapper script to add rpath flags automatically.

     

       75
       75
       +
         NIX_LDFLAGS = "-rpath ${pam}/lib -rpath ${libcap}/lib -rpath ${acl}/lib -rpath ${stdenv.gcc.gcc}/lib";

     

       76
       76
       +
       

     

       72
       77
        
         PYTHON_BINARY = "${coreutils}/bin/env python"; # don't want a build time dependency on Python

     

       73
       78
        
       

     

       74
       79
        
         NIX_CFLAGS_COMPILE =

     
···

       77
       82
        
             "-UPOLKIT_AGENT_BINARY_PATH" "-DPOLKIT_AGENT_BINARY_PATH=\"/run/current-system/sw/bin/pkttyagent\""

     

       78
       83
        
             "-fno-stack-protector"

     

       79
       84
        
       

     

       80
       80
       -
             # Work around our kernel headers being too old.  FIXME: remove

     

       81
       81
       -
             # this after the next stdenv update.

     

       82
       82
       -
             "-DFS_NOCOW_FL=0x00800000"

     

       83
       83
       -
       

     

       84
       85
        
             # Set the release_agent on /sys/fs/cgroup/systemd to the

     

       85
       86
        
             # currently running systemd (/run/current-system/systemd) so

     

       86
       87
        
             # that we don't use an obsolete/garbage-collected release agent.

     
···

       94
       95
        
         # /var is mounted.

     

       95
       96
        
         makeFlags = "hwdb_bin=/var/lib/udev/hwdb.bin";

     

       96
       97
        
       

     

       97
       97
       -
         installFlags = "localstatedir=$(TMPDIR)/var sysconfdir=$(out)/etc sysvinitdir=$(TMPDIR)/etc/init.d";

     

       98
       98
       +
         installFlags =

     

       99
       99
       +
           [ "localstatedir=$(TMPDIR)/var"

     

       100
       100
       +
             "sysconfdir=$(out)/etc"

     

       101
       101
       +
             "sysvinitdir=$(TMPDIR)/etc/init.d"

     

       102
       102
       +
             "pamconfdir=$(out)/etc/pam.d"

     

       103
       103
       +
           ];

     

       98
       104
        
       

     

       99
       105
        
         # Get rid of configuration-specific data.

     

       100
       106
        
         postInstall =

     
···

       102
       108
        
             mkdir -p $out/example/systemd

     

       103
       109
        
             mv $out/lib/{modules-load.d,binfmt.d,sysctl.d,tmpfiles.d} $out/example

     

       104
       110
        
             mv $out/lib/systemd/{system,user} $out/example/systemd

     

       111
       111
       +
       

     

       112
       112
       +
             rm -rf $out/etc/systemd/system

     

       105
       113
        
       

     

       106
       114
        
             # Install SysV compatibility commands.

     

       107
       115
        
             mkdir -p $out/sbin

     
···

       127
       135
        
         # systemd builds is the same, then we can switch between them at

     

       128
       136
        
         # runtime; otherwise we can't and we need to reboot.

     

       129
       137
        
         passthru.interfaceVersion = 2;

     

       130
       130
       -
       

     

       131
       131
       -
         passthru.headers = stdenv.mkDerivation {

     

       132
       132
       -
           name = "systemd-headers-${version}";

     

       133
       133
       -
           inherit src;

     

       134
       134
       -
       

     

       135
       135
       -
           phases = [ "unpackPhase" "installPhase" ];

     

       136
       136
       -
       

     

       137
       137
       -
           # some are needed by dbus.libs, which is needed for systemd :-)

     

       138
       138
       -
           installPhase = ''

     

       139
       139
       -
             mkdir -p "$out/include/systemd"

     

       140
       140
       -
             mv src/systemd/*.h "$out/include/systemd"

     

       141
       141
       -
           '';

     

       142
       142
       -
         };

     

       143
       138
        
       

     

       144
       139
        
         meta = {

     

       145
       140
        
           homepage = "http://www.freedesktop.org/wiki/Software/systemd";

-14

pkgs/os-specific/linux/systemd/fix_console_in_containers.patch

···

       1
       1
       -
       diff -ruN systemd-203/units/getty@.service.m4 systemd-203-patched/units/getty@.service.m4

     

       2
       2
       -
       --- systemd-203/units/getty@.service.m4	2013-01-07 22:50:49.083315575 +0100

     

       3
       3
       -
       +++ systemd-203-patched/units/getty@.service.m4	2014-03-18 09:54:40.002476232 +0100

     

       4
       4
       -
       @@ -23,7 +23,9 @@

     

       5
       5
       -
        # On systems without virtual consoles, don't start any getty. (Note

     

       6
       6
       -
        # that serial gettys are covered by serial-getty@.service, not this

     

       7
       7
       -
        # unit

     

       8
       8
       -
       -ConditionPathExists=/dev/tty0

     

       9
       9
       -
       +ConditionPathExists=|/dev/tty0

     

       10
       10
       -
       +ConditionVirtualization=|lxc

     

       11
       11
       -
       +ConditionVirtualization=|lxc-libvirt

     

       12
       12
       -
        

     

       13
       13
       -
        [Service]

     

       14
       14
       -
        # the VT is cleared by TTYVTDisallocate

+184 -628

pkgs/os-specific/linux/systemd/fixes.patch

···

       1
       1
       -
       diff --git a/man/systemd.special.xml b/man/systemd.special.xml

     

       2
       2
       -
       index 7164b1e..29401eb 100644

     

       3
       3
       -
       --- a/man/systemd.special.xml

     

       4
       4
       -
       +++ b/man/systemd.special.xml

     

       5
       5
       -
       @@ -381,7 +381,7 @@

     

       6
       6
       -
                                                this unit during

     

       7
       7
       -
                                                installation. This is best

     

       8
       8
       -
                                                configured via

     

       9
       9
       -
       -                                        <varname>WantedBy=multi-uer.target</varname>

     

       10
       10
       -
       +                                        <varname>WantedBy=multi-user.target</varname>

     

       11
       11
       -
                                                in the unit's

     

       12
       12
       -
                                                <literal>[Install]</literal>

     

       13
       13
       -
                                                section.</para>

     

       14
       14
       -
       diff --git a/rules/80-net-name-slot.rules b/rules/80-net-name-slot.rules

     

       15
       15
       -
       index 15b5bc4..c5f1b38 100644

     

       16
       16
       -
       --- a/rules/80-net-name-slot.rules

     

       17
       17
       -
       +++ b/rules/80-net-name-slot.rules

     

       18
       18
       -
       @@ -1,6 +1,6 @@

     

       19
       19
       -
        # do not edit this file, it will be overwritten on update

     

       20
       20
       -
        

     

       21
       21
       -
       -ACTION=="remove", GOTO="net_name_slot_end"

     

       22
       22
       -
       +ACTION!="add", GOTO="net_name_slot_end"

     

       23
       23
       -
        SUBSYSTEM!="net", GOTO="net_name_slot_end"

     

       24
       24
       -
        NAME!="", GOTO="net_name_slot_end"

     

       25
       25
       -
        

     

       26
       1
        
       diff --git a/rules/99-systemd.rules.in b/rules/99-systemd.rules.in

     

       27
       27
       -
       index d17bdd9..040b10e 100644

     

       2
       2
       +
       index db72373..2fc12ca 100644

     

       28
       3
        
       --- a/rules/99-systemd.rules.in

     

       29
       4
        
       +++ b/rules/99-systemd.rules.in

     

       30
       5
        
       @@ -14,10 +14,6 @@ KERNEL=="vport*", TAG+="systemd"

     

       31
       31
       -
        SUBSYSTEM=="block", KERNEL!="ram*|loop*", TAG+="systemd"

     

       32
       32
       -
        SUBSYSTEM=="block", KERNEL!="ram*|loop*", ENV{DM_UDEV_DISABLE_OTHER_RULES_FLAG}=="1", ENV{SYSTEMD_READY}="0"

     

       6
       6
       +
        SUBSYSTEM=="block", KERNEL!="ram*", TAG+="systemd"

     

       7
       7
       +
        SUBSYSTEM=="block", KERNEL!="ram*", ENV{DM_UDEV_DISABLE_OTHER_RULES_FLAG}=="1", ENV{SYSTEMD_READY}="0"

     

       33
       8
        
        

     

       34
       9
        
       -# Ignore encrypted devices with no identified superblock on it, since

     

       35
       10
        
       -# we are probably still calling mke2fs or mkswap on it.

     

       36
       36
       -
       -SUBSYSTEM=="block", KERNEL!="ram*|loop*", ENV{DM_UUID}=="CRYPT-*", ENV{ID_PART_TABLE_TYPE}=="", ENV{ID_FS_USAGE}=="", ENV{SYSTEMD_READY}="0"

     

       11
       11
       +
       -SUBSYSTEM=="block", KERNEL!="ram*", ENV{DM_UUID}=="CRYPT-*", ENV{ID_PART_TABLE_TYPE}=="", ENV{ID_FS_USAGE}=="", ENV{SYSTEMD_READY}="0"

     

       37
       12
        
       -

     

       38
       13
        
        # Ignore raid devices that are not yet assembled and started

     

       39
       14
        
        SUBSYSTEM=="block", ENV{DEVTYPE}=="disk", KERNEL=="md*", TEST!="md/array_state", ENV{SYSTEMD_READY}="0"

     

       40
       15
        
        SUBSYSTEM=="block", ENV{DEVTYPE}=="disk", KERNEL=="md*", ATTR{md/array_state}=="|clear|inactive", ENV{SYSTEMD_READY}="0"

     

       41
       41
       -
       diff --git a/src/core/cgroup-semantics.c b/src/core/cgroup-semantics.c

     

       42
       42
       -
       index 82b02bb..7df9d01 100644

     

       43
       43
       -
       --- a/src/core/cgroup-semantics.c

     

       44
       44
       -
       +++ b/src/core/cgroup-semantics.c

     

       45
       45
       -
       @@ -255,7 +255,7 @@ static int map_blkio(const CGroupSemantics *s, const char *value, char **ret) {

     

       46
       46
       -
        }

     

       47
       47
       -
        

     

       48
       48
       -
        static const CGroupSemantics semantics[] = {

     

       49
       49
       -
       -        { "cpu",     "cpu.shares",                 "CPUShare",              false, parse_cpu_shares,          NULL,       NULL },

     

       50
       50
       -
       +        { "cpu",     "cpu.shares",                 "CPUShares",             false, parse_cpu_shares,          NULL,       NULL },

     

       51
       51
       -
                { "memory",  "memory.soft_limit_in_bytes", "MemorySoftLimit",       false, parse_memory_limit,        NULL,       NULL },

     

       52
       52
       -
                { "memory",  "memory.limit_in_bytes",      "MemoryLimit",           false, parse_memory_limit,        NULL,       NULL },

     

       53
       53
       -
                { "devices", "devices.allow",              "DeviceAllow",           true,  parse_device,              map_device, NULL },

     

       54
       54
       -
       diff --git a/src/core/dbus-execute.h b/src/core/dbus-execute.h

     

       55
       55
       -
       index 91d70e5..698102f 100644

     

       56
       56
       -
       --- a/src/core/dbus-execute.h

     

       57
       57
       -
       +++ b/src/core/dbus-execute.h

     

       58
       58
       -
       @@ -63,7 +63,7 @@

     

       59
       59
       -
                "  <property name=\"CPUSchedulingPolicy\" type=\"i\" access=\"read\"/>\n" \

     

       60
       60
       -
                "  <property name=\"CPUSchedulingPriority\" type=\"i\" access=\"read\"/>\n" \

     

       61
       61
       -
                "  <property name=\"CPUAffinity\" type=\"ay\" access=\"read\"/>\n" \

     

       62
       62
       -
       -        "  <property name=\"TimerSlackNS\" type=\"t\" access=\"read\"/>\n" \

     

       63
       63
       -
       +        "  <property name=\"TimerSlackNSec\" type=\"t\" access=\"read\"/>\n" \

     

       64
       64
       -
                "  <property name=\"CPUSchedulingResetOnFork\" type=\"b\" access=\"read\"/>\n" \

     

       65
       65
       -
                "  <property name=\"NonBlocking\" type=\"b\" access=\"read\"/>\n" \

     

       66
       66
       -
                "  <property name=\"StandardInput\" type=\"s\" access=\"read\"/>\n" \

     

       67
       67
       -
       diff --git a/src/core/dbus-manager.c b/src/core/dbus-manager.c

     

       68
       68
       -
       index 56b02a1..2b6d799 100644

     

       69
       69
       -
       --- a/src/core/dbus-manager.c

     

       70
       70
       -
       +++ b/src/core/dbus-manager.c

     

       71
       71
       -
       @@ -1550,7 +1550,7 @@ static DBusHandlerResult bus_manager_message_handler(DBusConnection *connection,

     

       72
       72
       -
                        _cleanup_strv_free_ char **l = NULL;

     

       73
       73
       -
                        char **e = NULL;

     

       74
       74
       -
        

     

       75
       75
       -
       -                SELINUX_ACCESS_CHECK(connection, message, "reboot");

     

       76
       76
       -
       +                SELINUX_ACCESS_CHECK(connection, message, "reload");

     

       77
       77
       -
        

     

       78
       78
       -
                        r = bus_parse_strv(message, &l);

     

       79
       79
       -
                        if (r == -ENOMEM)

     

       80
       80
       -
       @@ -1577,7 +1577,7 @@ static DBusHandlerResult bus_manager_message_handler(DBusConnection *connection,

     

       81
       81
       -
                        _cleanup_strv_free_ char **l = NULL;

     

       82
       82
       -
                        char **e = NULL;

     

       83
       83
       -
        

     

       84
       84
       -
       -                SELINUX_ACCESS_CHECK(connection, message, "reboot");

     

       85
       85
       -
       +                SELINUX_ACCESS_CHECK(connection, message, "reload");

     

       86
       86
       -
        

     

       87
       87
       -
                        r = bus_parse_strv(message, &l);

     

       88
       88
       -
                        if (r == -ENOMEM)

     

       89
       89
       -
       @@ -1605,7 +1605,7 @@ static DBusHandlerResult bus_manager_message_handler(DBusConnection *connection,

     

       90
       90
       -
                        char **f = NULL;

     

       91
       91
       -
                        DBusMessageIter iter;

     

       92
       92
       -
        

     

       93
       93
       -
       -                SELINUX_ACCESS_CHECK(connection, message, "reboot");

     

       94
       94
       -
       +                SELINUX_ACCESS_CHECK(connection, message, "reload");

     

       95
       95
       -
        

     

       96
       96
       -
                        if (!dbus_message_iter_init(message, &iter))

     

       97
       97
       -
                                goto oom;

     

       98
       98
       -
       diff --git a/src/core/dbus-swap.c b/src/core/dbus-swap.c

     

       99
       99
       -
       index 2e99fba..e72749a 100644

     

       100
       100
       -
       --- a/src/core/dbus-swap.c

     

       101
       101
       -
       +++ b/src/core/dbus-swap.c

     

       102
       102
       -
       @@ -93,6 +93,7 @@ static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_swap_append_swap_result, swap_result,

     

       103
       103
       -
        static const BusProperty bus_swap_properties[] = {

     

       104
       104
       -
                { "What",       bus_property_append_string, "s", offsetof(Swap, what),  true },

     

       105
       105
       -
                { "Priority",   bus_swap_append_priority,   "i", 0 },

     

       106
       106
       -
       +        { "TimeoutUSec",bus_property_append_usec,   "t", offsetof(Swap, timeout_usec)},

     

       107
       107
       -
                BUS_EXEC_COMMAND_PROPERTY("ExecActivate",   offsetof(Swap, exec_command[SWAP_EXEC_ACTIVATE]),   false),

     

       108
       108
       -
                BUS_EXEC_COMMAND_PROPERTY("ExecDeactivate", offsetof(Swap, exec_command[SWAP_EXEC_DEACTIVATE]), false),

     

       109
       109
       -
                { "ControlPID", bus_property_append_pid,    "u", offsetof(Swap, control_pid) },

     

       110
       16
        
       diff --git a/src/core/main.c b/src/core/main.c

     

       111
       111
       -
       index 7fc06be..101ce79 100644

     

       17
       17
       +
       index 41605ee..8517369 100644

     

       112
       18
        
       --- a/src/core/main.c

     

       113
       19
        
       +++ b/src/core/main.c

     

       114
       114
       -
       @@ -1590,14 +1590,14 @@ int main(int argc, char *argv[]) {

     

       115
       115
       -
                                log_error("Failed to adjust timer slack: %m");

     

       116
       116
       -
        

     

       117
       117
       -
                if (arg_capability_bounding_set_drop) {

     

       118
       118
       -
       -                r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);

     

       119
       119
       -
       +                r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);

     

       120
       120
       -
                        if (r < 0) {

     

       121
       121
       -
       -                        log_error("Failed to drop capability bounding set: %s", strerror(-r));

     

       122
       122
       -
       +                        log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));

     

       123
       123
       -
                                goto finish;

     

       124
       124
       -
                        }

     

       125
       125
       -
       -                r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);

     

       126
       126
       -
       +                r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);

     

       127
       127
       -
                        if (r < 0) {

     

       128
       128
       -
       -                        log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));

     

       129
       129
       -
       +                        log_error("Failed to drop capability bounding set: %s", strerror(-r));

     

       130
       130
       -
                                goto finish;

     

       131
       131
       -
                        }

     

       132
       132
       -
                }

     

       133
       133
       -
       @@ -1650,6 +1650,7 @@ int main(int argc, char *argv[]) {

     

       134
       134
       -
                /* This will close all file descriptors that were opened, but

     

       135
       135
       -
                 * not claimed by any unit. */

     

       136
       136
       -
                fdset_free(fds);

     

       137
       137
       -
       +        fds = NULL;

     

       138
       138
       -
        

     

       139
       139
       -
                if (serialization) {

     

       140
       140
       -
                        fclose(serialization);

     

       141
       141
       -
       @@ -1857,7 +1858,7 @@ finish:

     

       20
       20
       +
       @@ -1883,7 +1883,7 @@ finish:

     

       142
       21
        
                                char_array_0(sfd);

     

       143
       22
        
        

     

       144
       23
        
                                i = 0;

     
···

       147
       26
        
                                if (switch_root_dir)

     

       148
       27
        
                                        args[i++] = "--switched-root";

     

       149
       28
        
                                args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";

     

       150
       150
       -
       diff --git a/src/core/manager.c b/src/core/manager.c

     

       151
       151
       -
       index c7f8f20..0508628 100644

     

       152
       152
       -
       --- a/src/core/manager.c

     

       153
       153
       -
       +++ b/src/core/manager.c

     

       154
       154
       -
       @@ -1372,7 +1372,7 @@ static int manager_process_signal_fd(Manager *m) {

     

       29
       29
       +
       diff --git a/src/core/socket.c b/src/core/socket.c

     

       30
       30
       +
       index 7c18a2b..eba67d5 100644

     

       31
       31
       +
       --- a/src/core/socket.c

     

       32
       32
       +
       +++ b/src/core/socket.c

     

       33
       33
       +
       @@ -663,16 +663,25 @@ static int instance_from_socket(int fd, unsigned nr, char **instance) {

     

       34
       34
       +
                        int k;

     

       155
       35
        
        

     

       156
       156
       -
                        case SIGINT:

     

       157
       157
       -
                                if (m->running_as == SYSTEMD_SYSTEM) {

     

       158
       158
       -
       -                                manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);

     

       159
       159
       -
       +                                manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);

     

       160
       160
       -
                                        break;

     

       161
       161
       -
                                }

     

       162
       162
       -
        

     

       163
       163
       -
       diff --git a/src/core/service.c b/src/core/service.c

     

       164
       164
       -
       index 3617c24..4d0e2ad 100644

     

       165
       165
       -
       --- a/src/core/service.c

     

       166
       166
       -
       +++ b/src/core/service.c

     

       167
       167
       -
       @@ -2642,6 +2642,9 @@ static int service_serialize(Unit *u, FILE *f, FDSet *fds) {

     

       168
       168
       -
                if (s->exec_context.var_tmp_dir)

     

       169
       169
       -
                        unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);

     

       170
       170
       -
        

     

       171
       171
       -
       +        if (s->forbid_restart)

     

       172
       172
       -
       +                unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));

     

       173
       173
       -
       +

     

       174
       174
       -
                return 0;

     

       175
       175
       -
        }

     

       176
       176
       -
        

     

       177
       177
       -
       @@ -2776,6 +2779,14 @@ static int service_deserialize_item(Unit *u, const char *key, const char *value,

     

       178
       178
       -
                                return log_oom();

     

       179
       179
       -
        

     

       180
       180
       -
                        s->exec_context.var_tmp_dir = t;

     

       181
       181
       -
       +        } else if (streq(key, "forbid-restart")) {

     

       182
       182
       -
       +                int b;

     

       183
       183
       -
       +

     

       184
       184
       -
       +                b = parse_boolean(value);

     

       185
       185
       -
       +                if (b < 0)

     

       186
       186
       -
       +                        log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);

     

       187
       187
       -
       +                else

     

       188
       188
       -
       +                        s->forbid_restart = b;

     

       189
       189
       -
                } else

     

       190
       190
       -
                        log_debug_unit(u->id, "Unknown serialization key '%s'", key);

     

       191
       191
       -
        

     

       192
       192
       -
       diff --git a/src/core/snapshot.c b/src/core/snapshot.c

     

       193
       193
       -
       index a63eccd..a6807eb 100644

     

       194
       194
       -
       --- a/src/core/snapshot.c

     

       195
       195
       -
       +++ b/src/core/snapshot.c

     

       196
       196
       -
       @@ -217,8 +217,10 @@ int snapshot_create(Manager *m, const char *name, bool cleanup, DBusError *e, Sn

     

       197
       197
       -
                                if (asprintf(&n, "snapshot-%u.snapshot", ++ m->n_snapshots) < 0)

     

       198
       198
       -
                                        return -ENOMEM;

     

       199
       199
       -
        

     

       200
       200
       -
       -                        if (!manager_get_unit(m, n))

     

       201
       201
       -
       +                        if (!manager_get_unit(m, n)) {

     

       202
       202
       -
       +                                name = n;

     

       203
       203
       -
                                        break;

     

       204
       204
       -
       +                        }

     

       36
       36
       +
                        k = getpeercred(fd, &ucred);

     

       37
       37
       +
       -                if (k < 0)

     

       38
       38
       +
       +                if (k == -ENODATA) {

     

       39
       39
       +
       +                        /* This handles the case where somebody is

     

       40
       40
       +
       +                         * connecting from another pid/uid namespace

     

       41
       41
       +
       +                         * (e.g. from outside of our container). */

     

       42
       42
       +
       +                        if (asprintf(&r,

     

       43
       43
       +
       +                                     "%u-unknown",

     

       44
       44
       +
       +                                     nr) < 0)

     

       45
       45
       +
       +                                return -ENOMEM;

     

       46
       46
       +
       +                }

     

       47
       47
       +
       +                else if (k < 0)

     

       48
       48
       +
                                return k;

     

       49
       49
       +
       -

     

       50
       50
       +
       -                if (asprintf(&r,

     

       51
       51
       +
       -                             "%u-%lu-%lu",

     

       52
       52
       +
       -                             nr,

     

       53
       53
       +
       -                             (unsigned long) ucred.pid,

     

       54
       54
       +
       -                             (unsigned long) ucred.uid) < 0)

     

       55
       55
       +
       -                        return -ENOMEM;

     

       56
       56
       +
       -

     

       57
       57
       +
       +                else {

     

       58
       58
       +
       +                        if (asprintf(&r,

     

       59
       59
       +
       +                                     "%u-%lu-%lu",

     

       60
       60
       +
       +                                     nr,

     

       61
       61
       +
       +                                     (unsigned long) ucred.pid,

     

       62
       62
       +
       +                                     (unsigned long) ucred.uid) < 0)

     

       63
       63
       +
       +                                return -ENOMEM;

     

       64
       64
       +
       +                }

     

       65
       65
       +
                        break;

     

       66
       66
       +
                }

     

       205
       67
        
        

     

       206
       206
       -
                                free(n);

     

       207
       207
       -
                        }

     

       208
       68
        
       diff --git a/src/core/umount.c b/src/core/umount.c

     

       209
       209
       -
       index 1e95ad7..9f0e471 100644

     

       69
       69
       +
       index d1258f0..0311812 100644

     

       210
       70
        
       --- a/src/core/umount.c

     

       211
       71
        
       +++ b/src/core/umount.c

     

       212
       212
       -
       @@ -435,6 +435,8 @@ static int mount_points_list_umount(MountPoint **head, bool *changed, bool log_e

     

       72
       72
       +
       @@ -404,6 +404,8 @@ static int mount_points_list_umount(MountPoint **head, bool *changed, bool log_e

     

       213
       73
        
                         * anyway, since we are running from it. They have

     

       214
       74
        
                         * already been remounted ro. */

     

       215
       75
        
                        if (path_equal(m->path, "/")

     
···

       218
       78
        
        #ifndef HAVE_SPLIT_USR

     

       219
       79
        
                            || path_equal(m->path, "/usr")

     

       220
       80
        
        #endif

     

       221
       221
       -
       diff --git a/src/cryptsetup/cryptsetup-generator.c b/src/cryptsetup/cryptsetup-generator.c

     

       222
       222
       -
       index 81b7708..edd0b40 100644

     

       223
       223
       -
       --- a/src/cryptsetup/cryptsetup-generator.c

     

       224
       224
       -
       +++ b/src/cryptsetup/cryptsetup-generator.c

     

       225
       225
       -
       @@ -111,6 +111,7 @@ static int create_disk(

     

       226
       226
       -
                        "Conflicts=umount.target\n"

     

       227
       227
       -
                        "DefaultDependencies=no\n"

     

       228
       228
       -
                        "BindsTo=dev-mapper-%i.device\n"

     

       229
       229
       -
       +                "IgnoreOnIsolate=true\n"

     

       230
       230
       -
                        "After=systemd-readahead-collect.service systemd-readahead-replay.service\n",

     

       231
       231
       -
                        f);

     

       232
       232
       -
        

     

       233
       233
       -
       diff --git a/src/fstab-generator/fstab-generator.c b/src/fstab-generator/fstab-generator.c

     

       234
       234
       -
       index c17299f..6b3e67e 100644

     

       235
       235
       -
       --- a/src/fstab-generator/fstab-generator.c

     

       236
       236
       -
       +++ b/src/fstab-generator/fstab-generator.c

     

       237
       237
       -
       @@ -351,7 +351,7 @@ static int add_mount(

     

       238
       238
       -
        

     

       239
       239
       -
                if (automount && !path_equal(where, "/")) {

     

       240
       240
       -
                        automount_name = unit_name_from_path(where, ".automount");

     

       241
       241
       -
       -                if (!name)

     

       242
       242
       -
       +                if (!automount_name)

     

       243
       243
       -
                                return log_oom();

     

       244
       244
       -
        

     

       245
       245
       -
                        automount_unit = strjoin(arg_dest, "/", automount_name, NULL);

     

       246
       246
       -
       @@ -596,9 +596,9 @@ static int parse_proc_cmdline(void) {

     

       247
       247
       -
                        } else if (startswith(word, "rd.fstab=")) {

     

       248
       248
       -
        

     

       249
       249
       -
                                if (in_initrd()) {

     

       250
       250
       -
       -                                r = parse_boolean(word + 6);

     

       251
       251
       -
       +                                r = parse_boolean(word + 9);

     

       252
       252
       -
                                        if (r < 0)

     

       253
       253
       -
       -                                        log_warning("Failed to parse fstab switch %s. Ignoring.", word + 6);

     

       254
       254
       -
       +                                        log_warning("Failed to parse fstab switch %s. Ignoring.", word + 9);

     

       255
       255
       -
                                        else

     

       256
       256
       -
                                                arg_enabled = r;

     

       81
       81
       +
       diff --git a/src/nspawn/nspawn.c b/src/nspawn/nspawn.c

     

       82
       82
       +
       index 9a9ed9d..9e46e18 100644

     

       83
       83
       +
       --- a/src/nspawn/nspawn.c

     

       84
       84
       +
       +++ b/src/nspawn/nspawn.c

     

       85
       85
       +
       @@ -2667,6 +2667,7 @@ int main(int argc, char *argv[]) {

     

       86
       86
       +
                                        goto finish;

     

       257
       87
        
                                }

     

       258
       258
       -
       diff --git a/src/journal/journal-file.c b/src/journal/journal-file.c

     

       259
       259
       -
       index 38499a6..bb80905 100644

     

       260
       260
       -
       --- a/src/journal/journal-file.c

     

       261
       261
       -
       +++ b/src/journal/journal-file.c

     

       262
       262
       -
       @@ -907,6 +907,8 @@ static int journal_file_append_field(

     

       263
       263
       -
        

     

       264
       264
       -
                osize = offsetof(Object, field.payload) + size;

     

       265
       265
       -
                r = journal_file_append_object(f, OBJECT_FIELD, osize, &o, &p);

     

       266
       266
       -
       +        if (r < 0)

     

       267
       267
       -
       +                return r;

     

       268
       268
       -
        

     

       269
       269
       -
                o->field.hash = htole64(hash);

     

       270
       270
       -
                memcpy(o->field.payload, field, size);

     

       271
       271
       -
       diff --git a/src/journal/journald-server.c b/src/journal/journald-server.c

     

       272
       272
       -
       index 88163c0..e09ba4c 100644

     

       273
       273
       -
       --- a/src/journal/journald-server.c

     

       274
       274
       -
       +++ b/src/journal/journald-server.c

     

       275
       275
       -
       @@ -333,8 +333,10 @@ void server_rotate(Server *s) {

     

       276
       276
       -
                        if (r < 0)

     

       277
       277
       -
                                if (f)

     

       278
       278
       -
                                        log_error("Failed to rotate %s: %s", f->path, strerror(-r));

     

       279
       279
       -
       -                        else

     

       280
       280
       -
       +                        else {

     

       281
       281
       -
                                        log_error("Failed to create user journal: %s", strerror(-r));

     

       282
       282
       -
       +                                hashmap_remove(s->user_journals, k);

     

       283
       283
       -
       +                        }

     

       284
       284
       -
                        else {

     

       285
       285
       -
                                hashmap_replace(s->user_journals, k, f);

     

       286
       286
       -
                                server_fix_perms(s, f, PTR_TO_UINT32(k));

     

       287
       287
       -
       @@ -975,7 +977,8 @@ int process_event(Server *s, struct epoll_event *ev) {

     

       288
       288
       -
                        ssize_t n;

     

       289
       289
       -
        

     

       290
       290
       -
                        if (ev->events != EPOLLIN) {

     

       291
       291
       -
       -                        log_error("Got invalid event from epoll.");

     

       292
       292
       -
       +                        log_error("Got invalid event from epoll for %s: %"PRIx32,

     

       293
       293
       -
       +                                  "signal fd", ev->events);

     

       294
       294
       -
                                return -EIO;

     

       295
       295
       -
                        }

     

       296
       296
       -
        

     

       297
       297
       -
       @@ -1024,8 +1027,12 @@ int process_event(Server *s, struct epoll_event *ev) {

     

       298
       298
       -
                } else if (ev->data.fd == s->dev_kmsg_fd) {

     

       299
       299
       -
                        int r;

     

       300
       300
       -
        

     

       301
       301
       -
       -                if (ev->events != EPOLLIN) {

     

       302
       302
       -
       -                        log_error("Got invalid event from epoll.");

     

       303
       303
       -
       +                if (ev->events & EPOLLERR)

     

       304
       304
       -
       +                        log_warning("/dev/kmsg buffer overrun, some messages lost.");

     

       305
       305
       -
       +

     

       306
       306
       -
       +                if (!(ev->events & EPOLLIN)) {

     

       307
       307
       -
       +                        log_error("Got invalid event from epoll for %s: %"PRIx32,

     

       308
       308
       -
       +                                  "/dev/kmsg", ev->events);

     

       309
       309
       -
                                return -EIO;

     

       310
       310
       -
                        }

     

       311
       311
       -
        

     

       312
       312
       -
       @@ -1039,7 +1046,9 @@ int process_event(Server *s, struct epoll_event *ev) {

     

       313
       313
       -
                           ev->data.fd == s->syslog_fd) {

     

       314
       314
       -
        

     

       315
       315
       -
                        if (ev->events != EPOLLIN) {

     

       316
       316
       -
       -                        log_error("Got invalid event from epoll.");

     

       317
       317
       -
       +                        log_error("Got invalid event from epoll for %s: %"PRIx32,

     

       318
       318
       -
       +                                  ev->data.fd == s->native_fd ? "native fd" : "syslog fd",

     

       319
       319
       -
       +                                  ev->events);

     

       320
       320
       -
                                return -EIO;

     

       321
       321
       -
                        }

     

       322
       322
       -
        

     

       323
       323
       -
       @@ -1140,12 +1149,7 @@ int process_event(Server *s, struct epoll_event *ev) {

     

       324
       324
       -
                                        char *e;

     

       325
       325
       -
        

     

       326
       326
       -
                                        if (n > 0 && n_fds == 0) {

     

       327
       327
       -
       -                                        e = memchr(s->buffer, '\n', n);

     

       328
       328
       -
       -                                        if (e)

     

       329
       329
       -
       -                                                *e = 0;

     

       330
       330
       -
       -                                        else

     

       331
       331
       -
       -                                                s->buffer[n] = 0;

     

       332
       332
       -
       -

     

       333
       333
       -
       +                                        s->buffer[n] = 0;

     

       334
       334
       -
                                                server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);

     

       335
       335
       -
                                        } else if (n_fds > 0)

     

       336
       336
       -
                                                log_warning("Got file descriptors via syslog socket. Ignoring.");

     

       337
       337
       -
       @@ -1167,7 +1171,8 @@ int process_event(Server *s, struct epoll_event *ev) {

     

       338
       338
       -
                } else if (ev->data.fd == s->stdout_fd) {

     

       339
       339
       -
        

     

       340
       340
       -
                        if (ev->events != EPOLLIN) {

     

       341
       341
       -
       -                        log_error("Got invalid event from epoll.");

     

       342
       342
       -
       +                        log_error("Got invalid event from epoll for %s: %"PRIx32,

     

       343
       343
       -
       +                                  "stdout fd", ev->events);

     

       344
       344
       -
                                return -EIO;

     

       345
       345
       -
                        }

     

       346
       346
       -
        

     

       347
       347
       -
       @@ -1178,6 +1183,8 @@ int process_event(Server *s, struct epoll_event *ev) {

     

       348
       348
       -
                        StdoutStream *stream;

     

       349
       349
       -
        

     

       350
       350
       -
                        if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {

     

       351
       351
       -
       +                        log_error("Got invalid event from epoll for %s: %"PRIx32,

     

       352
       352
       -
       +                                  "stdout stream", ev->events);

     

       353
       353
       -
                                log_error("Got invalid event from epoll.");

     

       354
       354
       -
                                return -EIO;

     

       355
       355
       -
                        }

     

       356
       356
       -
       diff --git a/src/journal/mmap-cache.c b/src/journal/mmap-cache.c

     

       357
       357
       -
       index 54bf114..bd197d0 100644

     

       358
       358
       -
       --- a/src/journal/mmap-cache.c

     

       359
       359
       -
       +++ b/src/journal/mmap-cache.c

     

       360
       360
       -
       @@ -308,9 +308,13 @@ static void mmap_cache_free(MMapCache *m) {

     

       361
       361
       -
                while ((c = hashmap_first(m->contexts)))

     

       362
       362
       -
                        context_free(c);

     

       363
       363
       -
        

     

       364
       364
       -
       +        hashmap_free(m->contexts);

     

       365
       365
       -
       +

     

       366
       366
       -
                while ((f = hashmap_first(m->fds)))

     

       367
       367
       -
                        fd_free(f);

     

       368
       368
       -
        

     

       369
       369
       -
       +        hashmap_free(m->fds);

     

       370
       370
       -
       +

     

       371
       371
       -
                while (m->unused)

     

       372
       372
       -
                        window_free(m->unused);

     

       373
       373
       -
        

     

       374
       374
       -
       diff --git a/src/libsystemd-bus/bus-internal.c b/src/libsystemd-bus/bus-internal.c

     

       375
       375
       -
       index 0e66f3d..cac948e 100644

     

       376
       376
       -
       --- a/src/libsystemd-bus/bus-internal.c

     

       377
       377
       -
       +++ b/src/libsystemd-bus/bus-internal.c

     

       378
       378
       -
       @@ -63,7 +63,7 @@ bool object_path_is_valid(const char *p) {

     

       379
       379
       -
        

     

       380
       380
       -
        bool interface_name_is_valid(const char *p) {

     

       381
       381
       -
                const char *q;

     

       382
       382
       -
       -        bool dot, found_dot;

     

       383
       383
       -
       +        bool dot, found_dot = false;

     

       384
       384
       -
        

     

       385
       385
       -
                if (isempty(p))

     

       386
       386
       -
                        return false;

     

       387
       387
       -
       @@ -103,7 +103,7 @@ bool interface_name_is_valid(const char *p) {

     

       388
       388
       -
        

     

       389
       389
       -
        bool service_name_is_valid(const char *p) {

     

       390
       390
       -
                const char *q;

     

       391
       391
       -
       -        bool dot, found_dot, unique;

     

       392
       392
       -
       +        bool dot, found_dot = false, unique;

     

       393
       393
       -
        

     

       394
       394
       -
                if (isempty(p))

     

       395
       395
       -
                        return false;

     

       396
       396
       -
       diff --git a/src/libsystemd-bus/sd-bus.c b/src/libsystemd-bus/sd-bus.c

     

       397
       397
       -
       index 7d6d848..b0eb2f1 100644

     

       398
       398
       -
       --- a/src/libsystemd-bus/sd-bus.c

     

       399
       399
       -
       +++ b/src/libsystemd-bus/sd-bus.c

     

       400
       400
       -
       @@ -1088,11 +1088,11 @@ static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {

     

       401
       401
       -
                        if (r == 0)

     

       402
       402
       -
                                return ret;

     

       403
       403
       -
        

     

       404
       404
       -
       -                r = 1;

     

       405
       405
       -
       +                ret = 1;

     

       406
       406
       -
                } while (!z);

     

       407
       407
       -
        

     

       408
       408
       -
                *m = z;

     

       409
       409
       -
       -        return 1;

     

       410
       410
       -
       +        return ret;

     

       411
       411
       -
        }

     

       412
       412
       -
        

     

       413
       413
       -
        int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {

     

       414
       414
       -
       diff --git a/src/libudev/libudev-enumerate.c b/src/libudev/libudev-enumerate.c

     

       415
       415
       -
       index 5ccaabd..100c1fb 100644

     

       416
       416
       -
       --- a/src/libudev/libudev-enumerate.c

     

       417
       417
       -
       +++ b/src/libudev/libudev-enumerate.c

     

       418
       418
       -
       @@ -299,7 +299,7 @@ _public_ struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enume

     

       419
       419
       -
                                /* skip to be delayed devices, and move the to

     

       420
       420
       -
                                 * the point where the prefix changes. We can

     

       421
       421
       -
                                 * only move one item at a time. */

     

       422
       422
       -
       -                        if (!move_later) {

     

       423
       423
       -
       +                        if (move_later == -1) {

     

       424
       424
       -
                                        move_later_prefix = devices_delay_later(udev_enumerate->udev, entry->syspath);

     

       425
       425
       -
        

     

       426
       426
       -
                                        if (move_later_prefix > 0) {

     

       427
       427
       -
       @@ -718,6 +718,8 @@ static bool match_subsystem(struct udev_enumerate *udev_enumerate, const char *s

     

       428
       428
       -
        {

     

       429
       429
       -
                struct udev_list_entry *list_entry;

     

       430
       430
       -
        

     

       431
       431
       -
       +        subsystem = subsystem ? : "";

     

       432
       432
       -
       +

     

       433
       433
       -
                udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_nomatch_list)) {

     

       434
       434
       -
                        if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)

     

       435
       435
       -
                                return false;

     

       436
       436
       -
       @@ -826,23 +828,27 @@ nomatch:

     

       437
       437
       -
        static int parent_add_child(struct udev_enumerate *enumerate, const char *path)

     

       438
       438
       -
        {

     

       439
       439
       -
                struct udev_device *dev;

     

       440
       440
       -
       +        int r = 0;

     

       441
       441
       -
        

     

       442
       442
       -
                dev = udev_device_new_from_syspath(enumerate->udev, path);

     

       443
       443
       -
                if (dev == NULL)

     

       444
       444
       -
                        return -ENODEV;

     

       88
       88
       +
                        } else {

     

       89
       89
       +
       +#if 0

     

       90
       90
       +
                                const char *p;

     

       445
       91
        
        

     

       446
       446
       -
                if (!match_subsystem(enumerate, udev_device_get_subsystem(dev)))

     

       447
       447
       -
       -                return 0;

     

       448
       448
       -
       +                goto nomatch;

     

       449
       449
       -
                if (!match_sysname(enumerate, udev_device_get_sysname(dev)))

     

       450
       450
       -
       -                return 0;

     

       451
       451
       -
       +                goto nomatch;

     

       452
       452
       -
                if (!match_property(enumerate, dev))

     

       453
       453
       -
       -                return 0;

     

       454
       454
       -
       +                goto nomatch;

     

       455
       455
       -
                if (!match_sysattr(enumerate, dev))

     

       456
       456
       -
       -                return 0;

     

       457
       457
       -
       +                goto nomatch;

     

       92
       92
       +
                                p = strappenda(arg_directory,

     

       93
       93
       +
       @@ -2676,6 +2677,7 @@ int main(int argc, char *argv[]) {

     

       94
       94
       +
                                        goto finish;

     

       458
       95
        
        

     

       459
       459
       -
                syspath_add(enumerate, udev_device_get_syspath(dev));

     

       460
       460
       -
       +        r = 1;

     

       461
       461
       -
       +

     

       462
       462
       -
       +nomatch:

     

       463
       463
       -
                udev_device_unref(dev);

     

       464
       464
       -
       -        return 1;

     

       465
       465
       -
       +        return r;

     

       466
       466
       -
        }

     

       467
       467
       -
        

     

       468
       468
       -
        static int parent_crawl_children(struct udev_enumerate *enumerate, const char *path, int maxdepth)

     

       469
       469
       -
       diff --git a/src/libudev/libudev.sym b/src/libudev/libudev.sym

     

       470
       470
       -
       index 8e09430..1e6f885 100644

     

       471
       471
       -
       --- a/src/libudev/libudev.sym

     

       472
       472
       -
       +++ b/src/libudev/libudev.sym

     

       473
       473
       -
       @@ -109,5 +109,6 @@ global:

     

       474
       474
       -
        } LIBUDEV_189;

     

       475
       475
       -
        

     

       476
       476
       -
        LIBUDEV_199 {

     

       477
       477
       -
       +global:

     

       478
       478
       -
                udev_device_set_sysattr_value;

     

       479
       479
       -
        } LIBUDEV_196;

     

       480
       480
       -
       diff --git a/src/modules-load/modules-load.c b/src/modules-load/modules-load.c

     

       481
       481
       -
       index 7b19ee0..49ee420 100644

     

       482
       482
       -
       --- a/src/modules-load/modules-load.c

     

       483
       483
       -
       +++ b/src/modules-load/modules-load.c

     

       484
       484
       -
       @@ -302,8 +302,8 @@ int main(int argc, char *argv[]) {

     

       485
       485
       -
        

     

       486
       486
       -
                        STRV_FOREACH(i, arg_proc_cmdline_modules) {

     

       487
       487
       -
                                k = load_module(ctx, *i);

     

       488
       488
       -
       -                        if (k < 0)

     

       489
       489
       -
       -                                r = EXIT_FAILURE;

     

       490
       490
       -
       +                        if (k < 0 && r == 0)

     

       491
       491
       -
       +                                r = k;

     

       96
       96
       +
                                }

     

       97
       97
       +
       +#endif

     

       492
       98
        
                        }

     

       493
       493
       -
        

     

       494
       494
       -
                        r = conf_files_list_nulstr(&files, ".conf", NULL, conf_file_dirs);

     

       99
       99
       +
                } else {

     

       100
       100
       +
                        char template[] = "/tmp/nspawn-root-XXXXXX";

     

       495
       101
        
       diff --git a/src/nss-myhostname/netlink.c b/src/nss-myhostname/netlink.c

     

       496
       496
       -
       index b1ef912..4f2ab5c 100644

     

       102
       102
       +
       index d61ecdf..228a3a4 100644

     

       497
       103
        
       --- a/src/nss-myhostname/netlink.c

     

       498
       104
        
       +++ b/src/nss-myhostname/netlink.c

     

       499
       499
       -
       @@ -113,6 +113,10 @@ static int read_reply(int fd, struct address **list, unsigned *n_list) {

     

       105
       105
       +
       @@ -112,6 +112,10 @@ static int read_reply(int fd, struct address **list, unsigned *n_list) {

     

       500
       106
        
                            ifaddrmsg->ifa_scope == RT_SCOPE_NOWHERE)

     

       501
       107
        
                                continue;

     

       502
       108
        
        

     
···

       507
       113
        
                        if (ifaddrmsg->ifa_flags & IFA_F_DEPRECATED)

     

       508
       114
        
                                continue;

     

       509
       115
        
        

     

       510
       510
       -
       diff --git a/src/shared/efivars.c b/src/shared/efivars.c

     

       511
       511
       -
       index 8d004ba..99340c9 100644

     

       512
       512
       -
       --- a/src/shared/efivars.c

     

       513
       513
       -
       +++ b/src/shared/efivars.c

     

       514
       514
       -
       @@ -383,7 +383,8 @@ int efi_get_boot_options(uint16_t **options) {

     

       515
       515
       -
                        list[count ++] = id;

     

       516
       516
       -
                }

     

       517
       517
       -
        

     

       518
       518
       -
       -        qsort(list, count, sizeof(uint16_t), cmp_uint16);

     

       519
       519
       -
       +        if (list)

     

       520
       520
       -
       +                qsort(list, count, sizeof(uint16_t), cmp_uint16);

     

       521
       521
       -
        

     

       522
       522
       -
                *options = list;

     

       523
       523
       -
                return count;

     

       524
       524
       -
       diff --git a/src/shared/env-util.c b/src/shared/env-util.c

     

       525
       525
       -
       index 6a52fb9..598222c 100644

     

       526
       526
       -
       --- a/src/shared/env-util.c

     

       527
       527
       -
       +++ b/src/shared/env-util.c

     

       528
       528
       -
       @@ -406,7 +406,9 @@ char **strv_env_clean_log(char **e, const char *message) {

     

       529
       529
       -
                        e[k++] = *p;

     

       530
       530
       -
                }

     

       531
       531
       -
        

     

       532
       532
       -
       -        e[k] = NULL;

     

       533
       533
       -
       +        if (e)

     

       534
       534
       -
       +                e[k] = NULL;

     

       535
       535
       -
       +

     

       536
       536
       -
                return e;

     

       537
       537
       -
        }

     

       538
       538
       -
        

     

       539
       539
       -
       diff --git a/src/shared/log.c b/src/shared/log.c

     

       540
       540
       -
       index 27317f7..8f4995a 100644

     

       541
       541
       -
       --- a/src/shared/log.c

     

       542
       542
       -
       +++ b/src/shared/log.c

     

       543
       543
       -
       @@ -115,16 +115,20 @@ void log_close_syslog(void) {

     

       544
       544
       -
        

     

       545
       545
       -
        static int create_log_socket(int type) {

     

       546
       546
       -
                int fd;

     

       547
       547
       -
       +        struct timeval tv;

     

       548
       548
       -
        

     

       549
       549
       -
       -        /* All output to the syslog/journal fds we do asynchronously,

     

       550
       550
       -
       -         * and if the buffers are full we just drop the messages */

     

       551
       551
       -
       -

     

       552
       552
       -
       -        fd = socket(AF_UNIX, type|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);

     

       553
       553
       -
       +        fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0);

     

       554
       554
       -
                if (fd < 0)

     

       555
       555
       -
                        return -errno;

     

       556
       556
       -
        

     

       557
       557
       -
                fd_inc_sndbuf(fd, SNDBUF_SIZE);

     

       558
       558
       -
        

     

       559
       559
       -
       +        /* We need a blocking fd here since we'd otherwise lose

     

       560
       560
       -
       +        messages way too early. However, let's not hang forever in the

     

       561
       561
       -
       +        unlikely case of a deadlock. */

     

       562
       562
       -
       +        timeval_store(&tv, 1*USEC_PER_MINUTE);

     

       563
       563
       -
       +        setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));

     

       564
       564
       -
       +

     

       565
       565
       -
                return fd;

     

       566
       566
       -
        }

     

       567
       567
       -
        

     

       568
       568
       -
       diff --git a/src/shared/polkit.c b/src/shared/polkit.c

     

       569
       569
       -
       index cea7074..1c5e9e3 100644

     

       570
       570
       -
       --- a/src/shared/polkit.c

     

       571
       571
       -
       +++ b/src/shared/polkit.c

     

       572
       572
       -
       @@ -38,12 +38,8 @@ int verify_polkit(

     

       573
       573
       -
        

     

       574
       574
       -
        #ifdef ENABLE_POLKIT

     

       575
       575
       -
                DBusMessage *m = NULL, *reply = NULL;

     

       576
       576
       -
       -        const char *unix_process = "unix-process", *pid = "pid", *starttime = "start-time", *cancel_id = "";

     

       577
       577
       -
       +        const char *system_bus_name = "system-bus-name", *name = "name", *cancel_id = "";

     

       578
       578
       -
                uint32_t flags = interactive ? 1 : 0;

     

       579
       579
       -
       -        pid_t pid_raw;

     

       580
       580
       -
       -        uint32_t pid_u32;

     

       581
       581
       -
       -        unsigned long long starttime_raw;

     

       582
       582
       -
       -        uint64_t starttime_u64;

     

       583
       583
       -
                DBusMessageIter iter_msg, iter_struct, iter_array, iter_dict, iter_variant;

     

       584
       584
       -
                int r;

     

       585
       585
       -
                dbus_bool_t authorized = FALSE, challenge = FALSE;

     

       586
       586
       -
       @@ -68,14 +64,6 @@ int verify_polkit(

     

       587
       587
       -
        

     

       588
       588
       -
        #ifdef ENABLE_POLKIT

     

       589
       589
       -
        

     

       590
       590
       -
       -        pid_raw = bus_get_unix_process_id(c, sender, error);

     

       591
       591
       -
       -        if (pid_raw == 0)

     

       592
       592
       -
       -                return -EINVAL;

     

       593
       593
       -
       -

     

       594
       594
       -
       -        r = get_starttime_of_pid(pid_raw, &starttime_raw);

     

       595
       595
       -
       -        if (r < 0)

     

       596
       596
       -
       -                return r;

     

       597
       597
       -
       -

     

       598
       598
       -
                m = dbus_message_new_method_call(

     

       599
       599
       -
                                "org.freedesktop.PolicyKit1",

     

       600
       600
       -
                                "/org/freedesktop/PolicyKit1/Authority",

     

       601
       601
       -
       @@ -86,22 +74,13 @@ int verify_polkit(

     

       602
       602
       -
        

     

       603
       603
       -
                dbus_message_iter_init_append(m, &iter_msg);

     

       604
       604
       -
        

     

       605
       605
       -
       -        pid_u32 = (uint32_t) pid_raw;

     

       606
       606
       -
       -        starttime_u64 = (uint64_t) starttime_raw;

     

       607
       607
       -
       -

     

       608
       608
       -
                if (!dbus_message_iter_open_container(&iter_msg, DBUS_TYPE_STRUCT, NULL, &iter_struct) ||

     

       609
       609
       -
       -            !dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &unix_process) ||

     

       610
       610
       -
       +            !dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &system_bus_name) ||

     

       611
       611
       -
                    !dbus_message_iter_open_container(&iter_struct, DBUS_TYPE_ARRAY, "{sv}", &iter_array) ||

     

       612
       612
       -
                    !dbus_message_iter_open_container(&iter_array, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict) ||

     

       613
       613
       -
       -            !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &pid) ||

     

       614
       614
       -
       -            !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "u", &iter_variant) ||

     

       615
       615
       -
       -            !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_UINT32, &pid_u32) ||

     

       616
       616
       -
       -            !dbus_message_iter_close_container(&iter_dict, &iter_variant) ||

     

       617
       617
       -
       -            !dbus_message_iter_close_container(&iter_array, &iter_dict) ||

     

       618
       618
       -
       -            !dbus_message_iter_open_container(&iter_array, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict) ||

     

       619
       619
       -
       -            !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &starttime) ||

     

       620
       620
       -
       -            !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "t", &iter_variant) ||

     

       621
       621
       -
       -            !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_UINT64, &starttime_u64) ||

     

       622
       622
       -
       +            !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &name) ||

     

       623
       623
       -
       +            !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "s", &iter_variant) ||

     

       624
       624
       -
       +            !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_STRING, &sender) ||

     

       625
       625
       -
                    !dbus_message_iter_close_container(&iter_dict, &iter_variant) ||

     

       626
       626
       -
                    !dbus_message_iter_close_container(&iter_array, &iter_dict) ||

     

       627
       627
       -
                    !dbus_message_iter_close_container(&iter_struct, &iter_array) ||

     

       628
       116
        
       diff --git a/src/systemctl/systemctl.c b/src/systemctl/systemctl.c

     

       629
       629
       -
       index 3cca861..f6052dd 100644

     

       117
       117
       +
       index 0887bc3..6b502ce 100644

     

       630
       118
        
       --- a/src/systemctl/systemctl.c

     

       631
       119
        
       +++ b/src/systemctl/systemctl.c

     

       632
       632
       -
       @@ -1482,7 +1482,7 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me

     

       120
       120
       +
       @@ -2561,7 +2561,7 @@ static int start_unit_one(

     

       633
       121
        
        

     

       634
       634
       -
                } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {

     

       635
       635
       -
                        uint32_t id;

     

       636
       636
       -
       -                const char *path, *result, *unit;

     

       637
       637
       -
       +                const char *path, *result, *unit, *r;

     

       638
       638
       -
        

     

       639
       639
       -
                        if (dbus_message_get_args(message, &error,

     

       640
       640
       -
                                                  DBUS_TYPE_UINT32, &id,

     

       641
       641
       -
       @@ -1491,7 +1491,11 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me

     

       642
       642
       -
                                                  DBUS_TYPE_STRING, &result,

     

       643
       643
       -
                                                  DBUS_TYPE_INVALID)) {

     

       644
       644
       -
        

     

       645
       645
       -
       -                        free(set_remove(d->set, (char*) path));

     

       646
       646
       -
       +                        r = set_remove(d->set, (char*) path);

     

       647
       647
       -
       +                        if (!r)

     

       648
       648
       -
       +                                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

     

       649
       649
       -
       +

     

       650
       650
       -
       +                        free(r);

     

       122
       122
       +
                        log_debug("Adding %s to the set", p);

     

       123
       123
       +
                        r = set_consume(s, p);

     

       124
       124
       +
       -                if (r < 0)

     

       125
       125
       +
       +                if (r < 0 && r != -EEXIST)

     

       126
       126
       +
                                return log_oom();

     

       127
       127
       +
                }

     

       651
       128
        
        

     

       652
       652
       -
                                if (!isempty(result))

     

       653
       653
       -
                                        d->result = strdup(result);

     

       654
       654
       -
       @@ -1511,7 +1515,11 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me

     

       655
       655
       -
                                /* Compatibility with older systemd versions <

     

       656
       656
       -
                                 * 183 during upgrades. This should be dropped

     

       657
       657
       -
                                 * one day. */

     

       658
       658
       -
       -                        free(set_remove(d->set, (char*) path));

     

       659
       659
       -
       +                        r = set_remove(d->set, (char*) path);

     

       660
       660
       -
       +                        if (!r)

     

       661
       661
       -
       +                                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

     

       662
       662
       -
       +

     

       663
       663
       -
       +                        free(r);

     

       129
       129
       +
       diff --git a/units/console-getty.service.m4.in b/units/console-getty.service.m4.in

     

       130
       130
       +
       index 8ac51a4..cae9fb5 100644

     

       131
       131
       +
       --- a/units/console-getty.service.m4.in

     

       132
       132
       +
       +++ b/units/console-getty.service.m4.in

     

       133
       133
       +
       @@ -15,7 +15,6 @@ After=rc-local.service

     

       134
       134
       +
        Before=getty.target

     

       664
       135
        
        

     

       665
       665
       -
                                if (*result)

     

       666
       666
       -
                                        d->result = strdup(result);

     

       667
       667
       -
       @@ -1867,7 +1875,7 @@ static int start_unit_one(

     

       668
       668
       -
                                return log_oom();

     

       136
       136
       +
        [Service]

     

       137
       137
       +
       -ExecStart=-/sbin/agetty --noclear --keep-baud console 115200,38400,9600 $TERM

     

       138
       138
       +
        Type=idle

     

       139
       139
       +
        Restart=always

     

       140
       140
       +
        RestartSec=0

     

       141
       141
       +
       diff --git a/units/container-getty@.service.m4.in b/units/container-getty@.service.m4.in

     

       142
       142
       +
       index 4f7794b..bad2a9a 100644

     

       143
       143
       +
       --- a/units/container-getty@.service.m4.in

     

       144
       144
       +
       +++ b/units/container-getty@.service.m4.in

     

       145
       145
       +
       @@ -16,7 +16,6 @@ Before=getty.target

     

       146
       146
       +
        IgnoreOnIsolate=yes

     

       669
       147
        
        

     

       670
       670
       -
                        r = set_consume(s, p);

     

       671
       671
       -
       -                if (r < 0) {

     

       672
       672
       -
       +                if (r < 0 && r != -EEXIST) {

     

       673
       673
       -
                                log_error("Failed to add path to set.");

     

       674
       674
       -
                                return r;

     

       675
       675
       -
                        }

     

       148
       148
       +
        [Service]

     

       149
       149
       +
       -ExecStart=-/sbin/agetty --noclear --keep-baud pts/%I 115200,38400,9600 $TERM

     

       150
       150
       +
        Type=idle

     

       151
       151
       +
        Restart=always

     

       152
       152
       +
        RestartSec=0

     

       676
       153
        
       diff --git a/units/emergency.service.in b/units/emergency.service.in

     

       677
       677
       -
       index 442f0e0..6b7eafd 100644

     

       154
       154
       +
       index 94c090f..0d20640 100644

     

       678
       155
        
       --- a/units/emergency.service.in

     

       679
       156
        
       +++ b/units/emergency.service.in

     

       680
       157
        
       @@ -15,7 +15,6 @@ Before=shutdown.target

     
···

       685
       162
        
        ExecStartPre=-/bin/echo -e 'Welcome to emergency mode! After logging in, type "journalctl -xb" to view\\nsystem logs, "systemctl reboot" to reboot, "systemctl default" to try again\\nto boot into default mode.'

     

       686
       163
        
        ExecStart=-/sbin/sulogin

     

       687
       164
        
        ExecStopPost=@SYSTEMCTL@ --fail --no-block default

     

       165
       165
       +
       diff --git a/units/getty@.service.m4 b/units/getty@.service.m4

     

       166
       166
       +
       index aa853b8..8bcc647 100644

     

       167
       167
       +
       --- a/units/getty@.service.m4

     

       168
       168
       +
       +++ b/units/getty@.service.m4

     

       169
       169
       +
       @@ -23,11 +23,12 @@ IgnoreOnIsolate=yes

     

       170
       170
       +
        # On systems without virtual consoles, don't start any getty. Note

     

       171
       171
       +
        # that serial gettys are covered by serial-getty@.service, not this

     

       172
       172
       +
        # unit.

     

       173
       173
       +
       -ConditionPathExists=/dev/tty0

     

       174
       174
       +
       +ConditionPathExists=|/dev/tty0

     

       175
       175
       +
       +ConditionVirtualization=|lxc

     

       176
       176
       +
       +ConditionVirtualization=|lxc-libvirt

     

       177
       177
       +
        

     

       178
       178
       +
        [Service]

     

       179
       179
       +
        # the VT is cleared by TTYVTDisallocate

     

       180
       180
       +
       -ExecStart=-/sbin/agetty --noclear %I $TERM

     

       181
       181
       +
        Type=idle

     

       182
       182
       +
        Restart=always

     

       183
       183
       +
        RestartSec=0

     

       184
       184
       +
       diff --git a/units/kmod-static-nodes.service.in b/units/kmod-static-nodes.service.in

     

       185
       185
       +
       index 368f980..d0c1bd2 100644

     

       186
       186
       +
       --- a/units/kmod-static-nodes.service.in

     

       187
       187
       +
       +++ b/units/kmod-static-nodes.service.in

     

       188
       188
       +
       @@ -10,7 +10,6 @@ Description=Create list of required static device nodes for the current kernel

     

       189
       189
       +
        DefaultDependencies=no

     

       190
       190
       +
        Before=sysinit.target systemd-tmpfiles-setup-dev.service

     

       191
       191
       +
        ConditionCapability=CAP_MKNOD

     

       192
       192
       +
       -ConditionPathExists=/lib/modules/%v/modules.devname

     

       193
       193
       +
        

     

       194
       194
       +
        [Service]

     

       195
       195
       +
        Type=oneshot

     

       688
       196
        
       diff --git a/units/local-fs.target b/units/local-fs.target

     

       689
       689
       -
       index 18c3d74..a09054c 100644

     

       197
       197
       +
       index ae3cedc..0e36840 100644

     

       690
       198
        
       --- a/units/local-fs.target

     

       691
       199
        
       +++ b/units/local-fs.target

     

       692
       692
       -
       @@ -11,3 +11,5 @@ Documentation=man:systemd.special(7)

     

       693
       693
       -
        After=local-fs-pre.target

     

       200
       200
       +
       @@ -13,3 +13,5 @@ DefaultDependencies=no

     

       201
       201
       +
        Conflicts=shutdown.target

     

       694
       202
        
        OnFailure=emergency.target

     

       695
       695
       -
        OnFailureIsolate=no

     

       203
       203
       +
        OnFailureJobMode=replace-irreversibly

     

       696
       204
        
       +

     

       697
       205
        
       +X-StopOnReconfiguration=yes

     

       698
       206
        
       diff --git a/units/remote-fs.target b/units/remote-fs.target

     

       699
       699
       -
       index 09213e8..47b4cf5 100644

     

       207
       207
       +
       index 43ffa5c..156a681 100644

     

       700
       208
        
       --- a/units/remote-fs.target

     

       701
       209
        
       +++ b/units/remote-fs.target

     

       702
       702
       -
       @@ -10,5 +10,7 @@ Description=Remote File Systems

     

       703
       703
       -
        Documentation=man:systemd.special(7)

     

       704
       704
       -
        After=remote-fs-pre.target

     

       210
       210
       +
       @@ -12,5 +12,7 @@ After=remote-fs-pre.target

     

       211
       211
       +
        DefaultDependencies=no

     

       212
       212
       +
        Conflicts=shutdown.target

     

       705
       213
        
        

     

       706
       214
        
       +X-StopOnReconfiguration=yes

     

       707
       215
        
       +

     

       708
       216
        
        [Install]

     

       709
       217
        
        WantedBy=multi-user.target

     

       710
       218
        
       diff --git a/units/rescue.service.m4.in b/units/rescue.service.m4.in

     

       711
       711
       -
       index 269797a..2c640f4 100644

     

       219
       219
       +
       index 552ef89..af3915f 100644

     

       712
       220
        
       --- a/units/rescue.service.m4.in

     

       713
       221
        
       +++ b/units/rescue.service.m4.in

     

       714
       222
        
       @@ -16,7 +16,6 @@ Before=shutdown.target

     
···

       719
       227
        
        ExecStartPre=-/bin/echo -e 'Welcome to rescue mode! Type "systemctl default" or ^D to enter default mode.\\nType "journalctl -xb" to view system logs. Type "systemctl reboot" to reboot.'

     

       720
       228
        
        ExecStart=-/sbin/sulogin

     

       721
       229
        
        ExecStopPost=-@SYSTEMCTL@ --fail --no-block default

     

       230
       230
       +
       diff --git a/units/serial-getty@.service.m4 b/units/serial-getty@.service.m4

     

       231
       231
       +
       index 4ac51e7..86a3b59 100644

     

       232
       232
       +
       --- a/units/serial-getty@.service.m4

     

       233
       233
       +
       +++ b/units/serial-getty@.service.m4

     

       234
       234
       +
       @@ -22,7 +22,6 @@ Before=getty.target

     

       235
       235
       +
        IgnoreOnIsolate=yes

     

       236
       236
       +
        

     

       237
       237
       +
        [Service]

     

       238
       238
       +
       -ExecStart=-/sbin/agetty --keep-baud 115200,38400,9600 %I $TERM

     

       239
       239
       +
        Type=idle

     

       240
       240
       +
        Restart=always

     

       241
       241
       +
        RestartSec=0

     

       722
       242
        
       diff --git a/units/sysinit.target b/units/sysinit.target

     

       723
       243
        
       index 8f4fb8f..e0f0147 100644

     

       724
       244
        
       --- a/units/sysinit.target

     
···

       731
       251
        
       -After=local-fs.target swap.target emergency.service emergency.target

     

       732
       252
        
       +After=emergency.service emergency.target

     

       733
       253
        
        RefuseManualStart=yes

     

       254
       254
       +
       diff --git a/units/systemd-backlight@.service.in b/units/systemd-backlight@.service.in

     

       255
       255
       +
       index e945d87..77728f2 100644

     

       256
       256
       +
       --- a/units/systemd-backlight@.service.in

     

       257
       257
       +
       +++ b/units/systemd-backlight@.service.in

     

       258
       258
       +
       @@ -19,3 +19,4 @@ Type=oneshot

     

       259
       259
       +
        RemainAfterExit=yes

     

       260
       260
       +
        ExecStart=@rootlibexecdir@/systemd-backlight load %i

     

       261
       261
       +
        ExecStop=@rootlibexecdir@/systemd-backlight save %i

     

       262
       262
       +
       +X-RestartIfChanged=false

     

       734
       263
        
       diff --git a/units/systemd-journald.service.in b/units/systemd-journald.service.in

     

       735
       735
       -
       index ab2e50c..9563a7d 100644

     

       264
       264
       +
       index de93879..c9a49f3 100644

     

       736
       265
        
       --- a/units/systemd-journald.service.in

     

       737
       266
        
       +++ b/units/systemd-journald.service.in

     

       738
       738
       -
       @@ -24,3 +24,8 @@ CapabilityBoundingSet=CAP_SYS_ADMIN CAP_DAC_OVERRIDE CAP_SYS_PTRACE CAP_SYSLOG C

     

       267
       267
       +
       @@ -25,3 +25,8 @@ WatchdogSec=1min

     

       739
       268
        
        # Increase the default a bit in order to allow many simultaneous

     

       740
       269
        
        # services being run since we keep one fd open per service.

     

       741
       270
        
        LimitNOFILE=16384

     
···

       744
       273
        
       +# journald to stop logging (see

     

       745
       274
        
       +# https://bugs.freedesktop.org/show_bug.cgi?id=56043).

     

       746
       275
        
       +X-RestartIfChanged=no

     

       276
       276
       +
       diff --git a/units/systemd-random-seed.service.in b/units/systemd-random-seed.service.in

     

       277
       277
       +
       index 1879b2f..9b895b9 100644

     

       278
       278
       +
       --- a/units/systemd-random-seed.service.in

     

       279
       279
       +
       +++ b/units/systemd-random-seed.service.in

     

       280
       280
       +
       @@ -19,3 +19,4 @@ Type=oneshot

     

       281
       281
       +
        RemainAfterExit=yes

     

       282
       282
       +
        ExecStart=@rootlibexecdir@/systemd-random-seed load

     

       283
       283
       +
        ExecStop=@rootlibexecdir@/systemd-random-seed save

     

       284
       284
       +
       +X-RestartIfChanged=false

     

       285
       285
       +
       diff --git a/units/systemd-rfkill@.service.in b/units/systemd-rfkill@.service.in

     

       286
       286
       +
       index 9d264a2..c505535 100644

     

       287
       287
       +
       --- a/units/systemd-rfkill@.service.in

     

       288
       288
       +
       +++ b/units/systemd-rfkill@.service.in

     

       289
       289
       +
       @@ -19,3 +19,4 @@ Type=oneshot

     

       290
       290
       +
        RemainAfterExit=yes

     

       291
       291
       +
        ExecStart=@rootlibexecdir@/systemd-rfkill load %I

     

       292
       292
       +
        ExecStop=@rootlibexecdir@/systemd-rfkill save %I

     

       293
       293
       +
       +X-RestartIfChanged=false

     

       294
       294
       +
       diff --git a/units/systemd-update-utmp.service.in b/units/systemd-update-utmp.service.in

     

       295
       295
       +
       index da7dda7..4cc550d 100644

     

       296
       296
       +
       --- a/units/systemd-update-utmp.service.in

     

       297
       297
       +
       +++ b/units/systemd-update-utmp.service.in

     

       298
       298
       +
       @@ -19,3 +19,4 @@ Type=oneshot

     

       299
       299
       +
        RemainAfterExit=yes

     

       300
       300
       +
        ExecStart=@rootlibexecdir@/systemd-update-utmp reboot

     

       301
       301
       +
        ExecStop=@rootlibexecdir@/systemd-update-utmp shutdown

     

       302
       302
       +
       +X-RestartIfChanged=false

     

       747
       303
        
       diff --git a/units/systemd-user-sessions.service.in b/units/systemd-user-sessions.service.in

     

       748
       304
        
       index 0869e73..b6ed958 100644

     

       749
       305
        
       --- a/units/systemd-user-sessions.service.in

-81

pkgs/os-specific/linux/systemd/libc-bug-accept4-arm.patch

···

       1
       1
       -
       Based on a patch for udev in

     

       2
       2
       -
       nixpkgs(upstart)/pkgs/os-specific/linux/udev/pre-accept4-kernel.patch

     

       3
       3
       -
       

     

       4
       4
       -
       It was taken from:

     

       5
       5
       -
       https://github.com/archlinuxarm/PKGBUILDs/blob/master/core/udev-oxnas/pre-accept4-kernel.patch

     

       6
       6
       -
       

     

       7
       7
       -
       Basically, ARM implemented accept4() only in 2.6.36. Nixpkgs now uses

     

       8
       8
       -
       linux headers from 2.6.35. And the particular nixpkgs glibc version had a bug,

     

       9
       9
       -
       not checking about 2.6.36 for accept4 on arm.

     

       10
       10
       -
       

     

       11
       11
       -
       diff --git a/src/journal/journald-stream.c b/src/journal/journald-stream.c

     

       12
       12
       -
       index 7b88f74..a9f7b62 100644

     

       13
       13
       -
       --- a/src/journal/journald-stream.c

     

       14
       14
       -
       +++ b/src/journal/journald-stream.c

     

       15
       15
       -
       @@ -347,10 +347,12 @@ int stdout_stream_new(Server *s) {

     

       16
       16
       -
                int fd, r;

     

       17
       17
       -
                socklen_t len;

     

       18
       18
       -
                struct epoll_event ev;

     

       19
       19
       -
       +        int flgs;

     

       20
       20
       -
        

     

       21
       21
       -
                assert(s);

     

       22
       22
       -
        

     

       23
       23
       -
       -        fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);

     

       24
       24
       -
       +        //fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);

     

       25
       25
       -
       +        fd = accept(s->stdout_fd, NULL, NULL);

     

       26
       26
       -
                if (fd < 0) {

     

       27
       27
       -
                        if (errno == EAGAIN)

     

       28
       28
       -
                                return 0;

     

       29
       29
       -
       @@ -359,6 +361,11 @@ int stdout_stream_new(Server *s) {

     

       30
       30
       -
                        return -errno;

     

       31
       31
       -
                }

     

       32
       32
       -
        

     

       33
       33
       -
       +        // Since we don't have accept4

     

       34
       34
       -
       +        flgs = fcntl(fd, F_GETFL, NULL);

     

       35
       35
       -
       +        if(flgs >= 0) fcntl(fd, F_SETFL, flgs | O_NONBLOCK);

     

       36
       36
       -
       +        fcntl(fd, F_SETFD, FD_CLOEXEC);

     

       37
       37
       -
       +

     

       38
       38
       -
                if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {

     

       39
       39
       -
                        log_warning("Too many stdout streams, refusing connection.");

     

       40
       40
       -
                        close_nointr_nofail(fd);

     

       41
       41
       -
       diff --git a/src/udev/udev-ctrl.c b/src/udev/udev-ctrl.c

     

       42
       42
       -
       index a235912..c05e4b4 100644

     

       43
       43
       -
       --- a/src/udev/udev-ctrl.c

     

       44
       44
       -
       +++ b/src/udev/udev-ctrl.c

     

       45
       45
       -
       @@ -15,6 +15,7 @@

     

       46
       46
       -
        #include <stddef.h>

     

       47
       47
       -
        #include <string.h>

     

       48
       48
       -
        #include <unistd.h>

     

       49
       49
       -
       +#include <fcntl.h>

     

       50
       50
       -
        #include <sys/types.h>

     

       51
       51
       -
        #include <sys/poll.h>

     

       52
       52
       -
        #include <sys/socket.h>

     

       53
       53
       -
       @@ -181,6 +182,7 @@ struct udev_ctrl_connection *udev_ctrl_get_connection(struct udev_ctrl *uctrl)

     

       54
       54
       -
                struct ucred ucred;

     

       55
       55
       -
                socklen_t slen;

     

       56
       56
       -
                const int on = 1;

     

       57
       57
       -
       +        int flgs;

     

       58
       58
       -
        

     

       59
       59
       -
                conn = calloc(1, sizeof(struct udev_ctrl_connection));

     

       60
       60
       -
                if (conn == NULL)

     

       61
       61
       -
       @@ -188,13 +190,19 @@ struct udev_ctrl_connection *udev_ctrl_get_connection(struct udev_ctrl *uctrl)

     

       62
       62
       -
                conn->refcount = 1;

     

       63
       63
       -
                conn->uctrl = uctrl;

     

       64
       64
       -
        

     

       65
       65
       -
       -        conn->sock = accept4(uctrl->sock, NULL, NULL, SOCK_CLOEXEC|SOCK_NONBLOCK);

     

       66
       66
       -
       +        //conn->sock = accept4(uctrl->sock, NULL, NULL, SOCK_CLOEXEC|SOCK_NONBLOCK);

     

       67
       67
       -
       +        conn->sock = accept(uctrl->sock, NULL, NULL);

     

       68
       68
       -
                if (conn->sock < 0) {

     

       69
       69
       -
                        if (errno != EINTR)

     

       70
       70
       -
                                log_error("unable to receive ctrl connection: %m\n");

     

       71
       71
       -
                        goto err;

     

       72
       72
       -
                }

     

       73
       73
       -
        

     

       74
       74
       -
       +        // Since we don't have accept4

     

       75
       75
       -
       +        flgs = fcntl(conn->sock, F_GETFL, NULL);

     

       76
       76
       -
       +        if(flgs >= 0) fcntl(conn->sock, F_SETFL, flgs | O_NONBLOCK);

     

       77
       77
       -
       +        fcntl(conn->sock, F_SETFD, FD_CLOEXEC);

     

       78
       78
       -
       +

     

       79
       79
       -
                /* check peer credential of connection */

     

       80
       80
       -
                slen = sizeof(ucred);

     

       81
       81
       -
                if (getsockopt(conn->sock, SOL_SOCKET, SO_PEERCRED, &ucred, &slen) < 0) {

+4 -8

pkgs/os-specific/linux/util-linux/default.nix

···

       1
       1
        
       { stdenv, fetchurl, zlib, ncurses ? null, perl ? null, pam }:

     

       2
       2
       -
       let

     

       3
       3
       -
         ver = "2.24";

     

       4
       4
       -
       in

     

       2
       2
       +
       

     

       5
       3
        
       stdenv.mkDerivation rec {

     

       6
       6
       -
         name = "util-linux-${ver}";

     

       4
       4
       +
         name = "util-linux-2.24.1";

     

       7
       5
        
       

     

       8
       6
        
         src = fetchurl {

     

       9
       9
       -
           url = "http://www.kernel.org/pub/linux/utils/util-linux/v${ver}/${name}.tar.bz2";

     

       10
       10
       -
           sha256 = "1nfnymj03rdcxjb677a9qq1zirppr8csh32cb85qm23x5xndi6v3";

     

       7
       7
       +
           url = "http://www.kernel.org/pub/linux/utils/util-linux/v2.24/${name}.tar.xz";

     

       8
       8
       +
           sha256 = "0444xhfm9525v3aagyfbp38mp7xsw2fn9zg4ya713c7s5hivcpl3";

     

       11
       9
        
         };

     

       12
       10
        
       

     

       13
       11
        
         crossAttrs = {

     
···

       19
       17
        
         # (/sbin/mount.*) through an environment variable, but that's

     

       20
       18
        
         # somewhat risky because we have to consider that mount can setuid

     

       21
       19
        
         # root...

     

       22
       22
       -
         # --enable-libmount-mount  fixes the behaviour being /etc/mtab a symlink to /proc/monunts

     

       23
       23
       -
         #     http://pl.digipedia.org/usenet/thread/19513/1924/

     

       24
       20
        
         configureFlags = ''

     

       25
       21
        
           --enable-write

     

       26
       22
        
           --enable-last

+3 -3

pkgs/servers/x11/xorg/default.nix

···

       1960
       1960
        
         })) // {inherit ;};

     

       1961
       1961
        
       

     

       1962
       1962
        
         xorgserver = (stdenv.mkDerivation ((if overrides ? xorgserver then overrides.xorgserver else x: x) {

     

       1963
       1963
       -
           name = "xorg-server-1.14.5";

     

       1963
       1963
       +
           name = "xorg-server-1.14.6";

     

       1964
       1964
        
           builder = ./builder.sh;

     

       1965
       1965
        
           src = fetchurl {

     

       1966
       1966
       -
             url = mirror://xorg/individual/xserver/xorg-server-1.14.5.tar.bz2;

     

       1967
       1967
       -
             sha256 = "1lb1fkscy7nwnabfj0d2shvxga16i047g11if18plj0n2jzhc3wd";

     

       1966
       1966
       +
             url = mirror://xorg/individual/xserver/xorg-server-1.14.6.tar.bz2;

     

       1967
       1967
       +
             sha256 = "0c57vp1z0p38dj5gfipkmlw6bvbz1mrr0sb3sbghdxxdyq4kzcz8";

     

       1968
       1968
        
           };

     

       1969
       1969
        
           buildInputs = [pkgconfig renderproto libdrm openssl libX11 libXau libXaw libXdmcp libXfixes libxkbfile libXmu libXpm libXrender libXres libXt libXv ];

     

       1970
       1970
        
         })) // {inherit renderproto libdrm openssl libX11 libXau libXaw libXdmcp libXfixes libxkbfile libXmu libXpm libXrender libXres libXt libXv ;};

+1 -1

pkgs/servers/x11/xorg/tarballs-7.7.list

···

       170
       170
        
       mirror://xorg/individual/app/xlsclients-1.1.3.tar.bz2

     

       171
       171
        
       mirror://xorg/individual/app/xmodmap-1.0.8.tar.bz2

     

       172
       172
        
       mirror://xorg/X11R7.7/src/everything/xorg-docs-1.7.tar.bz2

     

       173
       173
       -
       mirror://xorg/individual/xserver/xorg-server-1.14.5.tar.bz2

     

       173
       173
       +
       mirror://xorg/individual/xserver/xorg-server-1.14.6.tar.bz2

     

       174
       174
        
       mirror://xorg/X11R7.7/src/everything/xorg-sgml-doctools-1.11.tar.bz2

     

       175
       175
        
       mirror://xorg/X11R7.7/src/everything/xpr-1.0.4.tar.bz2

     

       176
       176
        
       mirror://xorg/individual/app/xprop-1.2.2.tar.bz2

+8 -10

pkgs/stdenv/generic/default.nix

···

       58
       58
        
                 pos' = if pos != null then "‘" + pos.file + ":" + toString pos.line + "’" else "«unknown-file»";

     

       59
       59
        
               in

     

       60
       60
        
               if !allowUnfree && (let l = lib.lists.toList attrs.meta.license or []; in lib.lists.elem "unfree" l || lib.lists.elem "unfree-redistributable" l) then

     

       61
       61
       -
                 throw ''package ‘${attrs.name}’ in ${pos'} has an unfree license, refusing to evaluate.

     

       62
       62
       -
                        You can set

     

       63
       63
       -
                           { nixpkgs.config.allowUnfree = true; }

     

       64
       64
       -
                        in configuration.nix to override this.

     

       65
       65
       -
                        If you use Nix standalone, you can add

     

       66
       66
       -
                           { config.allowUnfree = true; }

     

       67
       67
       -
                        to ~/.nixpkgs/config.nix or pass

     

       68
       68
       -
                           --arg config '{ allowUnfree = true; }'

     

       69
       69
       -
                        on the command line.

     

       70
       70
       -
                       ''

     

       61
       61
       +
                 throw ''

     

       62
       62
       +
                   Package ‘${attrs.name}’ in ${pos'} has an unfree license, refusing to evaluate. You can set

     

       63
       63
       +
                     { nixpkgs.config.allowUnfree = true; }

     

       64
       64
       +
                   in configuration.nix to override this. If you use Nix standalone, you can add

     

       65
       65
       +
                     { config.allowUnfree = true; }

     

       66
       66
       +
                   to ~/.nixpkgs/config.nix or pass

     

       67
       67
       +
                     --arg config '{ allowUnfree = true; }'

     

       68
       68
       +
                   on the command line.''

     

       71
       69
        
               else if !allowBroken && attrs.meta.broken or false then

     

       72
       70
        
                 throw "you can't use package ‘${attrs.name}’ in ${pos'} because it has been marked as broken"

     

       73
       71
        
               else if !allowBroken && attrs.meta.platforms or null != null && !lib.lists.elem result.system attrs.meta.platforms then

+2 -2

pkgs/tools/networking/dhcpcd/default.nix

···

       1
       1
        
       { stdenv, fetchurl, pkgconfig, udev }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "dhcpcd-6.2.1";

     

       4
       4
       +
         name = "dhcpcd-6.3.2";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "http://roy.marples.name/downloads/dhcpcd/${name}.tar.bz2";

     

       8
       8
       -
           sha256 = "1gs23zwhzml2aam4j6rdncaqfv3z5n1ifx6lq4b8ccifqa87gbga";

     

       8
       8
       +
           sha256 = "1v2m5wdr6x5cz6i0n1y63am9dhj5j7ylrk717scjgwwjdbq1x75n";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
        
         patches = [ ./lxc_ro_promote_secondaries.patch ];

+16 -15

pkgs/top-level/all-packages.nix

···

       829
       829
        
       

     

       830
       830
        
         dhcpcd = callPackage ../tools/networking/dhcpcd { };

     

       831
       831
        
       

     

       832
       832
       -
         dhcpcd_without_udev = callPackage ../tools/networking/dhcpcd { udev = null; };

     

       833
       833
       -
       

     

       834
       832
        
         diffstat = callPackage ../tools/text/diffstat { };

     

       835
       833
        
       

     

       836
       834
        
         diffutils = callPackage ../tools/text/diffutils { };

     
···

       4192
       4190
        
         dbus_glib       = callPackage ../development/libraries/dbus-glib { };

     

       4193
       4191
        
         dbus_java       = callPackage ../development/libraries/java/dbus-java { };

     

       4194
       4192
        
         dbus_python     = callPackage ../development/python-modules/dbus { };

     

       4193
       4193
       +
       

     

       4195
       4194
        
         # Should we deprecate these? Currently there are many references.

     

       4196
       4196
       -
         dbus_tools = dbus.tools;

     

       4197
       4197
       -
         dbus_libs = dbus.libs;

     

       4198
       4198
       -
         dbus_daemon = dbus.daemon;

     

       4195
       4195
       +
         dbus_tools = pkgs.dbus.tools;

     

       4196
       4196
       +
         dbus_libs = pkgs.dbus.libs;

     

       4197
       4197
       +
         dbus_daemon = pkgs.dbus.daemon;

     

       4199
       4198
        
       

     

       4200
       4199
        
         dhex = callPackage ../applications/editors/dhex { };

     

       4201
       4200
        
       

     
···

       6869
       6868
        
         libnl = callPackage ../os-specific/linux/libnl { };

     

       6870
       6869
        
         libnl_3_2_19 = callPackage ../os-specific/linux/libnl/3.2.19.nix { };

     

       6871
       6870
        
       

     

       6872
       6872
       -
         linuxHeaders = linuxHeaders37;

     

       6873
       6873
       -
       

     

       6874
       6871
        
         linuxConsoleTools = callPackage ../os-specific/linux/consoletools { };

     

       6875
       6872
        
       

     

       6876
       6876
       -
         linuxHeaders26 = callPackage ../os-specific/linux/kernel-headers/2.6.32.nix { };

     

       6877
       6877
       -
       

     

       6878
       6878
       -
         linuxHeaders37 = callPackage ../os-specific/linux/kernel-headers/3.7.nix { };

     

       6873
       6873
       +
         linuxHeaders = linuxHeaders_3_7;

     

       6879
       6874
        
       

     

       6880
       6880
       -
         linuxHeaders26Cross = forceNativeDrv (import ../os-specific/linux/kernel-headers/2.6.32.nix {

     

       6875
       6875
       +
         linuxHeaders24Cross = forceNativeDrv (import ../os-specific/linux/kernel-headers/2.4.nix {

     

       6881
       6876
        
           inherit stdenv fetchurl perl;

     

       6882
       6877
        
           cross = assert crossSystem != null; crossSystem;

     

       6883
       6878
        
         });

     

       6884
       6879
        
       

     

       6885
       6885
       -
         linuxHeaders24Cross = forceNativeDrv (import ../os-specific/linux/kernel-headers/2.4.nix {

     

       6880
       6880
       +
         linuxHeaders26Cross = forceNativeDrv (import ../os-specific/linux/kernel-headers/2.6.32.nix {

     

       6886
       6881
        
           inherit stdenv fetchurl perl;

     

       6887
       6882
        
           cross = assert crossSystem != null; crossSystem;

     

       6888
       6883
        
         });

     

       6884
       6884
       +
       

     

       6885
       6885
       +
         linuxHeaders_3_7 = callPackage ../os-specific/linux/kernel-headers/3.7.nix { };

     

       6886
       6886
       +
       

     

       6887
       6887
       +
         linuxHeaders_3_14 = callPackage ../os-specific/linux/kernel-headers/3.14.nix { };

     

       6889
       6888
        
       

     

       6890
       6889
        
         # We can choose:

     

       6891
       6890
        
         linuxHeadersCrossChooser = ver : if ver == "2.4" then linuxHeaders24Cross

     
···

       6894
       6893
        
       

     

       6895
       6894
        
         linuxHeadersCross = assert crossSystem != null;

     

       6896
       6895
        
           linuxHeadersCrossChooser crossSystem.platform.kernelMajor;

     

       6897
       6897
       -
       

     

       6898
       6898
       -
         linuxHeaders_2_6_28 = callPackage ../os-specific/linux/kernel-headers/2.6.28.nix { };

     

       6899
       6896
        
       

     

       6900
       6897
        
         kernelPatches = callPackage ../os-specific/linux/kernel/patches.nix { };

     

       6901
       6898
        
       

     
···

       7004
       7001
        
           blcr = callPackage ../os-specific/linux/blcr { };

     

       7005
       7002
        
       

     

       7006
       7003
        
           cryptodev = callPackage ../os-specific/linux/cryptodev { };

     

       7004
       7004
       +
       

     

       7005
       7005
       +
           cpupower = callPackage ../os-specific/linux/cpupower { };

     

       7007
       7006
        
       

     

       7008
       7007
        
           e1000e = callPackage ../os-specific/linux/e1000e {};

     

       7009
       7008
        
       

     
···

       7262
       7261
        
       

     

       7263
       7262
        
         sysstat = callPackage ../os-specific/linux/sysstat { };

     

       7264
       7263
        
       

     

       7265
       7265
       -
         systemd = callPackage ../os-specific/linux/systemd { };

     

       7264
       7264
       +
         systemd = callPackage ../os-specific/linux/systemd {

     

       7265
       7265
       +
           linuxHeaders = linuxHeaders_3_14;

     

       7266
       7266
       +
         };

     

       7266
       7267
        
       

     

       7267
       7268
        
         systemtap = callPackage ../development/tools/profiling/systemtap {

     

       7268
       7269
        
           inherit (gnome) libglademm;