[core] don't release mainaction before stopping workers

This reverts commit f2ade38923.

Running workers will try to handle connections, and thus changing
mainaction without locking is a race condition, and also we don't handle
a NULL mainaction properly and segfault.

Given running connections will keep mainaction alive anyway, it is
unclear what the purpose of releasing it early was in the first place.

Change-Id: I2266958520c3cfca28c5c19574abdf44ddf6b0bc

include/lighttpd/angel_plugin.h

@@ -11,6 +11,7 @@ typedef struct liPlugins liPlugins;
 
 typedef gboolean (*liPluginInitCB)                (liServer *srv, liPlugin *p);
 typedef void     (*liPluginFreeCB)                (liServer *srv, liPlugin *p);
+typedef void     (*liPluginStopCB)                (liServer *srv, liPlugin *p);
 
 typedef void     (*liPluginCleanConfigCB)         (liServer *srv, liPlugin *p);
 typedef gboolean (*liPluginCheckConfigCB)         (liServer *srv, liPlugin *p, GError **err);
@@ -37,8 +38,8 @@ struct liPlugin {
 	GHashTable *angel_callbacks; /**< map (const gchar*) -> liPluginHandleCallCB */
 
 	liPluginFreeCB handle_free;   /**< called before plugin is unloaded */
+	liPluginStopCB handle_stop;   /**< called to stop server */
 
-	liPluginCleanConfigCB handle_clean_config;        /**< called before the reloading of the config is started or after the reloading failed */
 	liPluginCheckConfigCB handle_check_config;        /**< called before activating a config to ensure everything works */
 	liPluginActivateConfigCB handle_activate_config;  /**< called to activate a config after successful loading it. this cannot fail */
 
@@ -49,21 +50,21 @@ struct liPlugin {
 struct liPlugins {
 	GString *config_filename;
 
-	GHashTable *items, *load_items; /**< gchar* -> server_item */
+	GHashTable *items; /**< gchar* -> server_item */
 
 	liModules *modules;
 
-	GHashTable *module_refs, *load_module_refs; /** gchar* -> server_module */
+	GHashTable *module_refs; /** gchar* -> server_module */
-	GHashTable *ht_plugins, *load_ht_plugins;
+	GHashTable *ht_plugins;
 
-	GPtrArray *plugins, *load_plugins; /* plugin* */
+	GPtrArray *plugins; /* plugin* */
 };
 
 LI_API void li_plugins_init(liServer *srv, const gchar *module_dir, gboolean module_resident);
 LI_API void li_plugins_clear(liServer *srv);
 
-LI_API void li_plugins_config_clean(liServer *srv);
 LI_API gboolean li_plugins_config_load(liServer *srv, const gchar *filename);
+LI_API void li_plugins_stop(liServer *srv);
 
 LI_API gboolean li_plugins_handle_item(liServer *srv, GString *itemname, liValue *parameters, GError **err);
 

include/lighttpd/angel_plugin_core.h

@@ -3,70 +3,6 @@
 
 #include <lighttpd/angel_base.h>
 
-typedef struct liPluginCoreParsing liPluginCoreParsing;
-struct liPluginCoreParsing {
-	GPtrArray *env; /* <gchar*> */
-
-	GString *user;
-	uid_t user_uid;
-	gid_t user_gid;
-
-	GString *group;
-	gid_t group_gid;
-
-	GString *binary;
-	GString *config;
-	GString *luaconfig;
-	GString *modules_path;
-	GPtrArray *wrapper; /* <gchar*> */
-
-	gint64 rlim_core, rlim_nofile;
-
-	liInstanceConf *instconf;
-
-	GPtrArray *listen_masks;
-};
-
-typedef struct liPluginCoreConfig liPluginCoreConfig;
-struct liPluginCoreConfig {
-	/* Parsing/Load */
-	liPluginCoreParsing parsing;
-
-	/* Running */
-	liInstanceConf *instconf;
-	GPtrArray *listen_masks;
-
-	liInstance *inst;
-	GHashTable *listen_sockets;
-
-	liEventSignal sig_hup;
-};
-
-typedef struct liPluginCoreListenMask liPluginCoreListenMask;
-struct liPluginCoreListenMask {
-	enum {
-		LI_PLUGIN_CORE_LISTEN_MASK_IPV4,
-		LI_PLUGIN_CORE_LISTEN_MASK_IPV6,
-		LI_PLUGIN_CORE_LISTEN_MASK_UNIX
-	} type;
-
-	union {
-		struct {
-			guint32 addr;
-			guint32 networkmask;
-			guint16 port;
-		} ipv4;
-		struct {
-			guint8 addr[16];
-			guint network;
-			guint16 port;
-		} ipv6;
-		struct {
-			GString *path;
-		} unix_socket;
-	} value;
-};
-
 LI_API gboolean li_plugin_core_init(liServer *srv);
 
 #endif

include/lighttpd/angel_server.h

@@ -29,6 +29,7 @@ struct liInstance {
 	liServer *srv;
 	liInstanceConf *ic;
 
+	int pid;  /** < remember PID for process as instance ID, even if process is already gone */
 	liProc *proc;
 	liEventChild child_watcher;
 

src/angel/angel_config_parser.rl

@@ -387,6 +387,7 @@ static gboolean tokenizer_init_file(liServer *srv, liConfigTokenizerContext *ctx
 
 static void tokenizer_clear(liConfigTokenizerContext *ctx) {
 	g_string_free(ctx->token_string, TRUE);
+	g_hash_table_destroy(ctx->variables);
 }
 
 static liConfigToken tokenizer_next(liConfigTokenizerContext *ctx, GError **error) {

src/angel/angel_main.c

@@ -87,8 +87,6 @@ int main(int argc, char *argv[]) {
 		goto cleanup;
 	}
 
-	INFO(srv, "%s", "parsed config file");
-
 	li_event_loop_run(&srv->loop);
 
 	INFO(srv, "%s", "going down");

src/angel/angel_plugin.c

@@ -13,7 +13,6 @@ struct server_item {
 
 typedef struct server_module server_module;
 struct server_module {
-	guint refcount;
 	gchar *name;
 	liServer *srv;
 	liModule *mod;
@@ -48,9 +47,6 @@ static void _server_module_release(gpointer d) {
 	server_module *sm = d;
 	guint i;
 
-	g_assert(sm->refcount > 0);
-	if (0 != --sm->refcount) return;
-
 	for (i = sm->plugins->len; i-- > 0; ) {
 		liPlugin *p = g_ptr_array_index(sm->plugins, i);
 		li_plugin_free(sm->srv, p);
@@ -61,14 +57,8 @@ static void _server_module_release(gpointer d) {
 	g_slice_free(server_module, sm);
 }
 
-static void server_module_acquire(server_module *sm) {
-	g_assert(sm->refcount > 0);
-	sm->refcount++;
-}
-
 static server_module* server_module_new(liServer *srv, const gchar *name) { /* module is set later */
 	server_module *sm = g_slice_new0(server_module);
-	sm->refcount = 1;
 	sm->srv = srv;
 	sm->plugins = g_ptr_array_new();
 	sm->name = g_strdup(name);
@@ -81,124 +71,90 @@ void li_plugins_init(liServer *srv, const gchar *module_dir, gboolean module_res
 	ps->modules = li_modules_new(srv, module_dir, module_resident);
 
 	ps->items = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, _server_item_free);
-	ps->load_items = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, _server_item_free);
 
 	ps->module_refs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, _server_module_release);
-	ps->load_module_refs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, _server_module_release);
 
 	ps->ht_plugins = g_hash_table_new(g_str_hash, g_str_equal);
-	ps->load_ht_plugins = g_hash_table_new(g_str_hash, g_str_equal);
 
 	ps->plugins = g_ptr_array_new();
-	ps->load_plugins = g_ptr_array_new();
 }
 
 void li_plugins_clear(liServer *srv) {
 	liPlugins *ps = &srv->plugins;
 
-	li_plugins_config_clean(srv);
-
 	g_hash_table_destroy(ps->items);
-	g_hash_table_destroy(ps->load_items);
-
 	g_hash_table_destroy(ps->module_refs);
-	g_hash_table_destroy(ps->load_module_refs);
-
 	g_hash_table_destroy(ps->ht_plugins);
-	g_hash_table_destroy(ps->load_ht_plugins);
-
 	g_ptr_array_free(ps->plugins, TRUE);
-	g_ptr_array_free(ps->load_plugins, TRUE);
 
 	if (ps->config_filename) g_string_free(ps->config_filename, TRUE);
 
 	li_modules_free(ps->modules);
 }
 
-void li_plugins_config_clean(liServer *srv) {
-	liPlugins *ps = &srv->plugins;
-	guint i;
-
-	for (i = ps->load_plugins->len; i-- > 0; ) {
-		liPlugin *p = g_ptr_array_index(ps->load_plugins, i);
-		if (p->handle_clean_config) p->handle_clean_config(srv, p);
-	}
-
-	g_hash_table_remove_all(ps->load_items);
-	g_hash_table_remove_all(ps->load_module_refs);
-	g_hash_table_remove_all(ps->load_ht_plugins);
-	g_ptr_array_set_size(ps->load_plugins, 0);
-}
-
 gboolean li_plugins_config_load(liServer *srv, const gchar *filename) {
 	liPlugins *ps = &srv->plugins;
 	GError *error = NULL;
 	guint i;
 
-	if (filename) {
+	if (!li_plugins_load_module(srv, NULL)) {
-		if (!li_plugins_load_module(srv, NULL)) {
+		ERROR(srv, "%s", "failed loading core plugins");
-			ERROR(srv, "%s", "failed loading core plugins");
+		return FALSE;
-			li_plugins_config_clean(srv);
-			return FALSE;
-		}
-
-		if (!li_angel_config_parse_file(srv, filename, &error)) {
-			ERROR(srv, "failed to parse config file: %s", error->message);
-			g_error_free(error);
-			li_plugins_config_clean(srv);
-			return FALSE;
-		}
 	}
 
+	if (!li_angel_config_parse_file(srv, filename, &error)) {
+		ERROR(srv, "failed to parse config file: %s", error->message);
+		g_error_free(error);
+		return FALSE;
+	}
+
+	DEBUG(srv, "parsed config file: %s", filename);
+
 	/* check new config */
-	for (i = ps->load_plugins->len; i-- > 0; ) {
+	for (i = ps->plugins->len; i-- > 0; ) {
-		liPlugin *p = g_ptr_array_index(ps->load_plugins, i);
+		liPlugin *p = g_ptr_array_index(ps->plugins, i);
 		if (p->handle_check_config) {
 			if (!p->handle_check_config(srv, p, &error)) {
 				ERROR(srv, "config check failed: %s", error->message);
 				g_error_free(error);
-				li_plugins_config_clean(srv);
 				return FALSE;
 			}
 		}
 	}
 
-	INFO(srv, "%s", "activate");
-
 	/* activate new config */
-	for (i = ps->load_plugins->len; i-- > 0; ) {
+	for (i = ps->plugins->len; i-- > 0; ) {
-		liPlugin *p = g_ptr_array_index(ps->load_plugins, i);
+		liPlugin *p = g_ptr_array_index(ps->plugins, i);
-		INFO(srv, "activate: %s", p->name);
+		DEBUG(srv, "activate plugin: %s", p->name);
 		if (p->handle_activate_config) {
 			p->handle_activate_config(srv, p);
 		}
 	}
 
-	INFO(srv, "%s", "done");
+	DEBUG(srv, "%s", "config loading done");
 
-	{ /* swap the arrays */
+	LI_FORCE_ASSERT(NULL == ps->config_filename);
-		GPtrArray *tmp = ps->load_plugins; ps->load_plugins = ps->plugins; ps->plugins = tmp;
+	ps->config_filename = g_string_new(filename);
-	}
-	{ /* swap the hash tables */
-		GHashTable *tmp;
-		tmp = ps->load_items; ps->load_items = ps->items; ps->items = tmp;
-		tmp = ps->load_module_refs; ps->load_module_refs = ps->module_refs; ps->module_refs = tmp;
-		tmp = ps->load_ht_plugins; ps->load_ht_plugins = ps->ht_plugins; ps->ht_plugins = tmp;
-	}
-	g_hash_table_remove_all(ps->load_items);
-	g_hash_table_remove_all(ps->load_module_refs);
-	g_hash_table_remove_all(ps->load_ht_plugins);
-	g_ptr_array_set_size(ps->load_plugins, 0);
-
-	if (!ps->config_filename) {
-		ps->config_filename = g_string_new(filename);
-	} else {
-		g_string_assign(ps->config_filename, filename ? filename : "");
-	}
 
 	return TRUE;
 }
 
+void li_plugins_stop(liServer *srv) {
+	liPlugins *ps = &srv->plugins;
+	guint i;
+
+	g_string_assign(ps->config_filename, "");
+
+	/* activate new config */
+	for (i = ps->plugins->len; i-- > 0; ) {
+		liPlugin *p = g_ptr_array_index(ps->plugins, i);
+		INFO(srv, "stop: %s", p->name);
+		if (p->handle_stop) {
+			p->handle_stop(srv, p);
+		}
+	}
+}
+
 gboolean li_plugins_handle_item(liServer *srv, GString *itemname, liValue *parameters, GError **err) {
 	liPlugins *ps = &srv->plugins;
 	server_item *si;
@@ -212,7 +168,7 @@ gboolean li_plugins_handle_item(liServer *srv, GString *itemname, liValue *param
 	}
 #endif
 
-	si = g_hash_table_lookup(ps->load_items, itemname->str);
+	si = g_hash_table_lookup(ps->items, itemname->str);
 	if (!si) {
 		g_set_error(err, LI_ANGEL_CONFIG_PARSER_ERROR, LI_ANGEL_CONFIG_PARSER_ERROR_PARSE,
 			"Unknown item '%s' - perhaps you forgot to load the module?", itemname->str);
@@ -230,19 +186,19 @@ static gboolean plugins_activate_module(liServer *srv, server_module *sm) {
 
 	for (i = 0; i < sm->plugins->len; i++) {
 		p = g_ptr_array_index(sm->plugins, i);
-		g_ptr_array_add(ps->load_plugins, p);
+		g_ptr_array_add(ps->plugins, p);
-		g_hash_table_insert(ps->load_ht_plugins, (gpointer) p->name, p);
+		g_hash_table_insert(ps->ht_plugins, (gpointer) p->name, p);
 		if (!p->items) continue;
 
 		for (pi = p->items; pi->name; pi++) {
 			server_item *si;
-			if (NULL != (si = g_hash_table_lookup(ps->load_items, pi->name))) {
+			if (NULL != (si = g_hash_table_lookup(ps->items, pi->name))) {
 				ERROR(srv, "Plugin item name conflict: cannot load '%s' for plugin '%s' (already provided by plugin '%s')",
 					pi->name, p->name, si->p->name);
 				goto item_collision;
 			} else {
 				si = server_item_new(p, pi);
-				g_hash_table_insert(ps->load_items, (gpointer) pi->name, si);
+				g_hash_table_insert(ps->items, (gpointer) pi->name, si);
 			}
 		}
 	}
@@ -252,18 +208,18 @@ static gboolean plugins_activate_module(liServer *srv, server_module *sm) {
 item_collision:
 	/* removed added items and plugins */
 	for ( ; pi-- != p->items; ) {
-		g_hash_table_remove(ps->load_items, pi->name);
+		g_hash_table_remove(ps->items, pi->name);
 	}
 
-	g_ptr_array_set_size(ps->load_plugins, ps->load_plugins->len - i+1);
+	g_ptr_array_set_size(ps->plugins, ps->plugins->len - i+1);
 
 	for ( ; i-- > 0; ) {
 		p = g_ptr_array_index(sm->plugins, i);
-		g_hash_table_remove(ps->load_ht_plugins, p->name);
+		g_hash_table_remove(ps->ht_plugins, p->name);
 		if (!p->items) continue;
 
 		for (pi = p->items; pi->name; pi++) {
-			g_hash_table_remove(ps->load_items, pi->name);
+			g_hash_table_remove(ps->items, pi->name);
 		}
 	}
 
@@ -275,16 +231,14 @@ gboolean li_plugins_load_module(liServer *srv, const gchar *name) {
 	server_module *sm;
 	const gchar* modname = name ? name : "core";
 
-	sm = g_hash_table_lookup(ps->load_module_refs, modname);
-	if (sm) return TRUE; /* already loaded */
 	sm = g_hash_table_lookup(ps->module_refs, modname);
-	if (sm) { /* loaded in previous config */
+	if (sm) return TRUE; /* already loaded */
-		server_module_acquire(sm);
+
-		g_hash_table_insert(ps->load_module_refs, sm->name, sm);
+	{
-	} else { /* not loaded yet */
+		/* not loaded yet */
 		liModule *mod;
 		sm = server_module_new(srv, modname);
-		g_hash_table_insert(ps->load_module_refs, sm->name, sm);
+		g_hash_table_insert(ps->module_refs, sm->name, sm);
 		if (name) {
 			mod = li_module_load(ps->modules, name);
 
@@ -315,7 +269,7 @@ liPlugin *li_angel_plugin_register(liServer *srv, liModule *mod, const gchar *na
 	liPlugin *p;
 	const gchar* modname = mod ? mod->name->str : "core";
 
-	sm = g_hash_table_lookup(ps->load_module_refs, modname);
+	sm = g_hash_table_lookup(ps->module_refs, modname);
 	if (!sm) {
 		ERROR(srv, "Module '%s' not loaded; cannot load plugin '%s'", modname, name);
 		return NULL;

src/angel/angel_plugin_core.c

@@ -16,6 +16,69 @@ typedef struct listen_ref_resource listen_ref_resource;
 # define DEFAULT_LIBEXECDIR "/usr/local/lib/lighttpd2"
 #endif
 
+struct plugin_parsing {
+	GPtrArray *env; /* <gchar*> */
+
+	GString *user;
+	uid_t user_uid;
+	gid_t user_gid;
+
+	GString *group;
+	gid_t group_gid;
+
+	GString *binary;
+	GString *config;
+	GString *luaconfig;
+	GString *modules_path;
+	GPtrArray *wrapper; /* <gchar*> */
+
+	gint64 rlim_core, rlim_nofile;
+
+	liInstanceConf *instconf;
+
+	GPtrArray *listen_masks;
+};
+
+typedef struct plugin_config plugin_config;
+struct plugin_config {
+	/* Parsing/Load */
+	struct plugin_parsing parsing;
+
+	/* Running */
+	liInstanceConf *instconf;
+	GPtrArray *listen_masks;
+
+	liInstance *inst;
+	GHashTable *listen_sockets;
+
+	liEventSignal sig_hup;
+};
+
+typedef struct listen_mask listen_mask;
+struct listen_mask {
+	enum {
+		LI_PLUGIN_CORE_LISTEN_MASK_IPV4,
+		LI_PLUGIN_CORE_LISTEN_MASK_IPV6,
+		LI_PLUGIN_CORE_LISTEN_MASK_UNIX
+	} type;
+
+	union {
+		struct {
+			guint32 addr;
+			guint32 networkmask;
+			guint16 port;
+		} ipv4;
+		struct {
+			guint8 addr[16];
+			guint network;
+			guint16 port;
+		} ipv6;
+		struct {
+			GString *path;
+		} unix_socket;
+	} value;
+};
+
 struct listen_socket {
 	gint refcount;
 
@@ -89,7 +152,7 @@ static gboolean core_parse_store_integer(liValue *value, const char* item, gint6
 
 
 static gboolean core_parse_user(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	struct passwd *pwd;
 	GString *user;
 	UNUSED(srv);
@@ -120,7 +183,7 @@ static gboolean core_parse_user(liServer *srv, liPlugin *p, liValue *value, GErr
 }
 
 static gboolean core_parse_group(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	struct group *grp;
 	GString *group;
 	UNUSED(srv);
@@ -145,14 +208,14 @@ static gboolean core_parse_group(liServer *srv, liPlugin *p, liValue *value, GEr
 }
 
 static gboolean core_parse_binary(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	return core_parse_store_string(value, "binary", &pc->parsing.binary, err);
 }
 
 static gboolean core_parse_config(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	if (NULL != pc->parsing.luaconfig) {
@@ -165,7 +228,7 @@ static gboolean core_parse_config(liServer *srv, liPlugin *p, liValue *value, GE
 }
 
 static gboolean core_parse_luaconfig(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	if (NULL != pc->parsing.config) {
@@ -178,7 +241,7 @@ static gboolean core_parse_luaconfig(liServer *srv, liPlugin *p, liValue *value,
 }
 
 static gboolean core_parse_modules_path(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	return core_parse_store_string(value, "modules_path", &pc->parsing.modules_path, err);
@@ -194,7 +257,7 @@ static void add_env(GPtrArray *env, const char *key, size_t keylen, const char *
 }
 
 static gboolean core_parse_env(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	value = li_value_get_single_argument(value);
@@ -226,7 +289,7 @@ parameter_type_error:
 }
 
 static gboolean core_parse_copy_env(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	value = li_value_get_single_argument(value);
@@ -256,14 +319,14 @@ parameter_type_error:
 }
 
 static gboolean core_parse_wrapper(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	return core_parse_store_string_list(value, "wrapper", pc->parsing.wrapper, err);
 }
 
 static gboolean core_parse_max_core_file_size(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	if (-1 != pc->parsing.rlim_core) {
@@ -276,7 +339,7 @@ static gboolean core_parse_max_core_file_size(liServer *srv, liPlugin *p, liValu
 }
 
 static gboolean core_parse_max_open_files(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	if (-1 != pc->parsing.rlim_nofile) {
@@ -291,7 +354,7 @@ static gboolean core_parse_max_open_files(liServer *srv, liPlugin *p, liValue *v
 
 
 
-static void core_listen_mask_free(liPluginCoreListenMask *mask) {
+static void core_listen_mask_free(listen_mask *mask) {
 	if (NULL == mask) return;
 
 	switch (mask->type) {
@@ -302,11 +365,11 @@ static void core_listen_mask_free(liPluginCoreListenMask *mask) {
 		g_string_free(mask->value.unix_socket.path, TRUE);
 		break;
 	}
-	g_slice_free(liPluginCoreListenMask, mask);
+	g_slice_free(listen_mask, mask);
 }
 
 static gboolean core_parse_allow_listen(liServer *srv, liPlugin *p, liValue *value, GError **err) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	value = li_value_get_single_argument(value);
@@ -316,12 +379,12 @@ static gboolean core_parse_allow_listen(liServer *srv, liPlugin *p, liValue *val
 
 	LI_VALUE_FOREACH(entry, value)
 		GString *s;
-		liPluginCoreListenMask *mask;
+		listen_mask *mask;
 
 		if (LI_VALUE_STRING != li_value_type(entry)) goto parameter_type_error;
 		s = entry->data.string;
 
-		mask = g_slice_new0(liPluginCoreListenMask);
+		mask = g_slice_new0(listen_mask);
 		if (li_string_prefix(s, CONST_STR_LEN("unix:/"))) {
 			mask->type = LI_PLUGIN_CORE_LISTEN_MASK_UNIX;
 			mask->value.unix_socket.path = li_value_extract_string(entry);
@@ -336,7 +399,7 @@ static gboolean core_parse_allow_listen(liServer *srv, liPlugin *p, liValue *val
 		else {
 			g_set_error(err, LI_ANGEL_CONFIG_PARSER_ERROR, LI_ANGEL_CONFIG_PARSER_ERROR_PARSE,
 				"allow_listen: couldn't parse socket address mask '%s'", s->str);
-			g_slice_free(liPluginCoreListenMask, mask);
+			g_slice_free(listen_mask, mask);
 			return FALSE;
 		}
 
@@ -386,7 +449,7 @@ static const liPluginItem core_items[] = {
 	}
 
 static void core_parse_init(liServer *srv, liPlugin *p) {
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	UNUSED(srv);
 
 	INIT_STR_LIST(env);
@@ -427,7 +490,7 @@ static gboolean core_check(liServer *srv, liPlugin *p, GError **err) {
 	GPtrArray *cmd;
 	GString *user;
 	gchar **cmdarr, **envarr;
-	liPluginCoreConfig *pc = p->data;
+	plugin_config *pc = p->data;
 	gid_t gid = ((gid_t)-1 != pc->parsing.group_gid) ? pc->parsing.group_gid : pc->parsing.user_gid;
 	UNUSED(srv);
 	UNUSED(err);
@@ -500,7 +563,7 @@ static void listen_ref_release(liServer *srv, liInstance *i, liPlugin *p, liInst
 
 	LI_FORCE_ASSERT(g_atomic_int_get(&sock->refcount) > 0);
 	if (g_atomic_int_dec_and_test(&sock->refcount)) {
-		liPluginCoreConfig *config = (liPluginCoreConfig*) p->data;
+		plugin_config *config = (plugin_config*) p->data;
 
 		/* theoretically the hash table entry might not point to `sock`,
 		 * but a) that shouldn't happen (can't bind two sockets to same
@@ -527,9 +590,9 @@ static void listen_socket_add(liInstance *i, liPlugin *p, listen_socket *sock) {
 	li_instance_add_resource(i, &ref->ires, listen_ref_release, p, ref);
 }
 
-static gboolean listen_check_acl(liServer *srv, liPluginCoreConfig *config, liSocketAddress *addr) {
+static gboolean listen_check_acl(liServer *srv, plugin_config *config, liSocketAddress *addr) {
 	guint i;
-	liPluginCoreListenMask *mask;
+	listen_mask *mask;
 
 	switch (addr->addr_up.plain->sa_family) {
 	case AF_INET: {
@@ -720,7 +783,7 @@ static void core_listen(liServer *srv, liPlugin *p, liInstance *i, gint32 id, GS
 	GError *err = NULL;
 	gint fd;
 	GArray *fds;
-	liPluginCoreConfig *config = (liPluginCoreConfig*) p->data;
+	plugin_config *config = (plugin_config*) p->data;
 	liSocketAddress addr;
 	listen_socket *sock;
 
@@ -866,7 +929,7 @@ static void core_log_open_file(liServer *srv, liPlugin *p, liInstance *i, gint32
 }
 
 static void core_free(liServer *srv, liPlugin *p) {
-	liPluginCoreConfig *config = (liPluginCoreConfig*) p->data;
+	plugin_config *config = (plugin_config*) p->data;
 	guint i;
 
 	li_event_clear(&config->sig_hup);
@@ -897,11 +960,22 @@ static void core_free(liServer *srv, liPlugin *p) {
 	g_hash_table_destroy(config->listen_sockets);
 	config->listen_masks = NULL;
 
-	g_slice_free(liPluginCoreConfig, config);
+	g_slice_free(plugin_config, config);
+}
+
+static void core_stop(liServer *srv, liPlugin *p) {
+	plugin_config *config = (plugin_config *)p->data;
+	UNUSED(srv);
+
+	if (config->inst) {
+		li_instance_set_state(config->inst, LI_INSTANCE_FINISHED);
+		li_instance_release(config->inst);
+		config->inst = NULL;
+	}
 }
 
 static void core_activate(liServer *srv, liPlugin *p) {
-	liPluginCoreConfig *config = (liPluginCoreConfig*) p->data;
+	plugin_config *config = (plugin_config*) p->data;
 	GPtrArray *tmp_ptrarray;
 	guint i;
 
@@ -934,7 +1008,7 @@ static void core_activate(liServer *srv, liPlugin *p) {
 }
 
 static void core_instance_replaced(liServer *srv, liPlugin *p, liInstance *oldi, liInstance *newi) {
-	liPluginCoreConfig *config = (liPluginCoreConfig*) p->data;
+	plugin_config *config = (plugin_config*) p->data;
 	UNUSED(srv);
 
 	if (oldi == config->inst && LI_INSTANCE_FINISHED == oldi->s_cur) {
@@ -945,7 +1019,7 @@ static void core_instance_replaced(liServer *srv, liPlugin *p, liInstance *oldi,
 }
 
 static void core_handle_sig_hup(liEventBase *watcher, int events) {
-	liPluginCoreConfig *config = LI_CONTAINER_OF(li_event_signal_from(watcher), liPluginCoreConfig, sig_hup);
+	plugin_config *config = LI_CONTAINER_OF(li_event_signal_from(watcher), plugin_config, sig_hup);
 	liInstance *oldi, *newi;
 	UNUSED(events);
 
@@ -960,13 +1034,13 @@ static void core_handle_sig_hup(liEventBase *watcher, int events) {
 }
 
 static gboolean core_init(liServer *srv, liPlugin *p) {
-	liPluginCoreConfig *config;
+	plugin_config *config;
 	UNUSED(srv);
-	p->data = config = g_slice_new0(liPluginCoreConfig);
+	p->data = config = g_slice_new0(plugin_config);
 	p->items = core_items;
 
 	p->handle_free = core_free;
-	p->handle_clean_config = core_parse_init;
+	p->handle_stop = core_stop;
 	p->handle_check_config = core_check;
 	p->handle_activate_config = core_activate;
 	p->handle_instance_replaced = core_instance_replaced;

src/angel/angel_server.c

@@ -46,7 +46,7 @@ void li_server_stop(liServer *srv) {
 	li_event_stop(&srv->sig_w_INT);
 	li_event_stop(&srv->sig_w_TERM);
 
-	li_plugins_config_load(srv, NULL);
+	li_plugins_stop(srv);
 
 	li_event_loop_end(&srv->loop);
 }
@@ -125,24 +125,24 @@ static void instance_child_cb(liEventBase *watcher, int events) {
 	if (i->s_dest == LI_INSTANCE_FINISHED) {
 		if (WIFEXITED(status)) {
 			if (0 != WEXITSTATUS(status)) {
-				ERROR(i->srv, "child %i died with exit status %i", i->proc->child_pid, WEXITSTATUS(status));
+				ERROR(i->srv, "instance[%i] died with exit status %i", i->pid, WEXITSTATUS(status));
 			} /* exit status 0 is ok, no message */
 		} else if (WIFSIGNALED(status)) {
-			ERROR(i->srv, "child %i died: killed by '%s' (%i)", i->proc->child_pid, g_strsignal(WTERMSIG(status)), WTERMSIG(status));
+			ERROR(i->srv, "instance[%i] died: killed by '%s' (%i)", i->pid, g_strsignal(WTERMSIG(status)), WTERMSIG(status));
 		} else {
-			ERROR(i->srv, "child %i died with unexpected stat_val %i", i->proc->child_pid, status);
+			ERROR(i->srv, "instance[%i] died with unexpected stat_val %i", i->pid, status);
 		}
 		news = LI_INSTANCE_FINISHED;
 	} else {
 		if (WIFEXITED(status)) {
-			ERROR(i->srv, "child %i died with exit status %i", i->proc->child_pid, WEXITSTATUS(status));
+			ERROR(i->srv, "instance[%i] died with exit status %i", i->pid, WEXITSTATUS(status));
 		} else if (WIFSIGNALED(status)) {
-			ERROR(i->srv, "child %i died: killed by %s", i->proc->child_pid, g_strsignal(WTERMSIG(status)));
+			ERROR(i->srv, "instance[%i] died: killed by %s", i->pid, g_strsignal(WTERMSIG(status)));
 		} else {
-			ERROR(i->srv, "child %i died with unexpected stat_val %i", i->proc->child_pid, status);
+			ERROR(i->srv, "instance[%i] died with unexpected stat_val %i", i->pid, status);
 		}
 		if (i->s_cur == LI_INSTANCE_DOWN) {
-			ERROR(i->srv, "spawning child %i failed, not restarting", i->proc->child_pid);
+			ERROR(i->srv, "instance[%i] spawning failed, not restarting", i->pid);
 			news = i->s_dest = LI_INSTANCE_FINISHED; /* TODO: retry spawn later? */
 		} else {
 			news = LI_INSTANCE_DOWN;
@@ -183,12 +183,13 @@ static void instance_spawn(liInstance *i) {
 
 	if (!i->proc) return;
 
+	i->pid = i->proc->child_pid;
 	close(confd[1]);
 	li_event_clear(&i->child_watcher);
 	li_event_child_init(&i->srv->loop, "lighttpd2-worker", &i->child_watcher, instance_child_cb, i->proc->child_pid);
 	i->s_cur = LI_INSTANCE_DOWN;
 	li_instance_acquire(i);
-	DEBUG(i->srv, "Instance (%i) spawned: %s", i->proc->child_pid, i->ic->cmd[0]);
+	INFO(i->srv, "instance[%i] spawned: %s", i->pid, i->ic->cmd[0]);
 }
 
 liInstance* li_server_new_instance(liServer *srv, liInstanceConf *ic) {
@@ -335,7 +336,7 @@ void li_instance_state_reached(liInstance *i, liInstanceState s) {
 			li_instance_unset_replace(i->replace, i);
 		} else if (i->s_dest == LI_INSTANCE_FINISHED) {
 			if (i->replace_by) {
-				INFO(i->srv, "%s", "Instance replaced");
+				INFO(i->srv, "instance[%i] replaced by instance[%i]", i->pid, i->replace_by->pid);
 				if (i->replace_by->s_dest == LI_INSTANCE_WARMUP) {
 					li_instance_set_state(i->replace_by, LI_INSTANCE_RUNNING);
 				}
@@ -371,7 +372,7 @@ void li_instance_release(liInstance *i) {
 	if (!g_atomic_int_dec_and_test(&i->refcount)) return;
 	g_assert(!i->proc);
 
-	DEBUG(srv, "%s", "instance released");
+	DEBUG(srv, "instance[%i] released", i->pid);
 
 	li_instance_conf_release(i->ic);
 	i->ic = NULL;

src/main/server.c

@@ -712,11 +712,6 @@ static void li_server_start_transition(liServer *srv, liServerState state) {
 		/* wait for closed connections and plugins */
 		break;
 	case LI_SERVER_STOPPING:
-		{
-			liAction* mainaction = srv->mainaction;
-			srv->mainaction = NULL;
-			li_action_release(srv, mainaction);
-		}
 		/* stop all workers */
 		for (i = 0; i < srv->worker_count; i++) {
 			liWorker *wrk;