mirror/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2024-12-13 11:09:06 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
1393325df8
nginx/src/event/ngx_event.c
Igor Sysoev 1393325df8 nginx-0.0.1-2003-05-29-17:02:09 import
2003-05-29 13:02:09 +00:00

400 lines
9.4 KiB
C
Raw Blame History

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_listen.h>
#include <ngx_connection.h>
#include <ngx_event.h>
#define DEF_CONNECTIONS 1024
extern ngx_module_t ngx_select_module;
#if (HAVE_KQUEUE)
#include <ngx_kqueue_module.h>
#endif
#if (HAVE_DEVPOLL)
extern ngx_module_t ngx_devpoll_module;
#endif
#if (HAVE_AIO)
#include <ngx_aio_module.h>
#endif
#if (HAVE_IOCP)
#include <ngx_event_acceptex.h>
#include <ngx_iocp_module.h>
#endif
static char *ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_event_use(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static void *ngx_event_create_conf(ngx_pool_t *pool);
static char *ngx_event_init_conf(ngx_pool_t *pool, void *conf);
int ngx_event_flags;
ngx_event_actions_t ngx_event_actions;
ngx_connection_t *ngx_connections;
ngx_event_t *ngx_read_events, *ngx_write_events;
static int ngx_event_max_module;
static int ngx_event_connections;
static ngx_str_t events_name = ngx_string("events");
static ngx_str_t event_name = ngx_string("event");
static ngx_command_t ngx_events_commands[] = {
{ngx_string("events"),
NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
ngx_events_block,
0,
0,
NULL},
ngx_null_command
};
ngx_module_t ngx_events_module = {
NGX_MODULE,
&events_name, /* module context */
ngx_events_commands, /* module directives */
NGX_CORE_MODULE, /* module type */
NULL /* init module */
};
static ngx_command_t ngx_event_commands[] = {
{ngx_string("connections"),
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_conf_set_num_slot,
0,
offsetof(ngx_event_conf_t, connections),
NULL},
{ngx_string("use"),
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_event_use,
0,
0,
NULL},
{ngx_string("timer_queues"),
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_conf_set_num_slot,
0,
offsetof(ngx_event_conf_t, timer_queues),
NULL},
ngx_null_command
};
ngx_event_module_t ngx_event_module_ctx = {
&event_name,
ngx_event_create_conf, /* create configuration */
ngx_event_init_conf, /* init configuration */
{ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
};
ngx_module_t ngx_event_module = {
NGX_MODULE,
&ngx_event_module_ctx, /* module context */
ngx_event_commands, /* module directives */
NGX_EVENT_MODULE, /* module type */
NULL /* init module */
};
int ngx_pre_thread(ngx_array_t *ls, ngx_pool_t *pool, ngx_log_t *log)
{
int m, i, fd;
ngx_listen_t *s;
ngx_event_t *ev;
ngx_connection_t *c;
ngx_event_conf_t *ecf;
ngx_event_module_t *module;
ecf = ngx_event_get_conf(ngx_event_module);
ngx_log_debug(log, "CONN: %d" _ ecf->connections);
ngx_log_debug(log, "TYPE: %d" _ ecf->use);
for (m = 0; ngx_modules[m]; m++) {
if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
continue;
}
if (ngx_modules[m]->ctx_index == ecf->use) {
module = ngx_modules[m]->ctx;
if (module->actions.init(log) == NGX_ERROR) {
return NGX_ERROR;
}
break;
}
}
ngx_test_null(ngx_connections,
ngx_alloc(sizeof(ngx_connection_t) * ecf->connections, log),
NGX_ERROR);
ngx_test_null(ngx_read_events,
ngx_alloc(sizeof(ngx_event_t) * ecf->connections, log),
NGX_ERROR);
ngx_test_null(ngx_write_events,
ngx_alloc(sizeof(ngx_event_t) * ecf->connections, log),
NGX_ERROR);
/* for each listening socket */
s = (ngx_listen_t *) ls->elts;
for (i = 0; i < ls->nelts; i++) {
fd = s[i].fd;
c = &ngx_connections[fd];
ev = &ngx_read_events[fd];
ngx_memzero(c, sizeof(ngx_connection_t));
ngx_memzero(ev, sizeof(ngx_event_t));
c->fd = fd;
c->family = s[i].family;
c->socklen = s[i].socklen;
c->sockaddr = ngx_palloc(pool, s[i].socklen);
c->addr = s[i].addr;
c->addr_text = s[i].addr_text;
c->addr_text_max_len = s[i].addr_text_max_len;
c->post_accept_timeout = s[i].post_accept_timeout;
c->handler = s[i].handler;
c->ctx = s[i].ctx;
c->servers = s[i].servers;
c->log = s[i].log;
c->pool_size = s[i].pool_size;
ngx_test_null(ev->log,
ngx_palloc(pool, sizeof(ngx_log_t)),
NGX_ERROR);
ngx_memcpy(ev->log, c->log, sizeof(ngx_log_t));
c->read = ev;
ev->data = c;
ev->index = NGX_INVALID_INDEX;
#if 0
ev->listening = 1;
#endif
ev->available = 0;
#if (HAVE_DEFERRED_ACCEPT)
ev->deferred_accept = s[i].deferred_accept;
#endif
#if (HAVE_IOCP)
if (ngx_event_flags & NGX_HAVE_IOCP_EVENT) {
ev->event_handler = &ngx_event_acceptex;
/* LOOK: we call ngx_iocp_add_event() also
in ngx_event_post_acceptex() */
if (ngx_iocp_add_event(ev) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_event_post_acceptex(&s[i], 1);
} else {
ev->event_handler = &ngx_event_accept;
}
#else
ev->event_handler = &ngx_event_accept;
ngx_add_event(ev, NGX_READ_EVENT, 0);
#endif
}
return NGX_OK;
}
void ngx_worker(ngx_log_t *log)
{
for ( ;; ) {
ngx_log_debug(log, "ngx_worker cycle");
ngx_process_events(log);
}
}
static char *ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
int m;
char *rv;
void ***ctx;
ngx_conf_t pcf;
ngx_event_module_t *module;
/* count the number of the event modules and set up their indices */
ngx_event_max_module = 0;
for (m = 0; ngx_modules[m]; m++) {
if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
continue;
}
ngx_modules[m]->ctx_index = ngx_event_max_module++;
}
ngx_test_null(ctx, ngx_pcalloc(cf->pool, sizeof(void *)), NGX_CONF_ERROR);
ngx_test_null(*ctx,
ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *)),
NGX_CONF_ERROR);
*(void **) conf = ctx;
for (m = 0; ngx_modules[m]; m++) {
if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
continue;
}
module = ngx_modules[m]->ctx;
if (module->create_conf) {
ngx_test_null((*ctx)[ngx_modules[m]->ctx_index],
module->create_conf(cf->pool),
NGX_CONF_ERROR);
}
}
pcf = *cf;
cf->ctx = ctx;
cf->module_type = NGX_EVENT_MODULE;
cf->cmd_type = NGX_EVENT_CONF;
rv = ngx_conf_parse(cf, NULL);
*cf = pcf;
if (rv != NGX_CONF_OK)
return rv;
for (m = 0; ngx_modules[m]; m++) {
if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
continue;
}
module = ngx_modules[m]->ctx;
if (module->init_conf) {
rv = module->init_conf(cf->pool, (*ctx)[ngx_modules[m]->ctx_index]);
if (rv != NGX_CONF_OK) {
return rv;
}
}
}
return NGX_CONF_OK;
}
static char *ngx_event_use(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_event_conf_t *ecf = conf;
int m;
ngx_str_t *args;
ngx_event_module_t *module;
if (ecf->use != NGX_CONF_UNSET) {
return "is duplicate" ;
}
args = cf->args->elts;
for (m = 0; ngx_modules[m]; m++) {
if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
continue;
}
module = ngx_modules[m]->ctx;
if (module->name->len == args[1].len) {
if (ngx_strcmp(module->name->data, args[1].data) == 0) {
ecf->use = ngx_modules[m]->ctx_index;
return NGX_CONF_OK;
}
}
}
return "invalid event type";
}
static void *ngx_event_create_conf(ngx_pool_t *pool)
{
ngx_event_conf_t *ecf;
ngx_test_null(ecf, ngx_palloc(pool, sizeof(ngx_event_conf_t)),
NGX_CONF_ERROR);
ecf->connections = NGX_CONF_UNSET;
ecf->timer_queues = NGX_CONF_UNSET;
ecf->use = NGX_CONF_UNSET;
return ecf;
}
static char *ngx_event_init_conf(ngx_pool_t *pool, void *conf)
{
ngx_event_conf_t *ecf = conf;
#if (HAVE_KQUEUE)
#if 0
if (ecf->connections != NGX_CONF_UNSET) {
ecf->connections = (ngx_max_connections < DEF_CONNECTIONS) ?
ngx_max_connections : DEF_CONNECTIONS;
} else if (ecf->connections > ngx_max_connections) {
}
#endif
ngx_conf_init_value(ecf->connections, DEF_CONNECTIONS);
ngx_conf_init_value(ecf->use, ngx_kqueue_module.ctx_index);
#elif (HAVE_DEVPOLL)
ngx_conf_init_value(ecf->connections, DEF_CONNECTIONS);
ngx_conf_init_value(ecf->use, ngx_devpoll_module.ctx_index);
#else /* HAVE_SELECT */
ngx_conf_init_value(ecf->connections,
FD_SETSIZE < DEF_CONNECTIONS ? FD_SETSIZE : DEF_CONNECTIONS);
ngx_conf_init_value(ecf->use, ngx_select_module.ctx_index);
#endif
ngx_conf_init_value(ecf->timer_queues, 10);
return NGX_CONF_OK;
}
Reference in New Issue View Git Blame Copy Permalink