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

Introducing tasks.

Browse Source
This commit is contained in:
Igor Sysoev
2017-01-23 19:56:03 +03:00
parent 16cbf3c076
commit de532922d9
71 changed files with 1694 additions and 1499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
auto/sources
View File

@@ -126,9 +126,16 @@ NXT_LIB_SRCS=" \
src/nxt_event_conn_proxy.c \
src/nxt_job.c \
src/nxt_job_file.c \
src/nxt_sockaddr.c \
src/nxt_job_resolve.c \
src/nxt_sockaddr.c \
src/nxt_listen_socket.c \
src/nxt_stream_source.c \
src/nxt_upstream_source.c \
src/nxt_http_source.c \
src/nxt_http_parse.c \
src/nxt_http_chunk_parse.c \
src/nxt_fastcgi_source.c \
src/nxt_fastcgi_record_parse.c \
"
NXT_LIB_THREAD_DEPS=" \

119
src/nxt_application.c
View File

@@ -19,17 +19,17 @@ static nxt_app_request_t *nxt_app_request_create(nxt_socket_t s,
static void nxt_app_conn_update(nxt_thread_t *thr, nxt_event_conn_t *c,
nxt_log_t *log);
static nxt_int_t nxt_app_write_finish(nxt_app_request_t *r);
static void nxt_app_buf_complettion(nxt_thread_t *thr, void *obj, void *data);
static void nxt_app_delivery_handler(nxt_thread_t *thr, void *obj, void *data);
static void nxt_app_delivery_ready(nxt_thread_t *thr, void *obj, void *data);
static void nxt_app_delivery_complettion(nxt_thread_t *thr, void *obj,
static void nxt_app_buf_completion(nxt_task_t *task, void *obj, void *data);
static void nxt_app_delivery_handler(nxt_task_t *task, void *obj, void *data);
static void nxt_app_delivery_ready(nxt_task_t *task, void *obj, void *data);
static void nxt_app_delivery_completion(nxt_task_t *task, void *obj,
void *data);
static void nxt_app_delivery_error(nxt_thread_t *thr, void *obj, void *data);
static void nxt_app_delivery_timeout(nxt_thread_t *thr, void *obj, void *data);
static void nxt_app_delivery_error(nxt_task_t *task, void *obj, void *data);
static void nxt_app_delivery_timeout(nxt_task_t *task, void *obj, void *data);
static nxt_msec_t nxt_app_delivery_timer_value(nxt_event_conn_t *c,
uintptr_t data);
static void nxt_app_delivery_done(nxt_thread_t *thr, nxt_event_conn_t *c);
static void nxt_app_close_request(nxt_thread_t *thr, nxt_app_request_t *r);
static void nxt_app_delivery_done(nxt_task_t *task, nxt_event_conn_t *c);
static void nxt_app_close_request(nxt_task_t *task, nxt_app_request_t *r);
typedef struct nxt_app_http_parse_state_s nxt_app_http_parse_state_t;
@@ -229,6 +229,13 @@ nxt_app_request_create(nxt_socket_t s, nxt_log_t *log)
c->socket.fd = s;
c->socket.data = r;
c->task.thread = nxt_thread();
c->task.log = log;
c->task.ident = log->ident;
c->socket.task = &c->task;
c->read_timer.task = &c->task;
c->write_timer.task = &c->task;
r->mem_pool = mp;
r->event_conn = c;
r->log = log;
@@ -480,8 +487,6 @@ nxt_app_http_process_headers(nxt_app_request_t *r)
static void
nxt_app_conn_update(nxt_thread_t *thr, nxt_event_conn_t *c, nxt_log_t *log)
{
static nxt_atomic_t ident = 1;
c->socket.write_ready = 1;
c->socket.log = &c->log;
@@ -490,11 +495,15 @@ nxt_app_conn_update(nxt_thread_t *thr, nxt_event_conn_t *c, nxt_log_t *log)
/* The while loop skips possible uint32_t overflow. */
while (c->log.ident == 0) {
c->log.ident = (uint32_t) nxt_atomic_fetch_add(&ident, 1);
c->log.ident = nxt_task_next_ident();
}
thr->engine->connections++;
c->task.thread = thr;
c->task.log = &c->log;
c->task.ident = c->log.ident;
c->io = thr->engine->event->io;
c->max_chunk = NXT_INT32_T_MAX;
c->sendfile = NXT_CONN_SENDFILE_UNSET;
@@ -568,10 +577,11 @@ nxt_app_http_read_body(nxt_app_request_t *r, u_char *data, size_t len)
nxt_int_t
nxt_app_write(nxt_app_request_t *r, const u_char *data, size_t len)
{
size_t free;
nxt_err_t err;
nxt_buf_t *b, *out, **next;
nxt_uint_t bufs;
size_t free;
nxt_err_t err;
nxt_buf_t *b, *out, **next;
nxt_uint_t bufs;
nxt_event_conn_t *c;
out = NULL;
next = &out;
@@ -609,9 +619,10 @@ nxt_app_write(nxt_app_request_t *r, const u_char *data, size_t len)
if (bufs == nxt_app_buf_max_number) {
bufs = 0;
*next = NULL;
c = r->event_conn;
nxt_event_engine_post(nxt_app_engine, nxt_app_delivery_handler,
r->event_conn, out, &nxt_main_log);
&c->task, c, out, &nxt_main_log);
out = NULL;
next = &out;
@@ -652,7 +663,7 @@ nxt_app_write(nxt_app_request_t *r, const u_char *data, size_t len)
return NXT_ERROR;
}
b->completion_handler = nxt_app_buf_complettion;
b->completion_handler = nxt_app_buf_completion;
nxt_app_buf_current_number++;
}
@@ -664,9 +675,10 @@ nxt_app_write(nxt_app_request_t *r, const u_char *data, size_t len)
if (out != NULL) {
*next = NULL;
c = r->event_conn;
nxt_event_engine_post(nxt_app_engine, nxt_app_delivery_handler,
r->event_conn, out, &nxt_main_log);
&c->task, c, out, &nxt_main_log);
}
return NXT_OK;
@@ -676,14 +688,15 @@ nxt_app_write(nxt_app_request_t *r, const u_char *data, size_t len)
static nxt_int_t
nxt_app_write_finish(nxt_app_request_t *r)
{
nxt_buf_t *b, *out;
nxt_buf_t *b, *out;
nxt_event_conn_t *c;
b = nxt_buf_sync_alloc(r->mem_pool, NXT_BUF_SYNC_LAST);
if (nxt_slow_path(b == NULL)) {
return NXT_ERROR;
}
b->completion_handler = nxt_app_buf_complettion;
b->completion_handler = nxt_app_buf_completion;
b->parent = (nxt_buf_t *) r;
out = r->output_buf;
@@ -696,21 +709,23 @@ nxt_app_write_finish(nxt_app_request_t *r)
out = b;
}
c = r->event_conn;
nxt_event_engine_post(nxt_app_engine, nxt_app_delivery_handler,
r->event_conn, out, &nxt_main_log);
&c->task, c, out, &nxt_main_log);
return NXT_OK;
}
static void
nxt_app_buf_complettion(nxt_thread_t *thr, void *obj, void *data)
nxt_app_buf_completion(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
b = obj;
nxt_log_debug(thr->log, "app buf completion");
nxt_debug(task, "app buf completion");
b->next = nxt_app_buf_done;
nxt_app_buf_done = b;
@@ -718,7 +733,7 @@ nxt_app_buf_complettion(nxt_thread_t *thr, void *obj, void *data)
static void
nxt_app_delivery_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_app_delivery_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_mem_pool_t *mp;
@@ -727,7 +742,7 @@ nxt_app_delivery_handler(nxt_thread_t *thr, void *obj, void *data)
c = obj;
b = data;
nxt_log_debug(thr->log, "app delivery handler");
nxt_debug(task, "app delivery handler");
if (c->write != NULL) {
nxt_buf_chain_add(&c->write, b);
@@ -742,21 +757,20 @@ nxt_app_delivery_handler(nxt_thread_t *thr, void *obj, void *data)
}
c->mem_pool = mp;
nxt_app_conn_update(thr, c, &nxt_main_log);
nxt_app_conn_update(task->thread, c, &nxt_main_log);
}
if (c->socket.timedout || c->socket.error != 0) {
nxt_buf_chain_add(&nxt_app_buf_done, b);
nxt_thread_work_queue_add(thr, c->write_work_queue,
nxt_app_delivery_complettion, c, NULL,
thr->log);
nxt_thread_work_queue_add(task->thread, c->write_work_queue,
nxt_app_delivery_completion, task, c, NULL);
return;
}
c->write = b;
c->write_state = &nxt_app_delivery_write_state;
nxt_event_conn_write(thr, c);
nxt_event_conn_write(task, c);
}
@@ -777,24 +791,29 @@ static const nxt_event_conn_state_t nxt_app_delivery_write_state
static void
nxt_app_delivery_ready(nxt_thread_t *thr, void *obj, void *data)
nxt_app_delivery_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_thread_work_queue_add(thr, c->write_work_queue,
nxt_app_delivery_complettion, c, NULL, thr->log);
nxt_debug(task, "app delivery ready");
nxt_thread_work_queue_add(task->thread, c->write_work_queue,
nxt_app_delivery_completion, task, c, NULL);
}
static void
nxt_app_delivery_complettion(nxt_thread_t *thr, void *obj, void *data)
nxt_app_delivery_completion(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b, *bn, *free;
nxt_thread_t *thread;
nxt_app_request_t *r;
nxt_log_debug(thr->log, "app delivery complettion");
thread = task->thread;
nxt_debug(task, "app delivery completion");
free = NULL;
@@ -813,7 +832,7 @@ nxt_app_delivery_complettion(nxt_thread_t *thr, void *obj, void *data)
if (nxt_buf_is_last(b)) {
r = (nxt_app_request_t *) b->parent;
nxt_app_close_request(thr, r);
nxt_app_close_request(task, r);
}
}
@@ -831,35 +850,35 @@ nxt_app_delivery_complettion(nxt_thread_t *thr, void *obj, void *data)
(void) nxt_thread_mutex_unlock(&nxt_app_mutex);
nxt_thread_time_update(thr);
nxt_thread_time_update(thread);
(void) nxt_thread_cond_signal(&nxt_app_cond);
}
static void
nxt_app_delivery_error(nxt_thread_t *thr, void *obj, void *data)
nxt_app_delivery_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_log_debug(thr->log, "app delivery error");
nxt_debug(task, "app delivery error");
nxt_app_delivery_done(thr, c);
nxt_app_delivery_done(task, c);
}
static void
nxt_app_delivery_timeout(nxt_thread_t *thr, void *obj, void *data)
nxt_app_delivery_timeout(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_log_debug(thr->log, "app delivery timeout");
nxt_debug(task, "app delivery timeout");
nxt_app_delivery_done(thr, c);
nxt_app_delivery_done(task, c);
}
@@ -872,31 +891,33 @@ nxt_app_delivery_timer_value(nxt_event_conn_t *c, uintptr_t data)
static void
nxt_app_delivery_done(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_app_delivery_done(nxt_task_t *task, nxt_event_conn_t *c)
{
if (c->write == NULL) {
return;
}
nxt_debug(task, "app delivery done");
nxt_buf_chain_add(&nxt_app_buf_done, c->write);
c->write = NULL;
nxt_thread_work_queue_add(thr, c->write_work_queue,
nxt_app_delivery_complettion, c, NULL, thr->log);
nxt_thread_work_queue_add(task->thread, c->write_work_queue,
nxt_app_delivery_completion, task, c, NULL);
}
static void
nxt_app_close_request(nxt_thread_t *thr, nxt_app_request_t *r)
nxt_app_close_request(nxt_task_t *task, nxt_app_request_t *r)
{
nxt_event_conn_t *c;
nxt_log_debug(thr->log, "app close connection");
nxt_debug(task, "app close connection");
c = r->event_conn;
nxt_event_conn_close(thr, c);
nxt_event_conn_close(task, c);
nxt_mem_pool_destroy(c->mem_pool);
nxt_mem_pool_destroy(r->mem_pool);

10
src/nxt_buf.c
View File

@@ -7,7 +7,7 @@
#include <nxt_main.h>
static void nxt_buf_completion(nxt_thread_t *thr, void *obj, void *data);
static void nxt_buf_completion(nxt_task_t *task, void *obj, void *data);
nxt_buf_t *
@@ -144,7 +144,7 @@ nxt_buf_chain_length(nxt_buf_t *b)
static void
nxt_buf_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_completion(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b, *parent;
nxt_mem_pool_t *mp;
@@ -152,20 +152,20 @@ nxt_buf_completion(nxt_thread_t *thr, void *obj, void *data)
b = obj;
parent = data;
nxt_log_debug(thr->log, "buf completion: %p %p", b, b->mem.start);
nxt_debug(task, "buf completion: %p %p", b, b->mem.start);
mp = b->data;
nxt_buf_free(mp, b);
if (parent != NULL) {
nxt_log_debug(thr->log, "parent retain:%uD", parent->retain);
nxt_debug(task, "parent retain:%uD", parent->retain);
parent->retain--;
if (parent->retain == 0) {
parent->mem.pos = parent->mem.free;
parent->completion_handler(thr, parent, parent->parent);
parent->completion_handler(task, parent, parent->parent);
}
}
}

95
src/nxt_buf_filter.c
View File

@@ -9,28 +9,28 @@
static nxt_int_t nxt_buf_filter_nobuf(nxt_buf_filter_t *f);
nxt_inline void nxt_buf_filter_next(nxt_buf_filter_t *f);
static void nxt_buf_filter_file_read_start(nxt_thread_t *thr,
static void nxt_buf_filter_file_read_start(nxt_task_t *task,
nxt_buf_filter_t *f);
static void nxt_buf_filter_file_read(nxt_thread_t *thr, nxt_buf_filter_t *f);
static void nxt_buf_filter_file_job_completion(nxt_thread_t *thr,
void *obj, void *data);
static void nxt_buf_filter_buf_completion(nxt_thread_t *thr, void *obj,
static void nxt_buf_filter_file_read(nxt_task_t *task, nxt_buf_filter_t *f);
static void nxt_buf_filter_file_job_completion(nxt_task_t *task, void *obj,
void *data);
static void nxt_buf_filter_file_read_error(nxt_thread_t *thr, void *obj,
static void nxt_buf_filter_buf_completion(nxt_task_t *task, void *obj,
void *data);
static void nxt_buf_filter_file_read_error(nxt_task_t *task, void *obj,
void *data);
void
nxt_buf_filter_add(nxt_thread_t *thr, nxt_buf_filter_t *f, nxt_buf_t *b)
nxt_buf_filter_add(nxt_task_t *task, nxt_buf_filter_t *f, nxt_buf_t *b)
{
nxt_buf_chain_add(&f->input, b);
nxt_buf_filter(thr, f, NULL);
nxt_buf_filter(task, f, NULL);
}
void
nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_int_t ret;
nxt_buf_t *b;
@@ -38,7 +38,7 @@ nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data)
f = obj;
nxt_log_debug(thr->log, "buf filter");
nxt_debug(task, "buf filter");
if (f->done) {
return;
@@ -59,7 +59,7 @@ nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data)
b = f->current;
nxt_log_debug(thr->log, "buf filter current: %p", b);
nxt_debug(task, "buf filter current: %p", b);
if (b == NULL) {
@@ -69,7 +69,7 @@ nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data)
b = f->input;
nxt_log_debug(thr->log, "buf filter input: %p", b);
nxt_debug(task, "buf filter input: %p", b);
if (b == NULL) {
/*
@@ -93,7 +93,7 @@ nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_filter_next(f);
}
nxt_buf_filter_file_read_start(thr, f);
nxt_buf_filter_file_read_start(task, f);
return;
}
}
@@ -139,9 +139,9 @@ nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data)
*/
if (b != NULL && b->mem.pos == b->mem.free) {
f->current = b->next;
nxt_thread_work_queue_add(thr, f->work_queue,
nxt_thread_work_queue_add(task->thread, f->work_queue,
b->completion_handler,
b, b->parent, thr->log);
task, b, b->parent);
}
continue;
@@ -165,8 +165,8 @@ nobuf:
fail:
nxt_thread_work_queue_add(thr, f->work_queue, f->run->filter_error,
f, f->data, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue, f->run->filter_error,
task, f, f->data);
}
@@ -208,20 +208,20 @@ nxt_buf_filter_next(nxt_buf_filter_t *f)
void
nxt_buf_filter_enqueue(nxt_thread_t *thr, nxt_buf_filter_t *f)
nxt_buf_filter_enqueue(nxt_task_t *task, nxt_buf_filter_t *f)
{
nxt_log_debug(thr->log, "buf filter enqueue: %d", f->queued);
nxt_debug(task, "buf filter enqueue: %d", f->queued);
if (!f->queued && !f->done) {
f->queued = 1;
nxt_thread_work_queue_add(thr, f->work_queue, nxt_buf_filter,
f, NULL, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue, nxt_buf_filter,
task, f, NULL);
}
}
static void
nxt_buf_filter_file_read_start(nxt_thread_t *thr, nxt_buf_filter_t *f)
nxt_buf_filter_file_read_start(nxt_task_t *task, nxt_buf_filter_t *f)
{
nxt_job_file_t *jbf;
nxt_buf_filter_file_t *ff;
@@ -229,8 +229,9 @@ nxt_buf_filter_file_read_start(nxt_thread_t *thr, nxt_buf_filter_t *f)
ff = f->run->job_file_create(f);
if (nxt_slow_path(ff == NULL)) {
nxt_thread_work_queue_add(thr, f->work_queue, f->run->filter_error,
f, f->data, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue,
f->run->filter_error,
task, f, f->data);
return;
}
@@ -246,12 +247,12 @@ nxt_buf_filter_file_read_start(nxt_thread_t *thr, nxt_buf_filter_t *f)
f->reading = 1;
nxt_buf_filter_file_read(thr, f);
nxt_buf_filter_file_read(task, f);
}
static void
nxt_buf_filter_file_read(nxt_thread_t *thr, nxt_buf_filter_t *f)
nxt_buf_filter_file_read(nxt_task_t *task, nxt_buf_filter_t *f)
{
nxt_int_t ret;
nxt_off_t size;
@@ -296,7 +297,7 @@ nxt_buf_filter_file_read(nxt_thread_t *thr, nxt_buf_filter_t *f)
f->run->job_file_retain(f);
nxt_job_file_read(thr, &ff->job_file.job);
nxt_job_file_read(task, &ff->job_file.job);
return;
}
@@ -316,8 +317,8 @@ nxt_buf_filter_file_read(nxt_thread_t *thr, nxt_buf_filter_t *f)
}
}
nxt_thread_work_queue_add(thr, f->work_queue, f->run->filter_error,
f, f->data, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue, f->run->filter_error,
task, f, f->data);
}
@@ -328,7 +329,7 @@ typedef struct {
static void
nxt_buf_filter_file_job_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_filter_file_job_completion(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_bool_t done;
@@ -341,8 +342,8 @@ nxt_buf_filter_file_job_completion(nxt_thread_t *thr, void *obj, void *data)
b = jbf->buffer;
jbf->buffer = NULL;
nxt_log_debug(thr->log, "buf filter file completion: \"%FN\" %O-%O",
jbf->file.name, b->file_pos, b->file_end);
nxt_debug(task, "buf filter file completion: \"%FN\" %O-%O",
jbf->file.name, b->file_pos, b->file_end);
f->run->job_file_release(f);
@@ -370,7 +371,7 @@ nxt_buf_filter_file_job_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_chain_add(&f->current, b);
nxt_buf_filter(thr, f, NULL);
nxt_buf_filter(task, f, NULL);
if (b->mem.pos == b->mem.free) {
/*
@@ -383,20 +384,20 @@ nxt_buf_filter_file_job_completion(nxt_thread_t *thr, void *obj, void *data)
if (!done) {
/* Try to allocate another buffer and read the next file part. */
nxt_buf_filter_file_read(thr, f);
nxt_buf_filter_file_read(task, f);
}
return;
fail:
nxt_thread_work_queue_add(thr, f->work_queue, f->run->filter_error,
f, f->data, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue, f->run->filter_error,
task, f, f->data);
}
static void
nxt_buf_filter_buf_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_filter_buf_completion(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *fb, *b;
nxt_buf_filter_t *f;
@@ -406,9 +407,8 @@ nxt_buf_filter_buf_completion(nxt_thread_t *thr, void *obj, void *data)
ctx = data;
f = ctx->filter;
nxt_log_debug(thr->log, "buf filter completion: %p \"%FN\" %O-%O",
b, f->filter_file->job_file.file.name,
b->file_pos, b->file_end);
nxt_debug(task, "buf filter completion: %p \"%FN\" %O-%O",
b, f->filter_file->job_file.file.name, b->file_pos, b->file_end);
/* nxt_http_send_filter() might clear a buffer's file status. */
b->is_file = 1;
@@ -419,7 +419,7 @@ nxt_buf_filter_buf_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_pool_free(&f->filter_file->buffers, b);
if (fb->file_pos < fb->file_end) {
nxt_buf_filter_file_read(thr, f);
nxt_buf_filter_file_read(task, f);
return;
}
@@ -428,21 +428,22 @@ nxt_buf_filter_buf_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_job_destroy(&f->filter_file->job_file.job);
nxt_thread_work_queue_add(thr, f->work_queue, fb->completion_handler,
fb, fb->parent, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue,
fb->completion_handler,
task, fb, fb->parent);
}
nxt_buf_filter(thr, f, NULL);
nxt_buf_filter(task, f, NULL);
}
static void
nxt_buf_filter_file_read_error(nxt_thread_t *thr, void *obj, void *data)
nxt_buf_filter_file_read_error(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_filter_t *f;
f = data;
nxt_thread_work_queue_add(thr, f->work_queue, f->run->filter_error,
f, f->data, thr->log);
nxt_thread_work_queue_add(task->thread, f->work_queue, f->run->filter_error,
task, f, f->data);
}

9
src/nxt_buf_filter.h
View File

@@ -77,8 +77,7 @@ typedef struct {
nxt_int_t (*filter_sync_last)(nxt_buf_filter_t *f);
void (*filter_next)(nxt_buf_filter_t *f);
void (*filter_error)(nxt_thread_t *thr, void *obj,
void *data);
nxt_work_handler_t filter_error;
nxt_buf_filter_file_t *(*job_file_create)(nxt_buf_filter_t *f);
void (*job_file_retain)(nxt_buf_filter_t *f);
@@ -107,10 +106,10 @@ struct nxt_buf_filter_s {
};
NXT_EXPORT void nxt_buf_filter_add(nxt_thread_t *thr, nxt_buf_filter_t *f,
NXT_EXPORT void nxt_buf_filter_add(nxt_task_t *task, nxt_buf_filter_t *f,
nxt_buf_t *b);
NXT_EXPORT void nxt_buf_filter(nxt_thread_t *thr, void *obj, void *data);
NXT_EXPORT void nxt_buf_filter_enqueue(nxt_thread_t *thr, nxt_buf_filter_t *f);
NXT_EXPORT void nxt_buf_filter(nxt_task_t *task, void *obj, void *data);
NXT_EXPORT void nxt_buf_filter_enqueue(nxt_task_t *task, nxt_buf_filter_t *f);
#endif /* _NXT_BUF_FILTER_H_INCLUDED_ */

82
src/nxt_chan.c
View File

@@ -7,13 +7,13 @@
#include <nxt_main.h>
static void nxt_chan_write_handler(nxt_thread_t *thr, void *obj, void *data);
static void nxt_chan_read_handler(nxt_thread_t *thr, void *obj, void *data);
static void nxt_chan_read_msg_process(nxt_thread_t *thr, nxt_chan_t *chan,
static void nxt_chan_write_handler(nxt_task_t *task, void *obj, void *data);
static void nxt_chan_read_handler(nxt_task_t *task, void *obj, void *data);
static void nxt_chan_read_msg_process(nxt_task_t *task, nxt_chan_t *chan,
nxt_chan_msg_t *msg, nxt_fd_t fd, nxt_buf_t *b, size_t size);
static nxt_buf_t *nxt_chan_buf_alloc(nxt_chan_t *chan);
static void nxt_chan_buf_free(nxt_chan_t *chan, nxt_buf_t *b);
static void nxt_chan_error_handler(nxt_thread_t *thr, void *obj, void *data);
static void nxt_chan_error_handler(nxt_task_t *task, void *obj, void *data);
nxt_chan_t *
@@ -129,13 +129,19 @@ nxt_chan_destroy(nxt_chan_t *chan)
void
nxt_chan_write_enable(nxt_thread_t *thr, nxt_chan_t *chan)
nxt_chan_write_enable(nxt_task_t *task, nxt_chan_t *chan)
{
chan->socket.fd = chan->pair[1];
chan->socket.log = &nxt_main_log;
chan->socket.write_ready = 1;
chan->socket.write_work_queue = &thr->work_queue.main;
chan->task.thread = task->thread;
chan->task.log = chan->socket.log;
chan->task.ident = nxt_task_next_ident();
chan->socket.task = &chan->task;
chan->socket.write_work_queue = &task->thread->work_queue.main;
chan->socket.write_handler = nxt_chan_write_handler;
chan->socket.error_handler = nxt_chan_error_handler;
}
@@ -150,10 +156,9 @@ nxt_chan_write_close(nxt_chan_t *chan)
nxt_int_t
nxt_chan_write(nxt_chan_t *chan, nxt_uint_t type, nxt_fd_t fd, uint32_t stream,
nxt_buf_t *b)
nxt_chan_write(nxt_task_t *task, nxt_chan_t *chan, nxt_uint_t type,
nxt_fd_t fd, uint32_t stream, nxt_buf_t *b)
{
nxt_thread_t *thr;
nxt_queue_link_t *link;
nxt_chan_send_msg_t *msg;
@@ -190,8 +195,7 @@ nxt_chan_write(nxt_chan_t *chan, nxt_uint_t type, nxt_fd_t fd, uint32_t stream,
nxt_queue_insert_tail(&chan->messages, &msg->link);
if (chan->socket.write_ready) {
thr = nxt_thread();
nxt_chan_write_handler(thr, chan, NULL);
nxt_chan_write_handler(task, chan, NULL);
}
return NXT_OK;
@@ -199,7 +203,7 @@ nxt_chan_write(nxt_chan_t *chan, nxt_uint_t type, nxt_fd_t fd, uint32_t stream,
static void
nxt_chan_write_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_chan_write_handler(nxt_task_t *task, void *obj, void *data)
{
ssize_t n;
nxt_uint_t niob;
@@ -215,7 +219,7 @@ nxt_chan_write_handler(nxt_thread_t *thr, void *obj, void *data)
link = nxt_queue_first(&chan->messages);
if (link == nxt_queue_tail(&chan->messages)) {
nxt_event_fd_block_write(thr->engine, &chan->socket);
nxt_event_fd_block_write(task->thread->engine, &chan->socket);
return;
}
@@ -231,7 +235,7 @@ nxt_chan_write_handler(nxt_thread_t *thr, void *obj, void *data)
sb.size = sizeof(nxt_chan_msg_t);
sb.limit = chan->max_size;
niob = nxt_sendbuf_mem_coalesce(&sb);
niob = nxt_sendbuf_mem_coalesce(task, &sb);
msg->chan_msg.last = sb.last;
@@ -239,13 +243,13 @@ nxt_chan_write_handler(nxt_thread_t *thr, void *obj, void *data)
if (n > 0) {
if (nxt_slow_path((size_t) n != sb.size)) {
nxt_log_alert(thr->log,
"chan %d: short write: %z instead of %uz",
chan->socket.fd, n, sb.size);
nxt_log(task, NXT_LOG_CRIT,
"chan %d: short write: %z instead of %uz",
chan->socket.fd, n, sb.size);
goto fail;
}
msg->buf = nxt_sendbuf_completion(thr,
msg->buf = nxt_sendbuf_completion(task,
chan->socket.write_work_queue,
msg->buf,
n - sizeof(nxt_chan_msg_t));
@@ -279,30 +283,36 @@ nxt_chan_write_handler(nxt_thread_t *thr, void *obj, void *data)
} while (chan->socket.write_ready);
if (nxt_event_fd_is_disabled(chan->socket.write)) {
nxt_event_fd_enable_write(thr->engine, &chan->socket);
nxt_event_fd_enable_write(task->thread->engine, &chan->socket);
}
return;
fail:
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_chan_error_handler,
&chan->socket, NULL, chan->socket.log);
nxt_thread_work_queue_add(task->thread, &task->thread->work_queue.main,
nxt_chan_error_handler, task, &chan->socket,
NULL);
}
void
nxt_chan_read_enable(nxt_thread_t *thr, nxt_chan_t *chan)
nxt_chan_read_enable(nxt_task_t *task, nxt_chan_t *chan)
{
chan->socket.fd = chan->pair[0];
chan->socket.log = &nxt_main_log;
chan->socket.read_work_queue = &thr->work_queue.main;
chan->task.thread = task->thread;
chan->task.log = chan->socket.log;
chan->task.ident = nxt_task_next_ident();
chan->socket.task = &chan->task;
chan->socket.read_work_queue = &task->thread->work_queue.main;
chan->socket.read_handler = nxt_chan_read_handler;
chan->socket.error_handler = nxt_chan_error_handler;
nxt_event_fd_enable_read(thr->engine, &chan->socket);
nxt_event_fd_enable_read(task->thread->engine, &chan->socket);
}
@@ -315,7 +325,7 @@ nxt_chan_read_close(nxt_chan_t *chan)
static void
nxt_chan_read_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_chan_read_handler(nxt_task_t *task, void *obj, void *data)
{
ssize_t n;
nxt_fd_t fd;
@@ -340,7 +350,7 @@ nxt_chan_read_handler(nxt_thread_t *thr, void *obj, void *data)
n = nxt_socketpair_recv(&chan->socket, &fd, iob, 2);
if (n > 0) {
nxt_chan_read_msg_process(thr, chan, &msg, fd, b, n);
nxt_chan_read_msg_process(task, chan, &msg, fd, b, n);
if (b->mem.pos == b->mem.free) {
@@ -362,30 +372,30 @@ nxt_chan_read_handler(nxt_thread_t *thr, void *obj, void *data)
if (n == NXT_AGAIN) {
nxt_chan_buf_free(chan, b);
nxt_event_fd_enable_read(thr->engine, &chan->socket);
nxt_event_fd_enable_read(task->thread->engine, &chan->socket);
return;
}
/* n == 0 || n == NXT_ERROR */
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_chan_error_handler,
&chan->socket, NULL, chan->socket.log);
nxt_thread_work_queue_add(task->thread, &task->thread->work_queue.main,
nxt_chan_error_handler, task,
&chan->socket, NULL);
return;
}
}
static void
nxt_chan_read_msg_process(nxt_thread_t *thr, nxt_chan_t *chan,
nxt_chan_read_msg_process(nxt_task_t *task, nxt_chan_t *chan,
nxt_chan_msg_t *msg, nxt_fd_t fd, nxt_buf_t *b, size_t size)
{
nxt_buf_t *sync;
nxt_chan_recv_msg_t recv_msg;
if (nxt_slow_path(size < sizeof(nxt_chan_msg_t))) {
nxt_log_alert(chan->socket.log, "chan %d: too small message:%uz",
chan->socket.fd, size);
nxt_log(chan->socket.task, NXT_LOG_CRIT,
"chan %d: too small message:%uz", chan->socket.fd, size);
goto fail;
}
@@ -406,7 +416,7 @@ nxt_chan_read_msg_process(nxt_thread_t *thr, nxt_chan_t *chan,
b->next = sync;
}
chan->handler(thr, &recv_msg);
chan->handler(task, &recv_msg);
return;
@@ -450,7 +460,7 @@ nxt_chan_buf_free(nxt_chan_t *chan, nxt_buf_t *b)
static void
nxt_chan_error_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_chan_error_handler(nxt_task_t *task, void *obj, void *data)
{
/* TODO */
}

12
src/nxt_chan.h
View File

@@ -26,13 +26,15 @@ typedef struct {
typedef struct nxt_chan_recv_msg_s nxt_chan_recv_msg_t;
typedef void (*nxt_chan_handler_t)(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg);
typedef void (*nxt_chan_handler_t)(nxt_task_t *task, nxt_chan_recv_msg_t *msg);
typedef struct {
/* Must be the first field. */
nxt_event_fd_t socket;
nxt_task_t task;
nxt_queue_t messages; /* of nxt_chan_send_msg_t */
/* Maximum size of message part. */
@@ -62,12 +64,12 @@ struct nxt_chan_recv_msg_s {
NXT_EXPORT nxt_chan_t *nxt_chan_alloc(void);
NXT_EXPORT nxt_chan_t *nxt_chan_create(size_t bufsize);
NXT_EXPORT void nxt_chan_destroy(nxt_chan_t *chan);
NXT_EXPORT void nxt_chan_write_enable(nxt_thread_t *thr, nxt_chan_t *chan);
NXT_EXPORT void nxt_chan_write_enable(nxt_task_t *task, nxt_chan_t *chan);
NXT_EXPORT void nxt_chan_write_close(nxt_chan_t *chan);
NXT_EXPORT void nxt_chan_read_enable(nxt_thread_t *thr, nxt_chan_t *chan);
NXT_EXPORT void nxt_chan_read_enable(nxt_task_t *task, nxt_chan_t *chan);
NXT_EXPORT void nxt_chan_read_close(nxt_chan_t *chan);
NXT_EXPORT nxt_int_t nxt_chan_write(nxt_chan_t *chan, nxt_uint_t type,
nxt_fd_t fd, uint32_t stream, nxt_buf_t *b);
NXT_EXPORT nxt_int_t nxt_chan_write(nxt_task_t *task, nxt_chan_t *chan,
nxt_uint_t type, nxt_fd_t fd, uint32_t stream, nxt_buf_t *b);
#endif /* _NXT_UNIX_CHAN_H_INCLUDED_ */

141
src/nxt_cycle.c
View File

@@ -18,14 +18,14 @@ static nxt_int_t nxt_cycle_systemd_listen_sockets(nxt_thread_t *thr,
static nxt_int_t nxt_cycle_event_engines(nxt_thread_t *thr, nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_processes(nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_thread_pools(nxt_thread_t *thr, nxt_cycle_t *cycle);
static void nxt_cycle_start(nxt_thread_t *thr, void *obj, void *data);
static void nxt_cycle_initial_start(nxt_thread_t *thr, nxt_cycle_t *cycle);
static void nxt_cycle_conf_test(nxt_thread_t *thr, nxt_cycle_t *cycle);
static void nxt_single_process_start(nxt_thread_t *thr, nxt_cycle_t *cycle);
static void nxt_cycle_close_idle_connections(nxt_thread_t *thr);
static void nxt_cycle_exit(nxt_thread_t *thr, void *obj, void *data);
static nxt_int_t nxt_cycle_event_engine_change(nxt_thread_t *thr,
static void nxt_cycle_start(nxt_task_t *task, void *obj, void *data);
static void nxt_cycle_initial_start(nxt_task_t *task, nxt_cycle_t *cycle);
static void nxt_single_process_start(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle);
static void nxt_cycle_close_idle_connections(nxt_thread_t *thr, nxt_task_t *task);
static void nxt_cycle_exit(nxt_task_t *task, void *obj, void *data);
static nxt_int_t nxt_cycle_event_engine_change(nxt_thread_t *thr,
nxt_task_t *task, nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_conf_init(nxt_thread_t *thr, nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_conf_read_cmd(nxt_thread_t *thr, nxt_cycle_t *cycle);
static nxt_sockaddr_t *nxt_cycle_sockaddr_parse(nxt_str_t *addr,
@@ -36,7 +36,8 @@ static nxt_sockaddr_t *nxt_cycle_sockaddr_inet6_parse(nxt_str_t *addr,
nxt_mem_pool_t *mp, nxt_log_t *log);
static nxt_sockaddr_t *nxt_cycle_sockaddr_inet_parse(nxt_str_t *addr,
nxt_mem_pool_t *mp, nxt_log_t *log);
static nxt_int_t nxt_cycle_conf_apply(nxt_thread_t *thr, nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_conf_apply(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_listen_socket(nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_hostname(nxt_thread_t *thr, nxt_cycle_t *cycle);
static nxt_int_t nxt_cycle_log_files_init(nxt_cycle_t *cycle);
@@ -49,7 +50,7 @@ static nxt_int_t nxt_cycle_shm_zone_create(nxt_cycle_shm_zone_t *shm_zone);
#if (NXT_THREADS)
static void nxt_cycle_thread_pool_destroy(nxt_thread_t *thr,
nxt_cycle_t *cycle, nxt_cycle_cont_t cont);
nxt_task_t *task, nxt_cycle_t *cycle, nxt_cycle_cont_t cont);
#endif
@@ -57,8 +58,8 @@ nxt_thread_declare_data(nxt_cycle_t *, nxt_thread_cycle_data);
nxt_int_t
nxt_cycle_create(nxt_thread_t *thr, nxt_cycle_t *previous,
nxt_cycle_cont_t start, nxt_str_t *config_name, nxt_bool_t test_config)
nxt_cycle_create(nxt_thread_t *thr, nxt_task_t *task, nxt_cycle_t *previous,
nxt_cycle_cont_t start, nxt_str_t *config_name)
{
nxt_int_t ret;
nxt_cycle_t *cycle;
@@ -78,7 +79,6 @@ nxt_cycle_create(nxt_thread_t *thr, nxt_cycle_t *previous,
cycle->mem_pool = mp;
cycle->previous = previous;
cycle->config_name = config_name;
cycle->test_config = test_config;
if (previous == NULL) {
cycle->prefix = nxt_current_directory(mp);
@@ -148,14 +148,13 @@ nxt_cycle_create(nxt_thread_t *thr, nxt_cycle_t *previous,
nxt_thread_init_data(nxt_thread_cycle_data);
nxt_thread_cycle_set(cycle);
cycle->start = test_config ? nxt_cycle_conf_test:
nxt_cycle_initial_start;
cycle->start = nxt_cycle_initial_start;
}
nxt_log_debug(thr->log, "new cycle: %p", cycle);
nxt_thread_work_queue_add(thr, &thr->work_queue.main, nxt_cycle_start,
cycle, NULL, &nxt_main_log);
task, cycle, NULL);
return NXT_OK;
@@ -410,31 +409,31 @@ nxt_cycle_thread_pools(nxt_thread_t *thr, nxt_cycle_t *cycle)
static void
nxt_cycle_start(nxt_thread_t *thr, void *obj, void *data)
nxt_cycle_start(nxt_task_t *task, void *obj, void *data)
{
nxt_uint_t i;
nxt_cycle_t *cycle;
cycle = obj;
nxt_log_debug(thr->log, "cycle conf done");
nxt_debug(task, "cycle conf done");
nxt_mem_pool_debug_lock(cycle->mem_pool, nxt_thread_tid(thr));
nxt_mem_pool_debug_lock(cycle->mem_pool, nxt_thread_tid(task->thread));
thr->log->ctx_handler = NULL;
thr->log->ctx = NULL;
task->thread->log->ctx_handler = NULL;
task->thread->log->ctx = NULL;
if (nxt_cycle_conf_init(thr, cycle) != NXT_OK) {
if (nxt_cycle_conf_init(task->thread, cycle) != NXT_OK) {
goto fail;
}
for (i = 0; i < nxt_init_modules_n; i++) {
if (nxt_init_modules[i](thr, cycle) != NXT_OK) {
if (nxt_init_modules[i](task->thread, cycle) != NXT_OK) {
goto fail;
}
}
if (nxt_cycle_conf_apply(thr, cycle) != NXT_OK) {
if (nxt_cycle_conf_apply(task->thread, task, cycle) != NXT_OK) {
goto fail;
}
@@ -447,11 +446,11 @@ nxt_cycle_start(nxt_thread_t *thr, void *obj, void *data)
* processes, because thread pool semaphores will stick in
* locked state in new processes after fork().
*/
nxt_cycle_thread_pool_destroy(thr, cycle, cycle->start);
nxt_cycle_thread_pool_destroy(task->thread, task, cycle, cycle->start);
#else
cycle->start(thr, cycle);
cycle->start(task->thread, cycle);
#endif
@@ -459,16 +458,19 @@ nxt_cycle_start(nxt_thread_t *thr, void *obj, void *data)
fail:
nxt_cycle_quit(thr, cycle);
nxt_cycle_quit(task, cycle);
}
static void
nxt_cycle_initial_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_cycle_initial_start(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_int_t ret;
nxt_thread_t *thr;
const nxt_event_set_ops_t *event_set;
thr = task->thread;
if (cycle->inherited_sockets == NULL && cycle->daemon) {
if (nxt_process_daemon() != NXT_OK) {
@@ -486,7 +488,7 @@ nxt_cycle_initial_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
goto fail;
}
ret = nxt_event_engine_change(thr, event_set, cycle->batch);
ret = nxt_event_engine_change(thr, task, event_set, cycle->batch);
if (ret != NXT_OK) {
goto fail;
}
@@ -497,39 +499,31 @@ nxt_cycle_initial_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
goto fail;
}
if (nxt_cycle_event_engine_change(thr, cycle) != NXT_OK) {
if (nxt_cycle_event_engine_change(thr, task, cycle) != NXT_OK) {
goto fail;
}
thr->engine->max_connections = cycle->engine_connections;
if (cycle->master_process) {
if (nxt_master_process_start(thr, cycle) != NXT_ERROR) {
if (nxt_master_process_start(thr, task, cycle) != NXT_ERROR) {
return;
}
} else {
nxt_single_process_start(thr, cycle);
nxt_single_process_start(thr, task, cycle);
return;
}
fail:
nxt_cycle_quit(thr, cycle);
nxt_cycle_quit(task, cycle);
}
static void
nxt_cycle_conf_test(nxt_thread_t *thr, nxt_cycle_t *cycle)
{
(void) nxt_cycle_pid_file_create(cycle->pid_file, cycle->test_config);
nxt_cycle_quit(thr, cycle);
}
static void
nxt_single_process_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_single_process_start(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle)
{
#if (NXT_THREADS)
nxt_int_t ret;
@@ -538,7 +532,7 @@ nxt_single_process_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
60000 * 1000000LL);
if (nxt_slow_path(ret != NXT_OK)) {
nxt_cycle_quit(thr, cycle);
nxt_cycle_quit(task, cycle);
return;
}
@@ -546,18 +540,21 @@ nxt_single_process_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
cycle->type = NXT_PROCESS_SINGLE;
nxt_cycle_listen_sockets_enable(thr, cycle);
nxt_cycle_listen_sockets_enable(task, cycle);
return;
}
void
nxt_cycle_quit(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_cycle_quit(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_bool_t done;
nxt_bool_t done;
nxt_thread_t *thr;
nxt_log_debug(thr->log, "exiting");
thr = task->thread;
nxt_debug(task, "exiting");
if (cycle == NULL) {
cycle = nxt_thread_cycle();
@@ -571,29 +568,29 @@ nxt_cycle_quit(nxt_thread_t *thr, nxt_cycle_t *cycle)
#if (NXT_THREADS)
if (!nxt_array_is_empty(cycle->thread_pools)) {
nxt_cycle_thread_pool_destroy(thr, cycle, nxt_cycle_quit);
nxt_cycle_thread_pool_destroy(thr, task, cycle, nxt_cycle_quit);
done = 0;
}
#endif
if (!cycle->test_config && cycle->type == NXT_PROCESS_MASTER) {
nxt_master_stop_worker_processes(cycle);
nxt_master_stop_worker_processes(task, cycle);
done = 0;
}
}
nxt_cycle_close_idle_connections(thr);
nxt_cycle_close_idle_connections(thr, task);
if (done) {
nxt_thread_work_queue_add(thr, &thr->work_queue.main, nxt_cycle_exit,
cycle, NULL, &nxt_main_log);
task, cycle, NULL);
}
}
static void
nxt_cycle_close_idle_connections(nxt_thread_t *thr)
nxt_cycle_close_idle_connections(nxt_thread_t *thr, nxt_task_t *task)
{
nxt_queue_t *idle;
nxt_queue_link_t *link, *next;
@@ -612,14 +609,14 @@ nxt_cycle_close_idle_connections(nxt_thread_t *thr)
if (!c->socket.read_ready) {
nxt_queue_remove(link);
nxt_event_conn_close(thr, c);
nxt_event_conn_close(task, c);
}
}
}
static void
nxt_cycle_exit(nxt_thread_t *thr, void *obj, void *data)
nxt_cycle_exit(nxt_task_t *task, void *obj, void *data)
{
nxt_cycle_t *cycle;
@@ -627,7 +624,7 @@ nxt_cycle_exit(nxt_thread_t *thr, void *obj, void *data)
#if (NXT_THREADS)
nxt_log_debug(thr->log, "thread pools: %d", cycle->thread_pools->nelts);
nxt_debug(task, "thread pools: %d", cycle->thread_pools->nelts);
if (!nxt_array_is_empty(cycle->thread_pools)) {
return;
@@ -639,11 +636,11 @@ nxt_cycle_exit(nxt_thread_t *thr, void *obj, void *data)
nxt_cycle_pid_file_delete(cycle);
}
if (!thr->engine->event->signal_support) {
nxt_event_engine_signals_stop(thr->engine);
if (!task->thread->engine->event->signal_support) {
nxt_event_engine_signals_stop(task->thread->engine);
}
nxt_log_debug(thr->log, "exit");
nxt_debug(task, "exit");
exit(0);
nxt_unreachable();
@@ -651,7 +648,8 @@ nxt_cycle_exit(nxt_thread_t *thr, void *obj, void *data)
static nxt_int_t
nxt_cycle_event_engine_change(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_cycle_event_engine_change(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle)
{
const nxt_event_set_ops_t *event_set;
@@ -663,7 +661,7 @@ nxt_cycle_event_engine_change(nxt_thread_t *thr, nxt_cycle_t *cycle)
event_set = nxt_service_get(cycle->services, "engine", cycle->engine);
if (event_set != NULL) {
return nxt_event_engine_change(thr, event_set, cycle->batch);
return nxt_event_engine_change(thr, task, event_set, cycle->batch);
}
return NXT_ERROR;
@@ -686,8 +684,7 @@ nxt_cycle_event_engine_free(nxt_cycle_t *cycle)
#if (NXT_THREADS)
static void nxt_cycle_thread_pool_init(void);
static void nxt_cycle_thread_pool_exit(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_cycle_thread_pool_exit(nxt_task_t *task, void *obj, void *data);
nxt_int_t
@@ -715,8 +712,8 @@ nxt_cycle_thread_pool_create(nxt_thread_t *thr, nxt_cycle_t *cycle,
static void
nxt_cycle_thread_pool_destroy(nxt_thread_t *thr, nxt_cycle_t *cycle,
nxt_cycle_cont_t cont)
nxt_cycle_thread_pool_destroy(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle, nxt_cycle_cont_t cont)
{
nxt_uint_t n;
nxt_thread_pool_t **tp;
@@ -726,7 +723,7 @@ nxt_cycle_thread_pool_destroy(nxt_thread_t *thr, nxt_cycle_t *cycle,
n = cycle->thread_pools->nelts;
if (n == 0) {
cont(thr, cycle);
cont(task, cycle);
return;
}
@@ -751,7 +748,7 @@ nxt_cycle_thread_pool_init(void)
static void
nxt_cycle_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data)
nxt_cycle_thread_pool_exit(nxt_task_t *task, void *obj, void *data)
{
nxt_uint_t i, n;
nxt_cycle_t *cycle;
@@ -770,7 +767,7 @@ nxt_cycle_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data)
thread_pools = cycle->thread_pools->elts;
n = cycle->thread_pools->nelts;
nxt_log_debug(thr->log, "thread pools: %ui, cycle %p", n, cycle);
nxt_debug(task, "thread pools: %ui, cycle %p", n, cycle);
for (i = 0; i < n; i++) {
@@ -779,7 +776,7 @@ nxt_cycle_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data)
if (n == 1) {
/* The last thread pool. */
cycle->continuation(thr, cycle);
cycle->continuation(task, cycle);
}
return;
@@ -1239,7 +1236,7 @@ invalid_addr:
static nxt_int_t
nxt_cycle_conf_apply(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_cycle_conf_apply(nxt_thread_t *thr, nxt_task_t *task, nxt_cycle_t *cycle)
{
if (nxt_cycle_log_files_create(cycle) != NXT_OK) {
return NXT_ERROR;
@@ -1249,7 +1246,7 @@ nxt_cycle_conf_apply(nxt_thread_t *thr, nxt_cycle_t *cycle)
return NXT_ERROR;
}
if (nxt_cycle_event_engine_change(thr, cycle) != NXT_OK) {
if (nxt_cycle_event_engine_change(thr, task, cycle) != NXT_OK) {
return NXT_ERROR;
}
@@ -1571,7 +1568,7 @@ nxt_cycle_listen_sockets_close(nxt_cycle_t *cycle)
nxt_int_t
nxt_cycle_listen_sockets_enable(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_cycle_listen_sockets_enable(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_uint_t i, n;
nxt_listen_socket_t *ls;
@@ -1580,7 +1577,7 @@ nxt_cycle_listen_sockets_enable(nxt_thread_t *thr, nxt_cycle_t *cycle)
n = cycle->listen_sockets->nelts;
for (i = 0; i < n; i++) {
if (nxt_event_conn_listen(thr, &ls[i]) != NXT_OK) {
if (nxt_event_conn_listen(task, &ls[i]) != NXT_OK) {
return NXT_ERROR;
}
}

11
src/nxt_cycle.h
View File

@@ -17,7 +17,7 @@ typedef enum {
typedef struct nxt_cycle_s nxt_cycle_t;
typedef void (*nxt_cycle_cont_t)(nxt_thread_t *thr, nxt_cycle_t *cycle);
typedef void (*nxt_cycle_cont_t)(nxt_task_t *task, nxt_cycle_t *cycle);
struct nxt_cycle_s {
@@ -120,9 +120,9 @@ nxt_thread_cycle(void)
}
nxt_int_t nxt_cycle_create(nxt_thread_t *thr, nxt_cycle_t *previous,
nxt_cycle_cont_t start, nxt_str_t *config_name, nxt_bool_t test_config);
void nxt_cycle_quit(nxt_thread_t *thr, nxt_cycle_t *cycle);
nxt_int_t nxt_cycle_create(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *previous, nxt_cycle_cont_t start, nxt_str_t *config_name);
void nxt_cycle_quit(nxt_task_t *task, nxt_cycle_t *cycle);
void nxt_cycle_event_engine_free(nxt_cycle_t *cycle);
@@ -138,8 +138,7 @@ nxt_int_t nxt_cycle_pid_file_create(nxt_file_name_t *pid_file, nxt_bool_t test);
nxt_listen_socket_t *nxt_cycle_listen_socket_add(nxt_cycle_t *cycle,
nxt_sockaddr_t *sa);
nxt_int_t nxt_cycle_listen_sockets_enable(nxt_thread_t *thr,
nxt_cycle_t *cycle);
nxt_int_t nxt_cycle_listen_sockets_enable(nxt_task_t *task, nxt_cycle_t *cycle);
nxt_file_t *nxt_cycle_log_file_add(nxt_cycle_t *cycle, nxt_str_t *name);
nxt_int_t nxt_cycle_shm_zone_add(nxt_cycle_t *cycle, nxt_str_t *name,

129
src/nxt_epoll.c
View File

@@ -65,37 +65,37 @@ static void nxt_epoll_enable_accept(nxt_event_set_t *event_set,
nxt_event_fd_t *ev);
static void nxt_epoll_change(nxt_event_set_t *event_set, nxt_event_fd_t *ev,
int op, uint32_t events);
static nxt_int_t nxt_epoll_commit_changes(nxt_thread_t *thr,
static nxt_int_t nxt_epoll_commit_changes(nxt_task_t *task,
nxt_epoll_event_set_t *es);
static void nxt_epoll_error_handler(nxt_thread_t *thr, void *obj,
static void nxt_epoll_error_handler(nxt_task_t *task, void *obj,
void *data);
#if (NXT_HAVE_SIGNALFD)
static nxt_int_t nxt_epoll_add_signal(nxt_epoll_event_set_t *es,
nxt_event_signals_t *signals);
static void nxt_epoll_signalfd_handler(nxt_thread_t *thr, void *obj,
static void nxt_epoll_signalfd_handler(nxt_task_t *task, void *obj,
void *data);
#endif
#if (NXT_HAVE_EVENTFD)
static nxt_int_t nxt_epoll_enable_post(nxt_event_set_t *event_set,
nxt_work_handler_t handler);
static void nxt_epoll_eventfd_handler(nxt_thread_t *thr, void *obj,
static void nxt_epoll_eventfd_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_epoll_signal(nxt_event_set_t *event_set, nxt_uint_t signo);
#endif
static void nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
static void nxt_epoll_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout);
#if (NXT_HAVE_ACCEPT4)
static void nxt_epoll_event_conn_io_accept4(nxt_thread_t *thr, void *obj,
static void nxt_epoll_event_conn_io_accept4(nxt_task_t *task, void *obj,
void *data);
#endif
#if (NXT_HAVE_EPOLL_EDGE)
static void nxt_epoll_edge_event_conn_io_connect(nxt_thread_t *thr, void *obj,
static void nxt_epoll_edge_event_conn_io_connect(nxt_task_t *task, void *obj,
void *data);
static void nxt_epoll_edge_event_conn_connected(nxt_thread_t *thr, void *obj,
static void nxt_epoll_edge_event_conn_connected(nxt_task_t *task, void *obj,
void *data);
static ssize_t nxt_epoll_edge_event_conn_io_recvbuf(nxt_event_conn_t *c,
nxt_buf_t *b);
@@ -427,7 +427,7 @@ nxt_epoll_close(nxt_event_set_t *event_set, nxt_event_fd_t *ev)
es = &event_set->epoll;
if (es->nchanges != 0) {
(void) nxt_epoll_commit_changes(nxt_thread(), &event_set->epoll);
(void) nxt_epoll_commit_changes(ev->task, &event_set->epoll);
}
}
@@ -614,7 +614,7 @@ nxt_epoll_change(nxt_event_set_t *event_set, nxt_event_fd_t *ev, int op,
es->epoll, ev->fd, op, events);
if (es->nchanges >= es->mchanges) {
(void) nxt_epoll_commit_changes(nxt_thread(), es);
(void) nxt_epoll_commit_changes(ev->task, es);
}
ch = &es->changes[es->nchanges++];
@@ -626,13 +626,13 @@ nxt_epoll_change(nxt_event_set_t *event_set, nxt_event_fd_t *ev, int op,
static nxt_int_t
nxt_epoll_commit_changes(nxt_thread_t *thr, nxt_epoll_event_set_t *es)
nxt_epoll_commit_changes(nxt_task_t *task, nxt_epoll_event_set_t *es)
{
nxt_int_t ret;
nxt_event_fd_t *ev;
nxt_epoll_change_t *ch, *end;
nxt_log_debug(thr->log, "epoll %d changes:%ui", es->epoll, es->nchanges);
nxt_debug(task, "epoll %d changes:%ui", es->epoll, es->nchanges);
ret = NXT_OK;
ch = es->changes;
@@ -641,16 +641,17 @@ nxt_epoll_commit_changes(nxt_thread_t *thr, nxt_epoll_event_set_t *es)
do {
ev = ch->event.data.ptr;
nxt_log_debug(ev->log, "epoll_ctl(%d): fd:%d op:%d ev:%XD",
es->epoll, ch->fd, ch->op, ch->event.events);
nxt_debug(ev->task, "epoll_ctl(%d): fd:%d op:%d ev:%XD",
es->epoll, ch->fd, ch->op, ch->event.events);
if (epoll_ctl(es->epoll, ch->op, ch->fd, &ch->event) != 0) {
nxt_log_alert(ev->log, "epoll_ctl(%d, %d, %d) failed %E",
es->epoll, ch->op, ch->fd, nxt_errno);
nxt_log(ev->task, NXT_LOG_CRIT, "epoll_ctl(%d, %d, %d) failed %E",
es->epoll, ch->op, ch->fd, nxt_errno);
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_thread_work_queue_add(task->thread,
&task->thread->work_queue.main,
nxt_epoll_error_handler,
ev, ev->data, ev->log);
ev->task, ev, ev->data);
ret = NXT_ERROR;
}
@@ -666,7 +667,7 @@ nxt_epoll_commit_changes(nxt_thread_t *thr, nxt_epoll_event_set_t *es)
static void
nxt_epoll_error_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_epoll_error_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_fd_t *ev;
@@ -675,7 +676,7 @@ nxt_epoll_error_handler(nxt_thread_t *thr, void *obj, void *data)
ev->read = NXT_EVENT_INACTIVE;
ev->write = NXT_EVENT_INACTIVE;
ev->error_handler(thr, ev, data);
ev->error_handler(ev->task, ev, data);
}
@@ -685,6 +686,7 @@ static nxt_int_t
nxt_epoll_add_signal(nxt_epoll_event_set_t *es, nxt_event_signals_t *signals)
{
int fd;
nxt_thread_t *thr;
struct epoll_event ee;
if (sigprocmask(SIG_BLOCK, &signals->sigmask, NULL) != 0) {
@@ -722,6 +724,9 @@ nxt_epoll_add_signal(nxt_epoll_event_set_t *es, nxt_event_signals_t *signals)
es->signalfd.read_handler = nxt_epoll_signalfd_handler;
es->signalfd.log = &nxt_main_log;
thr = nxt_thread();
es->signalfd.task = &thr->engine->task;
ee.events = EPOLLIN;
ee.data.ptr = &es->signalfd;
@@ -737,7 +742,7 @@ nxt_epoll_add_signal(nxt_epoll_event_set_t *es, nxt_event_signals_t *signals)
static void
nxt_epoll_signalfd_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_epoll_signalfd_handler(nxt_task_t *task, void *obj, void *data)
{
int n;
nxt_event_fd_t *ev;
@@ -747,20 +752,20 @@ nxt_epoll_signalfd_handler(nxt_thread_t *thr, void *obj, void *data)
ev = obj;
handler = data;
nxt_log_debug(thr->log, "signalfd handler");
nxt_debug(task, "signalfd handler");
n = read(ev->fd, &sfd, sizeof(struct signalfd_siginfo));
nxt_log_debug(thr->log, "read signalfd(%d): %d", ev->fd, n);
nxt_debug(task, "read signalfd(%d): %d", ev->fd, n);
if (n != sizeof(struct signalfd_siginfo)) {
nxt_log_alert(thr->log, "read signalfd(%d) failed %E",
ev->fd, nxt_errno);
nxt_log(task, NXT_LOG_CRIT, "read signalfd(%d) failed %E",
ev->fd, nxt_errno);
}
nxt_log_debug(thr->log, "signalfd(%d) signo:%d", ev->fd, sfd.ssi_signo);
nxt_debug(task, "signalfd(%d) signo:%d", ev->fd, sfd.ssi_signo);
handler(thr, (void *) (uintptr_t) sfd.ssi_signo, NULL);
handler(task, (void *) (uintptr_t) sfd.ssi_signo, NULL);
}
#endif
@@ -771,6 +776,7 @@ nxt_epoll_signalfd_handler(nxt_thread_t *thr, void *obj, void *data)
static nxt_int_t
nxt_epoll_enable_post(nxt_event_set_t *event_set, nxt_work_handler_t handler)
{
nxt_thread_t *thr;
struct epoll_event ee;
nxt_epoll_event_set_t *es;
@@ -804,6 +810,9 @@ nxt_epoll_enable_post(nxt_event_set_t *event_set, nxt_work_handler_t handler)
es->eventfd.data = es;
es->eventfd.log = &nxt_main_log;
thr = nxt_thread();
es->eventfd.task = &thr->engine->task;
ee.events = EPOLLIN | EPOLLET;
ee.data.ptr = &es->eventfd;
@@ -819,7 +828,7 @@ nxt_epoll_enable_post(nxt_event_set_t *event_set, nxt_work_handler_t handler)
static void
nxt_epoll_eventfd_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_epoll_eventfd_handler(nxt_task_t *task, void *obj, void *data)
{
int n;
uint64_t events;
@@ -827,7 +836,7 @@ nxt_epoll_eventfd_handler(nxt_thread_t *thr, void *obj, void *data)
es = data;
nxt_log_debug(thr->log, "eventfd handler, times:%ui", es->neventfd);
nxt_debug(task, "eventfd handler, times:%ui", es->neventfd);
/*
* The maximum value after write() to a eventfd() descriptor will
@@ -843,16 +852,15 @@ nxt_epoll_eventfd_handler(nxt_thread_t *thr, void *obj, void *data)
n = read(es->eventfd.fd, &events, sizeof(uint64_t));
nxt_log_debug(thr->log, "read(%d): %d events:%uL",
es->eventfd.fd, n, events);
nxt_debug(task, "read(%d): %d events:%uL", es->eventfd.fd, n, events);
if (n != sizeof(uint64_t)) {
nxt_log_alert(thr->log, "read eventfd(%d) failed %E",
es->eventfd.fd, nxt_errno);
nxt_log(task, NXT_LOG_CRIT, "read eventfd(%d) failed %E",
es->eventfd.fd, nxt_errno);
}
}
es->post_handler(thr, NULL, NULL);
es->post_handler(task, NULL, NULL);
}
@@ -881,7 +889,7 @@ nxt_epoll_signal(nxt_event_set_t *event_set, nxt_uint_t signo)
static void
nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_epoll_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout)
{
int nevents;
@@ -897,26 +905,25 @@ nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
es = &event_set->epoll;
if (es->nchanges != 0) {
if (nxt_epoll_commit_changes(thr, es) != NXT_OK) {
if (nxt_epoll_commit_changes(task, es) != NXT_OK) {
/* Error handlers have been enqueued on failure. */
timeout = 0;
}
}
nxt_log_debug(thr->log, "epoll_wait(%d) timeout:%M", es->epoll, timeout);
nxt_debug(task, "epoll_wait(%d) timeout:%M", es->epoll, timeout);
nevents = epoll_wait(es->epoll, es->events, es->mevents, timeout);
err = (nevents == -1) ? nxt_errno : 0;
nxt_thread_time_update(thr);
nxt_thread_time_update(task->thread);
nxt_log_debug(thr->log, "epoll_wait(%d): %d", es->epoll, nevents);
nxt_debug(task, "epoll_wait(%d): %d", es->epoll, nevents);
if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log_error(level, thr->log, "epoll_wait(%d) failed %E",
es->epoll, err);
nxt_log(task, level, "epoll_wait(%d) failed %E", es->epoll, err);
return;
}
@@ -926,8 +933,8 @@ nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
events = event->events;
ev = event->data.ptr;
nxt_log_debug(ev->log, "epoll: fd:%d ev:%04XD d:%p rd:%d wr:%d",
ev->fd, events, ev, ev->read, ev->write);
nxt_debug(ev->task, "epoll: fd:%d ev:%04XD d:%p rd:%d wr:%d",
ev->fd, events, ev, ev->read, ev->write);
/*
* On error epoll may set EPOLLERR and EPOLLHUP only without EPOLLIN or
@@ -953,9 +960,9 @@ nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
error = 0;
nxt_thread_work_queue_add(thr, ev->read_work_queue,
nxt_thread_work_queue_add(task->thread, ev->read_work_queue,
ev->read_handler,
ev, ev->data, ev->log);
ev->task, ev, ev->data);
} else if (event_set->epoll.mode == 0) {
/* Level-triggered mode. */
@@ -974,9 +981,9 @@ nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
error = 0;
nxt_thread_work_queue_add(thr, ev->write_work_queue,
nxt_thread_work_queue_add(task->thread, ev->write_work_queue,
ev->write_handler,
ev, ev->data, ev->log);
ev->task, ev, ev->data);
} else if (event_set->epoll.mode == 0) {
/* Level-triggered mode. */
@@ -995,7 +1002,7 @@ nxt_epoll_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
#if (NXT_HAVE_ACCEPT4)
static void
nxt_epoll_event_conn_io_accept4(nxt_thread_t *thr, void *obj, void *data)
nxt_epoll_event_conn_io_accept4(nxt_task_t *task, void *obj, void *data)
{
socklen_t len;
nxt_socket_t s;
@@ -1024,13 +1031,13 @@ nxt_epoll_event_conn_io_accept4(nxt_thread_t *thr, void *obj, void *data)
if (s != -1) {
c->socket.fd = s;
nxt_log_debug(thr->log, "accept4(%d): %d", cls->socket.fd, s);
nxt_debug(task, "accept4(%d): %d", cls->socket.fd, s);
nxt_event_conn_accept(thr, cls, c);
nxt_event_conn_accept(task, cls, c);
return;
}
nxt_event_conn_accept_error(thr, cls, "accept4", nxt_errno);
nxt_event_conn_accept_error(task, cls, "accept4", nxt_errno);
}
#endif
@@ -1049,8 +1056,7 @@ nxt_epoll_event_conn_io_accept4(nxt_thread_t *thr, void *obj, void *data)
*/
static void
nxt_epoll_edge_event_conn_io_connect(nxt_thread_t *thr, void *obj,
void *data)
nxt_epoll_edge_event_conn_io_connect(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_work_handler_t handler;
@@ -1071,9 +1077,9 @@ nxt_epoll_edge_event_conn_io_connect(nxt_thread_t *thr, void *obj,
c->socket.write_handler = nxt_epoll_edge_event_conn_connected;
c->socket.error_handler = nxt_event_conn_connect_error;
nxt_event_conn_timer(thr->engine, c, state, &c->write_timer);
nxt_event_conn_timer(task->thread->engine, c, state, &c->write_timer);
nxt_epoll_enable(thr->engine->event_set, &c->socket);
nxt_epoll_enable(task->thread->engine->event_set, &c->socket);
c->socket.read = NXT_EVENT_BLOCKED;
return;
@@ -1115,18 +1121,19 @@ nxt_epoll_edge_event_conn_io_connect(nxt_thread_t *thr, void *obj,
break;
}
nxt_event_conn_io_handle(thr, c->write_work_queue, handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue, handler,
task, c, data);
}
static void
nxt_epoll_edge_event_conn_connected(nxt_thread_t *thr, void *obj, void *data)
nxt_epoll_edge_event_conn_connected(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_log_debug(thr->log, "epoll event conn connected fd:%d", c->socket.fd);
nxt_debug(task, "epoll event conn connected fd:%d", c->socket.fd);
if (!c->socket.epoll_error) {
c->socket.write = NXT_EVENT_BLOCKED;
@@ -1135,12 +1142,12 @@ nxt_epoll_edge_event_conn_connected(nxt_thread_t *thr, void *obj, void *data)
nxt_event_timer_disable(&c->write_timer);
}
nxt_event_conn_io_handle(thr, c->write_work_queue,
c->write_state->ready_handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue,
c->write_state->ready_handler, task, c, data);
return;
}
nxt_event_conn_connect_test(thr, c, data);
nxt_event_conn_connect_test(task, c, data);
}

75
src/nxt_event_conn.c
View File

@@ -7,9 +7,9 @@
#include <nxt_main.h>
static void nxt_event_conn_shutdown_socket(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_shutdown_socket(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_close_socket(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_close_socket(nxt_task_t *task, void *obj,
void *data);
@@ -50,9 +50,8 @@ nxt_event_conn_io_t nxt_unix_event_conn_io = {
nxt_event_conn_t *
nxt_event_conn_create(nxt_mem_pool_t *mp, nxt_log_t *log)
{
nxt_thread_t *thr;
nxt_event_conn_t *c;
static nxt_atomic_t ident = 1;
nxt_thread_t *thr;
nxt_event_conn_t *c;
c = nxt_mem_zalloc(mp, sizeof(nxt_event_conn_t));
if (nxt_slow_path(c == NULL)) {
@@ -69,12 +68,19 @@ nxt_event_conn_create(nxt_mem_pool_t *mp, nxt_log_t *log)
/* The while loop skips possible uint32_t overflow. */
while (c->log.ident == 0) {
c->log.ident = (uint32_t) nxt_atomic_fetch_add(&ident, 1);
c->log.ident = nxt_task_next_ident();
}
thr = nxt_thread();
thr->engine->connections++;
c->task.thread = thr;
c->task.log = &c->log;
c->task.ident = c->log.ident;
c->socket.task = &c->task;
c->read_timer.task = &c->task;
c->write_timer.task = &c->task;
c->io = thr->engine->event->io;
c->max_chunk = NXT_INT32_T_MAX;
c->sendfile = NXT_CONN_SENDFILE_UNSET;
@@ -92,7 +98,7 @@ nxt_event_conn_create(nxt_mem_pool_t *mp, nxt_log_t *log)
void
nxt_event_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_io_shutdown(nxt_task_t *task, void *obj, void *data)
{
int ret;
socklen_t len;
@@ -101,12 +107,12 @@ nxt_event_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
c = obj;
nxt_log_debug(thr->log, "event conn shutdown");
nxt_debug(task, "event conn shutdown");
if (c->socket.timedout) {
/*
* A reset of timed out connection on close
* to release kernel memory associated with socket.
* Resetting of timed out connection on close
* releases kernel memory associated with socket.
* This also causes sending TCP/IP RST to a peer.
*/
linger.l_onoff = 1;
@@ -116,50 +122,54 @@ nxt_event_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
ret = setsockopt(c->socket.fd, SOL_SOCKET, SO_LINGER, &linger, len);
if (nxt_slow_path(ret != 0)) {
nxt_log_error(NXT_LOG_CRIT, thr->log,
"setsockopt(%d, SO_LINGER) failed %E",
c->socket.fd, nxt_socket_errno);
nxt_log(task, NXT_LOG_CRIT, "setsockopt(%d, SO_LINGER) failed %E",
c->socket.fd, nxt_socket_errno);
}
}
c->write_state->close_handler(thr, c, data);
c->write_state->close_handler(task, c, data);
}
void
nxt_event_conn_close(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_conn_close(nxt_task_t *task, nxt_event_conn_t *c)
{
nxt_thread_t *thr;
nxt_work_queue_t *wq;
nxt_event_engine_t *engine;
nxt_work_handler_t handler;
nxt_log_debug(thr->log, "event conn close fd:%d", c->socket.fd);
nxt_debug(task, "event conn close fd:%d", c->socket.fd);
thr = task->thread;
nxt_thread_work_queue_drop(thr, c);
nxt_thread_work_queue_drop(thr, &c->read_timer);
nxt_thread_work_queue_drop(thr, &c->write_timer);
nxt_event_timer_delete(thr->engine, &c->read_timer);
nxt_event_timer_delete(thr->engine, &c->write_timer);
engine = thr->engine;
nxt_event_fd_close(thr->engine, &c->socket);
thr->engine->connections--;
nxt_event_timer_delete(engine, &c->read_timer);
nxt_event_timer_delete(engine, &c->write_timer);
nxt_log_debug(thr->log, "event connections: %uD", thr->engine->connections);
nxt_event_fd_close(engine, &c->socket);
engine->connections--;
if (thr->engine->batch != 0) {
nxt_debug(task, "event connections: %uD", engine->connections);
if (engine->batch != 0) {
if (c->socket.closed || c->socket.error != 0) {
wq = &thr->engine->close_work_queue;
wq = &engine->close_work_queue;
handler = nxt_event_conn_close_socket;
} else {
wq = &thr->engine->shutdown_work_queue;
wq = &engine->shutdown_work_queue;
handler = nxt_event_conn_shutdown_socket;
}
nxt_thread_work_queue_add(thr, wq, handler,
(void *) (uintptr_t) c->socket.fd, NULL,
&nxt_main_log);
nxt_thread_work_queue_add(thr, wq, handler, task,
(void *) (uintptr_t) c->socket.fd, NULL);
} else {
nxt_socket_close(c->socket.fd);
@@ -170,7 +180,7 @@ nxt_event_conn_close(nxt_thread_t *thr, nxt_event_conn_t *c)
static void
nxt_event_conn_shutdown_socket(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_shutdown_socket(nxt_task_t *task, void *obj, void *data)
{
nxt_socket_t s;
@@ -178,14 +188,15 @@ nxt_event_conn_shutdown_socket(nxt_thread_t *thr, void *obj, void *data)
nxt_socket_shutdown(s, SHUT_RDWR);
nxt_thread_work_queue_add(thr, &thr->engine->close_work_queue,
nxt_event_conn_close_socket,
(void *) (uintptr_t) s, NULL, &nxt_main_log);
nxt_thread_work_queue_add(task->thread,
&task->thread->engine->close_work_queue,
nxt_event_conn_close_socket, task,
(void *) (uintptr_t) s, NULL);
}
static void
nxt_event_conn_close_socket(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_close_socket(nxt_task_t *task, void *obj, void *data)
{
nxt_socket_t s;

106
src/nxt_event_conn.h
View File

@@ -45,11 +45,8 @@ typedef struct {
typedef struct {
void (*connect)(nxt_thread_t *thr, void *obj,
void *data);
void (*accept)(nxt_thread_t *thr, void *obj,
void *data);
nxt_work_handler_t connect;
nxt_work_handler_t accept;
/*
* The read() with NULL c->read buffer waits readiness of a connection
@@ -59,8 +56,7 @@ typedef struct {
* connection without errors. In the latter case state's close_handler
* is called.
*/
void (*read)(nxt_thread_t *thr, void *obj,
void *data);
nxt_work_handler_t read;
ssize_t (*recvbuf)(nxt_event_conn_t *c, nxt_buf_t *b);
@@ -71,8 +67,7 @@ typedef struct {
* The write() is an interface to write a buffer chain with a given rate
* limit. It calls write_chunk() in a cycle and handles write event timer.
*/
void (*write)(nxt_thread_t *thr, void *obj,
void *data);
nxt_work_handler_t write;
/*
* The write_chunk() interface writes a buffer chain with a given limit
@@ -80,9 +75,8 @@ typedef struct {
* buffers data and calls the library specific send() interface to write
* the buffered data eventually.
*/
ssize_t (*write_chunk)(nxt_thread_t *thr,
nxt_event_conn_t *c, nxt_buf_t *b,
size_t limit);
ssize_t (*write_chunk)(nxt_event_conn_t *c,
nxt_buf_t *b, size_t limit);
/*
* The sendbuf() is an interface for OS-specific sendfile
@@ -102,8 +96,7 @@ typedef struct {
ssize_t (*send)(nxt_event_conn_t *c, void *buf,
size_t size);
void (*shutdown)(nxt_thread_t *thr, void *obj,
void *data);
nxt_work_handler_t shutdown;
} nxt_event_conn_io_t;
@@ -147,6 +140,7 @@ struct nxt_event_conn_s {
nxt_mem_pool_t *mem_pool;
nxt_task_t task;
nxt_log_t log;
nxt_listen_socket_t *listen;
@@ -178,12 +172,13 @@ typedef struct {
/* Must be the first field. */
nxt_event_fd_t socket;
nxt_task_t task;
uint32_t ready;
uint32_t batch;
/* An accept() interface is cached to minimize memory accesses. */
void (*accept)(nxt_thread_t *thr, void *obj,
void *data);
nxt_work_handler_t accept;
nxt_listen_socket_t *listen;
@@ -194,13 +189,13 @@ typedef struct {
#define \
nxt_event_conn_io_handle(thr, wq, handler, c, data) \
nxt_event_conn_io_handle(thr, wq, handler, task, c, data) \
do { \
if (thr->engine->batch != 0) { \
nxt_thread_work_queue_add(thr, wq, handler, c, data, thr->log); \
nxt_thread_work_queue_add(thr, wq, handler, task, c, data); \
\
} else { \
handler(thr, c, data); \
handler(task, c, data); \
} \
} while (0)
@@ -259,9 +254,8 @@ nxt_event_conn_tcp_nodelay_on(c) \
NXT_EXPORT nxt_event_conn_t *nxt_event_conn_create(nxt_mem_pool_t *mp,
nxt_log_t *log);
void nxt_event_conn_io_shutdown(nxt_thread_t *thr, void *obj,
void *data);
NXT_EXPORT void nxt_event_conn_close(nxt_thread_t *thr, nxt_event_conn_t *c);
void nxt_event_conn_io_shutdown(nxt_task_t *task, void *obj, void *data);
NXT_EXPORT void nxt_event_conn_close(nxt_task_t *task, nxt_event_conn_t *c);
NXT_EXPORT void nxt_event_conn_timer(nxt_event_engine_t *engine,
nxt_event_conn_t *c, const nxt_event_conn_state_t *state,
@@ -269,77 +263,66 @@ NXT_EXPORT void nxt_event_conn_timer(nxt_event_engine_t *engine,
NXT_EXPORT void nxt_event_conn_work_queue_set(nxt_event_conn_t *c,
nxt_work_queue_t *wq);
NXT_EXPORT void nxt_event_conn_connect(nxt_thread_t *thr, nxt_event_conn_t *c);
void nxt_event_conn_batch_socket(nxt_thread_t *thr, void *obj,
void *data);
void nxt_event_conn_io_connect(nxt_thread_t *thr, void *obj,
void *data);
nxt_int_t nxt_event_conn_socket(nxt_thread_t *thr,
nxt_event_conn_t *c);
void nxt_event_conn_connect_test(nxt_thread_t *thr, void *obj,
void *data);
void nxt_event_conn_connect_error(nxt_thread_t *thr, void *obj,
void *data);
NXT_EXPORT void nxt_event_conn_connect(nxt_task_t *task, nxt_event_conn_t *c);
void nxt_event_conn_batch_socket(nxt_task_t *task, void *obj, void *data);
void nxt_event_conn_io_connect(nxt_task_t *task, void *obj, void *data);
nxt_int_t nxt_event_conn_socket(nxt_task_t *task, nxt_event_conn_t *c);
void nxt_event_conn_connect_test(nxt_task_t *task, void *obj, void *data);
void nxt_event_conn_connect_error(nxt_task_t *task, void *obj, void *data);
NXT_EXPORT nxt_int_t nxt_event_conn_listen(nxt_thread_t *thr,
NXT_EXPORT nxt_int_t nxt_event_conn_listen(nxt_task_t *task,
nxt_listen_socket_t *ls);
void nxt_event_conn_io_accept(nxt_thread_t *thr, void *obj,
void *data);
NXT_EXPORT void nxt_event_conn_accept(nxt_thread_t *thr,
void nxt_event_conn_io_accept(nxt_task_t *task, void *obj, void *data);
NXT_EXPORT void nxt_event_conn_accept(nxt_task_t *task,
nxt_event_conn_listen_t *cls, nxt_event_conn_t *c);
void nxt_event_conn_accept_error(nxt_thread_t *thr,
nxt_event_conn_listen_t *cls, const char *accept_syscall, nxt_err_t err);
void nxt_event_conn_accept_error(nxt_task_t *task, nxt_event_conn_listen_t *cls,
const char *accept_syscall, nxt_err_t err);
NXT_EXPORT void nxt_event_conn_read(nxt_thread_t *thr, nxt_event_conn_t *c);
void nxt_event_conn_io_read(nxt_thread_t *thr, void *obj,
void *data);
NXT_EXPORT void nxt_event_conn_read(nxt_task_t *task, nxt_event_conn_t *c);
void nxt_event_conn_io_read(nxt_task_t *task, void *obj, void *data);
ssize_t nxt_event_conn_io_recvbuf(nxt_event_conn_t *c, nxt_buf_t *b);
ssize_t nxt_event_conn_io_recv(nxt_event_conn_t *c, void *buf,
size_t size, nxt_uint_t flags);
NXT_EXPORT void nxt_event_conn_write(nxt_thread_t *thr, nxt_event_conn_t *c);
NXT_EXPORT void nxt_event_conn_write(nxt_task_t *task, nxt_event_conn_t *c);
size_t nxt_event_conn_write_limit(nxt_event_conn_t *c);
nxt_bool_t nxt_event_conn_write_delayed(nxt_event_engine_t *engine,
nxt_event_conn_t *c, size_t sent);
void nxt_event_conn_io_write(nxt_thread_t *thr, void *obj,
void *data);
ssize_t nxt_event_conn_io_write_chunk(nxt_thread_t *thr,
nxt_event_conn_t *c, nxt_buf_t *b, size_t limit);
ssize_t nxt_event_conn_io_writev(nxt_event_conn_t *c,
nxt_iobuf_t *iob, nxt_uint_t niob);
ssize_t nxt_event_conn_io_send(nxt_event_conn_t *c, void *buf,
size_t size);
void nxt_event_conn_io_write(nxt_task_t *task, void *obj, void *data);
ssize_t nxt_event_conn_io_write_chunk(nxt_event_conn_t *c, nxt_buf_t *b,
size_t limit);
ssize_t nxt_event_conn_io_writev(nxt_event_conn_t *c, nxt_iobuf_t *iob,
nxt_uint_t niob);
ssize_t nxt_event_conn_io_send(nxt_event_conn_t *c, void *buf, size_t size);
NXT_EXPORT void nxt_event_conn_job_sendfile(nxt_thread_t *thr,
NXT_EXPORT void nxt_event_conn_job_sendfile(nxt_task_t *task,
nxt_event_conn_t *c);
#define \
nxt_event_conn_connect_enqueue(thr, c) \
nxt_event_conn_connect_enqueue(thr, task, c) \
nxt_thread_work_queue_add(thr, &thr->engine->socket_work_queue, \
nxt_event_conn_batch_socket, \
c, c->socket.data, c->socket.log)
task, c, c->socket.data)
#define \
nxt_event_conn_read_enqueue(thr, c) \
nxt_event_conn_read_enqueue(thr, task, c) \
do { \
c->socket.read_work_queue = &thr->engine->read_work_queue; \
\
nxt_thread_work_queue_add(thr, &thr->engine->read_work_queue, \
c->io->read, c, c->socket.data, \
c->socket.log); \
c->io->read, task, c, c->socket.data); \
} while (0)
#define \
nxt_event_conn_write_enqueue(thr, c) \
nxt_event_conn_write_enqueue(thr, task, c) \
do { \
c->socket.write_work_queue = &thr->engine->write_work_queue; \
\
nxt_thread_work_queue_add(thr, &thr->engine->write_work_queue, \
c->io->write, c, c->socket.data, \
c->socket.log); \
c->io->write, task, c, c->socket.data); \
} while (0)
@@ -376,7 +359,8 @@ typedef struct {
NXT_EXPORT nxt_event_conn_proxy_t *nxt_event_conn_proxy_create(
nxt_event_conn_t *c);
NXT_EXPORT void nxt_event_conn_proxy(nxt_event_conn_proxy_t *p);
NXT_EXPORT void nxt_event_conn_proxy(nxt_task_t *task,
nxt_event_conn_proxy_t *p);
#endif /* _NXT_EVENT_CONN_H_INCLUDED_ */

133
src/nxt_event_conn_accept.c
View File

@@ -18,23 +18,24 @@
*/
static nxt_event_conn_t *nxt_event_conn_accept_alloc(nxt_thread_t *thr,
static nxt_event_conn_t *nxt_event_conn_accept_alloc(nxt_task_t *task,
nxt_event_conn_listen_t *cls);
static void nxt_event_conn_listen_handler(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_listen_handler(nxt_task_t *task, void *obj,
void *data);
static nxt_event_conn_t *nxt_event_conn_accept_next(nxt_thread_t *thr,
static nxt_event_conn_t *nxt_event_conn_accept_next(nxt_task_t *task,
nxt_event_conn_listen_t *cls);
static nxt_int_t nxt_event_conn_accept_close_idle(nxt_thread_t *thr,
static nxt_int_t nxt_event_conn_accept_close_idle(nxt_task_t *task,
nxt_event_conn_listen_t *cls);
static void nxt_event_conn_listen_event_error(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_listen_event_error(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_listen_timer_handler(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_listen_timer_handler(nxt_task_t *task, void *obj,
void *data);
nxt_int_t
nxt_event_conn_listen(nxt_thread_t *thr, nxt_listen_socket_t *ls)
nxt_event_conn_listen(nxt_task_t *task, nxt_listen_socket_t *ls)
{
nxt_event_engine_t *engine;
nxt_event_conn_listen_t *cls;
cls = nxt_zalloc(sizeof(nxt_event_conn_listen_t));
@@ -42,13 +43,14 @@ nxt_event_conn_listen(nxt_thread_t *thr, nxt_listen_socket_t *ls)
if (nxt_fast_path(cls != NULL)) {
cls->socket.fd = ls->socket;
cls->batch = thr->engine->batch;
engine = task->thread->engine;
cls->batch = engine->batch;
if (cls->batch != 0) {
cls->socket.read_work_queue = &thr->engine->accept_work_queue;
cls->socket.read_work_queue = &engine->accept_work_queue;
} else {
cls->socket.read_work_queue = &thr->work_queue.main;
cls->socket.read_work_queue = &task->thread->work_queue.main;
cls->batch = 1;
}
@@ -56,20 +58,26 @@ nxt_event_conn_listen(nxt_thread_t *thr, nxt_listen_socket_t *ls)
cls->socket.error_handler = nxt_event_conn_listen_event_error;
cls->socket.log = &nxt_main_log;
cls->accept = thr->engine->event->io->accept;
cls->accept = engine->event->io->accept;
cls->listen = ls;
cls->timer.work_queue = &thr->work_queue.main;
cls->timer.work_queue = &task->thread->work_queue.main;
cls->timer.handler = nxt_event_conn_listen_timer_handler;
cls->timer.log = &nxt_main_log;
nxt_event_timer_ident(&cls->timer, cls->socket.fd);
if (nxt_event_conn_accept_alloc(thr, cls) != NULL) {
nxt_event_fd_enable_accept(thr->engine, &cls->socket);
cls->task.thread = task->thread;
cls->task.log = &nxt_main_log;
cls->task.ident = nxt_task_next_ident();
cls->socket.task = &cls->task;
cls->timer.task = &cls->task;
nxt_queue_insert_head(&thr->engine->listen_connections, &cls->link);
if (nxt_event_conn_accept_alloc(task, cls) != NULL) {
nxt_event_fd_enable_accept(engine, &cls->socket);
nxt_queue_insert_head(&engine->listen_connections, &cls->link);
}
return NXT_OK;
@@ -80,14 +88,17 @@ nxt_event_conn_listen(nxt_thread_t *thr, nxt_listen_socket_t *ls)
static nxt_event_conn_t *
nxt_event_conn_accept_alloc(nxt_thread_t *thr, nxt_event_conn_listen_t *cls)
nxt_event_conn_accept_alloc(nxt_task_t *task, nxt_event_conn_listen_t *cls)
{
nxt_sockaddr_t *sa, *remote;
nxt_mem_pool_t *mp;
nxt_event_conn_t *c;
nxt_event_engine_t *engine;
nxt_listen_socket_t *ls;
if (thr->engine->connections < thr->engine->max_connections) {
engine = task->thread->engine;
if (engine->connections < engine->max_connections) {
mp = nxt_mem_pool_create(cls->listen->mem_pool_size);
@@ -123,19 +134,19 @@ nxt_event_conn_accept_alloc(nxt_thread_t *thr, nxt_event_conn_listen_t *cls)
static void
nxt_event_conn_listen_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_listen_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_listen_t *cls;
cls = obj;
cls->ready = cls->batch;
cls->accept(thr, cls, data);
cls->accept(task, cls, data);
}
void
nxt_event_conn_io_accept(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_io_accept(nxt_task_t *task, void *obj, void *data)
{
socklen_t len;
nxt_socket_t s;
@@ -162,7 +173,7 @@ nxt_event_conn_io_accept(nxt_thread_t *thr, void *obj, void *data)
s = accept(cls->socket.fd, sa, &len);
if (s == -1) {
nxt_event_conn_accept_error(thr, cls, "accept", nxt_socket_errno);
nxt_event_conn_accept_error(task, cls, "accept", nxt_socket_errno);
return;
}
@@ -179,14 +190,14 @@ nxt_event_conn_io_accept(nxt_thread_t *thr, void *obj, void *data)
#endif
nxt_log_debug(thr->log, "accept(%d): %d", cls->socket.fd, s);
nxt_debug(task, "accept(%d): %d", cls->socket.fd, s);
nxt_event_conn_accept(thr, cls, c);
nxt_event_conn_accept(task, cls, c);
}
void
nxt_event_conn_accept(nxt_thread_t *thr, nxt_event_conn_listen_t *cls,
nxt_event_conn_accept(nxt_task_t *task, nxt_event_conn_listen_t *cls,
nxt_event_conn_t *c)
{
nxt_event_conn_t *next;
@@ -197,10 +208,9 @@ nxt_event_conn_accept(nxt_thread_t *thr, nxt_event_conn_listen_t *cls,
/* This allocation cannot fail. */
(void) nxt_sockaddr_text(c->mem_pool, c->remote, 0);
nxt_log_debug(c->socket.log, "client: %*s",
c->remote->text_len, c->remote->text);
nxt_debug(task, "client: %*s", c->remote->text_len, c->remote->text);
nxt_queue_insert_head(&thr->engine->idle_connections, &c->link);
nxt_queue_insert_head(&task->thread->engine->idle_connections, &c->link);
c->read_work_queue = c->listen->work_queue;
c->write_work_queue = c->listen->work_queue;
@@ -208,41 +218,39 @@ nxt_event_conn_accept(nxt_thread_t *thr, nxt_event_conn_listen_t *cls,
if (c->listen->read_after_accept) {
//c->socket.read_ready = 1;
thr->log = c->socket.log;
c->listen->handler(thr, c, NULL);
thr->log = cls->socket.log;
c->listen->handler(task, c, NULL);
} else {
nxt_thread_work_queue_add(thr, c->write_work_queue,
c->listen->handler, c, NULL, c->socket.log);
nxt_thread_work_queue_add(task->thread, c->write_work_queue,
c->listen->handler, task, c, NULL);
}
next = nxt_event_conn_accept_next(thr, cls);
next = nxt_event_conn_accept_next(task, cls);
if (next != NULL && cls->socket.read_ready) {
nxt_thread_work_queue_add(thr, cls->socket.read_work_queue,
cls->accept, cls, next, cls->socket.log);
nxt_thread_work_queue_add(task->thread, cls->socket.read_work_queue,
cls->accept, task, cls, next);
}
}
static nxt_event_conn_t *
nxt_event_conn_accept_next(nxt_thread_t *thr, nxt_event_conn_listen_t *cls)
nxt_event_conn_accept_next(nxt_task_t *task, nxt_event_conn_listen_t *cls)
{
nxt_event_conn_t *c;
cls->socket.data = NULL;
do {
c = nxt_event_conn_accept_alloc(thr, cls);
c = nxt_event_conn_accept_alloc(task, cls);
if (nxt_fast_path(c != NULL)) {
return c;
}
} while (nxt_event_conn_accept_close_idle(thr, cls) == NXT_OK);
} while (nxt_event_conn_accept_close_idle(task, cls) == NXT_OK);
nxt_log_alert(cls->socket.log, "no available connections, "
nxt_log(task, NXT_LOG_CRIT, "no available connections, "
"new connections are not accepted within 1s");
return NULL;
@@ -250,8 +258,7 @@ nxt_event_conn_accept_next(nxt_thread_t *thr, nxt_event_conn_listen_t *cls)
static nxt_int_t
nxt_event_conn_accept_close_idle(nxt_thread_t *thr,
nxt_event_conn_listen_t *cls)
nxt_event_conn_accept_close_idle(nxt_task_t *task, nxt_event_conn_listen_t *cls)
{
nxt_queue_t *idle;
nxt_queue_link_t *link;
@@ -261,7 +268,7 @@ nxt_event_conn_accept_close_idle(nxt_thread_t *thr,
NXT_LOG_INFO, 2, "idle connections closed", NXT_LOG_MODERATION
};
idle = &thr->engine->idle_connections;
idle = &task->thread->engine->idle_connections;
for (link = nxt_queue_last(idle);
link != nxt_queue_head(idle);
@@ -271,24 +278,25 @@ nxt_event_conn_accept_close_idle(nxt_thread_t *thr,
if (!c->socket.read_ready) {
nxt_log_moderate(&nxt_idle_close_log_moderation, NXT_LOG_INFO,
thr->log, "no available connections, "
task->log, "no available connections, "
"close idle connection");
nxt_queue_remove(link);
nxt_event_conn_close(thr, c);
nxt_event_conn_close(task, c);
return NXT_OK;
}
}
nxt_event_timer_add(thr->engine, &cls->timer, 1000);
nxt_event_fd_disable_read(thr->engine, &cls->socket);
nxt_event_timer_add(task->thread->engine, &cls->timer, 1000);
nxt_event_fd_disable_read(task->thread->engine, &cls->socket);
return NXT_DECLINED;
}
void
nxt_event_conn_accept_error(nxt_thread_t *thr, nxt_event_conn_listen_t *cls,
nxt_event_conn_accept_error(nxt_task_t *task, nxt_event_conn_listen_t *cls,
const char *accept_syscall, nxt_err_t err)
{
static nxt_log_moderation_t nxt_accept_log_moderation = {
@@ -300,13 +308,12 @@ nxt_event_conn_accept_error(nxt_thread_t *thr, nxt_event_conn_listen_t *cls,
switch (err) {
case NXT_EAGAIN:
nxt_log_debug(thr->log, "%s(%d) %E",
accept_syscall, cls->socket.fd, err);
nxt_debug(task, "%s(%d) %E", accept_syscall, cls->socket.fd, err);
return;
case ECONNABORTED:
nxt_log_moderate(&nxt_accept_log_moderation, NXT_LOG_INFO,
thr->log, "%s(%d) failed %E",
nxt_log_moderate(&nxt_accept_log_moderation, NXT_LOG_WARN,
task->log, "%s(%d) failed %E",
accept_syscall, cls->socket.fd, err);
return;
@@ -314,24 +321,24 @@ nxt_event_conn_accept_error(nxt_thread_t *thr, nxt_event_conn_listen_t *cls,
case ENFILE:
case ENOBUFS:
case ENOMEM:
if (nxt_event_conn_accept_close_idle(thr, cls) != NXT_OK) {
nxt_log_alert(thr->log, "%s(%d) failed %E, "
"new connections are not accepted within 1s",
accept_syscall, cls->socket.fd, err);
if (nxt_event_conn_accept_close_idle(task, cls) != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "%s(%d) failed %E, "
"new connections are not accepted within 1s",
accept_syscall, cls->socket.fd, err);
}
return;
default:
nxt_log_alert(thr->log, "%s(%d) failed %E",
accept_syscall, cls->socket.fd, err);
nxt_log(task, NXT_LOG_CRIT, "%s(%d) failed %E",
accept_syscall, cls->socket.fd, err);
return;
}
}
static void
nxt_event_conn_listen_timer_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_listen_timer_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_event_timer_t *ev;
@@ -343,25 +350,25 @@ nxt_event_conn_listen_timer_handler(nxt_thread_t *thr, void *obj, void *data)
c = cls->socket.data;
if (c == NULL) {
c = nxt_event_conn_accept_next(thr, cls);
c = nxt_event_conn_accept_next(task, cls);
if (c == NULL) {
return;
}
}
nxt_event_fd_enable_accept(thr->engine, &cls->socket);
nxt_event_fd_enable_accept(task->thread->engine, &cls->socket);
cls->accept(thr, cls, c);
cls->accept(task, cls, c);
}
static void
nxt_event_conn_listen_event_error(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_listen_event_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_fd_t *ev;
ev = obj;
nxt_log_alert(thr->log, "accept(%d) event error", ev->fd);
nxt_log(task, NXT_LOG_CRIT, "accept(%d) event error", ev->fd);
}

71
src/nxt_event_conn_connect.c
View File

@@ -8,37 +8,38 @@
void
nxt_event_conn_connect(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_conn_connect(nxt_task_t *task, nxt_event_conn_t *c)
{
void *data;
void *data;
nxt_event_engine_t *engine;
data = c->socket.data;
engine = task->thread->engine;
if (thr->engine->batch != 0) {
nxt_thread_work_queue_add(thr, &thr->engine->socket_work_queue,
nxt_event_conn_batch_socket, c, data,
c->socket.log);
if (engine->batch != 0) {
nxt_thread_work_queue_add(task->thread, &engine->socket_work_queue,
nxt_event_conn_batch_socket, task, c, data);
return;
}
if (nxt_event_conn_socket(thr, c) == NXT_OK) {
c->io->connect(thr, c, data);
if (nxt_event_conn_socket(task, c) == NXT_OK) {
c->io->connect(task, c, data);
return;
}
c->write_state->error_handler(thr, c, data);
c->write_state->error_handler(task, c, data);
}
void
nxt_event_conn_batch_socket(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_batch_socket(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_work_handler_t handler;
c = obj;
if (nxt_event_conn_socket(thr, c) == NXT_OK) {
if (nxt_event_conn_socket(task, c) == NXT_OK) {
c->socket.write_work_queue = c->write_work_queue;
handler = c->io->connect;
@@ -46,16 +47,18 @@ nxt_event_conn_batch_socket(nxt_thread_t *thr, void *obj, void *data)
handler = c->write_state->error_handler;
}
nxt_thread_work_queue_add(thr, &thr->engine->connect_work_queue,
handler, c, data, thr->log);
nxt_thread_work_queue_add(task->thread,
&task->thread->engine->connect_work_queue,
handler, task, c, data);
}
void
nxt_event_conn_io_connect(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_io_connect(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_work_handler_t handler;
nxt_event_engine_t *engine;
const nxt_event_conn_state_t *state;
c = obj;
@@ -73,9 +76,11 @@ nxt_event_conn_io_connect(nxt_thread_t *thr, void *obj, void *data)
c->socket.write_handler = nxt_event_conn_connect_test;
c->socket.error_handler = state->error_handler;
nxt_event_conn_timer(thr->engine, c, state, &c->write_timer);
engine = task->thread->engine;
nxt_event_fd_enable_write(thr->engine, &c->socket);
nxt_event_conn_timer(engine, c, state, &c->write_timer);
nxt_event_fd_enable_write(engine, &c->socket);
return;
case NXT_DECLINED:
@@ -87,17 +92,18 @@ nxt_event_conn_io_connect(nxt_thread_t *thr, void *obj, void *data)
break;
}
nxt_event_conn_io_handle(thr, c->write_work_queue, handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue, handler, task,
c, data);
}
nxt_int_t
nxt_event_conn_socket(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_conn_socket(nxt_task_t *task, nxt_event_conn_t *c)
{
nxt_uint_t family;
nxt_socket_t s;
nxt_log_debug(thr->log, "event conn socket");
nxt_debug(task, "event conn socket");
family = c->remote->u.sockaddr.sa_family;
@@ -122,6 +128,10 @@ nxt_event_conn_socket(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_timer_ident(&c->read_timer, s);
nxt_event_timer_ident(&c->write_timer, s);
c->socket.task = task;
c->read_timer.task = task;
c->write_timer.task = task;
if (c->local != NULL) {
if (nxt_slow_path(nxt_socket_bind(s, c->local, 0) != NXT_OK)) {
nxt_socket_close(s);
@@ -134,7 +144,7 @@ nxt_event_conn_socket(nxt_thread_t *thr, nxt_event_conn_t *c)
void
nxt_event_conn_connect_test(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_connect_test(nxt_task_t *task, void *obj, void *data)
{
int ret, err;
socklen_t len;
@@ -142,9 +152,9 @@ nxt_event_conn_connect_test(nxt_thread_t *thr, void *obj, void *data)
c = obj;
nxt_log_debug(thr->log, "event connect test fd:%d", c->socket.fd);
nxt_debug(task, "event connect test fd:%d", c->socket.fd);
nxt_event_fd_block_write(thr->engine, &c->socket);
nxt_event_fd_block_write(task->thread->engine, &c->socket);
if (c->write_state->autoreset_timer) {
nxt_event_timer_disable(&c->write_timer);
@@ -165,23 +175,23 @@ nxt_event_conn_connect_test(nxt_thread_t *thr, void *obj, void *data)
}
if (err == 0) {
nxt_event_conn_io_handle(thr, c->write_work_queue,
c->write_state->ready_handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue,
c->write_state->ready_handler, task, c, data);
return;
}
c->socket.error = err;
nxt_log_error(nxt_socket_error_level(err, c->socket.log_error), thr->log,
"connect(%d, %*s) failed %E",
c->socket.fd, c->remote->text_len, c->remote->text, err);
nxt_log(task, nxt_socket_error_level(err, c->socket.log_error),
"connect(%d, %*s) failed %E",
c->socket.fd, c->remote->text_len, c->remote->text, err);
nxt_event_conn_connect_error(thr, c, data);
nxt_event_conn_connect_error(task, c, data);
}
void
nxt_event_conn_connect_error(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_connect_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_work_handler_t handler;
@@ -209,5 +219,6 @@ nxt_event_conn_connect_error(nxt_thread_t *thr, void *obj, void *data)
break;
}
nxt_event_conn_io_handle(thr, c->write_work_queue, handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue, handler,
task, c, data);
}

69
src/nxt_event_conn_job_sendfile.c
View File

@@ -18,28 +18,28 @@ typedef struct {
} nxt_job_sendfile_t;
static void nxt_event_conn_job_sendfile_start(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_job_sendfile_start(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_job_sendfile_handler(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_job_sendfile_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_job_sendfile_return(nxt_task_t *task, void *obj,
void *data);
static nxt_buf_t *nxt_event_conn_job_sendfile_completion(nxt_thread_t *thr,
static nxt_buf_t *nxt_event_conn_job_sendfile_completion(nxt_task_t *task,
nxt_event_conn_t *c, nxt_buf_t *b);
void
nxt_event_conn_job_sendfile(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_conn_job_sendfile(nxt_task_t *task, nxt_event_conn_t *c)
{
nxt_event_fd_disable(thr->engine, &c->socket);
nxt_event_fd_disable(task->thread->engine, &c->socket);
/* A work item data is not used in nxt_event_conn_job_sendfile_start(). */
nxt_event_conn_job_sendfile_start(thr, c, NULL);
nxt_event_conn_job_sendfile_start(task, c, NULL);
}
static void
nxt_event_conn_job_sendfile_start(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_job_sendfile_start(nxt_task_t *task, void *obj, void *data)
{
nxt_iobuf_t b;
nxt_event_conn_t *c;
@@ -48,12 +48,12 @@ nxt_event_conn_job_sendfile_start(nxt_thread_t *thr, void *obj, void *data)
c = obj;
nxt_log_debug(thr->log, "event conn sendfile fd:%d", c->socket.fd);
nxt_debug(task, "event conn sendfile fd:%d", c->socket.fd);
jbs = nxt_job_create(c->mem_pool, sizeof(nxt_job_sendfile_t));
if (nxt_slow_path(jbs == NULL)) {
c->write_state->error_handler(thr, c, NULL);
c->write_state->error_handler(task, c, NULL);
return;
}
@@ -74,7 +74,7 @@ nxt_event_conn_job_sendfile_start(nxt_thread_t *thr, void *obj, void *data)
sb.size = 0;
sb.limit = jbs->limit;
if (nxt_sendbuf_mem_coalesce(&sb) != 0 || !sb.sync) {
if (nxt_sendbuf_mem_coalesce(c->socket.task, &sb) != 0 || !sb.sync) {
jbs->job.thread_pool = c->u.thread_pool;
jbs->job.log = c->socket.log;
@@ -88,17 +88,17 @@ nxt_event_conn_job_sendfile_start(nxt_thread_t *thr, void *obj, void *data)
c->write_timer.state = NXT_EVENT_TIMER_BLOCKED;
}
nxt_job_start(thr, &jbs->job, nxt_event_conn_job_sendfile_handler);
nxt_job_start(task, &jbs->job, nxt_event_conn_job_sendfile_handler);
return;
}
}
nxt_event_conn_job_sendfile_return(thr, jbs, c);
nxt_event_conn_job_sendfile_return(task, jbs, c);
}
static void
nxt_event_conn_job_sendfile_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_job_sendfile_handler(nxt_task_t *task, void *obj, void *data)
{
ssize_t ret;
nxt_buf_t *b;
@@ -109,7 +109,7 @@ nxt_event_conn_job_sendfile_handler(nxt_thread_t *thr, void *obj, void *data)
jbs = obj;
c = data;
nxt_log_debug(thr->log, "event conn job sendfile fd:%d", c->socket.fd);
nxt_debug(task, "event conn job sendfile fd:%d", c->socket.fd);
first = c->socket.write_ready;
b = jbs->out;
@@ -146,24 +146,25 @@ nxt_event_conn_job_sendfile_handler(nxt_thread_t *thr, void *obj, void *data)
} while (c->socket.write_ready);
if (first && thr->thread_pool->work_queue.head != NULL) {
if (first && task->thread->thread_pool->work_queue.head != NULL) {
goto fast;
}
done:
nxt_job_return(thr, &jbs->job, jbs->ready_handler);
nxt_job_return(task, &jbs->job, jbs->ready_handler);
return;
fast:
nxt_thread_pool_post(thr->thread_pool, nxt_event_conn_job_sendfile_handler,
jbs, c, thr->log);
nxt_thread_pool_post(task->thread->thread_pool,
nxt_event_conn_job_sendfile_handler,
&jbs->job.task, jbs, c);
}
static void
nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_job_sendfile_return(nxt_task_t *task, void *obj, void *data)
{
size_t sent;
nxt_buf_t *b;
@@ -179,7 +180,7 @@ nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj, void *data)
sent = jbs->sent;
c->sent += sent;
nxt_log_debug(thr->log, "event conn sendfile sent:%z", sent);
nxt_debug(task, "event conn sendfile sent:%z", sent);
b = jbs->out;
@@ -187,7 +188,7 @@ nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj, void *data)
nxt_job_destroy(jbs);
if (c->write_state->process_buffers) {
b = nxt_event_conn_job_sendfile_completion(thr, c, b);
b = nxt_event_conn_job_sendfile_completion(task, c, b);
done = (b == NULL);
@@ -200,7 +201,7 @@ nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj, void *data)
if (b != NULL) {
/* But new data has been added. */
nxt_event_conn_job_sendfile_start(thr, c, NULL);
nxt_event_conn_job_sendfile_start(task, c, NULL);
}
return;
@@ -215,17 +216,18 @@ nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj, void *data)
}
if (c->socket.error == 0
&& !nxt_event_conn_write_delayed(thr->engine, c, sent))
&& !nxt_event_conn_write_delayed(task->thread->engine, c, sent))
{
nxt_event_conn_timer(thr->engine, c, c->write_state, &c->write_timer);
nxt_event_conn_timer(task->thread->engine, c, c->write_state,
&c->write_timer);
nxt_event_fd_oneshot_write(thr->engine, &c->socket);
nxt_event_fd_oneshot_write(task->thread->engine, &c->socket);
}
if (sent != 0) {
nxt_event_conn_io_handle(thr, c->write_work_queue,
nxt_event_conn_io_handle(task->thread, c->write_work_queue,
c->write_state->ready_handler,
c, c->socket.data);
task, c, c->socket.data);
/*
* Fall through if first operations were
* successful but the last one failed.
@@ -233,15 +235,15 @@ nxt_event_conn_job_sendfile_return(nxt_thread_t *thr, void *obj, void *data)
}
if (nxt_slow_path(c->socket.error != 0)) {
nxt_event_conn_io_handle(thr, c->write_work_queue,
nxt_event_conn_io_handle(task->thread, c->write_work_queue,
c->write_state->error_handler,
c, c->socket.data);
task, c, c->socket.data);
}
}
static nxt_buf_t *
nxt_event_conn_job_sendfile_completion(nxt_thread_t *thr, nxt_event_conn_t *c,
nxt_event_conn_job_sendfile_completion(nxt_task_t *task, nxt_event_conn_t *c,
nxt_buf_t *b)
{
while (b != NULL) {
@@ -255,9 +257,8 @@ nxt_event_conn_job_sendfile_completion(nxt_thread_t *thr, nxt_event_conn_t *c,
break;
}
nxt_thread_work_queue_add(thr, c->write_work_queue,
b->completion_handler,
b, b->parent, thr->log);
nxt_thread_work_queue_add(task->thread, c->write_work_queue,
b->completion_handler, task, b, b->parent);
b = b->next;
}

257
src/nxt_event_conn_proxy.c
View File

@@ -7,53 +7,51 @@
#include <nxt_main.h>
static void nxt_event_conn_proxy_client_buffer_alloc(nxt_thread_t *thr,
static void nxt_event_conn_proxy_client_buffer_alloc(nxt_task_t *task,
void *obj, void *data);
static void nxt_event_conn_proxy_peer_connect(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_peer_connect(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_connected(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_connected(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_peer_read(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_peer_read(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_client_read_ready(nxt_thread_t *thr,
void *obj, void *data);
static void nxt_event_conn_proxy_peer_read_ready(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_client_read_ready(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_read_process(nxt_thread_t *thr,
static void nxt_event_conn_proxy_peer_read_ready(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_read_process(nxt_task_t *task,
nxt_event_conn_proxy_t *p, nxt_event_conn_t *source,
nxt_event_conn_t *sink);
static void nxt_event_conn_proxy_write_add(nxt_event_conn_t *c, nxt_buf_t *b);
static void nxt_event_conn_proxy_read(nxt_thread_t *thr, void *obj, void *data);
static void nxt_event_conn_proxy_client_write_ready(nxt_thread_t *thr,
void *obj, void *data);
static void nxt_event_conn_proxy_peer_write_ready(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_read(nxt_task_t *task, void *obj, void *data);
static void nxt_event_conn_proxy_client_write_ready(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_write_process(nxt_thread_t *thr,
static void nxt_event_conn_proxy_peer_write_ready(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_write_process(nxt_task_t *task,
nxt_event_conn_proxy_t *p, nxt_event_conn_t *sink,
nxt_event_conn_t *source);
static void nxt_event_conn_proxy_read_add(nxt_event_conn_t *c, nxt_buf_t *b);
static void nxt_event_conn_proxy_close(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_close(nxt_task_t *task, void *obj, void *data);
static void nxt_event_conn_proxy_error(nxt_task_t *task, void *obj, void *data);
static void nxt_event_conn_proxy_read_timeout(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_error(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_event_conn_proxy_read_timeout(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_event_conn_proxy_write_timeout(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_write_timeout(nxt_task_t *task, void *obj,
void *data);
static nxt_msec_t nxt_event_conn_proxy_timeout_value(nxt_event_conn_t *c,
uintptr_t data);
static void nxt_event_conn_proxy_refused(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_refused(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_reconnect_handler(nxt_thread_t *thr,
void *obj, void *data);
static void nxt_event_conn_proxy_shutdown(nxt_thread_t *thr,
static void nxt_event_conn_proxy_reconnect_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_shutdown(nxt_task_t *task,
nxt_event_conn_proxy_t *p, nxt_event_conn_t *source,
nxt_event_conn_t *sink);
static void nxt_event_conn_proxy_read_error(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_read_error(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_write_error(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_proxy_write_error(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_conn_proxy_complete(nxt_thread_t *thr,
static void nxt_event_conn_proxy_complete(nxt_task_t *task,
nxt_event_conn_proxy_t *p);
@@ -107,7 +105,7 @@ nxt_event_conn_proxy_create(nxt_event_conn_t *client)
void
nxt_event_conn_proxy(nxt_event_conn_proxy_t *p)
nxt_event_conn_proxy(nxt_task_t *task, nxt_event_conn_proxy_t *p)
{
nxt_thread_t *thr;
nxt_event_conn_t *peer;
@@ -127,7 +125,7 @@ nxt_event_conn_proxy(nxt_event_conn_proxy_t *p)
peer = p->peer;
peer->write_state = &nxt_event_conn_proxy_peer_connect_state;
nxt_event_conn_connect_enqueue(thr, peer);
nxt_event_conn_connect_enqueue(thr, task, peer);
}
/*
@@ -136,7 +134,7 @@ nxt_event_conn_proxy(nxt_event_conn_proxy_t *p)
*/
p->client->read_state = &nxt_event_conn_proxy_client_wait_state;
nxt_event_conn_read(thr, p->client);
nxt_event_conn_read(task, p->client);
}
@@ -157,7 +155,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_client_wait_state
static void
nxt_event_conn_proxy_client_buffer_alloc(nxt_thread_t *thr, void *obj,
nxt_event_conn_proxy_client_buffer_alloc(nxt_task_t *task, void *obj,
void *data)
{
nxt_buf_t *b;
@@ -167,15 +165,15 @@ nxt_event_conn_proxy_client_buffer_alloc(nxt_thread_t *thr, void *obj,
client = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy client first read fd:%d",
client->socket.fd);
nxt_debug(task, "event conn proxy client first read fd:%d",
client->socket.fd);
b = nxt_buf_mem_alloc(client->mem_pool, p->client_buffer_size,
NXT_MEM_BUF_CUTBACK | NXT_MEM_BUF_USABLE);
if (nxt_slow_path(b == NULL)) {
/* An error completion. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -203,7 +201,7 @@ nxt_event_conn_proxy_client_buffer_alloc(nxt_thread_t *thr, void *obj,
client->read_state = &nxt_event_conn_proxy_client_first_read_state;
}
nxt_event_conn_read(thr, client);
nxt_event_conn_read(task, client);
}
@@ -224,7 +222,7 @@ static const nxt_event_conn_state_t
static void
nxt_event_conn_proxy_peer_connect(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_peer_connect(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *client;
nxt_event_conn_proxy_t *p;
@@ -243,7 +241,7 @@ nxt_event_conn_proxy_peer_connect(nxt_thread_t *thr, void *obj, void *data)
p->peer->write_state = &nxt_event_conn_proxy_peer_connect_state;
nxt_event_conn_connect(thr, p->peer);
nxt_event_conn_connect(task, p->peer);
}
@@ -264,7 +262,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_peer_connect_state
static void
nxt_event_conn_proxy_connected(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_connected(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *client, *peer;
nxt_event_conn_proxy_t *p;
@@ -272,8 +270,7 @@ nxt_event_conn_proxy_connected(nxt_thread_t *thr, void *obj, void *data)
peer = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy connected fd:%d",
peer->socket.fd);
nxt_debug(task, "event conn proxy connected fd:%d", peer->socket.fd);
p->connected = 1;
@@ -285,7 +282,7 @@ nxt_event_conn_proxy_connected(nxt_thread_t *thr, void *obj, void *data)
peer->read_state = &nxt_event_conn_proxy_peer_wait_state;
peer->write_state = &nxt_event_conn_proxy_peer_write_state;
nxt_event_conn_read_enqueue(thr, peer);
nxt_event_conn_read_enqueue(task->thread, task, peer);
if (p->client_buffer != NULL) {
client = p->client;
@@ -296,7 +293,7 @@ nxt_event_conn_proxy_connected(nxt_thread_t *thr, void *obj, void *data)
* Send a client read data to the connected peer.
* Client write event: blocked.
*/
nxt_event_conn_proxy_read_process(thr, p, client, peer);
nxt_event_conn_proxy_read_process(task, p, client, peer);
}
}
@@ -318,7 +315,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_peer_wait_state
static void
nxt_event_conn_proxy_peer_read(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_peer_read(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_event_conn_t *peer;
@@ -327,15 +324,14 @@ nxt_event_conn_proxy_peer_read(nxt_thread_t *thr, void *obj, void *data)
peer = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy peer read fd:%d",
peer->socket.fd);
nxt_debug(task, "event conn proxy peer read fd:%d", peer->socket.fd);
b = nxt_buf_mem_alloc(peer->mem_pool, p->peer_buffer_size,
NXT_MEM_BUF_CUTBACK | NXT_MEM_BUF_USABLE);
if (nxt_slow_path(b == NULL)) {
/* An error completion. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -352,7 +348,7 @@ nxt_event_conn_proxy_peer_read(nxt_thread_t *thr, void *obj, void *data)
* Peer read event: waiting with possible peer_wait_timeout.
* Peer write event: blocked.
*/
nxt_event_conn_read(thr, peer);
nxt_event_conn_read(task, peer);
}
@@ -373,8 +369,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_client_read_state
static void
nxt_event_conn_proxy_client_read_ready(nxt_thread_t *thr, void *obj,
void *data)
nxt_event_conn_proxy_client_read_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *client;
nxt_event_conn_proxy_t *p;
@@ -382,10 +377,10 @@ nxt_event_conn_proxy_client_read_ready(nxt_thread_t *thr, void *obj,
client = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy client read ready fd:%d",
client->socket.fd);
nxt_debug(task, "event conn proxy client read ready fd:%d",
client->socket.fd);
nxt_event_conn_proxy_read_process(thr, p, client, p->peer);
nxt_event_conn_proxy_read_process(task, p, client, p->peer);
}
@@ -406,8 +401,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_peer_read_state
static void
nxt_event_conn_proxy_peer_read_ready(nxt_thread_t *thr, void *obj,
void *data)
nxt_event_conn_proxy_peer_read_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *peer;
nxt_event_conn_proxy_t *p;
@@ -415,24 +409,23 @@ nxt_event_conn_proxy_peer_read_ready(nxt_thread_t *thr, void *obj,
peer = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy peer read ready fd:%d",
peer->socket.fd);
nxt_debug(task, "event conn proxy peer read ready fd:%d", peer->socket.fd);
nxt_event_conn_proxy_read_process(thr, p, peer, p->client);
nxt_event_conn_proxy_read_process(task, p, peer, p->client);
}
static void
nxt_event_conn_proxy_read_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
nxt_event_conn_proxy_read_process(nxt_task_t *task, nxt_event_conn_proxy_t *p,
nxt_event_conn_t *source, nxt_event_conn_t *sink)
{
nxt_buf_t *rb, *wb;
if (sink->socket.error != 0) {
nxt_log_debug(thr->log, "event conn proxy sink fd:%d error:%d",
sink->socket.fd, sink->socket.error);
nxt_debug(task, "event conn proxy sink fd:%d error:%d",
sink->socket.fd, sink->socket.error);
nxt_event_conn_proxy_write_error(thr, sink, sink->socket.data);
nxt_event_conn_proxy_write_error(task, sink, sink->socket.data);
return;
}
@@ -447,7 +440,7 @@ nxt_event_conn_proxy_read_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
wb = nxt_buf_mem_alloc(source->mem_pool, 0, 0);
if (wb == NULL) {
/* An error completion. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -463,10 +456,9 @@ nxt_event_conn_proxy_read_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
}
if (rb->mem.start != rb->mem.end) {
nxt_thread_work_queue_push(thr, source->read_work_queue,
nxt_thread_work_queue_push(task->thread, source->read_work_queue,
nxt_event_conn_proxy_read,
source, source->socket.data,
source->socket.log);
task, source, source->socket.data);
break;
}
@@ -475,7 +467,7 @@ nxt_event_conn_proxy_read_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
}
if (p->connected) {
nxt_event_conn_write_enqueue(thr, sink);
nxt_event_conn_write_enqueue(task->thread, task, sink);
}
}
@@ -539,7 +531,7 @@ nxt_event_conn_proxy_write_add(nxt_event_conn_t *c, nxt_buf_t *b)
static void
nxt_event_conn_proxy_read(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_read(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *source, *sink;
nxt_event_conn_proxy_t *p;
@@ -547,13 +539,13 @@ nxt_event_conn_proxy_read(nxt_thread_t *thr, void *obj, void *data)
source = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy read fd:%d", source->socket.fd);
nxt_debug(task, "event conn proxy read fd:%d", source->socket.fd);
if (!source->socket.closed) {
sink = (source == p->client) ? p->peer : p->client;
if (sink->socket.error == 0) {
nxt_event_conn_read(thr, source);
nxt_event_conn_read(task, source);
}
}
}
@@ -576,8 +568,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_client_write_state
static void
nxt_event_conn_proxy_client_write_ready(nxt_thread_t *thr, void *obj,
void *data)
nxt_event_conn_proxy_client_write_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *client;
nxt_event_conn_proxy_t *p;
@@ -585,10 +576,10 @@ nxt_event_conn_proxy_client_write_ready(nxt_thread_t *thr, void *obj,
client = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy client write ready fd:%d",
client->socket.fd);
nxt_debug(task, "event conn proxy client write ready fd:%d",
client->socket.fd);
nxt_event_conn_proxy_write_process(thr, p, client, p->peer);
nxt_event_conn_proxy_write_process(task, p, client, p->peer);
}
@@ -609,7 +600,7 @@ static const nxt_event_conn_state_t nxt_event_conn_proxy_peer_write_state
static void
nxt_event_conn_proxy_peer_write_ready(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_peer_write_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *peer;
nxt_event_conn_proxy_t *p;
@@ -617,15 +608,14 @@ nxt_event_conn_proxy_peer_write_ready(nxt_thread_t *thr, void *obj, void *data)
peer = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy peer write ready fd:%d",
peer->socket.fd);
nxt_debug(task, "event conn proxy peer write ready fd:%d", peer->socket.fd);
nxt_event_conn_proxy_write_process(thr, p, peer, p->client);
nxt_event_conn_proxy_write_process(task, p, peer, p->client);
}
static void
nxt_event_conn_proxy_write_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
nxt_event_conn_proxy_write_process(nxt_task_t *task, nxt_event_conn_proxy_t *p,
nxt_event_conn_t *sink, nxt_event_conn_t *source)
{
nxt_buf_t *rb, *wb;
@@ -640,7 +630,7 @@ nxt_event_conn_proxy_write_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
sink->write = NULL;
nxt_buf_free(sink->mem_pool, wb);
nxt_event_conn_proxy_shutdown(thr, p, source, sink);
nxt_event_conn_proxy_shutdown(task, p, source, sink);
return;
}
@@ -651,7 +641,7 @@ nxt_event_conn_proxy_write_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
rb = nxt_buf_mem_alloc(sink->mem_pool, 0, 0);
if (rb == NULL) {
/* An error completion. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -666,7 +656,7 @@ nxt_event_conn_proxy_write_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
}
if (wb->mem.pos != wb->mem.free) {
nxt_event_conn_write_enqueue(thr, sink);
nxt_event_conn_write_enqueue(task->thread, task, sink);
break;
}
@@ -675,9 +665,9 @@ nxt_event_conn_proxy_write_process(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
nxt_buf_free(sink->mem_pool, wb);
}
nxt_thread_work_queue_push(thr, source->read_work_queue,
nxt_event_conn_proxy_read, source,
source->socket.data, source->socket.log);
nxt_thread_work_queue_push(task->thread, source->read_work_queue,
nxt_event_conn_proxy_read, task, source,
source->socket.data);
}
@@ -760,7 +750,7 @@ nxt_event_conn_proxy_read_add(nxt_event_conn_t *c, nxt_buf_t *b)
static void
nxt_event_conn_proxy_close(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_close(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_event_conn_t *source, *sink;
@@ -769,19 +759,19 @@ nxt_event_conn_proxy_close(nxt_thread_t *thr, void *obj, void *data)
source = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy close fd:%d", source->socket.fd);
nxt_debug(task, "event conn proxy close fd:%d", source->socket.fd);
sink = (source == p->client) ? p->peer : p->client;
if (sink->write == NULL) {
nxt_event_conn_proxy_shutdown(thr, p, source, sink);
nxt_event_conn_proxy_shutdown(task, p, source, sink);
return;
}
b = nxt_buf_sync_alloc(source->mem_pool, 0);
if (b == NULL) {
/* An error completion. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -790,7 +780,7 @@ nxt_event_conn_proxy_close(nxt_thread_t *thr, void *obj, void *data)
static void
nxt_event_conn_proxy_error(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_event_conn_proxy_t *p;
@@ -798,14 +788,14 @@ nxt_event_conn_proxy_error(nxt_thread_t *thr, void *obj, void *data)
c = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy error fd:%d", c->socket.fd);
nxt_debug(task, "event conn proxy error fd:%d", c->socket.fd);
nxt_event_conn_proxy_close(thr, c, p);
nxt_event_conn_proxy_close(task, c, p);
}
static void
nxt_event_conn_proxy_read_timeout(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_read_timeout(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_event_timer_t *ev;
@@ -816,15 +806,14 @@ nxt_event_conn_proxy_read_timeout(nxt_thread_t *thr, void *obj, void *data)
c->socket.timedout = 1;
c->socket.closed = 1;
nxt_log_debug(thr->log, "event conn proxy read timeout fd:%d",
c->socket.fd);
nxt_debug(task, "event conn proxy read timeout fd:%d", c->socket.fd);
nxt_event_conn_proxy_close(thr, c, c->socket.data);
nxt_event_conn_proxy_close(task, c, c->socket.data);
}
static void
nxt_event_conn_proxy_write_timeout(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_write_timeout(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_event_timer_t *ev;
@@ -835,10 +824,9 @@ nxt_event_conn_proxy_write_timeout(nxt_thread_t *thr, void *obj, void *data)
c->socket.timedout = 1;
c->socket.closed = 1;
nxt_log_debug(thr->log, "event conn proxy write timeout fd:%d",
c->socket.fd);
nxt_debug(task, "event conn proxy write timeout fd:%d", c->socket.fd);
nxt_event_conn_proxy_close(thr, c, c->socket.data);
nxt_event_conn_proxy_close(task, c, c->socket.data);
}
@@ -857,7 +845,7 @@ nxt_event_conn_proxy_timeout_value(nxt_event_conn_t *c, uintptr_t data)
static void
nxt_event_conn_proxy_refused(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_refused(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *peer;
nxt_event_conn_proxy_t *p;
@@ -865,11 +853,11 @@ nxt_event_conn_proxy_refused(nxt_thread_t *thr, void *obj, void *data)
peer = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy refused fd:%d", peer->socket.fd);
nxt_debug(task, "event conn proxy refused fd:%d", peer->socket.fd);
if (p->retries == 0) {
/* An error completion. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -882,13 +870,13 @@ nxt_event_conn_proxy_refused(nxt_thread_t *thr, void *obj, void *data)
p->delayed = 1;
peer->write_timer.handler = nxt_event_conn_proxy_reconnect_handler;
nxt_event_timer_add(thr->engine, &peer->write_timer, p->reconnect_timeout);
nxt_event_timer_add(task->thread->engine, &peer->write_timer,
p->reconnect_timeout);
}
static void
nxt_event_conn_proxy_reconnect_handler(nxt_thread_t *thr, void *obj,
void *data)
nxt_event_conn_proxy_reconnect_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *peer;
nxt_event_timer_t *ev;
@@ -896,13 +884,13 @@ nxt_event_conn_proxy_reconnect_handler(nxt_thread_t *thr, void *obj,
ev = obj;
nxt_log_debug(thr->log, "event conn proxy reconnect timer");
nxt_debug(task, "event conn proxy reconnect timer");
peer = nxt_event_write_timer_conn(ev);
p = peer->socket.data;
if (p->client->socket.closed) {
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -913,27 +901,27 @@ nxt_event_conn_proxy_reconnect_handler(nxt_thread_t *thr, void *obj,
* Peer read event: disabled.
* Peer write event: waiting for connection with connect_timeout.
*/
nxt_event_conn_connect(thr, peer);
nxt_event_conn_connect(task, peer);
}
static void
nxt_event_conn_proxy_shutdown(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
nxt_event_conn_proxy_shutdown(nxt_task_t *task, nxt_event_conn_proxy_t *p,
nxt_event_conn_t *source, nxt_event_conn_t *sink)
{
nxt_buf_t *b;
nxt_log_debug(source->socket.log,
"event conn proxy shutdown source fd:%d cl:%d err:%d",
source->socket.fd, source->socket.closed,
source->socket.error);
nxt_debug(source->socket.task,
"event conn proxy shutdown source fd:%d cl:%d err:%d",
source->socket.fd, source->socket.closed,
source->socket.error);
nxt_log_debug(sink->socket.log,
"event conn proxy shutdown sink fd:%d cl:%d err:%d",
sink->socket.fd, sink->socket.closed, sink->socket.error);
nxt_debug(sink->socket.task,
"event conn proxy shutdown sink fd:%d cl:%d err:%d",
sink->socket.fd, sink->socket.closed, sink->socket.error);
if (!p->connected || p->delayed) {
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -943,7 +931,7 @@ nxt_event_conn_proxy_shutdown(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
* remote side so the shutdown() syscall is surplus
* since the close() syscall also sends FIN.
*/
nxt_event_conn_close(thr, sink);
nxt_event_conn_close(task, sink);
} else {
nxt_socket_shutdown(sink->socket.fd, SHUT_WR);
@@ -953,7 +941,7 @@ nxt_event_conn_proxy_shutdown(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
|| (sink->socket.closed && source->write == NULL))
{
/* The opposite direction also has been already closed. */
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
return;
}
@@ -964,7 +952,7 @@ nxt_event_conn_proxy_shutdown(nxt_thread_t *thr, nxt_event_conn_proxy_t *p,
static void
nxt_event_conn_proxy_read_error(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_read_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_event_conn_proxy_t *p;
@@ -972,14 +960,14 @@ nxt_event_conn_proxy_read_error(nxt_thread_t *thr, void *obj, void *data)
c = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy read error fd:%d", c->socket.fd);
nxt_debug(task, "event conn proxy read error fd:%d", c->socket.fd);
nxt_event_conn_proxy_close(thr, c, p);
nxt_event_conn_proxy_close(task, c, p);
}
static void
nxt_event_conn_proxy_write_error(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_proxy_write_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *source, *sink;
nxt_event_conn_proxy_t *p;
@@ -987,48 +975,47 @@ nxt_event_conn_proxy_write_error(nxt_thread_t *thr, void *obj, void *data)
sink = obj;
p = data;
nxt_log_debug(thr->log, "event conn proxy write error fd:%d",
sink->socket.fd);
nxt_debug(task, "event conn proxy write error fd:%d", sink->socket.fd);
/* Clear data for the direction sink. */
sink->write = NULL;
/* Block the direction source. */
source = (sink == p->client) ? p->peer : p->client;
nxt_event_fd_block_read(thr->engine, &source->socket);
nxt_event_fd_block_read(task->thread->engine, &source->socket);
if (source->write == NULL) {
/*
* There is no data for the opposite direction and
* the next read from the sink will most probably fail.
*/
nxt_event_conn_proxy_complete(thr, p);
nxt_event_conn_proxy_complete(task, p);
}
}
static void
nxt_event_conn_proxy_complete(nxt_thread_t *thr, nxt_event_conn_proxy_t *p)
nxt_event_conn_proxy_complete(nxt_task_t *task, nxt_event_conn_proxy_t *p)
{
nxt_log_debug(p->client->socket.log, "event conn proxy complete %d:%d",
p->client->socket.fd, p->peer->socket.fd);
nxt_debug(p->client->socket.task, "event conn proxy complete %d:%d",
p->client->socket.fd, p->peer->socket.fd);
if (p->client->socket.fd != -1) {
nxt_event_conn_close(thr, p->client);
nxt_event_conn_close(task, p->client);
}
if (p->peer->socket.fd != -1) {
nxt_event_conn_close(thr, p->peer);
nxt_event_conn_close(task, p->peer);
} else if (p->delayed) {
nxt_thread_work_queue_drop(thr, &p->peer->write_timer);
nxt_thread_work_queue_drop(task->thread, &p->peer->write_timer);
nxt_queue_remove(&p->peer->link);
nxt_event_timer_delete(thr->engine, &p->peer->write_timer);
nxt_event_timer_delete(task->thread->engine, &p->peer->write_timer);
}
nxt_mem_free(p->client->mem_pool, p->client_buffer);
nxt_mem_free(p->client->mem_pool, p->peer_buffer);
p->completion_handler(thr, p, NULL);
p->completion_handler(task, p, NULL);
}

48
src/nxt_event_conn_read.c
View File

@@ -8,43 +8,46 @@
void
nxt_event_conn_read(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_conn_read(nxt_task_t *task, nxt_event_conn_t *c)
{
nxt_work_queue_t *wq;
nxt_work_handler_t handler;
handler = c->io->read;
if (thr->engine->batch != 0) {
if (task->thread->engine->batch != 0) {
wq = &thr->engine->read_work_queue;
wq = &task->thread->engine->read_work_queue;
c->socket.read_work_queue = wq;
nxt_thread_work_queue_add(thr, wq, handler, c, c->socket.data,
c->socket.log);
nxt_thread_work_queue_add(task->thread, wq, handler, task, c,
c->socket.data);
return;
}
handler(thr, c, c->socket.data);
handler(task, c, c->socket.data);
}
void
nxt_event_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_io_read(nxt_task_t *task, void *obj, void *data)
{
ssize_t n;
nxt_buf_t *b;
nxt_bool_t batch;
nxt_event_conn_t *c;
nxt_event_engine_t *engine;
nxt_work_handler_t handler;
const nxt_event_conn_state_t *state;
c = obj;
nxt_log_debug(thr->log, "event conn read fd:%d rdy:%d cl:%d",
c->socket.fd, c->socket.read_ready, c->socket.closed);
nxt_debug(task, "event conn read fd:%d rdy:%d cl:%d",
c->socket.fd, c->socket.read_ready, c->socket.closed);
batch = (thr->engine->batch != 0);
engine = task->thread->engine;
batch = (engine->batch != 0);
state = c->read_state;
if (c->socket.read_ready) {
@@ -83,7 +86,7 @@ nxt_event_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
}
if (n != NXT_AGAIN) {
nxt_event_fd_block_read(thr->engine, &c->socket);
nxt_event_fd_block_read(engine, &c->socket);
nxt_event_timer_disable(&c->read_timer);
if (n == 0) {
@@ -109,10 +112,10 @@ nxt_event_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
|| nxt_event_fd_is_disabled(c->socket.read))
{
/* Timer may be set or reset. */
nxt_event_conn_timer(thr->engine, c, state, &c->read_timer);
nxt_event_conn_timer(engine, c, state, &c->read_timer);
if (nxt_event_fd_is_disabled(c->socket.read)) {
nxt_event_fd_enable_read(thr->engine, &c->socket);
nxt_event_fd_enable_read(engine, &c->socket);
}
}
@@ -120,7 +123,7 @@ nxt_event_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
ready:
nxt_event_fd_block_read(thr->engine, &c->socket);
nxt_event_fd_block_read(engine, &c->socket);
if (state->autoreset_timer) {
nxt_event_timer_disable(&c->read_timer);
@@ -131,10 +134,10 @@ ready:
done:
if (batch) {
nxt_thread_work_queue_add(thr, c->read_work_queue, handler,
c, data, thr->log);
nxt_thread_work_queue_add(task->thread, c->read_work_queue, handler,
task, c, data);
} else {
handler(thr, c, data);
handler(task, c, data);
}
}
@@ -165,8 +168,7 @@ nxt_event_conn_io_recvbuf(nxt_event_conn_t *c, nxt_buf_t *b)
err = (n == -1) ? nxt_socket_errno : 0;
nxt_log_debug(c->socket.log, "readv(%d, %ui): %z",
c->socket.fd, niov, n);
nxt_debug(c->socket.task, "readv(%d, %ui): %z", c->socket.fd, niov, n);
if (n > 0) {
if ((size_t) n < rb.size) {
@@ -187,12 +189,12 @@ nxt_event_conn_io_recvbuf(nxt_event_conn_t *c, nxt_buf_t *b)
switch (err) {
case NXT_EAGAIN:
nxt_log_debug(c->socket.log, "readv() %E", err);
nxt_debug(c->socket.task, "readv() %E", err);
c->socket.read_ready = 0;
return NXT_AGAIN;
case NXT_EINTR:
nxt_log_debug(c->socket.log, "readv() %E", err);
nxt_debug(c->socket.task, "readv() %E", err);
continue;
default:
@@ -218,8 +220,8 @@ nxt_event_conn_io_recv(nxt_event_conn_t *c, void *buf, size_t size,
err = (n == -1) ? nxt_socket_errno : 0;
nxt_log_debug(c->socket.log, "recv(%d, %p, %uz, 0x%ui): %z",
c->socket.fd, buf, size, flags, n);
nxt_debug(c->socket.task, "recv(%d, %p, %uz, 0x%ui): %z",
c->socket.fd, buf, size, flags, n);
if (n > 0) {
if ((size_t) n < size) {

78
src/nxt_event_conn_write.c
View File

@@ -11,38 +11,41 @@ static void nxt_event_conn_average_rate_update(nxt_event_write_rate_t *rate,
size_t sent, nxt_msec_t now);
NXT_LIB_UNIT_TEST_STATIC double
nxt_event_conn_exponential_approximation(double n);
static void nxt_event_conn_write_timer_handler(nxt_thread_t *thr, void *obj,
static void nxt_event_conn_write_timer_handler(nxt_task_t *task, void *obj,
void *data);
void
nxt_event_conn_write(nxt_thread_t *thr, nxt_event_conn_t *c)
nxt_event_conn_write(nxt_task_t *task, nxt_event_conn_t *c)
{
if (thr->engine->batch != 0) {
nxt_event_conn_write_enqueue(thr, c);
if (task->thread->engine->batch != 0) {
nxt_event_conn_write_enqueue(task->thread, task, c);
} else {
c->io->write(thr, c, c->socket.data);
c->io->write(task, c, c->socket.data);
}
}
void
nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_io_write(nxt_task_t *task, void *obj, void *data)
{
size_t sent, limit;
ssize_t ret;
nxt_buf_t *b;
nxt_event_conn_t *c;
size_t sent, limit;
ssize_t ret;
nxt_buf_t *b;
nxt_event_conn_t *c;
nxt_event_engine_t *engine;
c = obj;
nxt_log_debug(thr->log, "event conn write fd:%d", c->socket.fd);
nxt_debug(task, "event conn write fd:%d", c->socket.fd);
if (!c->socket.write_ready || c->delayed || c->write == NULL) {
return;
}
engine = task->thread->engine;
c->socket.write_handler = nxt_event_conn_io_write;
c->socket.error_handler = c->write_state->error_handler;
@@ -54,7 +57,7 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
while (limit != 0) {
ret = c->io->write_chunk(thr, c, b, limit);
ret = c->io->write_chunk(c, b, limit);
if (ret < 0) {
/* ret == NXT_AGAIN || ret == NXT_ERROR. */
@@ -65,7 +68,7 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
limit -= ret;
if (c->write_state->process_buffers) {
b = nxt_sendbuf_completion(thr, c->write_work_queue, b, ret);
b = nxt_sendbuf_completion(task, c->write_work_queue, b, ret);
c->write = b;
} else {
@@ -73,7 +76,7 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
}
if (b == NULL) {
nxt_event_fd_block_write(thr->engine, &c->socket);
nxt_event_fd_block_write(engine, &c->socket);
break;
}
@@ -83,7 +86,7 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
}
}
nxt_log_debug(thr->log, "event conn: %i sent:%z", ret, sent);
nxt_debug(task, "event conn: %i sent:%z", ret, sent);
if (sent != 0) {
if (c->write_state->autoreset_timer) {
@@ -92,7 +95,7 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
}
if (ret != NXT_ERROR
&& !nxt_event_conn_write_delayed(thr->engine, c, sent))
&& !nxt_event_conn_write_delayed(engine, c, sent))
{
if (limit == 0) {
/*
@@ -100,7 +103,7 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
* process other recevied events and to get new events.
*/
c->write_timer.handler = nxt_event_conn_write_timer_handler;
nxt_event_timer_add(thr->engine, &c->write_timer, 0);
nxt_event_timer_add(engine, &c->write_timer, 0);
} else if (ret == NXT_AGAIN) {
/*
@@ -110,16 +113,15 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
* can be set here because it should be set only for write
* direction.
*/
nxt_event_conn_timer(thr->engine, c, c->write_state,
&c->write_timer);
nxt_event_conn_timer(engine, c, c->write_state, &c->write_timer);
}
}
if (ret == 0 || sent != 0) {
/* "ret == 0" means a sync buffer was processed. */
c->sent += sent;
nxt_event_conn_io_handle(thr, c->write_work_queue,
c->write_state->ready_handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue,
c->write_state->ready_handler, task, c, data);
/*
* Fall through if first operations were
* successful but the last one failed.
@@ -127,10 +129,10 @@ nxt_event_conn_io_write(nxt_thread_t *thr, void *obj, void *data)
}
if (nxt_slow_path(ret == NXT_ERROR)) {
nxt_event_fd_block_write(thr->engine, &c->socket);
nxt_event_fd_block_write(engine, &c->socket);
nxt_event_conn_io_handle(thr, c->write_work_queue,
c->write_state->error_handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue,
c->write_state->error_handler, task, c, data);
}
}
@@ -284,25 +286,24 @@ nxt_event_conn_exponential_approximation(double x)
static void
nxt_event_conn_write_timer_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_event_conn_write_timer_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_event_timer_t *ev;
ev = obj;
nxt_log_debug(thr->log, "event conn conn timer");
nxt_debug(task, "event conn conn timer");
c = nxt_event_write_timer_conn(ev);
c->delayed = 0;
c->io->write(thr, c, c->socket.data);
c->io->write(task, c, c->socket.data);
}
ssize_t
nxt_event_conn_io_write_chunk(nxt_thread_t *thr, nxt_event_conn_t *c,
nxt_buf_t *b, size_t limit)
nxt_event_conn_io_write_chunk(nxt_event_conn_t *c, nxt_buf_t *b, size_t limit)
{
ssize_t ret;
@@ -311,7 +312,7 @@ nxt_event_conn_io_write_chunk(nxt_thread_t *thr, nxt_event_conn_t *c,
if ((ret == NXT_AGAIN || !c->socket.write_ready)
&& nxt_event_fd_is_disabled(c->socket.write))
{
nxt_event_fd_enable_write(thr->engine, &c->socket);
nxt_event_fd_enable_write(c->socket.task->thread->engine, &c->socket);
}
return ret;
@@ -332,7 +333,7 @@ nxt_event_conn_io_sendbuf(nxt_event_conn_t *c, nxt_buf_t *b, size_t limit)
sb.size = 0;
sb.limit = limit;
niob = nxt_sendbuf_mem_coalesce(&sb);
niob = nxt_sendbuf_mem_coalesce(c->socket.task, &sb);
if (niob == 0 && sb.sync) {
return 0;
@@ -400,8 +401,8 @@ nxt_event_conn_io_send(nxt_event_conn_t *c, void *buf, size_t size)
err = (n == -1) ? nxt_socket_errno : 0;
nxt_log_debug(c->socket.log, "send(%d, %p, %uz): %z",
c->socket.fd, buf, size, n);
nxt_debug(c->socket.task, "send(%d, %p, %uz): %z",
c->socket.fd, buf, size, n);
if (n > 0) {
return n;
@@ -412,19 +413,20 @@ nxt_event_conn_io_send(nxt_event_conn_t *c, void *buf, size_t size)
switch (err) {
case NXT_EAGAIN:
nxt_log_debug(c->socket.log, "send() %E", err);
nxt_debug(c->socket.task, "send() %E", err);
c->socket.write_ready = 0;
return NXT_AGAIN;
case NXT_EINTR:
nxt_log_debug(c->socket.log, "send() %E", err);
nxt_debug(c->socket.task, "send() %E", err);
continue;
default:
c->socket.error = err;
nxt_log_error(nxt_socket_error_level(err, c->socket.log_error),
c->socket.log, "send(%d, %p, %uz) failed %E",
c->socket.fd, buf, size, err);
nxt_log(c->socket.task,
nxt_socket_error_level(err, c->socket.log_error),
"send(%d, %p, %uz) failed %E",
c->socket.fd, buf, size, err);
return NXT_ERROR;
}
}

120
src/nxt_event_engine.c
View File

@@ -7,21 +7,20 @@
#include <nxt_main.h>
static nxt_int_t nxt_event_engine_post_init(nxt_thread_t *thr,
static nxt_int_t nxt_event_engine_post_init(nxt_event_engine_t *engine);
static nxt_int_t nxt_event_engine_signal_pipe_create(
nxt_event_engine_t *engine);
static nxt_int_t nxt_event_engine_signal_pipe_create(nxt_thread_t *thr,
nxt_event_engine_t *engine);
static void nxt_event_engine_signal_pipe_close(nxt_thread_t *thr, void *obj,
static void nxt_event_engine_signal_pipe_close(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_engine_signal_pipe(nxt_thread_t *thr, void *obj,
static void nxt_event_engine_signal_pipe(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_engine_post_handler(nxt_thread_t *thr, void *obj,
static void nxt_event_engine_post_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_engine_signal_pipe_error(nxt_thread_t *thr, void *obj,
static void nxt_event_engine_signal_pipe_error(nxt_task_t *task, void *obj,
void *data);
static void nxt_event_engine_signal_handler(nxt_thread_t *thr, void *obj,
static void nxt_event_engine_signal_handler(nxt_task_t *task, void *obj,
void *data);
static const nxt_event_sig_t *nxt_event_engine_signal_find(nxt_thread_t *thr,
static const nxt_event_sig_t *nxt_event_engine_signal_find(nxt_task_t *task,
nxt_uint_t signo);
@@ -37,6 +36,13 @@ nxt_event_engine_create(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
return NULL;
}
engine->task.thread = thr;
engine->task.log = thr->log;
engine->task.ident = nxt_task_next_ident();
thr->engine = engine;
thr->fiber = &engine->fibers->fiber;
engine->batch = batch;
if (flags & NXT_ENGINE_FIBERS) {
@@ -91,7 +97,7 @@ nxt_event_engine_create(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
engine->event = event_set;
if (nxt_event_engine_post_init(thr, engine) != NXT_OK) {
if (nxt_event_engine_post_init(engine) != NXT_OK) {
goto post_fail;
}
@@ -107,8 +113,7 @@ nxt_event_engine_create(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
nxt_queue_init(&engine->listen_connections);
nxt_queue_init(&engine->idle_connections);
thr->engine = engine;
thr->fiber = &engine->fibers->fiber;
engine->thread = thr;
#if !(NXT_THREADS)
@@ -140,7 +145,7 @@ fibers_fail:
static nxt_int_t
nxt_event_engine_post_init(nxt_thread_t *thr, nxt_event_engine_t *engine)
nxt_event_engine_post_init(nxt_event_engine_t *engine)
{
if (engine->event->enable_post != NULL) {
return engine->event->enable_post(engine->event_set,
@@ -157,7 +162,7 @@ nxt_event_engine_post_init(nxt_thread_t *thr, nxt_event_engine_t *engine)
#endif
if (nxt_event_engine_signal_pipe_create(thr, engine) != NXT_OK) {
if (nxt_event_engine_signal_pipe_create(engine) != NXT_OK) {
return NXT_ERROR;
}
@@ -166,8 +171,7 @@ nxt_event_engine_post_init(nxt_thread_t *thr, nxt_event_engine_t *engine)
static nxt_int_t
nxt_event_engine_signal_pipe_create(nxt_thread_t *thr,
nxt_event_engine_t *engine)
nxt_event_engine_signal_pipe_create(nxt_event_engine_t *engine)
{
nxt_event_engine_pipe_t *pipe;
@@ -189,9 +193,9 @@ nxt_event_engine_signal_pipe_create(nxt_thread_t *thr,
}
pipe->event.fd = pipe->fds[0];
pipe->event.read_work_queue = &thr->work_queue.main;
pipe->event.read_work_queue = &engine->task.thread->work_queue.main;
pipe->event.read_handler = nxt_event_engine_signal_pipe;
pipe->event.write_work_queue = &thr->work_queue.main;
pipe->event.write_work_queue = &engine->task.thread->work_queue.main;
pipe->event.error_handler = nxt_event_engine_signal_pipe_error;
pipe->event.log = &nxt_main_log;
@@ -221,7 +225,7 @@ nxt_event_engine_signal_pipe_free(nxt_event_engine_t *engine)
static void
nxt_event_engine_signal_pipe_close(nxt_thread_t *thr, void *obj, void *data)
nxt_event_engine_signal_pipe_close(nxt_task_t *task, void *obj, void *data)
{
nxt_event_engine_pipe_t *pipe;
@@ -234,11 +238,11 @@ nxt_event_engine_signal_pipe_close(nxt_thread_t *thr, void *obj, void *data)
void
nxt_event_engine_post(nxt_event_engine_t *engine, nxt_work_handler_t handler,
void *obj, void *data, nxt_log_t *log)
nxt_task_t *task, void *obj, void *data, nxt_log_t *log)
{
nxt_thread_log_debug("event engine post");
nxt_locked_work_queue_add(&engine->work_queue, handler, obj, data, log);
nxt_locked_work_queue_add(&engine->work_queue, handler, task, obj, data);
nxt_event_engine_signal(engine, 0);
}
@@ -267,7 +271,7 @@ nxt_event_engine_signal(nxt_event_engine_t *engine, nxt_uint_t signo)
static void
nxt_event_engine_signal_pipe(nxt_thread_t *thr, void *obj, void *data)
nxt_event_engine_signal_pipe(nxt_task_t *task, void *obj, void *data)
{
int i, n;
u_char signo;
@@ -278,7 +282,7 @@ nxt_event_engine_signal_pipe(nxt_thread_t *thr, void *obj, void *data)
ev = obj;
nxt_log_debug(thr->log, "engine signal pipe");
nxt_debug(task, "engine signal pipe");
post = 0;
@@ -288,17 +292,17 @@ nxt_event_engine_signal_pipe(nxt_thread_t *thr, void *obj, void *data)
for (i = 0; i < n; i++) {
signo = buf[i];
nxt_log_debug(thr->log, "engine pipe signo:%d", signo);
nxt_debug(task, "engine pipe signo:%d", signo);
if (signo == 0) {
/* A post should be processed only once. */
post = 1;
} else {
sigev = nxt_event_engine_signal_find(thr, signo);
sigev = nxt_event_engine_signal_find(task, signo);
if (nxt_fast_path(sigev != NULL)) {
sigev->handler(thr, (void *) (uintptr_t) signo,
sigev->handler(task, (void *) (uintptr_t) signo,
(void *) sigev->name);
}
}
@@ -307,70 +311,77 @@ nxt_event_engine_signal_pipe(nxt_thread_t *thr, void *obj, void *data)
} while (n == sizeof(buf));
if (post) {
nxt_event_engine_post_handler(thr, NULL, NULL);
nxt_event_engine_post_handler(task, NULL, NULL);
}
}
static void
nxt_event_engine_post_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_event_engine_post_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_locked_work_queue_move(thr, &thr->engine->work_queue,
&thr->work_queue.main);
nxt_thread_t *thread;
thread = task->thread;
nxt_locked_work_queue_move(thread, &thread->engine->work_queue,
&thread->work_queue.main);
}
static void
nxt_event_engine_signal_pipe_error(nxt_thread_t *thr, void *obj, void *data)
nxt_event_engine_signal_pipe_error(nxt_task_t *task, void *obj, void *data)
{
nxt_event_fd_t *ev;
nxt_event_engine_t *engine;
ev = obj;
engine = task->thread->engine;
nxt_log_alert(ev->log, "engine pipe(%FD:%FD) event error",
thr->engine->pipe->fds[0], thr->engine->pipe->fds[1]);
nxt_log(task, NXT_LOG_CRIT, "engine pipe(%FD:%FD) event error",
engine->pipe->fds[0], engine->pipe->fds[1]);
nxt_event_fd_close(thr->engine, &thr->engine->pipe->event);
nxt_pipe_close(thr->engine->pipe->fds);
nxt_event_fd_close(engine, &engine->pipe->event);
nxt_pipe_close(engine->pipe->fds);
}
static void
nxt_event_engine_signal_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_event_engine_signal_handler(nxt_task_t *task, void *obj, void *data)
{
uintptr_t signo;
const nxt_event_sig_t *sigev;
signo = (uintptr_t) obj;
sigev = nxt_event_engine_signal_find(thr, signo);
sigev = nxt_event_engine_signal_find(task, signo);
if (nxt_fast_path(sigev != NULL)) {
sigev->handler(thr, (void *) (uintptr_t) signo, (void *) sigev->name);
sigev->handler(task, (void *) (uintptr_t) signo, (void *) sigev->name);
}
}
static const nxt_event_sig_t *
nxt_event_engine_signal_find(nxt_thread_t *thr, nxt_uint_t signo)
nxt_event_engine_signal_find(nxt_task_t *task, nxt_uint_t signo)
{
const nxt_event_sig_t *sigev;
for (sigev = thr->engine->signals->sigev; sigev->signo != 0; sigev++) {
for (sigev = task->thread->engine->signals->sigev;
sigev->signo != 0;
sigev++)
{
if (signo == (nxt_uint_t) sigev->signo) {
return sigev;
}
}
nxt_log_alert(thr->log, "signal %ui handler not found", signo);
nxt_log(task, NXT_LOG_CRIT, "signal %ui handler not found", signo);
return NULL;
}
nxt_int_t
nxt_event_engine_change(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
nxt_uint_t batch)
nxt_event_engine_change(nxt_thread_t *thr, nxt_task_t *task,
const nxt_event_set_ops_t *event_set, nxt_uint_t batch)
{
nxt_uint_t events;
nxt_event_engine_t *engine;
@@ -389,7 +400,7 @@ nxt_event_engine_change(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
* Add to thread main work queue the signal events possibly
* received before the blocking signal processing.
*/
nxt_event_engine_signal_pipe(thr, &engine->pipe->event, NULL);
nxt_event_engine_signal_pipe(task, &engine->pipe->event, NULL);
}
if (engine->pipe != NULL && event_set->enable_post != NULL) {
@@ -399,7 +410,7 @@ nxt_event_engine_change(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
*/
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_event_engine_signal_pipe_close,
engine->pipe, NULL, &nxt_main_log);
&engine->task, engine->pipe, NULL);
engine->pipe = NULL;
}
@@ -415,7 +426,7 @@ nxt_event_engine_change(nxt_thread_t *thr, const nxt_event_set_ops_t *event_set,
engine->event = event_set;
if (nxt_event_engine_post_init(thr, engine) != NXT_OK) {
if (nxt_event_engine_post_init(engine) != NXT_OK) {
return NXT_ERROR;
}
@@ -459,6 +470,7 @@ void
nxt_event_engine_start(nxt_event_engine_t *engine)
{
void *obj, *data;
nxt_task_t *task;
nxt_msec_t timeout, now;
nxt_thread_t *thr;
nxt_work_handler_t handler;
@@ -478,25 +490,25 @@ nxt_event_engine_start(nxt_event_engine_t *engine)
for ( ;; ) {
for ( ;; ) {
handler = nxt_thread_work_queue_pop(thr, &obj, &data, &thr->log);
handler = nxt_thread_work_queue_pop(thr, &task, &obj, &data);
if (handler == NULL) {
break;
}
handler(thr, obj, data);
handler(task, obj, data);
thr->log = &nxt_main_log;
}
for ( ;; ) {
handler = nxt_thread_last_work_queue_pop(thr, &obj, &data,
&thr->log);
handler = nxt_thread_last_work_queue_pop(thr, &task, &obj, &data);
if (handler == NULL) {
break;
}
handler(thr, obj, data);
handler(task, obj, data);
thr->log = &nxt_main_log;
}
@@ -508,7 +520,7 @@ nxt_event_engine_start(nxt_event_engine_t *engine)
timeout = nxt_event_timer_find(engine);
engine->event->poll(thr, engine->event_set, timeout);
engine->event->poll(task, engine->event_set, timeout);
/*
* Look up expired timers only if a new zero timer has been

7
src/nxt_event_engine.h
View File

@@ -23,6 +23,7 @@ struct nxt_event_engine_s {
nxt_event_timers_t timers;
nxt_task_t task;
/* The engine ID, the main engine has ID 0. */
uint32_t id;
@@ -44,6 +45,7 @@ struct nxt_event_engine_s {
nxt_event_signals_t *signals;
nxt_thread_t *thread;
nxt_fiber_main_t *fibers;
uint8_t shutdown; /* 1 bit */
@@ -61,12 +63,13 @@ NXT_EXPORT nxt_event_engine_t *nxt_event_engine_create(nxt_thread_t *thr,
const nxt_event_set_ops_t *event_set, const nxt_event_sig_t *signals,
nxt_uint_t flags, nxt_uint_t batch);
NXT_EXPORT nxt_int_t nxt_event_engine_change(nxt_thread_t *thr,
const nxt_event_set_ops_t *event_set, nxt_uint_t batch);
nxt_task_t *task, const nxt_event_set_ops_t *event_set, nxt_uint_t batch);
NXT_EXPORT void nxt_event_engine_free(nxt_event_engine_t *engine);
NXT_EXPORT void nxt_event_engine_start(nxt_event_engine_t *engine);
NXT_EXPORT void nxt_event_engine_post(nxt_event_engine_t *engine,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log);
nxt_work_handler_t handler, nxt_task_t *task, void *obj, void *data,
nxt_log_t *log);
NXT_EXPORT void nxt_event_engine_signal(nxt_event_engine_t *engine,
nxt_uint_t signo);

2
src/nxt_event_fd.h
View File

@@ -97,6 +97,8 @@ struct nxt_event_fd_s {
int32_t kq_available;
#endif
nxt_task_t *task;
nxt_work_queue_t *read_work_queue;
nxt_work_handler_t read_handler;
nxt_work_queue_t *write_work_queue;

1
src/nxt_event_file.h
View File

@@ -11,6 +11,7 @@ typedef struct {
void *data;
nxt_file_t *file;
nxt_work_handler_t handler;
nxt_task_t *task;
} nxt_event_file_t;

2
src/nxt_event_set.h
View File

@@ -163,7 +163,7 @@ typedef struct {
nxt_uint_t signo);
/* Poll an event set for new event notifications. */
void (*poll)(nxt_thread_t *thr,
void (*poll)(nxt_task_t *task,
nxt_event_set_t *event_set,
nxt_msec_t timeout);

6
src/nxt_event_timer.c
View File

@@ -141,8 +141,8 @@ nxt_event_timer_change(nxt_event_timers_t *timers, nxt_event_timer_t *ev,
void
nxt_event_timer_disable(nxt_event_timer_t *ev)
{
nxt_log_debug(ev->log, "event timer disable: %D: %d:%M",
ev->ident, ev->state, ev->time);
nxt_debug(ev->task, "event timer disable: %D: %d:%M",
ev->ident, ev->state, ev->time);
ev->state = NXT_EVENT_TIMER_DISABLED;
}
@@ -314,7 +314,7 @@ nxt_event_timer_expire(nxt_thread_t *thr, nxt_msec_t now)
ev->state = NXT_EVENT_TIMER_DISABLED;
nxt_thread_work_queue_add(thr, ev->work_queue, ev->handler,
ev, NULL, ev->log);
ev->task, ev, NULL);
}
}
}

5
src/nxt_event_timer.h
View File

@@ -15,11 +15,11 @@
#if (NXT_DEBUG)
#define NXT_EVENT_TIMER { NXT_RBTREE_NODE_INIT, 0, 0, 0, \
NULL, NULL, NULL, -1 }
NULL, NULL, NULL, NULL, -1 }
#else
#define NXT_EVENT_TIMER { NXT_RBTREE_NODE_INIT, 0, 0, 0, \
NULL, NULL, NULL }
NULL, NULL, NULL, NULL }
#endif
@@ -34,6 +34,7 @@ typedef struct {
nxt_work_queue_t *work_queue;
nxt_work_handler_t handler;
nxt_task_t *task;
nxt_log_t *log;
#if (NXT_DEBUG)
int32_t ident;

10
src/nxt_fastcgi_record_parse.c
View File

@@ -17,13 +17,13 @@ static nxt_int_t nxt_fastcgi_buffer(nxt_fastcgi_parse_t *fp, nxt_buf_t ***tail,
void
nxt_fastcgi_record_parse(nxt_fastcgi_parse_t *fp, nxt_buf_t *in)
nxt_fastcgi_record_parse(nxt_task_t *task, nxt_fastcgi_parse_t *fp,
nxt_buf_t *in)
{
u_char ch;
nxt_int_t ret, stream;
nxt_buf_t *b, *nb, **tail[2];
const char *msg;
nxt_thread_t *thr;
enum {
sw_fastcgi_version = 0,
sw_fastcgi_type,
@@ -208,9 +208,9 @@ nxt_fastcgi_record_parse(nxt_fastcgi_parse_t *fp, nxt_buf_t *in)
if (b->retain == 0) {
/* No record data was found in a buffer. */
thr = nxt_thread();
nxt_thread_current_work_queue_add(thr, b->completion_handler,
b, b->parent, thr->log);
nxt_thread_current_work_queue_add(task->thread,
b->completion_handler,
task, b, b->parent);
}
next:

124
src/nxt_fastcgi_source.c
View File

@@ -49,16 +49,17 @@ static nxt_buf_t *nxt_fastcgi_request_create(nxt_fastcgi_source_t *fs);
static nxt_int_t nxt_fastcgi_next_param(nxt_fastcgi_source_t *fs,
nxt_fastcgi_param_t *param);
static void nxt_fastcgi_source_record_filter(nxt_thread_t *thr, void *obj,
static void nxt_fastcgi_source_record_filter(nxt_task_t *task, void *obj,
void *data);
static void nxt_fastcgi_source_record_error(nxt_thread_t *thr, void *obj,
static void nxt_fastcgi_source_record_error(nxt_task_t *task, void *obj,
void *data);
static void nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj,
static void nxt_fastcgi_source_header_filter(nxt_task_t *task, void *obj,
void *data);
static void nxt_fastcgi_source_sync_buffer(nxt_thread_t *thr,
static void nxt_fastcgi_source_sync_buffer(nxt_task_t *task,
nxt_fastcgi_source_t *fs, nxt_buf_t *b);
static nxt_int_t nxt_fastcgi_source_header_process(nxt_fastcgi_source_t *fs);
static nxt_int_t nxt_fastcgi_source_header_process(nxt_task_t *task,
nxt_fastcgi_source_t *fs);
static nxt_int_t nxt_fastcgi_source_status(nxt_upstream_source_t *us,
nxt_name_value_t *nv);
static nxt_int_t nxt_fastcgi_source_content_length(nxt_upstream_source_t *us,
@@ -66,11 +67,12 @@ static nxt_int_t nxt_fastcgi_source_content_length(nxt_upstream_source_t *us,
static void nxt_fastcgi_source_header_ready(nxt_fastcgi_source_t *fs,
nxt_buf_t *b);
static void nxt_fastcgi_source_body_filter(nxt_thread_t *thr, void *obj,
static void nxt_fastcgi_source_body_filter(nxt_task_t *task, void *obj,
void *data);
static nxt_buf_t *nxt_fastcgi_source_last_buf(nxt_fastcgi_parse_t *fp);
static void nxt_fastcgi_source_error(nxt_stream_source_t *stream);
static void nxt_fastcgi_source_fail(nxt_fastcgi_source_t *fs);
static void nxt_fastcgi_source_error(nxt_task_t *task,
nxt_stream_source_t *stream);
static void nxt_fastcgi_source_fail(nxt_task_t *task, nxt_fastcgi_source_t *fs);
/*
@@ -117,7 +119,7 @@ static const uint8_t nxt_fastcgi_stdin_record[] = {
void
nxt_fastcgi_source_handler(nxt_upstream_source_t *us,
nxt_fastcgi_source_handler(nxt_task_t *task, nxt_upstream_source_t *us,
nxt_fastcgi_source_request_create_t request_create)
{
nxt_stream_source_t *stream;
@@ -181,13 +183,13 @@ nxt_fastcgi_source_handler(nxt_upstream_source_t *us,
nxt_memzero(&fs->u.header, sizeof(nxt_http_split_header_parse_t));
fs->u.header.mem_pool = fs->upstream->buffers.mem_pool;
nxt_stream_source_connect(stream);
nxt_stream_source_connect(task, stream);
return;
}
fail:
nxt_fastcgi_source_fail(fs);
nxt_fastcgi_source_fail(task, fs);
}
@@ -383,7 +385,7 @@ nxt_fastcgi_next_param(nxt_fastcgi_source_t *fs, nxt_fastcgi_param_t *param)
static void
nxt_fastcgi_source_record_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_fastcgi_source_record_filter(nxt_task_t *task, void *obj, void *data)
{
size_t size;
u_char *p;
@@ -394,18 +396,18 @@ nxt_fastcgi_source_record_filter(nxt_thread_t *thr, void *obj, void *data)
fsr = obj;
in = data;
nxt_log_debug(thr->log, "fastcgi source record filter");
nxt_debug(task, "fastcgi source record filter");
if (nxt_slow_path(fsr->parse.done)) {
return;
}
nxt_fastcgi_record_parse(&fsr->parse, in);
nxt_fastcgi_record_parse(task, &fsr->parse, in);
fs = nxt_container_of(fsr, nxt_fastcgi_source_t, record);
if (fsr->parse.error) {
nxt_fastcgi_source_fail(fs);
nxt_fastcgi_source_fail(task, fs);
return;
}
@@ -413,8 +415,9 @@ nxt_fastcgi_source_record_filter(nxt_thread_t *thr, void *obj, void *data)
/*
* Output all parsed before a FastCGI record error and close upstream.
*/
nxt_thread_current_work_queue_add(thr, nxt_fastcgi_source_record_error,
fs, NULL, thr->log);
nxt_thread_current_work_queue_add(task->thread,
nxt_fastcgi_source_record_error,
task, fs, NULL);
}
/* Log FastCGI stderr output. */
@@ -430,36 +433,36 @@ nxt_fastcgi_source_record_filter(nxt_thread_t *thr, void *obj, void *data)
size = (p + 1) - b->mem.pos;
if (size != 0) {
nxt_log_error(NXT_LOG_ERR, thr->log,
"upstream sent in FastCGI stderr: \"%*s\"",
size, b->mem.pos);
nxt_log(task, NXT_LOG_ERR,
"upstream sent in FastCGI stderr: \"%*s\"",
size, b->mem.pos);
}
b->completion_handler(thr, b, b->parent);
b->completion_handler(task, b, b->parent);
}
/* Process FastCGI stdout output. */
if (fsr->parse.out[0] != NULL) {
nxt_source_filter(thr, fs->upstream->work_queue, &fsr->next,
fsr->parse.out[0]);
nxt_source_filter(task->thread, fs->upstream->work_queue, task,
&fsr->next, fsr->parse.out[0]);
}
}
static void
nxt_fastcgi_source_record_error(nxt_thread_t *thr, void *obj, void *data)
nxt_fastcgi_source_record_error(nxt_task_t *task, void *obj, void *data)
{
nxt_fastcgi_source_t *fs;
fs = obj;
nxt_fastcgi_source_fail(fs);
nxt_fastcgi_source_fail(task, fs);
}
static void
nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_fastcgi_source_header_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_int_t ret;
nxt_buf_t *b;
@@ -469,10 +472,10 @@ nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
b = data;
do {
nxt_log_debug(thr->log, "fastcgi source header filter");
nxt_debug(task, "fastcgi source header filter");
if (nxt_slow_path(nxt_buf_is_sync(b))) {
nxt_fastcgi_source_sync_buffer(thr, fs, b);
nxt_fastcgi_source_sync_buffer(task, fs, b);
return;
}
@@ -483,7 +486,7 @@ nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
break;
}
ret = nxt_fastcgi_source_header_process(fs);
ret = nxt_fastcgi_source_header_process(task, fs);
if (nxt_slow_path(ret != NXT_OK)) {
break;
@@ -491,7 +494,7 @@ nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
}
if (nxt_fast_path(ret == NXT_DONE)) {
nxt_log_debug(thr->log, "fastcgi source header done");
nxt_debug(task, "fastcgi source header done");
nxt_fastcgi_source_header_ready(fs, b);
return;
}
@@ -500,16 +503,16 @@ nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
if (ret != NXT_ERROR) {
/* n == NXT_DECLINED: "\r" is not followed by "\n" */
nxt_log_error(NXT_LOG_ERR, thr->log,
"upstream sent invalid header line: \"%*s\\r...\"",
fs->u.header.parse.header_end
- fs->u.header.parse.header_name_start,
fs->u.header.parse.header_name_start);
nxt_log(task, NXT_LOG_ERR,
"upstream sent invalid header line: \"%*s\\r...\"",
fs->u.header.parse.header_end
- fs->u.header.parse.header_name_start,
fs->u.header.parse.header_name_start);
}
/* ret == NXT_ERROR */
nxt_fastcgi_source_fail(fs);
nxt_fastcgi_source_fail(task, fs);
return;
}
@@ -520,45 +523,41 @@ nxt_fastcgi_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
static void
nxt_fastcgi_source_sync_buffer(nxt_thread_t *thr, nxt_fastcgi_source_t *fs,
nxt_fastcgi_source_sync_buffer(nxt_task_t *task, nxt_fastcgi_source_t *fs,
nxt_buf_t *b)
{
if (nxt_buf_is_last(b)) {
nxt_log_error(NXT_LOG_ERR, thr->log,
"upstream closed prematurely connection");
nxt_log(task, NXT_LOG_ERR, "upstream closed prematurely connection");
} else {
nxt_log_error(NXT_LOG_ERR, thr->log, "%ui buffers %uz each are not "
"enough to process upstream response header",
fs->upstream->buffers.max,
fs->upstream->buffers.size);
nxt_log(task, NXT_LOG_ERR, "%ui buffers %uz each are not "
"enough to process upstream response header",
fs->upstream->buffers.max, fs->upstream->buffers.size);
}
/* The stream source sends only the last and the nobuf sync buffer. */
nxt_fastcgi_source_fail(fs);
nxt_fastcgi_source_fail(task, fs);
}
static nxt_int_t
nxt_fastcgi_source_header_process(nxt_fastcgi_source_t *fs)
nxt_fastcgi_source_header_process(nxt_task_t *task, nxt_fastcgi_source_t *fs)
{
size_t len;
nxt_thread_t *thr;
nxt_name_value_t *nv;
nxt_lvlhsh_query_t lhq;
nxt_http_header_parse_t *hp;
nxt_upstream_name_value_t *unv;
thr = nxt_thread();
hp = &fs->u.header.parse;
len = hp->header_name_end - hp->header_name_start;
if (len > 255) {
nxt_log_error(NXT_LOG_INFO, thr->log,
"upstream sent too long header field name: \"%*s\"",
len, hp->header_name_start);
nxt_log(task, NXT_LOG_INFO,
"upstream sent too long header field name: \"%*s\"",
len, hp->header_name_start);
return NXT_ERROR;
}
@@ -574,8 +573,8 @@ nxt_fastcgi_source_header_process(nxt_fastcgi_source_t *fs)
nv->value_len = hp->header_end - hp->header_start;
nv->value_start = hp->header_start;
nxt_log_debug(thr->log, "http header: \"%*s: %*s\"",
nv->name_len, nv->name_start, nv->value_len, nv->value_start);
nxt_debug(task, "http header: \"%*s: %*s\"",
nv->name_len, nv->name_start, nv->value_len, nv->value_start);
lhq.key_hash = nv->hash;
lhq.key.len = nv->name_len;
@@ -682,7 +681,7 @@ nxt_fastcgi_source_header_ready(nxt_fastcgi_source_t *fs, nxt_buf_t *b)
*/
static void
nxt_fastcgi_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_fastcgi_source_body_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b, *in;
nxt_fastcgi_source_t *fs;
@@ -690,7 +689,7 @@ nxt_fastcgi_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
fs = obj;
in = data;
nxt_log_debug(thr->log, "fastcgi source body filter");
nxt_debug(task, "fastcgi source body filter");
for (b = in; b != NULL; b = b->next) {
@@ -701,7 +700,8 @@ nxt_fastcgi_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
}
if (fs->next != NULL) {
nxt_source_filter(thr, fs->upstream->work_queue, fs->next, in);
nxt_source_filter(task->thread, fs->upstream->work_queue, task,
fs->next, in);
return;
}
@@ -729,7 +729,7 @@ nxt_fastcgi_source_last_buf(nxt_fastcgi_parse_t *fp)
static void
nxt_fastcgi_source_error(nxt_stream_source_t *stream)
nxt_fastcgi_source_error(nxt_task_t *task, nxt_stream_source_t *stream)
{
nxt_fastcgi_source_t *fs;
@@ -737,20 +737,16 @@ nxt_fastcgi_source_error(nxt_stream_source_t *stream)
fs = stream->upstream->protocol_source;
nxt_fastcgi_source_fail(fs);
nxt_fastcgi_source_fail(task, fs);
}
static void
nxt_fastcgi_source_fail(nxt_fastcgi_source_t *fs)
nxt_fastcgi_source_fail(nxt_task_t *task, nxt_fastcgi_source_t *fs)
{
nxt_thread_t *thr;
thr = nxt_thread();
nxt_log_debug(thr->log, "fastcgi source fail");
nxt_debug(task, "fastcgi source fail");
/* TODO: fail, next upstream, or bad gateway */
fs->upstream->state->error_handler(thr, fs, NULL);
fs->upstream->state->error_handler(task, fs, NULL);
}

6
src/nxt_fastcgi_source.h
View File

@@ -82,11 +82,13 @@ struct nxt_fastcgi_source_s {
};
NXT_EXPORT void nxt_fastcgi_source_handler(nxt_upstream_source_t *us,
NXT_EXPORT void nxt_fastcgi_source_handler(nxt_task_t *task,
nxt_upstream_source_t *us,
nxt_fastcgi_source_request_create_t request_create);
NXT_EXPORT nxt_int_t nxt_fastcgi_source_hash_create(nxt_mem_pool_t *mp,
nxt_lvlhsh_t *lh);
void nxt_fastcgi_record_parse(nxt_fastcgi_parse_t *fp, nxt_buf_t *in);
void nxt_fastcgi_record_parse(nxt_task_t *task, nxt_fastcgi_parse_t *fp,
nxt_buf_t *in);
#endif /* _NXT_FASTCGI_SOURCE_H_INCLUDED_ */

197
src/nxt_fiber.c
View File

@@ -7,19 +7,17 @@
#include <nxt_main.h>
static char *nxt_fiber_create_stack(nxt_fiber_t *fib);
static char *nxt_fiber_create_stack(nxt_task_t *task, nxt_fiber_t *fib);
static void nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent);
static void nxt_fiber_switch_handler(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_fiber_switch(nxt_thread_t *thr, nxt_fiber_t *fib);
static void nxt_fiber_timer_handler(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_fiber_switch_handler(nxt_task_t *task, void *obj, void *data);
static void nxt_fiber_switch(nxt_task_t *task, nxt_fiber_t *fib);
static void nxt_fiber_timer_handler(nxt_task_t *task, void *obj, void *data);
#define \
nxt_fiber_enqueue(thr, fib) \
nxt_fiber_enqueue(thr, task, fib) \
nxt_thread_work_queue_add(thr, &(thr)->work_queue.main, \
nxt_fiber_switch_handler, fib, NULL, thr->log)
nxt_fiber_switch_handler, task, fib, NULL)
nxt_fiber_main_t *
@@ -32,6 +30,7 @@ nxt_fiber_main_create(nxt_event_engine_t *engine)
return NULL;
}
fm->engine = engine;
fm->stack_size = 512 * 1024 - nxt_pagesize;
fm->idle = NULL;
@@ -67,8 +66,14 @@ nxt_fiber_create(nxt_fiber_start_t start, void *data, size_t stack)
fib->data = data;
fib->main = fm;
nxt_log_debug(thr->log, "fiber create cached: %PF", fib->fid);
nxt_fiber_enqueue(thr, fib);
fib->task.thread = thr;
fib->task.log = thr->log;
fib->task.ident = nxt_task_next_ident();
nxt_debug(&fib->task, "fiber create cached: %PF", fib->fid);
nxt_fiber_enqueue(thr, &fm->engine->task, fib);
return NXT_OK;
}
@@ -85,7 +90,11 @@ nxt_fiber_create(nxt_fiber_start_t start, void *data, size_t stack)
fib->stack_size = fm->stack_size;
fib->main = fm;
fib->stack = nxt_fiber_create_stack(fib);
fib->task.thread = thr;
fib->task.log = thr->log;
fib->task.ident = nxt_task_next_ident();
fib->stack = nxt_fiber_create_stack(&fib->task, fib);
if (nxt_fast_path(fib->stack != NULL)) {
@@ -113,7 +122,7 @@ nxt_fiber_create(nxt_fiber_start_t start, void *data, size_t stack)
#if (NXT_LINUX)
static char *
nxt_fiber_create_stack(nxt_fiber_t *fib)
nxt_fiber_create_stack(nxt_task_t *task, nxt_fiber_t *fib)
{
char *s;
size_t size;
@@ -124,21 +133,24 @@ nxt_fiber_create_stack(nxt_fiber_t *fib)
MAP_PRIVATE | MAP_ANON | MAP_GROWSDOWN, -1, 0);
if (nxt_slow_path(s == MAP_FAILED)) {
nxt_thread_log_alert("fiber stack "
"mmap(%uz, MAP_PRIVATE|MAP_ANON|MAP_GROWSDOWN) failed %E",
size, nxt_errno);
nxt_log(task, NXT_LOG_CRIT, "fiber stack "
"mmap(%uz, MAP_PRIVATE|MAP_ANON|MAP_GROWSDOWN) failed %E",
size, nxt_errno);
return NULL;
}
if (nxt_slow_path(mprotect(s, nxt_pagesize, PROT_NONE) != 0)) {
nxt_thread_log_alert("fiber stack mprotect(%uz, PROT_NONE) failed %E",
size, nxt_errno);
nxt_log(task, NXT_LOG_CRIT,
"fiber stack mprotect(%uz, PROT_NONE) failed %E",
size, nxt_errno);
return NULL;
}
s += nxt_pagesize;
nxt_thread_log_debug("fiber stack mmap: %p", s);
nxt_debug(task, "fiber stack mmap: %p", s);
return s;
}
@@ -146,7 +158,7 @@ nxt_fiber_create_stack(nxt_fiber_t *fib)
#else /* Generic version. */
static char *
nxt_fiber_create_stack(nxt_fiber_t *fib)
nxt_fiber_create_stack(nxt_task_t *task, nxt_fiber_t *fib)
{
char *s;
size_t size;
@@ -156,21 +168,24 @@ nxt_fiber_create_stack(nxt_fiber_t *fib)
s = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (nxt_slow_path(s == MAP_FAILED)) {
nxt_thread_log_alert("fiber stack "
"mmap(%uz, MAP_PRIVATE|MAP_ANON) failed %E",
size, nxt_errno);
nxt_log(task, NXT_LOG_CRIT,
"fiber stack mmap(%uz, MAP_PRIVATE|MAP_ANON) failed %E",
size, nxt_errno);
return NULL;
}
if (nxt_slow_path(mprotect(s, nxt_pagesize, PROT_NONE) != 0)) {
nxt_thread_log_alert("fiber stack mprotect(%uz, PROT_NONE) failed %E",
size, nxt_errno);
nxt_log(task, NXT_LOG_CRIT,
"fiber stack mprotect(%uz, PROT_NONE) failed %E",
size, nxt_errno);
return NULL;
}
s += nxt_pagesize;
nxt_thread_log_debug("fiber stack mmap: %p", s);
nxt_debug(task, "fiber stack mmap: %p", s);
return s;
}
@@ -194,10 +209,10 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
{
ucontext_t uc;
nxt_thread_log_debug("fiber switch to stack: %p", fib->stack);
nxt_debug(&fib->task, "fiber switch to stack: %p", fib->stack);
if (nxt_slow_path(getcontext(&uc) != 0)) {
nxt_thread_log_alert("getcontext() failed");
nxt_log(&fib->task, NXT_LOG_CRIT, "getcontext() failed");
return;
}
@@ -213,35 +228,38 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
setcontext(&uc);
nxt_thread_log_alert("setcontext() failed");
nxt_log(&fib->task, NXT_LOG_CRIT, "setcontext() failed");
}
static void
nxt_fiber_trampoline(uint32_t fh, uint32_t fl, uint32_t ph, uint32_t pl)
{
jmp_buf *parent;
nxt_fiber_t *fib;
nxt_thread_t *thr;
jmp_buf *parent;
nxt_task_t *task;
nxt_fiber_t *fib;
fib = (nxt_fiber_t *) (((uintptr_t) fh << 32) + fl);
parent = (jmp_buf *) (((uintptr_t) ph << 32) + pl);
thr = nxt_thread();
task = &fib->task;
if (_setjmp(fib->jmp) == 0) {
nxt_log_debug(thr->log, "fiber return to parent stack");
nxt_debug(task, "fiber return to parent stack");
nxt_fiber_enqueue(task->thread, task, fib);
nxt_fiber_enqueue(thr, fib);
_longjmp(*parent, 1);
nxt_unreachable();
}
nxt_log_debug(thr->log, "fiber start");
nxt_debug(task, "fiber start");
fib->start(fib->data);
nxt_fiber_exit(&fib->main->fiber, NULL);
nxt_fiber_exit(task, &fib->main->fiber, NULL);
nxt_unreachable();
}
@@ -257,10 +275,10 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
{
ucontext_t uc;
nxt_thread_log_debug("fiber switch to stack: %p", fib->stack);
nxt_debug(&fib->task, "fiber switch to stack: %p", fib->stack);
if (nxt_slow_path(getcontext(&uc) != 0)) {
nxt_thread_log_alert("getcontext() failed");
nxt_log(&fib->task, NXT_LOG_CRIT, "getcontext() failed");
return;
}
@@ -275,7 +293,7 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
#if !(NXT_SOLARIS)
/* Solaris declares setcontext() as __NORETURN. */
nxt_thread_log_alert("setcontext() failed");
nxt_log(&fib->task, NXT_LOG_CRIT, "setcontext() failed");
#endif
}
@@ -283,23 +301,26 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
static void
nxt_fiber_trampoline(nxt_fiber_t *fib, jmp_buf *parent)
{
nxt_thread_t *thr;
nxt_task_t *task;
thr = nxt_thread();
task = &fib->task;
if (_setjmp(fib->jmp) == 0) {
nxt_log_debug(thr->log, "fiber return to parent stack");
nxt_debug(task, "fiber return to parent stack");
nxt_fiber_enqueue(task->thread, task, fib);
nxt_fiber_enqueue(thr, fib);
_longjmp(*parent, 1);
nxt_unreachable();
}
nxt_log_debug(thr->log, "fiber start");
nxt_debug(task, "fiber start");
fib->start(fib->data);
nxt_fiber_exit(&fib->main->fiber, NULL);
nxt_fiber_exit(task, &fib->main->fiber, NULL);
nxt_unreachable();
}
@@ -311,24 +332,26 @@ nxt_fiber_trampoline(nxt_fiber_t *fib, jmp_buf *parent)
static void
nxt_fiber_switch_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_fiber_switch_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_fiber_t *fib;
fib = obj;
nxt_fiber_switch(thr, fib);
nxt_fiber_switch(task, fib);
nxt_unreachable();
}
static void
nxt_fiber_switch(nxt_thread_t *thr, nxt_fiber_t *fib)
nxt_fiber_switch(nxt_task_t *task, nxt_fiber_t *fib)
{
nxt_log_debug(thr->log, "fiber switch: %PF", fib->fid);
nxt_debug(task, "fiber switch: %PF", fib->fid);
task->thread->fiber = fib;
thr->fiber = fib;
_longjmp(fib->jmp, 1);
nxt_unreachable();
}
@@ -341,106 +364,106 @@ nxt_fiber_self(nxt_thread_t *thr)
void
nxt_fiber_yield(void)
nxt_fiber_yield(nxt_task_t *task)
{
nxt_fiber_t *fib;
nxt_thread_t *thr;
nxt_fiber_t *fib;
thr = nxt_thread();
fib = thr->fiber;
fib = task->thread->fiber;
if (_setjmp(fib->jmp) == 0) {
nxt_log_debug(thr->log, "fiber yield");
nxt_debug(task, "fiber yield");
nxt_fiber_enqueue(task->thread, &fib->main->engine->task, fib);
nxt_fiber_switch(task, &fib->main->fiber);
nxt_fiber_enqueue(thr, fib);
nxt_fiber_switch(thr, &fib->main->fiber);
nxt_unreachable();
}
nxt_log_debug(thr->log, "fiber yield return");
nxt_debug(task, "fiber yield return");
}
void
nxt_fiber_sleep(nxt_msec_t timeout)
nxt_fiber_sleep(nxt_task_t *task, nxt_msec_t timeout)
{
nxt_fiber_t *fib;
nxt_thread_t *thr;
nxt_fiber_t *fib;
thr = nxt_thread();
fib = thr->fiber;
fib = task->thread->fiber;
fib->timer.work_queue = &thr->work_queue.main;
fib->timer.work_queue = &task->thread->work_queue.main;
fib->timer.handler = nxt_fiber_timer_handler;
fib->timer.log = &nxt_main_log;
nxt_event_timer_add(thr->engine, &fib->timer, timeout);
task = &fib->task;
nxt_event_timer_add(task->thread->engine, &fib->timer, timeout);
if (_setjmp(fib->jmp) == 0) {
nxt_log_debug(thr->log, "fiber sleep: %T", timeout);
nxt_debug(task, "fiber sleep: %T", timeout);
nxt_fiber_switch(task, &fib->main->fiber);
nxt_fiber_switch(thr, &fib->main->fiber);
nxt_unreachable();
}
nxt_log_debug(thr->log, "fiber sleep return");
nxt_debug(task, "fiber sleep return");
}
static void
nxt_fiber_timer_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_fiber_timer_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_fiber_t *fib;
nxt_event_timer_t *ev;
ev = obj;
nxt_log_debug(thr->log, "fiber timer handler");
nxt_debug(task, "fiber timer handler");
fib = nxt_event_timer_data(ev, nxt_fiber_t, timer);
nxt_fiber_switch(thr, fib);
nxt_fiber_switch(task, fib);
nxt_unreachable();
}
void
nxt_fiber_wait(void)
nxt_fiber_wait(nxt_task_t *task)
{
nxt_fiber_t *fib;
nxt_thread_t *thr;
nxt_fiber_t *fib;
thr = nxt_thread();
fib = thr->fiber;
fib = task->thread->fiber;
if (_setjmp(fib->jmp) == 0) {
nxt_log_debug(thr->log, "fiber wait");
nxt_debug(task, "fiber wait");
nxt_fiber_switch(task, &fib->main->fiber);
nxt_fiber_switch(thr, &fib->main->fiber);
nxt_unreachable();
}
nxt_log_debug(thr->log, "fiber wait return");
nxt_debug(task, "fiber wait return");
}
void
nxt_fiber_exit(nxt_fiber_t *next, void *data)
nxt_fiber_exit(nxt_task_t *task, nxt_fiber_t *next, void *data)
{
nxt_fiber_t *fib;
nxt_thread_t *thr;
nxt_fiber_t *fib;
thr = nxt_thread();
fib = thr->fiber;
fib = task->thread->fiber;
nxt_log_debug(thr->log, "fiber exit");
nxt_debug(task, "fiber exit");
/* TODO: limit idle fibers. */
fib->next = fib->main->idle;
fib->main->idle = fib;
nxt_fiber_switch(thr, next);
nxt_fiber_switch(task, next);
nxt_unreachable();
}

11
src/nxt_fiber.h
View File

@@ -27,6 +27,8 @@ struct nxt_fiber_s {
size_t stack_size;
nxt_err_t err;
nxt_task_t task;
nxt_fiber_main_t *main;
nxt_fiber_t *next;
@@ -37,6 +39,7 @@ struct nxt_fiber_s {
struct nxt_fiber_main_s {
nxt_fiber_t fiber;
nxt_fiber_t *idle;
nxt_event_engine_t *engine;
size_t stack_size;
nxt_fid_t fid;
};
@@ -44,10 +47,10 @@ struct nxt_fiber_main_s {
nxt_fiber_main_t *nxt_fiber_main_create(nxt_event_engine_t *engine);
nxt_int_t nxt_fiber_create(nxt_fiber_start_t start, void *data, size_t stack);
void nxt_fiber_yield(void);
void nxt_fiber_sleep(nxt_msec_t timeout);
void nxt_fiber_wait(void);
void nxt_fiber_exit(nxt_fiber_t *next, void *data);
void nxt_fiber_yield(nxt_task_t *task);
void nxt_fiber_sleep(nxt_task_t *task, nxt_msec_t timeout);
void nxt_fiber_wait(nxt_task_t *task);
void nxt_fiber_exit(nxt_task_t *task, nxt_fiber_t *next, void *data);
NXT_EXPORT nxt_fiber_t *nxt_fiber_self(nxt_thread_t *thr);

4
src/nxt_freebsd_sendfile.c
View File

@@ -50,7 +50,7 @@ nxt_freebsd_event_conn_io_sendfile(nxt_event_conn_t *c, nxt_buf_t *b,
sb.size = 0;
sb.limit = limit;
nhd = nxt_sendbuf_mem_coalesce(&sb);
nhd = nxt_sendbuf_mem_coalesce(c->socket.task, &sb);
if (nhd == 0 && sb.sync) {
return 0;
@@ -70,7 +70,7 @@ nxt_freebsd_event_conn_io_sendfile(nxt_event_conn_t *c, nxt_buf_t *b,
sb.iobuf = tr;
ntr = nxt_sendbuf_mem_coalesce(&sb);
ntr = nxt_sendbuf_mem_coalesce(c->socket.task, &sb);
/*
* Disposal of surplus kernel operations

10
src/nxt_http_chunk_parse.c
View File

@@ -22,12 +22,12 @@ static nxt_int_t nxt_http_chunk_buffer(nxt_http_chunk_parse_t *hcp,
nxt_buf_t *
nxt_http_chunk_parse(nxt_http_chunk_parse_t *hcp, nxt_buf_t *in)
nxt_http_chunk_parse(nxt_task_t *task, nxt_http_chunk_parse_t *hcp,
nxt_buf_t *in)
{
u_char c, ch;
nxt_int_t ret;
nxt_buf_t *b, *out, *nb, **tail;
nxt_thread_t *thr;
enum {
sw_start = 0,
sw_chunk_size,
@@ -168,9 +168,9 @@ nxt_http_chunk_parse(nxt_http_chunk_parse_t *hcp, nxt_buf_t *in)
if (b->retain == 0) {
/* No chunk data was found in a buffer. */
thr = nxt_thread();
nxt_thread_current_work_queue_add(thr, b->completion_handler,
b, b->parent, thr->log);
nxt_thread_current_work_queue_add(task->thread,
b->completion_handler,
task, b, b->parent);
}

4
src/nxt_http_parse.h
View File

@@ -72,8 +72,8 @@ typedef struct {
} nxt_http_chunk_parse_t;
NXT_EXPORT nxt_buf_t *nxt_http_chunk_parse(nxt_http_chunk_parse_t *hcp,
nxt_buf_t *in);
NXT_EXPORT nxt_buf_t *nxt_http_chunk_parse(nxt_task_t *task,
nxt_http_chunk_parse_t *hcp, nxt_buf_t *in);
#endif /* _NXT_HTTP_PARSE_H_INCLUDED_ */

140
src/nxt_http_source.c
View File

@@ -15,9 +15,9 @@ typedef struct {
static nxt_buf_t *nxt_http_source_request_create(nxt_http_source_t *hs);
static void nxt_http_source_status_filter(nxt_thread_t *thr, void *obj,
static void nxt_http_source_status_filter(nxt_task_t *task, void *obj,
void *data);
static void nxt_http_source_header_filter(nxt_thread_t *thr, void *obj,
static void nxt_http_source_header_filter(nxt_task_t *task, void *obj,
void *data);
static nxt_int_t nxt_http_source_header_line_process(nxt_http_source_t *hs);
@@ -26,24 +26,25 @@ static nxt_int_t nxt_http_source_content_length(nxt_upstream_source_t *us,
static nxt_int_t nxt_http_source_transfer_encoding(nxt_upstream_source_t *us,
nxt_name_value_t *nv);
static void nxt_http_source_header_ready(nxt_http_source_t *hs,
nxt_buf_t *rest);
static void nxt_http_source_chunk_filter(nxt_thread_t *thr, void *obj,
static void nxt_http_source_header_ready(nxt_task_t *task,
nxt_http_source_t *hs, nxt_buf_t *rest);
static void nxt_http_source_chunk_filter(nxt_task_t *task, void *obj,
void *data);
static void nxt_http_source_chunk_error(nxt_thread_t *thr, void *obj,
static void nxt_http_source_chunk_error(nxt_task_t *task, void *obj,
void *data);
static void nxt_http_source_body_filter(nxt_thread_t *thr, void *obj,
static void nxt_http_source_body_filter(nxt_task_t *task, void *obj,
void *data);
static void nxt_http_source_sync_buffer(nxt_thread_t *thr,
nxt_http_source_t *hs, nxt_buf_t *b);
static void nxt_http_source_error(nxt_stream_source_t *stream);
static void nxt_http_source_fail(nxt_http_source_t *hs);
static void nxt_http_source_sync_buffer(nxt_task_t *task, nxt_http_source_t *hs,
nxt_buf_t *b);
static void nxt_http_source_error(nxt_task_t *task,
nxt_stream_source_t *stream);
static void nxt_http_source_fail(nxt_task_t *task, nxt_http_source_t *hs);
static void nxt_http_source_message(const char *msg, size_t len, u_char *p);
void
nxt_http_source_handler(nxt_upstream_source_t *us,
nxt_http_source_handler(nxt_task_t *task, nxt_upstream_source_t *us,
nxt_http_source_request_create_t request_create)
{
nxt_http_source_t *hs;
@@ -99,13 +100,13 @@ nxt_http_source_handler(nxt_upstream_source_t *us,
if (nxt_fast_path(stream->out != NULL)) {
nxt_memzero(&hs->u.status_parse, sizeof(nxt_http_status_parse_t));
nxt_stream_source_connect(stream);
nxt_stream_source_connect(task, stream);
return;
}
fail:
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
@@ -184,7 +185,7 @@ new_buffer:
static void
nxt_http_source_status_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_http_source_status_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_int_t ret;
nxt_buf_t *b;
@@ -198,10 +199,10 @@ nxt_http_source_status_filter(nxt_thread_t *thr, void *obj, void *data)
* start the stream source passes buffers one at a time.
*/
nxt_log_debug(thr->log, "http source status filter");
nxt_debug(task, "http source status filter");
if (nxt_slow_path(nxt_buf_is_sync(b))) {
nxt_http_source_sync_buffer(thr, hs, b);
nxt_http_source_sync_buffer(task, hs, b);
return;
}
@@ -214,28 +215,28 @@ nxt_http_source_status_filter(nxt_thread_t *thr, void *obj, void *data)
*/
hs->query.filter = nxt_http_source_header_filter;
nxt_log_debug(thr->log, "upstream status: \"%*s\"",
hs->u.status_parse.end - b->mem.start, b->mem.start);
nxt_debug(task, "upstream status: \"%*s\"",
hs->u.status_parse.end - b->mem.start, b->mem.start);
hs->header_in.status = hs->u.status_parse.code;
nxt_log_debug(thr->log, "upstream version:%d status:%uD \"%*s\"",
hs->u.status_parse.http_version,
hs->u.status_parse.code,
hs->u.status_parse.end - hs->u.status_parse.start,
hs->u.status_parse.start);
nxt_debug(task, "upstream version:%d status:%uD \"%*s\"",
hs->u.status_parse.http_version,
hs->u.status_parse.code,
hs->u.status_parse.end - hs->u.status_parse.start,
hs->u.status_parse.start);
nxt_memzero(&hs->u.header, sizeof(nxt_http_split_header_parse_t));
hs->u.header.mem_pool = hs->upstream->buffers.mem_pool;
nxt_http_source_header_filter(thr, hs, b);
nxt_http_source_header_filter(task, hs, b);
return;
}
if (nxt_slow_path(ret == NXT_ERROR)) {
/* HTTP/0.9 response. */
hs->header_in.status = 200;
nxt_http_source_header_ready(hs, b);
nxt_http_source_header_ready(task, hs, b);
return;
}
@@ -251,13 +252,13 @@ nxt_http_source_status_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_http_source_message("upstream sent too long status line: \"%*s\"",
b->mem.pos - b->mem.start, b->mem.start);
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
}
static void
nxt_http_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_http_source_header_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_int_t ret;
nxt_buf_t *b;
@@ -271,10 +272,10 @@ nxt_http_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
* start the stream source passes buffers one at a time.
*/
nxt_log_debug(thr->log, "http source header filter");
nxt_debug(task, "http source header filter");
if (nxt_slow_path(nxt_buf_is_sync(b))) {
nxt_http_source_sync_buffer(thr, hs, b);
nxt_http_source_sync_buffer(task, hs, b);
return;
}
@@ -293,8 +294,8 @@ nxt_http_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
}
if (nxt_fast_path(ret == NXT_DONE)) {
nxt_log_debug(thr->log, "http source header done");
nxt_http_source_header_ready(hs, b);
nxt_debug(task, "http source header done");
nxt_http_source_header_ready(task, hs, b);
return;
}
@@ -304,16 +305,16 @@ nxt_http_source_header_filter(nxt_thread_t *thr, void *obj, void *data)
if (ret != NXT_ERROR) {
/* ret == NXT_DECLINED: "\r" is not followed by "\n" */
nxt_log_error(NXT_LOG_ERR, thr->log,
"upstream sent invalid header line: \"%*s\\r...\"",
hs->u.header.parse.header_end
- hs->u.header.parse.header_name_start,
hs->u.header.parse.header_name_start);
nxt_log(task, NXT_LOG_ERR,
"upstream sent invalid header line: \"%*s\\r...\"",
hs->u.header.parse.header_end
- hs->u.header.parse.header_name_start,
hs->u.header.parse.header_name_start);
}
/* ret == NXT_ERROR */
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
@@ -425,7 +426,8 @@ nxt_http_source_transfer_encoding(nxt_upstream_source_t *us,
static void
nxt_http_source_header_ready(nxt_http_source_t *hs, nxt_buf_t *rest)
nxt_http_source_header_ready(nxt_task_t *task, nxt_http_source_t *hs,
nxt_buf_t *rest)
{
nxt_buf_t *b;
nxt_upstream_source_t *us;
@@ -461,7 +463,7 @@ nxt_http_source_header_ready(nxt_http_source_t *hs, nxt_buf_t *rest)
hsc->parse.mem_pool = hs->upstream->buffers.mem_pool;
if (nxt_buf_mem_used_size(&rest->mem) != 0) {
hs->rest = nxt_http_chunk_parse(&hsc->parse, rest);
hs->rest = nxt_http_chunk_parse(task, &hsc->parse, rest);
if (nxt_slow_path(hs->rest == NULL)) {
goto fail;
@@ -489,12 +491,12 @@ nxt_http_source_header_ready(nxt_http_source_t *hs, nxt_buf_t *rest)
us->buffers.max, us->buffers.size / 1024);
fail:
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
static void
nxt_http_source_chunk_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_http_source_chunk_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_http_source_t *hs;
@@ -503,37 +505,39 @@ nxt_http_source_chunk_filter(nxt_thread_t *thr, void *obj, void *data)
hsc = obj;
b = data;
nxt_log_debug(thr->log, "http source chunk filter");
nxt_debug(task, "http source chunk filter");
b = nxt_http_chunk_parse(&hsc->parse, b);
b = nxt_http_chunk_parse(task, &hsc->parse, b);
hs = hsc->next.context;
if (hsc->parse.error) {
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
return;
}
if (hsc->parse.chunk_error) {
/* Output all parsed before a chunk error and close upstream. */
nxt_thread_current_work_queue_add(thr, nxt_http_source_chunk_error,
hs, NULL, thr->log);
nxt_thread_current_work_queue_add(task->thread,
nxt_http_source_chunk_error,
task, hs, NULL);
}
if (b != NULL) {
nxt_source_filter(thr, hs->upstream->work_queue, &hsc->next, b);
nxt_source_filter(task->thread, hs->upstream->work_queue, task,
&hsc->next, b);
}
}
static void
nxt_http_source_chunk_error(nxt_thread_t *thr, void *obj, void *data)
nxt_http_source_chunk_error(nxt_task_t *task, void *obj, void *data)
{
nxt_http_source_t *hs;
hs = obj;
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
@@ -543,7 +547,7 @@ nxt_http_source_chunk_error(nxt_thread_t *thr, void *obj, void *data)
*/
static void
nxt_http_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
nxt_http_source_body_filter(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b, *in;
nxt_http_source_t *hs;
@@ -551,7 +555,7 @@ nxt_http_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
hs = obj;
in = data;
nxt_log_debug(thr->log, "http source body filter");
nxt_debug(task, "http source body filter");
for (b = in; b != NULL; b = b->next) {
@@ -562,7 +566,8 @@ nxt_http_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
}
if (hs->next != NULL) {
nxt_source_filter(thr, hs->upstream->work_queue, hs->next, in);
nxt_source_filter(task->thread, hs->upstream->work_queue, task,
hs->next, in);
return;
}
@@ -571,50 +576,45 @@ nxt_http_source_body_filter(nxt_thread_t *thr, void *obj, void *data)
static void
nxt_http_source_sync_buffer(nxt_thread_t *thr, nxt_http_source_t *hs,
nxt_http_source_sync_buffer(nxt_task_t *task, nxt_http_source_t *hs,
nxt_buf_t *b)
{
if (nxt_buf_is_last(b)) {
nxt_log_error(NXT_LOG_ERR, thr->log,
"upstream closed prematurely connection");
nxt_log(task, NXT_LOG_ERR,
"upstream closed prematurely connection");
} else {
nxt_log_error(NXT_LOG_ERR, thr->log, "%ui buffers %uz each are not "
"enough to process upstream response header",
hs->upstream->buffers.max,
hs->upstream->buffers.size);
nxt_log(task, NXT_LOG_ERR,"%ui buffers %uz each are not "
"enough to process upstream response header",
hs->upstream->buffers.max, hs->upstream->buffers.size);
}
/* The stream source sends only the last and the nobuf sync buffer. */
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
static void
nxt_http_source_error(nxt_stream_source_t *stream)
nxt_http_source_error(nxt_task_t *task, nxt_stream_source_t *stream)
{
nxt_http_source_t *hs;
nxt_thread_log_debug("http source error");
hs = stream->next->context;
nxt_http_source_fail(hs);
nxt_http_source_fail(task, hs);
}
static void
nxt_http_source_fail(nxt_http_source_t *hs)
nxt_http_source_fail(nxt_task_t *task, nxt_http_source_t *hs)
{
nxt_thread_t *thr;
thr = nxt_thread();
nxt_log_debug(thr->log, "http source fail");
nxt_debug(task, "http source fail");
/* TODO: fail, next upstream, or bad gateway */
hs->upstream->state->error_handler(thr, hs, NULL);
hs->upstream->state->error_handler(task, hs, NULL);
}

4
src/nxt_http_source.h
View File

@@ -40,8 +40,8 @@ struct nxt_http_source_s {
};
NXT_EXPORT void nxt_http_source_handler(nxt_upstream_source_t *us,
nxt_http_source_request_create_t request_create);
NXT_EXPORT void nxt_http_source_handler(nxt_task_t *task,
nxt_upstream_source_t *us, nxt_http_source_request_create_t request_create);
NXT_EXPORT nxt_int_t nxt_http_source_hash_create(nxt_mem_pool_t *mp,
nxt_lvlhsh_t *lh);

49
src/nxt_job.c
View File

@@ -8,8 +8,8 @@
#if (NXT_THREADS)
static void nxt_job_thread_trampoline(nxt_thread_t *thr, void *obj, void *data);
static void nxt_job_thread_return_handler(nxt_thread_t *thr, void *obj,
static void nxt_job_thread_trampoline(nxt_task_t *task, void *obj, void *data);
static void nxt_job_thread_return_handler(nxt_task_t *task, void *obj,
void *data);
#endif
@@ -44,6 +44,8 @@ nxt_job_create(nxt_mem_pool_t *mp, size_t size)
/* Allow safe nxt_queue_remove() in nxt_job_destroy(). */
nxt_queue_self(&job->link);
job->task.ident = nxt_task_next_ident();
return job;
}
@@ -56,6 +58,8 @@ nxt_job_init(nxt_job_t *job, size_t size)
nxt_job_set_name(job, "job");
nxt_queue_self(&job->link);
job->task.ident = nxt_task_next_ident();
}
@@ -103,18 +107,19 @@ nxt_job_cleanup_add(nxt_mem_pool_t *mp, nxt_job_t *job)
*/
void
nxt_job_start(nxt_thread_t *thr, nxt_job_t *job, nxt_work_handler_t handler)
nxt_job_start(nxt_task_t *task, nxt_job_t *job, nxt_work_handler_t handler)
{
nxt_log_debug(thr->log, "%s start", job->name);
nxt_debug(task, "%s start", job->name);
#if (NXT_THREADS)
if (job->thread_pool != NULL) {
nxt_int_t ret;
job->engine = thr->engine;
job->engine = task->thread->engine;
ret = nxt_thread_pool_post(job->thread_pool, nxt_job_thread_trampoline,
job, (void *) handler, job->log);
&job->task, job, (void *) handler);
if (ret == NXT_OK) {
return;
}
@@ -124,7 +129,7 @@ nxt_job_start(nxt_thread_t *thr, nxt_job_t *job, nxt_work_handler_t handler)
#endif
handler(thr, job, job->data);
handler(&job->task, job, job->data);
}
@@ -133,7 +138,7 @@ nxt_job_start(nxt_thread_t *thr, nxt_job_t *job, nxt_work_handler_t handler)
/* A trampoline function is called by a thread pool thread. */
static void
nxt_job_thread_trampoline(nxt_thread_t *thr, void *obj, void *data)
nxt_job_thread_trampoline(nxt_task_t *task, void *obj, void *data)
{
nxt_job_t *job;
nxt_work_handler_t handler;
@@ -141,13 +146,15 @@ nxt_job_thread_trampoline(nxt_thread_t *thr, void *obj, void *data)
job = obj;
handler = (nxt_work_handler_t) data;
nxt_log_debug(thr->log, "%s thread", job->name);
job->task.log = job->log;
nxt_debug(task, "%s thread", job->name);
if (nxt_slow_path(job->cancel)) {
nxt_job_return(thr, job, job->abort_handler);
nxt_job_return(task, job, job->abort_handler);
} else {
handler(thr, job, job->data);
handler(&job->task, job, job->data);
}
}
@@ -155,35 +162,35 @@ nxt_job_thread_trampoline(nxt_thread_t *thr, void *obj, void *data)
void
nxt_job_return(nxt_thread_t *thr, nxt_job_t *job, nxt_work_handler_t handler)
nxt_job_return(nxt_task_t *task, nxt_job_t *job, nxt_work_handler_t handler)
{
nxt_log_debug(thr->log, "%s return", job->name);
nxt_debug(task, "%s return", job->name);
#if (NXT_THREADS)
if (job->engine != NULL) {
/* A return function is called in thread pool thread context. */
nxt_event_engine_post(job->engine, nxt_job_thread_return_handler,
job, (void *) handler, job->log);
&job->task, job, (void *) handler, job->log);
return;
}
#endif
if (nxt_slow_path(job->cancel)) {
nxt_log_debug(thr->log, "%s cancellation", job->name);
nxt_debug(task, "%s cancellation", job->name);
handler = job->abort_handler;
}
nxt_thread_work_queue_push(thr, &thr->work_queue.main,
handler, job, job->data, thr->log);
nxt_thread_work_queue_push(task->thread, &task->thread->work_queue.main,
handler, &job->task, job, job->data);
}
#if (NXT_THREADS)
static void
nxt_job_thread_return_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_job_thread_return_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_job_t *job;
nxt_work_handler_t handler;
@@ -191,12 +198,14 @@ nxt_job_thread_return_handler(nxt_thread_t *thr, void *obj, void *data)
job = obj;
handler = (nxt_work_handler_t) data;
job->task.thread = task->thread;
if (nxt_slow_path(job->cancel)) {
nxt_log_debug(thr->log, "%s cancellation", job->name);
nxt_debug(task, "%s cancellation", job->name);
handler = job->abort_handler;
}
handler(thr, job, job->data);
handler(&job->task, job, job->data);
}
#endif

6
src/nxt_job.h
View File

@@ -33,6 +33,8 @@
typedef struct {
void *data;
nxt_task_t task;
nxt_work_handler_t abort_handler;
uint16_t cache_size;
@@ -59,9 +61,9 @@ NXT_EXPORT void nxt_job_init(nxt_job_t *job, size_t size);
NXT_EXPORT void nxt_job_destroy(void *data);
NXT_EXPORT nxt_int_t nxt_job_cleanup_add(nxt_mem_pool_t *mp, nxt_job_t *job);
NXT_EXPORT void nxt_job_start(nxt_thread_t *thr, nxt_job_t *job,
NXT_EXPORT void nxt_job_start(nxt_task_t *task, nxt_job_t *job,
nxt_work_handler_t handler);
NXT_EXPORT void nxt_job_return(nxt_thread_t *thr, nxt_job_t *job,
NXT_EXPORT void nxt_job_return(nxt_task_t *task, nxt_job_t *job,
nxt_work_handler_t handler);

15
src/nxt_job_file.c
View File

@@ -8,8 +8,7 @@
#include <nxt_main.h>
static void nxt_job_file_open_and_read(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_job_file_open_and_read(nxt_task_t *task, void *obj, void *data);
static nxt_int_t nxt_job_file_open(nxt_job_file_t *jbf);
static nxt_int_t nxt_job_file_info(nxt_job_file_t *jbf);
static nxt_int_t nxt_job_file_mmap(nxt_job_file_t *jbf, size_t size);
@@ -51,14 +50,14 @@ nxt_job_file_init(nxt_job_file_t *jbf)
*/
void
nxt_job_file_read(nxt_thread_t *thr, nxt_job_t *job)
nxt_job_file_read(nxt_task_t *task, nxt_job_t *job)
{
nxt_job_start(thr, job, nxt_job_file_open_and_read);
nxt_job_start(task, job, nxt_job_file_open_and_read);
}
static void
nxt_job_file_open_and_read(nxt_thread_t *thr, void *obj, void *data)
nxt_job_file_open_and_read(nxt_task_t *task, void *obj, void *data)
{
size_t size;
nxt_int_t n;
@@ -70,7 +69,7 @@ nxt_job_file_open_and_read(nxt_thread_t *thr, void *obj, void *data)
jbf = obj;
file = &jbf->file;
nxt_log_debug(thr->log, "file job read: \"%FN\"", file->name);
nxt_debug(task, "file job read: \"%FN\"", file->name);
if (file->fd != NXT_FILE_INVALID && jbf->close_before_open) {
nxt_file_close(file);
@@ -135,7 +134,7 @@ nxt_job_file_open_and_read(nxt_thread_t *thr, void *obj, void *data)
}
}
nxt_job_return(thr, &jbf->job, jbf->ready_handler);
nxt_job_return(task, &jbf->job, jbf->ready_handler);
return;
done:
@@ -145,7 +144,7 @@ done:
file->fd = NXT_FILE_INVALID;
}
nxt_job_return(thr, &jbf->job, handler);
nxt_job_return(task, &jbf->job, handler);
}

2
src/nxt_job_file.h
View File

@@ -68,7 +68,7 @@ struct nxt_job_file_s {
NXT_EXPORT nxt_job_file_t *nxt_job_file_create(nxt_mem_pool_t *mp);
NXT_EXPORT void nxt_job_file_init(nxt_job_file_t *jbf);
NXT_EXPORT void nxt_job_file_read(nxt_thread_t *thr, nxt_job_t *job);
NXT_EXPORT void nxt_job_file_read(nxt_task_t *task, nxt_job_t *job);
#endif /* _NXT_JOB_FILE_H_INCLUDED_ */

2
src/nxt_job_resolve.c
View File

@@ -121,5 +121,5 @@ fail:
freeaddrinfo(res);
}
nxt_job_return(nxt_thread(), &jbr->job, handler);
nxt_job_return(&jbr->job.task, &jbr->job, handler);
}

134
src/nxt_kqueue.c
View File

@@ -87,9 +87,9 @@ static void nxt_kqueue_fd_set(nxt_event_set_t *event_set, nxt_event_fd_t *ev,
static struct kevent *nxt_kqueue_get_kevent(nxt_kqueue_event_set_t *ks);
static void nxt_kqueue_commit_changes(nxt_kqueue_event_set_t *ks);
static void nxt_kqueue_error(nxt_kqueue_event_set_t *ks);
static void nxt_kqueue_fd_error_handler(nxt_thread_t *thr, void *obj,
static void nxt_kqueue_fd_error_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_kqueue_file_error_handler(nxt_thread_t *thr, void *obj,
static void nxt_kqueue_file_error_handler(nxt_task_t *task, void *obj,
void *data);
static nxt_int_t nxt_kqueue_add_signal(nxt_kqueue_event_set_t *kq,
const nxt_event_sig_t *sigev);
@@ -98,17 +98,17 @@ static nxt_int_t nxt_kqueue_enable_post(nxt_event_set_t *event_set,
nxt_work_handler_t handler);
static void nxt_kqueue_signal(nxt_event_set_t *event_set, nxt_uint_t signo);
#endif
static void nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
static void nxt_kqueue_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout);
static void nxt_kqueue_event_conn_io_connect(nxt_thread_t *thr, void *obj,
static void nxt_kqueue_event_conn_io_connect(nxt_task_t *task, void *obj,
void *data);
static void nxt_kqueue_event_conn_connected(nxt_thread_t *thr, void *obj,
static void nxt_kqueue_event_conn_connected(nxt_task_t *task, void *obj,
void *data);
static void nxt_kqueue_listen_handler(nxt_thread_t *thr, void *obj, void *data);
static void nxt_kqueue_event_conn_io_accept(nxt_thread_t *thr, void *obj,
static void nxt_kqueue_listen_handler(nxt_task_t *task, void *obj, void *data);
static void nxt_kqueue_event_conn_io_accept(nxt_task_t *task, void *obj,
void *data);
static void nxt_kqueue_event_conn_io_read(nxt_thread_t *thr, void *obj,
static void nxt_kqueue_event_conn_io_read(nxt_task_t *task, void *obj,
void *data);
static ssize_t nxt_kqueue_event_conn_io_recvbuf(nxt_event_conn_t *c,
nxt_buf_t *b);
@@ -547,14 +547,14 @@ nxt_kqueue_error(nxt_kqueue_event_set_t *ks)
ev = nxt_kevent_get_udata(kev->udata);
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_kqueue_fd_error_handler,
ev, ev->data, ev->log);
ev->task, ev, ev->data);
break;
case EVFILT_VNODE:
fev = nxt_kevent_get_udata(kev->udata);
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_kqueue_file_error_handler,
fev, fev->data, thr->log);
fev->task, fev, fev->data);
break;
}
}
@@ -562,7 +562,7 @@ nxt_kqueue_error(nxt_kqueue_event_set_t *ks)
static void
nxt_kqueue_fd_error_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_fd_error_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_fd_t *ev;
@@ -570,27 +570,27 @@ nxt_kqueue_fd_error_handler(nxt_thread_t *thr, void *obj, void *data)
if (ev->kq_eof && ev->kq_errno != 0) {
ev->error = ev->kq_errno;
nxt_log_error(nxt_socket_error_level(ev->kq_errno, ev->log_error),
thr->log, "kevent() reported error on descriptor %d %E",
ev->fd, ev->kq_errno);
nxt_log(task, nxt_socket_error_level(ev->kq_errno, ev->log_error),
"kevent() reported error on descriptor %d %E",
ev->fd, ev->kq_errno);
}
ev->read = NXT_EVENT_INACTIVE;
ev->write = NXT_EVENT_INACTIVE;
ev->error = ev->kq_errno;
ev->error_handler(thr, ev, data);
ev->error_handler(task, ev, data);
}
static void
nxt_kqueue_file_error_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_file_error_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_file_t *ev;
ev = obj;
ev->handler(thr, ev, data);
ev->handler(task, ev, data);
}
@@ -696,16 +696,16 @@ nxt_kqueue_signal(nxt_event_set_t *event_set, nxt_uint_t signo)
static void
nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_kqueue_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout)
{
int nevents;
void *obj, *data;
nxt_int_t i;
nxt_err_t err;
nxt_log_t *log;
nxt_uint_t level;
nxt_bool_t error, eof;
nxt_task_t *event_task;
struct kevent *kev;
nxt_event_fd_t *ev;
nxt_event_sig_t *sigev;
@@ -726,21 +726,21 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
ks = &event_set->kqueue;
nxt_log_debug(thr->log, "kevent(%d) changes:%d timeout:%M",
ks->kqueue, ks->nchanges, timeout);
nxt_debug(task, "kevent(%d) changes:%d timeout:%M",
ks->kqueue, ks->nchanges, timeout);
nevents = kevent(ks->kqueue, ks->changes, ks->nchanges,
ks->events, ks->mevents, tp);
err = (nevents == -1) ? nxt_errno : 0;
nxt_thread_time_update(thr);
nxt_thread_time_update(task->thread);
nxt_log_debug(thr->log, "kevent(%d): %d", ks->kqueue, nevents);
nxt_debug(task, "kevent(%d): %d", ks->kqueue, nevents);
if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log_error(level, thr->log, "kevent(%d) failed %E", ks->kqueue, err);
nxt_log(task, level, "kevent(%d) failed %E", ks->kqueue, err);
nxt_kqueue_error(ks);
return;
@@ -752,24 +752,25 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
kev = &ks->events[i];
nxt_log_debug(thr->log,
(kev->ident > 0x8000000 && kev->ident != (uintptr_t) -1) ?
"kevent: id:%p ft:%d fl:%04Xd ff:%d d:%d ud:%p":
"kevent: id:%d ft:%d fl:%04Xd ff:%d d:%d ud:%p",
kev->ident, kev->filter, kev->flags, kev->fflags,
kev->data, kev->udata);
nxt_debug(task,
(kev->ident > 0x8000000 && kev->ident != (uintptr_t) -1) ?
"kevent: id:%p ft:%d fl:%04Xd ff:%d d:%d ud:%p":
"kevent: id:%d ft:%d fl:%04Xd ff:%d d:%d ud:%p",
kev->ident, kev->filter, kev->flags, kev->fflags,
kev->data, kev->udata);
error = (kev->flags & EV_ERROR);
if (nxt_slow_path(error)) {
nxt_log_alert(thr->log, "kevent(%d) error %E on ident:%d filter:%d",
ks->kqueue, kev->data, kev->ident, kev->filter);
nxt_log(task, NXT_LOG_CRIT,
"kevent(%d) error %E on ident:%d filter:%d",
ks->kqueue, kev->data, kev->ident, kev->filter);
}
wq = &thr->work_queue.main;
event_task = task;
wq = &task->thread->work_queue.main;
handler = nxt_kqueue_fd_error_handler;
obj = nxt_kevent_get_udata(kev->udata);
log = thr->log;
switch (kev->filter) {
@@ -783,7 +784,7 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
ev->kq_eof = eof;
if (ev->read == NXT_EVENT_BLOCKED) {
nxt_log_debug(ev->log, "blocked read event fd:%d", ev->fd);
nxt_debug(ev->task, "blocked read event fd:%d", ev->fd);
continue;
}
@@ -800,8 +801,8 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
wq = ev->read_work_queue;
}
event_task = ev->task;
data = ev->data;
log = ev->log;
break;
@@ -814,7 +815,7 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
ev->kq_eof = eof;
if (ev->write == NXT_EVENT_BLOCKED) {
nxt_log_debug(ev->log, "blocked write event fd:%d", ev->fd);
nxt_debug(ev->task, "blocked write event fd:%d", ev->fd);
continue;
}
@@ -831,14 +832,15 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
wq = ev->write_work_queue;
}
event_task = ev->task;
data = ev->data;
log = ev->log;
break;
case EVFILT_VNODE:
fev = obj;
handler = fev->handler;
event_task = fev->task;
data = fev->data;
break;
@@ -861,15 +863,16 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
default:
#if (NXT_DEBUG)
nxt_log_alert(thr->log,
"unexpected kevent(%d) filter %d on ident %d",
ks->kqueue, kev->filter, kev->ident);
nxt_log(task, NXT_LOG_CRIT,
"unexpected kevent(%d) filter %d on ident %d",
ks->kqueue, kev->filter, kev->ident);
#endif
continue;
}
nxt_thread_work_queue_add(thr, wq, handler, obj, data, log);
nxt_thread_work_queue_add(task->thread, wq, handler,
event_task, obj, data);
}
}
@@ -880,7 +883,7 @@ nxt_kqueue_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
*/
static void
nxt_kqueue_event_conn_io_connect(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_event_conn_io_connect(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_work_handler_t handler;
@@ -901,9 +904,9 @@ nxt_kqueue_event_conn_io_connect(nxt_thread_t *thr, void *obj, void *data)
c->socket.write_handler = nxt_kqueue_event_conn_connected;
c->socket.error_handler = nxt_event_conn_connect_error;
nxt_event_conn_timer(thr->engine, c, state, &c->write_timer);
nxt_event_conn_timer(task->thread->engine, c, state, &c->write_timer);
nxt_kqueue_enable_write(thr->engine->event_set, &c->socket);
nxt_kqueue_enable_write(task->thread->engine->event_set, &c->socket);
return;
case NXT_DECLINED:
@@ -915,18 +918,19 @@ nxt_kqueue_event_conn_io_connect(nxt_thread_t *thr, void *obj, void *data)
break;
}
nxt_event_conn_io_handle(thr, c->write_work_queue, handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue, handler, task,
c, data);
}
static void
nxt_kqueue_event_conn_connected(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_event_conn_connected(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_log_debug(thr->log, "kqueue event conn connected fd:%d", c->socket.fd);
nxt_debug(task, "kqueue event conn connected fd:%d", c->socket.fd);
c->socket.write = NXT_EVENT_BLOCKED;
@@ -934,30 +938,29 @@ nxt_kqueue_event_conn_connected(nxt_thread_t *thr, void *obj, void *data)
nxt_event_timer_disable(&c->write_timer);
}
nxt_thread_work_queue_add(thr, c->write_work_queue,
c->write_state->ready_handler,
c, data, c->socket.log);
nxt_thread_work_queue_add(task->thread, c->write_work_queue,
c->write_state->ready_handler, task, c, data);
}
static void
nxt_kqueue_listen_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_listen_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_listen_t *cls;
cls = obj;
nxt_log_debug(thr->log, "kevent fd:%d avail:%D",
cls->socket.fd, cls->socket.kq_available);
nxt_debug(task, "kevent fd:%d avail:%D",
cls->socket.fd, cls->socket.kq_available);
cls->ready = nxt_min(cls->batch, (uint32_t) cls->socket.kq_available);
nxt_kqueue_event_conn_io_accept(thr, cls, data);
nxt_kqueue_event_conn_io_accept(task, cls, data);
}
static void
nxt_kqueue_event_conn_io_accept(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_event_conn_io_accept(nxt_task_t *task, void *obj, void *data)
{
socklen_t len;
nxt_socket_t s;
@@ -989,13 +992,13 @@ nxt_kqueue_event_conn_io_accept(nxt_thread_t *thr, void *obj, void *data)
if (s != -1) {
c->socket.fd = s;
nxt_log_debug(thr->log, "accept(%d): %d", cls->socket.fd, s);
nxt_debug(task, "accept(%d): %d", cls->socket.fd, s);
nxt_event_conn_accept(thr, cls, c);
nxt_event_conn_accept(task, cls, c);
return;
}
nxt_event_conn_accept_error(thr, cls, "accept", nxt_errno);
nxt_event_conn_accept_error(task, cls, "accept", nxt_errno);
}
@@ -1005,25 +1008,24 @@ nxt_kqueue_event_conn_io_accept(nxt_thread_t *thr, void *obj, void *data)
*/
static void
nxt_kqueue_event_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
nxt_kqueue_event_conn_io_read(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_log_debug(thr->log, "kqueue event conn read fd:%d", c->socket.fd);
nxt_debug(task, "kqueue event conn read fd:%d", c->socket.fd);
if (c->socket.kq_available == 0 && c->socket.kq_eof) {
nxt_log_debug(thr->log, "kevent fd:%d eof", c->socket.fd);
nxt_debug(task, "kevent fd:%d eof", c->socket.fd);
c->socket.closed = 1;
nxt_thread_work_queue_add(thr, c->read_work_queue,
c->read_state->close_handler,
c, data, c->socket.log);
nxt_thread_work_queue_add(task->thread, c->read_work_queue,
c->read_state->close_handler, task, c, data);
return;
}
nxt_event_conn_io_read(thr, c, data);
nxt_event_conn_io_read(task, c, data);
}

6
src/nxt_lib.c
View File

@@ -9,6 +9,8 @@
nxt_uint_t nxt_ncpu = 1;
nxt_uint_t nxt_pagesize;
nxt_task_t nxt_main_task;
nxt_atomic_t nxt_task_ident;
nxt_random_t nxt_random_data;
nxt_thread_declare_data(nxt_thread_t, nxt_thread_context);
@@ -70,6 +72,10 @@ nxt_lib_start(const char *app, char **argv, char ***envp)
thr->time.signal = -1;
#endif
nxt_main_task.thread = thr;
nxt_main_task.log = thr->log;
nxt_main_task.ident = nxt_task_next_ident();
if (nxt_strerror_start() != NXT_OK) {
return NXT_ERROR;
}

2
src/nxt_linux_sendfile.c
View File

@@ -62,7 +62,7 @@ nxt_linux_event_conn_io_sendfile(nxt_event_conn_t *c, nxt_buf_t *b,
sb.size = 0;
sb.limit = limit;
niov = nxt_sendbuf_mem_coalesce(&sb);
niov = nxt_sendbuf_mem_coalesce(c->socket.task, &sb);
if (niov == 0 && sb.sync) {
return 0;

2
src/nxt_log.c
View File

@@ -8,6 +8,8 @@
nxt_uint_t nxt_debug;
nxt_uint_t nxt_trace;
nxt_log_t nxt_main_log = {
NXT_LOG_INFO,

34
src/nxt_log.h
View File

@@ -66,6 +66,27 @@ nxt_log_alert(_log, ...) \
} while (0)
#define nxt_log(task, _level, ...) \
do { \
nxt_log_t *log = (task)->log; \
nxt_uint_t _level_ = (_level); \
\
if (nxt_slow_path(log->level >= _level_)) { \
log->handler(_level_, log, __VA_ARGS__); \
} \
} while (0)
#define nxt_trace(task, ...) \
do { \
nxt_log_t *log = (task)->log; \
\
if (nxt_slow_path(log->level >= NXT_LOG_NOTICE || nxt_trace)) { \
log->handler(NXT_LOG_NOTICE, log, __VA_ARGS__); \
} \
} while (0)
#define \
nxt_log_error(_level, _log, ...) \
do { \
@@ -80,6 +101,16 @@ nxt_log_error(_level, _log, ...) \
#if (NXT_DEBUG)
#define nxt_debug(task, ...) \
do { \
nxt_log_t *log = (task)->log; \
\
if (nxt_slow_path(log->level == NXT_LOG_DEBUG || nxt_debug)) { \
log->handler(NXT_LOG_DEBUG, log, __VA_ARGS__); \
} \
} while (0)
#define \
nxt_log_debug(_log, ...) \
do { \
@@ -92,6 +123,8 @@ nxt_log_debug(_log, ...) \
#else
#define nxt_log_debug(...)
#define \
nxt_log_debug(...)
@@ -119,6 +152,7 @@ nxt_main_log_debug(...) \
NXT_EXPORT extern nxt_uint_t nxt_debug;
NXT_EXPORT extern nxt_uint_t nxt_trace;
NXT_EXPORT extern nxt_log_t nxt_main_log;
NXT_EXPORT extern nxt_str_t nxt_log_levels[];

6
src/nxt_log_moderation.c
View File

@@ -7,7 +7,7 @@
#include <nxt_main.h>
static void nxt_log_moderate_timer_handler(nxt_thread_t *thr, void *obj,
static void nxt_log_moderate_timer_handler(nxt_task_t *task, void *obj,
void *data);
@@ -70,7 +70,7 @@ nxt_log_moderate_allow(nxt_log_moderation_t *mod)
static void
nxt_log_moderate_timer_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_log_moderate_timer_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_bool_t msg;
nxt_atomic_uint_t n;
@@ -82,7 +82,7 @@ nxt_log_moderate_timer_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_thread_spin_lock(&mod->lock);
mod->last = nxt_thread_time(thr);
mod->last = nxt_thread_time(task->thread);
n = mod->count;
mod->count = 0;
msg = (mod->pid == nxt_pid);

4
src/nxt_macosx_sendfile.c
View File

@@ -46,7 +46,7 @@ nxt_macosx_event_conn_io_sendfile(nxt_event_conn_t *c, nxt_buf_t *b,
sb.size = 0;
sb.limit = limit;
nhd = nxt_sendbuf_mem_coalesce(&sb);
nhd = nxt_sendbuf_mem_coalesce(c->socket.task, &sb);
if (nhd == 0 && sb.sync) {
return 0;
@@ -67,7 +67,7 @@ nxt_macosx_event_conn_io_sendfile(nxt_event_conn_t *c, nxt_buf_t *b,
sb.iobuf = tr;
ntr = nxt_sendbuf_mem_coalesce(&sb);
ntr = nxt_sendbuf_mem_coalesce(c->socket.task, &sb);
/*
* Disposal of surplus kernel operations if there are no headers

2
src/nxt_main.c
View File

@@ -32,7 +32,7 @@ main(int argc, char **argv)
nxt_log_error(NXT_LOG_INFO, thr->log, "nginman started");
ret = nxt_cycle_create(thr, NULL, NULL, &nxt_config_name, 0);
ret = nxt_cycle_create(thr, &nxt_main_task, NULL, NULL, &nxt_config_name);
if (ret != NXT_OK) {
return 1;

2
src/nxt_main.h
View File

@@ -174,6 +174,8 @@ NXT_EXPORT void nxt_lib_stop(void);
NXT_EXPORT extern nxt_uint_t nxt_ncpu;
NXT_EXPORT extern nxt_uint_t nxt_pagesize;
NXT_EXPORT extern nxt_task_t nxt_main_task;
NXT_EXPORT extern nxt_atomic_t nxt_task_ident;
NXT_EXPORT extern nxt_random_t nxt_random_data;

149
src/nxt_master_process.c
View File

@@ -10,28 +10,31 @@
#include <nxt_master_process.h>
static nxt_int_t nxt_master_process_chan_create(nxt_cycle_t *cycle);
static nxt_int_t nxt_master_process_chan_create(nxt_task_t *task,
nxt_cycle_t *cycle);
static void nxt_master_process_title(void);
static nxt_int_t nxt_master_start_worker_processes(nxt_cycle_t *cycle);
static nxt_int_t nxt_master_create_worker_process(nxt_cycle_t *cycle);
static void nxt_master_stop_previous_worker_processes(nxt_thread_t *thr,
static nxt_int_t nxt_master_start_worker_processes(nxt_task_t *task,
nxt_cycle_t *cycle);
static nxt_int_t nxt_master_create_worker_process(nxt_task_t *task,
nxt_cycle_t *cycle);
static void nxt_master_stop_previous_worker_processes(nxt_task_t *task,
void *obj, void *data);
static void nxt_master_process_sighup_handler(nxt_thread_t *thr, void *obj,
static void nxt_master_process_sighup_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_master_process_new_cycle(nxt_thread_t *thr, nxt_cycle_t *cycle);
static void nxt_master_process_sigterm_handler(nxt_thread_t *thr, void *obj,
static void nxt_master_process_new_cycle(nxt_task_t *task, nxt_cycle_t *cycle);
static void nxt_master_process_sigterm_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_master_process_sigquit_handler(nxt_thread_t *thr, void *obj,
static void nxt_master_process_sigquit_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_master_process_sigusr1_handler(nxt_thread_t *thr, void *obj,
static void nxt_master_process_sigusr1_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_master_process_sigusr2_handler(nxt_thread_t *thr, void *obj,
static void nxt_master_process_sigusr2_handler(nxt_task_t *task, void *obj,
void *data);
static char **nxt_master_process_upgrade_environment(nxt_cycle_t *cycle);
static char **nxt_master_process_upgrade_environment_create(nxt_cycle_t *cycle);
static void nxt_master_process_sigchld_handler(nxt_thread_t *thr, void *obj,
static void nxt_master_process_sigchld_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_master_cleanup_worker_process(nxt_thread_t *thr, nxt_pid_t pid);
static void nxt_master_cleanup_worker_process(nxt_task_t *task, nxt_pid_t pid);
const nxt_event_sig_t nxt_master_process_signals[] = {
@@ -50,22 +53,23 @@ static nxt_bool_t nxt_exiting;
nxt_int_t
nxt_master_process_start(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_master_process_start(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle)
{
cycle->type = NXT_PROCESS_MASTER;
if (nxt_master_process_chan_create(cycle) != NXT_OK) {
if (nxt_master_process_chan_create(task, cycle) != NXT_OK) {
return NXT_ERROR;
}
nxt_master_process_title();
return nxt_master_start_worker_processes(cycle);
return nxt_master_start_worker_processes(task, cycle);
}
static nxt_int_t
nxt_master_process_chan_create(nxt_cycle_t *cycle)
nxt_master_process_chan_create(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_process_chan_t *proc;
@@ -86,7 +90,7 @@ nxt_master_process_chan_create(nxt_cycle_t *cycle)
* A master process chan. A write chan is not closed
* since it should be inherited by worker processes.
*/
nxt_chan_read_enable(nxt_thread(), proc->chan);
nxt_chan_read_enable(task, proc->chan);
return NXT_OK;
}
@@ -115,7 +119,7 @@ nxt_master_process_title(void)
static nxt_int_t
nxt_master_start_worker_processes(nxt_cycle_t *cycle)
nxt_master_start_worker_processes(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_int_t ret;
nxt_uint_t n;
@@ -125,7 +129,7 @@ nxt_master_start_worker_processes(nxt_cycle_t *cycle)
n = cycle->worker_processes;
while (n-- != 0) {
ret = nxt_master_create_worker_process(cycle);
ret = nxt_master_create_worker_process(task, cycle);
if (ret != NXT_OK) {
return ret;
@@ -137,7 +141,7 @@ nxt_master_start_worker_processes(nxt_cycle_t *cycle)
static nxt_int_t
nxt_master_create_worker_process(nxt_cycle_t *cycle)
nxt_master_create_worker_process(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_pid_t pid;
nxt_process_chan_t *proc;
@@ -174,41 +178,46 @@ nxt_master_create_worker_process(nxt_cycle_t *cycle)
proc->pid = pid;
nxt_chan_read_close(proc->chan);
nxt_chan_write_enable(nxt_thread(), proc->chan);
nxt_chan_write_enable(task, proc->chan);
nxt_process_new_chan(cycle, proc);
nxt_process_new_chan(task, cycle, proc);
return NXT_OK;
}
}
static void
nxt_master_process_sighup_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_master_process_sighup_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_cycle_t *cycle;
cycle = nxt_thread_cycle();
nxt_log_error(NXT_LOG_NOTICE, thr->log, "signal %d (%s) recevied, %s",
(int) (uintptr_t) obj, data,
cycle->reconfiguring ? "ignored" : "reconfiguring");
nxt_log(task, NXT_LOG_NOTICE, "signal %d (%s) recevied, %s",
(int) (uintptr_t) obj, data,
cycle->reconfiguring ? "ignored" : "reconfiguring");
if (!cycle->reconfiguring) {
(void) nxt_cycle_create(thr, cycle, nxt_master_process_new_cycle,
cycle->config_name, 0);
(void) nxt_cycle_create(task->thread, task, cycle,
nxt_master_process_new_cycle,
cycle->config_name);
}
}
static void
nxt_master_process_new_cycle(nxt_thread_t *thr, nxt_cycle_t *cycle)
nxt_master_process_new_cycle(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_log_debug(thr->log, "new cycle");
nxt_thread_t *thr;
thr = task->thread;
nxt_debug(task, "new cycle");
/* A safe place to free the previous cycle. */
nxt_mem_pool_destroy(cycle->previous->mem_pool);
switch (nxt_master_start_worker_processes(cycle)) {
switch (nxt_master_start_worker_processes(task, cycle)) {
case NXT_OK:
/*
@@ -240,7 +249,7 @@ nxt_master_process_new_cycle(nxt_thread_t *thr, nxt_cycle_t *cycle)
static void
nxt_master_stop_previous_worker_processes(nxt_thread_t *thr, void *obj,
nxt_master_stop_previous_worker_processes(nxt_task_t *task, void *obj,
void *data)
{
uint32_t generation;
@@ -259,7 +268,8 @@ nxt_master_stop_previous_worker_processes(nxt_thread_t *thr, void *obj,
for (i = 1; i < n; i++) {
if (proc[i].generation == generation) {
(void) nxt_chan_write(proc[i].chan, NXT_CHAN_MSG_QUIT, -1, 0, NULL);
(void) nxt_chan_write(task, proc[i].chan, NXT_CHAN_MSG_QUIT,
-1, 0, NULL);
}
}
@@ -268,43 +278,43 @@ nxt_master_stop_previous_worker_processes(nxt_thread_t *thr, void *obj,
void
nxt_master_stop_worker_processes(nxt_cycle_t *cycle)
nxt_master_stop_worker_processes(nxt_task_t *task, nxt_cycle_t *cycle)
{
nxt_process_chan_write(cycle, NXT_CHAN_MSG_QUIT, -1, 0, NULL);
nxt_process_chan_write(task, cycle, NXT_CHAN_MSG_QUIT, -1, 0, NULL);
}
static void
nxt_master_process_sigterm_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_master_process_sigterm_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_log_debug(thr->log, "sigterm handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
nxt_debug(task, "sigterm handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
/* TODO: fast exit. */
nxt_exiting = 1;
nxt_cycle_quit(thr, NULL);
nxt_cycle_quit(task, NULL);
}
static void
nxt_master_process_sigquit_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_master_process_sigquit_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_log_debug(thr->log, "sigquit handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
nxt_debug(task, "sigquit handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
/* TODO: graceful exit. */
nxt_exiting = 1;
nxt_cycle_quit(thr, NULL);
nxt_cycle_quit(task, NULL);
}
static void
nxt_master_process_sigusr1_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_master_process_sigusr1_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_int_t ret;
nxt_uint_t n;
@@ -313,8 +323,8 @@ nxt_master_process_sigusr1_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_array_t *new_files;
nxt_mem_pool_t *mp;
nxt_log_error(NXT_LOG_NOTICE, thr->log, "signal %d (%s) recevied, %s",
(int) (uintptr_t) obj, data, "log files rotation");
nxt_log(task, NXT_LOG_NOTICE, "signal %d (%s) recevied, %s",
(int) (uintptr_t) obj, data, "log files rotation");
mp = nxt_mem_pool_create(1024);
if (mp == NULL) {
@@ -358,7 +368,7 @@ nxt_master_process_sigusr1_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_list_each(file, cycle->log_files) {
nxt_process_chan_change_log_file(cycle, n, new_file[n].fd);
nxt_process_chan_change_log_file(task, cycle, n, new_file[n].fd);
/*
* The old log file descriptor must be closed at the moment
* when no other threads use it. dup2() allows to use the
@@ -394,7 +404,7 @@ fail:
static void
nxt_master_process_sigusr2_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_master_process_sigusr2_handler(nxt_task_t *task, void *obj, void *data)
{
char **env;
nxt_int_t ret;
@@ -427,10 +437,10 @@ nxt_master_process_sigusr2_handler(nxt_thread_t *thr, void *obj, void *data)
ignore = 1;
}
nxt_log_error(NXT_LOG_NOTICE, thr->log,
"signal %d (%s) recevied, %s, parent pid: %PI",
(int) (uintptr_t) obj, data,
ignore ? "ignored" : "online binary file upgrade", ppid);
nxt_log(task, NXT_LOG_NOTICE,
"signal %d (%s) recevied, %s, parent pid: %PI",
(int) (uintptr_t) obj, data,
ignore ? "ignored" : "online binary file upgrade", ppid);
if (ignore) {
return;
@@ -552,14 +562,14 @@ nxt_master_process_upgrade_environment_create(nxt_cycle_t *cycle)
static void
nxt_master_process_sigchld_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_master_process_sigchld_handler(nxt_task_t *task, void *obj, void *data)
{
int status;
nxt_err_t err;
nxt_pid_t pid;
nxt_log_debug(thr->log, "sigchld handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
nxt_debug(task, "sigchld handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
for ( ;; ) {
pid = waitpid(-1, &status, WNOHANG);
@@ -575,12 +585,12 @@ nxt_master_process_sigchld_handler(nxt_thread_t *thr, void *obj, void *data)
continue;
default:
nxt_log_alert(thr->log, "waitpid() failed: %E", err);
nxt_log(task, NXT_LOG_CRIT, "waitpid() failed: %E", err);
return;
}
}
nxt_log_debug(thr->log, "waitpid(): %PI", pid);
nxt_debug(task, "waitpid(): %PI", pid);
if (pid == 0) {
return;
@@ -588,27 +598,26 @@ nxt_master_process_sigchld_handler(nxt_thread_t *thr, void *obj, void *data)
if (WTERMSIG(status)) {
#ifdef WCOREDUMP
nxt_log_alert(thr->log, "process %PI exited on signal %d%s",
pid, WTERMSIG(status),
WCOREDUMP(status) ? " (core dumped)" : "");
nxt_log(task, NXT_LOG_CRIT, "process %PI exited on signal %d%s",
pid, WTERMSIG(status),
WCOREDUMP(status) ? " (core dumped)" : "");
#else
nxt_log_alert(thr->log, "process %PI exited on signal %d",
pid, WTERMSIG(status));
nxt_log(task, NXT_LOG_CRIT, "process %PI exited on signal %d",
pid, WTERMSIG(status));
#endif
} else {
nxt_log_error(NXT_LOG_NOTICE, thr->log,
"process %PI exited with code %d",
pid, WEXITSTATUS(status));
nxt_trace(task, "process %PI exited with code %d",
pid, WEXITSTATUS(status));
}
nxt_master_cleanup_worker_process(thr, pid);
nxt_master_cleanup_worker_process(task, pid);
}
}
static void
nxt_master_cleanup_worker_process(nxt_thread_t *thr, nxt_pid_t pid)
nxt_master_cleanup_worker_process(nxt_task_t *task, nxt_pid_t pid)
{
nxt_uint_t i, n, generation;
nxt_cycle_t *cycle;
@@ -634,14 +643,14 @@ nxt_master_cleanup_worker_process(nxt_thread_t *thr, nxt_pid_t pid)
nxt_array_remove(cycle->processes, &proc[i]);
if (nxt_exiting) {
nxt_log_debug(thr->log, "processes %d", n);
nxt_debug(task, "processes %d", n);
if (n == 2) {
nxt_cycle_quit(thr, cycle);
nxt_cycle_quit(task, cycle);
}
} else if (generation == cycle->process_generation) {
(void) nxt_master_create_worker_process(cycle);
(void) nxt_master_create_worker_process(task, cycle);
}
return;

5
src/nxt_master_process.h
View File

@@ -8,8 +8,9 @@
#define _NXT_UNIX_MASTER_PROCESS_H_INCLUDED_
nxt_int_t nxt_master_process_start(nxt_thread_t *thr, nxt_cycle_t *cycle);
void nxt_master_stop_worker_processes(nxt_cycle_t *cycle);
nxt_int_t nxt_master_process_start(nxt_thread_t *thr, nxt_task_t *task,
nxt_cycle_t *cycle);
void nxt_master_stop_worker_processes(nxt_task_t *task, nxt_cycle_t *cycle);
void nxt_worker_process_start(void *data);

94
src/nxt_openssl.c
View File

@@ -22,19 +22,18 @@ typedef struct {
static nxt_int_t nxt_openssl_server_init(nxt_ssltls_conf_t *conf);
static void nxt_openssl_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
static void nxt_openssl_conn_init(nxt_task_t *task, nxt_ssltls_conf_t *conf,
nxt_event_conn_t *c);
static void nxt_openssl_session_cleanup(void *data);
static void nxt_openssl_conn_handshake(nxt_thread_t *thr, void *obj,
static void nxt_openssl_conn_handshake(nxt_task_t *task, void *obj, void *data);
static void nxt_openssl_conn_io_read(nxt_task_t *task, void *obj, void *data);
static void nxt_openssl_conn_io_shutdown(nxt_task_t *task, void *obj,
void *data);
static void nxt_openssl_conn_io_read(nxt_thread_t *thr, void *obj, void *data);
static void nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj,
void *data);
static ssize_t nxt_openssl_conn_io_write_chunk(nxt_thread_t *thr,
nxt_event_conn_t *c, nxt_buf_t *b, size_t limit);
static ssize_t nxt_openssl_conn_io_write_chunk(nxt_event_conn_t *c,
nxt_buf_t *b, size_t limit);
static ssize_t nxt_openssl_conn_io_send(nxt_event_conn_t *c, void *buf,
size_t size);
static nxt_int_t nxt_openssl_conn_test_error(nxt_thread_t *thr,
static nxt_int_t nxt_openssl_conn_test_error(nxt_task_t *task,
nxt_event_conn_t *c, int ret, nxt_err_t sys_err,
nxt_work_handler_t handler);
static void nxt_cdecl nxt_openssl_conn_error(nxt_event_conn_t *c, nxt_err_t err,
@@ -250,7 +249,7 @@ fail:
static void
nxt_openssl_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
nxt_openssl_conn_init(nxt_task_t *task, nxt_ssltls_conf_t *conf,
nxt_event_conn_t *c)
{
int ret;
@@ -305,13 +304,14 @@ nxt_openssl_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
c->io = &nxt_openssl_event_conn_io;
c->sendfile = NXT_CONN_SENDFILE_OFF;
nxt_openssl_conn_handshake(thr, c, c->socket.data);
nxt_openssl_conn_handshake(task, c, c->socket.data);
return;
fail:
nxt_event_conn_io_handle(thr, c->read_work_queue,
c->read_state->error_handler, c, c->socket.data);
nxt_event_conn_io_handle(task->thread, c->read_work_queue,
c->read_state->error_handler,
task, c, c->socket.data);
}
@@ -331,7 +331,7 @@ nxt_openssl_session_cleanup(void *data)
static void
nxt_openssl_conn_handshake(nxt_thread_t *thr, void *obj, void *data)
nxt_openssl_conn_handshake(nxt_task_t *task, void *obj, void *data)
{
int ret;
nxt_int_t n;
@@ -342,7 +342,7 @@ nxt_openssl_conn_handshake(nxt_thread_t *thr, void *obj, void *data)
c = obj;
ssltls = c->u.ssltls;
nxt_log_debug(thr->log, "openssl conn handshake: %d", ssltls->times);
nxt_debug(task, "openssl conn handshake: %d", ssltls->times);
/* "ssltls->times == 1" is suitable to run SSL_do_handshake() in job. */
@@ -350,26 +350,26 @@ nxt_openssl_conn_handshake(nxt_thread_t *thr, void *obj, void *data)
err = (ret <= 0) ? nxt_socket_errno : 0;
nxt_thread_time_debug_update(thr);
nxt_thread_time_debug_update(task->thread);
nxt_log_debug(thr->log, "SSL_do_handshake(%d): %d err:%d",
c->socket.fd, ret, err);
nxt_debug(task, "SSL_do_handshake(%d): %d err:%d", c->socket.fd, ret, err);
if (ret > 0) {
/* ret == 1, the handshake was successfully completed. */
nxt_openssl_conn_io_read(thr, c, data);
nxt_openssl_conn_io_read(task, c, data);
return;
}
n = nxt_openssl_conn_test_error(thr, c, ret, err,
n = nxt_openssl_conn_test_error(task, c, ret, err,
nxt_openssl_conn_handshake);
if (n == NXT_ERROR) {
nxt_openssl_conn_error(c, err, "SSL_do_handshake(%d) failed",
c->socket.fd);
nxt_event_conn_io_handle(thr, c->read_work_queue,
c->read_state->error_handler, c, data);
nxt_event_conn_io_handle(task->thread, c->read_work_queue,
c->read_state->error_handler,
task, c, data);
} else if (ssltls->ssl_error == SSL_ERROR_WANT_READ && ssltls->times < 2) {
ssltls->times++;
@@ -378,7 +378,7 @@ nxt_openssl_conn_handshake(nxt_thread_t *thr, void *obj, void *data)
static void
nxt_openssl_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
nxt_openssl_conn_io_read(nxt_task_t *task, void *obj, void *data)
{
int ret;
nxt_buf_t *b;
@@ -390,7 +390,7 @@ nxt_openssl_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
c = obj;
nxt_log_debug(thr->log, "openssl conn read");
nxt_debug(task, "openssl conn read");
handler = c->read_state->ready_handler;
b = c->read;
@@ -404,9 +404,9 @@ nxt_openssl_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
err = (ret <= 0) ? nxt_socket_errno : 0;
nxt_log_debug(thr->log, "SSL_read(%d, %p, %uz): %d err:%d",
c->socket.fd, b->mem.free, b->mem.end - b->mem.free,
ret, err);
nxt_debug(task, "SSL_read(%d, %p, %uz): %d err:%d",
c->socket.fd, b->mem.free, b->mem.end - b->mem.free,
ret, err);
if (ret > 0) {
/* c->socket.read_ready is kept. */
@@ -414,7 +414,7 @@ nxt_openssl_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
handler = c->read_state->ready_handler;
} else {
n = nxt_openssl_conn_test_error(thr, c, ret, err,
n = nxt_openssl_conn_test_error(task, c, ret, err,
nxt_openssl_conn_io_read);
if (nxt_fast_path(n != NXT_ERROR)) {
@@ -429,17 +429,17 @@ nxt_openssl_conn_io_read(nxt_thread_t *thr, void *obj, void *data)
}
}
nxt_event_conn_io_handle(thr, c->read_work_queue, handler, c, data);
nxt_event_conn_io_handle(task->thread, c->read_work_queue, handler,
task, c, data);
}
static ssize_t
nxt_openssl_conn_io_write_chunk(nxt_thread_t *thr, nxt_event_conn_t *c,
nxt_buf_t *b, size_t limit)
nxt_openssl_conn_io_write_chunk(nxt_event_conn_t *c, nxt_buf_t *b, size_t limit)
{
nxt_openssl_conn_t *ssltls;
nxt_log_debug(thr->log, "openssl conn write chunk");
nxt_debug(c->socket.task, "openssl conn write chunk");
ssltls = c->u.ssltls;
@@ -474,7 +474,7 @@ nxt_openssl_conn_io_send(nxt_event_conn_t *c, void *buf, size_t size)
return ret;
}
n = nxt_openssl_conn_test_error(nxt_thread(), c, ret, err,
n = nxt_openssl_conn_test_error(c->socket.task, c, ret, err,
nxt_event_conn_io_write);
if (n == NXT_ERROR) {
@@ -487,7 +487,7 @@ nxt_openssl_conn_io_send(nxt_event_conn_t *c, void *buf, size_t size)
static void
nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
nxt_openssl_conn_io_shutdown(nxt_task_t *task, void *obj, void *data)
{
int ret, mode;
SSL *s;
@@ -500,7 +500,7 @@ nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
c = obj;
nxt_log_debug(thr->log, "openssl conn shutdown");
nxt_debug(task, "openssl conn shutdown");
ssltls = c->u.ssltls;
s = ssltls->session;
@@ -533,8 +533,8 @@ nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
err = (ret <= 0) ? nxt_socket_errno : 0;
nxt_log_debug(thr->log, "SSL_shutdown(%d, %d, %b): %d err:%d",
c->socket.fd, mode, quiet, ret, err);
nxt_debug(task, "SSL_shutdown(%d, %d, %b): %d err:%d",
c->socket.fd, mode, quiet, ret, err);
if (ret > 0) {
/* ret == 1, the shutdown was successfully completed. */
@@ -565,7 +565,7 @@ nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
break;
}
n = nxt_openssl_conn_test_error(thr, c, ret, err,
n = nxt_openssl_conn_test_error(task, c, ret, err,
nxt_openssl_conn_io_shutdown);
if (nxt_fast_path(n == 0)) {
@@ -574,7 +574,7 @@ nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
if (n != NXT_ERROR) { /* n == NXT_AGAIN */
c->socket.error_handler = c->read_state->error_handler;
nxt_event_timer_add(thr->engine, &c->read_timer, 5000);
nxt_event_timer_add(task->thread->engine, &c->read_timer, 5000);
return;
}
@@ -584,12 +584,13 @@ nxt_openssl_conn_io_shutdown(nxt_thread_t *thr, void *obj, void *data)
done:
nxt_event_conn_io_handle(thr, c->write_work_queue, handler, c, data);
nxt_event_conn_io_handle(task->thread, c->write_work_queue, handler,
task, c, data);
}
static nxt_int_t
nxt_openssl_conn_test_error(nxt_thread_t *thr, nxt_event_conn_t *c, int ret,
nxt_openssl_conn_test_error(nxt_task_t *task, nxt_event_conn_t *c, int ret,
nxt_err_t sys_err, nxt_work_handler_t handler)
{
u_long lib_err;
@@ -605,25 +606,25 @@ nxt_openssl_conn_test_error(nxt_thread_t *thr, nxt_event_conn_t *c, int ret,
switch (ssltls->ssl_error) {
case SSL_ERROR_WANT_READ:
nxt_event_fd_block_write(thr->engine, &c->socket);
nxt_event_fd_block_write(task->thread->engine, &c->socket);
c->socket.read_ready = 0;
c->socket.read_handler = handler;
if (nxt_event_fd_is_disabled(c->socket.read)) {
nxt_event_fd_enable_read(thr->engine, &c->socket);
nxt_event_fd_enable_read(task->thread->engine, &c->socket);
}
return NXT_AGAIN;
case SSL_ERROR_WANT_WRITE:
nxt_event_fd_block_read(thr->engine, &c->socket);
nxt_event_fd_block_read(task->thread->engine, &c->socket);
c->socket.write_ready = 0;
c->socket.write_handler = handler;
if (nxt_event_fd_is_disabled(c->socket.write)) {
nxt_event_fd_enable_write(thr->engine, &c->socket);
nxt_event_fd_enable_write(task->thread->engine, &c->socket);
}
return NXT_AGAIN;
@@ -632,7 +633,7 @@ nxt_openssl_conn_test_error(nxt_thread_t *thr, nxt_event_conn_t *c, int ret,
lib_err = ERR_peek_error();
nxt_log_debug(c->socket.log, "ERR_peek_error(): %l", lib_err);
nxt_debug(task, "ERR_peek_error(): %l", lib_err);
if (sys_err != 0 || lib_err != 0) {
return NXT_ERROR;
@@ -655,7 +656,8 @@ nxt_openssl_conn_test_error(nxt_thread_t *thr, nxt_event_conn_t *c, int ret,
handler = c->write_state->close_handler;
}
nxt_event_conn_io_handle(thr, wq, handler, c, c->socket.data);
nxt_event_conn_io_handle(task->thread, wq, handler,
task, c, c->socket.data);
return 0;

44
src/nxt_poll.c
View File

@@ -58,7 +58,7 @@ static nxt_int_t nxt_poll_set_change(nxt_thread_t *thr,
nxt_poll_event_set_t *ps, nxt_poll_change_t *ch);
static nxt_int_t nxt_poll_set_delete(nxt_thread_t *thr,
nxt_poll_event_set_t *ps, nxt_poll_change_t *ch);
static void nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
static void nxt_poll_set_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout);
static nxt_poll_hash_entry_t *nxt_poll_fd_hash_get(nxt_poll_event_set_t *ps,
nxt_fd_t fd);
@@ -398,7 +398,7 @@ nxt_poll_commit_changes(nxt_thread_t *thr, nxt_poll_event_set_t *ps)
}
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
ev->error_handler, ev, ev->data, ev->log);
ev->error_handler, ev->task, ev, ev->data);
ret = NXT_ERROR;
@@ -534,7 +534,7 @@ nxt_poll_set_delete(nxt_thread_t *thr, nxt_poll_event_set_t *ps,
static void
nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_poll_set_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout)
{
int nevents;
@@ -556,19 +556,19 @@ nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
}
}
nxt_log_debug(thr->log, "poll() events:%ui timeout:%M", ps->nfds, timeout);
nxt_debug(task, "poll() events:%ui timeout:%M", ps->nfds, timeout);
nevents = poll(ps->poll_set, ps->nfds, timeout);
err = (nevents == -1) ? nxt_errno : 0;
nxt_thread_time_update(thr);
nxt_thread_time_update(task->thread);
nxt_log_debug(thr->log, "poll(): %d", nevents);
nxt_debug(task, "poll(): %d", nevents);
if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log_error(level, thr->log, "poll() failed %E", err);
nxt_log(task, level, "poll() failed %E", err);
return;
}
@@ -586,9 +586,9 @@ nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
phe = nxt_poll_fd_hash_get(ps, fd);
if (nxt_slow_path(phe == NULL)) {
nxt_log_alert(thr->log,
"poll() returned invalid fd:%d ev:%04Xd rev:%04uXi",
fd, pfd->events, events);
nxt_log(task, NXT_LOG_CRIT,
"poll() returned invalid fd:%d ev:%04Xd rev:%04uXi",
fd, pfd->events, events);
/* Mark the poll entry to ignore it by the kernel. */
pfd->fd = -1;
@@ -597,18 +597,21 @@ nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
ev = phe->event;
nxt_log_debug(ev->log, "poll: fd:%d ev:%04uXi rd:%d %wr:%d",
fd, events, ev->read, ev->write);
nxt_debug(ev->task, "poll: fd:%d ev:%04uXi rd:%d %wr:%d",
fd, events, ev->read, ev->write);
if (nxt_slow_path((events & POLLNVAL) != 0)) {
nxt_log_alert(ev->log, "poll() error fd:%d ev:%04Xd rev:%04uXi",
fd, pfd->events, events);
nxt_log(ev->task, NXT_LOG_CRIT,
"poll() error fd:%d ev:%04Xd rev:%04uXi",
fd, pfd->events, events);
/* Mark the poll entry to ignore it by the kernel. */
pfd->fd = -1;
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
ev->error_handler, ev, ev->data, ev->log);
nxt_thread_work_queue_add(task->thread,
&task->thread->work_queue.main,
ev->error_handler,
ev->task, ev, ev->data);
goto next;
}
@@ -650,8 +653,8 @@ nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_poll_change(event_set, ev, NXT_POLL_DELETE, 0);
}
nxt_thread_work_queue_add(thr, ev->read_work_queue,
ev->read_handler, ev, ev->data, ev->log);
nxt_thread_work_queue_add(task->thread, ev->read_work_queue,
ev->read_handler, ev->task, ev, ev->data);
}
if ((events & POLLOUT) || (error && ev->write_handler != NULL)) {
@@ -662,8 +665,9 @@ nxt_poll_set_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_poll_change(event_set, ev, NXT_POLL_DELETE, 0);
}
nxt_thread_work_queue_add(thr, ev->write_work_queue,
ev->write_handler, ev, ev->data, ev->log);
nxt_thread_work_queue_add(task->thread, ev->write_work_queue,
ev->write_handler,
ev->task, ev, ev->data);
}
next:

62
src/nxt_process_chan.c
View File

@@ -9,9 +9,9 @@
#include <nxt_process_chan.h>
static void nxt_process_chan_handler(nxt_thread_t *thr,
static void nxt_process_chan_handler(nxt_task_t *task,
nxt_chan_recv_msg_t *msg);
static void nxt_process_new_chan_buf_completion(nxt_thread_t *thr, void *obj,
static void nxt_process_new_chan_buf_completion(nxt_task_t *task, void *obj,
void *data);
@@ -25,13 +25,13 @@ nxt_process_chan_create(nxt_thread_t *thr, nxt_process_chan_t *proc,
proc->chan->data = handlers;
nxt_chan_write_close(proc->chan);
nxt_chan_read_enable(thr, proc->chan);
nxt_chan_read_enable(&thr->engine->task, proc->chan);
}
void
nxt_process_chan_write(nxt_cycle_t *cycle, nxt_uint_t type, nxt_fd_t fd,
uint32_t stream, nxt_buf_t *b)
nxt_process_chan_write(nxt_task_t *task, nxt_cycle_t *cycle, nxt_uint_t type,
nxt_fd_t fd, uint32_t stream, nxt_buf_t *b)
{
nxt_uint_t i, n;
nxt_process_chan_t *proc;
@@ -41,42 +41,43 @@ nxt_process_chan_write(nxt_cycle_t *cycle, nxt_uint_t type, nxt_fd_t fd,
for (i = 0; i < n; i++) {
if (nxt_pid != proc[i].pid) {
(void) nxt_chan_write(proc[i].chan, type, fd, stream, b);
(void) nxt_chan_write(task, proc[i].chan, type, fd, stream, b);
}
}
}
static void
nxt_process_chan_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
nxt_process_chan_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg)
{
nxt_process_chan_handler_t *handlers;
if (nxt_fast_path(msg->type <= NXT_CHAN_MSG_MAX)) {
nxt_log_debug(thr->log, "chan %d: message type:%uD",
msg->chan->socket.fd, msg->type);
nxt_debug(task, "chan %d: message type:%uD",
msg->chan->socket.fd, msg->type);
handlers = msg->chan->data;
handlers[msg->type](thr, msg);
handlers[msg->type](task, msg);
return;
}
nxt_log_alert(thr->log, "chan %d: unknown message type:%uD",
msg->chan->socket.fd, msg->type);
nxt_log(task, NXT_LOG_CRIT, "chan %d: unknown message type:%uD",
msg->chan->socket.fd, msg->type);
}
void
nxt_process_chan_quit_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
nxt_process_chan_quit_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg)
{
nxt_cycle_quit(thr, NULL);
nxt_cycle_quit(task, NULL);
}
void
nxt_process_new_chan(nxt_cycle_t *cycle, nxt_process_chan_t *proc)
nxt_process_new_chan(nxt_task_t *task, nxt_cycle_t *cycle,
nxt_process_chan_t *proc)
{
nxt_buf_t *b;
nxt_uint_t i, n;
@@ -116,14 +117,14 @@ nxt_process_new_chan(nxt_cycle_t *cycle, nxt_process_chan_t *proc)
new_chan->max_size = p[i].chan->max_size;
new_chan->max_share = p[i].chan->max_share;
(void) nxt_chan_write(p[i].chan, NXT_CHAN_MSG_NEW_CHAN,
(void) nxt_chan_write(task, p[i].chan, NXT_CHAN_MSG_NEW_CHAN,
proc->chan->socket.fd, 0, b);
}
}
static void
nxt_process_new_chan_buf_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_process_new_chan_buf_completion(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_chan_t *chan;
@@ -138,7 +139,7 @@ nxt_process_new_chan_buf_completion(nxt_thread_t *thr, void *obj, void *data)
void
nxt_process_chan_new_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
nxt_process_chan_new_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg)
{
nxt_chan_t *chan;
nxt_cycle_t *cycle;
@@ -162,8 +163,8 @@ nxt_process_chan_new_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
new_chan = (nxt_proc_msg_new_chan_t *) msg->buf->mem.pos;
msg->buf->mem.pos = msg->buf->mem.free;
nxt_log_debug(thr->log, "new chan %d received for process %PI engine %uD",
msg->fd, new_chan->pid, new_chan->engine);
nxt_debug(task, "new chan %d received for process %PI engine %uD",
msg->fd, new_chan->pid, new_chan->engine);
proc->pid = new_chan->pid;
proc->engine = new_chan->engine;
@@ -172,13 +173,13 @@ nxt_process_chan_new_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
chan->max_share = new_chan->max_share;
/* A read chan is not passed at all. */
nxt_chan_write_enable(thr, chan);
nxt_chan_write_enable(task, chan);
}
void
nxt_process_chan_change_log_file(nxt_cycle_t *cycle, nxt_uint_t slot,
nxt_fd_t fd)
nxt_process_chan_change_log_file(nxt_task_t *task, nxt_cycle_t *cycle,
nxt_uint_t slot, nxt_fd_t fd)
{
nxt_buf_t *b;
nxt_uint_t i, n;
@@ -206,13 +207,14 @@ nxt_process_chan_change_log_file(nxt_cycle_t *cycle, nxt_uint_t slot,
*(nxt_uint_t *) b->mem.pos = slot;
b->mem.free += sizeof(nxt_uint_t);
(void) nxt_chan_write(p[i].chan, NXT_CHAN_MSG_CHANGE_FILE, fd, 0, b);
(void) nxt_chan_write(task, p[i].chan, NXT_CHAN_MSG_CHANGE_FILE,
fd, 0, b);
}
}
void
nxt_process_chan_change_log_file_handler(nxt_thread_t *thr,
nxt_process_chan_change_log_file_handler(nxt_task_t *task,
nxt_chan_recv_msg_t *msg)
{
nxt_buf_t *b;
@@ -227,7 +229,7 @@ nxt_process_chan_change_log_file_handler(nxt_thread_t *thr,
log_file = nxt_list_elt(cycle->log_files, slot);
nxt_log_debug(thr->log, "change log file %FD:%FD", msg->fd, log_file->fd);
nxt_debug(task, "change log file %FD:%FD", msg->fd, log_file->fd);
/*
* The old log file descriptor must be closed at the moment when no
@@ -244,20 +246,20 @@ nxt_process_chan_change_log_file_handler(nxt_thread_t *thr,
void
nxt_process_chan_data_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
nxt_process_chan_data_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg)
{
nxt_buf_t *b;
b = msg->buf;
nxt_log_debug(thr->log, "data: %*s", b->mem.free - b->mem.pos, b->mem.pos);
nxt_debug(task, "data: %*s", b->mem.free - b->mem.pos, b->mem.pos);
b->mem.pos = b->mem.free;
}
void
nxt_process_chan_empty_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
nxt_process_chan_empty_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg)
{
nxt_log_debug(thr->log, "chan empty handler");
nxt_debug(task, "chan empty handler");
}

24
src/nxt_process_chan.h
View File

@@ -44,25 +44,25 @@ typedef union {
} nxt_process_chan_data_t;
typedef void (*nxt_process_chan_handler_t)(nxt_thread_t *thr,
typedef void (*nxt_process_chan_handler_t)(nxt_task_t *task,
nxt_chan_recv_msg_t *msg);
void nxt_process_chan_create(nxt_thread_t *thr, nxt_process_chan_t *proc,
nxt_process_chan_handler_t *handlers);
void nxt_process_chan_write(nxt_cycle_t *cycle, nxt_uint_t type,
nxt_fd_t fd, uint32_t stream, nxt_buf_t *b);
void nxt_process_new_chan(nxt_cycle_t *cycle, nxt_process_chan_t *proc);
void nxt_process_chan_change_log_file(nxt_cycle_t *cycle, nxt_uint_t slot,
nxt_fd_t fd);
void nxt_process_chan_write(nxt_task_t *task, nxt_cycle_t *cycle,
nxt_uint_t type, nxt_fd_t fd, uint32_t stream, nxt_buf_t *b);
void nxt_process_new_chan(nxt_task_t *task, nxt_cycle_t *cycle,
nxt_process_chan_t *proc);
void nxt_process_chan_change_log_file(nxt_task_t *task, nxt_cycle_t *cycle,
nxt_uint_t slot, nxt_fd_t fd);
void nxt_process_chan_quit_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg);
void nxt_process_chan_new_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg);
void nxt_process_chan_change_log_file_handler(nxt_thread_t *thr,
nxt_chan_recv_msg_t *msg);
void nxt_process_chan_data_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg);
void nxt_process_chan_empty_handler(nxt_thread_t *thr,
void nxt_process_chan_quit_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg);
void nxt_process_chan_new_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg);
void nxt_process_chan_change_log_file_handler(nxt_task_t *task,
nxt_chan_recv_msg_t *msg);
void nxt_process_chan_data_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg);
void nxt_process_chan_empty_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg);
#endif /* _NXT_PROCESS_CHAN_H_INCLUDED_ */

36
src/nxt_select.c
View File

@@ -16,8 +16,7 @@ static void nxt_select_enable_read(nxt_event_set_t *event_set,
nxt_event_fd_t *ev);
static void nxt_select_enable_write(nxt_event_set_t *event_set,
nxt_event_fd_t *ev);
static void nxt_select_error_handler(nxt_thread_t *thr, void *obj,
void *data);
static void nxt_select_error_handler(nxt_task_t *task, void *obj, void *data);
static void nxt_select_disable_read(nxt_event_set_t *event_set,
nxt_event_fd_t *ev);
static void nxt_select_disable_write(nxt_event_set_t *event_set,
@@ -30,7 +29,7 @@ static void nxt_select_oneshot_read(nxt_event_set_t *event_set,
nxt_event_fd_t *ev);
static void nxt_select_oneshot_write(nxt_event_set_t *event_set,
nxt_event_fd_t *ev);
static void nxt_select_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
static void nxt_select_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout);
@@ -144,7 +143,7 @@ nxt_select_enable_read(nxt_event_set_t *event_set, nxt_event_fd_t *ev)
thr = nxt_thread();
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_select_error_handler,
ev, ev->data, ev->log);
ev->task, ev, ev->data);
return;
}
@@ -177,7 +176,7 @@ nxt_select_enable_write(nxt_event_set_t *event_set, nxt_event_fd_t *ev)
thr = nxt_thread();
nxt_thread_work_queue_add(thr, &thr->work_queue.main,
nxt_select_error_handler,
ev, ev->data, ev->log);
ev->task, ev, ev->data);
return;
}
@@ -194,7 +193,7 @@ nxt_select_enable_write(nxt_event_set_t *event_set, nxt_event_fd_t *ev)
static void
nxt_select_error_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_select_error_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_event_fd_t *ev;
@@ -203,7 +202,7 @@ nxt_select_error_handler(nxt_thread_t *thr, void *obj, void *data)
ev->read = NXT_EVENT_INACTIVE;
ev->write = NXT_EVENT_INACTIVE;
ev->error_handler(thr, ev, data);
ev->error_handler(task, ev, data);
}
@@ -296,7 +295,7 @@ nxt_select_oneshot_write(nxt_event_set_t *event_set, nxt_event_fd_t *ev)
static void
nxt_select_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_select_poll(nxt_task_t *task, nxt_event_set_t *event_set,
nxt_msec_t timeout)
{
int nevents, nfds, found;
@@ -333,20 +332,20 @@ nxt_select_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nfds = ss->nfds + 1;
nxt_log_debug(thr->log, "select() nfds:%d timeout:%M", nfds, timeout);
nxt_debug(task, "select() nfds:%d timeout:%M", nfds, timeout);
nevents = select(nfds, &ss->work_read_fd_set, &ss->work_write_fd_set,
NULL, tp);
err = (nevents == -1) ? nxt_errno : 0;
nxt_thread_time_update(thr);
nxt_thread_time_update(task->thread);
nxt_log_debug(thr->log, "select(): %d", nevents);
nxt_debug(task, "select(): %d", nevents);
if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log_error(level, thr->log, "select() failed %E", err);
nxt_log(task, level, "select() failed %E", err);
return;
}
@@ -357,8 +356,8 @@ nxt_select_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
if (FD_ISSET(fd, &ss->work_read_fd_set)) {
ev = ss->events[fd];
nxt_log_debug(ev->log, "select() fd:%ui read rd:%d wr:%d",
fd, ev->read, ev->write);
nxt_debug(ev->task, "select() fd:%ui read rd:%d wr:%d",
fd, ev->read, ev->write);
ev->read_ready = 1;
@@ -366,8 +365,8 @@ nxt_select_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_select_disable_read(event_set, ev);
}
nxt_thread_work_queue_add(thr, ev->read_work_queue,
ev->read_handler, ev, ev->data, ev->log);
nxt_thread_work_queue_add(task->thread, ev->read_work_queue,
ev->read_handler, ev->task, ev, ev->data);
found = 1;
}
@@ -383,8 +382,9 @@ nxt_select_poll(nxt_thread_t *thr, nxt_event_set_t *event_set,
nxt_select_disable_write(event_set, ev);
}
nxt_thread_work_queue_add(thr, ev->write_work_queue,
ev->write_handler, ev, ev->data, ev->log);
nxt_thread_work_queue_add(task->thread, ev->write_work_queue,
ev->write_handler,
ev->task, ev, ev->data);
found = 1;
}

14
src/nxt_sendbuf.c
View File

@@ -12,7 +12,7 @@ static nxt_bool_t nxt_sendbuf_copy(nxt_buf_mem_t *bm, nxt_buf_t *b,
nxt_uint_t
nxt_sendbuf_mem_coalesce(nxt_sendbuf_coalesce_t *sb)
nxt_sendbuf_mem_coalesce(nxt_task_t *task, nxt_sendbuf_coalesce_t *sb)
{
u_char *last;
size_t size, total;
@@ -57,9 +57,9 @@ nxt_sendbuf_mem_coalesce(nxt_sendbuf_coalesce_t *sb)
nxt_iobuf_add(&sb->iobuf[n], size);
}
nxt_thread_log_debug("sendbuf: %ui, %p, %uz", n,
nxt_iobuf_data(&sb->iobuf[n]),
nxt_iobuf_size(&sb->iobuf[n]));
nxt_debug(task, "sendbuf: %ui, %p, %uz", n,
nxt_iobuf_data(&sb->iobuf[n]),
nxt_iobuf_size(&sb->iobuf[n]));
total += size;
last = b->mem.pos + size;
@@ -300,7 +300,7 @@ nxt_sendbuf_update(nxt_buf_t *b, size_t sent)
nxt_buf_t *
nxt_sendbuf_completion(nxt_thread_t *thr, nxt_work_queue_t *wq, nxt_buf_t *b,
nxt_sendbuf_completion(nxt_task_t *task, nxt_work_queue_t *wq, nxt_buf_t *b,
size_t sent)
{
size_t size;
@@ -343,8 +343,8 @@ nxt_sendbuf_completion(nxt_thread_t *thr, nxt_work_queue_t *wq, nxt_buf_t *b,
}
}
nxt_thread_work_queue_add(thr, wq, b->completion_handler,
b, b->parent, thr->log);
nxt_thread_work_queue_add(task->thread, wq, b->completion_handler, task,
b, b->parent);
b = b->next;
}

5
src/nxt_sendbuf.h
View File

@@ -88,7 +88,8 @@ ssize_t nxt_event_conn_io_sendbuf(nxt_event_conn_t *c, nxt_buf_t *b,
size_t limit);
nxt_uint_t nxt_sendbuf_mem_coalesce(nxt_sendbuf_coalesce_t *sb);
nxt_uint_t nxt_sendbuf_mem_coalesce(nxt_task_t *task,
nxt_sendbuf_coalesce_t *sb);
size_t nxt_sendbuf_file_coalesce(nxt_sendbuf_coalesce_t *sb);
/*
@@ -101,7 +102,7 @@ ssize_t nxt_sendbuf_copy_coalesce(nxt_event_conn_t *c, nxt_buf_mem_t *bm,
nxt_buf_t *b, size_t limit);
nxt_buf_t *nxt_sendbuf_update(nxt_buf_t *b, size_t sent);
nxt_buf_t *nxt_sendbuf_completion(nxt_thread_t *thr, nxt_work_queue_t *wq,
nxt_buf_t *nxt_sendbuf_completion(nxt_task_t *task, nxt_work_queue_t *wq,
nxt_buf_t *b, size_t sent);

2
src/nxt_sockaddr.c
View File

@@ -495,7 +495,7 @@ nxt_job_sockaddr_parse(nxt_job_sockaddr_parse_t *jbs)
return;
}
nxt_job_return(nxt_thread(), &jbs->resolve.job, handler);
nxt_job_return(&jbs->resolve.job.task, &jbs->resolve.job, handler);
}

29
src/nxt_socketpair.c
View File

@@ -82,8 +82,7 @@ nxt_socketpair_send(nxt_event_fd_t *ev, nxt_fd_t fd, nxt_iobuf_t *iob,
err = (n == -1) ? nxt_socket_errno : 0;
nxt_log_debug(ev->log, "sendmsg(%d, %FD, %ui): %z",
ev->fd, fd, niob, n);
nxt_debug(ev->task, "sendmsg(%d, %FD, %ui): %z", ev->fd, fd, niob, n);
if (n > 0) {
return n;
@@ -94,18 +93,19 @@ nxt_socketpair_send(nxt_event_fd_t *ev, nxt_fd_t fd, nxt_iobuf_t *iob,
switch (err) {
case NXT_EAGAIN:
nxt_log_debug(ev->log, "sendmsg(%d) not ready", ev->fd);
nxt_debug(ev->task, "sendmsg(%d) not ready", ev->fd);
ev->write_ready = 0;
return NXT_AGAIN;
case NXT_EINTR:
nxt_log_debug(ev->log, "sendmsg(%d) interrupted", ev->fd);
nxt_debug(ev->task, "sendmsg(%d) interrupted", ev->fd);
continue;
default:
nxt_log_error(NXT_LOG_CRIT, ev->log,
"sendmsg(%d, %FD, %ui) failed %E",
ev->fd, fd, niob, err);
nxt_log(ev->task, NXT_LOG_CRIT, "sendmsg(%d, %FD, %ui) failed %E",
ev->fd, fd, niob, err);
return NXT_ERROR;
}
}
@@ -124,8 +124,7 @@ nxt_socketpair_recv(nxt_event_fd_t *ev, nxt_fd_t *fd, nxt_iobuf_t *iob,
err = (n == -1) ? nxt_socket_errno : 0;
nxt_log_debug(ev->log, "recvmsg(%d, %FD, %ui): %z",
ev->fd, *fd, niob, n);
nxt_debug(ev->task, "recvmsg(%d, %FD, %ui): %z", ev->fd, *fd, niob, n);
if (n > 0) {
return n;
@@ -134,6 +133,7 @@ nxt_socketpair_recv(nxt_event_fd_t *ev, nxt_fd_t *fd, nxt_iobuf_t *iob,
if (n == 0) {
ev->closed = 1;
ev->read_ready = 0;
return n;
}
@@ -142,18 +142,19 @@ nxt_socketpair_recv(nxt_event_fd_t *ev, nxt_fd_t *fd, nxt_iobuf_t *iob,
switch (err) {
case NXT_EAGAIN:
nxt_log_debug(ev->log, "recvmsg(%d) not ready", ev->fd);
nxt_debug(ev->task, "recvmsg(%d) not ready", ev->fd);
ev->read_ready = 0;
return NXT_AGAIN;
case NXT_EINTR:
nxt_log_debug(ev->log, "recvmsg(%d) interrupted", ev->fd);
nxt_debug(ev->task, "recvmsg(%d) interrupted", ev->fd);
continue;
default:
nxt_log_error(NXT_LOG_CRIT, ev->log,
"recvmsg(%d, %p, %ui) failed %E",
ev->fd, fd, niob, err);
nxt_log(ev->task, NXT_LOG_CRIT, "recvmsg(%d, %p, %ui) failed %E",
ev->fd, fd, niob, err);
return NXT_ERROR;
}
}

8
src/nxt_source.h
View File

@@ -23,20 +23,20 @@ typedef void (*nxt_source_handler_t)(void *source_context,
#define \
nxt_source_filter(thr, wq, next, out) \
nxt_source_filter(thr, wq, task, next, out) \
do { \
if (thr->engine->batch != 0) { \
nxt_thread_work_queue_add(thr, wq, nxt_source_filter_handler, \
next, out, thr->log); \
task, next, out); \
\
} else { \
(next)->filter(thr, (next)->context, out); \
(next)->filter(task, (next)->context, out); \
} \
\
} while (0)
NXT_EXPORT void nxt_source_filter_handler(nxt_thread_t *thr, void *obj,
NXT_EXPORT void nxt_source_filter_handler(nxt_task_t *task, void *obj,
void *data);

2
src/nxt_ssltls.h
View File

@@ -34,7 +34,7 @@ typedef struct {
struct nxt_ssltls_conf_s {
void *ctx;
void (*conn_init)(nxt_thread_t *thr,
void (*conn_init)(nxt_task_t *task,
nxt_ssltls_conf_t *conf,
nxt_event_conn_t *c);

130
src/nxt_stream_source.c
View File

@@ -7,22 +7,22 @@
#include <nxt_main.h>
static void nxt_stream_source_connected(nxt_thread_t *thr, void *obj,
static void nxt_stream_source_connected(nxt_task_t *task, void *obj,
void *data);
static void nxt_stream_source_write_ready(nxt_thread_t *thr, void *obj,
static void nxt_stream_source_write_ready(nxt_task_t *task, void *obj,
void *data);
static void nxt_stream_source_read_ready(nxt_thread_t *thr, void *obj,
static void nxt_stream_source_read_ready(nxt_task_t *task, void *obj,
void *data);
static nxt_buf_t *nxt_stream_source_process_buffers(nxt_stream_source_t *stream,
nxt_event_conn_t *c);
static void nxt_stream_source_buf_completion(nxt_thread_t *thr, void *obj,
static void nxt_stream_source_buf_completion(nxt_task_t *task, void *obj,
void *data);
static void nxt_stream_source_read_done(nxt_thread_t *thr, void *obj,
static void nxt_stream_source_read_done(nxt_task_t *task, void *obj,
void *data);
static void nxt_stream_source_refused(nxt_thread_t *thr, void *obj, void *data);
static void nxt_stream_source_closed(nxt_thread_t *thr, void *obj, void *data);
static void nxt_stream_source_error(nxt_thread_t *thr, void *obj, void *data);
static void nxt_stream_source_close(nxt_thread_t *thr,
static void nxt_stream_source_refused(nxt_task_t *task, void *obj, void *data);
static void nxt_stream_source_closed(nxt_task_t *task, void *obj, void *data);
static void nxt_stream_source_error(nxt_task_t *task, void *obj, void *data);
static void nxt_stream_source_close(nxt_task_t *task,
nxt_stream_source_t *stream);
@@ -33,7 +33,7 @@ static const nxt_event_conn_state_t nxt_stream_source_response_read_state;
void
nxt_stream_source_connect(nxt_stream_source_t *stream)
nxt_stream_source_connect(nxt_task_t *task, nxt_stream_source_t *stream)
{
nxt_thread_t *thr;
nxt_event_conn_t *c;
@@ -44,9 +44,9 @@ nxt_stream_source_connect(nxt_stream_source_t *stream)
us = stream->upstream;
if (nxt_slow_path(!nxt_buf_pool_obtainable(&us->buffers))) {
nxt_thread_log_error(NXT_LOG_ERR, "%d buffers %uDK each "
"are not enough to read upstream response",
us->buffers.max, us->buffers.size / 1024);
nxt_log(task, NXT_LOG_ERR,
"%d buffers %uDK each are not enough to read upstream response",
us->buffers.max, us->buffers.size / 1024);
goto fail;
}
@@ -63,12 +63,12 @@ nxt_stream_source_connect(nxt_stream_source_t *stream)
c->remote = us->peer->sockaddr;
c->write_state = &nxt_stream_source_connect_state;
nxt_event_conn_connect(thr, c);
nxt_event_conn_connect(task, c);
return;
fail:
stream->error_handler(stream);
stream->error_handler(task, stream);
}
@@ -89,7 +89,7 @@ static const nxt_event_conn_state_t nxt_stream_source_connect_state
static void
nxt_stream_source_connected(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_connected(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
nxt_stream_source_t *stream;
@@ -97,21 +97,22 @@ nxt_stream_source_connected(nxt_thread_t *thr, void *obj, void *data)
c = obj;
stream = data;
nxt_log_debug(thr->log, "stream source connected fd:%d", c->socket.fd);
nxt_debug(task, "stream source connected fd:%d", c->socket.fd);
c->read_state = &nxt_stream_source_response_ready_state;
c->write = stream->out;
c->write_state = &nxt_stream_source_request_write_state;
if (thr->engine->batch != 0) {
nxt_event_conn_write(thr, c);
if (task->thread->engine->batch != 0) {
nxt_event_conn_write(task, c);
} else {
stream->read_queued = 1;
nxt_thread_work_queue_add(thr, &thr->engine->read_work_queue,
c->io->read, c, stream, thr->log);
nxt_thread_work_queue_add(task->thread,
&task->thread->engine->read_work_queue,
c->io->read, task, c, stream);
c->io->write(thr, c, stream);
c->io->write(task, c, stream);
}
}
@@ -149,20 +150,20 @@ static const nxt_event_conn_state_t nxt_stream_source_response_ready_state
static void
nxt_stream_source_write_ready(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_write_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_event_conn_t *c;
c = obj;
nxt_log_debug(thr->log, "stream source write ready fd:%d", c->socket.fd);
nxt_debug(task, "stream source write ready fd:%d", c->socket.fd);
nxt_event_conn_read(thr, c);
nxt_event_conn_read(task, c);
}
static void
nxt_stream_source_read_ready(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_read_ready(nxt_task_t *task, void *obj, void *data)
{
nxt_int_t ret;
nxt_buf_t *b;
@@ -174,7 +175,7 @@ nxt_stream_source_read_ready(nxt_thread_t *thr, void *obj, void *data)
stream = data;
stream->read_queued = 0;
nxt_log_debug(thr->log, "stream source read ready fd:%d", c->socket.fd);
nxt_debug(task, "stream source read ready fd:%d", c->socket.fd);
if (c->read == NULL) {
@@ -190,7 +191,7 @@ nxt_stream_source_read_ready(nxt_thread_t *thr, void *obj, void *data)
/* ret == NXT_AGAIN */
nxt_log_debug(thr->log, "stream source flush");
nxt_debug(task, "stream source flush");
b = nxt_buf_sync_alloc(buffers->mem_pool, NXT_BUF_SYNC_NOBUF);
@@ -198,9 +199,10 @@ nxt_stream_source_read_ready(nxt_thread_t *thr, void *obj, void *data)
goto fail;
}
nxt_event_fd_block_read(thr->engine, &c->socket);
nxt_event_fd_block_read(task->thread->engine, &c->socket);
nxt_source_filter(thr, c->write_work_queue, stream->next, b);
nxt_source_filter(task->thread, c->write_work_queue, task,
stream->next, b);
return;
}
@@ -210,12 +212,12 @@ nxt_stream_source_read_ready(nxt_thread_t *thr, void *obj, void *data)
c->read_state = &nxt_stream_source_response_read_state;
nxt_event_conn_read(thr, c);
nxt_event_conn_read(task, c);
return;
fail:
nxt_stream_source_close(thr, stream);
nxt_stream_source_close(task, stream);
}
@@ -236,7 +238,7 @@ static const nxt_event_conn_state_t nxt_stream_source_response_read_state
static void
nxt_stream_source_read_done(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_read_done(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_bool_t batch;
@@ -246,33 +248,35 @@ nxt_stream_source_read_done(nxt_thread_t *thr, void *obj, void *data)
c = obj;
stream = data;
nxt_log_debug(thr->log, "stream source read done fd:%d", c->socket.fd);
nxt_debug(task, "stream source read done fd:%d", c->socket.fd);
if (c->read != NULL) {
b = nxt_stream_source_process_buffers(stream, c);
if (nxt_slow_path(b == NULL)) {
nxt_stream_source_close(thr, stream);
nxt_stream_source_close(task, stream);
return;
}
batch = (thr->engine->batch != 0);
batch = (task->thread->engine->batch != 0);
if (batch) {
nxt_thread_work_queue_add(thr, stream->upstream->work_queue,
nxt_thread_work_queue_add(task->thread,
stream->upstream->work_queue,
nxt_source_filter_handler,
stream->next, b, thr->log);
task, stream->next, b);
}
if (!stream->read_queued) {
stream->read_queued = 1;
nxt_thread_work_queue_add(thr, stream->upstream->work_queue,
nxt_thread_work_queue_add(task->thread,
stream->upstream->work_queue,
nxt_stream_source_read_ready,
c, stream, thr->log);
task, c, stream);
}
if (!batch) {
stream->next->filter(thr, stream->next->context, b);
stream->next->filter(task, stream->next->context, b);
}
}
}
@@ -335,7 +339,7 @@ nxt_stream_source_process_buffers(nxt_stream_source_t *stream,
static void
nxt_stream_source_buf_completion(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_buf_completion(nxt_task_t *task, void *obj, void *data)
{
size_t size;
nxt_buf_t *b, *parent;
@@ -345,7 +349,7 @@ nxt_stream_source_buf_completion(nxt_thread_t *thr, void *obj, void *data)
parent = data;
#if 0
nxt_log_debug(thr->log,
nxt_debug(thr->log,
"stream source buf completion: %p parent:%p retain:%uD",
b, parent, parent->retain);
#endif
@@ -375,11 +379,11 @@ nxt_stream_source_buf_completion(nxt_thread_t *thr, void *obj, void *data)
if (!stream->read_queued) {
stream->read_queued = 1;
nxt_thread_work_queue_add(thr, stream->upstream->work_queue,
nxt_thread_work_queue_add(task->thread,
stream->upstream->work_queue,
nxt_stream_source_read_ready,
stream->conn,
stream->conn->socket.data,
stream->conn->socket.log);
task, stream->conn,
stream->conn->socket.data);
}
}
}
@@ -389,7 +393,7 @@ nxt_stream_source_buf_completion(nxt_thread_t *thr, void *obj, void *data)
static void
nxt_stream_source_refused(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_refused(nxt_task_t *task, void *obj, void *data)
{
nxt_stream_source_t *stream;
@@ -401,16 +405,16 @@ nxt_stream_source_refused(nxt_thread_t *thr, void *obj, void *data)
c = obj;
nxt_log_debug(thr->log, "stream source refused fd:%d", c->socket.fd);
nxt_debug(task, "stream source refused fd:%d", c->socket.fd);
}
#endif
nxt_stream_source_close(thr, stream);
nxt_stream_source_close(task, stream);
}
static void
nxt_stream_source_closed(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_closed(nxt_task_t *task, void *obj, void *data)
{
nxt_buf_t *b;
nxt_event_conn_t *c;
@@ -419,24 +423,24 @@ nxt_stream_source_closed(nxt_thread_t *thr, void *obj, void *data)
c = obj;
stream = data;
nxt_log_debug(thr->log, "stream source closed fd:%d", c->socket.fd);
nxt_debug(task, "stream source closed fd:%d", c->socket.fd);
nxt_event_conn_close(thr, c);
nxt_event_conn_close(task, c);
b = nxt_buf_sync_alloc(stream->upstream->buffers.mem_pool,
NXT_BUF_SYNC_LAST);
if (nxt_slow_path(b == NULL)) {
stream->error_handler(stream);
stream->error_handler(task, stream);
return;
}
nxt_source_filter(thr, c->write_work_queue, stream->next, b);
nxt_source_filter(task->thread, c->write_work_queue, task, stream->next, b);
}
static void
nxt_stream_source_error(nxt_thread_t *thr, void *obj, void *data)
nxt_stream_source_error(nxt_task_t *task, void *obj, void *data)
{
nxt_stream_source_t *stream;
@@ -448,29 +452,29 @@ nxt_stream_source_error(nxt_thread_t *thr, void *obj, void *data)
ev = obj;
nxt_log_debug(thr->log, "stream source error fd:%d", ev->fd);
nxt_debug(task, "stream source error fd:%d", ev->fd);
}
#endif
nxt_stream_source_close(thr, stream);
nxt_stream_source_close(task, stream);
}
static void
nxt_stream_source_close(nxt_thread_t *thr, nxt_stream_source_t *stream)
nxt_stream_source_close(nxt_task_t *task, nxt_stream_source_t *stream)
{
nxt_event_conn_close(thr, stream->conn);
nxt_event_conn_close(task, stream->conn);
stream->error_handler(stream);
stream->error_handler(task, stream);
}
void
nxt_source_filter_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_source_filter_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_source_hook_t *next;
next = obj;
next->filter(thr, next->context, data);
next->filter(task, next->context, data);
}

5
src/nxt_stream_source.h
View File

@@ -10,7 +10,8 @@
typedef struct nxt_stream_source_s nxt_stream_source_t;
typedef void (*nxt_stream_source_handler_t)(nxt_stream_source_t *u);
typedef void (*nxt_stream_source_handler_t)(nxt_task_t *task,
nxt_stream_source_t *s);
struct nxt_stream_source_s {
nxt_event_conn_t *conn;
@@ -25,7 +26,7 @@ struct nxt_stream_source_s {
};
void nxt_stream_source_connect(nxt_stream_source_t *stream);
void nxt_stream_source_connect(nxt_task_t *task, nxt_stream_source_t *stream);
#endif /* _NXT_STREAM_SOURCE_H_INCLUDED_ */

5
src/nxt_thread.c
View File

@@ -184,8 +184,9 @@ nxt_thread_exit(nxt_thread_t *thr)
if (thr->link != NULL) {
nxt_event_engine_post(thr->link->engine, thr->link->exit,
(void *) (uintptr_t) thr->handle, NULL,
&nxt_main_log);
&thr->link->engine->task,
(void *) (uintptr_t) thr->handle,
NULL, &nxt_main_log);
nxt_free(thr->link);
thr->link = NULL;

54
src/nxt_thread_pool.c
View File

@@ -8,7 +8,7 @@
static nxt_int_t nxt_thread_pool_init(nxt_thread_pool_t *tp);
static void nxt_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data);
static void nxt_thread_pool_exit(nxt_task_t *task, void *obj, void *data);
static void nxt_thread_pool_start(void *ctx);
static void nxt_thread_pool_wait(nxt_thread_pool_t *tp);
@@ -28,6 +28,8 @@ nxt_thread_pool_create(nxt_uint_t max_threads, nxt_nsec_t timeout,
tp->max_threads = max_threads;
tp->timeout = timeout;
tp->engine = engine;
tp->task.thread = engine->task.thread;
tp->task.log = engine->task.log;
tp->init = init;
tp->exit = exit;
@@ -37,7 +39,7 @@ nxt_thread_pool_create(nxt_uint_t max_threads, nxt_nsec_t timeout,
nxt_int_t
nxt_thread_pool_post(nxt_thread_pool_t *tp, nxt_work_handler_t handler,
void *obj, void *data, nxt_log_t *log)
nxt_task_t *task, void *obj, void *data)
{
nxt_thread_log_debug("thread pool post");
@@ -45,7 +47,7 @@ nxt_thread_pool_post(nxt_thread_pool_t *tp, nxt_work_handler_t handler,
return NXT_ERROR;
}
nxt_locked_work_queue_add(&tp->work_queue, handler, obj, data, log);
nxt_locked_work_queue_add(&tp->work_queue, handler, task, obj, data);
(void) nxt_sem_post(&tp->sem);
@@ -117,6 +119,7 @@ static void
nxt_thread_pool_start(void *ctx)
{
void *obj, *data;
nxt_task_t *task;
nxt_thread_t *thr;
nxt_thread_pool_t *tp;
nxt_work_handler_t handler;
@@ -129,6 +132,8 @@ nxt_thread_pool_start(void *ctx)
tp->main = thr->handle;
nxt_free(thr->link);
thr->link = NULL;
tp->task.thread = thr;
}
thr->thread_pool = tp;
@@ -142,24 +147,25 @@ nxt_thread_pool_start(void *ctx)
for ( ;; ) {
nxt_thread_pool_wait(tp);
handler = nxt_locked_work_queue_pop(&tp->work_queue, &obj,
&data, &thr->log);
handler = nxt_locked_work_queue_pop(&tp->work_queue, &task, &obj,
&data);
if (nxt_fast_path(handler != NULL)) {
task->thread = thr;
nxt_log_debug(thr->log, "locked work queue");
handler(thr, obj, data);
handler(task, obj, data);
}
for ( ;; ) {
thr->log = &nxt_main_log;
handler = nxt_thread_work_queue_pop(thr, &obj, &data, &thr->log);
handler = nxt_thread_work_queue_pop(thr, &task, &obj, &data);
if (handler == NULL) {
break;
}
handler(thr, obj, data);
handler(task, obj, data);
}
thr->log = &nxt_main_log;
@@ -236,11 +242,11 @@ nxt_thread_pool_destroy(nxt_thread_pool_t *tp)
{
nxt_thread_t *thr;
if (!tp->ready) {
thr = nxt_thread();
thr = nxt_thread();
if (!tp->ready) {
nxt_thread_work_queue_add(thr, &thr->work_queue.main, tp->exit,
tp, NULL, &nxt_main_log);
&tp->task, tp, NULL);
return;
}
@@ -248,7 +254,7 @@ nxt_thread_pool_destroy(nxt_thread_pool_t *tp)
/* Disable new threads creation and mark a pool as being destroyed. */
tp->max_threads = 0;
nxt_thread_pool_post(tp, nxt_thread_pool_exit, tp, NULL, &nxt_main_log);
nxt_thread_pool_post(tp, nxt_thread_pool_exit, &tp->task, tp, NULL);
}
}
@@ -265,15 +271,17 @@ nxt_thread_pool_destroy(nxt_thread_pool_t *tp)
*/
static void
nxt_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data)
nxt_thread_pool_exit(nxt_task_t *task, void *obj, void *data)
{
nxt_thread_t *thread;
nxt_thread_pool_t *tp;
nxt_atomic_uint_t threads;
nxt_thread_handle_t handle;
tp = obj;
thread = task->thread;
nxt_log_debug(thr->log, "thread pool exit");
nxt_debug(task, "thread pool exit");
if (data != NULL) {
handle = (nxt_thread_handle_t) (uintptr_t) data;
@@ -282,17 +290,18 @@ nxt_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data)
threads = nxt_atomic_fetch_add(&tp->threads, -1);
nxt_log_debug(thr->log, "thread pool threads: %A", threads);
nxt_debug(task, "thread pool threads: %A", threads);
if (threads > 1) {
nxt_thread_pool_post(tp, nxt_thread_pool_exit, tp,
(void *) (uintptr_t) thr->handle, &nxt_main_log);
nxt_thread_pool_post(tp, nxt_thread_pool_exit, &tp->task, tp,
(void *) (uintptr_t) thread->handle);
} else {
nxt_main_log_debug("thread pool destroy");
nxt_debug(task, "thread pool destroy");
nxt_event_engine_post(tp->engine, tp->exit, tp,
(void *) (uintptr_t) thr->handle, &nxt_main_log);
nxt_event_engine_post(tp->engine, tp->exit, &tp->task, tp,
(void *) (uintptr_t) thread->handle,
&nxt_main_log);
nxt_sem_destroy(&tp->sem);
@@ -301,8 +310,9 @@ nxt_thread_pool_exit(nxt_thread_t *thr, void *obj, void *data)
nxt_free(tp);
}
nxt_thread_work_queue_destroy(thr);
nxt_thread_work_queue_destroy(thread);
nxt_thread_exit(thread);
nxt_thread_exit(thr);
nxt_unreachable();
}

4
src/nxt_thread_pool.h
View File

@@ -20,6 +20,8 @@ struct nxt_thread_pool_s {
nxt_sem_t sem;
nxt_nsec_t timeout;
nxt_task_t task;
nxt_locked_work_queue_t work_queue;
nxt_thread_handle_t main;
@@ -35,7 +37,7 @@ NXT_EXPORT nxt_thread_pool_t *nxt_thread_pool_create(nxt_uint_t max_threads,
nxt_event_engine_t *engine, nxt_work_handler_t exit);
NXT_EXPORT void nxt_thread_pool_destroy(nxt_thread_pool_t *tp);
NXT_EXPORT nxt_int_t nxt_thread_pool_post(nxt_thread_pool_t *tp,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log);
nxt_work_handler_t handler, nxt_task_t *task, void *obj, void *data);
#endif /* _NXT_UNIX_THREAD_POOL_H_INCLUDED_ */

2
src/nxt_unix.h
View File

@@ -234,7 +234,7 @@
#if (NXT_TEST_BUILD)
#include <unix/nxt_test_build.h>
#include <nxt_test_build.h>
#endif

51
src/nxt_work_queue.c
View File

@@ -30,7 +30,7 @@ static void nxt_work_queue_allocate(nxt_work_queue_cache_t *cache,
static void nxt_work_queue_sleep(nxt_thread_spinlock_t *lock);
static nxt_work_queue_t *nxt_thread_current_work_queue(nxt_thread_t *thr);
static nxt_work_handler_t nxt_locked_work_queue_pop_work(
nxt_locked_work_queue_t *lwq, void **obj, void **data, nxt_log_t **log);
nxt_locked_work_queue_t *lwq, nxt_task_t **task, void **obj, void **data);
/* It should be adjusted with the "work_queue_bucket_items" directive. */
@@ -130,7 +130,7 @@ nxt_work_queue_sleep(nxt_thread_spinlock_t *lock)
void
nxt_thread_work_queue_add(nxt_thread_t *thr, nxt_work_queue_t *wq,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log)
nxt_work_handler_t handler, nxt_task_t *task, void *obj, void *data)
{
nxt_work_t *work;
@@ -144,9 +144,9 @@ nxt_thread_work_queue_add(nxt_thread_t *thr, nxt_work_queue_t *wq,
work->next = NULL;
work->handler = handler;
work->task = task;
work->obj = obj;
work->data = data;
work->log = log;
if (wq->tail != NULL) {
wq->tail->next = work;
@@ -169,7 +169,7 @@ nxt_thread_work_queue_add(nxt_thread_t *thr, nxt_work_queue_t *wq,
void
nxt_thread_work_queue_push(nxt_thread_t *thr, nxt_work_queue_t *wq,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log)
nxt_work_handler_t handler, nxt_task_t *task, void *obj, void *data)
{
nxt_work_t *work;
@@ -185,7 +185,6 @@ nxt_thread_work_queue_push(nxt_thread_t *thr, nxt_work_queue_t *wq,
work->handler = handler;
work->obj = obj;
work->data = data;
work->log = log;
wq->head = work;
@@ -223,8 +222,8 @@ nxt_work_queue_attach(nxt_thread_t *thr, nxt_work_queue_t *wq)
/* Pop a work from a thread work queue head. */
nxt_work_handler_t
nxt_thread_work_queue_pop(nxt_thread_t *thr, void **obj, void **data,
nxt_log_t **log)
nxt_thread_work_queue_pop(nxt_thread_t *thr, nxt_task_t **task, void **obj,
void **data)
{
nxt_work_t *work;
nxt_work_queue_t *wq;
@@ -242,6 +241,7 @@ nxt_thread_work_queue_pop(nxt_thread_t *thr, void **obj, void **data,
wq->tail = NULL;
}
*task = work->task;
*obj = work->obj;
nxt_prefetch(*obj);
*data = work->data;
@@ -250,8 +250,6 @@ nxt_thread_work_queue_pop(nxt_thread_t *thr, void **obj, void **data,
work->next = thr->work_queue.cache.next;
thr->work_queue.cache.next = work;
*log = work->log;
#if (NXT_DEBUG)
if (work->handler == NULL) {
@@ -335,7 +333,7 @@ nxt_thread_work_queue_drop(nxt_thread_t *thr, void *data)
void
nxt_thread_last_work_queue_add(nxt_thread_t *thr, nxt_work_handler_t handler,
void *obj, void *data, nxt_log_t *log)
void *obj, void *data)
{
nxt_work_t *work;
@@ -349,7 +347,6 @@ nxt_thread_last_work_queue_add(nxt_thread_t *thr, nxt_work_handler_t handler,
work->handler = handler;
work->obj = obj;
work->data = data;
work->log = log;
if (thr->work_queue.last.tail != NULL) {
thr->work_queue.last.tail->next = work;
@@ -371,8 +368,8 @@ nxt_thread_last_work_queue_add(nxt_thread_t *thr, nxt_work_handler_t handler,
/* Pop a work from the thread last work queue's head. */
nxt_work_handler_t
nxt_thread_last_work_queue_pop(nxt_thread_t *thr, void **obj, void **data,
nxt_log_t **log)
nxt_thread_last_work_queue_pop(nxt_thread_t *thr, nxt_task_t **task, void **obj,
void **data)
{
nxt_work_t *work;
@@ -387,6 +384,7 @@ nxt_thread_last_work_queue_pop(nxt_thread_t *thr, void **obj, void **data,
thr->work_queue.last.tail = NULL;
}
*task = work->task;
*obj = work->obj;
nxt_prefetch(*obj);
*data = work->data;
@@ -395,8 +393,6 @@ nxt_thread_last_work_queue_pop(nxt_thread_t *thr, void **obj, void **data,
work->next = thr->work_queue.cache.next;
thr->work_queue.cache.next = work;
*log = work->log;
#if (NXT_DEBUG)
if (work->handler == NULL) {
@@ -491,7 +487,7 @@ nxt_locked_work_queue_destroy(nxt_locked_work_queue_t *lwq)
void
nxt_locked_work_queue_add(nxt_locked_work_queue_t *lwq,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log)
nxt_work_handler_t handler, nxt_task_t *task, void *obj, void *data)
{
nxt_work_t *work;
@@ -505,9 +501,9 @@ nxt_locked_work_queue_add(nxt_locked_work_queue_t *lwq,
work->next = NULL;
work->handler = handler;
work->task = task;
work->obj = obj;
work->data = data;
work->log = log;
if (lwq->tail != NULL) {
lwq->tail->next = work;
@@ -531,14 +527,14 @@ nxt_locked_work_queue_add(nxt_locked_work_queue_t *lwq,
/* Pop a work from a locked work queue head. */
nxt_work_handler_t
nxt_locked_work_queue_pop(nxt_locked_work_queue_t *lwq, void **obj,
void **data, nxt_log_t **log)
nxt_locked_work_queue_pop(nxt_locked_work_queue_t *lwq, nxt_task_t **task,
void **obj, void **data)
{
nxt_work_handler_t handler;
nxt_thread_spin_lock(&lwq->lock);
handler = nxt_locked_work_queue_pop_work(lwq, obj, data, log);
handler = nxt_locked_work_queue_pop_work(lwq, task, obj, data);
nxt_thread_spin_unlock(&lwq->lock);
@@ -547,8 +543,8 @@ nxt_locked_work_queue_pop(nxt_locked_work_queue_t *lwq, void **obj,
static nxt_work_handler_t
nxt_locked_work_queue_pop_work(nxt_locked_work_queue_t *lwq, void **obj,
void **data, nxt_log_t **log)
nxt_locked_work_queue_pop_work(nxt_locked_work_queue_t *lwq, nxt_task_t **task,
void **obj, void **data)
{
nxt_work_t *work;
@@ -558,6 +554,7 @@ nxt_locked_work_queue_pop_work(nxt_locked_work_queue_t *lwq, void **obj,
return NULL;
}
*task = work->task;
*obj = work->obj;
nxt_prefetch(*obj);
*data = work->data;
@@ -572,8 +569,6 @@ nxt_locked_work_queue_pop_work(nxt_locked_work_queue_t *lwq, void **obj,
work->next = lwq->cache.next;
lwq->cache.next = work;
*log = work->log;
return work->handler;
}
@@ -585,7 +580,7 @@ nxt_locked_work_queue_move(nxt_thread_t *thr, nxt_locked_work_queue_t *lwq,
nxt_work_queue_t *wq)
{
void *obj, *data;
nxt_log_t *log;
nxt_task_t *task;
nxt_work_handler_t handler;
/* Locked work queue head can be tested without a lock. */
@@ -597,13 +592,15 @@ nxt_locked_work_queue_move(nxt_thread_t *thr, nxt_locked_work_queue_t *lwq,
nxt_thread_spin_lock(&lwq->lock);
for ( ;; ) {
handler = nxt_locked_work_queue_pop_work(lwq, &obj, &data, &log);
handler = nxt_locked_work_queue_pop_work(lwq, &task, &obj, &data);
if (handler == NULL) {
break;
}
nxt_thread_work_queue_add(thr, wq, handler, obj, data, log);
task->thread = thr;
nxt_thread_work_queue_add(thr, wq, handler, task, obj, data);
}
nxt_thread_spin_unlock(&lwq->lock);

44
src/nxt_work_queue.h
View File

@@ -8,6 +8,22 @@
#define _NXT_WORK_QUEUE_H_INCLUDED_
typedef struct nxt_work_s nxt_work_t;
typedef struct {
nxt_thread_t *thread;
nxt_log_t *log;
uint32_t ident;
nxt_work_t *next_work;
/* TODO: exception_handler, prev/next task, subtasks. */
} nxt_task_t;
#define nxt_task_next_ident() \
((uint32_t) nxt_atomic_fetch_add(&nxt_task_ident, 1) & 0x3fffffff)
/*
* A work handler with just the obj and data arguments instead
* of pointer to a possibly large a work struct allows to call
@@ -16,17 +32,15 @@
* source filters, so the data argument has been introduced and
* is used where appropriate.
*/
typedef void (*nxt_work_handler_t)(nxt_thread_t *thr, void *obj, void *data);
typedef struct nxt_work_s nxt_work_t;
typedef void (*nxt_work_handler_t)(nxt_task_t *task, void *obj, void *data);
struct nxt_work_s {
nxt_work_t *next;
nxt_work_handler_t handler;
nxt_task_t *task;
void *obj;
void *data;
nxt_log_t *log;
};
@@ -79,24 +93,24 @@ NXT_EXPORT void nxt_thread_work_queue_create(nxt_thread_t *thr,
size_t chunk_size);
NXT_EXPORT void nxt_thread_work_queue_destroy(nxt_thread_t *thr);
NXT_EXPORT void nxt_thread_work_queue_add(nxt_thread_t *thr,
nxt_work_queue_t *wq,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log);
nxt_work_queue_t *wq, nxt_work_handler_t handler, nxt_task_t *task,
void *obj, void *data);
NXT_EXPORT void nxt_thread_work_queue_push(nxt_thread_t *thr,
nxt_work_queue_t *wq, nxt_work_handler_t handler, void *obj, void *data,
nxt_log_t *log);
nxt_work_queue_t *wq, nxt_work_handler_t handler, nxt_task_t *task,
void *obj, void *data);
NXT_EXPORT void nxt_work_queue_attach(nxt_thread_t *thr, nxt_work_queue_t *wq);
NXT_EXPORT nxt_work_handler_t nxt_thread_work_queue_pop(nxt_thread_t *thr,
void **obj, void **data, nxt_log_t **log);
nxt_task_t **task, void **obj, void **data);
NXT_EXPORT void nxt_thread_work_queue_drop(nxt_thread_t *thr, void *data);
#define \
nxt_thread_current_work_queue_add(thr, handler, obj, data, log) \
nxt_thread_current_work_queue_add(thr, handler, task, obj, data) \
do { \
nxt_thread_t *_thr = thr; \
\
nxt_thread_work_queue_add(_thr, _thr->work_queue.head, \
handler, obj, data, log); \
handler, task, obj, data); \
} while (0)
@@ -118,18 +132,18 @@ nxt_work_queue_name(_wq, _name)
NXT_EXPORT void nxt_thread_last_work_queue_add(nxt_thread_t *thr,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log);
nxt_work_handler_t handler, void *obj, void *data);
NXT_EXPORT nxt_work_handler_t nxt_thread_last_work_queue_pop(nxt_thread_t *thr,
void **obj, void **data, nxt_log_t **log);
nxt_task_t **task, void **obj, void **data);
NXT_EXPORT void nxt_locked_work_queue_create(nxt_locked_work_queue_t *lwq,
size_t chunk_size);
NXT_EXPORT void nxt_locked_work_queue_destroy(nxt_locked_work_queue_t *lwq);
NXT_EXPORT void nxt_locked_work_queue_add(nxt_locked_work_queue_t *lwq,
nxt_work_handler_t handler, void *obj, void *data, nxt_log_t *log);
nxt_work_handler_t handler, nxt_task_t *task, void *obj, void *data);
NXT_EXPORT nxt_work_handler_t nxt_locked_work_queue_pop(
nxt_locked_work_queue_t *lwq, void **obj, void **data, nxt_log_t **log);
nxt_locked_work_queue_t *lwq, nxt_task_t **task, void **obj, void **data);
NXT_EXPORT void nxt_locked_work_queue_move(nxt_thread_t *thr,
nxt_locked_work_queue_t *lwq, nxt_work_queue_t *wq);

51
src/nxt_worker_process.c
View File

@@ -10,14 +10,14 @@
#include <nxt_master_process.h>
static void nxt_worker_process_quit(nxt_thread_t *thr);
static void nxt_worker_process_quit_handler(nxt_thread_t *thr,
static void nxt_worker_process_quit(nxt_task_t *task);
static void nxt_worker_process_quit_handler(nxt_task_t *task,
nxt_chan_recv_msg_t *msg);
static void nxt_worker_process_signal_handler(nxt_thread_t *thr, void *obj,
static void nxt_worker_process_signal_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_worker_process_sigterm_handler(nxt_thread_t *thr, void *obj,
static void nxt_worker_process_sigterm_handler(nxt_task_t *task, void *obj,
void *data);
static void nxt_worker_process_sigquit_handler(nxt_thread_t *thr, void *obj,
static void nxt_worker_process_sigquit_handler(nxt_task_t *task, void *obj,
void *data);
@@ -82,7 +82,7 @@ nxt_worker_process_start(void *data)
goto fail;
}
if (nxt_event_engine_change(thr, event_set, cycle->batch) != NXT_OK) {
if (nxt_event_engine_change(thr, &nxt_main_task, event_set, cycle->batch) != NXT_OK) {
goto fail;
}
@@ -96,7 +96,7 @@ nxt_worker_process_start(void *data)
/* A master process chan. */
nxt_chan_read_close(proc[0].chan);
nxt_chan_write_enable(thr, proc[0].chan);
nxt_chan_write_enable(&nxt_main_task, proc[0].chan);
/* A worker process chan. */
nxt_process_chan_create(thr, &proc[cycle->current_process],
@@ -127,7 +127,7 @@ fail:
static void
nxt_worker_process_quit(nxt_thread_t *thr)
nxt_worker_process_quit(nxt_task_t *task)
{
nxt_uint_t n;
nxt_cycle_t *cycle;
@@ -138,9 +138,9 @@ nxt_worker_process_quit(nxt_thread_t *thr)
cycle = nxt_thread_cycle();
nxt_log_debug(thr->log, "close listen connections");
nxt_debug(task, "close listen connections");
listen = &thr->engine->listen_connections;
listen = &task->thread->engine->listen_connections;
for (link = nxt_queue_first(listen);
link != nxt_queue_tail(listen);
@@ -150,7 +150,7 @@ nxt_worker_process_quit(nxt_thread_t *thr)
cls = nxt_queue_link_data(link, nxt_event_conn_listen_t, link);
nxt_queue_remove(link);
nxt_event_fd_close(thr->engine, &cls->socket);
nxt_event_fd_close(task->thread->engine, &cls->socket);
}
if (cycle->listen_sockets != NULL) {
@@ -169,45 +169,44 @@ nxt_worker_process_quit(nxt_thread_t *thr)
cycle->listen_sockets->nelts = 0;
}
nxt_cycle_quit(thr, cycle);
nxt_cycle_quit(task, cycle);
}
static void
nxt_worker_process_signal_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_worker_process_signal_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_log_error(NXT_LOG_INFO, thr->log,
"signal signo:%d (%s) recevied, ignored",
(int) (uintptr_t) obj, data);
nxt_trace(task, "signal signo:%d (%s) recevied, ignored",
(int) (uintptr_t) obj, data);
}
static void
nxt_worker_process_quit_handler(nxt_thread_t *thr, nxt_chan_recv_msg_t *msg)
nxt_worker_process_quit_handler(nxt_task_t *task, nxt_chan_recv_msg_t *msg)
{
nxt_worker_process_quit(thr);
nxt_worker_process_quit(task);
}
static void
nxt_worker_process_sigterm_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_worker_process_sigterm_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_log_debug(thr->log, "sigterm handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
nxt_debug(task, "sigterm handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
/* A fast exit. */
nxt_cycle_quit(thr, NULL);
nxt_cycle_quit(task, NULL);
}
static void
nxt_worker_process_sigquit_handler(nxt_thread_t *thr, void *obj, void *data)
nxt_worker_process_sigquit_handler(nxt_task_t *task, void *obj, void *data)
{
nxt_log_debug(thr->log, "sigquit handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
nxt_debug(task, "sigquit handler signo:%d (%s)",
(int) (uintptr_t) obj, data);
/* A graceful exit. */
nxt_worker_process_quit(thr);
nxt_worker_process_quit(task);
}