static void
runner_insert_arg (runner_t *runner, char *arg)
{
int i = 0;
GF_ASSERT (arg);
if (runner->runerr)
return;
for (i = 0; i < runner->argvlen; i++) {
if (runner->argv[i] == NULL)
break;
}
GF_ASSERT (i < runner->argvlen);
if (i == runner->argvlen - 1) {
runner->argv = GF_REALLOC (runner->argv,
runner->argvlen * 2 * sizeof (*runner->argv));
if (!runner->argv) {
runner->runerr = errno;
return;
}
memset (/* "+" is aware of the type of its left side,
* no need to multiply with type-size */
runner->argv + runner->argvlen,
0, runner->argvlen * sizeof (*runner->argv));
runner->argvlen *= 2;
}
runner->argv[i] = arg;
}
int
strprintf (strfd_t *strfd, const char *fmt, ...)
{
va_list ap;
char *str = NULL;
int size = 0;
va_start (ap, fmt);
size = vasprintf (&str, fmt, ap);
if (size < 0)
return size;
if (!strfd->alloc_size) {
strfd->data = GF_CALLOC (max(size + 1, 4096), 1,
gf_common_mt_strfd_data_t);
if (!strfd->data) {
free (str); /* NOT GF_FREE */
return -1;
}
strfd->alloc_size = max(size + 1, 4096);
}
if (strfd->alloc_size <= (strfd->size + size)) {
char *tmp_ptr = NULL;
int new_size = max ((strfd->alloc_size * 2),
gf_roundup_next_power_of_two (strfd->size + size + 1));
tmp_ptr = GF_REALLOC (strfd->data, new_size);
if (!tmp_ptr) {
free (str); /* NOT GF_FREE */
return -1;
}
strfd->alloc_size = new_size;
strfd->data = tmp_ptr;
}
// Copy the trailing '\0', but do not account for it in ->size.
// This allows safe use of strfd->data as a string.
memcpy (strfd->data + strfd->size, str, size + 1);
strfd->size += size;
free (str); /* NOT GF_FREE */
return size;
}
static int
event_register_poll (struct event_pool *event_pool, int fd,
event_handler_t handler,
void *data, int poll_in, int poll_out)
{
int idx = -1;
GF_VALIDATE_OR_GOTO ("event", event_pool, out);
pthread_mutex_lock (&event_pool->mutex);
{
if (event_pool->count == event_pool->used)
{
event_pool->count += 256;
event_pool->reg = GF_REALLOC (event_pool->reg,
event_pool->count *
sizeof (*event_pool->reg));
if (!event_pool->reg)
goto unlock;
}
idx = event_pool->used++;
event_pool->reg[idx].fd = fd;
event_pool->reg[idx].events = POLLPRI;
event_pool->reg[idx].handler = handler;
event_pool->reg[idx].data = data;
switch (poll_in) {
case 1:
event_pool->reg[idx].events |= POLLIN;
break;
case 0:
event_pool->reg[idx].events &= ~POLLIN;
break;
case -1:
/* do nothing */
break;
default:
gf_msg ("poll", GF_LOG_ERROR, 0,
LG_MSG_INVALID_POLL_IN,
"invalid poll_in value %d", poll_in);
break;
}
switch (poll_out) {
case 1:
event_pool->reg[idx].events |= POLLOUT;
break;
case 0:
event_pool->reg[idx].events &= ~POLLOUT;
break;
case -1:
/* do nothing */
break;
default:
gf_msg ("poll", GF_LOG_ERROR, 0,
LG_MSG_INVALID_POLL_OUT,
"invalid poll_out value %d", poll_out);
break;
}
event_pool->changed = 1;
}
unlock:
pthread_mutex_unlock (&event_pool->mutex);
out:
return idx;
}
int
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;
struct epoll_event epoll_event = {0, };
struct event_data *ev_data = (void *)&epoll_event.data;
GF_VALIDATE_OR_GOTO ("event", event_pool, out);
pthread_mutex_lock (&event_pool->mutex);
{
if (event_pool->count == event_pool->used) {
event_pool->count *= 2;
event_pool->reg = GF_REALLOC (event_pool->reg,
event_pool->count *
sizeof (*event_pool->reg));
if (!event_pool->reg) {
gf_log ("epoll", GF_LOG_ERROR,
"event registry re-allocation failed");
goto unlock;
}
}
idx = event_pool->used;
event_pool->used++;
event_pool->reg[idx].fd = fd;
event_pool->reg[idx].events = EPOLLPRI;
event_pool->reg[idx].handler = handler;
event_pool->reg[idx].data = data;
switch (poll_in) {
case 1:
event_pool->reg[idx].events |= EPOLLIN;
break;
case 0:
event_pool->reg[idx].events &= ~EPOLLIN;
break;
case -1:
/* do nothing */
break;
default:
gf_log ("epoll", GF_LOG_ERROR,
"invalid poll_in value %d", poll_in);
break;
}
switch (poll_out) {
case 1:
event_pool->reg[idx].events |= EPOLLOUT;
break;
case 0:
event_pool->reg[idx].events &= ~EPOLLOUT;
break;
case -1:
/* do nothing */
break;
default:
gf_log ("epoll", GF_LOG_ERROR,
"invalid poll_out value %d", poll_out);
break;
}
event_pool->changed = 1;
epoll_event.events = event_pool->reg[idx].events;
ev_data->fd = fd;
ev_data->idx = idx;
ret = epoll_ctl (event_pool->fd, EPOLL_CTL_ADD, fd,
&epoll_event);
if (ret == -1) {
gf_log ("epoll", GF_LOG_ERROR,
"failed to add fd(=%d) to epoll fd(=%d) (%s)",
fd, event_pool->fd, strerror (errno));
goto unlock;
}
pthread_cond_broadcast (&event_pool->cond);
}
unlock:
pthread_mutex_unlock (&event_pool->mutex);
out:
return ret;
}
