X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fcompat%2Fcompat-epoll.c;h=92abc0a7889ffa96f7c8b61c2280bfffb2eeeeff;hp=1380ce85527a74dae304b2777de5a72c489b6b5c;hb=cc0acbd149005db7b944856be2aff499f38c0d64;hpb=6cd525e813795a1d5e38feac8dedf2c73ffb1274 diff --git a/src/common/compat/compat-epoll.c b/src/common/compat/compat-epoll.c index 1380ce855..92abc0a78 100644 --- a/src/common/compat/compat-epoll.c +++ b/src/common/compat/compat-epoll.c @@ -15,7 +15,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -23,7 +23,7 @@ #include #include #include -#include +#include #include #include @@ -32,7 +32,17 @@ #include "poll.h" -unsigned int poll_max_size; +/* + * Maximum number of fd we can monitor. + * + * For epoll(7), /proc/sys/fs/epoll/max_user_watches (since Linux 2.6.28) will + * be used for the maximum size of the poll set. If this interface is not + * available, according to the manpage, the max_user_watches value is 1/25 (4%) + * of the available low memory divided by the registration cost in bytes which + * is 90 bytes on a 32-bit kernel and 160 bytes on a 64-bit kernel. + * + */ +static unsigned int poll_max_size; /* * Resize the epoll events structure of the new size. @@ -51,6 +61,11 @@ static int resize_poll_event(struct lttng_poll_event *events, PERROR("realloc epoll add"); goto error; } + if (new_size > events->alloc_size) { + /* Zero newly allocated memory */ + memset(ptr + events->alloc_size, 0, + (new_size - events->alloc_size) * sizeof(*ptr)); + } events->events = ptr; events->alloc_size = new_size; @@ -63,6 +78,7 @@ error: /* * Create epoll set and allocate returned events structure. */ +LTTNG_HIDDEN int compat_epoll_create(struct lttng_poll_event *events, int size, int flags) { int ret; @@ -71,12 +87,18 @@ int compat_epoll_create(struct lttng_poll_event *events, int size, int flags) goto error; } + if (!poll_max_size) { + if (lttng_poll_set_max_size()) { + goto error; + } + } + /* Don't bust the limit here */ - if (size > poll_max_size && poll_max_size != 0) { + if (size > poll_max_size) { size = poll_max_size; } - ret = epoll_create1(flags); + ret = compat_glibc_epoll_create(size, flags); if (ret < 0) { /* At this point, every error is fatal */ PERROR("epoll_create1"); @@ -109,6 +131,7 @@ error: /* * Add a fd to the epoll set with requesting events. */ +LTTNG_HIDDEN int compat_epoll_add(struct lttng_poll_event *events, int fd, uint32_t req_events) { int ret; @@ -119,6 +142,11 @@ int compat_epoll_add(struct lttng_poll_event *events, int fd, uint32_t req_event goto error; } + /* + * Zero struct epoll_event to ensure all representations of its + * union are zeroed. + */ + memset(&ev, 0, sizeof(ev)); ev.events = req_events; ev.data.fd = fd; @@ -151,11 +179,12 @@ error: /* * Remove a fd from the epoll set. */ +LTTNG_HIDDEN int compat_epoll_del(struct lttng_poll_event *events, int fd) { int ret; - if (events == NULL || fd < 0) { + if (events == NULL || fd < 0 || events->nb_fd == 0) { goto error; } @@ -182,10 +211,54 @@ error: return -1; } +/* + * Set an fd's events. + */ +LTTNG_HIDDEN +int compat_epoll_mod(struct lttng_poll_event *events, int fd, uint32_t req_events) +{ + int ret; + struct epoll_event ev; + + if (events == NULL || fd < 0 || events->nb_fd == 0) { + goto error; + } + + /* + * Zero struct epoll_event to ensure all representations of its + * union are zeroed. + */ + memset(&ev, 0, sizeof(ev)); + ev.events = req_events; + ev.data.fd = fd; + + ret = epoll_ctl(events->epfd, EPOLL_CTL_MOD, fd, &ev); + if (ret < 0) { + switch (errno) { + case ENOENT: + case EPERM: + /* Print PERROR and goto end not failing. Show must go on. */ + PERROR("epoll_ctl MOD"); + goto end; + default: + PERROR("epoll_ctl MOD fatal"); + goto error; + } + } + +end: + return 0; + +error: + return -1; +} + /* * Wait on epoll set. This is a blocking call of timeout value. */ -int compat_epoll_wait(struct lttng_poll_event *events, int timeout) +LTTNG_HIDDEN +int compat_epoll_wait(struct lttng_poll_event *events, int timeout, + bool interruptible) { int ret; uint32_t new_size; @@ -195,29 +268,19 @@ int compat_epoll_wait(struct lttng_poll_event *events, int timeout) goto error; } + if (events->nb_fd == 0) { + errno = EINVAL; + return -1; + } + /* * Resize if needed before waiting. We could either expand the array or * shrink it down. It's important to note that after this step, we are * ensured that the events argument of the epoll_wait call will be large * enough to hold every possible returned events. */ - if (events->nb_fd > events->alloc_size) { - /* Expand if the nb_fd is higher than the actual size. */ - new_size = max_t(uint32_t, - 1U << utils_get_count_order_u32(events->nb_fd), - events->alloc_size << 1UL); - } else if ((events->nb_fd << 1UL) <= events->alloc_size && - events->nb_fd >= events->init_size) { - /* Shrink if nb_fd multiplied by two is <= than the actual size. */ - new_size = max_t(uint32_t, - utils_get_count_order_u32(events->nb_fd) >> 1U, - events->alloc_size >> 1U); - } else { - /* Indicate that we don't want to resize. */ - new_size = 0; - } - - if (new_size) { + new_size = 1U << utils_get_count_order_u32(events->nb_fd); + if (new_size != events->alloc_size && new_size >= events->init_size) { ret = resize_poll_event(events, new_size); if (ret < 0) { /* ENOMEM problem at this point. */ @@ -227,10 +290,11 @@ int compat_epoll_wait(struct lttng_poll_event *events, int timeout) do { ret = epoll_wait(events->epfd, events->events, events->nb_fd, timeout); - } while (ret == -1 && errno == EINTR); + } while (!interruptible && ret == -1 && errno == EINTR); if (ret < 0) { - /* At this point, every error is fatal */ - PERROR("epoll_wait"); + if (errno != EINTR) { + PERROR("epoll_wait"); + } goto error; } @@ -247,17 +311,25 @@ error: /* * Setup poll set maximum size. */ -void compat_epoll_set_max_size(void) +LTTNG_HIDDEN +int compat_epoll_set_max_size(void) { - int ret, fd; - size_t size_ret; + int ret, fd, retval = 0; + ssize_t size_ret; char buf[64]; - poll_max_size = DEFAULT_POLL_SIZE; - fd = open(COMPAT_EPOLL_PROC_PATH, O_RDONLY); if (fd < 0) { - return; + /* + * Failing on opening [1] is not an error per see. [1] was + * introduced in Linux 2.6.28 but epoll is available since + * 2.5.44. Hence, goto end and set a default value without + * setting an error return value. + * + * [1] /proc/sys/fs/epoll/max_user_watches + */ + retval = 0; + goto end; } size_ret = lttng_read(fd, buf, sizeof(buf)); @@ -267,21 +339,20 @@ void compat_epoll_set_max_size(void) */ if (size_ret < 0 || size_ret >= sizeof(buf)) { PERROR("read set max size"); - goto error; + retval = -1; + goto end_read; } buf[size_ret] = '\0'; - poll_max_size = atoi(buf); - if (poll_max_size == 0) { - /* Extra precaution */ - poll_max_size = DEFAULT_POLL_SIZE; - } - - DBG("epoll set max size is %d", poll_max_size); - -error: +end_read: ret = close(fd); if (ret) { PERROR("close"); } +end: + if (!poll_max_size) { + poll_max_size = DEFAULT_POLL_SIZE; + } + DBG("epoll set max size is %d", poll_max_size); + return retval; }