/* * * Copyright 2015 gRPC authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ #include #include "src/core/lib/surface/channel.h" #include #include #include #include #include #include #include #include #include "src/core/lib/channel/channel_args.h" #include "src/core/lib/channel/channel_trace.h" #include "src/core/lib/channel/channelz.h" #include "src/core/lib/channel/channelz_registry.h" #include "src/core/lib/debug/stats.h" #include "src/core/lib/gpr/string.h" #include "src/core/lib/gprpp/manual_constructor.h" #include "src/core/lib/gprpp/memory.h" #include "src/core/lib/gprpp/ref_counted_ptr.h" #include "src/core/lib/iomgr/iomgr.h" #include "src/core/lib/iomgr/resource_quota.h" #include "src/core/lib/slice/slice_internal.h" #include "src/core/lib/surface/api_trace.h" #include "src/core/lib/surface/call.h" #include "src/core/lib/surface/channel_init.h" #include "src/core/lib/transport/static_metadata.h" /** Cache grpc-status: X mdelems for X = 0..NUM_CACHED_STATUS_ELEMS. * Avoids needing to take a metadata context lock for sending status * if the status code is <= NUM_CACHED_STATUS_ELEMS. * Sized to allow the most commonly used codes to fit in * (OK, Cancelled, Unknown). */ #define NUM_CACHED_STATUS_ELEMS 3 typedef struct registered_call { grpc_mdelem path; grpc_mdelem authority; struct registered_call* next; } registered_call; static void destroy_channel(void* arg, grpc_error* error); grpc_channel* grpc_channel_create_with_builder( grpc_channel_stack_builder* builder, grpc_channel_stack_type channel_stack_type) { char* target = gpr_strdup(grpc_channel_stack_builder_get_target(builder)); grpc_channel_args* args = grpc_channel_args_copy( grpc_channel_stack_builder_get_channel_arguments(builder)); grpc_resource_user* resource_user = grpc_channel_stack_builder_get_resource_user(builder); grpc_channel* channel; if (channel_stack_type == GRPC_SERVER_CHANNEL) { GRPC_STATS_INC_SERVER_CHANNELS_CREATED(); } else { GRPC_STATS_INC_CLIENT_CHANNELS_CREATED(); } grpc_error* error = grpc_channel_stack_builder_finish( builder, sizeof(grpc_channel), 1, destroy_channel, nullptr, reinterpret_cast(&channel)); if (error != GRPC_ERROR_NONE) { gpr_log(GPR_ERROR, "channel stack builder failed: %s", grpc_error_string(error)); GRPC_ERROR_UNREF(error); gpr_free(target); grpc_channel_args_destroy(args); return channel; } channel->target = target; channel->resource_user = resource_user; channel->is_client = grpc_channel_stack_type_is_client(channel_stack_type); gpr_mu_init(&channel->registered_call_mu); channel->registered_calls = nullptr; gpr_atm_no_barrier_store( &channel->call_size_estimate, (gpr_atm)CHANNEL_STACK_FROM_CHANNEL(channel)->call_stack_size + grpc_call_get_initial_size_estimate()); grpc_compression_options_init(&channel->compression_options); for (size_t i = 0; i < args->num_args; i++) { if (0 == strcmp(args->args[i].key, GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL)) { channel->compression_options.default_level.is_set = true; channel->compression_options.default_level.level = static_cast(grpc_channel_arg_get_integer( &args->args[i], {GRPC_COMPRESS_LEVEL_NONE, GRPC_COMPRESS_LEVEL_NONE, GRPC_COMPRESS_LEVEL_COUNT - 1})); } else if (0 == strcmp(args->args[i].key, GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) { channel->compression_options.default_algorithm.is_set = true; channel->compression_options.default_algorithm.algorithm = static_cast(grpc_channel_arg_get_integer( &args->args[i], {GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_ALGORITHMS_COUNT - 1})); } else if (0 == strcmp(args->args[i].key, GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) { channel->compression_options.enabled_algorithms_bitset = static_cast(args->args[i].value.integer) | 0x1; /* always support no compression */ } else if (0 == strcmp(args->args[i].key, GRPC_ARG_CHANNELZ_CHANNEL_NODE)) { GPR_ASSERT(args->args[i].type == GRPC_ARG_POINTER); GPR_ASSERT(args->args[i].value.pointer.p != nullptr); channel->channelz_node = static_cast( args->args[i].value.pointer.p) ->Ref(); } } grpc_channel_args_destroy(args); return channel; } static grpc_core::UniquePtr get_default_authority( const grpc_channel_args* input_args) { bool has_default_authority = false; char* ssl_override = nullptr; grpc_core::UniquePtr default_authority; const size_t num_args = input_args != nullptr ? input_args->num_args : 0; for (size_t i = 0; i < num_args; ++i) { if (0 == strcmp(input_args->args[i].key, GRPC_ARG_DEFAULT_AUTHORITY)) { has_default_authority = true; } else if (0 == strcmp(input_args->args[i].key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)) { ssl_override = grpc_channel_arg_get_string(&input_args->args[i]); } } if (!has_default_authority && ssl_override != nullptr) { default_authority.reset(gpr_strdup(ssl_override)); } return default_authority; } static grpc_channel_args* build_channel_args( const grpc_channel_args* input_args, char* default_authority) { grpc_arg new_args[1]; size_t num_new_args = 0; if (default_authority != nullptr) { new_args[num_new_args++] = grpc_channel_arg_string_create( const_cast(GRPC_ARG_DEFAULT_AUTHORITY), default_authority); } return grpc_channel_args_copy_and_add(input_args, new_args, num_new_args); } namespace { void* channelz_node_copy(void* p) { grpc_core::channelz::ChannelNode* node = static_cast(p); node->Ref().release(); return p; } void channelz_node_destroy(void* p) { grpc_core::channelz::ChannelNode* node = static_cast(p); node->Unref(); } int channelz_node_cmp(void* p1, void* p2) { return GPR_ICMP(p1, p2); } const grpc_arg_pointer_vtable channelz_node_arg_vtable = { channelz_node_copy, channelz_node_destroy, channelz_node_cmp}; void CreateChannelzNode(grpc_channel_stack_builder* builder) { const grpc_channel_args* args = grpc_channel_stack_builder_get_channel_arguments(builder); // Check whether channelz is enabled. const bool channelz_enabled = grpc_channel_arg_get_bool( grpc_channel_args_find(args, GRPC_ARG_ENABLE_CHANNELZ), GRPC_ENABLE_CHANNELZ_DEFAULT); if (!channelz_enabled) return; // Get parameters needed to create the channelz node. const size_t channel_tracer_max_memory = grpc_channel_arg_get_integer( grpc_channel_args_find(args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE), {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX}); const intptr_t channelz_parent_uuid = grpc_core::channelz::GetParentUuidFromArgs(*args); // Create the channelz node. grpc_core::RefCountedPtr channelz_node = grpc_core::MakeRefCounted( grpc_core::UniquePtr( gpr_strdup(grpc_channel_stack_builder_get_target(builder))), channel_tracer_max_memory, channelz_parent_uuid); channelz_node->AddTraceEvent( grpc_core::channelz::ChannelTrace::Severity::Info, grpc_slice_from_static_string("Channel created")); // Update parent channel node, if any. if (channelz_parent_uuid > 0) { grpc_core::RefCountedPtr parent_node = grpc_core::channelz::ChannelzRegistry::Get(channelz_parent_uuid); if (parent_node != nullptr) { grpc_core::channelz::ChannelNode* parent = static_cast(parent_node.get()); parent->AddChildChannel(channelz_node->uuid()); } } // Add channelz node to channel args. // We remove the arg for the parent uuid, since we no longer need it. grpc_arg new_arg = grpc_channel_arg_pointer_create( const_cast(GRPC_ARG_CHANNELZ_CHANNEL_NODE), channelz_node.get(), &channelz_node_arg_vtable); const char* args_to_remove[] = {GRPC_ARG_CHANNELZ_PARENT_UUID}; grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove( args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), &new_arg, 1); grpc_channel_stack_builder_set_channel_arguments(builder, new_args); grpc_channel_args_destroy(new_args); } } // namespace grpc_channel* grpc_channel_create(const char* target, const grpc_channel_args* input_args, grpc_channel_stack_type channel_stack_type, grpc_transport* optional_transport, grpc_resource_user* resource_user) { // We need to make sure that grpc_shutdown() does not shut things down // until after the channel is destroyed. However, the channel may not // actually be destroyed by the time grpc_channel_destroy() returns, // since there may be other existing refs to the channel. If those // refs are held by things that are visible to the wrapped language // (such as outstanding calls on the channel), then the wrapped // language can be responsible for making sure that grpc_shutdown() // does not run until after those refs are released. However, the // channel may also have refs to itself held internally for various // things that need to be cleaned up at channel destruction (e.g., // LB policies, subchannels, etc), and because these refs are not // visible to the wrapped language, it cannot be responsible for // deferring grpc_shutdown() until after they are released. To // accommodate that, we call grpc_init() here and then call // grpc_shutdown() when the channel is actually destroyed, thus // ensuring that shutdown is deferred until that point. grpc_init(); grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create(); const grpc_core::UniquePtr default_authority = get_default_authority(input_args); grpc_channel_args* args = build_channel_args(input_args, default_authority.get()); grpc_channel_stack_builder_set_channel_arguments(builder, args); grpc_channel_args_destroy(args); grpc_channel_stack_builder_set_target(builder, target); grpc_channel_stack_builder_set_transport(builder, optional_transport); grpc_channel_stack_builder_set_resource_user(builder, resource_user); if (!grpc_channel_init_create_stack(builder, channel_stack_type)) { grpc_channel_stack_builder_destroy(builder); if (resource_user != nullptr) { grpc_resource_user_free(resource_user, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE); } grpc_shutdown(); // Since we won't call destroy_channel(). return nullptr; } // We only need to do this for clients here. For servers, this will be // done in src/core/lib/surface/server.cc. if (grpc_channel_stack_type_is_client(channel_stack_type)) { CreateChannelzNode(builder); } grpc_channel* channel = grpc_channel_create_with_builder(builder, channel_stack_type); if (channel == nullptr) { grpc_shutdown(); // Since we won't call destroy_channel(). } return channel; } size_t grpc_channel_get_call_size_estimate(grpc_channel* channel) { #define ROUND_UP_SIZE 256 /* We round up our current estimate to the NEXT value of ROUND_UP_SIZE. This ensures: 1. a consistent size allocation when our estimate is drifting slowly (which is common) - which tends to help most allocators reuse memory 2. a small amount of allowed growth over the estimate without hitting the arena size doubling case, reducing overall memory usage */ return (static_cast( gpr_atm_no_barrier_load(&channel->call_size_estimate)) + 2 * ROUND_UP_SIZE) & ~static_cast(ROUND_UP_SIZE - 1); } void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size) { size_t cur = static_cast( gpr_atm_no_barrier_load(&channel->call_size_estimate)); if (cur < size) { /* size grew: update estimate */ gpr_atm_no_barrier_cas(&channel->call_size_estimate, static_cast(cur), static_cast(size)); /* if we lose: never mind, something else will likely update soon enough */ } else if (cur == size) { /* no change: holding pattern */ } else if (cur > 0) { /* size shrank: decrease estimate */ gpr_atm_no_barrier_cas( &channel->call_size_estimate, static_cast(cur), static_cast(GPR_MIN(cur - 1, (255 * cur + size) / 256))); /* if we lose: never mind, something else will likely update soon enough */ } } char* grpc_channel_get_target(grpc_channel* channel) { GRPC_API_TRACE("grpc_channel_get_target(channel=%p)", 1, (channel)); return gpr_strdup(channel->target); } void grpc_channel_get_info(grpc_channel* channel, const grpc_channel_info* channel_info) { grpc_core::ExecCtx exec_ctx; grpc_channel_element* elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0); elem->filter->get_channel_info(elem, channel_info); } void grpc_channel_reset_connect_backoff(grpc_channel* channel) { grpc_core::ExecCtx exec_ctx; GRPC_API_TRACE("grpc_channel_reset_connect_backoff(channel=%p)", 1, (channel)); grpc_transport_op* op = grpc_make_transport_op(nullptr); op->reset_connect_backoff = true; grpc_channel_element* elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0); elem->filter->start_transport_op(elem, op); } static grpc_call* grpc_channel_create_call_internal( grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative, grpc_mdelem path_mdelem, grpc_mdelem authority_mdelem, grpc_millis deadline) { grpc_mdelem send_metadata[2]; size_t num_metadata = 0; GPR_ASSERT(channel->is_client); GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr)); send_metadata[num_metadata++] = path_mdelem; if (!GRPC_MDISNULL(authority_mdelem)) { send_metadata[num_metadata++] = authority_mdelem; } grpc_call_create_args args; args.channel = channel; args.server = nullptr; args.parent = parent_call; args.propagation_mask = propagation_mask; args.cq = cq; args.pollset_set_alternative = pollset_set_alternative; args.server_transport_data = nullptr; args.add_initial_metadata = send_metadata; args.add_initial_metadata_count = num_metadata; args.send_deadline = deadline; grpc_call* call; GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call)); return call; } grpc_call* grpc_channel_create_call(grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_completion_queue* cq, grpc_slice method, const grpc_slice* host, gpr_timespec deadline, void* reserved) { GPR_ASSERT(!reserved); grpc_core::ExecCtx exec_ctx; grpc_call* call = grpc_channel_create_call_internal( channel, parent_call, propagation_mask, cq, nullptr, grpc_mdelem_create(GRPC_MDSTR_PATH, method, nullptr), host != nullptr ? grpc_mdelem_create(GRPC_MDSTR_AUTHORITY, *host, nullptr) : GRPC_MDNULL, grpc_timespec_to_millis_round_up(deadline)); return call; } grpc_call* grpc_channel_create_pollset_set_call( grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_pollset_set* pollset_set, const grpc_slice& method, const grpc_slice* host, grpc_millis deadline, void* reserved) { GPR_ASSERT(!reserved); return grpc_channel_create_call_internal( channel, parent_call, propagation_mask, nullptr, pollset_set, grpc_mdelem_create(GRPC_MDSTR_PATH, method, nullptr), host != nullptr ? grpc_mdelem_create(GRPC_MDSTR_AUTHORITY, *host, nullptr) : GRPC_MDNULL, deadline); } void* grpc_channel_register_call(grpc_channel* channel, const char* method, const char* host, void* reserved) { registered_call* rc = static_cast(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)); GPR_ASSERT(!reserved); grpc_core::ExecCtx exec_ctx; rc->path = grpc_mdelem_from_slices(GRPC_MDSTR_PATH, grpc_core::ExternallyManagedSlice(method)); rc->authority = host ? grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY, grpc_core::ExternallyManagedSlice(host)) : GRPC_MDNULL; gpr_mu_lock(&channel->registered_call_mu); rc->next = channel->registered_calls; channel->registered_calls = rc; gpr_mu_unlock(&channel->registered_call_mu); return rc; } 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 = static_cast(registered_call_handle); GRPC_API_TRACE( "grpc_channel_create_registered_call(" "channel=%p, parent_call=%p, propagation_mask=%x, completion_queue=%p, " "registered_call_handle=%p, " "deadline=gpr_timespec { tv_sec: %" PRId64 ", tv_nsec: %d, clock_type: %d }, " "reserved=%p)", 9, (channel, parent_call, (unsigned)propagation_mask, completion_queue, registered_call_handle, deadline.tv_sec, deadline.tv_nsec, (int)deadline.clock_type, reserved)); GPR_ASSERT(!reserved); grpc_core::ExecCtx exec_ctx; grpc_call* call = grpc_channel_create_call_internal( channel, parent_call, propagation_mask, completion_queue, nullptr, GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority), grpc_timespec_to_millis_round_up(deadline)); return call; } static void destroy_channel(void* arg, grpc_error* error) { grpc_channel* channel = static_cast(arg); if (channel->channelz_node != nullptr) { if (channel->channelz_node->parent_uuid() > 0) { grpc_core::RefCountedPtr parent_node = grpc_core::channelz::ChannelzRegistry::Get( channel->channelz_node->parent_uuid()); if (parent_node != nullptr) { grpc_core::channelz::ChannelNode* parent = static_cast(parent_node.get()); parent->RemoveChildChannel(channel->channelz_node->uuid()); } } channel->channelz_node->AddTraceEvent( grpc_core::channelz::ChannelTrace::Severity::Info, grpc_slice_from_static_string("Channel destroyed")); channel->channelz_node.reset(); } grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel)); while (channel->registered_calls) { registered_call* rc = channel->registered_calls; channel->registered_calls = rc->next; GRPC_MDELEM_UNREF(rc->path); GRPC_MDELEM_UNREF(rc->authority); gpr_free(rc); } if (channel->resource_user != nullptr) { grpc_resource_user_free(channel->resource_user, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE); } gpr_mu_destroy(&channel->registered_call_mu); gpr_free(channel->target); gpr_free(channel); // See comment in grpc_channel_create() for why we do this. grpc_shutdown(); } void grpc_channel_destroy(grpc_channel* channel) { grpc_transport_op* op = grpc_make_transport_op(nullptr); grpc_channel_element* elem; grpc_core::ExecCtx exec_ctx; GRPC_API_TRACE("grpc_channel_destroy(channel=%p)", 1, (channel)); op->disconnect_with_error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel Destroyed"); elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0); elem->filter->start_transport_op(elem, op); GRPC_CHANNEL_INTERNAL_UNREF(channel, "channel"); } grpc_mdelem grpc_channel_get_reffed_status_elem_slowpath(grpc_channel* channel, int i) { char tmp[GPR_LTOA_MIN_BUFSIZE]; gpr_ltoa(i, tmp); return grpc_mdelem_from_slices(GRPC_MDSTR_GRPC_STATUS, grpc_core::UnmanagedMemorySlice(tmp)); }