X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fcompat%2Fcompat-poll.c;h=0c59e98ce9917c4b22b5912d1e88e23fe4c777ae;hp=cff9f44b8e17c369a4b015866a825044bb43ef48;hb=4fb28dfc10106c4095ca3b1155d4da9a04467fd1;hpb=d21b0d71990ac6ec4272c1f80f0ca544103628b3 diff --git a/src/common/compat/compat-poll.c b/src/common/compat/compat-poll.c index cff9f44b8..0c59e98ce 100644 --- a/src/common/compat/compat-poll.c +++ b/src/common/compat/compat-poll.c @@ -1,32 +1,33 @@ /* - * Copyright (C) 2011 - David Goulet + * Copyright (C) 2011 David Goulet + * Copyright (C) 2019 Yannick Lamarre * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include #include +#include #include #include +#include +#include #include "poll.h" -unsigned int poll_max_size; + +/* + * Maximum number of fd we can monitor. + * + * For poll(2), the max fds must not exceed RLIMIT_NOFILE given by + * getrlimit(2). + */ +static unsigned int poll_max_size; /* * Resize the epoll events structure of the new size. @@ -40,11 +41,21 @@ static int resize_poll_event(struct compat_poll_event_array *array, assert(array); + /* Refuse to resize the array more than the max size. */ + if (new_size > poll_max_size) { + goto error; + } + ptr = realloc(array->events, new_size * sizeof(*ptr)); if (ptr == NULL) { PERROR("realloc epoll add"); goto error; } + if (new_size > array->alloc_size) { + /* Zero newly allocated memory */ + memset(ptr + array->alloc_size, 0, + (new_size - array->alloc_size) * sizeof(*ptr)); + } array->events = ptr; array->alloc_size = new_size; @@ -68,7 +79,7 @@ static int update_current_events(struct lttng_poll_event *events) wait = &events->wait; wait->nb_fd = current->nb_fd; - if (events->need_realloc) { + if (current->alloc_size != wait->alloc_size) { ret = resize_poll_event(wait, current->alloc_size); if (ret < 0) { goto error; @@ -77,9 +88,8 @@ static int update_current_events(struct lttng_poll_event *events) memcpy(wait->events, current->events, current->nb_fd * sizeof(*current->events)); - /* Update is done and realloc as well. */ + /* Update is done. */ events->need_update = 0; - events->need_realloc = 0; return 0; @@ -90,6 +100,7 @@ error: /* * Create pollfd data structure. */ +LTTNG_HIDDEN int compat_poll_create(struct lttng_poll_event *events, int size) { struct compat_poll_event_array *current, *wait; @@ -99,6 +110,12 @@ int compat_poll_create(struct lttng_poll_event *events, int size) 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) { size = poll_max_size; @@ -107,14 +124,13 @@ int compat_poll_create(struct lttng_poll_event *events, int size) /* Reset everything before begining the allocation. */ memset(events, 0, sizeof(struct lttng_poll_event)); - /* Ease our life a bit. */ current = &events->current; wait = &events->wait; /* This *must* be freed by using lttng_poll_free() */ wait->events = zmalloc(size * sizeof(struct pollfd)); if (wait->events == NULL) { - perror("zmalloc struct pollfd"); + PERROR("zmalloc struct pollfd"); goto error; } @@ -122,7 +138,7 @@ int compat_poll_create(struct lttng_poll_event *events, int size) current->events = zmalloc(size * sizeof(struct pollfd)); if (current->events == NULL) { - perror("zmalloc struct current pollfd"); + PERROR("zmalloc struct current pollfd"); goto error; } @@ -137,6 +153,7 @@ error: /* * Add fd to pollfd data structure with requested events. */ +LTTNG_HIDDEN int compat_poll_add(struct lttng_poll_event *events, int fd, uint32_t req_events) { @@ -148,27 +165,23 @@ int compat_poll_add(struct lttng_poll_event *events, int fd, goto error; } - /* Ease our life a bit. */ current = &events->current; /* Check if fd we are trying to add is already there. */ for (i = 0; i < current->nb_fd; i++) { - /* Don't put back the fd we want to delete */ if (current->events[i].fd == fd) { errno = EEXIST; goto error; } } - /* Check for a needed resize of the array. */ - if (current->nb_fd > current->alloc_size) { - /* Expand it by a power of two of the current size. */ - new_size = current->alloc_size << 1UL; + /* Resize array if needed. */ + new_size = 1U << utils_get_count_order_u32(current->nb_fd + 1); + if (new_size != current->alloc_size && new_size >= current->init_size) { ret = resize_poll_event(current, new_size); if (ret < 0) { goto error; } - events->need_realloc = 1; } current->events[current->nb_fd].fd = fd; @@ -185,41 +198,60 @@ error: } /* - * Remove a fd from the pollfd structure. + * Modify an fd's events.. */ -int compat_poll_del(struct lttng_poll_event *events, int fd) +LTTNG_HIDDEN +int compat_poll_mod(struct lttng_poll_event *events, int fd, + uint32_t req_events) { - int new_size, i, count = 0, ret; + int i; struct compat_poll_event_array *current; - if (events == NULL || events->current.events == NULL || fd < 0) { - ERR("Wrong arguments for poll del"); + if (events == NULL || events->current.nb_fd == 0 || + events->current.events == NULL || fd < 0) { + ERR("Bad compat poll mod arguments"); goto error; } - /* Ease our life a bit. */ current = &events->current; - /* Safety check on size */ - if (new_size > poll_max_size) { - new_size = poll_max_size; + for (i = 0; i < current->nb_fd; i++) { + if (current->events[i].fd == fd) { + current->events[i].events = req_events; + events->need_update = 1; + break; + } } - /* Check if we need to shrink it down. */ - if ((current->nb_fd << 1UL) <= current->alloc_size && - current->nb_fd >= current->init_size) { - /* - * Shrink if nb_fd multiplied by two is <= than the actual size and we - * are above the initial size. - */ - new_size = current->alloc_size >> 1UL; - ret = resize_poll_event(current, new_size); - if (ret < 0) { - goto error; - } - events->need_realloc = 1; + /* + * The epoll flavor doesn't flag modifying a non-included FD as an + * error. + */ + + return 0; + +error: + return -1; +} + +/* + * Remove a fd from the pollfd structure. + */ +LTTNG_HIDDEN +int compat_poll_del(struct lttng_poll_event *events, int fd) +{ + int i, count = 0, ret; + uint32_t new_size; + struct compat_poll_event_array *current; + + if (events == NULL || events->current.nb_fd == 0 || + events->current.events == NULL || fd < 0) { + goto error; } + /* Ease our life a bit. */ + current = &events->current; + for (i = 0; i < current->nb_fd; i++) { /* Don't put back the fd we want to delete */ if (current->events[i].fd != fd) { @@ -229,9 +261,28 @@ int compat_poll_del(struct lttng_poll_event *events, int fd) } } - current->nb_fd--; + /* The fd was not in our set, return no error as with epoll. */ + if (current->nb_fd == count) { + goto end; + } + + /* No fd duplicate should be ever added into array. */ + assert(current->nb_fd - 1 == count); + current->nb_fd = count; + + /* Resize array if needed. */ + new_size = 1U << utils_get_count_order_u32(current->nb_fd); + if (new_size != current->alloc_size && new_size >= current->init_size + && current->nb_fd != 0) { + ret = resize_poll_event(current, new_size); + if (ret < 0) { + goto error; + } + } + events->need_update = 1; +end: return 0; error: @@ -241,9 +292,13 @@ error: /* * Wait on poll() with timeout. Blocking call. */ -int compat_poll_wait(struct lttng_poll_event *events, int timeout) +LTTNG_HIDDEN +int compat_poll_wait(struct lttng_poll_event *events, int timeout, + bool interruptible) { - int ret; + int ret, active_fd_count; + int idle_pfd_index = 0; + size_t i; if (events == NULL || events->current.events == NULL) { ERR("poll wait arguments error"); @@ -253,6 +308,7 @@ int compat_poll_wait(struct lttng_poll_event *events, int timeout) if (events->current.nb_fd == 0) { /* Return an invalid error to be consistent with epoll. */ errno = EINVAL; + events->wait.nb_fd = 0; goto error; } @@ -264,18 +320,49 @@ int compat_poll_wait(struct lttng_poll_event *events, int timeout) } } - ret = poll(events->wait.events, events->wait.nb_fd, timeout); + do { + ret = poll(events->wait.events, events->wait.nb_fd, timeout); + } while (!interruptible && ret == -1 && errno == EINTR); if (ret < 0) { - /* At this point, every error is fatal */ - perror("poll wait"); + if (errno != EINTR) { + PERROR("poll wait"); + } goto error; } + active_fd_count = ret; + /* - * poll() should always iterate on all FDs since we handle the pollset in - * user space and after poll returns, we have to try every fd for a match. + * Swap all active pollfd structs to the beginning of the + * array to emulate compat-epoll behaviour. This algorithm takes + * advantage of poll's returned value and the burst nature of active + * events on the file descriptors. The while loop guarantees that + * idle_pfd will always point to an idle fd. */ - return events->wait.nb_fd; + if (active_fd_count == events->wait.nb_fd) { + goto end; + } + while (idle_pfd_index < active_fd_count && + events->wait.events[idle_pfd_index].revents != 0) { + idle_pfd_index++; + } + + for (i = idle_pfd_index + 1; idle_pfd_index < active_fd_count; + i++) { + struct pollfd swap_pfd; + struct pollfd *idle_pfd = &events->wait.events[idle_pfd_index]; + struct pollfd *current_pfd = &events->wait.events[i]; + + if (idle_pfd->revents != 0) { + swap_pfd = *current_pfd; + *current_pfd = *idle_pfd; + *idle_pfd = swap_pfd; + idle_pfd_index++; + } + } + +end: + return ret; error: return -1; @@ -284,25 +371,24 @@ error: /* * Setup poll set maximum size. */ -void compat_poll_set_max_size(void) +LTTNG_HIDDEN +int compat_poll_set_max_size(void) { - int ret; + int ret, retval = 0; struct rlimit lim; - /* Default value */ - poll_max_size = DEFAULT_POLL_SIZE; - ret = getrlimit(RLIMIT_NOFILE, &lim); if (ret < 0) { - perror("getrlimit poll RLIMIT_NOFILE"); - return; + PERROR("getrlimit poll RLIMIT_NOFILE"); + retval = -1; + goto end; } poll_max_size = lim.rlim_cur; +end: if (poll_max_size == 0) { - /* Extra precaution */ poll_max_size = DEFAULT_POLL_SIZE; } - DBG("poll set max size set to %u", poll_max_size); + return retval; }