~ubuntu-branches/debian/jessie/systemd/jessie
» Revision
23
: .pc/v44..upstream-fixes_44-11/src/service.c
« back to all changes in this revision
Viewing changes to .pc/v44..upstream-fixes_44-11/src/service.c
- browse files at revision 23
- compare with another revision
- download diff
- download tarball
- view history from revision 23
- Committer: Package Import Robot
- Author(s): Michael Biebl
- Date: 2013-03-13 08:03:06 UTC
- Revision ID: package-import@ubuntu.com-20130313080306-d0mkta856x23o4k4
Tags: 44-11
* Team upload.
* Run debian-enable-units.service after sysinit.target to ensure our tmp
files aren't nuked by systemd-tmpfiles.
* The mountoverflowtmp SysV init script no longer exists so remove that
from remount-rootfs.service to avoid an unnecessary diff to upstream.
* Do not fail on purge if /var/lib/systemd is empty and has been removed
by dpkg.
* Run debian-enable-units.service after sysinit.target to ensure our tmp
files aren't nuked by systemd-tmpfiles.
* The mountoverflowtmp SysV init script no longer exists so remove that
from remount-rootfs.service to avoid an unnecessary diff to upstream.
* Do not fail on purge if /var/lib/systemd is empty and has been removed
by dpkg.
- files added:
- .pc/v44..upstream-fixes_44-11
- .pc/v44..upstream-fixes_44-11/man
- .pc/v44..upstream-fixes_44-11/src
- .pc/v44..upstream-fixes_44-11/src/journal
- .pc/v44..upstream-fixes_44-11/units
- files removed:
- .pc/debian-changes/units/remount-rootfs.service
- .pc/v44..upstream-fixes_44-10
- .pc/v44..upstream-fixes_44-10/man
- .pc/v44..upstream-fixes_44-10/src
- .pc/v44..upstream-fixes_44-10/src/journal
- .pc/v44..upstream-fixes_44-10/units
- files modified:
- .pc/applied-patches
added
removed
.pc/v44..upstream-fixes_44-11/src/service.c
1
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3
/***
4
This file is part of systemd.
5
6
Copyright 2010 Lennart Poettering
7
8
systemd is free software; you can redistribute it and/or modify it
9
under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 2 of the License, or
11
(at your option) any later version.
12
13
systemd is distributed in the hope that it will be useful, but
14
WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
General Public License for more details.
17
18
You should have received a copy of the GNU General Public License
19
along with systemd; If not, see <http://www.gnu.org/licenses/>.
20
***/
21
22
#include <errno.h>
23
#include <signal.h>
24
#include <dirent.h>
25
#include <unistd.h>
26
#include <sys/reboot.h>
27
28
#include "manager.h"
29
#include "unit.h"
30
#include "service.h"
31
#include "load-fragment.h"
32
#include "load-dropin.h"
33
#include "log.h"
34
#include "strv.h"
35
#include "unit-name.h"
36
#include "dbus-service.h"
37
#include "special.h"
38
#include "bus-errors.h"
39
#include "exit-status.h"
40
#include "def.h"
41
#include "util.h"
42
#include "utf8.h"
43
44
#ifdef HAVE_SYSV_COMPAT
45
46
#define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
47
48
typedef enum RunlevelType {
49
RUNLEVEL_UP,
50
RUNLEVEL_DOWN,
51
RUNLEVEL_SYSINIT
52
} RunlevelType;
53
54
static const struct {
55
const char *path;
56
const char *target;
57
const RunlevelType type;
58
} rcnd_table[] = {
59
/* Standard SysV runlevels for start-up */
60
{ "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
61
{ "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
62
{ "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
63
{ "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
64
{ "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
65
66
#ifdef TARGET_SUSE
67
/* SUSE style boot.d */
68
{ "boot.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
69
#endif
70
71
#if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
72
/* Debian style rcS.d */
73
{ "rcS.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
74
#endif
75
76
/* Standard SysV runlevels for shutdown */
77
{ "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
78
{ "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
79
80
/* Note that the order here matters, as we read the
81
directories in this order, and we want to make sure that
82
sysv_start_priority is known when we first load the
83
unit. And that value we only know from S links. Hence
84
UP/SYSINIT must be read before DOWN */
85
};
86
87
#define RUNLEVELS_UP "12345"
88
/* #define RUNLEVELS_DOWN "06" */
89
#define RUNLEVELS_BOOT "bBsS"
90
#endif
91
92
static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
93
[SERVICE_DEAD] = UNIT_INACTIVE,
94
[SERVICE_START_PRE] = UNIT_ACTIVATING,
95
[SERVICE_START] = UNIT_ACTIVATING,
96
[SERVICE_START_POST] = UNIT_ACTIVATING,
97
[SERVICE_RUNNING] = UNIT_ACTIVE,
98
[SERVICE_EXITED] = UNIT_ACTIVE,
99
[SERVICE_RELOAD] = UNIT_RELOADING,
100
[SERVICE_STOP] = UNIT_DEACTIVATING,
101
[SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
102
[SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
103
[SERVICE_STOP_POST] = UNIT_DEACTIVATING,
104
[SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
105
[SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
106
[SERVICE_FAILED] = UNIT_FAILED,
107
[SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
108
};
109
110
static void service_init(Unit *u) {
111
Service *s = SERVICE(u);
112
113
assert(u);
114
assert(u->load_state == UNIT_STUB);
115
116
s->timeout_usec = DEFAULT_TIMEOUT_USEC;
117
s->restart_usec = DEFAULT_RESTART_USEC;
118
119
s->watchdog_watch.type = WATCH_INVALID;
120
121
s->timer_watch.type = WATCH_INVALID;
122
#ifdef HAVE_SYSV_COMPAT
123
s->sysv_start_priority = -1;
124
s->sysv_start_priority_from_rcnd = -1;
125
#endif
126
s->socket_fd = -1;
127
s->guess_main_pid = true;
128
129
exec_context_init(&s->exec_context);
130
131
RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
132
133
s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
134
}
135
136
static void service_unwatch_control_pid(Service *s) {
137
assert(s);
138
139
if (s->control_pid <= 0)
140
return;
141
142
unit_unwatch_pid(UNIT(s), s->control_pid);
143
s->control_pid = 0;
144
}
145
146
static void service_unwatch_main_pid(Service *s) {
147
assert(s);
148
149
if (s->main_pid <= 0)
150
return;
151
152
unit_unwatch_pid(UNIT(s), s->main_pid);
153
s->main_pid = 0;
154
}
155
156
static void service_unwatch_pid_file(Service *s) {
157
if (!s->pid_file_pathspec)
158
return;
159
160
log_debug("Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
161
path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
162
path_spec_done(s->pid_file_pathspec);
163
free(s->pid_file_pathspec);
164
s->pid_file_pathspec = NULL;
165
}
166
167
static int service_set_main_pid(Service *s, pid_t pid) {
168
pid_t ppid;
169
170
assert(s);
171
172
if (pid <= 1)
173
return -EINVAL;
174
175
if (pid == getpid())
176
return -EINVAL;
177
178
s->main_pid = pid;
179
s->main_pid_known = true;
180
181
if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
182
log_warning("%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
183
UNIT(s)->id, (unsigned long) pid);
184
185
s->main_pid_alien = true;
186
} else
187
s->main_pid_alien = false;
188
189
exec_status_start(&s->main_exec_status, pid);
190
191
return 0;
192
}
193
194
static void service_close_socket_fd(Service *s) {
195
assert(s);
196
197
if (s->socket_fd < 0)
198
return;
199
200
close_nointr_nofail(s->socket_fd);
201
s->socket_fd = -1;
202
}
203
204
static void service_connection_unref(Service *s) {
205
assert(s);
206
207
if (!UNIT_DEREF(s->accept_socket))
208
return;
209
210
socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
211
unit_ref_unset(&s->accept_socket);
212
}
213
214
static void service_stop_watchdog(Service *s) {
215
assert(s);
216
217
unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
218
s->watchdog_timestamp.realtime = 0;
219
s->watchdog_timestamp.monotonic = 0;
220
}
221
222
static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
223
224
static void service_handle_watchdog(Service *s) {
225
usec_t offset;
226
int r;
227
228
assert(s);
229
230
if (s->watchdog_usec == 0)
231
return;
232
233
offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
234
if (offset >= s->watchdog_usec) {
235
log_error("%s watchdog timeout!", UNIT(s)->id);
236
service_enter_dead(s, SERVICE_FAILURE_WATCHDOG, true);
237
return;
238
}
239
240
r = unit_watch_timer(UNIT(s), s->watchdog_usec - offset, &s->watchdog_watch);
241
if (r < 0)
242
log_warning("%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
243
}
244
245
static void service_reset_watchdog(Service *s) {
246
assert(s);
247
248
dual_timestamp_get(&s->watchdog_timestamp);
249
service_handle_watchdog(s);
250
}
251
252
static void service_done(Unit *u) {
253
Service *s = SERVICE(u);
254
255
assert(s);
256
257
free(s->pid_file);
258
s->pid_file = NULL;
259
260
#ifdef HAVE_SYSV_COMPAT
261
free(s->sysv_path);
262
s->sysv_path = NULL;
263
264
free(s->sysv_runlevels);
265
s->sysv_runlevels = NULL;
266
#endif
267
268
free(s->status_text);
269
s->status_text = NULL;
270
271
exec_context_done(&s->exec_context);
272
exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
273
s->control_command = NULL;
274
s->main_command = NULL;
275
276
/* This will leak a process, but at least no memory or any of
277
* our resources */
278
service_unwatch_main_pid(s);
279
service_unwatch_control_pid(s);
280
service_unwatch_pid_file(s);
281
282
if (s->bus_name) {
283
unit_unwatch_bus_name(u, s->bus_name);
284
free(s->bus_name);
285
s->bus_name = NULL;
286
}
287
288
service_close_socket_fd(s);
289
service_connection_unref(s);
290
291
unit_ref_unset(&s->accept_socket);
292
293
service_stop_watchdog(s);
294
295
unit_unwatch_timer(u, &s->timer_watch);
296
}
297
298
#ifdef HAVE_SYSV_COMPAT
299
static char *sysv_translate_name(const char *name) {
300
char *r;
301
302
if (!(r = new(char, strlen(name) + sizeof(".service"))))
303
return NULL;
304
305
#if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
306
if (endswith(name, ".sh"))
307
/* Drop Debian-style .sh suffix */
308
strcpy(stpcpy(r, name) - 3, ".service");
309
#endif
310
#ifdef TARGET_SUSE
311
if (startswith(name, "boot."))
312
/* Drop SuSE-style boot. prefix */
313
strcpy(stpcpy(r, name + 5), ".service");
314
#endif
315
#ifdef TARGET_FRUGALWARE
316
if (startswith(name, "rc."))
317
/* Drop Frugalware-style rc. prefix */
318
strcpy(stpcpy(r, name + 3), ".service");
319
#endif
320
else
321
/* Normal init scripts */
322
strcpy(stpcpy(r, name), ".service");
323
324
return r;
325
}
326
327
static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
328
329
/* We silently ignore the $ prefix here. According to the LSB
330
* spec it simply indicates whether something is a
331
* standardized name or a distribution-specific one. Since we
332
* just follow what already exists and do not introduce new
333
* uses or names we don't care who introduced a new name. */
334
335
static const char * const table[] = {
336
/* LSB defined facilities */
337
"local_fs", SPECIAL_LOCAL_FS_TARGET,
338
#if defined(TARGET_MANDRIVA) || defined(TARGET_MAGEIA)
339
#else
340
/* Due to unfortunate name selection in Mandriva,
341
* $network is provided by network-up which is ordered
342
* after network which actually starts interfaces.
343
* To break the loop, just ignore it */
344
"network", SPECIAL_NETWORK_TARGET,
345
#endif
346
"named", SPECIAL_NSS_LOOKUP_TARGET,
347
"portmap", SPECIAL_RPCBIND_TARGET,
348
"remote_fs", SPECIAL_REMOTE_FS_TARGET,
349
"syslog", SPECIAL_SYSLOG_TARGET,
350
"time", SPECIAL_TIME_SYNC_TARGET,
351
352
/* common extensions */
353
"mail-transfer-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
354
"x-display-manager", SPECIAL_DISPLAY_MANAGER_SERVICE,
355
"null", NULL,
356
357
#if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
358
"mail-transport-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
359
#endif
360
361
#ifdef TARGET_FEDORA
362
"MTA", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
363
"smtpdaemon", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
364
"httpd", SPECIAL_HTTP_DAEMON_TARGET,
365
#endif
366
367
#ifdef TARGET_SUSE
368
"smtp", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
369
#endif
370
};
371
372
unsigned i;
373
char *r;
374
const char *n;
375
376
assert(name);
377
assert(_r);
378
379
n = *name == '$' ? name + 1 : name;
380
381
for (i = 0; i < ELEMENTSOF(table); i += 2) {
382
383
if (!streq(table[i], n))
384
continue;
385
386
if (!table[i+1])
387
return 0;
388
389
if (!(r = strdup(table[i+1])))
390
return -ENOMEM;
391
392
goto finish;
393
}
394
395
/* If we don't know this name, fallback heuristics to figure
396
* out whether something is a target or a service alias. */
397
398
if (*name == '$') {
399
if (!unit_prefix_is_valid(n))
400
return -EINVAL;
401
402
/* Facilities starting with $ are most likely targets */
403
r = unit_name_build(n, NULL, ".target");
404
} else if (filename && streq(name, filename))
405
/* Names equaling the file name of the services are redundant */
406
return 0;
407
else
408
/* Everything else we assume to be normal service names */
409
r = sysv_translate_name(n);
410
411
if (!r)
412
return -ENOMEM;
413
414
finish:
415
*_r = r;
416
417
return 1;
418
}
419
420
static int sysv_fix_order(Service *s) {
421
Unit *other;
422
int r;
423
424
assert(s);
425
426
if (s->sysv_start_priority < 0)
427
return 0;
428
429
/* For each pair of services where at least one lacks a LSB
430
* header, we use the start priority value to order things. */
431
432
LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
433
Service *t;
434
UnitDependency d;
435
bool special_s, special_t;
436
437
t = SERVICE(other);
438
439
if (s == t)
440
continue;
441
442
if (UNIT(t)->load_state != UNIT_LOADED)
443
continue;
444
445
if (t->sysv_start_priority < 0)
446
continue;
447
448
/* If both units have modern headers we don't care
449
* about the priorities */
450
if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
451
(UNIT(t)->fragment_path || t->sysv_has_lsb))
452
continue;
453
454
special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
455
special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
456
457
if (special_t && !special_s)
458
d = UNIT_AFTER;
459
else if (special_s && !special_t)
460
d = UNIT_BEFORE;
461
else if (t->sysv_start_priority < s->sysv_start_priority)
462
d = UNIT_AFTER;
463
else if (t->sysv_start_priority > s->sysv_start_priority)
464
d = UNIT_BEFORE;
465
else
466
continue;
467
468
/* FIXME: Maybe we should compare the name here lexicographically? */
469
470
if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
471
return r;
472
}
473
474
return 0;
475
}
476
477
static ExecCommand *exec_command_new(const char *path, const char *arg1) {
478
ExecCommand *c;
479
480
if (!(c = new0(ExecCommand, 1)))
481
return NULL;
482
483
if (!(c->path = strdup(path))) {
484
free(c);
485
return NULL;
486
}
487
488
if (!(c->argv = strv_new(path, arg1, NULL))) {
489
free(c->path);
490
free(c);
491
return NULL;
492
}
493
494
return c;
495
}
496
497
static int sysv_exec_commands(Service *s) {
498
ExecCommand *c;
499
500
assert(s);
501
assert(s->sysv_path);
502
503
if (!(c = exec_command_new(s->sysv_path, "start")))
504
return -ENOMEM;
505
exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
506
507
if (!(c = exec_command_new(s->sysv_path, "stop")))
508
return -ENOMEM;
509
exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
510
511
if (!(c = exec_command_new(s->sysv_path, "reload")))
512
return -ENOMEM;
513
exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
514
515
return 0;
516
}
517
518
static int service_load_sysv_path(Service *s, const char *path) {
519
FILE *f;
520
Unit *u;
521
unsigned line = 0;
522
int r;
523
enum {
524
NORMAL,
525
DESCRIPTION,
526
LSB,
527
LSB_DESCRIPTION
528
} state = NORMAL;
529
char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
530
struct stat st;
531
532
assert(s);
533
assert(path);
534
535
u = UNIT(s);
536
537
if (!(f = fopen(path, "re"))) {
538
r = errno == ENOENT ? 0 : -errno;
539
goto finish;
540
}
541
542
zero(st);
543
if (fstat(fileno(f), &st) < 0) {
544
r = -errno;
545
goto finish;
546
}
547
548
free(s->sysv_path);
549
if (!(s->sysv_path = strdup(path))) {
550
r = -ENOMEM;
551
goto finish;
552
}
553
554
s->sysv_mtime = timespec_load(&st.st_mtim);
555
556
if (null_or_empty(&st)) {
557
u->load_state = UNIT_MASKED;
558
r = 0;
559
goto finish;
560
}
561
562
while (!feof(f)) {
563
char l[LINE_MAX], *t;
564
565
if (!fgets(l, sizeof(l), f)) {
566
if (feof(f))
567
break;
568
569
r = -errno;
570
log_error("Failed to read configuration file '%s': %s", path, strerror(-r));
571
goto finish;
572
}
573
574
line++;
575
576
t = strstrip(l);
577
if (*t != '#')
578
continue;
579
580
if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
581
state = LSB;
582
s->sysv_has_lsb = true;
583
continue;
584
}
585
586
if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
587
state = NORMAL;
588
continue;
589
}
590
591
t++;
592
t += strspn(t, WHITESPACE);
593
594
if (state == NORMAL) {
595
596
/* Try to parse Red Hat style chkconfig headers */
597
598
if (startswith_no_case(t, "chkconfig:")) {
599
int start_priority;
600
char runlevels[16], *k;
601
602
state = NORMAL;
603
604
if (sscanf(t+10, "%15s %i %*i",
605
runlevels,
606
&start_priority) != 2) {
607
608
log_warning("[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line);
609
continue;
610
}
611
612
/* A start priority gathered from the
613
* symlink farms is preferred over the
614
* data from the LSB header. */
615
if (start_priority < 0 || start_priority > 99)
616
log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line);
617
else
618
s->sysv_start_priority = start_priority;
619
620
char_array_0(runlevels);
621
k = delete_chars(runlevels, WHITESPACE "-");
622
623
if (k[0]) {
624
char *d;
625
626
if (!(d = strdup(k))) {
627
r = -ENOMEM;
628
goto finish;
629
}
630
631
free(s->sysv_runlevels);
632
s->sysv_runlevels = d;
633
}
634
635
} else if (startswith_no_case(t, "description:")) {
636
637
size_t k = strlen(t);
638
char *d;
639
const char *j;
640
641
if (t[k-1] == '\\') {
642
state = DESCRIPTION;
643
t[k-1] = 0;
644
}
645
646
if ((j = strstrip(t+12)) && *j) {
647
if (!(d = strdup(j))) {
648
r = -ENOMEM;
649
goto finish;
650
}
651
} else
652
d = NULL;
653
654
free(chkconfig_description);
655
chkconfig_description = d;
656
657
} else if (startswith_no_case(t, "pidfile:")) {
658
659
char *fn;
660
661
state = NORMAL;
662
663
fn = strstrip(t+8);
664
if (!path_is_absolute(fn)) {
665
log_warning("[%s:%u] PID file not absolute. Ignoring.", path, line);
666
continue;
667
}
668
669
if (!(fn = strdup(fn))) {
670
r = -ENOMEM;
671
goto finish;
672
}
673
674
free(s->pid_file);
675
s->pid_file = fn;
676
}
677
678
} else if (state == DESCRIPTION) {
679
680
/* Try to parse Red Hat style description
681
* continuation */
682
683
size_t k = strlen(t);
684
char *j;
685
686
if (t[k-1] == '\\')
687
t[k-1] = 0;
688
else
689
state = NORMAL;
690
691
if ((j = strstrip(t)) && *j) {
692
char *d = NULL;
693
694
if (chkconfig_description)
695
d = join(chkconfig_description, " ", j, NULL);
696
else
697
d = strdup(j);
698
699
if (!d) {
700
r = -ENOMEM;
701
goto finish;
702
}
703
704
free(chkconfig_description);
705
chkconfig_description = d;
706
}
707
708
} else if (state == LSB || state == LSB_DESCRIPTION) {
709
710
if (startswith_no_case(t, "Provides:")) {
711
char *i, *w;
712
size_t z;
713
714
state = LSB;
715
716
FOREACH_WORD_QUOTED(w, z, t+9, i) {
717
char *n, *m;
718
719
if (!(n = strndup(w, z))) {
720
r = -ENOMEM;
721
goto finish;
722
}
723
724
r = sysv_translate_facility(n, file_name_from_path(path), &m);
725
free(n);
726
727
if (r < 0)
728
goto finish;
729
730
if (r == 0)
731
continue;
732
733
if (unit_name_to_type(m) == UNIT_SERVICE)
734
r = unit_add_name(u, m);
735
else
736
/* NB: SysV targets
737
* which are provided
738
* by a service are
739
* pulled in by the
740
* services, as an
741
* indication that the
742
* generic service is
743
* now available. This
744
* is strictly
745
* one-way. The
746
* targets do NOT pull
747
* in the SysV
748
* services! */
749
r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
750
751
if (r < 0)
752
log_error("[%s:%u] Failed to add LSB Provides name %s, ignoring: %s", path, line, m, strerror(-r));
753
754
free(m);
755
}
756
757
} else if (startswith_no_case(t, "Required-Start:") ||
758
startswith_no_case(t, "Should-Start:") ||
759
startswith_no_case(t, "X-Start-Before:") ||
760
startswith_no_case(t, "X-Start-After:")) {
761
char *i, *w;
762
size_t z;
763
764
state = LSB;
765
766
FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
767
char *n, *m;
768
769
if (!(n = strndup(w, z))) {
770
r = -ENOMEM;
771
goto finish;
772
}
773
774
r = sysv_translate_facility(n, file_name_from_path(path), &m);
775
776
if (r < 0) {
777
log_error("[%s:%u] Failed to translate LSB dependency %s, ignoring: %s", path, line, n, strerror(-r));
778
free(n);
779
continue;
780
}
781
782
free(n);
783
784
if (r == 0)
785
continue;
786
787
r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
788
789
if (r < 0)
790
log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", path, line, m, strerror(-r));
791
792
free(m);
793
}
794
} else if (startswith_no_case(t, "Default-Start:")) {
795
char *k, *d;
796
797
state = LSB;
798
799
k = delete_chars(t+14, WHITESPACE "-");
800
801
if (k[0] != 0) {
802
if (!(d = strdup(k))) {
803
r = -ENOMEM;
804
goto finish;
805
}
806
807
free(s->sysv_runlevels);
808
s->sysv_runlevels = d;
809
}
810
811
} else if (startswith_no_case(t, "Description:")) {
812
char *d, *j;
813
814
state = LSB_DESCRIPTION;
815
816
if ((j = strstrip(t+12)) && *j) {
817
if (!(d = strdup(j))) {
818
r = -ENOMEM;
819
goto finish;
820
}
821
} else
822
d = NULL;
823
824
free(long_description);
825
long_description = d;
826
827
} else if (startswith_no_case(t, "Short-Description:")) {
828
char *d, *j;
829
830
state = LSB;
831
832
if ((j = strstrip(t+18)) && *j) {
833
if (!(d = strdup(j))) {
834
r = -ENOMEM;
835
goto finish;
836
}
837
} else
838
d = NULL;
839
840
free(short_description);
841
short_description = d;
842
843
} else if (state == LSB_DESCRIPTION) {
844
845
if (startswith(l, "#\t") || startswith(l, "# ")) {
846
char *j;
847
848
if ((j = strstrip(t)) && *j) {
849
char *d = NULL;
850
851
if (long_description)
852
d = join(long_description, " ", t, NULL);
853
else
854
d = strdup(j);
855
856
if (!d) {
857
r = -ENOMEM;
858
goto finish;
859
}
860
861
free(long_description);
862
long_description = d;
863
}
864
865
} else
866
state = LSB;
867
}
868
}
869
}
870
871
if ((r = sysv_exec_commands(s)) < 0)
872
goto finish;
873
if (s->sysv_runlevels &&
874
chars_intersect(RUNLEVELS_BOOT, s->sysv_runlevels) &&
875
chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
876
/* Service has both boot and "up" runlevels
877
configured. Kill the "up" ones. */
878
delete_chars(s->sysv_runlevels, RUNLEVELS_UP);
879
}
880
881
if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
882
/* If there a runlevels configured for this service
883
* but none of the standard ones, then we assume this
884
* is some special kind of service (which might be
885
* needed for early boot) and don't create any links
886
* to it. */
887
888
UNIT(s)->default_dependencies = false;
889
890
/* Don't timeout special services during boot (like fsck) */
891
s->timeout_usec = 0;
892
} else
893
s->timeout_usec = DEFAULT_SYSV_TIMEOUT_USEC;
894
895
/* Special setting for all SysV services */
896
s->type = SERVICE_FORKING;
897
s->remain_after_exit = !s->pid_file;
898
s->guess_main_pid = false;
899
s->restart = SERVICE_RESTART_NO;
900
s->exec_context.ignore_sigpipe = false;
901
902
if (UNIT(s)->manager->sysv_console)
903
s->exec_context.std_output = EXEC_OUTPUT_JOURNAL_AND_CONSOLE;
904
905
s->exec_context.kill_mode = KILL_PROCESS;
906
907
/* We use the long description only if
908
* no short description is set. */
909
910
if (short_description)
911
description = short_description;
912
else if (chkconfig_description)
913
description = chkconfig_description;
914
else if (long_description)
915
description = long_description;
916
else
917
description = NULL;
918
919
if (description) {
920
char *d;
921
922
if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
923
r = -ENOMEM;
924
goto finish;
925
}
926
927
u->description = d;
928
}
929
930
/* The priority that has been set in /etc/rcN.d/ hierarchies
931
* takes precedence over what is stored as default in the LSB
932
* header */
933
if (s->sysv_start_priority_from_rcnd >= 0)
934
s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
935
936
u->load_state = UNIT_LOADED;
937
r = 0;
938
939
finish:
940
941
if (f)
942
fclose(f);
943
944
free(short_description);
945
free(long_description);
946
free(chkconfig_description);
947
948
return r;
949
}
950
951
static int service_load_sysv_name(Service *s, const char *name) {
952
char **p;
953
954
assert(s);
955
assert(name);
956
957
/* For SysV services we strip the boot.*, rc.* and *.sh
958
* prefixes/suffixes. */
959
#if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
960
if (endswith(name, ".sh.service"))
961
return -ENOENT;
962
#endif
963
964
#ifdef TARGET_SUSE
965
if (startswith(name, "boot."))
966
return -ENOENT;
967
#endif
968
969
#ifdef TARGET_FRUGALWARE
970
if (startswith(name, "rc."))
971
return -ENOENT;
972
#endif
973
974
STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
975
char *path;
976
int r;
977
978
path = join(*p, "/", name, NULL);
979
if (!path)
980
return -ENOMEM;
981
982
assert(endswith(path, ".service"));
983
path[strlen(path)-8] = 0;
984
985
r = service_load_sysv_path(s, path);
986
987
#if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
988
if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
989
/* Try Debian style *.sh source'able init scripts */
990
strcat(path, ".sh");
991
r = service_load_sysv_path(s, path);
992
}
993
#endif
994
free(path);
995
996
#ifdef TARGET_SUSE
997
if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
998
/* Try SUSE style boot.* init scripts */
999
1000
path = join(*p, "/boot.", name, NULL);
1001
if (!path)
1002
return -ENOMEM;
1003
1004
/* Drop .service suffix */
1005
path[strlen(path)-8] = 0;
1006
r = service_load_sysv_path(s, path);
1007
free(path);
1008
}
1009
#endif
1010
1011
#ifdef TARGET_FRUGALWARE
1012
if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1013
/* Try Frugalware style rc.* init scripts */
1014
1015
path = join(*p, "/rc.", name, NULL);
1016
if (!path)
1017
return -ENOMEM;
1018
1019
/* Drop .service suffix */
1020
path[strlen(path)-8] = 0;
1021
r = service_load_sysv_path(s, path);
1022
free(path);
1023
}
1024
#endif
1025
1026
if (r < 0)
1027
return r;
1028
1029
if ((UNIT(s)->load_state != UNIT_STUB))
1030
break;
1031
}
1032
1033
return 0;
1034
}
1035
1036
static int service_load_sysv(Service *s) {
1037
const char *t;
1038
Iterator i;
1039
int r;
1040
1041
assert(s);
1042
1043
/* Load service data from SysV init scripts, preferably with
1044
* LSB headers ... */
1045
1046
if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1047
return 0;
1048
1049
if ((t = UNIT(s)->id))
1050
if ((r = service_load_sysv_name(s, t)) < 0)
1051
return r;
1052
1053
if (UNIT(s)->load_state == UNIT_STUB)
1054
SET_FOREACH(t, UNIT(s)->names, i) {
1055
if (t == UNIT(s)->id)
1056
continue;
1057
1058
if ((r = service_load_sysv_name(s, t)) < 0)
1059
return r;
1060
1061
if (UNIT(s)->load_state != UNIT_STUB)
1062
break;
1063
}
1064
1065
return 0;
1066
}
1067
#endif
1068
1069
static int fsck_fix_order(Service *s) {
1070
Unit *other;
1071
int r;
1072
1073
assert(s);
1074
1075
if (s->fsck_passno <= 0)
1076
return 0;
1077
1078
/* For each pair of services where both have an fsck priority
1079
* we order things based on it. */
1080
1081
LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
1082
Service *t;
1083
UnitDependency d;
1084
1085
t = SERVICE(other);
1086
1087
if (s == t)
1088
continue;
1089
1090
if (UNIT(t)->load_state != UNIT_LOADED)
1091
continue;
1092
1093
if (t->fsck_passno <= 0)
1094
continue;
1095
1096
if (t->fsck_passno < s->fsck_passno)
1097
d = UNIT_AFTER;
1098
else if (t->fsck_passno > s->fsck_passno)
1099
d = UNIT_BEFORE;
1100
else
1101
continue;
1102
1103
if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
1104
return r;
1105
}
1106
1107
return 0;
1108
}
1109
1110
static int service_verify(Service *s) {
1111
assert(s);
1112
1113
if (UNIT(s)->load_state != UNIT_LOADED)
1114
return 0;
1115
1116
if (!s->exec_command[SERVICE_EXEC_START]) {
1117
log_error("%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1118
return -EINVAL;
1119
}
1120
1121
if (s->type != SERVICE_ONESHOT &&
1122
s->exec_command[SERVICE_EXEC_START]->command_next) {
1123
log_error("%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1124
return -EINVAL;
1125
}
1126
1127
if (s->type == SERVICE_ONESHOT &&
1128
s->exec_command[SERVICE_EXEC_RELOAD]) {
1129
log_error("%s has an ExecReload setting, which is not allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1130
return -EINVAL;
1131
}
1132
1133
if (s->type == SERVICE_DBUS && !s->bus_name) {
1134
log_error("%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1135
return -EINVAL;
1136
}
1137
1138
if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
1139
log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1140
return -EINVAL;
1141
}
1142
1143
return 0;
1144
}
1145
1146
static int service_add_default_dependencies(Service *s) {
1147
int r;
1148
1149
assert(s);
1150
1151
/* Add a number of automatic dependencies useful for the
1152
* majority of services. */
1153
1154
/* First, pull in base system */
1155
if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
1156
1157
if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
1158
return r;
1159
1160
} else if (UNIT(s)->manager->running_as == MANAGER_USER) {
1161
1162
if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
1163
return r;
1164
}
1165
1166
/* Second, activate normal shutdown */
1167
return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
1168
}
1169
1170
static void service_fix_output(Service *s) {
1171
assert(s);
1172
1173
/* If nothing has been explicitly configured, patch default
1174
* output in. If input is socket/tty we avoid this however,
1175
* since in that case we want output to default to the same
1176
* place as we read input from. */
1177
1178
if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1179
s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1180
s->exec_context.std_input == EXEC_INPUT_NULL)
1181
s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1182
1183
if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1184
s->exec_context.std_input == EXEC_INPUT_NULL)
1185
s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1186
}
1187
1188
static int service_load(Unit *u) {
1189
int r;
1190
Service *s = SERVICE(u);
1191
1192
assert(s);
1193
1194
/* Load a .service file */
1195
if ((r = unit_load_fragment(u)) < 0)
1196
return r;
1197
1198
#ifdef HAVE_SYSV_COMPAT
1199
/* Load a classic init script as a fallback, if we couldn't find anything */
1200
if (u->load_state == UNIT_STUB)
1201
if ((r = service_load_sysv(s)) < 0)
1202
return r;
1203
#endif
1204
1205
/* Still nothing found? Then let's give up */
1206
if (u->load_state == UNIT_STUB)
1207
return -ENOENT;
1208
1209
/* We were able to load something, then let's add in the
1210
* dropin directories. */
1211
if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
1212
return r;
1213
1214
/* This is a new unit? Then let's add in some extras */
1215
if (u->load_state == UNIT_LOADED) {
1216
service_fix_output(s);
1217
1218
if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
1219
return r;
1220
1221
if ((r = unit_add_default_cgroups(u)) < 0)
1222
return r;
1223
1224
#ifdef HAVE_SYSV_COMPAT
1225
if ((r = sysv_fix_order(s)) < 0)
1226
return r;
1227
#endif
1228
1229
if ((r = fsck_fix_order(s)) < 0)
1230
return r;
1231
1232
if (s->bus_name)
1233
if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1234
return r;
1235
1236
if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1237
s->notify_access = NOTIFY_MAIN;
1238
1239
if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1240
s->notify_access = NOTIFY_MAIN;
1241
1242
if (s->type == SERVICE_DBUS || s->bus_name)
1243
if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true)) < 0)
1244
return r;
1245
1246
if (UNIT(s)->default_dependencies)
1247
if ((r = service_add_default_dependencies(s)) < 0)
1248
return r;
1249
}
1250
1251
return service_verify(s);
1252
}
1253
1254
static void service_dump(Unit *u, FILE *f, const char *prefix) {
1255
1256
ServiceExecCommand c;
1257
Service *s = SERVICE(u);
1258
const char *prefix2;
1259
char *p2;
1260
1261
assert(s);
1262
1263
p2 = strappend(prefix, "\t");
1264
prefix2 = p2 ? p2 : prefix;
1265
1266
fprintf(f,
1267
"%sService State: %s\n"
1268
"%sResult: %s\n"
1269
"%sReload Result: %s\n"
1270
"%sPermissionsStartOnly: %s\n"
1271
"%sRootDirectoryStartOnly: %s\n"
1272
"%sRemainAfterExit: %s\n"
1273
"%sGuessMainPID: %s\n"
1274
"%sType: %s\n"
1275
"%sRestart: %s\n"
1276
"%sNotifyAccess: %s\n",
1277
prefix, service_state_to_string(s->state),
1278
prefix, service_result_to_string(s->result),
1279
prefix, service_result_to_string(s->reload_result),
1280
prefix, yes_no(s->permissions_start_only),
1281
prefix, yes_no(s->root_directory_start_only),
1282
prefix, yes_no(s->remain_after_exit),
1283
prefix, yes_no(s->guess_main_pid),
1284
prefix, service_type_to_string(s->type),
1285
prefix, service_restart_to_string(s->restart),
1286
prefix, notify_access_to_string(s->notify_access));
1287
1288
if (s->control_pid > 0)
1289
fprintf(f,
1290
"%sControl PID: %lu\n",
1291
prefix, (unsigned long) s->control_pid);
1292
1293
if (s->main_pid > 0)
1294
fprintf(f,
1295
"%sMain PID: %lu\n"
1296
"%sMain PID Known: %s\n"
1297
"%sMain PID Alien: %s\n",
1298
prefix, (unsigned long) s->main_pid,
1299
prefix, yes_no(s->main_pid_known),
1300
prefix, yes_no(s->main_pid_alien));
1301
1302
if (s->pid_file)
1303
fprintf(f,
1304
"%sPIDFile: %s\n",
1305
prefix, s->pid_file);
1306
1307
if (s->bus_name)
1308
fprintf(f,
1309
"%sBusName: %s\n"
1310
"%sBus Name Good: %s\n",
1311
prefix, s->bus_name,
1312
prefix, yes_no(s->bus_name_good));
1313
1314
exec_context_dump(&s->exec_context, f, prefix);
1315
1316
for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1317
1318
if (!s->exec_command[c])
1319
continue;
1320
1321
fprintf(f, "%s-> %s:\n",
1322
prefix, service_exec_command_to_string(c));
1323
1324
exec_command_dump_list(s->exec_command[c], f, prefix2);
1325
}
1326
1327
#ifdef HAVE_SYSV_COMPAT
1328
if (s->sysv_path)
1329
fprintf(f,
1330
"%sSysV Init Script Path: %s\n"
1331
"%sSysV Init Script has LSB Header: %s\n"
1332
"%sSysVEnabled: %s\n",
1333
prefix, s->sysv_path,
1334
prefix, yes_no(s->sysv_has_lsb),
1335
prefix, yes_no(s->sysv_enabled));
1336
1337
if (s->sysv_start_priority >= 0)
1338
fprintf(f,
1339
"%sSysVStartPriority: %i\n",
1340
prefix, s->sysv_start_priority);
1341
1342
if (s->sysv_runlevels)
1343
fprintf(f, "%sSysVRunLevels: %s\n",
1344
prefix, s->sysv_runlevels);
1345
#endif
1346
1347
if (s->fsck_passno > 0)
1348
fprintf(f,
1349
"%sFsckPassNo: %i\n",
1350
prefix, s->fsck_passno);
1351
1352
if (s->status_text)
1353
fprintf(f, "%sStatus Text: %s\n",
1354
prefix, s->status_text);
1355
1356
free(p2);
1357
}
1358
1359
static int service_load_pid_file(Service *s, bool may_warn) {
1360
char *k;
1361
int r;
1362
pid_t pid;
1363
1364
assert(s);
1365
1366
if (!s->pid_file)
1367
return -ENOENT;
1368
1369
if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1370
if (may_warn)
1371
log_info("PID file %s not readable (yet?) after %s.",
1372
s->pid_file, service_state_to_string(s->state));
1373
return r;
1374
}
1375
1376
r = parse_pid(k, &pid);
1377
free(k);
1378
1379
if (r < 0)
1380
return r;
1381
1382
if (kill(pid, 0) < 0 && errno != EPERM) {
1383
if (may_warn)
1384
log_info("PID %lu read from file %s does not exist.",
1385
(unsigned long) pid, s->pid_file);
1386
return -ESRCH;
1387
}
1388
1389
if (s->main_pid_known) {
1390
if (pid == s->main_pid)
1391
return 0;
1392
1393
log_debug("Main PID changing: %lu -> %lu",
1394
(unsigned long) s->main_pid, (unsigned long) pid);
1395
service_unwatch_main_pid(s);
1396
s->main_pid_known = false;
1397
} else
1398
log_debug("Main PID loaded: %lu", (unsigned long) pid);
1399
1400
if ((r = service_set_main_pid(s, pid)) < 0)
1401
return r;
1402
1403
if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1404
/* FIXME: we need to do something here */
1405
return r;
1406
1407
return 0;
1408
}
1409
1410
static int service_search_main_pid(Service *s) {
1411
pid_t pid;
1412
int r;
1413
1414
assert(s);
1415
1416
/* If we know it anyway, don't ever fallback to unreliable
1417
* heuristics */
1418
if (s->main_pid_known)
1419
return 0;
1420
1421
if (!s->guess_main_pid)
1422
return 0;
1423
1424
assert(s->main_pid <= 0);
1425
1426
if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1427
return -ENOENT;
1428
1429
log_debug("Main PID guessed: %lu", (unsigned long) pid);
1430
if ((r = service_set_main_pid(s, pid)) < 0)
1431
return r;
1432
1433
if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1434
/* FIXME: we need to do something here */
1435
return r;
1436
1437
return 0;
1438
}
1439
1440
static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1441
Iterator i;
1442
Unit *u;
1443
1444
assert(s);
1445
1446
/* Notifies all our sockets when we die */
1447
1448
if (s->socket_fd >= 0)
1449
return;
1450
1451
SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1452
if (u->type == UNIT_SOCKET)
1453
socket_notify_service_dead(SOCKET(u), failed_permanent);
1454
1455
return;
1456
}
1457
1458
static void service_set_state(Service *s, ServiceState state) {
1459
ServiceState old_state;
1460
assert(s);
1461
1462
old_state = s->state;
1463
s->state = state;
1464
1465
service_unwatch_pid_file(s);
1466
1467
if (state != SERVICE_START_PRE &&
1468
state != SERVICE_START &&
1469
state != SERVICE_START_POST &&
1470
state != SERVICE_RELOAD &&
1471
state != SERVICE_STOP &&
1472
state != SERVICE_STOP_SIGTERM &&
1473
state != SERVICE_STOP_SIGKILL &&
1474
state != SERVICE_STOP_POST &&
1475
state != SERVICE_FINAL_SIGTERM &&
1476
state != SERVICE_FINAL_SIGKILL &&
1477
state != SERVICE_AUTO_RESTART)
1478
unit_unwatch_timer(UNIT(s), &s->timer_watch);
1479
1480
if (state != SERVICE_START &&
1481
state != SERVICE_START_POST &&
1482
state != SERVICE_RUNNING &&
1483
state != SERVICE_RELOAD &&
1484
state != SERVICE_STOP &&
1485
state != SERVICE_STOP_SIGTERM &&
1486
state != SERVICE_STOP_SIGKILL) {
1487
service_unwatch_main_pid(s);
1488
s->main_command = NULL;
1489
}
1490
1491
if (state != SERVICE_START_PRE &&
1492
state != SERVICE_START &&
1493
state != SERVICE_START_POST &&
1494
state != SERVICE_RELOAD &&
1495
state != SERVICE_STOP &&
1496
state != SERVICE_STOP_SIGTERM &&
1497
state != SERVICE_STOP_SIGKILL &&
1498
state != SERVICE_STOP_POST &&
1499
state != SERVICE_FINAL_SIGTERM &&
1500
state != SERVICE_FINAL_SIGKILL) {
1501
service_unwatch_control_pid(s);
1502
s->control_command = NULL;
1503
s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1504
}
1505
1506
if (state == SERVICE_DEAD ||
1507
state == SERVICE_STOP ||
1508
state == SERVICE_STOP_SIGTERM ||
1509
state == SERVICE_STOP_SIGKILL ||
1510
state == SERVICE_STOP_POST ||
1511
state == SERVICE_FINAL_SIGTERM ||
1512
state == SERVICE_FINAL_SIGKILL ||
1513
state == SERVICE_FAILED ||
1514
state == SERVICE_AUTO_RESTART)
1515
service_notify_sockets_dead(s, false);
1516
1517
if (state != SERVICE_START_PRE &&
1518
state != SERVICE_START &&
1519
state != SERVICE_START_POST &&
1520
state != SERVICE_RUNNING &&
1521
state != SERVICE_RELOAD &&
1522
state != SERVICE_STOP &&
1523
state != SERVICE_STOP_SIGTERM &&
1524
state != SERVICE_STOP_SIGKILL &&
1525
state != SERVICE_STOP_POST &&
1526
state != SERVICE_FINAL_SIGTERM &&
1527
state != SERVICE_FINAL_SIGKILL &&
1528
!(state == SERVICE_DEAD && UNIT(s)->job)) {
1529
service_close_socket_fd(s);
1530
service_connection_unref(s);
1531
}
1532
1533
if (state == SERVICE_STOP)
1534
service_stop_watchdog(s);
1535
1536
/* For the inactive states unit_notify() will trim the cgroup,
1537
* but for exit we have to do that ourselves... */
1538
if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1539
cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1540
1541
if (old_state != state)
1542
log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1543
1544
unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], s->reload_result == SERVICE_SUCCESS);
1545
s->reload_result = SERVICE_SUCCESS;
1546
}
1547
1548
static int service_coldplug(Unit *u) {
1549
Service *s = SERVICE(u);
1550
int r;
1551
1552
assert(s);
1553
assert(s->state == SERVICE_DEAD);
1554
1555
if (s->deserialized_state != s->state) {
1556
1557
if (s->deserialized_state == SERVICE_START_PRE ||
1558
s->deserialized_state == SERVICE_START ||
1559
s->deserialized_state == SERVICE_START_POST ||
1560
s->deserialized_state == SERVICE_RELOAD ||
1561
s->deserialized_state == SERVICE_STOP ||
1562
s->deserialized_state == SERVICE_STOP_SIGTERM ||
1563
s->deserialized_state == SERVICE_STOP_SIGKILL ||
1564
s->deserialized_state == SERVICE_STOP_POST ||
1565
s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1566
s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1567
s->deserialized_state == SERVICE_AUTO_RESTART) {
1568
1569
if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_usec > 0) {
1570
usec_t k;
1571
1572
k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_usec;
1573
1574
if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1575
return r;
1576
}
1577
}
1578
1579
if ((s->deserialized_state == SERVICE_START &&
1580
(s->type == SERVICE_FORKING ||
1581
s->type == SERVICE_DBUS ||
1582
s->type == SERVICE_ONESHOT ||
1583
s->type == SERVICE_NOTIFY)) ||
1584
s->deserialized_state == SERVICE_START_POST ||
1585
s->deserialized_state == SERVICE_RUNNING ||
1586
s->deserialized_state == SERVICE_RELOAD ||
1587
s->deserialized_state == SERVICE_STOP ||
1588
s->deserialized_state == SERVICE_STOP_SIGTERM ||
1589
s->deserialized_state == SERVICE_STOP_SIGKILL)
1590
if (s->main_pid > 0)
1591
if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1592
return r;
1593
1594
if (s->deserialized_state == SERVICE_START_PRE ||
1595
s->deserialized_state == SERVICE_START ||
1596
s->deserialized_state == SERVICE_START_POST ||
1597
s->deserialized_state == SERVICE_RELOAD ||
1598
s->deserialized_state == SERVICE_STOP ||
1599
s->deserialized_state == SERVICE_STOP_SIGTERM ||
1600
s->deserialized_state == SERVICE_STOP_SIGKILL ||
1601
s->deserialized_state == SERVICE_STOP_POST ||
1602
s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1603
s->deserialized_state == SERVICE_FINAL_SIGKILL)
1604
if (s->control_pid > 0)
1605
if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1606
return r;
1607
1608
if (s->deserialized_state == SERVICE_START_POST ||
1609
s->deserialized_state == SERVICE_RUNNING)
1610
service_handle_watchdog(s);
1611
1612
service_set_state(s, s->deserialized_state);
1613
}
1614
return 0;
1615
}
1616
1617
static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1618
Iterator i;
1619
int r;
1620
int *rfds = NULL;
1621
unsigned rn_fds = 0;
1622
Unit *u;
1623
1624
assert(s);
1625
assert(fds);
1626
assert(n_fds);
1627
1628
if (s->socket_fd >= 0)
1629
return 0;
1630
1631
SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1632
int *cfds;
1633
unsigned cn_fds;
1634
Socket *sock;
1635
1636
if (u->type != UNIT_SOCKET)
1637
continue;
1638
1639
sock = SOCKET(u);
1640
1641
if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1642
goto fail;
1643
1644
if (!cfds)
1645
continue;
1646
1647
if (!rfds) {
1648
rfds = cfds;
1649
rn_fds = cn_fds;
1650
} else {
1651
int *t;
1652
1653
if (!(t = new(int, rn_fds+cn_fds))) {
1654
free(cfds);
1655
r = -ENOMEM;
1656
goto fail;
1657
}
1658
1659
memcpy(t, rfds, rn_fds * sizeof(int));
1660
memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1661
free(rfds);
1662
free(cfds);
1663
1664
rfds = t;
1665
rn_fds = rn_fds+cn_fds;
1666
}
1667
}
1668
1669
*fds = rfds;
1670
*n_fds = rn_fds;
1671
1672
return 0;
1673
1674
fail:
1675
free(rfds);
1676
1677
return r;
1678
}
1679
1680
static int service_spawn(
1681
Service *s,
1682
ExecCommand *c,
1683
bool timeout,
1684
bool pass_fds,
1685
bool apply_permissions,
1686
bool apply_chroot,
1687
bool apply_tty_stdin,
1688
bool set_notify_socket,
1689
pid_t *_pid) {
1690
1691
pid_t pid;
1692
int r;
1693
int *fds = NULL, *fdsbuf = NULL;
1694
unsigned n_fds = 0, n_env = 0;
1695
char **argv = NULL, **final_env = NULL, **our_env = NULL;
1696
1697
assert(s);
1698
assert(c);
1699
assert(_pid);
1700
1701
if (pass_fds ||
1702
s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1703
s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1704
s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1705
1706
if (s->socket_fd >= 0) {
1707
fds = &s->socket_fd;
1708
n_fds = 1;
1709
} else {
1710
if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1711
goto fail;
1712
1713
fds = fdsbuf;
1714
}
1715
}
1716
1717
if (timeout && s->timeout_usec) {
1718
if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1719
goto fail;
1720
} else
1721
unit_unwatch_timer(UNIT(s), &s->timer_watch);
1722
1723
if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1724
r = -ENOMEM;
1725
goto fail;
1726
}
1727
1728
if (!(our_env = new0(char*, 4))) {
1729
r = -ENOMEM;
1730
goto fail;
1731
}
1732
1733
if (set_notify_socket)
1734
if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1735
r = -ENOMEM;
1736
goto fail;
1737
}
1738
1739
if (s->main_pid > 0)
1740
if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1741
r = -ENOMEM;
1742
goto fail;
1743
}
1744
1745
if (s->watchdog_usec > 0)
1746
if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1747
r = -ENOMEM;
1748
goto fail;
1749
}
1750
1751
if (!(final_env = strv_env_merge(2,
1752
UNIT(s)->manager->environment,
1753
our_env,
1754
NULL))) {
1755
r = -ENOMEM;
1756
goto fail;
1757
}
1758
1759
r = exec_spawn(c,
1760
argv,
1761
&s->exec_context,
1762
fds, n_fds,
1763
final_env,
1764
apply_permissions,
1765
apply_chroot,
1766
apply_tty_stdin,
1767
UNIT(s)->manager->confirm_spawn,
1768
UNIT(s)->cgroup_bondings,
1769
UNIT(s)->cgroup_attributes,
1770
&pid);
1771
1772
if (r < 0)
1773
goto fail;
1774
1775
1776
if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1777
/* FIXME: we need to do something here */
1778
goto fail;
1779
1780
free(fdsbuf);
1781
strv_free(argv);
1782
strv_free(our_env);
1783
strv_free(final_env);
1784
1785
*_pid = pid;
1786
1787
return 0;
1788
1789
fail:
1790
free(fdsbuf);
1791
strv_free(argv);
1792
strv_free(our_env);
1793
strv_free(final_env);
1794
1795
if (timeout)
1796
unit_unwatch_timer(UNIT(s), &s->timer_watch);
1797
1798
return r;
1799
}
1800
1801
static int main_pid_good(Service *s) {
1802
assert(s);
1803
1804
/* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1805
* don't know */
1806
1807
/* If we know the pid file, then lets just check if it is
1808
* still valid */
1809
if (s->main_pid_known) {
1810
1811
/* If it's an alien child let's check if it is still
1812
* alive ... */
1813
if (s->main_pid_alien)
1814
return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1815
1816
/* .. otherwise assume we'll get a SIGCHLD for it,
1817
* which we really should wait for to collect exit
1818
* status and code */
1819
return s->main_pid > 0;
1820
}
1821
1822
/* We don't know the pid */
1823
return -EAGAIN;
1824
}
1825
1826
static int control_pid_good(Service *s) {
1827
assert(s);
1828
1829
return s->control_pid > 0;
1830
}
1831
1832
static int cgroup_good(Service *s) {
1833
int r;
1834
1835
assert(s);
1836
1837
if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1838
return r;
1839
1840
return !r;
1841
}
1842
1843
static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1844
int r;
1845
assert(s);
1846
1847
if (f != SERVICE_SUCCESS)
1848
s->result = f;
1849
1850
if (allow_restart &&
1851
!s->forbid_restart &&
1852
(s->restart == SERVICE_RESTART_ALWAYS ||
1853
(s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1854
(s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1855
(s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1856
s->result == SERVICE_FAILURE_CORE_DUMP)))) {
1857
1858
r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1859
if (r < 0)
1860
goto fail;
1861
1862
service_set_state(s, SERVICE_AUTO_RESTART);
1863
} else
1864
service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1865
1866
s->forbid_restart = false;
1867
1868
return;
1869
1870
fail:
1871
log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1872
service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1873
}
1874
1875
static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1876
1877
static void service_enter_stop_post(Service *s, ServiceResult f) {
1878
int r;
1879
assert(s);
1880
1881
if (f != SERVICE_SUCCESS)
1882
s->result = f;
1883
1884
service_unwatch_control_pid(s);
1885
1886
if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1887
s->control_command_id = SERVICE_EXEC_STOP_POST;
1888
1889
if ((r = service_spawn(s,
1890
s->control_command,
1891
true,
1892
false,
1893
!s->permissions_start_only,
1894
!s->root_directory_start_only,
1895
true,
1896
false,
1897
&s->control_pid)) < 0)
1898
goto fail;
1899
1900
1901
service_set_state(s, SERVICE_STOP_POST);
1902
} else
1903
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1904
1905
return;
1906
1907
fail:
1908
log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1909
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1910
}
1911
1912
static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1913
int r;
1914
Set *pid_set = NULL;
1915
bool wait_for_exit = false;
1916
1917
assert(s);
1918
1919
if (f != SERVICE_SUCCESS)
1920
s->result = f;
1921
1922
if (s->exec_context.kill_mode != KILL_NONE) {
1923
int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1924
1925
if (s->main_pid > 0) {
1926
if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1927
log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1928
else
1929
wait_for_exit = !s->main_pid_alien;
1930
}
1931
1932
if (s->control_pid > 0) {
1933
if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1934
log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1935
else
1936
wait_for_exit = true;
1937
}
1938
1939
if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1940
1941
if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1942
r = -ENOMEM;
1943
goto fail;
1944
}
1945
1946
/* Exclude the main/control pids from being killed via the cgroup */
1947
if (s->main_pid > 0)
1948
if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
1949
goto fail;
1950
1951
if (s->control_pid > 0)
1952
if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1953
goto fail;
1954
1955
if ((r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, pid_set)) < 0) {
1956
if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1957
log_warning("Failed to kill control group: %s", strerror(-r));
1958
} else if (r > 0)
1959
wait_for_exit = true;
1960
1961
set_free(pid_set);
1962
pid_set = NULL;
1963
}
1964
}
1965
1966
if (wait_for_exit) {
1967
if (s->timeout_usec > 0)
1968
if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1969
goto fail;
1970
1971
service_set_state(s, state);
1972
} else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1973
service_enter_stop_post(s, SERVICE_SUCCESS);
1974
else
1975
service_enter_dead(s, SERVICE_SUCCESS, true);
1976
1977
return;
1978
1979
fail:
1980
log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1981
1982
if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1983
service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1984
else
1985
service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1986
1987
if (pid_set)
1988
set_free(pid_set);
1989
}
1990
1991
static void service_enter_stop(Service *s, ServiceResult f) {
1992
int r;
1993
1994
assert(s);
1995
1996
if (f != SERVICE_SUCCESS)
1997
s->result = f;
1998
1999
service_unwatch_control_pid(s);
2000
2001
if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2002
s->control_command_id = SERVICE_EXEC_STOP;
2003
2004
if ((r = service_spawn(s,
2005
s->control_command,
2006
true,
2007
false,
2008
!s->permissions_start_only,
2009
!s->root_directory_start_only,
2010
false,
2011
false,
2012
&s->control_pid)) < 0)
2013
goto fail;
2014
2015
service_set_state(s, SERVICE_STOP);
2016
} else
2017
service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2018
2019
return;
2020
2021
fail:
2022
log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2023
service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2024
}
2025
2026
static void service_enter_running(Service *s, ServiceResult f) {
2027
int main_pid_ok, cgroup_ok;
2028
assert(s);
2029
2030
if (f != SERVICE_SUCCESS)
2031
s->result = f;
2032
2033
main_pid_ok = main_pid_good(s);
2034
cgroup_ok = cgroup_good(s);
2035
2036
if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2037
(s->bus_name_good || s->type != SERVICE_DBUS))
2038
service_set_state(s, SERVICE_RUNNING);
2039
else if (s->remain_after_exit)
2040
service_set_state(s, SERVICE_EXITED);
2041
else
2042
service_enter_stop(s, SERVICE_SUCCESS);
2043
}
2044
2045
static void service_enter_start_post(Service *s) {
2046
int r;
2047
assert(s);
2048
2049
service_unwatch_control_pid(s);
2050
2051
if (s->watchdog_usec > 0)
2052
service_reset_watchdog(s);
2053
2054
if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2055
s->control_command_id = SERVICE_EXEC_START_POST;
2056
2057
if ((r = service_spawn(s,
2058
s->control_command,
2059
true,
2060
false,
2061
!s->permissions_start_only,
2062
!s->root_directory_start_only,
2063
false,
2064
false,
2065
&s->control_pid)) < 0)
2066
goto fail;
2067
2068
service_set_state(s, SERVICE_START_POST);
2069
} else
2070
service_enter_running(s, SERVICE_SUCCESS);
2071
2072
return;
2073
2074
fail:
2075
log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2076
service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2077
}
2078
2079
static void service_enter_start(Service *s) {
2080
pid_t pid;
2081
int r;
2082
ExecCommand *c;
2083
2084
assert(s);
2085
2086
assert(s->exec_command[SERVICE_EXEC_START]);
2087
assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2088
2089
if (s->type == SERVICE_FORKING)
2090
service_unwatch_control_pid(s);
2091
else
2092
service_unwatch_main_pid(s);
2093
2094
/* We want to ensure that nobody leaks processes from
2095
* START_PRE here, so let's go on a killing spree, People
2096
* should not spawn long running processes from START_PRE. */
2097
cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, NULL);
2098
2099
if (s->type == SERVICE_FORKING) {
2100
s->control_command_id = SERVICE_EXEC_START;
2101
c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2102
2103
s->main_command = NULL;
2104
} else {
2105
s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2106
s->control_command = NULL;
2107
2108
c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2109
}
2110
2111
if ((r = service_spawn(s,
2112
c,
2113
s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY,
2114
true,
2115
true,
2116
true,
2117
true,
2118
s->notify_access != NOTIFY_NONE,
2119
&pid)) < 0)
2120
goto fail;
2121
2122
if (s->type == SERVICE_SIMPLE) {
2123
/* For simple services we immediately start
2124
* the START_POST binaries. */
2125
2126
service_set_main_pid(s, pid);
2127
service_enter_start_post(s);
2128
2129
} else if (s->type == SERVICE_FORKING) {
2130
2131
/* For forking services we wait until the start
2132
* process exited. */
2133
2134
s->control_pid = pid;
2135
service_set_state(s, SERVICE_START);
2136
2137
} else if (s->type == SERVICE_ONESHOT ||
2138
s->type == SERVICE_DBUS ||
2139
s->type == SERVICE_NOTIFY) {
2140
2141
/* For oneshot services we wait until the start
2142
* process exited, too, but it is our main process. */
2143
2144
/* For D-Bus services we know the main pid right away,
2145
* but wait for the bus name to appear on the
2146
* bus. Notify services are similar. */
2147
2148
service_set_main_pid(s, pid);
2149
service_set_state(s, SERVICE_START);
2150
} else
2151
assert_not_reached("Unknown service type");
2152
2153
return;
2154
2155
fail:
2156
log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2157
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2158
}
2159
2160
static void service_enter_start_pre(Service *s) {
2161
int r;
2162
2163
assert(s);
2164
2165
service_unwatch_control_pid(s);
2166
2167
if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2168
2169
/* Before we start anything, let's clear up what might
2170
* be left from previous runs. */
2171
cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, NULL);
2172
2173
s->control_command_id = SERVICE_EXEC_START_PRE;
2174
2175
if ((r = service_spawn(s,
2176
s->control_command,
2177
true,
2178
false,
2179
!s->permissions_start_only,
2180
!s->root_directory_start_only,
2181
true,
2182
false,
2183
&s->control_pid)) < 0)
2184
goto fail;
2185
2186
service_set_state(s, SERVICE_START_PRE);
2187
} else
2188
service_enter_start(s);
2189
2190
return;
2191
2192
fail:
2193
log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2194
service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2195
}
2196
2197
static void service_enter_restart(Service *s) {
2198
int r;
2199
DBusError error;
2200
2201
assert(s);
2202
dbus_error_init(&error);
2203
2204
if (UNIT(s)->job) {
2205
log_info("Job pending for unit, delaying automatic restart.");
2206
2207
if ((r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch)) < 0)
2208
goto fail;
2209
}
2210
2211
service_enter_dead(s, SERVICE_SUCCESS, false);
2212
2213
if ((r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(s), JOB_FAIL, false, &error, NULL)) < 0)
2214
goto fail;
2215
2216
log_debug("%s scheduled restart job.", UNIT(s)->id);
2217
return;
2218
2219
fail:
2220
log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2221
service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2222
2223
dbus_error_free(&error);
2224
}
2225
2226
static void service_enter_reload(Service *s) {
2227
int r;
2228
2229
assert(s);
2230
2231
service_unwatch_control_pid(s);
2232
2233
if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2234
s->control_command_id = SERVICE_EXEC_RELOAD;
2235
2236
if ((r = service_spawn(s,
2237
s->control_command,
2238
true,
2239
false,
2240
!s->permissions_start_only,
2241
!s->root_directory_start_only,
2242
false,
2243
false,
2244
&s->control_pid)) < 0)
2245
goto fail;
2246
2247
service_set_state(s, SERVICE_RELOAD);
2248
} else
2249
service_enter_running(s, SERVICE_SUCCESS);
2250
2251
return;
2252
2253
fail:
2254
log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2255
s->reload_result = SERVICE_FAILURE_RESOURCES;
2256
service_enter_running(s, SERVICE_SUCCESS);
2257
}
2258
2259
static void service_run_next_control(Service *s) {
2260
int r;
2261
2262
assert(s);
2263
assert(s->control_command);
2264
assert(s->control_command->command_next);
2265
2266
assert(s->control_command_id != SERVICE_EXEC_START);
2267
2268
s->control_command = s->control_command->command_next;
2269
service_unwatch_control_pid(s);
2270
2271
if ((r = service_spawn(s,
2272
s->control_command,
2273
true,
2274
false,
2275
!s->permissions_start_only,
2276
!s->root_directory_start_only,
2277
s->control_command_id == SERVICE_EXEC_START_PRE ||
2278
s->control_command_id == SERVICE_EXEC_STOP_POST,
2279
false,
2280
&s->control_pid)) < 0)
2281
goto fail;
2282
2283
return;
2284
2285
fail:
2286
log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2287
2288
if (s->state == SERVICE_START_PRE)
2289
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2290
else if (s->state == SERVICE_STOP)
2291
service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2292
else if (s->state == SERVICE_STOP_POST)
2293
service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2294
else if (s->state == SERVICE_RELOAD) {
2295
s->reload_result = SERVICE_FAILURE_RESOURCES;
2296
service_enter_running(s, SERVICE_SUCCESS);
2297
} else
2298
service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2299
}
2300
2301
static void service_run_next_main(Service *s) {
2302
pid_t pid;
2303
int r;
2304
2305
assert(s);
2306
assert(s->main_command);
2307
assert(s->main_command->command_next);
2308
assert(s->type == SERVICE_ONESHOT);
2309
2310
s->main_command = s->main_command->command_next;
2311
service_unwatch_main_pid(s);
2312
2313
if ((r = service_spawn(s,
2314
s->main_command,
2315
false,
2316
true,
2317
true,
2318
true,
2319
true,
2320
s->notify_access != NOTIFY_NONE,
2321
&pid)) < 0)
2322
goto fail;
2323
2324
service_set_main_pid(s, pid);
2325
2326
return;
2327
2328
fail:
2329
log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2330
service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2331
}
2332
2333
static int service_start_limit_test(Service *s) {
2334
assert(s);
2335
2336
if (ratelimit_test(&s->start_limit))
2337
return 0;
2338
2339
switch (s->start_limit_action) {
2340
2341
case SERVICE_START_LIMIT_NONE:
2342
log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2343
break;
2344
2345
case SERVICE_START_LIMIT_REBOOT: {
2346
DBusError error;
2347
int r;
2348
2349
dbus_error_init(&error);
2350
2351
log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2352
2353
r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2354
if (r < 0) {
2355
log_error("Failed to reboot: %s.", bus_error(&error, r));
2356
dbus_error_free(&error);
2357
}
2358
2359
break;
2360
}
2361
2362
case SERVICE_START_LIMIT_REBOOT_FORCE:
2363
log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2364
UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2365
break;
2366
2367
case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2368
log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2369
reboot(RB_AUTOBOOT);
2370
break;
2371
2372
default:
2373
log_error("start limit action=%i", s->start_limit_action);
2374
assert_not_reached("Unknown StartLimitAction.");
2375
}
2376
2377
return -ECANCELED;
2378
}
2379
2380
static int service_start(Unit *u) {
2381
Service *s = SERVICE(u);
2382
int r;
2383
2384
assert(s);
2385
2386
/* We cannot fulfill this request right now, try again later
2387
* please! */
2388
if (s->state == SERVICE_STOP ||
2389
s->state == SERVICE_STOP_SIGTERM ||
2390
s->state == SERVICE_STOP_SIGKILL ||
2391
s->state == SERVICE_STOP_POST ||
2392
s->state == SERVICE_FINAL_SIGTERM ||
2393
s->state == SERVICE_FINAL_SIGKILL)
2394
return -EAGAIN;
2395
2396
/* Already on it! */
2397
if (s->state == SERVICE_START_PRE ||
2398
s->state == SERVICE_START ||
2399
s->state == SERVICE_START_POST)
2400
return 0;
2401
2402
assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED || s->state == SERVICE_AUTO_RESTART);
2403
2404
/* Make sure we don't enter a busy loop of some kind. */
2405
r = service_start_limit_test(s);
2406
if (r < 0) {
2407
service_notify_sockets_dead(s, true);
2408
return r;
2409
}
2410
2411
s->result = SERVICE_SUCCESS;
2412
s->reload_result = SERVICE_SUCCESS;
2413
s->main_pid_known = false;
2414
s->main_pid_alien = false;
2415
s->forbid_restart = false;
2416
2417
service_enter_start_pre(s);
2418
return 0;
2419
}
2420
2421
static int service_stop(Unit *u) {
2422
Service *s = SERVICE(u);
2423
2424
assert(s);
2425
2426
/* This is a user request, so don't do restarts on this
2427
* shutdown. */
2428
s->forbid_restart = true;
2429
2430
/* Already on it */
2431
if (s->state == SERVICE_STOP ||
2432
s->state == SERVICE_STOP_SIGTERM ||
2433
s->state == SERVICE_STOP_SIGKILL ||
2434
s->state == SERVICE_STOP_POST ||
2435
s->state == SERVICE_FINAL_SIGTERM ||
2436
s->state == SERVICE_FINAL_SIGKILL)
2437
return 0;
2438
2439
/* Don't allow a restart */
2440
if (s->state == SERVICE_AUTO_RESTART) {
2441
service_set_state(s, SERVICE_DEAD);
2442
return 0;
2443
}
2444
2445
/* If there's already something running we go directly into
2446
* kill mode. */
2447
if (s->state == SERVICE_START_PRE ||
2448
s->state == SERVICE_START ||
2449
s->state == SERVICE_START_POST ||
2450
s->state == SERVICE_RELOAD) {
2451
service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2452
return 0;
2453
}
2454
2455
assert(s->state == SERVICE_RUNNING ||
2456
s->state == SERVICE_EXITED);
2457
2458
service_enter_stop(s, SERVICE_SUCCESS);
2459
return 0;
2460
}
2461
2462
static int service_reload(Unit *u) {
2463
Service *s = SERVICE(u);
2464
2465
assert(s);
2466
2467
assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2468
2469
service_enter_reload(s);
2470
return 0;
2471
}
2472
2473
static bool service_can_reload(Unit *u) {
2474
Service *s = SERVICE(u);
2475
2476
assert(s);
2477
2478
return !!s->exec_command[SERVICE_EXEC_RELOAD];
2479
}
2480
2481
static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2482
Service *s = SERVICE(u);
2483
2484
assert(u);
2485
assert(f);
2486
assert(fds);
2487
2488
unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2489
unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2490
unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2491
2492
if (s->control_pid > 0)
2493
unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2494
2495
if (s->main_pid_known && s->main_pid > 0)
2496
unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2497
2498
unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2499
2500
if (s->status_text)
2501
unit_serialize_item(u, f, "status-text", s->status_text);
2502
2503
/* FIXME: There's a minor uncleanliness here: if there are
2504
* multiple commands attached here, we will start from the
2505
* first one again */
2506
if (s->control_command_id >= 0)
2507
unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2508
2509
if (s->socket_fd >= 0) {
2510
int copy;
2511
2512
if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2513
return copy;
2514
2515
unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2516
}
2517
2518
if (s->main_exec_status.pid > 0) {
2519
unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2520
dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2521
dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2522
2523
if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2524
unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2525
unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2526
}
2527
}
2528
if (dual_timestamp_is_set(&s->watchdog_timestamp))
2529
dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2530
2531
return 0;
2532
}
2533
2534
static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2535
Service *s = SERVICE(u);
2536
2537
assert(u);
2538
assert(key);
2539
assert(value);
2540
assert(fds);
2541
2542
if (streq(key, "state")) {
2543
ServiceState state;
2544
2545
if ((state = service_state_from_string(value)) < 0)
2546
log_debug("Failed to parse state value %s", value);
2547
else
2548
s->deserialized_state = state;
2549
} else if (streq(key, "result")) {
2550
ServiceResult f;
2551
2552
f = service_result_from_string(value);
2553
if (f < 0)
2554
log_debug("Failed to parse result value %s", value);
2555
else if (f != SERVICE_SUCCESS)
2556
s->result = f;
2557
2558
} else if (streq(key, "reload-result")) {
2559
ServiceResult f;
2560
2561
f = service_result_from_string(value);
2562
if (f < 0)
2563
log_debug("Failed to parse reload result value %s", value);
2564
else if (f != SERVICE_SUCCESS)
2565
s->reload_result = f;
2566
2567
} else if (streq(key, "control-pid")) {
2568
pid_t pid;
2569
2570
if (parse_pid(value, &pid) < 0)
2571
log_debug("Failed to parse control-pid value %s", value);
2572
else
2573
s->control_pid = pid;
2574
} else if (streq(key, "main-pid")) {
2575
pid_t pid;
2576
2577
if (parse_pid(value, &pid) < 0)
2578
log_debug("Failed to parse main-pid value %s", value);
2579
else
2580
service_set_main_pid(s, (pid_t) pid);
2581
} else if (streq(key, "main-pid-known")) {
2582
int b;
2583
2584
if ((b = parse_boolean(value)) < 0)
2585
log_debug("Failed to parse main-pid-known value %s", value);
2586
else
2587
s->main_pid_known = b;
2588
} else if (streq(key, "status-text")) {
2589
char *t;
2590
2591
if ((t = strdup(value))) {
2592
free(s->status_text);
2593
s->status_text = t;
2594
}
2595
2596
} else if (streq(key, "control-command")) {
2597
ServiceExecCommand id;
2598
2599
if ((id = service_exec_command_from_string(value)) < 0)
2600
log_debug("Failed to parse exec-command value %s", value);
2601
else {
2602
s->control_command_id = id;
2603
s->control_command = s->exec_command[id];
2604
}
2605
} else if (streq(key, "socket-fd")) {
2606
int fd;
2607
2608
if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2609
log_debug("Failed to parse socket-fd value %s", value);
2610
else {
2611
2612
if (s->socket_fd >= 0)
2613
close_nointr_nofail(s->socket_fd);
2614
s->socket_fd = fdset_remove(fds, fd);
2615
}
2616
} else if (streq(key, "main-exec-status-pid")) {
2617
pid_t pid;
2618
2619
if (parse_pid(value, &pid) < 0)
2620
log_debug("Failed to parse main-exec-status-pid value %s", value);
2621
else
2622
s->main_exec_status.pid = pid;
2623
} else if (streq(key, "main-exec-status-code")) {
2624
int i;
2625
2626
if (safe_atoi(value, &i) < 0)
2627
log_debug("Failed to parse main-exec-status-code value %s", value);
2628
else
2629
s->main_exec_status.code = i;
2630
} else if (streq(key, "main-exec-status-status")) {
2631
int i;
2632
2633
if (safe_atoi(value, &i) < 0)
2634
log_debug("Failed to parse main-exec-status-status value %s", value);
2635
else
2636
s->main_exec_status.status = i;
2637
} else if (streq(key, "main-exec-status-start"))
2638
dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2639
else if (streq(key, "main-exec-status-exit"))
2640
dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2641
else if (streq(key, "watchdog-timestamp"))
2642
dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2643
else
2644
log_debug("Unknown serialization key '%s'", key);
2645
2646
return 0;
2647
}
2648
2649
static UnitActiveState service_active_state(Unit *u) {
2650
assert(u);
2651
2652
return state_translation_table[SERVICE(u)->state];
2653
}
2654
2655
static const char *service_sub_state_to_string(Unit *u) {
2656
assert(u);
2657
2658
return service_state_to_string(SERVICE(u)->state);
2659
}
2660
2661
static bool service_check_gc(Unit *u) {
2662
Service *s = SERVICE(u);
2663
2664
assert(s);
2665
2666
/* Never clean up services that still have a process around,
2667
* even if the service is formally dead. */
2668
if (cgroup_good(s) > 0 ||
2669
main_pid_good(s) > 0 ||
2670
control_pid_good(s) > 0)
2671
return true;
2672
2673
#ifdef HAVE_SYSV_COMPAT
2674
if (s->sysv_path)
2675
return true;
2676
#endif
2677
2678
return false;
2679
}
2680
2681
static bool service_check_snapshot(Unit *u) {
2682
Service *s = SERVICE(u);
2683
2684
assert(s);
2685
2686
return !s->got_socket_fd;
2687
}
2688
2689
static int service_retry_pid_file(Service *s) {
2690
int r;
2691
2692
assert(s->pid_file);
2693
assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2694
2695
r = service_load_pid_file(s, false);
2696
if (r < 0)
2697
return r;
2698
2699
service_unwatch_pid_file(s);
2700
2701
service_enter_running(s, SERVICE_SUCCESS);
2702
return 0;
2703
}
2704
2705
static int service_watch_pid_file(Service *s) {
2706
int r;
2707
2708
log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2709
r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2710
if (r < 0)
2711
goto fail;
2712
2713
/* the pidfile might have appeared just before we set the watch */
2714
service_retry_pid_file(s);
2715
2716
return 0;
2717
fail:
2718
log_error("Failed to set a watch for %s's PID file %s: %s",
2719
UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2720
service_unwatch_pid_file(s);
2721
return r;
2722
}
2723
2724
static int service_demand_pid_file(Service *s) {
2725
PathSpec *ps;
2726
2727
assert(s->pid_file);
2728
assert(!s->pid_file_pathspec);
2729
2730
ps = new0(PathSpec, 1);
2731
if (!ps)
2732
return -ENOMEM;
2733
2734
ps->path = strdup(s->pid_file);
2735
if (!ps->path) {
2736
free(ps);
2737
return -ENOMEM;
2738
}
2739
2740
path_kill_slashes(ps->path);
2741
2742
/* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2743
* keep their PID file open all the time. */
2744
ps->type = PATH_MODIFIED;
2745
ps->inotify_fd = -1;
2746
2747
s->pid_file_pathspec = ps;
2748
2749
return service_watch_pid_file(s);
2750
}
2751
2752
static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2753
Service *s = SERVICE(u);
2754
2755
assert(s);
2756
assert(fd >= 0);
2757
assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2758
assert(s->pid_file_pathspec);
2759
assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2760
2761
log_debug("inotify event for %s", u->id);
2762
2763
if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2764
goto fail;
2765
2766
if (service_retry_pid_file(s) == 0)
2767
return;
2768
2769
if (service_watch_pid_file(s) < 0)
2770
goto fail;
2771
2772
return;
2773
fail:
2774
service_unwatch_pid_file(s);
2775
service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2776
}
2777
2778
static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2779
Service *s = SERVICE(u);
2780
ServiceResult f;
2781
2782
assert(s);
2783
assert(pid >= 0);
2784
2785
if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2786
f = SERVICE_SUCCESS;
2787
else if (code == CLD_EXITED)
2788
f = SERVICE_FAILURE_EXIT_CODE;
2789
else if (code == CLD_KILLED)
2790
f = SERVICE_FAILURE_SIGNAL;
2791
else if (code == CLD_DUMPED)
2792
f = SERVICE_FAILURE_CORE_DUMP;
2793
else
2794
assert_not_reached("Unknown code");
2795
2796
if (s->main_pid == pid) {
2797
/* Forking services may occasionally move to a new PID.
2798
* As long as they update the PID file before exiting the old
2799
* PID, they're fine. */
2800
if (service_load_pid_file(s, false) == 0)
2801
return;
2802
2803
s->main_pid = 0;
2804
exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2805
2806
/* If this is not a forking service than the main
2807
* process got started and hence we copy the exit
2808
* status so that it is recorded both as main and as
2809
* control process exit status */
2810
if (s->main_command) {
2811
s->main_command->exec_status = s->main_exec_status;
2812
2813
if (s->main_command->ignore)
2814
f = SERVICE_SUCCESS;
2815
}
2816
2817
log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2818
"%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2819
2820
if (f != SERVICE_SUCCESS)
2821
s->result = f;
2822
2823
if (s->main_command &&
2824
s->main_command->command_next &&
2825
f == SERVICE_SUCCESS) {
2826
2827
/* There is another command to *
2828
* execute, so let's do that. */
2829
2830
log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2831
service_run_next_main(s);
2832
2833
} else {
2834
2835
/* The service exited, so the service is officially
2836
* gone. */
2837
s->main_command = NULL;
2838
2839
switch (s->state) {
2840
2841
case SERVICE_START_POST:
2842
case SERVICE_RELOAD:
2843
case SERVICE_STOP:
2844
/* Need to wait until the operation is
2845
* done */
2846
break;
2847
2848
case SERVICE_START:
2849
if (s->type == SERVICE_ONESHOT) {
2850
/* This was our main goal, so let's go on */
2851
if (f == SERVICE_SUCCESS)
2852
service_enter_start_post(s);
2853
else
2854
service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2855
break;
2856
} else {
2857
assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2858
2859
/* Fall through */
2860
}
2861
2862
case SERVICE_RUNNING:
2863
service_enter_running(s, f);
2864
break;
2865
2866
case SERVICE_STOP_SIGTERM:
2867
case SERVICE_STOP_SIGKILL:
2868
2869
if (!control_pid_good(s))
2870
service_enter_stop_post(s, f);
2871
2872
/* If there is still a control process, wait for that first */
2873
break;
2874
2875
default:
2876
assert_not_reached("Uh, main process died at wrong time.");
2877
}
2878
}
2879
2880
} else if (s->control_pid == pid) {
2881
2882
s->control_pid = 0;
2883
2884
if (s->control_command) {
2885
exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2886
2887
if (s->control_command->ignore)
2888
f = SERVICE_SUCCESS;
2889
}
2890
2891
log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2892
"%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2893
2894
if (f != SERVICE_SUCCESS)
2895
s->result = f;
2896
2897
if (s->control_command &&
2898
s->control_command->command_next &&
2899
f == SERVICE_SUCCESS) {
2900
2901
/* There is another command to *
2902
* execute, so let's do that. */
2903
2904
log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2905
service_run_next_control(s);
2906
2907
} else {
2908
/* No further commands for this step, so let's
2909
* figure out what to do next */
2910
2911
s->control_command = NULL;
2912
s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2913
2914
log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2915
2916
switch (s->state) {
2917
2918
case SERVICE_START_PRE:
2919
if (f == SERVICE_SUCCESS)
2920
service_enter_start(s);
2921
else
2922
service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2923
break;
2924
2925
case SERVICE_START:
2926
assert(s->type == SERVICE_FORKING);
2927
2928
if (f != SERVICE_SUCCESS) {
2929
service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2930
break;
2931
}
2932
2933
if (s->pid_file) {
2934
bool has_start_post;
2935
int r;
2936
2937
/* Let's try to load the pid file here if we can.
2938
* The PID file might actually be created by a START_POST
2939
* script. In that case don't worry if the loading fails. */
2940
2941
has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2942
r = service_load_pid_file(s, !has_start_post);
2943
if (!has_start_post && r < 0) {
2944
r = service_demand_pid_file(s);
2945
if (r < 0 || !cgroup_good(s))
2946
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2947
break;
2948
}
2949
} else
2950
service_search_main_pid(s);
2951
2952
service_enter_start_post(s);
2953
break;
2954
2955
case SERVICE_START_POST:
2956
if (f != SERVICE_SUCCESS) {
2957
service_enter_stop(s, f);
2958
break;
2959
}
2960
2961
if (s->pid_file) {
2962
int r;
2963
2964
r = service_load_pid_file(s, true);
2965
if (r < 0) {
2966
r = service_demand_pid_file(s);
2967
if (r < 0 || !cgroup_good(s))
2968
service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2969
break;
2970
}
2971
} else
2972
service_search_main_pid(s);
2973
2974
service_enter_running(s, SERVICE_SUCCESS);
2975
break;
2976
2977
case SERVICE_RELOAD:
2978
if (f == SERVICE_SUCCESS) {
2979
service_load_pid_file(s, true);
2980
service_search_main_pid(s);
2981
}
2982
2983
s->reload_result = f;
2984
service_enter_running(s, SERVICE_SUCCESS);
2985
break;
2986
2987
case SERVICE_STOP:
2988
service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2989
break;
2990
2991
case SERVICE_STOP_SIGTERM:
2992
case SERVICE_STOP_SIGKILL:
2993
if (main_pid_good(s) <= 0)
2994
service_enter_stop_post(s, f);
2995
2996
/* If there is still a service
2997
* process around, wait until
2998
* that one quit, too */
2999
break;
3000
3001
case SERVICE_STOP_POST:
3002
case SERVICE_FINAL_SIGTERM:
3003
case SERVICE_FINAL_SIGKILL:
3004
service_enter_dead(s, f, true);
3005
break;
3006
3007
default:
3008
assert_not_reached("Uh, control process died at wrong time.");
3009
}
3010
}
3011
}
3012
3013
/* Notify clients about changed exit status */
3014
unit_add_to_dbus_queue(u);
3015
}
3016
3017
static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3018
Service *s = SERVICE(u);
3019
3020
assert(s);
3021
assert(elapsed == 1);
3022
3023
if (w == &s->watchdog_watch) {
3024
service_handle_watchdog(s);
3025
return;
3026
}
3027
3028
assert(w == &s->timer_watch);
3029
3030
switch (s->state) {
3031
3032
case SERVICE_START_PRE:
3033
case SERVICE_START:
3034
log_warning("%s operation timed out. Terminating.", u->id);
3035
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3036
break;
3037
3038
case SERVICE_START_POST:
3039
log_warning("%s operation timed out. Stopping.", u->id);
3040
service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3041
break;
3042
3043
case SERVICE_RELOAD:
3044
log_warning("%s operation timed out. Stopping.", u->id);
3045
s->reload_result = SERVICE_FAILURE_TIMEOUT;
3046
service_enter_running(s, SERVICE_SUCCESS);
3047
break;
3048
3049
case SERVICE_STOP:
3050
log_warning("%s stopping timed out. Terminating.", u->id);
3051
service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3052
break;
3053
3054
case SERVICE_STOP_SIGTERM:
3055
if (s->exec_context.send_sigkill) {
3056
log_warning("%s stopping timed out. Killing.", u->id);
3057
service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3058
} else {
3059
log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3060
service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3061
}
3062
3063
break;
3064
3065
case SERVICE_STOP_SIGKILL:
3066
/* Uh, we sent a SIGKILL and it is still not gone?
3067
* Must be something we cannot kill, so let's just be
3068
* weirded out and continue */
3069
3070
log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3071
service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3072
break;
3073
3074
case SERVICE_STOP_POST:
3075
log_warning("%s stopping timed out (2). Terminating.", u->id);
3076
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3077
break;
3078
3079
case SERVICE_FINAL_SIGTERM:
3080
if (s->exec_context.send_sigkill) {
3081
log_warning("%s stopping timed out (2). Killing.", u->id);
3082
service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3083
} else {
3084
log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3085
service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3086
}
3087
3088
break;
3089
3090
case SERVICE_FINAL_SIGKILL:
3091
log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3092
service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3093
break;
3094
3095
case SERVICE_AUTO_RESTART:
3096
log_info("%s holdoff time over, scheduling restart.", u->id);
3097
service_enter_restart(s);
3098
break;
3099
3100
default:
3101
assert_not_reached("Timeout at wrong time.");
3102
}
3103
}
3104
3105
static void service_cgroup_notify_event(Unit *u) {
3106
Service *s = SERVICE(u);
3107
3108
assert(u);
3109
3110
log_debug("%s: cgroup is empty", u->id);
3111
3112
switch (s->state) {
3113
3114
/* Waiting for SIGCHLD is usually more interesting,
3115
* because it includes return codes/signals. Which is
3116
* why we ignore the cgroup events for most cases,
3117
* except when we don't know pid which to expect the
3118
* SIGCHLD for. */
3119
3120
case SERVICE_START:
3121
case SERVICE_START_POST:
3122
/* If we were hoping for the daemon to write its PID file,
3123
* we can give up now. */
3124
if (s->pid_file_pathspec) {
3125
log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3126
service_unwatch_pid_file(s);
3127
if (s->state == SERVICE_START)
3128
service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3129
else
3130
service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3131
}
3132
break;
3133
3134
case SERVICE_RUNNING:
3135
/* service_enter_running() will figure out what to do */
3136
service_enter_running(s, SERVICE_SUCCESS);
3137
break;
3138
3139
case SERVICE_STOP_SIGTERM:
3140
case SERVICE_STOP_SIGKILL:
3141
3142
if (main_pid_good(s) <= 0 && !control_pid_good(s))
3143
service_enter_stop_post(s, SERVICE_SUCCESS);
3144
3145
break;
3146
3147
case SERVICE_FINAL_SIGTERM:
3148
case SERVICE_FINAL_SIGKILL:
3149
if (main_pid_good(s) <= 0 && !control_pid_good(s))
3150
service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3151
3152
break;
3153
3154
default:
3155
;
3156
}
3157
}
3158
3159
static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3160
Service *s = SERVICE(u);
3161
const char *e;
3162
3163
assert(u);
3164
3165
if (s->notify_access == NOTIFY_NONE) {
3166
log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3167
u->id, (unsigned long) pid);
3168
return;
3169
}
3170
3171
if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3172
log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3173
u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3174
return;
3175
}
3176
3177
log_debug("%s: Got message", u->id);
3178
3179
/* Interpret MAINPID= */
3180
if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3181
(s->state == SERVICE_START ||
3182
s->state == SERVICE_START_POST ||
3183
s->state == SERVICE_RUNNING ||
3184
s->state == SERVICE_RELOAD)) {
3185
3186
if (parse_pid(e + 8, &pid) < 0)
3187
log_warning("Failed to parse notification message %s", e);
3188
else {
3189
log_debug("%s: got %s", u->id, e);
3190
service_set_main_pid(s, pid);
3191
}
3192
}
3193
3194
/* Interpret READY= */
3195
if (s->type == SERVICE_NOTIFY &&
3196
s->state == SERVICE_START &&
3197
strv_find(tags, "READY=1")) {
3198
log_debug("%s: got READY=1", u->id);
3199
3200
service_enter_start_post(s);
3201
}
3202
3203
/* Interpret STATUS= */
3204
e = strv_find_prefix(tags, "STATUS=");
3205
if (e) {
3206
char *t;
3207
3208
if (e[7]) {
3209
3210
if (!utf8_is_valid(e+7)) {
3211
log_warning("Status message in notification is not UTF-8 clean.");
3212
return;
3213
}
3214
3215
t = strdup(e+7);
3216
if (!t) {
3217
log_error("Failed to allocate string.");
3218
return;
3219
}
3220
3221
log_debug("%s: got %s", u->id, e);
3222
3223
free(s->status_text);
3224
s->status_text = t;
3225
} else {
3226
free(s->status_text);
3227
s->status_text = NULL;
3228
}
3229
3230
}
3231
if (strv_find(tags, "WATCHDOG=1")) {
3232
log_debug("%s: got WATCHDOG=1", u->id);
3233
service_reset_watchdog(s);
3234
}
3235
3236
/* Notify clients about changed status or main pid */
3237
unit_add_to_dbus_queue(u);
3238
}
3239
3240
#ifdef HAVE_SYSV_COMPAT
3241
3242
#ifdef TARGET_SUSE
3243
static void sysv_facility_in_insserv_conf(Manager *mgr) {
3244
FILE *f=NULL;
3245
int r;
3246
3247
if (!(f = fopen("/etc/insserv.conf", "re"))) {
3248
r = errno == ENOENT ? 0 : -errno;
3249
goto finish;
3250
}
3251
3252
while (!feof(f)) {
3253
char l[LINE_MAX], *t;
3254
char **parsed = NULL;
3255
3256
if (!fgets(l, sizeof(l), f)) {
3257
if (feof(f))
3258
break;
3259
3260
r = -errno;
3261
log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3262
goto finish;
3263
}
3264
3265
t = strstrip(l);
3266
if (*t != '$' && *t != '<')
3267
continue;
3268
3269
parsed = strv_split(t,WHITESPACE);
3270
/* we ignore <interactive>, not used, equivalent to X-Interactive */
3271
if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3272
char *facility;
3273
Unit *u;
3274
if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3275
continue;
3276
if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3277
UnitDependency e;
3278
char *dep = NULL, *name, **j;
3279
3280
STRV_FOREACH (j, parsed+1) {
3281
if (*j[0]=='+') {
3282
e = UNIT_WANTS;
3283
name = *j+1;
3284
}
3285
else {
3286
e = UNIT_REQUIRES;
3287
name = *j;
3288
}
3289
if (sysv_translate_facility(name, NULL, &dep) < 0)
3290
continue;
3291
3292
r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3293
free(dep);
3294
}
3295
}
3296
free(facility);
3297
}
3298
strv_free(parsed);
3299
}
3300
finish:
3301
if (f)
3302
fclose(f);
3303
3304
}
3305
#endif
3306
3307
static int service_enumerate(Manager *m) {
3308
char **p;
3309
unsigned i;
3310
DIR *d = NULL;
3311
char *path = NULL, *fpath = NULL, *name = NULL;
3312
Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3313
Unit *service;
3314
Iterator j;
3315
int r;
3316
3317
assert(m);
3318
3319
if (m->running_as != MANAGER_SYSTEM)
3320
return 0;
3321
3322
zero(runlevel_services);
3323
3324
STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3325
for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3326
struct dirent *de;
3327
3328
free(path);
3329
path = join(*p, "/", rcnd_table[i].path, NULL);
3330
if (!path) {
3331
r = -ENOMEM;
3332
goto finish;
3333
}
3334
3335
if (d)
3336
closedir(d);
3337
3338
if (!(d = opendir(path))) {
3339
if (errno != ENOENT)
3340
log_warning("opendir() failed on %s: %s", path, strerror(errno));
3341
3342
continue;
3343
}
3344
3345
while ((de = readdir(d))) {
3346
int a, b;
3347
3348
if (ignore_file(de->d_name))
3349
continue;
3350
3351
if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3352
continue;
3353
3354
if (strlen(de->d_name) < 4)
3355
continue;
3356
3357
a = undecchar(de->d_name[1]);
3358
b = undecchar(de->d_name[2]);
3359
3360
if (a < 0 || b < 0)
3361
continue;
3362
3363
free(fpath);
3364
fpath = join(path, "/", de->d_name, NULL);
3365
if (!fpath) {
3366
r = -ENOMEM;
3367
goto finish;
3368
}
3369
3370
if (access(fpath, X_OK) < 0) {
3371
3372
if (errno != ENOENT)
3373
log_warning("access() failed on %s: %s", fpath, strerror(errno));
3374
3375
continue;
3376
}
3377
3378
free(name);
3379
if (!(name = sysv_translate_name(de->d_name + 3))) {
3380
r = -ENOMEM;
3381
goto finish;
3382
}
3383
3384
if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3385
log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3386
continue;
3387
}
3388
3389
if (de->d_name[0] == 'S') {
3390
3391
if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3392
SERVICE(service)->sysv_start_priority_from_rcnd =
3393
MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3394
3395
SERVICE(service)->sysv_enabled = true;
3396
}
3397
3398
if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3399
goto finish;
3400
3401
if ((r = set_put(runlevel_services[i], service)) < 0)
3402
goto finish;
3403
3404
} else if (de->d_name[0] == 'K' &&
3405
(rcnd_table[i].type == RUNLEVEL_DOWN ||
3406
rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3407
3408
if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3409
goto finish;
3410
3411
if ((r = set_put(shutdown_services, service)) < 0)
3412
goto finish;
3413
}
3414
}
3415
}
3416
3417
/* Now we loaded all stubs and are aware of the lowest
3418
start-up priority for all services, not let's actually load
3419
the services, this will also tell us which services are
3420
actually native now */
3421
manager_dispatch_load_queue(m);
3422
3423
/* If this is a native service, rely on native ways to pull in
3424
* a service, don't pull it in via sysv rcN.d links. */
3425
for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3426
SET_FOREACH(service, runlevel_services[i], j) {
3427
service = unit_follow_merge(service);
3428
3429
if (service->fragment_path)
3430
continue;
3431
3432
if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3433
goto finish;
3434
}
3435
3436
/* We honour K links only for halt/reboot. For the normal
3437
* runlevels we assume the stop jobs will be implicitly added
3438
* by the core logic. Also, we don't really distinguish here
3439
* between the runlevels 0 and 6 and just add them to the
3440
* special shutdown target. On SUSE the boot.d/ runlevel is
3441
* also used for shutdown, so we add links for that too to the
3442
* shutdown target.*/
3443
SET_FOREACH(service, shutdown_services, j) {
3444
service = unit_follow_merge(service);
3445
3446
if (service->fragment_path)
3447
continue;
3448
3449
if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3450
goto finish;
3451
}
3452
3453
r = 0;
3454
3455
#ifdef TARGET_SUSE
3456
sysv_facility_in_insserv_conf (m);
3457
#endif
3458
3459
finish:
3460
free(path);
3461
free(fpath);
3462
free(name);
3463
3464
for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3465
set_free(runlevel_services[i]);
3466
set_free(shutdown_services);
3467
3468
if (d)
3469
closedir(d);
3470
3471
return r;
3472
}
3473
#endif
3474
3475
static void service_bus_name_owner_change(
3476
Unit *u,
3477
const char *name,
3478
const char *old_owner,
3479
const char *new_owner) {
3480
3481
Service *s = SERVICE(u);
3482
3483
assert(s);
3484
assert(name);
3485
3486
assert(streq(s->bus_name, name));
3487
assert(old_owner || new_owner);
3488
3489
if (old_owner && new_owner)
3490
log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3491
else if (old_owner)
3492
log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3493
else
3494
log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3495
3496
s->bus_name_good = !!new_owner;
3497
3498
if (s->type == SERVICE_DBUS) {
3499
3500
/* service_enter_running() will figure out what to
3501
* do */
3502
if (s->state == SERVICE_RUNNING)
3503
service_enter_running(s, SERVICE_SUCCESS);
3504
else if (s->state == SERVICE_START && new_owner)
3505
service_enter_start_post(s);
3506
3507
} else if (new_owner &&
3508
s->main_pid <= 0 &&
3509
(s->state == SERVICE_START ||
3510
s->state == SERVICE_START_POST ||
3511
s->state == SERVICE_RUNNING ||
3512
s->state == SERVICE_RELOAD)) {
3513
3514
/* Try to acquire PID from bus service */
3515
log_debug("Trying to acquire PID from D-Bus name...");
3516
3517
bus_query_pid(u->manager, name);
3518
}
3519
}
3520
3521
static void service_bus_query_pid_done(
3522
Unit *u,
3523
const char *name,
3524
pid_t pid) {
3525
3526
Service *s = SERVICE(u);
3527
3528
assert(s);
3529
assert(name);
3530
3531
log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3532
3533
if (s->main_pid <= 0 &&
3534
(s->state == SERVICE_START ||
3535
s->state == SERVICE_START_POST ||
3536
s->state == SERVICE_RUNNING ||
3537
s->state == SERVICE_RELOAD))
3538
service_set_main_pid(s, pid);
3539
}
3540
3541
int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3542
3543
assert(s);
3544
assert(fd >= 0);
3545
3546
/* This is called by the socket code when instantiating a new
3547
* service for a stream socket and the socket needs to be
3548
* configured. */
3549
3550
if (UNIT(s)->load_state != UNIT_LOADED)
3551
return -EINVAL;
3552
3553
if (s->socket_fd >= 0)
3554
return -EBUSY;
3555
3556
if (s->state != SERVICE_DEAD)
3557
return -EAGAIN;
3558
3559
s->socket_fd = fd;
3560
s->got_socket_fd = true;
3561
3562
unit_ref_set(&s->accept_socket, UNIT(sock));
3563
3564
return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3565
}
3566
3567
static void service_reset_failed(Unit *u) {
3568
Service *s = SERVICE(u);
3569
3570
assert(s);
3571
3572
if (s->state == SERVICE_FAILED)
3573
service_set_state(s, SERVICE_DEAD);
3574
3575
s->result = SERVICE_SUCCESS;
3576
s->reload_result = SERVICE_SUCCESS;
3577
}
3578
3579
static bool service_need_daemon_reload(Unit *u) {
3580
Service *s = SERVICE(u);
3581
3582
assert(s);
3583
3584
#ifdef HAVE_SYSV_COMPAT
3585
if (s->sysv_path) {
3586
struct stat st;
3587
3588
zero(st);
3589
if (stat(s->sysv_path, &st) < 0)
3590
/* What, cannot access this anymore? */
3591
return true;
3592
3593
if (s->sysv_mtime > 0 &&
3594
timespec_load(&st.st_mtim) != s->sysv_mtime)
3595
return true;
3596
}
3597
#endif
3598
3599
return false;
3600
}
3601
3602
static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3603
Service *s = SERVICE(u);
3604
int r = 0;
3605
Set *pid_set = NULL;
3606
3607
assert(s);
3608
3609
if (s->main_pid <= 0 && who == KILL_MAIN) {
3610
dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3611
return -ESRCH;
3612
}
3613
3614
if (s->control_pid <= 0 && who == KILL_CONTROL) {
3615
dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3616
return -ESRCH;
3617
}
3618
3619
if (who == KILL_CONTROL || who == KILL_ALL)
3620
if (s->control_pid > 0)
3621
if (kill(s->control_pid, signo) < 0)
3622
r = -errno;
3623
3624
if (who == KILL_MAIN || who == KILL_ALL)
3625
if (s->main_pid > 0)
3626
if (kill(s->main_pid, signo) < 0)
3627
r = -errno;
3628
3629
if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3630
int q;
3631
3632
if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3633
return -ENOMEM;
3634
3635
/* Exclude the control/main pid from being killed via the cgroup */
3636
if (s->control_pid > 0)
3637
if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3638
r = q;
3639
goto finish;
3640
}
3641
3642
if (s->main_pid > 0)
3643
if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3644
r = q;
3645
goto finish;
3646
}
3647
3648
if ((q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, pid_set)) < 0)
3649
if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3650
r = q;
3651
}
3652
3653
finish:
3654
if (pid_set)
3655
set_free(pid_set);
3656
3657
return r;
3658
}
3659
3660
static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3661
[SERVICE_DEAD] = "dead",
3662
[SERVICE_START_PRE] = "start-pre",
3663
[SERVICE_START] = "start",
3664
[SERVICE_START_POST] = "start-post",
3665
[SERVICE_RUNNING] = "running",
3666
[SERVICE_EXITED] = "exited",
3667
[SERVICE_RELOAD] = "reload",
3668
[SERVICE_STOP] = "stop",
3669
[SERVICE_STOP_SIGTERM] = "stop-sigterm",
3670
[SERVICE_STOP_SIGKILL] = "stop-sigkill",
3671
[SERVICE_STOP_POST] = "stop-post",
3672
[SERVICE_FINAL_SIGTERM] = "final-sigterm",
3673
[SERVICE_FINAL_SIGKILL] = "final-sigkill",
3674
[SERVICE_FAILED] = "failed",
3675
[SERVICE_AUTO_RESTART] = "auto-restart",
3676
};
3677
3678
DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3679
3680
static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3681
[SERVICE_RESTART_NO] = "no",
3682
[SERVICE_RESTART_ON_SUCCESS] = "on-success",
3683
[SERVICE_RESTART_ON_FAILURE] = "on-failure",
3684
[SERVICE_RESTART_ON_ABORT] = "on-abort",
3685
[SERVICE_RESTART_ALWAYS] = "always"
3686
};
3687
3688
DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3689
3690
static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3691
[SERVICE_SIMPLE] = "simple",
3692
[SERVICE_FORKING] = "forking",
3693
[SERVICE_ONESHOT] = "oneshot",
3694
[SERVICE_DBUS] = "dbus",
3695
[SERVICE_NOTIFY] = "notify"
3696
};
3697
3698
DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3699
3700
static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3701
[SERVICE_EXEC_START_PRE] = "ExecStartPre",
3702
[SERVICE_EXEC_START] = "ExecStart",
3703
[SERVICE_EXEC_START_POST] = "ExecStartPost",
3704
[SERVICE_EXEC_RELOAD] = "ExecReload",
3705
[SERVICE_EXEC_STOP] = "ExecStop",
3706
[SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3707
};
3708
3709
DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3710
3711
static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3712
[NOTIFY_NONE] = "none",
3713
[NOTIFY_MAIN] = "main",
3714
[NOTIFY_ALL] = "all"
3715
};
3716
3717
DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3718
3719
static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3720
[SERVICE_SUCCESS] = "success",
3721
[SERVICE_FAILURE_RESOURCES] = "resources",
3722
[SERVICE_FAILURE_TIMEOUT] = "timeout",
3723
[SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3724
[SERVICE_FAILURE_SIGNAL] = "signal",
3725
[SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3726
[SERVICE_FAILURE_WATCHDOG] = "watchdog"
3727
};
3728
3729
DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3730
3731
static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3732
[SERVICE_START_LIMIT_NONE] = "none",
3733
[SERVICE_START_LIMIT_REBOOT] = "reboot",
3734
[SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3735
[SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3736
};
3737
DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3738
3739
const UnitVTable service_vtable = {
3740
.suffix = ".service",
3741
.object_size = sizeof(Service),
3742
.sections =
3743
"Unit\0"
3744
"Service\0"
3745
"Install\0",
3746
.show_status = true,
3747
3748
.init = service_init,
3749
.done = service_done,
3750
.load = service_load,
3751
3752
.coldplug = service_coldplug,
3753
3754
.dump = service_dump,
3755
3756
.start = service_start,
3757
.stop = service_stop,
3758
.reload = service_reload,
3759
3760
.can_reload = service_can_reload,
3761
3762
.kill = service_kill,
3763
3764
.serialize = service_serialize,
3765
.deserialize_item = service_deserialize_item,
3766
3767
.active_state = service_active_state,
3768
.sub_state_to_string = service_sub_state_to_string,
3769
3770
.check_gc = service_check_gc,
3771
.check_snapshot = service_check_snapshot,
3772
3773
.sigchld_event = service_sigchld_event,
3774
.timer_event = service_timer_event,
3775
.fd_event = service_fd_event,
3776
3777
.reset_failed = service_reset_failed,
3778
3779
.need_daemon_reload = service_need_daemon_reload,
3780
3781
.cgroup_notify_empty = service_cgroup_notify_event,
3782
.notify_message = service_notify_message,
3783
3784
.bus_name_owner_change = service_bus_name_owner_change,
3785
.bus_query_pid_done = service_bus_query_pid_done,
3786
3787
.bus_interface = "org.freedesktop.systemd1.Service",
3788
.bus_message_handler = bus_service_message_handler,
3789
.bus_invalidating_properties = bus_service_invalidating_properties,
3790
3791
#ifdef HAVE_SYSV_COMPAT
3792
.enumerate = service_enumerate
3793
#endif
3794
};
Loggerhead is a web-based interface for Breezy
Version: 2.0.1