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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
15 #ifndef __included_fifo_segment_h__
16 #define __included_fifo_segment_h__
19 #include <svm/svm_fifo.h>
23 FIFO_SEGMENT_FTYPE_NONE = -1,
24 FIFO_SEGMENT_RX_FIFO = 0,
27 } fifo_segment_ftype_t;
29 #define FIFO_SEGMENT_MIN_LOG2_FIFO_SIZE 12 /**< 4kB min fifo size */
30 #define FIFO_SEGMENT_MIN_FIFO_SIZE 4096 /**< 4kB min fifo size */
31 #define FIFO_SEGMENT_MAX_FIFO_SIZE (2 << 30) /**< 2GB max fifo size */
32 #define FIFO_SEGMENT_ALLOC_BATCH_SIZE 32 /* Allocation quantum */
34 typedef enum fifo_segment_flags_
36 FIFO_SEGMENT_F_IS_PREALLOCATED = 1 << 0,
37 FIFO_SEGMENT_F_WILL_DELETE = 1 << 1,
38 FIFO_SEGMENT_F_MEM_LIMIT = 1 << 2,
39 } fifo_segment_flags_t;
41 typedef struct fifo_segment_slice_
43 svm_fifo_t *fifos; /**< Linked list of active RX fifos */
44 svm_fifo_t *free_fifos; /**< Freelists by fifo size */
45 svm_fifo_chunk_t **free_chunks; /**< Freelists by chunk size */
46 uword n_fl_chunk_bytes; /**< Chunk bytes on freelist */
47 } fifo_segment_slice_t;
51 fifo_segment_slice_t *slices; /** Fixed array of slices */
52 ssvm_shared_header_t *ssvm_sh; /**< Pointer to fs ssvm shared hdr */
53 uword n_free_bytes; /**< Segment free bytes */
54 u32 n_active_fifos; /**< Number of active fifos */
55 u32 n_reserved_bytes; /**< Bytes not to be allocated */
56 u32 max_log2_chunk_size; /**< Max log2(chunk size) for fs */
57 u8 flags; /**< Segment flags */
58 u8 n_slices; /**< Number of slices */
59 } fifo_segment_header_t;
63 ssvm_private_t ssvm; /**< ssvm segment data */
64 fifo_segment_header_t *h; /**< fifo segment data */
65 u8 n_slices; /**< number of fifo segment slices */
70 fifo_segment_t *segments; /**< pool of fifo segments */
71 uword next_baseva; /**< Where to put the next one */
72 u32 timeout_in_seconds; /**< Time to wait during attach */
73 } fifo_segment_main_t;
77 ssvm_segment_type_t segment_type; /**< type of segment requested */
78 u32 segment_size; /**< size of the segment */
79 int memfd_fd; /**< fd for memfd segments */
80 char *segment_name; /**< segment name */
81 u32 *new_segment_indices; /**< return vec of new seg indices */
82 } fifo_segment_create_args_t;
84 #define fifo_segment_flags(_fs) _fs->h->flags
86 int fifo_segment_init (fifo_segment_t * fs);
87 int fifo_segment_create (fifo_segment_main_t * sm,
88 fifo_segment_create_args_t * a);
89 int fifo_segment_attach (fifo_segment_main_t * sm,
90 fifo_segment_create_args_t * a);
91 void fifo_segment_delete (fifo_segment_main_t * sm, fifo_segment_t * fs);
92 fifo_segment_t *fifo_segment_get_segment (fifo_segment_main_t * sm,
94 u32 fifo_segment_index (fifo_segment_main_t * sm, fifo_segment_t * fs);
95 void fifo_segment_info (fifo_segment_t * seg, char **address, size_t * size);
98 * Allocate fifo in fifo segment
100 * @param fs fifo segment for fifo
101 * @param data_bytes size of default fifo chunk in bytes
102 * @param ftype fifo type @ref fifo_segment_ftype_t
103 * @return new fifo or 0 if alloc failed
105 svm_fifo_t *fifo_segment_alloc_fifo_w_slice (fifo_segment_t * fs,
108 fifo_segment_ftype_t ftype);
111 * Free fifo allocated in fifo segment
113 * @param fs fifo segment for fifo
114 * @param f fifo to be freed
116 void fifo_segment_free_fifo (fifo_segment_t * fs, svm_fifo_t * f);
119 * Try to preallocate fifo headers
121 * Tries to preallocate fifo headers and adds them to freelist.
123 * @param fs fifo segment
124 * @param batch_size number of chunks to be allocated
125 * @return 0 on success, negative number otherwise
127 int fifo_segment_prealloc_fifo_hdrs (fifo_segment_t * fs, u32 slice_index,
131 * Try to preallocate fifo chunks on segment
133 * Tries to preallocate chunks of requested size on segment and adds them
136 * @param fs fifo segment
137 * @param chunk_size size of chunks to be allocated in bytes
138 * @param batch_size number of chunks to be allocated
139 * @return 0 on success, negative number otherwise
141 int fifo_segment_prealloc_fifo_chunks (fifo_segment_t * fs, u32 slice_index,
142 u32 chunk_size, u32 batch_size);
144 * Pre-allocates fifo pairs in fifo segment
146 * The number of fifos pre-allocated is the minimum of the requested number
147 * of pairs and the maximum number that fit within the segment. If the maximum
148 * is hit, the number of fifo pairs requested is updated by subtracting the
149 * number of fifos that have been successfully allocated.
151 * @param fs fifo segment for fifo
152 * @param rx_fifo_size data size of rx fifos
153 * @param tx_fifo_size data size of tx fifos
154 * @param n_fifo_pairs number of pairs requested. Prior to returning, this
155 * is decremented by the the number of pairs allocated.
157 void fifo_segment_preallocate_fifo_pairs (fifo_segment_t * fs,
162 * Grow fifo size by adding an additional chunk of memory
164 * @param fs fifo segment for fifo
165 * @param f fifo to be grown
166 * @param chunk_size number of bytes to be added to fifo
167 * @return 0 on success or a negative number otherwise
169 int fifo_segment_grow_fifo (fifo_segment_t * fs, svm_fifo_t * f,
173 * Collect unused chunks for fifo
175 * @param fs fifo segment for fifo
176 * @param f fifo whose chunks are to be collected
177 * @return 0 on success, error otherwise
179 int fifo_segment_collect_fifo_chunks (fifo_segment_t * fs, svm_fifo_t * f);
182 * Fifo segment estimate of number of free bytes
184 * Returns fifo segment's internal estimate of the number of free bytes.
185 * To force a synchronization between the segment and the underlying
186 * memory allocator, call @ref fifo_segment_update_free_bytes
188 * @param fs fifo segment
189 * @return free bytes estimate
191 uword fifo_segment_free_bytes (fifo_segment_t * fs);
194 * Update fifo segment free bytes estimate
196 * Forces fifo segment free bytes estimate synchronization with underlying
199 * @param fs fifo segment
201 void fifo_segment_update_free_bytes (fifo_segment_t * fs);
204 * Number of bytes on chunk free lists
206 * @param fs fifo segment
207 * @return free bytes on chunk free lists
209 uword fifo_segment_fl_chunk_bytes (fifo_segment_t * fs);
210 u8 fifo_segment_has_fifos (fifo_segment_t * fs);
211 svm_fifo_t *fifo_segment_get_slice_fifo_list (fifo_segment_t * fs,
213 u32 fifo_segment_num_fifos (fifo_segment_t * fs);
214 u32 fifo_segment_num_free_fifos (fifo_segment_t * fs);
216 * Find number of free chunks of given size
218 * @param fs fifo segment
219 * @param size chunk size of interest or ~0 if all should be counted
220 * @return number of chunks of given size
222 u32 fifo_segment_num_free_chunks (fifo_segment_t * fs, u32 size);
224 void fifo_segment_main_init (fifo_segment_main_t * sm, u64 baseva,
225 u32 timeout_in_seconds);
227 format_function_t format_fifo_segment;
228 format_function_t format_fifo_segment_type;
230 #endif /* __included_fifo_segment_h__ */
233 * fd.io coding-style-patch-verification: ON
236 * eval: (c-set-style "gnu")