Fix confusion between killer and prey

"who" is the entity doing the killing, "whom" is the target.
Follow-up for 4ccde410a3fc141c9ddf285f24a22dfea99e0287.

diff --git a/man/org.freedesktop.login1.xml b/man/org.freedesktop.login1.xml
index aacaa1b952572aa0844aedc6fff80125f36a33d5..d9b9b0e1b3b5903f27ddb325fad6ca70f5ef8779 100644 (file)
--- a/man/org.freedesktop.login1.xml
+++ b/man/org.freedesktop.login1.xml
@@ -113,7 +113,7 @@ node /org/freedesktop/login1 {
       LockSessions();
       UnlockSessions();
       KillSession(in  s session_id,
-                  in  s who,
+                  in  s whom,
                   in  i signal_number);
       KillUser(in  u uid,
                in  i signal_number);
@@ -1140,7 +1140,7 @@ node /org/freedesktop/login1/session/1 {
       Unlock();
       SetIdleHint(in  b idle);
       SetLockedHint(in  b locked);
-      Kill(in  s who,
+      Kill(in  s whom,
            in  i signal_number);
       TakeControl(in  b force);
       ReleaseControl();

diff --git a/man/org.freedesktop.machine1.xml b/man/org.freedesktop.machine1.xml
index 8abef00e53a34222610190143991e32398085bfd..ce39f2d9040a988f0b25d1a9c5514d61d4ee36d4 100644 (file)
--- a/man/org.freedesktop.machine1.xml
+++ b/man/org.freedesktop.machine1.xml
@@ -465,7 +465,7 @@ node /org/freedesktop/machine1/machine/rawhide {
   interface org.freedesktop.machine1.Machine {
     methods:
       Terminate();
-      Kill(in  s who,
+      Kill(in  s whom,
            in  i signal);
       GetAddresses(out a(iay) addresses);
       GetSSHInfo(out s ssh_address,

diff --git a/src/core/dbus-unit.c b/src/core/dbus-unit.c
index ecc502c273d2bc3e3e2f9d6e399435ee8eddab8a..707644d2f9074b34073238d283fe4786a4bd26a3 100644 (file)
--- a/src/core/dbus-unit.c
+++ b/src/core/dbus-unit.c
@@ -504,9 +504,9 @@ int bus_unit_method_enqueue_job(sd_bus_message *message, void *userdata, sd_bus_
 int bus_unit_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         Unit *u = ASSERT_PTR(userdata);
         int32_t value = 0;
-        const char *swho;
+        const char *swhom;
         int32_t signo;
-        KillWho who;
+        KillWhom whom;
         int r, code;
 
         assert(message);
@@ -515,7 +515,7 @@ int bus_unit_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *
         if (r < 0)
                 return r;
 
-        r = sd_bus_message_read(message, "si", &swho, &signo);
+        r = sd_bus_message_read(message, "si", &swhom, &signo);
         if (r < 0)
                 return r;
 
@@ -528,12 +528,12 @@ int bus_unit_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *
         } else
                 code = SI_USER;
 
-        if (isempty(swho))
-                who = KILL_ALL;
+        if (isempty(swhom))
+                whom = KILL_ALL;
         else {
-                who = kill_who_from_string(swho);
-                if (who < 0)
-                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid who argument: %s", swho);
+                whom = kill_whom_from_string(swhom);
+                if (whom < 0)
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid whom argument: %s", swhom);
         }
 
         if (!SIGNAL_VALID(signo))
@@ -554,7 +554,7 @@ int bus_unit_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *
         if (r == 0)
                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 
-        r = unit_kill(u, who, signo, code, value, error);
+        r = unit_kill(u, whom, signo, code, value, error);
         if (r < 0)
                 return r;
 

diff --git a/src/core/kill.c b/src/core/kill.c
index c8b581d05d5e75aa9130a799ce04cb6d9e47d9b6..a93132ccd81a07b86fe8ebd55a02d498d8c4ba73 100644 (file)
--- a/src/core/kill.c
+++ b/src/core/kill.c
@@ -44,7 +44,7 @@ static const char* const kill_mode_table[_KILL_MODE_MAX] = {
 
 DEFINE_STRING_TABLE_LOOKUP(kill_mode, KillMode);
 
-static const char* const kill_who_table[_KILL_WHO_MAX] = {
+static const char* const kill_whom_table[_KILL_WHOM_MAX] = {
         [KILL_MAIN]         = "main",
         [KILL_CONTROL]      = "control",
         [KILL_ALL]          = "all",
@@ -53,4 +53,4 @@ static const char* const kill_who_table[_KILL_WHO_MAX] = {
         [KILL_ALL_FAIL]     = "all-fail",
 };
 
-DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);
+DEFINE_STRING_TABLE_LOOKUP(kill_whom, KillWhom);

diff --git a/src/core/kill.h b/src/core/kill.h
index dbf884d152b70b2434079d6a97287330b5af5ed2..69041c1c533edf0794653fde2617ed9d1ed38f22 100644 (file)
--- a/src/core/kill.h
+++ b/src/core/kill.h
@@ -28,17 +28,17 @@ struct KillContext {
         bool send_sighup;
 };
 
-typedef enum KillWho {
-        /* Kill who is a property of an operation */
+typedef enum KillWhom {
+        /* Kill whom is a property of an operation */
         KILL_MAIN,
         KILL_CONTROL,
         KILL_ALL,
         KILL_MAIN_FAIL,
         KILL_CONTROL_FAIL,
         KILL_ALL_FAIL,
-        _KILL_WHO_MAX,
-        _KILL_WHO_INVALID = -EINVAL,
-} KillWho;
+        _KILL_WHOM_MAX,
+        _KILL_WHOM_INVALID = -EINVAL,
+} KillWhom;
 
 void kill_context_init(KillContext *c);
 void kill_context_dump(KillContext *c, FILE *f, const char *prefix);
@@ -46,8 +46,8 @@ void kill_context_dump(KillContext *c, FILE *f, const char *prefix);
 const char *kill_mode_to_string(KillMode k) _const_;
 KillMode kill_mode_from_string(const char *s) _pure_;
 
-const char *kill_who_to_string(KillWho k) _const_;
-KillWho kill_who_from_string(const char *s) _pure_;
+const char *kill_whom_to_string(KillWhom k) _const_;
+KillWhom kill_whom_from_string(const char *s) _pure_;
 
 static inline int restart_kill_signal(const KillContext *c) {
         if (c->restart_kill_signal != 0)

diff --git a/src/core/unit.c b/src/core/unit.c
index ac91af187ac89f5408ffc8940fbb8efbb45d3846..8823341f996baf73c9a4da849398354ea5779a03 100644 (file)
--- a/src/core/unit.c
+++ b/src/core/unit.c
@@ -4011,7 +4011,7 @@ static int unit_kill_one(
 
 int unit_kill(
                 Unit *u,
-                KillWho who,
+                KillWhom whom,
                 int signo,
                 int code,
                 int value,
@@ -4026,8 +4026,8 @@ int unit_kill(
          * stop a service ourselves. */
 
         assert(u);
-        assert(who >= 0);
-        assert(who < _KILL_WHO_MAX);
+        assert(whom >= 0);
+        assert(whom < _KILL_WHOM_MAX);
         assert(SIGNAL_VALID(signo));
         assert(IN_SET(code, SI_USER, SI_QUEUE));
 
@@ -4037,27 +4037,27 @@ int unit_kill(
         if (!UNIT_HAS_CGROUP_CONTEXT(u) && !main_pid && !control_pid)
                 return sd_bus_error_setf(ret_error, SD_BUS_ERROR_NOT_SUPPORTED, "Unit type does not support process killing.");
 
-        if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL)) {
+        if (IN_SET(whom, KILL_MAIN, KILL_MAIN_FAIL)) {
                 if (!main_pid)
                         return sd_bus_error_setf(ret_error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
                 if (!pidref_is_set(main_pid))
                         return sd_bus_error_set_const(ret_error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
         }
 
-        if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL)) {
+        if (IN_SET(whom, KILL_CONTROL, KILL_CONTROL_FAIL)) {
                 if (!control_pid)
                         return sd_bus_error_setf(ret_error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
                 if (!pidref_is_set(control_pid))
                         return sd_bus_error_set_const(ret_error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
         }
 
-        if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL, KILL_ALL, KILL_ALL_FAIL)) {
+        if (IN_SET(whom, KILL_CONTROL, KILL_CONTROL_FAIL, KILL_ALL, KILL_ALL_FAIL)) {
                 r = unit_kill_one(u, control_pid, "control", signo, code, value, ret_error);
                 RET_GATHER(ret, r);
                 killed = killed || r > 0;
         }
 
-        if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL, KILL_ALL, KILL_ALL_FAIL)) {
+        if (IN_SET(whom, KILL_MAIN, KILL_MAIN_FAIL, KILL_ALL, KILL_ALL_FAIL)) {
                 r = unit_kill_one(u, main_pid, "main", signo, code, value, ret >= 0 ? ret_error : NULL);
                 RET_GATHER(ret, r);
                 killed = killed || r > 0;
@@ -4066,7 +4066,7 @@ int unit_kill(
         /* Note: if we shall enqueue rather than kill we won't do this via the cgroup mechanism, since it
          * doesn't really make much sense (and given that enqueued values are a relatively expensive
          * resource, and we shouldn't allow us to be subjects for such allocation sprees) */
-        if (IN_SET(who, KILL_ALL, KILL_ALL_FAIL) && code == SI_USER) {
+        if (IN_SET(whom, KILL_ALL, KILL_ALL_FAIL) && code == SI_USER) {
                 CGroupRuntime *crt = unit_get_cgroup_runtime(u);
 
                 if (crt && crt->cgroup_path) {
@@ -4098,7 +4098,7 @@ int unit_kill(
         }
 
         /* If the "fail" versions of the operation are requested, then complain if the set of processes we killed is empty */
-        if (ret >= 0 && !killed && IN_SET(who, KILL_ALL_FAIL, KILL_CONTROL_FAIL, KILL_MAIN_FAIL))
+        if (ret >= 0 && !killed && IN_SET(whom, KILL_ALL_FAIL, KILL_CONTROL_FAIL, KILL_MAIN_FAIL))
                 return sd_bus_error_set_const(ret_error, BUS_ERROR_NO_SUCH_PROCESS, "No matching processes to kill");
 
         return ret;

diff --git a/src/core/unit.h b/src/core/unit.h
index b0ffbbcebe28940f5adfc2ac93e7ee4dc8568f20..a5202420206c08724fbca7d6f27e73c3603591fa 100644 (file)
--- a/src/core/unit.h
+++ b/src/core/unit.h
@@ -862,7 +862,7 @@ int unit_start(Unit *u, ActivationDetails *details);
 int unit_stop(Unit *u);
 int unit_reload(Unit *u);
 
-int unit_kill(Unit *u, KillWho w, int signo, int code, int value, sd_bus_error *ret_error);
+int unit_kill(Unit *u, KillWhom w, int signo, int code, int value, sd_bus_error *ret_error);
 
 void unit_notify_cgroup_oom(Unit *u, bool managed_oom);
 

diff --git a/src/login/logind-dbus.c b/src/login/logind-dbus.c
index a657b6ece3f5e7fe44c4fb154d86a03182612bc9..277561300c0a997ffa914f693c9d23245caef66e 100644 (file)
--- a/src/login/logind-dbus.c
+++ b/src/login/logind-dbus.c
@@ -3807,7 +3807,7 @@ static const sd_bus_vtable manager_vtable[] = {
                       method_lock_sessions,
                       SD_BUS_VTABLE_UNPRIVILEGED),
         SD_BUS_METHOD_WITH_ARGS("KillSession",
-                                SD_BUS_ARGS("s", session_id, "s", who, "i", signal_number),
+                                SD_BUS_ARGS("s", session_id, "s", whom, "i", signal_number),
                                 SD_BUS_NO_RESULT,
                                 method_kill_session,
                                 SD_BUS_VTABLE_UNPRIVILEGED),
@@ -4473,7 +4473,7 @@ int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *ret
         return 1;
 }
 
-int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
+int manager_kill_unit(Manager *manager, const char *unit, KillWhom whom, int signo, sd_bus_error *error) {
         assert(manager);
         assert(unit);
         assert(SIGNAL_VALID(signo));
@@ -4486,7 +4486,7 @@ int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo
                         NULL,
                         "ssi",
                         unit,
-                        who == KILL_LEADER ? "main" : "all",
+                        whom == KILL_LEADER ? "main" : "all",
                         signo);
 }
 

diff --git a/src/login/logind-dbus.h b/src/login/logind-dbus.h
index 8459d048b8ed882bb7165089fe29116b850021f9..ebb75abaf34e9fb452ef6c02e88dfa86ed44e2cf 100644 (file)
--- a/src/login/logind-dbus.h
+++ b/src/login/logind-dbus.h
@@ -40,7 +40,7 @@ int manager_start_scope(
 int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **ret_job);
 int manager_stop_unit(Manager *manager, const char *unit, const char *job_mode, sd_bus_error *error, char **ret_job);
 int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *error);
-int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error);
+int manager_kill_unit(Manager *manager, const char *unit, KillWhom whom, int signo, sd_bus_error *error);
 int manager_unit_is_active(Manager *manager, const char *unit, sd_bus_error *error);
 int manager_job_is_active(Manager *manager, const char *path, sd_bus_error *error);
 

diff --git a/src/login/logind-session-dbus.c b/src/login/logind-session-dbus.c
index f20ef4f309bfba7f7fd33381951de3f5de823ed2..142cb214e20881c3847d614934eb6371b36a04df 100644 (file)
--- a/src/login/logind-session-dbus.c
+++ b/src/login/logind-session-dbus.c
@@ -291,23 +291,23 @@ static int method_set_locked_hint(sd_bus_message *message, void *userdata, sd_bu
 
 int bus_session_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         Session *s = ASSERT_PTR(userdata);
-        const char *swho;
+        const char *swhom;
         int32_t signo;
-        KillWho who;
+        KillWhom whom;
         int r;
 
         assert(message);
 
-        r = sd_bus_message_read(message, "si", &swho, &signo);
+        r = sd_bus_message_read(message, "si", &swhom, &signo);
         if (r < 0)
                 return r;
 
-        if (isempty(swho))
-                who = KILL_ALL;
+        if (isempty(swhom))
+                whom = KILL_ALL;
         else {
-                who = kill_who_from_string(swho);
-                if (who < 0)
-                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
+                whom = kill_whom_from_string(swhom);
+                if (whom < 0)
+                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swhom);
         }
 
         if (!SIGNAL_VALID(signo))
@@ -326,7 +326,7 @@ int bus_session_method_kill(sd_bus_message *message, void *userdata, sd_bus_erro
         if (r == 0)
                 return 1; /* Will call us back */
 
-        r = session_kill(s, who, signo);
+        r = session_kill(s, whom, signo);
         if (r < 0)
                 return r;
 
@@ -1016,7 +1016,7 @@ static const sd_bus_vtable session_vtable[] = {
                                 method_set_locked_hint,
                                 SD_BUS_VTABLE_UNPRIVILEGED),
         SD_BUS_METHOD_WITH_ARGS("Kill",
-                                SD_BUS_ARGS("s", who, "i", signal_number),
+                                SD_BUS_ARGS("s", whom, "i", signal_number),
                                 SD_BUS_NO_RESULT,
                                 bus_session_method_kill,
                                 SD_BUS_VTABLE_UNPRIVILEGED),

diff --git a/src/login/logind-session.c b/src/login/logind-session.c
index 55d8b237b36375aeec993f9dbcf47835f47a4d86..bb77a20b5fc8de2ee018a89f9c6c48b24270508d 100644 (file)
--- a/src/login/logind-session.c
+++ b/src/login/logind-session.c
@@ -1384,13 +1384,13 @@ SessionState session_get_state(Session *s) {
         return SESSION_ONLINE;
 }
 
-int session_kill(Session *s, KillWho who, int signo) {
+int session_kill(Session *s, KillWhom whom, int signo) {
         assert(s);
 
         if (!s->scope)
                 return -ESRCH;
 
-        return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
+        return manager_kill_unit(s->manager, s->scope, whom, signo, NULL);
 }
 
 static int session_open_vt(Session *s, bool reopen) {
@@ -1665,12 +1665,12 @@ static const char* const session_class_table[_SESSION_CLASS_MAX] = {
 
 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
 
-static const char* const kill_who_table[_KILL_WHO_MAX] = {
+static const char* const kill_whom_table[_KILL_WHOM_MAX] = {
         [KILL_LEADER] = "leader",
         [KILL_ALL]    = "all",
 };
 
-DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);
+DEFINE_STRING_TABLE_LOOKUP(kill_whom, KillWhom);
 
 static const char* const tty_validity_table[_TTY_VALIDITY_MAX] = {
         [TTY_FROM_PAM]          = "from-pam",

diff --git a/src/login/logind-session.h b/src/login/logind-session.h
index c187bcd779930c7d189e9b682b4c9398a3453f4e..ab3fa4e0977102cb14a1c8fc12dd1f5318015754 100644 (file)
--- a/src/login/logind-session.h
+++ b/src/login/logind-session.h
@@ -2,7 +2,7 @@
 #pragma once
 
 typedef struct Session Session;
-typedef enum KillWho KillWho;
+typedef enum KillWhom KillWhom;
 
 #include "list.h"
 #include "login-util.h"
@@ -77,11 +77,11 @@ typedef enum SessionType {
 
 #define SESSION_TYPE_IS_GRAPHICAL(type) IN_SET(type, SESSION_X11, SESSION_WAYLAND, SESSION_MIR)
 
-enum KillWho {
+enum KillWhom {
         KILL_LEADER,
         KILL_ALL,
-        _KILL_WHO_MAX,
-        _KILL_WHO_INVALID = -EINVAL,
+        _KILL_WHOM_MAX,
+        _KILL_WHOM_INVALID = -EINVAL,
 };
 
 typedef enum TTYValidity {
@@ -191,7 +191,7 @@ int session_finalize(Session *s);
 int session_release(Session *s);
 int session_save(Session *s);
 int session_load(Session *s);
-int session_kill(Session *s, KillWho who, int signo);
+int session_kill(Session *s, KillWhom whom, int signo);
 
 SessionState session_get_state(Session *u);
 
@@ -204,8 +204,8 @@ SessionType session_type_from_string(const char *s) _pure_;
 const char* session_class_to_string(SessionClass t) _const_;
 SessionClass session_class_from_string(const char *s) _pure_;
 
-const char *kill_who_to_string(KillWho k) _const_;
-KillWho kill_who_from_string(const char *s) _pure_;
+const char *kill_whom_to_string(KillWhom k) _const_;
+KillWhom kill_whom_from_string(const char *s) _pure_;
 
 const char* tty_validity_to_string(TTYValidity t) _const_;
 TTYValidity tty_validity_from_string(const char *s) _pure_;

diff --git a/src/login/test-login-tables.c b/src/login/test-login-tables.c
index 1278af7504c70dd4ba9d8bab343f2d2b1e2e919a..9be781ce2dc1c1c3e2f4d3bcaa237059bea93dcb 100644 (file)
--- a/src/login/test-login-tables.c
+++ b/src/login/test-login-tables.c
@@ -25,7 +25,7 @@ int main(int argc, char **argv) {
 
         test_table(handle_action, HANDLE_ACTION);
         test_table(inhibit_mode, INHIBIT_MODE);
-        test_table(kill_who, KILL_WHO);
+        test_table(kill_whom, KILL_WHOM);
         test_table(session_class, SESSION_CLASS);
         test_table(session_state, SESSION_STATE);
         test_table(session_type, SESSION_TYPE);

diff --git a/src/machine/machine-dbus.c b/src/machine/machine-dbus.c
index a4f04c0b86df39abb7a4a5d7594b28a7247036bf..544f820f55c3f8765ab7177680382e39cb094bf4 100644 (file)
--- a/src/machine/machine-dbus.c
+++ b/src/machine/machine-dbus.c
@@ -123,7 +123,7 @@ int bus_machine_method_kill(sd_bus_message *message, void *userdata, sd_bus_erro
         Machine *m = ASSERT_PTR(userdata);
         const char *swho;
         int32_t signo;
-        KillWho who;
+        KillWhom whom;
         int r;
 
         assert(message);
@@ -133,10 +133,10 @@ int bus_machine_method_kill(sd_bus_message *message, void *userdata, sd_bus_erro
                 return r;
 
         if (isempty(swho))
-                who = KILL_ALL;
+                whom = KILL_ALL;
         else {
-                who = kill_who_from_string(swho);
-                if (who < 0)
+                whom = kill_whom_from_string(swho);
+                if (whom < 0)
                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
         }
 
@@ -160,7 +160,7 @@ int bus_machine_method_kill(sd_bus_message *message, void *userdata, sd_bus_erro
         if (r == 0)
                 return 1; /* Will call us back */
 
-        r = machine_kill(m, who, signo);
+        r = machine_kill(m, whom, signo);
         if (r < 0)
                 return r;
 
@@ -1293,7 +1293,7 @@ static const sd_bus_vtable machine_vtable[] = {
                       bus_machine_method_terminate,
                       SD_BUS_VTABLE_UNPRIVILEGED),
         SD_BUS_METHOD_WITH_ARGS("Kill",
-                                SD_BUS_ARGS("s", who, "i", signal),
+                                SD_BUS_ARGS("s", whom, "i", signal),
                                 SD_BUS_NO_RESULT,
                                 bus_machine_method_kill,
                                 SD_BUS_VTABLE_UNPRIVILEGED),

diff --git a/src/machine/machine.c b/src/machine/machine.c
index 0eb9a55e5f74dde6cd34dbecec1fa99f09e46808..1ef2be27abf9eec5c47a4011c0887e10976dfafe 100644 (file)
--- a/src/machine/machine.c
+++ b/src/machine/machine.c
@@ -609,7 +609,7 @@ MachineState machine_get_state(Machine *s) {
         return MACHINE_RUNNING;
 }
 
-int machine_kill(Machine *m, KillWho who, int signo) {
+int machine_kill(Machine *m, KillWhom whom, int signo) {
         assert(m);
 
         if (!IN_SET(m->class, MACHINE_VM, MACHINE_CONTAINER))
@@ -618,7 +618,7 @@ int machine_kill(Machine *m, KillWho who, int signo) {
         if (!m->unit)
                 return -ESRCH;
 
-        if (who == KILL_LEADER) /* If we shall simply kill the leader, do so directly */
+        if (whom == KILL_LEADER) /* If we shall simply kill the leader, do so directly */
                 return pidref_kill(&m->leader, signo);
 
         /* Otherwise, make PID 1 do it for us, for the entire cgroup */
@@ -920,9 +920,9 @@ static const char* const machine_state_table[_MACHINE_STATE_MAX] = {
 
 DEFINE_STRING_TABLE_LOOKUP(machine_state, MachineState);
 
-static const char* const kill_who_table[_KILL_WHO_MAX] = {
+static const char* const kill_whom_table[_KILL_WHOM_MAX] = {
         [KILL_LEADER] = "leader",
         [KILL_ALL] = "all"
 };
 
-DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);
+DEFINE_STRING_TABLE_LOOKUP(kill_whom, KillWhom);

diff --git a/src/machine/machine.h b/src/machine/machine.h
index f8146fb55b8da8eee6ff530f99f6d2fcece7fbe9..c01544a0be334deb1ef050175bde74b2b7174da7 100644 (file)
--- a/src/machine/machine.h
+++ b/src/machine/machine.h
@@ -2,7 +2,7 @@
 #pragma once
 
 typedef struct Machine Machine;
-typedef enum KillWho KillWho;
+typedef enum KillWhom KillWhom;
 
 #include "list.h"
 #include "machined.h"
@@ -26,11 +26,11 @@ typedef enum MachineClass {
         _MACHINE_CLASS_INVALID = -EINVAL,
 } MachineClass;
 
-enum KillWho {
+enum KillWhom {
         KILL_LEADER,
         KILL_ALL,
-        _KILL_WHO_MAX,
-        _KILL_WHO_INVALID = -EINVAL,
+        _KILL_WHOM_MAX,
+        _KILL_WHOM_INVALID = -EINVAL,
 };
 
 struct Machine {
@@ -81,7 +81,7 @@ int machine_stop(Machine *m);
 int machine_finalize(Machine *m);
 int machine_save(Machine *m);
 int machine_load(Machine *m);
-int machine_kill(Machine *m, KillWho who, int signo);
+int machine_kill(Machine *m, KillWhom whom, int signo);
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(Machine*, machine_free);
 
@@ -95,8 +95,8 @@ MachineClass machine_class_from_string(const char *s) _pure_;
 const char* machine_state_to_string(MachineState t) _const_;
 MachineState machine_state_from_string(const char *s) _pure_;
 
-const char *kill_who_to_string(KillWho k) _const_;
-KillWho kill_who_from_string(const char *s) _pure_;
+const char *kill_whom_to_string(KillWhom k) _const_;
+KillWhom kill_whom_from_string(const char *s) _pure_;
 
 int machine_openpt(Machine *m, int flags, char **ret_slave);
 int machine_open_terminal(Machine *m, const char *path, int mode);

diff --git a/src/machine/test-machine-tables.c b/src/machine/test-machine-tables.c
index 32c5e0e80d0acef62d86cc11e9950727e49fa10e..d0b73358bf8e0dcfa7e937c6befdd43b60a5571c 100644 (file)
--- a/src/machine/test-machine-tables.c
+++ b/src/machine/test-machine-tables.c
@@ -7,7 +7,7 @@
 int main(int argc, char **argv) {
         test_setup_logging(LOG_DEBUG);
 
-        test_table(kill_who, KILL_WHO);
+        test_table(kill_whom, KILL_WHOM);
         test_table(machine_class, MACHINE_CLASS);
         test_table(machine_state, MACHINE_STATE);
 

diff --git a/src/test/test-tables.c b/src/test/test-tables.c
index 8abfba550cc18184769c0bdeef7bf4a0c522668c..142ddc48328eed2997183ab24bc13251119d79e1 100644 (file)
--- a/src/test/test-tables.c
+++ b/src/test/test-tables.c
@@ -71,7 +71,7 @@ int main(int argc, char **argv) {
         test_table(job_state, JOB_STATE);
         test_table(job_type, JOB_TYPE);
         test_table(kill_mode, KILL_MODE);
-        test_table(kill_who, KILL_WHO);
+        test_table(kill_whom, KILL_WHOM);
         test_table(locale_variable, VARIABLE_LC);
         test_table(log_target, LOG_TARGET);
         test_table(managed_oom_mode, MANAGED_OOM_MODE);