X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fmachine%2Fmachine.c;h=1c9177e1c379b9a60ad2a7424b42bf2b8af8b4a6;hp=591a656f1ea192262dbb8ed57349ef4fe2307767;hb=e70bc43cdf75b36e7ad3d29e9a6f8ee1461e7d5e;hpb=f2d4f98d5873e0649b79b04b967fc9625ab3a350

diff --git a/src/machine/machine.c b/src/machine/machine.c
index 591a656f1..1c9177e1c 100644
--- a/src/machine/machine.c
+++ b/src/machine/machine.c
@@ -23,7 +23,7 @@
 #include <unistd.h>
 #include <errno.h>
 
-#include <systemd/sd-messages.h>
+#include "sd-messages.h"
 
 #include "util.h"
 #include "mkdir.h"
@@ -32,8 +32,9 @@
 #include "fileio.h"
 #include "special.h"
 #include "unit-name.h"
-#include "dbus-common.h"
 #include "machine.h"
+#include "bus-util.h"
+#include "bus-error.h"
 
 Machine* machine_new(Manager *manager, const char *name) {
         Machine *m;
@@ -73,24 +74,27 @@ void machine_free(Machine *m) {
         assert(m);
 
         if (m->in_gc_queue)
-                LIST_REMOVE(Machine, gc_queue, m->manager->machine_gc_queue, m);
+                LIST_REMOVE(gc_queue, m->manager->machine_gc_queue, m);
 
-        if (m->scope) {
-                hashmap_remove(m->manager->machine_units, m->scope);
-                free(m->scope);
+        if (m->unit) {
+                hashmap_remove(m->manager->machine_units, m->unit);
+                free(m->unit);
         }
 
         free(m->scope_job);
 
         hashmap_remove(m->manager->machines, m->name);
 
-        if (m->create_message)
-                dbus_message_unref(m->create_message);
+        if (m->leader > 0)
+                hashmap_remove_value(m->manager->machine_leaders, UINT_TO_PTR(m->leader), m);
+
+        sd_bus_message_unref(m->create_message);
 
         free(m->name);
         free(m->state_file);
         free(m->service);
         free(m->root_directory);
+        free(m->netif);
         free(m);
 }
 
@@ -120,57 +124,127 @@ int machine_save(Machine *m) {
                 "NAME=%s\n",
                 m->name);
 
-        if (m->scope)
-                fprintf(f, "SCOPE=%s\n", m->scope);
+        if (m->unit) {
+                _cleanup_free_ char *escaped;
+
+                escaped = cescape(m->unit);
+                if (!escaped) {
+                        r = -ENOMEM;
+                        goto finish;
+                }
+
+                fprintf(f, "SCOPE=%s\n", escaped); /* We continue to call this "SCOPE=" because it is internal only, and we want to stay compatible with old files */
+        }
 
         if (m->scope_job)
                 fprintf(f, "SCOPE_JOB=%s\n", m->scope_job);
 
-        if (m->service)
-                fprintf(f, "SERVICE=%s\n", m->service);
+        if (m->service) {
+                _cleanup_free_ char *escaped;
 
-        if (m->root_directory)
-                fprintf(f, "ROOT=%s\n", m->root_directory);
+                escaped = cescape(m->service);
+                if (!escaped) {
+                        r = -ENOMEM;
+                        goto finish;
+                }
+                fprintf(f, "SERVICE=%s\n", escaped);
+        }
+
+        if (m->root_directory) {
+                _cleanup_free_ char *escaped;
+
+                escaped = cescape(m->root_directory);
+                if (!escaped) {
+                        r = -ENOMEM;
+                        goto finish;
+                }
+                fprintf(f, "ROOT=%s\n", escaped);
+        }
 
         if (!sd_id128_equal(m->id, SD_ID128_NULL))
                 fprintf(f, "ID=" SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(m->id));
 
         if (m->leader != 0)
-                fprintf(f, "LEADER=%lu\n", (unsigned long) m->leader);
+                fprintf(f, "LEADER="PID_FMT"\n", m->leader);
 
         if (m->class != _MACHINE_CLASS_INVALID)
                 fprintf(f, "CLASS=%s\n", machine_class_to_string(m->class));
 
         if (dual_timestamp_is_set(&m->timestamp))
                 fprintf(f,
-                        "REALTIME=%llu\n"
-                        "MONOTONIC=%llu\n",
-                        (unsigned long long) m->timestamp.realtime,
-                        (unsigned long long) m->timestamp.monotonic);
+                        "REALTIME="USEC_FMT"\n"
+                        "MONOTONIC="USEC_FMT"\n",
+                        m->timestamp.realtime,
+                        m->timestamp.monotonic);
+
+        if (m->n_netif > 0) {
+                unsigned i;
+
+                fputs("NETIF=", f);
 
-        fflush(f);
+                for (i = 0; i < m->n_netif; i++) {
+                        if (i != 0)
+                                fputc(' ', f);
+
+                        fprintf(f, "%i", m->netif[i]);
+                }
+
+                fputc('\n', f);
+        }
 
-        if (ferror(f) || rename(temp_path, m->state_file) < 0) {
+        r = fflush_and_check(f);
+        if (r < 0)
+                goto finish;
+
+        if (rename(temp_path, m->state_file) < 0) {
                 r = -errno;
-                unlink(m->state_file);
-                unlink(temp_path);
+                goto finish;
+        }
+
+        if (m->unit) {
+                char *sl;
+
+                /* Create a symlink from the unit name to the machine
+                 * name, so that we can quickly find the machine for
+                 * each given unit */
+                sl = strappenda("/run/systemd/machines/unit:", m->unit);
+                symlink(m->name, sl);
         }
 
 finish:
-        if (r < 0)
-                log_error("Failed to save machine data for %s: %s", m->name, strerror(-r));
+        if (r < 0) {
+                if (temp_path)
+                        unlink(temp_path);
+
+                log_error("Failed to save machine data %s: %s", m->state_file, strerror(-r));
+        }
 
         return r;
 }
 
+static void machine_unlink(Machine *m) {
+        assert(m);
+
+        if (m->unit) {
+
+                char *sl;
+
+                sl = strappenda("/run/systemd/machines/unit:", m->unit);
+                unlink(sl);
+        }
+
+        if (m->state_file)
+                unlink(m->state_file);
+}
+
 int machine_load(Machine *m) {
-        _cleanup_free_ char *realtime = NULL, *monotonic = NULL, *id = NULL, *leader = NULL, *class = NULL;
+        _cleanup_free_ char *realtime = NULL, *monotonic = NULL, *id = NULL, *leader = NULL, *class = NULL, *netif = NULL;
         int r;
 
         assert(m);
 
         r = parse_env_file(m->state_file, NEWLINE,
-                           "SCOPE",     &m->scope,
+                           "SCOPE",     &m->unit,
                            "SCOPE_JOB", &m->scope_job,
                            "SERVICE",   &m->service,
                            "ROOT",      &m->root_directory,
@@ -179,6 +253,7 @@ int machine_load(Machine *m) {
                            "CLASS",     &class,
                            "REALTIME",  &realtime,
                            "MONOTONIC", &monotonic,
+                           "NETIF",     &netif,
                            NULL);
         if (r < 0) {
                 if (r == -ENOENT)
@@ -214,22 +289,46 @@ int machine_load(Machine *m) {
                         m->timestamp.monotonic = l;
         }
 
+        if (netif) {
+                size_t l, allocated = 0, nr = 0;
+                const char *word, *state;
+                int *ni = NULL;
+
+                FOREACH_WORD(word, l, netif, state) {
+                        char buf[l+1];
+                        int ifi;
+
+                        *(char*) (mempcpy(buf, word, l)) = 0;
+
+                        if (safe_atoi(buf, &ifi) < 0)
+                                continue;
+                        if (ifi <= 0)
+                                continue;
+
+                        if (!GREEDY_REALLOC(ni, allocated, nr+1)) {
+                                free(ni);
+                                return log_oom();
+                        }
+
+                        ni[nr++] = ifi;
+                }
+
+                free(m->netif);
+                m->netif = ni;
+                m->n_netif = nr;
+        }
+
         return r;
 }
 
-static int machine_start_scope(Machine *m) {
-        _cleanup_free_ char *description = NULL;
-        DBusError error;
-        char *job;
+static int machine_start_scope(Machine *m, sd_bus_message *properties, sd_bus_error *error) {
         int r = 0;
 
         assert(m);
 
-        dbus_error_init(&error);
-
-        if (!m->scope) {
+        if (!m->unit) {
                 _cleanup_free_ char *escaped = NULL;
-                char *scope;
+                char *scope, *description, *job = NULL;
 
                 escaped = unit_name_escape(m->name);
                 if (!escaped)
@@ -239,30 +338,28 @@ static int machine_start_scope(Machine *m) {
                 if (!scope)
                         return log_oom();
 
-                description = strappend(m->class == MACHINE_VM ? "Virtual Machine " : "Container ", m->name);
+                description = strappenda(m->class == MACHINE_VM ? "Virtual Machine " : "Container ", m->name);
 
-                r = manager_start_scope(m->manager, scope, m->leader, SPECIAL_MACHINE_SLICE, description, &error, &job);
+                r = manager_start_scope(m->manager, scope, m->leader, SPECIAL_MACHINE_SLICE, description, properties, error, &job);
                 if (r < 0) {
-                        log_error("Failed to start machine scope: %s", bus_error(&error, r));
-                        dbus_error_free(&error);
-
+                        log_error("Failed to start machine scope: %s", bus_error_message(error, r));
                         free(scope);
                         return r;
                 } else {
-                        m->scope = scope;
+                        m->unit = scope;
 
                         free(m->scope_job);
                         m->scope_job = job;
                 }
         }
 
-        if (m->scope)
-                hashmap_put(m->manager->machine_units, m->scope, m);
+        if (m->unit)
+                hashmap_put(m->manager->machine_units, m->unit, m);
 
         return r;
 }
 
-int machine_start(Machine *m) {
+int machine_start(Machine *m, sd_bus_message *properties, sd_bus_error *error) {
         int r;
 
         assert(m);
@@ -270,15 +367,19 @@ int machine_start(Machine *m) {
         if (m->started)
                 return 0;
 
+        r = hashmap_put(m->manager->machine_leaders, UINT_TO_PTR(m->leader), m);
+        if (r < 0)
+                return r;
+
         /* Create cgroup */
-        r = machine_start_scope(m);
+        r = machine_start_scope(m, properties, error);
         if (r < 0)
                 return r;
 
         log_struct(LOG_INFO,
                    MESSAGE_ID(SD_MESSAGE_MACHINE_START),
                    "NAME=%s", m->name,
-                   "LEADER=%lu", (unsigned long) m->leader,
+                   "LEADER="PID_FMT, m->leader,
                    "MESSAGE=New machine %s.", m->name,
                    NULL);
 
@@ -296,28 +397,27 @@ int machine_start(Machine *m) {
 }
 
 static int machine_stop_scope(Machine *m) {
-        DBusError error;
-        char *job;
+        _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+        char *job = NULL;
         int r;
 
         assert(m);
 
-        dbus_error_init(&error);
-
-        if (!m->scope)
+        if (!m->unit)
                 return 0;
 
-        r = manager_stop_unit(m->manager, m->scope, &error, &job);
-        if (r < 0) {
-                log_error("Failed to stop machine scope: %s", bus_error(&error, r));
-                dbus_error_free(&error);
-                return r;
+        if (!m->registered) {
+                r = manager_stop_unit(m->manager, m->unit, &error, &job);
+                if (r < 0) {
+                        log_error("Failed to stop machine scope: %s", bus_error_message(&error, r));
+                        return r;
+                }
         }
 
         free(m->scope_job);
         m->scope_job = job;
 
-        return r;
+        return 0;
 }
 
 int machine_stop(Machine *m) {
@@ -328,7 +428,7 @@ int machine_stop(Machine *m) {
                 log_struct(LOG_INFO,
                            MESSAGE_ID(SD_MESSAGE_MACHINE_STOP),
                            "NAME=%s", m->name,
-                           "LEADER=%lu", (unsigned long) m->leader,
+                           "LEADER="PID_FMT, m->leader,
                            "MESSAGE=Machine %s terminated.", m->name,
                            NULL);
 
@@ -337,7 +437,7 @@ int machine_stop(Machine *m) {
         if (k < 0)
                 r = k;
 
-        unlink(m->state_file);
+        machine_unlink(m);
         machine_add_to_gc_queue(m);
 
         if (m->started)
@@ -348,19 +448,19 @@ int machine_stop(Machine *m) {
         return r;
 }
 
-int machine_check_gc(Machine *m, bool drop_not_started) {
+bool machine_check_gc(Machine *m, bool drop_not_started) {
         assert(m);
 
         if (drop_not_started && !m->started)
-                return 0;
+                return false;
 
-        if (m->scope_job)
-                return 1;
+        if (m->scope_job && manager_job_is_active(m->manager, m->scope_job))
+                return true;
 
-        if (m->scope)
-                return manager_unit_is_active(m->manager, m->scope) != 0;
+        if (m->unit && manager_unit_is_active(m->manager, m->unit))
+                return true;
 
-        return 0;
+        return false;
 }
 
 void machine_add_to_gc_queue(Machine *m) {
@@ -369,7 +469,7 @@ void machine_add_to_gc_queue(Machine *m) {
         if (m->in_gc_queue)
                 return;
 
-        LIST_PREPEND(Machine, gc_queue, m->manager->machine_gc_queue, m);
+        LIST_PREPEND(gc_queue, m->manager->machine_gc_queue, m);
         m->in_gc_queue = true;
 }
 
@@ -385,10 +485,18 @@ MachineState machine_get_state(Machine *s) {
 int machine_kill(Machine *m, KillWho who, int signo) {
         assert(m);
 
-        if (!m->scope)
+        if (!m->unit)
                 return -ESRCH;
 
-        return manager_kill_unit(m->manager, m->scope, who, signo, NULL);
+        if (who == KILL_LEADER) {
+                /* If we shall simply kill the leader, do so directly */
+
+                if (kill(m->leader, signo) < 0)
+                        return -errno;
+        }
+
+        /* Otherwise make PID 1 do it for us, for the entire cgroup */
+        return manager_kill_unit(m->manager, m->unit, signo, NULL);
 }
 
 static const char* const machine_class_table[_MACHINE_CLASS_MAX] = {