build: basic autoconfization

[elogind.git] / unit.c

diff --git a/unit.c b/unit.c
index bd4272f6ddc92de9f95786832350e4b08f1692fd..a14e18ef5b18d05d9c11437b8154cd5c9d7fe006 100644 (file)
--- a/unit.c
+++ b/unit.c
@@ -1,5 +1,24 @@
 /*-*- Mode: C; c-basic-offset: 8 -*-*/
 
 /*-*- Mode: C; c-basic-offset: 8 -*-*/
 

+/***
+  This file is part of systemd.
+
+  Copyright 2010 Lennart Poettering
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+

 #include <assert.h>
 #include <errno.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <string.h>


@@ -329,55 +348,32 @@ const char *unit_description(Unit *u) {
 
 void unit_dump(Unit *u, FILE *f, const char *prefix) {
 
 
 void unit_dump(Unit *u, FILE *f, const char *prefix) {
 

-        static const char* const load_state_table[_UNIT_LOAD_STATE_MAX] = {
-                [UNIT_STUB] = "stub",
-                [UNIT_LOADED] = "loaded",
-                [UNIT_FAILED] = "failed"
-        };
-
-        static const char* const active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
-                [UNIT_ACTIVE] = "active",
-                [UNIT_INACTIVE] = "inactive",
-                [UNIT_ACTIVATING] = "activating",
-                [UNIT_DEACTIVATING] = "deactivating"
-        };
-
-        static const char* const dependency_table[_UNIT_DEPENDENCY_MAX] = {
-                [UNIT_REQUIRES] = "Requires",
-                [UNIT_SOFT_REQUIRES] = "SoftRequires",
-                [UNIT_WANTS] = "Wants",
-                [UNIT_REQUISITE] = "Requisite",
-                [UNIT_SOFT_REQUISITE] = "SoftRequisite",
-                [UNIT_REQUIRED_BY] = "RequiredBy",
-                [UNIT_SOFT_REQUIRED_BY] = "SoftRequiredBy",
-                [UNIT_WANTED_BY] = "WantedBy",
-                [UNIT_CONFLICTS] = "Conflicts",
-                [UNIT_BEFORE] = "Before",
-                [UNIT_AFTER] = "After",
-        };
-

         char *t;
         UnitDependency d;
         Iterator i;
         char *t;
         UnitDependency d;
         Iterator i;

-        char *prefix2;
+        char *p2;
+        const char *prefix2;

 
         assert(u);
 
         if (!prefix)
                 prefix = "";
 
         assert(u);
 
         if (!prefix)
                 prefix = "";

-        prefix2 = strappend(prefix, "\t");
-        if (!prefix2)
-                prefix2 = "";
+        p2 = strappend(prefix, "\t");
+        prefix2 = p2 ? p2 : prefix;

 
         fprintf(f,
                 "%s→ Unit %s:\n"
                 "%s\tDescription: %s\n"
                 "%s\tUnit Load State: %s\n"
 
         fprintf(f,
                 "%s→ Unit %s:\n"
                 "%s\tDescription: %s\n"
                 "%s\tUnit Load State: %s\n"

-                "%s\tUnit Active State: %s\n",
+                "%s\tUnit Active State: %s\n"
+                "%s\tRecursive Stop: %s\n"
+                "%s\tStop When Unneeded: %s\n",

                 prefix, unit_id(u),
                 prefix, unit_description(u),
                 prefix, unit_id(u),
                 prefix, unit_description(u),

-                prefix, load_state_table[u->meta.load_state],
-                prefix, active_state_table[unit_active_state(u)]);
+                prefix, unit_load_state_to_string(u->meta.load_state),
+                prefix, unit_active_state_to_string(unit_active_state(u)),
+                prefix, yes_no(u->meta.recursive_stop),
+                prefix, yes_no(u->meta.stop_when_unneeded));

 
         if (u->meta.load_path)
                 fprintf(f, "%s\tLoad Path: %s\n", prefix, u->meta.load_path);
 
         if (u->meta.load_path)
                 fprintf(f, "%s\tLoad Path: %s\n", prefix, u->meta.load_path);


@@ -392,7 +388,7 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
                         continue;
 
                 SET_FOREACH(other, u->meta.dependencies[d], i)
                         continue;
 
                 SET_FOREACH(other, u->meta.dependencies[d], i)

-                        fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], unit_id(other));
+                        fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), unit_id(other));

         }
 
         if (UNIT_VTABLE(u)->dump)
         }
 
         if (UNIT_VTABLE(u)->dump)


@@ -401,7 +397,7 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
         if (u->meta.job)
                 job_dump(u->meta.job, f, prefix2);
 
         if (u->meta.job)
                 job_dump(u->meta.job, f, prefix2);
 

-        free(prefix2);
+        free(p2);

 }
 
 /* Common implementation for multiple backends */
 }
 
 /* Common implementation for multiple backends */


@@ -538,6 +534,39 @@ bool unit_can_reload(Unit *u) {
         return UNIT_VTABLE(u)->can_reload(u);
 }
 
         return UNIT_VTABLE(u)->can_reload(u);
 }
 

+static void unit_check_uneeded(Unit *u) {
+        Iterator i;
+        Unit *other;
+
+        assert(u);
+
+        /* If this service shall be shut down when unneeded then do
+         * so. */
+
+        if (!u->meta.stop_when_unneeded)
+                return;
+
+        if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
+                return;
+
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        return;
+
+        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUIRED_BY], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        return;
+
+        SET_FOREACH(other, u->meta.dependencies[UNIT_WANTED_BY], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        return;
+
+        log_debug("Service %s is not needed anymore. Stopping.", unit_id(u));
+
+        /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
+        manager_add_job(u->meta.manager, JOB_STOP, u, JOB_FAIL, true, NULL);
+}
+

 static void retroactively_start_dependencies(Unit *u) {
         Iterator i;
         Unit *other;
 static void retroactively_start_dependencies(Unit *u) {
         Iterator i;
         Unit *other;


@@ -573,9 +602,29 @@ static void retroactively_stop_dependencies(Unit *u) {
         assert(u);
         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
 
         assert(u);
         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
 

-        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY], i)
+        if (u->meta.recursive_stop) {
+                /* Pull down units need us recursively if enabled */
+                SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY], i)
+                        if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                                manager_add_job(u->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
+        }
+
+        /* Garbage collect services that might not be needed anymore, if enabled */
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES], i)

                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))

-                        manager_add_job(u->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
+                        unit_check_uneeded(other);
+        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUIRES], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        unit_check_uneeded(other);
+        SET_FOREACH(other, u->meta.dependencies[UNIT_WANTS], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        unit_check_uneeded(other);
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        unit_check_uneeded(other);
+        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUISITE], i)
+                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+                        unit_check_uneeded(other);

 }
 
 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
 }
 
 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {


@@ -665,6 +714,10 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
                 retroactively_start_dependencies(u);
         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
                 retroactively_stop_dependencies(u);
                 retroactively_start_dependencies(u);
         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
                 retroactively_stop_dependencies(u);

+
+        /* Maybe we finished startup and are now ready for being
+         * stopped because unneeded? */
+        unit_check_uneeded(u);

 }
 
 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
 }
 
 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {


@@ -673,7 +726,7 @@ int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
         assert(u);
         assert(fd >= 0);
         assert(w);
         assert(u);
         assert(fd >= 0);
         assert(w);

-        assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->unit == u));
+        assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));

 
         zero(ev);
         ev.data.ptr = w;
 
         zero(ev);
         ev.data.ptr = w;


@@ -687,7 +740,7 @@ int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
 
         w->fd = fd;
         w->type = WATCH_FD;
 
         w->fd = fd;
         w->type = WATCH_FD;

-        w->unit = u;
+        w->data.unit = u;

 
         return 0;
 }
 
         return 0;
 }


@@ -699,12 +752,13 @@ void unit_unwatch_fd(Unit *u, Watch *w) {
         if (w->type == WATCH_INVALID)
                 return;
 
         if (w->type == WATCH_INVALID)
                 return;
 

-        assert(w->type == WATCH_FD && w->unit == u);
+        assert(w->type == WATCH_FD);
+        assert(w->data.unit == u);

         assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
 
         w->fd = -1;
         w->type = WATCH_INVALID;
         assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
 
         w->fd = -1;
         w->type = WATCH_INVALID;

-        w->unit = NULL;
+        w->data.unit = NULL;

 }
 
 int unit_watch_pid(Unit *u, pid_t pid) {
 }
 
 int unit_watch_pid(Unit *u, pid_t pid) {


@@ -728,7 +782,7 @@ int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
 
         assert(u);
         assert(w);
 
         assert(u);
         assert(w);

-        assert(w->type == WATCH_INVALID || (w->type == WATCH_TIMER && w->unit == u));
+        assert(w->type == WATCH_INVALID || (w->type == WATCH_TIMER && w->data.unit == u));

 
         /* This will try to reuse the old timer if there is one */
 
 
         /* This will try to reuse the old timer if there is one */
 


@@ -772,13 +826,13 @@ int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
 
         w->fd = fd;
         w->type = WATCH_TIMER;
 
         w->fd = fd;
         w->type = WATCH_TIMER;

-        w->unit = u;
+        w->data.unit = u;

 
         return 0;
 
 fail:
         if (ours)
 
         return 0;
 
 fail:
         if (ours)

-                assert_se(close_nointr(fd) == 0);
+                close_nointr_nofail(fd);

 
         return -errno;
 }
 
         return -errno;
 }


@@ -790,14 +844,14 @@ void unit_unwatch_timer(Unit *u, Watch *w) {
         if (w->type == WATCH_INVALID)
                 return;
 
         if (w->type == WATCH_INVALID)
                 return;
 

-        assert(w->type == WATCH_TIMER && w->unit == u);
+        assert(w->type == WATCH_TIMER && w->data.unit == u);

 
         assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
         assert_se(close_nointr(w->fd) == 0);
 
         w->fd = -1;
         w->type = WATCH_INVALID;
 
         assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
         assert_se(close_nointr(w->fd) == 0);
 
         w->fd = -1;
         w->type = WATCH_INVALID;

-        w->unit = NULL;
+        w->data.unit = NULL;

 }
 
 bool unit_job_is_applicable(Unit *u, JobType j) {
 }
 
 bool unit_job_is_applicable(Unit *u, JobType j) {


@@ -969,3 +1023,66 @@ char *unit_name_escape_path(const char *prefix, const char *path, const char *su
 
         return r;
 }
 
         return r;
 }

+
+char *unit_dbus_path(Unit *u) {
+        char *p, *e;
+
+        assert(u);
+
+        if (!(e = bus_path_escape(unit_id(u))))
+                return NULL;
+
+        if (asprintf(&p, "/org/freedesktop/systemd1/unit/%s", e) < 0) {
+                free(e);
+                return NULL;
+        }
+
+        free(e);
+        return p;
+}
+
+static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
+        [UNIT_SERVICE] = "service",
+        [UNIT_TIMER] = "timer",
+        [UNIT_SOCKET] = "socket",
+        [UNIT_TARGET] = "target",
+        [UNIT_DEVICE] = "device",
+        [UNIT_MOUNT] = "mount",
+        [UNIT_AUTOMOUNT] = "automount",
+        [UNIT_SNAPSHOT] = "snapshot"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_type, UnitType);
+
+static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
+        [UNIT_STUB] = "stub",
+        [UNIT_LOADED] = "loaded",
+        [UNIT_FAILED] = "failed"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
+
+static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
+        [UNIT_ACTIVE] = "active",
+        [UNIT_INACTIVE] = "inactive",
+        [UNIT_ACTIVATING] = "activating",
+        [UNIT_DEACTIVATING] = "deactivating"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
+
+static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
+        [UNIT_REQUIRES] = "Requires",
+        [UNIT_SOFT_REQUIRES] = "SoftRequires",
+        [UNIT_WANTS] = "Wants",
+        [UNIT_REQUISITE] = "Requisite",
+        [UNIT_SOFT_REQUISITE] = "SoftRequisite",
+        [UNIT_REQUIRED_BY] = "RequiredBy",
+        [UNIT_SOFT_REQUIRED_BY] = "SoftRequiredBy",
+        [UNIT_WANTED_BY] = "WantedBy",
+        [UNIT_CONFLICTS] = "Conflicts",
+        [UNIT_BEFORE] = "Before",
+        [UNIT_AFTER] = "After",
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);