static int slowlog_statistics_init(void)
{
int i;
slowlog_statistics = NULL;
today_idx = 0;
if (statistics_period == 0 || statistics_days == 0)
return NC_OK;
pthread_mutex_init(&statistics_locker,NULL);
slowlog_statistics = nc_calloc(statistics_days,sizeof(struct statistics_oneday));
if (slowlog_statistics == NULL)
return NC_ENOMEM;
for (i = 0; i < statistics_days; i ++) {
slowlog_statistics[i].year = 0;
slowlog_statistics[i].mon = 0;
slowlog_statistics[i].day = 0;
slowlog_statistics[i].periods = nc_calloc(statistics_period,sizeof(long long));
if (slowlog_statistics[i].periods == NULL)
return NC_ENOMEM;
}
return NC_OK;
}
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
struct event_base *evb;
int status, kq;
struct kevent *change, *event;
ASSERT(nevent > 0);
kq = kqueue();
if (kq < 0) {
log_error("kqueue failed: %s", strerror(errno));
return NULL;
}
change = nc_calloc(nevent, sizeof(*change));
if (change == NULL) {
status = close(kq);
if (status < 0) {
log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
}
return NULL;
}
event = nc_calloc(nevent, sizeof(*event));
if (event == NULL) {
nc_free(change);
status = close(kq);
if (status < 0) {
log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
}
return NULL;
}
evb = nc_alloc(sizeof(*evb));
if (evb == NULL) {
nc_free(change);
nc_free(event);
status = close(kq);
if (status < 0) {
log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
}
return NULL;
}
evb->kq = kq;
evb->change = change;
evb->nchange = 0;
evb->event = event;
evb->nevent = nevent;
evb->nreturned = 0;
evb->nprocessed = 0;
evb->cb = cb;
log_debug(LOG_INFO, "kq %d with nevent %d", evb->kq, evb->nevent);
return evb;
}
static int
nc_event_init(struct nc_event *event)
{
struct nc_event_state *e_state;
e_state = nc_alloc(sizeof(*e_state));
if (e_state == NULL) {
return -1;
}
e_state->events = nc_calloc(event->nevent, sizeof(struct epoll_event));
if (e_state->events == NULL) {
nc_free(e_state);
return -1;
}
e_state->ep = epoll_create(event->nevent);
if (e_state->ep < 0) {
nc_free(e_state->events);
nc_free(e_state);
log_error("epoll create of size %d failed: %s", event->nevent,
strerror(errno));
return -1;
}
log_debug(LOG_INFO, "e %d with nevent %d", e_state->ep, event->nevent);
event->event_data = e_state;
return 0;
}
struct evcenter *
event_init(int size)
{
int status, ep;
struct kevent *event;
struct fired_event *fired_events;
struct evcenter *center;
center = nc_zalloc(sizeof(struct evcenter));
if (center == NULL) {
log_error("center create failed: %s", strerror(errno));
return NULL;
}
ep = kqueue();
if (ep < 0) {
nc_free(center);
log_error("kqueue create failed: %s", strerror(errno));
return NULL;
}
event = nc_calloc(size, sizeof(struct kevent));
fired_events = nc_calloc(size, sizeof(struct fired_event));
if (event == NULL || fired_events == NULL) {
status = close(ep);
nc_free(center);
if (event != NULL)
nc_free(event);
if (fired_events != NULL)
nc_free(fired_events);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
center->ep = ep;
center->event = event;
center->nevent = size;
center->fired_events = fired_events;
log_debug(LOG_INFO, "e %d with nevent %d", center->ep,
center->nevent);
return center;
}
struct evbase *
evbase_create(int nevent, void (*callback_fp)(void *, uint32_t))
{
struct evbase *evb;
int status, ep;
struct epoll_event *event;
if (nevent <= 0) {
log_error("nevent has to be positive %d", nevent);
return NULL;
}
ep = epoll_create(nevent);
if (ep < 0) {
log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
return NULL;
}
event = nc_calloc(nevent, sizeof(*event));
if (event == NULL) {
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
evb = nc_alloc(sizeof(*evb));
if (evb == NULL) {
nc_free(event);
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
evb->nevent = nevent;
evb->ep = ep;
evb->event = event;
evb->callback_fp = callback_fp;
log_debug(LOG_INFO, "e %d with nevent %d", evb->ep,
evb->nevent);
return evb;
}
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
struct event_base *evb;
int status, evp;
port_event_t *event;
ASSERT(nevent > 0);
evp = port_create();
if (evp < 0) {
log_error("port create failed: %s", strerror(errno));
return NULL;
}
event = nc_calloc(nevent, sizeof(*event));
if (event == NULL) {
status = close(evp);
if (status < 0) {
log_error("close evp %d failed, ignored: %s", evp, strerror(errno));
}
return NULL;
}
evb = nc_alloc(sizeof(*evb));
if (evb == NULL) {
nc_free(event);
status = close(evp);
if (status < 0) {
log_error("close evp %d failed, ignored: %s", evp, strerror(errno));
}
return NULL;
}
evb->evp = evp;
evb->event = event;
evb->nevent = nevent;
evb->cb = cb;
log_info("evp %d with nevent %d", evb->evp, evb->nevent);
return evb;
}
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
struct event_base *evb;
int status, ep;
struct epoll_event *event;
ASSERT(nevent > 0);
ep = epoll_create(nevent);
if (ep < 0) {
log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
return NULL;
}
event = nc_calloc(nevent, sizeof(*event));
if (event == NULL) {
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
evb = nc_alloc(sizeof(*evb));
if (evb == NULL) {
nc_free(event);
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
evb->ep = ep;
evb->event = event;
evb->nevent = nevent;
evb->cb = cb;
log_debug(LOG_INFO, "e %d with nevent %d", evb->ep, evb->nevent);
return evb;
}
struct evbase *
evbase_create(int nevent, void (*callback_fp)(void *, uint32_t))
{
struct evbase *evb;
int status, kq;
struct kevent *changes, *kevents;
if (nevent <= 0) {
log_error("nevent has to be positive %d", nevent);
return NULL;
}
/* Initialize the kernel queue */
if ((kq = kqueue()) == -1) {
log_error("kernel queue create failed: %s", kq, strerror(errno));
return NULL;
}
changes = nc_calloc(nevent, sizeof(*changes));
if (changes == NULL) {
status = close(kq);
if (status < 0) {
log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
}
return NULL;
}
kevents = nc_calloc(nevent, sizeof(*kevents));
if (kevents == NULL) {
nc_free(changes);
status = close(kq);
if (status < 0) {
log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
}
return NULL;
}
evb = (struct evbase *) nc_alloc(sizeof(*evb));
if (evb == NULL) {
nc_free(changes);
nc_free(kevents);
status = close(kq);
if (status < 0) {
log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
}
return NULL;
}
evb->kq = kq;
evb->changes = changes;
evb->kevents = kevents;
evb->nevent = nevent;
evb->callback_fp = callback_fp;
evb->n_changes = 0;
log_debug(LOG_INFO, "kq %d with nevent %d", evb->kq,
evb->nevent);
return evb;
}
