Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2016-2019 Cisco and/or its affiliates. |
| 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | #ifndef __included_fifo_segment_h__ |
| 16 | #define __included_fifo_segment_h__ |
| 17 | |
| 18 | #include <svm/ssvm.h> |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 19 | #include <svm/fifo_types.h> |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 20 | #include <svm/message_queue.h> |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 21 | #include <svm/svm_fifo.h> |
| 22 | |
| 23 | typedef enum |
| 24 | { |
| 25 | FIFO_SEGMENT_FTYPE_NONE = -1, |
| 26 | FIFO_SEGMENT_RX_FIFO = 0, |
| 27 | FIFO_SEGMENT_TX_FIFO, |
| 28 | FIFO_SEGMENT_N_FTYPES |
| 29 | } fifo_segment_ftype_t; |
| 30 | |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 31 | #define FIFO_SEGMENT_MIN_LOG2_FIFO_SIZE 12 /**< 4kB min fifo size */ |
| 32 | #define FIFO_SEGMENT_MIN_FIFO_SIZE 4096 /**< 4kB min fifo size */ |
Florin Coras | e2c9f23 | 2020-09-29 10:27:07 -0700 | [diff] [blame] | 33 | #define FIFO_SEGMENT_MAX_FIFO_SIZE (2ULL << 30) /**< 2GB max fifo size */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 34 | #define FIFO_SEGMENT_ALLOC_BATCH_SIZE 32 /* Allocation quantum */ |
| 35 | |
| 36 | typedef enum fifo_segment_flags_ |
| 37 | { |
| 38 | FIFO_SEGMENT_F_IS_PREALLOCATED = 1 << 0, |
| 39 | FIFO_SEGMENT_F_WILL_DELETE = 1 << 1, |
Florin Coras | 8122cc2 | 2019-12-18 13:06:41 -0800 | [diff] [blame] | 40 | FIFO_SEGMENT_F_MEM_LIMIT = 1 << 2, |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 41 | } fifo_segment_flags_t; |
| 42 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 43 | #define foreach_segment_mem_status \ |
| 44 | _(NO_PRESSURE, "No pressure") \ |
| 45 | _(LOW_PRESSURE, "Low pressure") \ |
| 46 | _(HIGH_PRESSURE, "High pressure") \ |
| 47 | _(NO_MEMORY, "No memory") |
| 48 | |
| 49 | typedef enum |
| 50 | { |
| 51 | #define _(sym,str) MEMORY_PRESSURE_##sym, |
| 52 | foreach_segment_mem_status |
| 53 | #undef _ |
| 54 | MEMORY_N_PRESSURE, |
| 55 | } fifo_segment_mem_status_t; |
| 56 | |
| 57 | #if 0 |
| 58 | typedef enum fifo_segment_mem_status_ |
| 59 | { |
| 60 | MEMORY_PRESSURE_NO_PRESSURE, |
| 61 | MEMORY_PRESSURE_LOW_PRESSURE, |
| 62 | MEMORY_PRESSURE_HIGH_PRESSURE, |
| 63 | MEMORY_PRESSURE_NO_MEMORY, |
| 64 | } fifo_segment_mem_status_t; |
| 65 | #endif |
| 66 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 67 | typedef struct |
| 68 | { |
| 69 | ssvm_private_t ssvm; /**< ssvm segment data */ |
| 70 | fifo_segment_header_t *h; /**< fifo segment data */ |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 71 | uword max_byte_index; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 72 | u8 n_slices; /**< number of fifo segment slices */ |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 73 | fifo_slice_private_t *slices; /**< private slice information */ |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 74 | svm_msg_q_t *mqs; /**< private vec of attached mqs */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 75 | } fifo_segment_t; |
| 76 | |
| 77 | typedef struct |
| 78 | { |
| 79 | fifo_segment_t *segments; /**< pool of fifo segments */ |
Florin Coras | ef4f3e7 | 2019-12-11 14:27:53 -0800 | [diff] [blame] | 80 | uword next_baseva; /**< Where to put the next one */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 81 | u32 timeout_in_seconds; /**< Time to wait during attach */ |
| 82 | } fifo_segment_main_t; |
| 83 | |
| 84 | typedef struct |
| 85 | { |
| 86 | ssvm_segment_type_t segment_type; /**< type of segment requested */ |
| 87 | u32 segment_size; /**< size of the segment */ |
| 88 | int memfd_fd; /**< fd for memfd segments */ |
| 89 | char *segment_name; /**< segment name */ |
| 90 | u32 *new_segment_indices; /**< return vec of new seg indices */ |
| 91 | } fifo_segment_create_args_t; |
| 92 | |
| 93 | #define fifo_segment_flags(_fs) _fs->h->flags |
| 94 | |
| 95 | int fifo_segment_init (fifo_segment_t * fs); |
| 96 | int fifo_segment_create (fifo_segment_main_t * sm, |
| 97 | fifo_segment_create_args_t * a); |
| 98 | int fifo_segment_attach (fifo_segment_main_t * sm, |
| 99 | fifo_segment_create_args_t * a); |
| 100 | void fifo_segment_delete (fifo_segment_main_t * sm, fifo_segment_t * fs); |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 101 | void fifo_segment_cleanup (fifo_segment_t *fs); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 102 | fifo_segment_t *fifo_segment_get_segment (fifo_segment_main_t * sm, |
| 103 | u32 fs_index); |
Florin Coras | cbb5e82 | 2021-02-20 10:42:22 -0800 | [diff] [blame] | 104 | fifo_segment_t *fifo_segment_get_segment_if_valid (fifo_segment_main_t *sm, |
| 105 | u32 segment_index); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 106 | u32 fifo_segment_index (fifo_segment_main_t * sm, fifo_segment_t * fs); |
| 107 | void fifo_segment_info (fifo_segment_t * seg, char **address, size_t * size); |
| 108 | |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 109 | always_inline void * |
| 110 | fifo_segment_ptr (fifo_segment_t *fs, uword offset) |
| 111 | { |
| 112 | return (void *) ((u8 *) fs->h + offset); |
| 113 | } |
| 114 | |
| 115 | always_inline uword |
| 116 | fifo_segment_offset (fifo_segment_t *fs, void *p) |
| 117 | { |
| 118 | return (uword) ((u8 *) p - (u8 *) fs->h); |
| 119 | } |
| 120 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 121 | /** |
| 122 | * Allocate fifo in fifo segment |
| 123 | * |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 124 | * @param fs fifo segment for fifo |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 125 | * @param data_bytes size of default fifo chunk in bytes |
| 126 | * @param ftype fifo type @ref fifo_segment_ftype_t |
| 127 | * @return new fifo or 0 if alloc failed |
| 128 | */ |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 129 | svm_fifo_t *fifo_segment_alloc_fifo_w_slice (fifo_segment_t * fs, |
| 130 | u32 slice_index, |
| 131 | u32 data_bytes, |
| 132 | fifo_segment_ftype_t ftype); |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 133 | svm_fifo_t *fifo_segment_alloc_fifo_w_offset (fifo_segment_t *fs, |
| 134 | uword offset); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 135 | |
| 136 | /** |
| 137 | * Free fifo allocated in fifo segment |
| 138 | * |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 139 | * @param fs fifo segment for fifo |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 140 | * @param f fifo to be freed |
| 141 | */ |
| 142 | void fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f); |
| 143 | |
Florin Coras | cbb5e82 | 2021-02-20 10:42:22 -0800 | [diff] [blame] | 144 | /** |
| 145 | * Free fifo allocated by external applications |
| 146 | * |
| 147 | * @params fs fifo segment for fifo |
| 148 | * @param f fifo to be freed |
| 149 | */ |
| 150 | void fifo_segment_free_client_fifo (fifo_segment_t *fs, svm_fifo_t *f); |
| 151 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 152 | void fifo_segment_detach_fifo (fifo_segment_t *fs, svm_fifo_t **f); |
| 153 | void fifo_segment_attach_fifo (fifo_segment_t *fs, svm_fifo_t **f, |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 154 | u32 slice_index); |
Florin Coras | 14f066e | 2020-12-10 18:52:40 -0800 | [diff] [blame] | 155 | uword fifo_segment_fifo_offset (svm_fifo_t *f); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 156 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 157 | /** |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 158 | * Allocate message queue on segment |
| 159 | * |
| 160 | * @param fs fifo segment for mq |
| 161 | * @param mq_index index in private mqs vector to use to attach |
| 162 | * @param cfg configuration for mq |
| 163 | * @return attached message queue |
| 164 | */ |
| 165 | svm_msg_q_t *fifo_segment_msg_q_alloc (fifo_segment_t *fs, u32 mq_index, |
| 166 | svm_msg_q_cfg_t *cfg); |
| 167 | |
| 168 | /** |
| 169 | * Attach message queue at fifo segment offset |
| 170 | * |
| 171 | * @param fs fifo segment for mq |
| 172 | * @param offset offset for shared mq on the segment |
| 173 | * @param mq_index index in private mqs vector to use to attach |
| 174 | * @return attached message queue |
| 175 | */ |
| 176 | svm_msg_q_t *fifo_segment_msg_q_attach (fifo_segment_t *fs, uword offset, |
| 177 | u32 mq_index); |
| 178 | |
| 179 | /** |
Florin Coras | 80b7425 | 2021-01-27 18:08:25 -0800 | [diff] [blame] | 180 | * Discover mqs on mq only segment |
| 181 | * |
| 182 | * @param fs fifo segment for mq |
| 183 | * @param fds array of fds is mqs use eventfds |
| 184 | * @param n_fds number of fds |
| 185 | */ |
| 186 | void fifo_segment_msg_qs_discover (fifo_segment_t *fs, int *fds, u32 n_fds); |
| 187 | |
| 188 | /** |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 189 | * Message queue offset on segment |
| 190 | * |
| 191 | * @param fs fifo segment for mq |
| 192 | * @param mq_index index of mq in private mqs vector |
| 193 | * @return offset of the shared mq the private mq is attached to |
| 194 | */ |
| 195 | uword fifo_segment_msg_q_offset (fifo_segment_t *fs, u32 mq_index); |
| 196 | |
| 197 | /** |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 198 | * Try to preallocate fifo headers |
| 199 | * |
| 200 | * Tries to preallocate fifo headers and adds them to freelist. |
| 201 | * |
| 202 | * @param fs fifo segment |
| 203 | * @param batch_size number of chunks to be allocated |
| 204 | * @return 0 on success, negative number otherwise |
| 205 | */ |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 206 | int fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 slice_index, |
| 207 | u32 batch_size); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 208 | |
| 209 | /** |
| 210 | * Try to preallocate fifo chunks on segment |
| 211 | * |
| 212 | * Tries to preallocate chunks of requested size on segment and adds them |
| 213 | * to chunk freelist. |
| 214 | * |
| 215 | * @param fs fifo segment |
| 216 | * @param chunk_size size of chunks to be allocated in bytes |
| 217 | * @param batch_size number of chunks to be allocated |
| 218 | * @return 0 on success, negative number otherwise |
| 219 | */ |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 220 | int fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 slice_index, |
| 221 | u32 chunk_size, u32 batch_size); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 222 | /** |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 223 | * Pre-allocates fifo pairs in fifo segment |
| 224 | * |
| 225 | * The number of fifos pre-allocated is the minimum of the requested number |
| 226 | * of pairs and the maximum number that fit within the segment. If the maximum |
| 227 | * is hit, the number of fifo pairs requested is updated by subtracting the |
| 228 | * number of fifos that have been successfully allocated. |
| 229 | * |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 230 | * @param fs fifo segment for fifo |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 231 | * @param rx_fifo_size data size of rx fifos |
| 232 | * @param tx_fifo_size data size of tx fifos |
| 233 | * @param n_fifo_pairs number of pairs requested. Prior to returning, this |
| 234 | * is decremented by the the number of pairs allocated. |
| 235 | */ |
| 236 | void fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs, |
| 237 | u32 rx_fifo_size, |
| 238 | u32 tx_fifo_size, |
| 239 | u32 * n_fifo_pairs); |
Florin Coras | 344ce42 | 2019-05-03 11:46:55 -0700 | [diff] [blame] | 240 | |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 241 | /** |
| 242 | * Allocate chunks in fifo segment |
| 243 | * |
| 244 | * @param fsh fifo segment header |
| 245 | * @param slice_index slice where chunks should be alocated |
| 246 | * @param chunk_size chunk size needed |
| 247 | * @return chunk (or chunks) that cover at least chunk_size bytes |
| 248 | * on success, 0 on failure. |
| 249 | */ |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 250 | svm_fifo_chunk_t *fsh_alloc_chunk (fifo_segment_header_t * fsh, |
| 251 | u32 slice_index, u32 chunk_size); |
| 252 | |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 253 | /** |
| 254 | * Return chunks to fifo segment |
| 255 | * |
| 256 | * @param fsh fifo segment header |
| 257 | * @param slice_index slice where chunks should be returned |
| 258 | * @param c pointer to first chunk in 0 terminated linked list |
| 259 | */ |
Florin Coras | f22f4e5 | 2019-12-19 16:10:58 -0800 | [diff] [blame] | 260 | void fsh_collect_chunks (fifo_segment_header_t * fsh, u32 slice_index, |
Florin Coras | 9e61d9a | 2020-02-05 21:13:18 +0000 | [diff] [blame] | 261 | svm_fifo_chunk_t * c); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 262 | |
| 263 | /** |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 264 | * Fifo segment has reached mem limit |
| 265 | * |
| 266 | * @param fsh fifo segment header |
| 267 | * @return 1 (if reached) or 0 (otherwise) |
| 268 | */ |
| 269 | u8 fsh_has_reached_mem_limit (fifo_segment_header_t * fsh); |
| 270 | |
| 271 | /** |
| 272 | * Fifo segment reset mem limit flag |
| 273 | * |
| 274 | * @param fs fifo segment |
| 275 | */ |
| 276 | void fsh_reset_mem_limit (fifo_segment_header_t * fsh); |
| 277 | |
| 278 | /** |
Florin Coras | 213b1bb | 2020-12-07 14:33:58 -0800 | [diff] [blame] | 279 | * Fifo segment reset mem limit flag |
| 280 | * |
| 281 | * @param fs fifo segment |
| 282 | * @param size size requested |
| 283 | * @return pointer to memory allocated or 0 |
| 284 | */ |
| 285 | void *fifo_segment_alloc (fifo_segment_t *fs, uword size); |
| 286 | /** |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 287 | * Fifo segment allocated size |
| 288 | * |
| 289 | * Returns fifo segment's allocated size |
| 290 | * |
| 291 | * @param fs fifo segment |
| 292 | * @return allocated size in bytes |
| 293 | */ |
| 294 | uword fifo_segment_size (fifo_segment_t * fs); |
| 295 | |
| 296 | /** |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 297 | * Fifo segment estimate of number of free bytes |
| 298 | * |
| 299 | * Returns fifo segment's internal estimate of the number of free bytes. |
| 300 | * To force a synchronization between the segment and the underlying |
| 301 | * memory allocator, call @ref fifo_segment_update_free_bytes |
| 302 | * |
| 303 | * @param fs fifo segment |
| 304 | * @return free bytes estimate |
| 305 | */ |
Florin Coras | ef4f3e7 | 2019-12-11 14:27:53 -0800 | [diff] [blame] | 306 | uword fifo_segment_free_bytes (fifo_segment_t * fs); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 307 | |
| 308 | /** |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 309 | * Fifo segment number of cached bytes |
| 310 | * |
| 311 | * Returns fifo segment's number of cached bytes. |
| 312 | * |
| 313 | * @param fs fifo segment |
| 314 | * @return cached bytes |
| 315 | */ |
| 316 | uword fifo_segment_cached_bytes (fifo_segment_t * fs); |
| 317 | |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 318 | uword fifo_segment_available_bytes (fifo_segment_t * fs); |
| 319 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 320 | /** |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 321 | * Number of bytes on chunk free lists |
| 322 | * |
| 323 | * @param fs fifo segment |
| 324 | * @return free bytes on chunk free lists |
| 325 | */ |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 326 | uword fifo_segment_fl_chunk_bytes (fifo_segment_t * fs); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 327 | u8 fifo_segment_has_fifos (fifo_segment_t * fs); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 328 | svm_fifo_t *fifo_segment_get_slice_fifo_list (fifo_segment_t * fs, |
| 329 | u32 slice_index); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 330 | u32 fifo_segment_num_fifos (fifo_segment_t * fs); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 331 | u32 fifo_segment_num_free_fifos (fifo_segment_t * fs); |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 332 | /** |
| 333 | * Find number of free chunks of given size |
| 334 | * |
| 335 | * @param fs fifo segment |
| 336 | * @param size chunk size of interest or ~0 if all should be counted |
| 337 | * @return number of chunks of given size |
| 338 | */ |
| 339 | u32 fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 340 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 341 | u8 fifo_segment_get_mem_usage (fifo_segment_t * fs); |
| 342 | fifo_segment_mem_status_t fifo_segment_determine_status |
| 343 | (fifo_segment_header_t * fsh, u8 usage); |
| 344 | fifo_segment_mem_status_t fifo_segment_get_mem_status (fifo_segment_t * fs); |
| 345 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 346 | void fifo_segment_main_init (fifo_segment_main_t * sm, u64 baseva, |
| 347 | u32 timeout_in_seconds); |
| 348 | |
| 349 | format_function_t format_fifo_segment; |
| 350 | format_function_t format_fifo_segment_type; |
| 351 | |
| 352 | #endif /* __included_fifo_segment_h__ */ |
| 353 | |
| 354 | /* |
| 355 | * fd.io coding-style-patch-verification: ON |
| 356 | * |
| 357 | * Local Variables: |
| 358 | * eval: (c-set-style "gnu") |
| 359 | * End: |
| 360 | */ |