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

Reduced number of critical log levels.

Browse Source
This commit is contained in:
Valentin Bartenev
2018-03-05 17:32:50 +03:00
parent f2090bce21
commit 912a49c609
47 changed files with 403 additions and 534 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/nxt_app_log.c
View File

@@ -79,7 +79,7 @@ nxt_log_time_handler(nxt_uint_t level, nxt_log_t *log, const char *fmt, ...)
(void) nxt_write_console(nxt_stderr, msg, p - msg); (void) nxt_write_console(nxt_stderr, msg, p - msg);
if (level <= NXT_LOG_ALERT) { if (level == NXT_LOG_ALERT) {
*(p - NXT_LINEFEED_SIZE) = '\0'; *(p - NXT_LINEFEED_SIZE) = '\0';
/* /*

15
src/nxt_application.c
View File

@@ -196,8 +196,7 @@ nxt_discovery_module(nxt_task_t *task, nxt_mp_t *mp, nxt_array_t *modules,
dl = dlopen(name, RTLD_GLOBAL | RTLD_NOW); dl = dlopen(name, RTLD_GLOBAL | RTLD_NOW);
if (dl == NULL) { if (dl == NULL) {
nxt_log(task, NXT_LOG_CRIT, "dlopen(\"%s\"), failed: \"%s\"", nxt_alert(task, "dlopen(\"%s\"), failed: \"%s\"", name, dlerror());
name, dlerror());
return NXT_OK; return NXT_OK;
} }
@@ -262,8 +261,7 @@ nxt_discovery_module(nxt_task_t *task, nxt_mp_t *mp, nxt_array_t *modules,
nxt_memcpy(module->file.start, name, module->file.length); nxt_memcpy(module->file.start, name, module->file.length);
} else { } else {
nxt_log(task, NXT_LOG_CRIT, "dlsym(\"%s\"), failed: \"%s\"", nxt_alert(task, "dlsym(\"%s\"), failed: \"%s\"", name, dlerror());
name, dlerror());
} }
done: done:
@@ -273,8 +271,7 @@ done:
fail: fail:
if (dlclose(dl) != 0) { if (dlclose(dl) != 0) {
nxt_log(task, NXT_LOG_CRIT, "dlclose(\"%s\"), failed: \"%s\"", nxt_alert(task, "dlclose(\"%s\"), failed: \"%s\"", name, dlerror());
name, dlerror());
} }
return ret; return ret;
@@ -312,8 +309,7 @@ nxt_app_start(nxt_task_t *task, void *data)
lang = nxt_app_lang_module(task->thread->runtime, &app_conf->type); lang = nxt_app_lang_module(task->thread->runtime, &app_conf->type);
if (nxt_slow_path(lang == NULL)) { if (nxt_slow_path(lang == NULL)) {
nxt_log(task, NXT_LOG_CRIT, "unknown application type: \"%V\"", nxt_alert(task, "unknown application type: \"%V\"", &app_conf->type);
&app_conf->type);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -371,8 +367,7 @@ nxt_app_module_load(nxt_task_t *task, const char *name)
return dlsym(dl, "nxt_app_module"); return dlsym(dl, "nxt_app_module");
} }
nxt_log(task, NXT_LOG_CRIT, "dlopen(\"%s\"), failed: \"%s\"", nxt_alert(task, "dlopen(\"%s\"), failed: \"%s\"", name, dlerror());
name, dlerror());
return NULL; return NULL;
} }

23
src/nxt_buf.c
View File

@@ -202,13 +202,7 @@ nxt_buf_completion(nxt_task_t *task, void *obj, void *data)
nxt_debug(task, "buf completion: %p %p", b, b->mem.start); nxt_debug(task, "buf completion: %p %p", b, b->mem.start);
#if (NXT_DEBUG) nxt_assert(data == b->parent);
if (nxt_slow_path(data != b->parent)) {
nxt_log_alert(task->log, "completion data (%p) != b->parent (%p)",
data, b->parent);
nxt_abort();
}
#endif
mp = b->data; mp = b->data;
nxt_mp_free(mp, b); nxt_mp_free(mp, b);
@@ -235,12 +229,7 @@ nxt_buf_ts_handle(nxt_task_t *task, void *obj, void *data)
b = obj; b = obj;
#if (NXT_DEBUG) nxt_assert(b->is_ts != 0);
if (nxt_slow_path(b->is_ts == 0)) {
nxt_log_alert(task->log, "not a thread safe buf (%p) completed", b);
nxt_abort();
}
#endif
ts = nxt_pointer_to(b, NXT_BUF_MEM_SIZE); ts = nxt_pointer_to(b, NXT_BUF_MEM_SIZE);
@@ -277,13 +266,7 @@ nxt_buf_ts_completion(nxt_task_t *task, void *obj, void *data)
nxt_debug(task, "buf ts completion: %p %p", b, b->mem.start); nxt_debug(task, "buf ts completion: %p %p", b, b->mem.start);
#if (NXT_DEBUG) nxt_assert(data == b->parent);
if (nxt_slow_path(data != b->parent)) {
nxt_log_alert(task->log, "completion data (%p) != b->parent (%p)",
data, b->parent);
nxt_abort();
}
#endif
mp = b->data; mp = b->data;
nxt_mp_free(mp, b); nxt_mp_free(mp, b);

6
src/nxt_conn.c
View File

@@ -129,8 +129,8 @@ nxt_conn_io_shutdown(nxt_task_t *task, void *obj, void *data)
sizeof(struct linger)); sizeof(struct linger));
if (nxt_slow_path(ret != 0)) { if (nxt_slow_path(ret != 0)) {
nxt_log(task, NXT_LOG_CRIT, "setsockopt(%d, SO_LINGER) failed %E", nxt_alert(task, "setsockopt(%d, SO_LINGER) failed %E",
c->socket.fd, nxt_socket_errno); c->socket.fd, nxt_socket_errno);
} }
} }
@@ -205,7 +205,7 @@ nxt_conn_local_addr(nxt_task_t *task, nxt_conn_t *c)
ret = getsockname(c->socket.fd, &sa->u.sockaddr, &socklen); ret = getsockname(c->socket.fd, &sa->u.sockaddr, &socklen);
if (nxt_slow_path(ret != 0)) { if (nxt_slow_path(ret != 0)) {
nxt_log(task, NXT_LOG_CRIT, "getsockname(%d) failed", c->socket.fd); nxt_alert(task, "getsockname(%d) failed", c->socket.fd);
return NULL; return NULL;
} }

16
src/nxt_conn_accept.c
View File

@@ -234,8 +234,8 @@ nxt_conn_accept_next(nxt_task_t *task, nxt_listen_event_t *lev)
} while (nxt_conn_accept_close_idle(task, lev) == NXT_OK); } while (nxt_conn_accept_close_idle(task, lev) == NXT_OK);
nxt_log(task, NXT_LOG_CRIT, "no available connections, " nxt_alert(task, "no available connections, "
"new connections are not accepted within 1s"); "new connections are not accepted within 1s");
return NULL; return NULL;
} }
@@ -309,16 +309,16 @@ nxt_conn_accept_error(nxt_task_t *task, nxt_listen_event_t *lev,
case ENOBUFS: case ENOBUFS:
case ENOMEM: case ENOMEM:
if (nxt_conn_accept_close_idle(task, lev) != NXT_OK) { if (nxt_conn_accept_close_idle(task, lev) != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "%s(%d) failed %E, " nxt_alert(task, "%s(%d) failed %E, "
"new connections are not accepted within 1s", "new connections are not accepted within 1s",
accept_syscall, lev->socket.fd, err); accept_syscall, lev->socket.fd, err);
} }
return; return;
default: default:
nxt_log(task, NXT_LOG_CRIT, "%s(%d) failed %E", nxt_alert(task, "%s(%d) failed %E",
accept_syscall, lev->socket.fd, err); accept_syscall, lev->socket.fd, err);
return; return;
} }
} }
@@ -357,5 +357,5 @@ nxt_conn_listen_event_error(nxt_task_t *task, void *obj, void *data)
ev = obj; ev = obj;
nxt_log(task, NXT_LOG_CRIT, "accept(%d) event error", ev->fd); nxt_alert(task, "accept(%d) event error", ev->fd);
} }

5
src/nxt_conn_close.c
View File

@@ -46,9 +46,8 @@ nxt_conn_close(nxt_event_engine_t *engine, nxt_conn_t *c)
sizeof(struct linger)); sizeof(struct linger));
if (nxt_slow_path(ret != 0)) { if (nxt_slow_path(ret != 0)) {
nxt_log(c->socket.task, NXT_LOG_CRIT, nxt_alert(c->socket.task, "setsockopt(%d, SO_LINGER) failed %E",
"setsockopt(%d, SO_LINGER) failed %E", c->socket.fd, nxt_socket_errno);
c->socket.fd, nxt_socket_errno);
} }
} }

11
src/nxt_controller.c
View File

@@ -154,9 +154,8 @@ nxt_controller_start(nxt_task_t *task, void *data)
nxt_free(json->start); nxt_free(json->start);
if (nxt_slow_path(conf == NULL)) { if (nxt_slow_path(conf == NULL)) {
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "failed to restore previous configuration: "
"failed to restore previous configuration: " "file is corrupted or not enough memory");
"file is corrupted or not enough memory");
nxt_mp_destroy(mp); nxt_mp_destroy(mp);
return NXT_OK; return NXT_OK;
@@ -176,8 +175,8 @@ nxt_controller_start(nxt_task_t *task, void *data)
if (nxt_slow_path(ret != NXT_OK)) { if (nxt_slow_path(ret != NXT_OK)) {
if (ret == NXT_DECLINED) { if (ret == NXT_DECLINED) {
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "the previous configuration is invalid: %V",
"the previous configuration is invalid: %V", &vldt.error); &vldt.error);
nxt_mp_destroy(vldt.pool); nxt_mp_destroy(vldt.pool);
nxt_mp_destroy(mp); nxt_mp_destroy(mp);
@@ -279,7 +278,7 @@ nxt_controller_conf_init_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
nxt_runtime_t *rt; nxt_runtime_t *rt;
if (msg->port_msg.type != NXT_PORT_MSG_RPC_READY) { if (msg->port_msg.type != NXT_PORT_MSG_RPC_READY) {
nxt_log(task, NXT_LOG_ALERT, "failed to apply previous configuration"); nxt_alert(task, "failed to apply previous configuration");
nxt_mp_destroy(nxt_controller_conf.pool); nxt_mp_destroy(nxt_controller_conf.pool);

14
src/nxt_cyassl.c
View File

@@ -87,7 +87,7 @@ nxt_cyassl_start(void)
err = CyaSSL_Init(); err = CyaSSL_Init();
if (err != SSL_SUCCESS) { if (err != SSL_SUCCESS) {
nxt_cyassl_log_error(NXT_LOG_CRIT, thr->log, err, nxt_cyassl_log_error(NXT_LOG_ALERT, thr->log, err,
"CyaSSL_Init() failed"); "CyaSSL_Init() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -118,7 +118,7 @@ nxt_cyassl_server_init(nxt_ssltls_conf_t *conf)
ctx = CyaSSL_CTX_new(CyaSSLv23_server_method()); ctx = CyaSSL_CTX_new(CyaSSLv23_server_method());
if (ctx == NULL) { if (ctx == NULL) {
nxt_cyassl_log_error(NXT_LOG_CRIT, thr->log, 0, nxt_cyassl_log_error(NXT_LOG_ALERT, thr->log, 0,
"CyaSSL_CTX_new() failed"); "CyaSSL_CTX_new() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -130,7 +130,7 @@ nxt_cyassl_server_init(nxt_ssltls_conf_t *conf)
err = CyaSSL_CTX_use_certificate_file(ctx, certificate, SSL_FILETYPE_PEM); err = CyaSSL_CTX_use_certificate_file(ctx, certificate, SSL_FILETYPE_PEM);
if (err != SSL_SUCCESS) { if (err != SSL_SUCCESS) {
nxt_cyassl_log_error(NXT_LOG_CRIT, thr->log, err, nxt_cyassl_log_error(NXT_LOG_ALERT, thr->log, err,
"CyaSSL_CTX_use_certificate_file(\"%s\") failed", "CyaSSL_CTX_use_certificate_file(\"%s\") failed",
certificate); certificate);
goto fail; goto fail;
@@ -140,7 +140,7 @@ nxt_cyassl_server_init(nxt_ssltls_conf_t *conf)
err = CyaSSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM); err = CyaSSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM);
if (err != SSL_SUCCESS) { if (err != SSL_SUCCESS) {
nxt_cyassl_log_error(NXT_LOG_CRIT, thr->log, err, nxt_cyassl_log_error(NXT_LOG_ALERT, thr->log, err,
"CyaSSL_CTX_use_PrivateKey_file(\"%s\") failed", "CyaSSL_CTX_use_PrivateKey_file(\"%s\") failed",
key); key);
goto fail; goto fail;
@@ -149,7 +149,7 @@ nxt_cyassl_server_init(nxt_ssltls_conf_t *conf)
if (conf->ciphers != NULL) { if (conf->ciphers != NULL) {
err = CyaSSL_CTX_set_cipher_list(ctx, conf->ciphers); err = CyaSSL_CTX_set_cipher_list(ctx, conf->ciphers);
if (err != SSL_SUCCESS) { if (err != SSL_SUCCESS) {
nxt_cyassl_log_error(NXT_LOG_CRIT, thr->log, err, nxt_cyassl_log_error(NXT_LOG_ALERT, thr->log, err,
"CyaSSL_CTX_set_cipher_list(\"%s\") failed", "CyaSSL_CTX_set_cipher_list(\"%s\") failed",
conf->ciphers); conf->ciphers);
goto fail; goto fail;
@@ -199,7 +199,7 @@ nxt_cyassl_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
s = CyaSSL_new(ctx); s = CyaSSL_new(ctx);
if (s == NULL) { if (s == NULL) {
nxt_cyassl_log_error(NXT_LOG_CRIT, c->socket.log, 0, nxt_cyassl_log_error(NXT_LOG_ALERT, c->socket.log, 0,
"CyaSSL_new() failed"); "CyaSSL_new() failed");
goto fail; goto fail;
} }
@@ -574,7 +574,7 @@ nxt_cyassl_log_error_level(nxt_event_conn_t *c, nxt_err_t err, int ssl_error)
break; break;
default: default:
return NXT_LOG_CRIT; return NXT_LOG_ALERT;
} }
return NXT_LOG_INFO; return NXT_LOG_INFO;

30
src/nxt_devpoll_engine.c
View File

@@ -128,8 +128,7 @@ nxt_devpoll_create(nxt_event_engine_t *engine, nxt_uint_t mchanges,
engine->u.devpoll.fd = open("/dev/poll", O_RDWR); engine->u.devpoll.fd = open("/dev/poll", O_RDWR);
if (engine->u.devpoll.fd == -1) { if (engine->u.devpoll.fd == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "open(\"/dev/poll\") failed %E", nxt_alert(&engine->task, "open(\"/dev/poll\") failed %E", nxt_errno);
nxt_errno);
goto fail; goto fail;
} }
@@ -155,8 +154,7 @@ nxt_devpoll_free(nxt_event_engine_t *engine)
nxt_debug(&engine->task, "devpoll %d free", fd); nxt_debug(&engine->task, "devpoll %d free", fd);
if (fd != -1 && close(fd) != 0) { if (fd != -1 && close(fd) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "devpoll close(%d) failed %E", nxt_alert(&engine->task, "devpoll close(%d) failed %E", fd, nxt_errno);
fd, nxt_errno);
} }
nxt_free(engine->u.devpoll.events); nxt_free(engine->u.devpoll.events);
@@ -515,9 +513,8 @@ nxt_devpoll_remove(nxt_event_engine_t *engine, nxt_fd_t fd)
} }
if (n == -1) { if (n == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task, "ioctl(%d, DP_ISPOLLED, %d) failed %E",
"ioctl(%d, DP_ISPOLLED, %d) failed %E", engine->u.devpoll.fd, fd, nxt_errno);
engine->u.devpoll.fd, fd, nxt_errno);
/* Fall through. */ /* Fall through. */
} }
@@ -549,8 +546,7 @@ nxt_devpoll_write(nxt_event_engine_t *engine, struct pollfd *pfd, size_t n)
return NXT_OK; return NXT_OK;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, "devpoll write(%d) failed %E", nxt_alert(&engine->task, "devpoll write(%d) failed %E", fd, nxt_errno);
fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -592,7 +588,7 @@ nxt_devpoll_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
engine->u.devpoll.fd, nevents); engine->u.devpoll.fd, nevents);
if (nevents == -1) { if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_CRIT; level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log(&engine->task, level, "ioctl(%d, DP_POLL) failed %E", nxt_log(&engine->task, level, "ioctl(%d, DP_POLL) failed %E",
engine->u.devpoll.fd, err); engine->u.devpoll.fd, err);
@@ -610,10 +606,10 @@ nxt_devpoll_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
fd); fd);
if (nxt_slow_path(ev == NULL)) { if (nxt_slow_path(ev == NULL)) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task,
"ioctl(%d, DP_POLL) returned invalid " "ioctl(%d, DP_POLL) returned invalid "
"fd:%d ev:%04Xd rev:%04uXi", "fd:%d ev:%04Xd rev:%04uXi",
engine->u.devpoll.fd, fd, pfd->events, events); engine->u.devpoll.fd, fd, pfd->events, events);
nxt_devpoll_remove(engine, fd); nxt_devpoll_remove(engine, fd);
continue; continue;
@@ -623,9 +619,9 @@ nxt_devpoll_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
fd, events, ev->read, ev->write); fd, events, ev->read, ev->write);
if (nxt_slow_path(events & (POLLERR | POLLHUP | POLLNVAL)) != 0) { if (nxt_slow_path(events & (POLLERR | POLLHUP | POLLNVAL)) != 0) {
nxt_log(ev->task, NXT_LOG_CRIT, nxt_alert(ev->task,
"ioctl(%d, DP_POLL) error fd:%d ev:%04Xd rev:%04uXi", "ioctl(%d, DP_POLL) error fd:%d ev:%04Xd rev:%04uXi",
engine->u.devpoll.fd, fd, pfd->events, events); engine->u.devpoll.fd, fd, pfd->events, events);
nxt_work_queue_add(&engine->fast_work_queue, ev->error_handler, nxt_work_queue_add(&engine->fast_work_queue, ev->error_handler,
ev->task, ev, ev->data); ev->task, ev, ev->data);

48
src/nxt_epoll_engine.c
View File

@@ -256,8 +256,7 @@ nxt_epoll_create(nxt_event_engine_t *engine, nxt_uint_t mchanges,
engine->u.epoll.fd = epoll_create(1); engine->u.epoll.fd = epoll_create(1);
if (engine->u.epoll.fd == -1) { if (engine->u.epoll.fd == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "epoll_create() failed %E", nxt_alert(&engine->task, "epoll_create() failed %E", nxt_errno);
nxt_errno);
goto fail; goto fail;
} }
@@ -326,8 +325,7 @@ nxt_epoll_free(nxt_event_engine_t *engine)
fd = engine->u.epoll.signalfd.fd; fd = engine->u.epoll.signalfd.fd;
if (fd != -1 && close(fd) != 0) { if (fd != -1 && close(fd) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "signalfd close(%d) failed %E", nxt_alert(&engine->task, "signalfd close(%d) failed %E", fd, nxt_errno);
fd, nxt_errno);
} }
#endif #endif
@@ -337,8 +335,7 @@ nxt_epoll_free(nxt_event_engine_t *engine)
fd = engine->u.epoll.eventfd.fd; fd = engine->u.epoll.eventfd.fd;
if (fd != -1 && close(fd) != 0) { if (fd != -1 && close(fd) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "eventfd close(%d) failed %E", nxt_alert(&engine->task, "eventfd close(%d) failed %E", fd, nxt_errno);
fd, nxt_errno);
} }
#endif #endif
@@ -346,8 +343,7 @@ nxt_epoll_free(nxt_event_engine_t *engine)
fd = engine->u.epoll.fd; fd = engine->u.epoll.fd;
if (fd != -1 && close(fd) != 0) { if (fd != -1 && close(fd) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "epoll close(%d) failed %E", nxt_alert(&engine->task, "epoll close(%d) failed %E", fd, nxt_errno);
fd, nxt_errno);
} }
nxt_free(engine->u.epoll.events); nxt_free(engine->u.epoll.events);
@@ -637,8 +633,8 @@ nxt_epoll_commit_changes(nxt_event_engine_t *engine)
ret = epoll_ctl(engine->u.epoll.fd, change->op, ev->fd, &change->event); ret = epoll_ctl(engine->u.epoll.fd, change->op, ev->fd, &change->event);
if (nxt_slow_path(ret != 0)) { if (nxt_slow_path(ret != 0)) {
nxt_log(ev->task, NXT_LOG_CRIT, "epoll_ctl(%d, %d, %d) failed %E", nxt_alert(ev->task, "epoll_ctl(%d, %d, %d) failed %E",
engine->u.epoll.fd, change->op, ev->fd, nxt_errno); engine->u.epoll.fd, change->op, ev->fd, nxt_errno);
nxt_work_queue_add(&engine->fast_work_queue, nxt_work_queue_add(&engine->fast_work_queue,
nxt_epoll_error_handler, ev->task, ev, ev->data); nxt_epoll_error_handler, ev->task, ev, ev->data);
@@ -679,8 +675,7 @@ nxt_epoll_add_signal(nxt_event_engine_t *engine)
struct epoll_event ee; struct epoll_event ee;
if (sigprocmask(SIG_BLOCK, &engine->signals->sigmask, NULL) != 0) { if (sigprocmask(SIG_BLOCK, &engine->signals->sigmask, NULL) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task, "sigprocmask(SIG_BLOCK) failed %E", nxt_errno);
"sigprocmask(SIG_BLOCK) failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -696,8 +691,8 @@ nxt_epoll_add_signal(nxt_event_engine_t *engine)
fd = signalfd(-1, &engine->signals->sigmask, 0); fd = signalfd(-1, &engine->signals->sigmask, 0);
if (fd == -1) { if (fd == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "signalfd(%d) failed %E", nxt_alert(&engine->task, "signalfd(%d) failed %E",
engine->u.epoll.signalfd.fd, nxt_errno); engine->u.epoll.signalfd.fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -719,8 +714,8 @@ nxt_epoll_add_signal(nxt_event_engine_t *engine)
ee.data.ptr = &engine->u.epoll.signalfd; ee.data.ptr = &engine->u.epoll.signalfd;
if (epoll_ctl(engine->u.epoll.fd, EPOLL_CTL_ADD, fd, &ee) != 0) { if (epoll_ctl(engine->u.epoll.fd, EPOLL_CTL_ADD, fd, &ee) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "epoll_ctl(%d, %d, %d) failed %E", nxt_alert(&engine->task, "epoll_ctl(%d, %d, %d) failed %E",
engine->u.epoll.fd, EPOLL_CTL_ADD, fd, nxt_errno); engine->u.epoll.fd, EPOLL_CTL_ADD, fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -747,8 +742,7 @@ nxt_epoll_signalfd_handler(nxt_task_t *task, void *obj, void *data)
nxt_debug(task, "read signalfd(%d): %d", ev->fd, n); nxt_debug(task, "read signalfd(%d): %d", ev->fd, n);
if (n != sizeof(struct signalfd_siginfo)) { if (n != sizeof(struct signalfd_siginfo)) {
nxt_log(task, NXT_LOG_CRIT, "read signalfd(%d) failed %E", nxt_alert(task, "read signalfd(%d) failed %E", ev->fd, nxt_errno);
ev->fd, nxt_errno);
return; return;
} }
@@ -782,7 +776,7 @@ nxt_epoll_enable_post(nxt_event_engine_t *engine, nxt_work_handler_t handler)
engine->u.epoll.eventfd.fd = eventfd(0, 0); engine->u.epoll.eventfd.fd = eventfd(0, 0);
if (engine->u.epoll.eventfd.fd == -1) { if (engine->u.epoll.eventfd.fd == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "eventfd() failed %E", nxt_errno); nxt_alert(&engine->task, "eventfd() failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -809,9 +803,9 @@ nxt_epoll_enable_post(nxt_event_engine_t *engine, nxt_work_handler_t handler)
return NXT_OK; return NXT_OK;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, "epoll_ctl(%d, %d, %d) failed %E", nxt_alert(&engine->task, "epoll_ctl(%d, %d, %d) failed %E",
engine->u.epoll.fd, EPOLL_CTL_ADD, engine->u.epoll.eventfd.fd, engine->u.epoll.fd, EPOLL_CTL_ADD, engine->u.epoll.eventfd.fd,
nxt_errno); nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -846,8 +840,8 @@ nxt_epoll_eventfd_handler(nxt_task_t *task, void *obj, void *data)
engine->u.epoll.eventfd.fd, n, events); engine->u.epoll.eventfd.fd, n, events);
if (n != sizeof(uint64_t)) { if (n != sizeof(uint64_t)) {
nxt_log(task, NXT_LOG_CRIT, "read eventfd(%d) failed %E", nxt_alert(task, "read eventfd(%d) failed %E",
engine->u.epoll.eventfd.fd, nxt_errno); engine->u.epoll.eventfd.fd, nxt_errno);
} }
} }
@@ -871,8 +865,8 @@ nxt_epoll_signal(nxt_event_engine_t *engine, nxt_uint_t signo)
ret = write(engine->u.epoll.eventfd.fd, &event, sizeof(uint64_t)); ret = write(engine->u.epoll.eventfd.fd, &event, sizeof(uint64_t));
if (nxt_slow_path(ret != sizeof(uint64_t))) { if (nxt_slow_path(ret != sizeof(uint64_t))) {
nxt_log(&engine->task, NXT_LOG_CRIT, "write(%d) to eventfd failed %E", nxt_alert(&engine->task, "write(%d) to eventfd failed %E",
engine->u.epoll.eventfd.fd, nxt_errno); engine->u.epoll.eventfd.fd, nxt_errno);
} }
} }
@@ -911,7 +905,7 @@ nxt_epoll_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
nxt_debug(&engine->task, "epoll_wait(%d): %d", engine->u.epoll.fd, nevents); nxt_debug(&engine->task, "epoll_wait(%d): %d", engine->u.epoll.fd, nevents);
if (nevents == -1) { if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_CRIT; level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log(&engine->task, level, "epoll_wait(%d) failed %E", nxt_log(&engine->task, level, "epoll_wait(%d) failed %E",
engine->u.epoll.fd, err); engine->u.epoll.fd, err);

7
src/nxt_event_engine.c
View File

@@ -349,8 +349,8 @@ nxt_event_engine_signal_pipe_error(nxt_task_t *task, void *obj, void *data)
engine = task->thread->engine; engine = task->thread->engine;
pipe = engine->pipe; pipe = engine->pipe;
nxt_log(task, NXT_LOG_CRIT, "engine pipe(%FD:%FD) event error", nxt_alert(task, "engine pipe(%FD:%FD) event error",
pipe->fds[0], pipe->fds[1]); pipe->fds[0], pipe->fds[1]);
nxt_fd_event_close(engine, &pipe->event); nxt_fd_event_close(engine, &pipe->event);
nxt_pipe_close(pipe->event.task, pipe->fds); nxt_pipe_close(pipe->event.task, pipe->fds);
@@ -375,8 +375,7 @@ nxt_event_engine_signal_handler(nxt_task_t *task, void *obj, void *data)
} }
} }
nxt_log(task, NXT_LOG_CRIT, "signal %ui handler not found", nxt_alert(task, "signal %ui handler not found", (nxt_uint_t) signo);
(nxt_uint_t) signo);
} }

43
src/nxt_eventport_engine.c
View File

@@ -109,8 +109,7 @@ nxt_eventport_create(nxt_event_engine_t *engine, nxt_uint_t mchanges,
engine->u.eventport.fd = port_create(); engine->u.eventport.fd = port_create();
if (engine->u.eventport.fd == -1) { if (engine->u.eventport.fd == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "port_create() failed %E", nxt_alert(&engine->task, "port_create() failed %E", nxt_errno);
nxt_errno);
goto fail; goto fail;
} }
@@ -140,8 +139,8 @@ nxt_eventport_free(nxt_event_engine_t *engine)
nxt_debug(&engine->task, "eventport %d free", port); nxt_debug(&engine->task, "eventport %d free", port);
if (port != -1 && close(port) != 0) { if (port != -1 && close(port) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "eventport close(%d) failed %E", nxt_alert(&engine->task, "eventport close(%d) failed %E",
port, nxt_errno); port, nxt_errno);
} }
nxt_free(engine->u.eventport.events); nxt_free(engine->u.eventport.events);
@@ -326,9 +325,8 @@ nxt_eventport_commit_changes(nxt_event_engine_t *engine)
goto next; goto next;
} }
nxt_log(ev->task, NXT_LOG_CRIT, nxt_alert(ev->task, "port_associate(%d, %d, %d, %04XD) failed %E",
"port_associate(%d, %d, %d, %04XD) failed %E", port, PORT_SOURCE_FD, ev->fd, change->events, nxt_errno);
port, PORT_SOURCE_FD, ev->fd, change->events, nxt_errno);
} else { } else {
nxt_debug(ev->task, "port_dissociate(%d): fd:%d", port, ev->fd); nxt_debug(ev->task, "port_dissociate(%d): fd:%d", port, ev->fd);
@@ -339,9 +337,8 @@ nxt_eventport_commit_changes(nxt_event_engine_t *engine)
goto next; goto next;
} }
nxt_log(ev->task, NXT_LOG_CRIT, nxt_alert(ev->task, "port_dissociate(%d, %d, %d) failed %E",
"port_dissociate(%d, %d, %d) failed %E", port, PORT_SOURCE_FD, ev->fd, nxt_errno);
port, PORT_SOURCE_FD, ev->fd, nxt_errno);
} }
nxt_work_queue_add(&engine->fast_work_queue, nxt_work_queue_add(&engine->fast_work_queue,
@@ -445,8 +442,7 @@ nxt_eventport_signal(nxt_event_engine_t *engine, nxt_uint_t signo)
nxt_debug(&engine->task, "port_send(%d, %ui)", port, signo); nxt_debug(&engine->task, "port_send(%d, %ui)", port, signo);
if (port_send(port, signo, NULL) != 0) { if (port_send(port, signo, NULL) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "port_send(%d) failed %E", nxt_alert(&engine->task, "port_send(%d) failed %E", port, nxt_errno);
port, nxt_errno);
} }
} }
@@ -511,14 +507,13 @@ nxt_eventport_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
if (n == -1) { if (n == -1) {
if (err == NXT_ETIME || err == NXT_EINTR) { if (err == NXT_ETIME || err == NXT_EINTR) {
if (nevents != 0) { if (nevents != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task, "port_getn(%d) failed %E, events:%ud",
"port_getn(%d) failed %E, events:%ud", engine->u.eventport.fd, err, nevents);
engine->u.eventport.fd, err, nevents);
} }
} }
if (err != NXT_ETIME) { if (err != NXT_ETIME) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_CRIT; level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log(&engine->task, level, "port_getn(%d) failed %E", nxt_log(&engine->task, level, "port_getn(%d) failed %E",
engine->u.eventport.fd, err); engine->u.eventport.fd, err);
@@ -545,9 +540,8 @@ nxt_eventport_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
event->portev_object, events, ev, ev->read, ev->write); event->portev_object, events, ev, ev->read, ev->write);
if (nxt_slow_path(events & (POLLERR | POLLHUP | POLLNVAL)) != 0) { if (nxt_slow_path(events & (POLLERR | POLLHUP | POLLNVAL)) != 0) {
nxt_log(ev->task, NXT_LOG_CRIT, nxt_alert(ev->task, "port_getn(%d) error fd:%d events:%04Xud",
"port_getn(%d) error fd:%d events:%04Xud", engine->u.eventport.fd, ev->fd, events);
engine->u.eventport.fd, ev->fd, events);
nxt_work_queue_add(&engine->fast_work_queue, nxt_work_queue_add(&engine->fast_work_queue,
nxt_eventport_error_handler, nxt_eventport_error_handler,
@@ -608,11 +602,12 @@ nxt_eventport_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
break; break;
default: default:
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task,
"unexpected port_getn(%d) event: ev:%d src:%d obj:%p u:%p", "unexpected port_getn(%d) event: "
engine->u.eventport.fd, event->portev_events, "ev:%d src:%d obj:%p u:%p",
event->portev_source, event->portev_object, engine->u.eventport.fd, event->portev_events,
event->portev_user); event->portev_source, event->portev_object,
event->portev_user);
} }
} }
} }

4
src/nxt_fd_event.c
View File

@@ -46,7 +46,7 @@ nxt_fd_event_hash_add(nxt_lvlhsh_t *lvlhsh, nxt_fd_t fd, nxt_fd_event_t *ev)
return NXT_OK; return NXT_OK;
} }
nxt_log(ev->task, NXT_LOG_CRIT, "fd event %d is already in hash", ev->fd); nxt_alert(ev->task, "fd event %d is already in hash", ev->fd);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -126,5 +126,5 @@ nxt_fd_event_hash_destroy(nxt_lvlhsh_t *lvlhsh)
static void static void
nxt_fd_event_hash_error(nxt_task_t *task, nxt_fd_t fd) nxt_fd_event_hash_error(nxt_task_t *task, nxt_fd_t fd)
{ {
nxt_log(task, NXT_LOG_CRIT, "fd event %d not found in hash", fd); nxt_alert(task, "fd event %d not found in hash", fd);
} }

29
src/nxt_fiber.c
View File

@@ -133,17 +133,16 @@ nxt_fiber_create_stack(nxt_task_t *task, nxt_fiber_t *fib)
MAP_PRIVATE | MAP_ANON | MAP_GROWSDOWN, -1, 0); MAP_PRIVATE | MAP_ANON | MAP_GROWSDOWN, -1, 0);
if (nxt_slow_path(s == MAP_FAILED)) { if (nxt_slow_path(s == MAP_FAILED)) {
nxt_log(task, NXT_LOG_CRIT, "fiber stack " nxt_alert(task, "fiber stack "
"mmap(%uz, MAP_PRIVATE|MAP_ANON|MAP_GROWSDOWN) failed %E", "mmap(%uz, MAP_PRIVATE|MAP_ANON|MAP_GROWSDOWN) failed %E",
size, nxt_errno); size, nxt_errno);
return NULL; return NULL;
} }
if (nxt_slow_path(mprotect(s, nxt_pagesize, PROT_NONE) != 0)) { if (nxt_slow_path(mprotect(s, nxt_pagesize, PROT_NONE) != 0)) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "fiber stack mprotect(%uz, PROT_NONE) failed %E",
"fiber stack mprotect(%uz, PROT_NONE) failed %E", size, nxt_errno);
size, nxt_errno);
return NULL; return NULL;
} }
@@ -168,17 +167,15 @@ nxt_fiber_create_stack(nxt_task_t *task, nxt_fiber_t *fib)
s = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); s = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (nxt_slow_path(s == MAP_FAILED)) { if (nxt_slow_path(s == MAP_FAILED)) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "fiber stack mmap(%uz, MAP_PRIVATE|MAP_ANON) failed %E",
"fiber stack mmap(%uz, MAP_PRIVATE|MAP_ANON) failed %E", size, nxt_errno);
size, nxt_errno);
return NULL; return NULL;
} }
if (nxt_slow_path(mprotect(s, nxt_pagesize, PROT_NONE) != 0)) { if (nxt_slow_path(mprotect(s, nxt_pagesize, PROT_NONE) != 0)) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "fiber stack mprotect(%uz, PROT_NONE) failed %E",
"fiber stack mprotect(%uz, PROT_NONE) failed %E", size, nxt_errno);
size, nxt_errno);
return NULL; return NULL;
} }
@@ -212,7 +209,7 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
nxt_debug(&fib->task, "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)) { if (nxt_slow_path(getcontext(&uc) != 0)) {
nxt_log(&fib->task, NXT_LOG_CRIT, "getcontext() failed"); nxt_alert(&fib->task, "getcontext() failed");
return; return;
} }
@@ -228,7 +225,7 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
setcontext(&uc); setcontext(&uc);
nxt_log(&fib->task, NXT_LOG_CRIT, "setcontext() failed"); nxt_alert(&fib->task, "setcontext() failed");
} }
@@ -278,7 +275,7 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
nxt_debug(&fib->task, "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)) { if (nxt_slow_path(getcontext(&uc) != 0)) {
nxt_log(&fib->task, NXT_LOG_CRIT, "getcontext() failed"); nxt_alert(&fib->task, "getcontext() failed");
return; return;
} }
@@ -293,7 +290,7 @@ nxt_fiber_switch_stack(nxt_fiber_t *fib, jmp_buf *parent)
#if !(NXT_SOLARIS) #if !(NXT_SOLARIS)
/* Solaris declares setcontext() as __NORETURN. */ /* Solaris declares setcontext() as __NORETURN. */
nxt_log(&fib->task, NXT_LOG_CRIT, "setcontext() failed"); nxt_alert(&fib->task, "setcontext() failed");
#endif #endif
} }

58
src/nxt_file.c
View File

@@ -48,8 +48,8 @@ nxt_file_close(nxt_task_t *task, nxt_file_t *file)
nxt_debug(task, "close(%FD)", file->fd); nxt_debug(task, "close(%FD)", file->fd);
if (close(file->fd) != 0) { if (close(file->fd) != 0) {
nxt_log(task, NXT_LOG_CRIT, "close(%FD, \"%FN\") failed %E", nxt_alert(task, "close(%FD, \"%FN\") failed %E",
file->fd, file->name, nxt_errno); file->fd, file->name, nxt_errno);
} }
} }
@@ -75,8 +75,7 @@ nxt_file_write(nxt_file_t *file, const u_char *buf, size_t size,
return n; return n;
} }
nxt_thread_log_error(NXT_LOG_CRIT, nxt_thread_log_alert("pwrite(%FD, \"%FN\", %p, %uz, %O) failed %E",
"pwrite(%FD, \"%FN\", %p, %uz, %O) failed %E",
file->fd, file->name, buf, size, file->fd, file->name, buf, size,
offset, file->error); offset, file->error);
@@ -104,8 +103,7 @@ nxt_file_read(nxt_file_t *file, u_char *buf, size_t size, nxt_off_t offset)
return n; return n;
} }
nxt_thread_log_error(NXT_LOG_CRIT, nxt_thread_log_alert("pread(%FD, \"%FN\", %p, %uz, %O) failed %E",
"pread(%FD, \"%FN\", %p, %uz, %O) failed %E",
file->fd, file->name, buf, size, file->fd, file->name, buf, size,
offset, file->error); offset, file->error);
@@ -133,8 +131,7 @@ nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
return; return;
} }
nxt_thread_log_error(NXT_LOG_CRIT, nxt_thread_log_alert("fcntl(%FD, \"%FN\", F_READAHEAD, %uz) failed %E",
"fcntl(%FD, \"%FN\", F_READAHEAD, %uz) failed %E",
file->fd, file->name, size, nxt_errno); file->fd, file->name, size, nxt_errno);
} }
@@ -171,8 +168,7 @@ nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
return; return;
} }
nxt_thread_log_error(NXT_LOG_CRIT, nxt_thread_log_alert("posix_fadvise(%FD, \"%FN\", %O, %uz, %d) failed %E",
"posix_fadvise(%FD, \"%FN\", %O, %uz, %d) failed %E",
file->fd, file->name, offset, size, file->fd, file->name, offset, size,
POSIX_FADV_WILLNEED, err); POSIX_FADV_WILLNEED, err);
} }
@@ -196,8 +192,7 @@ nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
return; return;
} }
nxt_thread_log_error(NXT_LOG_CRIT, nxt_thread_log_alert("fcntl(%FD, \"%FN\", F_RDAHEAD, 1) failed %E",
"fcntl(%FD, \"%FN\", F_RDAHEAD, 1) failed %E",
file->fd, file->name, nxt_errno); file->fd, file->name, nxt_errno);
} }
@@ -248,9 +243,9 @@ nxt_file_info(nxt_file_t *file, nxt_file_info_t *fi)
return NXT_OK; return NXT_OK;
} }
/* Use NXT_LOG_CRIT because fstat() error on open file is strange. */ /* Use NXT_LOG_ALERT because fstat() error on open file is strange. */
nxt_thread_log_error(NXT_LOG_CRIT, "fstat(%FD, \"%FN\") failed %E", nxt_thread_log_alert("fstat(%FD, \"%FN\") failed %E",
file->fd, file->name, file->error); file->fd, file->name, file->error);
return NXT_ERROR; return NXT_ERROR;
@@ -330,7 +325,7 @@ nxt_fd_nonblocking(nxt_task_t *task, nxt_fd_t fd)
return NXT_OK; return NXT_OK;
} }
nxt_log(task, NXT_LOG_CRIT, "ioctl(%d, FIONBIO) failed %E", fd, nxt_errno); nxt_alert(task, "ioctl(%d, FIONBIO) failed %E", fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
@@ -348,7 +343,7 @@ nxt_fd_blocking(nxt_task_t *task, nxt_fd_t fd)
return NXT_OK; return NXT_OK;
} }
nxt_log(task, NXT_LOG_CRIT, "ioctl(%d, !FIONBIO) failed %E", fd, nxt_errno); nxt_alert(task, "ioctl(%d, !FIONBIO) failed %E", fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -363,16 +358,15 @@ nxt_fd_nonblocking(nxt_task_t *task, nxt_fd_t fd)
flags = fcntl(fd, F_GETFL); flags = fcntl(fd, F_GETFL);
if (nxt_slow_path(flags == -1)) { if (nxt_slow_path(flags == -1)) {
nxt_log(task, NXT_LOG_CRIT, "fcntl(%d, F_GETFL) failed %E", nxt_alert(task, "fcntl(%d, F_GETFL) failed %E", fd, nxt_errno);
fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
flags |= O_NONBLOCK; flags |= O_NONBLOCK;
if (nxt_slow_path(fcntl(fd, F_SETFL, flags) == -1)) { if (nxt_slow_path(fcntl(fd, F_SETFL, flags) == -1)) {
nxt_log(task, NXT_LOG_CRIT, "fcntl(%d, F_SETFL, O_NONBLOCK) failed %E", nxt_alert(task, "fcntl(%d, F_SETFL, O_NONBLOCK) failed %E",
fd, nxt_errno); fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -388,16 +382,15 @@ nxt_fd_blocking(nxt_task_t *task, nxt_fd_t fd)
flags = fcntl(fd, F_GETFL); flags = fcntl(fd, F_GETFL);
if (nxt_slow_path(flags == -1)) { if (nxt_slow_path(flags == -1)) {
nxt_log(task, NXT_LOG_CRIT, "fcntl(%d, F_GETFL) failed %E", nxt_alert(task, "fcntl(%d, F_GETFL) failed %E", fd, nxt_errno);
fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
flags &= O_NONBLOCK; flags &= O_NONBLOCK;
if (nxt_slow_path(fcntl(fd, F_SETFL, flags) == -1)) { if (nxt_slow_path(fcntl(fd, F_SETFL, flags) == -1)) {
nxt_log(task, NXT_LOG_CRIT, "fcntl(%d, F_SETFL, !O_NONBLOCK) failed %E", nxt_alert(task, "fcntl(%d, F_SETFL, !O_NONBLOCK) failed %E",
fd, nxt_errno); fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -458,8 +451,7 @@ nxt_fd_close(nxt_fd_t fd)
nxt_thread_log_debug("close(%FD)", fd); nxt_thread_log_debug("close(%FD)", fd);
if (nxt_slow_path(close(fd) != 0)) { if (nxt_slow_path(close(fd) != 0)) {
nxt_thread_log_error(NXT_LOG_CRIT, "close(%FD) failed %E", nxt_thread_log_alert("close(%FD) failed %E", fd, nxt_errno);
fd, nxt_errno);
} }
} }
@@ -475,13 +467,13 @@ nxt_file_redirect(nxt_file_t *file, nxt_fd_t fd)
nxt_thread_log_debug("dup2(%FD, %FD, \"%FN\")", fd, file->fd, file->name); nxt_thread_log_debug("dup2(%FD, %FD, \"%FN\")", fd, file->fd, file->name);
if (dup2(fd, file->fd) == -1) { if (dup2(fd, file->fd) == -1) {
nxt_thread_log_error(NXT_LOG_CRIT, "dup2(%FD, %FD, \"%FN\") failed %E", nxt_thread_log_alert("dup2(%FD, %FD, \"%FN\") failed %E",
fd, file->fd, file->name, nxt_errno); fd, file->fd, file->name, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
if (close(fd) != 0) { if (close(fd) != 0) {
nxt_thread_log_error(NXT_LOG_CRIT, "close(%FD, \"%FN\") failed %E", nxt_thread_log_alert("close(%FD, \"%FN\") failed %E",
fd, file->name, nxt_errno); fd, file->name, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -502,7 +494,7 @@ nxt_file_stderr(nxt_file_t *file)
return NXT_OK; return NXT_OK;
} }
nxt_thread_log_error(NXT_LOG_CRIT, "dup2(%FD, %FD, \"%FN\") failed %E", nxt_thread_log_alert("dup2(%FD, %FD, \"%FN\") failed %E",
file->fd, STDERR_FILENO, file->name, nxt_errno); file->fd, STDERR_FILENO, file->name, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
@@ -552,7 +544,7 @@ nxt_pipe_create(nxt_task_t *task, nxt_fd_t *pp, nxt_bool_t nbread,
nxt_bool_t nbwrite) nxt_bool_t nbwrite)
{ {
if (pipe(pp) != 0) { if (pipe(pp) != 0) {
nxt_log(task, NXT_LOG_CRIT, "pipe() failed %E", nxt_errno); nxt_alert(task, "pipe() failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -581,13 +573,11 @@ nxt_pipe_close(nxt_task_t *task, nxt_fd_t *pp)
nxt_debug(task, "pipe close(%FD:%FD)", pp[0], pp[1]); nxt_debug(task, "pipe close(%FD:%FD)", pp[0], pp[1]);
if (close(pp[0]) != 0) { if (close(pp[0]) != 0) {
nxt_log(task, NXT_LOG_CRIT, "pipe close(%FD) failed %E", nxt_alert(task, "pipe close(%FD) failed %E", pp[0], nxt_errno);
pp[0], nxt_errno);
} }
if (close(pp[1]) != 0) { if (close(pp[1]) != 0) {
nxt_log(task, NXT_LOG_CRIT, "pipe close(%FD) failed %E", nxt_alert(task, "pipe close(%FD) failed %E", pp[1], nxt_errno);
pp[1], nxt_errno);
} }
} }

2
src/nxt_file.h
View File

@@ -97,7 +97,7 @@ typedef struct {
/* /*
* Log open() file error with given log level if it is non zero. * Log open() file error with given log level if it is non zero.
* Note that zero log level is NXT_LOG_EMERG. * Note that zero log level is NXT_LOG_ALERT.
*/ */
uint8_t log_level; uint8_t log_level;

20
src/nxt_gnutls.c
View File

@@ -99,7 +99,7 @@ nxt_gnutls_start(void)
ret = gnutls_global_init(); ret = gnutls_global_init();
if (ret != GNUTLS_E_SUCCESS) { if (ret != GNUTLS_E_SUCCESS) {
nxt_gnutls_log_error(NXT_LOG_CRIT, nxt_thread_log(), ret, nxt_gnutls_log_error(NXT_LOG_ALERT, nxt_thread_log(), ret,
"gnutls_global_init() failed"); "gnutls_global_init() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -167,7 +167,7 @@ nxt_gnutls_server_init(nxt_ssltls_conf_t *conf)
ret = gnutls_certificate_allocate_credentials(&ctx->certificate); ret = gnutls_certificate_allocate_credentials(&ctx->certificate);
if (ret != GNUTLS_E_SUCCESS) { if (ret != GNUTLS_E_SUCCESS) {
nxt_gnutls_log_error(NXT_LOG_CRIT, thr->log, ret, nxt_gnutls_log_error(NXT_LOG_ALERT, thr->log, ret,
"gnutls_certificate_allocate_credentials() failed"); "gnutls_certificate_allocate_credentials() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -178,7 +178,7 @@ nxt_gnutls_server_init(nxt_ssltls_conf_t *conf)
ret = gnutls_certificate_set_x509_key_file(ctx->certificate, certificate, ret = gnutls_certificate_set_x509_key_file(ctx->certificate, certificate,
key, GNUTLS_X509_FMT_PEM); key, GNUTLS_X509_FMT_PEM);
if (ret != GNUTLS_E_SUCCESS) { if (ret != GNUTLS_E_SUCCESS) {
nxt_gnutls_log_error(NXT_LOG_CRIT, thr->log, ret, nxt_gnutls_log_error(NXT_LOG_ALERT, thr->log, ret,
"gnutls_certificate_set_x509_key_file(\"%s\", \"%s\") failed", "gnutls_certificate_set_x509_key_file(\"%s\", \"%s\") failed",
certificate, key); certificate, key);
goto certificate_fail; goto certificate_fail;
@@ -195,7 +195,7 @@ nxt_gnutls_server_init(nxt_ssltls_conf_t *conf)
ca_certificate, ca_certificate,
GNUTLS_X509_FMT_PEM); GNUTLS_X509_FMT_PEM);
if (ret < 0) { if (ret < 0) {
nxt_gnutls_log_error(NXT_LOG_CRIT, thr->log, ret, nxt_gnutls_log_error(NXT_LOG_ALERT, thr->log, ret,
"gnutls_certificate_set_x509_trust_file(\"%s\") failed", "gnutls_certificate_set_x509_trust_file(\"%s\") failed",
ca_certificate); ca_certificate);
goto ca_certificate_fail; goto ca_certificate_fail;
@@ -237,13 +237,13 @@ nxt_gnutls_set_ciphers(nxt_ssltls_conf_t *conf)
return NXT_OK; return NXT_OK;
case GNUTLS_E_INVALID_REQUEST: case GNUTLS_E_INVALID_REQUEST:
nxt_gnutls_log_error(NXT_LOG_CRIT, nxt_thread_log(), ret, nxt_gnutls_log_error(NXT_LOG_ALERT, nxt_thread_log(), ret,
"gnutls_priority_init(\"%s\") failed at \"%s\"", "gnutls_priority_init(\"%s\") failed at \"%s\"",
ciphers, err); ciphers, err);
return NXT_ERROR; return NXT_ERROR;
default: default:
nxt_gnutls_log_error(NXT_LOG_CRIT, nxt_thread_log(), ret, nxt_gnutls_log_error(NXT_LOG_ALERT, nxt_thread_log(), ret,
"gnutls_priority_init() failed"); "gnutls_priority_init() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -277,7 +277,7 @@ nxt_gnutls_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
ret = gnutls_init(&ssltls->session, GNUTLS_SERVER); ret = gnutls_init(&ssltls->session, GNUTLS_SERVER);
if (ret != GNUTLS_E_SUCCESS) { if (ret != GNUTLS_E_SUCCESS) {
nxt_gnutls_log_error(NXT_LOG_CRIT, c->socket.log, ret, nxt_gnutls_log_error(NXT_LOG_ALERT, c->socket.log, ret,
"gnutls_init() failed"); "gnutls_init() failed");
goto fail; goto fail;
} }
@@ -290,7 +290,7 @@ nxt_gnutls_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
ret = gnutls_priority_set(sess, ctx->ciphers); ret = gnutls_priority_set(sess, ctx->ciphers);
if (ret != GNUTLS_E_SUCCESS) { if (ret != GNUTLS_E_SUCCESS) {
nxt_gnutls_log_error(NXT_LOG_CRIT, c->socket.log, ret, nxt_gnutls_log_error(NXT_LOG_ALERT, c->socket.log, ret,
"gnutls_priority_set() failed"); "gnutls_priority_set() failed");
goto fail; goto fail;
} }
@@ -304,7 +304,7 @@ nxt_gnutls_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
ret = gnutls_credentials_set(sess, GNUTLS_CRD_CERTIFICATE, ret = gnutls_credentials_set(sess, GNUTLS_CRD_CERTIFICATE,
ctx->certificate); ctx->certificate);
if (ret != GNUTLS_E_SUCCESS) { if (ret != GNUTLS_E_SUCCESS) {
nxt_gnutls_log_error(NXT_LOG_CRIT, c->socket.log, ret, nxt_gnutls_log_error(NXT_LOG_ALERT, c->socket.log, ret,
"gnutls_credentials_set() failed"); "gnutls_credentials_set() failed");
goto fail; goto fail;
} }
@@ -719,7 +719,7 @@ nxt_gnutls_log_error_level(nxt_event_conn_t *c, ssize_t err)
break; break;
default: default:
return NXT_LOG_CRIT; return NXT_LOG_ALERT;
} }
return NXT_LOG_INFO; return NXT_LOG_INFO;

15
src/nxt_go.c
View File

@@ -38,8 +38,7 @@ nxt_go_fd_no_cloexec(nxt_task_t *task, nxt_socket_t fd)
flags = fcntl(fd, F_GETFD); flags = fcntl(fd, F_GETFD);
if (nxt_slow_path(flags == -1)) { if (nxt_slow_path(flags == -1)) {
nxt_log(task, NXT_LOG_CRIT, "fcntl(%d, F_GETFD) failed %E", nxt_alert(task, "fcntl(%d, F_GETFD) failed %E", fd, nxt_errno);
fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -48,8 +47,7 @@ nxt_go_fd_no_cloexec(nxt_task_t *task, nxt_socket_t fd)
res = fcntl(fd, F_SETFD, flags); res = fcntl(fd, F_SETFD, flags);
if (nxt_slow_path(res == -1)) { if (nxt_slow_path(res == -1)) {
nxt_log(task, NXT_LOG_CRIT, "fcntl(%d, F_SETFD) failed %E", nxt_alert(task, "fcntl(%d, F_SETFD) failed %E", fd, nxt_errno);
fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -100,8 +98,7 @@ nxt_go_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
my_port->pair[0], -1); my_port->pair[0], -1);
if (nxt_slow_path(p == end)) { if (nxt_slow_path(p == end)) {
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "internal error: buffer too small for NXT_GO_PORTS");
"internal error: buffer too small for NXT_GO_PORTS");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -110,8 +107,7 @@ nxt_go_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
rc = setenv("NXT_GO_PORTS", (char *) buf, 1); rc = setenv("NXT_GO_PORTS", (char *) buf, 1);
if (nxt_slow_path(rc == -1)) { if (nxt_slow_path(rc == -1)) {
nxt_log(task, NXT_LOG_CRIT, "setenv(NXT_GO_PORTS, %s) failed %E", nxt_alert(task, "setenv(NXT_GO_PORTS, %s) failed %E", buf, nxt_errno);
buf, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -123,8 +119,7 @@ nxt_go_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
(void) execve(c->executable, argv, environ); (void) execve(c->executable, argv, environ);
nxt_log(task, NXT_LOG_CRIT, "execve(%s) failed %E", nxt_alert(task, "execve(%s) failed %E", c->executable, nxt_errno);
c->executable, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }

38
src/nxt_kqueue_engine.c
View File

@@ -194,7 +194,7 @@ nxt_kqueue_create(nxt_event_engine_t *engine, nxt_uint_t mchanges,
engine->u.kqueue.fd = kqueue(); engine->u.kqueue.fd = kqueue();
if (engine->u.kqueue.fd == -1) { if (engine->u.kqueue.fd == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "kqueue() failed %E", nxt_errno); nxt_alert(&engine->task, "kqueue() failed %E", nxt_errno);
goto fail; goto fail;
} }
@@ -231,8 +231,8 @@ nxt_kqueue_free(nxt_event_engine_t *engine)
/* kqueue is not inherited by fork() */ /* kqueue is not inherited by fork() */
if (close(fd) != 0) { if (close(fd) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "kqueue close(%d) failed %E", nxt_alert(&engine->task, "kqueue close(%d) failed %E",
fd, nxt_errno); fd, nxt_errno);
} }
} }
@@ -478,8 +478,8 @@ nxt_kqueue_get_kevent(nxt_event_engine_t *engine)
NULL, 0, NULL); NULL, 0, NULL);
if (nxt_slow_path(ret != 0)) { if (nxt_slow_path(ret != 0)) {
nxt_log(&engine->task, NXT_LOG_CRIT, "kevent(%d) failed %E", nxt_alert(&engine->task, "kevent(%d) failed %E",
engine->u.kqueue.fd, nxt_errno); engine->u.kqueue.fd, nxt_errno);
nxt_kqueue_error(engine); nxt_kqueue_error(engine);
} }
@@ -581,8 +581,7 @@ nxt_kqueue_add_signal(nxt_event_engine_t *engine, const nxt_sig_event_t *sigev)
sa.sa_handler = (signo == SIGCHLD) ? SIG_DFL : SIG_IGN; sa.sa_handler = (signo == SIGCHLD) ? SIG_DFL : SIG_IGN;
if (sigaction(signo, &sa, NULL) != 0) { if (sigaction(signo, &sa, NULL) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "sigaction(%d) failed %E", nxt_alert(&engine->task, "sigaction(%d) failed %E", signo, nxt_errno);
signo, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -601,8 +600,7 @@ nxt_kqueue_add_signal(nxt_event_engine_t *engine, const nxt_sig_event_t *sigev)
return NXT_OK; return NXT_OK;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, "kevent(%d) failed %E", nxt_alert(&engine->task, "kevent(%d) failed %E", kqueue, nxt_errno);
kqueue, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -630,8 +628,8 @@ nxt_kqueue_enable_post(nxt_event_engine_t *engine, nxt_work_handler_t handler)
return NXT_OK; return NXT_OK;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, "kevent(%d) failed %E", nxt_alert(&engine->task, "kevent(%d) failed %E",
engine->u.kqueue.fd, nxt_errno); engine->u.kqueue.fd, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -655,8 +653,8 @@ nxt_kqueue_signal(nxt_event_engine_t *engine, nxt_uint_t signo)
kev.udata = NULL; kev.udata = NULL;
if (kevent(engine->u.kqueue.fd, &kev, 1, NULL, 0, NULL) != 0) { if (kevent(engine->u.kqueue.fd, &kev, 1, NULL, 0, NULL) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "kevent(%d) failed %E", nxt_alert(&engine->task, "kevent(%d) failed %E",
engine->u.kqueue.fd, nxt_errno); engine->u.kqueue.fd, nxt_errno);
} }
} }
@@ -704,7 +702,7 @@ nxt_kqueue_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
nxt_debug(&engine->task, "kevent(%d): %d", engine->u.kqueue.fd, nevents); nxt_debug(&engine->task, "kevent(%d): %d", engine->u.kqueue.fd, nevents);
if (nevents == -1) { if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_CRIT; level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log(&engine->task, level, "kevent(%d) failed %E", nxt_log(&engine->task, level, "kevent(%d) failed %E",
engine->u.kqueue.fd, err); engine->u.kqueue.fd, err);
@@ -729,9 +727,9 @@ nxt_kqueue_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
error = (kev->flags & EV_ERROR); error = (kev->flags & EV_ERROR);
if (nxt_slow_path(error)) { if (nxt_slow_path(error)) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task,
"kevent(%d) error %E on ident:%d filter:%d", "kevent(%d) error %E on ident:%d filter:%d",
engine->u.kqueue.fd, kev->data, kev->ident, kev->filter); engine->u.kqueue.fd, kev->data, kev->ident, kev->filter);
} }
task = &engine->task; task = &engine->task;
@@ -830,9 +828,9 @@ nxt_kqueue_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
default: default:
#if (NXT_DEBUG) #if (NXT_DEBUG)
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task,
"unexpected kevent(%d) filter %d on ident %d", "unexpected kevent(%d) filter %d on ident %d",
engine->u.kqueue.fd, kev->filter, kev->ident); engine->u.kqueue.fd, kev->filter, kev->ident);
#endif #endif
continue; continue;

11
src/nxt_listen_socket.c
View File

@@ -20,8 +20,7 @@ nxt_listen_socket(nxt_task_t *task, nxt_socket_t s, int backlog)
return NXT_OK; return NXT_OK;
} }
nxt_log(task, NXT_LOG_CRIT, "listen(%d, %d) failed %E", nxt_alert(task, "listen(%d, %d) failed %E", s, backlog, nxt_socket_errno);
s, backlog, nxt_socket_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -118,8 +117,8 @@ nxt_listen_socket_create(nxt_task_t *task, nxt_listen_socket_t *ls,
nxt_debug(task, "listen(%d, %d)", s, ls->backlog); nxt_debug(task, "listen(%d, %d)", s, ls->backlog);
if (listen(s, ls->backlog) != 0) { if (listen(s, ls->backlog) != 0) {
nxt_log(task, NXT_LOG_CRIT, "listen(%d, %d) failed %E", nxt_alert(task, "listen(%d, %d) failed %E",
s, ls->backlog, nxt_socket_errno); s, ls->backlog, nxt_socket_errno);
goto fail; goto fail;
} }
@@ -159,8 +158,8 @@ nxt_listen_socket_update(nxt_task_t *task, nxt_listen_socket_t *ls,
nxt_debug(task, "listen(%d, %d)", ls->socket, ls->backlog); nxt_debug(task, "listen(%d, %d)", ls->socket, ls->backlog);
if (listen(ls->socket, ls->backlog) != 0) { if (listen(ls->socket, ls->backlog) != 0) {
nxt_log(task, NXT_LOG_CRIT, "listen(%d, %d) failed %E", nxt_alert(task, "listen(%d, %d) failed %E",
ls->socket, ls->backlog, nxt_socket_errno); ls->socket, ls->backlog, nxt_socket_errno);
goto fail; goto fail;
} }

6
src/nxt_log.c
View File

@@ -20,10 +20,8 @@ nxt_log_t nxt_main_log = {
}; };
nxt_str_t nxt_log_levels[8] = { nxt_str_t nxt_log_levels[6] = {
nxt_string("emerg"),
nxt_string("alert"), nxt_string("alert"),
nxt_string("crit"),
nxt_string("error"), nxt_string("error"),
nxt_string("warn"), nxt_string("warn"),
nxt_string("notice"), nxt_string("notice"),
@@ -102,7 +100,7 @@ nxt_log_handler(nxt_uint_t level, nxt_log_t *log, const char *fmt, ...)
(void) nxt_write_console(nxt_stderr, msg, p - msg); (void) nxt_write_console(nxt_stderr, msg, p - msg);
if (level <= NXT_LOG_ALERT) { if (level == NXT_LOG_ALERT) {
*(p - NXT_LINEFEED_SIZE) = '\0'; *(p - NXT_LINEFEED_SIZE) = '\0';
/* /*

43
src/nxt_log.h
View File

@@ -8,14 +8,12 @@
#define _NXT_LOG_H_INCLUDED_ #define _NXT_LOG_H_INCLUDED_
#define NXT_LOG_EMERG 0 #define NXT_LOG_ALERT 0
#define NXT_LOG_ALERT 1 #define NXT_LOG_ERR 1
#define NXT_LOG_CRIT 2 #define NXT_LOG_WARN 2
#define NXT_LOG_ERR 3 #define NXT_LOG_NOTICE 3
#define NXT_LOG_WARN 4 #define NXT_LOG_INFO 4
#define NXT_LOG_NOTICE 5 #define NXT_LOG_DEBUG 5
#define NXT_LOG_INFO 6
#define NXT_LOG_DEBUG 7
#define NXT_MAX_ERROR_STR 2048 #define NXT_MAX_ERROR_STR 2048
@@ -48,21 +46,11 @@ nxt_log_level_enough(log, level) \
((log)->level >= (level)) ((log)->level >= (level))
#define \ #define nxt_alert(task, ...) \
nxt_log_emerg(_log, ...) \
do { \ do { \
nxt_log_t *_log_ = (_log); \ nxt_log_t *log = (task)->log; \
\ \
_log_->handler(NXT_LOG_EMERG, _log_, __VA_ARGS__); \ log->handler(NXT_LOG_ALERT, log, __VA_ARGS__); \
} while (0)
#define \
nxt_log_alert(_log, ...) \
do { \
nxt_log_t *_log_ = (_log); \
\
_log_->handler(NXT_LOG_ALERT, _log_, __VA_ARGS__); \
} while (0) } while (0)
@@ -87,6 +75,14 @@ nxt_log_alert(_log, ...) \
} while (0) } while (0)
#define nxt_log_alert(_log, ...) \
do { \
nxt_log_t *_log_ = (_log); \
\
_log_->handler(NXT_LOG_ALERT, _log_, __VA_ARGS__); \
} while (0)
#define \ #define \
nxt_log_error(_level, _log, ...) \ nxt_log_error(_level, _log, ...) \
do { \ do { \
@@ -155,11 +151,6 @@ nxt_log_debug(...)
#endif #endif
#define \
nxt_main_log_emerg(...) \
nxt_log_emerg(&nxt_main_log, __VA_ARGS__)
#define \ #define \
nxt_main_log_alert(...) \ nxt_main_log_alert(...) \
nxt_log_alert(&nxt_main_log, __VA_ARGS__) nxt_log_alert(&nxt_main_log, __VA_ARGS__)

11
src/nxt_log_moderation.h
View File

@@ -23,6 +23,17 @@ typedef struct {
#define NXT_LOG_MODERATION 0, -1, 0, 0, NXT_TIMER #define NXT_LOG_MODERATION 0, -1, 0, 0, NXT_TIMER
#define \
nxt_log_alert_moderate(_mod, _log, ...) \
do { \
nxt_log_t *_log_ = _log; \
\
if (nxt_log_moderate_allow(_mod)) { \
_log_->handler(NXT_LOG_ALERT, _log_, __VA_ARGS__); \
} \
} while (0)
#define \ #define \
nxt_log_moderate(_mod, _level, _log, ...) \ nxt_log_moderate(_mod, _level, _log, ...) \
do { \ do { \

34
src/nxt_main_process.c
View File

@@ -242,7 +242,7 @@ nxt_port_main_start_worker_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
conf = nxt_conf_json_parse(mp, start, b->mem.free, NULL); conf = nxt_conf_json_parse(mp, start, b->mem.free, NULL);
if (conf == NULL) { if (conf == NULL) {
nxt_log(task, NXT_LOG_ALERT, "router app configuration parsing error"); nxt_alert(task, "router app configuration parsing error");
goto failed; goto failed;
} }
@@ -252,8 +252,7 @@ nxt_port_main_start_worker_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
ret = nxt_conf_map_object(mp, conf, nxt_common_app_conf, ret = nxt_conf_map_object(mp, conf, nxt_common_app_conf,
nxt_nitems(nxt_common_app_conf), &app_conf); nxt_nitems(nxt_common_app_conf), &app_conf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "failed to map common app conf received from router");
"failed to map common app conf received from router");
goto failed; goto failed;
} }
@@ -268,8 +267,7 @@ nxt_port_main_start_worker_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
idx = nxt_app_parse_type(app_conf.type.start, type_len); idx = nxt_app_parse_type(app_conf.type.start, type_len);
if (nxt_slow_path(idx >= nxt_nitems(nxt_app_maps))) { if (nxt_slow_path(idx >= nxt_nitems(nxt_app_maps))) {
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "invalid app type %d received from router", (int) idx);
"invalid app type %d received from router", (int) idx);
goto failed; goto failed;
} }
@@ -277,8 +275,7 @@ nxt_port_main_start_worker_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
nxt_app_maps[idx].size, &app_conf); nxt_app_maps[idx].size, &app_conf);
if (nxt_slow_path(ret != NXT_OK)) { if (nxt_slow_path(ret != NXT_OK)) {
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "failed to map app conf received from router");
"failed to map app conf received from router");
goto failed; goto failed;
} }
@@ -440,9 +437,8 @@ nxt_main_create_controller_process(nxt_task_t *task, nxt_runtime_t *rt,
conf.length = 0; conf.length = 0;
nxt_free(conf.start); nxt_free(conf.start);
nxt_log(task, NXT_LOG_ALERT, nxt_alert(task, "failed to restore previous configuration: "
"failed to restore previous configuration: " "cannot read the file");
"cannot read the file");
} }
} }
@@ -718,7 +714,7 @@ nxt_main_process_sigusr1_handler(nxt_task_t *task, void *obj, void *data)
new_file->name = file->name; new_file->name = file->name;
new_file->fd = NXT_FILE_INVALID; new_file->fd = NXT_FILE_INVALID;
new_file->log_level = NXT_LOG_CRIT; new_file->log_level = NXT_LOG_ALERT;
ret = nxt_file_open(task, new_file, O_WRONLY | O_APPEND, O_CREAT, ret = nxt_file_open(task, new_file, O_WRONLY | O_APPEND, O_CREAT,
NXT_FILE_OWNER_ACCESS); NXT_FILE_OWNER_ACCESS);
@@ -797,7 +793,7 @@ nxt_main_process_sigchld_handler(nxt_task_t *task, void *obj, void *data)
continue; continue;
default: default:
nxt_log(task, NXT_LOG_CRIT, "waitpid() failed: %E", err); nxt_alert(task, "waitpid() failed: %E", err);
return; return;
} }
} }
@@ -810,12 +806,12 @@ nxt_main_process_sigchld_handler(nxt_task_t *task, void *obj, void *data)
if (WTERMSIG(status)) { if (WTERMSIG(status)) {
#ifdef WCOREDUMP #ifdef WCOREDUMP
nxt_log(task, NXT_LOG_CRIT, "process %PI exited on signal %d%s", nxt_alert(task, "process %PI exited on signal %d%s",
pid, WTERMSIG(status), pid, WTERMSIG(status),
WCOREDUMP(status) ? " (core dumped)" : ""); WCOREDUMP(status) ? " (core dumped)" : "");
#else #else
nxt_log(task, NXT_LOG_CRIT, "process %PI exited on signal %d", nxt_alert(task, "process %PI exited on signal %d",
pid, WTERMSIG(status)); pid, WTERMSIG(status));
#endif #endif
} else { } else {
@@ -937,7 +933,7 @@ nxt_main_port_socket_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
} else { } else {
size = ls.end - ls.start; size = ls.end - ls.start;
nxt_log(task, NXT_LOG_CRIT, "%*s", size, ls.start); nxt_alert(task, "%*s", size, ls.start);
out = nxt_buf_mem_ts_alloc(task, task->thread->engine->mem_pool, out = nxt_buf_mem_ts_alloc(task, task->thread->engine->mem_pool,
size + 1); size + 1);
@@ -1274,5 +1270,5 @@ nxt_main_port_conf_store_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
error: error:
nxt_log(task, NXT_LOG_ALERT, "failed to store current configuration"); nxt_alert(task, "failed to store current configuration");
} }

30
src/nxt_malloc.c
View File

@@ -38,9 +38,8 @@ nxt_malloc(size_t size)
nxt_log_debug(nxt_malloc_log(), "malloc(%uz): %p", size, p); nxt_log_debug(nxt_malloc_log(), "malloc(%uz): %p", size, p);
} else { } else {
nxt_log_moderate(&nxt_malloc_log_moderation, nxt_log_alert_moderate(&nxt_malloc_log_moderation, nxt_malloc_log(),
NXT_LOG_ALERT, nxt_malloc_log(), "malloc(%uz) failed %E", size, nxt_errno);
"malloc(%uz) failed %E", size, nxt_errno);
} }
return p; return p;
@@ -73,9 +72,9 @@ nxt_realloc(void *p, size_t size)
nxt_log_debug(nxt_malloc_log(), "realloc(%p, %uz): %p", p, size, n); nxt_log_debug(nxt_malloc_log(), "realloc(%p, %uz): %p", p, size, n);
} else { } else {
nxt_log_moderate(&nxt_malloc_log_moderation, nxt_log_alert_moderate(&nxt_malloc_log_moderation, nxt_malloc_log(),
NXT_LOG_ALERT, nxt_malloc_log(), "realloc(%p, %uz) failed %E",
"realloc(%p, %uz) failed %E", p, size, nxt_errno); p, size, nxt_errno);
} }
return n; return n;
@@ -117,10 +116,9 @@ nxt_memalign(size_t alignment, size_t size)
return p; return p;
} }
nxt_log_moderate(&nxt_malloc_log_moderation, nxt_log_alert_moderate(&nxt_malloc_log_moderation, nxt_malloc_log(),
NXT_LOG_ALERT, nxt_malloc_log(), "posix_memalign(%uz, %uz) failed %E",
"posix_memalign(%uz, %uz) failed %E", alignment, size, err);
alignment, size, err);
return NULL; return NULL;
} }
@@ -141,10 +139,9 @@ nxt_memalign(size_t alignment, size_t size)
return p; return p;
} }
nxt_log_moderate(&nxt_malloc_log_moderation, nxt_log_alert_moderate(&nxt_malloc_log_moderation, nxt_malloc_log(),
NXT_LOG_ALERT, nxt_malloc_log(), "memalign(%uz, %uz) failed %E",
"memalign(%uz, %uz) failed %E", alignment, size, nxt_errno);
alignment, size, nxt_errno);
return NULL; return NULL;
} }
@@ -189,9 +186,8 @@ nxt_memalign(size_t alignment, size_t size)
nxt_thread_log_debug("nxt_memalign(%uz, %uz): %p", alignment, size, p); nxt_thread_log_debug("nxt_memalign(%uz, %uz): %p", alignment, size, p);
} else { } else {
nxt_log_moderate(&nxt_malloc_log_moderation, nxt_log_alert_moderate(&nxt_malloc_log_moderation, nxt_malloc_log(),
NXT_LOG_ALERT, nxt_malloc_log(), "malloc(%uz) failed %E", size, nxt_errno);
"malloc(%uz) failed %E", size, nxt_errno);
} }
return p; return p;

3
src/nxt_mem_zone.c
View File

@@ -503,8 +503,7 @@ nxt_mem_zone_align(nxt_mem_zone_t *zone, size_t alignment, size_t size)
nxt_thread_log_debug("mem zone alloc: %p", p); nxt_thread_log_debug("mem zone alloc: %p", p);
} else { } else {
nxt_log_moderate(&nxt_mem_zone_log_moderation, nxt_log_alert_moderate(&nxt_mem_zone_log_moderation, nxt_thread_log(),
NXT_LOG_ALERT, nxt_thread_log(),
"nxt_mem_zone_alloc(%uz, %uz) failed, not enough memory", "nxt_mem_zone_alloc(%uz, %uz) failed, not enough memory",
alignment, size); alignment, size);
} }

5
src/nxt_mp.c
View File

@@ -772,7 +772,6 @@ void
nxt_mp_free(nxt_mp_t *mp, void *p) nxt_mp_free(nxt_mp_t *mp, void *p)
{ {
const char *err; const char *err;
nxt_thread_t *thread;
nxt_mp_block_t *block; nxt_mp_block_t *block;
nxt_mp_thread_assert(mp); nxt_mp_thread_assert(mp);
@@ -809,9 +808,7 @@ nxt_mp_free(nxt_mp_t *mp, void *p)
err = "freed pointer is out of pool: %p"; err = "freed pointer is out of pool: %p";
} }
thread = nxt_thread(); nxt_thread_log_alert(err, p);
nxt_log(thread->task, NXT_LOG_CRIT, err, p);
} }

23
src/nxt_openssl.c
View File

@@ -116,7 +116,7 @@ nxt_openssl_start(nxt_thread_t *thr)
index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL); index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
if (index == -1) { if (index == -1) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, nxt_openssl_log_error(NXT_LOG_ALERT, thr->log,
"SSL_get_ex_new_index() failed"); "SSL_get_ex_new_index() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -143,7 +143,7 @@ nxt_openssl_server_init(nxt_ssltls_conf_t *conf)
ctx = SSL_CTX_new(SSLv23_server_method()); ctx = SSL_CTX_new(SSLv23_server_method());
if (ctx == NULL) { if (ctx == NULL) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, "SSL_CTX_new() failed"); nxt_openssl_log_error(NXT_LOG_ALERT, thr->log, "SSL_CTX_new() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -174,7 +174,7 @@ nxt_openssl_server_init(nxt_ssltls_conf_t *conf)
certificate = conf->certificate; certificate = conf->certificate;
if (SSL_CTX_use_certificate_chain_file(ctx, certificate) == 0) { if (SSL_CTX_use_certificate_chain_file(ctx, certificate) == 0) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, nxt_openssl_log_error(NXT_LOG_ALERT, thr->log,
"SSL_CTX_use_certificate_file(\"%s\") failed", "SSL_CTX_use_certificate_file(\"%s\") failed",
certificate); certificate);
goto fail; goto fail;
@@ -183,7 +183,7 @@ nxt_openssl_server_init(nxt_ssltls_conf_t *conf)
key = conf->certificate_key; key = conf->certificate_key;
if (SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM) == 0) { if (SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM) == 0) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, nxt_openssl_log_error(NXT_LOG_ALERT, thr->log,
"SSL_CTX_use_PrivateKey_file(\"%s\") failed", "SSL_CTX_use_PrivateKey_file(\"%s\") failed",
key); key);
goto fail; goto fail;
@@ -192,7 +192,7 @@ nxt_openssl_server_init(nxt_ssltls_conf_t *conf)
ciphers = (conf->ciphers != NULL) ? conf->ciphers : "HIGH:!aNULL:!MD5"; ciphers = (conf->ciphers != NULL) ? conf->ciphers : "HIGH:!aNULL:!MD5";
if (SSL_CTX_set_cipher_list(ctx, ciphers) == 0) { if (SSL_CTX_set_cipher_list(ctx, ciphers) == 0) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, nxt_openssl_log_error(NXT_LOG_ALERT, thr->log,
"SSL_CTX_set_cipher_list(\"%s\") failed", "SSL_CTX_set_cipher_list(\"%s\") failed",
ciphers); ciphers);
goto fail; goto fail;
@@ -211,7 +211,7 @@ nxt_openssl_server_init(nxt_ssltls_conf_t *conf)
ca_certificate = conf->ca_certificate; ca_certificate = conf->ca_certificate;
if (SSL_CTX_load_verify_locations(ctx, ca_certificate, NULL) == 0) { if (SSL_CTX_load_verify_locations(ctx, ca_certificate, NULL) == 0) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, nxt_openssl_log_error(NXT_LOG_ALERT, thr->log,
"SSL_CTX_load_verify_locations(\"%s\") failed", "SSL_CTX_load_verify_locations(\"%s\") failed",
ca_certificate); ca_certificate);
goto fail; goto fail;
@@ -220,7 +220,7 @@ nxt_openssl_server_init(nxt_ssltls_conf_t *conf)
list = SSL_load_client_CA_file(ca_certificate); list = SSL_load_client_CA_file(ca_certificate);
if (list == NULL) { if (list == NULL) {
nxt_openssl_log_error(NXT_LOG_CRIT, thr->log, nxt_openssl_log_error(NXT_LOG_ALERT, thr->log,
"SSL_load_client_CA_file(\"%s\") failed", "SSL_load_client_CA_file(\"%s\") failed",
ca_certificate); ca_certificate);
goto fail; goto fail;
@@ -273,7 +273,8 @@ nxt_openssl_conn_init(nxt_task_t *task, nxt_ssltls_conf_t *conf, nxt_conn_t *c)
s = SSL_new(ctx); s = SSL_new(ctx);
if (s == NULL) { if (s == NULL) {
nxt_openssl_log_error(NXT_LOG_CRIT, c->socket.log, "SSL_new() failed"); nxt_openssl_log_error(NXT_LOG_ALERT, c->socket.log,
"SSL_new() failed");
goto fail; goto fail;
} }
@@ -284,7 +285,7 @@ nxt_openssl_conn_init(nxt_task_t *task, nxt_ssltls_conf_t *conf, nxt_conn_t *c)
ret = SSL_set_fd(s, c->socket.fd); ret = SSL_set_fd(s, c->socket.fd);
if (ret == 0) { if (ret == 0) {
nxt_openssl_log_error(NXT_LOG_CRIT, c->socket.log, nxt_openssl_log_error(NXT_LOG_ALERT, c->socket.log,
"SSL_set_fd(%d) failed", c->socket.fd); "SSL_set_fd(%d) failed", c->socket.fd);
goto fail; goto fail;
} }
@@ -292,7 +293,7 @@ nxt_openssl_conn_init(nxt_task_t *task, nxt_ssltls_conf_t *conf, nxt_conn_t *c)
SSL_set_accept_state(s); SSL_set_accept_state(s);
if (SSL_set_ex_data(s, nxt_openssl_connection_index, c) == 0) { if (SSL_set_ex_data(s, nxt_openssl_connection_index, c) == 0) {
nxt_openssl_log_error(NXT_LOG_CRIT, c->socket.log, nxt_openssl_log_error(NXT_LOG_ALERT, c->socket.log,
"SSL_set_ex_data() failed"); "SSL_set_ex_data() failed");
goto fail; goto fail;
} }
@@ -760,7 +761,7 @@ nxt_openssl_log_error_level(nxt_conn_t *c, nxt_err_t err)
return NXT_LOG_ERR; return NXT_LOG_ERR;
default: default:
return NXT_LOG_CRIT; return NXT_LOG_ALERT;
} }
return NXT_LOG_INFO; return NXT_LOG_INFO;

10
src/nxt_php_sapi.c
View File

@@ -191,7 +191,7 @@ nxt_php_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
c = &conf->u.php; c = &conf->u.php;
if (c->root == NULL) { if (c->root == NULL) {
nxt_log_emerg(task->log, "php root is empty"); nxt_alert(task, "php root is empty");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -202,8 +202,7 @@ nxt_php_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
root->start = nxt_realpath(c->root); root->start = nxt_realpath(c->root);
if (nxt_slow_path(root->start == NULL)) { if (nxt_slow_path(root->start == NULL)) {
nxt_log_emerg(task->log, "root realpath(%s) failed %E", nxt_alert(task, "root realpath(%s) failed %E", c->root, nxt_errno);
c->root, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -228,15 +227,14 @@ nxt_php_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
rpath.start = nxt_realpath(path->start); rpath.start = nxt_realpath(path->start);
if (nxt_slow_path(rpath.start == NULL)) { if (nxt_slow_path(rpath.start == NULL)) {
nxt_log_emerg(task->log, "script realpath(%V) failed %E", nxt_alert(task, "script realpath(%V) failed %E", path, nxt_errno);
path, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
rpath.length = nxt_strlen(rpath.start); rpath.length = nxt_strlen(rpath.start);
if (!nxt_str_start(&rpath, root->start, root->length)) { if (!nxt_str_start(&rpath, root->start, root->length)) {
nxt_log_emerg(task->log, "script is not under php root"); nxt_alert(task, "script is not under php root");
return NXT_ERROR; return NXT_ERROR;
} }

6
src/nxt_polarssl.c
View File

@@ -49,7 +49,7 @@ nxt_polarssl_server_init(nxt_ssltls_conf_t *conf)
n = ssl_init(&ctx->ssl); n = ssl_init(&ctx->ssl);
if (n != 0) { if (n != 0) {
nxt_polarssl_log_error(NXT_LOG_CRIT, thr->log, n, "ssl_init() failed"); nxt_polarssl_log_error(NXT_LOG_ALERT, thr->log, n, "ssl_init() failed");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -60,7 +60,7 @@ nxt_polarssl_server_init(nxt_ssltls_conf_t *conf)
n = x509parse_crtfile(&ctx->certificate, conf->certificate); n = x509parse_crtfile(&ctx->certificate, conf->certificate);
if (n != 0) { if (n != 0) {
nxt_polarssl_log_error(NXT_LOG_CRIT, thr->log, n, nxt_polarssl_log_error(NXT_LOG_ALERT, thr->log, n,
"x509parse_crt(\"%V\") failed", "x509parse_crt(\"%V\") failed",
&conf->certificate); &conf->certificate);
goto fail; goto fail;
@@ -70,7 +70,7 @@ nxt_polarssl_server_init(nxt_ssltls_conf_t *conf)
n = x509parse_keyfile(&ctx->key, conf->certificate_key, NULL); n = x509parse_keyfile(&ctx->key, conf->certificate_key, NULL);
if (n != 0) { if (n != 0) {
nxt_polarssl_log_error(NXT_LOG_CRIT, thr->log, n, nxt_polarssl_log_error(NXT_LOG_ALERT, thr->log, n,
"x509parse_key(\"%V\") failed", "x509parse_key(\"%V\") failed",
&conf->certificate_key); &conf->certificate_key);
goto fail; goto fail;

21
src/nxt_poll_engine.c
View File

@@ -546,9 +546,9 @@ nxt_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
phe = nxt_poll_fd_hash_get(engine, fd); phe = nxt_poll_fd_hash_get(engine, fd);
if (nxt_slow_path(phe == NULL)) { if (nxt_slow_path(phe == NULL)) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task,
"poll() returned invalid fd:%d ev:%04Xd rev:%04uXi", "poll() returned invalid fd:%d ev:%04Xd rev:%04uXi",
fd, pfd->events, events); fd, pfd->events, events);
/* Mark the poll entry to ignore it by the kernel. */ /* Mark the poll entry to ignore it by the kernel. */
pfd->fd = -1; pfd->fd = -1;
@@ -561,9 +561,8 @@ nxt_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
fd, events, ev->read, ev->write); fd, events, ev->read, ev->write);
if (nxt_slow_path((events & POLLNVAL) != 0)) { if (nxt_slow_path((events & POLLNVAL) != 0)) {
nxt_log(ev->task, NXT_LOG_CRIT, nxt_alert(ev->task, "poll() error fd:%d ev:%04Xd rev:%04uXi",
"poll() error fd:%d ev:%04Xd rev:%04uXi", fd, pfd->events, events);
fd, pfd->events, events);
/* Mark the poll entry to ignore it by the kernel. */ /* Mark the poll entry to ignore it by the kernel. */
pfd->fd = -1; pfd->fd = -1;
@@ -649,7 +648,7 @@ nxt_poll_fd_hash_get(nxt_event_engine_t *engine, nxt_fd_t fd)
return phe; return phe;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, "fd %d not found in hash", fd); nxt_alert(&engine->task, "fd %d not found in hash", fd);
return NULL; return NULL;
} }
@@ -671,9 +670,8 @@ nxt_poll_fd_hash_test(nxt_lvlhsh_query_t *lhq, void *data)
return NXT_OK; return NXT_OK;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task, "fd %d in hash mismatches fd %d in poll set",
"fd %d in hash mismatches fd %d in poll set", phe->fd, engine->u.poll.set[phe->index].fd);
phe->fd, engine->u.poll.set[phe->index].fd);
return NXT_DECLINED; return NXT_DECLINED;
} }
@@ -700,8 +698,7 @@ nxt_poll_fd_hash_destroy(nxt_event_engine_t *engine, nxt_lvlhsh_t *lh)
lhq.key_hash = nxt_murmur_hash2(&phe->fd, sizeof(nxt_fd_t)); lhq.key_hash = nxt_murmur_hash2(&phe->fd, sizeof(nxt_fd_t));
if (nxt_lvlhsh_delete(lh, &lhq) != NXT_OK) { if (nxt_lvlhsh_delete(lh, &lhq) != NXT_OK) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task, "event fd %d not found in hash", phe->fd);
"event fd %d not found in hash", phe->fd);
} }
nxt_free(phe); nxt_free(phe);

30
src/nxt_pollset_engine.c
View File

@@ -122,8 +122,7 @@ nxt_pollset_create(nxt_event_engine_t *engine, nxt_uint_t mchanges,
engine->u.pollset.ps = pollset_create(-1); engine->u.pollset.ps = pollset_create(-1);
if (engine->u.pollset.ps == -1) { if (engine->u.pollset.ps == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "pollset_create() failed %E", nxt_alert(&engine->task, "pollset_create() failed %E", nxt_errno);
nxt_errno);
goto fail; goto fail;
} }
@@ -149,8 +148,8 @@ nxt_pollset_free(nxt_event_engine_t *engine)
nxt_debug(&engine->task, "pollset %d free", ps); nxt_debug(&engine->task, "pollset %d free", ps);
if (ps != -1 && pollset_destroy(ps) != 0) { if (ps != -1 && pollset_destroy(ps) != 0) {
nxt_log(&engine->task, NXT_LOG_CRIT, "pollset_destroy(%d) failed %E", nxt_alert(&engine->task, "pollset_destroy(%d) failed %E",
ps, nxt_errno); ps, nxt_errno);
} }
nxt_free(engine->u.pollset.events); nxt_free(engine->u.pollset.events);
@@ -501,8 +500,8 @@ nxt_pollset_remove(nxt_event_engine_t *engine, nxt_fd_t fd)
} }
if (n == -1) { if (n == -1) {
nxt_log(&engine->task, NXT_LOG_CRIT, "pollset_query(%d, %d) failed %E", nxt_alert(&engine->task, "pollset_query(%d, %d) failed %E",
engine->u.pollset.ps, fd, nxt_errno); engine->u.pollset.ps, fd, nxt_errno);
/* Fall through. */ /* Fall through. */
} }
@@ -536,8 +535,7 @@ nxt_pollset_write(nxt_event_engine_t *engine, struct poll_ctl *ctl, int n)
return NXT_OK; return NXT_OK;
} }
nxt_log(&engine->task, NXT_LOG_CRIT, "pollset_ctl(%d) failed: %d %E", nxt_alert(&engine->task, "pollset_ctl(%d) failed: %d %E", ps, n, nxt_errno);
ps, n, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -575,7 +573,7 @@ nxt_pollset_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
engine->u.pollset.ps, nevents); engine->u.pollset.ps, nevents);
if (nevents == -1) { if (nevents == -1) {
level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_CRIT; level = (err == NXT_EINTR) ? NXT_LOG_INFO : NXT_LOG_ALERT;
nxt_log(&engine->task, level, "pollset_poll(%d) failed %E", nxt_log(&engine->task, level, "pollset_poll(%d) failed %E",
engine->u.pollset.ps, err); engine->u.pollset.ps, err);
@@ -593,10 +591,10 @@ nxt_pollset_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
fd); fd);
if (nxt_slow_path(ev == NULL)) { if (nxt_slow_path(ev == NULL)) {
nxt_log(&engine->task, NXT_LOG_CRIT, nxt_alert(&engine->task,
"pollset_poll(%d) returned invalid " "pollset_poll(%d) returned invalid "
"fd:%d ev:%04Xd rev:%04uXi", "fd:%d ev:%04Xd rev:%04uXi",
engine->u.pollset.ps, fd, pfd->events, events); engine->u.pollset.ps, fd, pfd->events, events);
nxt_pollset_remove(engine, fd); nxt_pollset_remove(engine, fd);
continue; continue;
@@ -605,9 +603,9 @@ nxt_pollset_poll(nxt_event_engine_t *engine, nxt_msec_t timeout)
nxt_debug(ev->task, "pollset: fd:%d ev:%04uXi", fd, events); nxt_debug(ev->task, "pollset: fd:%d ev:%04uXi", fd, events);
if (nxt_slow_path(events & (POLLERR | POLLHUP | POLLNVAL)) != 0) { if (nxt_slow_path(events & (POLLERR | POLLHUP | POLLNVAL)) != 0) {
nxt_log(ev->task, NXT_LOG_CRIT, nxt_alert(ev->task,
"pollset_poll(%d) error fd:%d ev:%04Xd rev:%04uXi", "pollset_poll(%d) error fd:%d ev:%04Xd rev:%04uXi",
engine->u.pollset.ps, fd, pfd->events, events); engine->u.pollset.ps, fd, pfd->events, events);
nxt_work_queue_add(&engine->fast_work_queue, ev->error_handler, nxt_work_queue_add(&engine->fast_work_queue, ev->error_handler,
ev->task, ev, ev->data); ev->task, ev, ev->data);

4
src/nxt_port.c
View File

@@ -167,8 +167,8 @@ nxt_port_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
return; return;
} }
nxt_log(task, NXT_LOG_CRIT, "port %d: unknown message type:%uD", nxt_alert(task, "port %d: unknown message type:%uD",
msg->port->socket.fd, msg->port_msg.type); msg->port->socket.fd, msg->port_msg.type);
} }

13
src/nxt_port_memory.c
View File

@@ -124,13 +124,7 @@ nxt_port_mmap_buf_completion(nxt_task_t *task, void *obj, void *data)
mp = b->data; mp = b->data;
#if (NXT_DEBUG) nxt_assert(data == b->parent);
if (nxt_slow_path(data != b->parent)) {
nxt_log_alert(task->log, "completion data (%p) != b->parent (%p)",
data, b->parent);
nxt_abort();
}
#endif
mmap_handler = data; mmap_handler = data;
hdr = mmap_handler->hdr; hdr = mmap_handler->hdr;
@@ -296,8 +290,7 @@ nxt_port_new_port_mmap(nxt_task_t *task, nxt_process_t *process,
fd = syscall(SYS_memfd_create, name, MFD_CLOEXEC); fd = syscall(SYS_memfd_create, name, MFD_CLOEXEC);
if (nxt_slow_path(fd == -1)) { if (nxt_slow_path(fd == -1)) {
nxt_log(task, NXT_LOG_CRIT, "memfd_create(%s) failed %E", nxt_alert(task, "memfd_create(%s) failed %E", name, nxt_errno);
name, nxt_errno);
goto remove_fail; goto remove_fail;
} }
@@ -314,7 +307,7 @@ nxt_port_new_port_mmap(nxt_task_t *task, nxt_process_t *process,
nxt_debug(task, "shm_open(%s): %FD", name, fd); nxt_debug(task, "shm_open(%s): %FD", name, fd);
if (nxt_slow_path(fd == -1)) { if (nxt_slow_path(fd == -1)) {
nxt_log(task, NXT_LOG_CRIT, "shm_open(%s) failed %E", name, nxt_errno); nxt_alert(task, "shm_open(%s) failed %E", name, nxt_errno);
goto remove_fail; goto remove_fail;
} }

17
src/nxt_port_socket.c
View File

@@ -141,13 +141,7 @@ nxt_port_release_send_msg(nxt_task_t *task, void *obj, void *data)
msg = obj; msg = obj;
engine = data; engine = data;
#if (NXT_DEBUG) nxt_assert(data == msg->work.data);
if (nxt_slow_path(data != msg->work.data)) {
nxt_log_alert(task->log, "release msg data (%p) != msg->engine (%p)",
data, msg->work.data);
nxt_abort();
}
#endif
if (engine != task->thread->engine) { if (engine != task->thread->engine) {
@@ -374,9 +368,8 @@ nxt_port_write_handler(nxt_task_t *task, void *obj, void *data)
if (n > 0) { if (n > 0) {
if (nxt_slow_path((size_t) n != sb.size + iov[0].iov_len)) { if (nxt_slow_path((size_t) n != sb.size + iov[0].iov_len)) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "port %d: short write: %z instead of %uz",
"port %d: short write: %z instead of %uz", port->socket.fd, n, sb.size + iov[0].iov_len);
port->socket.fd, n, sb.size + iov[0].iov_len);
goto fail; goto fail;
} }
@@ -691,8 +684,8 @@ nxt_port_read_msg_process(nxt_task_t *task, nxt_port_t *port,
nxt_port_recv_msg_t *fmsg; nxt_port_recv_msg_t *fmsg;
if (nxt_slow_path(msg->size < sizeof(nxt_port_msg_t))) { if (nxt_slow_path(msg->size < sizeof(nxt_port_msg_t))) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "port %d: too small message:%uz",
"port %d: too small message:%uz", port->socket.fd, msg->size); port->socket.fd, msg->size);
if (msg->fd != -1) { if (msg->fd != -1) {
nxt_fd_close(msg->fd); nxt_fd_close(msg->fd);

63
src/nxt_process.c
View File

@@ -51,8 +51,8 @@ nxt_process_create(nxt_task_t *task, nxt_process_t *process)
switch (pid) { switch (pid) {
case -1: case -1:
nxt_log(task, NXT_LOG_CRIT, "fork() failed while creating \"%s\" %E", nxt_alert(task, "fork() failed while creating \"%s\" %E",
process->init->name, nxt_errno); process->init->name, nxt_errno);
break; break;
case 0: case 0:
@@ -236,8 +236,7 @@ nxt_process_execute(nxt_task_t *task, char *name, char **argv, char **envp)
nxt_debug(task, "posix_spawn(\"%s\")", name); nxt_debug(task, "posix_spawn(\"%s\")", name);
if (posix_spawn(&pid, name, NULL, NULL, argv, envp) != 0) { if (posix_spawn(&pid, name, NULL, NULL, argv, envp) != 0) {
nxt_log(task, NXT_LOG_CRIT, "posix_spawn(\"%s\") failed %E", nxt_alert(task, "posix_spawn(\"%s\") failed %E", name, nxt_errno);
name, nxt_errno);
return -1; return -1;
} }
@@ -263,8 +262,8 @@ nxt_process_execute(nxt_task_t *task, char *name, char **argv, char **envp)
switch (pid) { switch (pid) {
case -1: case -1:
nxt_log(task, NXT_LOG_CRIT, "vfork() failed while executing \"%s\" %E", nxt_alert(task, "vfork() failed while executing \"%s\" %E",
name, nxt_errno); name, nxt_errno);
break; break;
case 0: case 0:
@@ -273,8 +272,7 @@ nxt_process_execute(nxt_task_t *task, char *name, char **argv, char **envp)
(void) execve(name, argv, envp); (void) execve(name, argv, envp);
nxt_log(task, NXT_LOG_CRIT, "execve(\"%s\") failed %E", nxt_alert(task, "execve(\"%s\") failed %E", name, nxt_errno);
name, nxt_errno);
exit(1); exit(1);
nxt_unreachable(); nxt_unreachable();
@@ -336,7 +334,7 @@ nxt_process_daemon(nxt_task_t *task)
/* Detach from controlling terminal. */ /* Detach from controlling terminal. */
if (setsid() == -1) { if (setsid() == -1) {
nxt_log(task, NXT_LOG_CRIT, "setsid() failed %E", nxt_errno); nxt_alert(task, "setsid() failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -372,7 +370,7 @@ nxt_process_daemon(nxt_task_t *task)
fail: fail:
nxt_log(task, NXT_LOG_CRIT, msg, nxt_errno); nxt_alert(task, msg, nxt_errno);
if (fd != -1) { if (fd != -1) {
nxt_fd_close(fd); nxt_fd_close(fd);
@@ -407,12 +405,10 @@ nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc, const char *group)
if (nxt_slow_path(pwd == NULL)) { if (nxt_slow_path(pwd == NULL)) {
if (nxt_errno == 0) { if (nxt_errno == 0) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "getpwnam(\"%s\") failed, user \"%s\" not found",
"getpwnam(\"%s\") failed, user \"%s\" not found", uc->user, uc->user);
uc->user, uc->user);
} else { } else {
nxt_log(task, NXT_LOG_CRIT, "getpwnam(\"%s\") failed %E", nxt_alert(task, "getpwnam(\"%s\") failed %E", uc->user, nxt_errno);
uc->user, nxt_errno);
} }
return NXT_ERROR; return NXT_ERROR;
@@ -429,12 +425,11 @@ nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc, const char *group)
if (nxt_slow_path(grp == NULL)) { if (nxt_slow_path(grp == NULL)) {
if (nxt_errno == 0) { if (nxt_errno == 0) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task,
"getgrnam(\"%s\") failed, group \"%s\" not found", "getgrnam(\"%s\") failed, group \"%s\" not found",
group, group); group, group);
} else { } else {
nxt_log(task, NXT_LOG_CRIT, "getgrnam(\"%s\") failed %E", nxt_alert(task, "getgrnam(\"%s\") failed %E", group, nxt_errno);
group, nxt_errno);
} }
return NXT_ERROR; return NXT_ERROR;
@@ -487,7 +482,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
nsaved = getgroups(0, NULL); nsaved = getgroups(0, NULL);
if (nsaved == -1) { if (nsaved == -1) {
nxt_log(task, NXT_LOG_CRIT, "getgroups(0, NULL) failed %E", nxt_errno); nxt_alert(task, "getgroups(0, NULL) failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -509,23 +504,21 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
nsaved = getgroups(nsaved, saved); nsaved = getgroups(nsaved, saved);
if (nsaved == -1) { if (nsaved == -1) {
nxt_log(task, NXT_LOG_CRIT, "getgroups(%d) failed %E", nxt_alert(task, "getgroups(%d) failed %E", nsaved, nxt_errno);
nsaved, nxt_errno);
goto fail; goto fail;
} }
nxt_debug(task, "getgroups(): %d", nsaved); nxt_debug(task, "getgroups(): %d", nsaved);
if (initgroups(uc->user, uc->base_gid) != 0) { if (initgroups(uc->user, uc->base_gid) != 0) {
nxt_log(task, NXT_LOG_CRIT, "initgroups(%s, %d) failed", nxt_alert(task, "initgroups(%s, %d) failed", uc->user, uc->base_gid);
uc->user, uc->base_gid);
goto restore; goto restore;
} }
ngroups = getgroups(0, NULL); ngroups = getgroups(0, NULL);
if (ngroups == -1) { if (ngroups == -1) {
nxt_log(task, NXT_LOG_CRIT, "getgroups(0, NULL) failed %E", nxt_errno); nxt_alert(task, "getgroups(0, NULL) failed %E", nxt_errno);
goto restore; goto restore;
} }
@@ -540,8 +533,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
ngroups = getgroups(ngroups, uc->gids); ngroups = getgroups(ngroups, uc->gids);
if (ngroups == -1) { if (ngroups == -1) {
nxt_log(task, NXT_LOG_CRIT, "getgroups(%d) failed %E", nxt_alert(task, "getgroups(%d) failed %E", ngroups, nxt_errno);
ngroups, nxt_errno);
goto restore; goto restore;
} }
@@ -571,8 +563,7 @@ nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
restore: restore:
if (setgroups(nsaved, saved) != 0) { if (setgroups(nsaved, saved) != 0) {
nxt_log(task, NXT_LOG_CRIT, "setgroups(%d) failed %E", nxt_alert(task, "setgroups(%d) failed %E", nsaved, nxt_errno);
nsaved, nxt_errno);
ret = NXT_ERROR; ret = NXT_ERROR;
} }
@@ -591,29 +582,27 @@ nxt_user_cred_set(nxt_task_t *task, nxt_user_cred_t *uc)
uc->user, (uint64_t) uc->uid, (uint64_t) uc->base_gid); uc->user, (uint64_t) uc->uid, (uint64_t) uc->base_gid);
if (setgid(uc->base_gid) != 0) { if (setgid(uc->base_gid) != 0) {
nxt_log(task, NXT_LOG_CRIT, "setgid(%d) failed %E", nxt_alert(task, "setgid(%d) failed %E", uc->base_gid, nxt_errno);
uc->base_gid, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
if (uc->gids != NULL) { if (uc->gids != NULL) {
if (setgroups(uc->ngroups, uc->gids) != 0) { if (setgroups(uc->ngroups, uc->gids) != 0) {
nxt_log(task, NXT_LOG_CRIT, "setgroups(%i) failed %E", nxt_alert(task, "setgroups(%i) failed %E", uc->ngroups, nxt_errno);
uc->ngroups, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
} else { } else {
/* MacOSX fallback. */ /* MacOSX fallback. */
if (initgroups(uc->user, uc->base_gid) != 0) { if (initgroups(uc->user, uc->base_gid) != 0) {
nxt_log(task, NXT_LOG_CRIT, "initgroups(%s, %d) failed", nxt_alert(task, "initgroups(%s, %d) failed",
uc->user, uc->base_gid); uc->user, uc->base_gid);
return NXT_ERROR; return NXT_ERROR;
} }
} }
if (setuid(uc->uid) != 0) { if (setuid(uc->uid) != 0) {
nxt_log(task, NXT_LOG_CRIT, "setuid(%d) failed %E", uc->uid, nxt_errno); nxt_alert(task, "setuid(%d) failed %E", uc->uid, nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }

75
src/nxt_python_wsgi.c
View File

@@ -197,7 +197,7 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
c = &conf->u.python; c = &conf->u.python;
if (c->module.length == 0) { if (c->module.length == 0) {
nxt_log_emerg(task->log, "python module is empty"); nxt_alert(task, "python module is empty");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -208,7 +208,7 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
nxt_py_home = nxt_malloc(sizeof(*nxt_py_home) * (len + 1)); nxt_py_home = nxt_malloc(sizeof(*nxt_py_home) * (len + 1));
if (nxt_slow_path(nxt_py_home == NULL)) { if (nxt_slow_path(nxt_py_home == NULL)) {
nxt_log_emerg(task->log, "Failed to allocate buffer for home path"); nxt_alert(task, "Failed to allocate buffer for home path");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -231,24 +231,21 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
c->path.length); c->path.length);
if (nxt_slow_path(obj == NULL)) { if (nxt_slow_path(obj == NULL)) {
nxt_log_alert(task->log, nxt_alert(task, "Python failed create string object \"%V\"",
"Python failed create string object \"%V\"", &c->path);
&c->path);
goto fail; goto fail;
} }
pypath = PySys_GetObject((char *) "path"); pypath = PySys_GetObject((char *) "path");
if (nxt_slow_path(pypath == NULL)) { if (nxt_slow_path(pypath == NULL)) {
nxt_log_alert(task->log, nxt_alert(task, "Python failed to get \"sys.path\" list");
"Python failed to get \"sys.path\" list");
goto fail; goto fail;
} }
if (nxt_slow_path(PyList_Insert(pypath, 0, obj) != 0)) { if (nxt_slow_path(PyList_Insert(pypath, 0, obj) != 0)) {
nxt_log_alert(task->log, nxt_alert(task, "Python failed to insert \"%V\" into \"sys.path\"",
"Python failed to insert \"%V\" into \"sys.path\"", &c->path);
&c->path);
goto fail; goto fail;
} }
@@ -259,7 +256,7 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
obj = PyCFunction_New(nxt_py_start_resp_method, NULL); obj = PyCFunction_New(nxt_py_start_resp_method, NULL);
if (nxt_slow_path(obj == NULL)) { if (nxt_slow_path(obj == NULL)) {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to initialize the \"start_response\" function"); "Python failed to initialize the \"start_response\" function");
goto fail; goto fail;
} }
@@ -276,13 +273,12 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
obj = Py_BuildValue("[s]", "unit"); obj = Py_BuildValue("[s]", "unit");
if (obj == NULL) { if (obj == NULL) {
nxt_log_alert(task->log, nxt_alert(task, "Python failed to create the \"sys.argv\" list");
"Python failed to create the \"sys.argv\" list");
goto fail; goto fail;
} }
if (PySys_SetObject((char *) "argv", obj) != 0) { if (PySys_SetObject((char *) "argv", obj) != 0) {
nxt_log_alert(task->log, "Python failed to set the \"sys.argv\" list"); nxt_alert(task, "Python failed to set the \"sys.argv\" list");
goto fail; goto fail;
} }
@@ -295,8 +291,7 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
module = PyImport_ImportModule(nxt_py_module); module = PyImport_ImportModule(nxt_py_module);
if (nxt_slow_path(module == NULL)) { if (nxt_slow_path(module == NULL)) {
nxt_log_emerg(task->log, "Python failed to import module \"%s\"", nxt_alert(task, "Python failed to import module \"%s\"", nxt_py_module);
nxt_py_module);
PyErr_PrintEx(1); PyErr_PrintEx(1);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -304,14 +299,14 @@ nxt_python_init(nxt_task_t *task, nxt_common_app_conf_t *conf)
obj = PyDict_GetItemString(PyModule_GetDict(module), "application"); obj = PyDict_GetItemString(PyModule_GetDict(module), "application");
if (nxt_slow_path(obj == NULL)) { if (nxt_slow_path(obj == NULL)) {
nxt_log_emerg(task->log, "Python failed to get \"application\" " nxt_alert(task, "Python failed to get \"application\" "
"from module \"%s\"", nxt_py_module); "from module \"%s\"", nxt_py_module);
goto fail; goto fail;
} }
if (nxt_slow_path(PyCallable_Check(obj) == 0)) { if (nxt_slow_path(PyCallable_Check(obj) == 0)) {
nxt_log_emerg(task->log, "\"application\" in module \"%s\" " nxt_alert(task, "\"application\" in module \"%s\" "
"is not a callable object", nxt_py_module); "is not a callable object", nxt_py_module);
PyErr_PrintEx(1); PyErr_PrintEx(1);
goto fail; goto fail;
} }
@@ -479,23 +474,22 @@ nxt_python_create_environ(nxt_task_t *task)
environ = PyDict_New(); environ = PyDict_New();
if (nxt_slow_path(environ == NULL)) { if (nxt_slow_path(environ == NULL)) {
nxt_log_alert(task->log, nxt_alert(task, "Python failed to create the \"environ\" dictionary");
"Python failed to create the \"environ\" dictionary");
return NULL; return NULL;
} }
obj = Py_BuildValue("(ii)", 1, 0); obj = Py_BuildValue("(ii)", 1, 0);
if (nxt_slow_path(obj == NULL)) { if (nxt_slow_path(obj == NULL)) {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to build the \"wsgi.version\" environ value"); "Python failed to build the \"wsgi.version\" environ value");
goto fail; goto fail;
} }
if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.version", obj) != 0)) if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.version", obj) != 0))
{ {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.version\" environ value"); "Python failed to set the \"wsgi.version\" environ value");
goto fail; goto fail;
} }
@@ -507,7 +501,7 @@ nxt_python_create_environ(nxt_task_t *task)
Py_False) Py_False)
!= 0)) != 0))
{ {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.multithread\" environ value"); "Python failed to set the \"wsgi.multithread\" environ value");
goto fail; goto fail;
} }
@@ -516,7 +510,7 @@ nxt_python_create_environ(nxt_task_t *task)
Py_True) Py_True)
!= 0)) != 0))
{ {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.multiprocess\" environ value"); "Python failed to set the \"wsgi.multiprocess\" environ value");
goto fail; goto fail;
} }
@@ -525,8 +519,8 @@ nxt_python_create_environ(nxt_task_t *task)
Py_False) Py_False)
!= 0)) != 0))
{ {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.run_once\" environ value"); "Python failed to set the \"wsgi.run_once\" environ value");
goto fail; goto fail;
} }
@@ -534,7 +528,7 @@ nxt_python_create_environ(nxt_task_t *task)
obj = PyString_FromString("http"); obj = PyString_FromString("http");
if (nxt_slow_path(obj == NULL)) { if (nxt_slow_path(obj == NULL)) {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to create the \"wsgi.url_scheme\" environ value"); "Python failed to create the \"wsgi.url_scheme\" environ value");
goto fail; goto fail;
} }
@@ -542,8 +536,8 @@ nxt_python_create_environ(nxt_task_t *task)
if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.url_scheme", obj) if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.url_scheme", obj)
!= 0)) != 0))
{ {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.url_scheme\" environ value"); "Python failed to set the \"wsgi.url_scheme\" environ value");
goto fail; goto fail;
} }
@@ -552,22 +546,21 @@ nxt_python_create_environ(nxt_task_t *task)
if (nxt_slow_path(PyType_Ready(&nxt_py_input_type) != 0)) { if (nxt_slow_path(PyType_Ready(&nxt_py_input_type) != 0)) {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to initialize the \"wsgi.input\" type object"); "Python failed to initialize the \"wsgi.input\" type object");
goto fail; goto fail;
} }
obj = (PyObject *) PyObject_New(nxt_py_input_t, &nxt_py_input_type); obj = (PyObject *) PyObject_New(nxt_py_input_t, &nxt_py_input_type);
if (nxt_slow_path(obj == NULL)) { if (nxt_slow_path(obj == NULL)) {
nxt_log_alert(task->log, nxt_alert(task, "Python failed to create the \"wsgi.input\" object");
"Python failed to create the \"wsgi.input\" object");
goto fail; goto fail;
} }
if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.input", obj) != 0)) { if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.input", obj) != 0)) {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.input\" environ value"); "Python failed to set the \"wsgi.input\" environ value");
goto fail; goto fail;
} }
@@ -578,14 +571,14 @@ nxt_python_create_environ(nxt_task_t *task)
err = PySys_GetObject((char *) "stderr"); err = PySys_GetObject((char *) "stderr");
if (nxt_slow_path(err == NULL)) { if (nxt_slow_path(err == NULL)) {
nxt_log_alert(task->log, "Python failed to get \"sys.stderr\" object"); nxt_alert(task, "Python failed to get \"sys.stderr\" object");
goto fail; goto fail;
} }
if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.errors", err) != 0)) if (nxt_slow_path(PyDict_SetItemString(environ, "wsgi.errors", err) != 0))
{ {
nxt_log_alert(task->log, nxt_alert(task,
"Python failed to set the \"wsgi.errors\" environ value"); "Python failed to set the \"wsgi.errors\" environ value");
goto fail; goto fail;
} }

29
src/nxt_router.c
View File

@@ -990,7 +990,7 @@ nxt_router_conf_error(nxt_task_t *task, nxt_router_temp_conf_t *tmcf)
nxt_queue_link_t *qlk; nxt_queue_link_t *qlk;
nxt_socket_conf_t *skcf; nxt_socket_conf_t *skcf;
nxt_log(task, NXT_LOG_CRIT, "failed to apply new conf"); nxt_alert(task, "failed to apply new conf");
for (qlk = nxt_queue_first(&tmcf->creating); for (qlk = nxt_queue_first(&tmcf->creating);
qlk != nxt_queue_tail(&tmcf->creating); qlk != nxt_queue_tail(&tmcf->creating);
@@ -1206,7 +1206,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
conf = nxt_conf_json_parse(tmcf->mem_pool, start, end, NULL); conf = nxt_conf_json_parse(tmcf->mem_pool, start, end, NULL);
if (conf == NULL) { if (conf == NULL) {
nxt_log(task, NXT_LOG_CRIT, "configuration parsing error"); nxt_alert(task, "configuration parsing error");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -1215,7 +1215,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
ret = nxt_conf_map_object(mp, conf, nxt_router_conf, ret = nxt_conf_map_object(mp, conf, nxt_router_conf,
nxt_nitems(nxt_router_conf), tmcf->conf); nxt_nitems(nxt_router_conf), tmcf->conf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "root map error"); nxt_alert(task, "root map error");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -1225,7 +1225,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
applications = nxt_conf_get_path(conf, &applications_path); applications = nxt_conf_get_path(conf, &applications_path);
if (applications == NULL) { if (applications == NULL) {
nxt_log(task, NXT_LOG_CRIT, "no \"applications\" block"); nxt_alert(task, "no \"applications\" block");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -1283,14 +1283,14 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
ret = nxt_conf_map_object(mp, application, nxt_router_app_conf, ret = nxt_conf_map_object(mp, application, nxt_router_app_conf,
nxt_nitems(nxt_router_app_conf), &apcf); nxt_nitems(nxt_router_app_conf), &apcf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "application map error"); nxt_alert(task, "application map error");
goto app_fail; goto app_fail;
} }
if (apcf.limits_value != NULL) { if (apcf.limits_value != NULL) {
if (nxt_conf_type(apcf.limits_value) != NXT_CONF_OBJECT) { if (nxt_conf_type(apcf.limits_value) != NXT_CONF_OBJECT) {
nxt_log(task, NXT_LOG_CRIT, "application limits is not object"); nxt_alert(task, "application limits is not object");
goto app_fail; goto app_fail;
} }
@@ -1299,7 +1299,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
nxt_nitems(nxt_router_app_limits_conf), nxt_nitems(nxt_router_app_limits_conf),
&apcf); &apcf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "application limits map error"); nxt_alert(task, "application limits map error");
goto app_fail; goto app_fail;
} }
} }
@@ -1312,7 +1312,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
nxt_nitems(nxt_router_app_processes_conf), nxt_nitems(nxt_router_app_processes_conf),
&apcf); &apcf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "application processes map error"); nxt_alert(task, "application processes map error");
goto app_fail; goto app_fail;
} }
@@ -1330,8 +1330,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
lang = nxt_app_lang_module(task->thread->runtime, &apcf.type); lang = nxt_app_lang_module(task->thread->runtime, &apcf.type);
if (lang == NULL) { if (lang == NULL) {
nxt_log(task, NXT_LOG_CRIT, "unknown application type: \"%V\"", nxt_alert(task, "unknown application type: \"%V\"", &apcf.type);
&apcf.type);
goto app_fail; goto app_fail;
} }
@@ -1386,14 +1385,14 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
http = nxt_conf_get_path(conf, &http_path); http = nxt_conf_get_path(conf, &http_path);
#if 0 #if 0
if (http == NULL) { if (http == NULL) {
nxt_log(task, NXT_LOG_CRIT, "no \"http\" block"); nxt_alert(task, "no \"http\" block");
return NXT_ERROR; return NXT_ERROR;
} }
#endif #endif
listeners = nxt_conf_get_path(conf, &listeners_path); listeners = nxt_conf_get_path(conf, &listeners_path);
if (listeners == NULL) { if (listeners == NULL) {
nxt_log(task, NXT_LOG_CRIT, "no \"listeners\" block"); nxt_alert(task, "no \"listeners\" block");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -1413,7 +1412,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
ret = nxt_conf_map_object(mp, listener, nxt_router_listener_conf, ret = nxt_conf_map_object(mp, listener, nxt_router_listener_conf,
nxt_nitems(nxt_router_listener_conf), &lscf); nxt_nitems(nxt_router_listener_conf), &lscf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "listener map error"); nxt_alert(task, "listener map error");
goto fail; goto fail;
} }
@@ -1434,7 +1433,7 @@ nxt_router_conf_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
ret = nxt_conf_map_object(mp, http, nxt_router_http_conf, ret = nxt_conf_map_object(mp, http, nxt_router_http_conf,
nxt_nitems(nxt_router_http_conf), skcf); nxt_nitems(nxt_router_http_conf), skcf);
if (ret != NXT_OK) { if (ret != NXT_OK) {
nxt_log(task, NXT_LOG_CRIT, "http map error"); nxt_alert(task, "http map error");
goto fail; goto fail;
} }
} }
@@ -1514,7 +1513,7 @@ nxt_router_socket_conf(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
sa = nxt_sockaddr_parse(tmcf->mem_pool, name); sa = nxt_sockaddr_parse(tmcf->mem_pool, name);
if (nxt_slow_path(sa == NULL)) { if (nxt_slow_path(sa == NULL)) {
nxt_log(task, NXT_LOG_CRIT, "invalid listener \"%V\"", name); nxt_alert(task, "invalid listener \"%V\"", name);
return NULL; return NULL;
} }

36
src/nxt_runtime.c
View File

@@ -157,7 +157,7 @@ nxt_runtime_inherited_listen_sockets(nxt_task_t *task, nxt_runtime_t *rt)
return nxt_runtime_systemd_listen_sockets(task, rt); return nxt_runtime_systemd_listen_sockets(task, rt);
} }
nxt_log(task, NXT_LOG_CRIT, "using inherited listen sockets: %s", v); nxt_alert(task, "using inherited listen sockets: %s", v);
inherited_sockets = nxt_array_create(rt->mem_pool, inherited_sockets = nxt_array_create(rt->mem_pool,
1, sizeof(nxt_listen_socket_t)); 1, sizeof(nxt_listen_socket_t));
@@ -173,9 +173,9 @@ nxt_runtime_inherited_listen_sockets(nxt_task_t *task, nxt_runtime_t *rt)
s = nxt_int_parse(v, p - v); s = nxt_int_parse(v, p - v);
if (nxt_slow_path(s < 0)) { if (nxt_slow_path(s < 0)) {
nxt_log(task, NXT_LOG_CRIT, "invalid socket number " nxt_alert(task, "invalid socket number \"%s\" "
"\"%s\" in NGINX environment variable, " "in NGINX environment variable, "
"ignoring the rest of the variable", v); "ignoring the rest of the variable", v);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -890,8 +890,7 @@ nxt_runtime_conf_read_cmd(nxt_task_t *task, nxt_runtime_t *rt)
if (nxt_strcmp(p, "--upstream") == 0) { if (nxt_strcmp(p, "--upstream") == 0) {
if (*argv == NULL) { if (*argv == NULL) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "no argument for option \"--upstream\"");
"no argument for option \"--upstream\"");
return NXT_ERROR; return NXT_ERROR;
} }
@@ -1060,14 +1059,12 @@ nxt_runtime_sockaddr_unix_parse(nxt_task_t *task, nxt_mp_t *mp, nxt_str_t *addr)
p = addr->start + 5; p = addr->start + 5;
if (length == 0) { if (length == 0) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "unix domain socket \"%V\" name is invalid", addr);
"unix domain socket \"%V\" name is invalid", addr);
return NULL; return NULL;
} }
if (length > max_len) { if (length > max_len) {
nxt_log(task, NXT_LOG_CRIT, nxt_alert(task, "unix domain socket \"%V\" name is too long", addr);
"unix domain socket \"%V\" name is too long", addr);
return NULL; return NULL;
} }
@@ -1106,8 +1103,7 @@ nxt_runtime_sockaddr_unix_parse(nxt_task_t *task, nxt_mp_t *mp, nxt_str_t *addr)
#else /* !(NXT_HAVE_UNIX_DOMAIN) */ #else /* !(NXT_HAVE_UNIX_DOMAIN) */
nxt_log(task, NXT_LOG_CRIT, "unix domain socket \"%V\" is not supported", nxt_alert(task, "unix domain socket \"%V\" is not supported", addr);
addr);
return NULL; return NULL;
@@ -1163,7 +1159,7 @@ nxt_runtime_sockaddr_inet6_parse(nxt_task_t *task, nxt_mp_t *mp,
} }
} }
nxt_log(task, NXT_LOG_CRIT, "invalid port in \"%V\"", addr); nxt_alert(task, "invalid port in \"%V\"", addr);
return NULL; return NULL;
@@ -1178,13 +1174,13 @@ found:
invalid_address: invalid_address:
nxt_log(task, NXT_LOG_CRIT, "invalid IPv6 address in \"%V\"", addr); nxt_alert(task, "invalid IPv6 address in \"%V\"", addr);
return NULL; return NULL;
#else #else
nxt_log(task, NXT_LOG_CRIT, "IPv6 socket \"%V\" is not supported", addr); nxt_alert(task, "IPv6 socket \"%V\" is not supported", addr);
return NULL; return NULL;
@@ -1275,13 +1271,13 @@ nxt_runtime_sockaddr_inet_parse(nxt_task_t *task, nxt_mp_t *mp,
invalid_port: invalid_port:
nxt_log(task, NXT_LOG_CRIT, "invalid port in \"%V\"", string); nxt_alert(task, "invalid port in \"%V\"", string);
return NULL; return NULL;
invalid_addr: invalid_addr:
nxt_log(task, NXT_LOG_CRIT, "invalid address in \"%V\"", string); nxt_alert(task, "invalid address in \"%V\"", string);
return NULL; return NULL;
} }
@@ -1324,7 +1320,7 @@ nxt_runtime_hostname(nxt_task_t *task, nxt_runtime_t *rt)
char hostname[NXT_MAXHOSTNAMELEN + 1]; char hostname[NXT_MAXHOSTNAMELEN + 1];
if (gethostname(hostname, NXT_MAXHOSTNAMELEN) != 0) { if (gethostname(hostname, NXT_MAXHOSTNAMELEN) != 0) {
nxt_log(task, NXT_LOG_CRIT, "gethostname() failed %E", nxt_errno); nxt_alert(task, "gethostname() failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -1367,7 +1363,7 @@ nxt_runtime_log_files_init(nxt_runtime_t *rt)
file = nxt_list_zero_add(log_files); file = nxt_list_zero_add(log_files);
file->fd = NXT_FILE_INVALID; file->fd = NXT_FILE_INVALID;
file->log_level = NXT_LOG_CRIT; file->log_level = NXT_LOG_ALERT;
return NXT_OK; return NXT_OK;
} }
@@ -1408,7 +1404,7 @@ nxt_runtime_log_file_add(nxt_runtime_t *rt, nxt_str_t *name)
} }
file->fd = NXT_FILE_INVALID; file->fd = NXT_FILE_INVALID;
file->log_level = NXT_LOG_CRIT; file->log_level = NXT_LOG_ALERT;
file->name = file_name.start; file->name = file_name.start;
return file; return file;

4
src/nxt_service.c
View File

@@ -107,7 +107,7 @@ nxt_service_add(nxt_array_t *services, const nxt_service_t *service)
goto next; goto next;
} }
nxt_thread_log_emerg("service \"%s:%s\" is duplicate", nxt_thread_log_alert("service \"%s:%s\" is duplicate",
service->type, service->name); service->type, service->name);
return NXT_ERROR; return NXT_ERROR;
@@ -158,7 +158,7 @@ nxt_service_get(nxt_array_t *services, const char *type, const char *name)
n--; n--;
} }
nxt_thread_log_emerg("service \"%s%s%s\" not found", nxt_thread_log_alert("service \"%s%s%s\" not found",
type, (name != NULL) ? ":" : "", name); type, (name != NULL) ? ":" : "", name);
return NULL; return NULL;

29
src/nxt_socket.c
View File

@@ -28,8 +28,8 @@ nxt_socket_create(nxt_task_t *task, nxt_uint_t domain, nxt_uint_t type,
s = socket(domain, type, protocol); s = socket(domain, type, protocol);
if (nxt_slow_path(s == -1)) { if (nxt_slow_path(s == -1)) {
nxt_log(task, NXT_LOG_CRIT, "socket(%ui, 0x%uXi, %ui) failed %E", nxt_alert(task, "socket(%ui, 0x%uXi, %ui) failed %E",
domain, type, protocol, nxt_socket_errno); domain, type, protocol, nxt_socket_errno);
return s; return s;
} }
@@ -57,8 +57,7 @@ nxt_socket_close(nxt_task_t *task, nxt_socket_t s)
nxt_debug(task, "socket close(%d)", s); nxt_debug(task, "socket close(%d)", s);
} else { } else {
nxt_log(task, NXT_LOG_CRIT, "socket close(%d) failed %E", nxt_alert(task, "socket close(%d) failed %E", s, nxt_socket_errno);
s, nxt_socket_errno);
} }
} }
@@ -99,9 +98,9 @@ nxt_socket_getsockopt(nxt_task_t *task, nxt_socket_t s, nxt_uint_t level,
return val; return val;
} }
nxt_log(task, NXT_LOG_CRIT, "getsockopt(%d, %ui, %s) failed %E", nxt_alert(task, "getsockopt(%d, %ui, %s) failed %E",
s, level, nxt_socket_sockopt_name(level, sockopt), s, level, nxt_socket_sockopt_name(level, sockopt),
nxt_socket_errno); nxt_socket_errno);
return -1; return -1;
} }
@@ -121,9 +120,9 @@ nxt_socket_setsockopt(nxt_task_t *task, nxt_socket_t s, nxt_uint_t level,
return NXT_OK; return NXT_OK;
} }
nxt_log(task, NXT_LOG_CRIT, "setsockopt(%d, %ui, %s, %d) failed %E", nxt_alert(task, "setsockopt(%d, %ui, %s, %d) failed %E",
s, level, nxt_socket_sockopt_name(level, sockopt), s, level, nxt_socket_sockopt_name(level, sockopt), val,
val, nxt_socket_errno); nxt_socket_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -203,8 +202,8 @@ nxt_socket_bind(nxt_task_t *task, nxt_socket_t s, nxt_sockaddr_t *sa,
return NXT_DECLINED; return NXT_DECLINED;
} }
nxt_log(task, NXT_LOG_CRIT, "bind(%d, %*s) failed %E", nxt_alert(task, "bind(%d, %*s) failed %E",
s, (size_t) sa->length, nxt_sockaddr_start(sa), err); s, (size_t) sa->length, nxt_sockaddr_start(sa), err);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -255,7 +254,7 @@ nxt_socket_connect(nxt_task_t *task, nxt_socket_t s, nxt_sockaddr_t *sa)
break; break;
default: default:
level = NXT_LOG_CRIT; level = NXT_LOG_ALERT;
ret = NXT_ERROR; ret = NXT_ERROR;
} }
@@ -294,7 +293,7 @@ nxt_socket_shutdown(nxt_task_t *task, nxt_socket_t s, nxt_uint_t how)
break; break;
default: default:
level = NXT_LOG_CRIT; level = NXT_LOG_ALERT;
} }
nxt_log(task, level, "shutdown(%d, %ui) failed %E", s, how, err); nxt_log(task, level, "shutdown(%d, %ui) failed %E", s, how, err);
@@ -317,6 +316,6 @@ nxt_socket_error_level(nxt_err_t err)
return NXT_LOG_ERR; return NXT_LOG_ERR;
default: default:
return NXT_LOG_CRIT; return NXT_LOG_ALERT;
} }
} }

10
src/nxt_socketpair.c
View File

@@ -30,7 +30,7 @@ nxt_int_t
nxt_socketpair_create(nxt_task_t *task, nxt_socket_t *pair) nxt_socketpair_create(nxt_task_t *task, nxt_socket_t *pair)
{ {
if (nxt_slow_path(socketpair(AF_UNIX, NXT_UNIX_SOCKET, 0, pair) != 0)) { if (nxt_slow_path(socketpair(AF_UNIX, NXT_UNIX_SOCKET, 0, pair) != 0)) {
nxt_log(task, NXT_LOG_CRIT, "socketpair() failed %E", nxt_errno); nxt_alert(task, "socketpair() failed %E", nxt_errno);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -103,8 +103,8 @@ nxt_socketpair_send(nxt_fd_event_t *ev, nxt_fd_t fd, nxt_iobuf_t *iob,
continue; continue;
default: default:
nxt_log(ev->task, NXT_LOG_CRIT, "sendmsg(%d, %FD, %ui) failed %E", nxt_alert(ev->task, "sendmsg(%d, %FD, %ui) failed %E",
ev->fd, fd, niob, err); ev->fd, fd, niob, err);
return NXT_ERROR; return NXT_ERROR;
} }
@@ -152,8 +152,8 @@ nxt_socketpair_recv(nxt_fd_event_t *ev, nxt_fd_t *fd, nxt_iobuf_t *iob,
continue; continue;
default: default:
nxt_log(ev->task, NXT_LOG_CRIT, "recvmsg(%d, %p, %ui) failed %E", nxt_alert(ev->task, "recvmsg(%d, %p, %ui) failed %E",
ev->fd, fd, niob, err); ev->fd, fd, niob, err);
return NXT_ERROR; return NXT_ERROR;
} }

2
src/nxt_thread.c
View File

@@ -33,7 +33,7 @@ nxt_thread_init_data(nxt_thread_specific_data_t tsd)
err = pthread_key_create(&key, nxt_thread_key_dtor); err = pthread_key_create(&key, nxt_thread_key_dtor);
if (err != 0) { if (err != 0) {
nxt_main_log_emerg("pthread_key_create() failed %E", err); nxt_main_log_alert("pthread_key_create() failed %E", err);
goto fail; goto fail;
} }

2
src/nxt_thread_cond.c
View File

@@ -18,7 +18,7 @@ nxt_thread_cond_create(nxt_thread_cond_t *cond)
return NXT_OK; return NXT_OK;
} }
nxt_thread_log_emerg("pthread_cond_init() failed %E", err); nxt_thread_log_alert("pthread_cond_init() failed %E", err);
return NXT_ERROR; return NXT_ERROR;
} }

9
src/nxt_thread_log.h
View File

@@ -8,15 +8,6 @@
#define _NXT_THREAD_LOG_H_INCLUDED_ #define _NXT_THREAD_LOG_H_INCLUDED_
#define nxt_thread_log_emerg(...) \
do { \
nxt_thread_t *_thr = nxt_thread(); \
\
nxt_log_emerg(_thr->log, __VA_ARGS__); \
\
} while (0)
#define nxt_thread_log_alert(...) \ #define nxt_thread_log_alert(...) \
do { \ do { \
nxt_thread_t *_thr = nxt_thread(); \ nxt_thread_t *_thr = nxt_thread(); \

6
src/nxt_thread_mutex.c
View File

@@ -85,20 +85,20 @@ nxt_thread_mutex_create(nxt_thread_mutex_t *mtx)
err = pthread_mutexattr_init(&attr); err = pthread_mutexattr_init(&attr);
if (err != 0) { if (err != 0) {
nxt_thread_log_emerg("pthread_mutexattr_init() failed %E", err); nxt_thread_log_alert("pthread_mutexattr_init() failed %E", err);
return NXT_ERROR; return NXT_ERROR;
} }
err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK); err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
if (err != 0) { if (err != 0) {
nxt_thread_log_emerg("pthread_mutexattr_settype" nxt_thread_log_alert("pthread_mutexattr_settype"
"(PTHREAD_MUTEX_ERRORCHECK) failed %E", err); "(PTHREAD_MUTEX_ERRORCHECK) failed %E", err);
return NXT_ERROR; return NXT_ERROR;
} }
err = pthread_mutex_init(mtx, &attr); err = pthread_mutex_init(mtx, &attr);
if (err != 0) { if (err != 0) {
nxt_thread_log_emerg("pthread_mutex_init() failed %E", err); nxt_thread_log_alert("pthread_mutex_init() failed %E", err);
return NXT_ERROR; return NXT_ERROR;
} }

19
src/perl/nxt_perl_psgi.c
View File

@@ -437,8 +437,7 @@ nxt_perl_psgi_interpreter_init(nxt_task_t *task, char *script)
my_perl = perl_alloc(); my_perl = perl_alloc();
if (nxt_slow_path(my_perl == NULL)) { if (nxt_slow_path(my_perl == NULL)) {
nxt_log_error(NXT_LOG_CRIT, task->log, nxt_alert(task, "PSGI: Failed to allocate memory for Perl interpreter");
"PSGI: Failed to allocate memory for Perl interpreter");
return NULL; return NULL;
} }
@@ -450,8 +449,7 @@ nxt_perl_psgi_interpreter_init(nxt_task_t *task, char *script)
status = perl_parse(my_perl, nxt_perl_psgi_xs_init, 3, embedding, NULL); status = perl_parse(my_perl, nxt_perl_psgi_xs_init, 3, embedding, NULL);
if (nxt_slow_path(status != 0)) { if (nxt_slow_path(status != 0)) {
nxt_log_error(NXT_LOG_CRIT, task->log, nxt_alert(task, "PSGI: Failed to parse Perl Script");
"PSGI: Failed to parse Perl Script");
goto fail; goto fail;
} }
@@ -461,8 +459,7 @@ nxt_perl_psgi_interpreter_init(nxt_task_t *task, char *script)
status = perl_run(my_perl); status = perl_run(my_perl);
if (nxt_slow_path(status != 0)) { if (nxt_slow_path(status != 0)) {
nxt_log_error(NXT_LOG_CRIT, task->log, nxt_alert(task, "PSGI: Failed to run Perl");
"PSGI: Failed to run Perl");
goto fail; goto fail;
} }
@@ -477,24 +474,22 @@ nxt_perl_psgi_interpreter_init(nxt_task_t *task, char *script)
status = nxt_perl_psgi_io_input_init(my_perl, &nxt_perl_psgi_arg_input); status = nxt_perl_psgi_io_input_init(my_perl, &nxt_perl_psgi_arg_input);
if (nxt_slow_path(status != NXT_OK)) { if (nxt_slow_path(status != NXT_OK)) {
nxt_log_error(NXT_LOG_CRIT, task->log, nxt_alert(task, "PSGI: Failed to init io.psgi.input");
"PSGI: Failed to init io.psgi.input");
goto fail; goto fail;
} }
status = nxt_perl_psgi_io_error_init(my_perl, &nxt_perl_psgi_arg_error); status = nxt_perl_psgi_io_error_init(my_perl, &nxt_perl_psgi_arg_error);
if (nxt_slow_path(status != NXT_OK)) { if (nxt_slow_path(status != NXT_OK)) {
nxt_log_error(NXT_LOG_CRIT, task->log, nxt_alert(task, "PSGI: Failed to init io.psgi.errors");
"PSGI: Failed to init io.psgi.errors");
goto fail; goto fail;
} }
nxt_perl_psgi_app = eval_pv((const char *) run_module, FALSE); nxt_perl_psgi_app = eval_pv((const char *) run_module, FALSE);
if (SvTRUE(ERRSV)) { if (SvTRUE(ERRSV)) {
nxt_log_emerg(task->log, "PSGI: Failed to parse script: %s\n%s", nxt_alert(task, "PSGI: Failed to parse script: %s\n%s",
script, SvPV_nolen(ERRSV)); script, SvPV_nolen(ERRSV));
goto fail; goto fail;
} }