X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=service.c;h=ef43537357ab9f70625b89f3fd7e99c8bcccb6fc;hb=28247076541bb1d1c0b09c8e10f4dcb421e20188;hp=c5e3bc13b4191ab878c747a5782c1572cef39cc7;hpb=8309400a17b041fb8b52b13b9125eb65d11f3669;p=elogind.git

diff --git a/service.c b/service.c
index c5e3bc13b..ef4353735 100644
--- a/service.c
+++ b/service.c
@@ -63,6 +63,26 @@ static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
 };
 
+static void service_unwatch_control_pid(Service *s) {
+        assert(s);
+
+        if (s->control_pid <= 0)
+                return;
+
+        unit_unwatch_pid(UNIT(s), s->control_pid);
+        s->control_pid = 0;
+}
+
+static void service_unwatch_main_pid(Service *s) {
+        assert(s);
+
+        if (s->main_pid <= 0)
+                return;
+
+        unit_unwatch_pid(UNIT(s), s->main_pid);
+        s->main_pid = 0;
+}
+
 static void service_done(Unit *u) {
         Service *s = SERVICE(u);
 
@@ -78,20 +98,13 @@ static void service_done(Unit *u) {
         s->sysv_runlevels = NULL;
 
         exec_context_done(&s->exec_context);
-        exec_command_free_array(s->exec_command, _SERVICE_EXEC_MAX);
+        exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
         s->control_command = NULL;
 
         /* This will leak a process, but at least no memory or any of
          * our resources */
-        if (s->main_pid > 0) {
-                unit_unwatch_pid(u, s->main_pid);
-                s->main_pid = 0;
-        }
-
-        if (s->control_pid > 0) {
-                unit_unwatch_pid(u, s->control_pid);
-                s->control_pid = 0;
-        }
+        service_unwatch_main_pid(s);
+        service_unwatch_control_pid(s);
 
         unit_unwatch_timer(u, &s->timer_watch);
 }
@@ -157,7 +170,10 @@ static int sysv_chkconfig_order(Service *s) {
                 if (t->sysv_start_priority < 0)
                         continue;
 
-                if (s->sysv_has_lsb && t->sysv_has_lsb)
+                /* If both units have modern headers we don't care
+                 * about the priorities */
+                if ((!s->sysv_path || s->sysv_has_lsb) &&
+                    (!t->sysv_path || t->sysv_has_lsb))
                         continue;
 
                 if (t->sysv_start_priority < s->sysv_start_priority)
@@ -277,7 +293,7 @@ static int priority_from_rcd(Service *s, const char *init_script) {
         return 0;
 }
 
-static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *new_state) {
+static int service_load_sysv_path(Service *s, const char *path) {
         FILE *f;
         Unit *u;
         unsigned line = 0;
@@ -291,7 +307,6 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n
 
         assert(s);
         assert(path);
-        assert(new_state);
 
         u = UNIT(s);
 
@@ -592,11 +607,19 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n
         if ((r = sysv_exec_commands(s)) < 0)
                 goto finish;
 
-        if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_BASIC_TARGET)) < 0 ||
-            (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_BASIC_TARGET)) < 0)
-                goto finish;
+        if (!s->sysv_runlevels || chars_intersect("12345", s->sysv_runlevels)) {
+                /* If there a runlevels configured for this service
+                 * but none of the standard ones, then we assume this
+                 * is some special kind of service (which might be
+                 * needed for early boot) and don't create any links
+                 * to it. */
 
-        *new_state = UNIT_LOADED;
+                if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_BASIC_TARGET)) < 0 ||
+                    (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_BASIC_TARGET)) < 0)
+                        goto finish;
+        }
+
+        u->meta.load_state = UNIT_LOADED;
         r = 0;
 
 finish:
@@ -607,7 +630,7 @@ finish:
         return r;
 }
 
-static int service_load_sysv_name(Service *s, const char *name, UnitLoadState *new_state) {
+static int service_load_sysv_name(Service *s, const char *name) {
         char **p;
 
         assert(s);
@@ -623,26 +646,25 @@ static int service_load_sysv_name(Service *s, const char *name, UnitLoadState *n
                 assert(endswith(path, ".service"));
                 path[strlen(path)-8] = 0;
 
-                r = service_load_sysv_path(s, path, new_state);
+                r = service_load_sysv_path(s, path);
                 free(path);
 
                 if (r < 0)
                         return r;
 
-                if (*new_state != UNIT_STUB)
+                if ((UNIT(s)->meta.load_state != UNIT_STUB))
                         break;
         }
 
         return 0;
 }
 
-static int service_load_sysv(Service *s, UnitLoadState *new_state) {
+static int service_load_sysv(Service *s) {
         const char *t;
         Iterator i;
         int r;
 
         assert(s);
-        assert(new_state);
 
         /* Load service data from SysV init scripts, preferably with
          * LSB headers ... */
@@ -651,31 +673,29 @@ static int service_load_sysv(Service *s, UnitLoadState *new_state) {
                 return 0;
 
         if ((t = unit_id(UNIT(s))))
-                if ((r = service_load_sysv_name(s, t, new_state)) < 0)
+                if ((r = service_load_sysv_name(s, t)) < 0)
                         return r;
 
-        if (*new_state == UNIT_STUB)
+        if (UNIT(s)->meta.load_state == UNIT_STUB)
                 SET_FOREACH(t, UNIT(s)->meta.names, i) {
-                        if ((r == service_load_sysv_name(s, t, new_state)) < 0)
+                        if (t == unit_id(UNIT(s)))
+                                continue;
+
+                        if ((r == service_load_sysv_name(s, t)) < 0)
                                 return r;
 
-                        if (*new_state != UNIT_STUB)
+                        if (UNIT(s)->meta.load_state != UNIT_STUB)
                                 break;
                 }
 
         return 0;
 }
 
-static int service_init(Unit *u, UnitLoadState *new_state) {
-        int r;
+static void service_init(Unit *u) {
         Service *s = SERVICE(u);
 
-        assert(s);
-        assert(new_state);
-        assert(*new_state == UNIT_STUB);
-
-        /* First, reset everything to the defaults, in case this is a
-         * reload */
+        assert(u);
+        assert(u->meta.load_state == UNIT_STUB);
 
         s->type = 0;
         s->restart = 0;
@@ -692,22 +712,33 @@ static int service_init(Unit *u, UnitLoadState *new_state) {
         s->sysv_start_priority = -1;
         s->permissions_start_only = false;
         s->root_directory_start_only = false;
-
+        s->valid_no_process = false;
+        s->kill_mode = 0;
         s->sysv_has_lsb = false;
+        s->main_pid = s->control_pid = 0;
+        s->main_pid_known = false;
+        s->failure = false;
 
         RATELIMIT_INIT(s->ratelimit, 10*USEC_PER_SEC, 5);
+}
+
+static int service_load(Unit *u) {
+        int r;
+        Service *s = SERVICE(u);
+
+        assert(s);
 
         /* Load a .service file */
-        if ((r = unit_load_fragment(u, new_state)) < 0)
+        if ((r = unit_load_fragment(u)) < 0)
                 return r;
 
         /* Load a classic init script as a fallback, if we couldn't find anything */
-        if (*new_state == UNIT_STUB)
-                if ((r = service_load_sysv(s, new_state)) < 0)
+        if (u->meta.load_state == UNIT_STUB)
+                if ((r = service_load_sysv(s)) < 0)
                         return r;
 
         /* Still nothing found? Then let's give up */
-        if (*new_state == UNIT_STUB)
+        if (u->meta.load_state == UNIT_STUB)
                 return -ENOENT;
 
         /* We were able to load something, then let's add in the
@@ -716,7 +747,7 @@ static int service_init(Unit *u, UnitLoadState *new_state) {
                 return r;
 
         /* This is a new unit? Then let's add in some extras */
-        if (*new_state == UNIT_LOADED) {
+        if (u->meta.load_state == UNIT_LOADED) {
                 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
                         return r;
 
@@ -747,13 +778,25 @@ static void service_dump(Unit *u, FILE *f, const char *prefix) {
                 "%sPermissionsStartOnly: %s\n"
                 "%sRootDirectoryStartOnly: %s\n"
                 "%sValidNoProcess: %s\n"
+                "%sKillMode: %s\n"
                 "%sType: %s\n",
                 prefix, service_state_to_string(s->state),
                 prefix, yes_no(s->permissions_start_only),
                 prefix, yes_no(s->root_directory_start_only),
                 prefix, yes_no(s->valid_no_process),
+                prefix, kill_mode_to_string(s->kill_mode),
                 prefix, service_type_to_string(s->type));
 
+        if (s->control_pid > 0)
+                fprintf(f,
+                        "%sControl PID: %llu\n",
+                        prefix, (unsigned long long) s->control_pid);
+
+        if (s->main_pid > 0)
+                fprintf(f,
+                        "%sMain PID: %llu\n",
+                        prefix, (unsigned long long) s->main_pid);
+
         if (s->pid_file)
                 fprintf(f,
                         "%sPIDFile: %s\n",
@@ -761,7 +804,7 @@ static void service_dump(Unit *u, FILE *f, const char *prefix) {
 
         exec_context_dump(&s->exec_context, f, prefix);
 
-        for (c = 0; c < _SERVICE_EXEC_MAX; c++) {
+        for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
 
                 if (!s->exec_command[c])
                         continue;
@@ -801,6 +844,8 @@ static int service_load_pid_file(Service *s) {
         if (s->main_pid_known)
                 return 0;
 
+        assert(s->main_pid <= 0);
+
         if (!s->pid_file)
                 return -ENOENT;
 
@@ -815,7 +860,17 @@ static int service_load_pid_file(Service *s) {
         if ((unsigned long) (pid_t) p != p)
                 return -ERANGE;
 
-        s->main_pid = p;
+        if (kill((pid_t) p, 0) < 0 && errno != EPERM) {
+                log_warning("PID %llu read from file %s does not exist. Your service or init script might be broken.",
+                            (unsigned long long) p, s->pid_file);
+                return -ESRCH;
+        }
+
+        if ((r = unit_watch_pid(UNIT(s), (pid_t) p)) < 0)
+                /* FIXME: we need to do something here */
+                return r;
+
+        s->main_pid = (pid_t) p;
         s->main_pid_known = true;
 
         return 0;
@@ -867,7 +922,7 @@ fail:
 }
 
 
-static int service_notify_sockets(Service *s) {
+static int service_notify_sockets_dead(Service *s) {
         Iterator i;
         Set *set;
         Socket *sock;
@@ -915,10 +970,7 @@ static void service_set_state(Service *s, ServiceState state) {
             state != SERVICE_STOP &&
             state != SERVICE_STOP_SIGTERM &&
             state != SERVICE_STOP_SIGKILL)
-                if (s->main_pid > 0) {
-                        unit_unwatch_pid(UNIT(s), s->main_pid);
-                        s->main_pid = 0;
-                }
+                service_unwatch_main_pid(s);
 
         if (state != SERVICE_START_PRE &&
             state != SERVICE_START &&
@@ -929,19 +981,10 @@ static void service_set_state(Service *s, ServiceState state) {
             state != SERVICE_STOP_SIGKILL &&
             state != SERVICE_STOP_POST &&
             state != SERVICE_FINAL_SIGTERM &&
-            state != SERVICE_FINAL_SIGKILL)
-                if (s->control_pid > 0) {
-                        unit_unwatch_pid(UNIT(s), s->control_pid);
-                        s->control_pid = 0;
-                }
-
-        if (state != SERVICE_START_PRE &&
-            state != SERVICE_START &&
-            state != SERVICE_START_POST &&
-            state != SERVICE_RELOAD &&
-            state != SERVICE_STOP &&
-            state != SERVICE_STOP_POST)
+            state != SERVICE_FINAL_SIGKILL) {
+                service_unwatch_control_pid(s);
                 s->control_command = NULL;
+        }
 
         if (state == SERVICE_DEAD ||
             state == SERVICE_STOP ||
@@ -952,9 +995,10 @@ static void service_set_state(Service *s, ServiceState state) {
             state == SERVICE_FINAL_SIGKILL ||
             state == SERVICE_MAINTAINANCE ||
             state == SERVICE_AUTO_RESTART)
-                service_notify_sockets(s);
+                service_notify_sockets_dead(s);
 
-        log_debug("%s changed %s → %s", unit_id(UNIT(s)), service_state_to_string(old_state), service_state_to_string(state));
+        if (old_state != state)
+                log_debug("%s changed %s → %s", unit_id(UNIT(s)), service_state_to_string(old_state), service_state_to_string(state));
 
         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]);
 }
@@ -1109,6 +1153,8 @@ static void service_enter_stop_post(Service *s, bool success) {
         if (!success)
                 s->failure = true;
 
+        service_unwatch_control_pid(s);
+
         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST]))
                 if ((r = service_spawn(s,
                                        s->control_command,
@@ -1146,23 +1192,34 @@ static void service_enter_signal(Service *s, ServiceState state, bool success) {
 
                 sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
 
-                r = 0;
-                if (s->main_pid > 0) {
-                        if (kill(s->main_pid, sig) < 0 && errno != ESRCH)
-                                r = -errno;
-                        else
-                                sent = true;
-                }
+                if (s->kill_mode == KILL_CONTROL_GROUP) {
 
-                if (s->control_pid > 0) {
-                        if (kill(s->control_pid, sig) < 0 && errno != ESRCH)
-                                r = -errno;
-                        else
+                        if ((r = cgroup_bonding_kill_list(UNIT(s)->meta.cgroup_bondings, sig)) < 0) {
+                                if (r != -EAGAIN && r != -ESRCH)
+                                        goto fail;
+                        } else
                                 sent = true;
                 }
 
-                if (r < 0)
-                        goto fail;
+                if (!sent) {
+                        r = 0;
+                        if (s->main_pid > 0) {
+                                if (kill(s->kill_mode == KILL_PROCESS ? s->main_pid : -s->main_pid, sig) < 0 && errno != ESRCH)
+                                        r = -errno;
+                                else
+                                        sent = true;
+                        }
+
+                        if (s->control_pid > 0) {
+                                if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH)
+                                        r = -errno;
+                                else
+                                        sent = true;
+                        }
+
+                        if (r < 0)
+                                goto fail;
+                }
         }
 
         service_set_state(s, state);
@@ -1191,6 +1248,8 @@ static void service_enter_stop(Service *s, bool success) {
         if (!success)
                 s->failure = true;
 
+        service_unwatch_control_pid(s);
+
         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP]))
                 if ((r = service_spawn(s,
                                        s->control_command,
@@ -1217,6 +1276,8 @@ static void service_enter_start_post(Service *s) {
         int r;
         assert(s);
 
+        service_unwatch_control_pid(s);
+
         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST]))
                 if ((r = service_spawn(s,
                                        s->control_command,
@@ -1264,6 +1325,8 @@ static void service_enter_start(Service *s) {
                 /* For simple services we immediately start
                  * the START_POST binaries. */
 
+                service_unwatch_main_pid(s);
+
                 s->main_pid = pid;
                 s->main_pid_known = true;
                 service_enter_start_post(s);
@@ -1273,6 +1336,8 @@ static void service_enter_start(Service *s) {
                 /* For forking services we wait until the start
                  * process exited. */
 
+                service_unwatch_control_pid(s);
+
                 s->control_pid = pid;
                 s->control_command = s->exec_command[SERVICE_EXEC_START];
         } else if (s->type == SERVICE_FINISH) {
@@ -1280,7 +1345,10 @@ static void service_enter_start(Service *s) {
                 /* For finishing services we wait until the start
                  * process exited, too, but it is our main process. */
 
+                service_unwatch_main_pid(s);
+
                 s->main_pid = pid;
+                s->main_pid_known = true;
                 s->control_command = s->exec_command[SERVICE_EXEC_START];
         } else
                 assert_not_reached("Unknown service type");
@@ -1297,6 +1365,8 @@ static void service_enter_start_pre(Service *s) {
 
         assert(s);
 
+        service_unwatch_control_pid(s);
+
         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE]))
                 if ((r = service_spawn(s,
                                        s->control_command,
@@ -1341,6 +1411,8 @@ static void service_enter_reload(Service *s) {
 
         assert(s);
 
+        service_unwatch_control_pid(s);
+
         if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD]))
                 if ((r = service_spawn(s,
                                        s->control_command,
@@ -1375,6 +1447,8 @@ static void service_run_next(Service *s, bool success) {
 
         s->control_command = s->control_command->command_next;
 
+        service_unwatch_control_pid(s);
+
         if ((r = service_spawn(s,
                                s->control_command,
                                true,
@@ -1438,12 +1512,22 @@ static int service_stop(Unit *u) {
 
         assert(s);
 
+        /* Cannot do this now */
         if (s->state == SERVICE_START_PRE ||
             s->state == SERVICE_START ||
             s->state == SERVICE_START_POST ||
             s->state == SERVICE_RELOAD)
                 return -EAGAIN;
 
+        /* Already on it */
+        if (s->state == SERVICE_STOP ||
+            s->state == SERVICE_STOP_SIGTERM ||
+            s->state == SERVICE_STOP_SIGKILL ||
+            s->state == SERVICE_STOP_POST ||
+            s->state == SERVICE_FINAL_SIGTERM ||
+            s->state == SERVICE_FINAL_SIGKILL)
+                return 0;
+
         if (s->state == SERVICE_AUTO_RESTART) {
                 service_set_state(s, SERVICE_DEAD);
                 return 0;
@@ -1530,7 +1614,7 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
                         s->exec_command[SERVICE_EXEC_START]->exec_status = s->main_exec_status;
                 }
 
-                log_debug("%s: main process exited, code=%s status=%i", unit_id(u), sigchld_code_to_string(code), status);
+                log_debug("%s: main process exited, code=%s, status=%i", unit_id(u), sigchld_code_to_string(code), status);
 
                 /* The service exited, so the service is officially
                  * gone. */
@@ -1915,7 +1999,7 @@ static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
 
 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
 
-static const char* const service_exec_command_table[_SERVICE_EXEC_MAX] = {
+static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
         [SERVICE_EXEC_START] = "ExecStart",
         [SERVICE_EXEC_START_POST] = "ExecStartPost",
@@ -1930,6 +2014,7 @@ const UnitVTable service_vtable = {
         .suffix = ".service",
 
         .init = service_init,
+        .load = service_load,
         .done = service_done,
 
         .dump = service_dump,