grpc 1.6.7 → 1.7.0.pre1

data/src/core/lib/iomgr/tcp_server_utils_posix_common.c

@@ -93,7 +93,7 @@ static grpc_error *add_socket_to_server(grpc_tcp_server *s, int fd,
     gpr_mu_lock(&s->mu);
     s->nports++;
     GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
-    sp = gpr_malloc(sizeof(grpc_tcp_listener));
+    sp = (grpc_tcp_listener *)gpr_malloc(sizeof(grpc_tcp_listener));
     sp->next = NULL;
     if (s->head == NULL) {
       s->head = sp;

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

@@ -44,6 +44,10 @@ void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
                      gpr_timespec deadline, grpc_closure *closure,
                      gpr_timespec now);
 
+/* Initialize *timer without setting it. This can later be passed through
+   the regular init or cancel */
+void grpc_timer_init_unset(grpc_timer *timer);
+
 /* Note that there is no timer destroy function. This is because the
    timer is a one-time occurrence with a guarantee that the callback will
    be called exactly once, either at expiration or cancellation. Thus, all

data/src/core/lib/iomgr/timer_generic.c

@@ -79,6 +79,125 @@ static timer_shard g_shards[NUM_SHARDS];
  * Access to this is protected by g_shared_mutables.mu */
 static timer_shard *g_shard_queue[NUM_SHARDS];
 
+#ifndef NDEBUG
+
+/* == Hash table for duplicate timer detection == */
+
+#define NUM_HASH_BUCKETS 1009 /* Prime number close to 1000 */
+
+static gpr_mu g_hash_mu[NUM_HASH_BUCKETS]; /* One mutex per bucket */
+static grpc_timer *g_timer_ht[NUM_HASH_BUCKETS] = {NULL};
+
+static void init_timer_ht() {
+  for (int i = 0; i < NUM_HASH_BUCKETS; i++) {
+    gpr_mu_init(&g_hash_mu[i]);
+  }
+}
+
+static bool is_in_ht(grpc_timer *t) {
+  size_t i = GPR_HASH_POINTER(t, NUM_HASH_BUCKETS);
+
+  gpr_mu_lock(&g_hash_mu[i]);
+  grpc_timer *p = g_timer_ht[i];
+  while (p != NULL && p != t) {
+    p = p->hash_table_next;
+  }
+  gpr_mu_unlock(&g_hash_mu[i]);
+
+  return (p == t);
+}
+
+static void add_to_ht(grpc_timer *t) {
+  GPR_ASSERT(!t->hash_table_next);
+  size_t i = GPR_HASH_POINTER(t, NUM_HASH_BUCKETS);
+
+  gpr_mu_lock(&g_hash_mu[i]);
+  grpc_timer *p = g_timer_ht[i];
+  while (p != NULL && p != t) {
+    p = p->hash_table_next;
+  }
+
+  if (p == t) {
+    grpc_closure *c = t->closure;
+    gpr_log(GPR_ERROR,
+            "** Duplicate timer (%p) being added. Closure: (%p), created at: "
+            "(%s:%d), scheduled at: (%s:%d) **",
+            t, c, c->file_created, c->line_created, c->file_initiated,
+            c->line_initiated);
+    abort();
+  }
+
+  /* Timer not present in the bucket. Insert at head of the list */
+  t->hash_table_next = g_timer_ht[i];
+  g_timer_ht[i] = t;
+  gpr_mu_unlock(&g_hash_mu[i]);
+}
+
+static void remove_from_ht(grpc_timer *t) {
+  size_t i = GPR_HASH_POINTER(t, NUM_HASH_BUCKETS);
+  bool removed = false;
+
+  gpr_mu_lock(&g_hash_mu[i]);
+  if (g_timer_ht[i] == t) {
+    g_timer_ht[i] = g_timer_ht[i]->hash_table_next;
+    removed = true;
+  } else if (g_timer_ht[i] != NULL) {
+    grpc_timer *p = g_timer_ht[i];
+    while (p->hash_table_next != NULL && p->hash_table_next != t) {
+      p = p->hash_table_next;
+    }
+
+    if (p->hash_table_next == t) {
+      p->hash_table_next = t->hash_table_next;
+      removed = true;
+    }
+  }
+  gpr_mu_unlock(&g_hash_mu[i]);
+
+  if (!removed) {
+    grpc_closure *c = t->closure;
+    gpr_log(GPR_ERROR,
+            "** Removing timer (%p) that is not added to hash table. Closure "
+            "(%p), created at: (%s:%d), scheduled at: (%s:%d) **",
+            t, c, c->file_created, c->line_created, c->file_initiated,
+            c->line_initiated);
+    abort();
+  }
+
+  t->hash_table_next = NULL;
+}
+
+/* If a timer is added to a timer shard (either heap or a list), it cannot
+ * be pending. A timer is added to hash table only-if it is added to the
+ * timer shard.
+ * Therefore, if timer->pending is false, it cannot be in hash table */
+static void validate_non_pending_timer(grpc_timer *t) {
+  if (!t->pending && is_in_ht(t)) {
+    grpc_closure *c = t->closure;
+    gpr_log(GPR_ERROR,
+            "** gpr_timer_cancel() called on a non-pending timer (%p) which "
+            "is in the hash table. Closure: (%p), created at: (%s:%d), "
+            "scheduled at: (%s:%d) **",
+            t, c, c->file_created, c->line_created, c->file_initiated,
+            c->line_initiated);
+    abort();
+  }
+}
+
+#define INIT_TIMER_HASH_TABLE() init_timer_ht()
+#define ADD_TO_HASH_TABLE(t) add_to_ht((t))
+#define REMOVE_FROM_HASH_TABLE(t) remove_from_ht((t))
+#define VALIDATE_NON_PENDING_TIMER(t) validate_non_pending_timer((t))
+
+#else
+
+#define INIT_TIMER_HASH_TABLE()
+#define ADD_TO_HASH_TABLE(t)
+#define REMOVE_FROM_HASH_TABLE(t)
+#define VALIDATE_NON_PENDING_TIMER(t)
+
+#endif
+
 /* Thread local variable that stores the deadline of the next timer the thread
  * has last-seen. This is an optimization to prevent the thread from checking
  * shared_mutables.min_timer (which requires acquiring shared_mutables.mu lock,
@@ -95,9 +214,7 @@ struct shared_mutables {
   gpr_mu mu;
 } GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
 
-static struct shared_mutables g_shared_mutables = {
-    .checker_mu = GPR_SPINLOCK_STATIC_INITIALIZER, .initialized = false,
-};
+static struct shared_mutables g_shared_mutables;
 
 static gpr_clock_type g_clock_type;
 static gpr_timespec g_start_time;
@@ -155,6 +272,7 @@ void grpc_timer_list_init(gpr_timespec now) {
   uint32_t i;
 
   g_shared_mutables.initialized = true;
+  g_shared_mutables.checker_mu = GPR_SPINLOCK_INITIALIZER;
   gpr_mu_init(&g_shared_mutables.mu);
   g_clock_type = now.clock_type;
   g_start_time = now;
@@ -176,6 +294,8 @@ void grpc_timer_list_init(gpr_timespec now) {
     shard->min_deadline = compute_min_deadline(shard);
     g_shard_queue[i] = shard;
   }
+
+  INIT_TIMER_HASH_TABLE();
 }
 
 void grpc_timer_list_shutdown(grpc_exec_ctx *exec_ctx) {
@@ -234,6 +354,8 @@ static void note_deadline_change(timer_shard *shard) {
   }
 }
 
+void grpc_timer_init_unset(grpc_timer *timer) { timer->pending = false; }
+
 void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
                      gpr_timespec deadline, grpc_closure *closure,
                      gpr_timespec now) {
@@ -244,6 +366,10 @@ void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
   timer->closure = closure;
   gpr_atm deadline_atm = timer->deadline = timespec_to_atm_round_up(deadline);
 
+#ifndef NDEBUG
+  timer->hash_table_next = NULL;
+#endif
+
   if (GRPC_TRACER_ON(grpc_timer_trace)) {
     gpr_log(GPR_DEBUG, "TIMER %p: SET %" PRId64 ".%09d [%" PRIdPTR
                        "] now %" PRId64 ".%09d [%" PRIdPTR "] call %p[%p]",
@@ -271,6 +397,9 @@ void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
 
   grpc_time_averaged_stats_add_sample(&shard->stats,
                                       ts_to_dbl(gpr_time_sub(deadline, now)));
+
+  ADD_TO_HASH_TABLE(timer);
+
   if (deadline_atm < shard->queue_deadline_cap) {
     is_first_timer = grpc_timer_heap_add(&shard->heap, timer);
   } else {
@@ -332,7 +461,10 @@ void grpc_timer_cancel(grpc_exec_ctx *exec_ctx, grpc_timer *timer) {
     gpr_log(GPR_DEBUG, "TIMER %p: CANCEL pending=%s", timer,
             timer->pending ? "true" : "false");
   }
+
   if (timer->pending) {
+    REMOVE_FROM_HASH_TABLE(timer);
+
     GRPC_CLOSURE_SCHED(exec_ctx, timer->closure, GRPC_ERROR_CANCELLED);
     timer->pending = false;
     if (timer->heap_index == INVALID_HEAP_INDEX) {
@@ -340,6 +472,8 @@ void grpc_timer_cancel(grpc_exec_ctx *exec_ctx, grpc_timer *timer) {
     } else {
       grpc_timer_heap_remove(&shard->heap, timer);
     }
+  } else {
+    VALIDATE_NON_PENDING_TIMER(timer);
   }
   gpr_mu_unlock(&shard->mu);
 }
@@ -423,6 +557,7 @@ static size_t pop_timers(grpc_exec_ctx *exec_ctx, timer_shard *shard,
   grpc_timer *timer;
   gpr_mu_lock(&shard->mu);
   while ((timer = pop_one(shard, now))) {
+    REMOVE_FROM_HASH_TABLE(timer);
     GRPC_CLOSURE_SCHED(exec_ctx, timer->closure, GRPC_ERROR_REF(error));
     n++;
   }

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

@@ -29,6 +29,9 @@ struct grpc_timer {
   struct grpc_timer *next;
   struct grpc_timer *prev;
   grpc_closure *closure;
+#ifndef NDEBUG
+  struct grpc_timer *hash_table_next;
+#endif
 };
 
 #endif /* GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H */

data/src/core/lib/iomgr/timer_heap.c

@@ -74,8 +74,8 @@ static void maybe_shrink(grpc_timer_heap *heap) {
   if (heap->timer_count >= 8 &&
       heap->timer_count <= heap->timer_capacity / SHRINK_FULLNESS_FACTOR / 2) {
     heap->timer_capacity = heap->timer_count * SHRINK_FULLNESS_FACTOR;
-    heap->timers =
-        gpr_realloc(heap->timers, heap->timer_capacity * sizeof(grpc_timer *));
+    heap->timers = (grpc_timer **)gpr_realloc(
+        heap->timers, heap->timer_capacity * sizeof(grpc_timer *));
   }
 }
 
@@ -99,8 +99,8 @@ int grpc_timer_heap_add(grpc_timer_heap *heap, grpc_timer *timer) {
   if (heap->timer_count == heap->timer_capacity) {
     heap->timer_capacity =
         GPR_MAX(heap->timer_capacity + 1, heap->timer_capacity * 3 / 2);
-    heap->timers =
-        gpr_realloc(heap->timers, heap->timer_capacity * sizeof(grpc_timer *));
+    heap->timers = (grpc_timer **)gpr_realloc(
+        heap->timers, heap->timer_capacity * sizeof(grpc_timer *));
   }
   timer->heap_index = heap->timer_count;
   adjust_upwards(heap->timers, heap->timer_count, timer);

data/src/core/lib/iomgr/timer_manager.c

@@ -83,7 +83,7 @@ static void start_timer_thread_and_unlock(void) {
   }
   gpr_thd_options opt = gpr_thd_options_default();
   gpr_thd_options_set_joinable(&opt);
-  completed_thread *ct = gpr_malloc(sizeof(*ct));
+  completed_thread *ct = (completed_thread *)gpr_malloc(sizeof(*ct));
   // The call to gpr_thd_new() has to be under the same lock used by
   // gc_completed_threads(), particularly due to ct->t, which is written here
   // (internally by gpr_thd_new) and read there. Otherwise it's possible for ct
@@ -276,7 +276,7 @@ static void timer_thread(void *completed_thread_ptr) {
       GRPC_EXEC_CTX_INITIALIZER(0, grpc_never_ready_to_finish, NULL);
   timer_main_loop(&exec_ctx);
   grpc_exec_ctx_finish(&exec_ctx);
-  timer_thread_cleanup(completed_thread_ptr);
+  timer_thread_cleanup((completed_thread *)completed_thread_ptr);
 }
 
 static void start_threads(void) {

data/src/core/lib/iomgr/timer_uv.c

@@ -77,6 +77,8 @@ void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
   uv_unref((uv_handle_t *)uv_timer);
 }
 
+void grpc_timer_init_unset(grpc_timer *timer) { timer->pending = 0; }
+
 void grpc_timer_cancel(grpc_exec_ctx *exec_ctx, grpc_timer *timer) {
   GRPC_UV_ASSERT_SAME_THREAD();
   if (timer->pending) {

data/src/core/lib/iomgr/udp_server.c

@@ -118,14 +118,14 @@ static grpc_socket_factory *get_socket_factory(const grpc_channel_args *args) {
     const grpc_arg *arg = grpc_channel_args_find(args, GRPC_ARG_SOCKET_FACTORY);
     if (arg) {
       GPR_ASSERT(arg->type == GRPC_ARG_POINTER);
-      return arg->value.pointer.p;
+      return (grpc_socket_factory *)arg->value.pointer.p;
     }
   }
   return NULL;
 }
 
 grpc_udp_server *grpc_udp_server_create(const grpc_channel_args *args) {
-  grpc_udp_server *s = gpr_malloc(sizeof(grpc_udp_server));
+  grpc_udp_server *s = (grpc_udp_server *)gpr_malloc(sizeof(grpc_udp_server));
   gpr_mu_init(&s->mu);
   s->socket_factory = get_socket_factory(args);
   if (s->socket_factory) {
@@ -176,7 +176,7 @@ static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_udp_server *s) {
 
 static void destroyed_port(grpc_exec_ctx *exec_ctx, void *server,
                            grpc_error *error) {
-  grpc_udp_server *s = server;
+  grpc_udp_server *s = (grpc_udp_server *)server;
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;
   if (s->destroyed_ports == s->nports) {
@@ -237,7 +237,8 @@ void grpc_udp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_udp_server *s,
   if (s->active_ports) {
     for (sp = s->head; sp; sp = sp->next) {
       GPR_ASSERT(sp->orphan_cb);
-      struct shutdown_fd_args *args = gpr_malloc(sizeof(*args));
+      struct shutdown_fd_args *args =
+          (struct shutdown_fd_args *)gpr_malloc(sizeof(*args));
       args->fd = sp->emfd;
       args->server_mu = &s->mu;
       GRPC_CLOSURE_INIT(&sp->orphan_fd_closure, shutdown_fd, args,
@@ -331,7 +332,7 @@ error:
 
 /* event manager callback when reads are ready */
 static void on_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_udp_listener *sp = arg;
+  grpc_udp_listener *sp = (grpc_udp_listener *)arg;
 
   gpr_mu_lock(&sp->server->mu);
   if (error != GRPC_ERROR_NONE) {
@@ -354,7 +355,7 @@ static void on_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
 }
 
 static void on_write(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_udp_listener *sp = arg;
+  grpc_udp_listener *sp = (grpc_udp_listener *)arg;
 
   gpr_mu_lock(&(sp->server->mu));
   if (error != GRPC_ERROR_NONE) {
@@ -393,7 +394,7 @@ static int add_socket_to_server(grpc_udp_server *s, int fd,
     gpr_free(addr_str);
     gpr_mu_lock(&s->mu);
     s->nports++;
-    sp = gpr_malloc(sizeof(grpc_udp_listener));
+    sp = (grpc_udp_listener *)gpr_malloc(sizeof(grpc_udp_listener));
     sp->next = NULL;
     if (s->head == NULL) {
       s->head = sp;
@@ -444,7 +445,8 @@ int grpc_udp_server_add_port(grpc_udp_server *s,
                            (socklen_t *)&sockname_temp.len)) {
         port = grpc_sockaddr_get_port(&sockname_temp);
         if (port > 0) {
-          allocated_addr = gpr_malloc(sizeof(grpc_resolved_address));
+          allocated_addr = (grpc_resolved_address *)gpr_malloc(
+              sizeof(grpc_resolved_address));
           memcpy(allocated_addr, addr, sizeof(grpc_resolved_address));
           grpc_sockaddr_set_port(allocated_addr, port);
           addr = allocated_addr;

data/src/core/lib/iomgr/unix_sockets_posix.c

@@ -49,9 +49,11 @@ grpc_error *grpc_resolve_unix_domain_address(const char *name,
     gpr_free(err_msg);
     return err;
   }
-  *addrs = gpr_malloc(sizeof(grpc_resolved_addresses));
+  *addrs =
+      (grpc_resolved_addresses *)gpr_malloc(sizeof(grpc_resolved_addresses));
   (*addrs)->naddrs = 1;
-  (*addrs)->addrs = gpr_malloc(sizeof(grpc_resolved_address));
+  (*addrs)->addrs =
+      (grpc_resolved_address *)gpr_malloc(sizeof(grpc_resolved_address));
   un = (struct sockaddr_un *)(*addrs)->addrs->addr;
   un->sun_family = AF_UNIX;
   strcpy(un->sun_path, name);

data/src/core/lib/iomgr/wakeup_fd_cv.c

@@ -42,7 +42,8 @@ static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) {
   gpr_mu_lock(&g_cvfds.mu);
   if (!g_cvfds.free_fds) {
     newsize = GPR_MIN(g_cvfds.size * 2, g_cvfds.size + MAX_TABLE_RESIZE);
-    g_cvfds.cvfds = gpr_realloc(g_cvfds.cvfds, sizeof(fd_node) * newsize);
+    g_cvfds.cvfds =
+        (fd_node*)gpr_realloc(g_cvfds.cvfds, sizeof(fd_node) * newsize);
     for (i = g_cvfds.size; i < newsize; i++) {
       g_cvfds.cvfds[i].is_set = 0;
       g_cvfds.cvfds[i].cvs = NULL;
@@ -56,7 +57,7 @@ static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) {
   g_cvfds.free_fds = g_cvfds.free_fds->next_free;
   g_cvfds.cvfds[idx].cvs = NULL;
   g_cvfds.cvfds[idx].is_set = 0;
-  fd_info->read_fd = IDX_TO_FD(idx);
+  fd_info->read_fd = GRPC_IDX_TO_FD(idx);
   fd_info->write_fd = -1;
   gpr_mu_unlock(&g_cvfds.mu);
   return GRPC_ERROR_NONE;
@@ -65,8 +66,8 @@ static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) {
 static grpc_error* cv_fd_wakeup(grpc_wakeup_fd* fd_info) {
   cv_node* cvn;
   gpr_mu_lock(&g_cvfds.mu);
-  g_cvfds.cvfds[FD_TO_IDX(fd_info->read_fd)].is_set = 1;
-  cvn = g_cvfds.cvfds[FD_TO_IDX(fd_info->read_fd)].cvs;
+  g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].is_set = 1;
+  cvn = g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].cvs;
   while (cvn) {
     gpr_cv_signal(cvn->cv);
     cvn = cvn->next;
@@ -77,7 +78,7 @@ static grpc_error* cv_fd_wakeup(grpc_wakeup_fd* fd_info) {
 
 static grpc_error* cv_fd_consume(grpc_wakeup_fd* fd_info) {
   gpr_mu_lock(&g_cvfds.mu);
-  g_cvfds.cvfds[FD_TO_IDX(fd_info->read_fd)].is_set = 0;
+  g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].is_set = 0;
   gpr_mu_unlock(&g_cvfds.mu);
   return GRPC_ERROR_NONE;
 }
@@ -88,9 +89,9 @@ static void cv_fd_destroy(grpc_wakeup_fd* fd_info) {
   }
   gpr_mu_lock(&g_cvfds.mu);
   // Assert that there are no active pollers
-  GPR_ASSERT(!g_cvfds.cvfds[FD_TO_IDX(fd_info->read_fd)].cvs);
-  g_cvfds.cvfds[FD_TO_IDX(fd_info->read_fd)].next_free = g_cvfds.free_fds;
-  g_cvfds.free_fds = &g_cvfds.cvfds[FD_TO_IDX(fd_info->read_fd)];
+  GPR_ASSERT(!g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].cvs);
+  g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].next_free = g_cvfds.free_fds;
+  g_cvfds.free_fds = &g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)];
   gpr_mu_unlock(&g_cvfds.mu);
 }
 

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

@@ -37,8 +37,8 @@
 
 #include "src/core/lib/iomgr/ev_posix.h"
 
-#define FD_TO_IDX(fd) (-(fd)-1)
-#define IDX_TO_FD(idx) (-(idx)-1)
+#define GRPC_FD_TO_IDX(fd) (-(fd)-1)
+#define GRPC_IDX_TO_FD(idx) (-(idx)-1)
 
 typedef struct cv_node {
   gpr_cv* cv;

data/src/core/lib/json/json.c

@@ -23,7 +23,7 @@
 #include "src/core/lib/json/json.h"
 
 grpc_json* grpc_json_create(grpc_json_type type) {
-  grpc_json* json = gpr_zalloc(sizeof(*json));
+  grpc_json* json = (grpc_json*)gpr_zalloc(sizeof(*json));
   json->type = type;
 
   return json;

data/src/core/lib/json/json_string.c

@@ -63,19 +63,19 @@ typedef struct {
  * bytes at a time (or multiples thereof).
  */
 static void json_writer_output_check(void *userdata, size_t needed) {
-  json_writer_userdata *state = userdata;
+  json_writer_userdata *state = (json_writer_userdata *)userdata;
   if (state->free_space >= needed) return;
   needed -= state->free_space;
   /* Round up by 256 bytes. */
   needed = (needed + 0xff) & ~0xffU;
-  state->output = gpr_realloc(state->output, state->allocated + needed);
+  state->output = (char *)gpr_realloc(state->output, state->allocated + needed);
   state->free_space += needed;
   state->allocated += needed;
 }
 
 /* These are needed by the writer's implementation. */
 static void json_writer_output_char(void *userdata, char c) {
-  json_writer_userdata *state = userdata;
+  json_writer_userdata *state = (json_writer_userdata *)userdata;
   json_writer_output_check(userdata, 1);
   state->output[state->string_len++] = c;
   state->free_space--;
@@ -83,7 +83,7 @@ static void json_writer_output_char(void *userdata, char c) {
 
 static void json_writer_output_string_with_len(void *userdata, const char *str,
                                                size_t len) {
-  json_writer_userdata *state = userdata;
+  json_writer_userdata *state = (json_writer_userdata *)userdata;
   json_writer_output_check(userdata, len);
   memcpy(state->output + state->string_len, str, len);
   state->string_len += len;
@@ -99,7 +99,7 @@ static void json_writer_output_string(void *userdata, const char *str) {
  * the end of the current string, and advance our output pointer.
  */
 static void json_reader_string_clear(void *userdata) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   if (state->string) {
     GPR_ASSERT(state->string_ptr < state->input);
     *state->string_ptr++ = 0;
@@ -108,7 +108,7 @@ static void json_reader_string_clear(void *userdata) {
 }
 
 static void json_reader_string_add_char(void *userdata, uint32_t c) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   GPR_ASSERT(state->string_ptr < state->input);
   GPR_ASSERT(c <= 0xff);
   *state->string_ptr++ = (uint8_t)c;
@@ -149,7 +149,7 @@ static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
  */
 static uint32_t json_reader_read_char(void *userdata) {
   uint32_t r;
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
 
   if (state->remaining_input == 0) return GRPC_JSON_READ_CHAR_EOF;
 
@@ -168,7 +168,7 @@ static uint32_t json_reader_read_char(void *userdata) {
  * our tree-in-progress inside our opaque structure.
  */
 static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   grpc_json *json = grpc_json_create(type);
 
   json->parent = state->current_container;
@@ -194,7 +194,7 @@ static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
 }
 
 static void json_reader_container_begins(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   grpc_json *container;
 
   GPR_ASSERT(type == GRPC_JSON_ARRAY || type == GRPC_JSON_OBJECT);
@@ -215,7 +215,7 @@ static void json_reader_container_begins(void *userdata, grpc_json_type type) {
  */
 static grpc_json_type json_reader_container_ends(void *userdata) {
   grpc_json_type container_type = GRPC_JSON_TOP_LEVEL;
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
 
   GPR_ASSERT(state->current_container);
 
@@ -236,18 +236,18 @@ static grpc_json_type json_reader_container_ends(void *userdata) {
  * We'll keep it as a string, and leave it to the caller to evaluate it.
  */
 static void json_reader_set_key(void *userdata) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   state->key = state->string;
 }
 
 static void json_reader_set_string(void *userdata) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   grpc_json *json = json_create_and_link(userdata, GRPC_JSON_STRING);
   json->value = (char *)state->string;
 }
 
 static int json_reader_set_number(void *userdata) {
-  json_reader_userdata *state = userdata;
+  json_reader_userdata *state = (json_reader_userdata *)userdata;
   grpc_json *json = json_create_and_link(userdata, GRPC_JSON_NUMBER);
   json->value = (char *)state->string;
   return 1;