system/systemd
system/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd synced 2024-07-01 07:34:28 +00:00
Code Issues Projects Releases Wiki Activity

Fix confusion between killer and prey

Browse Source 
"who" is the entity doing the killing, "whom" is the target.
Follow-up for 4ccde410a3.
This commit is contained in:
Zbigniew Jędrzejewski-Szmek 2024-05-16 16:45:04 +02:00
parent 07748c53df
commit cd2fb04960
18 changed files with 76 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
man/org.freedesktop.login1.xml
View File

@ -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();

2
man/org.freedesktop.machine1.xml
View File

@ -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,

18
src/core/dbus-unit.c
View File

@ -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;

4
src/core/kill.c
View File

@ -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);

14
src/core/kill.h
View File

@ -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)

18
src/core/unit.c
View File

@ -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;

2
src/core/unit.h
View File

@ -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);

6
src/login/logind-dbus.c
View File

@ -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);
}

2
src/login/logind-dbus.h
View File

@ -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);

20
src/login/logind-session-dbus.c
View File

@ -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),

8
src/login/logind-session.c
View File

@ -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",

14
src/login/logind-session.h
View File

@ -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_;

2
src/login/test-login-tables.c
View File

@ -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);

12
src/machine/machine-dbus.c
View File

@ -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),

8
src/machine/machine.c
View File

@ -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);

14
src/machine/machine.h
View File

@ -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);

2
src/machine/test-machine-tables.c
View File

@ -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);

2
src/test/test-tables.c
View File

@ -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);