src/core/iomgr/pollset_posix.c

/*
 *
 * Copyright 2014, Google Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "src/core/iomgr/pollset_posix.h"

#include <errno.h>
#include <poll.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "src/core/iomgr/alarm_internal.h"
#include "src/core/iomgr/fd_posix.h"
#include "src/core/iomgr/iomgr_internal.h"
#include "src/core/iomgr/socket_utils_posix.h"
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/thd.h>
#include <grpc/support/useful.h>

/* kick pipes: we keep a sharded set of pipes to allow breaking from poll.
   Ideally this would be 1:1 with pollsets, but we'd like to avoid associating
   full kernel objects with each pollset to keep them lightweight, so instead
   keep a sharded set and allow associating a pollset with one of the shards.

   TODO(ctiller): move this out from this file, and allow an eventfd
                  implementation on linux */

#define LOG2_KICK_SHARDS 6
#define KICK_SHARDS (1 << LOG2_KICK_SHARDS)

static int g_kick_pipes[KICK_SHARDS][2];
static grpc_pollset g_backup_pollset;
static int g_shutdown_backup_poller;
static gpr_event g_backup_poller_done;

static void backup_poller(void *p) {
  gpr_timespec delta = gpr_time_from_millis(100);
  gpr_timespec last_poll = gpr_now();

  gpr_mu_lock(&g_backup_pollset.mu);
  while (g_shutdown_backup_poller == 0) {
    gpr_timespec next_poll = gpr_time_add(last_poll, delta);
    grpc_pollset_work(&g_backup_pollset, next_poll);
    gpr_mu_unlock(&g_backup_pollset.mu);
    gpr_sleep_until(next_poll);
    gpr_mu_lock(&g_backup_pollset.mu);
    last_poll = next_poll;
  }
  gpr_mu_unlock(&g_backup_pollset.mu);

  gpr_event_set(&g_backup_poller_done, (void *)1);
}

static size_t kick_shard(const grpc_pollset *info) {
  size_t x = (size_t)info;
  return ((x >> 4) ^ (x >> 9) ^ (x >> 14)) & (KICK_SHARDS - 1);
}

int grpc_kick_read_fd(grpc_pollset *p) {
  return g_kick_pipes[kick_shard(p)][0];
}

static int grpc_kick_write_fd(grpc_pollset *p) {
  return g_kick_pipes[kick_shard(p)][1];
}

void grpc_pollset_force_kick(grpc_pollset *p) {
  char c = 0;
  while (write(grpc_kick_write_fd(p), &c, 1) != 1 && errno == EINTR)
    ;
}

void grpc_pollset_kick(grpc_pollset *p) {
  if (!p->counter) return;
  grpc_pollset_force_kick(p);
}

void grpc_kick_drain(grpc_pollset *p) {
  int fd = grpc_kick_read_fd(p);
  char buf[128];
  int r;

  for (;;) {
    r = read(fd, buf, sizeof(buf));
    if (r > 0) continue;
    if (r == 0) return;
    switch (errno) {
      case EAGAIN:
        return;
      case EINTR:
        continue;
      default:
        gpr_log(GPR_ERROR, "error reading pipe: %s", strerror(errno));
        return;
    }
  }
}

/* global state management */

grpc_pollset *grpc_backup_pollset(void) { return &g_backup_pollset; }

void grpc_pollset_global_init(void) {
  int i;
  gpr_thd_id id;

  /* initialize the kick shards */
  for (i = 0; i < KICK_SHARDS; i++) {
    GPR_ASSERT(0 == pipe(g_kick_pipes[i]));
    GPR_ASSERT(grpc_set_socket_nonblocking(g_kick_pipes[i][0], 1));
    GPR_ASSERT(grpc_set_socket_nonblocking(g_kick_pipes[i][1], 1));
  }

  /* initialize the backup pollset */
  grpc_pollset_init(&g_backup_pollset);

  /* start the backup poller thread */
  g_shutdown_backup_poller = 0;
  gpr_event_init(&g_backup_poller_done);
  gpr_thd_new(&id, backup_poller, NULL, NULL);
}

void grpc_pollset_global_shutdown(void) {
  int i;

  /* terminate the backup poller thread */
  gpr_mu_lock(&g_backup_pollset.mu);
  g_shutdown_backup_poller = 1;
  gpr_mu_unlock(&g_backup_pollset.mu);
  gpr_event_wait(&g_backup_poller_done, gpr_inf_future);

  /* destroy the backup pollset */
  grpc_pollset_destroy(&g_backup_pollset);

  /* destroy the kick shards */
  for (i = 0; i < KICK_SHARDS; i++) {
    close(g_kick_pipes[i][0]);
    close(g_kick_pipes[i][1]);
  }
}

/* main interface */

static void become_empty_pollset(grpc_pollset *pollset);
static void become_unary_pollset(grpc_pollset *pollset, grpc_fd *fd);

void grpc_pollset_init(grpc_pollset *pollset) {
  gpr_mu_init(&pollset->mu);
  gpr_cv_init(&pollset->cv);
  become_empty_pollset(pollset);
}

void grpc_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd) {
  gpr_mu_lock(&pollset->mu);
  pollset->vtable->add_fd(pollset, fd);
  gpr_cv_broadcast(&pollset->cv);
  gpr_mu_unlock(&pollset->mu);
}

void grpc_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd) {
  gpr_mu_lock(&pollset->mu);
  pollset->vtable->del_fd(pollset, fd);
  gpr_cv_broadcast(&pollset->cv);
  gpr_mu_unlock(&pollset->mu);
}

int grpc_pollset_work(grpc_pollset *pollset, gpr_timespec deadline) {
  /* pollset->mu already held */
  gpr_timespec now;
  now = gpr_now();
  if (gpr_time_cmp(now, deadline) > 0) {
    return 0;
  }
  if (grpc_maybe_call_delayed_callbacks(&pollset->mu, 1)) {
    return 1;
  }
  if (grpc_alarm_check(&pollset->mu, now, &deadline)) {
    return 1;
  }
  return pollset->vtable->maybe_work(pollset, deadline, now, 1);
}

void grpc_pollset_destroy(grpc_pollset *pollset) {
  pollset->vtable->destroy(pollset);
  gpr_mu_destroy(&pollset->mu);
  gpr_cv_destroy(&pollset->cv);
}

/*
 * empty_pollset - a vtable that provides polling for NO file descriptors
 */

static void empty_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd) {
  become_unary_pollset(pollset, fd);
}

static void empty_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd) {}

static int empty_pollset_maybe_work(grpc_pollset *pollset,
                                    gpr_timespec deadline, gpr_timespec now,
                                    int allow_synchronous_callback) {
  return 0;
}

static void empty_pollset_destroy(grpc_pollset *pollset) {}

static const grpc_pollset_vtable empty_pollset = {
    empty_pollset_add_fd, empty_pollset_del_fd, empty_pollset_maybe_work,
    empty_pollset_destroy};

static void become_empty_pollset(grpc_pollset *pollset) {
  pollset->vtable = &empty_pollset;
}

/*
 * unary_poll_pollset - a vtable that provides polling for one file descriptor
 *                      via poll()
 */

static void unary_poll_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd) {
  grpc_fd *fds[2];
  if (fd == pollset->data.ptr) return;
  fds[0] = pollset->data.ptr;
  fds[1] = fd;
  grpc_platform_become_multipoller(pollset, fds, GPR_ARRAY_SIZE(fds));
  grpc_fd_unref(fds[0]);
}

static void unary_poll_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd) {
  if (fd == pollset->data.ptr) {
    grpc_fd_unref(pollset->data.ptr);
    become_empty_pollset(pollset);
  }
}

static int unary_poll_pollset_maybe_work(grpc_pollset *pollset,
                                         gpr_timespec deadline,
                                         gpr_timespec now,
                                         int allow_synchronous_callback) {
  struct pollfd pfd[2];
  grpc_fd *fd;
  int timeout;
  int r;

  if (pollset->counter) {
    return 0;
  }
  fd = pollset->data.ptr;
  if (grpc_fd_is_orphaned(fd)) {
    grpc_fd_unref(fd);
    become_empty_pollset(pollset);
    return 0;
  }
  if (gpr_time_cmp(deadline, gpr_inf_future) == 0) {
    timeout = -1;
  } else {
    timeout = gpr_time_to_millis(gpr_time_sub(deadline, now));
    if (timeout <= 0) {
      return 1;
    }
  }
  pfd[0].fd = grpc_kick_read_fd(pollset);
  pfd[0].events = POLLIN;
  pfd[0].revents = 0;
  pfd[1].fd = fd->fd;
  pfd[1].events = grpc_fd_begin_poll(fd, pollset, POLLIN, POLLOUT);
  pfd[1].revents = 0;
  pollset->counter = 1;
  gpr_mu_unlock(&pollset->mu);

  r = poll(pfd, GPR_ARRAY_SIZE(pfd), timeout);
  if (r < 0) {
    if (errno != EINTR) {
      gpr_log(GPR_ERROR, "poll() failed: %s", strerror(errno));
    }
  } else if (r == 0) {
    /* do nothing */
  } else {
    if (pfd[0].revents & POLLIN) {
      grpc_kick_drain(pollset);
    }
    if (pfd[1].revents & POLLIN) {
      grpc_fd_become_readable(fd, allow_synchronous_callback);
    }
    if (pfd[1].revents & POLLOUT) {
      grpc_fd_become_writable(fd, allow_synchronous_callback);
    }
  }

  gpr_mu_lock(&pollset->mu);
  grpc_fd_end_poll(fd, pollset);
  pollset->counter = 0;
  gpr_cv_broadcast(&pollset->cv);
  return 1;
}

static void unary_poll_pollset_destroy(grpc_pollset *pollset) {
  GPR_ASSERT(pollset->counter == 0);
  grpc_fd_unref(pollset->data.ptr);
}

static const grpc_pollset_vtable unary_poll_pollset = {
    unary_poll_pollset_add_fd, unary_poll_pollset_del_fd,
    unary_poll_pollset_maybe_work, unary_poll_pollset_destroy};

static void become_unary_pollset(grpc_pollset *pollset, grpc_fd *fd) {
  pollset->vtable = &unary_poll_pollset;
  pollset->counter = 0;
  pollset->data.ptr = fd;
  grpc_fd_ref(fd);
}