| /* |
| * |
| * Copyright 2015-2016, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #include "src/core/transport/chttp2/internal.h" |
| |
| #include <limits.h> |
| |
| #include <grpc/support/log.h> |
| |
| #include "src/core/profiling/timers.h" |
| #include "src/core/transport/chttp2/http2_errors.h" |
| |
| static void finalize_outbuf(grpc_exec_ctx *exec_ctx, |
| grpc_chttp2_transport_writing *transport_writing); |
| |
| int grpc_chttp2_unlocking_check_writes( |
| grpc_chttp2_transport_global *transport_global, |
| grpc_chttp2_transport_writing *transport_writing, int is_parsing) { |
| grpc_chttp2_stream_global *stream_global; |
| grpc_chttp2_stream_writing *stream_writing; |
| |
| GPR_TIMER_BEGIN("grpc_chttp2_unlocking_check_writes", 0); |
| |
| /* simple writes are queued to qbuf, and flushed here */ |
| gpr_slice_buffer_swap(&transport_global->qbuf, &transport_writing->outbuf); |
| GPR_ASSERT(transport_global->qbuf.count == 0); |
| |
| grpc_chttp2_hpack_compressor_set_max_table_size( |
| &transport_writing->hpack_compressor, |
| transport_global->settings[GRPC_PEER_SETTINGS] |
| [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]); |
| |
| if (transport_global->dirtied_local_settings && |
| !transport_global->sent_local_settings && !is_parsing) { |
| gpr_slice_buffer_add( |
| &transport_writing->outbuf, |
| grpc_chttp2_settings_create( |
| transport_global->settings[GRPC_SENT_SETTINGS], |
| transport_global->settings[GRPC_LOCAL_SETTINGS], |
| transport_global->force_send_settings, GRPC_CHTTP2_NUM_SETTINGS)); |
| transport_global->force_send_settings = 0; |
| transport_global->dirtied_local_settings = 0; |
| transport_global->sent_local_settings = 1; |
| } |
| |
| GRPC_CHTTP2_FLOW_MOVE_TRANSPORT("write", transport_writing, outgoing_window, |
| transport_global, outgoing_window); |
| bool is_window_available = transport_writing->outgoing_window > 0; |
| grpc_chttp2_list_flush_writing_stalled_by_transport(transport_writing, |
| is_window_available); |
| |
| /* for each grpc_chttp2_stream that's become writable, frame it's data |
| (according to available window sizes) and add to the output buffer */ |
| while (grpc_chttp2_list_pop_writable_stream( |
| transport_global, transport_writing, &stream_global, &stream_writing)) { |
| uint8_t sent_initial_metadata; |
| |
| stream_writing->id = stream_global->id; |
| stream_writing->read_closed = stream_global->read_closed; |
| |
| GRPC_CHTTP2_FLOW_MOVE_STREAM("write", transport_writing, stream_writing, |
| outgoing_window, stream_global, |
| outgoing_window); |
| |
| sent_initial_metadata = stream_writing->sent_initial_metadata; |
| if (!sent_initial_metadata && stream_global->send_initial_metadata) { |
| stream_writing->send_initial_metadata = |
| stream_global->send_initial_metadata; |
| stream_global->send_initial_metadata = NULL; |
| if (grpc_chttp2_list_add_writing_stream(transport_writing, |
| stream_writing)) { |
| GRPC_CHTTP2_STREAM_REF(stream_global, "chttp2_writing"); |
| } |
| sent_initial_metadata = 1; |
| } |
| if (sent_initial_metadata) { |
| if (stream_global->send_message != NULL) { |
| gpr_slice hdr = gpr_slice_malloc(5); |
| uint8_t *p = GPR_SLICE_START_PTR(hdr); |
| uint32_t len = stream_global->send_message->length; |
| GPR_ASSERT(stream_writing->send_message == NULL); |
| p[0] = (stream_global->send_message->flags & |
| GRPC_WRITE_INTERNAL_COMPRESS) != 0; |
| p[1] = (uint8_t)(len >> 24); |
| p[2] = (uint8_t)(len >> 16); |
| p[3] = (uint8_t)(len >> 8); |
| p[4] = (uint8_t)(len); |
| gpr_slice_buffer_add(&stream_writing->flow_controlled_buffer, hdr); |
| if (stream_global->send_message->length > 0) { |
| stream_writing->send_message = stream_global->send_message; |
| } else { |
| stream_writing->send_message = NULL; |
| } |
| stream_writing->stream_fetched = 0; |
| stream_global->send_message = NULL; |
| } |
| if ((stream_writing->send_message != NULL || |
| stream_writing->flow_controlled_buffer.length > 0) && |
| stream_writing->outgoing_window > 0) { |
| if (transport_writing->outgoing_window > 0) { |
| if (grpc_chttp2_list_add_writing_stream(transport_writing, |
| stream_writing)) { |
| GRPC_CHTTP2_STREAM_REF(stream_global, "chttp2_writing"); |
| } |
| } else { |
| grpc_chttp2_list_add_writing_stalled_by_transport(transport_writing, |
| stream_writing); |
| } |
| } |
| if (stream_global->send_trailing_metadata) { |
| stream_writing->send_trailing_metadata = |
| stream_global->send_trailing_metadata; |
| stream_global->send_trailing_metadata = NULL; |
| if (grpc_chttp2_list_add_writing_stream(transport_writing, |
| stream_writing)) { |
| GRPC_CHTTP2_STREAM_REF(stream_global, "chttp2_writing"); |
| } |
| } |
| } |
| |
| if (!stream_global->read_closed && |
| stream_global->unannounced_incoming_window_for_writing > 1024) { |
| GRPC_CHTTP2_FLOW_MOVE_STREAM("write", transport_global, stream_writing, |
| announce_window, stream_global, |
| unannounced_incoming_window_for_writing); |
| if (grpc_chttp2_list_add_writing_stream(transport_writing, |
| stream_writing)) { |
| GRPC_CHTTP2_STREAM_REF(stream_global, "chttp2_writing"); |
| } |
| } |
| } |
| |
| /* if the grpc_chttp2_transport is ready to send a window update, do so here |
| also; 3/4 is a magic number that will likely get tuned soon */ |
| if (transport_global->announce_incoming_window > 0) { |
| uint32_t announced = (uint32_t)GPR_MIN( |
| transport_global->announce_incoming_window, UINT32_MAX); |
| GRPC_CHTTP2_FLOW_DEBIT_TRANSPORT("write", transport_global, |
| announce_incoming_window, announced); |
| gpr_slice_buffer_add(&transport_writing->outbuf, |
| grpc_chttp2_window_update_create(0, announced)); |
| } |
| |
| GPR_TIMER_END("grpc_chttp2_unlocking_check_writes", 0); |
| |
| return transport_writing->outbuf.count > 0 || |
| grpc_chttp2_list_have_writing_streams(transport_writing); |
| } |
| |
| void grpc_chttp2_perform_writes( |
| grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_writing *transport_writing, |
| grpc_endpoint *endpoint) { |
| GPR_ASSERT(transport_writing->outbuf.count > 0 || |
| grpc_chttp2_list_have_writing_streams(transport_writing)); |
| |
| finalize_outbuf(exec_ctx, transport_writing); |
| |
| GPR_ASSERT(endpoint); |
| |
| if (transport_writing->outbuf.count > 0) { |
| grpc_endpoint_write(exec_ctx, endpoint, &transport_writing->outbuf, |
| &transport_writing->done_cb); |
| } else { |
| grpc_exec_ctx_enqueue(exec_ctx, &transport_writing->done_cb, true, NULL); |
| } |
| } |
| |
| static void finalize_outbuf(grpc_exec_ctx *exec_ctx, |
| grpc_chttp2_transport_writing *transport_writing) { |
| grpc_chttp2_stream_writing *stream_writing; |
| |
| GPR_TIMER_BEGIN("finalize_outbuf", 0); |
| |
| while ( |
| grpc_chttp2_list_pop_writing_stream(transport_writing, &stream_writing)) { |
| uint32_t max_outgoing = |
| (uint32_t)GPR_MIN(GRPC_CHTTP2_MAX_PAYLOAD_LENGTH, |
| GPR_MIN(stream_writing->outgoing_window, |
| transport_writing->outgoing_window)); |
| /* send initial metadata if it's available */ |
| if (stream_writing->send_initial_metadata != NULL) { |
| grpc_chttp2_encode_header( |
| &transport_writing->hpack_compressor, stream_writing->id, |
| stream_writing->send_initial_metadata, 0, &transport_writing->outbuf); |
| stream_writing->send_initial_metadata = NULL; |
| stream_writing->sent_initial_metadata = 1; |
| } |
| /* send any window updates */ |
| if (stream_writing->announce_window > 0 && |
| stream_writing->send_initial_metadata == NULL) { |
| uint32_t announce = stream_writing->announce_window; |
| gpr_slice_buffer_add( |
| &transport_writing->outbuf, |
| grpc_chttp2_window_update_create(stream_writing->id, |
| stream_writing->announce_window)); |
| GRPC_CHTTP2_FLOW_DEBIT_STREAM("write", transport_writing, stream_writing, |
| announce_window, announce); |
| stream_writing->announce_window = 0; |
| } |
| /* fetch any body bytes */ |
| while (!stream_writing->fetching && stream_writing->send_message && |
| stream_writing->flow_controlled_buffer.length < max_outgoing && |
| stream_writing->stream_fetched < |
| stream_writing->send_message->length) { |
| if (grpc_byte_stream_next(exec_ctx, stream_writing->send_message, |
| &stream_writing->fetching_slice, max_outgoing, |
| &stream_writing->finished_fetch)) { |
| stream_writing->stream_fetched += |
| GPR_SLICE_LENGTH(stream_writing->fetching_slice); |
| if (stream_writing->stream_fetched == |
| stream_writing->send_message->length) { |
| stream_writing->send_message = NULL; |
| } |
| gpr_slice_buffer_add(&stream_writing->flow_controlled_buffer, |
| stream_writing->fetching_slice); |
| } else { |
| stream_writing->fetching = 1; |
| } |
| } |
| /* send any body bytes */ |
| if (stream_writing->flow_controlled_buffer.length > 0) { |
| if (max_outgoing > 0) { |
| uint32_t send_bytes = (uint32_t)GPR_MIN( |
| max_outgoing, stream_writing->flow_controlled_buffer.length); |
| int is_last_data_frame = |
| stream_writing->send_message == NULL && |
| send_bytes == stream_writing->flow_controlled_buffer.length; |
| int is_last_frame = is_last_data_frame && |
| stream_writing->send_trailing_metadata != NULL && |
| grpc_metadata_batch_is_empty( |
| stream_writing->send_trailing_metadata); |
| grpc_chttp2_encode_data( |
| stream_writing->id, &stream_writing->flow_controlled_buffer, |
| send_bytes, is_last_frame, &transport_writing->outbuf); |
| GRPC_CHTTP2_FLOW_DEBIT_STREAM("write", transport_writing, |
| stream_writing, outgoing_window, |
| send_bytes); |
| GRPC_CHTTP2_FLOW_DEBIT_TRANSPORT("write", transport_writing, |
| outgoing_window, send_bytes); |
| if (is_last_frame) { |
| stream_writing->send_trailing_metadata = NULL; |
| stream_writing->sent_trailing_metadata = 1; |
| } |
| if (is_last_data_frame) { |
| GPR_ASSERT(stream_writing->send_message == NULL); |
| stream_writing->sent_message = 1; |
| } |
| } else if (transport_writing->outgoing_window == 0) { |
| grpc_chttp2_list_add_writing_stalled_by_transport(transport_writing, |
| stream_writing); |
| grpc_chttp2_list_add_written_stream(transport_writing, stream_writing); |
| } |
| } |
| /* send trailing metadata if it's available and we're ready for it */ |
| if (stream_writing->send_message == NULL && |
| stream_writing->flow_controlled_buffer.length == 0 && |
| stream_writing->send_trailing_metadata != NULL) { |
| if (grpc_metadata_batch_is_empty( |
| stream_writing->send_trailing_metadata)) { |
| grpc_chttp2_encode_data(stream_writing->id, |
| &stream_writing->flow_controlled_buffer, 0, 1, |
| &transport_writing->outbuf); |
| } else { |
| grpc_chttp2_encode_header(&transport_writing->hpack_compressor, |
| stream_writing->id, |
| stream_writing->send_trailing_metadata, 1, |
| &transport_writing->outbuf); |
| } |
| if (!transport_writing->is_client && !stream_writing->read_closed) { |
| gpr_slice_buffer_add(&transport_writing->outbuf, |
| grpc_chttp2_rst_stream_create( |
| stream_writing->id, GRPC_CHTTP2_NO_ERROR)); |
| } |
| stream_writing->send_trailing_metadata = NULL; |
| stream_writing->sent_trailing_metadata = 1; |
| } |
| /* if there's more to write, then loop, otherwise prepare to finish the |
| * write */ |
| if ((stream_writing->flow_controlled_buffer.length > 0 || |
| (stream_writing->send_message && !stream_writing->fetching)) && |
| stream_writing->outgoing_window > 0) { |
| if (transport_writing->outgoing_window > 0) { |
| if (grpc_chttp2_list_add_writing_stream(transport_writing, |
| stream_writing)) { |
| /* do nothing - already reffed */ |
| } |
| } else { |
| grpc_chttp2_list_add_writing_stalled_by_transport(transport_writing, |
| stream_writing); |
| grpc_chttp2_list_add_written_stream(transport_writing, stream_writing); |
| } |
| } else { |
| grpc_chttp2_list_add_written_stream(transport_writing, stream_writing); |
| } |
| } |
| |
| GPR_TIMER_END("finalize_outbuf", 0); |
| } |
| |
| void grpc_chttp2_cleanup_writing( |
| grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_global *transport_global, |
| grpc_chttp2_transport_writing *transport_writing) { |
| grpc_chttp2_stream_writing *stream_writing; |
| grpc_chttp2_stream_global *stream_global; |
| |
| while (grpc_chttp2_list_pop_written_stream( |
| transport_global, transport_writing, &stream_global, &stream_writing)) { |
| if (stream_writing->sent_initial_metadata) { |
| grpc_chttp2_complete_closure_step( |
| exec_ctx, &stream_global->send_initial_metadata_finished, 1); |
| } |
| if (stream_writing->sent_message) { |
| GPR_ASSERT(stream_writing->send_message == NULL); |
| grpc_chttp2_complete_closure_step( |
| exec_ctx, &stream_global->send_message_finished, 1); |
| stream_writing->sent_message = 0; |
| } |
| if (stream_writing->sent_trailing_metadata) { |
| grpc_chttp2_complete_closure_step( |
| exec_ctx, &stream_global->send_trailing_metadata_finished, 1); |
| } |
| if (stream_writing->sent_trailing_metadata) { |
| grpc_chttp2_mark_stream_closed(exec_ctx, transport_global, stream_global, |
| !transport_global->is_client, 1); |
| } |
| GRPC_CHTTP2_STREAM_UNREF(exec_ctx, stream_global, "chttp2_writing"); |
| } |
| gpr_slice_buffer_reset_and_unref(&transport_writing->outbuf); |
| } |
