src/core/killall.c

	killall.c revision 1359fffa573f42463e3b369df5e57b0c33821a61
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers/***
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  This file is part of systemd.
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  Copyright 2010 ProFUSION embedded systems
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  systemd is free software; you can redistribute it and/or modify it
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  under the terms of the GNU Lesser General Public License as published by
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  the Free Software Foundation; either version 2.1 of the License, or
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  (at your option) any later version.
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  systemd is distributed in the hope that it will be useful, but
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  WITHOUT ANY WARRANTY; without even the implied warranty of
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  Lesser General Public License for more details.
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  You should have received a copy of the GNU Lesser General Public License
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers  along with systemd; If not, see <http://www.gnu.org/licenses/>.
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers***/
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include <errno.h>
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include <signal.h>
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include <sys/wait.h>
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include <unistd.h>
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "alloc-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "fd-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "formats-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "killall.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "parse-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "process-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "set.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "string-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "terminal-util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#include "util.h"
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers#define TIMEOUT_USEC (10 * USEC_PER_SEC)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sieversstatic bool ignore_proc(pid_t pid, bool warn_rootfs) {
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        _cleanup_fclose_ FILE *f = NULL;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        char c;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        const char *p;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        size_t count;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        uid_t uid;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        int r;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        /* We are PID 1, let's not commit suicide */
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        if (pid == 1)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                return true;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        r = get_process_uid(pid, &uid);
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        if (r < 0)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                return true; /* not really, but better safe than sorry */
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        /* Non-root processes otherwise are always subject to be killed */
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        if (uid != 0)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                return false;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        p = procfs_file_alloca(pid, "cmdline");
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        f = fopen(p, "re");
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        if (!f)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                return true; /* not really, but has the desired effect */
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        count = fread(&c, 1, 1, f);
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        /* Kernel threads have an empty cmdline */
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        if (count <= 0)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                return true;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        /* Processes with argv[0][0] = '@' we ignore from the killing
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers         * spree.
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers         *
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers         * http://www.freedesktop.org/wiki/Software/systemd/RootStorageDaemons */
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers        if (c == '@' && warn_rootfs) {
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                _cleanup_free_ char *comm = NULL;
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                r = pid_from_same_root_fs(pid);
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                if (r < 0)
796b06c21b62d13c9021e2fbd9c58a5c6edb2764Kay Sievers                        return true;

                get_process_comm(pid, &comm);

                if (r)
                        log_notice("Process " PID_FMT " (%s) has been been marked to be excluded from killing. It is "
                                   "running from the root file system, and thus likely to block re-mounting of the "
                                   "root file system to read-only. Please consider moving it into an initrd file "
                                   "system instead.", pid, strna(comm));
                return true;
        } else if (c == '@')
                return true;

        return false;
}

static void wait_for_children(Set *pids, sigset_t *mask) {
        usec_t until;

        assert(mask);

        if (set_isempty(pids))
                return;

        until = now(CLOCK_MONOTONIC) + TIMEOUT_USEC;
        for (;;) {
                struct timespec ts;
                int k;
                usec_t n;
                void *p;
                Iterator i;

                /* First, let the kernel inform us about killed
                 * children. Most processes will probably be our
                 * children, but some are not (might be our
                 * grandchildren instead...). */
                for (;;) {
                        pid_t pid;

                        pid = waitpid(-1, NULL, WNOHANG);
                        if (pid == 0)
                                break;
                        if (pid < 0) {
                                if (errno == ECHILD)
                                        break;

                                log_error_errno(errno, "waitpid() failed: %m");
                                return;
                        }

                        (void) set_remove(pids, PID_TO_PTR(pid));
                }

                /* Now explicitly check who might be remaining, who
                 * might not be our child. */
                SET_FOREACH(p, pids, i) {

                        /* We misuse getpgid as a check whether a
                         * process still exists. */
                        if (getpgid(PTR_TO_PID(p)) >= 0)
                                continue;

                        if (errno != ESRCH)
                                continue;

                        set_remove(pids, p);
                }

                if (set_isempty(pids))
                        return;

                n = now(CLOCK_MONOTONIC);
                if (n >= until)
                        return;

                timespec_store(&ts, until - n);
                k = sigtimedwait(mask, NULL, &ts);
                if (k != SIGCHLD) {

                        if (k < 0 && errno != EAGAIN) {
                                log_error_errno(errno, "sigtimedwait() failed: %m");
                                return;
                        }

                        if (k >= 0)
                                log_warning("sigtimedwait() returned unexpected signal.");
                }
        }
}

static int killall(int sig, Set *pids, bool send_sighup) {
        _cleanup_closedir_ DIR *dir = NULL;
        struct dirent *d;

        dir = opendir("/proc");
        if (!dir)
                return -errno;

        while ((d = readdir(dir))) {
                pid_t pid;
                int r;

                if (d->d_type != DT_DIR &&
                    d->d_type != DT_UNKNOWN)
                        continue;

                if (parse_pid(d->d_name, &pid) < 0)
                        continue;

                if (ignore_proc(pid, sig == SIGKILL && !in_initrd()))
                        continue;

                if (sig == SIGKILL) {
                        _cleanup_free_ char *s = NULL;

                        get_process_comm(pid, &s);
                        log_notice("Sending SIGKILL to PID "PID_FMT" (%s).", pid, strna(s));
                }

                if (kill(pid, sig) >= 0) {
                        if (pids) {
                                r = set_put(pids, PID_TO_PTR(pid));
                                if (r < 0)
                                        log_oom();
                        }
                } else if (errno != ENOENT)
                        log_warning_errno(errno, "Could not kill %d: %m", pid);

                if (send_sighup) {
                        /* Optionally, also send a SIGHUP signal, but
                        only if the process has a controlling
                        tty. This is useful to allow handling of
                        shells which ignore SIGTERM but react to
                        SIGHUP. We do not send this to processes that
                        have no controlling TTY since we don't want to
                        trigger reloads of daemon processes. Also we
                        make sure to only send this after SIGTERM so
                        that SIGTERM is always first in the queue. */


                        if (get_ctty_devnr(pid, NULL) >= 0)
                                kill(pid, SIGHUP);
                }
        }

        return set_size(pids);
}

void broadcast_signal(int sig, bool wait_for_exit, bool send_sighup) {
        sigset_t mask, oldmask;
        _cleanup_set_free_ Set *pids = NULL;

        if (wait_for_exit)
                pids = set_new(NULL);

        assert_se(sigemptyset(&mask) == 0);
        assert_se(sigaddset(&mask, SIGCHLD) == 0);
        assert_se(sigprocmask(SIG_BLOCK, &mask, &oldmask) == 0);

        if (kill(-1, SIGSTOP) < 0 && errno != ESRCH)
                log_warning_errno(errno, "kill(-1, SIGSTOP) failed: %m");

        killall(sig, pids, send_sighup);

        if (kill(-1, SIGCONT) < 0 && errno != ESRCH)
                log_warning_errno(errno, "kill(-1, SIGCONT) failed: %m");

        if (wait_for_exit)
                wait_for_children(pids, &mask);

        assert_se(sigprocmask(SIG_SETMASK, &oldmask, NULL) == 0);
}