Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * |
yang-g | 897925e | 2016-01-28 09:23:46 -0800 | [diff] [blame] | 3 | * Copyright 2015-2016, Google Inc. |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 34 | #include "src/core/lib/transport/chttp2/internal.h" |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 35 | |
| 36 | #include <grpc/support/log.h> |
| 37 | |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 38 | #define TRANSPORT_FROM_GLOBAL(tg) \ |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 39 | ((grpc_chttp2_transport *)((char *)(tg)-offsetof(grpc_chttp2_transport, \ |
| 40 | global))) |
| 41 | |
| 42 | #define STREAM_FROM_GLOBAL(sg) \ |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 43 | ((grpc_chttp2_stream *)((char *)(sg)-offsetof(grpc_chttp2_stream, global))) |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 44 | |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 45 | #define TRANSPORT_FROM_WRITING(tw) \ |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 46 | ((grpc_chttp2_transport *)((char *)(tw)-offsetof(grpc_chttp2_transport, \ |
| 47 | writing))) |
| 48 | |
| 49 | #define STREAM_FROM_WRITING(sw) \ |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 50 | ((grpc_chttp2_stream *)((char *)(sw)-offsetof(grpc_chttp2_stream, writing))) |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 51 | |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 52 | #define TRANSPORT_FROM_PARSING(tp) \ |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 53 | ((grpc_chttp2_transport *)((char *)(tp)-offsetof(grpc_chttp2_transport, \ |
| 54 | parsing))) |
| 55 | |
| 56 | #define STREAM_FROM_PARSING(sp) \ |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 57 | ((grpc_chttp2_stream *)((char *)(sp)-offsetof(grpc_chttp2_stream, parsing))) |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 58 | |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 59 | /* core list management */ |
| 60 | |
| 61 | static int stream_list_empty(grpc_chttp2_transport *t, |
| 62 | grpc_chttp2_stream_list_id id) { |
| 63 | return t->lists[id].head == NULL; |
| 64 | } |
| 65 | |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 66 | static int stream_list_pop(grpc_chttp2_transport *t, |
| 67 | grpc_chttp2_stream **stream, |
| 68 | grpc_chttp2_stream_list_id id) { |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 69 | grpc_chttp2_stream *s = t->lists[id].head; |
| 70 | if (s) { |
| 71 | grpc_chttp2_stream *new_head = s->links[id].next; |
| 72 | GPR_ASSERT(s->included[id]); |
| 73 | if (new_head) { |
| 74 | t->lists[id].head = new_head; |
| 75 | new_head->links[id].prev = NULL; |
| 76 | } else { |
| 77 | t->lists[id].head = NULL; |
| 78 | t->lists[id].tail = NULL; |
| 79 | } |
| 80 | s->included[id] = 0; |
| 81 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 82 | *stream = s; |
| 83 | return s != 0; |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | static void stream_list_remove(grpc_chttp2_transport *t, grpc_chttp2_stream *s, |
| 87 | grpc_chttp2_stream_list_id id) { |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 88 | GPR_ASSERT(s->included[id]); |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 89 | s->included[id] = 0; |
| 90 | if (s->links[id].prev) { |
| 91 | s->links[id].prev->links[id].next = s->links[id].next; |
| 92 | } else { |
| 93 | GPR_ASSERT(t->lists[id].head == s); |
| 94 | t->lists[id].head = s->links[id].next; |
| 95 | } |
| 96 | if (s->links[id].next) { |
| 97 | s->links[id].next->links[id].prev = s->links[id].prev; |
| 98 | } else { |
| 99 | t->lists[id].tail = s->links[id].prev; |
| 100 | } |
| 101 | } |
| 102 | |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 103 | static bool stream_list_maybe_remove(grpc_chttp2_transport *t, |
Craig Tiller | 285b882 | 2015-06-17 15:58:13 -0700 | [diff] [blame] | 104 | grpc_chttp2_stream *s, |
| 105 | grpc_chttp2_stream_list_id id) { |
Craig Tiller | 759eb32 | 2015-06-16 22:41:18 -0700 | [diff] [blame] | 106 | if (s->included[id]) { |
| 107 | stream_list_remove(t, s, id); |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 108 | return true; |
| 109 | } else { |
| 110 | return false; |
Craig Tiller | 759eb32 | 2015-06-16 22:41:18 -0700 | [diff] [blame] | 111 | } |
| 112 | } |
| 113 | |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 114 | static void stream_list_add_tail(grpc_chttp2_transport *t, |
| 115 | grpc_chttp2_stream *s, |
| 116 | grpc_chttp2_stream_list_id id) { |
| 117 | grpc_chttp2_stream *old_tail; |
| 118 | GPR_ASSERT(!s->included[id]); |
| 119 | old_tail = t->lists[id].tail; |
| 120 | s->links[id].next = NULL; |
| 121 | s->links[id].prev = old_tail; |
| 122 | if (old_tail) { |
| 123 | old_tail->links[id].next = s; |
| 124 | } else { |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 125 | t->lists[id].head = s; |
| 126 | } |
| 127 | t->lists[id].tail = s; |
| 128 | s->included[id] = 1; |
| 129 | } |
| 130 | |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 131 | static bool stream_list_add(grpc_chttp2_transport *t, grpc_chttp2_stream *s, |
| 132 | grpc_chttp2_stream_list_id id) { |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 133 | if (s->included[id]) { |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 134 | return false; |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 135 | } |
| 136 | stream_list_add_tail(t, s, id); |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 137 | return true; |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 138 | } |
| 139 | |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 140 | /* wrappers for specializations */ |
| 141 | |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 142 | bool grpc_chttp2_list_add_writable_stream( |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 143 | grpc_chttp2_transport_global *transport_global, |
| 144 | grpc_chttp2_stream_global *stream_global) { |
Craig Tiller | 8631652 | 2015-07-15 11:35:07 -0700 | [diff] [blame] | 145 | GPR_ASSERT(stream_global->id != 0); |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 146 | return stream_list_add(TRANSPORT_FROM_GLOBAL(transport_global), |
| 147 | STREAM_FROM_GLOBAL(stream_global), |
| 148 | GRPC_CHTTP2_LIST_WRITABLE); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | int grpc_chttp2_list_pop_writable_stream( |
| 152 | grpc_chttp2_transport_global *transport_global, |
| 153 | grpc_chttp2_transport_writing *transport_writing, |
| 154 | grpc_chttp2_stream_global **stream_global, |
| 155 | grpc_chttp2_stream_writing **stream_writing) { |
| 156 | grpc_chttp2_stream *stream; |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 157 | int r = stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
| 158 | GRPC_CHTTP2_LIST_WRITABLE); |
David Garcia Quintas | c9ab6a0 | 2015-08-26 13:11:48 -0700 | [diff] [blame] | 159 | if (r != 0) { |
| 160 | *stream_global = &stream->global; |
| 161 | *stream_writing = &stream->writing; |
| 162 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 163 | return r; |
| 164 | } |
| 165 | |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 166 | bool grpc_chttp2_list_remove_writable_stream( |
Craig Tiller | 994c262 | 2015-07-23 14:00:58 -0700 | [diff] [blame] | 167 | grpc_chttp2_transport_global *transport_global, |
| 168 | grpc_chttp2_stream_global *stream_global) { |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 169 | return stream_list_maybe_remove(TRANSPORT_FROM_GLOBAL(transport_global), |
| 170 | STREAM_FROM_GLOBAL(stream_global), |
| 171 | GRPC_CHTTP2_LIST_WRITABLE); |
Craig Tiller | 994c262 | 2015-07-23 14:00:58 -0700 | [diff] [blame] | 172 | } |
| 173 | |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 174 | void grpc_chttp2_list_add_writing_stream( |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 175 | grpc_chttp2_transport_writing *transport_writing, |
| 176 | grpc_chttp2_stream_writing *stream_writing) { |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 177 | GPR_ASSERT(stream_list_add(TRANSPORT_FROM_WRITING(transport_writing), |
| 178 | STREAM_FROM_WRITING(stream_writing), |
| 179 | GRPC_CHTTP2_LIST_WRITING)); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | int grpc_chttp2_list_have_writing_streams( |
| 183 | grpc_chttp2_transport_writing *transport_writing) { |
Craig Tiller | cdf52bc | 2015-06-16 13:00:27 -0700 | [diff] [blame] | 184 | return !stream_list_empty(TRANSPORT_FROM_WRITING(transport_writing), |
| 185 | GRPC_CHTTP2_LIST_WRITING); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | int grpc_chttp2_list_pop_writing_stream( |
| 189 | grpc_chttp2_transport_writing *transport_writing, |
| 190 | grpc_chttp2_stream_writing **stream_writing) { |
| 191 | grpc_chttp2_stream *stream; |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 192 | int r = stream_list_pop(TRANSPORT_FROM_WRITING(transport_writing), &stream, |
| 193 | GRPC_CHTTP2_LIST_WRITING); |
David Garcia Quintas | c9ab6a0 | 2015-08-26 13:11:48 -0700 | [diff] [blame] | 194 | if (r != 0) { |
| 195 | *stream_writing = &stream->writing; |
| 196 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 197 | return r; |
| 198 | } |
| 199 | |
| 200 | void grpc_chttp2_list_add_written_stream( |
| 201 | grpc_chttp2_transport_writing *transport_writing, |
| 202 | grpc_chttp2_stream_writing *stream_writing) { |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 203 | stream_list_add(TRANSPORT_FROM_WRITING(transport_writing), |
| 204 | STREAM_FROM_WRITING(stream_writing), |
| 205 | GRPC_CHTTP2_LIST_WRITTEN); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | int grpc_chttp2_list_pop_written_stream( |
| 209 | grpc_chttp2_transport_global *transport_global, |
| 210 | grpc_chttp2_transport_writing *transport_writing, |
| 211 | grpc_chttp2_stream_global **stream_global, |
| 212 | grpc_chttp2_stream_writing **stream_writing) { |
| 213 | grpc_chttp2_stream *stream; |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 214 | int r = stream_list_pop(TRANSPORT_FROM_WRITING(transport_writing), &stream, |
| 215 | GRPC_CHTTP2_LIST_WRITTEN); |
David Garcia Quintas | c9ab6a0 | 2015-08-26 13:11:48 -0700 | [diff] [blame] | 216 | if (r != 0) { |
| 217 | *stream_global = &stream->global; |
| 218 | *stream_writing = &stream->writing; |
| 219 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 220 | return r; |
| 221 | } |
| 222 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 223 | void grpc_chttp2_list_add_unannounced_incoming_window_available( |
| 224 | grpc_chttp2_transport_global *transport_global, |
| 225 | grpc_chttp2_stream_global *stream_global) { |
| 226 | GPR_ASSERT(stream_global->id != 0); |
| 227 | stream_list_add(TRANSPORT_FROM_GLOBAL(transport_global), |
| 228 | STREAM_FROM_GLOBAL(stream_global), |
| 229 | GRPC_CHTTP2_LIST_UNANNOUNCED_INCOMING_WINDOW_AVAILABLE); |
| 230 | } |
| 231 | |
| 232 | void grpc_chttp2_list_remove_unannounced_incoming_window_available( |
| 233 | grpc_chttp2_transport_global *transport_global, |
| 234 | grpc_chttp2_stream_global *stream_global) { |
| 235 | stream_list_maybe_remove( |
| 236 | TRANSPORT_FROM_GLOBAL(transport_global), |
| 237 | STREAM_FROM_GLOBAL(stream_global), |
| 238 | GRPC_CHTTP2_LIST_UNANNOUNCED_INCOMING_WINDOW_AVAILABLE); |
| 239 | } |
| 240 | |
| 241 | int grpc_chttp2_list_pop_unannounced_incoming_window_available( |
| 242 | grpc_chttp2_transport_global *transport_global, |
| 243 | grpc_chttp2_transport_parsing *transport_parsing, |
| 244 | grpc_chttp2_stream_global **stream_global, |
| 245 | grpc_chttp2_stream_parsing **stream_parsing) { |
| 246 | grpc_chttp2_stream *stream; |
| 247 | int r = |
| 248 | stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
| 249 | GRPC_CHTTP2_LIST_UNANNOUNCED_INCOMING_WINDOW_AVAILABLE); |
| 250 | if (r != 0) { |
| 251 | *stream_global = &stream->global; |
| 252 | *stream_parsing = &stream->parsing; |
| 253 | } |
| 254 | return r; |
| 255 | } |
| 256 | |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 257 | void grpc_chttp2_list_add_parsing_seen_stream( |
| 258 | grpc_chttp2_transport_parsing *transport_parsing, |
| 259 | grpc_chttp2_stream_parsing *stream_parsing) { |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 260 | stream_list_add(TRANSPORT_FROM_PARSING(transport_parsing), |
| 261 | STREAM_FROM_PARSING(stream_parsing), |
| 262 | GRPC_CHTTP2_LIST_PARSING_SEEN); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | int grpc_chttp2_list_pop_parsing_seen_stream( |
| 266 | grpc_chttp2_transport_global *transport_global, |
| 267 | grpc_chttp2_transport_parsing *transport_parsing, |
| 268 | grpc_chttp2_stream_global **stream_global, |
| 269 | grpc_chttp2_stream_parsing **stream_parsing) { |
| 270 | grpc_chttp2_stream *stream; |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 271 | int r = stream_list_pop(TRANSPORT_FROM_PARSING(transport_parsing), &stream, |
| 272 | GRPC_CHTTP2_LIST_PARSING_SEEN); |
David Garcia Quintas | c9ab6a0 | 2015-08-26 13:11:48 -0700 | [diff] [blame] | 273 | if (r != 0) { |
| 274 | *stream_global = &stream->global; |
| 275 | *stream_parsing = &stream->parsing; |
| 276 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 277 | return r; |
| 278 | } |
| 279 | |
| 280 | void grpc_chttp2_list_add_waiting_for_concurrency( |
| 281 | grpc_chttp2_transport_global *transport_global, |
| 282 | grpc_chttp2_stream_global *stream_global) { |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 283 | stream_list_add(TRANSPORT_FROM_GLOBAL(transport_global), |
| 284 | STREAM_FROM_GLOBAL(stream_global), |
| 285 | GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | int grpc_chttp2_list_pop_waiting_for_concurrency( |
| 289 | grpc_chttp2_transport_global *transport_global, |
| 290 | grpc_chttp2_stream_global **stream_global) { |
| 291 | grpc_chttp2_stream *stream; |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 292 | int r = stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
| 293 | GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY); |
David Garcia Quintas | c9ab6a0 | 2015-08-26 13:11:48 -0700 | [diff] [blame] | 294 | if (r != 0) { |
| 295 | *stream_global = &stream->global; |
| 296 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 297 | return r; |
| 298 | } |
| 299 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 300 | void grpc_chttp2_list_add_check_read_ops( |
| 301 | grpc_chttp2_transport_global *transport_global, |
| 302 | grpc_chttp2_stream_global *stream_global) { |
| 303 | stream_list_add(TRANSPORT_FROM_GLOBAL(transport_global), |
| 304 | STREAM_FROM_GLOBAL(stream_global), |
| 305 | GRPC_CHTTP2_LIST_CHECK_READ_OPS); |
| 306 | } |
| 307 | |
| 308 | int grpc_chttp2_list_pop_check_read_ops( |
| 309 | grpc_chttp2_transport_global *transport_global, |
| 310 | grpc_chttp2_stream_global **stream_global) { |
| 311 | grpc_chttp2_stream *stream; |
| 312 | int r = stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
| 313 | GRPC_CHTTP2_LIST_CHECK_READ_OPS); |
| 314 | if (r != 0) { |
| 315 | *stream_global = &stream->global; |
| 316 | } |
| 317 | return r; |
| 318 | } |
| 319 | |
yang-g | 348f3a2 | 2016-01-27 16:17:32 -0800 | [diff] [blame] | 320 | void grpc_chttp2_list_add_writing_stalled_by_transport( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 321 | grpc_chttp2_transport_writing *transport_writing, |
| 322 | grpc_chttp2_stream_writing *stream_writing) { |
yang-g | 276e32d | 2016-02-22 13:15:30 -0800 | [diff] [blame] | 323 | grpc_chttp2_stream *stream = STREAM_FROM_WRITING(stream_writing); |
| 324 | if (!stream->included[GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT]) { |
| 325 | GRPC_CHTTP2_STREAM_REF(&stream->global, "chttp2_writing_stalled"); |
| 326 | } |
| 327 | stream_list_add(TRANSPORT_FROM_WRITING(transport_writing), stream, |
yang-g | 348f3a2 | 2016-01-27 16:17:32 -0800 | [diff] [blame] | 328 | GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT); |
| 329 | } |
| 330 | |
| 331 | void grpc_chttp2_list_flush_writing_stalled_by_transport( |
yang-g | 276e32d | 2016-02-22 13:15:30 -0800 | [diff] [blame] | 332 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_writing *transport_writing, |
yang-g | 55b1b59 | 2016-01-28 12:03:03 -0800 | [diff] [blame] | 333 | bool is_window_available) { |
yang-g | 348f3a2 | 2016-01-27 16:17:32 -0800 | [diff] [blame] | 334 | grpc_chttp2_stream *stream; |
| 335 | grpc_chttp2_transport *transport = TRANSPORT_FROM_WRITING(transport_writing); |
| 336 | while (stream_list_pop(transport, &stream, |
| 337 | GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT)) { |
yang-g | 55b1b59 | 2016-01-28 12:03:03 -0800 | [diff] [blame] | 338 | if (is_window_available) { |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 339 | grpc_chttp2_become_writable(&transport->global, &stream->global); |
yang-g | 348f3a2 | 2016-01-27 16:17:32 -0800 | [diff] [blame] | 340 | } else { |
yang-g | 276e32d | 2016-02-22 13:15:30 -0800 | [diff] [blame] | 341 | grpc_chttp2_list_add_stalled_by_transport(transport_writing, |
| 342 | &stream->writing); |
yang-g | 348f3a2 | 2016-01-27 16:17:32 -0800 | [diff] [blame] | 343 | } |
yang-g | 276e32d | 2016-02-22 13:15:30 -0800 | [diff] [blame] | 344 | GRPC_CHTTP2_STREAM_UNREF(exec_ctx, &stream->global, |
| 345 | "chttp2_writing_stalled"); |
yang-g | 348f3a2 | 2016-01-27 16:17:32 -0800 | [diff] [blame] | 346 | } |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 347 | } |
| 348 | |
yang-g | 276e32d | 2016-02-22 13:15:30 -0800 | [diff] [blame] | 349 | void grpc_chttp2_list_add_stalled_by_transport( |
| 350 | grpc_chttp2_transport_writing *transport_writing, |
| 351 | grpc_chttp2_stream_writing *stream_writing) { |
| 352 | stream_list_add(TRANSPORT_FROM_WRITING(transport_writing), |
| 353 | STREAM_FROM_WRITING(stream_writing), |
| 354 | GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT); |
| 355 | } |
| 356 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 357 | int grpc_chttp2_list_pop_stalled_by_transport( |
| 358 | grpc_chttp2_transport_global *transport_global, |
| 359 | grpc_chttp2_stream_global **stream_global) { |
| 360 | grpc_chttp2_stream *stream; |
| 361 | int r = stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
| 362 | GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT); |
| 363 | if (r != 0) { |
| 364 | *stream_global = &stream->global; |
| 365 | } |
| 366 | return r; |
| 367 | } |
| 368 | |
yang-g | 0db9032 | 2015-12-21 13:38:56 -0800 | [diff] [blame] | 369 | void grpc_chttp2_list_remove_stalled_by_transport( |
| 370 | grpc_chttp2_transport_global *transport_global, |
| 371 | grpc_chttp2_stream_global *stream_global) { |
| 372 | stream_list_maybe_remove(TRANSPORT_FROM_GLOBAL(transport_global), |
| 373 | STREAM_FROM_GLOBAL(stream_global), |
| 374 | GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT); |
| 375 | } |
| 376 | |
Craig Tiller | 83fb070 | 2015-06-16 21:13:07 -0700 | [diff] [blame] | 377 | void grpc_chttp2_list_add_closed_waiting_for_parsing( |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 378 | grpc_chttp2_transport_global *transport_global, |
| 379 | grpc_chttp2_stream_global *stream_global) { |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 380 | stream_list_add(TRANSPORT_FROM_GLOBAL(transport_global), |
| 381 | STREAM_FROM_GLOBAL(stream_global), |
Craig Tiller | 83fb070 | 2015-06-16 21:13:07 -0700 | [diff] [blame] | 382 | GRPC_CHTTP2_LIST_CLOSED_WAITING_FOR_PARSING); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 383 | } |
| 384 | |
Craig Tiller | 83fb070 | 2015-06-16 21:13:07 -0700 | [diff] [blame] | 385 | int grpc_chttp2_list_pop_closed_waiting_for_parsing( |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 386 | grpc_chttp2_transport_global *transport_global, |
| 387 | grpc_chttp2_stream_global **stream_global) { |
| 388 | grpc_chttp2_stream *stream; |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 389 | int r = stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
Craig Tiller | 83fb070 | 2015-06-16 21:13:07 -0700 | [diff] [blame] | 390 | GRPC_CHTTP2_LIST_CLOSED_WAITING_FOR_PARSING); |
David Garcia Quintas | c9ab6a0 | 2015-08-26 13:11:48 -0700 | [diff] [blame] | 391 | if (r != 0) { |
| 392 | *stream_global = &stream->global; |
| 393 | } |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 394 | return r; |
| 395 | } |
| 396 | |
Craig Tiller | abb2e3d | 2015-12-15 06:23:59 -0800 | [diff] [blame] | 397 | void grpc_chttp2_list_add_closed_waiting_for_writing( |
| 398 | grpc_chttp2_transport_global *transport_global, |
| 399 | grpc_chttp2_stream_global *stream_global) { |
| 400 | stream_list_add(TRANSPORT_FROM_GLOBAL(transport_global), |
| 401 | STREAM_FROM_GLOBAL(stream_global), |
| 402 | GRPC_CHTTP2_LIST_CLOSED_WAITING_FOR_WRITING); |
| 403 | } |
| 404 | |
| 405 | int grpc_chttp2_list_pop_closed_waiting_for_writing( |
| 406 | grpc_chttp2_transport_global *transport_global, |
| 407 | grpc_chttp2_stream_global **stream_global) { |
| 408 | grpc_chttp2_stream *stream; |
| 409 | int r = stream_list_pop(TRANSPORT_FROM_GLOBAL(transport_global), &stream, |
| 410 | GRPC_CHTTP2_LIST_CLOSED_WAITING_FOR_WRITING); |
| 411 | if (r != 0) { |
| 412 | *stream_global = &stream->global; |
| 413 | } |
| 414 | return r; |
| 415 | } |
| 416 | |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 417 | void grpc_chttp2_register_stream(grpc_chttp2_transport *t, |
| 418 | grpc_chttp2_stream *s) { |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 419 | stream_list_add_tail(t, s, GRPC_CHTTP2_LIST_ALL_STREAMS); |
| 420 | } |
Craig Tiller | 1937b06 | 2015-06-16 08:47:38 -0700 | [diff] [blame] | 421 | |
Craig Tiller | 9188d7a | 2015-07-05 12:44:37 -0700 | [diff] [blame] | 422 | int grpc_chttp2_unregister_stream(grpc_chttp2_transport *t, |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 423 | grpc_chttp2_stream *s) { |
Craig Tiller | 9188d7a | 2015-07-05 12:44:37 -0700 | [diff] [blame] | 424 | stream_list_maybe_remove(t, s, GRPC_CHTTP2_LIST_ALL_STREAMS); |
| 425 | return stream_list_empty(t, GRPC_CHTTP2_LIST_ALL_STREAMS); |
| 426 | } |
| 427 | |
| 428 | int grpc_chttp2_has_streams(grpc_chttp2_transport *t) { |
| 429 | return !stream_list_empty(t, GRPC_CHTTP2_LIST_ALL_STREAMS); |
Craig Tiller | 6459db4 | 2015-06-15 17:11:45 -0700 | [diff] [blame] | 430 | } |
Craig Tiller | 1937b06 | 2015-06-16 08:47:38 -0700 | [diff] [blame] | 431 | |
Craig Tiller | 9850510 | 2015-06-16 11:33:15 -0700 | [diff] [blame] | 432 | void grpc_chttp2_for_all_streams( |
| 433 | grpc_chttp2_transport_global *transport_global, void *user_data, |
| 434 | void (*cb)(grpc_chttp2_transport_global *transport_global, void *user_data, |
| 435 | grpc_chttp2_stream_global *stream_global)) { |
Craig Tiller | 1937b06 | 2015-06-16 08:47:38 -0700 | [diff] [blame] | 436 | grpc_chttp2_stream *s; |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 437 | grpc_chttp2_transport *t = TRANSPORT_FROM_GLOBAL(transport_global); |
| 438 | for (s = t->lists[GRPC_CHTTP2_LIST_ALL_STREAMS].head; s != NULL; |
| 439 | s = s->links[GRPC_CHTTP2_LIST_ALL_STREAMS].next) { |
Craig Tiller | 1937b06 | 2015-06-16 08:47:38 -0700 | [diff] [blame] | 440 | cb(transport_global, user_data, &s->global); |
| 441 | } |
| 442 | } |