Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2015 gRPC authors. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 4 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 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 |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 10 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 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. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
Alexander Polcyn | db3e898 | 2018-02-21 16:59:24 -0800 | [diff] [blame] | 19 | #include <grpc/support/port_platform.h> |
| 20 | |
Craig Tiller | 57726ca | 2016-09-12 11:59:45 -0700 | [diff] [blame] | 21 | #include <grpc/support/alloc.h> |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 22 | #include <grpc/support/log.h> |
Alexander Polcyn | db3e898 | 2018-02-21 16:59:24 -0800 | [diff] [blame] | 23 | #include "src/core/lib/channel/channel_stack.h" |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 24 | #include "src/core/lib/gpr/alloc.h" |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 25 | |
| 26 | #include <stdlib.h> |
Craig Tiller | 83f88d9 | 2015-04-21 16:02:05 -0700 | [diff] [blame] | 27 | #include <string.h> |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 28 | |
Craig Tiller | 694580f | 2017-10-18 14:48:14 -0700 | [diff] [blame] | 29 | grpc_core::TraceFlag grpc_trace_channel(false, "channel"); |
Craig Tiller | faa8480 | 2015-03-01 21:56:38 -0800 | [diff] [blame] | 30 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 31 | /* Memory layouts. |
| 32 | |
| 33 | Channel stack is laid out as: { |
| 34 | grpc_channel_stack stk; |
| 35 | padding to GPR_MAX_ALIGNMENT |
| 36 | grpc_channel_element[stk.count]; |
| 37 | per-filter memory, aligned to GPR_MAX_ALIGNMENT |
| 38 | } |
| 39 | |
| 40 | Call stack is laid out as: { |
| 41 | grpc_call_stack stk; |
| 42 | padding to GPR_MAX_ALIGNMENT |
| 43 | grpc_call_element[stk.count]; |
| 44 | per-filter memory, aligned to GPR_MAX_ALIGNMENT |
| 45 | } */ |
| 46 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 47 | size_t grpc_channel_stack_size(const grpc_channel_filter** filters, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 48 | size_t filter_count) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 49 | /* always need the header, and size for the channel elements */ |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 50 | size_t size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) + |
| 51 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * |
| 52 | sizeof(grpc_channel_element)); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 53 | size_t i; |
| 54 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 55 | GPR_ASSERT((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0 && |
| 56 | "GPR_MAX_ALIGNMENT must be a power of two"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 57 | |
| 58 | /* add the size for each filter */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 59 | for (i = 0; i < filter_count; i++) { |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 60 | size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 61 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 62 | |
| 63 | return size; |
| 64 | } |
| 65 | |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 66 | #define CHANNEL_ELEMS_FROM_STACK(stk) \ |
| 67 | ((grpc_channel_element*)((char*)(stk) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 68 | sizeof(grpc_channel_stack)))) |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 69 | |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 70 | #define CALL_ELEMS_FROM_STACK(stk) \ |
| 71 | ((grpc_call_element*)((char*)(stk) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \ |
| 72 | sizeof(grpc_call_stack)))) |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 73 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 74 | grpc_channel_element* grpc_channel_stack_element( |
| 75 | grpc_channel_stack* channel_stack, size_t index) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 76 | return CHANNEL_ELEMS_FROM_STACK(channel_stack) + index; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 77 | } |
| 78 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 79 | grpc_channel_element* grpc_channel_stack_last_element( |
| 80 | grpc_channel_stack* channel_stack) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 81 | return grpc_channel_stack_element(channel_stack, channel_stack->count - 1); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 82 | } |
| 83 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 84 | grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 85 | size_t index) { |
| 86 | return CALL_ELEMS_FROM_STACK(call_stack) + index; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 87 | } |
| 88 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 89 | grpc_error* grpc_channel_stack_init( |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 90 | int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg, |
| 91 | const grpc_channel_filter** filters, size_t filter_count, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 92 | const grpc_channel_args* channel_args, grpc_transport* optional_transport, |
| 93 | const char* name, grpc_channel_stack* stack) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 94 | size_t call_size = |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 95 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) + |
| 96 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element)); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 97 | grpc_channel_element* elems; |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 98 | grpc_channel_element_args args; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 99 | char* user_data; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 100 | size_t i; |
| 101 | |
| 102 | stack->count = filter_count; |
Craig Tiller | 27e5aa4 | 2015-11-24 16:28:54 -0800 | [diff] [blame] | 103 | GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg, |
Craig Tiller | 50ec267 | 2015-11-27 21:45:11 -0800 | [diff] [blame] | 104 | name); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 105 | elems = CHANNEL_ELEMS_FROM_STACK(stack); |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 106 | user_data = (reinterpret_cast<char*>(elems)) + |
| 107 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * |
| 108 | sizeof(grpc_channel_element)); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 109 | |
| 110 | /* init per-filter data */ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 111 | grpc_error* first_error = GRPC_ERROR_NONE; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 112 | for (i = 0; i < filter_count; i++) { |
Craig Tiller | 906e3bc | 2015-11-24 07:31:31 -0800 | [diff] [blame] | 113 | args.channel_stack = stack; |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 114 | args.channel_args = channel_args; |
Craig Tiller | 9d69e80 | 2016-06-06 11:37:50 -0700 | [diff] [blame] | 115 | args.optional_transport = optional_transport; |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 116 | args.is_first = i == 0; |
| 117 | args.is_last = i == (filter_count - 1); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 118 | elems[i].filter = filters[i]; |
| 119 | elems[i].channel_data = user_data; |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 120 | grpc_error* error = elems[i].filter->init_channel_elem(&elems[i], &args); |
Mark D. Roth | 5e2566e | 2016-11-18 10:53:13 -0800 | [diff] [blame] | 121 | if (error != GRPC_ERROR_NONE) { |
| 122 | if (first_error == GRPC_ERROR_NONE) { |
| 123 | first_error = error; |
| 124 | } else { |
| 125 | GRPC_ERROR_UNREF(error); |
| 126 | } |
| 127 | } |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 128 | user_data += |
| 129 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data); |
| 130 | call_size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 131 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 132 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 133 | GPR_ASSERT(user_data > (char*)stack); |
| 134 | GPR_ASSERT((uintptr_t)(user_data - (char*)stack) == |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 135 | grpc_channel_stack_size(filters, filter_count)); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 136 | |
| 137 | stack->call_stack_size = call_size; |
Mark D. Roth | 5e2566e | 2016-11-18 10:53:13 -0800 | [diff] [blame] | 138 | return first_error; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 139 | } |
| 140 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 141 | void grpc_channel_stack_destroy(grpc_channel_stack* stack) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 142 | grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(stack); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 143 | size_t count = stack->count; |
| 144 | size_t i; |
| 145 | |
| 146 | /* destroy per-filter data */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 147 | for (i = 0; i < count; i++) { |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 148 | channel_elems[i].filter->destroy_channel_elem(&channel_elems[i]); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 149 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 150 | } |
| 151 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 152 | grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack, |
Craig Tiller | d426cac | 2017-03-13 12:30:45 -0700 | [diff] [blame] | 153 | int initial_refs, grpc_iomgr_cb_func destroy, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 154 | void* destroy_arg, |
| 155 | const grpc_call_element_args* elem_args) { |
| 156 | grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(channel_stack); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 157 | size_t count = channel_stack->count; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 158 | grpc_call_element* call_elems; |
| 159 | char* user_data; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 160 | size_t i; |
| 161 | |
Craig Tiller | d426cac | 2017-03-13 12:30:45 -0700 | [diff] [blame] | 162 | elem_args->call_stack->count = count; |
| 163 | GRPC_STREAM_REF_INIT(&elem_args->call_stack->refcount, initial_refs, destroy, |
Craig Tiller | 27e5aa4 | 2015-11-24 16:28:54 -0800 | [diff] [blame] | 164 | destroy_arg, "CALL_STACK"); |
Craig Tiller | d426cac | 2017-03-13 12:30:45 -0700 | [diff] [blame] | 165 | call_elems = CALL_ELEMS_FROM_STACK(elem_args->call_stack); |
Noah Eisen | be82e64 | 2018-02-09 09:16:55 -0800 | [diff] [blame] | 166 | user_data = (reinterpret_cast<char*>(call_elems)) + |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 167 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element)); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 168 | |
| 169 | /* init per-filter data */ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 170 | grpc_error* first_error = GRPC_ERROR_NONE; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 171 | for (i = 0; i < count; i++) { |
| 172 | call_elems[i].filter = channel_elems[i].filter; |
| 173 | call_elems[i].channel_data = channel_elems[i].channel_data; |
| 174 | call_elems[i].call_data = user_data; |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 175 | grpc_error* error = |
| 176 | call_elems[i].filter->init_call_elem(&call_elems[i], elem_args); |
Mark D. Roth | 05d73af | 2016-07-27 15:52:46 +0000 | [diff] [blame] | 177 | if (error != GRPC_ERROR_NONE) { |
| 178 | if (first_error == GRPC_ERROR_NONE) { |
| 179 | first_error = error; |
| 180 | } else { |
| 181 | GRPC_ERROR_UNREF(error); |
| 182 | } |
| 183 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 184 | user_data += |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 185 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(call_elems[i].filter->sizeof_call_data); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 186 | } |
Mark D. Roth | 5d11e43 | 2016-06-23 13:14:05 -0700 | [diff] [blame] | 187 | return first_error; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 188 | } |
| 189 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 190 | void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 191 | grpc_polling_entity* pollent) { |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 192 | size_t count = call_stack->count; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 193 | grpc_call_element* call_elems; |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 194 | size_t i; |
| 195 | |
| 196 | call_elems = CALL_ELEMS_FROM_STACK(call_stack); |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 197 | |
| 198 | /* init per-filter data */ |
| 199 | for (i = 0; i < count; i++) { |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 200 | call_elems[i].filter->set_pollset_or_pollset_set(&call_elems[i], pollent); |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 201 | } |
| 202 | } |
| 203 | |
David Garcia Quintas | 2a50dfe | 2016-05-31 15:09:12 -0700 | [diff] [blame] | 204 | void grpc_call_stack_ignore_set_pollset_or_pollset_set( |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 205 | grpc_call_element* elem, grpc_polling_entity* pollent) {} |
Craig Tiller | 577c9b2 | 2015-11-02 14:11:15 -0800 | [diff] [blame] | 206 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 207 | void grpc_call_stack_destroy(grpc_call_stack* stack, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 208 | const grpc_call_final_info* final_info, |
| 209 | grpc_closure* then_schedule_closure) { |
| 210 | grpc_call_element* elems = CALL_ELEMS_FROM_STACK(stack); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 211 | size_t count = stack->count; |
| 212 | size_t i; |
| 213 | |
| 214 | /* destroy per-filter data */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 215 | for (i = 0; i < count; i++) { |
Craig Tiller | e7a1702 | 2017-03-13 10:20:38 -0700 | [diff] [blame] | 216 | elems[i].filter->destroy_call_elem( |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 217 | &elems[i], final_info, |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 218 | i == count - 1 ? then_schedule_closure : nullptr); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 219 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 220 | } |
| 221 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 222 | void grpc_call_next_op(grpc_call_element* elem, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 223 | grpc_transport_stream_op_batch* op) { |
| 224 | grpc_call_element* next_elem = elem + 1; |
Mark D. Roth | 764cf04 | 2017-09-01 09:00:06 -0700 | [diff] [blame] | 225 | GRPC_CALL_LOG_OP(GPR_INFO, next_elem, op); |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 226 | next_elem->filter->start_transport_stream_op_batch(next_elem, op); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 227 | } |
| 228 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 229 | void grpc_channel_next_get_info(grpc_channel_element* elem, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 230 | const grpc_channel_info* channel_info) { |
| 231 | grpc_channel_element* next_elem = elem + 1; |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 232 | next_elem->filter->get_channel_info(next_elem, channel_info); |
Mark D. Roth | b2d2488 | 2016-10-27 15:44:07 -0700 | [diff] [blame] | 233 | } |
| 234 | |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 235 | void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 236 | grpc_channel_element* next_elem = elem + 1; |
Yash Tibrewal | 8cf1470 | 2017-12-06 09:47:54 -0800 | [diff] [blame] | 237 | next_elem->filter->start_transport_op(next_elem, op); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 238 | } |
| 239 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 240 | grpc_channel_stack* grpc_channel_stack_from_top_element( |
| 241 | grpc_channel_element* elem) { |
Noah Eisen | 4d20a66 | 2018-02-09 09:34:04 -0800 | [diff] [blame] | 242 | return reinterpret_cast<grpc_channel_stack*>( |
| 243 | reinterpret_cast<char*>(elem) - |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 244 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack))); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 245 | } |
| 246 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 247 | grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) { |
Noah Eisen | 4d20a66 | 2018-02-09 09:34:04 -0800 | [diff] [blame] | 248 | return reinterpret_cast<grpc_call_stack*>( |
| 249 | reinterpret_cast<char*>(elem) - |
Mark D. Roth | 2223e60 | 2018-06-27 07:23:33 -0700 | [diff] [blame^] | 250 | GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack))); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 251 | } |