Attachment #621005 for bug #878853

View | Details | Raw Unified | Return to bug 878853
Collapse All | Expand All





#define BUS_SCOPE_INTERFACE                                             \
        " <interface name=\"org.freedesktop.systemd1.Scope\">\n"        \
        "  <method name=\"Abandon\"/>\n"                                \
        BUS_UNIT_CGROUP_INTERFACE                                       \
        "  <property name=\"Controller\" type=\"s\" access=\"read\"/>\n"\
        "  <property name=\"TimeoutStopUSec\" type=\"t\" access=\"read\"/>\n" \
        BUS_KILL_CONTEXT_INTERFACE                                      \
        BUS_CGROUP_CONTEXT_INTERFACE                                    \
        "  <property name=\"Result\" type=\"s\" access=\"read\"/>\n"    \
        "  <signal name=\"RequestStop\"/>\n"                            \
        " </interface>\n"

#define INTROSPECTION                                                   \

static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_scope_append_scope_result, scope_result, ScopeResult);

static const BusProperty bus_scope_properties[] = {
        { "Controller",             bus_property_append_string,    "s", offsetof(Scope, controller)        },
        { "TimeoutStopUSec",        bus_property_append_usec,      "t", offsetof(Scope, timeout_stop_usec) },
        { "Result",                 bus_scope_append_scope_result, "s", offsetof(Scope, result)            },
        {}


DBusHandlerResult bus_scope_message_handler(Unit *u, DBusConnection *c, DBusMessage *message) {
        Scope *s = SCOPE(u);
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

        SELINUX_UNIT_ACCESS_CHECK(u, c, message, "status");

        if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Scope", "Abandon")) {
                int r;

                r = scope_abandon(s);
                if (r < 0)
                        log_error("Failed to mark scope %s as abandoned : %s", UNIT(s)->id, strerror(-r));

                reply = dbus_message_new_method_return(message);
                if (!reply)
                        goto oom;
        } else {
                const BusBoundProperties bps[] = {
                { "org.freedesktop.systemd1.Unit",  bus_unit_properties,           u },
                { "org.freedesktop.systemd1.Scope", bus_unit_cgroup_properties,    u },
                { "org.freedesktop.systemd1.Scope", bus_scope_properties,          s },
                { "org.freedesktop.systemd1.Scope", bus_cgroup_context_properties, &s->cgroup_context },
                { "org.freedesktop.systemd1.Scope", bus_kill_context_properties,   &s->kill_context   },
                {}
                };

               return  bus_default_message_handler(c, message, INTROSPECTION, INTERFACES_LIST, bps);
        }

        if (reply)
                if (!bus_maybe_send_reply(c, message, reply))
                        goto oom;

        return DBUS_HANDLER_RESULT_HANDLED;
oom:
        return DBUS_HANDLER_RESULT_NEED_MEMORY;
}

static int bus_scope_set_transient_property(

                    dbus_message_iter_get_element_type(i) != DBUS_TYPE_UINT32)
                        return -EINVAL;

                r = set_ensure_allocated(&s->pids, trivial_hash_func, trivial_compare_func);
                if (r < 0)
                        return r;

                dbus_message_iter_recurse(i, &sub);
                while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32) {
                        uint32_t pid;

                                return -EINVAL;

                        if (mode != UNIT_CHECK) {
                                r = unit_watch_pid(UNIT(s), pid);
                                if (r < 0 && r != -EEXIST)
                                        return r;
                        }


                return 1;

        } else if (streq(name, "Controller")) {
                const char *controller;

                if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING)
                        return -EINVAL;

                dbus_message_iter_get_basic(i, &controller);

                if (!isempty(controller) && !bus_service_name_is_valid(controller))
                        return -EINVAL;

                if (mode != UNIT_CHECK) {
                        char *c = NULL;

                        if (!isempty(controller)) {
                                c = strdup(controller);
                                if (!c)
                                        return -ENOMEM;
                        }

                        free(s->controller);
                        s->controller = c;
                }

                return 1;
        } else if (streq(name, "TimeoutStopUSec")) {

                if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_UINT64)

        unit_realize_cgroup(u);
        return 0;
}

int bus_scope_send_request_stop(Scope *s) {
        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
        _cleanup_free_ char *p = NULL;
        int r;

        assert(s);

        if (!s->controller)
                return 0;

        p = unit_dbus_path(UNIT(s));
        if (!p)
                return -ENOMEM;

        m = dbus_message_new_signal(p,
                                    "org.freedesktop.systemd1.Scope",
                                    "RequestStop");
        if (!m)
                return 0;

        r = dbus_message_set_destination(m, s->controller);
        if (!r)
                return 0;

        return dbus_connection_send(UNIT(s)->manager->api_bus, m, NULL);
}

Lines 30-33 Link Here

(-)systemd-208.mod.bck/src/core/dbus-scope.h (+2 lines)
30	int bus_scope_set_property(Unit u, const char name, DBusMessageIter i, UnitSetPropertiesMode mode, DBusError error);	30	int bus_scope_set_property(Unit u, const char name, DBusMessageIter i, UnitSetPropertiesMode mode, DBusError error);
31	int bus_scope_commit_properties(Unit *u);	31	int bus_scope_commit_properties(Unit *u);
32		32
		33	int bus_scope_send_request_stop(Scope *s);
		34
33	extern const char bus_scope_interface[];	35	extern const char bus_scope_interface[];

Lines 1389-1395 Link Here

(-)systemd-208.mod.bck/src/core/manager.c (-1 / +1 lines)
1389	log_debug_unit(u->id,	1389	log_debug_unit(u->id,
1390	"Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);	1390	"Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1391		1391
1392	hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));	1392	unit_unwatch_pid(u, si.si_pid);
1393	UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);	1393	UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1394	}	1394	}
1395		1395

Lines 35-40 Link Here

(-)systemd-208.mod.bck/src/core/scope.c (-26 / +79 lines)
35	static const UnitActiveState state_translation_table[_SCOPE_STATE_MAX] = {	35	static const UnitActiveState state_translation_table[_SCOPE_STATE_MAX] = {
36	[SCOPE_DEAD] = UNIT_INACTIVE,	36	[SCOPE_DEAD] = UNIT_INACTIVE,
37	[SCOPE_RUNNING] = UNIT_ACTIVE,	37	[SCOPE_RUNNING] = UNIT_ACTIVE,
		38	[SCOPE_ABANDONED] = UNIT_ACTIVE,
38	[SCOPE_STOP_SIGTERM] = UNIT_DEACTIVATING,	39	[SCOPE_STOP_SIGTERM] = UNIT_DEACTIVATING,
39	[SCOPE_STOP_SIGKILL] = UNIT_DEACTIVATING,	40	[SCOPE_STOP_SIGKILL] = UNIT_DEACTIVATING,
40	[SCOPE_FAILED] = UNIT_FAILED	41	[SCOPE_FAILED] = UNIT_FAILED
Lines 64-71 Link Here
64		65
65	cgroup_context_done(&s->cgroup_context);	66	cgroup_context_done(&s->cgroup_context);
66		67
67	set_free(s->pids);	68	free(s->controller);
68	s->pids = NULL;	69	s->controller = NULL;
69		70
70	unit_unwatch_timer(u, &s->timer_watch);	71	unit_unwatch_timer(u, &s->timer_watch);
71	}	72	}
Lines 81-86 Link Here
81	state != SCOPE_STOP_SIGKILL)	82	state != SCOPE_STOP_SIGKILL)
82	unit_unwatch_timer(UNIT(s), &s->timer_watch);	83	unit_unwatch_timer(UNIT(s), &s->timer_watch);
83		84
		85	if (state == SCOPE_DEAD \|\| state == SCOPE_FAILED)
		86	unit_unwatch_all_pids(UNIT(s));
		87
84	if (state != old_state)	88	if (state != old_state)
85	log_debug("%s changed %s -> %s",	89	log_debug("%s changed %s -> %s",
86	UNIT(s)->id,	90	UNIT(s)->id,
Lines 112-118 Link Here
112	if (UNIT(s)->load_state != UNIT_LOADED)	116	if (UNIT(s)->load_state != UNIT_LOADED)
113	return 0;	117	return 0;
114		118
115	if (set_size(s->pids) <= 0 && UNIT(s)->manager->n_reloading <= 0) {	119	if (set_size(UNIT(s)->pids) <= 0 && UNIT(s)->manager->n_reloading <= 0) {
116	log_error_unit(UNIT(s)->id, "Scope %s has no PIDs. Refusing.", UNIT(s)->id);	120	log_error_unit(UNIT(s)->id, "Scope %s has no PIDs. Refusing.", UNIT(s)->id);
117	return -EINVAL;	121	return -EINVAL;
118	}	122	}
Lines 166-171 Link Here
166	return r;	170	return r;
167	}	171	}
168		172
		173	if (s->deserialized_state != SCOPE_DEAD && s->deserialized_state != SCOPE_FAILED)
		174	unit_watch_all_pids(UNIT(s));
		175
169	scope_set_state(s, s->deserialized_state);	176	scope_set_state(s, s->deserialized_state);
170	}	177	}
171		178
Lines 198-203 Link Here
198	}	205	}
199		206
200	static void scope_enter_signal(Scope *s, ScopeState state, ScopeResult f) {	207	static void scope_enter_signal(Scope *s, ScopeState state, ScopeResult f) {
		208	bool skip_signal = false;
201	int r;	209	int r;
202		210
203	assert(s);	211	assert(s);
Lines 205-217 Link Here
205	if (f != SCOPE_SUCCESS)	213	if (f != SCOPE_SUCCESS)
206	s->result = f;	214	s->result = f;
207		215
208	r = unit_kill_context(	216	unit_watch_all_pids(UNIT(s));
		217
		218	/* If we have a controller set let's ask the controller nicely
		219	* to terminate the scope, instead of us going directly into
		220	* SIGTERM beserk mode */
		221	if (state == SCOPE_STOP_SIGTERM)
		222	skip_signal = bus_scope_send_request_stop(s) > 0;
		223
		224	if (!skip_signal) {
		225	r = unit_kill_context(
209	UNIT(s),	226	UNIT(s),
210	&s->kill_context,	227	&s->kill_context,
211	state != SCOPE_STOP_SIGTERM,	228	state != SCOPE_STOP_SIGTERM,
212	-1, -1, false);	229	-1, -1, false);
213	if (r < 0)	230
214	goto fail;	231	if (r < 0)
		232	goto fail;
		233	} else
		234	r = 1;
215		235
216	if (r > 0) {	236	if (r > 0) {
217	if (s->timeout_stop_usec > 0) {	237	if (s->timeout_stop_usec > 0) {
Lines 257-269 Link Here
257	return r;	277	return r;
258	}	278	}
259		279
260	r = cg_attach_many_everywhere(u->manager->cgroup_supported, u->cgroup_path, s->pids);	280	r = cg_attach_many_everywhere(u->manager->cgroup_supported, u->cgroup_path, UNIT(s)->pids);
261	if (r < 0)	281	if (r < 0)
262	return r;	282	return r;
263		283
264	set_free(s->pids);
265	s->pids = NULL;
266
267	s->result = SCOPE_SUCCESS;	284	s->result = SCOPE_SUCCESS;
268		285
269	scope_set_state(s, SCOPE_RUNNING);	286	scope_set_state(s, SCOPE_RUNNING);
Lines 274-286 Link Here
274	Scope *s = SCOPE(u);	291	Scope *s = SCOPE(u);
275		292
276	assert(s);	293	assert(s);
277	assert(s->state == SCOPE_RUNNING);
278		294
279	if (s->state == SCOPE_STOP_SIGTERM \|\|	295	if (s->state == SCOPE_STOP_SIGTERM \|\|
280	s->state == SCOPE_STOP_SIGKILL)	296	s->state == SCOPE_STOP_SIGKILL)
281	return 0;	297	return 0;
282		298
283	assert(s->state == SCOPE_RUNNING);	299	assert(s->state == SCOPE_RUNNING \|\|
		300	s->state == SCOPE_ABANDONED);
284		301
285	scope_enter_signal(s, SCOPE_STOP_SIGTERM, SCOPE_SUCCESS);	302	scope_enter_signal(s, SCOPE_STOP_SIGTERM, SCOPE_SUCCESS);
286	return 0;	303	return 0;
Lines 344-350 Link Here
344	/* Never clean up scopes that still have a process around,	361	/* Never clean up scopes that still have a process around,
345	* even if the scope is formally dead. */	362	* even if the scope is formally dead. */
346		363
347	if (UNIT(s)->cgroup_path) {	364	if (u->cgroup_path) {
348	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);	365	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
349	if (r <= 0)	366	if (r <= 0)
350	return true;	367	return true;
Lines 353-358 Link Here
353	return false;	370	return false;
354	}	371	}
355		372
		373	static void scope_notify_cgroup_empty_event(Unit *u) {
		374	Scope *s = SCOPE(u);
		375
		376	assert(u);
		377
		378	log_debug_unit(u->id, "%s: cgroup is empty", u->id);
		379
		380	if (s->state == SCOPE_RUNNING \|\| s->state == SCOPE_ABANDONED \|\|
		381	s->state == SCOPE_STOP_SIGTERM \|\| SCOPE_STOP_SIGKILL)
		382	scope_enter_dead(s, SCOPE_SUCCESS);
		383	}
		384
		385	static void scope_sigchld_event(Unit *u, pid_t pid, int code, int status) {
		386	/* If we get a SIGCHLD event for one of the processes we were
		387	interested in, then we look for others to watch, under the
		388	assumption that we'll sooner or later get a SIGCHLD for
		389	them, as the original process we watched was probably the
		390	parent of them, and they are hence now our children. */
		391
		392	unit_tidy_watch_pids(u, 0, 0);
		393	unit_watch_all_pids(u);
		394
		395	/* If the PID set is empty now, then let's finish this off */
		396	if (set_isempty(u->pids))
		397	scope_notify_cgroup_empty_event(u);
		398	}
		399
356	static void scope_timer_event(Unit u, uint64_t elapsed, Watchw) {	400	static void scope_timer_event(Unit u, uint64_t elapsed, Watchw) {
357	Scope *s = SCOPE(u);	401	Scope *s = SCOPE(u);
358		402
Lines 383-406 Link Here
383	}	427	}
384	}	428	}
385		429
386	static void scope_notify_cgroup_empty_event(Unit *u) {	430	int scope_abandon(Scope *s) {
387	Scope *s = SCOPE(u);	431	assert(s);
388	assert(u);
389		432
390	log_debug_unit(u->id, "%s: cgroup is empty", u->id);	433	if (s->state != SCOPE_RUNNING && s->state != SCOPE_ABANDONED)
		434	return -ESTALE;
391		435
392	switch (s->state) {	436	free(s->controller);
		437	s->controller = NULL;
393		438
394	case SCOPE_RUNNING:	439	/* The client is no longer watching the remaining processes,
395	case SCOPE_STOP_SIGTERM:	440	* so let's step in here, under the assumption that the
396	case SCOPE_STOP_SIGKILL:	441	* remaining processes will be sooner or later reassigned to
397	scope_enter_dead(s, SCOPE_SUCCESS);	442	* us as parent. */
398		443
399	break;	444	unit_tidy_watch_pids(UNIT(s), 0, 0);
		445	unit_watch_all_pids(UNIT(s));
400		446
401	default:	447	/* If the PID set is empty now, then let's finish this off */
402	;	448	if (set_isempty(UNIT(s)->pids))
403	}	449	scope_notify_cgroup_empty_event(UNIT(s));
		450	else
		451	scope_set_state(s, SCOPE_ABANDONED);
		452
		453	return 0;
404	}	454	}
405		455
406	_pure_ static UnitActiveState scope_active_state(Unit *u) {	456	_pure_ static UnitActiveState scope_active_state(Unit *u) {
Lines 418-423 Link Here
418	static const char* const scope_state_table[_SCOPE_STATE_MAX] = {	468	static const char* const scope_state_table[_SCOPE_STATE_MAX] = {
419	[SCOPE_DEAD] = "dead",	469	[SCOPE_DEAD] = "dead",
420	[SCOPE_RUNNING] = "running",	470	[SCOPE_RUNNING] = "running",
		471	[SCOPE_ABANDONED] = "abandoned",
421	[SCOPE_STOP_SIGTERM] = "stop-sigterm",	472	[SCOPE_STOP_SIGTERM] = "stop-sigterm",
422	[SCOPE_STOP_SIGKILL] = "stop-sigkill",	473	[SCOPE_STOP_SIGKILL] = "stop-sigkill",
423	[SCOPE_FAILED] = "failed",	474	[SCOPE_FAILED] = "failed",
Lines 467-472 Link Here
467		518
468	.check_gc = scope_check_gc,	519	.check_gc = scope_check_gc,
469		520
		521	.sigchld_event = scope_sigchld_event,
		522
470	.timer_event = scope_timer_event,	523	.timer_event = scope_timer_event,
471		524
472	.reset_failed = scope_reset_failed,	525	.reset_failed = scope_reset_failed,




typedef enum ScopeState {
        SCOPE_DEAD,
        SCOPE_RUNNING,
        SCOPE_ABANDONED,
        SCOPE_STOP_SIGTERM,
        SCOPE_STOP_SIGKILL,
        SCOPE_FAILED,


        usec_t timeout_stop_usec;

        char *controller;

        Watch timer_watch;
};

extern const UnitVTable scope_vtable;

int scope_abandon(Scope *s);

const char* scope_state_to_string(ScopeState i) _const_;
ScopeState scope_state_from_string(const char *s) _pure_;


Lines 1612-1617 Link Here

(-)systemd-208.mod.bck/src/core/service.c (-56 / +84 lines)
1612	s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;	1612	s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1613	}	1613	}
1614		1614
		1615	if (state == SERVICE_DEAD \|\|
		1616	state == SERVICE_FAILED \|\|
		1617	state == SERVICE_AUTO_RESTART)
		1618	unit_unwatch_all_pids(UNIT(s));
		1619
1615	if (state != SERVICE_START_PRE &&	1620	if (state != SERVICE_START_PRE &&
1616	state != SERVICE_START &&	1621	state != SERVICE_START &&
1617	state != SERVICE_START_POST &&	1622	state != SERVICE_START_POST &&
Lines 1711-1718 Link Here
1711	return r;	1716	return r;
1712	}	1717	}
1713		1718
		1719	if (s->deserialized_state != SERVICE_DEAD &&
		1720	s->deserialized_state != SERVICE_FAILED &&
		1721	s->deserialized_state != SERVICE_AUTO_RESTART)
		1722	unit_watch_all_pids(UNIT(s));
		1723
1714	if (s->deserialized_state == SERVICE_START_POST \|\|	1724	if (s->deserialized_state == SERVICE_START_POST \|\|
1715	s->deserialized_state == SERVICE_RUNNING)	1725	s->deserialized_state == SERVICE_RUNNING \|\|
		1726	s->deserialized_state == SERVICE_RELOAD)
1716	service_handle_watchdog(s);	1727	service_handle_watchdog(s);
1717		1728
1718	service_set_state(s, s->deserialized_state);	1729	service_set_state(s, s->deserialized_state);
Lines 2020-2025 Link Here
2020	s->result = f;	2031	s->result = f;
2021		2032
2022	service_unwatch_control_pid(s);	2033	service_unwatch_control_pid(s);
		2034	unit_watch_all_pids(UNIT(s));
2023		2035
2024	s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];	2036	s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
2025	if (s->control_command) {	2037	if (s->control_command) {
Lines 2060-2065 Link Here
2060	if (f != SERVICE_SUCCESS)	2072	if (f != SERVICE_SUCCESS)
2061	s->result = f;	2073	s->result = f;
2062		2074
		2075	unit_watch_all_pids(UNIT(s));
		2076
2063	r = unit_kill_context(	2077	r = unit_kill_context(
2064	UNIT(s),	2078	UNIT(s),
2065	&s->kill_context,	2079	&s->kill_context,
Lines 2105-2110 Link Here
2105	s->result = f;	2119	s->result = f;
2106		2120
2107	service_unwatch_control_pid(s);	2121	service_unwatch_control_pid(s);
		2122	unit_watch_all_pids(UNIT(s));
2108		2123
2109	s->control_command = s->exec_command[SERVICE_EXEC_STOP];	2124	s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2110	if (s->control_command) {	2125	if (s->control_command) {
Lines 3016-3021 Link Here
3016	service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);	3031	service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
3017	}	3032	}
3018		3033
		3034	static void service_notify_cgroup_empty_event(Unit *u) {
		3035	Service *s = SERVICE(u);
		3036
		3037	assert(u);
		3038
		3039	log_debug_unit(u->id, "%s: cgroup is empty", u->id);
		3040
		3041	switch (s->state) {
		3042
		3043	/* Waiting for SIGCHLD is usually more interesting,
		3044	* because it includes return codes/signals. Which is
		3045	* why we ignore the cgroup events for most cases,
		3046	* except when we don't know pid which to expect the
		3047	* SIGCHLD for. */
		3048
		3049	case SERVICE_START:
		3050	case SERVICE_START_POST:
		3051	/* If we were hoping for the daemon to write its PID file,
		3052	* we can give up now. */
		3053	if (s->pid_file_pathspec) {
		3054	log_warning_unit(u->id,
		3055	"%s never wrote its PID file. Failing.", UNIT(s)->id);
		3056	service_unwatch_pid_file(s);
		3057	if (s->state == SERVICE_START)
		3058	service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
		3059	else
		3060	service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
		3061	}
		3062	break;
		3063
		3064	case SERVICE_RUNNING:
		3065	/* service_enter_running() will figure out what to do */
		3066	service_enter_running(s, SERVICE_SUCCESS);
		3067	break;
		3068
		3069	case SERVICE_STOP_SIGTERM:
		3070	case SERVICE_STOP_SIGKILL:
		3071
		3072	if (main_pid_good(s) <= 0 && !control_pid_good(s))
		3073	service_enter_stop_post(s, SERVICE_SUCCESS);
		3074
		3075	break;
		3076
		3077	case SERVICE_STOP_POST:
		3078	case SERVICE_FINAL_SIGTERM:
		3079	case SERVICE_FINAL_SIGKILL:
		3080	if (main_pid_good(s) <= 0 && !control_pid_good(s))
		3081	service_enter_dead(s, SERVICE_SUCCESS, true);
		3082
		3083	break;
		3084
		3085	default:
		3086	;
		3087	}
		3088	}
		3089
3019	static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {	3090	static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
3020	Service *s = SERVICE(u);	3091	Service *s = SERVICE(u);
3021	ServiceResult f;	3092	ServiceResult f;
Lines 3284-3289 Link Here
3284		3355
3285	/* Notify clients about changed exit status */	3356	/* Notify clients about changed exit status */
3286	unit_add_to_dbus_queue(u);	3357	unit_add_to_dbus_queue(u);
		3358
		3359	/* We got one SIGCHLD for the service, let's watch all
		3360	* processes that are now running of the service, and watch
		3361	* that. Among the PIDs we then watch will be children
		3362	* reassigned to us, which hopefully allows us to identify
		3363	* when all children are gone */
		3364	unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
		3365	unit_watch_all_pids(u);
		3366
		3367	/* If the PID set is empty now, then let's finish this off */
		3368	if (set_isempty(u->pids))
		3369	service_notify_cgroup_empty_event(u);
3287	}	3370	}
3288		3371
3289	static void service_timer_event(Unit u, uint64_t elapsed, Watch w) {	3372	static void service_timer_event(Unit u, uint64_t elapsed, Watch w) {
Lines 3387-3447 Link Here
3387	}	3470	}
3388	}	3471	}
3389		3472
3390	static void service_notify_cgroup_empty_event(Unit *u) {
3391	Service *s = SERVICE(u);
3392
3393	assert(u);
3394
3395	log_debug_unit(u->id, "%s: cgroup is empty", u->id);
3396
3397	switch (s->state) {
3398
3399	/* Waiting for SIGCHLD is usually more interesting,
3400	* because it includes return codes/signals. Which is
3401	* why we ignore the cgroup events for most cases,
3402	* except when we don't know pid which to expect the
3403	* SIGCHLD for. */
3404
3405	case SERVICE_START:
3406	case SERVICE_START_POST:
3407	/* If we were hoping for the daemon to write its PID file,
3408	* we can give up now. */
3409	if (s->pid_file_pathspec) {
3410	log_warning_unit(u->id,
3411	"%s never wrote its PID file. Failing.", UNIT(s)->id);
3412	service_unwatch_pid_file(s);
3413	if (s->state == SERVICE_START)
3414	service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3415	else
3416	service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3417	}
3418	break;
3419
3420	case SERVICE_RUNNING:
3421	/* service_enter_running() will figure out what to do */
3422	service_enter_running(s, SERVICE_SUCCESS);
3423	break;
3424
3425	case SERVICE_STOP_SIGTERM:
3426	case SERVICE_STOP_SIGKILL:
3427
3428	if (main_pid_good(s) <= 0 && !control_pid_good(s))
3429	service_enter_stop_post(s, SERVICE_SUCCESS);
3430
3431	break;
3432
3433	case SERVICE_FINAL_SIGTERM:
3434	case SERVICE_FINAL_SIGKILL:
3435	if (main_pid_good(s) <= 0 && !control_pid_good(s))
3436	service_enter_dead(s, SERVICE_SUCCESS, true);
3437
3438	break;
3439
3440	default:
3441	;
3442	}
3443	}
3444
3445	static void service_notify_message(Unit u, pid_t pid, char *tags) {	3473	static void service_notify_message(Unit u, pid_t pid, char *tags) {
3446	Service *s = SERVICE(u);	3474	Service *s = SERVICE(u);
3447	const char *e;	3475	const char *e;




                unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);

        if (s->forbid_restart)
                unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));

        return 0;
}

                        return log_oom();

                s->exec_context.var_tmp_dir = t;
        } else if (streq(key, "forbid-restart")) {
                int b;

                b = parse_boolean(value);
                if (b < 0)
                        log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
                else
                        s->forbid_restart = b;
        } else

Lines 472-477 Link Here

(-)systemd-208.mod.bck/src/core/unit.c (-1 / +111 lines)
472		472
473	set_free_free(u->names);	473	set_free_free(u->names);
474		474
		475	unit_unwatch_all_pids(u);
		476
475	condition_free_list(u->conditions);	477	condition_free_list(u->conditions);
476		478
477	unit_ref_unset(&u->slice);	479	unit_ref_unset(&u->slice);
Lines 1652-1664 Link Here
1652	}	1654	}
1653		1655
1654	int unit_watch_pid(Unit *u, pid_t pid) {	1656	int unit_watch_pid(Unit *u, pid_t pid) {
		1657	int q, r;
		1658
1655	assert(u);	1659	assert(u);
1656	assert(pid >= 1);	1660	assert(pid >= 1);
1657		1661
		1662	r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
		1663	if (r < 0)
		1664	return r;
		1665
1658	/* Watch a specific PID. We only support one unit watching	1666	/* Watch a specific PID. We only support one unit watching
1659	* each PID for now. */	1667	* each PID for now. */
1660		1668
1661	return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);	1669	r = set_put(u->pids, LONG_TO_PTR(pid));
		1670
		1671	q = hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
		1672	if (q < 0)
		1673	return q;
		1674
		1675	return r;
1662	}	1676	}
1663		1677
1664	void unit_unwatch_pid(Unit *u, pid_t pid) {	1678	void unit_unwatch_pid(Unit *u, pid_t pid) {
Lines 1666-1671 Link Here
1666	assert(pid >= 1);	1680	assert(pid >= 1);
1667		1681
1668	hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);	1682	hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
		1683	set_remove(u->pids, LONG_TO_PTR(pid));
		1684	}
		1685
		1686	static int watch_pids_in_path(Unit u, const char path) {
		1687	_cleanup_closedir_ DIR *d = NULL;
		1688	_cleanup_fclose_ FILE *f = NULL;
		1689	int ret = 0, r;
		1690
		1691	assert(u);
		1692	assert(path);
		1693
		1694	/* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
		1695
		1696	r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
		1697	if (r >= 0) {
		1698	pid_t pid;
		1699
		1700	while ((r = cg_read_pid(f, &pid)) > 0) {
		1701	r = unit_watch_pid(u, pid);
		1702	if (r < 0 && ret >= 0)
		1703	ret = r;
		1704	}
		1705	if (r < 0 && ret >= 0)
		1706	ret = r;
		1707
		1708	} else if (ret >= 0)
		1709	ret = r;
		1710
		1711	r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
		1712	if (r >= 0) {
		1713	char *fn;
		1714
		1715	while ((r = cg_read_subgroup(d, &fn)) > 0) {
		1716	_cleanup_free_ char *p = NULL;
		1717
		1718	p = strjoin(path, "/", fn, NULL);
		1719	free(fn);
		1720
		1721	if (!p)
		1722	return -ENOMEM;
		1723
		1724	r = watch_pids_in_path(u, p);
		1725	if (r < 0 && ret >= 0)
		1726	ret = r;
		1727	}
		1728	if (r < 0 && ret >= 0)
		1729	ret = r;
		1730
		1731	} else if (ret >= 0)
		1732	ret = r;
		1733
		1734	return ret;
		1735	}
		1736
		1737
		1738	int unit_watch_all_pids(Unit *u) {
		1739	assert(u);
		1740
		1741	if (!u->cgroup_path)
		1742	return -ENOENT;
		1743
		1744	/* Adds all PIDs from our cgroup to the set of PIDs we watch */
		1745
		1746	return watch_pids_in_path(u, u->cgroup_path);
1747	}
1748
1749	void unit_unwatch_all_pids(Unit *u) {
1750	Iterator i;
1751	void *e;
1752
1753	assert(u);
1754
1755	SET_FOREACH(e, u->pids, i)
1756	hashmap_remove_value(u->manager->watch_pids, e, u);
1757
1758	set_free(u->pids);
1759	u->pids = NULL;
1760	}
1761
1762	void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1763	Iterator i;
1764	void *e;
1765
1766	assert(u);
1767
1768	/* Cleans dead PIDs from our list */
1769
1770	SET_FOREACH(e, u->pids, i) {
1771	pid_t pid = PTR_TO_LONG(e);
1772
1773	if (pid == except1 \|\| pid == except2)
1774	continue;
1775
1776	if (kill(pid, 0) < 0 && errno == ESRCH)
1777	set_remove(u->pids, e);
1778	}
1669	}	1779	}
1670		1780
1671	int unit_watch_timer(Unit u, clockid_t clock_id, bool relative, usec_t usec, Watch w) {	1781	int unit_watch_timer(Unit u, clockid_t clock_id, bool relative, usec_t usec, Watch w) {




/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <assert.h>
#include <errno.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/timerfd.h>
#include <sys/poll.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>

#include "systemd/sd-id128.h"
#include "systemd/sd-messages.h"
#include "set.h"
#include "unit.h"
#include "macro.h"
#include "strv.h"
#include "path-util.h"
#include "load-fragment.h"
#include "load-dropin.h"
#include "log.h"
#include "unit-name.h"
#include "dbus-unit.h"
#include "special.h"
#include "cgroup-util.h"
#include "missing.h"
#include "mkdir.h"
#include "label.h"
#include "fileio-label.h"
#include "bus-errors.h"

const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
        [UNIT_SERVICE] = &service_vtable,
        [UNIT_TIMER] = &timer_vtable,
        [UNIT_SOCKET] = &socket_vtable,
        [UNIT_TARGET] = &target_vtable,
        [UNIT_DEVICE] = &device_vtable,
        [UNIT_MOUNT] = &mount_vtable,
        [UNIT_AUTOMOUNT] = &automount_vtable,
        [UNIT_SNAPSHOT] = &snapshot_vtable,
        [UNIT_SWAP] = &swap_vtable,
        [UNIT_PATH] = &path_vtable,
        [UNIT_SLICE] = &slice_vtable,
        [UNIT_SCOPE] = &scope_vtable
};

Unit *unit_new(Manager *m, size_t size) {
        Unit *u;

        assert(m);
        assert(size >= sizeof(Unit));

        u = malloc0(size);
        if (!u)
                return NULL;

        u->names = set_new(string_hash_func, string_compare_func);
        if (!u->names) {
                free(u);
                return NULL;
        }

        u->manager = m;
        u->type = _UNIT_TYPE_INVALID;
        u->deserialized_job = _JOB_TYPE_INVALID;
        u->default_dependencies = true;
        u->unit_file_state = _UNIT_FILE_STATE_INVALID;

        return u;
}

bool unit_has_name(Unit *u, const char *name) {
        assert(u);
        assert(name);

        return !!set_get(u->names, (char*) name);
}

int unit_add_name(Unit *u, const char *text) {
        UnitType t;
        char *s, *i = NULL;
        int r;

        assert(u);
        assert(text);

        if (unit_name_is_template(text)) {
                if (!u->instance)
                        return -EINVAL;

                s = unit_name_replace_instance(text, u->instance);
        } else
                s = strdup(text);

        if (!s)
                return -ENOMEM;

        if (!unit_name_is_valid(s, false)) {
                r = -EINVAL;
                goto fail;
        }

        assert_se((t = unit_name_to_type(s)) >= 0);

        if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
                r = -EINVAL;
                goto fail;
        }

        if ((r = unit_name_to_instance(s, &i)) < 0)
                goto fail;

        if (i && unit_vtable[t]->no_instances) {
                r = -EINVAL;
                goto fail;
        }

        /* Ensure that this unit is either instanced or not instanced,
         * but not both. */
        if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
                r = -EINVAL;
                goto fail;
        }

        if (unit_vtable[t]->no_alias &&
            !set_isempty(u->names) &&
            !set_get(u->names, s)) {
                r = -EEXIST;
                goto fail;
        }

        if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
                r = -E2BIG;
                goto fail;
        }

        if ((r = set_put(u->names, s)) < 0) {
                if (r == -EEXIST)
                        r = 0;
                goto fail;
        }

        if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
                set_remove(u->names, s);
                goto fail;
        }

        if (u->type == _UNIT_TYPE_INVALID) {

                u->type = t;
                u->id = s;
                u->instance = i;

                LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);

                if (UNIT_VTABLE(u)->init)
                        UNIT_VTABLE(u)->init(u);
        } else
                free(i);

        unit_add_to_dbus_queue(u);
        return 0;

fail:
        free(s);
        free(i);

        return r;
}

int unit_choose_id(Unit *u, const char *name) {
        char *s, *i;
        _cleanup_free_ char *t = NULL;
        int r;

        assert(u);
        assert(name);

        if (unit_name_is_template(name)) {

                if (!u->instance)
                        return -EINVAL;

                if (!(t = unit_name_replace_instance(name, u->instance)))
                        return -ENOMEM;

                name = t;
        }

        /* Selects one of the names of this unit as the id */
        s = set_get(u->names, (char*) name);

        if (!s)
                return -ENOENT;

        if ((r = unit_name_to_instance(s, &i)) < 0)
                return r;

        u->id = s;

        free(u->instance);
        u->instance = i;

        unit_add_to_dbus_queue(u);

        return 0;
}

int unit_set_description(Unit *u, const char *description) {
        char *s;

        assert(u);

        if (isempty(description))
                s = NULL;
        else {
                s = strdup(description);
                if (!s)
                        return -ENOMEM;
        }

        free(u->description);
        u->description = s;

        unit_add_to_dbus_queue(u);
        return 0;
}

bool unit_check_gc(Unit *u) {
        assert(u);

        if (u->load_state == UNIT_STUB)
                return true;

        if (UNIT_VTABLE(u)->no_gc)
                return true;

        if (u->no_gc)
                return true;

        if (u->job)
                return true;

        if (u->nop_job)
                return true;

        if (unit_active_state(u) != UNIT_INACTIVE)
                return true;

        if (u->refs)
                return true;

        if (UNIT_VTABLE(u)->check_gc)
                if (UNIT_VTABLE(u)->check_gc(u))
                        return true;

        return false;
}

void unit_add_to_load_queue(Unit *u) {
        assert(u);
        assert(u->type != _UNIT_TYPE_INVALID);

        if (u->load_state != UNIT_STUB || u->in_load_queue)
                return;

        LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
        u->in_load_queue = true;
}

void unit_add_to_cleanup_queue(Unit *u) {
        assert(u);

        if (u->in_cleanup_queue)
                return;

        LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
        u->in_cleanup_queue = true;
}

void unit_add_to_gc_queue(Unit *u) {
        assert(u);

        if (u->in_gc_queue || u->in_cleanup_queue)
                return;

        if (unit_check_gc(u))
                return;

        LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
        u->in_gc_queue = true;

        u->manager->n_in_gc_queue ++;
}

void unit_add_to_dbus_queue(Unit *u) {
        assert(u);
        assert(u->type != _UNIT_TYPE_INVALID);

        if (u->load_state == UNIT_STUB || u->in_dbus_queue)
                return;

        /* Shortcut things if nobody cares */
        if (!bus_has_subscriber(u->manager)) {
                u->sent_dbus_new_signal = true;
                return;
        }

        LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
        u->in_dbus_queue = true;
}

static void bidi_set_free(Unit *u, Set *s) {
        Iterator i;
        Unit *other;

        assert(u);

        /* Frees the set and makes sure we are dropped from the
         * inverse pointers */

        SET_FOREACH(other, s, i) {
                UnitDependency d;

                for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
                        set_remove(other->dependencies[d], u);

                unit_add_to_gc_queue(other);
        }

        set_free(s);
}

static void unit_remove_transient(Unit *u) {
        char **i;

        assert(u);

        if (!u->transient)
                return;

        if (u->fragment_path)
                unlink(u->fragment_path);

        STRV_FOREACH(i, u->dropin_paths) {
                _cleanup_free_ char *p = NULL;
                int r;

                unlink(*i);

                r = path_get_parent(*i, &p);
                if (r >= 0)
                        rmdir(p);
        }
}

static void unit_free_requires_mounts_for(Unit *u) {
        char **j;

        STRV_FOREACH(j, u->requires_mounts_for) {
                char s[strlen(*j) + 1];

                PATH_FOREACH_PREFIX_MORE(s, *j) {
                        char *y;
                        Set *x;

                        x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
                        if (!x)
                                continue;

                        set_remove(x, u);

                        if (set_isempty(x)) {
                                hashmap_remove(u->manager->units_requiring_mounts_for, y);
                                free(y);
                                set_free(x);
                        }
                }
        }

        strv_free(u->requires_mounts_for);
        u->requires_mounts_for = NULL;
}

void unit_free(Unit *u) {
        UnitDependency d;
        Iterator i;
        char *t;

        assert(u);

        if (u->manager->n_reloading <= 0)
                unit_remove_transient(u);

        bus_unit_send_removed_signal(u);

        if (u->load_state != UNIT_STUB)
                if (UNIT_VTABLE(u)->done)
                        UNIT_VTABLE(u)->done(u);

        unit_free_requires_mounts_for(u);

        SET_FOREACH(t, u->names, i)
                hashmap_remove_value(u->manager->units, t, u);

        if (u->job) {
                Job *j = u->job;
                job_uninstall(j);
                job_free(j);
        }

        if (u->nop_job) {
                Job *j = u->nop_job;
                job_uninstall(j);
                job_free(j);
        }

        for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
                bidi_set_free(u, u->dependencies[d]);

        if (u->type != _UNIT_TYPE_INVALID)
                LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);

        if (u->in_load_queue)
                LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);

        if (u->in_dbus_queue)
                LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);

        if (u->in_cleanup_queue)
                LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);

        if (u->in_gc_queue) {
                LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
                u->manager->n_in_gc_queue--;
        }

        if (u->in_cgroup_queue)
                LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);

        if (u->cgroup_path) {
                hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
                free(u->cgroup_path);
        }

        free(u->description);
        strv_free(u->documentation);
        free(u->fragment_path);
        free(u->source_path);
        strv_free(u->dropin_paths);
        free(u->instance);

        set_free_free(u->names);

        condition_free_list(u->conditions);

        unit_ref_unset(&u->slice);

        while (u->refs)
                unit_ref_unset(u->refs);

        free(u);
}

UnitActiveState unit_active_state(Unit *u) {
        assert(u);

        if (u->load_state == UNIT_MERGED)
                return unit_active_state(unit_follow_merge(u));

        /* After a reload it might happen that a unit is not correctly
         * loaded but still has a process around. That's why we won't
         * shortcut failed loading to UNIT_INACTIVE_FAILED. */

        return UNIT_VTABLE(u)->active_state(u);
}

const char* unit_sub_state_to_string(Unit *u) {
        assert(u);

        return UNIT_VTABLE(u)->sub_state_to_string(u);
}

static void complete_move(Set **s, Set **other) {
        assert(s);
        assert(other);

        if (!*other)
                return;

        if (*s)
                set_move(*s, *other);
        else {
                *s = *other;
                *other = NULL;
        }
}

static void merge_names(Unit *u, Unit *other) {
        char *t;
        Iterator i;

        assert(u);
        assert(other);

        complete_move(&u->names, &other->names);

        set_free_free(other->names);
        other->names = NULL;
        other->id = NULL;

        SET_FOREACH(t, u->names, i)
                assert_se(hashmap_replace(u->manager->units, t, u) == 0);
}

static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
        Iterator i;
        Unit *back;
        int r;

        assert(u);
        assert(other);
        assert(d < _UNIT_DEPENDENCY_MAX);

        /* Fix backwards pointers */
        SET_FOREACH(back, other->dependencies[d], i) {
                UnitDependency k;

                for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
                        if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {

                                if (r == -EEXIST)
                                        set_remove(back->dependencies[k], other);
                                else
                                        assert(r == -ENOENT);
                        }
        }

        complete_move(&u->dependencies[d], &other->dependencies[d]);

        set_free(other->dependencies[d]);
        other->dependencies[d] = NULL;
}

int unit_merge(Unit *u, Unit *other) {
        UnitDependency d;

        assert(u);
        assert(other);
        assert(u->manager == other->manager);
        assert(u->type != _UNIT_TYPE_INVALID);

        other = unit_follow_merge(other);

        if (other == u)
                return 0;

        if (u->type != other->type)
                return -EINVAL;

        if (!u->instance != !other->instance)
                return -EINVAL;

        if (other->load_state != UNIT_STUB &&
            other->load_state != UNIT_NOT_FOUND)
                return -EEXIST;

        if (other->job)
                return -EEXIST;

        if (other->nop_job)
                return -EEXIST;

        if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
                return -EEXIST;

        /* Merge names */
        merge_names(u, other);

        /* Redirect all references */
        while (other->refs)
                unit_ref_set(other->refs, u);

        /* Merge dependencies */
        for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
                merge_dependencies(u, other, d);

        other->load_state = UNIT_MERGED;
        other->merged_into = u;

        /* If there is still some data attached to the other node, we
         * don't need it anymore, and can free it. */
        if (other->load_state != UNIT_STUB)
                if (UNIT_VTABLE(other)->done)
                        UNIT_VTABLE(other)->done(other);

        unit_add_to_dbus_queue(u);
        unit_add_to_cleanup_queue(other);

        return 0;
}

int unit_merge_by_name(Unit *u, const char *name) {
        Unit *other;
        int r;
        _cleanup_free_ char *s = NULL;

        assert(u);
        assert(name);

        if (unit_name_is_template(name)) {
                if (!u->instance)
                        return -EINVAL;

                if (!(s = unit_name_replace_instance(name, u->instance)))
                        return -ENOMEM;

                name = s;
        }

        other = manager_get_unit(u->manager, name);
        if (!other)
                r = unit_add_name(u, name);
        else
                r = unit_merge(u, other);

        return r;
}

Unit* unit_follow_merge(Unit *u) {
        assert(u);

        while (u->load_state == UNIT_MERGED)
                assert_se(u = u->merged_into);

        return u;
}

int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
        int r;

        assert(u);
        assert(c);

        if (c->std_output != EXEC_OUTPUT_KMSG &&
            c->std_output != EXEC_OUTPUT_SYSLOG &&
            c->std_output != EXEC_OUTPUT_JOURNAL &&
            c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
            c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
            c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
            c->std_error != EXEC_OUTPUT_KMSG &&
            c->std_error != EXEC_OUTPUT_SYSLOG &&
            c->std_error != EXEC_OUTPUT_JOURNAL &&
            c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
            c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
            c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
                return 0;

        /* If syslog or kernel logging is requested, make sure our own
         * logging daemon is run first. */

        if (u->manager->running_as == SYSTEMD_SYSTEM) {
                r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
                if (r < 0)
                        return r;
        }

        return 0;
}

const char *unit_description(Unit *u) {
        assert(u);

        if (u->description)
                return u->description;

        return strna(u->id);
}

void unit_dump(Unit *u, FILE *f, const char *prefix) {
        char *t, **j;
        UnitDependency d;
        Iterator i;
        _cleanup_free_ char *p2 = NULL;
        const char *prefix2;
        char
                timestamp1[FORMAT_TIMESTAMP_MAX],
                timestamp2[FORMAT_TIMESTAMP_MAX],
                timestamp3[FORMAT_TIMESTAMP_MAX],
                timestamp4[FORMAT_TIMESTAMP_MAX],
                timespan[FORMAT_TIMESPAN_MAX];
        Unit *following;

        assert(u);
        assert(u->type >= 0);

        if (!prefix)
                prefix = "";
        p2 = strappend(prefix, "\t");
        prefix2 = p2 ? p2 : prefix;

        fprintf(f,
                "%s-> Unit %s:\n"
                "%s\tDescription: %s\n"
                "%s\tInstance: %s\n"
                "%s\tUnit Load State: %s\n"
                "%s\tUnit Active State: %s\n"
                "%s\tInactive Exit Timestamp: %s\n"
                "%s\tActive Enter Timestamp: %s\n"
                "%s\tActive Exit Timestamp: %s\n"
                "%s\tInactive Enter Timestamp: %s\n"
                "%s\tGC Check Good: %s\n"
                "%s\tNeed Daemon Reload: %s\n"
                "%s\tTransient: %s\n"
                "%s\tSlice: %s\n"
                "%s\tCGroup: %s\n"
                "%s\tCGroup realized: %s\n"
                "%s\tCGroup mask: 0x%x\n",
                prefix, u->id,
                prefix, unit_description(u),
                prefix, strna(u->instance),
                prefix, unit_load_state_to_string(u->load_state),
                prefix, unit_active_state_to_string(unit_active_state(u)),
                prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
                prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
                prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
                prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
                prefix, yes_no(unit_check_gc(u)),
                prefix, yes_no(unit_need_daemon_reload(u)),
                prefix, yes_no(u->transient),
                prefix, strna(unit_slice_name(u)),
                prefix, strna(u->cgroup_path),
                prefix, yes_no(u->cgroup_realized),
                prefix, u->cgroup_mask);

        SET_FOREACH(t, u->names, i)
                fprintf(f, "%s\tName: %s\n", prefix, t);

        STRV_FOREACH(j, u->documentation)
                fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);

        if ((following = unit_following(u)))
                fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);

        if (u->fragment_path)
                fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);

        if (u->source_path)
                fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);

        STRV_FOREACH(j, u->dropin_paths)
                fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);

        if (u->job_timeout > 0)
                fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));

        condition_dump_list(u->conditions, f, prefix);

        if (dual_timestamp_is_set(&u->condition_timestamp))
                fprintf(f,
                        "%s\tCondition Timestamp: %s\n"
                        "%s\tCondition Result: %s\n",
                        prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
                        prefix, yes_no(u->condition_result));

        for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
                Unit *other;

                SET_FOREACH(other, u->dependencies[d], i)
                        fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
        }

        if (!strv_isempty(u->requires_mounts_for)) {
                fprintf(f,
                        "%s\tRequiresMountsFor:", prefix);

                STRV_FOREACH(j, u->requires_mounts_for)
                        fprintf(f, " %s", *j);

                fputs("\n", f);
        }

        if (u->load_state == UNIT_LOADED) {

                fprintf(f,
                        "%s\tStopWhenUnneeded: %s\n"
                        "%s\tRefuseManualStart: %s\n"
                        "%s\tRefuseManualStop: %s\n"
                        "%s\tDefaultDependencies: %s\n"
                        "%s\tOnFailureIsolate: %s\n"
                        "%s\tIgnoreOnIsolate: %s\n"
                        "%s\tIgnoreOnSnapshot: %s\n",
                        prefix, yes_no(u->stop_when_unneeded),
                        prefix, yes_no(u->refuse_manual_start),
                        prefix, yes_no(u->refuse_manual_stop),
                        prefix, yes_no(u->default_dependencies),
                        prefix, yes_no(u->on_failure_isolate),
                        prefix, yes_no(u->ignore_on_isolate),
                        prefix, yes_no(u->ignore_on_snapshot));

                if (UNIT_VTABLE(u)->dump)
                        UNIT_VTABLE(u)->dump(u, f, prefix2);

        } else if (u->load_state == UNIT_MERGED)
                fprintf(f,
                        "%s\tMerged into: %s\n",
                        prefix, u->merged_into->id);
        else if (u->load_state == UNIT_ERROR)
                fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));


        if (u->job)
                job_dump(u->job, f, prefix2);

        if (u->nop_job)
                job_dump(u->nop_job, f, prefix2);

}

/* Common implementation for multiple backends */
int unit_load_fragment_and_dropin(Unit *u) {
        int r;

        assert(u);

        /* Load a .service file */
        r = unit_load_fragment(u);
        if (r < 0)
                return r;

        if (u->load_state == UNIT_STUB)
                return -ENOENT;

        /* Load drop-in directory data */
        r = unit_load_dropin(unit_follow_merge(u));
        if (r < 0)
                return r;

        return 0;
}

/* Common implementation for multiple backends */
int unit_load_fragment_and_dropin_optional(Unit *u) {
        int r;

        assert(u);

        /* Same as unit_load_fragment_and_dropin(), but whether
         * something can be loaded or not doesn't matter. */

        /* Load a .service file */
        r = unit_load_fragment(u);
        if (r < 0)
                return r;

        if (u->load_state == UNIT_STUB)
                u->load_state = UNIT_LOADED;

        /* Load drop-in directory data */
        r = unit_load_dropin(unit_follow_merge(u));
        if (r < 0)
                return r;

        return 0;
}

int unit_add_default_target_dependency(Unit *u, Unit *target) {
        assert(u);
        assert(target);

        if (target->type != UNIT_TARGET)
                return 0;

        /* Only add the dependency if both units are loaded, so that
         * that loop check below is reliable */
        if (u->load_state != UNIT_LOADED ||
            target->load_state != UNIT_LOADED)
                return 0;

        /* If either side wants no automatic dependencies, then let's
         * skip this */
        if (!u->default_dependencies ||
            !target->default_dependencies)
                return 0;

        /* Don't create loops */
        if (set_get(target->dependencies[UNIT_BEFORE], u))
                return 0;

        return unit_add_dependency(target, UNIT_AFTER, u, true);
}

static int unit_add_default_dependencies(Unit *u) {

        static const UnitDependency deps[] = {
                UNIT_REQUIRED_BY,
                UNIT_REQUIRED_BY_OVERRIDABLE,
                UNIT_WANTED_BY,
                UNIT_BOUND_BY
        };

        Unit *target;
        Iterator i;
        int r;
        unsigned k;

        assert(u);

        for (k = 0; k < ELEMENTSOF(deps); k++)
                SET_FOREACH(target, u->dependencies[deps[k]], i) {
                        r = unit_add_default_target_dependency(u, target);
                        if (r < 0)
                                return r;
                }

        if (u->default_dependencies && unit_get_cgroup_context(u)) {
                if (UNIT_ISSET(u->slice))
                        r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
                else
                        r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);

                if (r < 0)
                        return r;
        }

        return 0;
}

int unit_load(Unit *u) {
        int r;

        assert(u);

        if (u->in_load_queue) {
                LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
                u->in_load_queue = false;
        }

        if (u->type == _UNIT_TYPE_INVALID)
                return -EINVAL;

        if (u->load_state != UNIT_STUB)
                return 0;

        if (UNIT_VTABLE(u)->load) {
                r = UNIT_VTABLE(u)->load(u);
                if (r < 0)
                        goto fail;
        }

        if (u->load_state == UNIT_STUB) {
                r = -ENOENT;
                goto fail;
        }

        if (u->load_state == UNIT_LOADED) {

                if (u->default_dependencies) {
                        r = unit_add_default_dependencies(u);
                        if (r < 0)
                                goto fail;
                }

                r = unit_add_mount_links(u);
                if (r < 0)
                        goto fail;

                if (u->on_failure_isolate &&
                    set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {

                        log_error_unit(u->id,
                                       "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);

                        r = -EINVAL;
                        goto fail;
                }
        }

        assert((u->load_state != UNIT_MERGED) == !u->merged_into);

        unit_add_to_dbus_queue(unit_follow_merge(u));
        unit_add_to_gc_queue(u);

        return 0;

fail:
        u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
        u->load_error = r;
        unit_add_to_dbus_queue(u);
        unit_add_to_gc_queue(u);

        log_debug_unit(u->id, "Failed to load configuration for %s: %s",
                       u->id, strerror(-r));

        return r;
}

bool unit_condition_test(Unit *u) {
        assert(u);

        dual_timestamp_get(&u->condition_timestamp);
        u->condition_result = condition_test_list(u->id, u->conditions);

        return u->condition_result;
}

_pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
        const UnitStatusMessageFormats *format_table;

        assert(u);
        assert(t >= 0);
        assert(t < _JOB_TYPE_MAX);

        if (t != JOB_START && t != JOB_STOP)
                return NULL;

        format_table = &UNIT_VTABLE(u)->status_message_formats;
        if (!format_table)
                return NULL;

        return format_table->starting_stopping[t == JOB_STOP];
}

_pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
        const char *format;

        assert(u);
        assert(t >= 0);
        assert(t < _JOB_TYPE_MAX);

        format = unit_get_status_message_format(u, t);
        if (format)
                return format;

        /* Return generic strings */
        if (t == JOB_START)
                return "Starting %s.";
        else if (t == JOB_STOP)
                return "Stopping %s.";
        else if (t == JOB_RELOAD)
                return "Reloading %s.";

        return NULL;
}

static void unit_status_print_starting_stopping(Unit *u, JobType t) {
        const char *format;

        assert(u);

        /* We only print status messages for selected units on
         * selected operations. */

        format = unit_get_status_message_format(u, t);
        if (!format)
                return;

        unit_status_printf(u, "", format);
}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
        const char *format;
        char buf[LINE_MAX];
        sd_id128_t mid;

        assert(u);

        if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
                return;

        if (log_on_console())
                return;

        /* We log status messages for all units and all operations. */

        format = unit_get_status_message_format_try_harder(u, t);
        if (!format)
                return;

        snprintf(buf, sizeof(buf), format, unit_description(u));
        char_array_0(buf);

        mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
              t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
                               SD_MESSAGE_UNIT_RELOADING;

        log_struct_unit(LOG_INFO,
                        u->id,
                        MESSAGE_ID(mid),
                        "MESSAGE=%s", buf,
                        NULL);
}
#pragma GCC diagnostic pop

/* Errors:
 *         -EBADR:     This unit type does not support starting.
 *         -EALREADY:  Unit is already started.
 *         -EAGAIN:    An operation is already in progress. Retry later.
 *         -ECANCELED: Too many requests for now.
 */
int unit_start(Unit *u) {
        UnitActiveState state;
        Unit *following;

        assert(u);

        if (u->load_state != UNIT_LOADED)
                return -EINVAL;

        /* If this is already started, then this will succeed. Note
         * that this will even succeed if this unit is not startable
         * by the user. This is relied on to detect when we need to
         * wait for units and when waiting is finished. */
        state = unit_active_state(u);
        if (UNIT_IS_ACTIVE_OR_RELOADING(state))
                return -EALREADY;

        /* If the conditions failed, don't do anything at all. If we
         * already are activating this call might still be useful to
         * speed up activation in case there is some hold-off time,
         * but we don't want to recheck the condition in that case. */
        if (state != UNIT_ACTIVATING &&
            !unit_condition_test(u)) {
                log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
                return -EALREADY;
        }

        /* Forward to the main object, if we aren't it. */
        following = unit_following(u);
        if (following) {
                log_debug_unit(u->id, "Redirecting start request from %s to %s.",
                               u->id, following->id);
                return unit_start(following);
        }

        unit_status_log_starting_stopping_reloading(u, JOB_START);
        unit_status_print_starting_stopping(u, JOB_START);

        /* If it is stopped, but we cannot start it, then fail */
        if (!UNIT_VTABLE(u)->start)
                return -EBADR;

        /* We don't suppress calls to ->start() here when we are
         * already starting, to allow this request to be used as a
         * "hurry up" call, for example when the unit is in some "auto
         * restart" state where it waits for a holdoff timer to elapse
         * before it will start again. */

        unit_add_to_dbus_queue(u);

        return UNIT_VTABLE(u)->start(u);
}

bool unit_can_start(Unit *u) {
        assert(u);

        return !!UNIT_VTABLE(u)->start;
}

bool unit_can_isolate(Unit *u) {
        assert(u);

        return unit_can_start(u) &&
                u->allow_isolate;
}

/* Errors:
 *         -EBADR:    This unit type does not support stopping.
 *         -EALREADY: Unit is already stopped.
 *         -EAGAIN:   An operation is already in progress. Retry later.
 */
int unit_stop(Unit *u) {
        UnitActiveState state;
        Unit *following;

        assert(u);

        state = unit_active_state(u);
        if (UNIT_IS_INACTIVE_OR_FAILED(state))
                return -EALREADY;

        if ((following = unit_following(u))) {
                log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
                               u->id, following->id);
                return unit_stop(following);
        }

        unit_status_log_starting_stopping_reloading(u, JOB_STOP);
        unit_status_print_starting_stopping(u, JOB_STOP);

        if (!UNIT_VTABLE(u)->stop)
                return -EBADR;

        unit_add_to_dbus_queue(u);

        return UNIT_VTABLE(u)->stop(u);
}

/* Errors:
 *         -EBADR:    This unit type does not support reloading.
 *         -ENOEXEC:  Unit is not started.
 *         -EAGAIN:   An operation is already in progress. Retry later.
 */
int unit_reload(Unit *u) {
        UnitActiveState state;
        Unit *following;

        assert(u);

        if (u->load_state != UNIT_LOADED)
                return -EINVAL;

        if (!unit_can_reload(u))
                return -EBADR;

        state = unit_active_state(u);
        if (state == UNIT_RELOADING)
                return -EALREADY;

        if (state != UNIT_ACTIVE)
                return -ENOEXEC;

        if ((following = unit_following(u))) {
                log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
                               u->id, following->id);
                return unit_reload(following);
        }

        unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);

        unit_add_to_dbus_queue(u);
        return UNIT_VTABLE(u)->reload(u);
}

bool unit_can_reload(Unit *u) {
        assert(u);

        if (!UNIT_VTABLE(u)->reload)
                return false;

        if (!UNIT_VTABLE(u)->can_reload)
                return true;

        return UNIT_VTABLE(u)->can_reload(u);
}

static void unit_check_unneeded(Unit *u) {
        Iterator i;
        Unit *other;

        assert(u);

        /* If this service shall be shut down when unneeded then do
         * so. */

        if (!u->stop_when_unneeded)
                return;

        if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
                return;

        SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
                if (unit_active_or_pending(other))
                        return;

        SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
                if (unit_active_or_pending(other))
                        return;

        SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
                if (unit_active_or_pending(other))
                        return;

        SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
                if (unit_active_or_pending(other))
                        return;

        log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);

        /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
        manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
}

static void retroactively_start_dependencies(Unit *u) {
        Iterator i;
        Unit *other;

        assert(u);
        assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));

        SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
                if (!set_get(u->dependencies[UNIT_AFTER], other) &&
                    !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);

        SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
                if (!set_get(u->dependencies[UNIT_AFTER], other) &&
                    !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);

        SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
                if (!set_get(u->dependencies[UNIT_AFTER], other) &&
                    !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);

        SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
                if (!set_get(u->dependencies[UNIT_AFTER], other) &&
                    !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);

        SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);

        SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
}

static void retroactively_stop_dependencies(Unit *u) {
        Iterator i;
        Unit *other;

        assert(u);
        assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));

        /* Pull down units which are bound to us recursively if enabled */
        SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
}

static void check_unneeded_dependencies(Unit *u) {
        Iterator i;
        Unit *other;

        assert(u);
        assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));

        /* Garbage collect services that might not be needed anymore, if enabled */
        SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        unit_check_unneeded(other);
        SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        unit_check_unneeded(other);
        SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        unit_check_unneeded(other);
        SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        unit_check_unneeded(other);
        SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        unit_check_unneeded(other);
        SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
                if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                        unit_check_unneeded(other);
}

void unit_start_on_failure(Unit *u) {
        Unit *other;
        Iterator i;

        assert(u);

        if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
                return;

        log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);

        SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
                int r;

                r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
                if (r < 0)
                        log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
        }
}

void unit_trigger_notify(Unit *u) {
        Unit *other;
        Iterator i;

        assert(u);

        SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
                if (UNIT_VTABLE(other)->trigger_notify)
                        UNIT_VTABLE(other)->trigger_notify(other, u);
}

void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
        Manager *m;
        bool unexpected;

        assert(u);
        assert(os < _UNIT_ACTIVE_STATE_MAX);
        assert(ns < _UNIT_ACTIVE_STATE_MAX);

        /* Note that this is called for all low-level state changes,
         * even if they might map to the same high-level
         * UnitActiveState! That means that ns == os is OK an expected
         * behavior here. For example: if a mount point is remounted
         * this function will be called too! */

        m = u->manager;

        if (m->n_reloading <= 0) {
                dual_timestamp ts;

                dual_timestamp_get(&ts);

                if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
                        u->inactive_exit_timestamp = ts;
                else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
                        u->inactive_enter_timestamp = ts;

                if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
                        u->active_enter_timestamp = ts;
                else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
                        u->active_exit_timestamp = ts;
        }

        if (UNIT_IS_INACTIVE_OR_FAILED(ns))
                unit_destroy_cgroup(u);

        if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
                ExecContext *ec = unit_get_exec_context(u);
                if (ec && exec_context_may_touch_console(ec)) {
                        if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
                                m->n_on_console --;

                                if (m->n_on_console == 0)
                                        /* unset no_console_output flag, since the console is free */
                                        m->no_console_output = 0;
                        } else
                                m->n_on_console ++;
                }
        }

        if (u->job) {
                unexpected = false;

                if (u->job->state == JOB_WAITING)

                        /* So we reached a different state for this
                         * job. Let's see if we can run it now if it
                         * failed previously due to EAGAIN. */
                        job_add_to_run_queue(u->job);

                /* Let's check whether this state change constitutes a
                 * finished job, or maybe contradicts a running job and
                 * hence needs to invalidate jobs. */

                switch (u->job->type) {

                case JOB_START:
                case JOB_VERIFY_ACTIVE:

                        if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
                                job_finish_and_invalidate(u->job, JOB_DONE, true);
                        else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
                                unexpected = true;

                                if (UNIT_IS_INACTIVE_OR_FAILED(ns))
                                        job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
                        }

                        break;

                case JOB_RELOAD:
                case JOB_RELOAD_OR_START:

                        if (u->job->state == JOB_RUNNING) {
                                if (ns == UNIT_ACTIVE)
                                        job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
                                else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
                                        unexpected = true;

                                        if (UNIT_IS_INACTIVE_OR_FAILED(ns))
                                                job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
                                }
                        }

                        break;

                case JOB_STOP:
                case JOB_RESTART:
                case JOB_TRY_RESTART:

                        if (UNIT_IS_INACTIVE_OR_FAILED(ns))
                                job_finish_and_invalidate(u->job, JOB_DONE, true);
                        else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
                                unexpected = true;
                                job_finish_and_invalidate(u->job, JOB_FAILED, true);
                        }

                        break;

                default:
                        assert_not_reached("Job type unknown");
                }

        } else
                unexpected = true;

        if (m->n_reloading <= 0) {

                /* If this state change happened without being
                 * requested by a job, then let's retroactively start
                 * or stop dependencies. We skip that step when
                 * deserializing, since we don't want to create any
                 * additional jobs just because something is already
                 * activated. */

                if (unexpected) {
                        if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
                                retroactively_start_dependencies(u);
                        else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
                                retroactively_stop_dependencies(u);
                }

                /* stop unneeded units regardless if going down was expected or not */
                if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
                        check_unneeded_dependencies(u);

                if (ns != os && ns == UNIT_FAILED) {
                        log_notice_unit(u->id,
                                        "Unit %s entered failed state.", u->id);
                        unit_start_on_failure(u);
                }
        }

        /* Some names are special */
        if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {

                if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
                        /* The bus just might have become available,
                         * hence try to connect to it, if we aren't
                         * yet connected. */
                        bus_init(m, true);

                if (u->type == UNIT_SERVICE &&
                    !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
                    m->n_reloading <= 0) {
                        /* Write audit record if we have just finished starting up */
                        manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
                        u->in_audit = true;
                }

                if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
                        manager_send_unit_plymouth(m, u);

        } else {

                /* We don't care about D-Bus here, since we'll get an
                 * asynchronous notification for it anyway. */

                if (u->type == UNIT_SERVICE &&
                    UNIT_IS_INACTIVE_OR_FAILED(ns) &&
                    !UNIT_IS_INACTIVE_OR_FAILED(os) &&
                    m->n_reloading <= 0) {

                        /* Hmm, if there was no start record written
                         * write it now, so that we always have a nice
                         * pair */
                        if (!u->in_audit) {
                                manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);

                                if (ns == UNIT_INACTIVE)
                                        manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
                        } else
                                /* Write audit record if we have just finished shutting down */
                                manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);

                        u->in_audit = false;
                }
        }

        manager_recheck_journal(m);
        unit_trigger_notify(u);

        /* Maybe we finished startup and are now ready for being
         * stopped because unneeded? */
        if (u->manager->n_reloading <= 0)
                unit_check_unneeded(u);

        unit_add_to_dbus_queue(u);
        unit_add_to_gc_queue(u);
}

int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
        struct epoll_event ev = {
                .data.ptr = w,
                .events = events,
        };

        assert(u);
        assert(fd >= 0);
        assert(w);
        assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));

        if (epoll_ctl(u->manager->epoll_fd,
                      w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
                      fd,
                      &ev) < 0)
                return -errno;

        w->fd = fd;
        w->type = WATCH_FD;
        w->data.unit = u;

        return 0;
}

void unit_unwatch_fd(Unit *u, Watch *w) {
        assert(u);
        assert(w);

        if (w->type == WATCH_INVALID)
                return;

        assert(w->type == WATCH_FD);
        assert(w->data.unit == u);
        assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);

        w->fd = -1;
        w->type = WATCH_INVALID;
        w->data.unit = NULL;
}

int unit_watch_pid(Unit *u, pid_t pid) {
        assert(u);
        assert(pid >= 1);

        /* Watch a specific PID. We only support one unit watching
         * each PID for now. */

        return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
}

void unit_unwatch_pid(Unit *u, pid_t pid) {
        assert(u);
        assert(pid >= 1);

        hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
}

int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
        struct itimerspec its = {};
        int flags, fd;
        bool ours;

        assert(u);
        assert(w);
        assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));

        /* This will try to reuse the old timer if there is one */

        if (w->type == WATCH_UNIT_TIMER) {
                assert(w->data.unit == u);
                assert(w->fd >= 0);

                ours = false;
                fd = w->fd;
        } else if (w->type == WATCH_INVALID) {

                ours = true;
                fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
                if (fd < 0)
                        return -errno;
        } else
                assert_not_reached("Invalid watch type");

        if (usec <= 0) {
                /* Set absolute time in the past, but not 0, since we
                 * don't want to disarm the timer */
                its.it_value.tv_sec = 0;
                its.it_value.tv_nsec = 1;

                flags = TFD_TIMER_ABSTIME;
        } else {
                timespec_store(&its.it_value, usec);
                flags = relative ? 0 : TFD_TIMER_ABSTIME;
        }

        /* This will also flush the elapse counter */
        if (timerfd_settime(fd, flags, &its, NULL) < 0)
                goto fail;

        if (w->type == WATCH_INVALID) {
                struct epoll_event ev = {
                        .data.ptr = w,
                        .events = EPOLLIN,
                };

                if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
                        goto fail;
        }

        w->type = WATCH_UNIT_TIMER;
        w->fd = fd;
        w->data.unit = u;

        return 0;

fail:
        if (ours)
                close_nointr_nofail(fd);

        return -errno;
}

void unit_unwatch_timer(Unit *u, Watch *w) {
        assert(u);
        assert(w);

        if (w->type == WATCH_INVALID)
                return;

        assert(w->type == WATCH_UNIT_TIMER);
        assert(w->data.unit == u);
        assert(w->fd >= 0);

        assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
        close_nointr_nofail(w->fd);

        w->fd = -1;
        w->type = WATCH_INVALID;
        w->data.unit = NULL;
}

bool unit_job_is_applicable(Unit *u, JobType j) {
        assert(u);
        assert(j >= 0 && j < _JOB_TYPE_MAX);

        switch (j) {

        case JOB_VERIFY_ACTIVE:
        case JOB_START:
        case JOB_STOP:
        case JOB_NOP:
                return true;

        case JOB_RESTART:
        case JOB_TRY_RESTART:
                return unit_can_start(u);

        case JOB_RELOAD:
                return unit_can_reload(u);

        case JOB_RELOAD_OR_START:
                return unit_can_reload(u) && unit_can_start(u);

        default:
                assert_not_reached("Invalid job type");
        }
}

int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {

        static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
                [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
                [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
                [UNIT_WANTS] = UNIT_WANTED_BY,
                [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
                [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
                [UNIT_BINDS_TO] = UNIT_BOUND_BY,
                [UNIT_PART_OF] = UNIT_CONSISTS_OF,
                [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
                [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
                [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
                [UNIT_BOUND_BY] = UNIT_BINDS_TO,
                [UNIT_CONSISTS_OF] = UNIT_PART_OF,
                [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
                [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
                [UNIT_BEFORE] = UNIT_AFTER,
                [UNIT_AFTER] = UNIT_BEFORE,
                [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
                [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
                [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
                [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
                [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
                [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
                [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
        };
        int r, q = 0, v = 0, w = 0;

        assert(u);
        assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
        assert(other);

        u = unit_follow_merge(u);
        other = unit_follow_merge(other);

        /* We won't allow dependencies on ourselves. We will not
         * consider them an error however. */
        if (u == other)
                return 0;

        if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
                return r;

        if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
                if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
                        return r;

        if (add_reference)
                if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
                    (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
                        return r;

        if ((q = set_put(u->dependencies[d], other)) < 0)
                return q;

        if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
                if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
                        r = v;
                        goto fail;
                }

        if (add_reference) {
                if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
                        r = w;
                        goto fail;
                }

                if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
                        goto fail;
        }

        unit_add_to_dbus_queue(u);
        return 0;

fail:
        if (q > 0)
                set_remove(u->dependencies[d], other);

        if (v > 0)
                set_remove(other->dependencies[inverse_table[d]], u);

        if (w > 0)
                set_remove(u->dependencies[UNIT_REFERENCES], other);

        return r;
}

int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
        int r;

        assert(u);

        if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
                return r;

        if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
                return r;

        return 0;
}

static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
        char *s;

        assert(u);
        assert(name || path);
        assert(p);

        if (!name)
                name = path_get_file_name(path);

        if (!unit_name_is_template(name)) {
                *p = NULL;
                return name;
        }

        if (u->instance)
                s = unit_name_replace_instance(name, u->instance);
        else {
                _cleanup_free_ char *i = NULL;

                i = unit_name_to_prefix(u->id);
                if (!i)
                        return NULL;

                s = unit_name_replace_instance(name, i);
        }

        if (!s)
                return NULL;

        *p = s;
        return s;
}

int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
        Unit *other;
        int r;
        _cleanup_free_ char *s = NULL;

        assert(u);
        assert(name || path);

        name = resolve_template(u, name, path, &s);
        if (!name)
                return -ENOMEM;

        r = manager_load_unit(u->manager, name, path, NULL, &other);
        if (r < 0)
                return r;

        return unit_add_dependency(u, d, other, add_reference);
}

int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
        Unit *other;
        int r;
        _cleanup_free_ char *s = NULL;

        assert(u);
        assert(name || path);

        if (!(name = resolve_template(u, name, path, &s)))
                return -ENOMEM;

        if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
                return r;

        r = unit_add_two_dependencies(u, d, e, other, add_reference);

        return r;
}

int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
        Unit *other;
        int r;
        _cleanup_free_ char *s = NULL;

        assert(u);
        assert(name || path);

        if (!(name = resolve_template(u, name, path, &s)))
                return -ENOMEM;

        if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
                return r;

        r = unit_add_dependency(other, d, u, add_reference);

        return r;
}

int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
        Unit *other;
        int r;
        _cleanup_free_ char *s = NULL;

        assert(u);
        assert(name || path);

        if (!(name = resolve_template(u, name, path, &s)))
                return -ENOMEM;

        if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
                return r;

        if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
                return r;

        return r;
}

int set_unit_path(const char *p) {
        _cleanup_free_ char *c = NULL;

        /* This is mostly for debug purposes */
        c = path_make_absolute_cwd(p);
        if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
                return -errno;

        return 0;
}

char *unit_dbus_path(Unit *u) {
        assert(u);

        if (!u->id)
                return NULL;

        return unit_dbus_path_from_name(u->id);
}

char *unit_default_cgroup_path(Unit *u) {
        _cleanup_free_ char *escaped = NULL, *slice = NULL;
        int r;

        assert(u);

        if (unit_has_name(u, SPECIAL_ROOT_SLICE))
                return strdup(u->manager->cgroup_root);

        if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
                r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
                if (r < 0)
                        return NULL;
        }

        escaped = cg_escape(u->id);
        if (!escaped)
                return NULL;

        if (slice)
                return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
        else
                return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
}

int unit_add_default_slice(Unit *u) {
        _cleanup_free_ char *b = NULL;
        const char *slice_name;
        Unit *slice;
        int r;

        assert(u);

        if (UNIT_ISSET(u->slice))
                return 0;

        if (!unit_get_cgroup_context(u))
                return 0;

        if (u->instance) {
                _cleanup_free_ char *prefix = NULL, *escaped = NULL;

                /* Implicitly place all instantiated units in their
                 * own per-template slice */

                prefix = unit_name_to_prefix(u->id);
                if (!prefix)
                        return -ENOMEM;

                /* The prefix is already escaped, but it might include
                 * "-" which has a special meaning for slice units,
                 * hence escape it here extra. */
                escaped = strreplace(prefix, "-", "\\x2d");
                if (!escaped)
                        return -ENOMEM;

                if (u->manager->running_as == SYSTEMD_SYSTEM)
                        b = strjoin("system-", escaped, ".slice", NULL);
                else
                        b = strappend(escaped, ".slice");
                if (!b)
                        return -ENOMEM;

                slice_name = b;
        } else
                slice_name =
                        u->manager->running_as == SYSTEMD_SYSTEM
                        ? SPECIAL_SYSTEM_SLICE
                        : SPECIAL_ROOT_SLICE;

        r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
        if (r < 0)
                return r;

        unit_ref_set(&u->slice, slice);
        return 0;
}

const char *unit_slice_name(Unit *u) {
        assert(u);

        if (!UNIT_ISSET(u->slice))
                return NULL;

        return UNIT_DEREF(u->slice)->id;
}

int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
        _cleanup_free_ char *t = NULL;
        int r;

        assert(u);
        assert(type);
        assert(_found);

        t = unit_name_change_suffix(u->id, type);
        if (!t)
                return -ENOMEM;

        assert(!unit_has_name(u, t));

        r = manager_load_unit(u->manager, t, NULL, NULL, _found);
        assert(r < 0 || *_found != u);
        return r;
}

int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
        _cleanup_free_ char *t = NULL;
        Unit *found;

        assert(u);
        assert(type);
        assert(_found);

        t = unit_name_change_suffix(u->id, type);
        if (!t)
                return -ENOMEM;

        assert(!unit_has_name(u, t));

        found = manager_get_unit(u->manager, t);
        if (!found)
                return -ENOENT;

        *_found = found;
        return 0;
}

int unit_watch_bus_name(Unit *u, const char *name) {
        assert(u);
        assert(name);

        /* Watch a specific name on the bus. We only support one unit
         * watching each name for now. */

        return hashmap_put(u->manager->watch_bus, name, u);
}

void unit_unwatch_bus_name(Unit *u, const char *name) {
        assert(u);
        assert(name);

        hashmap_remove_value(u->manager->watch_bus, name, u);
}

bool unit_can_serialize(Unit *u) {
        assert(u);

        return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
}

int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
        int r;

        assert(u);
        assert(f);
        assert(fds);

        if (!unit_can_serialize(u))
                return 0;

        r = UNIT_VTABLE(u)->serialize(u, f, fds);
        if (r < 0)
                return r;


        if (serialize_jobs) {
                if (u->job) {
                        fprintf(f, "job\n");
                        job_serialize(u->job, f, fds);
                }

                if (u->nop_job) {
                        fprintf(f, "job\n");
                        job_serialize(u->nop_job, f, fds);
                }
        }

        dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
        dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
        dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
        dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
        dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);

        if (dual_timestamp_is_set(&u->condition_timestamp))
                unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));

        unit_serialize_item(u, f, "transient", yes_no(u->transient));

        if (u->cgroup_path)
                unit_serialize_item(u, f, "cgroup", u->cgroup_path);

        /* End marker */
        fputc('\n', f);
        return 0;
}

void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
        va_list ap;

        assert(u);
        assert(f);
        assert(key);
        assert(format);

        fputs(key, f);
        fputc('=', f);

        va_start(ap, format);
        vfprintf(f, format, ap);
        va_end(ap);

        fputc('\n', f);
}

void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
        assert(u);
        assert(f);
        assert(key);
        assert(value);

        fprintf(f, "%s=%s\n", key, value);
}

int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
        int r;

        assert(u);
        assert(f);
        assert(fds);

        if (!unit_can_serialize(u))
                return 0;

        for (;;) {
                char line[LINE_MAX], *l, *v;
                size_t k;

                if (!fgets(line, sizeof(line), f)) {
                        if (feof(f))
                                return 0;
                        return -errno;
                }

                char_array_0(line);
                l = strstrip(line);

                /* End marker */
                if (l[0] == 0)
                        return 0;

                k = strcspn(l, "=");

                if (l[k] == '=') {
                        l[k] = 0;
                        v = l+k+1;
                } else
                        v = l+k;

                if (streq(l, "job")) {
                        if (v[0] == '\0') {
                                /* new-style serialized job */
                                Job *j = job_new_raw(u);
                                if (!j)
                                        return -ENOMEM;

                                r = job_deserialize(j, f, fds);
                                if (r < 0) {
                                        job_free(j);
                                        return r;
                                }

                                r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
                                if (r < 0) {
                                        job_free(j);
                                        return r;
                                }

                                r = job_install_deserialized(j);
                                if (r < 0) {
                                        hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
                                        job_free(j);
                                        return r;
                                }

                                if (j->state == JOB_RUNNING)
                                        u->manager->n_running_jobs++;
                        } else {
                                /* legacy */
                                JobType type = job_type_from_string(v);
                                if (type < 0)
                                        log_debug("Failed to parse job type value %s", v);
                                else
                                        u->deserialized_job = type;
                        }
                        continue;
                } else if (streq(l, "inactive-exit-timestamp")) {
                        dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
                        continue;
                } else if (streq(l, "active-enter-timestamp")) {
                        dual_timestamp_deserialize(v, &u->active_enter_timestamp);
                        continue;
                } else if (streq(l, "active-exit-timestamp")) {
                        dual_timestamp_deserialize(v, &u->active_exit_timestamp);
                        continue;
                } else if (streq(l, "inactive-enter-timestamp")) {
                        dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
                        continue;
                } else if (streq(l, "condition-timestamp")) {
                        dual_timestamp_deserialize(v, &u->condition_timestamp);
                        continue;
                } else if (streq(l, "condition-result")) {
                        int b;

                        b = parse_boolean(v);
                        if (b < 0)
                                log_debug("Failed to parse condition result value %s", v);
                        else
                                u->condition_result = b;

                        continue;

                } else if (streq(l, "transient")) {
                        int b;

                        b = parse_boolean(v);
                        if (b < 0)
                                log_debug("Failed to parse transient bool %s", v);
                        else
                                u->transient = b;

                        continue;
                } else if (streq(l, "cgroup")) {
                        char *s;

                        s = strdup(v);
                        if (!s)
                                return -ENOMEM;

                        free(u->cgroup_path);
                        u->cgroup_path = s;

                        assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
                        continue;
                }

                r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
                if (r < 0)
                        return r;
        }
}

int unit_add_node_link(Unit *u, const char *what, bool wants) {
        Unit *device;
        _cleanup_free_ char *e = NULL;
        int r;

        assert(u);

        if (!what)
                return 0;

        /* Adds in links to the device node that this unit is based on */

        if (!is_device_path(what))
                return 0;

        e = unit_name_from_path(what, ".device");
        if (!e)
                return -ENOMEM;

        r = manager_load_unit(u->manager, e, NULL, NULL, &device);

        if (r < 0)
                return r;

        r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
        if (r < 0)
                return r;

        if (wants) {
                r = unit_add_dependency(device, UNIT_WANTS, u, false);
                if (r < 0)
                        return r;
        }

        return 0;
}

int unit_coldplug(Unit *u) {
        int r;

        assert(u);

        if (UNIT_VTABLE(u)->coldplug)
                if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
                        return r;

        if (u->job) {
                r = job_coldplug(u->job);
                if (r < 0)
                        return r;
        } else if (u->deserialized_job >= 0) {
                /* legacy */
                r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
                if (r < 0)
                        return r;

                u->deserialized_job = _JOB_TYPE_INVALID;
        }

        return 0;
}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
        manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
}
#pragma GCC diagnostic pop

bool unit_need_daemon_reload(Unit *u) {
        _cleanup_strv_free_ char **t = NULL;
        char **path;
        struct stat st;
        unsigned loaded_cnt, current_cnt;

        assert(u);

        if (u->fragment_path) {
                zero(st);
                if (stat(u->fragment_path, &st) < 0)
                        /* What, cannot access this anymore? */
                        return true;

                if (u->fragment_mtime > 0 &&
                    timespec_load(&st.st_mtim) != u->fragment_mtime)
                        return true;
        }

        if (u->source_path) {
                zero(st);
                if (stat(u->source_path, &st) < 0)
                        return true;

                if (u->source_mtime > 0 &&
                    timespec_load(&st.st_mtim) != u->source_mtime)
                        return true;
        }

        t = unit_find_dropin_paths(u);
        loaded_cnt = strv_length(t);
        current_cnt = strv_length(u->dropin_paths);

        if (loaded_cnt == current_cnt) {
                if (loaded_cnt == 0)
                        return false;

                if (strv_overlap(u->dropin_paths, t)) {
                        STRV_FOREACH(path, u->dropin_paths) {
                                zero(st);
                                if (stat(*path, &st) < 0)
                                        return true;

                                if (u->dropin_mtime > 0 &&
                                    timespec_load(&st.st_mtim) > u->dropin_mtime)
                                        return true;
                        }

                        return false;
                } else
                        return true;
        } else
                return true;
}

void unit_reset_failed(Unit *u) {
        assert(u);

        if (UNIT_VTABLE(u)->reset_failed)
                UNIT_VTABLE(u)->reset_failed(u);
}

Unit *unit_following(Unit *u) {
        assert(u);

        if (UNIT_VTABLE(u)->following)
                return UNIT_VTABLE(u)->following(u);

        return NULL;
}

bool unit_stop_pending(Unit *u) {
        assert(u);

        /* This call does check the current state of the unit. It's
         * hence useful to be called from state change calls of the
         * unit itself, where the state isn't updated yet. This is
         * different from unit_inactive_or_pending() which checks both
         * the current state and for a queued job. */

        return u->job && u->job->type == JOB_STOP;
}

bool unit_inactive_or_pending(Unit *u) {
        assert(u);

        /* Returns true if the unit is inactive or going down */

        if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
                return true;

        if (unit_stop_pending(u))
                return true;

        return false;
}

bool unit_active_or_pending(Unit *u) {
        assert(u);

        /* Returns true if the unit is active or going up */

        if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
                return true;

        if (u->job &&
            (u->job->type == JOB_START ||
             u->job->type == JOB_RELOAD_OR_START ||
             u->job->type == JOB_RESTART))
                return true;

        return false;
}

int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
        assert(u);
        assert(w >= 0 && w < _KILL_WHO_MAX);
        assert(signo > 0);
        assert(signo < _NSIG);

        if (!UNIT_VTABLE(u)->kill)
                return -ENOTSUP;

        return UNIT_VTABLE(u)->kill(u, w, signo, error);
}

static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
        Set *pid_set;
        int r;

        pid_set = set_new(trivial_hash_func, trivial_compare_func);
        if (!pid_set)
                return NULL;

        /* Exclude the main/control pids from being killed via the cgroup */
        if (main_pid > 0) {
                r = set_put(pid_set, LONG_TO_PTR(main_pid));
                if (r < 0)
                        goto fail;
        }

        if (control_pid > 0) {
                r = set_put(pid_set, LONG_TO_PTR(control_pid));
                if (r < 0)
                        goto fail;
        }

        return pid_set;

fail:
        set_free(pid_set);
        return NULL;
}

int unit_kill_common(
                Unit *u,
                KillWho who,
                int signo,
                pid_t main_pid,
                pid_t control_pid,
                DBusError *error) {

        int r = 0;

        if (who == KILL_MAIN && main_pid <= 0) {
                if (main_pid < 0)
                        dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
                else
                        dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
                return -ESRCH;
        }

        if (who == KILL_CONTROL && control_pid <= 0) {
                if (control_pid < 0)
                        dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
                else
                        dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
                return -ESRCH;
        }

        if (who == KILL_CONTROL || who == KILL_ALL)
                if (control_pid > 0)
                        if (kill(control_pid, signo) < 0)
                                r = -errno;

        if (who == KILL_MAIN || who == KILL_ALL)
                if (main_pid > 0)
                        if (kill(main_pid, signo) < 0)
                                r = -errno;

        if (who == KILL_ALL && u->cgroup_path) {
                _cleanup_set_free_ Set *pid_set = NULL;
                int q;

                /* Exclude the main/control pids from being killed via the cgroup */
                pid_set = unit_pid_set(main_pid, control_pid);
                if (!pid_set)
                        return -ENOMEM;

                q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
                if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
                        r = q;
        }

        return r;
}

int unit_following_set(Unit *u, Set **s) {
        assert(u);
        assert(s);

        if (UNIT_VTABLE(u)->following_set)
                return UNIT_VTABLE(u)->following_set(u, s);

        *s = NULL;
        return 0;
}

UnitFileState unit_get_unit_file_state(Unit *u) {
        assert(u);

        if (u->unit_file_state < 0 && u->fragment_path)
                u->unit_file_state = unit_file_get_state(
                                u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
                                NULL, path_get_file_name(u->fragment_path));

        return u->unit_file_state;
}

Unit* unit_ref_set(UnitRef *ref, Unit *u) {
        assert(ref);
        assert(u);

        if (ref->unit)
                unit_ref_unset(ref);

        ref->unit = u;
        LIST_PREPEND(UnitRef, refs, u->refs, ref);
        return u;
}

void unit_ref_unset(UnitRef *ref) {
        assert(ref);

        if (!ref->unit)
                return;

        LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
        ref->unit = NULL;
}

int unit_add_mount_links(Unit *u) {
        char **i;
        int r;

        assert(u);

        STRV_FOREACH(i, u->requires_mounts_for) {
                char prefix[strlen(*i) + 1];

                PATH_FOREACH_PREFIX_MORE(prefix, *i) {
                        Unit *m;

                        r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                continue;
                        if (m == u)
                                continue;

                        if (m->load_state != UNIT_LOADED)
                                continue;

                        r = unit_add_dependency(u, UNIT_AFTER, m, true);
                        if (r < 0)
                                return r;

                        if (m->fragment_path) {
                                r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
                                if (r < 0)
                                        return r;
                        }
                }
        }

        return 0;
}

int unit_exec_context_defaults(Unit *u, ExecContext *c) {
        unsigned i;
        int r;

        assert(u);
        assert(c);

        /* This only copies in the ones that need memory */
        for (i = 0; i < RLIMIT_NLIMITS; i++)
                if (u->manager->rlimit[i] && !c->rlimit[i]) {
                        c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
                        if (!c->rlimit[i])
                                return -ENOMEM;
                }

        if (u->manager->running_as == SYSTEMD_USER &&
            !c->working_directory) {

                r = get_home_dir(&c->working_directory);
                if (r < 0)
                        return r;
        }

        return 0;
}

ExecContext *unit_get_exec_context(Unit *u) {
        size_t offset;
        assert(u);

        offset = UNIT_VTABLE(u)->exec_context_offset;
        if (offset <= 0)
                return NULL;

        return (ExecContext*) ((uint8_t*) u + offset);
}

CGroupContext *unit_get_cgroup_context(Unit *u) {
        size_t offset;

        offset = UNIT_VTABLE(u)->cgroup_context_offset;
        if (offset <= 0)
                return NULL;

        return (CGroupContext*) ((uint8_t*) u + offset);
}

static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
        _cleanup_free_ char *b = NULL;
        char *p, *q;
        int r;

        assert(u);
        assert(name);
        assert(_p);
        assert(_q);
        assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));

        b = xescape(name, "/.");
        if (!b)
                return -ENOMEM;

        if (!filename_is_safe(b))
                return -EINVAL;

        if (u->manager->running_as == SYSTEMD_USER) {
                _cleanup_free_ char *c = NULL;

                r = user_config_home(&c);
                if (r < 0)
                        return r;
                if (r == 0)
                        return -ENOENT;

                p = strjoin(c, "/", u->id, ".d", NULL);
        } else if (mode & UNIT_PERSISTENT)
                p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
        else
                p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
        if (!p)
                return -ENOMEM;

        q = strjoin(p, "/90-", b, ".conf", NULL);
        if (!q) {
                free(p);
                return -ENOMEM;
        }

        *_p = p;
        *_q = q;
        return 0;
}

int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
        _cleanup_free_ char *p = NULL, *q = NULL;
        int r;

        assert(u);
        assert(name);
        assert(data);

        if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
                return 0;

        r = drop_in_file(u, mode, name, &p, &q);
        if (r < 0)
                return r;

        mkdir_p(p, 0755);
        return write_string_file_atomic_label(q, data);
}

int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
        _cleanup_free_ char *p = NULL;
        va_list ap;
        int r;

        assert(u);
        assert(name);
        assert(format);

        if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
                return 0;

        va_start(ap, format);
        r = vasprintf(&p, format, ap);
        va_end(ap);

        if (r < 0)
                return -ENOMEM;

        return unit_write_drop_in(u, mode, name, p);
}

int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
        _cleanup_free_ char *ndata = NULL;

        assert(u);
        assert(name);
        assert(data);

        if (!UNIT_VTABLE(u)->private_section)
                return -EINVAL;

        if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
                return 0;

        ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
        if (!ndata)
                return -ENOMEM;

        return unit_write_drop_in(u, mode, name, ndata);
}

int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
        _cleanup_free_ char *p = NULL;
        va_list ap;
        int r;

        assert(u);
        assert(name);
        assert(format);

        if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
                return 0;

        va_start(ap, format);
        r = vasprintf(&p, format, ap);
        va_end(ap);

        if (r < 0)
                return -ENOMEM;

        return unit_write_drop_in_private(u, mode, name, p);
}

int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
        _cleanup_free_ char *p = NULL, *q = NULL;
        int r;

        assert(u);

        if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
                return 0;

        r = drop_in_file(u, mode, name, &p, &q);
        if (r < 0)
                return r;

        if (unlink(q) < 0)
                r = errno == ENOENT ? 0 : -errno;
        else
                r = 1;

        rmdir(p);
        return r;
}

int unit_make_transient(Unit *u) {
        int r;

        assert(u);

        u->load_state = UNIT_STUB;
        u->load_error = 0;
        u->transient = true;

        free(u->fragment_path);
        u->fragment_path = NULL;

        if (u->manager->running_as == SYSTEMD_USER) {
                _cleanup_free_ char *c = NULL;

                r = user_config_home(&c);
                if (r < 0)
                        return r;
                if (r == 0)
                        return -ENOENT;

                u->fragment_path = strjoin(c, "/", u->id, NULL);
                if (!u->fragment_path)
                        return -ENOMEM;

                mkdir_p(c, 0755);
        } else {
                u->fragment_path = strappend("/run/systemd/system/", u->id);
                if (!u->fragment_path)
                        return -ENOMEM;

                mkdir_p("/run/systemd/system", 0755);
        }

        return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
}

int unit_kill_context(
                Unit *u,
                KillContext *c,
                bool sigkill,
                pid_t main_pid,
                pid_t control_pid,
                bool main_pid_alien) {

        int sig, wait_for_exit = 0, r;

        assert(u);
        assert(c);

        if (c->kill_mode == KILL_NONE)
                return 0;

        sig = sigkill ? SIGKILL : c->kill_signal;

        if (main_pid > 0) {
                r = kill_and_sigcont(main_pid, sig);

                if (r < 0 && r != -ESRCH) {
                        _cleanup_free_ char *comm = NULL;
                        get_process_comm(main_pid, &comm);

                        log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
                                         (long) main_pid, strna(comm), strerror(-r));
                } else {
                        wait_for_exit = !main_pid_alien;

                        if (c->send_sighup)
                                kill(main_pid, SIGHUP);
                }
        }

        if (control_pid > 0) {
                r = kill_and_sigcont(control_pid, sig);

                if (r < 0 && r != -ESRCH) {
                        _cleanup_free_ char *comm = NULL;
                        get_process_comm(control_pid, &comm);

                        log_warning_unit(u->id,
                                         "Failed to kill control process %li (%s): %s",
                                         (long) control_pid, strna(comm), strerror(-r));
                } else {
                        wait_for_exit = true;

                        if (c->send_sighup)
                                kill(control_pid, SIGHUP);
                }
        }

        if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
                _cleanup_set_free_ Set *pid_set = NULL;

                /* Exclude the main/control pids from being killed via the cgroup */
                pid_set = unit_pid_set(main_pid, control_pid);
                if (!pid_set)
                        return -ENOMEM;

                r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
                if (r < 0) {
                        if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
                                log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
                } else if (r > 0) {
                        wait_for_exit = true;
                        if (c->send_sighup) {
                                set_free(pid_set);

                                pid_set = unit_pid_set(main_pid, control_pid);
                                if (!pid_set)
                                        return -ENOMEM;

                                cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
                        }
                }
        }

        return wait_for_exit;
}

int unit_require_mounts_for(Unit *u, const char *path) {
        char prefix[strlen(path) + 1], *p;
        int r;

        assert(u);
        assert(path);

        /* Registers a unit for requiring a certain path and all its
         * prefixes. We keep a simple array of these paths in the
         * unit, since its usually short. However, we build a prefix
         * table for all possible prefixes so that new appearing mount
         * units can easily determine which units to make themselves a
         * dependency of. */

        p = strdup(path);
        if (!p)
                return -ENOMEM;

        path_kill_slashes(p);

        if (!path_is_absolute(p)) {
                free(p);
                return -EINVAL;
        }

        if (!path_is_safe(p)) {
                free(p);
                return -EPERM;
        }

        if (strv_contains(u->requires_mounts_for, p)) {
                free(p);
                return 0;
        }

        r = strv_push(&u->requires_mounts_for, p);
        if (r < 0) {
                free(p);
                return r;
        }

        PATH_FOREACH_PREFIX_MORE(prefix, p) {
                Set *x;

                x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
                if (!x) {
                        char *q;

                        if (!u->manager->units_requiring_mounts_for) {
                                u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
                                if (!u->manager->units_requiring_mounts_for)
                                        return -ENOMEM;
                        }

                        q = strdup(prefix);
                        if (!q)
                                return -ENOMEM;

                        x = set_new(NULL, NULL);
                        if (!x) {
                                free(q);
                                return -ENOMEM;
                        }

                        r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
                        if (r < 0) {
                                free(q);
                                set_free(x);
                                return r;
                        }
                }

                r = set_put(x, u);
                if (r < 0)
                        return r;
        }

        return 0;
}

static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
        [UNIT_ACTIVE] = "active",
        [UNIT_RELOADING] = "reloading",
        [UNIT_INACTIVE] = "inactive",
        [UNIT_FAILED] = "failed",
        [UNIT_ACTIVATING] = "activating",
        [UNIT_DEACTIVATING] = "deactivating"
};

DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);

static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
        [UNIT_REQUIRES] = "Requires",
        [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
        [UNIT_REQUISITE] = "Requisite",
        [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
        [UNIT_WANTS] = "Wants",
        [UNIT_BINDS_TO] = "BindsTo",
        [UNIT_PART_OF] = "PartOf",
        [UNIT_REQUIRED_BY] = "RequiredBy",
        [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
        [UNIT_WANTED_BY] = "WantedBy",
        [UNIT_BOUND_BY] = "BoundBy",
        [UNIT_CONSISTS_OF] = "ConsistsOf",
        [UNIT_CONFLICTS] = "Conflicts",
        [UNIT_CONFLICTED_BY] = "ConflictedBy",
        [UNIT_BEFORE] = "Before",
        [UNIT_AFTER] = "After",
        [UNIT_ON_FAILURE] = "OnFailure",
        [UNIT_TRIGGERS] = "Triggers",
        [UNIT_TRIGGERED_BY] = "TriggeredBy",
        [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
        [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
        [UNIT_REFERENCES] = "References",
        [UNIT_REFERENCED_BY] = "ReferencedBy",
};

DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);

Lines 198-203 Link Here

(-)systemd-208.mod.bck/src/core/unit.h (+9 lines)
198	/* CGroup realize members queue */	198	/* CGroup realize members queue */
199	LIST_FIELDS(Unit, cgroup_queue);	199	LIST_FIELDS(Unit, cgroup_queue);
200		200
		201	/* PIDs we keep an eye on. Note that a unit might have many
		202	* more, but these are the ones we care enough about to
		203	* process SIGCHLD for */
		204	Set *pids;
		205
201	/* Used during GC sweeps */	206	/* Used during GC sweeps */
202	unsigned gc_marker;	207	unsigned gc_marker;
203		208
Lines 531-536 Link Here
531		536
532	int unit_watch_pid(Unit *u, pid_t pid);	537	int unit_watch_pid(Unit *u, pid_t pid);
533	void unit_unwatch_pid(Unit *u, pid_t pid);	538	void unit_unwatch_pid(Unit *u, pid_t pid);
		539	int unit_watch_all_pids(Unit *u);
		540	void unit_unwatch_all_pids(Unit *u);
		541
		542	void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2);
534		543
535	int unit_watch_timer(Unit u, clockid_t, bool relative, usec_t usec, Watch w);	544	int unit_watch_timer(Unit u, clockid_t, bool relative, usec_t usec, Watch w);
536	void unit_unwatch_timer(Unit u, Watch w);	545	void unit_unwatch_timer(Unit u, Watch w);




        m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
        m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
        m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
        m->timer_fds = hashmap_new(trivial_hash_func, trivial_compare_func);

        if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->busnames ||
            !m->user_units || !m->session_units ||
            !m->session_fds || !m->inhibitor_fds || !m->button_fds || !m->timer_fds) {
                manager_free(m);
                return NULL;
        }

        hashmap_free(m->session_fds);
        hashmap_free(m->inhibitor_fds);
        hashmap_free(m->button_fds);
        hashmap_free(m->timer_fds);

        if (m->console_active_fd >= 0)
                close_nointr_nofail(m->console_active_fd);

                return;
        }

        s = hashmap_get(m->timer_fds, INT_TO_PTR(fd + 1));
        if (s) {
                assert(s->timer_fd == fd);
                session_stop(s);
                return;
        }

        i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));
        if (i) {
                assert(i->fifo_fd == fd);

                LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
                session->in_gc_queue = false;

                /* First, if we are not closing yet, initiate stopping */
                if (!session_check_gc(session, drop_not_started) &&
                    session_get_state(session) != SESSION_CLOSING)
                        session_stop(session);

                if (!session_check_gc(session, drop_not_started)) {
                        session_finalize(session);
                        session_free(session);
                }

                LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
                user->in_gc_queue = false;

                if (!user_check_gc(user, drop_not_started) &&
                    user_get_state(user) != USER_CLOSING)
                        user_stop(user);

                if (!user_check_gc(user, drop_not_started)) {
                        user_finalize(user);
                        user_free(user);
                }


        return r;
}

int manager_startup(Manager *m) {
        int r;
        Seat *seat;




                if (!session)
                        return bus_send_error_reply(connection, message, &error, -ENOENT);

                session_release(session);
                process invoking PAM dies abnormally. We need to make
                sure that that process is not killed if at the clean
                end of the session it closes the FIFO. Hence, with
                this call explicitly turn off the FIFO logic, so that
                the PAM code can finish clean up on its own */
                session_remove_fifo(session);

                reply = dbus_message_new_method_return(message);
                if (!reply)

                const char *slice,
                const char *description,
                const char *after,
                const char *after2,
                DBusError *error,
                char **job) {

        const char *send_sighup_property = "SendSIGHUP", *pids_property = "PIDs", *after_property = "After";
        _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
        DBusMessageIter iter, sub, sub2, sub3, sub4;
        uint64_t timeout = 500 * USEC_PER_MSEC;
        dbus_bool_t send_sighup = true;
        const char *fail = "fail";
        uint32_t u;

        }

        if (!isempty(after)) {
                const char *after_property = "After";

                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) ||
                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) ||

                        return log_oom();
        }

        if (!isempty(after2)) {
                const char *kill_mode_property = "KillMode";

                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) ||
                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) ||
                    !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "s", &sub4) ||
                    !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_STRING, &after2) ||
                    !dbus_message_iter_close_container(&sub3, &sub4) ||
                    !dbus_message_iter_close_container(&sub2, &sub3) ||
                    !dbus_message_iter_close_container(&sub, &sub2))
                        return log_oom();

         * stop timeout for sessions, so that we don't wait
         * forever. */

        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
            !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &timeout_stop_property) ||
            !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "t", &sub3) ||
            !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &timeout) ||
            !dbus_message_iter_close_container(&sub2, &sub3) ||
            !dbus_message_iter_close_container(&sub, &sub2))
                return log_oom();

        /* Make sure that the session shells are terminated with
         * SIGHUP since bash and friends tend to ignore SIGTERM */
        if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||

        }

        return 1;
}

int manager_abandon_scope(Manager *manager, const char *scope, DBusError *error) {
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
        _cleanup_free_ char *path = NULL;
        int r;

        assert(manager);
        assert(scope);

        path = unit_dbus_path_from_name(scope);
        if (!path)
                return -ENOMEM;

        r = bus_method_call_with_reply(
                manager->bus,
                "org.freedesktop.systemd1",
                path,
                "org.freedesktop.systemd1.Scope",
                "Abandon",
                &reply,
                error,
                DBUS_TYPE_INVALID);

        if (r < 0) {
                log_error("Failed to abandon scope %s", scope);
                return r;
        }

        return 1;
}

int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error) {




        Hashmap *session_fds;
        Hashmap *inhibitor_fds;
        Hashmap *button_fds;
        Hashmap *timer_fds;

        usec_t inhibit_delay_max;



int manager_dispatch_delayed(Manager *manager);

int manager_start_scope(Manager *manager, const char *scope, pid_t pid, const char *slice, const char *description, const char *after, const char *after2, DBusError *error, char **job);
int manager_start_unit(Manager *manager, const char *unit, DBusError *error, char **job);
int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char **job);
int manager_abandon_scope(Manager *manager, const char *scope, DBusError *error);
int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error);
int manager_unit_is_active(Manager *manager, const char *unit);


Lines 24-29 Link Here

(-)systemd-208.mod.bck/src/login/logind-session.c (-29 / +104 lines)
24	#include <unistd.h>	24	#include <unistd.h>
25	#include <sys/epoll.h>	25	#include <sys/epoll.h>
26	#include <fcntl.h>	26	#include <fcntl.h>
		27	#include <sys/timerfd.h>
27		28
28	#include <systemd/sd-id128.h>	29	#include <systemd/sd-id128.h>
29	#include <systemd/sd-messages.h>	30	#include <systemd/sd-messages.h>
Lines 36-41 Link Here
36	#include "dbus-common.h"	37	#include "dbus-common.h"
37	#include "logind-session.h"	38	#include "logind-session.h"
38		39
		40	#define RELEASE_SEC 20
		41
39	static unsigned devt_hash_func(const void *p) {	42	static unsigned devt_hash_func(const void *p) {
40	uint64_t u = (const dev_t)p;	43	uint64_t u = (const dev_t)p;
41		44
Lines 86-91 Link Here
86		89
87	s->manager = m;	90	s->manager = m;
88	s->fifo_fd = -1;	91	s->fifo_fd = -1;
		92	s->timer_fd = -1;
89		93
90	return s;	94	return s;
91	}	95	}
Lines 505-511 Link Here
505		509
506	if (!s->scope) {	510	if (!s->scope) {
507	_cleanup_free_ char *description = NULL;	511	_cleanup_free_ char *description = NULL;
508	const char *kill_mode;
509	char scope, job;	512	char scope, job;
510		513
511	description = strjoin("Session ", s->id, " of user ", s->user->name, NULL);	514	description = strjoin("Session ", s->id, " of user ", s->user->name, NULL);
Lines 516-524 Link Here
516	if (!scope)	519	if (!scope)
517	return log_oom();	520	return log_oom();
518		521
519	kill_mode = manager_shall_kill(s->manager, s->user->name) ? "control-group" : "none";	522	r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-logind.service", "systemd-user-sessions.service", &error, &job);
520
521	r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-user-sessions.service", kill_mode, &error, &job);
522	if (r < 0) {	523	if (r < 0) {
523	log_error("Failed to start session scope %s: %s %s",	524	log_error("Failed to start session scope %s: %s %s",
524	scope, bus_error(&error, r), error.name);	525	scope, bus_error(&error, r), error.name);
Lines 579-601 Link Here
579		580
580	s->started = true;	581	s->started = true;
581		582
582	/* Save session data */	583	/* Save data */
583	session_save(s);	584	session_save(s);
584	user_save(s->user);	585	user_save(s->user);
		586	if (s->seat)
		587	seat_save(s->seat);
585		588
		589	/* Send signals */
586	session_send_signal(s, true);	590	session_send_signal(s, true);
		591	user_send_changed(s->user, "Sessions\0");
587		592
588	if (s->seat) {	593	if (s->seat) {
589	seat_save(s->seat);
590
591	if (s->seat->active == s)	594	if (s->seat->active == s)
592	seat_send_changed(s->seat, "Sessions\0ActiveSession\0");	595	seat_send_changed(s->seat, "Sessions\0ActiveSession\0");
593	else	596	else
594	seat_send_changed(s->seat, "Sessions\0");	597	seat_send_changed(s->seat, "Sessions\0");
595	}	598	}
596		599
597	user_send_changed(s->user, "Sessions\0");
598
599	return 0;	600	return 0;
600	}	601	}
601		602
Lines 611-625 Link Here
611	if (!s->scope)	612	if (!s->scope)
612	return 0;	613	return 0;
613		614
614	r = manager_stop_unit(s->manager, s->scope, &error, &job);	615	if (manager_shall_kill(s->manager, s->user->name)) {
615	if (r < 0) {	616	r = manager_stop_unit(s->manager, s->scope, &error, &job);
616	log_error("Failed to stop session scope: %s", bus_error(&error, r));	617	if (r < 0) {
617	dbus_error_free(&error);	618	log_error("Failed to stop session scope: %s", bus_error(&error, r));
618	return r;	619	dbus_error_free(&error);
619	}	620	return r;
		621	}
620		622
621	free(s->scope_job);	623	free(s->scope_job);
622	s->scope_job = job;	624	s->scope_job = job;
		625	} else {
		626	r = manager_abandon_scope(s->manager, s->scope, &error);
		627	if (r < 0) {
		628	log_error("Failed to abandon session scope: %s", bus_error(&error, r));
		629	dbus_error_free(&error);
		630	return r;
		631	}
		632	}
623		633
624	return 0;	634	return 0;
625	}	635	}
Lines 644-649 Link Here
644	return r < 0 ? -errno : 0;	654	return r < 0 ? -errno : 0;
645	}	655	}
646		656
		657	static void session_close_timer_fd(Session *s) {
		658	assert(s);
		659
		660	if (s->timer_fd <= 0)
		661	return;
		662
		663	hashmap_remove(s->manager->timer_fds, INT_TO_PTR(s->timer_fd + 1));
		664	epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->timer_fd, NULL);
		665
		666	close_nointr(s->timer_fd);
		667	s->timer_fd = -1;
		668	}
		669
647	int session_stop(Session *s) {	670	int session_stop(Session *s) {
648	int r;	671	int r;
649		672
Lines 652-661 Link Here
652	if (!s->user)	675	if (!s->user)
653	return -ESTALE;	676	return -ESTALE;
654		677
		678	session_close_timer_fd(s);
		679
		680	/* We are going down, don't care about FIFOs anymore */
		681	session_remove_fifo(s);
		682
655	/* Kill cgroup */	683	/* Kill cgroup */
656	r = session_stop_scope(s);	684	r = session_stop_scope(s);
657		685
		686	s->stopping = true;
		687
658	session_save(s);	688	session_save(s);
		689	user_save(s->user);
659		690
660	return r;	691	return r;
661	}	692	}
Lines 678-683 Link Here
678	"MESSAGE=Removed session %s.", s->id,	709	"MESSAGE=Removed session %s.", s->id,
679	NULL);	710	NULL);
680		711
		712	session_close_timer_fd(s);
		713
681	/* Kill session devices */	714	/* Kill session devices */
682	while ((sd = hashmap_first(s->devices)))	715	while ((sd = hashmap_first(s->devices)))
683	session_device_free(sd);	716	session_device_free(sd);
Lines 698-713 Link Here
698	if (s->seat->active == s)	731	if (s->seat->active == s)
699	seat_set_active(s->seat, NULL);	732	seat_set_active(s->seat, NULL);
700		733
701	seat_send_changed(s->seat, "Sessions\0");
702	seat_save(s->seat);	734	seat_save(s->seat);
		735	seat_send_changed(s->seat, "Sessions\0");
703	}	736	}
704		737
705	user_send_changed(s->user, "Sessions\0");
706	user_save(s->user);	738	user_save(s->user);
		739	user_send_changed(s->user, "Sessions\0");
707		740
708	return r;	741	return r;
709	}	742	}
710		743
		744	void session_release(Session *s) {
		745	int r;
		746
		747	struct itimerspec its = { .it_value.tv_sec = RELEASE_SEC };
		748	struct epoll_event ev = {};
		749
		750	assert(s);
		751
		752	if (!s->started \|\| s->stopping)
		753	return;
		754
		755	if (s->timer_fd >= 0)
		756	return;
		757
		758	s->timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK\|TFD_CLOEXEC);
		759	if (s->timer_fd < 0) {
		760	log_error("Failed to create session release timer fd");
		761	goto out;
		762	}
		763
		764	r = hashmap_put(s->manager->timer_fds, INT_TO_PTR(s->timer_fd + 1), s);
		765	if (r < 0) {
		766	log_error("Failed to store session release timer fd");
		767	goto out;
		768	}
		769
		770	ev.events = EPOLLONESHOT;
		771	ev.data.u32 = FD_OTHER_BASE + s->timer_fd;
		772
		773	r = epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->timer_fd, &ev);
		774	if (r < 0) {
		775	log_error("Failed to add session release timer fd to epoll instance");
		776	goto out;
		777	}
		778
		779	r = timerfd_settime(s->timer_fd, TFD_TIMER_ABSTIME, &its, NULL);
		780	if (r < 0) {
		781	log_error("Failed to arm timer : %m");
		782	goto out;
		783	}
		784
		785	out:
		786	if (s->timer_fd >= 0) {
		787	close_nointr(s->timer_fd);
		788	s->timer_fd = -1;
		789	}
		790	}
		791
711	bool session_is_active(Session *s) {	792	bool session_is_active(Session *s) {
712	assert(s);	793	assert(s);
713		794
Lines 904-911 Link Here
904	}	985	}
905		986
906	int session_check_gc(Session *s, bool drop_not_started) {	987	int session_check_gc(Session *s, bool drop_not_started) {
907	int r;
908
909	assert(s);	988	assert(s);
910		989
911	if (drop_not_started && !s->started)	990	if (drop_not_started && !s->started)
Lines 915-925 Link Here
915	return 0;	994	return 0;
916		995
917	if (s->fifo_fd >= 0) {	996	if (s->fifo_fd >= 0) {
918	r = pipe_eof(s->fifo_fd);	997	if (pipe_eof(s->fifo_fd) <= 0)
919	if (r < 0)
920	return r;
921
922	if (r == 0)
923	return 1;	998	return 1;
924	}	999	}
925		1000
Lines 945-959 Link Here
945	SessionState session_get_state(Session *s) {	1020	SessionState session_get_state(Session *s) {
946	assert(s);	1021	assert(s);
947		1022
		1023	if (s->stopping \|\| s->timer_fd >= 0)
		1024	return SESSION_CLOSING;
		1025
948	if (s->closing)	1026	if (s->closing)
949	return SESSION_CLOSING;	1027	return SESSION_CLOSING;
950		1028
951	if (s->scope_job)	1029	if (s->scope_job)
952	return SESSION_OPENING;	1030	return SESSION_OPENING;
953		1031
954	if (s->fifo_fd < 0)
955	return SESSION_CLOSING;
956
957	if (session_is_active(s))	1032	if (session_is_active(s))
958	return SESSION_ACTIVE;	1033	return SESSION_ACTIVE;
959		1034

Lines 98-108 Link Here

(-)systemd-208.mod.bck/src/login/logind-session.h (+4 lines)
98	int fifo_fd;	98	int fifo_fd;
99	char *fifo_path;	99	char *fifo_path;
100		100
		101	int timer_fd;
		102
101	bool idle_hint;	103	bool idle_hint;
102	dual_timestamp idle_hint_timestamp;	104	dual_timestamp idle_hint_timestamp;
103		105
104	bool in_gc_queue:1;	106	bool in_gc_queue:1;
105	bool started:1;	107	bool started:1;
		108	bool stopping:1;
106	bool closing:1;	109	bool closing:1;
107		110
108	DBusMessage *create_message;	111	DBusMessage *create_message;
Lines 130-135 Link Here
130	int session_start(Session *s);	133	int session_start(Session *s);
131	int session_stop(Session *s);	134	int session_stop(Session *s);
132	int session_finalize(Session *s);	135	int session_finalize(Session *s);
		136	void session_release(Session *s);
133	int session_save(Session *s);	137	int session_save(Session *s);
134	int session_load(Session *s);	138	int session_load(Session *s);
135	int session_kill(Session *s, KillWho who, int signo);	139	int session_kill(Session *s, KillWho who, int signo);

Lines 529-534 Link Here

(-)systemd-208.mod.bck/src/login/logind-user.c (-9 / +16 lines)
529	if (k < 0)	529	if (k < 0)
530	r = k;	530	r = k;
531		531
		532	u->stopping = true;
		533
532	user_save(u);	534	user_save(u);
533		535
534	return r;	536	return r;
Lines 644-669 Link Here
644		646
645	UserState user_get_state(User *u) {	647	UserState user_get_state(User *u) {
646	Session *i;	648	Session *i;
647	bool all_closing = true;
648		649
649	assert(u);	650	assert(u);
650		651
651	if (u->closing)	652	if (u->closing)
652	return USER_CLOSING;	653	return USER_CLOSING;
653		654
		655	if (u->stopping)
		656	return USER_CLOSING;
		657
654	if (u->slice_job \|\| u->service_job)	658	if (u->slice_job \|\| u->service_job)
655	return USER_OPENING;	659	return USER_OPENING;
656		660
657	LIST_FOREACH(sessions_by_user, i, u->sessions) {	661	if (u->sessions) {
658	if (session_is_active(i))	662	bool all_closing = true;
659	return USER_ACTIVE;
660	if (session_get_state(i) != SESSION_CLOSING)
661	all_closing = false;
662	}
663		663
664	if (u->sessions)	664	LIST_FOREACH(sessions_by_user, i, u->sessions) {
665	return all_closing ? USER_CLOSING : USER_ONLINE;	665	if (session_is_active(i))
		666	return USER_ACTIVE;
		667	if (session_get_state(i) != SESSION_CLOSING)
		668	all_closing = false;
		669	}
666		670
		671	return all_closing ? USER_CLOSING : USER_ONLINE;
		672	}
		673
667	if (user_check_linger_file(u) > 0)	674	if (user_check_linger_file(u) > 0)
668	return USER_LINGERING;	675	return USER_LINGERING;
669		676

Lines 61-66 Link Here

(-)systemd-208.mod.bck/src/login/logind-user.h (+1 lines)
61		61
62	bool in_gc_queue:1;	62	bool in_gc_queue:1;
63	bool started:1;	63	bool started:1;
		64	bool stopping:1;
64	bool closing:1;	65	bool closing:1;
65		66
66	LIST_HEAD(Session, sessions);	67	LIST_HEAD(Session, sessions);




                int flags,
                int argc, const char **argv) {

        const void *existing = NULL;
        const char *id;
        DBusConnection *bus = NULL;
        DBusMessage *m = NULL, *reply = NULL;

                }
        }


        /* Note that we are knowingly leaking the FIFO fd here. This
         * way, logind can watch us die. If we closed it here it would
         * not have any clue when that is completed. Given that one
         * cannot really have multiple PAM sessions open from the same
         * process this means we will leak one FD at max. */
        r = PAM_SUCCESS;

finish:
        pam_get_data(handle, "systemd.session-fd", &p);
        if (p)
                close_nointr(PTR_TO_INT(p) - 1);

        dbus_error_free(&error);


Lines 309-314 Link Here

(-)systemd-208.mod.bck/src/run/run.c (+8 lines)
309	if (r < 0)	309	if (r < 0)
310	return r;	310	return r;
311		311
		312	{
		313	const char *unique_id;
		314	sd_bus_get_unique_name(bus, &unique_id);
		315	r = sd_bus_message_append(m, "(sv)", "Controller", "s", unique_id);
		316	if (r < 0)
		317	return r;
		318	}
		319
312	r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, (uint32_t) getpid());	320	r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, (uint32_t) getpid());
313	if (r < 0)	321	if (r < 0)
314	return r;	322	return r;




/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdio.h>
#include <getopt.h>

#include "sd-bus.h"
#include "bus-internal.h"
#include "bus-message.h"
#include "strv.h"
#include "build.h"
#include "unit-name.h"
#include "path-util.h"

static bool arg_scope = false;
static bool arg_user = false;
static bool arg_remain_after_exit = false;
static const char *arg_unit = NULL;
static const char *arg_description = NULL;
static const char *arg_slice = NULL;
static bool arg_send_sighup = false;

static int help(void) {

        printf("%s [OPTIONS...] COMMAND [ARGS...]\n\n"
               "Run the specified command in a transient scope or service unit.\n\n"
               "  -h --help               Show this help\n"
               "     --version            Show package version\n"
               "     --user               Run as user unit\n"
               "     --scope              Run this as scope rather than service\n"
               "     --unit=UNIT          Run under the specified unit name\n"
               "     --description=TEXT   Description for unit\n"
               "     --slice=SLICE        Run in the specified slice\n"
               "  -r --remain-after-exit  Leave service around until explicitly stopped\n"
               "     --send-sighup        Send SIGHUP when terminating\n",
               program_invocation_short_name);

        return 0;
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_VERSION = 0x100,
                ARG_USER,
                ARG_SCOPE,
                ARG_UNIT,
                ARG_DESCRIPTION,
                ARG_SLICE,
                ARG_SEND_SIGHUP,
        };

        static const struct option options[] = {
                { "help",              no_argument,       NULL, 'h'             },
                { "version",           no_argument,       NULL, ARG_VERSION     },
                { "user",              no_argument,       NULL, ARG_USER        },
                { "scope",             no_argument,       NULL, ARG_SCOPE       },
                { "unit",              required_argument, NULL, ARG_UNIT        },
                { "description",       required_argument, NULL, ARG_DESCRIPTION },
                { "slice",             required_argument, NULL, ARG_SLICE       },
                { "remain-after-exit", no_argument,       NULL, 'r'             },
                { "send-sighup",       no_argument,       NULL, ARG_SEND_SIGHUP },
                { NULL,                0,                 NULL, 0               },
        };

        int c;

        assert(argc >= 0);
        assert(argv);

        while ((c = getopt_long(argc, argv, "+hr", options, NULL)) >= 0) {

                switch (c) {

                case 'h':
                        help();
                        return 0;

                case ARG_VERSION:
                        puts(PACKAGE_STRING);
                        puts(SYSTEMD_FEATURES);
                        return 0;

                case ARG_USER:
                        arg_user = true;
                        break;

                case ARG_SCOPE:
                        arg_scope = true;
                        break;

                case ARG_UNIT:
                        arg_unit = optarg;
                        break;

                case ARG_DESCRIPTION:
                        arg_description = optarg;
                        break;

                case ARG_SLICE:
                        arg_slice = optarg;
                        break;

                case ARG_SEND_SIGHUP:
                        arg_send_sighup = true;
                        break;

                case 'r':
                        arg_remain_after_exit = true;
                        break;

                case '?':
                        return -EINVAL;

                default:
                        log_error("Unknown option code %c", c);
                        return -EINVAL;
                }
        }

        if (optind >= argc) {
                log_error("Command line to execute required.");
                return -EINVAL;
        }

        return 1;
}

static int message_start_transient_unit_new(sd_bus *bus, const char *name, sd_bus_message **ret) {
        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
        int r;

        log_info("Running as unit %s.", name);

        r = sd_bus_message_new_method_call(
                        bus,
                        "org.freedesktop.systemd1",
                        "/org/freedesktop/systemd1",
                        "org.freedesktop.systemd1.Manager",
                        "StartTransientUnit", &m);
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "ss", name, "fail");
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(m, 'a', "(sv)");
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "(sv)", "Description", "s", arg_description);
        if (r < 0)
                return r;

        if (!isempty(arg_slice)) {
                _cleanup_free_ char *slice;

                slice = unit_name_mangle_with_suffix(arg_slice, ".slice");
                if (!slice)
                        return -ENOMEM;

                r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
                if (r < 0)
                        return r;
        }

        r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", arg_send_sighup);
        if (r < 0)
                return r;

        *ret = m;
        m = NULL;

        return 0;
}

static int message_start_transient_unit_send(sd_bus *bus, sd_bus_message *m, sd_bus_error *error, sd_bus_message **reply) {
        int r;

        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;

        return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply);
}

static int start_transient_service(
                sd_bus *bus,
                char **argv,
                sd_bus_error *error) {

        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
        _cleanup_free_ char *name = NULL;
        char **i;
        int r;

        if (arg_unit)
                name = unit_name_mangle_with_suffix(arg_unit, ".service");
        else
                asprintf(&name, "run-%lu.service", (unsigned long) getpid());
        if (!name)
                return -ENOMEM;

        r = message_start_transient_unit_new(bus, name, &m);
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "(sv)", "RemainAfterExit", "b", arg_remain_after_exit);
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(m, 'r', "sv");
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "s", "ExecStart");
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(m, 'v', "a(sasb)");
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(m, 'a', "(sasb)");
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(m, 'r', "sasb");
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "s", argv[0]);
        if (r < 0)
                return r;

        r = sd_bus_message_open_container(m, 'a', "s");
        if (r < 0)
                return r;

        STRV_FOREACH(i, argv) {
                r = sd_bus_message_append(m, "s", *i);
                if (r < 0)
                        return r;
        }

        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "b", false);
        if (r < 0)
                return r;

        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;

        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;

        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;

        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;

        return  message_start_transient_unit_send(bus, m, error, &reply);
}

static int start_transient_scope(
                sd_bus *bus,
                char **argv,
                sd_bus_error *error) {

        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
        _cleanup_free_ char *name = NULL;
        int r;

        if (arg_unit)
                name = unit_name_mangle_with_suffix(arg_unit, ".scope");
        else
                asprintf(&name, "run-%lu.scope", (unsigned long) getpid());
        if (!name)
                return -ENOMEM;

        r = message_start_transient_unit_new(bus, name, &m);
        if (r < 0)
                return r;

        r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, (uint32_t) getpid());
        if (r < 0)
                return r;

        r = message_start_transient_unit_send(bus, m, error, &reply);
        if (r < 0)
                return r;

        execvp(argv[0], argv);
        log_error("Failed to execute: %m");
        return -errno;
}

int main(int argc, char* argv[]) {
        sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        _cleanup_free_ char *description = NULL, *command = NULL;
        int r;

        log_parse_environment();
        log_open();

        r = parse_argv(argc, argv);
        if (r <= 0)
                goto fail;

        r = find_binary(argv[optind], &command);
        if (r < 0) {
                log_error("Failed to find executable %s: %s", argv[optind], strerror(-r));
                goto fail;
        }
        argv[optind] = command;

        if (!arg_description) {
                description = strv_join(argv + optind, " ");
                if (!description) {
                        r = log_oom();
                        goto fail;
                }

                arg_description = description;
        }

        if (arg_user)
                r = sd_bus_open_user(&bus);
        else
                r = sd_bus_open_system(&bus);
        if (r < 0) {
                log_error("Failed to create new bus connection: %s", strerror(-r));
                goto fail;
        }

        if (arg_scope)
                r = start_transient_scope(bus, argv + optind, &error);
        else
                r = start_transient_service(bus, argv + optind, &error);
        if (r < 0) {
                log_error("Failed start transient unit: %s", error.message ? error.message : strerror(-r));
                sd_bus_error_free(&error);
                goto fail;
        }

fail:
        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}





        return ":no-sender";
}

bool bus_service_name_is_valid(const char *p) {
        const char *q;
        bool dot, found_dot = false, unique;

        if (isempty(p))
                return false;

        unique = p[0] == ':';

        for (dot = true, q = unique ? p+1 : p; *q; q++)
                if (*q == '.') {
                        if (dot)
                                return false;

                        found_dot = dot = true;
                } else {
                        bool good;

                        good =
                                (*q >= 'a' && *q <= 'z') ||
                                (*q >= 'A' && *q <= 'Z') ||
                                ((!dot || unique) && *q >= '0' && *q <= '9') ||
                                *q == '_' || *q == '-';

                        if (!good)
                                return false;

                        dot = false;
                }

        if (q - p > 255)
                return false;

        if (dot)
                return false;

        if (!found_dot)
                return false;

        return true;
}

Lines 242-246 Link Here

(-)systemd-208.mod.bck/src/shared/dbus-common.h (+2 lines)
242		242
243	void bus_message_unrefp(DBusMessage **reply);	243	void bus_message_unrefp(DBusMessage **reply);
244		244
		245	bool bus_service_name_is_valid(const char *p);
		246
245	#define _cleanup_dbus_message_unref_ __attribute__((cleanup(bus_message_unrefp)))	247	#define _cleanup_dbus_message_unref_ __attribute__((cleanup(bus_message_unrefp)))
246	#define _cleanup_dbus_error_free_ __attribute__((cleanup(dbus_error_free)))	248	#define _cleanup_dbus_error_free_ __attribute__((cleanup(dbus_error_free)))

Return to bug 878853

Lines 2725-2731 Link Here

(-)systemd-208.mod.bck/src/core/service.c.orig (-3 / +3 lines)
2725	unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);	2725	unit_serialize_item(u, f, "var-tmp-dir", s->exec_context.var_tmp_dir);
2726		2726
2727	if (s->forbid_restart)	2727	if (s->forbid_restart)
2728	unit_serialize_item(u, f, "forbid_restart", yes_no(s->forbid_restart));	2728	unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2729		2729
2730	return 0;	2730	return 0;
2731	}	2731	}
Lines 2863-2874 Link Here
2863	return log_oom();	2863	return log_oom();
2864		2864
2865	s->exec_context.var_tmp_dir = t;	2865	s->exec_context.var_tmp_dir = t;
2866	} else if (streq(key, "forbid_restart")) {	2866	} else if (streq(key, "forbid-restart")) {
2867	int b;	2867	int b;
2868		2868
2869	b = parse_boolean(value);	2869	b = parse_boolean(value);
2870	if (b < 0)	2870	if (b < 0)
2871	log_debug_unit(u->id, "Failed to parse forbid_restart value %s", value);	2871	log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
2872	else	2872	else
2873	s->forbid_restart = b;	2873	s->forbid_restart = b;
2874	} else	2874	} else

Lines 1746-1758 Link Here

(-)systemd-208.mod.bck/src/login/logind-dbus.c (-26 / +39 lines)
1746	if (!session)	1746	if (!session)
1747	return bus_send_error_reply(connection, message, &error, -ENOENT);	1747	return bus_send_error_reply(connection, message, &error, -ENOENT);
1748		1748
1749	/* We use the FIFO to detect stray sessions where the	1749	session_release(session);
1750	process invoking PAM dies abnormally. We need to make
1751	sure that that process is not killed if at the clean
1752	end of the session it closes the FIFO. Hence, with
1753	this call explicitly turn off the FIFO logic, so that
1754	the PAM code can finish clean up on its own */
1755	session_remove_fifo(session);
1756		1750
1757	reply = dbus_message_new_method_return(message);	1751	reply = dbus_message_new_method_return(message);
1758	if (!reply)	1752	if (!reply)
Lines 2550-2563 Link Here
2550	const char *slice,	2544	const char *slice,
2551	const char *description,	2545	const char *description,
2552	const char *after,	2546	const char *after,
2553	const char *kill_mode,	2547	const char *after2,
2554	DBusError *error,	2548	DBusError *error,
2555	char **job) {	2549	char **job) {
2556		2550
2557	const char timeout_stop_property = "TimeoutStopUSec", send_sighup_property = "SendSIGHUP", *pids_property = "PIDs";	2551	const char send_sighup_property = "SendSIGHUP", pids_property = "PIDs", *after_property = "After";
2558	_cleanup_dbus_message_unref_ DBusMessage m = NULL, reply = NULL;	2552	_cleanup_dbus_message_unref_ DBusMessage m = NULL, reply = NULL;
2559	DBusMessageIter iter, sub, sub2, sub3, sub4;	2553	DBusMessageIter iter, sub, sub2, sub3, sub4;
2560	uint64_t timeout = 500 * USEC_PER_MSEC;
2561	dbus_bool_t send_sighup = true;	2554	dbus_bool_t send_sighup = true;
2562	const char *fail = "fail";	2555	const char *fail = "fail";
2563	uint32_t u;	2556	uint32_t u;
Lines 2609-2616 Link Here
2609	}	2602	}
2610		2603
2611	if (!isempty(after)) {	2604	if (!isempty(after)) {
2612	const char *after_property = "After";
2613
2614	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|	2605	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|
2615	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) \|\|	2606	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) \|\|
2616	!dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) \|\|	2607	!dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) \|\|
Lines 2622-2634 Link Here
2622	return log_oom();	2613	return log_oom();
2623	}	2614	}
2624		2615
2625	if (!isempty(kill_mode)) {	2616	if (!isempty(after2)) {
2626	const char *kill_mode_property = "KillMode";
2627
2628	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|	2617	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|
2629	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &kill_mode_property) \|\|	2618	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) \|\|
2630	!dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) \|\|	2619	!dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) \|\|
2631	!dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &kill_mode) \|\|	2620	!dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "s", &sub4) \|\|
		2621	!dbus_message_iter_append_basic(&sub4, DBUS_TYPE_STRING, &after2) \|\|
		2622	!dbus_message_iter_close_container(&sub3, &sub4) \|\|
2632	!dbus_message_iter_close_container(&sub2, &sub3) \|\|	2623	!dbus_message_iter_close_container(&sub2, &sub3) \|\|
2633	!dbus_message_iter_close_container(&sub, &sub2))	2624	!dbus_message_iter_close_container(&sub, &sub2))
2634	return log_oom();	2625	return log_oom();
Lines 2639-2652 Link Here
2639	* stop timeout for sessions, so that we don't wait	2630	* stop timeout for sessions, so that we don't wait
2640	* forever. */	2631	* forever. */
2641		2632
2642	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|
2643	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &timeout_stop_property) \|\|
2644	!dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "t", &sub3) \|\|
2645	!dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &timeout) \|\|
2646	!dbus_message_iter_close_container(&sub2, &sub3) \|\|
2647	!dbus_message_iter_close_container(&sub, &sub2))
2648	return log_oom();
2649
2650	/* Make sure that the session shells are terminated with	2633	/* Make sure that the session shells are terminated with
2651	* SIGHUP since bash and friends tend to ignore SIGTERM */	2634	* SIGHUP since bash and friends tend to ignore SIGTERM */
2652	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|	2635	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|
Lines 2790-2795 Link Here
2790	}	2773	}
2791		2774
2792	return 1;	2775	return 1;
		2776	}
		2777
		2778	int manager_abandon_scope(Manager manager, const char scope, DBusError *error) {
		2779	_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
		2780	_cleanup_free_ char *path = NULL;
		2781	int r;
		2782
		2783	assert(manager);
		2784	assert(scope);
		2785
		2786	path = unit_dbus_path_from_name(scope);
		2787	if (!path)
		2788	return -ENOMEM;
		2789
		2790	r = bus_method_call_with_reply(
		2791	manager->bus,
		2792	"org.freedesktop.systemd1",
		2793	path,
		2794	"org.freedesktop.systemd1.Scope",
		2795	"Abandon",
		2796	&reply,
		2797	error,
		2798	DBUS_TYPE_INVALID);
		2799
		2800	if (r < 0) {
		2801	log_error("Failed to abandon scope %s", scope);
		2802	return r;
		2803	}
		2804
		2805	return 1;
2793	}	2806	}
2794		2807
2795	int manager_kill_unit(Manager manager, const char unit, KillWho who, int signo, DBusError *error) {	2808	int manager_kill_unit(Manager manager, const char unit, KillWho who, int signo, DBusError *error) {

Lines 490-496 Link Here

(-)systemd-208.mod.bck/src/login/pam-module.c (-4 / +7 lines)
490	int flags,	490	int flags,
491	int argc, const char **argv) {	491	int argc, const char **argv) {
492		492
493	const void p = NULL, existing = NULL;	493	const void *existing = NULL;
494	const char *id;	494	const char *id;
495	DBusConnection *bus = NULL;	495	DBusConnection *bus = NULL;
496	DBusMessage m = NULL, reply = NULL;	496	DBusMessage m = NULL, reply = NULL;
Lines 547-558 Link Here
547	}	547	}
548	}	548	}
549		549
		550
		551	/* Note that we are knowingly leaking the FIFO fd here. This
		552	* way, logind can watch us die. If we closed it here it would
		553	* not have any clue when that is completed. Given that one
		554	* cannot really have multiple PAM sessions open from the same
		555	* process this means we will leak one FD at max. */
550	r = PAM_SUCCESS;	556	r = PAM_SUCCESS;
551		557
552	finish:	558	finish:
553	pam_get_data(handle, "systemd.session-fd", &p);
554	if (p)
555	close_nointr(PTR_TO_INT(p) - 1);
556		559
557	dbus_error_free(&error);	560	dbus_error_free(&error);
558		561

Lines 1428-1430 Link Here

(-)systemd-208.mod.bck/src/shared/dbus-common.c (+42 lines)
1428		1428
1429	return ":no-sender";	1429	return ":no-sender";
1430	}	1430	}
		1431
		1432	bool bus_service_name_is_valid(const char *p) {
		1433	const char *q;
		1434	bool dot, found_dot = false, unique;
		1435
		1436	if (isempty(p))
		1437	return false;
		1438
		1439	unique = p[0] == ':';
		1440
		1441	for (dot = true, q = unique ? p+1 : p; *q; q++)
		1442	if (*q == '.') {
		1443	if (dot)
		1444	return false;
		1445
		1446	found_dot = dot = true;
		1447	} else {
		1448	bool good;
		1449
		1450	good =
		1451	(q >= 'a' && q <= 'z') \|\|
		1452	(q >= 'A' && q <= 'Z') \|\|
		1453	((!dot \|\| unique) && q >= '0' && q <= '9') \|\|
		1454	q == '_' \|\| q == '-';
		1455
		1456	if (!good)
		1457	return false;
		1458
		1459	dot = false;
		1460	}
		1461
		1462	if (q - p > 255)
		1463	return false;
		1464
		1465	if (dot)
		1466	return false;
		1467
		1468	if (!found_dot)
		1469	return false;
		1470
		1471	return true;
		1472	}

Lines 30-40 Link Here

(-)systemd-208.mod.bck/src/core/dbus-scope.c (-9 / +82 lines)
30		30
31	#define BUS_SCOPE_INTERFACE \	31	#define BUS_SCOPE_INTERFACE \
32	" <interface name=\"org.freedesktop.systemd1.Scope\">\n" \	32	" <interface name=\"org.freedesktop.systemd1.Scope\">\n" \
		33	" <method name=\"Abandon\"/>\n" \
33	BUS_UNIT_CGROUP_INTERFACE \	34	BUS_UNIT_CGROUP_INTERFACE \
		35	" <property name=\"Controller\" type=\"s\" access=\"read\"/>\n"\
34	" <property name=\"TimeoutStopUSec\" type=\"t\" access=\"read\"/>\n" \	36	" <property name=\"TimeoutStopUSec\" type=\"t\" access=\"read\"/>\n" \
35	BUS_KILL_CONTEXT_INTERFACE \	37	BUS_KILL_CONTEXT_INTERFACE \
36	BUS_CGROUP_CONTEXT_INTERFACE \	38	BUS_CGROUP_CONTEXT_INTERFACE \
37	" <property name=\"Result\" type=\"s\" access=\"read\"/>\n" \	39	" <property name=\"Result\" type=\"s\" access=\"read\"/>\n" \
		40	" <signal name=\"RequestStop\"/>\n" \
38	" </interface>\n"	41	" </interface>\n"
39		42
40	#define INTROSPECTION \	43	#define INTROSPECTION \
Lines 56-61 Link Here
56	static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_scope_append_scope_result, scope_result, ScopeResult);	59	static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_scope_append_scope_result, scope_result, ScopeResult);
57		60
58	static const BusProperty bus_scope_properties[] = {	61	static const BusProperty bus_scope_properties[] = {
		62	{ "Controller", bus_property_append_string, "s", offsetof(Scope, controller) },
59	{ "TimeoutStopUSec", bus_property_append_usec, "t", offsetof(Scope, timeout_stop_usec) },	63	{ "TimeoutStopUSec", bus_property_append_usec, "t", offsetof(Scope, timeout_stop_usec) },
60	{ "Result", bus_scope_append_scope_result, "s", offsetof(Scope, result) },	64	{ "Result", bus_scope_append_scope_result, "s", offsetof(Scope, result) },
61	{}	65	{}
Lines 63-81 Link Here
63		67
64	DBusHandlerResult bus_scope_message_handler(Unit u, DBusConnection c, DBusMessage *message) {	68	DBusHandlerResult bus_scope_message_handler(Unit u, DBusConnection c, DBusMessage *message) {
65	Scope *s = SCOPE(u);	69	Scope *s = SCOPE(u);
		70	_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
66		71
67	const BusBoundProperties bps[] = {	72	SELINUX_UNIT_ACCESS_CHECK(u, c, message, "status");
		73
		74	if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Scope", "Abandon")) {
		75	int r;
		76
		77	r = scope_abandon(s);
		78	if (r < 0)
		79	log_error("Failed to mark scope %s as abandoned : %s", UNIT(s)->id, strerror(-r));
		80
		81	reply = dbus_message_new_method_return(message);
		82	if (!reply)
		83	goto oom;
		84	} else {
		85	const BusBoundProperties bps[] = {
68	{ "org.freedesktop.systemd1.Unit", bus_unit_properties, u },	86	{ "org.freedesktop.systemd1.Unit", bus_unit_properties, u },
69	{ "org.freedesktop.systemd1.Scope", bus_unit_cgroup_properties, u },	87	{ "org.freedesktop.systemd1.Scope", bus_unit_cgroup_properties, u },
70	{ "org.freedesktop.systemd1.Scope", bus_scope_properties, s },	88	{ "org.freedesktop.systemd1.Scope", bus_scope_properties, s },
71	{ "org.freedesktop.systemd1.Scope", bus_cgroup_context_properties, &s->cgroup_context },	89	{ "org.freedesktop.systemd1.Scope", bus_cgroup_context_properties, &s->cgroup_context },
72	{ "org.freedesktop.systemd1.Scope", bus_kill_context_properties, &s->kill_context },	90	{ "org.freedesktop.systemd1.Scope", bus_kill_context_properties, &s->kill_context },
73	{}	91	{}
74	};	92	};
75		93
76	SELINUX_UNIT_ACCESS_CHECK(u, c, message, "status");	94	return bus_default_message_handler(c, message, INTROSPECTION, INTERFACES_LIST, bps);
		95	}
77		96
78	return bus_default_message_handler(c, message, INTROSPECTION, INTERFACES_LIST, bps);	97	if (reply)
		98	if (!bus_maybe_send_reply(c, message, reply))
		99	goto oom;
		100
		101	return DBUS_HANDLER_RESULT_HANDLED;
		102	oom:
		103	return DBUS_HANDLER_RESULT_NEED_MEMORY;
79	}	104	}
80		105
81	static int bus_scope_set_transient_property(	106	static int bus_scope_set_transient_property(
Lines 99-108 Link Here
99	dbus_message_iter_get_element_type(i) != DBUS_TYPE_UINT32)	124	dbus_message_iter_get_element_type(i) != DBUS_TYPE_UINT32)
100	return -EINVAL;	125	return -EINVAL;
101		126
102	r = set_ensure_allocated(&s->pids, trivial_hash_func, trivial_compare_func);
103	if (r < 0)
104	return r;
105
106	dbus_message_iter_recurse(i, &sub);	127	dbus_message_iter_recurse(i, &sub);
107	while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32) {	128	while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32) {
108	uint32_t pid;	129	uint32_t pid;
Lines 113-119 Link Here
113	return -EINVAL;	134	return -EINVAL;
114		135
115	if (mode != UNIT_CHECK) {	136	if (mode != UNIT_CHECK) {
116	r = set_put(s->pids, LONG_TO_PTR(pid));	137	r = unit_watch_pid(UNIT(s), pid);
117	if (r < 0 && r != -EEXIST)	138	if (r < 0 && r != -EEXIST)
118	return r;	139	return r;
119	}	140	}
Lines 127-132 Link Here
127		148
128	return 1;	149	return 1;
129		150
		151	} else if (streq(name, "Controller")) {
		152	const char *controller;
		153
		154	if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING)
		155	return -EINVAL;
		156
		157	dbus_message_iter_get_basic(i, &controller);
		158
		159	if (!isempty(controller) && !bus_service_name_is_valid(controller))
		160	return -EINVAL;
		161
		162	if (mode != UNIT_CHECK) {
		163	char *c = NULL;
		164
		165	if (!isempty(controller)) {
		166	c = strdup(controller);
		167	if (!c)
		168	return -ENOMEM;
		169	}
		170
		171	free(s->controller);
		172	s->controller = c;
		173	}
		174
		175	return 1;
130	} else if (streq(name, "TimeoutStopUSec")) {	176	} else if (streq(name, "TimeoutStopUSec")) {
131		177
132	if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_UINT64)	178	if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_UINT64)
Lines 187-189 Link Here
187	unit_realize_cgroup(u);	233	unit_realize_cgroup(u);
188	return 0;	234	return 0;
189	}	235	}
		236
		237	int bus_scope_send_request_stop(Scope *s) {
		238	_cleanup_dbus_message_unref_ DBusMessage *m = NULL;
		239	_cleanup_free_ char *p = NULL;
		240	int r;
		241
		242	assert(s);
		243
		244	if (!s->controller)
		245	return 0;
		246
		247	p = unit_dbus_path(UNIT(s));
		248	if (!p)
		249	return -ENOMEM;
		250
		251	m = dbus_message_new_signal(p,
		252	"org.freedesktop.systemd1.Scope",
		253	"RequestStop");
		254	if (!m)
		255	return 0;
		256
		257	r = dbus_message_set_destination(m, s->controller);
		258	if (!r)
		259	return 0;
		260
		261	return dbus_connection_send(UNIT(s)->manager->api_bus, m, NULL);
		262	}

Lines 29-34 Link Here

(-)systemd-208.mod.bck/src/core/scope.h (-1 / +4 lines)
29	typedef enum ScopeState {	29	typedef enum ScopeState {
30	SCOPE_DEAD,	30	SCOPE_DEAD,
31	SCOPE_RUNNING,	31	SCOPE_RUNNING,
		32	SCOPE_ABANDONED,
32	SCOPE_STOP_SIGTERM,	33	SCOPE_STOP_SIGTERM,
33	SCOPE_STOP_SIGKILL,	34	SCOPE_STOP_SIGKILL,
34	SCOPE_FAILED,	35	SCOPE_FAILED,
Lines 55-67 Link Here
55		56
56	usec_t timeout_stop_usec;	57	usec_t timeout_stop_usec;
57		58
58	Set *pids;	59	char *controller;
59		60
60	Watch timer_watch;	61	Watch timer_watch;
61	};	62	};
62		63
63	extern const UnitVTable scope_vtable;	64	extern const UnitVTable scope_vtable;
64		65
		66	int scope_abandon(Scope *s);
		67
65	const char* scope_state_to_string(ScopeState i) _const_;	68	const char* scope_state_to_string(ScopeState i) _const_;
66	ScopeState scope_state_from_string(const char *s) _pure_;	69	ScopeState scope_state_from_string(const char *s) _pure_;
67		70

Lines 80-89 Link Here

(-)systemd-208.mod.bck/src/login/logind.c (-3 / +20 lines)
80	m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);	80	m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
81	m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);	81	m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
82	m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);	82	m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
		83	m->timer_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
83		84
84	if (!m->devices \|\| !m->seats \|\| !m->sessions \|\| !m->users \|\| !m->inhibitors \|\| !m->buttons \|\| !m->busnames \|\|	85	if (!m->devices \|\| !m->seats \|\| !m->sessions \|\| !m->users \|\| !m->inhibitors \|\| !m->buttons \|\| !m->busnames \|\|
85	!m->user_units \|\| !m->session_units \|\|	86	!m->user_units \|\| !m->session_units \|\|
86	!m->session_fds \|\| !m->inhibitor_fds \|\| !m->button_fds) {	87	!m->session_fds \|\| !m->inhibitor_fds \|\| !m->button_fds \|\| !m->timer_fds) {
87	manager_free(m);	88	manager_free(m);
88	return NULL;	89	return NULL;
89	}	90	}
Lines 149-154 Link Here
149	hashmap_free(m->session_fds);	150	hashmap_free(m->session_fds);
150	hashmap_free(m->inhibitor_fds);	151	hashmap_free(m->inhibitor_fds);
151	hashmap_free(m->button_fds);	152	hashmap_free(m->button_fds);
		153	hashmap_free(m->timer_fds);
152		154
153	if (m->console_active_fd >= 0)	155	if (m->console_active_fd >= 0)
154	close_nointr_nofail(m->console_active_fd);	156	close_nointr_nofail(m->console_active_fd);
Lines 620-625 Link Here
620	return;	622	return;
621	}	623	}
622		624
		625	s = hashmap_get(m->timer_fds, INT_TO_PTR(fd + 1));
		626	if (s) {
		627	assert(s->timer_fd == fd);
		628	session_stop(s);
		629	return;
		630	}
		631
623	i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));	632	i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));
624	if (i) {	633	if (i) {
625	assert(i->fifo_fd == fd);	634	assert(i->fifo_fd == fd);
Lines 942-949 Link Here
942	LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);	951	LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
943	session->in_gc_queue = false;	952	session->in_gc_queue = false;
944		953
945	if (session_check_gc(session, drop_not_started) == 0) {	954	/* First, if we are not closing yet, initiate stopping */
		955	if (!session_check_gc(session, drop_not_started) &&
		956	session_get_state(session) != SESSION_CLOSING)
946	session_stop(session);	957	session_stop(session);
		958
		959	if (!session_check_gc(session, drop_not_started)) {
947	session_finalize(session);	960	session_finalize(session);
948	session_free(session);	961	session_free(session);
949	}	962	}
Lines 953-960 Link Here
953	LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);	966	LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
954	user->in_gc_queue = false;	967	user->in_gc_queue = false;
955		968
956	if (user_check_gc(user, drop_not_started) == 0) {	969	if (!user_check_gc(user, drop_not_started) &&
		970	user_get_state(user) != USER_CLOSING)
957	user_stop(user);	971	user_stop(user);
		972
		973	if (!user_check_gc(user, drop_not_started)) {
958	user_finalize(user);	974	user_finalize(user);
959	user_free(user);	975	user_free(user);
960	}	976	}
Lines 1032-1037 Link Here
1032		1048
1033	return r;	1049	return r;
1034	}	1050	}
		1051
1035	int manager_startup(Manager *m) {	1052	int manager_startup(Manager *m) {
1036	int r;	1053	int r;
1037	Seat *seat;	1054	Seat *seat;

Lines 88-93 Link Here

(-)systemd-208.mod.bck/src/login/logind.h (-1 / +3 lines)
88	Hashmap *session_fds;	88	Hashmap *session_fds;
89	Hashmap *inhibitor_fds;	89	Hashmap *inhibitor_fds;
90	Hashmap *button_fds;	90	Hashmap *button_fds;
		91	Hashmap *timer_fds;
91		92
92	usec_t inhibit_delay_max;	93	usec_t inhibit_delay_max;
93		94
Lines 183-191 Link Here
183		184
184	int manager_dispatch_delayed(Manager *manager);	185	int manager_dispatch_delayed(Manager *manager);
185		186
186	int manager_start_scope(Manager manager, const char scope, pid_t pid, const char slice, const char description, const char after, const char kill_mode, DBusError error, char *job);	187	int manager_start_scope(Manager manager, const char scope, pid_t pid, const char slice, const char description, const char after, const char after2, DBusError error, char *job);
187	int manager_start_unit(Manager manager, const char unit, DBusError error, char *job);	188	int manager_start_unit(Manager manager, const char unit, DBusError error, char *job);
188	int manager_stop_unit(Manager manager, const char unit, DBusError error, char *job);	189	int manager_stop_unit(Manager manager, const char unit, DBusError error, char *job);
		190	int manager_abandon_scope(Manager manager, const char scope, DBusError *error);
189	int manager_kill_unit(Manager manager, const char unit, KillWho who, int signo, DBusError *error);	191	int manager_kill_unit(Manager manager, const char unit, KillWho who, int signo, DBusError *error);
190	int manager_unit_is_active(Manager manager, const char unit);	192	int manager_unit_is_active(Manager manager, const char unit);
191		193

Line 0 Link Here

(-)systemd-208.mod.bck/src/run/run.c.orig (+376 lines)
		1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
		2
		3	/***
		4	This file is part of systemd.
		5
		6	Copyright 2013 Lennart Poettering
		7
		8	systemd is free software; you can redistribute it and/or modify it
		9	under the terms of the GNU Lesser General Public License as published by
		10	the Free Software Foundation; either version 2.1 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	Lesser General Public License for more details.
		17
		18	You should have received a copy of the GNU Lesser General Public License
		19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
		20	***/
		21
		22	#include <stdio.h>
		23	#include <getopt.h>
		24
		25	#include "sd-bus.h"
		26	#include "bus-internal.h"
		27	#include "bus-message.h"
		28	#include "strv.h"
		29	#include "build.h"
		30	#include "unit-name.h"
		31	#include "path-util.h"
		32
		33	static bool arg_scope = false;
		34	static bool arg_user = false;
		35	static bool arg_remain_after_exit = false;
		36	static const char *arg_unit = NULL;
		37	static const char *arg_description = NULL;
		38	static const char *arg_slice = NULL;
		39	static bool arg_send_sighup = false;
		40
		41	static int help(void) {
		42
		43	printf("%s [OPTIONS...] COMMAND [ARGS...]\n\n"
		44	"Run the specified command in a transient scope or service unit.\n\n"
		45	" -h --help Show this help\n"
		46	" --version Show package version\n"
		47	" --user Run as user unit\n"
		48	" --scope Run this as scope rather than service\n"
		49	" --unit=UNIT Run under the specified unit name\n"
		50	" --description=TEXT Description for unit\n"
		51	" --slice=SLICE Run in the specified slice\n"
		52	" -r --remain-after-exit Leave service around until explicitly stopped\n"
		53	" --send-sighup Send SIGHUP when terminating\n",
		54	program_invocation_short_name);
		55
		56	return 0;
		57	}
		58
		59	static int parse_argv(int argc, char *argv[]) {
		60
		61	enum {
		62	ARG_VERSION = 0x100,
		63	ARG_USER,
		64	ARG_SCOPE,
65	ARG_UNIT,
66	ARG_DESCRIPTION,
67	ARG_SLICE,
68	ARG_SEND_SIGHUP,
69	};
70
71	static const struct option options[] = {
72	{ "help", no_argument, NULL, 'h' },
73	{ "version", no_argument, NULL, ARG_VERSION },
74	{ "user", no_argument, NULL, ARG_USER },
75	{ "scope", no_argument, NULL, ARG_SCOPE },
76	{ "unit", required_argument, NULL, ARG_UNIT },
77	{ "description", required_argument, NULL, ARG_DESCRIPTION },
78	{ "slice", required_argument, NULL, ARG_SLICE },
79	{ "remain-after-exit", no_argument, NULL, 'r' },
80	{ "send-sighup", no_argument, NULL, ARG_SEND_SIGHUP },
81	{ NULL, 0, NULL, 0 },
82	};
83
84	int c;
85
86	assert(argc >= 0);
87	assert(argv);
88
89	while ((c = getopt_long(argc, argv, "+hr", options, NULL)) >= 0) {
90
91	switch (c) {
92
93	case 'h':
94	help();
95	return 0;
96
97	case ARG_VERSION:
98	puts(PACKAGE_STRING);
99	puts(SYSTEMD_FEATURES);
100	return 0;
101
102	case ARG_USER:
103	arg_user = true;
104	break;
105
106	case ARG_SCOPE:
107	arg_scope = true;
108	break;
109
110	case ARG_UNIT:
111	arg_unit = optarg;
112	break;
113
114	case ARG_DESCRIPTION:
115	arg_description = optarg;
116	break;
117
118	case ARG_SLICE:
119	arg_slice = optarg;
120	break;
121
122	case ARG_SEND_SIGHUP:
123	arg_send_sighup = true;
124	break;
125
126	case 'r':
127	arg_remain_after_exit = true;
128	break;
129
130	case '?':
131	return -EINVAL;
132
133	default:
134	log_error("Unknown option code %c", c);
135	return -EINVAL;
136	}
137	}
138
139	if (optind >= argc) {
140	log_error("Command line to execute required.");
141	return -EINVAL;
142	}
143
144	return 1;
145	}
146
147	static int message_start_transient_unit_new(sd_bus bus, const char name, sd_bus_message **ret) {
148	_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
149	int r;
150
151	log_info("Running as unit %s.", name);
152
153	r = sd_bus_message_new_method_call(
154	bus,
155	"org.freedesktop.systemd1",
156	"/org/freedesktop/systemd1",
157	"org.freedesktop.systemd1.Manager",
158	"StartTransientUnit", &m);
159	if (r < 0)
160	return r;
161
162	r = sd_bus_message_append(m, "ss", name, "fail");
163	if (r < 0)
164	return r;
165
166	r = sd_bus_message_open_container(m, 'a', "(sv)");
167	if (r < 0)
168	return r;
169
170	r = sd_bus_message_append(m, "(sv)", "Description", "s", arg_description);
171	if (r < 0)
172	return r;
173
174	if (!isempty(arg_slice)) {
175	_cleanup_free_ char *slice;
176
177	slice = unit_name_mangle_with_suffix(arg_slice, ".slice");
178	if (!slice)
179	return -ENOMEM;
180
181	r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
182	if (r < 0)
183	return r;
184	}
185
186	r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", arg_send_sighup);
187	if (r < 0)
188	return r;
189
190	*ret = m;
191	m = NULL;
192
193	return 0;
194	}
195
196	static int message_start_transient_unit_send(sd_bus bus, sd_bus_message m, sd_bus_error error, sd_bus_message *reply) {
197	int r;
198
199	r = sd_bus_message_close_container(m);
200	if (r < 0)
201	return r;
202
203	return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply);
204	}
205
206	static int start_transient_service(
207	sd_bus *bus,
208	char **argv,
209	sd_bus_error *error) {
210
211	_cleanup_bus_message_unref_ sd_bus_message m = NULL, reply = NULL;
212	_cleanup_free_ char *name = NULL;
213	char **i;
214	int r;
215
216	if (arg_unit)
217	name = unit_name_mangle_with_suffix(arg_unit, ".service");
218	else
219	asprintf(&name, "run-%lu.service", (unsigned long) getpid());
220	if (!name)
221	return -ENOMEM;
222
223	r = message_start_transient_unit_new(bus, name, &m);
224	if (r < 0)
225	return r;
226
227	r = sd_bus_message_append(m, "(sv)", "RemainAfterExit", "b", arg_remain_after_exit);
228	if (r < 0)
229	return r;
230
231	r = sd_bus_message_open_container(m, 'r', "sv");
232	if (r < 0)
233	return r;
234
235	r = sd_bus_message_append(m, "s", "ExecStart");
236	if (r < 0)
237	return r;
238
239	r = sd_bus_message_open_container(m, 'v', "a(sasb)");
240	if (r < 0)
241	return r;
242
243	r = sd_bus_message_open_container(m, 'a', "(sasb)");
244	if (r < 0)
245	return r;
246
247	r = sd_bus_message_open_container(m, 'r', "sasb");
248	if (r < 0)
249	return r;
250
251	r = sd_bus_message_append(m, "s", argv[0]);
252	if (r < 0)
253	return r;
254
255	r = sd_bus_message_open_container(m, 'a', "s");
256	if (r < 0)
257	return r;
258
259	STRV_FOREACH(i, argv) {
260	r = sd_bus_message_append(m, "s", *i);
261	if (r < 0)
262	return r;
263	}
264
265	r = sd_bus_message_close_container(m);
266	if (r < 0)
267	return r;
268
269	r = sd_bus_message_append(m, "b", false);
270	if (r < 0)
271	return r;
272
273	r = sd_bus_message_close_container(m);
274	if (r < 0)
275	return r;
276
277	r = sd_bus_message_close_container(m);
278	if (r < 0)
279	return r;
280
281	r = sd_bus_message_close_container(m);
282	if (r < 0)
283	return r;
284
285	r = sd_bus_message_close_container(m);
286	if (r < 0)
287	return r;
288
289	return message_start_transient_unit_send(bus, m, error, &reply);
290	}
291
292	static int start_transient_scope(
293	sd_bus *bus,
294	char **argv,
295	sd_bus_error *error) {
296
297	_cleanup_bus_message_unref_ sd_bus_message m = NULL, reply = NULL;
298	_cleanup_free_ char *name = NULL;
299	int r;
300
301	if (arg_unit)
302	name = unit_name_mangle_with_suffix(arg_unit, ".scope");
303	else
304	asprintf(&name, "run-%lu.scope", (unsigned long) getpid());
305	if (!name)
306	return -ENOMEM;
307
308	r = message_start_transient_unit_new(bus, name, &m);
309	if (r < 0)
310	return r;
311
312	r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, (uint32_t) getpid());
313	if (r < 0)
314	return r;
315
316	r = message_start_transient_unit_send(bus, m, error, &reply);
317	if (r < 0)
318	return r;
319
320	execvp(argv[0], argv);
321	log_error("Failed to execute: %m");
322	return -errno;
323	}
324
325	int main(int argc, char* argv[]) {
326	sd_bus_error error = SD_BUS_ERROR_NULL;
327	_cleanup_bus_unref_ sd_bus *bus = NULL;
328	_cleanup_free_ char description = NULL, command = NULL;
329	int r;
330
331	log_parse_environment();
332	log_open();
333
334	r = parse_argv(argc, argv);
335	if (r <= 0)
336	goto fail;
337
338	r = find_binary(argv[optind], &command);
339	if (r < 0) {
340	log_error("Failed to find executable %s: %s", argv[optind], strerror(-r));
341	goto fail;
342	}
343	argv[optind] = command;
344
345	if (!arg_description) {
346	description = strv_join(argv + optind, " ");
347	if (!description) {
348	r = log_oom();
349	goto fail;
350	}
351
352	arg_description = description;
353	}
354
355	if (arg_user)
356	r = sd_bus_open_user(&bus);
357	else
358	r = sd_bus_open_system(&bus);
359	if (r < 0) {
360	log_error("Failed to create new bus connection: %s", strerror(-r));
361	goto fail;
362	}
363
364	if (arg_scope)
365	r = start_transient_scope(bus, argv + optind, &error);
366	else
367	r = start_transient_service(bus, argv + optind, &error);
368	if (r < 0) {
369	log_error("Failed start transient unit: %s", error.message ? error.message : strerror(-r));
370	sd_bus_error_free(&error);
371	goto fail;
372	}
373
374	fail:
375	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
376	}