[thirdparty/systemd.git] / src / basic / unit-def.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include "alloc-util.h"
#include "bus-label.h"
#include "string-table.h"
#include "unit-def.h"
#include "unit-name.h"

char *unit_dbus_path_from_name(const char *name) {
        _cleanup_free_ char *e = NULL;

        assert(name);

        e = bus_label_escape(name);
        if (!e)
                return NULL;

        return strjoin("/org/freedesktop/systemd1/unit/", e);
}

int unit_name_from_dbus_path(const char *path, char **name) {
        const char *e;
        char *n;

        e = startswith(path, "/org/freedesktop/systemd1/unit/");
        if (!e)
                return -EINVAL;

        n = bus_label_unescape(e);
        if (!n)
                return -ENOMEM;

        *name = n;
        return 0;
}

const char* unit_dbus_interface_from_type(UnitType t) {

        static const char *const table[_UNIT_TYPE_MAX] = {
                [UNIT_SERVICE] = "org.freedesktop.systemd1.Service",
                [UNIT_SOCKET] = "org.freedesktop.systemd1.Socket",
                [UNIT_TARGET] = "org.freedesktop.systemd1.Target",
                [UNIT_DEVICE] = "org.freedesktop.systemd1.Device",
                [UNIT_MOUNT] = "org.freedesktop.systemd1.Mount",
                [UNIT_AUTOMOUNT] = "org.freedesktop.systemd1.Automount",
                [UNIT_SWAP] = "org.freedesktop.systemd1.Swap",
                [UNIT_TIMER] = "org.freedesktop.systemd1.Timer",
                [UNIT_PATH] = "org.freedesktop.systemd1.Path",
                [UNIT_SLICE] = "org.freedesktop.systemd1.Slice",
                [UNIT_SCOPE] = "org.freedesktop.systemd1.Scope",
        };

        if (t < 0)
                return NULL;
        if (t >= _UNIT_TYPE_MAX)
                return NULL;

        return table[t];
}

const char *unit_dbus_interface_from_name(const char *name) {
        UnitType t;

        t = unit_name_to_type(name);
        if (t < 0)
                return NULL;

        return unit_dbus_interface_from_type(t);
}

static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
        [UNIT_SERVICE] = "service",
        [UNIT_SOCKET] = "socket",
        [UNIT_TARGET] = "target",
        [UNIT_DEVICE] = "device",
        [UNIT_MOUNT] = "mount",
        [UNIT_AUTOMOUNT] = "automount",
        [UNIT_SWAP] = "swap",
        [UNIT_TIMER] = "timer",
        [UNIT_PATH] = "path",
        [UNIT_SLICE] = "slice",
        [UNIT_SCOPE] = "scope",
};

DEFINE_STRING_TABLE_LOOKUP(unit_type, UnitType);

static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
        [UNIT_STUB] = "stub",
        [UNIT_LOADED] = "loaded",
        [UNIT_NOT_FOUND] = "not-found",
        [UNIT_BAD_SETTING] = "bad-setting",
        [UNIT_ERROR] = "error",
        [UNIT_MERGED] = "merged",
        [UNIT_MASKED] = "masked"
};

DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);

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",
        [UNIT_MAINTENANCE] = "maintenance",
};

DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);

static const char* const automount_state_table[_AUTOMOUNT_STATE_MAX] = {
        [AUTOMOUNT_DEAD] = "dead",
        [AUTOMOUNT_WAITING] = "waiting",
        [AUTOMOUNT_RUNNING] = "running",
        [AUTOMOUNT_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(automount_state, AutomountState);

static const char* const device_state_table[_DEVICE_STATE_MAX] = {
        [DEVICE_DEAD] = "dead",
        [DEVICE_TENTATIVE] = "tentative",
        [DEVICE_PLUGGED] = "plugged",
};

DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);

static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
        [MOUNT_DEAD] = "dead",
        [MOUNT_MOUNTING] = "mounting",
        [MOUNT_MOUNTING_DONE] = "mounting-done",
        [MOUNT_MOUNTED] = "mounted",
        [MOUNT_REMOUNTING] = "remounting",
        [MOUNT_UNMOUNTING] = "unmounting",
        [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
        [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
        [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
        [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
        [MOUNT_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);

static const char* const path_state_table[_PATH_STATE_MAX] = {
        [PATH_DEAD] = "dead",
        [PATH_WAITING] = "waiting",
        [PATH_RUNNING] = "running",
        [PATH_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);

static const char* const scope_state_table[_SCOPE_STATE_MAX] = {
        [SCOPE_DEAD] = "dead",
        [SCOPE_RUNNING] = "running",
        [SCOPE_ABANDONED] = "abandoned",
        [SCOPE_STOP_SIGTERM] = "stop-sigterm",
        [SCOPE_STOP_SIGKILL] = "stop-sigkill",
        [SCOPE_FAILED] = "failed",
};

DEFINE_STRING_TABLE_LOOKUP(scope_state, ScopeState);

static const char* const service_state_table[_SERVICE_STATE_MAX] = {
        [SERVICE_DEAD] = "dead",
        [SERVICE_CONDITION] = "condition",
        [SERVICE_START_PRE] = "start-pre",
        [SERVICE_START] = "start",
        [SERVICE_START_POST] = "start-post",
        [SERVICE_RUNNING] = "running",
        [SERVICE_EXITED] = "exited",
        [SERVICE_RELOAD] = "reload",
        [SERVICE_STOP] = "stop",
        [SERVICE_STOP_WATCHDOG] = "stop-watchdog",
        [SERVICE_STOP_SIGTERM] = "stop-sigterm",
        [SERVICE_STOP_SIGKILL] = "stop-sigkill",
        [SERVICE_STOP_POST] = "stop-post",
        [SERVICE_FINAL_SIGTERM] = "final-sigterm",
        [SERVICE_FINAL_SIGKILL] = "final-sigkill",
        [SERVICE_FAILED] = "failed",
        [SERVICE_AUTO_RESTART] = "auto-restart",
        [SERVICE_CLEANING] = "cleaning",
};

DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);

static const char* const slice_state_table[_SLICE_STATE_MAX] = {
        [SLICE_DEAD] = "dead",
        [SLICE_ACTIVE] = "active"
};

DEFINE_STRING_TABLE_LOOKUP(slice_state, SliceState);

static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
        [SOCKET_DEAD] = "dead",
        [SOCKET_START_PRE] = "start-pre",
        [SOCKET_START_CHOWN] = "start-chown",
        [SOCKET_START_POST] = "start-post",
        [SOCKET_LISTENING] = "listening",
        [SOCKET_RUNNING] = "running",
        [SOCKET_STOP_PRE] = "stop-pre",
        [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
        [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
        [SOCKET_STOP_POST] = "stop-post",
        [SOCKET_FINAL_SIGTERM] = "final-sigterm",
        [SOCKET_FINAL_SIGKILL] = "final-sigkill",
        [SOCKET_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);

static const char* const swap_state_table[_SWAP_STATE_MAX] = {
        [SWAP_DEAD] = "dead",
        [SWAP_ACTIVATING] = "activating",
        [SWAP_ACTIVATING_DONE] = "activating-done",
        [SWAP_ACTIVE] = "active",
        [SWAP_DEACTIVATING] = "deactivating",
        [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
        [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
        [SWAP_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);

static const char* const target_state_table[_TARGET_STATE_MAX] = {
        [TARGET_DEAD] = "dead",
        [TARGET_ACTIVE] = "active"
};

DEFINE_STRING_TABLE_LOOKUP(target_state, TargetState);

static const char* const timer_state_table[_TIMER_STATE_MAX] = {
        [TIMER_DEAD] = "dead",
        [TIMER_WAITING] = "waiting",
        [TIMER_RUNNING] = "running",
        [TIMER_ELAPSED] = "elapsed",
        [TIMER_FAILED] = "failed"
};

DEFINE_STRING_TABLE_LOOKUP(timer_state, TimerState);

static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
        [UNIT_REQUIRES] = "Requires",
        [UNIT_REQUISITE] = "Requisite",
        [UNIT_WANTS] = "Wants",
        [UNIT_BINDS_TO] = "BindsTo",
        [UNIT_PART_OF] = "PartOf",
        [UNIT_REQUIRED_BY] = "RequiredBy",
        [UNIT_REQUISITE_OF] = "RequisiteOf",
        [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_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
        [UNIT_REFERENCES] = "References",
        [UNIT_REFERENCED_BY] = "ReferencedBy",
};

DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);

static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
        [NOTIFY_NONE] = "none",
        [NOTIFY_MAIN] = "main",
        [NOTIFY_EXEC] = "exec",
        [NOTIFY_ALL] = "all"
};

DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
523578aa LP	2
	3	#include "alloc-util.h"
	4	#include "bus-label.h"
	5	#include "string-table.h"
	6	#include "unit-def.h"
	7	#include "unit-name.h"
	8
	9	char unit_dbus_path_from_name(const char name) {
	10	_cleanup_free_ char *e = NULL;
	11
	12	assert(name);
	13
	14	e = bus_label_escape(name);
	15	if (!e)
	16	return NULL;
	17
b910cc72	18	return strjoin("/org/freedesktop/systemd1/unit/", e);
523578aa LP	19	}
	20
	21	int unit_name_from_dbus_path(const char path, char *name) {
	22	const char *e;
	23	char *n;
	24
	25	e = startswith(path, "/org/freedesktop/systemd1/unit/");
	26	if (!e)
	27	return -EINVAL;
	28
	29	n = bus_label_unescape(e);
	30	if (!n)
	31	return -ENOMEM;
	32
	33	*name = n;
	34	return 0;
	35	}
	36
	37	const char* unit_dbus_interface_from_type(UnitType t) {
	38
	39	static const char *const table[_UNIT_TYPE_MAX] = {
	40	[UNIT_SERVICE] = "org.freedesktop.systemd1.Service",
	41	[UNIT_SOCKET] = "org.freedesktop.systemd1.Socket",
	42	[UNIT_TARGET] = "org.freedesktop.systemd1.Target",
	43	[UNIT_DEVICE] = "org.freedesktop.systemd1.Device",
	44	[UNIT_MOUNT] = "org.freedesktop.systemd1.Mount",
	45	[UNIT_AUTOMOUNT] = "org.freedesktop.systemd1.Automount",
	46	[UNIT_SWAP] = "org.freedesktop.systemd1.Swap",
	47	[UNIT_TIMER] = "org.freedesktop.systemd1.Timer",
	48	[UNIT_PATH] = "org.freedesktop.systemd1.Path",
	49	[UNIT_SLICE] = "org.freedesktop.systemd1.Slice",
	50	[UNIT_SCOPE] = "org.freedesktop.systemd1.Scope",
	51	};
	52
	53	if (t < 0)
	54	return NULL;
	55	if (t >= _UNIT_TYPE_MAX)
	56	return NULL;
	57
	58	return table[t];
	59	}
	60
	61	const char unit_dbus_interface_from_name(const char name) {
	62	UnitType t;
	63
	64	t = unit_name_to_type(name);
	65	if (t < 0)
	66	return NULL;
	67
	68	return unit_dbus_interface_from_type(t);
	69	}
	70
	71	static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
	72	[UNIT_SERVICE] = "service",
	73	[UNIT_SOCKET] = "socket",
	74	[UNIT_TARGET] = "target",
	75	[UNIT_DEVICE] = "device",
	76	[UNIT_MOUNT] = "mount",
	77	[UNIT_AUTOMOUNT] = "automount",
	78	[UNIT_SWAP] = "swap",
	79	[UNIT_TIMER] = "timer",
	80	[UNIT_PATH] = "path",
	81	[UNIT_SLICE] = "slice",
	82	[UNIT_SCOPE] = "scope",
83	};
84
85	DEFINE_STRING_TABLE_LOOKUP(unit_type, UnitType);
86
87	static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
88	[UNIT_STUB] = "stub",
89	[UNIT_LOADED] = "loaded",
90	[UNIT_NOT_FOUND] = "not-found",
c4555ad8	91	[UNIT_BAD_SETTING] = "bad-setting",
523578aa LP	92	[UNIT_ERROR] = "error",
	93	[UNIT_MERGED] = "merged",
	94	[UNIT_MASKED] = "masked"
	95	};
	96
	97	DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
	98
	99	static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
	100	[UNIT_ACTIVE] = "active",
	101	[UNIT_RELOADING] = "reloading",
	102	[UNIT_INACTIVE] = "inactive",
	103	[UNIT_FAILED] = "failed",
	104	[UNIT_ACTIVATING] = "activating",
380dc8b0 LP	105	[UNIT_DEACTIVATING] = "deactivating",
380dc8b0 LP	106	[UNIT_MAINTENANCE] = "maintenance",
523578aa LP	107	};
	108
	109	DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
	110
	111	static const char* const automount_state_table[_AUTOMOUNT_STATE_MAX] = {
	112	[AUTOMOUNT_DEAD] = "dead",
	113	[AUTOMOUNT_WAITING] = "waiting",
	114	[AUTOMOUNT_RUNNING] = "running",
	115	[AUTOMOUNT_FAILED] = "failed"
	116	};
	117
	118	DEFINE_STRING_TABLE_LOOKUP(automount_state, AutomountState);
	119
	120	static const char* const device_state_table[_DEVICE_STATE_MAX] = {
	121	[DEVICE_DEAD] = "dead",
	122	[DEVICE_TENTATIVE] = "tentative",
	123	[DEVICE_PLUGGED] = "plugged",
	124	};
	125
	126	DEFINE_STRING_TABLE_LOOKUP(device_state, DeviceState);
	127
	128	static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
	129	[MOUNT_DEAD] = "dead",
	130	[MOUNT_MOUNTING] = "mounting",
	131	[MOUNT_MOUNTING_DONE] = "mounting-done",
	132	[MOUNT_MOUNTED] = "mounted",
	133	[MOUNT_REMOUNTING] = "remounting",
	134	[MOUNT_UNMOUNTING] = "unmounting",
	135	[MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
	136	[MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
	137	[MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
	138	[MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
	139	[MOUNT_FAILED] = "failed"
	140	};
	141
	142	DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
	143
	144	static const char* const path_state_table[_PATH_STATE_MAX] = {
	145	[PATH_DEAD] = "dead",
	146	[PATH_WAITING] = "waiting",
	147	[PATH_RUNNING] = "running",
	148	[PATH_FAILED] = "failed"
	149	};
	150
	151	DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
	152
	153	static const char* const scope_state_table[_SCOPE_STATE_MAX] = {
	154	[SCOPE_DEAD] = "dead",
	155	[SCOPE_RUNNING] = "running",
	156	[SCOPE_ABANDONED] = "abandoned",
	157	[SCOPE_STOP_SIGTERM] = "stop-sigterm",
	158	[SCOPE_STOP_SIGKILL] = "stop-sigkill",
	159	[SCOPE_FAILED] = "failed",
	160	};
	161
	162	DEFINE_STRING_TABLE_LOOKUP(scope_state, ScopeState);
	163
	164	static const char* const service_state_table[_SERVICE_STATE_MAX] = {
	165	[SERVICE_DEAD] = "dead",
31cd5f63	166	[SERVICE_CONDITION] = "condition",
523578aa LP	167	[SERVICE_START_PRE] = "start-pre",
	168	[SERVICE_START] = "start",
	169	[SERVICE_START_POST] = "start-post",
	170	[SERVICE_RUNNING] = "running",
	171	[SERVICE_EXITED] = "exited",
	172	[SERVICE_RELOAD] = "reload",
	173	[SERVICE_STOP] = "stop",
c87700a1	174	[SERVICE_STOP_WATCHDOG] = "stop-watchdog",
523578aa LP	175	[SERVICE_STOP_SIGTERM] = "stop-sigterm",
	176	[SERVICE_STOP_SIGKILL] = "stop-sigkill",
	177	[SERVICE_STOP_POST] = "stop-post",
	178	[SERVICE_FINAL_SIGTERM] = "final-sigterm",
	179	[SERVICE_FINAL_SIGKILL] = "final-sigkill",
	180	[SERVICE_FAILED] = "failed",
	181	[SERVICE_AUTO_RESTART] = "auto-restart",
4c2f5842	182	[SERVICE_CLEANING] = "cleaning",
523578aa LP	183	};
	184
	185	DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
	186
	187	static const char* const slice_state_table[_SLICE_STATE_MAX] = {
	188	[SLICE_DEAD] = "dead",
	189	[SLICE_ACTIVE] = "active"
	190	};
	191
	192	DEFINE_STRING_TABLE_LOOKUP(slice_state, SliceState);
	193
	194	static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
	195	[SOCKET_DEAD] = "dead",
	196	[SOCKET_START_PRE] = "start-pre",
	197	[SOCKET_START_CHOWN] = "start-chown",
	198	[SOCKET_START_POST] = "start-post",
	199	[SOCKET_LISTENING] = "listening",
	200	[SOCKET_RUNNING] = "running",
	201	[SOCKET_STOP_PRE] = "stop-pre",
	202	[SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
	203	[SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
	204	[SOCKET_STOP_POST] = "stop-post",
	205	[SOCKET_FINAL_SIGTERM] = "final-sigterm",
	206	[SOCKET_FINAL_SIGKILL] = "final-sigkill",
	207	[SOCKET_FAILED] = "failed"
	208	};
	209
	210	DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
	211
	212	static const char* const swap_state_table[_SWAP_STATE_MAX] = {
	213	[SWAP_DEAD] = "dead",
	214	[SWAP_ACTIVATING] = "activating",
	215	[SWAP_ACTIVATING_DONE] = "activating-done",
	216	[SWAP_ACTIVE] = "active",
	217	[SWAP_DEACTIVATING] = "deactivating",
	218	[SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
	219	[SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
	220	[SWAP_FAILED] = "failed"
	221	};
	222
	223	DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
	224
	225	static const char* const target_state_table[_TARGET_STATE_MAX] = {
	226	[TARGET_DEAD] = "dead",
	227	[TARGET_ACTIVE] = "active"
	228	};
	229
	230	DEFINE_STRING_TABLE_LOOKUP(target_state, TargetState);
	231
	232	static const char* const timer_state_table[_TIMER_STATE_MAX] = {
	233	[TIMER_DEAD] = "dead",
	234	[TIMER_WAITING] = "waiting",
	235	[TIMER_RUNNING] = "running",
	236	[TIMER_ELAPSED] = "elapsed",
	237	[TIMER_FAILED] = "failed"
	238	};
	239
	240	DEFINE_STRING_TABLE_LOOKUP(timer_state, TimerState);
	241
	242	static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
	243	[UNIT_REQUIRES] = "Requires",
	244	[UNIT_REQUISITE] = "Requisite",
	245	[UNIT_WANTS] = "Wants",
	246	[UNIT_BINDS_TO] = "BindsTo",
247	[UNIT_PART_OF] = "PartOf",
248	[UNIT_REQUIRED_BY] = "RequiredBy",
249	[UNIT_REQUISITE_OF] = "RequisiteOf",
250	[UNIT_WANTED_BY] = "WantedBy",
251	[UNIT_BOUND_BY] = "BoundBy",
252	[UNIT_CONSISTS_OF] = "ConsistsOf",
253	[UNIT_CONFLICTS] = "Conflicts",
254	[UNIT_CONFLICTED_BY] = "ConflictedBy",
255	[UNIT_BEFORE] = "Before",
256	[UNIT_AFTER] = "After",
257	[UNIT_ON_FAILURE] = "OnFailure",
258	[UNIT_TRIGGERS] = "Triggers",
259	[UNIT_TRIGGERED_BY] = "TriggeredBy",
260	[UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
261	[UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
262	[UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
263	[UNIT_REFERENCES] = "References",
264	[UNIT_REFERENCED_BY] = "ReferencedBy",
265	};
266
267	DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);
268
269	static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
270	[NOTIFY_NONE] = "none",
271	[NOTIFY_MAIN] = "main",
272	[NOTIFY_EXEC] = "exec",
273	[NOTIFY_ALL] = "all"
274	};
275
276	DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);