chiark / gitweb /
greatly extend what we enforce as process properties
[elogind.git] / service.c
1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
2
3 #include <errno.h>
4 #include <signal.h>
5
6 #include "unit.h"
7 #include "service.h"
8 #include "load-fragment.h"
9 #include "load-dropin.h"
10 #include "log.h"
11
12 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
13         [SERVICE_DEAD] = UNIT_INACTIVE,
14         [SERVICE_START_PRE] = UNIT_ACTIVATING,
15         [SERVICE_START] = UNIT_ACTIVATING,
16         [SERVICE_START_POST] = UNIT_ACTIVATING,
17         [SERVICE_RUNNING] = UNIT_ACTIVE,
18         [SERVICE_RELOAD] = UNIT_ACTIVE_RELOADING,
19         [SERVICE_STOP] = UNIT_DEACTIVATING,
20         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
21         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
22         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
23         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
24         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
25         [SERVICE_MAINTAINANCE] = UNIT_INACTIVE,
26         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
27 };
28
29 static void service_done(Unit *u) {
30         Service *s = SERVICE(u);
31
32         assert(s);
33
34         free(s->pid_file);
35         s->pid_file = NULL;
36
37         exec_context_done(&s->exec_context);
38         exec_command_free_array(s->exec_command, _SERVICE_EXEC_MAX);
39         s->control_command = NULL;
40
41         /* This will leak a process, but at least no memory or any of
42          * our resources */
43         if (s->main_pid > 0) {
44                 unit_unwatch_pid(u, s->main_pid);
45                 s->main_pid = 0;
46         }
47
48         if (s->control_pid > 0) {
49                 unit_unwatch_pid(u, s->control_pid);
50                 s->control_pid = 0;
51         }
52
53         unit_unwatch_timer(u, &s->timer_watch);
54 }
55
56 static int service_load_sysv(Service *s) {
57         assert(s);
58
59         /* Load service data from SysV init scripts, preferably with
60          * LSB headers ... */
61
62         return -ENOENT;
63 }
64
65 static int service_init(Unit *u) {
66         int r;
67         Service *s = SERVICE(u);
68
69         assert(s);
70
71         /* First, reset everything to the defaults, in case this is a
72          * reload */
73
74         s->type = 0;
75         s->restart = 0;
76
77         s->timeout_usec = DEFAULT_TIMEOUT_USEC;
78         s->restart_usec = DEFAULT_RESTART_USEC;
79
80         exec_context_init(&s->exec_context);
81
82         s->timer_watch.type = WATCH_INVALID;
83
84         s->state = SERVICE_DEAD;
85
86         RATELIMIT_INIT(s->ratelimit, 10*USEC_PER_SEC, 5);
87
88         /* Load a .service file */
89         if ((r = unit_load_fragment(u)) < 0) {
90                 service_done(u);
91                 return r;
92         }
93
94         /* Load a classic init script as a fallback, if we couldn*t find anything */
95         if (r == 0)
96                 if ((r = service_load_sysv(s)) <= 0) {
97                         service_done(u);
98                         return r < 0 ? r : -ENOENT;
99                 }
100
101         /* Load dropin directory data */
102         if ((r = unit_load_dropin(u)) < 0) {
103                 service_done(u);
104                 return r;
105         }
106
107         return 0;
108 }
109
110 static void service_dump(Unit *u, FILE *f, const char *prefix) {
111
112         ServiceExecCommand c;
113         Service *s = SERVICE(u);
114         char *prefix2;
115
116         assert(s);
117
118         prefix2 = strappend(prefix, "\t");
119         if (!prefix2)
120                 prefix2 = "";
121
122         fprintf(f,
123                 "%sService State: %s\n",
124                 prefix, service_state_to_string(s->state));
125
126         if (s->pid_file)
127                 fprintf(f,
128                         "%sPIDFile: %s\n",
129                         prefix, s->pid_file);
130
131
132         exec_context_dump(&s->exec_context, f, prefix);
133
134         for (c = 0; c < _SERVICE_EXEC_MAX; c++) {
135
136                 if (!s->exec_command[c])
137                         continue;
138
139                 fprintf(f, "%sā†’ %s:\n",
140                         prefix, service_exec_command_to_string(c));
141
142                 exec_command_dump_list(s->exec_command[c], f, prefix2);
143         }
144
145         free(prefix2);
146 }
147
148 static int service_load_pid_file(Service *s) {
149         char *k;
150         unsigned long p;
151         int r;
152
153         assert(s);
154
155         if (s->main_pid_known)
156                 return 0;
157
158         if (!s->pid_file)
159                 return -ENOENT;
160
161         if ((r = read_one_line_file(s->pid_file, &k)) < 0)
162                 return r;
163
164         if ((r = safe_atolu(k, &p)) < 0) {
165                 free(k);
166                 return r;
167         }
168
169         if ((unsigned long) (pid_t) p != p)
170                 return -ERANGE;
171
172         s->main_pid = p;
173         s->main_pid_known = true;
174
175         return 0;
176 }
177
178 static int service_get_sockets(Service *s, Set **_set) {
179         Set *set;
180         Iterator i;
181         char *t;
182         int r;
183
184         assert(s);
185         assert(_set);
186
187         /* Collects all Socket objects that belong to this
188          * service. Note that a service might have multiple sockets
189          * via multiple names. */
190
191         if (!(set = set_new(NULL, NULL)))
192                 return -ENOMEM;
193
194         SET_FOREACH(t, UNIT(s)->meta.names, i) {
195                 char *k;
196                 Unit *p;
197
198                 /* Look for all socket objects that go by any of our
199                  * units and collect their fds */
200
201                 if (!(k = unit_name_change_suffix(t, ".socket"))) {
202                         r = -ENOMEM;
203                         goto fail;
204                 }
205
206                 p = manager_get_unit(UNIT(s)->meta.manager, k);
207                 free(k);
208
209                 if (!p) continue;
210
211                 if ((r = set_put(set, p)) < 0)
212                         goto fail;
213         }
214
215         *_set = set;
216         return 0;
217
218 fail:
219         set_free(set);
220         return r;
221 }
222
223
224 static int service_notify_sockets(Service *s) {
225         Iterator i;
226         Set *set;
227         Socket *socket;
228         int r;
229
230         assert(s);
231
232         /* Notifies all our sockets when we die */
233
234         if ((r = service_get_sockets(s, &set)) < 0)
235                 return r;
236
237         SET_FOREACH(socket, set, i)
238                 socket_notify_service_dead(socket);
239
240         set_free(set);
241
242         return 0;
243 }
244
245 static void service_set_state(Service *s, ServiceState state) {
246         ServiceState old_state;
247         assert(s);
248
249         old_state = s->state;
250         s->state = state;
251
252         if (state != SERVICE_START_PRE &&
253             state != SERVICE_START &&
254             state != SERVICE_START_POST &&
255             state != SERVICE_RELOAD &&
256             state != SERVICE_STOP &&
257             state != SERVICE_STOP_SIGTERM &&
258             state != SERVICE_STOP_SIGKILL &&
259             state != SERVICE_STOP_POST &&
260             state != SERVICE_FINAL_SIGTERM &&
261             state != SERVICE_FINAL_SIGKILL &&
262             state != SERVICE_AUTO_RESTART)
263                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
264
265         if (state != SERVICE_START_POST &&
266             state != SERVICE_RUNNING &&
267             state != SERVICE_RELOAD &&
268             state != SERVICE_STOP &&
269             state != SERVICE_STOP_SIGTERM &&
270             state != SERVICE_STOP_SIGKILL)
271                 if (s->main_pid > 0) {
272                         unit_unwatch_pid(UNIT(s), s->main_pid);
273                         s->main_pid = 0;
274                 }
275
276         if (state != SERVICE_START_PRE &&
277             state != SERVICE_START &&
278             state != SERVICE_START_POST &&
279             state != SERVICE_RELOAD &&
280             state != SERVICE_STOP &&
281             state != SERVICE_STOP_SIGTERM &&
282             state != SERVICE_STOP_SIGKILL &&
283             state != SERVICE_STOP_POST &&
284             state != SERVICE_FINAL_SIGTERM &&
285             state != SERVICE_FINAL_SIGKILL)
286                 if (s->control_pid > 0) {
287                         unit_unwatch_pid(UNIT(s), s->control_pid);
288                         s->control_pid = 0;
289                 }
290
291         if (state != SERVICE_START_PRE &&
292             state != SERVICE_START &&
293             state != SERVICE_START_POST &&
294             state != SERVICE_RELOAD &&
295             state != SERVICE_STOP &&
296             state != SERVICE_STOP_POST)
297                 s->control_command = NULL;
298
299         if (state == SERVICE_DEAD ||
300             state == SERVICE_STOP ||
301             state == SERVICE_STOP_SIGTERM ||
302             state == SERVICE_STOP_SIGKILL ||
303             state == SERVICE_STOP_POST ||
304             state == SERVICE_FINAL_SIGTERM ||
305             state == SERVICE_FINAL_SIGKILL ||
306             state == SERVICE_MAINTAINANCE ||
307             state == SERVICE_AUTO_RESTART)
308                 service_notify_sockets(s);
309
310         log_debug("%s changed %s ā†’ %s", unit_id(UNIT(s)), service_state_to_string(old_state), service_state_to_string(state));
311
312         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]);
313 }
314
315 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
316         Iterator i;
317         int r;
318         int *rfds = NULL;
319         unsigned rn_fds = 0;
320         Set *set;
321         Socket *socket;
322
323         assert(s);
324         assert(fds);
325         assert(n_fds);
326
327         if ((r = service_get_sockets(s, &set)) < 0)
328                 return r;
329
330         SET_FOREACH(socket, set, i) {
331                 int *cfds;
332                 unsigned cn_fds;
333
334                 if ((r = socket_collect_fds(socket, &cfds, &cn_fds)) < 0)
335                         goto fail;
336
337                 if (!cfds)
338                         continue;
339
340                 if (!rfds) {
341                         rfds = cfds;
342                         rn_fds = cn_fds;
343                 } else {
344                         int *t;
345
346                         if (!(t = new(int, rn_fds+cn_fds))) {
347                                 free(cfds);
348                                 r = -ENOMEM;
349                                 goto fail;
350                         }
351
352                         memcpy(t, rfds, rn_fds);
353                         memcpy(t+rn_fds, cfds, cn_fds);
354                         free(rfds);
355                         free(cfds);
356
357                         rfds = t;
358                         rn_fds = rn_fds+cn_fds;
359                 }
360         }
361
362         *fds = rfds;
363         *n_fds = rn_fds;
364
365         set_free(set);
366
367         return 0;
368
369 fail:
370         set_free(set);
371         free(rfds);
372
373         return r;
374 }
375
376 static int service_spawn(Service *s, ExecCommand *c, bool timeout, bool pass_fds, pid_t *_pid) {
377         pid_t pid;
378         int r;
379         int *fds = NULL;
380         unsigned n_fds = 0;
381
382         assert(s);
383         assert(c);
384         assert(_pid);
385
386         if (pass_fds)
387                 if ((r = service_collect_fds(s, &fds, &n_fds)) < 0)
388                         goto fail;
389
390         if (timeout) {
391                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
392                         goto fail;
393         } else
394                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
395
396         if ((r = exec_spawn(c, &s->exec_context, fds, n_fds, &pid)) < 0)
397                 goto fail;
398
399         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
400                 /* FIXME: we need to do something here */
401                 goto fail;
402
403         free(fds);
404         *_pid = pid;
405
406         return 0;
407
408 fail:
409         free(fds);
410
411         if (timeout)
412                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
413
414         return r;
415 }
416
417 static void service_enter_dead(Service *s, bool success, bool allow_restart) {
418         int r;
419         assert(s);
420
421         if (!success)
422                 s->failure = true;
423
424         if (allow_restart &&
425             (s->restart == SERVICE_RESTART_ALWAYS ||
426              (s->restart == SERVICE_RESTART_ON_SUCCESS && !s->failure))) {
427
428                 if ((r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch)) < 0)
429                         goto fail;
430
431                 service_set_state(s, SERVICE_AUTO_RESTART);
432         } else
433                 service_set_state(s, s->failure ? SERVICE_MAINTAINANCE : SERVICE_DEAD);
434
435         return;
436
437 fail:
438         log_warning("%s failed to run install restart timer: %s", unit_id(UNIT(s)), strerror(-r));
439         service_enter_dead(s, false, false);
440 }
441
442 static void service_enter_signal(Service *s, ServiceState state, bool success);
443
444 static void service_enter_stop_post(Service *s, bool success) {
445         int r;
446         assert(s);
447
448         if (!success)
449                 s->failure = true;
450
451         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST]))
452                 if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0)
453                         goto fail;
454
455
456         service_set_state(s, SERVICE_STOP_POST);
457
458         if (!s->control_command)
459                 service_enter_dead(s, true, true);
460
461         return;
462
463 fail:
464         log_warning("%s failed to run stop executable: %s", unit_id(UNIT(s)), strerror(-r));
465         service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
466 }
467
468 static void service_enter_signal(Service *s, ServiceState state, bool success) {
469         int r;
470         bool sent = false;
471
472         assert(s);
473
474         if (!success)
475                 s->failure = true;
476
477         if (s->main_pid > 0 || s->control_pid > 0) {
478                 int sig;
479
480                 sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
481
482                 r = 0;
483                 if (s->main_pid > 0) {
484                         if (kill(s->main_pid, sig) < 0 && errno != ESRCH)
485                                 r = -errno;
486                         else
487                                 sent = true;
488                 }
489
490                 if (s->control_pid > 0) {
491                         if (kill(s->control_pid, sig) < 0 && errno != ESRCH)
492                                 r = -errno;
493                         else
494                                 sent = true;
495                 }
496
497                 if (r < 0)
498                         goto fail;
499         }
500
501         service_set_state(s, state);
502
503         if (s->main_pid <= 0 && s->control_pid <= 0)
504                 service_enter_dead(s, true, true);
505
506         return;
507
508 fail:
509         log_warning("%s failed to kill processes: %s", unit_id(UNIT(s)), strerror(-r));
510
511         if (sent)  {
512                 s->failure = true;
513                 service_set_state(s, state);
514         } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
515                 service_enter_stop_post(s, false);
516         else
517                 service_enter_dead(s, false, true);
518 }
519
520 static void service_enter_stop(Service *s, bool success) {
521         int r;
522         assert(s);
523
524         if (!success)
525                 s->failure = true;
526
527         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP]))
528                 if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0)
529                         goto fail;
530
531         service_set_state(s, SERVICE_STOP);
532
533         if (!s->control_command)
534                 service_enter_signal(s, SERVICE_STOP_SIGTERM, true);
535
536         return;
537
538 fail:
539         log_warning("%s failed to run stop executable: %s", unit_id(UNIT(s)), strerror(-r));
540         service_enter_signal(s, SERVICE_STOP_SIGTERM, false);
541 }
542
543 static void service_enter_start_post(Service *s) {
544         int r;
545         assert(s);
546
547         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST]))
548                 if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0)
549                         goto fail;
550
551
552         service_set_state(s, SERVICE_START_POST);
553
554         if (!s->control_command)
555                 service_set_state(s, SERVICE_RUNNING);
556
557         return;
558
559 fail:
560         log_warning("%s failed to run start-post executable: %s", unit_id(UNIT(s)), strerror(-r));
561         service_enter_stop(s, false);
562 }
563
564 static void service_enter_start(Service *s) {
565         pid_t pid;
566         int r;
567
568         assert(s);
569
570         assert(s->exec_command[SERVICE_EXEC_START]);
571         assert(!s->exec_command[SERVICE_EXEC_START]->command_next);
572
573         if ((r = service_spawn(s, s->exec_command[SERVICE_EXEC_START], s->type == SERVICE_FORKING, true, &pid)) < 0)
574                 goto fail;
575
576         service_set_state(s, SERVICE_START);
577
578         if (s->type == SERVICE_SIMPLE) {
579                 /* For simple services we immediately start
580                  * the START_POST binaries. */
581
582                 s->main_pid = pid;
583                 s->main_pid_known = true;
584                 service_enter_start_post(s);
585
586         } else  if (s->type == SERVICE_FORKING) {
587
588                 /* For forking services we wait until the start
589                  * process exited. */
590
591                 s->control_pid = pid;
592                 s->control_command = s->exec_command[SERVICE_EXEC_START];
593         } else
594                 assert_not_reached("Unknown service type");
595
596         return;
597
598 fail:
599         log_warning("%s failed to run start exectuable: %s", unit_id(UNIT(s)), strerror(-r));
600         service_enter_stop(s, false);
601 }
602
603 static void service_enter_start_pre(Service *s) {
604         int r;
605
606         assert(s);
607
608         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE]))
609                 if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0)
610                         goto fail;
611
612         service_set_state(s, SERVICE_START_PRE);
613
614         if (!s->control_command)
615                 service_enter_start(s);
616
617         return;
618
619 fail:
620         log_warning("%s failed to run start-pre executable: %s", unit_id(UNIT(s)), strerror(-r));
621         service_enter_dead(s, false, true);
622 }
623
624 static void service_enter_restart(Service *s) {
625         int r;
626         assert(s);
627
628         if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s), JOB_FAIL, false, NULL)) < 0)
629                 goto fail;
630
631         log_debug("%s scheduled restart job.", unit_id(UNIT(s)));
632         service_enter_dead(s, true, false);
633         return;
634
635 fail:
636
637         log_warning("%s failed to schedule restart job: %s", unit_id(UNIT(s)), strerror(-r));
638         service_enter_dead(s, false, false);
639 }
640
641 static void service_enter_reload(Service *s) {
642         int r;
643
644         assert(s);
645
646         if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD]))
647                 if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0)
648                         goto fail;
649
650         service_set_state(s, SERVICE_RELOAD);
651
652         if (!s->control_command)
653                 service_set_state(s, SERVICE_RUNNING);
654
655         return;
656
657 fail:
658         log_warning("%s failed to run reload executable: %s", unit_id(UNIT(s)), strerror(-r));
659         service_enter_stop(s, false);
660 }
661
662 static void service_run_next(Service *s, bool success) {
663         int r;
664
665         assert(s);
666         assert(s->control_command);
667         assert(s->control_command->command_next);
668
669         if (!success)
670                 s->failure = true;
671
672         s->control_command = s->control_command->command_next;
673
674         if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0)
675                 goto fail;
676
677         return;
678
679 fail:
680         log_warning("%s failed to run spawn next executable: %s", unit_id(UNIT(s)), strerror(-r));
681
682         if (s->state == SERVICE_STOP)
683                 service_enter_stop_post(s, false);
684         else if (s->state == SERVICE_STOP_POST)
685                 service_enter_dead(s, false, true);
686         else
687                 service_enter_stop(s, false);
688 }
689
690 static int service_start(Unit *u) {
691         Service *s = SERVICE(u);
692
693         assert(s);
694
695         /* We cannot fulfill this request right now, try again later
696          * please! */
697         if (s->state == SERVICE_STOP ||
698             s->state == SERVICE_STOP_SIGTERM ||
699             s->state == SERVICE_STOP_SIGKILL ||
700             s->state == SERVICE_STOP_POST ||
701             s->state == SERVICE_FINAL_SIGTERM ||
702             s->state == SERVICE_FINAL_SIGKILL)
703                 return -EAGAIN;
704
705         /* Already on it! */
706         if (s->state == SERVICE_START_PRE ||
707             s->state == SERVICE_START ||
708             s->state == SERVICE_START_POST)
709                 return 0;
710
711         assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTAINANCE || s->state == SERVICE_AUTO_RESTART);
712
713         /* Make sure we don't enter a busy loop of some kind. */
714         if (!ratelimit_test(&s->ratelimit)) {
715                 log_warning("%s start request repeated too quickly, refusing to start.", unit_id(u));
716                 return -EAGAIN;
717         }
718
719         s->failure = false;
720         s->main_pid_known = false;
721
722         service_enter_start_pre(s);
723         return 0;
724 }
725
726 static int service_stop(Unit *u) {
727         Service *s = SERVICE(u);
728
729         assert(s);
730
731         if (s->state == SERVICE_START_PRE ||
732             s->state == SERVICE_START ||
733             s->state == SERVICE_START_POST ||
734             s->state == SERVICE_RELOAD)
735                 return -EAGAIN;
736
737         if (s->state == SERVICE_AUTO_RESTART) {
738                 service_set_state(s, SERVICE_DEAD);
739                 return 0;
740         }
741
742         assert(s->state == SERVICE_RUNNING);
743
744         service_enter_stop(s, true);
745         return 0;
746 }
747
748 static int service_reload(Unit *u) {
749         Service *s = SERVICE(u);
750
751         assert(s);
752
753         assert(s->state == SERVICE_RUNNING);
754
755         service_enter_reload(s);
756         return 0;
757 }
758
759 static bool service_can_reload(Unit *u) {
760         Service *s = SERVICE(u);
761
762         assert(s);
763
764         return !!s->exec_command[SERVICE_EXEC_RELOAD];
765 }
766
767 static UnitActiveState service_active_state(Unit *u) {
768         assert(u);
769
770         return state_translation_table[SERVICE(u)->state];
771 }
772
773 static int main_pid_good(Service *s) {
774         assert(s);
775
776         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
777          * don't know */
778
779         /* If we know the pid file, then lets just check if it is
780          * still valid */
781         if (s->main_pid_known)
782                 return s->main_pid > 0;
783
784         /* We don't know the pid */
785         return -1;
786 }
787
788 static bool control_pid_good(Service *s) {
789         assert(s);
790
791         return s->control_pid > 0;
792 }
793
794 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
795         Service *s = SERVICE(u);
796         bool success;
797
798         assert(s);
799         assert(pid >= 0);
800
801         success = code == CLD_EXITED && status == 0;
802         s->failure = s->failure || !success;
803
804         if (s->main_pid == pid) {
805
806                 exec_status_fill(&s->main_exec_status, pid, code, status);
807                 s->main_pid = 0;
808
809                 if (s->type == SERVICE_SIMPLE) {
810                         assert(s->exec_command[SERVICE_EXEC_START]);
811                         s->exec_command[SERVICE_EXEC_START]->exec_status = s->main_exec_status;
812                 }
813
814                 log_debug("%s: main process exited, code=%s status=%i", unit_id(u), sigchld_code_to_string(code), status);
815
816                 /* The service exited, so the service is officially
817                  * gone. */
818
819                 switch (s->state) {
820
821                 case SERVICE_START_POST:
822                 case SERVICE_RELOAD:
823                 case SERVICE_STOP:
824                         /* Need to wait until the operation is
825                          * done */
826                         break;
827
828                 case SERVICE_RUNNING:
829                         service_enter_stop(s, success);
830                         break;
831
832                 case SERVICE_STOP_SIGTERM:
833                 case SERVICE_STOP_SIGKILL:
834
835                         if (!control_pid_good(s))
836                                 service_enter_stop_post(s, success);
837
838                         /* If there is still a control process, wait for that first */
839                         break;
840
841                 default:
842                         assert_not_reached("Uh, main process died at wrong time.");
843                 }
844
845         } else if (s->control_pid == pid) {
846                 assert(s->control_command);
847
848                 exec_status_fill(&s->control_command->exec_status, pid, code, status);
849                 s->control_pid = 0;
850
851                 log_debug("%s: control process exited, code=%s status=%i", unit_id(u), sigchld_code_to_string(code), status);
852
853                 /* If we are shutting things down anyway we
854                  * don't care about failing commands. */
855
856                 if (s->control_command->command_next &&
857                     (success || (s->state == SERVICE_EXEC_STOP || s->state == SERVICE_EXEC_STOP_POST)))
858
859                         /* There is another command to *
860                          * execute, so let's do that. */
861
862                         service_run_next(s, success);
863
864                 else {
865                         /* No further commands for this step, so let's
866                          * figure out what to do next */
867
868                         log_debug("%s got final SIGCHLD for state %s", unit_id(u), service_state_to_string(s->state));
869
870                         switch (s->state) {
871
872                         case SERVICE_START_PRE:
873                                 if (success)
874                                         service_enter_start(s);
875                                 else
876                                         service_enter_stop(s, false);
877                                 break;
878
879                         case SERVICE_START:
880                                 assert(s->type == SERVICE_FORKING);
881
882                                 /* Let's try to load the pid
883                                  * file here if we can. We
884                                  * ignore the return value,
885                                  * since the PID file might
886                                  * actually be created by a
887                                  * START_POST script */
888
889                                 if (success) {
890                                         if (s->pid_file)
891                                                 service_load_pid_file(s);
892
893                                         service_enter_start_post(s);
894                                 } else
895                                         service_enter_stop(s, false);
896
897                                 break;
898
899                         case SERVICE_START_POST:
900                                 if (success && s->pid_file && !s->main_pid_known) {
901                                         int r;
902
903                                         /* Hmm, let's see if we can
904                                          * load the pid now after the
905                                          * start-post scripts got
906                                          * executed. */
907
908                                         if ((r = service_load_pid_file(s)) < 0)
909                                                 log_warning("%s: failed to load PID file %s: %s", unit_id(UNIT(s)), s->pid_file, strerror(-r));
910                                 }
911
912                                 /* Fall through */
913
914                         case SERVICE_RELOAD:
915                                 if (success) {
916                                         if (main_pid_good(s) != 0)
917                                                 service_set_state(s, SERVICE_RUNNING);
918                                         else
919                                                 service_enter_stop(s, true);
920                                 } else
921                                         service_enter_stop(s, false);
922
923                                 break;
924
925                         case SERVICE_STOP:
926                                 if (main_pid_good(s) > 0)
927                                         /* Still not dead and we know the PID? Let's go hunting. */
928                                         service_enter_signal(s, SERVICE_STOP_SIGTERM, success);
929                                 else
930                                         service_enter_stop_post(s, success);
931                                 break;
932
933                         case SERVICE_STOP_SIGTERM:
934                         case SERVICE_STOP_SIGKILL:
935                                 if (main_pid_good(s) <= 0)
936                                         service_enter_stop_post(s, success);
937
938                                 /* If there is still a service
939                                  * process around, wait until
940                                  * that one quit, too */
941                                 break;
942
943                         case SERVICE_STOP_POST:
944                         case SERVICE_FINAL_SIGTERM:
945                         case SERVICE_FINAL_SIGKILL:
946                                 service_enter_dead(s, success, true);
947                                 break;
948
949                         default:
950                                 assert_not_reached("Uh, control process died at wrong time.");
951                         }
952                 }
953         } else
954                 assert_not_reached("Got SIGCHLD for unkown PID");
955 }
956
957 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
958         Service *s = SERVICE(u);
959
960         assert(s);
961         assert(elapsed == 1);
962
963         assert(w == &s->timer_watch);
964
965         switch (s->state) {
966
967         case SERVICE_START_PRE:
968         case SERVICE_START:
969         case SERVICE_START_POST:
970         case SERVICE_RELOAD:
971                 log_warning("%s operation timed out. Stopping.", unit_id(u));
972                 service_enter_stop(s, false);
973                 break;
974
975         case SERVICE_STOP:
976                 log_warning("%s stopping timed out. Terminating.", unit_id(u));
977                 service_enter_signal(s, SERVICE_STOP_SIGTERM, false);
978                 break;
979
980         case SERVICE_STOP_SIGTERM:
981                 log_warning("%s stopping timed out. Killing.", unit_id(u));
982                 service_enter_signal(s, SERVICE_STOP_SIGKILL, false);
983                 break;
984
985         case SERVICE_STOP_SIGKILL:
986                 /* Uh, wie sent a SIGKILL and it is still not gone?
987                  * Must be something we cannot kill, so let's just be
988                  * weirded out and continue */
989
990                 log_warning("%s still around after SIGKILL. Ignoring.", unit_id(u));
991                 service_enter_stop_post(s, false);
992                 break;
993
994         case SERVICE_STOP_POST:
995                 log_warning("%s stopping timed out (2). Terminating.", unit_id(u));
996                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
997                 break;
998
999         case SERVICE_FINAL_SIGTERM:
1000                 log_warning("%s stopping timed out (2). Killing.", unit_id(u));
1001                 service_enter_signal(s, SERVICE_FINAL_SIGKILL, false);
1002                 break;
1003
1004         case SERVICE_FINAL_SIGKILL:
1005                 log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", unit_id(u));
1006                 service_enter_dead(s, false, true);
1007                 break;
1008
1009         case SERVICE_AUTO_RESTART:
1010                 log_debug("%s holdoff time over, scheduling restart.", unit_id(u));
1011                 service_enter_restart(s);
1012                 break;
1013
1014         default:
1015                 assert_not_reached("Timeout at wrong time.");
1016         }
1017 }
1018
1019 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
1020         [SERVICE_DEAD] = "dead",
1021         [SERVICE_START_PRE] = "start-pre",
1022         [SERVICE_START] = "start",
1023         [SERVICE_START_POST] = "start-post",
1024         [SERVICE_RUNNING] = "running",
1025         [SERVICE_RELOAD] = "reload",
1026         [SERVICE_STOP] = "stop",
1027         [SERVICE_STOP_SIGTERM] = "stop-sigterm",
1028         [SERVICE_STOP_SIGKILL] = "stop-sigkill",
1029         [SERVICE_STOP_POST] = "stop-post",
1030         [SERVICE_FINAL_SIGTERM] = "final-sigterm",
1031         [SERVICE_FINAL_SIGKILL] = "final-sigkill",
1032         [SERVICE_MAINTAINANCE] = "maintainance",
1033         [SERVICE_AUTO_RESTART] = "auto-restart",
1034 };
1035
1036 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
1037
1038 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
1039         [SERVICE_ONCE] = "once",
1040         [SERVICE_RESTART_ON_SUCCESS] = "restart-on-success",
1041         [SERVICE_RESTART_ALWAYS] = "restart-on-failure",
1042 };
1043
1044 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
1045
1046 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
1047         [SERVICE_FORKING] = "forking",
1048         [SERVICE_SIMPLE] = "simple",
1049         [SERVICE_FINISH] = "finish"
1050 };
1051
1052 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
1053
1054 static const char* const service_exec_command_table[_SERVICE_EXEC_MAX] = {
1055         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
1056         [SERVICE_EXEC_START] = "ExecStart",
1057         [SERVICE_EXEC_START_POST] = "ExecStartPost",
1058         [SERVICE_EXEC_RELOAD] = "ExecReload",
1059         [SERVICE_EXEC_STOP] = "ExecStop",
1060         [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
1061 };
1062
1063 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
1064
1065 const UnitVTable service_vtable = {
1066         .suffix = ".service",
1067
1068         .init = service_init,
1069         .done = service_done,
1070
1071         .dump = service_dump,
1072
1073         .start = service_start,
1074         .stop = service_stop,
1075         .reload = service_reload,
1076
1077         .can_reload = service_can_reload,
1078
1079         .active_state = service_active_state,
1080
1081         .sigchld_event = service_sigchld_event,
1082         .timer_event = service_timer_event,
1083 };