grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/{iomgr_uv.c → iomgr_uv.cc}

@@ -31,7 +31,7 @@ gpr_thd_id g_init_thread;
 void grpc_iomgr_platform_init(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_pollset_global_init();
-  grpc_register_tracer(&grpc_tcp_trace);
+
   grpc_executor_set_threading(&exec_ctx, false);
   g_init_thread = gpr_thd_currentid();
   grpc_exec_ctx_finish(&exec_ctx);

data/src/core/lib/iomgr/iomgr_uv.h

@@ -23,10 +23,18 @@
 
 #include <grpc/support/thd.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* The thread ID of the thread on which grpc was initialized. Used to verify
  * that all calls into libuv are made on that same thread */
 extern gpr_thd_id g_init_thread;
 
+#ifdef __cplusplus
+}
+#endif
+
 #ifdef GRPC_UV_THREAD_CHECK
 #define GRPC_UV_ASSERT_SAME_THREAD() \
   GPR_ASSERT(gpr_thd_currentid() == g_init_thread)

data/src/core/lib/iomgr/{is_epollexclusive_available.c → is_epollexclusive_available.cc}

@@ -62,7 +62,7 @@ bool grpc_is_epollexclusive_available(void) {
      EPOLLEXCLUSIVE enabled kernels - specifically the combination of
      EPOLLONESHOT and EPOLLEXCLUSIVE */
   ev.events = (uint32_t)(EPOLLET | EPOLLIN | EPOLLEXCLUSIVE | EPOLLONESHOT);
-  ev.data.ptr = NULL;
+  ev.data.ptr = nullptr;
   if (epoll_ctl(fd, EPOLL_CTL_ADD, evfd, &ev) != 0) {
     if (errno != EINVAL) {
       if (!logged_why_not) {

data/src/core/lib/iomgr/is_epollexclusive_available.h

@@ -21,6 +21,14 @@
 
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 bool grpc_is_epollexclusive_available(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_IS_EPOLLEXCLUSIVE_AVAILABLE_H */

data/src/core/lib/iomgr/{load_file.c → load_file.cc}

@@ -25,21 +25,21 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/support/block_annotate.h"
+#include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/support/string.h"
 
-grpc_error *grpc_load_file(const char *filename, int add_null_terminator,
-                           grpc_slice *output) {
-  unsigned char *contents = NULL;
+grpc_error* grpc_load_file(const char* filename, int add_null_terminator,
+                           grpc_slice* output) {
+  unsigned char* contents = nullptr;
   size_t contents_size = 0;
   grpc_slice result = grpc_empty_slice();
-  FILE *file;
+  FILE* file;
   size_t bytes_read = 0;
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
   file = fopen(filename, "rb");
-  if (file == NULL) {
+  if (file == nullptr) {
     error = GRPC_OS_ERROR(errno, "fopen");
     goto end;
   }
@@ -47,8 +47,8 @@ grpc_error *grpc_load_file(const char *filename, int add_null_terminator,
   /* Converting to size_t on the assumption that it will not fail */
   contents_size = (size_t)ftell(file);
   fseek(file, 0, SEEK_SET);
-  contents = (unsigned char *)gpr_malloc(contents_size +
-                                         (add_null_terminator ? 1 : 0));
+  contents =
+      (unsigned char*)gpr_malloc(contents_size + (add_null_terminator ? 1 : 0));
   bytes_read = fread(contents, 1, contents_size, file);
   if (bytes_read < contents_size) {
     error = GRPC_OS_ERROR(errno, "fread");
@@ -62,9 +62,9 @@ grpc_error *grpc_load_file(const char *filename, int add_null_terminator,
 
 end:
   *output = result;
-  if (file != NULL) fclose(file);
+  if (file != nullptr) fclose(file);
   if (error != GRPC_ERROR_NONE) {
-    grpc_error *error_out =
+    grpc_error* error_out =
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),
                            GRPC_ERROR_STR_FILENAME,
@@ -73,6 +73,6 @@ end:
     GRPC_ERROR_UNREF(error);
     error = error_out;
   }
-  GRPC_SCHEDULING_END_BLOCKING_REGION;
+  GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX;
   return error;
 }

data/src/core/lib/iomgr/load_file.h

@@ -31,8 +31,8 @@ extern "C" {
 
 /* Loads the content of a file into a slice. add_null_terminator will add
    a NULL terminator if non-zero. */
-grpc_error *grpc_load_file(const char *filename, int add_null_terminator,
-                           grpc_slice *slice);
+grpc_error* grpc_load_file(const char* filename, int add_null_terminator,
+                           grpc_slice* slice);
 
 #ifdef __cplusplus
 }

data/src/core/lib/iomgr/{lockfree_event.c → lockfree_event.cc}

@@ -22,96 +22,102 @@
 
 #include "src/core/lib/debug/trace.h"
 
-extern grpc_tracer_flag grpc_polling_trace;
+extern grpc_core::TraceFlag grpc_polling_trace;
 
 /* 'state' holds the to call when the fd is readable or writable respectively.
    It can contain one of the following values:
-     CLOSURE_READY     : The fd has an I/O event of interest but there is no
+     kClosureReady     : The fd has an I/O event of interest but there is no
                          closure yet to execute
 
-     CLOSURE_NOT_READY : The fd has no I/O event of interest
+     kClosureNotReady : The fd has no I/O event of interest
 
      closure ptr       : The closure to be executed when the fd has an I/O
                          event of interest
 
-     shutdown_error | FD_SHUTDOWN_BIT :
-                        'shutdown_error' field ORed with FD_SHUTDOWN_BIT.
+     shutdown_error | kShutdownBit :
+                        'shutdown_error' field ORed with kShutdownBit.
                          This indicates that the fd is shutdown. Since all
                          memory allocations are word-aligned, the lower two
                          bits of the shutdown_error pointer are always 0. So
-                         it is safe to OR these with FD_SHUTDOWN_BIT
+                         it is safe to OR these with kShutdownBit
 
    Valid state transitions:
 
-     <closure ptr> <-----3------ CLOSURE_NOT_READY ----1---->  CLOSURE_READY
+     <closure ptr> <-----3------ kClosureNotReady -----1------->  kClosureReady
        |  |                         ^   |    ^                         |  |
        |  |                         |   |    |                         |  |
        |  +--------------4----------+   6    +---------2---------------+  |
        |                                |                                 |
        |                                v                                 |
-       +-----5------->  [shutdown_error | FD_SHUTDOWN_BIT] <----7---------+
+       +-----5------->  [shutdown_error | kShutdownBit] <-------7---------+
 
-    For 1, 4 : See grpc_lfev_set_ready() function
-    For 2, 3 : See grpc_lfev_notify_on() function
-    For 5,6,7: See grpc_lfev_set_shutdown() function */
+    For 1, 4 : See SetReady() function
+    For 2, 3 : See NotifyOn() function
+    For 5,6,7: See SetShutdown() function */
 
-#define CLOSURE_NOT_READY ((gpr_atm)0)
-#define CLOSURE_READY ((gpr_atm)2)
+namespace grpc_core {
 
-#define FD_SHUTDOWN_BIT ((gpr_atm)1)
+LockfreeEvent::LockfreeEvent() { InitEvent(); }
 
-void grpc_lfev_init(gpr_atm *state) {
-  gpr_atm_no_barrier_store(state, CLOSURE_NOT_READY);
-}
+void LockfreeEvent::InitEvent() {
+  /* Perform an atomic store to start the state machine.
 
-void grpc_lfev_destroy(gpr_atm *state) {
-  gpr_atm curr = gpr_atm_no_barrier_load(state);
-  if (curr & FD_SHUTDOWN_BIT) {
-    GRPC_ERROR_UNREF((grpc_error *)(curr & ~FD_SHUTDOWN_BIT));
-  } else {
-    GPR_ASSERT(curr == CLOSURE_NOT_READY || curr == CLOSURE_READY);
-  }
+     Note carefully that LockfreeEvent *MAY* be used whilst in a destroyed
+     state, while a file descriptor is on a freelist. In such a state it may
+     be SetReady'd, and so we need to perform an atomic operation here to
+     ensure no races */
+  gpr_atm_no_barrier_store(&state_, kClosureNotReady);
 }
 
-bool grpc_lfev_is_shutdown(gpr_atm *state) {
-  gpr_atm curr = gpr_atm_no_barrier_load(state);
-  return (curr & FD_SHUTDOWN_BIT) != 0;
+void LockfreeEvent::DestroyEvent() {
+  gpr_atm curr;
+  do {
+    curr = gpr_atm_no_barrier_load(&state_);
+    if (curr & kShutdownBit) {
+      GRPC_ERROR_UNREF((grpc_error*)(curr & ~kShutdownBit));
+    } else {
+      GPR_ASSERT(curr == kClosureNotReady || curr == kClosureReady);
+    }
+    /* we CAS in a shutdown, no error value here. If this event is interacted
+       with post-deletion (see the note in the constructor) we want the bit
+       pattern to prevent error retention in a deleted object */
+  } while (!gpr_atm_no_barrier_cas(&state_, curr,
+                                   kShutdownBit /* shutdown, no error */));
 }
 
-void grpc_lfev_notify_on(grpc_exec_ctx *exec_ctx, gpr_atm *state,
-                         grpc_closure *closure, const char *variable) {
+void LockfreeEvent::NotifyOn(grpc_exec_ctx* exec_ctx, grpc_closure* closure) {
   while (true) {
-    gpr_atm curr = gpr_atm_no_barrier_load(state);
-    if (GRPC_TRACER_ON(grpc_polling_trace)) {
-      gpr_log(GPR_ERROR, "lfev_notify_on[%s]: %p curr=%p closure=%p", variable,
-              state, (void *)curr, closure);
+    gpr_atm curr = gpr_atm_no_barrier_load(&state_);
+    if (grpc_polling_trace.enabled()) {
+      gpr_log(GPR_ERROR, "LockfreeEvent::NotifyOn: %p curr=%p closure=%p", this,
+              (void*)curr, closure);
     }
     switch (curr) {
-      case CLOSURE_NOT_READY: {
-        /* CLOSURE_NOT_READY -> <closure>.
+      case kClosureNotReady: {
+        /* kClosureNotReady -> <closure>.
 
            We're guaranteed by API that there's an acquire barrier before here,
            so there's no need to double-dip and this can be a release-only.
 
            The release itself pairs with the acquire half of a set_ready full
            barrier. */
-        if (gpr_atm_rel_cas(state, CLOSURE_NOT_READY, (gpr_atm)closure)) {
+        if (gpr_atm_rel_cas(&state_, kClosureNotReady, (gpr_atm)closure)) {
           return; /* Successful. Return */
         }
 
         break; /* retry */
       }
 
-      case CLOSURE_READY: {
-        /* Change the state to CLOSURE_NOT_READY. Schedule the closure if
+      case kClosureReady: {
+        /* Change the state to kClosureNotReady. Schedule the closure if
            successful. If not, the state most likely transitioned to shutdown.
            We should retry.
 
            This can be a no-barrier cas since the state is being transitioned to
-           CLOSURE_NOT_READY; set_ready and set_shutdown do not schedule any
+           kClosureNotReady; set_ready and set_shutdown do not schedule any
            closure when transitioning out of CLOSURE_NO_READY state (i.e there
            is no other code that needs to 'happen-after' this) */
-        if (gpr_atm_no_barrier_cas(state, CLOSURE_READY, CLOSURE_NOT_READY)) {
+        if (gpr_atm_no_barrier_cas(&state_, kClosureReady, kClosureNotReady)) {
           GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_NONE);
           return; /* Successful. Return */
         }
@@ -123,8 +129,8 @@ void grpc_lfev_notify_on(grpc_exec_ctx *exec_ctx, gpr_atm *state,
         /* 'curr' is either a closure or the fd is shutdown(in which case 'curr'
            contains a pointer to the shutdown-error). If the fd is shutdown,
            schedule the closure with the shutdown error */
-        if ((curr & FD_SHUTDOWN_BIT) > 0) {
-          grpc_error *shutdown_err = (grpc_error *)(curr & ~FD_SHUTDOWN_BIT);
+        if ((curr & kShutdownBit) > 0) {
+          grpc_error* shutdown_err = (grpc_error*)(curr & ~kShutdownBit);
           GRPC_CLOSURE_SCHED(exec_ctx, closure,
                              GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                  "FD Shutdown", &shutdown_err, 1));
@@ -133,7 +139,8 @@ void grpc_lfev_notify_on(grpc_exec_ctx *exec_ctx, gpr_atm *state,
 
         /* There is already a closure!. This indicates a bug in the code */
         gpr_log(GPR_ERROR,
-                "notify_on called with a previous callback still pending");
+                "LockfreeEvent::NotifyOn: notify_on called with a previous "
+                "callback still pending");
         abort();
       }
     }
@@ -142,22 +149,22 @@ void grpc_lfev_notify_on(grpc_exec_ctx *exec_ctx, gpr_atm *state,
   GPR_UNREACHABLE_CODE(return );
 }
 
-bool grpc_lfev_set_shutdown(grpc_exec_ctx *exec_ctx, gpr_atm *state,
-                            grpc_error *shutdown_err) {
-  gpr_atm new_state = (gpr_atm)shutdown_err | FD_SHUTDOWN_BIT;
+bool LockfreeEvent::SetShutdown(grpc_exec_ctx* exec_ctx,
+                                grpc_error* shutdown_err) {
+  gpr_atm new_state = (gpr_atm)shutdown_err | kShutdownBit;
 
   while (true) {
-    gpr_atm curr = gpr_atm_no_barrier_load(state);
-    if (GRPC_TRACER_ON(grpc_polling_trace)) {
-      gpr_log(GPR_ERROR, "lfev_set_shutdown: %p curr=%p err=%s", state,
-              (void *)curr, grpc_error_string(shutdown_err));
+    gpr_atm curr = gpr_atm_no_barrier_load(&state_);
+    if (grpc_polling_trace.enabled()) {
+      gpr_log(GPR_ERROR, "LockfreeEvent::SetShutdown: %p curr=%p err=%s",
+              &state_, (void*)curr, grpc_error_string(shutdown_err));
     }
     switch (curr) {
-      case CLOSURE_READY:
-      case CLOSURE_NOT_READY:
+      case kClosureReady:
+      case kClosureNotReady:
         /* Need a full barrier here so that the initial load in notify_on
            doesn't need a barrier */
-        if (gpr_atm_full_cas(state, curr, new_state)) {
+        if (gpr_atm_full_cas(&state_, curr, new_state)) {
           return true; /* early out */
         }
         break; /* retry */
@@ -166,7 +173,7 @@ bool grpc_lfev_set_shutdown(grpc_exec_ctx *exec_ctx, gpr_atm *state,
         /* 'curr' is either a closure or the fd is already shutdown */
 
         /* If fd is already shutdown, we are done */
-        if ((curr & FD_SHUTDOWN_BIT) > 0) {
+        if ((curr & kShutdownBit) > 0) {
           GRPC_ERROR_UNREF(shutdown_err);
           return false;
         }
@@ -176,8 +183,8 @@ bool grpc_lfev_set_shutdown(grpc_exec_ctx *exec_ctx, gpr_atm *state,
            Needs an acquire to pair with setting the closure (and get a
            happens-after on that edge), and a release to pair with anything
            loading the shutdown state. */
-        if (gpr_atm_full_cas(state, curr, new_state)) {
-          GRPC_CLOSURE_SCHED(exec_ctx, (grpc_closure *)curr,
+        if (gpr_atm_full_cas(&state_, curr, new_state)) {
+          GRPC_CLOSURE_SCHED(exec_ctx, (grpc_closure*)curr,
                              GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                  "FD Shutdown", &shutdown_err, 1));
           return true;
@@ -193,26 +200,25 @@ bool grpc_lfev_set_shutdown(grpc_exec_ctx *exec_ctx, gpr_atm *state,
   GPR_UNREACHABLE_CODE(return false);
 }
 
-void grpc_lfev_set_ready(grpc_exec_ctx *exec_ctx, gpr_atm *state,
-                         const char *variable) {
+void LockfreeEvent::SetReady(grpc_exec_ctx* exec_ctx) {
   while (true) {
-    gpr_atm curr = gpr_atm_no_barrier_load(state);
+    gpr_atm curr = gpr_atm_no_barrier_load(&state_);
 
-    if (GRPC_TRACER_ON(grpc_polling_trace)) {
-      gpr_log(GPR_ERROR, "lfev_set_ready[%s]: %p curr=%p", variable, state,
-              (void *)curr);
+    if (grpc_polling_trace.enabled()) {
+      gpr_log(GPR_ERROR, "LockfreeEvent::SetReady: %p curr=%p", &state_,
+              (void*)curr);
     }
 
     switch (curr) {
-      case CLOSURE_READY: {
+      case kClosureReady: {
         /* Already ready. We are done here */
         return;
       }
 
-      case CLOSURE_NOT_READY: {
+      case kClosureNotReady: {
         /* No barrier required as we're transitioning to a state that does not
            involve a closure */
-        if (gpr_atm_no_barrier_cas(state, CLOSURE_NOT_READY, CLOSURE_READY)) {
+        if (gpr_atm_no_barrier_cas(&state_, kClosureNotReady, kClosureReady)) {
           return; /* early out */
         }
         break; /* retry */
@@ -220,15 +226,15 @@ void grpc_lfev_set_ready(grpc_exec_ctx *exec_ctx, gpr_atm *state,
 
       default: {
         /* 'curr' is either a closure or the fd is shutdown */
-        if ((curr & FD_SHUTDOWN_BIT) > 0) {
+        if ((curr & kShutdownBit) > 0) {
           /* The fd is shutdown. Do nothing */
           return;
         }
         /* Full cas: acquire pairs with this cas' release in the event of a
            spurious set_ready; release pairs with this or the acquire in
            notify_on (or set_shutdown) */
-        else if (gpr_atm_full_cas(state, curr, CLOSURE_NOT_READY)) {
-          GRPC_CLOSURE_SCHED(exec_ctx, (grpc_closure *)curr, GRPC_ERROR_NONE);
+        else if (gpr_atm_full_cas(&state_, curr, kClosureNotReady)) {
+          GRPC_CLOSURE_SCHED(exec_ctx, (grpc_closure*)curr, GRPC_ERROR_NONE);
           return;
         }
         /* else the state changed again (only possible by either a racing
@@ -239,3 +245,5 @@ void grpc_lfev_set_ready(grpc_exec_ctx *exec_ctx, gpr_atm *state,
     }
   }
 }
+
+}  // namespace grpc_core

data/src/core/lib/iomgr/lockfree_event.h

@@ -25,16 +25,35 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-void grpc_lfev_init(gpr_atm *state);
-void grpc_lfev_destroy(gpr_atm *state);
-bool grpc_lfev_is_shutdown(gpr_atm *state);
-
-void grpc_lfev_notify_on(grpc_exec_ctx *exec_ctx, gpr_atm *state,
-                         grpc_closure *closure, const char *variable);
-/* Returns true on first successful shutdown */
-bool grpc_lfev_set_shutdown(grpc_exec_ctx *exec_ctx, gpr_atm *state,
-                            grpc_error *shutdown_err);
-void grpc_lfev_set_ready(grpc_exec_ctx *exec_ctx, gpr_atm *state,
-                         const char *variable);
+namespace grpc_core {
+
+class LockfreeEvent {
+ public:
+  LockfreeEvent();
+
+  LockfreeEvent(const LockfreeEvent&) = delete;
+  LockfreeEvent& operator=(const LockfreeEvent&) = delete;
+
+  // These methods are used to initialize and destroy the internal state. These
+  // cannot be done in constructor and destructor because SetReady may be called
+  // when the event is destroyed and put in a freelist.
+  void InitEvent();
+  void DestroyEvent();
+
+  bool IsShutdown() const {
+    return (gpr_atm_no_barrier_load(&state_) & kShutdownBit) != 0;
+  }
+
+  void NotifyOn(grpc_exec_ctx* exec_ctx, grpc_closure* closure);
+  bool SetShutdown(grpc_exec_ctx* exec_ctx, grpc_error* error);
+  void SetReady(grpc_exec_ctx* exec_ctx);
+
+ private:
+  enum State { kClosureNotReady = 0, kClosureReady = 2, kShutdownBit = 1 };
+
+  gpr_atm state_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_LOCKFREE_EVENT_H */

data/src/core/lib/iomgr/{network_status_tracker.c → network_status_tracker.cc}

@@ -16,6 +16,7 @@
  *
  */
 
+#include "src/core/lib/iomgr/network_status_tracker.h"
 #include "src/core/lib/iomgr/endpoint.h"
 
 void grpc_network_status_shutdown(void) {}
@@ -26,8 +27,8 @@ void grpc_network_status_init(void) {
 
 void grpc_destroy_network_status_monitor() {}
 
-void grpc_network_status_register_endpoint(grpc_endpoint *ep) { (void)ep; }
+void grpc_network_status_register_endpoint(grpc_endpoint* ep) { (void)ep; }
 
-void grpc_network_status_unregister_endpoint(grpc_endpoint *ep) { (void)ep; }
+void grpc_network_status_unregister_endpoint(grpc_endpoint* ep) { (void)ep; }
 
 void grpc_network_status_shutdown_all_endpoints() {}