Refactor of process init.

Introduces the functions nxt_process_init_create() and
nxt_process_init_creds_set().

8 files changed, 249 insertions, 149 deletions

diff --git a/src/nxt_main_process.c b/src/nxt_main_process.c
index cfe0341f..05027443 100644
--- a/src/nxt_main_process.c
+++ b/src/nxt_main_process.c
@@ -29,6 +29,10 @@ typedef struct {
 } nxt_conf_app_map_t;
 
 
+extern nxt_port_handlers_t  nxt_controller_process_port_handlers;
+extern nxt_port_handlers_t  nxt_router_process_port_handlers;
+
+
 static nxt_int_t nxt_main_process_port_create(nxt_task_t *task,
     nxt_runtime_t *rt);
 static void nxt_main_process_title(nxt_task_t *task);
@@ -36,6 +40,8 @@ static nxt_int_t nxt_main_start_controller_process(nxt_task_t *task,
     nxt_runtime_t *rt);
 static nxt_int_t nxt_main_create_controller_process(nxt_task_t *task,
     nxt_runtime_t *rt, nxt_process_init_t *init);
+static nxt_int_t nxt_main_create_router_process(nxt_task_t *task, nxt_runtime_t *rt,
+    nxt_process_init_t *init);
 static nxt_int_t nxt_main_start_router_process(nxt_task_t *task,
     nxt_runtime_t *rt);
 static nxt_int_t nxt_main_start_discovery_process(nxt_task_t *task,
@@ -67,6 +73,12 @@ static void nxt_main_port_conf_store_handler(nxt_task_t *task,
     nxt_port_recv_msg_t *msg);
 static void nxt_main_port_access_log_handler(nxt_task_t *task,
     nxt_port_recv_msg_t *msg);
+static nxt_process_init_t *nxt_process_init_create(nxt_task_t *task,
+    nxt_process_type_t type, const nxt_str_t *name);
+static nxt_int_t nxt_process_init_name_set(nxt_process_init_t *init,
+    nxt_process_type_t type, const nxt_str_t *name);
+static nxt_int_t nxt_process_init_creds_set(nxt_task_t *task,
+    nxt_process_init_t *init, nxt_str_t *user, nxt_str_t *group);
 
 static nxt_int_t nxt_init_set_isolation(nxt_task_t *task,
     nxt_process_init_t *init, nxt_conf_value_t *isolation);
@@ -84,6 +96,54 @@ const nxt_sig_event_t  nxt_main_process_signals[] = {
 };
 
 
+static const nxt_port_handlers_t  nxt_app_process_port_handlers = {
+    .new_port     = nxt_port_new_port_handler,
+    .change_file  = nxt_port_change_log_file_handler,
+    .mmap         = nxt_port_mmap_handler,
+    .remove_pid   = nxt_port_remove_pid_handler,
+};
+
+
+static const nxt_port_handlers_t  nxt_discovery_process_port_handlers = {
+    .quit         = nxt_worker_process_quit_handler,
+    .new_port     = nxt_port_new_port_handler,
+    .change_file  = nxt_port_change_log_file_handler,
+    .mmap         = nxt_port_mmap_handler,
+    .data         = nxt_port_data_handler,
+    .remove_pid   = nxt_port_remove_pid_handler,
+    .rpc_ready    = nxt_port_rpc_handler,
+    .rpc_error    = nxt_port_rpc_handler,
+};
+
+
+static const nxt_port_handlers_t  *nxt_process_port_handlers[NXT_PROCESS_MAX] =
+{
+    NULL,
+    &nxt_discovery_process_port_handlers,
+    &nxt_controller_process_port_handlers,
+    &nxt_router_process_port_handlers,
+    &nxt_app_process_port_handlers
+};
+
+
+static const nxt_process_start_t  nxt_process_starts[NXT_PROCESS_MAX] = {
+    NULL,
+    nxt_discovery_start,
+    nxt_controller_start,
+    nxt_router_start,
+    nxt_app_start
+};
+
+
+static const nxt_process_restart_t  nxt_process_restarts[NXT_PROCESS_MAX] = {
+    NULL,
+    NULL,
+    &nxt_main_create_controller_process,
+    &nxt_main_create_router_process,
+    NULL
+};
+
+
 static nxt_bool_t  nxt_exiting;
 
 
@@ -453,20 +513,13 @@ nxt_main_start_controller_process(nxt_task_t *task, nxt_runtime_t *rt)
 {
     nxt_process_init_t  *init;
 
-    init = nxt_mp_zalloc(rt->mem_pool, sizeof(nxt_process_init_t));
+    static const nxt_str_t  name = nxt_string("controller");
+
+    init = nxt_process_init_create(task, NXT_PROCESS_CONTROLLER, &name);
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
 
-    init->start = nxt_controller_start;
-    init->name = "controller";
-    init->user_cred = &rt->user_cred;
-    init->port_handlers = &nxt_controller_process_port_handlers;
-    init->signals = nxt_worker_process_signals;
-    init->type = NXT_PROCESS_CONTROLLER;
-    init->stream = 0;
-    init->restart = &nxt_main_create_controller_process;
-
     return nxt_main_create_controller_process(task, rt, init);;
 }
 
@@ -547,21 +600,13 @@ nxt_main_start_discovery_process(nxt_task_t *task, nxt_runtime_t *rt)
 {
     nxt_process_init_t  *init;
 
-    init = nxt_mp_zalloc(rt->mem_pool, sizeof(nxt_process_init_t));
+    static const nxt_str_t  name = nxt_string("discovery");
+
+    init = nxt_process_init_create(task, NXT_PROCESS_DISCOVERY, &name);
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
 
-    init->start = nxt_discovery_start;
-    init->name = "discovery";
-    init->user_cred = &rt->user_cred;
-    init->port_handlers = &nxt_discovery_process_port_handlers;
-    init->signals = nxt_worker_process_signals;
-    init->type = NXT_PROCESS_DISCOVERY;
-    init->data = rt;
-    init->stream = 0;
-    init->restart = NULL;
-
     return nxt_main_create_worker_process(task, rt, init);
 }
 
@@ -571,72 +616,43 @@ nxt_main_start_router_process(nxt_task_t *task, nxt_runtime_t *rt)
 {
     nxt_process_init_t  *init;
 
-    init = nxt_mp_zalloc(rt->mem_pool, sizeof(nxt_process_init_t));
+    static const nxt_str_t  name = nxt_string("router");
+
+    init = nxt_process_init_create(task, NXT_PROCESS_ROUTER, &name);
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
 
-    init->start = nxt_router_start;
-    init->name = "router";
-    init->user_cred = &rt->user_cred;
-    init->port_handlers = &nxt_router_process_port_handlers;
-    init->signals = nxt_worker_process_signals;
-    init->type = NXT_PROCESS_ROUTER;
-    init->data = rt;
-    init->stream = 0;
-    init->restart = &nxt_main_create_worker_process;
+    return nxt_main_create_router_process(task, rt, init);
+}
+
+
+static nxt_int_t
+nxt_main_create_router_process(nxt_task_t *task, nxt_runtime_t *rt,
+    nxt_process_init_t *init)
+{
+    nxt_main_stop_worker_processes(task, rt);
 
     return nxt_main_create_worker_process(task, rt, init);
 }
 
+
 static nxt_int_t
 nxt_main_start_worker_process(nxt_task_t *task, nxt_runtime_t *rt,
     nxt_common_app_conf_t *app_conf, uint32_t stream)
 {
-    char                *user, *group;
-    u_char              *title, *last, *end;
-    size_t              size;
     nxt_int_t           ret;
     nxt_process_init_t  *init;
 
-    size = sizeof(nxt_process_init_t)
-           + app_conf->name.length
-           + sizeof("\"\" application");
-
-    if (rt->capabilities.setid) {
-        size += sizeof(nxt_user_cred_t)
-                + app_conf->user.length + 1
-                + app_conf->group.length + 1;
-    }
-
-    init = nxt_mp_zalloc(rt->mem_pool, size);
+    init = nxt_process_init_create(task, NXT_PROCESS_WORKER, &app_conf->name);
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
 
     if (rt->capabilities.setid) {
-        init->user_cred = nxt_pointer_to(init, sizeof(nxt_process_init_t));
-        user = nxt_pointer_to(init->user_cred, sizeof(nxt_user_cred_t));
-
-        nxt_memcpy(user, app_conf->user.start, app_conf->user.length);
-        last = nxt_pointer_to(user, app_conf->user.length);
-        *last++ = '\0';
-
-        init->user_cred->user = user;
-
-        if (app_conf->group.start != NULL) {
-            group = (char *) last;
-
-            nxt_memcpy(group, app_conf->group.start, app_conf->group.length);
-            last = nxt_pointer_to(group, app_conf->group.length);
-            *last++ = '\0';
-
-        } else {
-            group = NULL;
-        }
-
-        ret = nxt_user_cred_get(task, init->user_cred, group);
-        if (ret != NXT_OK) {
+        ret = nxt_process_init_creds_set(task, init, &app_conf->user,
+                                         &app_conf->group);
+        if (nxt_slow_path(ret != NXT_OK)) {
             goto fail;
         }
 
@@ -658,23 +674,10 @@ nxt_main_start_worker_process(nxt_task_t *task, nxt_runtime_t *rt,
                             &app_conf->name);
             goto fail;
         }
-
-        last = nxt_pointer_to(init, sizeof(nxt_process_init_t));
     }
 
-    title = last;
-    end = title + app_conf->name.length + sizeof("\"\" application");
-
-    nxt_sprintf(title, end, "\"%V\" application%Z", &app_conf->name);
-
-    init->start = nxt_app_start;
-    init->name = (char *) title;
-    init->port_handlers = &nxt_app_process_port_handlers;
-    init->signals = nxt_worker_process_signals;
-    init->type = NXT_PROCESS_WORKER;
     init->data = app_conf;
     init->stream = stream;
-    init->restart = NULL;
 
     ret = nxt_init_set_isolation(task, init, app_conf->isolation);
     if (nxt_slow_path(ret != NXT_OK)) {
@@ -685,13 +688,13 @@ nxt_main_start_worker_process(nxt_task_t *task, nxt_runtime_t *rt,
 
 fail:
 
-    nxt_mp_free(rt->mem_pool, init);
+    nxt_mp_destroy(init->mem_pool);
 
     return NXT_ERROR;
 }
 
 
-static nxt_int_t
+nxt_int_t
 nxt_main_create_worker_process(nxt_task_t *task, nxt_runtime_t *rt,
     nxt_process_init_t *init)
 {
@@ -706,7 +709,7 @@ nxt_main_create_worker_process(nxt_task_t *task, nxt_runtime_t *rt,
 
     process = nxt_runtime_process_new(rt);
     if (nxt_slow_path(process == NULL)) {
-        nxt_mp_free(rt->mem_pool, init);
+        nxt_mp_destroy(init->mem_pool);
 
         return NXT_ERROR;
     }
@@ -972,12 +975,13 @@ nxt_main_process_signal_handler(nxt_task_t *task, void *obj, void *data)
 static void
 nxt_main_cleanup_worker_process(nxt_task_t *task, nxt_pid_t pid)
 {
-    nxt_buf_t           *buf;
-    nxt_port_t          *port;
-    nxt_runtime_t       *rt;
-    nxt_process_t       *process;
-    nxt_process_type_t  ptype;
-    nxt_process_init_t  *init;
+    nxt_buf_t              *buf;
+    nxt_port_t             *port;
+    nxt_runtime_t          *rt;
+    nxt_process_t          *process;
+    nxt_process_type_t     ptype;
+    nxt_process_init_t     *init;
+    nxt_process_restart_t  restart;
 
     rt = task->thread->runtime;
 
@@ -988,6 +992,7 @@ nxt_main_cleanup_worker_process(nxt_task_t *task, nxt_pid_t pid)
         process->init = NULL;
 
         ptype = nxt_process_type(process);
+        restart = nxt_process_restarts[ptype];
 
         if (process->ready) {
             init->stream = 0;
@@ -996,6 +1001,8 @@ nxt_main_cleanup_worker_process(nxt_task_t *task, nxt_pid_t pid)
         nxt_process_close_ports(task, process);
 
         if (nxt_exiting) {
+            nxt_mp_destroy(init->mem_pool);
+
             if (rt->nprocesses <= 2) {
                 nxt_runtime_quit(task, 0);
             }
@@ -1030,15 +1037,11 @@ nxt_main_cleanup_worker_process(nxt_task_t *task, nxt_pid_t pid)
                                   -1, init->stream, 0, buf);
         } nxt_runtime_process_loop;
 
-        if (init->restart != NULL) {
-            if (init->type == NXT_PROCESS_ROUTER) {
-                nxt_main_stop_worker_processes(task, rt);
-            }
-
-            init->restart(task, rt, init);
+        if (restart != NULL) {
+            restart(task, rt, init);
 
         } else {
-            nxt_mp_free(rt->mem_pool, init);
+            nxt_mp_destroy(init->mem_pool);
         }
     }
 }
@@ -1588,3 +1591,121 @@ nxt_init_set_ns(nxt_task_t *task, nxt_process_init_t *init,
 
     return NXT_OK;
 }
+
+
+static nxt_process_init_t *
+nxt_process_init_create(nxt_task_t *task, nxt_process_type_t type,
+    const nxt_str_t *name)
+{
+    nxt_mp_t            *mp;
+    nxt_int_t           ret;
+    nxt_runtime_t       *rt;
+    nxt_process_init_t  *init;
+
+    mp = nxt_mp_create(1024, 128, 256, 32);
+    if (nxt_slow_path(mp == NULL)) {
+        return NULL;
+    }
+
+    init = nxt_mp_zalloc(mp, sizeof(nxt_process_init_t));
+    if (nxt_slow_path(init == NULL)) {
+        goto fail;
+    }
+
+    init->mem_pool = mp;
+
+    ret = nxt_process_init_name_set(init, type, name);
+    if (nxt_slow_path(ret != NXT_OK)) {
+        goto fail;
+    }
+
+    rt = task->thread->runtime;
+
+    init->type = type;
+    init->start = nxt_process_starts[type];
+    init->port_handlers = nxt_process_port_handlers[type];
+    init->signals = nxt_worker_process_signals;
+    init->user_cred = &rt->user_cred;
+    init->data = &rt;
+
+    return init;
+
+fail:
+
+    nxt_mp_destroy(mp);
+
+    return NULL;
+}
+
+
+static nxt_int_t
+nxt_process_init_name_set(nxt_process_init_t *init, nxt_process_type_t type,
+    const nxt_str_t *name)
+{
+    u_char      *str, *end;
+    size_t      size;
+    const char  *fmt;
+
+    size = name->length + 1;
+
+    if (type == NXT_PROCESS_WORKER) {
+        size += nxt_length("\"\" application");
+        fmt = "\"%V\" application%Z";
+
+    } else {
+        fmt = "%V%Z";
+    }
+
+    str = nxt_mp_alloc(init->mem_pool, size);
+    if (nxt_slow_path(str == NULL)) {
+        return NXT_ERROR;
+    }
+
+    end = str + size;
+
+    nxt_sprintf(str, end, fmt, name);
+
+    init->name = (char *) str;
+
+    return NXT_OK;
+}
+
+
+static nxt_int_t
+nxt_process_init_creds_set(nxt_task_t *task, nxt_process_init_t *init,
+    nxt_str_t *user, nxt_str_t *group)
+{
+    char  *str;
+
+    init->user_cred = nxt_mp_zalloc(init->mem_pool,
+                                    sizeof(nxt_user_cred_t));
+
+    if (nxt_slow_path(init->user_cred == NULL)) {
+        return NXT_ERROR;
+    }
+
+    str = nxt_mp_zalloc(init->mem_pool, user->length + 1);
+    if (nxt_slow_path(str == NULL)) {
+        return NXT_ERROR;
+    }
+
+    nxt_memcpy(str, user->start, user->length);
+    str[user->length] = '\0';
+
+    init->user_cred->user = str;
+
+    if (group->start != NULL) {
+        str = nxt_mp_zalloc(init->mem_pool, group->length + 1);
+        if (nxt_slow_path(str == NULL)) {
+            return NXT_ERROR;
+        }
+
+        nxt_memcpy(str, group->start, group->length);
+        str[group->length] = '\0';
+
+    } else {
+        str = NULL;
+    }
+
+    return nxt_user_cred_get(task, init->mem_pool, init->user_cred, str);
+}
diff --git a/src/nxt_main_process.h b/src/nxt_main_process.h
index d932e11f..b0570a84 100644
--- a/src/nxt_main_process.h
+++ b/src/nxt_main_process.h
@@ -36,10 +36,7 @@ nxt_int_t nxt_router_start(nxt_task_t *task, void *data);
 nxt_int_t nxt_discovery_start(nxt_task_t *task, void *data);
 nxt_int_t nxt_app_start(nxt_task_t *task, void *data);
 
-extern nxt_port_handlers_t  nxt_controller_process_port_handlers;
-extern nxt_port_handlers_t  nxt_discovery_process_port_handlers;
-extern nxt_port_handlers_t  nxt_app_process_port_handlers;
-extern nxt_port_handlers_t  nxt_router_process_port_handlers;
+
 extern const nxt_sig_event_t  nxt_main_process_signals[];
 extern const nxt_sig_event_t  nxt_worker_process_signals[];
 
diff --git a/src/nxt_port.c b/src/nxt_port.c
index 8d14a5e7..70cf33e6 100644
--- a/src/nxt_port.c
+++ b/src/nxt_port.c
@@ -140,7 +140,7 @@ nxt_port_reset_next_id()
 
 void
 nxt_port_enable(nxt_task_t *task, nxt_port_t *port,
-    nxt_port_handlers_t *handlers)
+    const nxt_port_handlers_t *handlers)
 {
     port->pid = nxt_pid;
     port->handler = nxt_port_handler;
diff --git a/src/nxt_port.h b/src/nxt_port.h
index eeb6caa5..3f9302e8 100644
--- a/src/nxt_port.h
+++ b/src/nxt_port.h
@@ -269,7 +269,7 @@ nxt_port_socket_write(nxt_task_t *task, nxt_port_t *port,
 }
 
 void nxt_port_enable(nxt_task_t *task, nxt_port_t *port,
-    nxt_port_handlers_t *handlers);
+    const nxt_port_handlers_t *handlers);
 nxt_int_t nxt_port_send_port(nxt_task_t *task, nxt_port_t *port,
     nxt_port_t *new_port, uint32_t stream);
 void nxt_port_change_log_file(nxt_task_t *task, nxt_runtime_t *rt,
diff --git a/src/nxt_process.c b/src/nxt_process.c
index 64356d64..0cb0fbdd 100644
--- a/src/nxt_process.c
+++ b/src/nxt_process.c
@@ -14,7 +14,8 @@
 #include <signal.h>
 
 static void nxt_process_start(nxt_task_t *task, nxt_process_t *process);
-static nxt_int_t nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc);
+static nxt_int_t nxt_user_groups_get(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_user_cred_t *uc);
 static nxt_int_t nxt_process_worker_setup(nxt_task_t *task,
     nxt_process_t *process, int parentfd);
 
@@ -526,7 +527,8 @@ nxt_nanosleep(nxt_nsec_t ns)
 
 
 nxt_int_t
-nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc, const char *group)
+nxt_user_cred_get(nxt_task_t *task, nxt_mp_t *mp, nxt_user_cred_t *uc,
+    const char *group)
 {
     struct group   *grp;
     struct passwd  *pwd;
@@ -574,7 +576,7 @@ nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc, const char *group)
     nxt_debug(task, "about to get \"%s\" groups (uid:%d, base gid:%d)",
               uc->user, uc->uid, uc->base_gid);
 
-    if (nxt_user_groups_get(task, uc) != NXT_OK) {
+    if (nxt_user_groups_get(task, mp, uc) != NXT_OK) {
         return NXT_ERROR;
     }
 
@@ -606,7 +608,7 @@ nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc, const char *group)
 
 
 static nxt_int_t
-nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
+nxt_user_groups_get(nxt_task_t *task, nxt_mp_t *mp, nxt_user_cred_t *uc)
 {
     int    ngroups;
     gid_t  groups[NXT_NGROUPS];
@@ -629,7 +631,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
 
         uc->ngroups = ngroups;
 
-        uc->gids = nxt_malloc(ngroups * sizeof(gid_t));
+        uc->gids = nxt_mp_alloc(mp, ngroups * sizeof(gid_t));
         if (nxt_slow_path(uc->gids == NULL)) {
             return NXT_ERROR;
         }
@@ -640,8 +642,6 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
             nxt_alert(task, "getgrouplist(\"%s\", %d) failed %E", uc->user,
                       uc->base_gid, nxt_errno);
 
-            nxt_free(uc->gids);
-
             return NXT_ERROR;
         }
 
@@ -650,7 +650,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
 
     uc->ngroups = ngroups;
 
-    uc->gids = nxt_malloc(ngroups * sizeof(gid_t));
+    uc->gids = nxt_mp_alloc(mp, ngroups * sizeof(gid_t));
     if (nxt_slow_path(uc->gids == NULL)) {
         return NXT_ERROR;
     }
@@ -692,7 +692,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
  */
 
 static nxt_int_t
-nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
+nxt_user_groups_get(nxt_task_t *task, nxt_mp_t *mp, nxt_user_cred_t *uc)
 {
     int        nsaved, ngroups;
     nxt_int_t  ret;
@@ -716,7 +716,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
         return NXT_OK;
     }
 
-    saved = nxt_malloc(nsaved * sizeof(nxt_gid_t));
+    saved = nxt_mp_alloc(mp, nsaved * sizeof(nxt_gid_t));
 
     if (nxt_slow_path(saved == NULL)) {
         return NXT_ERROR;
@@ -759,7 +759,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
 
     nxt_debug(task, "getgroups(0, NULL): %d", ngroups);
 
-    uc->gids = nxt_malloc(ngroups * sizeof(nxt_gid_t));
+    uc->gids = nxt_mp_alloc(mp, ngroups * sizeof(nxt_gid_t));
 
     if (nxt_slow_path(uc->gids == NULL)) {
         goto restore;
@@ -785,7 +785,7 @@ restore:
 
 free:
 
-    nxt_free(saved);
+    nxt_mp_free(mp, saved);
 
     return ret;
 }
diff --git a/src/nxt_process.h b/src/nxt_process.h
index d67573f1..3f247ae1 100644
--- a/src/nxt_process.h
+++ b/src/nxt_process.h
@@ -35,22 +35,21 @@ typedef nxt_int_t (*nxt_process_restart_t)(nxt_task_t *task, nxt_runtime_t *rt,
     nxt_process_init_t *init);
 
 struct nxt_process_init_s {
-    nxt_process_start_t      start;
-    const char               *name;
-    nxt_user_cred_t          *user_cred;
+    nxt_mp_t                   *mem_pool;
+    nxt_process_start_t        start;
+    const char                 *name;
+    nxt_user_cred_t            *user_cred;
 
-    nxt_port_handlers_t      *port_handlers;
-    const nxt_sig_event_t    *signals;
+    const nxt_port_handlers_t  *port_handlers;
+    const nxt_sig_event_t      *signals;
 
-    nxt_process_type_t       type;
+    nxt_process_type_t         type;
 
-    void                     *data;
-    uint32_t                 stream;
-
-    nxt_process_restart_t    restart;
+    void                       *data;
+    uint32_t                   stream;
 
     union {
-        nxt_process_clone_t  clone;
+        nxt_process_clone_t    clone;
     } isolation;
 };
 
@@ -126,7 +125,6 @@ void nxt_process_connected_port_remove(nxt_process_t *process,
 nxt_port_t *nxt_process_connected_port_find(nxt_process_t *process,
     nxt_pid_t pid, nxt_port_id_t port_id);
 
-
 void nxt_worker_process_quit_handler(nxt_task_t *task,
     nxt_port_recv_msg_t *msg);
 
@@ -155,8 +153,8 @@ NXT_EXPORT void nxt_process_title(nxt_task_t *task, const char *fmt, ...);
 #define nxt_abort()                                                           \
     (void) raise(SIGABRT)
 
-NXT_EXPORT nxt_int_t nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc,
-    const char *group);
+NXT_EXPORT nxt_int_t nxt_user_cred_get(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_user_cred_t *uc, const char *group);
 NXT_EXPORT nxt_int_t nxt_user_cred_set(nxt_task_t *task, nxt_user_cred_t *uc);
 
 NXT_EXPORT extern nxt_pid_t  nxt_pid;
diff --git a/src/nxt_runtime.c b/src/nxt_runtime.c
index 096aabc4..afd2cb66 100644
--- a/src/nxt_runtime.c
+++ b/src/nxt_runtime.c
@@ -705,7 +705,10 @@ nxt_runtime_conf_init(nxt_task_t *task, nxt_runtime_t *rt)
     }
 
     if (rt->capabilities.setid) {
-        if (nxt_user_cred_get(task, &rt->user_cred, rt->group) != NXT_OK) {
+        ret = nxt_user_cred_get(task, rt->mem_pool, &rt->user_cred,
+                                rt->group);
+
+        if (nxt_slow_path(ret != NXT_OK)) {
             return NXT_ERROR;
         }
 
@@ -1323,7 +1326,7 @@ nxt_runtime_process_release(nxt_runtime_t *rt, nxt_process_t *process)
     nxt_thread_mutex_destroy(&process->cp_mutex);
 
     if (process->init != NULL) {
-        nxt_mp_free(rt->mem_pool, process->init);
+        nxt_mp_destroy(process->init->mem_pool);
     }
 
     nxt_mp_free(rt->mem_pool, process);
diff --git a/src/nxt_worker_process.c b/src/nxt_worker_process.c
index c068cca4..754e2ea8 100644
--- a/src/nxt_worker_process.c
+++ b/src/nxt_worker_process.c
@@ -19,25 +19,6 @@ static void nxt_worker_process_sigterm_handler(nxt_task_t *task, void *obj,
 static void nxt_worker_process_sigquit_handler(nxt_task_t *task, void *obj,
     void *data);
 
-nxt_port_handlers_t  nxt_app_process_port_handlers = {
-    .new_port     = nxt_port_new_port_handler,
-    .change_file  = nxt_port_change_log_file_handler,
-    .mmap         = nxt_port_mmap_handler,
-    .remove_pid   = nxt_port_remove_pid_handler,
-};
-
-
-nxt_port_handlers_t  nxt_discovery_process_port_handlers = {
-    .quit         = nxt_worker_process_quit_handler,
-    .new_port     = nxt_port_new_port_handler,
-    .change_file  = nxt_port_change_log_file_handler,
-    .mmap         = nxt_port_mmap_handler,
-    .data         = nxt_port_data_handler,
-    .remove_pid   = nxt_port_remove_pid_handler,
-    .rpc_ready    = nxt_port_rpc_handler,
-    .rpc_error    = nxt_port_rpc_handler,
-};
-
 
 const nxt_sig_event_t  nxt_worker_process_signals[] = {
     nxt_event_signal(SIGHUP,  nxt_worker_process_signal_handler),