aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/core/lib/iomgr/ev_epollsig_linux.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/lib/iomgr/ev_epollsig_linux.cc')
-rw-r--r--src/core/lib/iomgr/ev_epollsig_linux.cc409
1 files changed, 205 insertions, 204 deletions
diff --git a/src/core/lib/iomgr/ev_epollsig_linux.cc b/src/core/lib/iomgr/ev_epollsig_linux.cc
index 035bdc4cb5..d5f3122abc 100644
--- a/src/core/lib/iomgr/ev_epollsig_linux.cc
+++ b/src/core/lib/iomgr/ev_epollsig_linux.cc
@@ -51,7 +51,7 @@
#include "src/core/lib/iomgr/wakeup_fd_posix.h"
#include "src/core/lib/profiling/timers.h"
-#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker *)1)
+#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
#define GRPC_POLLING_TRACE(...) \
if (GRPC_TRACER_ON(grpc_polling_trace)) { \
@@ -90,10 +90,10 @@ typedef struct poll_obj {
poll_obj_type obj_type;
#endif
gpr_mu mu;
- struct polling_island *pi;
+ struct polling_island* pi;
} poll_obj;
-const char *poll_obj_string(poll_obj_type po_type) {
+const char* poll_obj_string(poll_obj_type po_type) {
switch (po_type) {
case POLL_OBJ_FD:
return "fd";
@@ -106,11 +106,11 @@ const char *poll_obj_string(poll_obj_type po_type) {
GPR_UNREACHABLE_CODE(return "UNKNOWN");
}
-/*******************************************************************************
- * Fd Declarations
- */
+ /*******************************************************************************
+ * Fd Declarations
+ */
-#define FD_FROM_PO(po) ((grpc_fd *)(po))
+#define FD_FROM_PO(po) ((grpc_fd*)(po))
struct grpc_fd {
poll_obj po;
@@ -130,8 +130,8 @@ struct grpc_fd {
gpr_atm read_closure;
gpr_atm write_closure;
- struct grpc_fd *freelist_next;
- grpc_closure *on_done_closure;
+ struct grpc_fd* freelist_next;
+ grpc_closure* on_done_closure;
/* The pollset that last noticed that the fd is readable. The actual type
* stored in this is (grpc_pollset *) */
@@ -142,14 +142,14 @@ struct grpc_fd {
/* Reference counting for fds */
#ifndef NDEBUG
-static void fd_ref(grpc_fd *fd, const char *reason, const char *file, int line);
-static void fd_unref(grpc_fd *fd, const char *reason, const char *file,
+static void fd_ref(grpc_fd* fd, const char* reason, const char* file, int line);
+static void fd_unref(grpc_fd* fd, const char* reason, const char* file,
int line);
#define GRPC_FD_REF(fd, reason) fd_ref(fd, reason, __FILE__, __LINE__)
#define GRPC_FD_UNREF(fd, reason) fd_unref(fd, reason, __FILE__, __LINE__)
#else
-static void fd_ref(grpc_fd *fd);
-static void fd_unref(grpc_fd *fd);
+static void fd_ref(grpc_fd* fd);
+static void fd_unref(grpc_fd* fd);
#define GRPC_FD_REF(fd, reason) fd_ref(fd)
#define GRPC_FD_UNREF(fd, reason) fd_unref(fd)
#endif
@@ -203,7 +203,7 @@ typedef struct polling_island {
/* The file descriptors in the epoll set */
size_t fd_cnt;
size_t fd_capacity;
- grpc_fd **fds;
+ grpc_fd** fds;
} polling_island;
/*******************************************************************************
@@ -215,8 +215,8 @@ struct grpc_pollset_worker {
/* Used to prevent a worker from getting kicked multiple times */
gpr_atm is_kicked;
- struct grpc_pollset_worker *next;
- struct grpc_pollset_worker *prev;
+ struct grpc_pollset_worker* next;
+ struct grpc_pollset_worker* prev;
};
struct grpc_pollset {
@@ -227,7 +227,7 @@ struct grpc_pollset {
bool shutting_down; /* Is the pollset shutting down ? */
bool finish_shutdown_called; /* Is the 'finish_shutdown_locked()' called ? */
- grpc_closure *shutdown_done; /* Called after after shutdown is complete */
+ grpc_closure* shutdown_done; /* Called after after shutdown is complete */
};
/*******************************************************************************
@@ -241,8 +241,8 @@ struct grpc_pollset_set {
* Common helpers
*/
-static bool append_error(grpc_error **composite, grpc_error *error,
- const char *desc) {
+static bool append_error(grpc_error** composite, grpc_error* error,
+ const char* desc) {
if (error == GRPC_ERROR_NONE) return true;
if (*composite == GRPC_ERROR_NONE) {
*composite = GRPC_ERROR_CREATE_FROM_COPIED_STRING(desc);
@@ -266,10 +266,10 @@ static grpc_wakeup_fd polling_island_wakeup_fd;
/* The polling island being polled right now.
See comments in workqueue_maybe_wakeup for why this is tracked. */
-static __thread polling_island *g_current_thread_polling_island;
+static __thread polling_island* g_current_thread_polling_island;
/* Forward declaration */
-static void polling_island_delete(grpc_exec_ctx *exec_ctx, polling_island *pi);
+static void polling_island_delete(grpc_exec_ctx* exec_ctx, polling_island* pi);
#ifdef GRPC_TSAN
/* Currently TSAN may incorrectly flag data races between epoll_ctl and
@@ -282,38 +282,40 @@ static void polling_island_delete(grpc_exec_ctx *exec_ctx, polling_island *pi);
gpr_atm g_epoll_sync;
#endif /* defined(GRPC_TSAN) */
-static void pi_add_ref(polling_island *pi);
-static void pi_unref(grpc_exec_ctx *exec_ctx, polling_island *pi);
+static void pi_add_ref(polling_island* pi);
+static void pi_unref(grpc_exec_ctx* exec_ctx, polling_island* pi);
#ifndef NDEBUG
-static void pi_add_ref_dbg(polling_island *pi, const char *reason,
- const char *file, int line) {
+static void pi_add_ref_dbg(polling_island* pi, const char* reason,
+ const char* file, int line) {
if (GRPC_TRACER_ON(grpc_polling_trace)) {
gpr_atm old_cnt = gpr_atm_acq_load(&pi->ref_count);
- gpr_log(GPR_DEBUG, "Add ref pi: %p, old:%" PRIdPTR " -> new:%" PRIdPTR
- " (%s) - (%s, %d)",
+ gpr_log(GPR_DEBUG,
+ "Add ref pi: %p, old:%" PRIdPTR " -> new:%" PRIdPTR
+ " (%s) - (%s, %d)",
pi, old_cnt, old_cnt + 1, reason, file, line);
}
pi_add_ref(pi);
}
-static void pi_unref_dbg(grpc_exec_ctx *exec_ctx, polling_island *pi,
- const char *reason, const char *file, int line) {
+static void pi_unref_dbg(grpc_exec_ctx* exec_ctx, polling_island* pi,
+ const char* reason, const char* file, int line) {
if (GRPC_TRACER_ON(grpc_polling_trace)) {
gpr_atm old_cnt = gpr_atm_acq_load(&pi->ref_count);
- gpr_log(GPR_DEBUG, "Unref pi: %p, old:%" PRIdPTR " -> new:%" PRIdPTR
- " (%s) - (%s, %d)",
+ gpr_log(GPR_DEBUG,
+ "Unref pi: %p, old:%" PRIdPTR " -> new:%" PRIdPTR
+ " (%s) - (%s, %d)",
pi, old_cnt, (old_cnt - 1), reason, file, line);
}
pi_unref(exec_ctx, pi);
}
#endif
-static void pi_add_ref(polling_island *pi) {
+static void pi_add_ref(polling_island* pi) {
gpr_atm_no_barrier_fetch_add(&pi->ref_count, 1);
}
-static void pi_unref(grpc_exec_ctx *exec_ctx, polling_island *pi) {
+static void pi_unref(grpc_exec_ctx* exec_ctx, polling_island* pi) {
/* If ref count went to zero, delete the polling island.
Note that this deletion not be done under a lock. Once the ref count goes
to zero, we are guaranteed that no one else holds a reference to the
@@ -323,7 +325,7 @@ static void pi_unref(grpc_exec_ctx *exec_ctx, polling_island *pi) {
non-empty, we should remove a ref to the merged_to polling island
*/
if (1 == gpr_atm_full_fetch_add(&pi->ref_count, -1)) {
- polling_island *next = (polling_island *)gpr_atm_acq_load(&pi->merged_to);
+ polling_island* next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
polling_island_delete(exec_ctx, pi);
if (next != NULL) {
PI_UNREF(exec_ctx, next, "pi_delete"); /* Recursive call */
@@ -332,14 +334,14 @@ static void pi_unref(grpc_exec_ctx *exec_ctx, polling_island *pi) {
}
/* The caller is expected to hold pi->mu lock before calling this function */
-static void polling_island_add_fds_locked(polling_island *pi, grpc_fd **fds,
+static void polling_island_add_fds_locked(polling_island* pi, grpc_fd** fds,
size_t fd_count, bool add_fd_refs,
- grpc_error **error) {
+ grpc_error** error) {
int err;
size_t i;
struct epoll_event ev;
- char *err_msg;
- const char *err_desc = "polling_island_add_fds";
+ char* err_msg;
+ const char* err_desc = "polling_island_add_fds";
#ifdef GRPC_TSAN
/* See the definition of g_epoll_sync for more context */
@@ -367,7 +369,7 @@ static void polling_island_add_fds_locked(polling_island *pi, grpc_fd **fds,
if (pi->fd_cnt == pi->fd_capacity) {
pi->fd_capacity = GPR_MAX(pi->fd_capacity + 8, pi->fd_cnt * 3 / 2);
pi->fds =
- (grpc_fd **)gpr_realloc(pi->fds, sizeof(grpc_fd *) * pi->fd_capacity);
+ (grpc_fd**)gpr_realloc(pi->fds, sizeof(grpc_fd*) * pi->fd_capacity);
}
pi->fds[pi->fd_cnt++] = fds[i];
@@ -378,13 +380,13 @@ static void polling_island_add_fds_locked(polling_island *pi, grpc_fd **fds,
}
/* The caller is expected to hold pi->mu before calling this */
-static void polling_island_add_wakeup_fd_locked(polling_island *pi,
- grpc_wakeup_fd *wakeup_fd,
- grpc_error **error) {
+static void polling_island_add_wakeup_fd_locked(polling_island* pi,
+ grpc_wakeup_fd* wakeup_fd,
+ grpc_error** error) {
struct epoll_event ev;
int err;
- char *err_msg;
- const char *err_desc = "polling_island_add_wakeup_fd";
+ char* err_msg;
+ const char* err_desc = "polling_island_add_wakeup_fd";
ev.events = (uint32_t)(EPOLLIN | EPOLLET);
ev.data.ptr = wakeup_fd;
@@ -402,13 +404,13 @@ static void polling_island_add_wakeup_fd_locked(polling_island *pi,
}
/* The caller is expected to hold pi->mu lock before calling this function */
-static void polling_island_remove_all_fds_locked(polling_island *pi,
+static void polling_island_remove_all_fds_locked(polling_island* pi,
bool remove_fd_refs,
- grpc_error **error) {
+ grpc_error** error) {
int err;
size_t i;
- char *err_msg;
- const char *err_desc = "polling_island_remove_fds";
+ char* err_msg;
+ const char* err_desc = "polling_island_remove_fds";
for (i = 0; i < pi->fd_cnt; i++) {
err = epoll_ctl(pi->epoll_fd, EPOLL_CTL_DEL, pi->fds[i]->fd, NULL);
@@ -430,13 +432,13 @@ static void polling_island_remove_all_fds_locked(polling_island *pi,
}
/* The caller is expected to hold pi->mu lock before calling this function */
-static void polling_island_remove_fd_locked(polling_island *pi, grpc_fd *fd,
+static void polling_island_remove_fd_locked(polling_island* pi, grpc_fd* fd,
bool is_fd_closed,
- grpc_error **error) {
+ grpc_error** error) {
int err;
size_t i;
- char *err_msg;
- const char *err_desc = "polling_island_remove_fd";
+ char* err_msg;
+ const char* err_desc = "polling_island_remove_fd";
/* If fd is already closed, then it would have been automatically been removed
from the epoll set */
@@ -462,15 +464,15 @@ static void polling_island_remove_fd_locked(polling_island *pi, grpc_fd *fd,
}
/* Might return NULL in case of an error */
-static polling_island *polling_island_create(grpc_exec_ctx *exec_ctx,
- grpc_fd *initial_fd,
- grpc_error **error) {
- polling_island *pi = NULL;
- const char *err_desc = "polling_island_create";
+static polling_island* polling_island_create(grpc_exec_ctx* exec_ctx,
+ grpc_fd* initial_fd,
+ grpc_error** error) {
+ polling_island* pi = NULL;
+ const char* err_desc = "polling_island_create";
*error = GRPC_ERROR_NONE;
- pi = (polling_island *)gpr_malloc(sizeof(*pi));
+ pi = (polling_island*)gpr_malloc(sizeof(*pi));
gpr_mu_init(&pi->mu);
pi->fd_cnt = 0;
pi->fd_capacity = 0;
@@ -500,7 +502,7 @@ done:
return pi;
}
-static void polling_island_delete(grpc_exec_ctx *exec_ctx, polling_island *pi) {
+static void polling_island_delete(grpc_exec_ctx* exec_ctx, polling_island* pi) {
GPR_ASSERT(pi->fd_cnt == 0);
if (pi->epoll_fd >= 0) {
@@ -514,11 +516,11 @@ static void polling_island_delete(grpc_exec_ctx *exec_ctx, polling_island *pi) {
/* Attempts to gets the last polling island in the linked list (liked by the
* 'merged_to' field). Since this does not lock the polling island, there are no
* guarantees that the island returned is the last island */
-static polling_island *polling_island_maybe_get_latest(polling_island *pi) {
- polling_island *next = (polling_island *)gpr_atm_acq_load(&pi->merged_to);
+static polling_island* polling_island_maybe_get_latest(polling_island* pi) {
+ polling_island* next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
while (next != NULL) {
pi = next;
- next = (polling_island *)gpr_atm_acq_load(&pi->merged_to);
+ next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
}
return pi;
@@ -533,18 +535,18 @@ static polling_island *polling_island_maybe_get_latest(polling_island *pi) {
... critical section ..
...
gpr_mu_unlock(&pi_latest->mu); // NOTE: use pi_latest->mu. NOT pi->mu */
-static polling_island *polling_island_lock(polling_island *pi) {
- polling_island *next = NULL;
+static polling_island* polling_island_lock(polling_island* pi) {
+ polling_island* next = NULL;
while (true) {
- next = (polling_island *)gpr_atm_acq_load(&pi->merged_to);
+ next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
if (next == NULL) {
/* Looks like 'pi' is the last node in the linked list but unless we check
this by holding the pi->mu lock, we cannot be sure (i.e without the
pi->mu lock, we don't prevent island merges).
To be absolutely sure, check once more by holding the pi->mu lock */
gpr_mu_lock(&pi->mu);
- next = (polling_island *)gpr_atm_acq_load(&pi->merged_to);
+ next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
if (next == NULL) {
/* pi is infact the last node and we have the pi->mu lock. we're done */
break;
@@ -582,11 +584,11 @@ static polling_island *polling_island_lock(polling_island *pi) {
// Release locks: Always call polling_island_unlock_pair() to release locks
polling_island_unlock_pair(p1, p2);
*/
-static void polling_island_lock_pair(polling_island **p, polling_island **q) {
- polling_island *pi_1 = *p;
- polling_island *pi_2 = *q;
- polling_island *next_1 = NULL;
- polling_island *next_2 = NULL;
+static void polling_island_lock_pair(polling_island** p, polling_island** q) {
+ polling_island* pi_1 = *p;
+ polling_island* pi_2 = *q;
+ polling_island* next_1 = NULL;
+ polling_island* next_2 = NULL;
/* The algorithm is simple:
- Go to the last polling islands in the linked lists *pi_1 and *pi_2 (and
@@ -603,16 +605,16 @@ static void polling_island_lock_pair(polling_island **p, polling_island **q) {
- If the polling islands are the last islands, we are done. If not,
release the locks and continue the process from the first step */
while (true) {
- next_1 = (polling_island *)gpr_atm_acq_load(&pi_1->merged_to);
+ next_1 = (polling_island*)gpr_atm_acq_load(&pi_1->merged_to);
while (next_1 != NULL) {
pi_1 = next_1;
- next_1 = (polling_island *)gpr_atm_acq_load(&pi_1->merged_to);
+ next_1 = (polling_island*)gpr_atm_acq_load(&pi_1->merged_to);
}
- next_2 = (polling_island *)gpr_atm_acq_load(&pi_2->merged_to);
+ next_2 = (polling_island*)gpr_atm_acq_load(&pi_2->merged_to);
while (next_2 != NULL) {
pi_2 = next_2;
- next_2 = (polling_island *)gpr_atm_acq_load(&pi_2->merged_to);
+ next_2 = (polling_island*)gpr_atm_acq_load(&pi_2->merged_to);
}
if (pi_1 == pi_2) {
@@ -628,8 +630,8 @@ static void polling_island_lock_pair(polling_island **p, polling_island **q) {
gpr_mu_lock(&pi_1->mu);
}
- next_1 = (polling_island *)gpr_atm_acq_load(&pi_1->merged_to);
- next_2 = (polling_island *)gpr_atm_acq_load(&pi_2->merged_to);
+ next_1 = (polling_island*)gpr_atm_acq_load(&pi_1->merged_to);
+ next_2 = (polling_island*)gpr_atm_acq_load(&pi_2->merged_to);
if (next_1 == NULL && next_2 == NULL) {
break;
}
@@ -642,7 +644,7 @@ static void polling_island_lock_pair(polling_island **p, polling_island **q) {
*q = pi_2;
}
-static void polling_island_unlock_pair(polling_island *p, polling_island *q) {
+static void polling_island_unlock_pair(polling_island* p, polling_island* q) {
if (p == q) {
gpr_mu_unlock(&p->mu);
} else {
@@ -651,16 +653,16 @@ static void polling_island_unlock_pair(polling_island *p, polling_island *q) {
}
}
-static polling_island *polling_island_merge(polling_island *p,
- polling_island *q,
- grpc_error **error) {
+static polling_island* polling_island_merge(polling_island* p,
+ polling_island* q,
+ grpc_error** error) {
/* Get locks on both the polling islands */
polling_island_lock_pair(&p, &q);
if (p != q) {
/* Make sure that p points to the polling island with fewer fds than q */
if (p->fd_cnt > q->fd_cnt) {
- GPR_SWAP(polling_island *, p, q);
+ GPR_SWAP(polling_island*, p, q);
}
/* Merge p with q i.e move all the fds from p (The one with fewer fds) to q
@@ -685,8 +687,8 @@ static polling_island *polling_island_merge(polling_island *p,
return q;
}
-static grpc_error *polling_island_global_init() {
- grpc_error *error = GRPC_ERROR_NONE;
+static grpc_error* polling_island_global_init() {
+ grpc_error* error = GRPC_ERROR_NONE;
error = grpc_wakeup_fd_init(&polling_island_wakeup_fd);
if (error == GRPC_ERROR_NONE) {
@@ -722,13 +724,13 @@ static void polling_island_global_shutdown() {
* alarm 'epoch'). This wakeup_fd gives us something to alert on when such a
* case occurs. */
-static grpc_fd *fd_freelist = NULL;
+static grpc_fd* fd_freelist = NULL;
static gpr_mu fd_freelist_mu;
#ifndef NDEBUG
#define REF_BY(fd, n, reason) ref_by(fd, n, reason, __FILE__, __LINE__)
#define UNREF_BY(fd, n, reason) unref_by(fd, n, reason, __FILE__, __LINE__)
-static void ref_by(grpc_fd *fd, int n, const char *reason, const char *file,
+static void ref_by(grpc_fd* fd, int n, const char* reason, const char* file,
int line) {
if (GRPC_TRACER_ON(grpc_trace_fd_refcount)) {
gpr_log(GPR_DEBUG,
@@ -739,13 +741,13 @@ static void ref_by(grpc_fd *fd, int n, const char *reason, const char *file,
#else
#define REF_BY(fd, n, reason) ref_by(fd, n)
#define UNREF_BY(fd, n, reason) unref_by(fd, n)
-static void ref_by(grpc_fd *fd, int n) {
+static void ref_by(grpc_fd* fd, int n) {
#endif
GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&fd->refst, n) > 0);
}
#ifndef NDEBUG
-static void unref_by(grpc_fd *fd, int n, const char *reason, const char *file,
+static void unref_by(grpc_fd* fd, int n, const char* reason, const char* file,
int line) {
if (GRPC_TRACER_ON(grpc_trace_fd_refcount)) {
gpr_log(GPR_DEBUG,
@@ -754,7 +756,7 @@ static void unref_by(grpc_fd *fd, int n, const char *reason, const char *file,
gpr_atm_no_barrier_load(&fd->refst) - n, reason, file, line);
}
#else
-static void unref_by(grpc_fd *fd, int n) {
+static void unref_by(grpc_fd* fd, int n) {
#endif
gpr_atm old = gpr_atm_full_fetch_add(&fd->refst, -n);
if (old == n) {
@@ -775,18 +777,18 @@ static void unref_by(grpc_fd *fd, int n) {
/* Increment refcount by two to avoid changing the orphan bit */
#ifndef NDEBUG
-static void fd_ref(grpc_fd *fd, const char *reason, const char *file,
+static void fd_ref(grpc_fd* fd, const char* reason, const char* file,
int line) {
ref_by(fd, 2, reason, file, line);
}
-static void fd_unref(grpc_fd *fd, const char *reason, const char *file,
+static void fd_unref(grpc_fd* fd, const char* reason, const char* file,
int line) {
unref_by(fd, 2, reason, file, line);
}
#else
-static void fd_ref(grpc_fd *fd) { ref_by(fd, 2); }
-static void fd_unref(grpc_fd *fd) { unref_by(fd, 2); }
+static void fd_ref(grpc_fd* fd) { ref_by(fd, 2); }
+static void fd_unref(grpc_fd* fd) { unref_by(fd, 2); }
#endif
static void fd_global_init(void) { gpr_mu_init(&fd_freelist_mu); }
@@ -795,7 +797,7 @@ static void fd_global_shutdown(void) {
gpr_mu_lock(&fd_freelist_mu);
gpr_mu_unlock(&fd_freelist_mu);
while (fd_freelist != NULL) {
- grpc_fd *fd = fd_freelist;
+ grpc_fd* fd = fd_freelist;
fd_freelist = fd_freelist->freelist_next;
gpr_mu_destroy(&fd->po.mu);
gpr_free(fd);
@@ -803,8 +805,8 @@ static void fd_global_shutdown(void) {
gpr_mu_destroy(&fd_freelist_mu);
}
-static grpc_fd *fd_create(int fd, const char *name) {
- grpc_fd *new_fd = NULL;
+static grpc_fd* fd_create(int fd, const char* name) {
+ grpc_fd* new_fd = NULL;
gpr_mu_lock(&fd_freelist_mu);
if (fd_freelist != NULL) {
@@ -814,7 +816,7 @@ static grpc_fd *fd_create(int fd, const char *name) {
gpr_mu_unlock(&fd_freelist_mu);
if (new_fd == NULL) {
- new_fd = (grpc_fd *)gpr_malloc(sizeof(grpc_fd));
+ new_fd = (grpc_fd*)gpr_malloc(sizeof(grpc_fd));
gpr_mu_init(&new_fd->po.mu);
}
@@ -839,14 +841,14 @@ static grpc_fd *fd_create(int fd, const char *name) {
gpr_mu_unlock(&new_fd->po.mu);
- char *fd_name;
+ char* fd_name;
gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name);
gpr_free(fd_name);
return new_fd;
}
-static int fd_wrapped_fd(grpc_fd *fd) {
+static int fd_wrapped_fd(grpc_fd* fd) {
int ret_fd = -1;
gpr_mu_lock(&fd->po.mu);
if (!fd->orphaned) {
@@ -857,11 +859,11 @@ static int fd_wrapped_fd(grpc_fd *fd) {
return ret_fd;
}
-static void fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
- grpc_closure *on_done, int *release_fd,
- bool already_closed, const char *reason) {
- grpc_error *error = GRPC_ERROR_NONE;
- polling_island *unref_pi = NULL;
+static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+ grpc_closure* on_done, int* release_fd,
+ bool already_closed, const char* reason) {
+ grpc_error* error = GRPC_ERROR_NONE;
+ polling_island* unref_pi = NULL;
gpr_mu_lock(&fd->po.mu);
fd->on_done_closure = on_done;
@@ -879,7 +881,7 @@ static void fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
- Set fd->po.pi to NULL (but remove the ref on the polling island
before doing this.) */
if (fd->po.pi != NULL) {
- polling_island *pi_latest = polling_island_lock(fd->po.pi);
+ polling_island* pi_latest = polling_island_lock(fd->po.pi);
polling_island_remove_fd_locked(pi_latest, fd, already_closed, &error);
gpr_mu_unlock(&pi_latest->mu);
@@ -909,24 +911,24 @@ static void fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
PI_UNREF(exec_ctx, unref_pi, "fd_orphan");
}
if (error != GRPC_ERROR_NONE) {
- const char *msg = grpc_error_string(error);
+ const char* msg = grpc_error_string(error);
gpr_log(GPR_DEBUG, "fd_orphan: %s", msg);
}
GRPC_ERROR_UNREF(error);
}
-static grpc_pollset *fd_get_read_notifier_pollset(grpc_exec_ctx *exec_ctx,
- grpc_fd *fd) {
+static grpc_pollset* fd_get_read_notifier_pollset(grpc_exec_ctx* exec_ctx,
+ grpc_fd* fd) {
gpr_atm notifier = gpr_atm_acq_load(&fd->read_notifier_pollset);
- return (grpc_pollset *)notifier;
+ return (grpc_pollset*)notifier;
}
-static bool fd_is_shutdown(grpc_fd *fd) {
+static bool fd_is_shutdown(grpc_fd* fd) {
return grpc_lfev_is_shutdown(&fd->read_closure);
}
/* Might be called multiple times */
-static void fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {
+static void fd_shutdown(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_error* why) {
if (grpc_lfev_set_shutdown(exec_ctx, &fd->read_closure,
GRPC_ERROR_REF(why))) {
shutdown(fd->fd, SHUT_RDWR);
@@ -935,13 +937,13 @@ static void fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {
GRPC_ERROR_UNREF(why);
}
-static void fd_notify_on_read(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
- grpc_closure *closure) {
+static void fd_notify_on_read(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+ grpc_closure* closure) {
grpc_lfev_notify_on(exec_ctx, &fd->read_closure, closure, "read");
}
-static void fd_notify_on_write(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
- grpc_closure *closure) {
+static void fd_notify_on_write(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+ grpc_closure* closure) {
grpc_lfev_notify_on(exec_ctx, &fd->write_closure, closure, "write");
}
@@ -962,7 +964,7 @@ static void sig_handler(int sig_num) {
static void poller_kick_init() { signal(grpc_wakeup_signal, sig_handler); }
/* Global state management */
-static grpc_error *pollset_global_init(void) {
+static grpc_error* pollset_global_init(void) {
gpr_tls_init(&g_current_thread_pollset);
gpr_tls_init(&g_current_thread_worker);
poller_kick_init();
@@ -974,14 +976,14 @@ static void pollset_global_shutdown(void) {
gpr_tls_destroy(&g_current_thread_worker);
}
-static grpc_error *pollset_worker_kick(grpc_pollset_worker *worker) {
- grpc_error *err = GRPC_ERROR_NONE;
+static grpc_error* pollset_worker_kick(grpc_pollset_worker* worker) {
+ grpc_error* err = GRPC_ERROR_NONE;
/* Kick the worker only if it was not already kicked */
if (gpr_atm_no_barrier_cas(&worker->is_kicked, (gpr_atm)0, (gpr_atm)1)) {
GRPC_POLLING_TRACE(
"pollset_worker_kick: Kicking worker: %p (thread id: %ld)",
- (void *)worker, (long int)worker->pt_id);
+ (void*)worker, (long int)worker->pt_id);
int err_num = pthread_kill(worker->pt_id, grpc_wakeup_signal);
if (err_num != 0) {
err = GRPC_OS_ERROR(err_num, "pthread_kill");
@@ -992,18 +994,18 @@ static grpc_error *pollset_worker_kick(grpc_pollset_worker *worker) {
/* Return 1 if the pollset has active threads in pollset_work (pollset must
* be locked) */
-static int pollset_has_workers(grpc_pollset *p) {
+static int pollset_has_workers(grpc_pollset* p) {
return p->root_worker.next != &p->root_worker;
}
-static void remove_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
+static void remove_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
worker->prev->next = worker->next;
worker->next->prev = worker->prev;
}
-static grpc_pollset_worker *pop_front_worker(grpc_pollset *p) {
+static grpc_pollset_worker* pop_front_worker(grpc_pollset* p) {
if (pollset_has_workers(p)) {
- grpc_pollset_worker *w = p->root_worker.next;
+ grpc_pollset_worker* w = p->root_worker.next;
remove_worker(p, w);
return w;
} else {
@@ -1011,26 +1013,26 @@ static grpc_pollset_worker *pop_front_worker(grpc_pollset *p) {
}
}
-static void push_back_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
+static void push_back_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
worker->next = &p->root_worker;
worker->prev = worker->next->prev;
worker->prev->next = worker->next->prev = worker;
}
-static void push_front_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
+static void push_front_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
worker->prev = &p->root_worker;
worker->next = worker->prev->next;
worker->prev->next = worker->next->prev = worker;
}
/* p->mu must be held before calling this function */
-static grpc_error *pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
- grpc_pollset_worker *specific_worker) {
+static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
+ grpc_pollset_worker* specific_worker) {
GPR_TIMER_BEGIN("pollset_kick", 0);
- grpc_error *error = GRPC_ERROR_NONE;
+ grpc_error* error = GRPC_ERROR_NONE;
GRPC_STATS_INC_POLLSET_KICK(exec_ctx);
- const char *err_desc = "Kick Failure";
- grpc_pollset_worker *worker = specific_worker;
+ const char* err_desc = "Kick Failure";
+ grpc_pollset_worker* worker = specific_worker;
if (worker != NULL) {
if (worker == GRPC_POLLSET_KICK_BROADCAST) {
if (pollset_has_workers(p)) {
@@ -1076,7 +1078,7 @@ static grpc_error *pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
return error;
}
-static void pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
+static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
gpr_mu_init(&pollset->po.mu);
*mu = &pollset->po.mu;
pollset->po.pi = NULL;
@@ -1092,7 +1094,7 @@ static void pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
pollset->shutdown_done = NULL;
}
-static int poll_deadline_to_millis_timeout(grpc_exec_ctx *exec_ctx,
+static int poll_deadline_to_millis_timeout(grpc_exec_ctx* exec_ctx,
grpc_millis millis) {
if (millis == GRPC_MILLIS_INF_FUTURE) return -1;
grpc_millis delta = millis - grpc_exec_ctx_now(exec_ctx);
@@ -1104,8 +1106,8 @@ static int poll_deadline_to_millis_timeout(grpc_exec_ctx *exec_ctx,
return (int)delta;
}
-static void fd_become_readable(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
- grpc_pollset *notifier) {
+static void fd_become_readable(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+ grpc_pollset* notifier) {
grpc_lfev_set_ready(exec_ctx, &fd->read_closure, "read");
/* Note, it is possible that fd_become_readable might be called twice with
@@ -1117,21 +1119,21 @@ static void fd_become_readable(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
gpr_atm_rel_store(&fd->read_notifier_pollset, (gpr_atm)notifier);
}
-static void fd_become_writable(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
+static void fd_become_writable(grpc_exec_ctx* exec_ctx, grpc_fd* fd) {
grpc_lfev_set_ready(exec_ctx, &fd->write_closure, "write");
}
-static void pollset_release_polling_island(grpc_exec_ctx *exec_ctx,
- grpc_pollset *ps,
- const char *reason) {
+static void pollset_release_polling_island(grpc_exec_ctx* exec_ctx,
+ grpc_pollset* ps,
+ const char* reason) {
if (ps->po.pi != NULL) {
PI_UNREF(exec_ctx, ps->po.pi, reason);
}
ps->po.pi = NULL;
}
-static void finish_shutdown_locked(grpc_exec_ctx *exec_ctx,
- grpc_pollset *pollset) {
+static void finish_shutdown_locked(grpc_exec_ctx* exec_ctx,
+ grpc_pollset* pollset) {
/* The pollset cannot have any workers if we are at this stage */
GPR_ASSERT(!pollset_has_workers(pollset));
@@ -1143,8 +1145,8 @@ static void finish_shutdown_locked(grpc_exec_ctx *exec_ctx,
}
/* pollset->po.mu lock must be held by the caller before calling this */
-static void pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
- grpc_closure *closure) {
+static void pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+ grpc_closure* closure) {
GPR_TIMER_BEGIN("pollset_shutdown", 0);
GPR_ASSERT(!pollset->shutting_down);
pollset->shutting_down = true;
@@ -1165,23 +1167,23 @@ static void pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
/* pollset_shutdown is guaranteed to be called before pollset_destroy. So other
* than destroying the mutexes, there is nothing special that needs to be done
* here */
-static void pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
+static void pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
GPR_ASSERT(!pollset_has_workers(pollset));
gpr_mu_destroy(&pollset->po.mu);
}
#define GRPC_EPOLL_MAX_EVENTS 100
/* Note: sig_mask contains the signal mask to use *during* epoll_wait() */
-static void pollset_work_and_unlock(grpc_exec_ctx *exec_ctx,
- grpc_pollset *pollset,
- grpc_pollset_worker *worker, int timeout_ms,
- sigset_t *sig_mask, grpc_error **error) {
+static void pollset_work_and_unlock(grpc_exec_ctx* exec_ctx,
+ grpc_pollset* pollset,
+ grpc_pollset_worker* worker, int timeout_ms,
+ sigset_t* sig_mask, grpc_error** error) {
struct epoll_event ep_ev[GRPC_EPOLL_MAX_EVENTS];
int epoll_fd = -1;
int ep_rv;
- polling_island *pi = NULL;
- char *err_msg;
- const char *err_desc = "pollset_work_and_unlock";
+ polling_island* pi = NULL;
+ char* err_msg;
+ const char* err_desc = "pollset_work_and_unlock";
GPR_TIMER_BEGIN("pollset_work_and_unlock", 0);
/* We need to get the epoll_fd to wait on. The epoll_fd is in inside the
@@ -1203,7 +1205,7 @@ static void pollset_work_and_unlock(grpc_exec_ctx *exec_ctx,
PI_ADD_REF(pollset->po.pi, "ps");
GRPC_POLLING_TRACE("pollset_work: pollset: %p created new pi: %p",
- (void *)pollset, (void *)pollset->po.pi);
+ (void*)pollset, (void*)pollset->po.pi);
}
pi = polling_island_maybe_get_latest(pollset->po.pi);
@@ -1243,7 +1245,7 @@ static void pollset_work_and_unlock(grpc_exec_ctx *exec_ctx,
/* We were interrupted. Save an interation by doing a zero timeout
epoll_wait to see if there are any other events of interest */
GRPC_POLLING_TRACE("pollset_work: pollset: %p, worker: %p received kick",
- (void *)pollset, (void *)worker);
+ (void*)pollset, (void*)worker);
ep_rv = epoll_wait(epoll_fd, ep_ev, GRPC_EPOLL_MAX_EVENTS, 0);
}
}
@@ -1254,18 +1256,18 @@ static void pollset_work_and_unlock(grpc_exec_ctx *exec_ctx,
#endif /* defined(GRPC_TSAN) */
for (int i = 0; i < ep_rv; ++i) {
- void *data_ptr = ep_ev[i].data.ptr;
+ void* data_ptr = ep_ev[i].data.ptr;
if (data_ptr == &polling_island_wakeup_fd) {
GRPC_POLLING_TRACE(
"pollset_work: pollset: %p, worker: %p polling island (epoll_fd: "
"%d) got merged",
- (void *)pollset, (void *)worker, epoll_fd);
+ (void*)pollset, (void*)worker, epoll_fd);
/* This means that our polling island is merged with a different
island. We do not have to do anything here since the subsequent call
to the function pollset_work_and_unlock() will pick up the correct
epoll_fd */
} else {
- grpc_fd *fd = (grpc_fd *)data_ptr;
+ grpc_fd* fd = (grpc_fd*)data_ptr;
int cancel = ep_ev[i].events & (EPOLLERR | EPOLLHUP);
int read_ev = ep_ev[i].events & (EPOLLIN | EPOLLPRI);
int write_ev = ep_ev[i].events & EPOLLOUT;
@@ -1297,11 +1299,11 @@ static void pollset_work_and_unlock(grpc_exec_ctx *exec_ctx,
The function pollset_work() may temporarily release the lock (pollset->po.mu)
during the course of its execution but it will always re-acquire the lock and
ensure that it is held by the time the function returns */
-static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
- grpc_pollset_worker **worker_hdl,
+static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+ grpc_pollset_worker** worker_hdl,
grpc_millis deadline) {
GPR_TIMER_BEGIN("pollset_work", 0);
- grpc_error *error = GRPC_ERROR_NONE;
+ grpc_error* error = GRPC_ERROR_NONE;
int timeout_ms = poll_deadline_to_millis_timeout(exec_ctx, deadline);
sigset_t new_mask;
@@ -1400,8 +1402,8 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
return error;
}
-static void add_poll_object(grpc_exec_ctx *exec_ctx, poll_obj *bag,
- poll_obj_type bag_type, poll_obj *item,
+static void add_poll_object(grpc_exec_ctx* exec_ctx, poll_obj* bag,
+ poll_obj_type bag_type, poll_obj* item,
poll_obj_type item_type) {
GPR_TIMER_BEGIN("add_poll_object", 0);
@@ -1410,8 +1412,8 @@ static void add_poll_object(grpc_exec_ctx *exec_ctx, poll_obj *bag,
GPR_ASSERT(bag->obj_type == bag_type);
#endif
- grpc_error *error = GRPC_ERROR_NONE;
- polling_island *pi_new = NULL;
+ grpc_error* error = GRPC_ERROR_NONE;
+ polling_island* pi_new = NULL;
gpr_mu_lock(&bag->mu);
gpr_mu_lock(&item->mu);
@@ -1462,8 +1464,8 @@ retry:
GRPC_POLLING_TRACE(
"add_poll_object: Raced creating new polling island. pi_new: %p "
"(fd: %d, %s: %p)",
- (void *)pi_new, FD_FROM_PO(item)->fd, poll_obj_string(bag_type),
- (void *)bag);
+ (void*)pi_new, FD_FROM_PO(item)->fd, poll_obj_string(bag_type),
+ (void*)bag);
/* No need to lock 'pi_new' here since this is a new polling island
and no one has a reference to it yet */
polling_island_remove_all_fds_locked(pi_new, true, &error);
@@ -1481,13 +1483,12 @@ retry:
GRPC_POLLING_TRACE(
"add_poll_object: Created new polling island. pi_new: %p (%s: %p, "
"%s: %p)",
- (void *)pi_new, poll_obj_string(item_type), (void *)item,
- poll_obj_string(bag_type), (void *)bag);
+ (void*)pi_new, poll_obj_string(item_type), (void*)item,
+ poll_obj_string(bag_type), (void*)bag);
} else {
GRPC_POLLING_TRACE(
"add_poll_object: Same polling island. pi: %p (%s, %s)",
- (void *)pi_new, poll_obj_string(item_type),
- poll_obj_string(bag_type));
+ (void*)pi_new, poll_obj_string(item_type), poll_obj_string(bag_type));
}
} else if (item->pi == NULL) {
/* GPR_ASSERT(bag->pi != NULL) */
@@ -1495,7 +1496,7 @@ retry:
pi_new = polling_island_lock(bag->pi);
if (item_type == POLL_OBJ_FD) {
- grpc_fd *fd = FD_FROM_PO(item);
+ grpc_fd* fd = FD_FROM_PO(item);
polling_island_add_fds_locked(pi_new, &fd, 1, true, &error);
}
@@ -1503,8 +1504,8 @@ retry:
GRPC_POLLING_TRACE(
"add_poll_obj: item->pi was NULL. pi_new: %p (item(%s): %p, "
"bag(%s): %p)",
- (void *)pi_new, poll_obj_string(item_type), (void *)item,
- poll_obj_string(bag_type), (void *)bag);
+ (void*)pi_new, poll_obj_string(item_type), (void*)item,
+ poll_obj_string(bag_type), (void*)bag);
} else if (bag->pi == NULL) {
/* GPR_ASSERT(item->pi != NULL) */
/* Make pi_new to point to latest pi */
@@ -1513,15 +1514,15 @@ retry:
GRPC_POLLING_TRACE(
"add_poll_obj: bag->pi was NULL. pi_new: %p (item(%s): %p, "
"bag(%s): %p)",
- (void *)pi_new, poll_obj_string(item_type), (void *)item,
- poll_obj_string(bag_type), (void *)bag);
+ (void*)pi_new, poll_obj_string(item_type), (void*)item,
+ poll_obj_string(bag_type), (void*)bag);
} else {
pi_new = polling_island_merge(item->pi, bag->pi, &error);
GRPC_POLLING_TRACE(
"add_poll_obj: polling islands merged. pi_new: %p (item(%s): %p, "
"bag(%s): %p)",
- (void *)pi_new, poll_obj_string(item_type), (void *)item,
- poll_obj_string(bag_type), (void *)bag);
+ (void*)pi_new, poll_obj_string(item_type), (void*)item,
+ poll_obj_string(bag_type), (void*)bag);
}
/* At this point, pi_new is the polling island that both item->pi and bag->pi
@@ -1550,8 +1551,8 @@ retry:
GPR_TIMER_END("add_poll_object", 0);
}
-static void pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
- grpc_fd *fd) {
+static void pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+ grpc_fd* fd) {
add_poll_object(exec_ctx, &pollset->po, POLL_OBJ_POLLSET, &fd->po,
POLL_OBJ_FD);
}
@@ -1560,8 +1561,8 @@ static void pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
* Pollset-set Definitions
*/
-static grpc_pollset_set *pollset_set_create(void) {
- grpc_pollset_set *pss = (grpc_pollset_set *)gpr_malloc(sizeof(*pss));
+static grpc_pollset_set* pollset_set_create(void) {
+ grpc_pollset_set* pss = (grpc_pollset_set*)gpr_malloc(sizeof(*pss));
gpr_mu_init(&pss->po.mu);
pss->po.pi = NULL;
#ifndef NDEBUG
@@ -1570,8 +1571,8 @@ static grpc_pollset_set *pollset_set_create(void) {
return pss;
}
-static void pollset_set_destroy(grpc_exec_ctx *exec_ctx,
- grpc_pollset_set *pss) {
+static void pollset_set_destroy(grpc_exec_ctx* exec_ctx,
+ grpc_pollset_set* pss) {
gpr_mu_destroy(&pss->po.mu);
if (pss->po.pi != NULL) {
@@ -1581,45 +1582,45 @@ static void pollset_set_destroy(grpc_exec_ctx *exec_ctx,
gpr_free(pss);
}
-static void pollset_set_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset_set *pss,
- grpc_fd *fd) {
+static void pollset_set_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset_set* pss,
+ grpc_fd* fd) {
add_poll_object(exec_ctx, &pss->po, POLL_OBJ_POLLSET_SET, &fd->po,
POLL_OBJ_FD);
}
-static void pollset_set_del_fd(grpc_exec_ctx *exec_ctx, grpc_pollset_set *pss,
- grpc_fd *fd) {
+static void pollset_set_del_fd(grpc_exec_ctx* exec_ctx, grpc_pollset_set* pss,
+ grpc_fd* fd) {
/* Nothing to do */
}
-static void pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
- grpc_pollset_set *pss, grpc_pollset *ps) {
+static void pollset_set_add_pollset(grpc_exec_ctx* exec_ctx,
+ grpc_pollset_set* pss, grpc_pollset* ps) {
add_poll_object(exec_ctx, &pss->po, POLL_OBJ_POLLSET_SET, &ps->po,
POLL_OBJ_POLLSET);
}
-static void pollset_set_del_pollset(grpc_exec_ctx *exec_ctx,
- grpc_pollset_set *pss, grpc_pollset *ps) {
+static void pollset_set_del_pollset(grpc_exec_ctx* exec_ctx,
+ grpc_pollset_set* pss, grpc_pollset* ps) {
/* Nothing to do */
}
-static void pollset_set_add_pollset_set(grpc_exec_ctx *exec_ctx,
- grpc_pollset_set *bag,
- grpc_pollset_set *item) {
+static void pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx,
+ grpc_pollset_set* bag,
+ grpc_pollset_set* item) {
add_poll_object(exec_ctx, &bag->po, POLL_OBJ_POLLSET_SET, &item->po,
POLL_OBJ_POLLSET_SET);
}
-static void pollset_set_del_pollset_set(grpc_exec_ctx *exec_ctx,
- grpc_pollset_set *bag,
- grpc_pollset_set *item) {
+static void pollset_set_del_pollset_set(grpc_exec_ctx* exec_ctx,
+ grpc_pollset_set* bag,
+ grpc_pollset_set* item) {
/* Nothing to do */
}
/* Test helper functions
* */
-void *grpc_fd_get_polling_island(grpc_fd *fd) {
- polling_island *pi;
+void* grpc_fd_get_polling_island(grpc_fd* fd) {
+ polling_island* pi;
gpr_mu_lock(&fd->po.mu);
pi = fd->po.pi;
@@ -1628,8 +1629,8 @@ void *grpc_fd_get_polling_island(grpc_fd *fd) {
return pi;
}
-void *grpc_pollset_get_polling_island(grpc_pollset *ps) {
- polling_island *pi;
+void* grpc_pollset_get_polling_island(grpc_pollset* ps) {
+ polling_island* pi;
gpr_mu_lock(&ps->po.mu);
pi = ps->po.pi;
@@ -1638,9 +1639,9 @@ void *grpc_pollset_get_polling_island(grpc_pollset *ps) {
return pi;
}
-bool grpc_are_polling_islands_equal(void *p, void *q) {
- polling_island *p1 = (polling_island *)p;
- polling_island *p2 = (polling_island *)q;
+bool grpc_are_polling_islands_equal(void* p, void* q) {
+ polling_island* p1 = (polling_island*)p;
+ polling_island* p2 = (polling_island*)q;
/* Note: polling_island_lock_pair() may change p1 and p2 to point to the
latest polling islands in their respective linked lists */
@@ -1706,7 +1707,7 @@ static bool is_epoll_available() {
return true;
}
-const grpc_event_engine_vtable *grpc_init_epollsig_linux(
+const grpc_event_engine_vtable* grpc_init_epollsig_linux(
bool explicit_request) {
/* If use of signals is disabled, we cannot use epoll engine*/
if (is_grpc_wakeup_signal_initialized && grpc_wakeup_signal < 0) {
@@ -1748,7 +1749,7 @@ const grpc_event_engine_vtable *grpc_init_epollsig_linux(
#include "src/core/lib/iomgr/ev_epollsig_linux.h"
/* If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
* NULL */
-const grpc_event_engine_vtable *grpc_init_epollsig_linux(
+const grpc_event_engine_vtable* grpc_init_epollsig_linux(
bool explicit_request) {
return NULL;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-06 01:00:55 +0000