static void channel_op(grpc_channel_element *elem, grpc_channel_element *from_elem, grpc_channel_op *op) { channel_data *chand = elem->channel_data; grpc_server *server = chand->server; switch (op->type) { case GRPC_ACCEPT_CALL: /* create a call */ grpc_call_create(chand->channel, NULL, op->data.accept_call.transport_server_data, NULL, 0, gpr_inf_future); break; case GRPC_TRANSPORT_CLOSED: /* if the transport is closed for a server channel, we destroy the channel */ gpr_mu_lock(&server->mu); server_ref(server); destroy_channel(chand); gpr_mu_unlock(&server->mu); server_unref(server); break; case GRPC_TRANSPORT_GOAWAY: gpr_slice_unref(op->data.goaway.message); break; default: GPR_ASSERT(op->dir == GRPC_CALL_DOWN); grpc_channel_next_op(elem, op); break; } }
void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel *channel, const char *reason) { gpr_log(GPR_DEBUG, "CHANNEL: unref %p %d -> %d [%s]", channel, channel->refs.count, channel->refs.count - 1, reason); #else void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel *channel) { #endif if (gpr_unref(&channel->refs)) { destroy_channel(exec_ctx, channel); } } void grpc_channel_destroy(grpc_channel *channel) { grpc_transport_op op; grpc_channel_element *elem; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; GRPC_API_TRACE("grpc_channel_destroy(channel=%p)", 1, (channel)); memset(&op, 0, sizeof(op)); op.disconnect = 1; elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0); elem->filter->start_transport_op(&exec_ctx, elem, &op); GRPC_CHANNEL_INTERNAL_UNREF(&exec_ctx, channel, "channel"); grpc_exec_ctx_finish(&exec_ctx); }
static void mcap_mdl_connected_cb(struct mcap_mdl *mdl, void *data) { struct health_channel *channel = data; int fd; if (!channel->mdl) channel->mdl = mcap_mdl_ref(mdl); DBG("Data channel connected: mdl %p channel %p", mdl, channel); fd = mcap_mdl_get_fd(channel->mdl); if (fd < 0) { error("health: error retrieving fd"); goto fail; } if (channel->mdep_id == MDEP_ECHO) { GIOChannel *io; io = g_io_channel_unix_new(fd); g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL | G_IO_IN, serve_echo, channel); g_io_channel_unref(io); return; } send_channel_state_notify(channel, HAL_HEALTH_CHANNEL_CONNECTED, fd); return; fail: /* TODO: mcap_mdl_abort */ destroy_channel(channel); }
int main() { int i; for (i=0; i<10000; ++i) { if (i % 1000 == 0) printf("Connections: %d\n", i); create_channel(&channel, &client, NULL); create_dangling_policy_request(); destroy_channel(channel, client); } return 0; }
static void mcap_mdl_deleted_cb(struct mcap_mdl *mdl, void *data) { struct health_channel *channel; info("health: MDL deleted"); channel = search_channel_by_mdl(mdl); if (!channel) return; DBG("channel %p mdl %p", channel, mdl); destroy_channel(channel); }
int aout_sles_close(rh_aout_itf * pself) { if(pself) { struct aout_instance * instance = (struct aout_instance *)*pself; if(instance) { destroy_channel(h); free(instance->interface); free(instance); } *pself = NULL; } return 0; }
static void channel_connectivity_changed(grpc_exec_ctx *exec_ctx, void *cd, grpc_error *error) { channel_data *chand = cd; grpc_server *server = chand->server; if (chand->connectivity_state != GRPC_CHANNEL_SHUTDOWN) { grpc_transport_op op; memset(&op, 0, sizeof(op)); op.on_connectivity_state_change = &chand->channel_connectivity_changed, op.connectivity_state = &chand->connectivity_state; grpc_channel_next_op(exec_ctx, grpc_channel_stack_element( grpc_channel_get_channel_stack(chand->channel), 0), &op); } else { gpr_mu_lock(&server->mu_global); destroy_channel(exec_ctx, chand); gpr_mu_unlock(&server->mu_global); GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, chand->channel, "connectivity"); } }
static void mcap_mdl_deleted_cb(struct mcap_mdl *mdl, void *data) { struct health_channel *channel = data; struct health_device *dev; if (!channel) return; dev = channel->dev; DBG("device %p channel %p mdl %p", dev, channel, mdl); /* mdl == NULL means, delete all mdls */ if (!mdl) { queue_foreach(dev->channels, notify_channel, NULL); queue_remove_all(dev->channels, NULL, NULL, free_health_channel); return; } destroy_channel(channel); }
int aout_sles_open(rh_aout_itf self, unsigned int channels, unsigned int rate, unsigned int samplesize, unsigned int bigendian) { struct aout_instance * instance = (struct aout_instance *)self; if( instance != NULL ) { if(instance->channels == channels && instance->samplerate == rate && instance->samplesize == samplesize && instance->bigendian == bigendian) { return 0; // channel is already open, and the correct format. } // channel is open, but the wrong format, close it. destroy_channel(self); } // open new channel. { if( instance ) { instance->channels = channels; instance->samplerate = rate; instance->samplesize = samplesize; instance->bigendian = bigendian; buffer_queue_alloc( &instance->bq, 3, 32 * 1024 ); // 3 32k periods. buffer_queue_alloc_buffers(&instance->bq); create_channel(self); return 0; } return -1; } }
static int create_channel(rh_aout_itf self) { struct aout_instance * instance = (struct aout_instance *)self; off_t start; off_t length; struct sles_api_instance * api_instance = (struct sles_api_instance *)instance->api; if(instance->playerObject) return 0; { int e = 0; SLuint32 channelMask = _sles_get_channelmask(instance->channels); const SLInterfaceID ids[] = { SL_IID_SEEK, SL_IID_BUFFERQUEUE }; const SLboolean req[] = { SL_BOOLEAN_FALSE, SL_BOOLEAN_TRUE }; // configure audio source SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, instance->bq.nb_buffers}; SLDataFormat_PCM format_pcm = { SL_DATAFORMAT_PCM, instance->channels, instance->samplerate * 1000, instance->samplesize * 8, instance->samplesize * 8, channelMask, (instance->bigendian ? SL_BYTEORDER_BIGENDIAN : SL_BYTEORDER_LITTLEENDIAN ) }; SLDataSource audioSrc = {&loc_bufq, &format_pcm}; // configure audio sink SLDataLocator_OutputMix loc_outmix = { SL_DATALOCATOR_OUTPUTMIX, api_instance->outputMix }; SLDataSink audioSnk = { &loc_outmix, NULL }; if (SL_RESULT_SUCCESS != (*api_instance->engineItf)->CreateAudioPlayer( api_instance->engineItf, &instance->playerObject, &audioSrc, &audioSnk, sizeof(ids) / sizeof(ids[0]), ids, req)) e = 1; else if (SL_RESULT_SUCCESS != (*instance->playerObject)->Realize(instance->playerObject, SL_BOOLEAN_FALSE )) e = 2; else if (SL_RESULT_SUCCESS != (*instance->playerObject)->GetInterface(instance->playerObject, SL_IID_PLAY, &instance->playItf)) e = 3; else if(SL_RESULT_SUCCESS != (*instance->playerObject)->GetInterface(instance->playerObject, SL_IID_BUFFERQUEUE, &instance->bufferQueueItf)) e = 5; else if(SL_RESULT_SUCCESS != (*instance->bufferQueueItf)->RegisterCallback(instance->bufferQueueItf, &_buffer_queue_cb, self)) e = 6; else if (SL_RESULT_SUCCESS != (*instance->playItf)->SetCallbackEventsMask(instance->playItf, SL_PLAYEVENT_HEADATEND )) e = 7; if (e) { destroy_channel(h); return -1; } } return 0; }