From e16868dede6455cab644805af6fe1ac312775e13 Mon Sep 17 00:00:00 2001 From: Gluster Ant Date: Wed, 12 Sep 2018 17:52:45 +0530 Subject: Land part 2 of clang-format changes Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4 Signed-off-by: Nigel Babu --- libglusterfs/src/event-epoll.c | 1518 ++++++++++++++++++++-------------------- 1 file changed, 749 insertions(+), 769 deletions(-) (limited to 'libglusterfs/src/event-epoll.c') diff --git a/libglusterfs/src/event-epoll.c b/libglusterfs/src/event-epoll.c index b144b77a11c..9826cc9e275 100644 --- a/libglusterfs/src/event-epoll.c +++ b/libglusterfs/src/event-epoll.c @@ -23,766 +23,747 @@ #include "syscall.h" #include "libglusterfs-messages.h" - #ifdef HAVE_SYS_EPOLL_H #include - struct event_slot_epoll { - int fd; - int events; - int gen; - gf_atomic_t ref; - int do_close; - int in_handler; - int handled_error; - void *data; - event_handler_t handler; - gf_lock_t lock; + int fd; + int events; + int gen; + gf_atomic_t ref; + int do_close; + int in_handler; + int handled_error; + void *data; + event_handler_t handler; + gf_lock_t lock; }; struct event_thread_data { - struct event_pool *event_pool; - int event_index; + struct event_pool *event_pool; + int event_index; }; static struct event_slot_epoll * -__event_newtable (struct event_pool *event_pool, int table_idx) +__event_newtable(struct event_pool *event_pool, int table_idx) { - struct event_slot_epoll *table = NULL; - int i = -1; + struct event_slot_epoll *table = NULL; + int i = -1; - table = GF_CALLOC (sizeof (*table), EVENT_EPOLL_SLOTS, - gf_common_mt_ereg); - if (!table) - return NULL; + table = GF_CALLOC(sizeof(*table), EVENT_EPOLL_SLOTS, gf_common_mt_ereg); + if (!table) + return NULL; - for (i = 0; i < EVENT_EPOLL_SLOTS; i++) { - table[i].fd = -1; - LOCK_INIT (&table[i].lock); - } + for (i = 0; i < EVENT_EPOLL_SLOTS; i++) { + table[i].fd = -1; + LOCK_INIT(&table[i].lock); + } - event_pool->ereg[table_idx] = table; - event_pool->slots_used[table_idx] = 0; + event_pool->ereg[table_idx] = table; + event_pool->slots_used[table_idx] = 0; - return table; + return table; } - static int -__event_slot_alloc (struct event_pool *event_pool, int fd) +__event_slot_alloc(struct event_pool *event_pool, int fd) { - int i = 0; - int table_idx = -1; - int gen = -1; - struct event_slot_epoll *table = NULL; - - for (i = 0; i < EVENT_EPOLL_TABLES; i++) { - switch (event_pool->slots_used[i]) { - case EVENT_EPOLL_SLOTS: - continue; - case 0: - if (!event_pool->ereg[i]) { - table = __event_newtable (event_pool, i); - if (!table) - return -1; - } else { - table = event_pool->ereg[i]; - } - break; - default: - table = event_pool->ereg[i]; - break; - } - - if (table) - /* break out of the loop */ - break; - } - - if (!table) - return -1; - - table_idx = i; - - for (i = 0; i < EVENT_EPOLL_SLOTS; i++) { - if (table[i].fd == -1) { - /* wipe everything except bump the generation */ - gen = table[i].gen; - memset (&table[i], 0, sizeof (table[i])); - table[i].gen = gen + 1; - - LOCK_INIT (&table[i].lock); - - table[i].fd = fd; - event_pool->slots_used[table_idx]++; - - break; - } - } - - return table_idx * EVENT_EPOLL_SLOTS + i; -} + int i = 0; + int table_idx = -1; + int gen = -1; + struct event_slot_epoll *table = NULL; + + for (i = 0; i < EVENT_EPOLL_TABLES; i++) { + switch (event_pool->slots_used[i]) { + case EVENT_EPOLL_SLOTS: + continue; + case 0: + if (!event_pool->ereg[i]) { + table = __event_newtable(event_pool, i); + if (!table) + return -1; + } else { + table = event_pool->ereg[i]; + } + break; + default: + table = event_pool->ereg[i]; + break; + } + if (table) + /* break out of the loop */ + break; + } -static int -event_slot_alloc (struct event_pool *event_pool, int fd) -{ - int idx = -1; + if (!table) + return -1; + + table_idx = i; + + for (i = 0; i < EVENT_EPOLL_SLOTS; i++) { + if (table[i].fd == -1) { + /* wipe everything except bump the generation */ + gen = table[i].gen; + memset(&table[i], 0, sizeof(table[i])); + table[i].gen = gen + 1; - pthread_mutex_lock (&event_pool->mutex); - { - idx = __event_slot_alloc (event_pool, fd); - } - pthread_mutex_unlock (&event_pool->mutex); + LOCK_INIT(&table[i].lock); - return idx; + table[i].fd = fd; + event_pool->slots_used[table_idx]++; + + break; + } + } + + return table_idx * EVENT_EPOLL_SLOTS + i; } +static int +event_slot_alloc(struct event_pool *event_pool, int fd) +{ + int idx = -1; + pthread_mutex_lock(&event_pool->mutex); + { + idx = __event_slot_alloc(event_pool, fd); + } + pthread_mutex_unlock(&event_pool->mutex); + + return idx; +} static void -__event_slot_dealloc (struct event_pool *event_pool, int idx) +__event_slot_dealloc(struct event_pool *event_pool, int idx) { - int table_idx = 0; - int offset = 0; - struct event_slot_epoll *table = NULL; - struct event_slot_epoll *slot = NULL; + int table_idx = 0; + int offset = 0; + struct event_slot_epoll *table = NULL; + struct event_slot_epoll *slot = NULL; - table_idx = idx / EVENT_EPOLL_SLOTS; - offset = idx % EVENT_EPOLL_SLOTS; + table_idx = idx / EVENT_EPOLL_SLOTS; + offset = idx % EVENT_EPOLL_SLOTS; - table = event_pool->ereg[table_idx]; - if (!table) - return; + table = event_pool->ereg[table_idx]; + if (!table) + return; - slot = &table[offset]; - slot->gen++; + slot = &table[offset]; + slot->gen++; - slot->fd = -1; - slot->handled_error = 0; - slot->in_handler = 0; - event_pool->slots_used[table_idx]--; + slot->fd = -1; + slot->handled_error = 0; + slot->in_handler = 0; + event_pool->slots_used[table_idx]--; - return; + return; } - static void -event_slot_dealloc (struct event_pool *event_pool, int idx) +event_slot_dealloc(struct event_pool *event_pool, int idx) { - pthread_mutex_lock (&event_pool->mutex); - { - __event_slot_dealloc (event_pool, idx); - } - pthread_mutex_unlock (&event_pool->mutex); + pthread_mutex_lock(&event_pool->mutex); + { + __event_slot_dealloc(event_pool, idx); + } + pthread_mutex_unlock(&event_pool->mutex); - return; + return; } - static struct event_slot_epoll * -event_slot_get (struct event_pool *event_pool, int idx) +event_slot_get(struct event_pool *event_pool, int idx) { - struct event_slot_epoll *slot = NULL; - struct event_slot_epoll *table = NULL; - int table_idx = 0; - int offset = 0; + struct event_slot_epoll *slot = NULL; + struct event_slot_epoll *table = NULL; + int table_idx = 0; + int offset = 0; - table_idx = idx / EVENT_EPOLL_SLOTS; - offset = idx % EVENT_EPOLL_SLOTS; + table_idx = idx / EVENT_EPOLL_SLOTS; + offset = idx % EVENT_EPOLL_SLOTS; - table = event_pool->ereg[table_idx]; - if (!table) - return NULL; + table = event_pool->ereg[table_idx]; + if (!table) + return NULL; - slot = &table[offset]; - GF_ATOMIC_INC (slot->ref); + slot = &table[offset]; + GF_ATOMIC_INC(slot->ref); - return slot; + return slot; } - static void -event_slot_unref (struct event_pool *event_pool, struct event_slot_epoll *slot, - int idx) +event_slot_unref(struct event_pool *event_pool, struct event_slot_epoll *slot, + int idx) { - int ref = -1; - int fd = -1; - int do_close = 0; - - ref = GF_ATOMIC_DEC (slot->ref); - if (ref) - /* slot still alive */ - goto done; - - LOCK (&slot->lock); - { - fd = slot->fd; - do_close = slot->do_close; - slot->do_close = 0; - } - UNLOCK (&slot->lock); - - event_slot_dealloc (event_pool, idx); - - if (do_close) - sys_close (fd); + int ref = -1; + int fd = -1; + int do_close = 0; + + ref = GF_ATOMIC_DEC(slot->ref); + if (ref) + /* slot still alive */ + goto done; + + LOCK(&slot->lock); + { + fd = slot->fd; + do_close = slot->do_close; + slot->do_close = 0; + } + UNLOCK(&slot->lock); + + event_slot_dealloc(event_pool, idx); + + if (do_close) + sys_close(fd); done: - return; + return; } - static struct event_pool * -event_pool_new_epoll (int count, int eventthreadcount) +event_pool_new_epoll(int count, int eventthreadcount) { - struct event_pool *event_pool = NULL; - int epfd = -1; + struct event_pool *event_pool = NULL; + int epfd = -1; - event_pool = GF_CALLOC (1, sizeof (*event_pool), - gf_common_mt_event_pool); + event_pool = GF_CALLOC(1, sizeof(*event_pool), gf_common_mt_event_pool); - if (!event_pool) - goto out; + if (!event_pool) + goto out; - epfd = epoll_create (count); + epfd = epoll_create(count); - if (epfd == -1) { - gf_msg ("epoll", GF_LOG_ERROR, errno, - LG_MSG_EPOLL_FD_CREATE_FAILED, "epoll fd creation " - "failed"); - GF_FREE (event_pool->reg); - GF_FREE (event_pool); - event_pool = NULL; - goto out; - } + if (epfd == -1) { + gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_CREATE_FAILED, + "epoll fd creation " + "failed"); + GF_FREE(event_pool->reg); + GF_FREE(event_pool); + event_pool = NULL; + goto out; + } - event_pool->fd = epfd; + event_pool->fd = epfd; - event_pool->count = count; + event_pool->count = count; - event_pool->eventthreadcount = eventthreadcount; - event_pool->auto_thread_count = 0; + event_pool->eventthreadcount = eventthreadcount; + event_pool->auto_thread_count = 0; - pthread_mutex_init (&event_pool->mutex, NULL); + pthread_mutex_init(&event_pool->mutex, NULL); out: - return event_pool; + return event_pool; } - static void -__slot_update_events (struct event_slot_epoll *slot, int poll_in, int poll_out) +__slot_update_events(struct event_slot_epoll *slot, int poll_in, int poll_out) { - switch (poll_in) { - case 1: - slot->events |= EPOLLIN; - break; - case 0: - slot->events &= ~EPOLLIN; - break; - case -1: - /* do nothing */ - break; - default: - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN, - "invalid poll_in value %d", poll_in); - break; - } - - switch (poll_out) { - case 1: - slot->events |= EPOLLOUT; - break; - case 0: - slot->events &= ~EPOLLOUT; - break; - case -1: - /* do nothing */ - break; - default: - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT, - "invalid poll_out value %d", poll_out); - break; - } + switch (poll_in) { + case 1: + slot->events |= EPOLLIN; + break; + case 0: + slot->events &= ~EPOLLIN; + break; + case -1: + /* do nothing */ + break; + default: + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN, + "invalid poll_in value %d", poll_in); + break; + } + + switch (poll_out) { + case 1: + slot->events |= EPOLLOUT; + break; + case 0: + slot->events &= ~EPOLLOUT; + break; + case -1: + /* do nothing */ + break; + default: + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT, + "invalid poll_out value %d", poll_out); + break; + } } - int -event_register_epoll (struct event_pool *event_pool, int fd, - event_handler_t handler, - void *data, int poll_in, int poll_out) +event_register_epoll(struct event_pool *event_pool, int fd, + event_handler_t handler, void *data, int poll_in, + int poll_out) { - int idx = -1; - int ret = -1; - int destroy = 0; - struct epoll_event epoll_event = {0, }; - struct event_data *ev_data = (void *)&epoll_event.data; - struct event_slot_epoll *slot = NULL; - - - GF_VALIDATE_OR_GOTO ("event", event_pool, out); - - /* TODO: Even with the below check, there is a possibility of race, - * What if the destroy mode is set after the check is done. - * Not sure of the best way to prevent this race, ref counting - * is one possibility. - * There is no harm in registering and unregistering the fd - * even after destroy mode is set, just that such fds will remain - * open until unregister is called, also the events on that fd will be - * notified, until one of the poller thread is alive. - */ - pthread_mutex_lock (&event_pool->mutex); - { - destroy = event_pool->destroy; - } - pthread_mutex_unlock (&event_pool->mutex); - - if (destroy == 1) - goto out; - - idx = event_slot_alloc (event_pool, fd); - if (idx == -1) { - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, - "could not find slot for fd=%d", fd); - return -1; - } - - slot = event_slot_get (event_pool, idx); - if (!slot) { - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, - "could not find slot for fd=%d idx=%d", fd, idx); - return -1; - } - - assert (slot->fd == fd); - - LOCK (&slot->lock); - { - /* make epoll 'singleshot', which - means we need to re-add the fd with - epoll_ctl(EPOLL_CTL_MOD) after delivery of every - single event. This assures us that while a poller - thread has picked up and is processing an event, - another poller will not try to pick this at the same - time as well. - */ - - slot->events = EPOLLPRI | EPOLLHUP | EPOLLERR | EPOLLONESHOT; - slot->handler = handler; - slot->data = data; - - __slot_update_events (slot, poll_in, poll_out); - - epoll_event.events = slot->events; - ev_data->idx = idx; - ev_data->gen = slot->gen; - - ret = epoll_ctl (event_pool->fd, EPOLL_CTL_ADD, fd, - &epoll_event); - /* check ret after UNLOCK() to avoid deadlock in - event_slot_unref() - */ - } - UNLOCK (&slot->lock); - - if (ret == -1) { - gf_msg ("epoll", GF_LOG_ERROR, errno, - LG_MSG_EPOLL_FD_ADD_FAILED, "failed to add fd(=%d) to " - "epoll fd(=%d)", fd, event_pool->fd); - event_slot_unref (event_pool, slot, idx); - idx = -1; - } - - /* keep slot->ref (do not event_slot_unref) if successful */ + int idx = -1; + int ret = -1; + int destroy = 0; + struct epoll_event epoll_event = { + 0, + }; + struct event_data *ev_data = (void *)&epoll_event.data; + struct event_slot_epoll *slot = NULL; + + GF_VALIDATE_OR_GOTO("event", event_pool, out); + + /* TODO: Even with the below check, there is a possibility of race, + * What if the destroy mode is set after the check is done. + * Not sure of the best way to prevent this race, ref counting + * is one possibility. + * There is no harm in registering and unregistering the fd + * even after destroy mode is set, just that such fds will remain + * open until unregister is called, also the events on that fd will be + * notified, until one of the poller thread is alive. + */ + pthread_mutex_lock(&event_pool->mutex); + { + destroy = event_pool->destroy; + } + pthread_mutex_unlock(&event_pool->mutex); + + if (destroy == 1) + goto out; + + idx = event_slot_alloc(event_pool, fd); + if (idx == -1) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, + "could not find slot for fd=%d", fd); + return -1; + } + + slot = event_slot_get(event_pool, idx); + if (!slot) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, + "could not find slot for fd=%d idx=%d", fd, idx); + return -1; + } + + assert(slot->fd == fd); + + LOCK(&slot->lock); + { + /* make epoll 'singleshot', which + means we need to re-add the fd with + epoll_ctl(EPOLL_CTL_MOD) after delivery of every + single event. This assures us that while a poller + thread has picked up and is processing an event, + another poller will not try to pick this at the same + time as well. + */ + + slot->events = EPOLLPRI | EPOLLHUP | EPOLLERR | EPOLLONESHOT; + slot->handler = handler; + slot->data = data; + + __slot_update_events(slot, poll_in, poll_out); + + epoll_event.events = slot->events; + ev_data->idx = idx; + ev_data->gen = slot->gen; + + ret = epoll_ctl(event_pool->fd, EPOLL_CTL_ADD, fd, &epoll_event); + /* check ret after UNLOCK() to avoid deadlock in + event_slot_unref() + */ + } + UNLOCK(&slot->lock); + + if (ret == -1) { + gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_ADD_FAILED, + "failed to add fd(=%d) to " + "epoll fd(=%d)", + fd, event_pool->fd); + event_slot_unref(event_pool, slot, idx); + idx = -1; + } + + /* keep slot->ref (do not event_slot_unref) if successful */ out: - return idx; + return idx; } - static int -event_unregister_epoll_common (struct event_pool *event_pool, int fd, - int idx, int do_close) +event_unregister_epoll_common(struct event_pool *event_pool, int fd, int idx, + int do_close) { - int ret = -1; - struct event_slot_epoll *slot = NULL; - - GF_VALIDATE_OR_GOTO ("event", event_pool, out); - - /* During shutdown, it may happen that a socket registration with - * the event sub-system may fail and an rpc_transport_unref() may - * be called for such an unregistered socket with idx == -1. This - * may cause the following assert(slot->fd == fd) to fail. - */ - if (idx < 0) - goto out; - - slot = event_slot_get (event_pool, idx); - if (!slot) { - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, - "could not find slot for fd=%d idx=%d", fd, idx); - return -1; + int ret = -1; + struct event_slot_epoll *slot = NULL; + + GF_VALIDATE_OR_GOTO("event", event_pool, out); + + /* During shutdown, it may happen that a socket registration with + * the event sub-system may fail and an rpc_transport_unref() may + * be called for such an unregistered socket with idx == -1. This + * may cause the following assert(slot->fd == fd) to fail. + */ + if (idx < 0) + goto out; + + slot = event_slot_get(event_pool, idx); + if (!slot) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, + "could not find slot for fd=%d idx=%d", fd, idx); + return -1; + } + + assert(slot->fd == fd); + + LOCK(&slot->lock); + { + ret = epoll_ctl(event_pool->fd, EPOLL_CTL_DEL, fd, NULL); + + if (ret == -1) { + gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_DEL_FAILED, + "fail to del " + "fd(=%d) from epoll fd(=%d)", + fd, event_pool->fd); + goto unlock; } - assert (slot->fd == fd); - - LOCK (&slot->lock); - { - ret = epoll_ctl (event_pool->fd, EPOLL_CTL_DEL, fd, NULL); - - if (ret == -1) { - gf_msg ("epoll", GF_LOG_ERROR, errno, - LG_MSG_EPOLL_FD_DEL_FAILED, "fail to del " - "fd(=%d) from epoll fd(=%d)", fd, - event_pool->fd); - goto unlock; - } - - slot->do_close = do_close; - slot->gen++; /* detect unregister in dispatch_handler() */ - } + slot->do_close = do_close; + slot->gen++; /* detect unregister in dispatch_handler() */ + } unlock: - UNLOCK (&slot->lock); + UNLOCK(&slot->lock); - event_slot_unref (event_pool, slot, idx); /* one for event_register() */ - event_slot_unref (event_pool, slot, idx); /* one for event_slot_get() */ + event_slot_unref(event_pool, slot, idx); /* one for event_register() */ + event_slot_unref(event_pool, slot, idx); /* one for event_slot_get() */ out: - return ret; + return ret; } - static int -event_unregister_epoll (struct event_pool *event_pool, int fd, int idx_hint) +event_unregister_epoll(struct event_pool *event_pool, int fd, int idx_hint) { - int ret = -1; + int ret = -1; - ret = event_unregister_epoll_common (event_pool, fd, idx_hint, 0); + ret = event_unregister_epoll_common(event_pool, fd, idx_hint, 0); - return ret; + return ret; } - static int -event_unregister_close_epoll (struct event_pool *event_pool, int fd, - int idx_hint) +event_unregister_close_epoll(struct event_pool *event_pool, int fd, + int idx_hint) { - int ret = -1; + int ret = -1; - ret = event_unregister_epoll_common (event_pool, fd, idx_hint, 1); + ret = event_unregister_epoll_common(event_pool, fd, idx_hint, 1); - return ret; + return ret; } - static int -event_select_on_epoll (struct event_pool *event_pool, int fd, int idx, - int poll_in, int poll_out) +event_select_on_epoll(struct event_pool *event_pool, int fd, int idx, + int poll_in, int poll_out) { - int ret = -1; - struct event_slot_epoll *slot = NULL; - struct epoll_event epoll_event = {0, }; - struct event_data *ev_data = (void *)&epoll_event.data; - - - GF_VALIDATE_OR_GOTO ("event", event_pool, out); - - slot = event_slot_get (event_pool, idx); - if (!slot) { - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, - "could not find slot for fd=%d idx=%d", fd, idx); - return -1; + int ret = -1; + struct event_slot_epoll *slot = NULL; + struct epoll_event epoll_event = { + 0, + }; + struct event_data *ev_data = (void *)&epoll_event.data; + + GF_VALIDATE_OR_GOTO("event", event_pool, out); + + slot = event_slot_get(event_pool, idx); + if (!slot) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, + "could not find slot for fd=%d idx=%d", fd, idx); + return -1; + } + + assert(slot->fd == fd); + + LOCK(&slot->lock); + { + __slot_update_events(slot, poll_in, poll_out); + + epoll_event.events = slot->events; + ev_data->idx = idx; + ev_data->gen = slot->gen; + + if (slot->in_handler) + /* + * in_handler indicates at least one thread + * executing event_dispatch_epoll_handler() + * which will perform epoll_ctl(EPOLL_CTL_MOD) + * anyways (because of EPOLLET) + * + * This not only saves a system call, but also + * avoids possibility of another epoll thread + * picking up the next event while the ongoing + * handler is still in progress (and resulting + * in unnecessary contention on rpc_transport_t->mutex). + */ + goto unlock; + + ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event); + if (ret == -1) { + gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_MODIFY_FAILED, + "failed to " + "modify fd(=%d) events to %d", + fd, epoll_event.events); } - - assert (slot->fd == fd); - - LOCK (&slot->lock); - { - __slot_update_events (slot, poll_in, poll_out); - - epoll_event.events = slot->events; - ev_data->idx = idx; - ev_data->gen = slot->gen; - - if (slot->in_handler) - /* - * in_handler indicates at least one thread - * executing event_dispatch_epoll_handler() - * which will perform epoll_ctl(EPOLL_CTL_MOD) - * anyways (because of EPOLLET) - * - * This not only saves a system call, but also - * avoids possibility of another epoll thread - * picking up the next event while the ongoing - * handler is still in progress (and resulting - * in unnecessary contention on rpc_transport_t->mutex). - */ - goto unlock; - - ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, fd, - &epoll_event); - if (ret == -1) { - gf_msg ("epoll", GF_LOG_ERROR, errno, - LG_MSG_EPOLL_FD_MODIFY_FAILED, "failed to " - "modify fd(=%d) events to %d", fd, - epoll_event.events); - } - } + } unlock: - UNLOCK (&slot->lock); + UNLOCK(&slot->lock); - event_slot_unref (event_pool, slot, idx); + event_slot_unref(event_pool, slot, idx); out: - return idx; + return idx; } - static int -event_dispatch_epoll_handler (struct event_pool *event_pool, - struct epoll_event *event) +event_dispatch_epoll_handler(struct event_pool *event_pool, + struct epoll_event *event) { - struct event_data *ev_data = NULL; - struct event_slot_epoll *slot = NULL; - event_handler_t handler = NULL; - void *data = NULL; - int idx = -1; - int gen = -1; - int ret = -1; - int fd = -1; - gf_boolean_t handled_error_previously = _gf_false; - - ev_data = (void *)&event->data; - handler = NULL; - data = NULL; - - idx = ev_data->idx; - gen = ev_data->gen; - - slot = event_slot_get (event_pool, idx); - if (!slot) { - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, - "could not find slot for idx=%d", idx); - return -1; + struct event_data *ev_data = NULL; + struct event_slot_epoll *slot = NULL; + event_handler_t handler = NULL; + void *data = NULL; + int idx = -1; + int gen = -1; + int ret = -1; + int fd = -1; + gf_boolean_t handled_error_previously = _gf_false; + + ev_data = (void *)&event->data; + handler = NULL; + data = NULL; + + idx = ev_data->idx; + gen = ev_data->gen; + + slot = event_slot_get(event_pool, idx); + if (!slot) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, + "could not find slot for idx=%d", idx); + return -1; + } + + LOCK(&slot->lock); + { + fd = slot->fd; + if (fd == -1) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_STALE_FD_FOUND, + "stale fd found on " + "idx=%d, gen=%d, events=%d, slot->gen=%d", + idx, gen, event->events, slot->gen); + /* fd got unregistered in another thread */ + goto pre_unlock; } - LOCK (&slot->lock); - { - fd = slot->fd; - if (fd == -1) { - gf_msg ("epoll", GF_LOG_ERROR, 0, - LG_MSG_STALE_FD_FOUND, "stale fd found on " - "idx=%d, gen=%d, events=%d, slot->gen=%d", - idx, gen, event->events, slot->gen); - /* fd got unregistered in another thread */ - goto pre_unlock; - } - - if (gen != slot->gen) { - gf_msg ("epoll", GF_LOG_ERROR, 0, - LG_MSG_GENERATION_MISMATCH, "generation " - "mismatch on idx=%d, gen=%d, slot->gen=%d, " - "slot->fd=%d", idx, gen, slot->gen, slot->fd); - /* slot was re-used and therefore is another fd! */ - goto pre_unlock; - } - - handler = slot->handler; - data = slot->data; - - if (slot->handled_error) { - handled_error_previously = _gf_true; - } else { - slot->handled_error = (event->events - & (EPOLLERR|EPOLLHUP)); - slot->in_handler++; - } - } + if (gen != slot->gen) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_GENERATION_MISMATCH, + "generation " + "mismatch on idx=%d, gen=%d, slot->gen=%d, " + "slot->fd=%d", + idx, gen, slot->gen, slot->fd); + /* slot was re-used and therefore is another fd! */ + goto pre_unlock; + } + + handler = slot->handler; + data = slot->data; + + if (slot->handled_error) { + handled_error_previously = _gf_true; + } else { + slot->handled_error = (event->events & (EPOLLERR | EPOLLHUP)); + slot->in_handler++; + } + } pre_unlock: - UNLOCK (&slot->lock); + UNLOCK(&slot->lock); - ret = 0; + ret = 0; - if (!handler) - goto out; + if (!handler) + goto out; - if (!handled_error_previously) { - ret = handler (fd, idx, gen, data, - (event->events & (EPOLLIN|EPOLLPRI)), - (event->events & (EPOLLOUT)), - (event->events & (EPOLLERR|EPOLLHUP))); - } + if (!handled_error_previously) { + ret = handler(fd, idx, gen, data, + (event->events & (EPOLLIN | EPOLLPRI)), + (event->events & (EPOLLOUT)), + (event->events & (EPOLLERR | EPOLLHUP))); + } out: - event_slot_unref (event_pool, slot, idx); + event_slot_unref(event_pool, slot, idx); - return ret; + return ret; } - static void * -event_dispatch_epoll_worker (void *data) +event_dispatch_epoll_worker(void *data) { - struct epoll_event event; - int ret = -1; - struct event_thread_data *ev_data = data; - struct event_pool *event_pool; - int myindex = -1; - int timetodie = 0; - - GF_VALIDATE_OR_GOTO ("event", ev_data, out); - - event_pool = ev_data->event_pool; - myindex = ev_data->event_index; - - GF_VALIDATE_OR_GOTO ("event", event_pool, out); - - gf_msg ("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD, "Started" - " thread with index %d", myindex); - - pthread_mutex_lock (&event_pool->mutex); - { - event_pool->activethreadcount++; - } - pthread_mutex_unlock (&event_pool->mutex); - - for (;;) { + struct epoll_event event; + int ret = -1; + struct event_thread_data *ev_data = data; + struct event_pool *event_pool; + int myindex = -1; + int timetodie = 0; + + GF_VALIDATE_OR_GOTO("event", ev_data, out); + + event_pool = ev_data->event_pool; + myindex = ev_data->event_index; + + GF_VALIDATE_OR_GOTO("event", event_pool, out); + + gf_msg("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD, + "Started" + " thread with index %d", + myindex); + + pthread_mutex_lock(&event_pool->mutex); + { + event_pool->activethreadcount++; + } + pthread_mutex_unlock(&event_pool->mutex); + + for (;;) { + if (event_pool->eventthreadcount < myindex) { + /* ...time to die, thread count was decreased below + * this threads index */ + /* Start with extra safety at this point, reducing + * lock conention in normal case when threads are not + * reconfigured always */ + pthread_mutex_lock(&event_pool->mutex); + { if (event_pool->eventthreadcount < myindex) { - /* ...time to die, thread count was decreased below - * this threads index */ - /* Start with extra safety at this point, reducing - * lock conention in normal case when threads are not - * reconfigured always */ - pthread_mutex_lock (&event_pool->mutex); - { - if (event_pool->eventthreadcount < - myindex) { - /* if found true in critical section, - * die */ - event_pool->pollers[myindex - 1] = 0; - event_pool->activethreadcount--; - timetodie = 1; - pthread_cond_broadcast (&event_pool->cond); - } - } - pthread_mutex_unlock (&event_pool->mutex); - if (timetodie) { - gf_msg ("epoll", GF_LOG_INFO, 0, - LG_MSG_EXITED_EPOLL_THREAD, "Exited " - "thread with index %d", myindex); - goto out; - } + /* if found true in critical section, + * die */ + event_pool->pollers[myindex - 1] = 0; + event_pool->activethreadcount--; + timetodie = 1; + pthread_cond_broadcast(&event_pool->cond); } + } + pthread_mutex_unlock(&event_pool->mutex); + if (timetodie) { + gf_msg("epoll", GF_LOG_INFO, 0, LG_MSG_EXITED_EPOLL_THREAD, + "Exited " + "thread with index %d", + myindex); + goto out; + } + } - ret = epoll_wait (event_pool->fd, &event, 1, -1); + ret = epoll_wait(event_pool->fd, &event, 1, -1); - if (ret == 0) - /* timeout */ - continue; + if (ret == 0) + /* timeout */ + continue; - if (ret == -1 && errno == EINTR) - /* sys call */ - continue; + if (ret == -1 && errno == EINTR) + /* sys call */ + continue; - ret = event_dispatch_epoll_handler (event_pool, &event); - if (ret) { - gf_msg ("epoll", GF_LOG_ERROR, 0, - LG_MSG_EXITED_EPOLL_THREAD, - "Failed to dispatch handler"); - } + ret = event_dispatch_epoll_handler(event_pool, &event); + if (ret) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_EXITED_EPOLL_THREAD, + "Failed to dispatch handler"); } + } out: - if (ev_data) - GF_FREE (ev_data); - return NULL; + if (ev_data) + GF_FREE(ev_data); + return NULL; } /* Attempts to start the # of configured pollers, ensuring at least the first * is started in a joinable state */ static int -event_dispatch_epoll (struct event_pool *event_pool) +event_dispatch_epoll(struct event_pool *event_pool) { - int i = 0; - pthread_t t_id; - int pollercount = 0; - int ret = -1; - struct event_thread_data *ev_data = NULL; - char thread_name[GF_THREAD_NAMEMAX] = {0,}; - - /* Start the configured number of pollers */ - pthread_mutex_lock (&event_pool->mutex); - { - pollercount = event_pool->eventthreadcount; - - /* Set to MAX if greater */ - if (pollercount > EVENT_MAX_THREADS) - pollercount = EVENT_MAX_THREADS; - - /* Default pollers to 1 in case this is incorrectly set */ - if (pollercount <= 0) - pollercount = 1; - - event_pool->activethreadcount++; - - for (i = 0; i < pollercount; i++) { - ev_data = GF_CALLOC (1, sizeof (*ev_data), - gf_common_mt_event_pool); - if (!ev_data) { - if (i == 0) { - /* Need to succeed creating 0'th - * thread, to joinable and wait */ - break; - } else { - /* Inability to create other threads - * are a lesser evil, and ignored */ - continue; - } - } - - ev_data->event_pool = event_pool; - ev_data->event_index = i + 1; - - snprintf (thread_name, sizeof(thread_name), - "epoll%03hx", (i & 0x3ff)); - ret = gf_thread_create (&t_id, NULL, - event_dispatch_epoll_worker, - ev_data, thread_name); - if (!ret) { - event_pool->pollers[i] = t_id; - - /* mark all threads other than one in index 0 - * as detachable. Errors can be ignored, they - * spend their time as zombies if not detched - * and the thread counts are decreased */ - if (i != 0) - pthread_detach (event_pool->pollers[i]); - } else { - gf_msg ("epoll", GF_LOG_WARNING, 0, - LG_MSG_START_EPOLL_THREAD_FAILED, - "Failed to start thread for index %d", - i); - if (i == 0) { - GF_FREE (ev_data); - break; - } else { - GF_FREE (ev_data); - continue; - } - } + int i = 0; + pthread_t t_id; + int pollercount = 0; + int ret = -1; + struct event_thread_data *ev_data = NULL; + char thread_name[GF_THREAD_NAMEMAX] = { + 0, + }; + + /* Start the configured number of pollers */ + pthread_mutex_lock(&event_pool->mutex); + { + pollercount = event_pool->eventthreadcount; + + /* Set to MAX if greater */ + if (pollercount > EVENT_MAX_THREADS) + pollercount = EVENT_MAX_THREADS; + + /* Default pollers to 1 in case this is incorrectly set */ + if (pollercount <= 0) + pollercount = 1; + + event_pool->activethreadcount++; + + for (i = 0; i < pollercount; i++) { + ev_data = GF_CALLOC(1, sizeof(*ev_data), gf_common_mt_event_pool); + if (!ev_data) { + if (i == 0) { + /* Need to succeed creating 0'th + * thread, to joinable and wait */ + break; + } else { + /* Inability to create other threads + * are a lesser evil, and ignored */ + continue; } + } + + ev_data->event_pool = event_pool; + ev_data->event_index = i + 1; + + snprintf(thread_name, sizeof(thread_name), "epoll%03hx", + (i & 0x3ff)); + ret = gf_thread_create(&t_id, NULL, event_dispatch_epoll_worker, + ev_data, thread_name); + if (!ret) { + event_pool->pollers[i] = t_id; + + /* mark all threads other than one in index 0 + * as detachable. Errors can be ignored, they + * spend their time as zombies if not detched + * and the thread counts are decreased */ + if (i != 0) + pthread_detach(event_pool->pollers[i]); + } else { + gf_msg("epoll", GF_LOG_WARNING, 0, + LG_MSG_START_EPOLL_THREAD_FAILED, + "Failed to start thread for index %d", i); + if (i == 0) { + GF_FREE(ev_data); + break; + } else { + GF_FREE(ev_data); + continue; + } + } } - pthread_mutex_unlock (&event_pool->mutex); + } + pthread_mutex_unlock(&event_pool->mutex); - /* Just wait for the first thread, that is created in a joinable state - * and will never die, ensuring this function never returns */ - if (event_pool->pollers[0] != 0) - pthread_join (event_pool->pollers[0], NULL); + /* Just wait for the first thread, that is created in a joinable state + * and will never die, ensuring this function never returns */ + if (event_pool->pollers[0] != 0) + pthread_join(event_pool->pollers[0], NULL); - pthread_mutex_lock (&event_pool->mutex); - { - event_pool->activethreadcount--; - } - pthread_mutex_unlock (&event_pool->mutex); + pthread_mutex_lock(&event_pool->mutex); + { + event_pool->activethreadcount--; + } + pthread_mutex_unlock(&event_pool->mutex); - return ret; + return ret; } /** @@ -795,89 +776,87 @@ event_dispatch_epoll (struct event_pool *event_pool) */ static int -event_pool_dispatched_unlocked (struct event_pool *event_pool) +event_pool_dispatched_unlocked(struct event_pool *event_pool) { - return (event_pool->pollers[0] != 0); - + return (event_pool->pollers[0] != 0); } - int -event_reconfigure_threads_epoll (struct event_pool *event_pool, int value) +event_reconfigure_threads_epoll(struct event_pool *event_pool, int value) { - int i; - int ret = 0; - pthread_t t_id; - int oldthreadcount; - struct event_thread_data *ev_data = NULL; - char thread_name[GF_THREAD_NAMEMAX] = {0,}; - - pthread_mutex_lock (&event_pool->mutex); - { - /* Reconfigure to 0 threads is allowed only in destroy mode */ - if (event_pool->destroy == 1) { - value = 0; - } else { - /* Set to MAX if greater */ - if (value > EVENT_MAX_THREADS) - value = EVENT_MAX_THREADS; - - /* Default pollers to 1 in case this is set incorrectly */ - if (value <= 0) - value = 1; - } + int i; + int ret = 0; + pthread_t t_id; + int oldthreadcount; + struct event_thread_data *ev_data = NULL; + char thread_name[GF_THREAD_NAMEMAX] = { + 0, + }; + + pthread_mutex_lock(&event_pool->mutex); + { + /* Reconfigure to 0 threads is allowed only in destroy mode */ + if (event_pool->destroy == 1) { + value = 0; + } else { + /* Set to MAX if greater */ + if (value > EVENT_MAX_THREADS) + value = EVENT_MAX_THREADS; + + /* Default pollers to 1 in case this is set incorrectly */ + if (value <= 0) + value = 1; + } - oldthreadcount = event_pool->eventthreadcount; - - /* Start 'worker' threads as necessary only if event_dispatch() - * was called before. If event_dispatch() was not called, there - * will be no epoll 'worker' threads running yet. */ - - if (event_pool_dispatched_unlocked(event_pool) - && (oldthreadcount < value)) { - /* create more poll threads */ - for (i = oldthreadcount; i < value; i++) { - /* Start a thread if the index at this location - * is a 0, so that the older thread is confirmed - * as dead */ - if (event_pool->pollers[i] == 0) { - ev_data = GF_CALLOC (1, - sizeof (*ev_data), - gf_common_mt_event_pool); - if (!ev_data) { - continue; - } - - ev_data->event_pool = event_pool; - ev_data->event_index = i + 1; - - snprintf (thread_name, - sizeof(thread_name), - "epoll%03hx", (i & 0x3ff)); - ret = gf_thread_create (&t_id, NULL, - event_dispatch_epoll_worker, - ev_data, thread_name); - if (ret) { - gf_msg ("epoll", GF_LOG_WARNING, - 0, - LG_MSG_START_EPOLL_THREAD_FAILED, - "Failed to start thread" - " for index %d", i); - GF_FREE (ev_data); - } else { - pthread_detach (t_id); - event_pool->pollers[i] = t_id; - } - } - } + oldthreadcount = event_pool->eventthreadcount; + + /* Start 'worker' threads as necessary only if event_dispatch() + * was called before. If event_dispatch() was not called, there + * will be no epoll 'worker' threads running yet. */ + + if (event_pool_dispatched_unlocked(event_pool) && + (oldthreadcount < value)) { + /* create more poll threads */ + for (i = oldthreadcount; i < value; i++) { + /* Start a thread if the index at this location + * is a 0, so that the older thread is confirmed + * as dead */ + if (event_pool->pollers[i] == 0) { + ev_data = GF_CALLOC(1, sizeof(*ev_data), + gf_common_mt_event_pool); + if (!ev_data) { + continue; + } + + ev_data->event_pool = event_pool; + ev_data->event_index = i + 1; + + snprintf(thread_name, sizeof(thread_name), "epoll%03hx", + (i & 0x3ff)); + ret = gf_thread_create(&t_id, NULL, + event_dispatch_epoll_worker, ev_data, + thread_name); + if (ret) { + gf_msg("epoll", GF_LOG_WARNING, 0, + LG_MSG_START_EPOLL_THREAD_FAILED, + "Failed to start thread" + " for index %d", + i); + GF_FREE(ev_data); + } else { + pthread_detach(t_id); + event_pool->pollers[i] = t_id; + } } - - /* if value decreases, threads will terminate, themselves */ - event_pool->eventthreadcount = value; + } } - pthread_mutex_unlock (&event_pool->mutex); - return 0; + /* if value decreases, threads will terminate, themselves */ + event_pool->eventthreadcount = value; + } + pthread_mutex_unlock(&event_pool->mutex); + + return 0; } /* This function is the destructor for the event_pool data structure @@ -885,98 +864,99 @@ event_reconfigure_threads_epoll (struct event_pool *event_pool, int value) * else will lead to crashes. */ static int -event_pool_destroy_epoll (struct event_pool *event_pool) +event_pool_destroy_epoll(struct event_pool *event_pool) { - int ret = 0, i = 0, j = 0; - struct event_slot_epoll *table = NULL; - - ret = sys_close (event_pool->fd); - - for (i = 0; i < EVENT_EPOLL_TABLES; i++) { - if (event_pool->ereg[i]) { - table = event_pool->ereg[i]; - event_pool->ereg[i] = NULL; - for (j = 0; j < EVENT_EPOLL_SLOTS; j++) { - LOCK_DESTROY (&table[j].lock); - } - GF_FREE (table); - } + int ret = 0, i = 0, j = 0; + struct event_slot_epoll *table = NULL; + + ret = sys_close(event_pool->fd); + + for (i = 0; i < EVENT_EPOLL_TABLES; i++) { + if (event_pool->ereg[i]) { + table = event_pool->ereg[i]; + event_pool->ereg[i] = NULL; + for (j = 0; j < EVENT_EPOLL_SLOTS; j++) { + LOCK_DESTROY(&table[j].lock); + } + GF_FREE(table); } + } - pthread_mutex_destroy (&event_pool->mutex); - pthread_cond_destroy (&event_pool->cond); + pthread_mutex_destroy(&event_pool->mutex); + pthread_cond_destroy(&event_pool->cond); - GF_FREE (event_pool->evcache); - GF_FREE (event_pool->reg); - GF_FREE (event_pool); + GF_FREE(event_pool->evcache); + GF_FREE(event_pool->reg); + GF_FREE(event_pool); - return ret; + return ret; } static int -event_handled_epoll (struct event_pool *event_pool, int fd, int idx, int gen) +event_handled_epoll(struct event_pool *event_pool, int fd, int idx, int gen) { - struct event_slot_epoll *slot = NULL; - struct epoll_event epoll_event = {0, }; - struct event_data *ev_data = (void *)&epoll_event.data; - int ret = 0; - - slot = event_slot_get (event_pool, idx); - if (!slot) { - gf_msg ("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, - "could not find slot for fd=%d idx=%d", fd, idx); - return -1; + struct event_slot_epoll *slot = NULL; + struct epoll_event epoll_event = { + 0, + }; + struct event_data *ev_data = (void *)&epoll_event.data; + int ret = 0; + + slot = event_slot_get(event_pool, idx); + if (!slot) { + gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, + "could not find slot for fd=%d idx=%d", fd, idx); + return -1; + } + + assert(slot->fd == fd); + + LOCK(&slot->lock); + { + slot->in_handler--; + + if (gen != slot->gen) { + /* event_unregister() happened while we were + in handler() + */ + gf_msg_debug("epoll", 0, + "generation bumped on idx=%d" + " from gen=%d to slot->gen=%d, fd=%d, " + "slot->fd=%d", + idx, gen, slot->gen, fd, slot->fd); + goto post_unlock; } - assert (slot->fd == fd); - - LOCK (&slot->lock); - { - slot->in_handler--; - - if (gen != slot->gen) { - /* event_unregister() happened while we were - in handler() - */ - gf_msg_debug ("epoll", 0, "generation bumped on idx=%d" - " from gen=%d to slot->gen=%d, fd=%d, " - "slot->fd=%d", idx, gen, slot->gen, fd, - slot->fd); - goto post_unlock; - } - - /* This call also picks up the changes made by another - thread calling event_select_on_epoll() while this - thread was busy in handler() - */ - if (slot->in_handler == 0) { - epoll_event.events = slot->events; - ev_data->idx = idx; - ev_data->gen = gen; - - ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, - fd, &epoll_event); - } - } + /* This call also picks up the changes made by another + thread calling event_select_on_epoll() while this + thread was busy in handler() + */ + if (slot->in_handler == 0) { + epoll_event.events = slot->events; + ev_data->idx = idx; + ev_data->gen = gen; + + ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event); + } + } post_unlock: - UNLOCK (&slot->lock); + UNLOCK(&slot->lock); - event_slot_unref (event_pool, slot, idx); + event_slot_unref(event_pool, slot, idx); - return ret; + return ret; } - struct event_ops event_ops_epoll = { - .new = event_pool_new_epoll, - .event_register = event_register_epoll, - .event_select_on = event_select_on_epoll, - .event_unregister = event_unregister_epoll, - .event_unregister_close = event_unregister_close_epoll, - .event_dispatch = event_dispatch_epoll, - .event_reconfigure_threads = event_reconfigure_threads_epoll, - .event_pool_destroy = event_pool_destroy_epoll, - .event_handled = event_handled_epoll, + .new = event_pool_new_epoll, + .event_register = event_register_epoll, + .event_select_on = event_select_on_epoll, + .event_unregister = event_unregister_epoll, + .event_unregister_close = event_unregister_close_epoll, + .event_dispatch = event_dispatch_epoll, + .event_reconfigure_threads = event_reconfigure_threads_epoll, + .event_pool_destroy = event_pool_destroy_epoll, + .event_handled = event_handled_epoll, }; #endif -- cgit