mirror of
https://github.com/systemd/systemd.git
synced 2025-01-13 17:18:18 +03:00
typo: the correct spelling is maintenance not maintainance
This commit is contained in:
parent
8c47c7325f
commit
18c78fb1af
@ -41,7 +41,7 @@ CONTRIBUTING UPSTREAM:
|
||||
|
||||
BE CONSIDERATE:
|
||||
We'd like to keep differences between the distributions
|
||||
minimal. This both simplifies our maintainance work, as well
|
||||
minimal. This both simplifies our maintenance work, as well
|
||||
as it helps administrators to move from one distribution to
|
||||
another.
|
||||
|
||||
|
2
fixme
2
fixme
@ -57,8 +57,6 @@
|
||||
|
||||
* use setproctitle() when forking, before exec() (waiting for (PR_SET_PROCTITLE_AREA to enter the kernel)
|
||||
|
||||
* s/maintainance/maintenance/
|
||||
|
||||
* follow property change dbus spec
|
||||
|
||||
Regularly:
|
||||
|
@ -40,7 +40,7 @@ static const UnitActiveState state_translation_table[_AUTOMOUNT_STATE_MAX] = {
|
||||
[AUTOMOUNT_DEAD] = UNIT_INACTIVE,
|
||||
[AUTOMOUNT_WAITING] = UNIT_ACTIVE,
|
||||
[AUTOMOUNT_RUNNING] = UNIT_ACTIVE,
|
||||
[AUTOMOUNT_MAINTAINANCE] = UNIT_INACTIVE,
|
||||
[AUTOMOUNT_MAINTENANCE] = UNIT_INACTIVE,
|
||||
};
|
||||
|
||||
static int open_dev_autofs(Manager *m);
|
||||
@ -264,7 +264,7 @@ static void automount_enter_dead(Automount *a, bool success) {
|
||||
if (!success)
|
||||
a->failure = true;
|
||||
|
||||
automount_set_state(a, a->failure ? AUTOMOUNT_MAINTAINANCE : AUTOMOUNT_DEAD);
|
||||
automount_set_state(a, a->failure ? AUTOMOUNT_MAINTENANCE : AUTOMOUNT_DEAD);
|
||||
}
|
||||
|
||||
static int open_dev_autofs(Manager *m) {
|
||||
@ -562,7 +562,7 @@ static int automount_start(Unit *u) {
|
||||
|
||||
assert(a);
|
||||
|
||||
assert(a->state == AUTOMOUNT_DEAD || a->state == AUTOMOUNT_MAINTAINANCE);
|
||||
assert(a->state == AUTOMOUNT_DEAD || a->state == AUTOMOUNT_MAINTENANCE);
|
||||
|
||||
if (path_is_mount_point(a->where)) {
|
||||
log_error("Path %s is already a mount point, refusing start for %s", a->where, u->meta.id);
|
||||
@ -754,7 +754,7 @@ static const char* const automount_state_table[_AUTOMOUNT_STATE_MAX] = {
|
||||
[AUTOMOUNT_DEAD] = "dead",
|
||||
[AUTOMOUNT_WAITING] = "waiting",
|
||||
[AUTOMOUNT_RUNNING] = "running",
|
||||
[AUTOMOUNT_MAINTAINANCE] = "maintainance"
|
||||
[AUTOMOUNT_MAINTENANCE] = "maintenance"
|
||||
};
|
||||
|
||||
DEFINE_STRING_TABLE_LOOKUP(automount_state, AutomountState);
|
||||
|
@ -30,7 +30,7 @@ typedef enum AutomountState {
|
||||
AUTOMOUNT_DEAD,
|
||||
AUTOMOUNT_WAITING,
|
||||
AUTOMOUNT_RUNNING,
|
||||
AUTOMOUNT_MAINTAINANCE,
|
||||
AUTOMOUNT_MAINTENANCE,
|
||||
_AUTOMOUNT_STATE_MAX,
|
||||
_AUTOMOUNT_STATE_INVALID = -1
|
||||
} AutomountState;
|
||||
|
12
src/mount.c
12
src/mount.c
@ -49,7 +49,7 @@ static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
|
||||
[MOUNT_REMOUNTING_SIGKILL] = UNIT_ACTIVE_RELOADING,
|
||||
[MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
|
||||
[MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
|
||||
[MOUNT_MAINTAINANCE] = UNIT_INACTIVE,
|
||||
[MOUNT_MAINTENANCE] = UNIT_INACTIVE,
|
||||
};
|
||||
|
||||
static void mount_init(Unit *u) {
|
||||
@ -416,7 +416,7 @@ static void mount_set_state(Mount *m, MountState state) {
|
||||
state == MOUNT_REMOUNTING_SIGKILL ||
|
||||
state == MOUNT_UNMOUNTING_SIGTERM ||
|
||||
state == MOUNT_UNMOUNTING_SIGKILL ||
|
||||
state == MOUNT_MAINTAINANCE)
|
||||
state == MOUNT_MAINTENANCE)
|
||||
mount_notify_automount(m, -ENODEV);
|
||||
|
||||
if (state != old_state)
|
||||
@ -555,7 +555,7 @@ static void mount_enter_dead(Mount *m, bool success) {
|
||||
if (!success)
|
||||
m->failure = true;
|
||||
|
||||
mount_set_state(m, m->failure ? MOUNT_MAINTAINANCE : MOUNT_DEAD);
|
||||
mount_set_state(m, m->failure ? MOUNT_MAINTENANCE : MOUNT_DEAD);
|
||||
}
|
||||
|
||||
static void mount_enter_mounted(Mount *m, bool success) {
|
||||
@ -780,7 +780,7 @@ static int mount_start(Unit *u) {
|
||||
m->state == MOUNT_MOUNTING_SIGKILL)
|
||||
return 0;
|
||||
|
||||
assert(m->state == MOUNT_DEAD || m->state == MOUNT_MAINTAINANCE);
|
||||
assert(m->state == MOUNT_DEAD || m->state == MOUNT_MAINTENANCE);
|
||||
|
||||
m->failure = false;
|
||||
mount_enter_mounting(m);
|
||||
@ -1435,7 +1435,7 @@ void mount_fd_event(Manager *m, int events) {
|
||||
switch (mount->state) {
|
||||
|
||||
case MOUNT_DEAD:
|
||||
case MOUNT_MAINTAINANCE:
|
||||
case MOUNT_MAINTENANCE:
|
||||
mount_enter_mounted(mount, true);
|
||||
break;
|
||||
|
||||
@ -1523,7 +1523,7 @@ static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
|
||||
[MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
|
||||
[MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
|
||||
[MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
|
||||
[MOUNT_MAINTAINANCE] = "maintainance"
|
||||
[MOUNT_MAINTENANCE] = "maintenance"
|
||||
};
|
||||
|
||||
DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
|
||||
|
@ -39,7 +39,7 @@ typedef enum MountState {
|
||||
MOUNT_REMOUNTING_SIGKILL,
|
||||
MOUNT_UNMOUNTING_SIGTERM,
|
||||
MOUNT_UNMOUNTING_SIGKILL,
|
||||
MOUNT_MAINTAINANCE,
|
||||
MOUNT_MAINTENANCE,
|
||||
_MOUNT_STATE_MAX,
|
||||
_MOUNT_STATE_INVALID = -1
|
||||
} MountState;
|
||||
|
@ -34,7 +34,7 @@ static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
|
||||
[PATH_DEAD] = UNIT_INACTIVE,
|
||||
[PATH_WAITING] = UNIT_ACTIVE,
|
||||
[PATH_RUNNING] = UNIT_ACTIVE,
|
||||
[PATH_MAINTAINANCE] = UNIT_INACTIVE
|
||||
[PATH_MAINTENANCE] = UNIT_INACTIVE
|
||||
};
|
||||
|
||||
static void path_done(Unit *u) {
|
||||
@ -290,7 +290,7 @@ static void path_enter_dead(Path *p, bool success) {
|
||||
if (!success)
|
||||
p->failure = true;
|
||||
|
||||
path_set_state(p, p->failure ? PATH_MAINTAINANCE : PATH_DEAD);
|
||||
path_set_state(p, p->failure ? PATH_MAINTENANCE : PATH_DEAD);
|
||||
}
|
||||
|
||||
static void path_enter_running(Path *p) {
|
||||
@ -363,7 +363,7 @@ static int path_start(Unit *u) {
|
||||
Path *p = PATH(u);
|
||||
|
||||
assert(p);
|
||||
assert(p->state == PATH_DEAD || p->state == PATH_MAINTAINANCE);
|
||||
assert(p->state == PATH_DEAD || p->state == PATH_MAINTENANCE);
|
||||
|
||||
if (p->unit->meta.load_state != UNIT_LOADED)
|
||||
return -ENOENT;
|
||||
@ -540,7 +540,7 @@ static const char* const path_state_table[_PATH_STATE_MAX] = {
|
||||
[PATH_DEAD] = "dead",
|
||||
[PATH_WAITING] = "waiting",
|
||||
[PATH_RUNNING] = "running",
|
||||
[PATH_MAINTAINANCE] = "maintainance"
|
||||
[PATH_MAINTENANCE] = "maintenance"
|
||||
};
|
||||
|
||||
DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
|
||||
|
@ -31,7 +31,7 @@ typedef enum PathState {
|
||||
PATH_DEAD,
|
||||
PATH_WAITING,
|
||||
PATH_RUNNING,
|
||||
PATH_MAINTAINANCE,
|
||||
PATH_MAINTENANCE,
|
||||
_PATH_STATE_MAX,
|
||||
_PATH_STATE_INVALID = -1
|
||||
} PathState;
|
||||
|
@ -82,7 +82,7 @@ static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
|
||||
[SERVICE_STOP_POST] = UNIT_DEACTIVATING,
|
||||
[SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
|
||||
[SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
|
||||
[SERVICE_MAINTAINANCE] = UNIT_INACTIVE,
|
||||
[SERVICE_MAINTENANCE] = UNIT_INACTIVE,
|
||||
[SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
|
||||
};
|
||||
|
||||
@ -1079,7 +1079,7 @@ static void service_set_state(Service *s, ServiceState state) {
|
||||
state == SERVICE_STOP_POST ||
|
||||
state == SERVICE_FINAL_SIGTERM ||
|
||||
state == SERVICE_FINAL_SIGKILL ||
|
||||
state == SERVICE_MAINTAINANCE ||
|
||||
state == SERVICE_MAINTENANCE ||
|
||||
state == SERVICE_AUTO_RESTART)
|
||||
service_notify_sockets_dead(s);
|
||||
|
||||
@ -1350,7 +1350,7 @@ static void service_enter_dead(Service *s, bool success, bool allow_restart) {
|
||||
|
||||
service_set_state(s, SERVICE_AUTO_RESTART);
|
||||
} else
|
||||
service_set_state(s, s->failure ? SERVICE_MAINTAINANCE : SERVICE_DEAD);
|
||||
service_set_state(s, s->failure ? SERVICE_MAINTENANCE : SERVICE_DEAD);
|
||||
|
||||
return;
|
||||
|
||||
@ -1737,7 +1737,7 @@ static int service_start(Unit *u) {
|
||||
s->state == SERVICE_START_POST)
|
||||
return 0;
|
||||
|
||||
assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTAINANCE || s->state == SERVICE_AUTO_RESTART);
|
||||
assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTENANCE || s->state == SERVICE_AUTO_RESTART);
|
||||
|
||||
/* Make sure we don't enter a busy loop of some kind. */
|
||||
if (!ratelimit_test(&s->ratelimit)) {
|
||||
@ -2167,7 +2167,7 @@ static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
|
||||
break;
|
||||
|
||||
case SERVICE_FINAL_SIGKILL:
|
||||
log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id);
|
||||
log_warning("%s still around after SIGKILL (2). Entering maintenance mode.", u->meta.id);
|
||||
service_enter_dead(s, false, true);
|
||||
break;
|
||||
|
||||
@ -2499,7 +2499,7 @@ static const char* const service_state_table[_SERVICE_STATE_MAX] = {
|
||||
[SERVICE_STOP_POST] = "stop-post",
|
||||
[SERVICE_FINAL_SIGTERM] = "final-sigterm",
|
||||
[SERVICE_FINAL_SIGKILL] = "final-sigkill",
|
||||
[SERVICE_MAINTAINANCE] = "maintainance",
|
||||
[SERVICE_MAINTENANCE] = "maintenance",
|
||||
[SERVICE_AUTO_RESTART] = "auto-restart",
|
||||
};
|
||||
|
||||
|
@ -41,7 +41,7 @@ typedef enum ServiceState {
|
||||
SERVICE_STOP_POST,
|
||||
SERVICE_FINAL_SIGTERM, /* In case the STOP_POST executable hangs, we shoot that down, too */
|
||||
SERVICE_FINAL_SIGKILL,
|
||||
SERVICE_MAINTAINANCE,
|
||||
SERVICE_MAINTENANCE,
|
||||
SERVICE_AUTO_RESTART,
|
||||
_SERVICE_STATE_MAX,
|
||||
_SERVICE_STATE_INVALID = -1
|
||||
|
12
src/socket.c
12
src/socket.c
@ -49,7 +49,7 @@ static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
|
||||
[SOCKET_STOP_POST] = UNIT_DEACTIVATING,
|
||||
[SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
|
||||
[SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
|
||||
[SOCKET_MAINTAINANCE] = UNIT_INACTIVE,
|
||||
[SOCKET_MAINTENANCE] = UNIT_INACTIVE,
|
||||
};
|
||||
|
||||
static void socket_init(Unit *u) {
|
||||
@ -707,7 +707,7 @@ static void socket_enter_dead(Socket *s, bool success) {
|
||||
if (!success)
|
||||
s->failure = true;
|
||||
|
||||
socket_set_state(s, s->failure ? SOCKET_MAINTAINANCE : SOCKET_DEAD);
|
||||
socket_set_state(s, s->failure ? SOCKET_MAINTENANCE : SOCKET_DEAD);
|
||||
}
|
||||
|
||||
static void socket_enter_signal(Socket *s, SocketState state, bool success);
|
||||
@ -995,12 +995,12 @@ static int socket_start(Unit *u) {
|
||||
/* If the service is alredy actvie we cannot start the
|
||||
* socket */
|
||||
if (s->service->state != SERVICE_DEAD &&
|
||||
s->service->state != SERVICE_MAINTAINANCE &&
|
||||
s->service->state != SERVICE_MAINTENANCE &&
|
||||
s->service->state != SERVICE_AUTO_RESTART)
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE);
|
||||
assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTENANCE);
|
||||
|
||||
s->failure = false;
|
||||
socket_enter_start_pre(s);
|
||||
@ -1331,7 +1331,7 @@ static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
|
||||
break;
|
||||
|
||||
case SOCKET_FINAL_SIGKILL:
|
||||
log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id);
|
||||
log_warning("%s still around after SIGKILL (2). Entering maintenance mode.", u->meta.id);
|
||||
socket_enter_dead(s, false);
|
||||
break;
|
||||
|
||||
@ -1395,7 +1395,7 @@ static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
|
||||
[SOCKET_STOP_POST] = "stop-post",
|
||||
[SOCKET_FINAL_SIGTERM] = "final-sigterm",
|
||||
[SOCKET_FINAL_SIGKILL] = "final-sigkill",
|
||||
[SOCKET_MAINTAINANCE] = "maintainance"
|
||||
[SOCKET_MAINTENANCE] = "maintenance"
|
||||
};
|
||||
|
||||
DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
|
||||
|
@ -41,7 +41,7 @@ typedef enum SocketState {
|
||||
SOCKET_STOP_POST,
|
||||
SOCKET_FINAL_SIGTERM,
|
||||
SOCKET_FINAL_SIGKILL,
|
||||
SOCKET_MAINTAINANCE,
|
||||
SOCKET_MAINTENANCE,
|
||||
_SOCKET_STATE_MAX,
|
||||
_SOCKET_STATE_INVALID = -1
|
||||
} SocketState;
|
||||
|
@ -37,7 +37,7 @@
|
||||
static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
|
||||
[SWAP_DEAD] = UNIT_INACTIVE,
|
||||
[SWAP_ACTIVE] = UNIT_ACTIVE,
|
||||
[SWAP_MAINTAINANCE] = UNIT_INACTIVE
|
||||
[SWAP_MAINTENANCE] = UNIT_INACTIVE
|
||||
};
|
||||
|
||||
static void swap_init(Unit *u) {
|
||||
@ -382,7 +382,7 @@ static void swap_dump(Unit *u, FILE *f, const char *prefix) {
|
||||
static void swap_enter_dead(Swap *s, bool success) {
|
||||
assert(s);
|
||||
|
||||
swap_set_state(s, success ? SWAP_MAINTAINANCE : SWAP_DEAD);
|
||||
swap_set_state(s, success ? SWAP_MAINTENANCE : SWAP_DEAD);
|
||||
}
|
||||
|
||||
static int swap_start(Unit *u) {
|
||||
@ -391,7 +391,7 @@ static int swap_start(Unit *u) {
|
||||
int r;
|
||||
|
||||
assert(s);
|
||||
assert(s->state == SWAP_DEAD || s->state == SWAP_MAINTAINANCE);
|
||||
assert(s->state == SWAP_DEAD || s->state == SWAP_MAINTENANCE);
|
||||
|
||||
if (s->from_fragment)
|
||||
priority = s->parameters_fragment.priority;
|
||||
@ -527,7 +527,7 @@ static void swap_shutdown(Manager *m) {
|
||||
static const char* const swap_state_table[_SWAP_STATE_MAX] = {
|
||||
[SWAP_DEAD] = "dead",
|
||||
[SWAP_ACTIVE] = "active",
|
||||
[SWAP_MAINTAINANCE] = "maintainance"
|
||||
[SWAP_MAINTENANCE] = "maintenance"
|
||||
};
|
||||
|
||||
DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
|
||||
|
@ -30,7 +30,7 @@ typedef struct Swap Swap;
|
||||
typedef enum SwapState {
|
||||
SWAP_DEAD,
|
||||
SWAP_ACTIVE,
|
||||
SWAP_MAINTAINANCE,
|
||||
SWAP_MAINTENANCE,
|
||||
_SWAP_STATE_MAX,
|
||||
_SWAP_STATE_INVALID = -1
|
||||
} SwapState;
|
||||
|
10
src/timer.c
10
src/timer.c
@ -31,7 +31,7 @@ static const UnitActiveState state_translation_table[_TIMER_STATE_MAX] = {
|
||||
[TIMER_WAITING] = UNIT_ACTIVE,
|
||||
[TIMER_RUNNING] = UNIT_ACTIVE,
|
||||
[TIMER_ELAPSED] = UNIT_ACTIVE,
|
||||
[TIMER_MAINTAINANCE] = UNIT_INACTIVE
|
||||
[TIMER_MAINTENANCE] = UNIT_INACTIVE
|
||||
};
|
||||
|
||||
static void timer_init(Unit *u) {
|
||||
@ -167,7 +167,7 @@ static void timer_enter_dead(Timer *t, bool success) {
|
||||
if (!success)
|
||||
t->failure = true;
|
||||
|
||||
timer_set_state(t, t->failure ? TIMER_MAINTAINANCE : TIMER_DEAD);
|
||||
timer_set_state(t, t->failure ? TIMER_MAINTENANCE : TIMER_DEAD);
|
||||
}
|
||||
|
||||
static void timer_enter_waiting(Timer *t, bool initial) {
|
||||
@ -273,7 +273,7 @@ static int timer_start(Unit *u) {
|
||||
Timer *t = TIMER(u);
|
||||
|
||||
assert(t);
|
||||
assert(t->state == TIMER_DEAD || t->state == TIMER_MAINTAINANCE);
|
||||
assert(t->state == TIMER_DEAD || t->state == TIMER_MAINTENANCE);
|
||||
|
||||
if (t->unit->meta.load_state != UNIT_LOADED)
|
||||
return -ENOENT;
|
||||
@ -409,7 +409,7 @@ void timer_unit_notify(Unit *u, UnitActiveState new_state) {
|
||||
break;
|
||||
|
||||
case TIMER_DEAD:
|
||||
case TIMER_MAINTAINANCE:
|
||||
case TIMER_MAINTENANCE:
|
||||
;
|
||||
|
||||
default:
|
||||
@ -428,7 +428,7 @@ static const char* const timer_state_table[_TIMER_STATE_MAX] = {
|
||||
[TIMER_WAITING] = "waiting",
|
||||
[TIMER_RUNNING] = "running",
|
||||
[TIMER_ELAPSED] = "elapsed",
|
||||
[TIMER_MAINTAINANCE] = "maintainance"
|
||||
[TIMER_MAINTENANCE] = "maintenance"
|
||||
};
|
||||
|
||||
DEFINE_STRING_TABLE_LOOKUP(timer_state, TimerState);
|
||||
|
@ -31,7 +31,7 @@ typedef enum TimerState {
|
||||
TIMER_WAITING,
|
||||
TIMER_RUNNING,
|
||||
TIMER_ELAPSED,
|
||||
TIMER_MAINTAINANCE,
|
||||
TIMER_MAINTENANCE,
|
||||
_TIMER_STATE_MAX,
|
||||
_TIMER_STATE_INVALID = -1
|
||||
} TimerState;
|
||||
|
Loading…
x
Reference in New Issue
Block a user