From ca3c1c05ebad2b77f0c16c9f424ef42d5198cfd9 Mon Sep 17 00:00:00 2001 From: Yash Tibrewal Date: Thu, 7 Sep 2017 22:47:16 -0700 Subject: More explicit pointer type conversion --- src/core/lib/surface/alarm.c | 6 +- src/core/lib/surface/byte_buffer.c | 6 +- src/core/lib/surface/call.c | 35 +++++------ src/core/lib/surface/channel.c | 6 +- src/core/lib/surface/channel_init.c | 12 ++-- src/core/lib/surface/channel_ping.c | 4 +- src/core/lib/surface/completion_queue.c | 25 ++++---- src/core/lib/surface/server.c | 103 ++++++++++++++++---------------- 8 files changed, 102 insertions(+), 95 deletions(-) (limited to 'src/core/lib/surface') diff --git a/src/core/lib/surface/alarm.c b/src/core/lib/surface/alarm.c index 5dbfaa2d43..7712f560b9 100644 --- a/src/core/lib/surface/alarm.c +++ b/src/core/lib/surface/alarm.c @@ -80,12 +80,12 @@ static void alarm_unref_dbg(grpc_alarm *alarm, const char *reason, static void alarm_end_completion(grpc_exec_ctx *exec_ctx, void *arg, grpc_cq_completion *c) { - grpc_alarm *alarm = arg; + grpc_alarm *alarm = (grpc_alarm *)arg; GRPC_ALARM_UNREF(alarm, "dequeue-end-op"); } static void alarm_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - grpc_alarm *alarm = arg; + grpc_alarm *alarm = (grpc_alarm *)arg; /* We are queuing an op on completion queue. This means, the alarm's structure cannot be destroyed until the op is dequeued. Adding an extra ref @@ -96,7 +96,7 @@ static void alarm_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { } grpc_alarm *grpc_alarm_create(void *reserved) { - grpc_alarm *alarm = gpr_malloc(sizeof(grpc_alarm)); + grpc_alarm *alarm = (grpc_alarm *)gpr_malloc(sizeof(grpc_alarm)); #ifndef NDEBUG if (GRPC_TRACER_ON(grpc_trace_alarm_refcount)) { diff --git a/src/core/lib/surface/byte_buffer.c b/src/core/lib/surface/byte_buffer.c index 0bc990d487..7ed550ef87 100644 --- a/src/core/lib/surface/byte_buffer.c +++ b/src/core/lib/surface/byte_buffer.c @@ -32,7 +32,8 @@ grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create( grpc_slice *slices, size_t nslices, grpc_compression_algorithm compression) { size_t i; - grpc_byte_buffer *bb = gpr_malloc(sizeof(grpc_byte_buffer)); + grpc_byte_buffer *bb = + (grpc_byte_buffer *)gpr_malloc(sizeof(grpc_byte_buffer)); bb->type = GRPC_BB_RAW; bb->data.raw.compression = compression; grpc_slice_buffer_init(&bb->data.raw.slice_buffer); @@ -45,7 +46,8 @@ grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create( grpc_byte_buffer *grpc_raw_byte_buffer_from_reader( grpc_byte_buffer_reader *reader) { - grpc_byte_buffer *bb = gpr_malloc(sizeof(grpc_byte_buffer)); + grpc_byte_buffer *bb = + (grpc_byte_buffer *)gpr_malloc(sizeof(grpc_byte_buffer)); grpc_slice slice; bb->type = GRPC_BB_RAW; bb->data.raw.compression = GRPC_COMPRESS_NONE; diff --git a/src/core/lib/surface/call.c b/src/core/lib/surface/call.c index 3aa20ffcd7..93c512df69 100644 --- a/src/core/lib/surface/call.c +++ b/src/core/lib/surface/call.c @@ -307,7 +307,7 @@ void *grpc_call_arena_alloc(grpc_call *call, size_t size) { static parent_call *get_or_create_parent_call(grpc_call *call) { parent_call *p = (parent_call *)gpr_atm_acq_load(&call->parent_call_atm); if (p == NULL) { - p = gpr_arena_alloc(call->arena, sizeof(*p)); + p = (parent_call *)gpr_arena_alloc(call->arena, sizeof(*p)); gpr_mu_init(&p->child_list_mu); if (!gpr_atm_rel_cas(&call->parent_call_atm, (gpr_atm)NULL, (gpr_atm)p)) { gpr_mu_destroy(&p->child_list_mu); @@ -332,8 +332,8 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx, GPR_TIMER_BEGIN("grpc_call_create", 0); gpr_arena *arena = gpr_arena_create(grpc_channel_get_call_size_estimate(args->channel)); - call = gpr_arena_alloc(arena, - sizeof(grpc_call) + channel_stack->call_stack_size); + call = (grpc_call *)gpr_arena_alloc( + arena, sizeof(grpc_call) + channel_stack->call_stack_size); gpr_ref_init(&call->ext_ref, 1); call->arena = arena; grpc_call_combiner_init(&call->call_combiner); @@ -511,7 +511,7 @@ void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *c REF_ARG) { static void release_call(grpc_exec_ctx *exec_ctx, void *call, grpc_error *error) { - grpc_call *c = call; + grpc_call *c = (grpc_call *)call; grpc_channel *channel = c->channel; grpc_call_combiner_destroy(&c->call_combiner); gpr_free((char *)c->peer_string); @@ -524,7 +524,7 @@ static void destroy_call(grpc_exec_ctx *exec_ctx, void *call, grpc_error *error) { size_t i; int ii; - grpc_call *c = call; + grpc_call *c = (grpc_call *)call; GPR_TIMER_BEGIN("destroy_call", 0); for (i = 0; i < 2; i++) { grpc_metadata_batch_destroy( @@ -624,8 +624,8 @@ grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved) { // the filter stack. static void execute_batch_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *ignored) { - grpc_transport_stream_op_batch *batch = arg; - grpc_call *call = batch->handler_private.extra_arg; + grpc_transport_stream_op_batch *batch = (grpc_transport_stream_op_batch *)arg; + grpc_call *call = (grpc_call *)batch->handler_private.extra_arg; GPR_TIMER_BEGIN("execute_batch", 0); grpc_call_element *elem = CALL_ELEM_FROM_CALL(call, 0); GRPC_CALL_LOG_OP(GPR_INFO, elem, batch); @@ -1105,8 +1105,8 @@ static void publish_app_metadata(grpc_call *call, grpc_metadata_batch *b, if (dest->count + b->list.count > dest->capacity) { dest->capacity = GPR_MAX(dest->capacity + b->list.count, dest->capacity * 3 / 2); - dest->metadata = - gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity); + dest->metadata = (grpc_metadata *)gpr_realloc( + dest->metadata, sizeof(grpc_metadata) * dest->capacity); } for (grpc_linked_mdelem *l = b->list.head; l != NULL; l = l->next) { mdusr = &dest->metadata[dest->count++]; @@ -1157,7 +1157,7 @@ static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call, static void recv_trailing_filter(grpc_exec_ctx *exec_ctx, void *args, grpc_metadata_batch *b) { - grpc_call *call = args; + grpc_call *call = (grpc_call *)args; if (b->idx.named.grpc_status != NULL) { uint32_t status_code = decode_status(b->idx.named.grpc_status->md); grpc_error *error = @@ -1241,7 +1241,8 @@ static batch_control *allocate_batch_control(grpc_call *call, int slot = batch_slot_for_op(ops[0].op); batch_control **pslot = &call->active_batches[slot]; if (*pslot == NULL) { - *pslot = gpr_arena_alloc(call->arena, sizeof(batch_control)); + *pslot = + (batch_control *)gpr_arena_alloc(call->arena, sizeof(batch_control)); } batch_control *bctl = *pslot; if (bctl->call != NULL) { @@ -1255,7 +1256,7 @@ static batch_control *allocate_batch_control(grpc_call *call, static void finish_batch_completion(grpc_exec_ctx *exec_ctx, void *user_data, grpc_cq_completion *storage) { - batch_control *bctl = user_data; + batch_control *bctl = (batch_control *)user_data; grpc_call *call = bctl->call; bctl->call = NULL; GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "completion"); @@ -1398,7 +1399,7 @@ static void continue_receiving_slices(grpc_exec_ctx *exec_ctx, static void receiving_slice_ready(grpc_exec_ctx *exec_ctx, void *bctlp, grpc_error *error) { - batch_control *bctl = bctlp; + batch_control *bctl = (batch_control *)bctlp; grpc_call *call = bctl->call; grpc_byte_stream *bs = call->receiving_stream; bool release_error = false; @@ -1457,7 +1458,7 @@ static void process_data_after_md(grpc_exec_ctx *exec_ctx, static void receiving_stream_ready(grpc_exec_ctx *exec_ctx, void *bctlp, grpc_error *error) { - batch_control *bctl = bctlp; + batch_control *bctl = (batch_control *)bctlp; grpc_call *call = bctl->call; if (error != GRPC_ERROR_NONE) { if (call->receiving_stream != NULL) { @@ -1483,7 +1484,7 @@ static void receiving_stream_ready(grpc_exec_ctx *exec_ctx, void *bctlp, static void receiving_stream_ready_in_call_combiner(grpc_exec_ctx *exec_ctx, void *bctlp, grpc_error *error) { - batch_control *bctl = bctlp; + batch_control *bctl = (batch_control *)bctlp; grpc_call *call = bctl->call; GRPC_CALL_COMBINER_STOP(exec_ctx, &call->call_combiner, "recv_message_ready"); receiving_stream_ready(exec_ctx, bctlp, error); @@ -1592,7 +1593,7 @@ static void add_batch_error(grpc_exec_ctx *exec_ctx, batch_control *bctl, static void receiving_initial_metadata_ready(grpc_exec_ctx *exec_ctx, void *bctlp, grpc_error *error) { - batch_control *bctl = bctlp; + batch_control *bctl = (batch_control *)bctlp; grpc_call *call = bctl->call; GRPC_CALL_COMBINER_STOP(exec_ctx, &call->call_combiner, @@ -1650,7 +1651,7 @@ static void receiving_initial_metadata_ready(grpc_exec_ctx *exec_ctx, static void finish_batch(grpc_exec_ctx *exec_ctx, void *bctlp, grpc_error *error) { - batch_control *bctl = bctlp; + batch_control *bctl = (batch_control *)bctlp; grpc_call *call = bctl->call; GRPC_CALL_COMBINER_STOP(exec_ctx, &call->call_combiner, "on_complete"); add_batch_error(exec_ctx, bctl, GRPC_ERROR_REF(error), false); diff --git a/src/core/lib/surface/channel.c b/src/core/lib/surface/channel.c index 850fbe6a69..34548dac26 100644 --- a/src/core/lib/surface/channel.c +++ b/src/core/lib/surface/channel.c @@ -327,7 +327,7 @@ grpc_call *grpc_channel_create_pollset_set_call( void *grpc_channel_register_call(grpc_channel *channel, const char *method, const char *host, void *reserved) { - registered_call *rc = gpr_malloc(sizeof(registered_call)); + registered_call *rc = (registered_call *)gpr_malloc(sizeof(registered_call)); GRPC_API_TRACE( "grpc_channel_register_call(channel=%p, method=%s, host=%s, reserved=%p)", 4, (channel, method, host, reserved)); @@ -354,7 +354,7 @@ grpc_call *grpc_channel_create_registered_call( grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask, grpc_completion_queue *completion_queue, void *registered_call_handle, gpr_timespec deadline, void *reserved) { - registered_call *rc = registered_call_handle; + registered_call *rc = (registered_call *)registered_call_handle; GRPC_API_TRACE( "grpc_channel_create_registered_call(" "channel=%p, parent_call=%p, propagation_mask=%x, completion_queue=%p, " @@ -392,7 +392,7 @@ void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, static void destroy_channel(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - grpc_channel *channel = arg; + grpc_channel *channel = (grpc_channel *)arg; grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(channel)); while (channel->registered_calls) { registered_call *rc = channel->registered_calls; diff --git a/src/core/lib/surface/channel_init.c b/src/core/lib/surface/channel_init.c index a1391ffe56..33f444b89e 100644 --- a/src/core/lib/surface/channel_init.c +++ b/src/core/lib/surface/channel_init.c @@ -53,9 +53,9 @@ void grpc_channel_init_register_stage(grpc_channel_stack_type type, GPR_ASSERT(!g_finalized); if (g_slots[type].cap_slots == g_slots[type].num_slots) { g_slots[type].cap_slots = GPR_MAX(8, 3 * g_slots[type].cap_slots / 2); - g_slots[type].slots = - gpr_realloc(g_slots[type].slots, - g_slots[type].cap_slots * sizeof(*g_slots[type].slots)); + g_slots[type].slots = (stage_slot *)gpr_realloc( + g_slots[type].slots, + g_slots[type].cap_slots * sizeof(*g_slots[type].slots)); } stage_slot *s = &g_slots[type].slots[g_slots[type].num_slots++]; s->insertion_order = g_slots[type].num_slots; @@ -65,8 +65,8 @@ void grpc_channel_init_register_stage(grpc_channel_stack_type type, } static int compare_slots(const void *a, const void *b) { - const stage_slot *sa = a; - const stage_slot *sb = b; + const stage_slot *sa = (const stage_slot *)a; + const stage_slot *sb = (const stage_slot *)b; int c = GPR_ICMP(sa->priority, sb->priority); if (c != 0) return c; @@ -85,7 +85,7 @@ void grpc_channel_init_finalize(void) { void grpc_channel_init_shutdown(void) { for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) { gpr_free(g_slots[i].slots); - g_slots[i].slots = (void *)(uintptr_t)0xdeadbeef; + g_slots[i].slots = (stage_slot *)(void *)(uintptr_t)0xdeadbeef; } } diff --git a/src/core/lib/surface/channel_ping.c b/src/core/lib/surface/channel_ping.c index e85b308850..f45b568958 100644 --- a/src/core/lib/surface/channel_ping.c +++ b/src/core/lib/surface/channel_ping.c @@ -39,7 +39,7 @@ static void ping_destroy(grpc_exec_ctx *exec_ctx, void *arg, } static void ping_done(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - ping_result *pr = arg; + ping_result *pr = (ping_result *)arg; grpc_cq_end_op(exec_ctx, pr->cq, pr->tag, GRPC_ERROR_REF(error), ping_destroy, pr, &pr->completion_storage); } @@ -49,7 +49,7 @@ void grpc_channel_ping(grpc_channel *channel, grpc_completion_queue *cq, GRPC_API_TRACE("grpc_channel_ping(channel=%p, cq=%p, tag=%p, reserved=%p)", 4, (channel, cq, tag, reserved)); grpc_transport_op *op = grpc_make_transport_op(NULL); - ping_result *pr = gpr_malloc(sizeof(*pr)); + ping_result *pr = (ping_result *)gpr_malloc(sizeof(*pr)); grpc_channel_element *top_elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0); grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; diff --git a/src/core/lib/surface/completion_queue.c b/src/core/lib/surface/completion_queue.c index 10e4e5ab0c..4726503994 100644 --- a/src/core/lib/surface/completion_queue.c +++ b/src/core/lib/surface/completion_queue.c @@ -420,8 +420,9 @@ grpc_completion_queue *grpc_completion_queue_create_internal( const cq_poller_vtable *poller_vtable = &g_poller_vtable_by_poller_type[polling_type]; - cq = gpr_zalloc(sizeof(grpc_completion_queue) + vtable->data_size + - poller_vtable->size()); + cq = (grpc_completion_queue *)gpr_zalloc(sizeof(grpc_completion_queue) + + vtable->data_size + + poller_vtable->size()); cq->vtable = vtable; cq->poller_vtable = poller_vtable; @@ -441,7 +442,7 @@ grpc_completion_queue *grpc_completion_queue_create_internal( } static void cq_init_next(void *ptr) { - cq_next_data *cqd = ptr; + cq_next_data *cqd = (cq_next_data *)ptr; /* Initial count is dropped by grpc_completion_queue_shutdown */ gpr_atm_no_barrier_store(&cqd->pending_events, 1); cqd->shutdown_called = false; @@ -450,13 +451,13 @@ static void cq_init_next(void *ptr) { } static void cq_destroy_next(void *ptr) { - cq_next_data *cqd = ptr; + cq_next_data *cqd = (cq_next_data *)ptr; GPR_ASSERT(cq_event_queue_num_items(&cqd->queue) == 0); cq_event_queue_destroy(&cqd->queue); } static void cq_init_pluck(void *ptr) { - cq_pluck_data *cqd = ptr; + cq_pluck_data *cqd = (cq_pluck_data *)ptr; /* Initial count is dropped by grpc_completion_queue_shutdown */ gpr_atm_no_barrier_store(&cqd->pending_events, 1); cqd->completed_tail = &cqd->completed_head; @@ -468,7 +469,7 @@ static void cq_init_pluck(void *ptr) { } static void cq_destroy_pluck(void *ptr) { - cq_pluck_data *cqd = ptr; + cq_pluck_data *cqd = (cq_pluck_data *)ptr; GPR_ASSERT(cqd->completed_head.next == (uintptr_t)&cqd->completed_head); } @@ -501,7 +502,7 @@ void grpc_cq_internal_ref(grpc_completion_queue *cq) { static void on_pollset_shutdown_done(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - grpc_completion_queue *cq = arg; + grpc_completion_queue *cq = (grpc_completion_queue *)arg; GRPC_CQ_INTERNAL_UNREF(exec_ctx, cq, "pollset_destroy"); } @@ -588,9 +589,9 @@ bool grpc_cq_begin_op(grpc_completion_queue *cq, void *tag) { gpr_mu_lock(cq->mu); if (cq->outstanding_tag_count == cq->outstanding_tag_capacity) { cq->outstanding_tag_capacity = GPR_MAX(4, 2 * cq->outstanding_tag_capacity); - cq->outstanding_tags = - gpr_realloc(cq->outstanding_tags, sizeof(*cq->outstanding_tags) * - cq->outstanding_tag_capacity); + cq->outstanding_tags = (void **)gpr_realloc( + cq->outstanding_tags, + sizeof(*cq->outstanding_tags) * cq->outstanding_tag_capacity); } cq->outstanding_tags[cq->outstanding_tag_count++] = tag; gpr_mu_unlock(cq->mu); @@ -766,7 +767,7 @@ typedef struct { } cq_is_finished_arg; static bool cq_is_next_finished(grpc_exec_ctx *exec_ctx, void *arg) { - cq_is_finished_arg *a = arg; + cq_is_finished_arg *a = (cq_is_finished_arg *)arg; grpc_completion_queue *cq = a->cq; cq_next_data *cqd = DATA_FROM_CQ(cq); GPR_ASSERT(a->stolen_completion == NULL); @@ -1017,7 +1018,7 @@ static void del_plucker(grpc_completion_queue *cq, void *tag, } static bool cq_is_pluck_finished(grpc_exec_ctx *exec_ctx, void *arg) { - cq_is_finished_arg *a = arg; + cq_is_finished_arg *a = (cq_is_finished_arg *)arg; grpc_completion_queue *cq = a->cq; cq_pluck_data *cqd = DATA_FROM_CQ(cq); diff --git a/src/core/lib/surface/server.c b/src/core/lib/surface/server.c index 8582d826ca..a8eb1b0425 100644 --- a/src/core/lib/surface/server.c +++ b/src/core/lib/surface/server.c @@ -250,7 +250,8 @@ static void channel_broadcaster_init(grpc_server *s, channel_broadcaster *cb) { count++; } cb->num_channels = count; - cb->channels = gpr_malloc(sizeof(*cb->channels) * cb->num_channels); + cb->channels = + (grpc_channel **)gpr_malloc(sizeof(*cb->channels) * cb->num_channels); count = 0; for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) { cb->channels[count++] = c->channel; @@ -265,14 +266,15 @@ struct shutdown_cleanup_args { static void shutdown_cleanup(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - struct shutdown_cleanup_args *a = arg; + struct shutdown_cleanup_args *a = (struct shutdown_cleanup_args *)arg; grpc_slice_unref_internal(exec_ctx, a->slice); gpr_free(a); } static void send_shutdown(grpc_exec_ctx *exec_ctx, grpc_channel *channel, bool send_goaway, grpc_error *send_disconnect) { - struct shutdown_cleanup_args *sc = gpr_malloc(sizeof(*sc)); + struct shutdown_cleanup_args *sc = + (struct shutdown_cleanup_args *)gpr_malloc(sizeof(*sc)); GRPC_CLOSURE_INIT(&sc->closure, shutdown_cleanup, sc, grpc_schedule_on_exec_ctx); grpc_transport_op *op = grpc_make_transport_op(&sc->closure); @@ -314,8 +316,8 @@ static void request_matcher_init(request_matcher *rm, size_t entries, grpc_server *server) { memset(rm, 0, sizeof(*rm)); rm->server = server; - rm->requests_per_cq = - gpr_malloc(sizeof(*rm->requests_per_cq) * server->cq_count); + rm->requests_per_cq = (gpr_stack_lockfree **)gpr_malloc( + sizeof(*rm->requests_per_cq) * server->cq_count); for (size_t i = 0; i < server->cq_count; i++) { rm->requests_per_cq[i] = gpr_stack_lockfree_create(entries); } @@ -426,7 +428,7 @@ static void orphan_channel(channel_data *chand) { static void finish_destroy_channel(grpc_exec_ctx *exec_ctx, void *cd, grpc_error *error) { - channel_data *chand = cd; + channel_data *chand = (channel_data *)cd; grpc_server *server = chand->server; GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, chand->channel, "server"); server_unref(exec_ctx, server); @@ -459,7 +461,7 @@ static void destroy_channel(grpc_exec_ctx *exec_ctx, channel_data *chand, static void done_request_event(grpc_exec_ctx *exec_ctx, void *req, grpc_cq_completion *c) { - requested_call *rc = req; + requested_call *rc = (requested_call *)req; grpc_server *server = rc->server; if (rc >= server->requested_calls_per_cq[rc->cq_idx] && @@ -505,7 +507,7 @@ static void publish_call(grpc_exec_ctx *exec_ctx, grpc_server *server, grpc_call_element *elem = grpc_call_stack_element(grpc_call_get_call_stack(call), 0); - channel_data *chand = elem->channel_data; + channel_data *chand = (channel_data *)elem->channel_data; server_ref(chand->server); grpc_cq_end_op(exec_ctx, calld->cq_new, rc->tag, GRPC_ERROR_NONE, done_request_event, rc, &rc->completion); @@ -513,9 +515,9 @@ static void publish_call(grpc_exec_ctx *exec_ctx, grpc_server *server, static void publish_new_rpc(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - grpc_call_element *call_elem = arg; - call_data *calld = call_elem->call_data; - channel_data *chand = call_elem->channel_data; + grpc_call_element *call_elem = (grpc_call_element *)arg; + call_data *calld = (call_data *)call_elem->call_data; + channel_data *chand = (channel_data *)call_elem->channel_data; request_matcher *rm = calld->request_matcher; grpc_server *server = rm->server; @@ -566,7 +568,7 @@ static void finish_start_new_rpc( grpc_exec_ctx *exec_ctx, grpc_server *server, grpc_call_element *elem, request_matcher *rm, grpc_server_register_method_payload_handling payload_handling) { - call_data *calld = elem->call_data; + call_data *calld = (call_data *)elem->call_data; if (gpr_atm_acq_load(&server->shutdown_flag)) { gpr_mu_lock(&calld->mu_state); @@ -599,8 +601,8 @@ static void finish_start_new_rpc( } static void start_new_rpc(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) { - channel_data *chand = elem->channel_data; - call_data *calld = elem->call_data; + channel_data *chand = (channel_data *)elem->channel_data; + call_data *calld = (call_data *)elem->call_data; grpc_server *server = chand->server; uint32_t i; uint32_t hash; @@ -732,8 +734,8 @@ static void maybe_finish_shutdown(grpc_exec_ctx *exec_ctx, static void server_on_recv_initial_metadata(grpc_exec_ctx *exec_ctx, void *ptr, grpc_error *error) { - grpc_call_element *elem = ptr; - call_data *calld = elem->call_data; + grpc_call_element *elem = (grpc_call_element *)ptr; + call_data *calld = (call_data *)elem->call_data; gpr_timespec op_deadline; if (error == GRPC_ERROR_NONE) { @@ -771,7 +773,7 @@ static void server_on_recv_initial_metadata(grpc_exec_ctx *exec_ctx, void *ptr, static void server_mutate_op(grpc_call_element *elem, grpc_transport_stream_op_batch *op) { - call_data *calld = elem->call_data; + call_data *calld = (call_data *)elem->call_data; if (op->recv_initial_metadata) { GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags == NULL); @@ -795,8 +797,8 @@ static void server_start_transport_stream_op_batch( static void got_initial_metadata(grpc_exec_ctx *exec_ctx, void *ptr, grpc_error *error) { - grpc_call_element *elem = ptr; - call_data *calld = elem->call_data; + grpc_call_element *elem = (grpc_call_element *)ptr; + call_data *calld = (call_data *)elem->call_data; if (error == GRPC_ERROR_NONE) { start_new_rpc(exec_ctx, elem); } else { @@ -822,7 +824,7 @@ static void got_initial_metadata(grpc_exec_ctx *exec_ctx, void *ptr, static void accept_stream(grpc_exec_ctx *exec_ctx, void *cd, grpc_transport *transport, const void *transport_server_data) { - channel_data *chand = cd; + channel_data *chand = (channel_data *)cd; /* create a call */ grpc_call_create_args args; memset(&args, 0, sizeof(args)); @@ -838,7 +840,7 @@ static void accept_stream(grpc_exec_ctx *exec_ctx, void *cd, GRPC_ERROR_UNREF(error); return; } - call_data *calld = elem->call_data; + call_data *calld = (call_data *)elem->call_data; grpc_op op; memset(&op, 0, sizeof(op)); op.op = GRPC_OP_RECV_INITIAL_METADATA; @@ -852,7 +854,7 @@ static void accept_stream(grpc_exec_ctx *exec_ctx, void *cd, static void channel_connectivity_changed(grpc_exec_ctx *exec_ctx, void *cd, grpc_error *error) { - channel_data *chand = cd; + channel_data *chand = (channel_data *)cd; grpc_server *server = chand->server; if (chand->connectivity_state != GRPC_CHANNEL_SHUTDOWN) { grpc_transport_op *op = grpc_make_transport_op(NULL); @@ -873,8 +875,8 @@ static void channel_connectivity_changed(grpc_exec_ctx *exec_ctx, void *cd, static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, const grpc_call_element_args *args) { - call_data *calld = elem->call_data; - channel_data *chand = elem->channel_data; + call_data *calld = (call_data *)elem->call_data; + channel_data *chand = (channel_data *)elem->channel_data; memset(calld, 0, sizeof(call_data)); calld->deadline = gpr_inf_future(GPR_CLOCK_REALTIME); calld->call = grpc_call_from_top_element(elem); @@ -891,8 +893,8 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx, static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, const grpc_call_final_info *final_info, grpc_closure *ignored) { - channel_data *chand = elem->channel_data; - call_data *calld = elem->call_data; + channel_data *chand = (channel_data *)elem->channel_data; + call_data *calld = (call_data *)elem->call_data; GPR_ASSERT(calld->state != PENDING); @@ -913,7 +915,7 @@ static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, grpc_channel_element_args *args) { - channel_data *chand = elem->channel_data; + channel_data *chand = (channel_data *)elem->channel_data; GPR_ASSERT(args->is_first); GPR_ASSERT(!args->is_last); chand->server = NULL; @@ -930,7 +932,7 @@ static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx, static void destroy_channel_elem(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem) { size_t i; - channel_data *chand = elem->channel_data; + channel_data *chand = (channel_data *)elem->channel_data; if (chand->registered_methods) { for (i = 0; i < chand->registered_method_slots; i++) { grpc_slice_unref_internal(exec_ctx, chand->registered_methods[i].method); @@ -976,8 +978,8 @@ static void register_completion_queue(grpc_server *server, GRPC_CQ_INTERNAL_REF(cq, "server"); n = server->cq_count++; - server->cqs = gpr_realloc(server->cqs, - server->cq_count * sizeof(grpc_completion_queue *)); + server->cqs = (grpc_completion_queue **)gpr_realloc( + server->cqs, server->cq_count * sizeof(grpc_completion_queue *)); server->cqs[n] = cq; } @@ -1002,7 +1004,7 @@ void grpc_server_register_completion_queue(grpc_server *server, grpc_server *grpc_server_create(const grpc_channel_args *args, void *reserved) { GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved)); - grpc_server *server = gpr_zalloc(sizeof(grpc_server)); + grpc_server *server = (grpc_server *)gpr_zalloc(sizeof(grpc_server)); gpr_mu_init(&server->mu_global); gpr_mu_init(&server->mu_call); @@ -1053,7 +1055,7 @@ void *grpc_server_register_method( flags); return NULL; } - m = gpr_zalloc(sizeof(registered_method)); + m = (registered_method *)gpr_zalloc(sizeof(registered_method)); m->method = gpr_strdup(method); m->host = gpr_strdup(host); m->next = server->registered_methods; @@ -1065,7 +1067,7 @@ void *grpc_server_register_method( static void start_listeners(grpc_exec_ctx *exec_ctx, void *s, grpc_error *error) { - grpc_server *server = s; + grpc_server *server = (grpc_server *)s; for (listener *l = server->listeners; l; l = l->next) { l->start(exec_ctx, server, l->arg, server->pollsets, server->pollset_count); } @@ -1086,11 +1088,12 @@ void grpc_server_start(grpc_server *server) { server->started = true; server->pollset_count = 0; - server->pollsets = gpr_malloc(sizeof(grpc_pollset *) * server->cq_count); - server->request_freelist_per_cq = - gpr_malloc(sizeof(*server->request_freelist_per_cq) * server->cq_count); - server->requested_calls_per_cq = - gpr_malloc(sizeof(*server->requested_calls_per_cq) * server->cq_count); + server->pollsets = + (grpc_pollset **)gpr_malloc(sizeof(grpc_pollset *) * server->cq_count); + server->request_freelist_per_cq = (gpr_stack_lockfree **)gpr_malloc( + sizeof(*server->request_freelist_per_cq) * server->cq_count); + server->requested_calls_per_cq = (requested_call **)gpr_malloc( + sizeof(*server->requested_calls_per_cq) * server->cq_count); for (i = 0; i < server->cq_count; i++) { if (grpc_cq_can_listen(server->cqs[i])) { server->pollsets[server->pollset_count++] = @@ -1101,9 +1104,9 @@ void grpc_server_start(grpc_server *server) { for (int j = 0; j < server->max_requested_calls_per_cq; j++) { gpr_stack_lockfree_push(server->request_freelist_per_cq[i], j); } - server->requested_calls_per_cq[i] = - gpr_malloc((size_t)server->max_requested_calls_per_cq * - sizeof(*server->requested_calls_per_cq[i])); + server->requested_calls_per_cq[i] = (requested_call *)gpr_malloc( + (size_t)server->max_requested_calls_per_cq * + sizeof(*server->requested_calls_per_cq[i])); } request_matcher_init(&server->unregistered_request_matcher, (size_t)server->max_requested_calls_per_cq, server); @@ -1171,7 +1174,7 @@ void grpc_server_setup_transport(grpc_exec_ctx *exec_ctx, grpc_server *s, if (num_registered_methods > 0) { slots = 2 * num_registered_methods; alloc = sizeof(channel_registered_method) * slots; - chand->registered_methods = gpr_zalloc(alloc); + chand->registered_methods = (channel_registered_method *)gpr_zalloc(alloc); for (rm = s->registered_methods; rm; rm = rm->next) { grpc_slice host; bool has_host; @@ -1232,7 +1235,7 @@ void done_published_shutdown(grpc_exec_ctx *exec_ctx, void *done_arg, static void listener_destroy_done(grpc_exec_ctx *exec_ctx, void *s, grpc_error *error) { - grpc_server *server = s; + grpc_server *server = (grpc_server *)s; gpr_mu_lock(&server->mu_global); server->listeners_destroyed++; maybe_finish_shutdown(exec_ctx, server); @@ -1264,9 +1267,9 @@ void grpc_server_shutdown_and_notify(grpc_server *server, gpr_mu_unlock(&server->mu_global); goto done; } - server->shutdown_tags = - gpr_realloc(server->shutdown_tags, - sizeof(shutdown_tag) * (server->num_shutdown_tags + 1)); + server->shutdown_tags = (shutdown_tag *)gpr_realloc( + server->shutdown_tags, + sizeof(shutdown_tag) * (server->num_shutdown_tags + 1)); sdt = &server->shutdown_tags[server->num_shutdown_tags++]; sdt->tag = tag; sdt->cq = cq; @@ -1349,7 +1352,7 @@ void grpc_server_add_listener( grpc_pollset **pollsets, size_t pollset_count), void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg, grpc_closure *on_done)) { - listener *l = gpr_malloc(sizeof(listener)); + listener *l = (listener *)gpr_malloc(sizeof(listener)); l->arg = arg; l->start = start; l->destroy = destroy; @@ -1426,7 +1429,7 @@ grpc_call_error grpc_server_request_call( grpc_completion_queue *cq_for_notification, void *tag) { grpc_call_error error; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - requested_call *rc = gpr_malloc(sizeof(*rc)); + requested_call *rc = (requested_call *)gpr_malloc(sizeof(*rc)); GRPC_API_TRACE( "grpc_server_request_call(" "server=%p, call=%p, details=%p, initial_metadata=%p, " @@ -1471,8 +1474,8 @@ grpc_call_error grpc_server_request_registered_call( grpc_completion_queue *cq_for_notification, void *tag) { grpc_call_error error; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - requested_call *rc = gpr_malloc(sizeof(*rc)); - registered_method *rm = rmp; + requested_call *rc = (requested_call *)gpr_malloc(sizeof(*rc)); + registered_method *rm = (registered_method *)rmp; GRPC_API_TRACE( "grpc_server_request_registered_call(" "server=%p, rmp=%p, call=%p, deadline=%p, initial_metadata=%p, " -- cgit v1.2.3