technocloud-public/nginx-unit
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Refactor of process init.

Browse Source 
Introduces the functions nxt_process_init_create() and
nxt_process_init_creds_set().
This commit is contained in:
Tiago Natel
2019-11-26 16:26:24 +00:00
parent a3e5d09501
commit 417cc7be7c
8 changed files with 249 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
src/nxt_main_process.c
View File

@@ -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);
}

5
src/nxt_main_process.h
View File

@@ -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[];

2
src/nxt_port.c
View File

@@ -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;

2
src/nxt_port.h
View File

@@ -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,

24
src/nxt_process.c
View File

@@ -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;
}

26
src/nxt_process.h
View File

@@ -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;

7
src/nxt_runtime.c
View File

@@ -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);

19
src/nxt_worker_process.c
View File

@@ -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),