GRPC C++  1.39.1
internal.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
20 #define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
21 
23 
24 #include <assert.h>
25 #include <stdbool.h>
26 
47 
48 namespace grpc_core {
49 class ContextList;
50 }
51 
52 /* streams are kept in various linked lists depending on what things need to
53  happen to them... this enum labels each list */
54 typedef enum {
55  /* If a stream is in the following two lists, an explicit ref is associated
56  with the stream */
59  /* No additional ref is taken for the following refs. Make sure to remove the
60  stream from these lists when the stream is removed. */
66  STREAM_LIST_COUNT /* must be last */
68 
69 typedef enum {
74 
75 typedef enum {
79 
80 typedef enum {
84  GRPC_CHTTP2_PCL_COUNT /* must be last */
86 
87 typedef enum {
110 
113 
116  uint64_t inflight_id = 0;
117 };
122 };
128 };
132 };
133 /* deframer state for the overall http2 stream of bytes */
134 typedef enum {
135  /* prefix: one entry per http2 connection prefix byte */
160  /* frame header byte 0... */
161  /* must follow from the prefix states */
170  /* ... frame header byte 8 */
172  /* inside a http2 frame */
175 
179 };
183 };
184 /* We keep several sets of connection wide parameters */
185 typedef enum {
186  /* The settings our peer has asked for (and we have acked) */
188  /* The settings we'd like to have */
190  /* The settings we've published to our peer */
192  /* The settings the peer has acked */
196 
197 typedef enum {
202 
203 typedef struct grpc_chttp2_write_cb {
204  int64_t call_at_byte;
208 
209 namespace grpc_core {
210 
212  public:
214  grpc_chttp2_stream* stream, uint32_t frame_size,
215  uint32_t flags);
216 
217  void Orphan() override;
218 
219  bool Next(size_t max_size_hint, grpc_closure* on_complete) override;
221  void Shutdown(grpc_error_handle error) override;
222 
223  // TODO(roth): When I converted this class to C++, I wanted to make it
224  // inherit from RefCounted or InternallyRefCounted instead of continuing
225  // to use its own custom ref-counting code. However, that would require
226  // using multiple inheritance, which sucks in general. And to make matters
227  // worse, it causes problems with our New<> and Delete<> wrappers.
228  // Specifically, unless RefCounted is first in the list of parent classes,
229  // it will see a different value of the address of the object than the one
230  // we actually allocated, in which case gpr_free() will be called on a
231  // different address than the one we got from gpr_malloc(), thus causing a
232  // crash. Given the fragility of depending on that, as well as a desire to
233  // avoid multiple inheritance in general, I've decided to leave this
234  // alone for now. We can revisit this once we're able to link against
235  // libc++, at which point we can eliminate New<> and Delete<> and
236  // switch to std::shared_ptr<>.
237  void Ref() { refs_.Ref(); }
238  void Unref() {
239  if (GPR_UNLIKELY(refs_.Unref())) {
240  delete this;
241  }
242  }
243 
245 
246  grpc_error_handle Push(const grpc_slice& slice, grpc_slice* slice_out);
247 
248  grpc_error_handle Finished(grpc_error_handle error, bool reset_on_error);
249 
250  uint32_t remaining_bytes() const { return remaining_bytes_; }
251 
252  private:
253  static void NextLocked(void* arg, grpc_error_handle error_ignored);
254  static void OrphanLocked(void* arg, grpc_error_handle error_ignored);
255 
256  void MaybeCreateStreamDecompressionCtx();
257 
258  grpc_chttp2_transport* transport_; // Immutable.
259  grpc_chttp2_stream* stream_; // Immutable.
260 
261  grpc_core::RefCount refs_;
262 
263  /* Accessed only by transport thread when stream->pending_byte_stream == false
264  * Accessed only by application thread when stream->pending_byte_stream ==
265  * true */
266  uint32_t remaining_bytes_;
267 
268  /* Accessed only by transport thread when stream->pending_byte_stream == false
269  * Accessed only by application thread when stream->pending_byte_stream ==
270  * true */
271  struct {
275  } next_action_;
276  grpc_closure destroy_action_;
277 };
278 
279 } // namespace grpc_core
280 
281 typedef enum {
287 
289  grpc_chttp2_transport(const grpc_channel_args* channel_args,
290  grpc_endpoint* ep, bool is_client,
293 
294  grpc_transport base; /* must be first */
297  std::string peer_string;
298 
300 
302 
305 
308 
310  uint8_t destroying = false;
313 
315  uint8_t endpoint_reading = 1;
316 
319 
322 
326 
328 
331 
336 
337  /* accept stream callback */
338  void (*accept_stream_cb)(void* user_data, grpc_transport* transport,
339  const void* server_data);
341 
344 
350  bool is_client;
351 
354 
357  uint32_t write_buffer_size = grpc_core::chttp2::kDefaultWindow;
358 
362 
364 
368  bool sent_local_settings = false;
375 
378  uint32_t next_stream_id = 0;
379 
381  uint32_t last_new_stream_id = 0;
382 
387  uint64_t ping_ctr = 0; /* unique id for pings */
389 
391  size_t ping_ack_count = 0;
392  size_t ping_ack_capacity = 0;
393  uint64_t* ping_acks = nullptr;
395 
399  union {
407 
417 
418  /* deframing */
420  uint8_t incoming_frame_type = 0;
421  uint8_t incoming_frame_flags = 0;
422  uint8_t header_eof = 0;
423  bool is_first_frame = true;
425  uint32_t incoming_frame_size = 0;
426  uint32_t incoming_stream_id = 0;
427 
428  /* active parser */
429  void* parser_data = nullptr;
431  grpc_error_handle (*parser)(void* parser_user_data, grpc_chttp2_transport* t,
433  int is_last);
434 
436 
437  /* bdp estimator */
439  false; /* Is the BDP blocked due to not receiving any data? */
443 
444  /* if non-NULL, close the transport with this error when writes are finished
445  */
447 
448  /* a list of closures to run after writes are finished */
450 
451  /* buffer pool state */
460 
461  /* next bdp ping timer */
464  bool bdp_ping_started = false;
466 
467  /* keep-alive ping support */
500 };
501 
502 typedef enum {
508 
511  const void* server_data, grpc_core::Arena* arena);
513 
514  void* context;
517  // Reffer is a 0-len structure, simply reffing `t` and `refcount` in its ctor
518  // before initializing the rest of the stream, to avoid cache misses. This
519  // field MUST be right after `t` and `refcount`.
520  struct Reffer {
521  explicit Reffer(grpc_chttp2_stream* s);
523 
526 
529 
531  uint32_t id = 0;
532 
537  // TODO(yashykt): Find a better name for the below field and others in this
538  // struct to betteer distinguish inputs, return values, and
539  // internal state.
540  // sent_trailing_metadata_op allows the transport to fill in to the upper
541  // layer whether this stream was able to send its trailing metadata (used for
542  // detecting cancellation on the server-side)..
543  bool* sent_trailing_metadata_op = nullptr;
545 
554 
563 
566 
568  bool write_closed = false;
570  bool read_closed = false;
575  bool seen_error = false;
578  bool write_buffering = false;
579 
580  /* have we sent or received the EOS bit? */
581  bool eos_received = false;
582  bool eos_sent = false;
583 
588 
591 
593 
594  grpc_slice_buffer frame_storage; /* protected by t combiner */
595 
596  grpc_closure* on_next = nullptr; /* protected by t combiner */
597  bool pending_byte_stream = false; /* protected by t combiner */
598  // cached length of buffer to be used by the transport thread in cases where
599  // stream->pending_byte_stream == true. The value is saved before
600  // application threads are allowed to modify
601  // unprocessed_incoming_frames_buffer
603  /* Accessed only by transport thread when stream->pending_byte_stream == false
604  * Accessed only by application thread when stream->pending_byte_stream ==
605  * true */
609  GRPC_ERROR_NONE; /* protected by t combiner */
610  bool received_last_frame = false; /* protected by t combiner */
611 
613 
619  /* Accessed only by transport thread when stream->pending_byte_stream == false
620  * Accessed only by application thread when stream->pending_byte_stream ==
621  * true */
624  int64_t received_bytes = 0;
625 
626  bool sent_initial_metadata = false;
628 
634 
636 
640  size_t sending_bytes = 0;
641 
642  /* Stream compression method to be used. */
645  /* Stream decompression method to be used. */
648 
653  bool traced = false;
657  size_t byte_counter = 0;
658 
666 
674 };
675 
690 
693  bool writing;
695  bool partial;
698 };
702 
706  const grpc_slice& slice);
707 
709  grpc_chttp2_stream* s);
713  grpc_chttp2_stream** s);
715  grpc_chttp2_stream* s);
716 
718  grpc_chttp2_stream* s);
721  grpc_chttp2_stream** s);
722 
724  grpc_chttp2_stream* s);
726  grpc_chttp2_stream** s);
727 
729  grpc_chttp2_stream* s);
731  grpc_chttp2_stream** s);
733  grpc_chttp2_stream* s);
734 
736  grpc_chttp2_stream* s);
738  grpc_chttp2_stream** s);
740  grpc_chttp2_stream* s);
741 
743  grpc_chttp2_stream* s);
745  grpc_chttp2_stream** s);
747  grpc_chttp2_stream* s);
748 
749 /********* Flow Control ***************/
750 
751 // Takes in a flow control action and performs all the needed operations.
755 
756 /********* End of Flow Control ***************/
757 
759  grpc_chttp2_transport* t, uint32_t id) {
760  return static_cast<grpc_chttp2_stream*>(
762 }
764  uint32_t id);
765 
767  uint32_t goaway_error,
768  uint32_t last_stream_id,
769  const grpc_slice& goaway_text);
770 
772 
775  grpc_closure** pclosure,
777  const char* desc);
778 
779 #define GRPC_HEADER_SIZE_IN_BYTES 5
780 #define MAX_SIZE_T (~(size_t)0)
781 
782 #define GRPC_CHTTP2_CLIENT_CONNECT_STRING "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
783 #define GRPC_CHTTP2_CLIENT_CONNECT_STRLEN \
784  (sizeof(GRPC_CHTTP2_CLIENT_CONNECT_STRING) - 1)
785 
786 // extern grpc_core::TraceFlag grpc_http_trace;
787 // extern grpc_core::TraceFlag grpc_flowctl_trace;
788 
789 #define GRPC_CHTTP2_IF_TRACING(stmt) \
790  do { \
791  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) { \
792  (stmt); \
793  } \
794  } while (0)
795 
797  grpc_chttp2_stream* stream,
800  grpc_chttp2_stream* s, int close_reads,
801  int close_writes, grpc_error_handle error);
803 
804 #ifndef NDEBUG
805 #define GRPC_CHTTP2_STREAM_REF(stream, reason) \
806  grpc_chttp2_stream_ref(stream, reason)
807 #define GRPC_CHTTP2_STREAM_UNREF(stream, reason) \
808  grpc_chttp2_stream_unref(stream, reason)
809 void grpc_chttp2_stream_ref(grpc_chttp2_stream* s, const char* reason);
810 void grpc_chttp2_stream_unref(grpc_chttp2_stream* s, const char* reason);
811 #else
812 #define GRPC_CHTTP2_STREAM_REF(stream, reason) grpc_chttp2_stream_ref(stream)
813 #define GRPC_CHTTP2_STREAM_UNREF(stream, reason) \
814  grpc_chttp2_stream_unref(stream)
817 #endif
818 
819 #ifndef NDEBUG
820 #define GRPC_CHTTP2_REF_TRANSPORT(t, r) \
821  grpc_chttp2_ref_transport(t, r, __FILE__, __LINE__)
822 #define GRPC_CHTTP2_UNREF_TRANSPORT(t, r) \
823  grpc_chttp2_unref_transport(t, r, __FILE__, __LINE__)
825  const char* reason, const char* file,
826  int line) {
827  if (t->refs.Unref(grpc_core::DebugLocation(file, line), reason)) {
828  delete t;
829  }
830 }
832  const char* reason, const char* file,
833  int line) {
834  t->refs.Ref(grpc_core::DebugLocation(file, line), reason);
835 }
836 #else
837 #define GRPC_CHTTP2_REF_TRANSPORT(t, r) grpc_chttp2_ref_transport(t)
838 #define GRPC_CHTTP2_UNREF_TRANSPORT(t, r) grpc_chttp2_unref_transport(t)
840  if (t->refs.Unref()) {
841  delete t;
842  }
843 }
845  t->refs.Ref();
846 }
847 #endif
848 
849 void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id);
850 
856 
862 
866  grpc_chttp2_stream* s);
867 
869  grpc_error_handle due_to_error);
870 
872  grpc_chttp2_stream* s);
874  grpc_chttp2_stream* s);
876  grpc_chttp2_stream* s);
877 
881 
885  bool is_client);
886 
888 
890 
891 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H */
Definition: arena.h:44
Definition: byte_stream.h:41
uint32_t flags() const
Definition: byte_stream.h:71
Definition: internal.h:211
grpc_error_handle Push(const grpc_slice &slice, grpc_slice *slice_out)
Definition: chttp2_transport.cc:3119
uint32_t remaining_bytes() const
Definition: internal.h:250
grpc_closure * on_complete
Definition: internal.h:274
Chttp2IncomingByteStream(grpc_chttp2_transport *transport, grpc_chttp2_stream *stream, uint32_t frame_size, uint32_t flags)
Definition: chttp2_transport.cc:2962
grpc_error_handle Pull(grpc_slice *slice) override
Definition: chttp2_transport.cc:3064
void PublishError(grpc_error_handle error)
Definition: chttp2_transport.cc:3109
grpc_closure closure
Definition: internal.h:272
void Ref()
Definition: internal.h:237
void Shutdown(grpc_error_handle error) override
Definition: chttp2_transport.cc:3152
size_t max_size_hint
Definition: internal.h:273
bool Next(size_t max_size_hint, grpc_closure *on_complete) override
Definition: chttp2_transport.cc:3038
grpc_error_handle Finished(grpc_error_handle error, bool reset_on_error)
Definition: chttp2_transport.cc:3137
void Orphan() override
Definition: chttp2_transport.cc:2985
void Unref()
Definition: internal.h:238
Definition: combiner.h:33
Definition: connectivity_state.h:98
A list of RPC Contexts.
Definition: context_list.h:30
Definition: debug_location.h:31
Definition: manual_constructor.h:104
Definition: ref_counted.h:47
void Ref(Value n=1)
Definition: ref_counted.h:71
bool Unref()
Definition: ref_counted.h:155
Definition: flow_control.h:57
Definition: flow_control.h:337
Definition: flow_control.h:391
Definition: flow_control.h:409
Definition: flow_control.h:144
Definition: flow_control.h:221
#define GRPC_CLOSURE_LIST_INIT
Definition: closure.h:167
grpc_error * grpc_error_handle
Definition: error.h:48
#define GRPC_ERROR_NONE
The following "special" errors can be propagated without allocating memory.
Definition: error.h:228
int64_t grpc_millis
Definition: exec_ctx.h:37
#define GRPC_MILLIS_INF_FUTURE
Definition: exec_ctx.h:39
GPRAPI grpc_slice grpc_empty_slice(void)
Definition: slice.cc:40
@ GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE
Definition: http2_settings.h:33
#define GRPC_CHTTP2_NUM_SETTINGS
Definition: http2_settings.h:39
#define GPR_UNLIKELY(x)
Definition: port_platform.h:660
void grpc_chttp2_mark_stream_closed(grpc_chttp2_transport *t, grpc_chttp2_stream *s, int close_reads, int close_writes, grpc_error_handle error)
Definition: chttp2_transport.cc:2200
void grpc_chttp2_list_add_waiting_for_concurrency(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:171
grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport *t, const grpc_slice &slice)
Process one slice of incoming data; return 1 if the connection is still viable after reading,...
Definition: parsing.cc:56
void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: chttp2_transport.cc:1873
void grpc_chttp2_cancel_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s, grpc_error_handle due_to_error)
Definition: chttp2_transport.cc:2071
void grpc_chttp2_end_write(grpc_chttp2_transport *t, grpc_error_handle error)
Definition: writing.cc:685
void grpc_chttp2_add_ping_strike(grpc_chttp2_transport *t)
Add a new ping strike to ping_recv_state.ping_strikes.
Definition: chttp2_transport.cc:1770
bool grpc_chttp2_list_pop_writable_stream(grpc_chttp2_transport *t, grpc_chttp2_stream **s)
Get a writable stream returns non-zero if there was a stream available.
Definition: stream_lists.cc:147
void schedule_bdp_ping_locked(grpc_chttp2_transport *t)
Definition: chttp2_transport.cc:2614
bool grpc_chttp2_list_pop_writing_stream(grpc_chttp2_transport *t, grpc_chttp2_stream **s)
Definition: stream_lists.cc:166
grpc_chttp2_stream * grpc_chttp2_parsing_lookup_stream(grpc_chttp2_transport *t, uint32_t id)
Definition: internal.h:758
void grpc_chttp2_mark_stream_writable(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
add a ref to the stream and add it to the writable list; ref will be dropped in writing....
Definition: chttp2_transport.cc:941
grpc_chttp2_initiate_write_reason
Definition: internal.h:87
@ GRPC_CHTTP2_INITIATE_WRITE_GOAWAY_SENT
Definition: internal.h:95
@ GRPC_CHTTP2_INITIATE_WRITE_CLOSE_FROM_API
Definition: internal.h:97
@ GRPC_CHTTP2_INITIATE_WRITE_SEND_SETTINGS
Definition: internal.h:100
@ GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_SETTING
Definition: internal.h:101
@ GRPC_CHTTP2_INITIATE_WRITE_SEND_INITIAL_METADATA
Definition: internal.h:91
@ GRPC_CHTTP2_INITIATE_WRITE_APPLICATION_PING
Definition: internal.h:103
@ GRPC_CHTTP2_INITIATE_WRITE_RETRY_SEND_PING
Definition: internal.h:93
@ GRPC_CHTTP2_INITIATE_WRITE_PING_RESPONSE
Definition: internal.h:107
@ GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM
Definition: internal.h:96
@ GRPC_CHTTP2_INITIATE_WRITE_BDP_PING
Definition: internal.h:104
@ GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING
Definition: internal.h:105
@ GRPC_CHTTP2_INITIATE_WRITE_START_NEW_STREAM
Definition: internal.h:89
@ GRPC_CHTTP2_INITIATE_WRITE_CONTINUE_PINGS
Definition: internal.h:94
@ GRPC_CHTTP2_INITIATE_WRITE_SEND_TRAILING_METADATA
Definition: internal.h:92
@ GRPC_CHTTP2_INITIATE_WRITE_STREAM_FLOW_CONTROL
Definition: internal.h:98
@ GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL
Definition: internal.h:99
@ GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM
Definition: internal.h:108
@ GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_UPDATE
Definition: internal.h:102
@ GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL_UNSTALLED
Definition: internal.h:106
@ GRPC_CHTTP2_INITIATE_WRITE_SEND_MESSAGE
Definition: internal.h:90
@ GRPC_CHTTP2_INITIATE_WRITE_INITIAL_WRITE
Definition: internal.h:88
struct grpc_chttp2_write_cb grpc_chttp2_write_cb
grpc_chttp2_write_state
Definition: internal.h:69
@ GRPC_CHTTP2_WRITE_STATE_WRITING_WITH_MORE
Definition: internal.h:72
@ GRPC_CHTTP2_WRITE_STATE_IDLE
Definition: internal.h:70
@ GRPC_CHTTP2_WRITE_STATE_WRITING
Definition: internal.h:71
void grpc_chttp2_list_add_written_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
grpc_chttp2_ping_closure_list
Definition: internal.h:80
@ GRPC_CHTTP2_PCL_NEXT
Definition: internal.h:82
@ GRPC_CHTTP2_PCL_COUNT
Definition: internal.h:84
@ GRPC_CHTTP2_PCL_INFLIGHT
Definition: internal.h:83
@ GRPC_CHTTP2_PCL_INITIATE
Definition: internal.h:81
void grpc_chttp2_act_on_flowctl_action(const grpc_core::chttp2::FlowControlAction &action, grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: chttp2_transport.cc:2457
void grpc_chttp2_fake_status(grpc_chttp2_transport *t, grpc_chttp2_stream *stream, grpc_error_handle error)
Definition: chttp2_transport.cc:2095
bool grpc_chttp2_list_pop_stalled_by_stream(grpc_chttp2_transport *t, grpc_chttp2_stream **s)
Definition: stream_lists.cc:208
void grpc_chttp2_initiate_write(grpc_chttp2_transport *t, grpc_chttp2_initiate_write_reason reason)
Transport writing call flow: grpc_chttp2_initiate_write() is called anywhere that we know bytes need ...
Definition: chttp2_transport.cc:901
bool grpc_chttp2_list_add_writing_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:157
bool grpc_chttp2_list_pop_written_stream(grpc_chttp2_transport *t, grpc_chttp2_stream **s)
bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:141
void grpc_chttp2_start_writing(grpc_chttp2_transport *t)
void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport *t)
Definition: parsing.cc:337
void grpc_chttp2_ack_ping(grpc_chttp2_transport *t, uint64_t id)
Definition: chttp2_transport.cc:1740
grpc_published_metadata_method
Definition: internal.h:502
@ GRPC_METADATA_PUBLISHED_AT_CLOSE
Definition: internal.h:506
@ GRPC_METADATA_PUBLISHED_FROM_WIRE
Definition: internal.h:505
@ GRPC_METADATA_NOT_PUBLISHED
Definition: internal.h:503
@ GRPC_METADATA_SYNTHESIZED_FROM_FAKE
Definition: internal.h:504
grpc_chttp2_setting_set
Definition: internal.h:185
@ GRPC_PEER_SETTINGS
Definition: internal.h:187
@ GRPC_ACKED_SETTINGS
Definition: internal.h:193
@ GRPC_LOCAL_SETTINGS
Definition: internal.h:189
@ GRPC_SENT_SETTINGS
Definition: internal.h:191
@ GRPC_NUM_SETTING_SETS
Definition: internal.h:194
grpc_chttp2_deframe_transport_state
Definition: internal.h:134
@ GRPC_DTS_CLIENT_PREFIX_15
Definition: internal.h:151
@ GRPC_DTS_FH_4
Definition: internal.h:166
@ GRPC_DTS_FRAME
Definition: internal.h:173
@ GRPC_DTS_CLIENT_PREFIX_23
Definition: internal.h:159
@ GRPC_DTS_FH_3
Definition: internal.h:165
@ GRPC_DTS_CLIENT_PREFIX_20
Definition: internal.h:156
@ GRPC_DTS_CLIENT_PREFIX_0
Definition: internal.h:136
@ GRPC_DTS_FH_8
Definition: internal.h:171
@ GRPC_DTS_CLIENT_PREFIX_6
Definition: internal.h:142
@ GRPC_DTS_CLIENT_PREFIX_21
Definition: internal.h:157
@ GRPC_DTS_CLIENT_PREFIX_3
Definition: internal.h:139
@ GRPC_DTS_CLIENT_PREFIX_2
Definition: internal.h:138
@ GRPC_DTS_CLIENT_PREFIX_9
Definition: internal.h:145
@ GRPC_DTS_CLIENT_PREFIX_5
Definition: internal.h:141
@ GRPC_DTS_FH_1
Definition: internal.h:163
@ GRPC_DTS_FH_6
Definition: internal.h:168
@ GRPC_DTS_CLIENT_PREFIX_13
Definition: internal.h:149
@ GRPC_DTS_CLIENT_PREFIX_17
Definition: internal.h:153
@ GRPC_DTS_FH_5
Definition: internal.h:167
@ GRPC_DTS_CLIENT_PREFIX_10
Definition: internal.h:146
@ GRPC_DTS_CLIENT_PREFIX_1
Definition: internal.h:137
@ GRPC_DTS_CLIENT_PREFIX_12
Definition: internal.h:148
@ GRPC_DTS_FH_2
Definition: internal.h:164
@ GRPC_DTS_CLIENT_PREFIX_16
Definition: internal.h:152
@ GRPC_DTS_CLIENT_PREFIX_19
Definition: internal.h:155
@ GRPC_DTS_CLIENT_PREFIX_8
Definition: internal.h:144
@ GRPC_DTS_CLIENT_PREFIX_22
Definition: internal.h:158
@ GRPC_DTS_CLIENT_PREFIX_4
Definition: internal.h:140
@ GRPC_DTS_CLIENT_PREFIX_18
Definition: internal.h:154
@ GRPC_DTS_FH_0
Definition: internal.h:162
@ GRPC_DTS_CLIENT_PREFIX_14
Definition: internal.h:150
@ GRPC_DTS_CLIENT_PREFIX_7
Definition: internal.h:143
@ GRPC_DTS_CLIENT_PREFIX_11
Definition: internal.h:147
@ GRPC_DTS_FH_7
Definition: internal.h:169
grpc_chttp2_stream * grpc_chttp2_parsing_accept_stream(grpc_chttp2_transport *t, uint32_t id)
Definition: chttp2_transport.cc:767
bool grpc_chttp2_list_remove_stalled_by_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:213
bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport *t, grpc_chttp2_stream **s)
Definition: stream_lists.cc:192
bool grpc_chttp2_list_have_writing_streams(grpc_chttp2_transport *t)
Definition: stream_lists.cc:162
grpc_chttp2_sent_goaway_state
Definition: internal.h:197
@ GRPC_CHTTP2_NO_GOAWAY_SEND
Definition: internal.h:198
@ GRPC_CHTTP2_GOAWAY_SEND_SCHEDULED
Definition: internal.h:199
@ GRPC_CHTTP2_GOAWAY_SENT
Definition: internal.h:200
grpc_chttp2_keepalive_state
Definition: internal.h:281
@ GRPC_CHTTP2_KEEPALIVE_STATE_WAITING
Definition: internal.h:282
@ GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED
Definition: internal.h:285
@ GRPC_CHTTP2_KEEPALIVE_STATE_PINGING
Definition: internal.h:283
@ GRPC_CHTTP2_KEEPALIVE_STATE_DYING
Definition: internal.h:284
void grpc_chttp2_complete_closure_step(grpc_chttp2_transport *t, grpc_chttp2_stream *s, grpc_closure **pclosure, grpc_error_handle error, const char *desc)
Definition: chttp2_transport.cc:1210
void grpc_chttp2_stream_ref(grpc_chttp2_stream *s, const char *reason)
Definition: chttp2_transport.cc:622
const char * grpc_chttp2_initiate_write_reason_string(grpc_chttp2_initiate_write_reason reason)
Definition: chttp2_transport.cc:3263
void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:181
void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport *t, grpc_chttp2_stream *s, grpc_error_handle error)
Definition: chttp2_transport.cc:2176
void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: chttp2_transport.cc:1962
void grpc_chttp2_list_add_stalled_by_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:202
bool grpc_chttp2_list_pop_waiting_for_concurrency(grpc_chttp2_transport *t, grpc_chttp2_stream **s)
Definition: stream_lists.cc:176
void grpc_chttp2_list_remove_stalled_by_transport(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:197
void grpc_chttp2_stream_unref(grpc_chttp2_stream *s, const char *reason)
Definition: chttp2_transport.cc:625
void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport *t, uint32_t goaway_error, uint32_t last_stream_id, const grpc_slice &goaway_text)
Definition: chttp2_transport.cc:1084
grpc_chttp2_stream_list_id
Definition: internal.h:54
@ GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY
streams that are waiting to start because there are too many concurrent streams on the connection
Definition: internal.h:65
@ GRPC_CHTTP2_LIST_WRITING
Definition: internal.h:58
@ GRPC_CHTTP2_LIST_WRITABLE
Definition: internal.h:57
@ GRPC_CHTTP2_LIST_STALLED_BY_STREAM
Definition: internal.h:62
@ GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT
Definition: internal.h:61
@ STREAM_LIST_COUNT
Definition: internal.h:66
void grpc_chttp2_reset_ping_clock(grpc_chttp2_transport *t)
Resets ping clock.
Definition: chttp2_transport.cc:1785
grpc_chttp2_optimization_target
Definition: internal.h:75
@ GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT
Definition: internal.h:77
@ GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY
Definition: internal.h:76
void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:186
bool grpc_chttp2_list_remove_writable_stream(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: stream_lists.cc:152
void grpc_chttp2_unref_transport(grpc_chttp2_transport *t, const char *reason, const char *file, int line)
Definition: internal.h:824
void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_chttp2_transport *t, grpc_chttp2_stream *s)
Definition: chttp2_transport.cc:1856
grpc_chttp2_begin_write_result grpc_chttp2_begin_write(grpc_chttp2_transport *t)
Definition: writing.cc:638
void grpc_chttp2_retry_initiate_ping(void *tp, grpc_error_handle error)
Definition: chttp2_transport.cc:1724
void grpc_chttp2_ref_transport(grpc_chttp2_transport *t, const char *reason, const char *file, int line)
Definition: internal.h:831
void grpc_chttp2_config_default_keepalive_args(grpc_channel_args *args, bool is_client)
Set the default keepalive configurations, must only be called at initialization.
Definition: chttp2_transport.cc:2712
grpc_error_handle error
Definition: lame_client.cc:54
Round Robin Policy.
Definition: backend_metric.cc:26
std::unique_ptr< T, Deleter > OrphanablePtr
Definition: orphanable.h:67
grpc_slice slice
Definition: server.cc:461
grpc_stream_compression_method
Definition: stream_compression.h:38
@ GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS
Definition: stream_compression.h:40
@ GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
Definition: stream_compression.h:39
void * grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, uint32_t key)
Definition: stream_map.cc:145
An array of arguments that can be passed around.
Definition: grpc_types.h:132
Definition: internal.h:691
bool partial
if writing: was it a complete flush (false) or a partial flush (true)
Definition: internal.h:695
bool early_results_scheduled
did we queue any completions as part of beginning the write
Definition: internal.h:697
bool writing
are we writing?
Definition: internal.h:693
Definition: frame_data.h:46
Definition: frame_goaway.h:40
Definition: hpack_encoder.h:41
Definition: hpack_parser.h:46
Definition: incoming_metadata.h:26
Definition: frame_ping.h:27
Definition: internal.h:114
uint64_t inflight_id
Definition: internal.h:116
grpc_closure_list lists[GRPC_CHTTP2_PCL_COUNT]
Definition: internal.h:115
Definition: internal.h:118
grpc_millis min_recv_ping_interval_without_data
Definition: internal.h:121
int max_ping_strikes
Definition: internal.h:120
int max_pings_without_data
Definition: internal.h:119
Definition: internal.h:123
grpc_millis last_ping_sent_time
Definition: internal.h:124
grpc_timer delayed_ping_timer
Definition: internal.h:126
int pings_before_data_required
Definition: internal.h:125
bool is_delayed_ping_timer_set
Definition: internal.h:127
Definition: frame_rst_stream.h:28
Definition: internal.h:129
grpc_millis last_ping_recv_time
Definition: internal.h:130
int ping_strikes
Definition: internal.h:131
Definition: frame_settings.h:37
Definition: internal.h:520
Reffer(grpc_chttp2_stream *s)
Definition: chttp2_transport.cc:637
Definition: internal.h:176
grpc_chttp2_stream * tail
Definition: internal.h:178
grpc_chttp2_stream * head
Definition: internal.h:177
Definition: stream_map.h:32
Definition: internal.h:509
size_t unprocessed_incoming_frames_buffer_cached_length
Definition: internal.h:602
grpc_metadata_batch * send_initial_metadata
things the upper layers would like to send
Definition: internal.h:534
bool received_last_frame
Definition: internal.h:610
grpc_chttp2_data_parser data_parser
parsing state for data frames
Definition: internal.h:622
bool eos_received
Definition: internal.h:581
grpc_error_handle read_closed_error
the error that resulted in this stream being read-closed
Definition: internal.h:585
grpc_closure * send_trailing_metadata_finished
Definition: internal.h:544
bool sent_initial_metadata
Definition: internal.h:626
grpc_closure * fetching_send_message_finished
Definition: internal.h:553
grpc_chttp2_write_cb * on_write_finished_cbs
Definition: internal.h:638
grpc_metadata_batch * send_trailing_metadata
Definition: internal.h:536
bool eos_sent
Definition: internal.h:582
grpc_error_handle write_closed_error
the error that resulted in this stream being write-closed
Definition: internal.h:587
grpc_slice_buffer compressed_data_buffer
Buffer storing data that is compressed but not sent.
Definition: internal.h:665
grpc_closure complete_fetch_locked
Definition: internal.h:552
grpc_core::OrphanablePtr< grpc_core::ByteStream > * recv_message
Definition: internal.h:558
uint32_t fetched_send_message_length
Definition: internal.h:547
uint8_t header_frames_received
how many header frames have we received?
Definition: internal.h:617
grpc_published_metadata_method published_metadata[2]
Definition: internal.h:589
uint8_t included[STREAM_LIST_COUNT]
Definition: internal.h:528
grpc_slice_buffer flow_controlled_buffer
Definition: internal.h:635
grpc_metadata_batch * recv_trailing_metadata
Definition: internal.h:561
grpc_chttp2_write_cb * on_flow_controlled_cbs
Definition: internal.h:637
size_t byte_counter
Byte counter for number of bytes written.
Definition: internal.h:657
grpc_error_handle byte_stream_error
Definition: internal.h:608
size_t sending_bytes
Definition: internal.h:640
grpc_slice_buffer unprocessed_incoming_frames_buffer
Definition: internal.h:606
grpc_transport_stream_stats stats
Definition: internal.h:565
grpc_closure * send_initial_metadata_finished
Definition: internal.h:535
grpc_closure * recv_trailing_metadata_finished
Definition: internal.h:562
int64_t flow_controlled_bytes_written
Definition: internal.h:550
bool final_metadata_requested
Definition: internal.h:590
bool * call_failed_before_recv_message
Definition: internal.h:559
grpc_chttp2_stream_link links[STREAM_LIST_COUNT]
Definition: internal.h:527
bool traced
Whether the bytes needs to be traced using Fathom.
Definition: internal.h:653
bool unprocessed_incoming_frames_decompressed
Whether bytes stored in unprocessed_incoming_byte_stream is decompressed.
Definition: internal.h:651
size_t decompressed_header_bytes
gRPC header bytes that are already decompressed
Definition: internal.h:655
grpc_millis deadline
Definition: internal.h:612
bool all_incoming_byte_streams_finished
Are all published incoming byte streams closed.
Definition: internal.h:572
bool pending_byte_stream
Definition: internal.h:597
grpc_closure reset_byte_stream
Definition: internal.h:607
grpc_stream_compression_context * stream_compression_ctx
Stream compression compress context.
Definition: internal.h:663
bool write_closed
Is this stream closed for writing.
Definition: internal.h:568
bool sent_trailing_metadata
Definition: internal.h:627
grpc_stream_compression_context * stream_decompression_ctx
Stream compression decompress context.
Definition: internal.h:668
grpc_chttp2_incoming_metadata_buffer metadata_buffer[2]
Definition: internal.h:592
grpc_chttp2_stream(grpc_chttp2_transport *t, grpc_stream_refcount *refcount, const void *server_data, grpc_core::Arena *arena)
Definition: chttp2_transport.cc:645
grpc_closure * destroy_stream_arg
Definition: internal.h:525
grpc_closure * recv_initial_metadata_ready
Definition: internal.h:556
struct grpc_chttp2_stream::Reffer reffer
grpc_core::PolymorphicManualConstructor< grpc_core::chttp2::StreamFlowControlBase, grpc_core::chttp2::StreamFlowControl, grpc_core::chttp2::StreamFlowControlDisabled > flow_control
Definition: internal.h:633
grpc_metadata_batch * recv_initial_metadata
Definition: internal.h:555
grpc_stream_compression_method stream_compression_method
Definition: internal.h:643
int64_t flow_controlled_bytes_flowed
Definition: internal.h:551
grpc_slice_buffer frame_storage
Definition: internal.h:594
grpc_closure * recv_message_ready
Definition: internal.h:560
size_t uncompressed_data_size
Amount of uncompressed bytes sent out when compressed_data_buffer is emptied.
Definition: internal.h:661
void * context
Definition: internal.h:514
grpc_error_handle forced_close_error
saw some stream level error
Definition: internal.h:615
grpc_slice fetching_slice
Definition: internal.h:548
grpc_slice_buffer decompressed_data_buffer
Temporary buffer storing decompressed data.
Definition: internal.h:673
int64_t next_message_end_offset
Definition: internal.h:549
grpc_chttp2_transport * t
Definition: internal.h:515
grpc_closure destroy_stream
Definition: internal.h:524
grpc_core::OrphanablePtr< grpc_core::ByteStream > fetching_send_message
Definition: internal.h:546
int64_t received_bytes
number of bytes received - reset at end of parse thread execution
Definition: internal.h:624
bool * sent_trailing_metadata_op
Definition: internal.h:543
bool write_buffering
Are we buffering writes on this stream? If yes, we won't become writable until there's enough queued ...
Definition: internal.h:578
bool read_closed
Is this stream reading half-closed.
Definition: internal.h:570
~grpc_chttp2_stream()
Definition: chttp2_transport.cc:675
grpc_stream_refcount * refcount
Definition: internal.h:516
grpc_stream_compression_method stream_decompression_method
Definition: internal.h:646
grpc_transport_stream_stats * collecting_stats
Definition: internal.h:564
grpc_chttp2_write_cb * finish_after_write
Definition: internal.h:639
bool * trailing_metadata_available
Definition: internal.h:557
grpc_closure * on_next
Definition: internal.h:596
bool seen_error
Has this stream seen an error.
Definition: internal.h:575
Definition: internal.h:288
grpc_core::ContextList * cl
Definition: internal.h:490
void * parser_data
Definition: internal.h:429
grpc_millis keepalive_timeout
grace period for a ping to complete before watchdog kicks in
Definition: internal.h:483
uint32_t write_buffer_size
how much data are we willing to buffer when the WRITE_BUFFER_HINT is set?
Definition: internal.h:357
grpc_closure read_action_locked
Definition: internal.h:327
uint8_t header_eof
Definition: internal.h:422
bool is_client
is this a client?
Definition: internal.h:350
size_t ping_ack_capacity
Definition: internal.h:392
grpc_closure benign_reclaimer_locked
benign cleanup closure
Definition: internal.h:457
grpc_closure write_action_end_locked
Definition: internal.h:325
grpc_closure finish_keepalive_ping_locked
Cousure to run when the keepalive ping ack is received.
Definition: internal.h:473
uint64_t * ping_acks
Definition: internal.h:393
uint32_t next_stream_id
what is the next stream id to be allocated by this peer? copied to next_stream_id in parsing when par...
Definition: internal.h:378
grpc_chttp2_rst_stream_parser rst_stream
Definition: internal.h:403
int64_t initial_window_update
initial window change.
Definition: internal.h:416
grpc_chttp2_settings_parser settings
Definition: internal.h:401
grpc_chttp2_window_update_parser window_update
Definition: internal.h:400
grpc_millis keepalive_time
time duration in between pings
Definition: internal.h:481
bool bdp_ping_started
If start_bdp_ping_locked has been called.
Definition: internal.h:464
grpc_chttp2_sent_goaway_state sent_goaway_state
Definition: internal.h:363
grpc_closure finish_bdp_ping_locked
Definition: internal.h:442
grpc_chttp2_deframe_transport_state deframe_state
Definition: internal.h:419
grpc_timer keepalive_ping_timer
timer to initiate ping events
Definition: internal.h:477
grpc_closure * notify_on_receive_settings
Definition: internal.h:303
bool dirtied_local_settings
are the local settings dirty and need to be sent?
Definition: internal.h:366
grpc_core::RefCountedPtr< grpc_core::channelz::SocketNode > channelz_socket
Definition: internal.h:491
grpc_closure_list run_after_write
Definition: internal.h:449
uint64_t ping_ctr
Definition: internal.h:387
grpc_error_handle goaway_error
Set to a grpc_error object if a goaway frame is received.
Definition: internal.h:361
bool reading_paused_on_pending_induced_frames
Definition: internal.h:499
grpc_timer keepalive_watchdog_timer
watchdog to kill the transport when waiting for the keepalive ping
Definition: internal.h:479
size_t ping_ack_count
ping acks
Definition: internal.h:391
grpc_chttp2_stream ** accepting_stream
address to place a newly accepted stream - set and unset by grpc_chttp2_parsing_accept_stream; used b...
Definition: internal.h:335
uint32_t incoming_frame_size
Definition: internal.h:425
grpc_closure * notify_on_close
Definition: internal.h:304
bool keepalive_permit_without_calls
if keepalive pings are allowed when there's no outstanding streams
Definition: internal.h:485
grpc_slice_buffer outbuf
data to write now
Definition: internal.h:346
grpc_chttp2_goaway_parser goaway_parser
parser for goaway frames
Definition: internal.h:406
void * accept_stream_cb_user_data
Definition: internal.h:340
grpc_chttp2_repeated_ping_policy ping_policy
Definition: internal.h:385
uint32_t last_new_stream_id
last new stream id
Definition: internal.h:381
uint32_t num_pending_induced_frames
The number of pending induced frames (SETTINGS_ACK, PINGS_ACK and RST_STREAM) in the outgoing buffer ...
Definition: internal.h:498
grpc_chttp2_ping_queue ping_queue
ping queues for various ping insertion points
Definition: internal.h:384
grpc_timer next_bdp_ping_timer
Definition: internal.h:465
bool keepalive_ping_started
If start_keepalive_ping_locked has been called.
Definition: internal.h:487
bool benign_reclaimer_registered
have we scheduled a benign cleanup?
Definition: internal.h:453
uint8_t endpoint_reading
is there a read request to the endpoint outstanding?
Definition: internal.h:315
grpc_chttp2_stream_list lists[STREAM_LIST_COUNT]
various lists of streams
Definition: internal.h:318
bool is_first_frame
Definition: internal.h:423
grpc_closure start_keepalive_ping_locked
Closure to run when the keepalive ping is sent.
Definition: internal.h:471
grpc_chttp2_stream_map stream_map
maps stream id to grpc_chttp2_stream objects
Definition: internal.h:321
std::string peer_string
Definition: internal.h:297
union grpc_chttp2_transport::@17 simple
simple one shot parsers
grpc_chttp2_stream * incoming_stream
Definition: internal.h:430
grpc_resource_user * resource_user
Definition: internal.h:299
grpc_closure next_bdp_ping_timer_expired_locked
Definition: internal.h:440
grpc_slice_buffer qbuf
data to write next write
Definition: internal.h:353
grpc_chttp2_write_state write_state
write execution state of the transport
Definition: internal.h:307
bool bdp_ping_blocked
Definition: internal.h:438
grpc_closure retry_initiate_ping_locked
Definition: internal.h:388
grpc_closure keepalive_watchdog_fired_locked
Closrue to run when the keepalive ping timeouts.
Definition: internal.h:475
uint32_t num_messages_in_next_write
Definition: internal.h:492
uint8_t destroying
is the transport destroying itself?
Definition: internal.h:310
grpc_chttp2_keepalive_state keepalive_state
keep-alive state machine state
Definition: internal.h:489
grpc_chttp2_hpack_parser hpack_parser
parser for headers
Definition: internal.h:397
~grpc_chttp2_transport()
Definition: chttp2_transport.cc:195
grpc_closure destructive_reclaimer_locked
destructive cleanup closure
Definition: internal.h:459
grpc_slice_buffer read_buffer
incoming read bytes
Definition: internal.h:330
grpc_core::RefCount refs
Definition: internal.h:295
grpc_endpoint * ep
Definition: internal.h:296
uint32_t expect_continuation_stream_id
Definition: internal.h:424
grpc_closure write_action_begin_locked
Definition: internal.h:323
grpc_transport base
Definition: internal.h:294
uint8_t incoming_frame_type
Definition: internal.h:420
bool have_next_bdp_ping_timer
Definition: internal.h:462
uint32_t settings[GRPC_NUM_SETTING_SETS][GRPC_CHTTP2_NUM_SETTINGS]
settings values
Definition: internal.h:374
void(* accept_stream_cb)(void *user_data, grpc_transport *transport, const void *server_data)
Definition: internal.h:338
grpc_error_handle close_transport_on_writes_finished
Definition: internal.h:446
uint32_t incoming_stream_id
Definition: internal.h:426
grpc_error_handle(* parser)(void *parser_user_data, grpc_chttp2_transport *t, grpc_chttp2_stream *s, const grpc_slice &slice, int is_last)
Definition: internal.h:431
bool destructive_reclaimer_registered
have we scheduled a destructive cleanup?
Definition: internal.h:455
grpc_error_handle closed_with_error
has the upper layer closed the transport?
Definition: internal.h:312
grpc_core::ConnectivityStateTracker state_tracker
connectivity tracking
Definition: internal.h:343
bool sent_local_settings
have local settings been sent?
Definition: internal.h:368
grpc_chttp2_ping_parser ping
Definition: internal.h:402
grpc_core::PolymorphicManualConstructor< grpc_core::chttp2::TransportFlowControlBase, grpc_core::chttp2::TransportFlowControl, grpc_core::chttp2::TransportFlowControlDisabled > flow_control
Definition: internal.h:412
grpc_chttp2_transport(const grpc_channel_args *channel_args, grpc_endpoint *ep, bool is_client, grpc_resource_user *resource_user)
Definition: chttp2_transport.cc:447
grpc_chttp2_repeated_ping_state ping_state
Definition: internal.h:386
uint32_t force_send_settings
bitmask of setting indexes to send out Hack: it's common for implementations to assume 65536 bytes in...
Definition: internal.h:372
grpc_closure init_keepalive_ping_locked
Closure to initialize a keepalive ping.
Definition: internal.h:469
grpc_chttp2_server_ping_recv_state ping_recv_state
Definition: internal.h:394
uint8_t incoming_frame_flags
Definition: internal.h:421
grpc_core::Combiner * combiner
Definition: internal.h:301
grpc_chttp2_hpack_compressor hpack_compressor
hpack encoding
Definition: internal.h:348
grpc_closure start_bdp_ping_locked
Definition: internal.h:441
grpc_closure write_action
Definition: internal.h:324
grpc_chttp2_write_cb * write_cb_pool
Definition: internal.h:435
Definition: frame_window_update.h:28
Definition: internal.h:203
grpc_closure * closure
Definition: internal.h:205
struct grpc_chttp2_write_cb * next
Definition: internal.h:206
int64_t call_at_byte
Definition: internal.h:204
Definition: closure.h:41
A closure over a grpc_iomgr_cb_func.
Definition: closure.h:56
Definition: endpoint.h:106
Definition: error_internal.h:41
Definition: metadata_batch.h:52
Definition: resource_quota.cc:65
Represents an expandable array of slices, to be interpreted as a single item.
Definition: slice.h:78
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:60
Definition: stream_compression.h:34
Definition: transport.h:56
Definition: timer.h:32
Definition: transport.h:128
Definition: transport_impl.h:66
upb_arena * arena
Definition: xds_api.cc:909