1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 fn extract_bit(byte: u8, index: usize) -> bool {
20 let bit_index = if cfg!(target_endian = "big") {
21 7 - (index % 8)
22 } else {
23 index % 8
24 };
25 let mask = 1 << bit_index;
26 byte & mask == mask
27 }
28 #[inline]
29 pub fn get_bit(&self, index: usize) -> bool {
30 debug_assert!(index / 8 < self.storage.as_ref().len());
31 let byte_index = index / 8;
32 let byte = self.storage.as_ref()[byte_index];
33 Self::extract_bit(byte, index)
34 }
35 #[inline]
36 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
37 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
38 let byte_index = index / 8;
39 let byte = unsafe {
40 *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
41 };
42 Self::extract_bit(byte, index)
43 }
44 #[inline]
45 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
46 let bit_index = if cfg!(target_endian = "big") {
47 7 - (index % 8)
48 } else {
49 index % 8
50 };
51 let mask = 1 << bit_index;
52 if val { byte | mask } else { byte & !mask }
53 }
54 #[inline]
55 pub fn set_bit(&mut self, index: usize, val: bool) {
56 debug_assert!(index / 8 < self.storage.as_ref().len());
57 let byte_index = index / 8;
58 let byte = &mut self.storage.as_mut()[byte_index];
59 *byte = Self::change_bit(*byte, index, val);
60 }
61 #[inline]
62 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
63 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
64 let byte_index = index / 8;
65 let byte = unsafe {
66 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
67 };
68 unsafe { *byte = Self::change_bit(*byte, index, val) };
69 }
70 #[inline]
71 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
72 debug_assert!(bit_width <= 64);
73 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
74 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
75 let mut val = 0;
76 for i in 0..(bit_width as usize) {
77 if self.get_bit(i + bit_offset) {
78 let index = if cfg!(target_endian = "big") {
79 bit_width as usize - 1 - i
80 } else {
81 i
82 };
83 val |= 1 << index;
84 }
85 }
86 val
87 }
88 #[inline]
89 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
90 debug_assert!(bit_width <= 64);
91 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
92 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
93 let mut val = 0;
94 for i in 0..(bit_width as usize) {
95 if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
96 let index = if cfg!(target_endian = "big") {
97 bit_width as usize - 1 - i
98 } else {
99 i
100 };
101 val |= 1 << index;
102 }
103 }
104 val
105 }
106 #[inline]
107 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
108 debug_assert!(bit_width <= 64);
109 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
110 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
111 for i in 0..(bit_width as usize) {
112 let mask = 1 << i;
113 let val_bit_is_set = val & mask == mask;
114 let index = if cfg!(target_endian = "big") {
115 bit_width as usize - 1 - i
116 } else {
117 i
118 };
119 self.set_bit(index + bit_offset, val_bit_is_set);
120 }
121 }
122 #[inline]
123 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
124 debug_assert!(bit_width <= 64);
125 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
126 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
127 for i in 0..(bit_width as usize) {
128 let mask = 1 << i;
129 let val_bit_is_set = val & mask == mask;
130 let index = if cfg!(target_endian = "big") {
131 bit_width as usize - 1 - i
132 } else {
133 i
134 };
135 unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
136 }
137 }
138}
139#[repr(C)]
140#[derive(Default)]
141pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
142impl<T> __IncompleteArrayField<T> {
143 #[inline]
144 pub const fn new() -> Self {
145 __IncompleteArrayField(::std::marker::PhantomData, [])
146 }
147 #[inline]
148 pub fn as_ptr(&self) -> *const T {
149 self as *const _ as *const T
150 }
151 #[inline]
152 pub fn as_mut_ptr(&mut self) -> *mut T {
153 self as *mut _ as *mut T
154 }
155 #[inline]
156 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
157 ::std::slice::from_raw_parts(self.as_ptr(), len)
158 }
159 #[inline]
160 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
161 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
162 }
163}
164impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
165 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
166 fmt.write_str("__IncompleteArrayField")
167 }
168}
169#[repr(C)]
170pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
171impl<T> __BindgenUnionField<T> {
172 #[inline]
173 pub const fn new() -> Self {
174 __BindgenUnionField(::std::marker::PhantomData)
175 }
176 #[inline]
177 pub unsafe fn as_ref(&self) -> &T {
178 ::std::mem::transmute(self)
179 }
180 #[inline]
181 pub unsafe fn as_mut(&mut self) -> &mut T {
182 ::std::mem::transmute(self)
183 }
184}
185impl<T> ::std::default::Default for __BindgenUnionField<T> {
186 #[inline]
187 fn default() -> Self {
188 Self::new()
189 }
190}
191impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
192 #[inline]
193 fn clone(&self) -> Self {
194 *self
195 }
196}
197impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
198impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
199 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
200 fmt.write_str("__BindgenUnionField")
201 }
202}
203impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
204 fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
205}
206impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
207 fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
208 true
209 }
210}
211impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
212pub const CLIB_LOG2_CACHE_LINE_BYTES: u32 = 6;
213pub const CLIB_LIB_DIR: &[u8; 21] = b"lib/x86_64-linux-gnu\0";
214pub const CLIB_VECTOR_GROW_BY_ONE: u32 = 0;
215pub const CLIB_MAX_MHEAPS: u32 = 256;
216pub const CLIB_MAX_NUMAS: u32 = 16;
217pub const CLIB_MEM_ERROR: i32 = -1;
218pub const CLIB_MEM_LOG2_MIN_ALIGN: u32 = 3;
219pub const CLIB_MEM_MIN_ALIGN: u32 = 8;
220pub const CLIB_VM_MAP_HDR_NAME_MAX_LEN: u32 = 64;
221pub const VEC_NUMA_UNSPECIFIED: u32 = 255;
222pub const VEC_MIN_ALIGN: u32 = 8;
223pub const UNFORMAT_END_OF_INPUT: i32 = -1;
224pub const UNFORMAT_MORE_INPUT: u32 = 0;
225pub const VLIB_BUFFER_PRE_DATA_SIZE: u32 = 128;
226pub const VLIB_BUFFER_ALIGN: u32 = 64;
227pub const VLIB_BUFFER_ALLOC_FAULT_INJECTOR: u32 = 0;
228pub const VLIB_PROCESS_LOG2_STACK_SIZE: u32 = 15;
229pub const VLIB_BUFFER_DEFAULT_DATA_SIZE: u32 = 2048;
230pub const VLIB_BUFFER_MIN_CHAIN_SEG_SIZE: u32 = 128;
231pub const VLIB_BUFFER_CLONE_HEAD_SIZE: u32 = 256;
232pub const VLIB_BUFFER_FLAGS_ALL: u32 = 15;
233pub const VLIB_BUFFER_TRACE_TRAJECTORY: u32 = 0;
234pub const VLIB_BUFFER_TRACE_TRAJECTORY_SZ: u32 = 0;
235pub const VLIB_BUFFER_INVALID_INDEX: u32 = 4294967295;
236pub const VLIB_BUFFER_POOL_PER_THREAD_CACHE_SZ: u32 = 512;
237pub const VLIB_BUFFER_MAX_NUMA_NODES: u32 = 32;
238pub const CLIB_MARCH_VARIANT_STR: &[u8; 8] = b"default\0";
239pub const VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH: u32 = 1;
240pub const VLIB_NODE_FLAG_IS_OUTPUT: u32 = 2;
241pub const VLIB_NODE_FLAG_IS_DROP: u32 = 4;
242pub const VLIB_NODE_FLAG_IS_PUNT: u32 = 8;
243pub const VLIB_NODE_FLAG_IS_HANDOFF: u32 = 16;
244pub const VLIB_NODE_FLAG_TRACE: u32 = 32;
245pub const VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE: u32 = 64;
246pub const VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE: u32 = 128;
247pub const VLIB_NODE_FLAG_TRACE_SUPPORTED: u32 = 256;
248pub const VLIB_NODE_FLAG_ADAPTIVE_MODE: u32 = 512;
249pub const VLIB_NODE_FLAG_ALLOW_LAZY_NEXT_NODES: u32 = 1024;
250pub const VLIB_FRAME_SIZE: u32 = 256;
251pub const VLIB_FRAME_SIZE_EXTRA: u32 = 4;
252pub const VLIB_FRAME_DATA_ALIGN: u32 = 16;
253pub const VLIB_FRAME_NO_FREE_AFTER_DISPATCH: u32 = 1;
254pub const VLIB_FRAME_NO_APPEND: u32 = 16384;
255pub const VLIB_FRAME_OWNER: u32 = 32768;
256pub const VLIB_FRAME_IS_ALLOCATED: u32 = 2;
257pub const VLIB_FRAME_PENDING: u32 = 4;
258pub const VLIB_FRAME_FREE_AFTER_DISPATCH: u32 = 8;
259pub const VLIB_FRAME_TRACE: u32 = 32;
260pub const VLIB_PROCESS_RESUME_LONGJMP_SUSPEND: u32 = 0;
261pub const VLIB_PROCESS_RESUME_LONGJMP_RESUME: u32 = 1;
262pub const VLIB_PROCESS_STACK_MAGIC: u32 = 3735912109;
263pub const VLIB_NODE_MAIN_RUNTIME_STARTED: u32 = 1;
264pub const FRAME_QUEUE_MAX_NELTS: u32 = 64;
265pub const VLIB_ELOG_MAIN_LOOP: u32 = 0;
266pub const VLIB_LOG2_MAIN_LOOPS_PER_STATS_UPDATE: u32 = 7;
267pub const VLIB_MAIN_LOOP_EXIT_NONE: u32 = 0;
268pub const VLIB_MAIN_LOOP_EXIT_PANIC: u32 = 1;
269pub const VLIB_MAIN_LOOP_EXIT_CLI: u32 = 2;
270pub const VLIB_BUFFER_LINEARIZE_MAX: u32 = 64;
271pub const VNET_REWRITE_TOTAL_BYTES: u32 = 128;
272pub const VL_API_LITTLE_ENDIAN: u32 = 0;
273pub const VL_API_BIG_ENDIAN: u32 = 1;
274pub const VL_SHM_VERSION: u32 = 2;
275pub const VL_API_EPOCH_MASK: u32 = 255;
276pub const VL_API_EPOCH_SHIFT: u32 = 8;
277pub type i8_ = ::std::os::raw::c_schar;
278pub type i16_ = ::std::os::raw::c_short;
279pub type u8_ = ::std::os::raw::c_uchar;
280pub type u16_ = ::std::os::raw::c_ushort;
281pub type i32_ = ::std::os::raw::c_int;
282pub type i64_ = ::std::os::raw::c_long;
283pub type u32_ = ::std::os::raw::c_uint;
284pub type u64_ = ::std::os::raw::c_ulong;
285pub type word = i64_;
286pub type uword = u64_;
287pub type any = word;
288pub type f64_ = f64;
289pub type clib_thread_index_t = u16_;
290pub type __dev_t = ::std::os::raw::c_ulong;
291pub type __uid_t = ::std::os::raw::c_uint;
292pub type __gid_t = ::std::os::raw::c_uint;
293pub type __ino_t = ::std::os::raw::c_ulong;
294pub type __mode_t = ::std::os::raw::c_uint;
295pub type __nlink_t = ::std::os::raw::c_ulong;
296pub type __off_t = ::std::os::raw::c_long;
297pub type __off64_t = ::std::os::raw::c_long;
298pub type __time_t = ::std::os::raw::c_long;
299pub type __blksize_t = ::std::os::raw::c_long;
300pub type __blkcnt_t = ::std::os::raw::c_long;
301pub type __syscall_slong_t = ::std::os::raw::c_long;
302#[repr(C)]
303#[derive(Debug, Default, Copy, Clone)]
304pub struct timespec {
305 pub tv_sec: __time_t,
306 pub tv_nsec: __syscall_slong_t,
307}
308#[repr(C)]
309#[derive(Copy, Clone)]
310pub union __atomic_wide_counter {
311 pub __value64: ::std::os::raw::c_ulonglong,
312 pub __value32: __atomic_wide_counter__bindgen_ty_1,
313}
314#[repr(C)]
315#[derive(Debug, Default, Copy, Clone)]
316pub struct __atomic_wide_counter__bindgen_ty_1 {
317 pub __low: ::std::os::raw::c_uint,
318 pub __high: ::std::os::raw::c_uint,
319}
320impl Default for __atomic_wide_counter {
321 fn default() -> Self {
322 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
323 unsafe {
324 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
325 s.assume_init()
326 }
327 }
328}
329#[repr(C)]
330#[derive(Debug, Copy, Clone)]
331pub struct __pthread_internal_list {
332 pub __prev: *mut __pthread_internal_list,
333 pub __next: *mut __pthread_internal_list,
334}
335impl Default for __pthread_internal_list {
336 fn default() -> Self {
337 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
338 unsafe {
339 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
340 s.assume_init()
341 }
342 }
343}
344pub type __pthread_list_t = __pthread_internal_list;
345#[repr(C)]
346#[derive(Debug, Copy, Clone)]
347pub struct __pthread_mutex_s {
348 pub __lock: ::std::os::raw::c_int,
349 pub __count: ::std::os::raw::c_uint,
350 pub __owner: ::std::os::raw::c_int,
351 pub __nusers: ::std::os::raw::c_uint,
352 pub __kind: ::std::os::raw::c_int,
353 pub __spins: ::std::os::raw::c_short,
354 pub __elision: ::std::os::raw::c_short,
355 pub __list: __pthread_list_t,
356}
357impl Default for __pthread_mutex_s {
358 fn default() -> Self {
359 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
360 unsafe {
361 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
362 s.assume_init()
363 }
364 }
365}
366#[repr(C)]
367#[derive(Copy, Clone)]
368pub struct __pthread_cond_s {
369 pub __wseq: __atomic_wide_counter,
370 pub __g1_start: __atomic_wide_counter,
371 pub __g_refs: [::std::os::raw::c_uint; 2usize],
372 pub __g_size: [::std::os::raw::c_uint; 2usize],
373 pub __g1_orig_size: ::std::os::raw::c_uint,
374 pub __wrefs: ::std::os::raw::c_uint,
375 pub __g_signals: [::std::os::raw::c_uint; 2usize],
376}
377impl Default for __pthread_cond_s {
378 fn default() -> Self {
379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
380 unsafe {
381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
382 s.assume_init()
383 }
384 }
385}
386pub type pthread_t = ::std::os::raw::c_ulong;
387#[repr(C)]
388#[derive(Copy, Clone)]
389pub union pthread_mutex_t {
390 pub __data: __pthread_mutex_s,
391 pub __size: [::std::os::raw::c_char; 40usize],
392 pub __align: ::std::os::raw::c_long,
393}
394impl Default for pthread_mutex_t {
395 fn default() -> Self {
396 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
397 unsafe {
398 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
399 s.assume_init()
400 }
401 }
402}
403#[repr(C)]
404#[derive(Copy, Clone)]
405pub union pthread_cond_t {
406 pub __data: __pthread_cond_s,
407 pub __size: [::std::os::raw::c_char; 48usize],
408 pub __align: ::std::os::raw::c_longlong,
409}
410impl Default for pthread_cond_t {
411 fn default() -> Self {
412 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
413 unsafe {
414 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
415 s.assume_init()
416 }
417 }
418}
419pub const CLIB_ERROR_FATAL: _bindgen_ty_29 = 1;
420pub const CLIB_ERROR_ABORT: _bindgen_ty_29 = 2;
421pub const CLIB_ERROR_WARNING: _bindgen_ty_29 = 4;
422pub const CLIB_ERROR_ERRNO_VALID: _bindgen_ty_29 = 65536;
423pub const CLIB_ERROR_NO_RATE_LIMIT: _bindgen_ty_29 = 131072;
424pub type _bindgen_ty_29 = ::std::os::raw::c_uint;
425unsafe extern "C" {
426 pub fn _clib_error(
427 code: ::std::os::raw::c_int,
428 function_name: *const ::std::os::raw::c_char,
429 line_number: uword,
430 format: *const ::std::os::raw::c_char,
431 ...
432 );
433}
434pub type va_list = __builtin_va_list;
435#[repr(C)]
436#[derive(Debug, Copy, Clone)]
437pub struct clib_error_t {
438 pub what: *mut u8_,
439 pub where_: *const u8_,
440 pub flags: uword,
441 pub code: any,
442}
443impl Default for clib_error_t {
444 fn default() -> Self {
445 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
446 unsafe {
447 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
448 s.assume_init()
449 }
450 }
451}
452pub type u64x2 = [u64_; 2usize];
453pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_UNKNOWN: clib_mem_page_sz_t = 0;
454pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_DEFAULT: clib_mem_page_sz_t = 1;
455pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_DEFAULT_HUGE: clib_mem_page_sz_t = 2;
456pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_4K: clib_mem_page_sz_t = 12;
457pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_16K: clib_mem_page_sz_t = 14;
458pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_64K: clib_mem_page_sz_t = 16;
459pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_1M: clib_mem_page_sz_t = 20;
460pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_2M: clib_mem_page_sz_t = 21;
461pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_16M: clib_mem_page_sz_t = 24;
462pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_32M: clib_mem_page_sz_t = 25;
463pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_512M: clib_mem_page_sz_t = 29;
464pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_1G: clib_mem_page_sz_t = 30;
465pub const clib_mem_page_sz_t_CLIB_MEM_PAGE_SZ_16G: clib_mem_page_sz_t = 34;
466pub type clib_mem_page_sz_t = ::std::os::raw::c_uint;
467#[repr(C)]
468#[derive(Debug, Copy, Clone)]
469pub struct _clib_mem_vm_map_hdr {
470 pub base_addr: uword,
471 pub num_pages: uword,
472 pub log2_page_sz: clib_mem_page_sz_t,
473 pub fd: ::std::os::raw::c_int,
474 pub name: [::std::os::raw::c_char; 64usize],
475 pub prev: *mut _clib_mem_vm_map_hdr,
476 pub next: *mut _clib_mem_vm_map_hdr,
477}
478impl Default for _clib_mem_vm_map_hdr {
479 fn default() -> Self {
480 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
481 unsafe {
482 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
483 s.assume_init()
484 }
485 }
486}
487pub type clib_mem_vm_map_hdr_t = _clib_mem_vm_map_hdr;
488pub const clib_mem_heap_flag_t_CLIB_MEM_HEAP_F_LOCKED: clib_mem_heap_flag_t = 1;
489pub const clib_mem_heap_flag_t_CLIB_MEM_HEAP_F_UNMAP_ON_DESTROY: clib_mem_heap_flag_t = 2;
490pub const clib_mem_heap_flag_t_CLIB_MEM_HEAP_F_TRACED: clib_mem_heap_flag_t = 4;
491pub type clib_mem_heap_flag_t = ::std::os::raw::c_uint;
492#[repr(C)]
493#[derive(Debug)]
494pub struct clib_mem_heap_t<FAM: ?Sized = [::std::os::raw::c_char; 0]> {
495 pub base: *mut ::std::os::raw::c_void,
496 pub mspace: *mut ::std::os::raw::c_void,
497 pub size: uword,
498 pub _bitfield_align_1: [u8; 0],
499 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
500 pub name: FAM,
501}
502impl clib_mem_heap_t<[::std::os::raw::c_char]> {}
503impl clib_mem_heap_t<[::std::os::raw::c_char; 0]> {}
504impl Default for clib_mem_heap_t<[::std::os::raw::c_char; 0]> {
505 fn default() -> Self {
506 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
507 unsafe {
508 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
509 s.assume_init()
510 }
511 }
512}
513impl clib_mem_heap_t<[::std::os::raw::c_char; 0]> {
514 #[inline]
515 pub fn log2_page_sz(&self) -> clib_mem_page_sz_t {
516 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
517 }
518 #[inline]
519 pub fn set_log2_page_sz(&mut self, val: clib_mem_page_sz_t) {
520 unsafe {
521 let val: u32 = ::std::mem::transmute(val);
522 self._bitfield_1.set(0usize, 8u8, val as u64)
523 }
524 }
525 #[inline]
526 pub unsafe fn log2_page_sz_raw(this: *const Self) -> clib_mem_page_sz_t {
527 unsafe {
528 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
529 ::std::ptr::addr_of!((*this)._bitfield_1),
530 0usize,
531 8u8,
532 ) as u32)
533 }
534 }
535 #[inline]
536 pub unsafe fn set_log2_page_sz_raw(this: *mut Self, val: clib_mem_page_sz_t) {
537 unsafe {
538 let val: u32 = ::std::mem::transmute(val);
539 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
540 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
541 0usize,
542 8u8,
543 val as u64,
544 )
545 }
546 }
547 #[inline]
548 pub fn flags(&self) -> clib_mem_heap_flag_t {
549 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
550 }
551 #[inline]
552 pub fn set_flags(&mut self, val: clib_mem_heap_flag_t) {
553 unsafe {
554 let val: u32 = ::std::mem::transmute(val);
555 self._bitfield_1.set(8usize, 8u8, val as u64)
556 }
557 }
558 #[inline]
559 pub unsafe fn flags_raw(this: *const Self) -> clib_mem_heap_flag_t {
560 unsafe {
561 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
562 ::std::ptr::addr_of!((*this)._bitfield_1),
563 8usize,
564 8u8,
565 ) as u32)
566 }
567 }
568 #[inline]
569 pub unsafe fn set_flags_raw(this: *mut Self, val: clib_mem_heap_flag_t) {
570 unsafe {
571 let val: u32 = ::std::mem::transmute(val);
572 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
573 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
574 8usize,
575 8u8,
576 val as u64,
577 )
578 }
579 }
580 #[inline]
581 pub fn new_bitfield_1(
582 log2_page_sz: clib_mem_page_sz_t,
583 flags: clib_mem_heap_flag_t,
584 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
585 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
586 __bindgen_bitfield_unit.set(0usize, 8u8, {
587 let log2_page_sz: u32 = unsafe { ::std::mem::transmute(log2_page_sz) };
588 log2_page_sz as u64
589 });
590 __bindgen_bitfield_unit.set(8usize, 8u8, {
591 let flags: u32 = unsafe { ::std::mem::transmute(flags) };
592 flags as u64
593 });
594 __bindgen_bitfield_unit
595 }
596}
597#[repr(C)]
598#[derive(Debug, Copy, Clone)]
599pub struct clib_mem_main_t {
600 pub log2_page_sz: clib_mem_page_sz_t,
601 pub log2_default_hugepage_sz: clib_mem_page_sz_t,
602 pub log2_sys_default_hugepage_sz: clib_mem_page_sz_t,
603 pub numa_node_bitmap: u32_,
604 pub per_cpu_mheaps: [*mut ::std::os::raw::c_void; 256usize],
605 pub per_numa_mheaps: [*mut ::std::os::raw::c_void; 16usize],
606 pub first_map: *mut clib_mem_vm_map_hdr_t,
607 pub last_map: *mut clib_mem_vm_map_hdr_t,
608 pub map_lock: u8_,
609 pub error: *mut clib_error_t,
610}
611impl Default for clib_mem_main_t {
612 fn default() -> Self {
613 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
614 unsafe {
615 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
616 s.assume_init()
617 }
618 }
619}
620unsafe extern "C" {
621 pub static mut clib_mem_main: clib_mem_main_t;
622}
623unsafe extern "C" {
624 pub fn clib_mem_alloc(size: uword) -> *mut ::std::os::raw::c_void;
625}
626unsafe extern "C" {
627 pub fn clib_mem_alloc_aligned(size: uword, align: uword) -> *mut ::std::os::raw::c_void;
628}
629unsafe extern "C" {
630 pub fn clib_mem_alloc_or_null(size: uword) -> *mut ::std::os::raw::c_void;
631}
632unsafe extern "C" {
633 pub fn clib_mem_alloc_aligned_or_null(size: uword, align: uword)
634 -> *mut ::std::os::raw::c_void;
635}
636unsafe extern "C" {
637 pub fn clib_mem_realloc(
638 p: *mut ::std::os::raw::c_void,
639 new_size: uword,
640 ) -> *mut ::std::os::raw::c_void;
641}
642unsafe extern "C" {
643 pub fn clib_mem_realloc_aligned(
644 p: *mut ::std::os::raw::c_void,
645 new_size: uword,
646 align: uword,
647 ) -> *mut ::std::os::raw::c_void;
648}
649unsafe extern "C" {
650 pub fn clib_mem_is_heap_object(p: *mut ::std::os::raw::c_void) -> uword;
651}
652unsafe extern "C" {
653 pub fn clib_mem_free(p: *mut ::std::os::raw::c_void);
654}
655unsafe extern "C" {
656 pub fn clib_mem_heap_alloc(
657 heap: *mut ::std::os::raw::c_void,
658 size: uword,
659 ) -> *mut ::std::os::raw::c_void;
660}
661unsafe extern "C" {
662 pub fn clib_mem_heap_alloc_aligned(
663 heap: *mut ::std::os::raw::c_void,
664 size: uword,
665 align: uword,
666 ) -> *mut ::std::os::raw::c_void;
667}
668unsafe extern "C" {
669 pub fn clib_mem_heap_alloc_or_null(
670 heap: *mut ::std::os::raw::c_void,
671 size: uword,
672 ) -> *mut ::std::os::raw::c_void;
673}
674unsafe extern "C" {
675 pub fn clib_mem_heap_alloc_aligned_or_null(
676 heap: *mut ::std::os::raw::c_void,
677 size: uword,
678 align: uword,
679 ) -> *mut ::std::os::raw::c_void;
680}
681unsafe extern "C" {
682 pub fn clib_mem_heap_realloc(
683 heap: *mut ::std::os::raw::c_void,
684 p: *mut ::std::os::raw::c_void,
685 new_size: uword,
686 ) -> *mut ::std::os::raw::c_void;
687}
688unsafe extern "C" {
689 pub fn clib_mem_heap_realloc_aligned(
690 heap: *mut ::std::os::raw::c_void,
691 p: *mut ::std::os::raw::c_void,
692 new_size: uword,
693 align: uword,
694 ) -> *mut ::std::os::raw::c_void;
695}
696unsafe extern "C" {
697 pub fn clib_mem_heap_is_heap_object(
698 heap: *mut ::std::os::raw::c_void,
699 p: *mut ::std::os::raw::c_void,
700 ) -> uword;
701}
702unsafe extern "C" {
703 pub fn clib_mem_heap_free(heap: *mut ::std::os::raw::c_void, p: *mut ::std::os::raw::c_void);
704}
705unsafe extern "C" {
706 pub fn clib_mem_size(p: *mut ::std::os::raw::c_void) -> uword;
707}
708unsafe extern "C" {
709 pub fn clib_mem_free_s(p: *mut ::std::os::raw::c_void);
710}
711unsafe extern "C" {
712 pub fn clib_mem_destroy_heap(heap: *mut clib_mem_heap_t);
713}
714unsafe extern "C" {
715 pub fn clib_mem_create_heap(
716 base: *mut ::std::os::raw::c_void,
717 size: uword,
718 is_locked: ::std::os::raw::c_int,
719 fmt: *mut ::std::os::raw::c_char,
720 ...
721 ) -> *mut clib_mem_heap_t;
722}
723unsafe extern "C" {
724 pub fn clib_mem_main_init();
725}
726unsafe extern "C" {
727 pub fn clib_mem_init(
728 base: *mut ::std::os::raw::c_void,
729 size: uword,
730 ) -> *mut ::std::os::raw::c_void;
731}
732unsafe extern "C" {
733 pub fn clib_mem_init_with_page_size(
734 memory_size: uword,
735 log2_page_sz: clib_mem_page_sz_t,
736 ) -> *mut ::std::os::raw::c_void;
737}
738unsafe extern "C" {
739 pub fn clib_mem_init_thread_safe(
740 memory: *mut ::std::os::raw::c_void,
741 memory_size: uword,
742 ) -> *mut ::std::os::raw::c_void;
743}
744unsafe extern "C" {
745 pub fn clib_mem_exit();
746}
747#[repr(C)]
748#[derive(Debug, Copy, Clone)]
749pub struct mheap_trace_t {
750 pub callers: [*mut ::std::os::raw::c_void; 12usize],
751 pub n_allocations: u32_,
752 pub n_bytes: u32_,
753 pub offset: uword,
754}
755impl Default for mheap_trace_t {
756 fn default() -> Self {
757 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
758 unsafe {
759 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
760 s.assume_init()
761 }
762 }
763}
764unsafe extern "C" {
765 pub fn clib_mem_trace(enable: ::std::os::raw::c_int);
766}
767unsafe extern "C" {
768 pub fn clib_mem_is_traced() -> ::std::os::raw::c_int;
769}
770unsafe extern "C" {
771 pub fn clib_mem_trace_dup(heap: *mut clib_mem_heap_t) -> *mut mheap_trace_t;
772}
773#[repr(C)]
774#[derive(Debug, Default, Copy, Clone)]
775pub struct clib_mem_usage_t {
776 pub object_count: uword,
777 pub bytes_total: uword,
778 pub bytes_used: uword,
779 pub bytes_free: uword,
780 pub bytes_overhead: uword,
781 pub bytes_free_reclaimed: uword,
782 pub bytes_used_sbrk: uword,
783 pub bytes_used_mmap: uword,
784 pub bytes_max: uword,
785}
786unsafe extern "C" {
787 pub fn clib_mem_get_heap_usage(heap: *mut clib_mem_heap_t, usage: *mut clib_mem_usage_t);
788}
789unsafe extern "C" {
790 pub fn clib_mem_get_heap_base(heap: *mut clib_mem_heap_t) -> *mut ::std::os::raw::c_void;
791}
792unsafe extern "C" {
793 pub fn clib_mem_get_heap_size(heap: *mut clib_mem_heap_t) -> uword;
794}
795unsafe extern "C" {
796 pub fn clib_mem_get_heap_free_space(heap: *mut clib_mem_heap_t) -> uword;
797}
798unsafe extern "C" {
799 pub fn format_clib_mem_usage(s: *mut u8_, args: *mut va_list) -> *mut u8_;
800}
801unsafe extern "C" {
802 pub fn format_clib_mem_heap(s: *mut u8_, va: *mut va_list) -> *mut u8_;
803}
804unsafe extern "C" {
805 pub fn format_clib_mem_page_stats(s: *mut u8_, va: *mut va_list) -> *mut u8_;
806}
807unsafe extern "C" {
808 pub fn clib_mem_vm_map_internal(
809 base: *mut ::std::os::raw::c_void,
810 log2_page_sz: clib_mem_page_sz_t,
811 size: uword,
812 fd: ::std::os::raw::c_int,
813 offset: uword,
814 name: *mut ::std::os::raw::c_char,
815 ) -> *mut ::std::os::raw::c_void;
816}
817unsafe extern "C" {
818 pub fn clib_mem_vm_map(
819 start: *mut ::std::os::raw::c_void,
820 size: uword,
821 log2_page_size: clib_mem_page_sz_t,
822 fmt: *mut ::std::os::raw::c_char,
823 ...
824 ) -> *mut ::std::os::raw::c_void;
825}
826unsafe extern "C" {
827 pub fn clib_mem_vm_map_stack(
828 size: uword,
829 log2_page_size: clib_mem_page_sz_t,
830 fmt: *mut ::std::os::raw::c_char,
831 ...
832 ) -> *mut ::std::os::raw::c_void;
833}
834unsafe extern "C" {
835 pub fn clib_mem_vm_map_shared(
836 start: *mut ::std::os::raw::c_void,
837 size: uword,
838 fd: ::std::os::raw::c_int,
839 offset: uword,
840 fmt: *mut ::std::os::raw::c_char,
841 ...
842 ) -> *mut ::std::os::raw::c_void;
843}
844unsafe extern "C" {
845 pub fn clib_mem_vm_unmap(base: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
846}
847unsafe extern "C" {
848 pub fn clib_mem_vm_get_next_map_hdr(
849 hdr: *mut clib_mem_vm_map_hdr_t,
850 ) -> *mut clib_mem_vm_map_hdr_t;
851}
852unsafe extern "C" {
853 pub fn clib_mem_vm_create_fd(
854 log2_page_size: clib_mem_page_sz_t,
855 fmt: *mut ::std::os::raw::c_char,
856 ...
857 ) -> ::std::os::raw::c_int;
858}
859unsafe extern "C" {
860 pub fn clib_mem_get_fd_page_size(fd: ::std::os::raw::c_int) -> uword;
861}
862unsafe extern "C" {
863 pub fn clib_mem_get_fd_log2_page_size(fd: ::std::os::raw::c_int) -> clib_mem_page_sz_t;
864}
865unsafe extern "C" {
866 pub fn clib_mem_vm_reserve(
867 start: uword,
868 size: uword,
869 log2_page_sz: clib_mem_page_sz_t,
870 ) -> uword;
871}
872unsafe extern "C" {
873 pub fn clib_mem_vm_get_paddr(
874 mem: *mut ::std::os::raw::c_void,
875 log2_page_size: clib_mem_page_sz_t,
876 n_pages: ::std::os::raw::c_int,
877 ) -> *mut u64_;
878}
879unsafe extern "C" {
880 pub fn clib_mem_destroy();
881}
882unsafe extern "C" {
883 pub fn clib_mem_set_numa_affinity(
884 numa_node: u8_,
885 force: ::std::os::raw::c_int,
886 ) -> ::std::os::raw::c_int;
887}
888unsafe extern "C" {
889 pub fn clib_mem_set_default_numa_affinity() -> ::std::os::raw::c_int;
890}
891unsafe extern "C" {
892 pub fn clib_mem_vm_randomize_va(requested_va: *mut uword, log2_page_size: clib_mem_page_sz_t);
893}
894unsafe extern "C" {
895 pub fn mheap_trace(v: *mut clib_mem_heap_t, enable: ::std::os::raw::c_int);
896}
897unsafe extern "C" {
898 pub fn clib_mem_trace_enable_disable(enable: uword) -> uword;
899}
900#[repr(C)]
901#[derive(Debug, Copy, Clone)]
902pub struct clib_mem_page_stats_t {
903 pub log2_page_sz: clib_mem_page_sz_t,
904 pub total: uword,
905 pub mapped: uword,
906 pub not_mapped: uword,
907 pub per_numa: [uword; 16usize],
908 pub unknown: uword,
909}
910impl Default for clib_mem_page_stats_t {
911 fn default() -> Self {
912 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
913 unsafe {
914 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
915 s.assume_init()
916 }
917 }
918}
919unsafe extern "C" {
920 pub fn clib_mem_get_page_stats(
921 start: *mut ::std::os::raw::c_void,
922 log2_page_size: clib_mem_page_sz_t,
923 n_pages: uword,
924 stats: *mut clib_mem_page_stats_t,
925 );
926}
927pub type clib_mem_bulk_handle_t = *mut ::std::os::raw::c_void;
928unsafe extern "C" {
929 pub fn clib_mem_bulk_init(
930 elt_sz: u32_,
931 align: u32_,
932 min_elts_per_chunk: u32_,
933 ) -> clib_mem_bulk_handle_t;
934}
935unsafe extern "C" {
936 pub fn clib_mem_bulk_destroy(h: clib_mem_bulk_handle_t);
937}
938unsafe extern "C" {
939 pub fn clib_mem_bulk_alloc(h: clib_mem_bulk_handle_t) -> *mut ::std::os::raw::c_void;
940}
941unsafe extern "C" {
942 pub fn clib_mem_bulk_free(h: clib_mem_bulk_handle_t, p: *mut ::std::os::raw::c_void);
943}
944unsafe extern "C" {
945 pub fn format_clib_mem_bulk(s: *mut u8_, args: *mut va_list) -> *mut u8_;
946}
947#[repr(C)]
948#[derive(Debug, Default)]
949pub struct vec_header_t<FAM: ?Sized = [u8_; 0]> {
950 pub len: u32_,
951 pub hdr_size: u8_,
952 pub _bitfield_align_1: [u8; 0],
953 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
954 pub grow_elts: u8_,
955 pub vpad: [u8_; 1usize],
956 pub vector_data: FAM,
957}
958impl vec_header_t<[u8_]> {}
959impl vec_header_t<[u8_; 0]> {}
960impl vec_header_t<[u8_; 0]> {
961 #[inline]
962 pub fn log2_align(&self) -> u8_ {
963 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u8) }
964 }
965 #[inline]
966 pub fn set_log2_align(&mut self, val: u8_) {
967 unsafe {
968 let val: u8 = ::std::mem::transmute(val);
969 self._bitfield_1.set(0usize, 7u8, val as u64)
970 }
971 }
972 #[inline]
973 pub unsafe fn log2_align_raw(this: *const Self) -> u8_ {
974 unsafe {
975 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
976 ::std::ptr::addr_of!((*this)._bitfield_1),
977 0usize,
978 7u8,
979 ) as u8)
980 }
981 }
982 #[inline]
983 pub unsafe fn set_log2_align_raw(this: *mut Self, val: u8_) {
984 unsafe {
985 let val: u8 = ::std::mem::transmute(val);
986 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
987 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
988 0usize,
989 7u8,
990 val as u64,
991 )
992 }
993 }
994 #[inline]
995 pub fn default_heap(&self) -> u8_ {
996 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
997 }
998 #[inline]
999 pub fn set_default_heap(&mut self, val: u8_) {
1000 unsafe {
1001 let val: u8 = ::std::mem::transmute(val);
1002 self._bitfield_1.set(7usize, 1u8, val as u64)
1003 }
1004 }
1005 #[inline]
1006 pub unsafe fn default_heap_raw(this: *const Self) -> u8_ {
1007 unsafe {
1008 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1009 ::std::ptr::addr_of!((*this)._bitfield_1),
1010 7usize,
1011 1u8,
1012 ) as u8)
1013 }
1014 }
1015 #[inline]
1016 pub unsafe fn set_default_heap_raw(this: *mut Self, val: u8_) {
1017 unsafe {
1018 let val: u8 = ::std::mem::transmute(val);
1019 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1020 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1021 7usize,
1022 1u8,
1023 val as u64,
1024 )
1025 }
1026 }
1027 #[inline]
1028 pub fn new_bitfield_1(
1029 log2_align: u8_,
1030 default_heap: u8_,
1031 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1032 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1033 __bindgen_bitfield_unit.set(0usize, 7u8, {
1034 let log2_align: u8 = unsafe { ::std::mem::transmute(log2_align) };
1035 log2_align as u64
1036 });
1037 __bindgen_bitfield_unit.set(7usize, 1u8, {
1038 let default_heap: u8 = unsafe { ::std::mem::transmute(default_heap) };
1039 default_heap as u64
1040 });
1041 __bindgen_bitfield_unit
1042 }
1043}
1044unsafe extern "C" {
1045 pub fn vec_len_not_inline(v: *mut ::std::os::raw::c_void) -> u32_;
1046}
1047unsafe extern "C" {
1048 pub fn vec_mem_size(v: *mut ::std::os::raw::c_void) -> uword;
1049}
1050#[repr(C)]
1051#[derive(Debug, Copy, Clone)]
1052pub struct vec_attr_t {
1053 pub heap: *mut ::std::os::raw::c_void,
1054 pub elt_sz: u32_,
1055 pub hdr_sz: u16_,
1056 pub align: u16_,
1057}
1058impl Default for vec_attr_t {
1059 fn default() -> Self {
1060 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1061 unsafe {
1062 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1063 s.assume_init()
1064 }
1065 }
1066}
1067unsafe extern "C" {
1068 pub fn _vec_alloc_internal(
1069 n_elts: uword,
1070 attr: *const vec_attr_t,
1071 ) -> *mut ::std::os::raw::c_void;
1072}
1073unsafe extern "C" {
1074 pub fn _vec_realloc_internal(
1075 v: *mut ::std::os::raw::c_void,
1076 n_elts: uword,
1077 attr: *const vec_attr_t,
1078 ) -> *mut ::std::os::raw::c_void;
1079}
1080unsafe extern "C" {
1081 pub fn _vec_resize_internal(
1082 v: *mut ::std::os::raw::c_void,
1083 n_elts: uword,
1084 attr: *const vec_attr_t,
1085 ) -> *mut ::std::os::raw::c_void;
1086}
1087unsafe extern "C" {
1088 pub fn vec_free_not_inline(v: *mut ::std::os::raw::c_void);
1089}
1090pub type clib_error_handler_func_t = ::std::option::Option<
1091 unsafe extern "C" fn(
1092 arg: *mut ::std::os::raw::c_void,
1093 msg: *mut u8_,
1094 msg_len: ::std::os::raw::c_int,
1095 ),
1096>;
1097unsafe extern "C" {
1098 pub fn clib_error_register_handler(
1099 func: clib_error_handler_func_t,
1100 arg: *mut ::std::os::raw::c_void,
1101 );
1102}
1103unsafe extern "C" {
1104 pub fn clib_error_free_vector(errors: *mut clib_error_t) -> *mut ::std::os::raw::c_void;
1105}
1106unsafe extern "C" {
1107 pub fn _clib_error_return(
1108 errors: *mut clib_error_t,
1109 code: any,
1110 flags: uword,
1111 where_: *const ::std::os::raw::c_char,
1112 fmt: *const ::std::os::raw::c_char,
1113 ...
1114 ) -> *mut clib_error_t;
1115}
1116unsafe extern "C" {
1117 pub fn _clib_error_report(errors: *mut clib_error_t) -> *mut clib_error_t;
1118}
1119unsafe extern "C" {
1120 pub fn format_clib_error(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1121}
1122#[repr(C)]
1123#[repr(align(64))]
1124#[derive(Debug)]
1125pub struct clib_spinlock_s {
1126 pub cacheline0: __IncompleteArrayField<u8_>,
1127 pub lock: u32_,
1128}
1129impl Default for clib_spinlock_s {
1130 fn default() -> Self {
1131 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1132 unsafe {
1133 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1134 s.assume_init()
1135 }
1136 }
1137}
1138pub type clib_spinlock_t = *mut clib_spinlock_s;
1139pub const pcap_packet_type_t_PCAP_PACKET_TYPE_null: pcap_packet_type_t = 0;
1140pub const pcap_packet_type_t_PCAP_PACKET_TYPE_ethernet: pcap_packet_type_t = 1;
1141pub const pcap_packet_type_t_PCAP_PACKET_TYPE_ppp: pcap_packet_type_t = 9;
1142pub const pcap_packet_type_t_PCAP_PACKET_TYPE_ip: pcap_packet_type_t = 12;
1143pub const pcap_packet_type_t_PCAP_PACKET_TYPE_hdlc: pcap_packet_type_t = 104;
1144pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user0: pcap_packet_type_t = 147;
1145pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user1: pcap_packet_type_t = 148;
1146pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user2: pcap_packet_type_t = 149;
1147pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user3: pcap_packet_type_t = 150;
1148pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user4: pcap_packet_type_t = 151;
1149pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user5: pcap_packet_type_t = 152;
1150pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user6: pcap_packet_type_t = 153;
1151pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user7: pcap_packet_type_t = 154;
1152pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user8: pcap_packet_type_t = 155;
1153pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user9: pcap_packet_type_t = 156;
1154pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user10: pcap_packet_type_t = 157;
1155pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user11: pcap_packet_type_t = 158;
1156pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user12: pcap_packet_type_t = 159;
1157pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user13: pcap_packet_type_t = 160;
1158pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user14: pcap_packet_type_t = 161;
1159pub const pcap_packet_type_t_PCAP_PACKET_TYPE_user15: pcap_packet_type_t = 162;
1160pub const pcap_packet_type_t_PCAP_PACKET_TYPE_vpp: pcap_packet_type_t = 280;
1161pub type pcap_packet_type_t = ::std::os::raw::c_uint;
1162#[repr(C)]
1163#[derive(Debug, Copy, Clone)]
1164pub struct pcap_main_t {
1165 pub lock: clib_spinlock_t,
1166 pub file_name: *mut ::std::os::raw::c_char,
1167 pub n_packets_to_capture: u32_,
1168 pub packet_type: pcap_packet_type_t,
1169 pub n_packets_captured: u32_,
1170 pub flags: u32_,
1171 pub file_descriptor: ::std::os::raw::c_int,
1172 pub n_pcap_data_written: u32_,
1173 pub pcap_data: *mut u8_,
1174 pub packets_read: *mut *mut u8_,
1175 pub timestamps: *mut u64_,
1176 pub min_packet_bytes: u32_,
1177 pub max_packet_bytes: u32_,
1178}
1179impl Default for pcap_main_t {
1180 fn default() -> Self {
1181 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1182 unsafe {
1183 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1184 s.assume_init()
1185 }
1186 }
1187}
1188pub type format_function_t =
1189 ::std::option::Option<unsafe extern "C" fn(s: *mut u8_, args: *mut va_list) -> *mut u8_>;
1190unsafe extern "C" {
1191 pub fn va_format(
1192 s: *mut u8_,
1193 format: *const ::std::os::raw::c_char,
1194 args: *mut va_list,
1195 ) -> *mut u8_;
1196}
1197unsafe extern "C" {
1198 pub fn format(s: *mut u8_, format: *const ::std::os::raw::c_char, ...) -> *mut u8_;
1199}
1200pub type FILE = _IO_FILE;
1201#[repr(C)]
1202#[derive(Debug, Copy, Clone)]
1203pub struct _IO_marker {
1204 _unused: [u8; 0],
1205}
1206#[repr(C)]
1207#[derive(Debug, Copy, Clone)]
1208pub struct _IO_codecvt {
1209 _unused: [u8; 0],
1210}
1211#[repr(C)]
1212#[derive(Debug, Copy, Clone)]
1213pub struct _IO_wide_data {
1214 _unused: [u8; 0],
1215}
1216pub type _IO_lock_t = ::std::os::raw::c_void;
1217#[repr(C)]
1218#[derive(Debug, Copy, Clone)]
1219pub struct _IO_FILE {
1220 pub _flags: ::std::os::raw::c_int,
1221 pub _IO_read_ptr: *mut ::std::os::raw::c_char,
1222 pub _IO_read_end: *mut ::std::os::raw::c_char,
1223 pub _IO_read_base: *mut ::std::os::raw::c_char,
1224 pub _IO_write_base: *mut ::std::os::raw::c_char,
1225 pub _IO_write_ptr: *mut ::std::os::raw::c_char,
1226 pub _IO_write_end: *mut ::std::os::raw::c_char,
1227 pub _IO_buf_base: *mut ::std::os::raw::c_char,
1228 pub _IO_buf_end: *mut ::std::os::raw::c_char,
1229 pub _IO_save_base: *mut ::std::os::raw::c_char,
1230 pub _IO_backup_base: *mut ::std::os::raw::c_char,
1231 pub _IO_save_end: *mut ::std::os::raw::c_char,
1232 pub _markers: *mut _IO_marker,
1233 pub _chain: *mut _IO_FILE,
1234 pub _fileno: ::std::os::raw::c_int,
1235 pub _flags2: ::std::os::raw::c_int,
1236 pub _old_offset: __off_t,
1237 pub _cur_column: ::std::os::raw::c_ushort,
1238 pub _vtable_offset: ::std::os::raw::c_schar,
1239 pub _shortbuf: [::std::os::raw::c_char; 1usize],
1240 pub _lock: *mut _IO_lock_t,
1241 pub _offset: __off64_t,
1242 pub _codecvt: *mut _IO_codecvt,
1243 pub _wide_data: *mut _IO_wide_data,
1244 pub _freeres_list: *mut _IO_FILE,
1245 pub _freeres_buf: *mut ::std::os::raw::c_void,
1246 pub __pad5: usize,
1247 pub _mode: ::std::os::raw::c_int,
1248 pub _unused2: [::std::os::raw::c_char; 20usize],
1249}
1250impl Default for _IO_FILE {
1251 fn default() -> Self {
1252 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1253 unsafe {
1254 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1255 s.assume_init()
1256 }
1257 }
1258}
1259unsafe extern "C" {
1260 pub fn va_fformat(f: *mut FILE, fmt: *mut ::std::os::raw::c_char, va: *mut va_list) -> word;
1261}
1262unsafe extern "C" {
1263 pub fn fformat(f: *mut FILE, fmt: *mut ::std::os::raw::c_char, ...) -> word;
1264}
1265unsafe extern "C" {
1266 pub fn fdformat(fd: ::std::os::raw::c_int, fmt: *mut ::std::os::raw::c_char, ...) -> word;
1267}
1268unsafe extern "C" {
1269 pub fn format_vec32(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1270}
1271unsafe extern "C" {
1272 pub fn format_vec_uword(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1273}
1274unsafe extern "C" {
1275 pub fn format_ascii_bytes(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1276}
1277unsafe extern "C" {
1278 pub fn format_hex_bytes(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1279}
1280unsafe extern "C" {
1281 pub fn format_hex_bytes_no_wrap(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1282}
1283unsafe extern "C" {
1284 pub fn format_white_space(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1285}
1286unsafe extern "C" {
1287 pub fn format_f64(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1288}
1289unsafe extern "C" {
1290 pub fn format_time_interval(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1291}
1292unsafe extern "C" {
1293 pub fn format_duration(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1294}
1295unsafe extern "C" {
1296 pub fn format_address_family(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1297}
1298unsafe extern "C" {
1299 pub fn format_network_address(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1300}
1301unsafe extern "C" {
1302 pub fn format_network_protocol(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1303}
1304unsafe extern "C" {
1305 pub fn format_network_port(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1306}
1307unsafe extern "C" {
1308 pub fn format_sockaddr(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1309}
1310unsafe extern "C" {
1311 pub fn format_timeval(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1312}
1313unsafe extern "C" {
1314 pub fn format_time_float(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1315}
1316unsafe extern "C" {
1317 pub fn format_signal(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1318}
1319unsafe extern "C" {
1320 pub fn format_ucontext_pc(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1321}
1322#[repr(C)]
1323#[derive(Debug, Copy, Clone)]
1324pub struct _unformat_input_t {
1325 pub buffer: *mut u8_,
1326 pub index: uword,
1327 pub buffer_marks: *mut uword,
1328 pub fill_buffer:
1329 ::std::option::Option<unsafe extern "C" fn(i: *mut _unformat_input_t) -> uword>,
1330 pub free: ::std::option::Option<unsafe extern "C" fn(i: *mut _unformat_input_t)>,
1331 pub fill_buffer_arg: *mut ::std::os::raw::c_void,
1332}
1333impl Default for _unformat_input_t {
1334 fn default() -> Self {
1335 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1336 unsafe {
1337 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1338 s.assume_init()
1339 }
1340 }
1341}
1342pub type unformat_input_t = _unformat_input_t;
1343unsafe extern "C" {
1344 pub fn unformat_skip_white_space(input: *mut unformat_input_t) -> uword;
1345}
1346pub type unformat_function_t = ::std::option::Option<
1347 unsafe extern "C" fn(input: *mut unformat_input_t, args: *mut va_list) -> uword,
1348>;
1349unsafe extern "C" {
1350 pub fn unformat(i: *mut unformat_input_t, fmt: *const ::std::os::raw::c_char, ...) -> uword;
1351}
1352unsafe extern "C" {
1353 pub fn unformat_user(input: *mut unformat_input_t, func: unformat_function_t, ...) -> uword;
1354}
1355unsafe extern "C" {
1356 pub fn va_unformat(
1357 i: *mut unformat_input_t,
1358 fmt: *const ::std::os::raw::c_char,
1359 args: *mut va_list,
1360 ) -> uword;
1361}
1362unsafe extern "C" {
1363 pub fn unformat_init_command_line(
1364 input: *mut unformat_input_t,
1365 argv: *mut *mut ::std::os::raw::c_char,
1366 );
1367}
1368unsafe extern "C" {
1369 pub fn unformat_init_string(
1370 input: *mut unformat_input_t,
1371 string: *const ::std::os::raw::c_char,
1372 string_len: ::std::os::raw::c_int,
1373 );
1374}
1375unsafe extern "C" {
1376 pub fn unformat_init_vector(input: *mut unformat_input_t, vector_string: *mut u8_);
1377}
1378unsafe extern "C" {
1379 pub fn unformat_u8(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1380}
1381unsafe extern "C" {
1382 pub fn unformat_u16(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1383}
1384unsafe extern "C" {
1385 pub fn format_unformat_error(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1386}
1387unsafe extern "C" {
1388 pub fn format_unformat_input(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1389}
1390unsafe extern "C" {
1391 pub fn unformat_input(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1392}
1393unsafe extern "C" {
1394 pub fn unformat_line(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1395}
1396unsafe extern "C" {
1397 pub fn unformat_line_input(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1398}
1399unsafe extern "C" {
1400 pub fn unformat_token(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1401}
1402unsafe extern "C" {
1403 pub fn unformat_hex_string(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1404}
1405unsafe extern "C" {
1406 pub fn unformat_eof(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1407}
1408unsafe extern "C" {
1409 pub fn unformat_memory_size(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1410}
1411unsafe extern "C" {
1412 pub fn unformat_base10(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1413}
1414unsafe extern "C" {
1415 pub fn unformat_c_string_array(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1416}
1417unsafe extern "C" {
1418 pub fn unformat_single_quoted_string(input: *mut unformat_input_t, args: *mut va_list)
1419 -> uword;
1420}
1421unsafe extern "C" {
1422 pub fn unformat_double_quoted_string(input: *mut unformat_input_t, args: *mut va_list)
1423 -> uword;
1424}
1425unsafe extern "C" {
1426 pub fn format_base10(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1427}
1428unsafe extern "C" {
1429 pub fn format_memory_size(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1430}
1431unsafe extern "C" {
1432 pub fn unformat_log2_page_size(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1433}
1434unsafe extern "C" {
1435 pub fn format_log2_page_size(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1436}
1437unsafe extern "C" {
1438 pub fn format_c_identifier(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1439}
1440unsafe extern "C" {
1441 pub fn format_hexdump(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1442}
1443unsafe extern "C" {
1444 pub fn format_hexdump_u16(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1445}
1446unsafe extern "C" {
1447 pub fn format_hexdump_u32(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1448}
1449unsafe extern "C" {
1450 pub fn format_hexdump_u64(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1451}
1452unsafe extern "C" {
1453 pub fn format_uword_bitmap(s: *mut u8_, va: *mut va_list) -> *mut u8_;
1454}
1455unsafe extern "C" {
1456 pub fn unformat_init_clib_file(
1457 input: *mut unformat_input_t,
1458 file_descriptor: ::std::os::raw::c_int,
1459 );
1460}
1461unsafe extern "C" {
1462 pub fn unformat_init_file(
1463 input: *mut unformat_input_t,
1464 fmt: *mut ::std::os::raw::c_char,
1465 ...
1466 ) -> uword;
1467}
1468unsafe extern "C" {
1469 pub fn unformat_init_unix_env(
1470 input: *mut unformat_input_t,
1471 var: *mut ::std::os::raw::c_char,
1472 ) -> uword;
1473}
1474unsafe extern "C" {
1475 pub fn unformat_unix_gid(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1476}
1477unsafe extern "C" {
1478 pub fn unformat_data_size(input: *mut unformat_input_t, args: *mut va_list) -> uword;
1479}
1480unsafe extern "C" {
1481 pub fn test_format_main(input: *mut unformat_input_t) -> ::std::os::raw::c_int;
1482}
1483unsafe extern "C" {
1484 pub fn test_unformat_main(input: *mut unformat_input_t) -> ::std::os::raw::c_int;
1485}
1486unsafe extern "C" {
1487 pub fn test_vec_main(input: *mut unformat_input_t) -> ::std::os::raw::c_int;
1488}
1489unsafe extern "C" {
1490 pub fn format_c_string(
1491 s: *mut u8_,
1492 fmt: *const ::std::os::raw::c_char,
1493 ...
1494 ) -> *mut ::std::os::raw::c_char;
1495}
1496pub const vnet_error_t_VNET_ERR_UNSPECIFIED: vnet_error_t = -1;
1497pub const vnet_error_t_VNET_ERR_INVALID_SW_IF_INDEX: vnet_error_t = -2;
1498pub const vnet_error_t_VNET_ERR_NO_SUCH_FIB: vnet_error_t = -3;
1499pub const vnet_error_t_VNET_ERR_NO_SUCH_INNER_FIB: vnet_error_t = -4;
1500pub const vnet_error_t_VNET_ERR_NO_SUCH_LABEL: vnet_error_t = -5;
1501pub const vnet_error_t_VNET_ERR_NO_SUCH_ENTRY: vnet_error_t = -6;
1502pub const vnet_error_t_VNET_ERR_INVALID_VALUE: vnet_error_t = -7;
1503pub const vnet_error_t_VNET_ERR_INVALID_VALUE_2: vnet_error_t = -8;
1504pub const vnet_error_t_VNET_ERR_UNIMPLEMENTED: vnet_error_t = -9;
1505pub const vnet_error_t_VNET_ERR_INVALID_SW_IF_INDEX_2: vnet_error_t = -10;
1506pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_1: vnet_error_t = -11;
1507pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_2: vnet_error_t = -12;
1508pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_3: vnet_error_t = -13;
1509pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_4: vnet_error_t = -14;
1510pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_5: vnet_error_t = -15;
1511pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_6: vnet_error_t = -16;
1512pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_7: vnet_error_t = -17;
1513pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_8: vnet_error_t = -18;
1514pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_9: vnet_error_t = -19;
1515pub const vnet_error_t_VNET_ERR_SYSCALL_ERROR_10: vnet_error_t = -20;
1516pub const vnet_error_t_VNET_ERR_FEATURE_DISABLED: vnet_error_t = -30;
1517pub const vnet_error_t_VNET_ERR_INVALID_REGISTRATION: vnet_error_t = -31;
1518pub const vnet_error_t_VNET_ERR_NEXT_HOP_NOT_IN_FIB: vnet_error_t = -50;
1519pub const vnet_error_t_VNET_ERR_UNKNOWN_DESTINATION: vnet_error_t = -51;
1520pub const vnet_error_t_VNET_ERR_NO_PATHS_IN_ROUTE: vnet_error_t = -52;
1521pub const vnet_error_t_VNET_ERR_NEXT_HOP_NOT_FOUND_MP: vnet_error_t = -53;
1522pub const vnet_error_t_VNET_ERR_NO_MATCHING_INTERFACE: vnet_error_t = -54;
1523pub const vnet_error_t_VNET_ERR_INVALID_VLAN: vnet_error_t = -55;
1524pub const vnet_error_t_VNET_ERR_VLAN_ALREADY_EXISTS: vnet_error_t = -56;
1525pub const vnet_error_t_VNET_ERR_INVALID_SRC_ADDRESS: vnet_error_t = -57;
1526pub const vnet_error_t_VNET_ERR_INVALID_DST_ADDRESS: vnet_error_t = -58;
1527pub const vnet_error_t_VNET_ERR_ADDRESS_LENGTH_MISMATCH: vnet_error_t = -59;
1528pub const vnet_error_t_VNET_ERR_ADDRESS_NOT_FOUND_FOR_INTERFACE: vnet_error_t = -60;
1529pub const vnet_error_t_VNET_ERR_ADDRESS_NOT_DELETABLE: vnet_error_t = -61;
1530pub const vnet_error_t_VNET_ERR_IP6_NOT_ENABLED: vnet_error_t = -62;
1531pub const vnet_error_t_VNET_ERR_NO_SUCH_NODE: vnet_error_t = -63;
1532pub const vnet_error_t_VNET_ERR_NO_SUCH_NODE2: vnet_error_t = -64;
1533pub const vnet_error_t_VNET_ERR_NO_SUCH_TABLE: vnet_error_t = -65;
1534pub const vnet_error_t_VNET_ERR_NO_SUCH_TABLE2: vnet_error_t = -66;
1535pub const vnet_error_t_VNET_ERR_NO_SUCH_TABLE3: vnet_error_t = -67;
1536pub const vnet_error_t_VNET_ERR_SUBIF_ALREADY_EXISTS: vnet_error_t = -68;
1537pub const vnet_error_t_VNET_ERR_SUBIF_CREATE_FAILED: vnet_error_t = -69;
1538pub const vnet_error_t_VNET_ERR_INVALID_MEMORY_SIZE: vnet_error_t = -70;
1539pub const vnet_error_t_VNET_ERR_INVALID_INTERFACE: vnet_error_t = -71;
1540pub const vnet_error_t_VNET_ERR_INVALID_VLAN_TAG_COUNT: vnet_error_t = -72;
1541pub const vnet_error_t_VNET_ERR_INVALID_ARGUMENT: vnet_error_t = -73;
1542pub const vnet_error_t_VNET_ERR_UNEXPECTED_INTF_STATE: vnet_error_t = -74;
1543pub const vnet_error_t_VNET_ERR_TUNNEL_EXIST: vnet_error_t = -75;
1544pub const vnet_error_t_VNET_ERR_INVALID_DECAP_NEXT: vnet_error_t = -76;
1545pub const vnet_error_t_VNET_ERR_RESPONSE_NOT_READY: vnet_error_t = -77;
1546pub const vnet_error_t_VNET_ERR_NOT_CONNECTED: vnet_error_t = -78;
1547pub const vnet_error_t_VNET_ERR_IF_ALREADY_EXISTS: vnet_error_t = -79;
1548pub const vnet_error_t_VNET_ERR_BOND_SLAVE_NOT_ALLOWED: vnet_error_t = -80;
1549pub const vnet_error_t_VNET_ERR_VALUE_EXIST: vnet_error_t = -81;
1550pub const vnet_error_t_VNET_ERR_SAME_SRC_DST: vnet_error_t = -82;
1551pub const vnet_error_t_VNET_ERR_IP6_MULTICAST_ADDRESS_NOT_PRESENT: vnet_error_t = -83;
1552pub const vnet_error_t_VNET_ERR_SR_POLICY_NAME_NOT_PRESENT: vnet_error_t = -84;
1553pub const vnet_error_t_VNET_ERR_NOT_RUNNING_AS_ROOT: vnet_error_t = -85;
1554pub const vnet_error_t_VNET_ERR_ALREADY_CONNECTED: vnet_error_t = -86;
1555pub const vnet_error_t_VNET_ERR_UNSUPPORTED_JNI_VERSION: vnet_error_t = -87;
1556pub const vnet_error_t_VNET_ERR_IP_PREFIX_INVALID: vnet_error_t = -88;
1557pub const vnet_error_t_VNET_ERR_INVALID_WORKER: vnet_error_t = -89;
1558pub const vnet_error_t_VNET_ERR_LISP_DISABLED: vnet_error_t = -90;
1559pub const vnet_error_t_VNET_ERR_CLASSIFY_TABLE_NOT_FOUND: vnet_error_t = -91;
1560pub const vnet_error_t_VNET_ERR_INVALID_EID_TYPE: vnet_error_t = -92;
1561pub const vnet_error_t_VNET_ERR_CANNOT_CREATE_PCAP_FILE: vnet_error_t = -93;
1562pub const vnet_error_t_VNET_ERR_INCORRECT_ADJACENCY_TYPE: vnet_error_t = -94;
1563pub const vnet_error_t_VNET_ERR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY: vnet_error_t = -95;
1564pub const vnet_error_t_VNET_ERR_EXCEEDED_NUMBER_OF_PORTS_CAPACITY: vnet_error_t = -96;
1565pub const vnet_error_t_VNET_ERR_INVALID_ADDRESS_FAMILY: vnet_error_t = -97;
1566pub const vnet_error_t_VNET_ERR_INVALID_SUB_SW_IF_INDEX: vnet_error_t = -98;
1567pub const vnet_error_t_VNET_ERR_TABLE_TOO_BIG: vnet_error_t = -99;
1568pub const vnet_error_t_VNET_ERR_CANNOT_ENABLE_DISABLE_FEATURE: vnet_error_t = -100;
1569pub const vnet_error_t_VNET_ERR_BFD_EEXIST: vnet_error_t = -101;
1570pub const vnet_error_t_VNET_ERR_BFD_ENOENT: vnet_error_t = -102;
1571pub const vnet_error_t_VNET_ERR_BFD_EINUSE: vnet_error_t = -103;
1572pub const vnet_error_t_VNET_ERR_BFD_NOTSUPP: vnet_error_t = -104;
1573pub const vnet_error_t_VNET_ERR_ADDRESS_IN_USE: vnet_error_t = -105;
1574pub const vnet_error_t_VNET_ERR_ADDRESS_NOT_IN_USE: vnet_error_t = -106;
1575pub const vnet_error_t_VNET_ERR_QUEUE_FULL: vnet_error_t = -107;
1576pub const vnet_error_t_VNET_ERR_APP_UNSUPPORTED_CFG: vnet_error_t = -108;
1577pub const vnet_error_t_VNET_ERR_URI_FIFO_CREATE_FAILED: vnet_error_t = -109;
1578pub const vnet_error_t_VNET_ERR_LISP_RLOC_LOCAL: vnet_error_t = -110;
1579pub const vnet_error_t_VNET_ERR_BFD_EAGAIN: vnet_error_t = -111;
1580pub const vnet_error_t_VNET_ERR_INVALID_GPE_MODE: vnet_error_t = -112;
1581pub const vnet_error_t_VNET_ERR_LISP_GPE_ENTRIES_PRESENT: vnet_error_t = -113;
1582pub const vnet_error_t_VNET_ERR_ADDRESS_FOUND_FOR_INTERFACE: vnet_error_t = -114;
1583pub const vnet_error_t_VNET_ERR_SESSION_CONNECT: vnet_error_t = -115;
1584pub const vnet_error_t_VNET_ERR_ENTRY_ALREADY_EXISTS: vnet_error_t = -116;
1585pub const vnet_error_t_VNET_ERR_SVM_SEGMENT_CREATE_FAIL: vnet_error_t = -117;
1586pub const vnet_error_t_VNET_ERR_APPLICATION_NOT_ATTACHED: vnet_error_t = -118;
1587pub const vnet_error_t_VNET_ERR_BD_ALREADY_EXISTS: vnet_error_t = -119;
1588pub const vnet_error_t_VNET_ERR_BD_IN_USE: vnet_error_t = -120;
1589pub const vnet_error_t_VNET_ERR_BD_NOT_MODIFIABLE: vnet_error_t = -121;
1590pub const vnet_error_t_VNET_ERR_BD_ID_EXCEED_MAX: vnet_error_t = -122;
1591pub const vnet_error_t_VNET_ERR_SUBIF_DOESNT_EXIST: vnet_error_t = -123;
1592pub const vnet_error_t_VNET_ERR_L2_MACS_EVENT_CLINET_PRESENT: vnet_error_t = -124;
1593pub const vnet_error_t_VNET_ERR_INVALID_QUEUE: vnet_error_t = -125;
1594pub const vnet_error_t_VNET_ERR_UNSUPPORTED: vnet_error_t = -126;
1595pub const vnet_error_t_VNET_ERR_DUPLICATE_IF_ADDRESS: vnet_error_t = -127;
1596pub const vnet_error_t_VNET_ERR_APP_INVALID_NS: vnet_error_t = -128;
1597pub const vnet_error_t_VNET_ERR_APP_WRONG_NS_SECRET: vnet_error_t = -129;
1598pub const vnet_error_t_VNET_ERR_APP_CONNECT_SCOPE: vnet_error_t = -130;
1599pub const vnet_error_t_VNET_ERR_APP_ALREADY_ATTACHED: vnet_error_t = -131;
1600pub const vnet_error_t_VNET_ERR_SESSION_REDIRECT: vnet_error_t = -132;
1601pub const vnet_error_t_VNET_ERR_ILLEGAL_NAME: vnet_error_t = -133;
1602pub const vnet_error_t_VNET_ERR_NO_NAME_SERVERS: vnet_error_t = -134;
1603pub const vnet_error_t_VNET_ERR_NAME_SERVER_NOT_FOUND: vnet_error_t = -135;
1604pub const vnet_error_t_VNET_ERR_NAME_RESOLUTION_NOT_ENABLED: vnet_error_t = -136;
1605pub const vnet_error_t_VNET_ERR_NAME_SERVER_FORMAT_ERROR: vnet_error_t = -137;
1606pub const vnet_error_t_VNET_ERR_NAME_SERVER_NO_SUCH_NAME: vnet_error_t = -138;
1607pub const vnet_error_t_VNET_ERR_NAME_SERVER_NO_ADDRESSES: vnet_error_t = -139;
1608pub const vnet_error_t_VNET_ERR_NAME_SERVER_NEXT_SERVER: vnet_error_t = -140;
1609pub const vnet_error_t_VNET_ERR_APP_CONNECT_FILTERED: vnet_error_t = -141;
1610pub const vnet_error_t_VNET_ERR_ACL_IN_USE_INBOUND: vnet_error_t = -142;
1611pub const vnet_error_t_VNET_ERR_ACL_IN_USE_OUTBOUND: vnet_error_t = -143;
1612pub const vnet_error_t_VNET_ERR_INIT_FAILED: vnet_error_t = -144;
1613pub const vnet_error_t_VNET_ERR_NETLINK_ERROR: vnet_error_t = -145;
1614pub const vnet_error_t_VNET_ERR_BIER_BSL_UNSUP: vnet_error_t = -146;
1615pub const vnet_error_t_VNET_ERR_INSTANCE_IN_USE: vnet_error_t = -147;
1616pub const vnet_error_t_VNET_ERR_INVALID_SESSION_ID: vnet_error_t = -148;
1617pub const vnet_error_t_VNET_ERR_ACL_IN_USE_BY_LOOKUP_CONTEXT: vnet_error_t = -149;
1618pub const vnet_error_t_VNET_ERR_INVALID_VALUE_3: vnet_error_t = -150;
1619pub const vnet_error_t_VNET_ERR_NON_ETHERNET: vnet_error_t = -151;
1620pub const vnet_error_t_VNET_ERR_BD_ALREADY_HAS_BVI: vnet_error_t = -152;
1621pub const vnet_error_t_VNET_ERR_INVALID_PROTOCOL: vnet_error_t = -153;
1622pub const vnet_error_t_VNET_ERR_INVALID_ALGORITHM: vnet_error_t = -154;
1623pub const vnet_error_t_VNET_ERR_RSRC_IN_USE: vnet_error_t = -155;
1624pub const vnet_error_t_VNET_ERR_KEY_LENGTH: vnet_error_t = -156;
1625pub const vnet_error_t_VNET_ERR_FIB_PATH_UNSUPPORTED_NH_PROTO: vnet_error_t = -157;
1626pub const vnet_error_t_VNET_ERR_API_ENDIAN_FAILED: vnet_error_t = -159;
1627pub const vnet_error_t_VNET_ERR_NO_CHANGE: vnet_error_t = -160;
1628pub const vnet_error_t_VNET_ERR_MISSING_CERT_KEY: vnet_error_t = -161;
1629pub const vnet_error_t_VNET_ERR_LIMIT_EXCEEDED: vnet_error_t = -162;
1630pub const vnet_error_t_VNET_ERR_IKE_NO_PORT: vnet_error_t = -163;
1631pub const vnet_error_t_VNET_ERR_UDP_PORT_TAKEN: vnet_error_t = -164;
1632pub const vnet_error_t_VNET_ERR_EAGAIN: vnet_error_t = -165;
1633pub const vnet_error_t_VNET_ERR_INVALID_VALUE_4: vnet_error_t = -166;
1634pub const vnet_error_t_VNET_ERR_BUSY: vnet_error_t = -167;
1635pub const vnet_error_t_VNET_ERR_BUG: vnet_error_t = -168;
1636pub const vnet_error_t_VNET_ERR_FEATURE_ALREADY_DISABLED: vnet_error_t = -169;
1637pub const vnet_error_t_VNET_ERR_FEATURE_ALREADY_ENABLED: vnet_error_t = -170;
1638pub const vnet_error_t_VNET_ERR_INVALID_PREFIX_LENGTH: vnet_error_t = -171;
1639pub const vnet_error_t_VNET_N_ERROR: vnet_error_t = -170;
1640pub type vnet_error_t = ::std::os::raw::c_int;
1641unsafe extern "C" {
1642 pub fn vnet_error(
1643 code: vnet_error_t,
1644 fmt: *mut ::std::os::raw::c_char,
1645 ...
1646 ) -> *mut clib_error_t;
1647}
1648unsafe extern "C" {
1649 pub fn format_vnet_api_errno(s: *mut u8_, args: *mut va_list) -> *mut u8_;
1650}
1651pub const vlib_rx_or_tx_t_VLIB_RX: vlib_rx_or_tx_t = 0;
1652pub const vlib_rx_or_tx_t_VLIB_TX: vlib_rx_or_tx_t = 1;
1653pub const vlib_rx_or_tx_t_VLIB_N_RX_TX: vlib_rx_or_tx_t = 2;
1654pub type vlib_rx_or_tx_t = ::std::os::raw::c_uint;
1655pub use self::vlib_rx_or_tx_t as vlib_dir_t;
1656pub const vlib_read_or_write_t_VLIB_READ: vlib_read_or_write_t = 0;
1657pub const vlib_read_or_write_t_VLIB_WRITE: vlib_read_or_write_t = 1;
1658pub type vlib_read_or_write_t = ::std::os::raw::c_uint;
1659pub const vlib_up_or_down_t_VLIB_DOWN: vlib_up_or_down_t = 0;
1660pub const vlib_up_or_down_t_VLIB_UP: vlib_up_or_down_t = 1;
1661pub type vlib_up_or_down_t = ::std::os::raw::c_uint;
1662pub const vlib_enable_or_disable_t_VLIB_DISABLE: vlib_enable_or_disable_t = 0;
1663pub const vlib_enable_or_disable_t_VLIB_ENABLE: vlib_enable_or_disable_t = 1;
1664pub type vlib_enable_or_disable_t = ::std::os::raw::c_uint;
1665pub type vlib_log_class_t = u32_;
1666pub type clib_bitmap_t = uword;
1667#[repr(C)]
1668#[derive(Debug, Default, Copy, Clone)]
1669pub struct clib_pmalloc_chunk_t {
1670 pub start: u32_,
1671 pub prev: u32_,
1672 pub next: u32_,
1673 pub _bitfield_align_1: [u32; 0],
1674 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1675}
1676impl clib_pmalloc_chunk_t {
1677 #[inline]
1678 pub fn size(&self) -> u32_ {
1679 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) }
1680 }
1681 #[inline]
1682 pub fn set_size(&mut self, val: u32_) {
1683 unsafe {
1684 let val: u32 = ::std::mem::transmute(val);
1685 self._bitfield_1.set(0usize, 31u8, val as u64)
1686 }
1687 }
1688 #[inline]
1689 pub unsafe fn size_raw(this: *const Self) -> u32_ {
1690 unsafe {
1691 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1692 ::std::ptr::addr_of!((*this)._bitfield_1),
1693 0usize,
1694 31u8,
1695 ) as u32)
1696 }
1697 }
1698 #[inline]
1699 pub unsafe fn set_size_raw(this: *mut Self, val: u32_) {
1700 unsafe {
1701 let val: u32 = ::std::mem::transmute(val);
1702 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1703 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1704 0usize,
1705 31u8,
1706 val as u64,
1707 )
1708 }
1709 }
1710 #[inline]
1711 pub fn used(&self) -> u32_ {
1712 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
1713 }
1714 #[inline]
1715 pub fn set_used(&mut self, val: u32_) {
1716 unsafe {
1717 let val: u32 = ::std::mem::transmute(val);
1718 self._bitfield_1.set(31usize, 1u8, val as u64)
1719 }
1720 }
1721 #[inline]
1722 pub unsafe fn used_raw(this: *const Self) -> u32_ {
1723 unsafe {
1724 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1725 ::std::ptr::addr_of!((*this)._bitfield_1),
1726 31usize,
1727 1u8,
1728 ) as u32)
1729 }
1730 }
1731 #[inline]
1732 pub unsafe fn set_used_raw(this: *mut Self, val: u32_) {
1733 unsafe {
1734 let val: u32 = ::std::mem::transmute(val);
1735 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1736 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1737 31usize,
1738 1u8,
1739 val as u64,
1740 )
1741 }
1742 }
1743 #[inline]
1744 pub fn new_bitfield_1(size: u32_, used: u32_) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1745 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1746 __bindgen_bitfield_unit.set(0usize, 31u8, {
1747 let size: u32 = unsafe { ::std::mem::transmute(size) };
1748 size as u64
1749 });
1750 __bindgen_bitfield_unit.set(31usize, 1u8, {
1751 let used: u32 = unsafe { ::std::mem::transmute(used) };
1752 used as u64
1753 });
1754 __bindgen_bitfield_unit
1755 }
1756}
1757#[repr(C)]
1758#[derive(Debug, Copy, Clone)]
1759pub struct clib_pmalloc_page_t {
1760 pub index: u32_,
1761 pub arena_index: u32_,
1762 pub chunks: *mut clib_pmalloc_chunk_t,
1763 pub first_chunk_index: u32_,
1764 pub n_free_chunks: u32_,
1765 pub n_free_blocks: u32_,
1766}
1767impl Default for clib_pmalloc_page_t {
1768 fn default() -> Self {
1769 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1770 unsafe {
1771 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1772 s.assume_init()
1773 }
1774 }
1775}
1776#[repr(C)]
1777#[derive(Debug, Copy, Clone)]
1778pub struct clib_pmalloc_arena_t {
1779 pub index: u32_,
1780 pub flags: u32_,
1781 pub fd: ::std::os::raw::c_int,
1782 pub numa_node: u32_,
1783 pub first_page_index: u32_,
1784 pub log2_subpage_sz: u32_,
1785 pub subpages_per_page: u32_,
1786 pub n_pages: u32_,
1787 pub name: *mut u8_,
1788 pub page_indices: *mut u32_,
1789}
1790impl Default for clib_pmalloc_arena_t {
1791 fn default() -> Self {
1792 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1793 unsafe {
1794 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1795 s.assume_init()
1796 }
1797 }
1798}
1799#[repr(C)]
1800#[derive(Debug, Copy, Clone)]
1801pub struct clib_pmalloc_main_t {
1802 pub flags: u32_,
1803 pub base: *mut u8_,
1804 pub def_log2_page_sz: clib_mem_page_sz_t,
1805 pub max_pages: u32_,
1806 pub pages: *mut clib_pmalloc_page_t,
1807 pub chunk_index_by_va: *mut uword,
1808 pub arenas: *mut clib_pmalloc_arena_t,
1809 pub default_arena_for_numa_node: *mut u32_,
1810 pub lookup_table: *mut uword,
1811 pub lookup_log2_page_sz: u32_,
1812 pub error: *mut clib_error_t,
1813}
1814impl Default for clib_pmalloc_main_t {
1815 fn default() -> Self {
1816 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1817 unsafe {
1818 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1819 s.assume_init()
1820 }
1821 }
1822}
1823#[repr(C)]
1824#[derive(Debug, Copy, Clone)]
1825pub struct vlib_physmem_map_t {
1826 pub index: ::std::os::raw::c_int,
1827 pub fd: ::std::os::raw::c_int,
1828 pub base: *mut ::std::os::raw::c_void,
1829 pub n_pages: u32_,
1830 pub page_table: *mut uword,
1831 pub log2_page_size: u32_,
1832 pub numa_node: u32_,
1833}
1834impl Default for vlib_physmem_map_t {
1835 fn default() -> Self {
1836 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1837 unsafe {
1838 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1839 s.assume_init()
1840 }
1841 }
1842}
1843#[repr(C)]
1844#[derive(Debug, Copy, Clone)]
1845pub struct vlib_physmem_main_t {
1846 pub flags: u32_,
1847 pub base_addr: uword,
1848 pub max_size: uword,
1849 pub maps: *mut vlib_physmem_map_t,
1850 pub pmalloc_main: *mut clib_pmalloc_main_t,
1851}
1852impl Default for vlib_physmem_main_t {
1853 fn default() -> Self {
1854 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1855 unsafe {
1856 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1857 s.assume_init()
1858 }
1859 }
1860}
1861#[repr(C)]
1862#[derive(Debug, Default, Copy, Clone)]
1863pub struct clib_longjmp_t {
1864 pub regs: [uword; 8usize],
1865}
1866pub type vlib_error_t = u16_;
1867pub const vl_counter_severity_e_VL_COUNTER_SEVERITY_ERROR: vl_counter_severity_e = 0;
1868pub const vl_counter_severity_e_VL_COUNTER_SEVERITY_WARN: vl_counter_severity_e = 1;
1869pub const vl_counter_severity_e_VL_COUNTER_SEVERITY_INFO: vl_counter_severity_e = 2;
1870pub type vl_counter_severity_e = ::std::os::raw::c_uint;
1871#[repr(C)]
1872#[derive(Debug, Copy, Clone)]
1873pub struct vlib_error_desc_t {
1874 pub name: *mut ::std::os::raw::c_char,
1875 pub desc: *mut ::std::os::raw::c_char,
1876 pub severity: vl_counter_severity_e,
1877 pub stats_entry_index: u32_,
1878}
1879impl Default for vlib_error_desc_t {
1880 fn default() -> Self {
1881 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1882 unsafe {
1883 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1884 s.assume_init()
1885 }
1886 }
1887}
1888#[repr(C)]
1889#[derive(Debug, Copy, Clone)]
1890pub struct vlib_error_main_t {
1891 pub counters: *mut u64_,
1892 pub counters_last_clear: *mut u64_,
1893 pub counters_heap: *mut vlib_error_desc_t,
1894 pub stats_err_entry_index: u32_,
1895}
1896impl Default for vlib_error_main_t {
1897 fn default() -> Self {
1898 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1899 unsafe {
1900 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1901 s.assume_init()
1902 }
1903 }
1904}
1905pub const VLIB_BUFFER_IS_TRACED: _bindgen_ty_30 = 1;
1906pub const VLIB_BUFFER_NEXT_PRESENT: _bindgen_ty_30 = 2;
1907pub const VLIB_BUFFER_TOTAL_LENGTH_VALID: _bindgen_ty_30 = 4;
1908pub const VLIB_BUFFER_EXT_HDR_VALID: _bindgen_ty_30 = 8;
1909pub type _bindgen_ty_30 = ::std::os::raw::c_uint;
1910pub const VLIB_BUFFER_LOG2_IS_TRACED: _bindgen_ty_31 = 0;
1911pub const VLIB_BUFFER_LOG2_NEXT_PRESENT: _bindgen_ty_31 = 1;
1912pub const VLIB_BUFFER_LOG2_TOTAL_LENGTH_VALID: _bindgen_ty_31 = 2;
1913pub const VLIB_BUFFER_LOG2_EXT_HDR_VALID: _bindgen_ty_31 = 3;
1914pub type _bindgen_ty_31 = ::std::os::raw::c_uint;
1915#[repr(C)]
1916#[repr(align(64))]
1917pub struct vlib_buffer_template_t {
1918 pub align_mark: __IncompleteArrayField<u8_>,
1919 pub current_data: i16_,
1920 pub current_length: u16_,
1921 pub flags: u32_,
1922 pub flow_id: u32_,
1923 pub ref_count: u8_,
1924 pub buffer_pool_index: u8_,
1925 pub error: vlib_error_t,
1926 pub next_buffer: u32_,
1927 pub __bindgen_anon_1: vlib_buffer_template_t__bindgen_ty_1,
1928 pub opaque: [u32_; 10usize],
1929}
1930#[repr(C)]
1931#[derive(Copy, Clone)]
1932pub union vlib_buffer_template_t__bindgen_ty_1 {
1933 pub current_config_index: u32_,
1934 pub punt_reason: u32_,
1935}
1936impl Default for vlib_buffer_template_t__bindgen_ty_1 {
1937 fn default() -> Self {
1938 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1939 unsafe {
1940 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1941 s.assume_init()
1942 }
1943 }
1944}
1945impl Default for vlib_buffer_template_t {
1946 fn default() -> Self {
1947 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1948 unsafe {
1949 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1950 s.assume_init()
1951 }
1952 }
1953}
1954#[repr(C)]
1955#[repr(align(64))]
1956pub struct vlib_buffer_t__bindgen_ty_1<FAM: ?Sized = [u8_; 0]> {
1957 pub __bindgen_anon_1: vlib_buffer_t__bindgen_ty_1__bindgen_ty_1,
1958 pub second_half: __IncompleteArrayField<u8_>,
1959 pub trace_handle: u32_,
1960 pub total_length_not_including_first_buffer: u32_,
1961 pub opaque2: [u32_; 14usize],
1962 pub headroom: __IncompleteArrayField<u8_>,
1963 pub pre_data: [u8_; 128usize],
1964 pub data: FAM,
1965}
1966#[repr(C)]
1967#[repr(align(64))]
1968pub struct vlib_buffer_t__bindgen_ty_1__bindgen_ty_1 {
1969 pub __bindgen_anon_1:
1970 __BindgenUnionField<vlib_buffer_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>,
1971 pub template: __BindgenUnionField<vlib_buffer_template_t>,
1972 pub bindgen_union_field: [u8; 64usize],
1973}
1974#[repr(C)]
1975#[derive(Copy, Clone)]
1976pub struct vlib_buffer_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
1977 pub current_data: i16_,
1978 pub current_length: u16_,
1979 pub flags: u32_,
1980 pub flow_id: u32_,
1981 pub ref_count: u8_,
1982 pub buffer_pool_index: u8_,
1983 pub error: vlib_error_t,
1984 pub next_buffer: u32_,
1985 pub __bindgen_anon_1: vlib_buffer_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
1986 pub opaque: [u32_; 10usize],
1987}
1988#[repr(C)]
1989#[derive(Copy, Clone)]
1990pub union vlib_buffer_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
1991 pub current_config_index: u32_,
1992 pub punt_reason: u32_,
1993}
1994impl Default for vlib_buffer_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
1995 fn default() -> Self {
1996 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1997 unsafe {
1998 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1999 s.assume_init()
2000 }
2001 }
2002}
2003impl Default for vlib_buffer_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2004 fn default() -> Self {
2005 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2006 unsafe {
2007 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2008 s.assume_init()
2009 }
2010 }
2011}
2012impl Default for vlib_buffer_t__bindgen_ty_1__bindgen_ty_1 {
2013 fn default() -> Self {
2014 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2015 unsafe {
2016 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2017 s.assume_init()
2018 }
2019 }
2020}
2021impl vlib_buffer_t__bindgen_ty_1<[u8_]> {}
2022impl vlib_buffer_t__bindgen_ty_1<[u8_; 0]> {}
2023impl Default for vlib_buffer_t__bindgen_ty_1<[u8_; 0]> {
2024 fn default() -> Self {
2025 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2026 unsafe {
2027 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2028 s.assume_init()
2029 }
2030 }
2031}
2032#[repr(C)]
2033#[repr(align(64))]
2034#[derive(Debug)]
2035pub struct vlib_buffer_pool_thread_t {
2036 pub cacheline0: __IncompleteArrayField<u8_>,
2037 pub cached_buffers: [u32_; 512usize],
2038 pub n_cached: u32_,
2039}
2040impl Default for vlib_buffer_pool_thread_t {
2041 fn default() -> Self {
2042 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2043 unsafe {
2044 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2045 s.assume_init()
2046 }
2047 }
2048}
2049#[repr(C)]
2050#[repr(align(64))]
2051pub struct vlib_buffer_pool_t {
2052 pub cacheline0: __IncompleteArrayField<u8_>,
2053 pub start: uword,
2054 pub size: uword,
2055 pub log2_page_size: u8_,
2056 pub index: u8_,
2057 pub numa_node: u8_,
2058 pub physmem_map_index: u32_,
2059 pub data_size: u32_,
2060 pub alloc_size: u32_,
2061 pub n_buffers: u32_,
2062 pub n_avail: u32_,
2063 pub buffers: *mut u32_,
2064 pub name: *mut u8_,
2065 pub lock: clib_spinlock_t,
2066 pub threads: *mut vlib_buffer_pool_thread_t,
2067 pub __bindgen_padding_0: [u64; 7usize],
2068 pub buffer_template: vlib_buffer_template_t,
2069}
2070impl Default for vlib_buffer_pool_t {
2071 fn default() -> Self {
2072 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2073 unsafe {
2074 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2075 s.assume_init()
2076 }
2077 }
2078}
2079pub type vlib_buffer_alloc_free_callback_t = ::std::option::Option<
2080 unsafe extern "C" fn(
2081 vm: *mut vlib_main_t,
2082 buffer_pool_index: u8_,
2083 buffers: *mut u32_,
2084 n_buffers: u32_,
2085 ) -> u32_,
2086>;
2087#[repr(C)]
2088#[repr(align(64))]
2089#[derive(Debug)]
2090pub struct vlib_buffer_main_t {
2091 pub cacheline0: __IncompleteArrayField<u8_>,
2092 pub buffer_mem_start: uword,
2093 pub buffer_mem_size: uword,
2094 pub buffer_pools: *mut vlib_buffer_pool_t,
2095 pub alloc_callback_fn: vlib_buffer_alloc_free_callback_t,
2096 pub free_callback_fn: vlib_buffer_alloc_free_callback_t,
2097 pub default_buffer_pool_index_for_numa: [u8_; 32usize],
2098 pub default_buffers_per_numa: u32_,
2099 pub buffers_per_numa: [u32_; 32usize],
2100 pub ext_hdr_size: u16_,
2101 pub default_data_size: u32_,
2102 pub log2_page_size: clib_mem_page_sz_t,
2103 pub buffer_known_hash: *mut uword,
2104 pub buffer_known_hash_lockp: clib_spinlock_t,
2105 pub log_default: vlib_log_class_t,
2106}
2107impl Default for vlib_buffer_main_t {
2108 fn default() -> Self {
2109 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2110 unsafe {
2111 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2112 s.assume_init()
2113 }
2114 }
2115}
2116unsafe extern "C" {
2117 pub fn vlib_buffer_main_init(vm: *mut vlib_main_t) -> *mut clib_error_t;
2118}
2119unsafe extern "C" {
2120 pub fn format_vlib_buffer_pool_all(s: *mut u8_, args: *mut va_list) -> *mut u8_;
2121}
2122unsafe extern "C" {
2123 pub fn vlib_buffer_set_alloc_free_callback(
2124 vm: *mut vlib_main_t,
2125 alloc_callback_fn: vlib_buffer_alloc_free_callback_t,
2126 free_callback_fn: vlib_buffer_alloc_free_callback_t,
2127 ) -> ::std::os::raw::c_int;
2128}
2129unsafe extern "C" {
2130 pub static mut __vlib_buffer_external_hdr_size: u16_;
2131}
2132#[repr(C)]
2133#[derive(Debug, Copy, Clone)]
2134pub struct vlib_cli_parse_position_t {
2135 pub min_char: u32_,
2136 pub bitmaps: *mut *mut uword,
2137}
2138impl Default for vlib_cli_parse_position_t {
2139 fn default() -> Self {
2140 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2141 unsafe {
2142 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2143 s.assume_init()
2144 }
2145 }
2146}
2147#[repr(C)]
2148#[derive(Debug, Copy, Clone)]
2149pub struct vlib_cli_sub_command_t {
2150 pub name: *mut u8_,
2151 pub index: u32_,
2152}
2153impl Default for vlib_cli_sub_command_t {
2154 fn default() -> Self {
2155 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2156 unsafe {
2157 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2158 s.assume_init()
2159 }
2160 }
2161}
2162#[repr(C)]
2163#[derive(Debug, Copy, Clone)]
2164pub struct vlib_cli_sub_rule_t {
2165 pub name: *mut u8_,
2166 pub rule_index: u32_,
2167 pub command_index: u32_,
2168}
2169impl Default for vlib_cli_sub_rule_t {
2170 fn default() -> Self {
2171 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2172 unsafe {
2173 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2174 s.assume_init()
2175 }
2176 }
2177}
2178#[repr(C)]
2179#[derive(Debug, Copy, Clone)]
2180pub struct vlib_cli_parse_rule_t {
2181 pub name: *mut ::std::os::raw::c_char,
2182 pub short_help: *mut ::std::os::raw::c_char,
2183 pub long_help: *mut ::std::os::raw::c_char,
2184 pub data_size: uword,
2185 pub unformat_function: unformat_function_t,
2186 pub unformat_function_arg: [uword; 2usize],
2187}
2188impl Default for vlib_cli_parse_rule_t {
2189 fn default() -> Self {
2190 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2191 unsafe {
2192 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2193 s.assume_init()
2194 }
2195 }
2196}
2197pub type vlib_cli_command_function_t = ::std::option::Option<
2198 unsafe extern "C" fn(
2199 vm: *mut vlib_main_t,
2200 input: *mut unformat_input_t,
2201 cmd: *mut vlib_cli_command_t,
2202 ) -> *mut clib_error_t,
2203>;
2204#[repr(C)]
2205#[derive(Debug, Copy, Clone)]
2206pub struct vlib_cli_command_t {
2207 pub path: *mut ::std::os::raw::c_char,
2208 pub short_help: *mut ::std::os::raw::c_char,
2209 pub long_help: *mut ::std::os::raw::c_char,
2210 pub function: vlib_cli_command_function_t,
2211 pub function_arg: uword,
2212 pub is_mp_safe: uword,
2213 pub sub_commands: *mut vlib_cli_sub_command_t,
2214 pub sub_command_index_by_name: *mut uword,
2215 pub sub_command_positions: *mut vlib_cli_parse_position_t,
2216 pub sub_rule_index_by_name: *mut uword,
2217 pub sub_rules: *mut vlib_cli_sub_rule_t,
2218 pub next_cli_command: *mut vlib_cli_command_t,
2219 pub hit_counter: u32_,
2220}
2221impl Default for vlib_cli_command_t {
2222 fn default() -> Self {
2223 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2224 unsafe {
2225 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2226 s.assume_init()
2227 }
2228 }
2229}
2230pub type vlib_cli_output_function_t =
2231 ::std::option::Option<unsafe extern "C" fn(arg: uword, buffer: *mut u8_, buffer_bytes: uword)>;
2232#[repr(C)]
2233#[derive(Debug, Copy, Clone)]
2234pub struct vlib_cli_main_t {
2235 pub commands: *mut vlib_cli_command_t,
2236 pub command_index_by_path: *mut uword,
2237 pub cli_command_registrations: *mut vlib_cli_command_t,
2238 pub sort_vector: *mut u32_,
2239 pub perf_counter_cbs: *mut ::std::option::Option<
2240 unsafe extern "C" fn(
2241 arg1: *mut vlib_cli_main_t,
2242 id: u32_,
2243 before_or_after: ::std::os::raw::c_int,
2244 ),
2245 >,
2246 pub perf_counter_cbs_tmp: *mut ::std::option::Option<
2247 unsafe extern "C" fn(
2248 arg1: *mut vlib_cli_main_t,
2249 id: u32_,
2250 before_or_after: ::std::os::raw::c_int,
2251 ),
2252 >,
2253 pub log: vlib_log_class_t,
2254}
2255impl Default for vlib_cli_main_t {
2256 fn default() -> Self {
2257 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2258 unsafe {
2259 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2260 s.assume_init()
2261 }
2262 }
2263}
2264unsafe extern "C" {
2265 pub fn vlib_cli_output(vm: *mut vlib_main_t, fmt: *mut ::std::os::raw::c_char, ...);
2266}
2267unsafe extern "C" {
2268 pub fn vlib_cli_input(
2269 vm: *mut vlib_main_t,
2270 input: *mut unformat_input_t,
2271 function: vlib_cli_output_function_t,
2272 function_arg: uword,
2273 ) -> ::std::os::raw::c_int;
2274}
2275unsafe extern "C" {
2276 pub fn vlib_cli_register(vm: *mut vlib_main_t, c: *mut vlib_cli_command_t)
2277 -> *mut clib_error_t;
2278}
2279unsafe extern "C" {
2280 pub fn vlib_cli_register_parse_rule(
2281 vm: *mut vlib_main_t,
2282 c: *mut vlib_cli_parse_rule_t,
2283 ) -> *mut clib_error_t;
2284}
2285unsafe extern "C" {
2286 pub fn unformat_vlib_cli_line(input: *mut unformat_input_t, args: *mut va_list) -> uword;
2287}
2288unsafe extern "C" {
2289 pub fn unformat_vlib_cli_sub_input(i: *mut unformat_input_t, args: *mut va_list) -> uword;
2290}
2291unsafe extern "C" {
2292 pub fn vlib_cli_get_possible_completions(input_str: *mut u8_) -> *mut *mut u8_;
2293}
2294pub type counter_t = u64;
2295#[repr(C)]
2296#[derive(Debug, Default, Copy, Clone)]
2297pub struct vlib_counter_t {
2298 pub packets: counter_t,
2299 pub bytes: counter_t,
2300}
2301#[repr(C)]
2302#[derive(Debug, Copy, Clone)]
2303pub struct vlib_simple_counter_main_t {
2304 pub counters: *mut *mut counter_t,
2305 pub name: *mut ::std::os::raw::c_char,
2306 pub stat_segment_name: *mut ::std::os::raw::c_char,
2307 pub stats_entry_index: u32_,
2308}
2309impl Default for vlib_simple_counter_main_t {
2310 fn default() -> Self {
2311 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2312 unsafe {
2313 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2314 s.assume_init()
2315 }
2316 }
2317}
2318unsafe extern "C" {
2319 pub fn vlib_simple_counter_n_counters(cm: *const vlib_simple_counter_main_t) -> u32_;
2320}
2321#[repr(C)]
2322#[derive(Debug, Copy, Clone)]
2323pub struct vlib_combined_counter_main_t {
2324 pub counters: *mut *mut vlib_counter_t,
2325 pub name: *mut ::std::os::raw::c_char,
2326 pub stat_segment_name: *mut ::std::os::raw::c_char,
2327 pub stats_entry_index: u32_,
2328}
2329impl Default for vlib_combined_counter_main_t {
2330 fn default() -> Self {
2331 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2332 unsafe {
2333 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2334 s.assume_init()
2335 }
2336 }
2337}
2338unsafe extern "C" {
2339 pub fn vlib_combined_counter_n_counters(cm: *const vlib_combined_counter_main_t) -> u32_;
2340}
2341unsafe extern "C" {
2342 pub fn vlib_clear_simple_counters(cm: *mut vlib_simple_counter_main_t);
2343}
2344unsafe extern "C" {
2345 pub fn vlib_clear_combined_counters(cm: *mut vlib_combined_counter_main_t);
2346}
2347unsafe extern "C" {
2348 pub fn vlib_validate_simple_counter(cm: *mut vlib_simple_counter_main_t, index: u32_);
2349}
2350unsafe extern "C" {
2351 pub fn vlib_free_simple_counter(cm: *mut vlib_simple_counter_main_t);
2352}
2353unsafe extern "C" {
2354 pub fn vlib_validate_combined_counter(cm: *mut vlib_combined_counter_main_t, index: u32_);
2355}
2356unsafe extern "C" {
2357 pub fn vlib_validate_combined_counter_will_expand(
2358 cm: *mut vlib_combined_counter_main_t,
2359 index: u32_,
2360 ) -> ::std::os::raw::c_int;
2361}
2362unsafe extern "C" {
2363 pub fn vlib_free_combined_counter(cm: *mut vlib_combined_counter_main_t);
2364}
2365pub type vlib_init_function_t =
2366 ::std::option::Option<unsafe extern "C" fn(vm: *mut vlib_main_t) -> *mut clib_error_t>;
2367#[repr(C)]
2368#[derive(Debug, Copy, Clone)]
2369pub struct _vlib_init_function_list_elt {
2370 pub next_init_function: *mut _vlib_init_function_list_elt,
2371 pub f: vlib_init_function_t,
2372 pub name: *mut ::std::os::raw::c_char,
2373 pub runs_before: *mut *mut ::std::os::raw::c_char,
2374 pub runs_after: *mut *mut ::std::os::raw::c_char,
2375 pub init_order: *mut *mut ::std::os::raw::c_char,
2376}
2377impl Default for _vlib_init_function_list_elt {
2378 fn default() -> Self {
2379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2380 unsafe {
2381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2382 s.assume_init()
2383 }
2384 }
2385}
2386pub type _vlib_init_function_list_elt_t = _vlib_init_function_list_elt;
2387pub type vlib_config_function_t = ::std::option::Option<
2388 unsafe extern "C" fn(vm: *mut vlib_main_t, input: *mut unformat_input_t) -> *mut clib_error_t,
2389>;
2390#[repr(C)]
2391#[derive(Debug, Copy, Clone)]
2392pub struct vlib_config_function_runtime_t {
2393 pub function: vlib_config_function_t,
2394 pub input: unformat_input_t,
2395 pub next_registration: *mut vlib_config_function_runtime_t,
2396 pub is_early: u8_,
2397 pub name: [::std::os::raw::c_char; 32usize],
2398}
2399impl Default for vlib_config_function_runtime_t {
2400 fn default() -> Self {
2401 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2402 unsafe {
2403 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2404 s.assume_init()
2405 }
2406 }
2407}
2408unsafe extern "C" {
2409 pub fn vlib_call_all_init_functions(vm: *mut vlib_main_t) -> *mut clib_error_t;
2410}
2411unsafe extern "C" {
2412 pub fn vlib_call_all_config_functions(
2413 vm: *mut vlib_main_t,
2414 input: *mut unformat_input_t,
2415 is_early: ::std::os::raw::c_int,
2416 ) -> *mut clib_error_t;
2417}
2418unsafe extern "C" {
2419 pub fn vlib_call_all_main_loop_enter_functions(vm: *mut vlib_main_t) -> *mut clib_error_t;
2420}
2421unsafe extern "C" {
2422 pub fn vlib_call_all_main_loop_exit_functions(vm: *mut vlib_main_t) -> *mut clib_error_t;
2423}
2424unsafe extern "C" {
2425 pub fn vlib_call_init_exit_functions(
2426 vm: *mut vlib_main_t,
2427 headp: *mut *mut _vlib_init_function_list_elt_t,
2428 call_once: ::std::os::raw::c_int,
2429 is_global: ::std::os::raw::c_int,
2430 ) -> *mut clib_error_t;
2431}
2432unsafe extern "C" {
2433 pub fn vlib_call_init_exit_functions_no_sort(
2434 vm: *mut vlib_main_t,
2435 headp: *mut *mut _vlib_init_function_list_elt_t,
2436 call_once: ::std::os::raw::c_int,
2437 is_global: ::std::os::raw::c_int,
2438 ) -> *mut clib_error_t;
2439}
2440unsafe extern "C" {
2441 pub fn vlib_sort_init_exit_functions(
2442 arg1: *mut *mut _vlib_init_function_list_elt_t,
2443 ) -> *mut clib_error_t;
2444}
2445unsafe extern "C" {
2446 pub fn vlib_node_cli_reference();
2447}
2448unsafe extern "C" {
2449 pub fn vlib_trace_cli_reference();
2450}
2451pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE: clib_march_variant_type_t = 0;
2452pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_scalar: clib_march_variant_type_t = 1;
2453pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_hsw: clib_march_variant_type_t = 2;
2454pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_trm: clib_march_variant_type_t = 3;
2455pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_skx: clib_march_variant_type_t = 4;
2456pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_icl: clib_march_variant_type_t = 5;
2457pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_adl: clib_march_variant_type_t = 6;
2458pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_spr: clib_march_variant_type_t = 7;
2459pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_znver3: clib_march_variant_type_t = 8;
2460pub const clib_march_variant_type_t_CLIB_MARCH_VARIANT_TYPE_znver4: clib_march_variant_type_t = 9;
2461pub const clib_march_variant_type_t_CLIB_MARCH_TYPE_N_VARIANTS: clib_march_variant_type_t = 10;
2462pub type clib_march_variant_type_t = ::std::os::raw::c_uint;
2463#[repr(C)]
2464#[derive(Debug, Default)]
2465pub struct vlib_trace_header_t<FAM: ?Sized = [u8_; 0]> {
2466 pub time: u64_,
2467 pub node_index: u32_,
2468 pub n_data: u32_,
2469 pub data: FAM,
2470}
2471impl vlib_trace_header_t<[u8_]> {}
2472impl vlib_trace_header_t<[u8_; 0]> {}
2473#[repr(C)]
2474#[derive(Debug, Default, Copy, Clone)]
2475pub struct vlib_trace_node_t {
2476 pub count: u32_,
2477 pub limit: u32_,
2478}
2479pub type vlib_trace_buffer_callback_t = ::std::option::Option<
2480 unsafe extern "C" fn(arg1: *mut vlib_main_t, arg2: *mut vlib_trace_main_t),
2481>;
2482pub type vlib_add_trace_callback_t = ::std::option::Option<
2483 unsafe extern "C" fn(
2484 arg1: *mut vlib_main_t,
2485 r: *mut vlib_node_runtime_t,
2486 b: *mut vlib_buffer_t,
2487 n_data_bytes: u32_,
2488 ) -> *mut ::std::os::raw::c_void,
2489>;
2490pub type vlib_is_packet_traced_fn_t = ::std::option::Option<
2491 unsafe extern "C" fn(
2492 b: *mut vlib_buffer_t,
2493 classify_table_index: u32_,
2494 func: ::std::os::raw::c_int,
2495 ) -> ::std::os::raw::c_int,
2496>;
2497pub type vlib_node_function_t = ::std::option::Option<
2498 unsafe extern "C" fn(
2499 vm: *mut vlib_main_t,
2500 node: *mut vlib_node_runtime_t,
2501 frame: *mut vlib_frame_t,
2502 ) -> uword,
2503>;
2504pub const vlib_node_proto_hint_t_VLIB_NODE_PROTO_HINT_NONE: vlib_node_proto_hint_t = 0;
2505pub const vlib_node_proto_hint_t_VLIB_NODE_PROTO_HINT_ETHERNET: vlib_node_proto_hint_t = 1;
2506pub const vlib_node_proto_hint_t_VLIB_NODE_PROTO_HINT_IP4: vlib_node_proto_hint_t = 2;
2507pub const vlib_node_proto_hint_t_VLIB_NODE_PROTO_HINT_IP6: vlib_node_proto_hint_t = 3;
2508pub const vlib_node_proto_hint_t_VLIB_NODE_PROTO_HINT_TCP: vlib_node_proto_hint_t = 4;
2509pub const vlib_node_proto_hint_t_VLIB_NODE_PROTO_HINT_UDP: vlib_node_proto_hint_t = 5;
2510pub const vlib_node_proto_hint_t_VLIB_NODE_N_PROTO_HINTS: vlib_node_proto_hint_t = 6;
2511pub type vlib_node_proto_hint_t = ::std::os::raw::c_uint;
2512pub const vlib_node_type_t_VLIB_NODE_TYPE_INTERNAL: vlib_node_type_t = 0;
2513pub const vlib_node_type_t_VLIB_NODE_TYPE_INPUT: vlib_node_type_t = 1;
2514pub const vlib_node_type_t_VLIB_NODE_TYPE_PRE_INPUT: vlib_node_type_t = 2;
2515pub const vlib_node_type_t_VLIB_NODE_TYPE_PROCESS: vlib_node_type_t = 3;
2516pub const vlib_node_type_t_VLIB_NODE_TYPE_SCHED: vlib_node_type_t = 4;
2517pub const vlib_node_type_t_VLIB_N_NODE_TYPE: vlib_node_type_t = 5;
2518pub type vlib_node_type_t = ::std::os::raw::c_uint;
2519#[repr(C)]
2520#[derive(Debug, Default, Copy, Clone)]
2521pub struct vlib_node_type_atts_t {
2522 pub _bitfield_align_1: [u8; 0],
2523 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2524}
2525impl vlib_node_type_atts_t {
2526 #[inline]
2527 pub fn can_be_disabled(&self) -> u8_ {
2528 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2529 }
2530 #[inline]
2531 pub fn set_can_be_disabled(&mut self, val: u8_) {
2532 unsafe {
2533 let val: u8 = ::std::mem::transmute(val);
2534 self._bitfield_1.set(0usize, 1u8, val as u64)
2535 }
2536 }
2537 #[inline]
2538 pub unsafe fn can_be_disabled_raw(this: *const Self) -> u8_ {
2539 unsafe {
2540 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2541 ::std::ptr::addr_of!((*this)._bitfield_1),
2542 0usize,
2543 1u8,
2544 ) as u8)
2545 }
2546 }
2547 #[inline]
2548 pub unsafe fn set_can_be_disabled_raw(this: *mut Self, val: u8_) {
2549 unsafe {
2550 let val: u8 = ::std::mem::transmute(val);
2551 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2552 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2553 0usize,
2554 1u8,
2555 val as u64,
2556 )
2557 }
2558 }
2559 #[inline]
2560 pub fn may_receive_interrupts(&self) -> u8_ {
2561 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2562 }
2563 #[inline]
2564 pub fn set_may_receive_interrupts(&mut self, val: u8_) {
2565 unsafe {
2566 let val: u8 = ::std::mem::transmute(val);
2567 self._bitfield_1.set(1usize, 1u8, val as u64)
2568 }
2569 }
2570 #[inline]
2571 pub unsafe fn may_receive_interrupts_raw(this: *const Self) -> u8_ {
2572 unsafe {
2573 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2574 ::std::ptr::addr_of!((*this)._bitfield_1),
2575 1usize,
2576 1u8,
2577 ) as u8)
2578 }
2579 }
2580 #[inline]
2581 pub unsafe fn set_may_receive_interrupts_raw(this: *mut Self, val: u8_) {
2582 unsafe {
2583 let val: u8 = ::std::mem::transmute(val);
2584 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2585 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2586 1usize,
2587 1u8,
2588 val as u64,
2589 )
2590 }
2591 }
2592 #[inline]
2593 pub fn decrement_main_loop_per_calls_if_polling(&self) -> u8_ {
2594 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2595 }
2596 #[inline]
2597 pub fn set_decrement_main_loop_per_calls_if_polling(&mut self, val: u8_) {
2598 unsafe {
2599 let val: u8 = ::std::mem::transmute(val);
2600 self._bitfield_1.set(2usize, 1u8, val as u64)
2601 }
2602 }
2603 #[inline]
2604 pub unsafe fn decrement_main_loop_per_calls_if_polling_raw(this: *const Self) -> u8_ {
2605 unsafe {
2606 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2607 ::std::ptr::addr_of!((*this)._bitfield_1),
2608 2usize,
2609 1u8,
2610 ) as u8)
2611 }
2612 }
2613 #[inline]
2614 pub unsafe fn set_decrement_main_loop_per_calls_if_polling_raw(this: *mut Self, val: u8_) {
2615 unsafe {
2616 let val: u8 = ::std::mem::transmute(val);
2617 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2618 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2619 2usize,
2620 1u8,
2621 val as u64,
2622 )
2623 }
2624 }
2625 #[inline]
2626 pub fn supports_adaptive_mode(&self) -> u8_ {
2627 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2628 }
2629 #[inline]
2630 pub fn set_supports_adaptive_mode(&mut self, val: u8_) {
2631 unsafe {
2632 let val: u8 = ::std::mem::transmute(val);
2633 self._bitfield_1.set(3usize, 1u8, val as u64)
2634 }
2635 }
2636 #[inline]
2637 pub unsafe fn supports_adaptive_mode_raw(this: *const Self) -> u8_ {
2638 unsafe {
2639 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2640 ::std::ptr::addr_of!((*this)._bitfield_1),
2641 3usize,
2642 1u8,
2643 ) as u8)
2644 }
2645 }
2646 #[inline]
2647 pub unsafe fn set_supports_adaptive_mode_raw(this: *mut Self, val: u8_) {
2648 unsafe {
2649 let val: u8 = ::std::mem::transmute(val);
2650 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2651 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2652 3usize,
2653 1u8,
2654 val as u64,
2655 )
2656 }
2657 }
2658 #[inline]
2659 pub fn can_be_polled(&self) -> u8_ {
2660 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2661 }
2662 #[inline]
2663 pub fn set_can_be_polled(&mut self, val: u8_) {
2664 unsafe {
2665 let val: u8 = ::std::mem::transmute(val);
2666 self._bitfield_1.set(4usize, 1u8, val as u64)
2667 }
2668 }
2669 #[inline]
2670 pub unsafe fn can_be_polled_raw(this: *const Self) -> u8_ {
2671 unsafe {
2672 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2673 ::std::ptr::addr_of!((*this)._bitfield_1),
2674 4usize,
2675 1u8,
2676 ) as u8)
2677 }
2678 }
2679 #[inline]
2680 pub unsafe fn set_can_be_polled_raw(this: *mut Self, val: u8_) {
2681 unsafe {
2682 let val: u8 = ::std::mem::transmute(val);
2683 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2684 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2685 4usize,
2686 1u8,
2687 val as u64,
2688 )
2689 }
2690 }
2691 #[inline]
2692 pub fn is_process(&self) -> u8_ {
2693 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2694 }
2695 #[inline]
2696 pub fn set_is_process(&mut self, val: u8_) {
2697 unsafe {
2698 let val: u8 = ::std::mem::transmute(val);
2699 self._bitfield_1.set(5usize, 1u8, val as u64)
2700 }
2701 }
2702 #[inline]
2703 pub unsafe fn is_process_raw(this: *const Self) -> u8_ {
2704 unsafe {
2705 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2706 ::std::ptr::addr_of!((*this)._bitfield_1),
2707 5usize,
2708 1u8,
2709 ) as u8)
2710 }
2711 }
2712 #[inline]
2713 pub unsafe fn set_is_process_raw(this: *mut Self, val: u8_) {
2714 unsafe {
2715 let val: u8 = ::std::mem::transmute(val);
2716 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2717 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2718 5usize,
2719 1u8,
2720 val as u64,
2721 )
2722 }
2723 }
2724 #[inline]
2725 pub fn new_bitfield_1(
2726 can_be_disabled: u8_,
2727 may_receive_interrupts: u8_,
2728 decrement_main_loop_per_calls_if_polling: u8_,
2729 supports_adaptive_mode: u8_,
2730 can_be_polled: u8_,
2731 is_process: u8_,
2732 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2733 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2734 __bindgen_bitfield_unit.set(0usize, 1u8, {
2735 let can_be_disabled: u8 = unsafe { ::std::mem::transmute(can_be_disabled) };
2736 can_be_disabled as u64
2737 });
2738 __bindgen_bitfield_unit.set(1usize, 1u8, {
2739 let may_receive_interrupts: u8 =
2740 unsafe { ::std::mem::transmute(may_receive_interrupts) };
2741 may_receive_interrupts as u64
2742 });
2743 __bindgen_bitfield_unit.set(2usize, 1u8, {
2744 let decrement_main_loop_per_calls_if_polling: u8 =
2745 unsafe { ::std::mem::transmute(decrement_main_loop_per_calls_if_polling) };
2746 decrement_main_loop_per_calls_if_polling as u64
2747 });
2748 __bindgen_bitfield_unit.set(3usize, 1u8, {
2749 let supports_adaptive_mode: u8 =
2750 unsafe { ::std::mem::transmute(supports_adaptive_mode) };
2751 supports_adaptive_mode as u64
2752 });
2753 __bindgen_bitfield_unit.set(4usize, 1u8, {
2754 let can_be_polled: u8 = unsafe { ::std::mem::transmute(can_be_polled) };
2755 can_be_polled as u64
2756 });
2757 __bindgen_bitfield_unit.set(5usize, 1u8, {
2758 let is_process: u8 = unsafe { ::std::mem::transmute(is_process) };
2759 is_process as u64
2760 });
2761 __bindgen_bitfield_unit
2762 }
2763}
2764unsafe extern "C" {
2765 pub static node_type_attrs: [vlib_node_type_atts_t; 5usize];
2766}
2767#[repr(C)]
2768#[derive(Debug, Copy, Clone)]
2769pub struct _vlib_node_fn_registration {
2770 pub function: vlib_node_function_t,
2771 pub march_variant: clib_march_variant_type_t,
2772 pub next_registration: *mut _vlib_node_fn_registration,
2773}
2774impl Default for _vlib_node_fn_registration {
2775 fn default() -> Self {
2776 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2777 unsafe {
2778 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2779 s.assume_init()
2780 }
2781 }
2782}
2783pub type vlib_node_fn_registration_t = _vlib_node_fn_registration;
2784#[repr(C)]
2785#[derive(Debug)]
2786pub struct _vlib_node_registration<FAM: ?Sized = [*mut ::std::os::raw::c_char; 0]> {
2787 pub function: vlib_node_function_t,
2788 pub node_fn_registrations: *mut vlib_node_fn_registration_t,
2789 pub name: *mut ::std::os::raw::c_char,
2790 pub sibling_of: *mut ::std::os::raw::c_char,
2791 pub index: u32_,
2792 pub type_: vlib_node_type_t,
2793 pub error_strings: *mut *mut ::std::os::raw::c_char,
2794 pub error_counters: *mut vlib_error_desc_t,
2795 pub format_buffer: format_function_t,
2796 pub unformat_buffer: unformat_function_t,
2797 pub format_trace: format_function_t,
2798 pub unformat_trace: unformat_function_t,
2799 pub validate_frame: ::std::option::Option<
2800 unsafe extern "C" fn(
2801 vm: *mut vlib_main_t,
2802 arg1: *mut vlib_node_runtime_t,
2803 f: *mut vlib_frame_t,
2804 ) -> *mut u8_,
2805 >,
2806 pub runtime_data: *mut ::std::os::raw::c_void,
2807 pub process_log2_n_stack_bytes: u16_,
2808 pub runtime_data_bytes: u8_,
2809 pub state: u8_,
2810 pub flags: u16_,
2811 pub protocol_hint: u8_,
2812 pub vector_size: u8_,
2813 pub aux_size: u8_,
2814 pub scalar_size: u16_,
2815 pub n_errors: u16_,
2816 pub n_next_nodes: u16_,
2817 pub next_registration: *mut _vlib_node_registration,
2818 pub next_nodes: FAM,
2819}
2820impl _vlib_node_registration<[*mut ::std::os::raw::c_char]> {}
2821impl _vlib_node_registration<[*mut ::std::os::raw::c_char; 0]> {}
2822impl Default for _vlib_node_registration<[*mut ::std::os::raw::c_char; 0]> {
2823 fn default() -> Self {
2824 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2825 unsafe {
2826 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2827 s.assume_init()
2828 }
2829 }
2830}
2831pub type vlib_node_registration_t = _vlib_node_registration;
2832unsafe extern "C" {
2833 pub fn unformat_vlib_node_variant(input: *mut unformat_input_t, args: *mut va_list) -> uword;
2834}
2835#[repr(C)]
2836#[derive(Debug, Default, Copy, Clone)]
2837pub struct vlib_node_stats_t {
2838 pub calls: u64_,
2839 pub vectors: u64_,
2840 pub clocks: u64_,
2841 pub suspends: u64_,
2842 pub max_clock: u64_,
2843 pub max_clock_n: u64_,
2844}
2845pub const vlib_node_state_t_VLIB_NODE_STATE_POLLING: vlib_node_state_t = 0;
2846pub const vlib_node_state_t_VLIB_NODE_STATE_INTERRUPT: vlib_node_state_t = 1;
2847pub const vlib_node_state_t_VLIB_NODE_STATE_DISABLED: vlib_node_state_t = 2;
2848pub const vlib_node_state_t_VLIB_N_NODE_STATE: vlib_node_state_t = 3;
2849pub type vlib_node_state_t = ::std::os::raw::c_uchar;
2850pub const vlib_node_dispatch_reason_t_VLIB_NODE_DISPATCH_REASON_UNKNOWN:
2851 vlib_node_dispatch_reason_t = 0;
2852pub const vlib_node_dispatch_reason_t_VLIB_NODE_DISPATCH_REASON_PENDING_FRAME:
2853 vlib_node_dispatch_reason_t = 1;
2854pub const vlib_node_dispatch_reason_t_VLIB_NODE_DISPATCH_REASON_POLL: vlib_node_dispatch_reason_t =
2855 2;
2856pub const vlib_node_dispatch_reason_t_VLIB_NODE_DISPATCH_REASON_INTERRUPT:
2857 vlib_node_dispatch_reason_t = 3;
2858pub const vlib_node_dispatch_reason_t_VLIB_NODE_DISPATCH_REASON_SCHED: vlib_node_dispatch_reason_t =
2859 4;
2860pub const vlib_node_dispatch_reason_t_VLIB_NODE_DISPATCH_N_REASON: vlib_node_dispatch_reason_t = 5;
2861pub type vlib_node_dispatch_reason_t = ::std::os::raw::c_uchar;
2862#[repr(C)]
2863#[derive(Debug, Copy, Clone)]
2864pub struct vlib_node_t {
2865 pub function: vlib_node_function_t,
2866 pub name: *mut u8_,
2867 pub name_elog_string: u32_,
2868 pub stats_total: vlib_node_stats_t,
2869 pub stats_last_clear: vlib_node_stats_t,
2870 pub type_: vlib_node_type_t,
2871 pub index: u32_,
2872 pub runtime_index: u32_,
2873 pub runtime_data: *mut u8_,
2874 pub flags: u16_,
2875 pub state: u8_,
2876 pub runtime_data_bytes: u8_,
2877 pub protocol_hint: u8_,
2878 pub n_errors: u16_,
2879 pub frame_size: u16_,
2880 pub scalar_offset: u16_,
2881 pub vector_offset: u16_,
2882 pub magic_offset: u16_,
2883 pub aux_offset: u16_,
2884 pub frame_size_index: u16_,
2885 pub error_heap_handle: u32_,
2886 pub error_heap_index: u32_,
2887 pub error_counters: *mut vlib_error_desc_t,
2888 pub next_node_names: *mut *mut ::std::os::raw::c_char,
2889 pub next_nodes: *mut u32_,
2890 pub sibling_of: *mut ::std::os::raw::c_char,
2891 pub sibling_bitmap: *mut uword,
2892 pub n_vectors_by_next_node: *mut u64_,
2893 pub next_slot_by_node: *mut uword,
2894 pub prev_node_bitmap: *mut uword,
2895 pub owner_node_index: u32_,
2896 pub owner_next_index: u32_,
2897 pub format_buffer: format_function_t,
2898 pub unformat_buffer: unformat_function_t,
2899 pub format_trace: format_function_t,
2900 pub validate_frame: ::std::option::Option<
2901 unsafe extern "C" fn(
2902 vm: *mut vlib_main_t,
2903 arg1: *mut vlib_node_runtime_t,
2904 f: *mut vlib_frame_t,
2905 ) -> *mut u8_,
2906 >,
2907 pub state_string: *mut u8_,
2908 pub node_fn_registrations: *mut vlib_node_fn_registration_t,
2909}
2910impl Default for vlib_node_t {
2911 fn default() -> Self {
2912 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2913 unsafe {
2914 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2915 s.assume_init()
2916 }
2917 }
2918}
2919#[repr(C)]
2920#[derive(Debug, Default)]
2921pub struct vlib_frame_t<FAM: ?Sized = [u8_; 0]> {
2922 pub frame_flags: u16_,
2923 pub flags: u16_,
2924 pub scalar_offset: u16_,
2925 pub vector_offset: u16_,
2926 pub aux_offset: u16_,
2927 pub n_vectors: u16_,
2928 pub frame_size_index: u16_,
2929 pub arguments: FAM,
2930}
2931impl vlib_frame_t<[u8_]> {}
2932impl vlib_frame_t<[u8_; 0]> {}
2933#[repr(C)]
2934#[derive(Debug, Copy, Clone)]
2935pub struct vlib_next_frame_t {
2936 pub frame: *mut vlib_frame_t,
2937 pub node_runtime_index: u32_,
2938 pub flags: u32_,
2939 pub vectors_since_last_overflow: u32_,
2940}
2941impl Default for vlib_next_frame_t {
2942 fn default() -> Self {
2943 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2944 unsafe {
2945 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2946 s.assume_init()
2947 }
2948 }
2949}
2950#[repr(C)]
2951#[derive(Debug, Copy, Clone)]
2952pub struct vlib_pending_frame_t {
2953 pub frame: *mut vlib_frame_t,
2954 pub node_runtime_index: u32_,
2955 pub next_frame_index: u32_,
2956}
2957impl Default for vlib_pending_frame_t {
2958 fn default() -> Self {
2959 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2960 unsafe {
2961 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2962 s.assume_init()
2963 }
2964 }
2965}
2966#[repr(C)]
2967#[repr(align(64))]
2968#[derive(Debug)]
2969pub struct vlib_node_runtime_t<FAM: ?Sized = [u8_; 0]> {
2970 pub cacheline0: __IncompleteArrayField<u8_>,
2971 pub function: vlib_node_function_t,
2972 pub errors: *mut vlib_error_t,
2973 pub clocks_since_last_overflow: u32_,
2974 pub max_clock: u32_,
2975 pub max_clock_n: u32_,
2976 pub calls_since_last_overflow: u32_,
2977 pub vectors_since_last_overflow: u32_,
2978 pub next_frame_index: u32_,
2979 pub node_index: u32_,
2980 pub input_main_loops_per_call: u32_,
2981 pub main_loop_count_last_dispatch: u32_,
2982 pub main_loop_vector_stats: [u32_; 2usize],
2983 pub flags: u16_,
2984 pub state: vlib_node_state_t,
2985 pub dispatch_reason: vlib_node_dispatch_reason_t,
2986 pub n_next_nodes: u16_,
2987 pub cached_next_index: u16_,
2988 pub stop_timer_handle_plus_1: u32_,
2989 pub runtime_data_pad: __IncompleteArrayField<u8_>,
2990 pub runtime_data: FAM,
2991}
2992impl vlib_node_runtime_t<[u8_]> {}
2993impl vlib_node_runtime_t<[u8_; 0]> {}
2994impl Default for vlib_node_runtime_t<[u8_; 0]> {
2995 fn default() -> Self {
2996 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2997 unsafe {
2998 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2999 s.assume_init()
3000 }
3001 }
3002}
3003#[repr(C)]
3004#[derive(Debug, Copy, Clone)]
3005pub struct vlib_frame_size_t {
3006 pub n_alloc_frames: u32_,
3007 pub frame_size: u16_,
3008 pub free_frames: *mut *mut vlib_frame_t,
3009}
3010impl Default for vlib_frame_size_t {
3011 fn default() -> Self {
3012 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3013 unsafe {
3014 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3015 s.assume_init()
3016 }
3017 }
3018}
3019#[repr(C)]
3020#[derive(Debug, Default, Copy, Clone)]
3021pub struct vlib_process_event_type_t {
3022 pub opaque: uword,
3023}
3024pub const vlib_process_state_t_VLIB_PROCESS_STATE_NOT_STARTED: vlib_process_state_t = 0;
3025pub const vlib_process_state_t_VLIB_PROCESS_STATE_RUNNING: vlib_process_state_t = 1;
3026pub const vlib_process_state_t_VLIB_PROCESS_STATE_SUSPENDED: vlib_process_state_t = 2;
3027pub const vlib_process_state_t_VLIB_PROCESS_STATE_WAIT_FOR_EVENT: vlib_process_state_t = 3;
3028pub const vlib_process_state_t_VLIB_PROCESS_STATE_WAIT_FOR_CLOCK: vlib_process_state_t = 4;
3029pub const vlib_process_state_t_VLIB_PROCESS_STATE_WAIT_FOR_EVENT_OR_CLOCK: vlib_process_state_t = 5;
3030pub const vlib_process_state_t_VLIB_PROCESS_STATE_WAIT_FOR_ONE_TIME_EVENT: vlib_process_state_t = 6;
3031pub const vlib_process_state_t_VLIB_PROCESS_STATE_YIELD: vlib_process_state_t = 7;
3032pub const vlib_process_state_t_VLIB_PROCESS_N_STATES: vlib_process_state_t = 8;
3033pub type vlib_process_state_t = ::std::os::raw::c_uchar;
3034pub const vlib_process_restore_reason_t_VLIB_PROCESS_RESTORE_REASON_UNKNOWN:
3035 vlib_process_restore_reason_t = 0;
3036pub const vlib_process_restore_reason_t_VLIB_PROCESS_RESTORE_REASON_EVENT:
3037 vlib_process_restore_reason_t = 1;
3038pub const vlib_process_restore_reason_t_VLIB_PROCESS_RESTORE_REASON_CLOCK:
3039 vlib_process_restore_reason_t = 2;
3040pub const vlib_process_restore_reason_t_VLIB_PROCESS_RESTORE_REASON_TIMED_EVENT:
3041 vlib_process_restore_reason_t = 3;
3042pub const vlib_process_restore_reason_t_VLIB_PROCESS_RESTORE_REASON_YIELD:
3043 vlib_process_restore_reason_t = 4;
3044pub const vlib_process_restore_reason_t_VLIB_PROCRSS_N_RESTORE_REASON:
3045 vlib_process_restore_reason_t = 5;
3046pub type vlib_process_restore_reason_t = ::std::os::raw::c_uchar;
3047#[repr(C, packed)]
3048#[derive(Copy, Clone)]
3049pub struct vlib_process_restore_t {
3050 pub reason: vlib_process_restore_reason_t,
3051 pub __bindgen_anon_1: vlib_process_restore_t__bindgen_ty_1,
3052}
3053#[repr(C)]
3054#[derive(Copy, Clone)]
3055pub union vlib_process_restore_t__bindgen_ty_1 {
3056 pub runtime_index: u32_,
3057 pub timed_event_data_pool_index: u32_,
3058}
3059impl Default for vlib_process_restore_t__bindgen_ty_1 {
3060 fn default() -> Self {
3061 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3062 unsafe {
3063 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3064 s.assume_init()
3065 }
3066 }
3067}
3068impl Default for vlib_process_restore_t {
3069 fn default() -> Self {
3070 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3071 unsafe {
3072 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3073 s.assume_init()
3074 }
3075 }
3076}
3077#[repr(C)]
3078#[repr(align(64))]
3079#[derive(Debug)]
3080pub struct vlib_process_t {
3081 pub cacheline0: __IncompleteArrayField<u8_>,
3082 pub node_runtime: vlib_node_runtime_t,
3083 pub return_longjmp: clib_longjmp_t,
3084 pub resume_longjmp: clib_longjmp_t,
3085 pub state: vlib_process_state_t,
3086 pub _bitfield_align_1: [u8; 0],
3087 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3088 pub log2_n_stack_bytes: u16_,
3089 pub suspended_process_frame_index: u32_,
3090 pub n_suspends: u32_,
3091 pub pending_event_data_by_type_index: *mut *mut u8_,
3092 pub non_empty_event_type_bitmap: *mut uword,
3093 pub one_time_event_type_bitmap: *mut uword,
3094 pub event_type_index_by_type_opaque: *mut uword,
3095 pub event_type_pool: *mut vlib_process_event_type_t,
3096 pub resume_clock_interval: u64_,
3097 pub stop_timer_handle: u32_,
3098 pub output_function: vlib_cli_output_function_t,
3099 pub output_function_arg: uword,
3100 pub stack: *mut u32_,
3101}
3102impl Default for vlib_process_t {
3103 fn default() -> Self {
3104 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3105 unsafe {
3106 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3107 s.assume_init()
3108 }
3109 }
3110}
3111impl vlib_process_t {
3112 #[inline]
3113 pub fn event_resume_pending(&self) -> u8_ {
3114 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
3115 }
3116 #[inline]
3117 pub fn set_event_resume_pending(&mut self, val: u8_) {
3118 unsafe {
3119 let val: u8 = ::std::mem::transmute(val);
3120 self._bitfield_1.set(0usize, 1u8, val as u64)
3121 }
3122 }
3123 #[inline]
3124 pub unsafe fn event_resume_pending_raw(this: *const Self) -> u8_ {
3125 unsafe {
3126 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3127 ::std::ptr::addr_of!((*this)._bitfield_1),
3128 0usize,
3129 1u8,
3130 ) as u8)
3131 }
3132 }
3133 #[inline]
3134 pub unsafe fn set_event_resume_pending_raw(this: *mut Self, val: u8_) {
3135 unsafe {
3136 let val: u8 = ::std::mem::transmute(val);
3137 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3138 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3139 0usize,
3140 1u8,
3141 val as u64,
3142 )
3143 }
3144 }
3145 #[inline]
3146 pub fn new_bitfield_1(event_resume_pending: u8_) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3147 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3148 __bindgen_bitfield_unit.set(0usize, 1u8, {
3149 let event_resume_pending: u8 = unsafe { ::std::mem::transmute(event_resume_pending) };
3150 event_resume_pending as u64
3151 });
3152 __bindgen_bitfield_unit
3153 }
3154}
3155#[repr(C)]
3156#[derive(Debug, Default, Copy, Clone)]
3157pub struct vlib_one_time_waiting_process_t {
3158 pub node_index: u32_,
3159 pub one_time_event: u32_,
3160}
3161#[repr(C)]
3162#[derive(Copy, Clone)]
3163pub struct vlib_signal_timed_event_data_t {
3164 pub n_data_elts: u16_,
3165 pub n_data_elt_bytes: u16_,
3166 pub n_data_bytes: u32_,
3167 pub process_node_index: u32_,
3168 pub event_type_index: u32_,
3169 pub __bindgen_anon_1: vlib_signal_timed_event_data_t__bindgen_ty_1,
3170}
3171#[repr(C)]
3172#[derive(Copy, Clone)]
3173pub union vlib_signal_timed_event_data_t__bindgen_ty_1 {
3174 pub inline_event_data: [u8_; 48usize],
3175 pub event_data_as_vector: *mut u8_,
3176}
3177impl Default for vlib_signal_timed_event_data_t__bindgen_ty_1 {
3178 fn default() -> Self {
3179 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3180 unsafe {
3181 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3182 s.assume_init()
3183 }
3184 }
3185}
3186impl Default for vlib_signal_timed_event_data_t {
3187 fn default() -> Self {
3188 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3189 unsafe {
3190 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3191 s.assume_init()
3192 }
3193 }
3194}
3195#[repr(C)]
3196#[derive(Debug, Copy, Clone)]
3197pub struct vlib_node_fn_variant_t {
3198 pub index: clib_march_variant_type_t,
3199 pub priority: ::std::os::raw::c_int,
3200 pub suffix: *mut ::std::os::raw::c_char,
3201 pub desc: *mut ::std::os::raw::c_char,
3202}
3203impl Default for vlib_node_fn_variant_t {
3204 fn default() -> Self {
3205 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3206 unsafe {
3207 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3208 s.assume_init()
3209 }
3210 }
3211}
3212#[repr(C)]
3213#[derive(Debug, Copy, Clone)]
3214pub struct vlib_node_main_t {
3215 pub nodes: *mut *mut vlib_node_t,
3216 pub node_by_name: *mut uword,
3217 pub flags: u32_,
3218 pub nodes_by_type: [*mut vlib_node_runtime_t; 5usize],
3219 pub node_interrupts: [*mut ::std::os::raw::c_void; 5usize],
3220 pub polling_threshold_vector_length: u32_,
3221 pub interrupt_threshold_vector_length: u32_,
3222 pub next_frames: *mut vlib_next_frame_t,
3223 pub pending_frames: *mut vlib_pending_frame_t,
3224 pub signal_timed_event_data_pool: *mut vlib_signal_timed_event_data_t,
3225 pub process_restore_current: *mut vlib_process_restore_t,
3226 pub sched_node_pending: *mut u32_,
3227 pub process_restore_next: *mut vlib_process_restore_t,
3228 pub time_next_process_ready: f64_,
3229 pub processes: *mut *mut vlib_process_t,
3230 pub current_process_index: u32_,
3231 pub suspended_process_frames: *mut vlib_pending_frame_t,
3232 pub recycled_event_data_vectors: *mut *mut ::std::os::raw::c_void,
3233 pub input_node_counts_by_state: [u32_; 3usize],
3234 pub frame_sizes: *mut vlib_frame_size_t,
3235 pub time_last_runtime_stats_clear: f64_,
3236 pub node_by_error: *mut u32_,
3237 pub variants: *mut vlib_node_fn_variant_t,
3238 pub node_fn_default_march_variant: u32_,
3239 pub node_fn_march_variant_by_suffix: *mut uword,
3240}
3241impl Default for vlib_node_main_t {
3242 fn default() -> Self {
3243 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3244 unsafe {
3245 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3246 s.assume_init()
3247 }
3248 }
3249}
3250#[repr(C)]
3251#[repr(align(64))]
3252#[derive(Debug)]
3253pub struct frame_queue_trace_t {
3254 pub cacheline0: __IncompleteArrayField<u8_>,
3255 pub head: u64_,
3256 pub tail: u64_,
3257 pub n_in_use: u32_,
3258 pub nelts: u32_,
3259 pub written: u32_,
3260 pub threshold: u32_,
3261 pub n_vectors: [i32_; 64usize],
3262}
3263impl Default for frame_queue_trace_t {
3264 fn default() -> Self {
3265 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3266 unsafe {
3267 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3268 s.assume_init()
3269 }
3270 }
3271}
3272#[repr(C)]
3273#[derive(Debug, Copy, Clone)]
3274pub struct frame_queue_nelt_counter_t {
3275 pub count: [u64_; 64usize],
3276}
3277impl Default for frame_queue_nelt_counter_t {
3278 fn default() -> Self {
3279 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3280 unsafe {
3281 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3282 s.assume_init()
3283 }
3284 }
3285}
3286#[repr(C)]
3287#[derive(Debug, Default, Copy, Clone)]
3288pub struct clib_time_t {
3289 pub total_cpu_time: u64_,
3290 pub last_cpu_time: u64_,
3291 pub clocks_per_second: f64_,
3292 pub seconds_per_clock: f64_,
3293 pub init_cpu_time: u64_,
3294 pub init_reference_time: f64_,
3295 pub last_verify_cpu_time: u64_,
3296 pub last_verify_reference_time: f64_,
3297 pub log2_clocks_per_second: u32_,
3298 pub log2_clocks_per_frequency_verify: u32_,
3299 pub damping_constant: f64_,
3300}
3301#[repr(C)]
3302#[derive(Copy, Clone)]
3303pub struct elog_event_t {
3304 pub __bindgen_anon_1: elog_event_t__bindgen_ty_1,
3305 pub event_type: u16_,
3306 pub track: u16_,
3307 pub data: [u8_; 20usize],
3308}
3309#[repr(C)]
3310#[derive(Copy, Clone)]
3311pub union elog_event_t__bindgen_ty_1 {
3312 pub time_cycles: u64_,
3313 pub time: f64_,
3314}
3315impl Default for elog_event_t__bindgen_ty_1 {
3316 fn default() -> Self {
3317 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3318 unsafe {
3319 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3320 s.assume_init()
3321 }
3322 }
3323}
3324impl Default for elog_event_t {
3325 fn default() -> Self {
3326 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3327 unsafe {
3328 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3329 s.assume_init()
3330 }
3331 }
3332}
3333#[repr(C)]
3334#[derive(Debug)]
3335pub struct elog_event_type_t<FAM: ?Sized = [*mut ::std::os::raw::c_char; 0]> {
3336 pub type_index_plus_one: u32_,
3337 pub enum_strings_vector: *mut *mut ::std::os::raw::c_char,
3338 pub format: *mut ::std::os::raw::c_char,
3339 pub format_args: *mut ::std::os::raw::c_char,
3340 pub function: *mut ::std::os::raw::c_char,
3341 pub n_enum_strings: u32_,
3342 pub enum_strings: FAM,
3343}
3344impl elog_event_type_t<[*mut ::std::os::raw::c_char]> {}
3345impl elog_event_type_t<[*mut ::std::os::raw::c_char; 0]> {}
3346impl Default for elog_event_type_t<[*mut ::std::os::raw::c_char; 0]> {
3347 fn default() -> Self {
3348 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3349 unsafe {
3350 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3351 s.assume_init()
3352 }
3353 }
3354}
3355#[repr(C)]
3356#[derive(Debug, Copy, Clone)]
3357pub struct elog_track_t {
3358 pub name: *mut ::std::os::raw::c_char,
3359 pub track_index_plus_one: u32_,
3360}
3361impl Default for elog_track_t {
3362 fn default() -> Self {
3363 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3364 unsafe {
3365 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3366 s.assume_init()
3367 }
3368 }
3369}
3370#[repr(C)]
3371#[derive(Debug, Default, Copy, Clone)]
3372pub struct elog_time_stamp_t {
3373 pub cpu: u64_,
3374 pub os_nsec: u64_,
3375}
3376#[repr(C)]
3377#[derive(Copy, Clone)]
3378pub struct elog_main_t {
3379 pub n_total_events: u32_,
3380 pub n_total_events_disable_limit: u32_,
3381 pub placeholder_event: elog_event_t,
3382 pub event_ring_size: uword,
3383 pub event_ring: *mut elog_event_t,
3384 pub event_types: *mut elog_event_type_t,
3385 pub event_type_by_format: *mut uword,
3386 pub string_table: *mut ::std::os::raw::c_char,
3387 pub string_table_hash: *mut uword,
3388 pub string_table_tmp: *mut u8_,
3389 pub tracks: *mut elog_track_t,
3390 pub default_track: elog_track_t,
3391 pub cpu_timer: clib_time_t,
3392 pub init_time: elog_time_stamp_t,
3393 pub serialize_time: elog_time_stamp_t,
3394 pub lock: *mut uword,
3395 pub nsec_per_cpu_clock: f64_,
3396 pub events: *mut elog_event_t,
3397}
3398impl Default for elog_main_t {
3399 fn default() -> Self {
3400 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3401 unsafe {
3402 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3403 s.assume_init()
3404 }
3405 }
3406}
3407#[repr(C)]
3408#[derive(Debug, Default, Copy, Clone)]
3409pub struct isaac_t {
3410 pub memory: [uword; 16usize],
3411 pub a: uword,
3412 pub b: uword,
3413 pub c: uword,
3414}
3415#[repr(C)]
3416#[derive(Copy, Clone)]
3417pub struct clib_random_buffer_t {
3418 pub ctx: [isaac_t; 2usize],
3419 pub buffer: *mut uword,
3420 pub next_read_len: uword,
3421 pub n_cached_bytes: uword,
3422 pub __bindgen_anon_1: clib_random_buffer_t__bindgen_ty_1,
3423}
3424#[repr(C)]
3425#[derive(Copy, Clone)]
3426pub union clib_random_buffer_t__bindgen_ty_1 {
3427 pub cached_bytes: [u8_; 8usize],
3428 pub cached_word: uword,
3429}
3430impl Default for clib_random_buffer_t__bindgen_ty_1 {
3431 fn default() -> Self {
3432 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3433 unsafe {
3434 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3435 s.assume_init()
3436 }
3437 }
3438}
3439impl Default for clib_random_buffer_t {
3440 fn default() -> Self {
3441 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3442 unsafe {
3443 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3444 s.assume_init()
3445 }
3446 }
3447}
3448#[repr(C)]
3449#[derive(Debug, Default, Copy, Clone)]
3450pub struct vlib_trace_filter_t {
3451 pub trace_filter_enable: u8_,
3452 pub classify_table_index: u32_,
3453}
3454pub const vlib_node_runtime_perf_call_type_t_VLIB_NODE_RUNTIME_PERF_BEFORE:
3455 vlib_node_runtime_perf_call_type_t = 0;
3456pub const vlib_node_runtime_perf_call_type_t_VLIB_NODE_RUNTIME_PERF_AFTER:
3457 vlib_node_runtime_perf_call_type_t = 1;
3458pub const vlib_node_runtime_perf_call_type_t_VLIB_NODE_RUNTIME_PERF_RESET:
3459 vlib_node_runtime_perf_call_type_t = 2;
3460pub type vlib_node_runtime_perf_call_type_t = ::std::os::raw::c_uint;
3461#[repr(C)]
3462#[derive(Debug, Copy, Clone)]
3463pub struct vlib_node_runtime_perf_callback_args_t {
3464 pub vm: *mut vlib_main_t,
3465 pub node: *mut vlib_node_runtime_t,
3466 pub frame: *mut vlib_frame_t,
3467 pub packets: uword,
3468 pub cpu_time_now: u64_,
3469 pub call_type: vlib_node_runtime_perf_call_type_t,
3470}
3471impl Default for vlib_node_runtime_perf_callback_args_t {
3472 fn default() -> Self {
3473 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3474 unsafe {
3475 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3476 s.assume_init()
3477 }
3478 }
3479}
3480pub type vlib_node_runtime_perf_callback_fp_t = ::std::option::Option<
3481 unsafe extern "C" fn(
3482 data: *mut vlib_node_runtime_perf_callback_data_t,
3483 args: *mut vlib_node_runtime_perf_callback_args_t,
3484 ),
3485>;
3486#[repr(C)]
3487#[derive(Copy, Clone)]
3488pub struct vlib_node_runtime_perf_callback_data_t {
3489 pub fp: vlib_node_runtime_perf_callback_fp_t,
3490 pub u: [vlib_node_runtime_perf_callback_data_t__bindgen_ty_1; 3usize],
3491}
3492#[repr(C)]
3493#[derive(Copy, Clone)]
3494pub union vlib_node_runtime_perf_callback_data_t__bindgen_ty_1 {
3495 pub v: *mut ::std::os::raw::c_void,
3496 pub u: u64_,
3497}
3498impl Default for vlib_node_runtime_perf_callback_data_t__bindgen_ty_1 {
3499 fn default() -> Self {
3500 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3501 unsafe {
3502 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3503 s.assume_init()
3504 }
3505 }
3506}
3507impl Default for vlib_node_runtime_perf_callback_data_t {
3508 fn default() -> Self {
3509 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3510 unsafe {
3511 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3512 s.assume_init()
3513 }
3514 }
3515}
3516#[repr(C)]
3517#[derive(Debug, Copy, Clone)]
3518pub struct vlib_node_runtime_perf_callback_set_t {
3519 pub curr: *mut vlib_node_runtime_perf_callback_data_t,
3520 pub next: *mut vlib_node_runtime_perf_callback_data_t,
3521 pub spare: *mut vlib_node_runtime_perf_callback_data_t,
3522 pub lock: *mut clib_spinlock_t,
3523}
3524impl Default for vlib_node_runtime_perf_callback_set_t {
3525 fn default() -> Self {
3526 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3527 unsafe {
3528 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3529 s.assume_init()
3530 }
3531 }
3532}
3533#[repr(C)]
3534#[repr(align(64))]
3535pub struct vlib_main_t {
3536 pub cacheline0: __IncompleteArrayField<u8_>,
3537 pub clib_time: clib_time_t,
3538 pub time_offset: f64_,
3539 pub time_last_barrier_release: f64_,
3540 pub cpu_time_last_node_dispatch: u64_,
3541 pub cpu_time_main_loop_start: u64_,
3542 pub main_loop_count: u32_,
3543 pub main_loop_vectors_processed: u32_,
3544 pub main_loop_nodes_processed: u32_,
3545 pub internal_node_vectors: u64_,
3546 pub internal_node_calls: u64_,
3547 pub internal_node_vectors_last_clear: u64_,
3548 pub internal_node_calls_last_clear: u64_,
3549 pub internal_node_last_vectors_per_main_loop: u32_,
3550 pub vlib_node_runtime_perf_callbacks: vlib_node_runtime_perf_callback_set_t,
3551 pub dispatch_wrapper_fn: vlib_node_function_t,
3552 pub main_loop_exit_set: u32_,
3553 pub main_loop_exit_now: u32_,
3554 pub main_loop_exit_status: ::std::os::raw::c_int,
3555 pub __bindgen_padding_0: [u64; 0usize],
3556 pub main_loop_exit: clib_longjmp_t,
3557 pub main_loop_error: *mut clib_error_t,
3558 pub buffer_main: *mut vlib_buffer_main_t,
3559 pub physmem_main: vlib_physmem_main_t,
3560 pub node_main: vlib_node_main_t,
3561 pub trace_main: vlib_trace_main_t,
3562 pub error_main: vlib_error_main_t,
3563 pub os_punt_frame: ::std::option::Option<
3564 unsafe extern "C" fn(
3565 vm: *mut vlib_main_t,
3566 node: *mut vlib_node_runtime_t,
3567 frame: *mut vlib_frame_t,
3568 ),
3569 >,
3570 pub mc_stream_index: u32_,
3571 pub worker_init_functions_called: *mut uword,
3572 pub procs_waiting_for_mc_stream_join: *mut vlib_one_time_waiting_process_t,
3573 pub elog_trace_api_messages: ::std::os::raw::c_int,
3574 pub elog_trace_cli_commands: ::std::os::raw::c_int,
3575 pub elog_trace_graph_dispatch: ::std::os::raw::c_int,
3576 pub elog_trace_graph_circuit: ::std::os::raw::c_int,
3577 pub elog_trace_graph_circuit_node_index: u32_,
3578 pub node_call_elog_event_types: *mut elog_event_type_t,
3579 pub node_return_elog_event_types: *mut elog_event_type_t,
3580 pub error_elog_event_types: *mut elog_event_type_t,
3581 pub random_seed: uword,
3582 pub random_buffer: clib_random_buffer_t,
3583 pub thread_index: clib_thread_index_t,
3584 pub numa_node: u32_,
3585 pub epoll_fd: ::std::os::raw::c_int,
3586 pub wakeup_fd: ::std::os::raw::c_int,
3587 pub n_epoll_fds: ::std::os::raw::c_int,
3588 pub file_poll_skip_loops: u32_,
3589 pub epoll_files_ready: u64_,
3590 pub epoll_waits: u64_,
3591 pub wakeup_pending: u8_,
3592 pub thread_sleeps: u8_,
3593 pub queue_signal_pending: u32_,
3594 pub api_queue_nonempty: u32_,
3595 pub queue_signal_callback: ::std::option::Option<unsafe extern "C" fn(arg1: *mut vlib_main_t)>,
3596 pub worker_thread_main_loop_callbacks:
3597 *mut ::std::option::Option<unsafe extern "C" fn(arg1: *mut vlib_main_t, t: u64_)>,
3598 pub worker_thread_main_loop_callback_tmp:
3599 *mut ::std::option::Option<unsafe extern "C" fn(arg1: *mut vlib_main_t, t: u64_)>,
3600 pub worker_thread_main_loop_callback_lock: clib_spinlock_t,
3601 pub parked_at_barrier: ::std::os::raw::c_int,
3602 pub loops_this_reporting_interval: u64_,
3603 pub loop_interval_end: f64_,
3604 pub loop_interval_start: f64_,
3605 pub loops_per_second: f64_,
3606 pub seconds_per_loop: f64_,
3607 pub damping_constant: f64_,
3608 pub barrier_epoch: f64_,
3609 pub barrier_no_close_before: f64_,
3610 pub barrier_perf_callbacks: *mut ::std::option::Option<
3611 unsafe extern "C" fn(arg1: *mut vlib_main_t, t: u64_, leave: ::std::os::raw::c_int),
3612 >,
3613 pub barrier_perf_callbacks_tmp: *mut ::std::option::Option<
3614 unsafe extern "C" fn(arg1: *mut vlib_main_t, t: u64_, leave: ::std::os::raw::c_int),
3615 >,
3616 pub check_frame_queues: uword,
3617 pub pending_rpc_requests: *mut uword,
3618 pub processing_rpc_requests: *mut uword,
3619 pub pending_rpc_lock: clib_spinlock_t,
3620 pub buffer_alloc_success_seed: u32_,
3621 pub buffer_alloc_success_rate: f64_,
3622 pub timing_wheel: *mut ::std::os::raw::c_void,
3623 pub n_tw_timers: u32_,
3624}
3625impl Default for vlib_main_t {
3626 fn default() -> Self {
3627 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3628 unsafe {
3629 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3630 s.assume_init()
3631 }
3632 }
3633}
3634#[repr(C)]
3635#[repr(align(64))]
3636pub struct vlib_global_main_t {
3637 pub cacheline0: __IncompleteArrayField<u8_>,
3638 pub vlib_mains: *mut *mut vlib_main_t,
3639 pub name: *mut ::std::os::raw::c_char,
3640 pub exec_path: *mut ::std::os::raw::c_char,
3641 pub argv: *mut *mut u8_,
3642 pub post_mortem_callbacks: *mut ::std::option::Option<unsafe extern "C" fn()>,
3643 pub need_vlib_worker_thread_node_runtime_update: ::std::os::raw::c_int,
3644 pub cli_main: vlib_cli_main_t,
3645 pub node_registrations: *mut vlib_node_registration_t,
3646 pub elog_main: elog_main_t,
3647 pub configured_elog_ring_size: u32_,
3648 pub trace_filter: vlib_trace_filter_t,
3649 pub init_function_registrations: *mut _vlib_init_function_list_elt_t,
3650 pub main_loop_enter_function_registrations: *mut _vlib_init_function_list_elt_t,
3651 pub main_loop_exit_function_registrations: *mut _vlib_init_function_list_elt_t,
3652 pub worker_init_function_registrations: *mut _vlib_init_function_list_elt_t,
3653 pub num_workers_change_function_registrations: *mut _vlib_init_function_list_elt_t,
3654 pub api_init_function_registrations: *mut _vlib_init_function_list_elt_t,
3655 pub config_function_registrations: *mut vlib_config_function_runtime_t,
3656 pub init_functions_called: *mut uword,
3657}
3658impl Default for vlib_global_main_t {
3659 fn default() -> Self {
3660 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3661 unsafe {
3662 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3663 s.assume_init()
3664 }
3665 }
3666}
3667unsafe extern "C" {
3668 pub static mut vlib_global_main: vlib_global_main_t;
3669}
3670unsafe extern "C" {
3671 pub fn vlib_exit_with_status(vm: *mut vlib_main_t, status: ::std::os::raw::c_int);
3672}
3673unsafe extern "C" {
3674 pub fn vlib_main(vm: *mut vlib_main_t, input: *mut unformat_input_t) -> ::std::os::raw::c_int;
3675}
3676unsafe extern "C" {
3677 pub static mut vlib_thread_stacks: *mut *mut u8_;
3678}
3679unsafe extern "C" {
3680 pub fn vlib_app_num_thread_stacks_needed() -> u32_;
3681}
3682unsafe extern "C" {
3683 pub fn vlib_add_del_post_mortem_callback(
3684 cb: *mut ::std::os::raw::c_void,
3685 is_add: ::std::os::raw::c_int,
3686 );
3687}
3688unsafe extern "C" {
3689 pub fn vlib_get_main_not_inline() -> *mut vlib_main_t;
3690}
3691unsafe extern "C" {
3692 pub fn vlib_get_elog_main_not_inline() -> *mut elog_main_t;
3693}
3694pub type vlib_thread_function_t =
3695 ::std::option::Option<unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void)>;
3696#[repr(C)]
3697#[derive(Debug, Copy, Clone)]
3698pub struct vlib_thread_registration_ {
3699 pub next: *mut vlib_thread_registration_,
3700 pub name: *mut ::std::os::raw::c_char,
3701 pub short_name: *mut ::std::os::raw::c_char,
3702 pub function: vlib_thread_function_t,
3703 pub mheap_size: uword,
3704 pub fixed_count: ::std::os::raw::c_int,
3705 pub count: u32_,
3706 pub no_data_structure_clone: ::std::os::raw::c_int,
3707 pub frame_queue_nelts: u32_,
3708 pub use_pthreads: ::std::os::raw::c_int,
3709 pub first_index: u32_,
3710 pub coremask: *mut uword,
3711}
3712impl Default for vlib_thread_registration_ {
3713 fn default() -> Self {
3714 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3715 unsafe {
3716 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3717 s.assume_init()
3718 }
3719 }
3720}
3721pub type vlib_thread_registration_t = vlib_thread_registration_;
3722#[repr(C)]
3723#[repr(align(64))]
3724#[derive(Debug)]
3725pub struct vlib_frame_queue_elt_t {
3726 pub cacheline0: __IncompleteArrayField<u8_>,
3727 pub valid: u32_,
3728 pub _bitfield_align_1: [u8; 0],
3729 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3730 pub n_vectors: u32_,
3731 pub offset: u32_,
3732 pub end_of_reset: __IncompleteArrayField<u8_>,
3733 pub __bindgen_padding_0: [u8; 48usize],
3734 pub cacheline1: __IncompleteArrayField<u8_>,
3735 pub buffer_index: [u32_; 256usize],
3736 pub aux_data: [u32_; 256usize],
3737}
3738impl Default for vlib_frame_queue_elt_t {
3739 fn default() -> Self {
3740 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3741 unsafe {
3742 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3743 s.assume_init()
3744 }
3745 }
3746}
3747impl vlib_frame_queue_elt_t {
3748 #[inline]
3749 pub fn maybe_trace(&self) -> u32_ {
3750 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3751 }
3752 #[inline]
3753 pub fn set_maybe_trace(&mut self, val: u32_) {
3754 unsafe {
3755 let val: u32 = ::std::mem::transmute(val);
3756 self._bitfield_1.set(0usize, 1u8, val as u64)
3757 }
3758 }
3759 #[inline]
3760 pub unsafe fn maybe_trace_raw(this: *const Self) -> u32_ {
3761 unsafe {
3762 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3763 ::std::ptr::addr_of!((*this)._bitfield_1),
3764 0usize,
3765 1u8,
3766 ) as u32)
3767 }
3768 }
3769 #[inline]
3770 pub unsafe fn set_maybe_trace_raw(this: *mut Self, val: u32_) {
3771 unsafe {
3772 let val: u32 = ::std::mem::transmute(val);
3773 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3774 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3775 0usize,
3776 1u8,
3777 val as u64,
3778 )
3779 }
3780 }
3781 #[inline]
3782 pub fn new_bitfield_1(maybe_trace: u32_) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3783 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3784 __bindgen_bitfield_unit.set(0usize, 1u8, {
3785 let maybe_trace: u32 = unsafe { ::std::mem::transmute(maybe_trace) };
3786 maybe_trace as u64
3787 });
3788 __bindgen_bitfield_unit
3789 }
3790}
3791#[repr(C)]
3792#[repr(align(64))]
3793#[derive(Debug)]
3794pub struct vlib_worker_thread_t {
3795 pub cacheline0: __IncompleteArrayField<u8_>,
3796 pub wait_at_barrier: *mut u32_,
3797 pub workers_at_barrier: *mut u32_,
3798 pub __bindgen_padding_0: [u8; 48usize],
3799 pub cacheline1: __IncompleteArrayField<u8_>,
3800 pub thread_mheap: *mut ::std::os::raw::c_void,
3801 pub thread_stack: *mut u8_,
3802 pub thread_function:
3803 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3804 pub thread_function_arg: *mut ::std::os::raw::c_void,
3805 pub recursion_level: i64_,
3806 pub elog_track: elog_track_t,
3807 pub instance_id: u32_,
3808 pub registration: *mut vlib_thread_registration_t,
3809 pub name: *mut u8_,
3810 pub barrier_sync_count: u64_,
3811 pub barrier_elog_enabled: u8_,
3812 pub barrier_caller: *const ::std::os::raw::c_char,
3813 pub barrier_context: *const ::std::os::raw::c_char,
3814 pub node_reforks_required: *mut u32_,
3815 pub wait_before_barrier: u32_,
3816 pub workers_before_barrier: u32_,
3817 pub done_work_before_barrier: u32_,
3818 pub lwp: ::std::os::raw::c_long,
3819 pub cpu_id: ::std::os::raw::c_int,
3820 pub core_id: ::std::os::raw::c_int,
3821 pub numa_id: ::std::os::raw::c_int,
3822 pub thread_id: pthread_t,
3823}
3824impl Default for vlib_worker_thread_t {
3825 fn default() -> Self {
3826 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3827 unsafe {
3828 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3829 s.assume_init()
3830 }
3831 }
3832}
3833#[repr(C)]
3834#[repr(align(64))]
3835#[derive(Debug)]
3836pub struct vlib_frame_queue_t {
3837 pub cacheline0: __IncompleteArrayField<u8_>,
3838 pub elts: *mut vlib_frame_queue_elt_t,
3839 pub vector_threshold: u64_,
3840 pub trace: u64_,
3841 pub nelts: u32_,
3842 pub __bindgen_padding_0: [u8; 36usize],
3843 pub cacheline1: __IncompleteArrayField<u8_>,
3844 pub tail: u64_,
3845 pub __bindgen_padding_1: [u8; 56usize],
3846 pub cacheline2: __IncompleteArrayField<u8_>,
3847 pub head: u64_,
3848}
3849impl Default for vlib_frame_queue_t {
3850 fn default() -> Self {
3851 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3852 unsafe {
3853 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3854 s.assume_init()
3855 }
3856 }
3857}
3858pub type vlib_frame_queue_dequeue_fn_t = ::std::option::Option<
3859 unsafe extern "C" fn(vm: *mut vlib_main_t, fqm: *mut vlib_frame_queue_main_t_) -> u32_,
3860>;
3861#[repr(C)]
3862#[derive(Debug, Copy, Clone)]
3863pub struct vlib_frame_queue_main_t_ {
3864 pub node_index: u32_,
3865 pub frame_queue_nelts: u32_,
3866 pub vlib_frame_queues: *mut *mut vlib_frame_queue_t,
3867 pub frame_queue_traces: *mut frame_queue_trace_t,
3868 pub frame_queue_histogram: *mut frame_queue_nelt_counter_t,
3869 pub frame_queue_dequeue_fn: vlib_frame_queue_dequeue_fn_t,
3870}
3871impl Default for vlib_frame_queue_main_t_ {
3872 fn default() -> Self {
3873 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3874 unsafe {
3875 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3876 s.assume_init()
3877 }
3878 }
3879}
3880pub type vlib_frame_queue_main_t = vlib_frame_queue_main_t_;
3881#[repr(C)]
3882#[derive(Debug, Copy, Clone)]
3883pub struct vlib_thread_main_t {
3884 pub next: *mut vlib_thread_registration_t,
3885 pub registrations: *mut *mut vlib_thread_registration_t,
3886 pub thread_registrations_by_name: *mut uword,
3887 pub worker_threads: *mut vlib_worker_thread_t,
3888 pub use_pthreads: ::std::os::raw::c_int,
3889 pub cpu_translate: ::std::os::raw::c_int,
3890 pub n_vlib_mains: u32_,
3891 pub n_thread_stacks: u32_,
3892 pub n_pthreads: u32_,
3893 pub n_threads: u32_,
3894 pub skip_cores: u32_,
3895 pub thread_prefix: *mut u8_,
3896 pub main_lcore: u32_,
3897 pub cpu_core_bitmap: *mut uword,
3898 pub cpu_socket_bitmap: *mut uword,
3899 pub frame_queue_mains: *mut vlib_frame_queue_main_t,
3900 pub worker_thread_release: u32_,
3901 pub sched_policy: u32_,
3902 pub sched_priority: u32_,
3903 pub numa_heap_size: uword,
3904}
3905impl Default for vlib_thread_main_t {
3906 fn default() -> Self {
3907 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3908 unsafe {
3909 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3910 s.assume_init()
3911 }
3912 }
3913}
3914pub type vlib_buffer_enqueue_to_next_fn_t = ::std::option::Option<
3915 unsafe extern "C" fn(
3916 vm: *mut vlib_main_t,
3917 node: *mut vlib_node_runtime_t,
3918 buffers: *mut u32_,
3919 nexts: *mut u16_,
3920 count: uword,
3921 ),
3922>;
3923pub type vlib_buffer_enqueue_to_next_with_aux_fn_t = ::std::option::Option<
3924 unsafe extern "C" fn(
3925 vm: *mut vlib_main_t,
3926 node: *mut vlib_node_runtime_t,
3927 buffers: *mut u32_,
3928 aux_data: *mut u32_,
3929 nexts: *mut u16_,
3930 count: uword,
3931 ),
3932>;
3933pub type vlib_buffer_enqueue_to_single_next_fn_t = ::std::option::Option<
3934 unsafe extern "C" fn(
3935 vm: *mut vlib_main_t,
3936 node: *mut vlib_node_runtime_t,
3937 ers: *mut u32_,
3938 next_index: u16_,
3939 count: u32_,
3940 ),
3941>;
3942pub type vlib_buffer_enqueue_to_single_next_with_aux_fn_t = ::std::option::Option<
3943 unsafe extern "C" fn(
3944 vm: *mut vlib_main_t,
3945 node: *mut vlib_node_runtime_t,
3946 ers: *mut u32_,
3947 aux_data: *mut u32_,
3948 next_index: u16_,
3949 count: u32_,
3950 ),
3951>;
3952pub type vlib_buffer_enqueue_to_thread_fn_t = ::std::option::Option<
3953 unsafe extern "C" fn(
3954 vm: *mut vlib_main_t,
3955 node: *mut vlib_node_runtime_t,
3956 frame_queue_index: u32_,
3957 buffer_indices: *mut u32_,
3958 thread_indices: *mut u16_,
3959 n_packets: u32_,
3960 drop_on_congestion: ::std::os::raw::c_int,
3961 ) -> u32_,
3962>;
3963pub type vlib_buffer_enqueue_to_thread_with_aux_fn_t = ::std::option::Option<
3964 unsafe extern "C" fn(
3965 vm: *mut vlib_main_t,
3966 node: *mut vlib_node_runtime_t,
3967 frame_queue_index: u32_,
3968 buffer_indices: *mut u32_,
3969 aux: *mut u32_,
3970 thread_indices: *mut u16_,
3971 n_packets: u32_,
3972 drop_on_congestion: ::std::os::raw::c_int,
3973 ) -> u32_,
3974>;
3975#[repr(C)]
3976#[derive(Debug, Default, Copy, Clone)]
3977pub struct vlib_buffer_func_main_t {
3978 pub buffer_enqueue_to_next_fn: vlib_buffer_enqueue_to_next_fn_t,
3979 pub buffer_enqueue_to_next_with_aux_fn: vlib_buffer_enqueue_to_next_with_aux_fn_t,
3980 pub buffer_enqueue_to_single_next_fn: vlib_buffer_enqueue_to_single_next_fn_t,
3981 pub buffer_enqueue_to_single_next_with_aux_fn: vlib_buffer_enqueue_to_single_next_with_aux_fn_t,
3982 pub buffer_enqueue_to_thread_fn: vlib_buffer_enqueue_to_thread_fn_t,
3983 pub buffer_enqueue_to_thread_with_aux_fn: vlib_buffer_enqueue_to_thread_with_aux_fn_t,
3984}
3985unsafe extern "C" {
3986 pub static mut vlib_buffer_func_main: vlib_buffer_func_main_t;
3987}
3988unsafe extern "C" {
3989 pub fn vlib_buffer_length_in_chain_slow_path(
3990 vm: *mut vlib_main_t,
3991 b_first: *mut vlib_buffer_t,
3992 ) -> uword;
3993}
3994pub const vlib_buffer_known_state_t_VLIB_BUFFER_UNKNOWN: vlib_buffer_known_state_t = 0;
3995pub const vlib_buffer_known_state_t_VLIB_BUFFER_KNOWN_FREE: vlib_buffer_known_state_t = 1;
3996pub const vlib_buffer_known_state_t_VLIB_BUFFER_KNOWN_ALLOCATED: vlib_buffer_known_state_t = 2;
3997pub type vlib_buffer_known_state_t = ::std::os::raw::c_uint;
3998unsafe extern "C" {
3999 pub fn vlib_buffer_validate_alloc_free(
4000 vm: *mut vlib_main_t,
4001 buffers: *mut u32_,
4002 n_buffers: uword,
4003 expected_state: vlib_buffer_known_state_t,
4004 );
4005}
4006unsafe extern "C" {
4007 pub fn vlib_validate_buffer(
4008 vm: *mut vlib_main_t,
4009 buffer_index: u32_,
4010 follow_chain: uword,
4011 ) -> *mut u8_;
4012}
4013unsafe extern "C" {
4014 pub fn vlib_validate_buffers(
4015 vm: *mut vlib_main_t,
4016 buffers: *mut u32_,
4017 next_buffer_stride: uword,
4018 n_buffers: uword,
4019 known_state: vlib_buffer_known_state_t,
4020 follow_buffer_next: uword,
4021 ) -> *mut u8_;
4022}
4023unsafe extern "C" {
4024 pub fn vlib_buffer_add_data(
4025 vm: *mut vlib_main_t,
4026 buffer_index: *mut u32_,
4027 data: *mut ::std::os::raw::c_void,
4028 n_data_bytes: u32_,
4029 ) -> ::std::os::raw::c_int;
4030}
4031unsafe extern "C" {
4032 pub fn vlib_buffer_chain_append_data_with_alloc(
4033 vm: *mut vlib_main_t,
4034 first: *mut vlib_buffer_t,
4035 last: *mut *mut vlib_buffer_t,
4036 data: *mut ::std::os::raw::c_void,
4037 data_len: u16_,
4038 ) -> u16_;
4039}
4040unsafe extern "C" {
4041 pub fn vlib_buffer_chain_validate(vm: *mut vlib_main_t, first: *mut vlib_buffer_t);
4042}
4043unsafe extern "C" {
4044 pub fn format_vlib_buffer(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4045}
4046unsafe extern "C" {
4047 pub fn format_vlib_buffer_and_data(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4048}
4049unsafe extern "C" {
4050 pub fn format_vlib_buffer_contents(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4051}
4052unsafe extern "C" {
4053 pub fn format_vlib_buffer_no_chain(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4054}
4055#[repr(C)]
4056#[derive(Debug, Copy, Clone)]
4057pub struct vlib_packet_template_t {
4058 pub packet_data: *mut u8_,
4059 pub min_n_buffers_each_alloc: u32_,
4060 pub name: *mut u8_,
4061}
4062impl Default for vlib_packet_template_t {
4063 fn default() -> Self {
4064 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4065 unsafe {
4066 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4067 s.assume_init()
4068 }
4069 }
4070}
4071unsafe extern "C" {
4072 pub fn vlib_packet_template_init(
4073 vm: *mut vlib_main_t,
4074 t: *mut vlib_packet_template_t,
4075 packet_data: *mut ::std::os::raw::c_void,
4076 n_packet_data_bytes: uword,
4077 min_n_buffers_each_alloc: uword,
4078 fmt: *mut ::std::os::raw::c_char,
4079 ...
4080 );
4081}
4082unsafe extern "C" {
4083 pub fn vlib_packet_template_get_packet(
4084 vm: *mut vlib_main_t,
4085 t: *mut vlib_packet_template_t,
4086 bi_result: *mut u32_,
4087 ) -> *mut ::std::os::raw::c_void;
4088}
4089unsafe extern "C" {
4090 pub static mut vnet_trace_placeholder: *mut u8_;
4091}
4092unsafe extern "C" {
4093 pub fn vlib_add_handoff_trace(
4094 vm: *mut vlib_main_t,
4095 b: *mut vlib_buffer_t,
4096 ) -> ::std::os::raw::c_int;
4097}
4098unsafe extern "C" {
4099 pub fn vlib_add_trace(
4100 vm: *mut vlib_main_t,
4101 r: *mut vlib_node_runtime_t,
4102 b: *mut vlib_buffer_t,
4103 n_data_bytes: u32_,
4104 ) -> *mut ::std::os::raw::c_void;
4105}
4106unsafe extern "C" {
4107 pub fn trace_apply_filter(vm: *mut vlib_main_t);
4108}
4109unsafe extern "C" {
4110 pub fn vlib_trace_frame_buffers_only(
4111 vm: *mut vlib_main_t,
4112 node: *mut vlib_node_runtime_t,
4113 buffers: *mut u32_,
4114 n_buffers: uword,
4115 next_buffer_stride: uword,
4116 n_buffer_data_bytes_in_trace: uword,
4117 );
4118}
4119pub const VNET_BUFFER_F_L4_CHECKSUM_COMPUTED: _bindgen_ty_32 = -2147483648;
4120pub const VNET_BUFFER_F_L4_CHECKSUM_CORRECT: _bindgen_ty_32 = 1073741824;
4121pub const VNET_BUFFER_F_VLAN_2_DEEP: _bindgen_ty_32 = 536870912;
4122pub const VNET_BUFFER_F_VLAN_1_DEEP: _bindgen_ty_32 = 268435456;
4123pub const VNET_BUFFER_F_SPAN_CLONE: _bindgen_ty_32 = 134217728;
4124pub const VNET_BUFFER_F_LOOP_COUNTER_VALID: _bindgen_ty_32 = 67108864;
4125pub const VNET_BUFFER_F_LOCALLY_ORIGINATED: _bindgen_ty_32 = 33554432;
4126pub const VNET_BUFFER_F_IS_IP4: _bindgen_ty_32 = 16777216;
4127pub const VNET_BUFFER_F_IS_IP6: _bindgen_ty_32 = 8388608;
4128pub const VNET_BUFFER_F_OFFLOAD: _bindgen_ty_32 = 4194304;
4129pub const VNET_BUFFER_F_IS_NATED: _bindgen_ty_32 = 2097152;
4130pub const VNET_BUFFER_F_L2_HDR_OFFSET_VALID: _bindgen_ty_32 = 1048576;
4131pub const VNET_BUFFER_F_L3_HDR_OFFSET_VALID: _bindgen_ty_32 = 524288;
4132pub const VNET_BUFFER_F_L4_HDR_OFFSET_VALID: _bindgen_ty_32 = 262144;
4133pub const VNET_BUFFER_F_FLOW_REPORT: _bindgen_ty_32 = 131072;
4134pub const VNET_BUFFER_F_IS_DVR: _bindgen_ty_32 = 65536;
4135pub const VNET_BUFFER_F_QOS_DATA_VALID: _bindgen_ty_32 = 32768;
4136pub const VNET_BUFFER_F_GSO: _bindgen_ty_32 = 16384;
4137pub const VNET_BUFFER_F_AVAIL1: _bindgen_ty_32 = 8192;
4138pub const VNET_BUFFER_F_AVAIL2: _bindgen_ty_32 = 4096;
4139pub const VNET_BUFFER_F_AVAIL3: _bindgen_ty_32 = 2048;
4140pub const VNET_BUFFER_F_AVAIL4: _bindgen_ty_32 = 1024;
4141pub const VNET_BUFFER_F_AVAIL5: _bindgen_ty_32 = 512;
4142pub const VNET_BUFFER_F_AVAIL6: _bindgen_ty_32 = 256;
4143pub const VNET_BUFFER_F_AVAIL7: _bindgen_ty_32 = 128;
4144pub const VNET_BUFFER_F_AVAIL8: _bindgen_ty_32 = 64;
4145pub const VNET_BUFFER_F_AVAIL9: _bindgen_ty_32 = 32;
4146pub type _bindgen_ty_32 = ::std::os::raw::c_int;
4147pub const VNET_BUFFER_F_LOG2_L4_CHECKSUM_COMPUTED: _bindgen_ty_33 = 31;
4148pub const VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT: _bindgen_ty_33 = 30;
4149pub const VNET_BUFFER_F_LOG2_VLAN_2_DEEP: _bindgen_ty_33 = 29;
4150pub const VNET_BUFFER_F_LOG2_VLAN_1_DEEP: _bindgen_ty_33 = 28;
4151pub const VNET_BUFFER_F_LOG2_SPAN_CLONE: _bindgen_ty_33 = 27;
4152pub const VNET_BUFFER_F_LOG2_LOOP_COUNTER_VALID: _bindgen_ty_33 = 26;
4153pub const VNET_BUFFER_F_LOG2_LOCALLY_ORIGINATED: _bindgen_ty_33 = 25;
4154pub const VNET_BUFFER_F_LOG2_IS_IP4: _bindgen_ty_33 = 24;
4155pub const VNET_BUFFER_F_LOG2_IS_IP6: _bindgen_ty_33 = 23;
4156pub const VNET_BUFFER_F_LOG2_OFFLOAD: _bindgen_ty_33 = 22;
4157pub const VNET_BUFFER_F_LOG2_IS_NATED: _bindgen_ty_33 = 21;
4158pub const VNET_BUFFER_F_LOG2_L2_HDR_OFFSET_VALID: _bindgen_ty_33 = 20;
4159pub const VNET_BUFFER_F_LOG2_L3_HDR_OFFSET_VALID: _bindgen_ty_33 = 19;
4160pub const VNET_BUFFER_F_LOG2_L4_HDR_OFFSET_VALID: _bindgen_ty_33 = 18;
4161pub const VNET_BUFFER_F_LOG2_FLOW_REPORT: _bindgen_ty_33 = 17;
4162pub const VNET_BUFFER_F_LOG2_IS_DVR: _bindgen_ty_33 = 16;
4163pub const VNET_BUFFER_F_LOG2_QOS_DATA_VALID: _bindgen_ty_33 = 15;
4164pub const VNET_BUFFER_F_LOG2_GSO: _bindgen_ty_33 = 14;
4165pub const VNET_BUFFER_F_LOG2_AVAIL1: _bindgen_ty_33 = 13;
4166pub const VNET_BUFFER_F_LOG2_AVAIL2: _bindgen_ty_33 = 12;
4167pub const VNET_BUFFER_F_LOG2_AVAIL3: _bindgen_ty_33 = 11;
4168pub const VNET_BUFFER_F_LOG2_AVAIL4: _bindgen_ty_33 = 10;
4169pub const VNET_BUFFER_F_LOG2_AVAIL5: _bindgen_ty_33 = 9;
4170pub const VNET_BUFFER_F_LOG2_AVAIL6: _bindgen_ty_33 = 8;
4171pub const VNET_BUFFER_F_LOG2_AVAIL7: _bindgen_ty_33 = 7;
4172pub const VNET_BUFFER_F_LOG2_AVAIL8: _bindgen_ty_33 = 6;
4173pub const VNET_BUFFER_F_LOG2_AVAIL9: _bindgen_ty_33 = 5;
4174pub type _bindgen_ty_33 = ::std::os::raw::c_uint;
4175pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_IP_CKSUM: vnet_buffer_oflags_t = 1;
4176pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_TCP_CKSUM: vnet_buffer_oflags_t = 2;
4177pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_UDP_CKSUM: vnet_buffer_oflags_t = 4;
4178pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_OUTER_IP_CKSUM: vnet_buffer_oflags_t = 8;
4179pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_OUTER_UDP_CKSUM: vnet_buffer_oflags_t = 16;
4180pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_TNL_VXLAN: vnet_buffer_oflags_t = 32;
4181pub const vnet_buffer_oflags_t_VNET_BUFFER_OFFLOAD_F_TNL_IPIP: vnet_buffer_oflags_t = 64;
4182pub type vnet_buffer_oflags_t = ::std::os::raw::c_uint;
4183#[repr(C)]
4184#[derive(Copy, Clone)]
4185pub struct vnet_buffer_opaque_t {
4186 pub sw_if_index: [u32_; 2usize],
4187 pub l2_hdr_offset: i16_,
4188 pub l3_hdr_offset: i16_,
4189 pub l4_hdr_offset: i16_,
4190 pub feature_arc_index: u8_,
4191 pub _bitfield_align_1: [u8; 0],
4192 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4193 pub __bindgen_anon_1: vnet_buffer_opaque_t__bindgen_ty_1,
4194}
4195#[repr(C)]
4196#[derive(Copy, Clone)]
4197pub union vnet_buffer_opaque_t__bindgen_ty_1 {
4198 pub ip: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1,
4199 pub mpls: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_2,
4200 pub l2: vnet_buffer_opaque_t__bindgen_ty_1_opaque_l2,
4201 pub l2t: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_3,
4202 pub l2_classify: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_4,
4203 pub policer: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_5,
4204 pub ipsec: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_6,
4205 pub map: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_7,
4206 pub map_t: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_8,
4207 pub ip_frag: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_9,
4208 pub cop: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_10,
4209 pub lisp: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_11,
4210 pub tcp: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_12,
4211 pub udp: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13,
4212 pub snat: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_14,
4213 pub unused: [u32_; 6usize],
4214}
4215#[repr(C)]
4216#[derive(Copy, Clone)]
4217pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1 {
4218 pub adj_index: [u32_; 2usize],
4219 pub __bindgen_anon_1: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
4220}
4221#[repr(C)]
4222#[derive(Copy, Clone)]
4223pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
4224 pub __bindgen_anon_1:
4225 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
4226 pub icmp: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
4227 pub reass: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3,
4228}
4229#[repr(C)]
4230#[derive(Copy, Clone)]
4231pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
4232 pub flow_hash: u32_,
4233 pub __bindgen_anon_1:
4234 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
4235 pub save_rewrite_length: u8_,
4236 pub __bindgen_anon_2:
4237 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
4238}
4239#[repr(C)]
4240#[derive(Copy, Clone)]
4241pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
4242{
4243 pub save_protocol: u32_,
4244 pub fib_index: u32_,
4245}
4246impl Default
4247 for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
4248{
4249 fn default() -> Self {
4250 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4251 unsafe {
4252 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4253 s.assume_init()
4254 }
4255 }
4256}
4257#[repr(C)]
4258#[derive(Copy, Clone)]
4259pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2
4260{
4261 pub rx_sw_if_index: u32_,
4262 pub rpf_id: u32_,
4263}
4264impl Default
4265 for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2
4266{
4267 fn default() -> Self {
4268 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4269 unsafe {
4270 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4271 s.assume_init()
4272 }
4273 }
4274}
4275impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
4276 fn default() -> Self {
4277 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4278 unsafe {
4279 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4280 s.assume_init()
4281 }
4282 }
4283}
4284#[repr(C)]
4285#[derive(Debug, Default, Copy, Clone)]
4286pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 {
4287 pub type_: u8_,
4288 pub code: u8_,
4289 pub data: u32_,
4290}
4291#[repr(C)]
4292#[derive(Copy, Clone)]
4293pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3 {
4294 pub __bindgen_anon_1:
4295 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1,
4296 pub __bindgen_anon_2:
4297 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2,
4298 pub __bindgen_anon_3:
4299 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_3,
4300}
4301#[repr(C)]
4302#[derive(Debug, Default, Copy, Clone)]
4303pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1
4304{
4305 pub next_index: u32_,
4306 pub error_next_index: u32_,
4307 pub _save_rewrite_length: u8_,
4308 pub owner_thread_index: u16_,
4309}
4310#[repr(C)]
4311#[derive(Copy, Clone)]
4312pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2 { pub __bindgen_anon_1 : vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1 , }
4313#[repr(C)]
4314#[derive(Copy, Clone)]
4315pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1 { pub __bindgen_anon_1 : vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 , pub __bindgen_anon_2 : vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2 , }
4316#[repr(C)]
4317#[derive(Debug, Default, Copy, Clone)]
4318pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1
4319{
4320 pub l4_src_port: u16_,
4321 pub l4_dst_port: u16_,
4322 pub tcp_ack_number: u32_,
4323 pub save_rewrite_length: u8_,
4324 pub ip_proto: u8_,
4325 pub icmp_type_or_tcp_flags: u8_,
4326 pub _bitfield_align_1: [u8; 0],
4327 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4328 pub tcp_seq_number: u32_,
4329}
4330impl vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 { # [inline] pub fn is_non_first_fragment (& self) -> u8_ { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (0usize , 1u8) as u8) } } # [inline] pub fn set_is_non_first_fragment (& mut self , val : u8_) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_1 . set (0usize , 1u8 , val as u64) } } # [inline] pub unsafe fn is_non_first_fragment_raw (this : * const Self) -> u8_ { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_is_non_first_fragment_raw (this : * mut Self , val : u8_) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 0usize , 1u8 , val as u64 ,) } } # [inline] pub fn l4_hdr_truncated (& self) -> u8_ { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (1usize , 1u8) as u8) } } # [inline] pub fn set_l4_hdr_truncated (& mut self , val : u8_) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_1 . set (1usize , 1u8 , val as u64) } } # [inline] pub unsafe fn l4_hdr_truncated_raw (this : * const Self) -> u8_ { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 1usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_l4_hdr_truncated_raw (this : * mut Self , val : u8_) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 1usize , 1u8 , val as u64 ,) } } # [inline] pub fn unused (& self) -> u8_ { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (2usize , 6u8) as u8) } } # [inline] pub fn set_unused (& mut self , val : u8_) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_1 . set (2usize , 6u8 , val as u64) } } # [inline] pub unsafe fn unused_raw (this : * const Self) -> u8_ { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 2usize , 6u8 ,) as u8) } } # [inline] pub unsafe fn set_unused_raw (this : * mut Self , val : u8_) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 2usize , 6u8 , val as u64 ,) } } # [inline] pub fn new_bitfield_1 (is_non_first_fragment : u8_ , l4_hdr_truncated : u8_ , unused : u8_) -> __BindgenBitfieldUnit < [u8 ; 1usize] > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [u8 ; 1usize] > = Default :: default () ; __bindgen_bitfield_unit . set (0usize , 1u8 , { let is_non_first_fragment : u8 = unsafe { :: std :: mem :: transmute (is_non_first_fragment) } ; is_non_first_fragment as u64 }) ; __bindgen_bitfield_unit . set (1usize , 1u8 , { let l4_hdr_truncated : u8 = unsafe { :: std :: mem :: transmute (l4_hdr_truncated) } ; l4_hdr_truncated as u64 }) ; __bindgen_bitfield_unit . set (2usize , 6u8 , { let unused : u8 = unsafe { :: std :: mem :: transmute (unused) } ; unused as u64 }) ; __bindgen_bitfield_unit } }
4331#[repr(C)]
4332#[derive(Debug, Default, Copy, Clone)]
4333pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2
4334{
4335 pub estimated_mtu: u16_,
4336}
4337impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2__bindgen_ty_1 { fn default () -> Self { let mut s = :: std :: mem :: MaybeUninit :: < Self > :: uninit () ; unsafe { :: std :: ptr :: write_bytes (s . as_mut_ptr () , 0 , 1) ; s . assume_init () } } }
4338impl Default
4339 for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_2
4340{
4341 fn default() -> Self {
4342 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4343 unsafe {
4344 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4345 s.assume_init()
4346 }
4347 }
4348}
4349#[repr(C)]
4350#[derive(Debug, Default, Copy, Clone)]
4351pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_3
4352{
4353 pub fragment_first: u16_,
4354 pub fragment_last: u16_,
4355 pub range_first: u16_,
4356 pub range_last: u16_,
4357 pub next_range_bi: u32_,
4358 pub ip6_frag_hdr_offset: u16_,
4359}
4360impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3 {
4361 fn default() -> Self {
4362 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4363 unsafe {
4364 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4365 s.assume_init()
4366 }
4367 }
4368}
4369impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
4370 fn default() -> Self {
4371 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4372 unsafe {
4373 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4374 s.assume_init()
4375 }
4376 }
4377}
4378impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_1 {
4379 fn default() -> Self {
4380 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4381 unsafe {
4382 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4383 s.assume_init()
4384 }
4385 }
4386}
4387#[repr(C)]
4388#[derive(Debug, Default, Copy, Clone)]
4389pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_2 {
4390 pub pad: [u32_; 3usize],
4391 pub ttl: u8_,
4392 pub exp: u8_,
4393 pub first: u8_,
4394 pub _bitfield_align_1: [u8; 0],
4395 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4396 pub save_rewrite_length: u8_,
4397 pub mpls_hdr_length: u8_,
4398 pub bier: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
4399}
4400#[repr(C)]
4401#[derive(Debug, Default, Copy, Clone)]
4402pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
4403 pub n_bytes: u8_,
4404}
4405impl vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_2 {
4406 #[inline]
4407 pub fn pyld_proto(&self) -> u8_ {
4408 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) }
4409 }
4410 #[inline]
4411 pub fn set_pyld_proto(&mut self, val: u8_) {
4412 unsafe {
4413 let val: u8 = ::std::mem::transmute(val);
4414 self._bitfield_1.set(0usize, 3u8, val as u64)
4415 }
4416 }
4417 #[inline]
4418 pub unsafe fn pyld_proto_raw(this: *const Self) -> u8_ {
4419 unsafe {
4420 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4421 ::std::ptr::addr_of!((*this)._bitfield_1),
4422 0usize,
4423 3u8,
4424 ) as u8)
4425 }
4426 }
4427 #[inline]
4428 pub unsafe fn set_pyld_proto_raw(this: *mut Self, val: u8_) {
4429 unsafe {
4430 let val: u8 = ::std::mem::transmute(val);
4431 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4432 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4433 0usize,
4434 3u8,
4435 val as u64,
4436 )
4437 }
4438 }
4439 #[inline]
4440 pub fn rsvd(&self) -> u8_ {
4441 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 5u8) as u8) }
4442 }
4443 #[inline]
4444 pub fn set_rsvd(&mut self, val: u8_) {
4445 unsafe {
4446 let val: u8 = ::std::mem::transmute(val);
4447 self._bitfield_1.set(3usize, 5u8, val as u64)
4448 }
4449 }
4450 #[inline]
4451 pub unsafe fn rsvd_raw(this: *const Self) -> u8_ {
4452 unsafe {
4453 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4454 ::std::ptr::addr_of!((*this)._bitfield_1),
4455 3usize,
4456 5u8,
4457 ) as u8)
4458 }
4459 }
4460 #[inline]
4461 pub unsafe fn set_rsvd_raw(this: *mut Self, val: u8_) {
4462 unsafe {
4463 let val: u8 = ::std::mem::transmute(val);
4464 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4465 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4466 3usize,
4467 5u8,
4468 val as u64,
4469 )
4470 }
4471 }
4472 #[inline]
4473 pub fn new_bitfield_1(pyld_proto: u8_, rsvd: u8_) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4474 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4475 __bindgen_bitfield_unit.set(0usize, 3u8, {
4476 let pyld_proto: u8 = unsafe { ::std::mem::transmute(pyld_proto) };
4477 pyld_proto as u64
4478 });
4479 __bindgen_bitfield_unit.set(3usize, 5u8, {
4480 let rsvd: u8 = unsafe { ::std::mem::transmute(rsvd) };
4481 rsvd as u64
4482 });
4483 __bindgen_bitfield_unit
4484 }
4485}
4486#[repr(C)]
4487#[derive(Debug, Default, Copy, Clone)]
4488pub struct vnet_buffer_opaque_t__bindgen_ty_1_opaque_l2 {
4489 pub feature_bitmap: u32_,
4490 pub bd_index: u16_,
4491 pub l2fib_sn: u16_,
4492 pub l2_len: u8_,
4493 pub shg: u8_,
4494 pub bd_age: u8_,
4495}
4496#[repr(C)]
4497#[derive(Debug, Default, Copy, Clone)]
4498pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_3 {
4499 pub pad: [u32_; 4usize],
4500 pub next_index: u8_,
4501 pub session_index: u32_,
4502}
4503#[repr(C)]
4504#[derive(Copy, Clone)]
4505pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_4 {
4506 pub pad: [u32_; 4usize],
4507 pub __bindgen_anon_1: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1,
4508 pub hash: u32_,
4509}
4510#[repr(C)]
4511#[derive(Copy, Clone)]
4512pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1 {
4513 pub table_index: u32_,
4514 pub opaque_index: u32_,
4515}
4516impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1 {
4517 fn default() -> Self {
4518 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4519 unsafe {
4520 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4521 s.assume_init()
4522 }
4523 }
4524}
4525impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_4 {
4526 fn default() -> Self {
4527 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4528 unsafe {
4529 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4530 s.assume_init()
4531 }
4532 }
4533}
4534#[repr(C)]
4535#[derive(Debug, Default, Copy, Clone)]
4536pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_5 {
4537 pub pad: [u32_; 5usize],
4538 pub index: u32_,
4539}
4540#[repr(C)]
4541#[derive(Debug, Default, Copy, Clone)]
4542pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_6 {
4543 pub __pad: [u32_; 3usize],
4544 pub sad_index: u32_,
4545 pub protect_index: u32_,
4546 pub thread_index: clib_thread_index_t,
4547}
4548#[repr(C)]
4549#[derive(Debug, Default, Copy, Clone)]
4550pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_7 {
4551 pub mtu: u16_,
4552}
4553#[repr(C)]
4554#[derive(Debug, Default, Copy, Clone)]
4555pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_8 {
4556 pub map_domain_index: u32_,
4557 pub v6: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4558 pub checksum_offset: u16_,
4559 pub mtu: u16_,
4560}
4561#[repr(C)]
4562#[derive(Debug, Default, Copy, Clone)]
4563pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
4564 pub saddr: u32_,
4565 pub daddr: u32_,
4566 pub frag_offset: u16_,
4567 pub l4_offset: u16_,
4568 pub l4_protocol: u8_,
4569}
4570#[repr(C)]
4571#[derive(Debug, Default, Copy, Clone)]
4572pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_9 {
4573 pub pad: [u32_; 2usize],
4574 pub mtu: u16_,
4575 pub next_index: u8_,
4576 pub flags: u8_,
4577}
4578#[repr(C)]
4579#[derive(Debug, Default, Copy, Clone)]
4580pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_10 {
4581 pub current_config_index: u32_,
4582}
4583#[repr(C)]
4584#[derive(Debug, Default, Copy, Clone)]
4585pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_11 {
4586 pub overlay_afi: u16_,
4587}
4588#[repr(C)]
4589#[derive(Copy, Clone)]
4590pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_12 {
4591 pub connection_index: u32_,
4592 pub __bindgen_anon_1: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1,
4593 pub seq_end: u32_,
4594 pub ack_number: u32_,
4595 pub hdr_offset: u16_,
4596 pub data_offset: u16_,
4597 pub data_len: u16_,
4598 pub flags: u8_,
4599}
4600#[repr(C)]
4601#[derive(Copy, Clone)]
4602pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1 {
4603 pub seq_number: u32_,
4604 pub next_node_opaque: u32_,
4605}
4606impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1 {
4607 fn default() -> Self {
4608 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4609 unsafe {
4610 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4611 s.assume_init()
4612 }
4613 }
4614}
4615impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_12 {
4616 fn default() -> Self {
4617 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4618 unsafe {
4619 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4620 s.assume_init()
4621 }
4622 }
4623}
4624#[repr(C)]
4625#[derive(Copy, Clone)]
4626pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13 {
4627 pub __bindgen_anon_1: vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13__bindgen_ty_1,
4628}
4629#[repr(C)]
4630#[derive(Copy, Clone)]
4631pub union vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13__bindgen_ty_1 {
4632 pub __bindgen_anon_1:
4633 vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13__bindgen_ty_1__bindgen_ty_1,
4634 pub session_handle: u64_,
4635}
4636#[repr(C)]
4637#[derive(Debug, Default, Copy, Clone)]
4638pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13__bindgen_ty_1__bindgen_ty_1 {
4639 pub session_index: u32_,
4640 pub thread_index: clib_thread_index_t,
4641}
4642impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13__bindgen_ty_1 {
4643 fn default() -> Self {
4644 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4645 unsafe {
4646 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4647 s.assume_init()
4648 }
4649 }
4650}
4651impl Default for vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_13 {
4652 fn default() -> Self {
4653 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4654 unsafe {
4655 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4656 s.assume_init()
4657 }
4658 }
4659}
4660#[repr(C)]
4661#[derive(Debug, Default, Copy, Clone)]
4662pub struct vnet_buffer_opaque_t__bindgen_ty_1__bindgen_ty_14 {
4663 pub flags: u32_,
4664 pub required_thread_index: u32_,
4665}
4666impl Default for vnet_buffer_opaque_t__bindgen_ty_1 {
4667 fn default() -> Self {
4668 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4669 unsafe {
4670 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4671 s.assume_init()
4672 }
4673 }
4674}
4675impl Default for vnet_buffer_opaque_t {
4676 fn default() -> Self {
4677 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4678 unsafe {
4679 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4680 s.assume_init()
4681 }
4682 }
4683}
4684impl vnet_buffer_opaque_t {
4685 #[inline]
4686 pub fn oflags(&self) -> vnet_buffer_oflags_t {
4687 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
4688 }
4689 #[inline]
4690 pub fn set_oflags(&mut self, val: vnet_buffer_oflags_t) {
4691 unsafe {
4692 let val: u32 = ::std::mem::transmute(val);
4693 self._bitfield_1.set(0usize, 8u8, val as u64)
4694 }
4695 }
4696 #[inline]
4697 pub unsafe fn oflags_raw(this: *const Self) -> vnet_buffer_oflags_t {
4698 unsafe {
4699 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4700 ::std::ptr::addr_of!((*this)._bitfield_1),
4701 0usize,
4702 8u8,
4703 ) as u32)
4704 }
4705 }
4706 #[inline]
4707 pub unsafe fn set_oflags_raw(this: *mut Self, val: vnet_buffer_oflags_t) {
4708 unsafe {
4709 let val: u32 = ::std::mem::transmute(val);
4710 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4711 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4712 0usize,
4713 8u8,
4714 val as u64,
4715 )
4716 }
4717 }
4718 #[inline]
4719 pub fn new_bitfield_1(oflags: vnet_buffer_oflags_t) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4720 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4721 __bindgen_bitfield_unit.set(0usize, 8u8, {
4722 let oflags: u32 = unsafe { ::std::mem::transmute(oflags) };
4723 oflags as u64
4724 });
4725 __bindgen_bitfield_unit
4726 }
4727}
4728#[repr(C)]
4729#[derive(Copy, Clone)]
4730pub struct vnet_buffer_opaque2_t {
4731 pub qos: vnet_buffer_opaque2_t__bindgen_ty_1,
4732 pub loop_counter: u8_,
4733 pub pad: [u8_; 5usize],
4734 pub __bindgen_anon_1: vnet_buffer_opaque2_t__bindgen_ty_2,
4735 pub nat: vnet_buffer_opaque2_t__bindgen_ty_3,
4736 pub ip: vnet_buffer_opaque2_t__bindgen_ty_4,
4737 pub unused: [u32_; 5usize],
4738}
4739#[repr(C)]
4740#[derive(Debug, Default, Copy, Clone)]
4741pub struct vnet_buffer_opaque2_t__bindgen_ty_1 {
4742 pub bits: u8_,
4743 pub source: u8_,
4744}
4745#[repr(C)]
4746#[derive(Debug, Default, Copy, Clone)]
4747pub struct vnet_buffer_opaque2_t__bindgen_ty_2 {
4748 pub gso_size: u16_,
4749 pub gso_l4_hdr_sz: u16_,
4750 pub outer_l3_hdr_offset: i16_,
4751 pub outer_l4_hdr_offset: i16_,
4752}
4753#[repr(C)]
4754#[derive(Copy, Clone)]
4755pub struct vnet_buffer_opaque2_t__bindgen_ty_3 {
4756 pub arc_next: u32_,
4757 pub __bindgen_anon_1: vnet_buffer_opaque2_t__bindgen_ty_3__bindgen_ty_1,
4758}
4759#[repr(C)]
4760#[derive(Copy, Clone)]
4761pub union vnet_buffer_opaque2_t__bindgen_ty_3__bindgen_ty_1 {
4762 pub cached_session_index: u32_,
4763 pub cached_dst_nat_session_index: u32_,
4764}
4765impl Default for vnet_buffer_opaque2_t__bindgen_ty_3__bindgen_ty_1 {
4766 fn default() -> Self {
4767 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4768 unsafe {
4769 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4770 s.assume_init()
4771 }
4772 }
4773}
4774impl Default for vnet_buffer_opaque2_t__bindgen_ty_3 {
4775 fn default() -> Self {
4776 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4777 unsafe {
4778 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4779 s.assume_init()
4780 }
4781 }
4782}
4783#[repr(C)]
4784#[derive(Debug, Default, Copy, Clone)]
4785pub struct vnet_buffer_opaque2_t__bindgen_ty_4 {
4786 pub reass: vnet_buffer_opaque2_t__bindgen_ty_4__bindgen_ty_1,
4787}
4788#[repr(C)]
4789#[derive(Debug, Default, Copy, Clone)]
4790pub struct vnet_buffer_opaque2_t__bindgen_ty_4__bindgen_ty_1 {
4791 pub thread_index: clib_thread_index_t,
4792 pub pool_index: u32_,
4793 pub id: u32_,
4794}
4795impl Default for vnet_buffer_opaque2_t {
4796 fn default() -> Self {
4797 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4798 unsafe {
4799 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4800 s.assume_init()
4801 }
4802 }
4803}
4804unsafe extern "C" {
4805 pub fn format_vnet_buffer_no_chain(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4806}
4807unsafe extern "C" {
4808 pub fn format_vnet_buffer(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4809}
4810unsafe extern "C" {
4811 pub fn format_vnet_buffer_offload(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4812}
4813unsafe extern "C" {
4814 pub fn format_vnet_buffer_flags(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4815}
4816unsafe extern "C" {
4817 pub fn format_vnet_buffer_opaque(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4818}
4819unsafe extern "C" {
4820 pub fn format_vnet_buffer_opaque2(s: *mut u8_, args: *mut va_list) -> *mut u8_;
4821}
4822#[repr(C)]
4823#[derive(Debug, Copy, Clone)]
4824pub struct vnet_config_feature_t {
4825 pub feature_index: u32_,
4826 pub node_index: u32_,
4827 pub next_index: u32_,
4828 pub feature_config: *mut u32_,
4829}
4830impl Default for vnet_config_feature_t {
4831 fn default() -> Self {
4832 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4833 unsafe {
4834 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4835 s.assume_init()
4836 }
4837 }
4838}
4839#[repr(C)]
4840#[derive(Debug, Copy, Clone)]
4841pub struct vnet_config_t {
4842 pub features: *mut vnet_config_feature_t,
4843 pub config_string_vector: *mut u32_,
4844 pub config_string_heap_index: u32_,
4845 pub config_string_heap_handle: u32_,
4846 pub index: u32_,
4847 pub reference_count: u32_,
4848}
4849impl Default for vnet_config_t {
4850 fn default() -> Self {
4851 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4852 unsafe {
4853 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4854 s.assume_init()
4855 }
4856 }
4857}
4858#[repr(C)]
4859#[derive(Debug, Copy, Clone)]
4860pub struct vnet_config_main_t {
4861 pub config_pool: *mut vnet_config_t,
4862 pub config_string_hash: *mut uword,
4863 pub config_string_heap: *mut u32_,
4864 pub start_node_indices: *mut u32_,
4865 pub end_node_indices_by_user_index: *mut u32_,
4866 pub default_end_node_index: u32_,
4867 pub node_index_by_feature_index: *mut u32_,
4868 pub config_pool_index_by_user_index: *mut u32_,
4869 pub config_string_temp: *mut u32_,
4870}
4871impl Default for vnet_config_main_t {
4872 fn default() -> Self {
4873 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4874 unsafe {
4875 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4876 s.assume_init()
4877 }
4878 }
4879}
4880pub const vnet_hash_fn_type_t_VNET_HASH_FN_TYPE_ETHERNET: vnet_hash_fn_type_t = 0;
4881pub const vnet_hash_fn_type_t_VNET_HASH_FN_TYPE_IP4: vnet_hash_fn_type_t = 1;
4882pub const vnet_hash_fn_type_t_VNET_HASH_FN_TYPE_IP6: vnet_hash_fn_type_t = 2;
4883pub const vnet_hash_fn_type_t_VNET_HASH_FN_TYPE_IP: vnet_hash_fn_type_t = 3;
4884pub const vnet_hash_fn_type_t_VNET_HASH_FN_TYPE_N: vnet_hash_fn_type_t = 4;
4885pub type vnet_hash_fn_type_t = ::std::os::raw::c_uint;
4886pub type vnet_hash_fn_t = ::std::option::Option<
4887 unsafe extern "C" fn(p: *mut *mut ::std::os::raw::c_void, h: *mut u32_, n_packets: u32_),
4888>;
4889#[repr(C)]
4890#[derive(Copy, Clone)]
4891pub struct ip46_address_t_ {
4892 _unused: [u8; 0],
4893}
4894pub const vnet_hw_if_rx_mode_VNET_HW_IF_RX_MODE_UNKNOWN: vnet_hw_if_rx_mode = 0;
4895pub const vnet_hw_if_rx_mode_VNET_HW_IF_RX_MODE_POLLING: vnet_hw_if_rx_mode = 1;
4896pub const vnet_hw_if_rx_mode_VNET_HW_IF_RX_MODE_INTERRUPT: vnet_hw_if_rx_mode = 2;
4897pub const vnet_hw_if_rx_mode_VNET_HW_IF_RX_MODE_ADAPTIVE: vnet_hw_if_rx_mode = 3;
4898pub const vnet_hw_if_rx_mode_VNET_HW_IF_RX_MODE_DEFAULT: vnet_hw_if_rx_mode = 4;
4899pub const vnet_hw_if_rx_mode_VNET_HW_IF_NUM_RX_MODES: vnet_hw_if_rx_mode = 5;
4900pub type vnet_hw_if_rx_mode = ::std::os::raw::c_uint;
4901pub type vnet_interface_function_t = ::std::option::Option<
4902 unsafe extern "C" fn(vnm: *mut vnet_main_t, if_index: u32_, flags: u32_) -> *mut clib_error_t,
4903>;
4904pub type vnet_subif_add_del_function_t = ::std::option::Option<
4905 unsafe extern "C" fn(
4906 vnm: *mut vnet_main_t,
4907 if_index: u32_,
4908 template: *mut vnet_sw_interface_t,
4909 is_add: ::std::os::raw::c_int,
4910 ) -> *mut clib_error_t,
4911>;
4912pub type vnet_interface_set_max_frame_size_function_t = ::std::option::Option<
4913 unsafe extern "C" fn(
4914 vnm: *mut vnet_main_t,
4915 hi: *mut vnet_hw_interface_t,
4916 mtu: u32_,
4917 ) -> *mut clib_error_t,
4918>;
4919pub type vnet_interface_set_mac_address_function_t = ::std::option::Option<
4920 unsafe extern "C" fn(
4921 hi: *mut vnet_hw_interface_t,
4922 old_address: *const u8_,
4923 new_address: *const u8_,
4924 ) -> *mut clib_error_t,
4925>;
4926pub type vnet_interface_add_del_mac_address_function_t = ::std::option::Option<
4927 unsafe extern "C" fn(
4928 hi: *mut vnet_hw_interface_t,
4929 address: *const u8_,
4930 is_add: u8_,
4931 ) -> *mut clib_error_t,
4932>;
4933pub type vnet_interface_set_rx_mode_function_t = ::std::option::Option<
4934 unsafe extern "C" fn(
4935 vnm: *mut vnet_main_t,
4936 if_index: u32_,
4937 queue_id: u32_,
4938 mode: vnet_hw_if_rx_mode,
4939 ) -> *mut clib_error_t,
4940>;
4941pub type vnet_interface_set_l2_mode_function_t = ::std::option::Option<
4942 unsafe extern "C" fn(
4943 vnm: *mut vnet_main_t,
4944 hi: *mut vnet_hw_interface_t,
4945 l2_if_adjust: i32_,
4946 ) -> *mut clib_error_t,
4947>;
4948pub type vnet_interface_rss_queues_set_t = ::std::option::Option<
4949 unsafe extern "C" fn(
4950 vnm: *mut vnet_main_t,
4951 hi: *mut vnet_hw_interface_t,
4952 bitmap: *mut clib_bitmap_t,
4953 ) -> *mut clib_error_t,
4954>;
4955pub const vnet_interface_eeprom_type_t_VNET_INTERFACE_EEPROM_TYPE_UNKNOWN:
4956 vnet_interface_eeprom_type_t = 0;
4957pub const vnet_interface_eeprom_type_t_VNET_INTERFACE_EEPROM_TYPE_SFF8079:
4958 vnet_interface_eeprom_type_t = 1;
4959pub const vnet_interface_eeprom_type_t_VNET_INTERFACE_EEPROM_TYPE_SFF8472:
4960 vnet_interface_eeprom_type_t = 2;
4961pub const vnet_interface_eeprom_type_t_VNET_INTERFACE_EEPROM_TYPE_SFF8636:
4962 vnet_interface_eeprom_type_t = 3;
4963pub const vnet_interface_eeprom_type_t_VNET_INTERFACE_EEPROM_TYPE_SFF8436:
4964 vnet_interface_eeprom_type_t = 4;
4965pub type vnet_interface_eeprom_type_t = ::std::os::raw::c_uint;
4966#[repr(C)]
4967#[derive(Debug, Copy, Clone)]
4968pub struct vnet_interface_eeprom_t {
4969 pub eeprom_type: vnet_interface_eeprom_type_t,
4970 pub eeprom_len: u32_,
4971 pub eeprom_raw: [u8_; 1024usize],
4972}
4973impl Default for vnet_interface_eeprom_t {
4974 fn default() -> Self {
4975 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4976 unsafe {
4977 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4978 s.assume_init()
4979 }
4980 }
4981}
4982pub type vnet_interface_eeprom_read_t = ::std::option::Option<
4983 unsafe extern "C" fn(
4984 vnm: *mut vnet_main_t,
4985 hi: *mut vnet_hw_interface_t,
4986 eeprom: *mut *mut vnet_interface_eeprom_t,
4987 ) -> *mut clib_error_t,
4988>;
4989pub const vnet_flow_dev_op_t_VNET_FLOW_DEV_OP_ADD_FLOW: vnet_flow_dev_op_t = 0;
4990pub const vnet_flow_dev_op_t_VNET_FLOW_DEV_OP_DEL_FLOW: vnet_flow_dev_op_t = 1;
4991pub const vnet_flow_dev_op_t_VNET_FLOW_DEV_OP_GET_COUNTER: vnet_flow_dev_op_t = 2;
4992pub const vnet_flow_dev_op_t_VNET_FLOW_DEV_OP_RESET_COUNTER: vnet_flow_dev_op_t = 3;
4993pub type vnet_flow_dev_op_t = ::std::os::raw::c_uint;
4994pub type vnet_flow_dev_ops_function_t = ::std::option::Option<
4995 unsafe extern "C" fn(
4996 vnm: *mut vnet_main_t,
4997 op: vnet_flow_dev_op_t,
4998 hw_if_index: u32_,
4999 index: u32_,
5000 private_data: *mut uword,
5001 ) -> ::std::os::raw::c_int,
5002>;
5003#[repr(C)]
5004#[derive(Debug, Copy, Clone)]
5005pub struct _vnet_interface_function_list_elt {
5006 pub next_interface_function: *mut _vnet_interface_function_list_elt,
5007 pub fp: ::std::option::Option<
5008 unsafe extern "C" fn(
5009 vnm: *mut vnet_main_t,
5010 if_index: u32_,
5011 flags: u32_,
5012 ) -> *mut clib_error_t,
5013 >,
5014}
5015impl Default for _vnet_interface_function_list_elt {
5016 fn default() -> Self {
5017 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5018 unsafe {
5019 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5020 s.assume_init()
5021 }
5022 }
5023}
5024pub type _vnet_interface_function_list_elt_t = _vnet_interface_function_list_elt;
5025pub type vnet_dev_class_ip_tunnel_desc_t = ::std::option::Option<
5026 unsafe extern "C" fn(
5027 sw_if_index: u32_,
5028 src: *mut ip46_address_t_,
5029 dst: *mut ip46_address_t_,
5030 is_l2: *mut u8_,
5031 ) -> ::std::os::raw::c_int,
5032>;
5033#[repr(C)]
5034#[derive(Debug, Copy, Clone)]
5035pub struct _vnet_device_class {
5036 pub index: u32_,
5037 pub name: *mut ::std::os::raw::c_char,
5038 pub interface_add_del_function: vnet_interface_function_t,
5039 pub admin_up_down_function: vnet_interface_function_t,
5040 pub subif_add_del_function: vnet_subif_add_del_function_t,
5041 pub rx_mode_change_function: vnet_interface_set_rx_mode_function_t,
5042 pub set_l2_mode_function: vnet_interface_set_l2_mode_function_t,
5043 pub redistribute: u32_,
5044 pub tx_function: vlib_node_function_t,
5045 pub tx_fn_registrations: *mut vlib_node_fn_registration_t,
5046 pub tx_function_error_strings: *mut *mut ::std::os::raw::c_char,
5047 pub tx_function_error_counters: *mut vlib_error_desc_t,
5048 pub tx_function_n_errors: u32_,
5049 pub name_renumber: ::std::option::Option<
5050 unsafe extern "C" fn(
5051 hi: *mut vnet_hw_interface_t,
5052 new_dev_instance: u32_,
5053 ) -> ::std::os::raw::c_int,
5054 >,
5055 pub flow_ops_function: vnet_flow_dev_ops_function_t,
5056 pub format_device_name: format_function_t,
5057 pub unformat_device_name: unformat_function_t,
5058 pub format_device: format_function_t,
5059 pub format_tx_trace: format_function_t,
5060 pub format_flow: format_function_t,
5061 pub ip_tun_desc: vnet_dev_class_ip_tunnel_desc_t,
5062 pub clear_counters: ::std::option::Option<unsafe extern "C" fn(dev_class_instance: u32_)>,
5063 pub is_valid_class_for_interface: ::std::option::Option<
5064 unsafe extern "C" fn(
5065 vnm: *mut vnet_main_t,
5066 hw_if_index: u32_,
5067 hw_class_index: u32_,
5068 ) -> uword,
5069 >,
5070 pub hw_class_change: ::std::option::Option<
5071 unsafe extern "C" fn(vnm: *mut vnet_main_t, hw_if_index: u32_, new_hw_class_index: u32_),
5072 >,
5073 pub rx_redirect_to_node: ::std::option::Option<
5074 unsafe extern "C" fn(vnm: *mut vnet_main_t, hw_if_index: u32_, node_index: u32_),
5075 >,
5076 pub next_class_registration: *mut _vnet_device_class,
5077 pub mac_addr_change_function: vnet_interface_set_mac_address_function_t,
5078 pub mac_addr_add_del_function: vnet_interface_add_del_mac_address_function_t,
5079 pub set_rss_queues_function: vnet_interface_rss_queues_set_t,
5080 pub eeprom_read_function: vnet_interface_eeprom_read_t,
5081}
5082impl Default for _vnet_device_class {
5083 fn default() -> Self {
5084 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5085 unsafe {
5086 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5087 s.assume_init()
5088 }
5089 }
5090}
5091pub type vnet_device_class_t = _vnet_device_class;
5092pub const vnet_link_t__VNET_LINK_IP4: vnet_link_t_ = 0;
5093pub const vnet_link_t__VNET_LINK_IP6: vnet_link_t_ = 1;
5094pub const vnet_link_t__VNET_LINK_MPLS: vnet_link_t_ = 2;
5095pub const vnet_link_t__VNET_LINK_ETHERNET: vnet_link_t_ = 3;
5096pub const vnet_link_t__VNET_LINK_ARP: vnet_link_t_ = 4;
5097pub const vnet_link_t__VNET_LINK_NSH: vnet_link_t_ = 5;
5098pub type vnet_link_t_ = ::std::os::raw::c_uchar;
5099pub use self::vnet_link_t_ as vnet_link_t;
5100pub const vnet_hw_interface_class_flags_t__VNET_HW_INTERFACE_CLASS_FLAG_P2P:
5101 vnet_hw_interface_class_flags_t_ = 1;
5102pub const vnet_hw_interface_class_flags_t__VNET_HW_INTERFACE_CLASS_FLAG_NBMA:
5103 vnet_hw_interface_class_flags_t_ = 2;
5104pub type vnet_hw_interface_class_flags_t_ = ::std::os::raw::c_uint;
5105pub use self::vnet_hw_interface_class_flags_t_ as vnet_hw_interface_class_flags_t;
5106#[repr(C)]
5107#[derive(Debug, Copy, Clone)]
5108pub struct _vnet_hw_interface_class {
5109 pub index: u32_,
5110 pub name: *mut ::std::os::raw::c_char,
5111 pub flags: vnet_hw_interface_class_flags_t,
5112 pub tx_hash_fn_type: vnet_hash_fn_type_t,
5113 pub interface_add_del_function: vnet_interface_function_t,
5114 pub admin_up_down_function: vnet_interface_function_t,
5115 pub link_up_down_function: vnet_interface_function_t,
5116 pub mac_addr_change_function: vnet_interface_set_mac_address_function_t,
5117 pub mac_addr_add_del_function: vnet_interface_add_del_mac_address_function_t,
5118 pub set_max_frame_size: vnet_interface_set_max_frame_size_function_t,
5119 pub format_interface_name: format_function_t,
5120 pub format_address: format_function_t,
5121 pub format_header: format_function_t,
5122 pub format_device: format_function_t,
5123 pub unformat_hw_address: unformat_function_t,
5124 pub unformat_header: unformat_function_t,
5125 pub build_rewrite: ::std::option::Option<
5126 unsafe extern "C" fn(
5127 vnm: *mut vnet_main_t,
5128 sw_if_index: u32_,
5129 link_type: vnet_link_t,
5130 dst_hw_address: *const ::std::os::raw::c_void,
5131 ) -> *mut u8_,
5132 >,
5133 pub update_adjacency: ::std::option::Option<
5134 unsafe extern "C" fn(vnm: *mut vnet_main_t, sw_if_index: u32_, adj_index: u32_),
5135 >,
5136 pub is_valid_class_for_interface: ::std::option::Option<
5137 unsafe extern "C" fn(
5138 vnm: *mut vnet_main_t,
5139 hw_if_index: u32_,
5140 hw_class_index: u32_,
5141 ) -> uword,
5142 >,
5143 pub hw_class_change: ::std::option::Option<
5144 unsafe extern "C" fn(
5145 vnm: *mut vnet_main_t,
5146 hw_if_index: u32_,
5147 old_class_index: u32_,
5148 new_class_index: u32_,
5149 ),
5150 >,
5151 pub next_class_registration: *mut _vnet_hw_interface_class,
5152}
5153impl Default for _vnet_hw_interface_class {
5154 fn default() -> Self {
5155 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5156 unsafe {
5157 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5158 s.assume_init()
5159 }
5160 }
5161}
5162pub type vnet_hw_interface_class_t = _vnet_hw_interface_class;
5163pub const vnet_hw_interface_flags_t__VNET_HW_INTERFACE_FLAG_NONE: vnet_hw_interface_flags_t_ = 0;
5164pub const vnet_hw_interface_flags_t__VNET_HW_INTERFACE_FLAG_LINK_UP: vnet_hw_interface_flags_t_ = 1;
5165pub const vnet_hw_interface_flags_t__VNET_HW_INTERFACE_FLAG_HALF_DUPLEX:
5166 vnet_hw_interface_flags_t_ = 2;
5167pub const vnet_hw_interface_flags_t__VNET_HW_INTERFACE_FLAG_FULL_DUPLEX:
5168 vnet_hw_interface_flags_t_ = 4;
5169pub const vnet_hw_interface_flags_t__VNET_HW_INTERFACE_FLAG_NBMA: vnet_hw_interface_flags_t_ =
5170 524288;
5171pub type vnet_hw_interface_flags_t_ = ::std::os::raw::c_uint;
5172pub use self::vnet_hw_interface_flags_t_ as vnet_hw_interface_flags_t;
5173pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_NONE: vnet_hw_if_caps_t_ = 0;
5174pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TX_IP4_CKSUM: vnet_hw_if_caps_t_ = 1;
5175pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TX_TCP_CKSUM: vnet_hw_if_caps_t_ = 2;
5176pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TX_UDP_CKSUM: vnet_hw_if_caps_t_ = 4;
5177pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TX_IP4_OUTER_CKSUM: vnet_hw_if_caps_t_ = 8;
5178pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TX_UDP_OUTER_CKSUM: vnet_hw_if_caps_t_ = 16;
5179pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_RX_IP4_CKSUM: vnet_hw_if_caps_t_ = 32;
5180pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_RX_TCP_CKSUM: vnet_hw_if_caps_t_ = 64;
5181pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_RX_UDP_CKSUM: vnet_hw_if_caps_t_ = 128;
5182pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_RX_IP4_OUTER_CKSUM: vnet_hw_if_caps_t_ = 256;
5183pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_RX_UDP_OUTER_CKSUM: vnet_hw_if_caps_t_ = 512;
5184pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TCP_GSO: vnet_hw_if_caps_t_ = 1024;
5185pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_UDP_GSO: vnet_hw_if_caps_t_ = 2048;
5186pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_VXLAN_TNL_GSO: vnet_hw_if_caps_t_ = 4096;
5187pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_IPIP_TNL_GSO: vnet_hw_if_caps_t_ = 8192;
5188pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_GENEVE_TNL_GSO: vnet_hw_if_caps_t_ = 16384;
5189pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_GRE_TNL_GSO: vnet_hw_if_caps_t_ = 32768;
5190pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_UDP_TNL_GSO: vnet_hw_if_caps_t_ = 65536;
5191pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_IP_TNL_GSO: vnet_hw_if_caps_t_ = 131072;
5192pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TCP_LRO: vnet_hw_if_caps_t_ = 262144;
5193pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_TX_FIXED_OFFSET: vnet_hw_if_caps_t_ = 524288;
5194pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_INT_MODE: vnet_hw_if_caps_t_ = 1073741824;
5195pub const vnet_hw_if_caps_t__VNET_HW_IF_CAP_MAC_FILTER: vnet_hw_if_caps_t_ = -2147483648;
5196pub type vnet_hw_if_caps_t_ = ::std::os::raw::c_int;
5197pub use self::vnet_hw_if_caps_t_ as vnet_hw_if_caps_t;
5198#[repr(C)]
5199#[derive(Debug, Copy, Clone)]
5200pub struct vnet_hw_if_rx_queue_t {
5201 pub hw_if_index: u32_,
5202 pub dev_instance: u32_,
5203 pub thread_index: clib_thread_index_t,
5204 pub file_index: u32_,
5205 pub queue_id: u32_,
5206 pub _bitfield_align_1: [u8; 0],
5207 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5208 pub __bindgen_padding_0: [u8; 3usize],
5209}
5210impl Default for vnet_hw_if_rx_queue_t {
5211 fn default() -> Self {
5212 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5213 unsafe {
5214 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5215 s.assume_init()
5216 }
5217 }
5218}
5219impl vnet_hw_if_rx_queue_t {
5220 #[inline]
5221 pub fn mode(&self) -> vnet_hw_if_rx_mode {
5222 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
5223 }
5224 #[inline]
5225 pub fn set_mode(&mut self, val: vnet_hw_if_rx_mode) {
5226 unsafe {
5227 let val: u32 = ::std::mem::transmute(val);
5228 self._bitfield_1.set(0usize, 8u8, val as u64)
5229 }
5230 }
5231 #[inline]
5232 pub unsafe fn mode_raw(this: *const Self) -> vnet_hw_if_rx_mode {
5233 unsafe {
5234 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5235 ::std::ptr::addr_of!((*this)._bitfield_1),
5236 0usize,
5237 8u8,
5238 ) as u32)
5239 }
5240 }
5241 #[inline]
5242 pub unsafe fn set_mode_raw(this: *mut Self, val: vnet_hw_if_rx_mode) {
5243 unsafe {
5244 let val: u32 = ::std::mem::transmute(val);
5245 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5246 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5247 0usize,
5248 8u8,
5249 val as u64,
5250 )
5251 }
5252 }
5253 #[inline]
5254 pub fn new_bitfield_1(mode: vnet_hw_if_rx_mode) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5255 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5256 __bindgen_bitfield_unit.set(0usize, 8u8, {
5257 let mode: u32 = unsafe { ::std::mem::transmute(mode) };
5258 mode as u64
5259 });
5260 __bindgen_bitfield_unit
5261 }
5262}
5263#[repr(C)]
5264#[derive(Debug, Copy, Clone)]
5265pub struct vnet_hw_if_tx_queue_t {
5266 pub _bitfield_align_1: [u8; 0],
5267 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5268 pub hw_if_index: u32_,
5269 pub queue_id: u32_,
5270 pub threads: *mut clib_bitmap_t,
5271}
5272impl Default for vnet_hw_if_tx_queue_t {
5273 fn default() -> Self {
5274 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5275 unsafe {
5276 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5277 s.assume_init()
5278 }
5279 }
5280}
5281impl vnet_hw_if_tx_queue_t {
5282 #[inline]
5283 pub fn shared_queue(&self) -> u8_ {
5284 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
5285 }
5286 #[inline]
5287 pub fn set_shared_queue(&mut self, val: u8_) {
5288 unsafe {
5289 let val: u8 = ::std::mem::transmute(val);
5290 self._bitfield_1.set(0usize, 1u8, val as u64)
5291 }
5292 }
5293 #[inline]
5294 pub unsafe fn shared_queue_raw(this: *const Self) -> u8_ {
5295 unsafe {
5296 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5297 ::std::ptr::addr_of!((*this)._bitfield_1),
5298 0usize,
5299 1u8,
5300 ) as u8)
5301 }
5302 }
5303 #[inline]
5304 pub unsafe fn set_shared_queue_raw(this: *mut Self, val: u8_) {
5305 unsafe {
5306 let val: u8 = ::std::mem::transmute(val);
5307 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5308 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5309 0usize,
5310 1u8,
5311 val as u64,
5312 )
5313 }
5314 }
5315 #[inline]
5316 pub fn new_bitfield_1(shared_queue: u8_) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5317 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5318 __bindgen_bitfield_unit.set(0usize, 1u8, {
5319 let shared_queue: u8 = unsafe { ::std::mem::transmute(shared_queue) };
5320 shared_queue as u64
5321 });
5322 __bindgen_bitfield_unit
5323 }
5324}
5325pub const vnet_hw_if_tx_frame_hint_t_VNET_HW_IF_TX_FRAME_HINT_NOT_CHAINED:
5326 vnet_hw_if_tx_frame_hint_t = 1;
5327pub const vnet_hw_if_tx_frame_hint_t_VNET_HW_IF_TX_FRAME_HINT_NO_GSO: vnet_hw_if_tx_frame_hint_t =
5328 2;
5329pub const vnet_hw_if_tx_frame_hint_t_VNET_HW_IF_TX_FRAME_HINT_NO_CKSUM_OFFLOAD:
5330 vnet_hw_if_tx_frame_hint_t = 4;
5331pub type vnet_hw_if_tx_frame_hint_t = ::std::os::raw::c_uint;
5332#[repr(C)]
5333#[derive(Debug, Copy, Clone)]
5334pub struct vnet_hw_if_tx_frame_t {
5335 pub _bitfield_align_1: [u16; 0],
5336 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
5337 pub queue_id: u32_,
5338}
5339impl Default for vnet_hw_if_tx_frame_t {
5340 fn default() -> Self {
5341 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5342 unsafe {
5343 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5344 s.assume_init()
5345 }
5346 }
5347}
5348impl vnet_hw_if_tx_frame_t {
5349 #[inline]
5350 pub fn shared_queue(&self) -> u8_ {
5351 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
5352 }
5353 #[inline]
5354 pub fn set_shared_queue(&mut self, val: u8_) {
5355 unsafe {
5356 let val: u8 = ::std::mem::transmute(val);
5357 self._bitfield_1.set(0usize, 1u8, val as u64)
5358 }
5359 }
5360 #[inline]
5361 pub unsafe fn shared_queue_raw(this: *const Self) -> u8_ {
5362 unsafe {
5363 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get(
5364 ::std::ptr::addr_of!((*this)._bitfield_1),
5365 0usize,
5366 1u8,
5367 ) as u8)
5368 }
5369 }
5370 #[inline]
5371 pub unsafe fn set_shared_queue_raw(this: *mut Self, val: u8_) {
5372 unsafe {
5373 let val: u8 = ::std::mem::transmute(val);
5374 <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set(
5375 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5376 0usize,
5377 1u8,
5378 val as u64,
5379 )
5380 }
5381 }
5382 #[inline]
5383 pub fn hints(&self) -> vnet_hw_if_tx_frame_hint_t {
5384 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 16u8) as u32) }
5385 }
5386 #[inline]
5387 pub fn set_hints(&mut self, val: vnet_hw_if_tx_frame_hint_t) {
5388 unsafe {
5389 let val: u32 = ::std::mem::transmute(val);
5390 self._bitfield_1.set(1usize, 16u8, val as u64)
5391 }
5392 }
5393 #[inline]
5394 pub unsafe fn hints_raw(this: *const Self) -> vnet_hw_if_tx_frame_hint_t {
5395 unsafe {
5396 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get(
5397 ::std::ptr::addr_of!((*this)._bitfield_1),
5398 1usize,
5399 16u8,
5400 ) as u32)
5401 }
5402 }
5403 #[inline]
5404 pub unsafe fn set_hints_raw(this: *mut Self, val: vnet_hw_if_tx_frame_hint_t) {
5405 unsafe {
5406 let val: u32 = ::std::mem::transmute(val);
5407 <__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set(
5408 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5409 1usize,
5410 16u8,
5411 val as u64,
5412 )
5413 }
5414 }
5415 #[inline]
5416 pub fn new_bitfield_1(
5417 shared_queue: u8_,
5418 hints: vnet_hw_if_tx_frame_hint_t,
5419 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
5420 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
5421 __bindgen_bitfield_unit.set(0usize, 1u8, {
5422 let shared_queue: u8 = unsafe { ::std::mem::transmute(shared_queue) };
5423 shared_queue as u64
5424 });
5425 __bindgen_bitfield_unit.set(1usize, 16u8, {
5426 let hints: u32 = unsafe { ::std::mem::transmute(hints) };
5427 hints as u64
5428 });
5429 __bindgen_bitfield_unit
5430 }
5431}
5432#[repr(C)]
5433#[repr(align(64))]
5434#[derive(Debug)]
5435pub struct vnet_hw_if_output_node_runtime_t {
5436 pub cacheline0: __IncompleteArrayField<u8_>,
5437 pub frame: *mut vnet_hw_if_tx_frame_t,
5438 pub lookup_table: *mut u32_,
5439 pub n_queues: u32_,
5440}
5441impl Default for vnet_hw_if_output_node_runtime_t {
5442 fn default() -> Self {
5443 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5444 unsafe {
5445 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5446 s.assume_init()
5447 }
5448 }
5449}
5450#[repr(C)]
5451#[repr(align(64))]
5452#[derive(Debug)]
5453pub struct vnet_hw_interface_t {
5454 pub cacheline0: __IncompleteArrayField<u8_>,
5455 pub flags: vnet_hw_interface_flags_t,
5456 pub caps: vnet_hw_if_caps_t,
5457 pub hw_address: *mut u8_,
5458 pub output_node_index: u32_,
5459 pub tx_node_index: u32_,
5460 pub if_out_arc_end_node_next_index: u32_,
5461 pub dev_class_index: u32_,
5462 pub dev_instance: u32_,
5463 pub hw_class_index: u32_,
5464 pub hw_instance: u32_,
5465 pub hw_if_index: u32_,
5466 pub sw_if_index: u32_,
5467 pub output_node_thread_runtimes: *mut vnet_hw_if_output_node_runtime_t,
5468 pub cacheline1: __IncompleteArrayField<u8_>,
5469 pub name: *mut u8_,
5470 pub link_speed: u32_,
5471 pub output_node_next_index: u32_,
5472 pub hf: vnet_hash_fn_t,
5473 pub max_rate_bits_per_sec: f64_,
5474 pub min_frame_size: u32_,
5475 pub max_frame_size: u32_,
5476 pub frame_overhead: u16_,
5477 pub sub_interface_sw_if_index_by_id: *mut uword,
5478 pub l2_if_count: u32_,
5479 pub l3_if_count: u32_,
5480 pub bond_info: *mut uword,
5481 pub input_node_index: u32_,
5482 pub default_rx_mode: vnet_hw_if_rx_mode,
5483 pub rx_queue_indices: *mut u32_,
5484 pub tx_queue_indices: *mut u32_,
5485 pub numa_node: u8_,
5486 pub rss_queues: *mut clib_bitmap_t,
5487 pub n_trace: i32_,
5488 pub trace_classify_table_index: u32_,
5489}
5490impl Default for vnet_hw_interface_t {
5491 fn default() -> Self {
5492 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5493 unsafe {
5494 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5495 s.assume_init()
5496 }
5497 }
5498}
5499pub const vnet_sw_interface_type_t_VNET_SW_INTERFACE_TYPE_HARDWARE: vnet_sw_interface_type_t = 0;
5500pub const vnet_sw_interface_type_t_VNET_SW_INTERFACE_TYPE_SUB: vnet_sw_interface_type_t = 1;
5501pub const vnet_sw_interface_type_t_VNET_SW_INTERFACE_TYPE_P2P: vnet_sw_interface_type_t = 2;
5502pub const vnet_sw_interface_type_t_VNET_SW_INTERFACE_TYPE_PIPE: vnet_sw_interface_type_t = 3;
5503pub type vnet_sw_interface_type_t = ::std::os::raw::c_uint;
5504#[repr(C)]
5505#[derive(Copy, Clone)]
5506pub struct vnet_sub_interface_t {
5507 pub id: u32_,
5508 pub eth: vnet_sub_interface_t__bindgen_ty_1,
5509}
5510#[repr(C)]
5511#[derive(Copy, Clone)]
5512pub struct vnet_sub_interface_t__bindgen_ty_1 {
5513 pub outer_vlan_id: u16_,
5514 pub inner_vlan_id: u16_,
5515 pub __bindgen_anon_1: vnet_sub_interface_t__bindgen_ty_1__bindgen_ty_1,
5516}
5517#[repr(C)]
5518#[derive(Copy, Clone)]
5519pub union vnet_sub_interface_t__bindgen_ty_1__bindgen_ty_1 {
5520 pub raw_flags: u16_,
5521 pub flags: vnet_sub_interface_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
5522}
5523#[repr(C)]
5524#[repr(align(2))]
5525#[derive(Debug, Default, Copy, Clone)]
5526pub struct vnet_sub_interface_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
5527 pub _bitfield_align_1: [u8; 0],
5528 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5529 pub __bindgen_padding_0: u8,
5530}
5531impl vnet_sub_interface_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
5532 #[inline]
5533 pub fn no_tags(&self) -> u16_ {
5534 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
5535 }
5536 #[inline]
5537 pub fn set_no_tags(&mut self, val: u16_) {
5538 unsafe {
5539 let val: u16 = ::std::mem::transmute(val);
5540 self._bitfield_1.set(0usize, 1u8, val as u64)
5541 }
5542 }
5543 #[inline]
5544 pub unsafe fn no_tags_raw(this: *const Self) -> u16_ {
5545 unsafe {
5546 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5547 ::std::ptr::addr_of!((*this)._bitfield_1),
5548 0usize,
5549 1u8,
5550 ) as u16)
5551 }
5552 }
5553 #[inline]
5554 pub unsafe fn set_no_tags_raw(this: *mut Self, val: u16_) {
5555 unsafe {
5556 let val: u16 = ::std::mem::transmute(val);
5557 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5558 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5559 0usize,
5560 1u8,
5561 val as u64,
5562 )
5563 }
5564 }
5565 #[inline]
5566 pub fn one_tag(&self) -> u16_ {
5567 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) }
5568 }
5569 #[inline]
5570 pub fn set_one_tag(&mut self, val: u16_) {
5571 unsafe {
5572 let val: u16 = ::std::mem::transmute(val);
5573 self._bitfield_1.set(1usize, 1u8, val as u64)
5574 }
5575 }
5576 #[inline]
5577 pub unsafe fn one_tag_raw(this: *const Self) -> u16_ {
5578 unsafe {
5579 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5580 ::std::ptr::addr_of!((*this)._bitfield_1),
5581 1usize,
5582 1u8,
5583 ) as u16)
5584 }
5585 }
5586 #[inline]
5587 pub unsafe fn set_one_tag_raw(this: *mut Self, val: u16_) {
5588 unsafe {
5589 let val: u16 = ::std::mem::transmute(val);
5590 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5591 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5592 1usize,
5593 1u8,
5594 val as u64,
5595 )
5596 }
5597 }
5598 #[inline]
5599 pub fn two_tags(&self) -> u16_ {
5600 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
5601 }
5602 #[inline]
5603 pub fn set_two_tags(&mut self, val: u16_) {
5604 unsafe {
5605 let val: u16 = ::std::mem::transmute(val);
5606 self._bitfield_1.set(2usize, 1u8, val as u64)
5607 }
5608 }
5609 #[inline]
5610 pub unsafe fn two_tags_raw(this: *const Self) -> u16_ {
5611 unsafe {
5612 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5613 ::std::ptr::addr_of!((*this)._bitfield_1),
5614 2usize,
5615 1u8,
5616 ) as u16)
5617 }
5618 }
5619 #[inline]
5620 pub unsafe fn set_two_tags_raw(this: *mut Self, val: u16_) {
5621 unsafe {
5622 let val: u16 = ::std::mem::transmute(val);
5623 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5624 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5625 2usize,
5626 1u8,
5627 val as u64,
5628 )
5629 }
5630 }
5631 #[inline]
5632 pub fn dot1ad(&self) -> u16_ {
5633 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
5634 }
5635 #[inline]
5636 pub fn set_dot1ad(&mut self, val: u16_) {
5637 unsafe {
5638 let val: u16 = ::std::mem::transmute(val);
5639 self._bitfield_1.set(3usize, 1u8, val as u64)
5640 }
5641 }
5642 #[inline]
5643 pub unsafe fn dot1ad_raw(this: *const Self) -> u16_ {
5644 unsafe {
5645 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5646 ::std::ptr::addr_of!((*this)._bitfield_1),
5647 3usize,
5648 1u8,
5649 ) as u16)
5650 }
5651 }
5652 #[inline]
5653 pub unsafe fn set_dot1ad_raw(this: *mut Self, val: u16_) {
5654 unsafe {
5655 let val: u16 = ::std::mem::transmute(val);
5656 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5657 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5658 3usize,
5659 1u8,
5660 val as u64,
5661 )
5662 }
5663 }
5664 #[inline]
5665 pub fn exact_match(&self) -> u16_ {
5666 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
5667 }
5668 #[inline]
5669 pub fn set_exact_match(&mut self, val: u16_) {
5670 unsafe {
5671 let val: u16 = ::std::mem::transmute(val);
5672 self._bitfield_1.set(4usize, 1u8, val as u64)
5673 }
5674 }
5675 #[inline]
5676 pub unsafe fn exact_match_raw(this: *const Self) -> u16_ {
5677 unsafe {
5678 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5679 ::std::ptr::addr_of!((*this)._bitfield_1),
5680 4usize,
5681 1u8,
5682 ) as u16)
5683 }
5684 }
5685 #[inline]
5686 pub unsafe fn set_exact_match_raw(this: *mut Self, val: u16_) {
5687 unsafe {
5688 let val: u16 = ::std::mem::transmute(val);
5689 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5690 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5691 4usize,
5692 1u8,
5693 val as u64,
5694 )
5695 }
5696 }
5697 #[inline]
5698 pub fn default_sub(&self) -> u16_ {
5699 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
5700 }
5701 #[inline]
5702 pub fn set_default_sub(&mut self, val: u16_) {
5703 unsafe {
5704 let val: u16 = ::std::mem::transmute(val);
5705 self._bitfield_1.set(5usize, 1u8, val as u64)
5706 }
5707 }
5708 #[inline]
5709 pub unsafe fn default_sub_raw(this: *const Self) -> u16_ {
5710 unsafe {
5711 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5712 ::std::ptr::addr_of!((*this)._bitfield_1),
5713 5usize,
5714 1u8,
5715 ) as u16)
5716 }
5717 }
5718 #[inline]
5719 pub unsafe fn set_default_sub_raw(this: *mut Self, val: u16_) {
5720 unsafe {
5721 let val: u16 = ::std::mem::transmute(val);
5722 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5723 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5724 5usize,
5725 1u8,
5726 val as u64,
5727 )
5728 }
5729 }
5730 #[inline]
5731 pub fn outer_vlan_id_any(&self) -> u16_ {
5732 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) }
5733 }
5734 #[inline]
5735 pub fn set_outer_vlan_id_any(&mut self, val: u16_) {
5736 unsafe {
5737 let val: u16 = ::std::mem::transmute(val);
5738 self._bitfield_1.set(6usize, 1u8, val as u64)
5739 }
5740 }
5741 #[inline]
5742 pub unsafe fn outer_vlan_id_any_raw(this: *const Self) -> u16_ {
5743 unsafe {
5744 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5745 ::std::ptr::addr_of!((*this)._bitfield_1),
5746 6usize,
5747 1u8,
5748 ) as u16)
5749 }
5750 }
5751 #[inline]
5752 pub unsafe fn set_outer_vlan_id_any_raw(this: *mut Self, val: u16_) {
5753 unsafe {
5754 let val: u16 = ::std::mem::transmute(val);
5755 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5756 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5757 6usize,
5758 1u8,
5759 val as u64,
5760 )
5761 }
5762 }
5763 #[inline]
5764 pub fn inner_vlan_id_any(&self) -> u16_ {
5765 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
5766 }
5767 #[inline]
5768 pub fn set_inner_vlan_id_any(&mut self, val: u16_) {
5769 unsafe {
5770 let val: u16 = ::std::mem::transmute(val);
5771 self._bitfield_1.set(7usize, 1u8, val as u64)
5772 }
5773 }
5774 #[inline]
5775 pub unsafe fn inner_vlan_id_any_raw(this: *const Self) -> u16_ {
5776 unsafe {
5777 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5778 ::std::ptr::addr_of!((*this)._bitfield_1),
5779 7usize,
5780 1u8,
5781 ) as u16)
5782 }
5783 }
5784 #[inline]
5785 pub unsafe fn set_inner_vlan_id_any_raw(this: *mut Self, val: u16_) {
5786 unsafe {
5787 let val: u16 = ::std::mem::transmute(val);
5788 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5789 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5790 7usize,
5791 1u8,
5792 val as u64,
5793 )
5794 }
5795 }
5796 #[inline]
5797 pub fn new_bitfield_1(
5798 no_tags: u16_,
5799 one_tag: u16_,
5800 two_tags: u16_,
5801 dot1ad: u16_,
5802 exact_match: u16_,
5803 default_sub: u16_,
5804 outer_vlan_id_any: u16_,
5805 inner_vlan_id_any: u16_,
5806 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5807 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5808 __bindgen_bitfield_unit.set(0usize, 1u8, {
5809 let no_tags: u16 = unsafe { ::std::mem::transmute(no_tags) };
5810 no_tags as u64
5811 });
5812 __bindgen_bitfield_unit.set(1usize, 1u8, {
5813 let one_tag: u16 = unsafe { ::std::mem::transmute(one_tag) };
5814 one_tag as u64
5815 });
5816 __bindgen_bitfield_unit.set(2usize, 1u8, {
5817 let two_tags: u16 = unsafe { ::std::mem::transmute(two_tags) };
5818 two_tags as u64
5819 });
5820 __bindgen_bitfield_unit.set(3usize, 1u8, {
5821 let dot1ad: u16 = unsafe { ::std::mem::transmute(dot1ad) };
5822 dot1ad as u64
5823 });
5824 __bindgen_bitfield_unit.set(4usize, 1u8, {
5825 let exact_match: u16 = unsafe { ::std::mem::transmute(exact_match) };
5826 exact_match as u64
5827 });
5828 __bindgen_bitfield_unit.set(5usize, 1u8, {
5829 let default_sub: u16 = unsafe { ::std::mem::transmute(default_sub) };
5830 default_sub as u64
5831 });
5832 __bindgen_bitfield_unit.set(6usize, 1u8, {
5833 let outer_vlan_id_any: u16 = unsafe { ::std::mem::transmute(outer_vlan_id_any) };
5834 outer_vlan_id_any as u64
5835 });
5836 __bindgen_bitfield_unit.set(7usize, 1u8, {
5837 let inner_vlan_id_any: u16 = unsafe { ::std::mem::transmute(inner_vlan_id_any) };
5838 inner_vlan_id_any as u64
5839 });
5840 __bindgen_bitfield_unit
5841 }
5842}
5843impl Default for vnet_sub_interface_t__bindgen_ty_1__bindgen_ty_1 {
5844 fn default() -> Self {
5845 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5846 unsafe {
5847 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5848 s.assume_init()
5849 }
5850 }
5851}
5852impl Default for vnet_sub_interface_t__bindgen_ty_1 {
5853 fn default() -> Self {
5854 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5855 unsafe {
5856 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5857 s.assume_init()
5858 }
5859 }
5860}
5861impl Default for vnet_sub_interface_t {
5862 fn default() -> Self {
5863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5864 unsafe {
5865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5866 s.assume_init()
5867 }
5868 }
5869}
5870#[repr(C)]
5871#[derive(Debug, Default, Copy, Clone)]
5872pub struct vnet_p2p_sub_interface_t {
5873 pub id: u32_,
5874 pub pool_index: u32_,
5875 pub client_mac: [u8_; 6usize],
5876}
5877pub const vnet_flood_class_t_VNET_FLOOD_CLASS_BVI: vnet_flood_class_t = 0;
5878pub const vnet_flood_class_t_VNET_FLOOD_CLASS_NORMAL: vnet_flood_class_t = 1;
5879pub const vnet_flood_class_t_VNET_FLOOD_CLASS_TUNNEL_MASTER: vnet_flood_class_t = 2;
5880pub const vnet_flood_class_t_VNET_FLOOD_CLASS_TUNNEL_NORMAL: vnet_flood_class_t = 3;
5881pub const vnet_flood_class_t_VNET_FLOOD_CLASS_NO_FLOOD: vnet_flood_class_t = 4;
5882pub type vnet_flood_class_t = ::std::os::raw::c_uint;
5883pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_NONE: vnet_sw_interface_flags_t_ = 0;
5884pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_ADMIN_UP: vnet_sw_interface_flags_t_ =
5885 1;
5886pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_PUNT: vnet_sw_interface_flags_t_ = 2;
5887pub const vnet_sw_interface_flags_t____VNET_SW_INTERFACE_FLAG_UNSUED: vnet_sw_interface_flags_t_ =
5888 4;
5889pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_UNNUMBERED: vnet_sw_interface_flags_t_ =
5890 8;
5891pub const vnet_sw_interface_flags_t____VNET_SW_INTERFACE_FLAG_UNUSED2: vnet_sw_interface_flags_t_ =
5892 16;
5893pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_HIDDEN: vnet_sw_interface_flags_t_ = 32;
5894pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_ERROR: vnet_sw_interface_flags_t_ = 64;
5895pub const vnet_sw_interface_flags_t__VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST:
5896 vnet_sw_interface_flags_t_ = 128;
5897pub type vnet_sw_interface_flags_t_ = ::std::os::raw::c_uchar;
5898pub use self::vnet_sw_interface_flags_t_ as vnet_sw_interface_flags_t;
5899#[repr(C)]
5900#[derive(Debug, Default, Copy, Clone)]
5901pub struct vnet_hw_interface_nodes_t {
5902 pub output_node_index: u32_,
5903 pub tx_node_index: u32_,
5904}
5905#[repr(C)]
5906#[repr(align(64))]
5907#[derive(Debug)]
5908pub struct vnet_interface_per_thread_data_t {
5909 pub cacheline0: __IncompleteArrayField<u8_>,
5910 pub split_buffers: *mut u32_,
5911}
5912impl Default for vnet_interface_per_thread_data_t {
5913 fn default() -> Self {
5914 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5915 unsafe {
5916 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5917 s.assume_init()
5918 }
5919 }
5920}
5921pub type vnet_buffer_opquae_formatter_t =
5922 ::std::option::Option<unsafe extern "C" fn(b: *const vlib_buffer_t, s: *mut u8_) -> *mut u8_>;
5923#[repr(C)]
5924#[derive(Debug, Copy, Clone)]
5925pub struct vnet_interface_main_t {
5926 pub hw_interfaces: *mut vnet_hw_interface_t,
5927 pub hw_if_rx_queues: *mut vnet_hw_if_rx_queue_t,
5928 pub rxq_index_by_hw_if_index_and_queue_id: *mut uword,
5929 pub hw_if_tx_queues: *mut vnet_hw_if_tx_queue_t,
5930 pub txq_index_by_hw_if_index_and_queue_id: *mut uword,
5931 pub hw_interface_by_name: *mut uword,
5932 pub hw_interface_classes: *mut vnet_hw_interface_class_t,
5933 pub device_classes: *mut vnet_device_class_t,
5934 pub hw_interface_class_by_name: *mut uword,
5935 pub device_class_by_name: *mut uword,
5936 pub sw_interfaces: *mut vnet_sw_interface_t,
5937 pub sw_if_index_by_sup_and_sub: *mut uword,
5938 pub sw_if_counter_lock: clib_spinlock_t,
5939 pub sw_if_counters: *mut vlib_simple_counter_main_t,
5940 pub combined_sw_if_counters: *mut vlib_combined_counter_main_t,
5941 pub deleted_hw_interface_nodes: *mut vnet_hw_interface_nodes_t,
5942 pub pcap_drop_filter_hash: *mut uword,
5943 pub buffer_opaque_format_helpers: *mut vnet_buffer_opquae_formatter_t,
5944 pub buffer_opaque2_format_helpers: *mut vnet_buffer_opquae_formatter_t,
5945 pub per_thread_data: *mut vnet_interface_per_thread_data_t,
5946 pub output_feature_arc_index: u8_,
5947 pub drop_feature_arc_index: u8_,
5948 pub hw_if_index_by_sw_if_index: *mut u32_,
5949 pub if_out_arc_end_next_index_by_sw_if_index: *mut u16_,
5950}
5951impl Default for vnet_interface_main_t {
5952 fn default() -> Self {
5953 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5954 unsafe {
5955 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5956 s.assume_init()
5957 }
5958 }
5959}
5960pub const vnet_api_error_t_VNET_API_ERROR_UNSPECIFIED: vnet_api_error_t = -1;
5961pub const vnet_api_error_t_VNET_API_ERROR_INVALID_SW_IF_INDEX: vnet_api_error_t = -2;
5962pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_FIB: vnet_api_error_t = -3;
5963pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_INNER_FIB: vnet_api_error_t = -4;
5964pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_LABEL: vnet_api_error_t = -5;
5965pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_ENTRY: vnet_api_error_t = -6;
5966pub const vnet_api_error_t_VNET_API_ERROR_INVALID_VALUE: vnet_api_error_t = -7;
5967pub const vnet_api_error_t_VNET_API_ERROR_INVALID_VALUE_2: vnet_api_error_t = -8;
5968pub const vnet_api_error_t_VNET_API_ERROR_UNIMPLEMENTED: vnet_api_error_t = -9;
5969pub const vnet_api_error_t_VNET_API_ERROR_INVALID_SW_IF_INDEX_2: vnet_api_error_t = -10;
5970pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_1: vnet_api_error_t = -11;
5971pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_2: vnet_api_error_t = -12;
5972pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_3: vnet_api_error_t = -13;
5973pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_4: vnet_api_error_t = -14;
5974pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_5: vnet_api_error_t = -15;
5975pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_6: vnet_api_error_t = -16;
5976pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_7: vnet_api_error_t = -17;
5977pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_8: vnet_api_error_t = -18;
5978pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_9: vnet_api_error_t = -19;
5979pub const vnet_api_error_t_VNET_API_ERROR_SYSCALL_ERROR_10: vnet_api_error_t = -20;
5980pub const vnet_api_error_t_VNET_API_ERROR_FEATURE_DISABLED: vnet_api_error_t = -30;
5981pub const vnet_api_error_t_VNET_API_ERROR_INVALID_REGISTRATION: vnet_api_error_t = -31;
5982pub const vnet_api_error_t_VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB: vnet_api_error_t = -50;
5983pub const vnet_api_error_t_VNET_API_ERROR_UNKNOWN_DESTINATION: vnet_api_error_t = -51;
5984pub const vnet_api_error_t_VNET_API_ERROR_NO_PATHS_IN_ROUTE: vnet_api_error_t = -52;
5985pub const vnet_api_error_t_VNET_API_ERROR_NEXT_HOP_NOT_FOUND_MP: vnet_api_error_t = -53;
5986pub const vnet_api_error_t_VNET_API_ERROR_NO_MATCHING_INTERFACE: vnet_api_error_t = -54;
5987pub const vnet_api_error_t_VNET_API_ERROR_INVALID_VLAN: vnet_api_error_t = -55;
5988pub const vnet_api_error_t_VNET_API_ERROR_VLAN_ALREADY_EXISTS: vnet_api_error_t = -56;
5989pub const vnet_api_error_t_VNET_API_ERROR_INVALID_SRC_ADDRESS: vnet_api_error_t = -57;
5990pub const vnet_api_error_t_VNET_API_ERROR_INVALID_DST_ADDRESS: vnet_api_error_t = -58;
5991pub const vnet_api_error_t_VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH: vnet_api_error_t = -59;
5992pub const vnet_api_error_t_VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE: vnet_api_error_t = -60;
5993pub const vnet_api_error_t_VNET_API_ERROR_ADDRESS_NOT_DELETABLE: vnet_api_error_t = -61;
5994pub const vnet_api_error_t_VNET_API_ERROR_IP6_NOT_ENABLED: vnet_api_error_t = -62;
5995pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_NODE: vnet_api_error_t = -63;
5996pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_NODE2: vnet_api_error_t = -64;
5997pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_TABLE: vnet_api_error_t = -65;
5998pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_TABLE2: vnet_api_error_t = -66;
5999pub const vnet_api_error_t_VNET_API_ERROR_NO_SUCH_TABLE3: vnet_api_error_t = -67;
6000pub const vnet_api_error_t_VNET_API_ERROR_SUBIF_ALREADY_EXISTS: vnet_api_error_t = -68;
6001pub const vnet_api_error_t_VNET_API_ERROR_SUBIF_CREATE_FAILED: vnet_api_error_t = -69;
6002pub const vnet_api_error_t_VNET_API_ERROR_INVALID_MEMORY_SIZE: vnet_api_error_t = -70;
6003pub const vnet_api_error_t_VNET_API_ERROR_INVALID_INTERFACE: vnet_api_error_t = -71;
6004pub const vnet_api_error_t_VNET_API_ERROR_INVALID_VLAN_TAG_COUNT: vnet_api_error_t = -72;
6005pub const vnet_api_error_t_VNET_API_ERROR_INVALID_ARGUMENT: vnet_api_error_t = -73;
6006pub const vnet_api_error_t_VNET_API_ERROR_UNEXPECTED_INTF_STATE: vnet_api_error_t = -74;
6007pub const vnet_api_error_t_VNET_API_ERROR_TUNNEL_EXIST: vnet_api_error_t = -75;
6008pub const vnet_api_error_t_VNET_API_ERROR_INVALID_DECAP_NEXT: vnet_api_error_t = -76;
6009pub const vnet_api_error_t_VNET_API_ERROR_RESPONSE_NOT_READY: vnet_api_error_t = -77;
6010pub const vnet_api_error_t_VNET_API_ERROR_NOT_CONNECTED: vnet_api_error_t = -78;
6011pub const vnet_api_error_t_VNET_API_ERROR_IF_ALREADY_EXISTS: vnet_api_error_t = -79;
6012pub const vnet_api_error_t_VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED: vnet_api_error_t = -80;
6013pub const vnet_api_error_t_VNET_API_ERROR_VALUE_EXIST: vnet_api_error_t = -81;
6014pub const vnet_api_error_t_VNET_API_ERROR_SAME_SRC_DST: vnet_api_error_t = -82;
6015pub const vnet_api_error_t_VNET_API_ERROR_IP6_MULTICAST_ADDRESS_NOT_PRESENT: vnet_api_error_t = -83;
6016pub const vnet_api_error_t_VNET_API_ERROR_SR_POLICY_NAME_NOT_PRESENT: vnet_api_error_t = -84;
6017pub const vnet_api_error_t_VNET_API_ERROR_NOT_RUNNING_AS_ROOT: vnet_api_error_t = -85;
6018pub const vnet_api_error_t_VNET_API_ERROR_ALREADY_CONNECTED: vnet_api_error_t = -86;
6019pub const vnet_api_error_t_VNET_API_ERROR_UNSUPPORTED_JNI_VERSION: vnet_api_error_t = -87;
6020pub const vnet_api_error_t_VNET_API_ERROR_IP_PREFIX_INVALID: vnet_api_error_t = -88;
6021pub const vnet_api_error_t_VNET_API_ERROR_INVALID_WORKER: vnet_api_error_t = -89;
6022pub const vnet_api_error_t_VNET_API_ERROR_LISP_DISABLED: vnet_api_error_t = -90;
6023pub const vnet_api_error_t_VNET_API_ERROR_CLASSIFY_TABLE_NOT_FOUND: vnet_api_error_t = -91;
6024pub const vnet_api_error_t_VNET_API_ERROR_INVALID_EID_TYPE: vnet_api_error_t = -92;
6025pub const vnet_api_error_t_VNET_API_ERROR_CANNOT_CREATE_PCAP_FILE: vnet_api_error_t = -93;
6026pub const vnet_api_error_t_VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE: vnet_api_error_t = -94;
6027pub const vnet_api_error_t_VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY: vnet_api_error_t =
6028 -95;
6029pub const vnet_api_error_t_VNET_API_ERROR_EXCEEDED_NUMBER_OF_PORTS_CAPACITY: vnet_api_error_t = -96;
6030pub const vnet_api_error_t_VNET_API_ERROR_INVALID_ADDRESS_FAMILY: vnet_api_error_t = -97;
6031pub const vnet_api_error_t_VNET_API_ERROR_INVALID_SUB_SW_IF_INDEX: vnet_api_error_t = -98;
6032pub const vnet_api_error_t_VNET_API_ERROR_TABLE_TOO_BIG: vnet_api_error_t = -99;
6033pub const vnet_api_error_t_VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE: vnet_api_error_t = -100;
6034pub const vnet_api_error_t_VNET_API_ERROR_BFD_EEXIST: vnet_api_error_t = -101;
6035pub const vnet_api_error_t_VNET_API_ERROR_BFD_ENOENT: vnet_api_error_t = -102;
6036pub const vnet_api_error_t_VNET_API_ERROR_BFD_EINUSE: vnet_api_error_t = -103;
6037pub const vnet_api_error_t_VNET_API_ERROR_BFD_NOTSUPP: vnet_api_error_t = -104;
6038pub const vnet_api_error_t_VNET_API_ERROR_ADDRESS_IN_USE: vnet_api_error_t = -105;
6039pub const vnet_api_error_t_VNET_API_ERROR_ADDRESS_NOT_IN_USE: vnet_api_error_t = -106;
6040pub const vnet_api_error_t_VNET_API_ERROR_QUEUE_FULL: vnet_api_error_t = -107;
6041pub const vnet_api_error_t_VNET_API_ERROR_APP_UNSUPPORTED_CFG: vnet_api_error_t = -108;
6042pub const vnet_api_error_t_VNET_API_ERROR_URI_FIFO_CREATE_FAILED: vnet_api_error_t = -109;
6043pub const vnet_api_error_t_VNET_API_ERROR_LISP_RLOC_LOCAL: vnet_api_error_t = -110;
6044pub const vnet_api_error_t_VNET_API_ERROR_BFD_EAGAIN: vnet_api_error_t = -111;
6045pub const vnet_api_error_t_VNET_API_ERROR_INVALID_GPE_MODE: vnet_api_error_t = -112;
6046pub const vnet_api_error_t_VNET_API_ERROR_LISP_GPE_ENTRIES_PRESENT: vnet_api_error_t = -113;
6047pub const vnet_api_error_t_VNET_API_ERROR_ADDRESS_FOUND_FOR_INTERFACE: vnet_api_error_t = -114;
6048pub const vnet_api_error_t_VNET_API_ERROR_SESSION_CONNECT: vnet_api_error_t = -115;
6049pub const vnet_api_error_t_VNET_API_ERROR_ENTRY_ALREADY_EXISTS: vnet_api_error_t = -116;
6050pub const vnet_api_error_t_VNET_API_ERROR_SVM_SEGMENT_CREATE_FAIL: vnet_api_error_t = -117;
6051pub const vnet_api_error_t_VNET_API_ERROR_APPLICATION_NOT_ATTACHED: vnet_api_error_t = -118;
6052pub const vnet_api_error_t_VNET_API_ERROR_BD_ALREADY_EXISTS: vnet_api_error_t = -119;
6053pub const vnet_api_error_t_VNET_API_ERROR_BD_IN_USE: vnet_api_error_t = -120;
6054pub const vnet_api_error_t_VNET_API_ERROR_BD_NOT_MODIFIABLE: vnet_api_error_t = -121;
6055pub const vnet_api_error_t_VNET_API_ERROR_BD_ID_EXCEED_MAX: vnet_api_error_t = -122;
6056pub const vnet_api_error_t_VNET_API_ERROR_SUBIF_DOESNT_EXIST: vnet_api_error_t = -123;
6057pub const vnet_api_error_t_VNET_API_ERROR_L2_MACS_EVENT_CLINET_PRESENT: vnet_api_error_t = -124;
6058pub const vnet_api_error_t_VNET_API_ERROR_INVALID_QUEUE: vnet_api_error_t = -125;
6059pub const vnet_api_error_t_VNET_API_ERROR_UNSUPPORTED: vnet_api_error_t = -126;
6060pub const vnet_api_error_t_VNET_API_ERROR_DUPLICATE_IF_ADDRESS: vnet_api_error_t = -127;
6061pub const vnet_api_error_t_VNET_API_ERROR_APP_INVALID_NS: vnet_api_error_t = -128;
6062pub const vnet_api_error_t_VNET_API_ERROR_APP_WRONG_NS_SECRET: vnet_api_error_t = -129;
6063pub const vnet_api_error_t_VNET_API_ERROR_APP_CONNECT_SCOPE: vnet_api_error_t = -130;
6064pub const vnet_api_error_t_VNET_API_ERROR_APP_ALREADY_ATTACHED: vnet_api_error_t = -131;
6065pub const vnet_api_error_t_VNET_API_ERROR_SESSION_REDIRECT: vnet_api_error_t = -132;
6066pub const vnet_api_error_t_VNET_API_ERROR_ILLEGAL_NAME: vnet_api_error_t = -133;
6067pub const vnet_api_error_t_VNET_API_ERROR_NO_NAME_SERVERS: vnet_api_error_t = -134;
6068pub const vnet_api_error_t_VNET_API_ERROR_NAME_SERVER_NOT_FOUND: vnet_api_error_t = -135;
6069pub const vnet_api_error_t_VNET_API_ERROR_NAME_RESOLUTION_NOT_ENABLED: vnet_api_error_t = -136;
6070pub const vnet_api_error_t_VNET_API_ERROR_NAME_SERVER_FORMAT_ERROR: vnet_api_error_t = -137;
6071pub const vnet_api_error_t_VNET_API_ERROR_NAME_SERVER_NO_SUCH_NAME: vnet_api_error_t = -138;
6072pub const vnet_api_error_t_VNET_API_ERROR_NAME_SERVER_NO_ADDRESSES: vnet_api_error_t = -139;
6073pub const vnet_api_error_t_VNET_API_ERROR_NAME_SERVER_NEXT_SERVER: vnet_api_error_t = -140;
6074pub const vnet_api_error_t_VNET_API_ERROR_APP_CONNECT_FILTERED: vnet_api_error_t = -141;
6075pub const vnet_api_error_t_VNET_API_ERROR_ACL_IN_USE_INBOUND: vnet_api_error_t = -142;
6076pub const vnet_api_error_t_VNET_API_ERROR_ACL_IN_USE_OUTBOUND: vnet_api_error_t = -143;
6077pub const vnet_api_error_t_VNET_API_ERROR_INIT_FAILED: vnet_api_error_t = -144;
6078pub const vnet_api_error_t_VNET_API_ERROR_NETLINK_ERROR: vnet_api_error_t = -145;
6079pub const vnet_api_error_t_VNET_API_ERROR_BIER_BSL_UNSUP: vnet_api_error_t = -146;
6080pub const vnet_api_error_t_VNET_API_ERROR_INSTANCE_IN_USE: vnet_api_error_t = -147;
6081pub const vnet_api_error_t_VNET_API_ERROR_INVALID_SESSION_ID: vnet_api_error_t = -148;
6082pub const vnet_api_error_t_VNET_API_ERROR_ACL_IN_USE_BY_LOOKUP_CONTEXT: vnet_api_error_t = -149;
6083pub const vnet_api_error_t_VNET_API_ERROR_INVALID_VALUE_3: vnet_api_error_t = -150;
6084pub const vnet_api_error_t_VNET_API_ERROR_NON_ETHERNET: vnet_api_error_t = -151;
6085pub const vnet_api_error_t_VNET_API_ERROR_BD_ALREADY_HAS_BVI: vnet_api_error_t = -152;
6086pub const vnet_api_error_t_VNET_API_ERROR_INVALID_PROTOCOL: vnet_api_error_t = -153;
6087pub const vnet_api_error_t_VNET_API_ERROR_INVALID_ALGORITHM: vnet_api_error_t = -154;
6088pub const vnet_api_error_t_VNET_API_ERROR_RSRC_IN_USE: vnet_api_error_t = -155;
6089pub const vnet_api_error_t_VNET_API_ERROR_KEY_LENGTH: vnet_api_error_t = -156;
6090pub const vnet_api_error_t_VNET_API_ERROR_FIB_PATH_UNSUPPORTED_NH_PROTO: vnet_api_error_t = -157;
6091pub const vnet_api_error_t_VNET_API_ERROR_API_ENDIAN_FAILED: vnet_api_error_t = -159;
6092pub const vnet_api_error_t_VNET_API_ERROR_NO_CHANGE: vnet_api_error_t = -160;
6093pub const vnet_api_error_t_VNET_API_ERROR_MISSING_CERT_KEY: vnet_api_error_t = -161;
6094pub const vnet_api_error_t_VNET_API_ERROR_LIMIT_EXCEEDED: vnet_api_error_t = -162;
6095pub const vnet_api_error_t_VNET_API_ERROR_IKE_NO_PORT: vnet_api_error_t = -163;
6096pub const vnet_api_error_t_VNET_API_ERROR_UDP_PORT_TAKEN: vnet_api_error_t = -164;
6097pub const vnet_api_error_t_VNET_API_ERROR_EAGAIN: vnet_api_error_t = -165;
6098pub const vnet_api_error_t_VNET_API_ERROR_INVALID_VALUE_4: vnet_api_error_t = -166;
6099pub const vnet_api_error_t_VNET_API_ERROR_BUSY: vnet_api_error_t = -167;
6100pub const vnet_api_error_t_VNET_API_ERROR_BUG: vnet_api_error_t = -168;
6101pub const vnet_api_error_t_VNET_API_ERROR_FEATURE_ALREADY_DISABLED: vnet_api_error_t = -169;
6102pub const vnet_api_error_t_VNET_API_ERROR_FEATURE_ALREADY_ENABLED: vnet_api_error_t = -170;
6103pub const vnet_api_error_t_VNET_API_ERROR_INVALID_PREFIX_LENGTH: vnet_api_error_t = -171;
6104pub const vnet_api_error_t_VNET_API_N_ERROR: vnet_api_error_t = -170;
6105pub type vnet_api_error_t = ::std::os::raw::c_int;
6106#[repr(C)]
6107#[derive(Debug, Copy, Clone)]
6108pub struct _vnet_ip_table_function_list_elt {
6109 pub next_ip_table_function: *mut _vnet_ip_table_function_list_elt,
6110 pub fp: ::std::option::Option<
6111 unsafe extern "C" fn(
6112 vnm: *mut vnet_main_t,
6113 table_id: u32_,
6114 flags: u32_,
6115 ) -> *mut clib_error_t,
6116 >,
6117}
6118impl Default for _vnet_ip_table_function_list_elt {
6119 fn default() -> Self {
6120 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6121 unsafe {
6122 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6123 s.assume_init()
6124 }
6125 }
6126}
6127pub type _vnet_ip_table_function_list_elt_t = _vnet_ip_table_function_list_elt;
6128#[repr(C)]
6129#[derive(Debug, Copy, Clone)]
6130pub struct vnet_pcap_t {
6131 pub pcap_rx_enable: u8_,
6132 pub pcap_tx_enable: u8_,
6133 pub pcap_drop_enable: u8_,
6134 pub pcap_filter_enable: u8_,
6135 pub max_bytes_per_pkt: u32_,
6136 pub pcap_sw_if_index: u32_,
6137 pub pcap_main: pcap_main_t,
6138 pub filter_classify_table_index: u32_,
6139 pub current_filter_function: vlib_is_packet_traced_fn_t,
6140 pub pcap_error_index: vlib_error_t,
6141}
6142impl Default for vnet_pcap_t {
6143 fn default() -> Self {
6144 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6145 unsafe {
6146 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6147 s.assume_init()
6148 }
6149 }
6150}
6151#[repr(C)]
6152#[derive(Debug, Copy, Clone)]
6153pub struct vnet_main_t {
6154 pub local_interface_hw_if_index: u32_,
6155 pub local_interface_sw_if_index: u32_,
6156 pub interface_main: vnet_interface_main_t,
6157 pub device_class_registrations: *mut vnet_device_class_t,
6158 pub hw_interface_class_registrations: *mut vnet_hw_interface_class_t,
6159 pub hw_interface_add_del_functions: [*mut _vnet_interface_function_list_elt_t; 2usize],
6160 pub hw_interface_link_up_down_functions: [*mut _vnet_interface_function_list_elt_t; 2usize],
6161 pub sw_interface_add_del_functions: [*mut _vnet_interface_function_list_elt_t; 2usize],
6162 pub sw_interface_admin_up_down_functions: [*mut _vnet_interface_function_list_elt_t; 2usize],
6163 pub sw_interface_mtu_change_functions: [*mut _vnet_interface_function_list_elt_t; 2usize],
6164 pub interface_tag_by_sw_if_index: *mut uword,
6165 pub ip_table_add_del_functions: [*mut _vnet_ip_table_function_list_elt_t; 2usize],
6166 pub pcap: vnet_pcap_t,
6167 pub api_errno: vnet_api_error_t,
6168 pub vlib_main: *mut vlib_main_t,
6169}
6170impl Default for vnet_main_t {
6171 fn default() -> Self {
6172 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6173 unsafe {
6174 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6175 s.assume_init()
6176 }
6177 }
6178}
6179unsafe extern "C" {
6180 pub fn vnet_get_main() -> *mut vnet_main_t;
6181}
6182#[repr(C)]
6183#[derive(Debug, Copy, Clone)]
6184pub struct _vnet_feature_arc_registration {
6185 pub next: *mut _vnet_feature_arc_registration,
6186 pub arc_name: *mut ::std::os::raw::c_char,
6187 pub start_nodes: *mut *mut ::std::os::raw::c_char,
6188 pub n_start_nodes: ::std::os::raw::c_int,
6189 pub last_in_arc: *mut ::std::os::raw::c_char,
6190 pub feature_arc_index: u8_,
6191 pub arc_index_ptr: *mut u8_,
6192}
6193impl Default for _vnet_feature_arc_registration {
6194 fn default() -> Self {
6195 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6196 unsafe {
6197 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6198 s.assume_init()
6199 }
6200 }
6201}
6202pub type vnet_feature_arc_registration_t = _vnet_feature_arc_registration;
6203pub type vnet_feature_enable_disable_function_t = ::std::option::Option<
6204 unsafe extern "C" fn(
6205 sw_if_index: u32_,
6206 enable_disable: ::std::os::raw::c_int,
6207 ) -> *mut clib_error_t,
6208>;
6209#[repr(C)]
6210#[derive(Debug, Copy, Clone)]
6211pub struct _vnet_feature_registration {
6212 pub next: *mut _vnet_feature_registration,
6213 pub next_in_arc: *mut _vnet_feature_registration,
6214 pub arc_name: *mut ::std::os::raw::c_char,
6215 pub node_name: *mut ::std::os::raw::c_char,
6216 pub feature_index_ptr: *mut u32_,
6217 pub feature_index: u32_,
6218 pub runs_before: *mut *mut ::std::os::raw::c_char,
6219 pub runs_after: *mut *mut ::std::os::raw::c_char,
6220 pub enable_disable_cb: vnet_feature_enable_disable_function_t,
6221}
6222impl Default for _vnet_feature_registration {
6223 fn default() -> Self {
6224 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6225 unsafe {
6226 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6227 s.assume_init()
6228 }
6229 }
6230}
6231pub type vnet_feature_registration_t = _vnet_feature_registration;
6232#[repr(C)]
6233#[derive(Debug, Copy, Clone)]
6234pub struct _vnet_feature_constraint_registration {
6235 pub next: *mut _vnet_feature_constraint_registration,
6236 pub next_in_arc: *mut _vnet_feature_constraint_registration,
6237 pub arc_name: *mut ::std::os::raw::c_char,
6238 pub feature_arc_index: u8_,
6239 pub node_names: *mut *mut ::std::os::raw::c_char,
6240}
6241impl Default for _vnet_feature_constraint_registration {
6242 fn default() -> Self {
6243 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6244 unsafe {
6245 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6246 s.assume_init()
6247 }
6248 }
6249}
6250pub type vnet_feature_constraint_registration_t = _vnet_feature_constraint_registration;
6251#[repr(C)]
6252#[derive(Debug, Copy, Clone)]
6253pub struct vnet_feature_config_main_t_ {
6254 pub config_main: vnet_config_main_t,
6255 pub config_index_by_sw_if_index: *mut u32_,
6256}
6257impl Default for vnet_feature_config_main_t_ {
6258 fn default() -> Self {
6259 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6260 unsafe {
6261 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6262 s.assume_init()
6263 }
6264 }
6265}
6266pub type vnet_feature_config_main_t = vnet_feature_config_main_t_;
6267#[repr(C)]
6268#[derive(Debug, Copy, Clone)]
6269pub struct vnet_feature_main_t {
6270 pub next_arc: *mut vnet_feature_arc_registration_t,
6271 pub arc_index_by_name: *mut *mut uword,
6272 pub next_feature: *mut vnet_feature_registration_t,
6273 pub next_feature_by_arc: *mut *mut vnet_feature_registration_t,
6274 pub next_constraint: *mut vnet_feature_constraint_registration_t,
6275 pub next_constraint_by_arc: *mut *mut vnet_feature_constraint_registration_t,
6276 pub next_feature_by_name: *mut *mut uword,
6277 pub feature_config_mains: *mut vnet_feature_config_main_t,
6278 pub feature_nodes: *mut *mut *mut ::std::os::raw::c_char,
6279 pub sw_if_index_has_features: *mut *mut uword,
6280 pub feature_count_by_sw_if_index: *mut *mut i16_,
6281 pub device_input_feature_arc_index: u8_,
6282 pub vlib_main: *mut vlib_main_t,
6283 pub vnet_main: *mut vnet_main_t,
6284}
6285impl Default for vnet_feature_main_t {
6286 fn default() -> Self {
6287 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6288 unsafe {
6289 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6290 s.assume_init()
6291 }
6292 }
6293}
6294unsafe extern "C" {
6295 pub static mut feature_main: vnet_feature_main_t;
6296}
6297unsafe extern "C" {
6298 pub fn vnet_config_update_feature_count(
6299 fm: *mut vnet_feature_main_t,
6300 arc: u8_,
6301 sw_if_index: u32_,
6302 is_add: ::std::os::raw::c_int,
6303 );
6304}
6305unsafe extern "C" {
6306 pub fn vnet_get_feature_index(arc: u8_, s: *const ::std::os::raw::c_char) -> u32_;
6307}
6308unsafe extern "C" {
6309 pub fn vnet_get_feature_arc_index(s: *const ::std::os::raw::c_char) -> u8_;
6310}
6311unsafe extern "C" {
6312 pub fn vnet_get_feature_reg(
6313 arc_name: *const ::std::os::raw::c_char,
6314 node_name: *const ::std::os::raw::c_char,
6315 ) -> *mut vnet_feature_registration_t;
6316}
6317unsafe extern "C" {
6318 pub fn vnet_feature_enable_disable_with_index(
6319 arc_index: u8_,
6320 feature_index: u32_,
6321 sw_if_index: u32_,
6322 enable_disable: ::std::os::raw::c_int,
6323 feature_config: *mut ::std::os::raw::c_void,
6324 n_feature_config_bytes: u32_,
6325 ) -> ::std::os::raw::c_int;
6326}
6327unsafe extern "C" {
6328 pub fn vnet_feature_enable_disable(
6329 arc_name: *const ::std::os::raw::c_char,
6330 node_name: *const ::std::os::raw::c_char,
6331 sw_if_index: u32_,
6332 enable_disable: ::std::os::raw::c_int,
6333 feature_config: *mut ::std::os::raw::c_void,
6334 n_feature_config_bytes: u32_,
6335 ) -> ::std::os::raw::c_int;
6336}
6337unsafe extern "C" {
6338 pub fn vnet_feature_modify_end_node(
6339 arc_index: u8_,
6340 sw_if_index: u32_,
6341 node_index: u32_,
6342 ) -> u32_;
6343}
6344unsafe extern "C" {
6345 pub fn vnet_feature_get_end_node(arc_index: u8_, sw_if_index: u32_) -> u32_;
6346}
6347unsafe extern "C" {
6348 pub fn vnet_feature_reset_end_node(arc_index: u8_, sw_if_index: u32_) -> u32_;
6349}
6350unsafe extern "C" {
6351 pub fn vnet_feature_arc_init(
6352 vm: *mut vlib_main_t,
6353 vcm: *mut vnet_config_main_t,
6354 feature_start_nodes: *mut *mut ::std::os::raw::c_char,
6355 num_feature_start_nodes: ::std::os::raw::c_int,
6356 last_in_arc: *mut ::std::os::raw::c_char,
6357 first_reg: *mut vnet_feature_registration_t,
6358 first_const_set: *mut vnet_feature_constraint_registration_t,
6359 in_feature_nodes: *mut *mut *mut ::std::os::raw::c_char,
6360 ) -> *mut clib_error_t;
6361}
6362unsafe extern "C" {
6363 pub fn vnet_interface_features_show(
6364 vm: *mut vlib_main_t,
6365 sw_if_index: u32_,
6366 verbose: ::std::os::raw::c_int,
6367 );
6368}
6369pub type vnet_feature_update_cb_t = ::std::option::Option<
6370 unsafe extern "C" fn(
6371 sw_if_index: u32_,
6372 arc_index: u8_,
6373 is_enable: u8_,
6374 cb: *mut ::std::os::raw::c_void,
6375 ),
6376>;
6377unsafe extern "C" {
6378 pub fn vnet_feature_register(cb: vnet_feature_update_cb_t, data: *mut ::std::os::raw::c_void);
6379}
6380unsafe extern "C" {
6381 pub fn vnet_feature_is_enabled(
6382 arc_name: *const ::std::os::raw::c_char,
6383 feature_node_name: *const ::std::os::raw::c_char,
6384 sw_if_index: u32_,
6385 ) -> ::std::os::raw::c_int;
6386}
6387#[repr(C)]
6388#[derive(Debug, Default, Copy, Clone)]
6389pub struct stat {
6390 pub st_dev: __dev_t,
6391 pub st_ino: __ino_t,
6392 pub st_nlink: __nlink_t,
6393 pub st_mode: __mode_t,
6394 pub st_uid: __uid_t,
6395 pub st_gid: __gid_t,
6396 pub __pad0: ::std::os::raw::c_int,
6397 pub st_rdev: __dev_t,
6398 pub st_size: __off_t,
6399 pub st_blksize: __blksize_t,
6400 pub st_blocks: __blkcnt_t,
6401 pub st_atim: timespec,
6402 pub st_mtim: timespec,
6403 pub st_ctim: timespec,
6404 pub __glibc_reserved: [__syscall_slong_t; 3usize],
6405}
6406#[repr(C)]
6407#[repr(align(64))]
6408#[derive(Debug)]
6409pub struct vlib_plugin_registration_t {
6410 pub cacheline0: __IncompleteArrayField<u8_>,
6411 pub _bitfield_align_1: [u8; 0],
6412 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6413 pub version: [::std::os::raw::c_char; 64usize],
6414 pub version_required: [::std::os::raw::c_char; 64usize],
6415 pub overrides: [::std::os::raw::c_char; 256usize],
6416 pub early_init: *const ::std::os::raw::c_char,
6417 pub description: *const ::std::os::raw::c_char,
6418}
6419impl Default for vlib_plugin_registration_t {
6420 fn default() -> Self {
6421 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6422 unsafe {
6423 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6424 s.assume_init()
6425 }
6426 }
6427}
6428impl vlib_plugin_registration_t {
6429 #[inline]
6430 pub fn default_disabled(&self) -> u8_ {
6431 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
6432 }
6433 #[inline]
6434 pub fn set_default_disabled(&mut self, val: u8_) {
6435 unsafe {
6436 let val: u8 = ::std::mem::transmute(val);
6437 self._bitfield_1.set(0usize, 1u8, val as u64)
6438 }
6439 }
6440 #[inline]
6441 pub unsafe fn default_disabled_raw(this: *const Self) -> u8_ {
6442 unsafe {
6443 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
6444 ::std::ptr::addr_of!((*this)._bitfield_1),
6445 0usize,
6446 1u8,
6447 ) as u8)
6448 }
6449 }
6450 #[inline]
6451 pub unsafe fn set_default_disabled_raw(this: *mut Self, val: u8_) {
6452 unsafe {
6453 let val: u8 = ::std::mem::transmute(val);
6454 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
6455 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6456 0usize,
6457 1u8,
6458 val as u64,
6459 )
6460 }
6461 }
6462 #[inline]
6463 pub fn deep_bind(&self) -> u8_ {
6464 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
6465 }
6466 #[inline]
6467 pub fn set_deep_bind(&mut self, val: u8_) {
6468 unsafe {
6469 let val: u8 = ::std::mem::transmute(val);
6470 self._bitfield_1.set(1usize, 1u8, val as u64)
6471 }
6472 }
6473 #[inline]
6474 pub unsafe fn deep_bind_raw(this: *const Self) -> u8_ {
6475 unsafe {
6476 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
6477 ::std::ptr::addr_of!((*this)._bitfield_1),
6478 1usize,
6479 1u8,
6480 ) as u8)
6481 }
6482 }
6483 #[inline]
6484 pub unsafe fn set_deep_bind_raw(this: *mut Self, val: u8_) {
6485 unsafe {
6486 let val: u8 = ::std::mem::transmute(val);
6487 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
6488 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6489 1usize,
6490 1u8,
6491 val as u64,
6492 )
6493 }
6494 }
6495 #[inline]
6496 pub fn new_bitfield_1(
6497 default_disabled: u8_,
6498 deep_bind: u8_,
6499 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6500 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6501 __bindgen_bitfield_unit.set(0usize, 1u8, {
6502 let default_disabled: u8 = unsafe { ::std::mem::transmute(default_disabled) };
6503 default_disabled as u64
6504 });
6505 __bindgen_bitfield_unit.set(1usize, 1u8, {
6506 let deep_bind: u8 = unsafe { ::std::mem::transmute(deep_bind) };
6507 deep_bind as u64
6508 });
6509 __bindgen_bitfield_unit
6510 }
6511}
6512#[repr(C)]
6513#[derive(Debug, Default, Copy, Clone)]
6514pub struct vlib_r2_string_t {
6515 pub data_segment_offset: uword,
6516 pub length: uword,
6517}
6518#[repr(C)]
6519#[derive(Debug, Default, Copy, Clone)]
6520pub struct vlib_plugin_r2_t {
6521 pub default_disabled: ::std::os::raw::c_int,
6522 pub version: vlib_r2_string_t,
6523 pub version_required: vlib_r2_string_t,
6524 pub overrides: vlib_r2_string_t,
6525 pub early_init: vlib_r2_string_t,
6526 pub description: vlib_r2_string_t,
6527}
6528#[repr(C)]
6529#[derive(Debug, Copy, Clone)]
6530pub struct plugin_info_t {
6531 pub name: *mut u8_,
6532 pub filename: *mut u8_,
6533 pub file_info: stat,
6534 pub handle: *mut ::std::os::raw::c_void,
6535 pub reg: *mut vlib_plugin_registration_t,
6536 pub version: *mut ::std::os::raw::c_char,
6537}
6538impl Default for plugin_info_t {
6539 fn default() -> Self {
6540 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6541 unsafe {
6542 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6543 s.assume_init()
6544 }
6545 }
6546}
6547#[repr(C)]
6548#[derive(Debug, Copy, Clone)]
6549pub struct plugin_config_t {
6550 pub name: *mut ::std::os::raw::c_char,
6551 pub is_disabled: u8_,
6552 pub is_enabled: u8_,
6553 pub skip_version_check: u8_,
6554}
6555impl Default for plugin_config_t {
6556 fn default() -> Self {
6557 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6558 unsafe {
6559 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6560 s.assume_init()
6561 }
6562 }
6563}
6564#[repr(C)]
6565#[derive(Debug, Copy, Clone)]
6566pub struct plugin_main_t {
6567 pub plugin_info: *mut plugin_info_t,
6568 pub plugin_by_name_hash: *mut uword,
6569 pub plugin_overrides_by_name_hash: *mut uword,
6570 pub plugin_path: *mut u8_,
6571 pub plugin_path_add: *mut u8_,
6572 pub plugin_name_filter: *mut u8_,
6573 pub vat_plugin_path: *mut u8_,
6574 pub vat_plugin_name_filter: *mut u8_,
6575 pub plugins_default_disable: u8_,
6576 pub configs: *mut plugin_config_t,
6577 pub config_index_by_name: *mut uword,
6578 pub logger: vlib_log_class_t,
6579 pub vlib_main: *mut vlib_main_t,
6580}
6581impl Default for plugin_main_t {
6582 fn default() -> Self {
6583 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6584 unsafe {
6585 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6586 s.assume_init()
6587 }
6588 }
6589}
6590unsafe extern "C" {
6591 pub static mut vlib_plugin_main: plugin_main_t;
6592}
6593unsafe extern "C" {
6594 pub fn vlib_plugin_config(
6595 vm: *mut vlib_main_t,
6596 input: *mut unformat_input_t,
6597 ) -> *mut clib_error_t;
6598}
6599unsafe extern "C" {
6600 pub fn vlib_plugin_early_init(vm: *mut vlib_main_t) -> ::std::os::raw::c_int;
6601}
6602unsafe extern "C" {
6603 pub fn vlib_load_new_plugins(
6604 pm: *mut plugin_main_t,
6605 from_early_init: ::std::os::raw::c_int,
6606 ) -> ::std::os::raw::c_int;
6607}
6608unsafe extern "C" {
6609 pub fn vlib_get_plugin_symbol(
6610 plugin_name: *const ::std::os::raw::c_char,
6611 symbol_name: *const ::std::os::raw::c_char,
6612 ) -> *mut ::std::os::raw::c_void;
6613}
6614unsafe extern "C" {
6615 pub fn vlib_get_vat_plugin_path() -> *mut u8_;
6616}
6617pub const ip_dscp_t__IP_DSCP_CS0: ip_dscp_t_ = 0;
6618pub const ip_dscp_t__IP_DSCP_CS1: ip_dscp_t_ = 8;
6619pub const ip_dscp_t__IP_DSCP_AF11: ip_dscp_t_ = 10;
6620pub const ip_dscp_t__IP_DSCP_AF12: ip_dscp_t_ = 12;
6621pub const ip_dscp_t__IP_DSCP_AF13: ip_dscp_t_ = 14;
6622pub const ip_dscp_t__IP_DSCP_CS2: ip_dscp_t_ = 16;
6623pub const ip_dscp_t__IP_DSCP_AF21: ip_dscp_t_ = 18;
6624pub const ip_dscp_t__IP_DSCP_AF22: ip_dscp_t_ = 20;
6625pub const ip_dscp_t__IP_DSCP_AF23: ip_dscp_t_ = 22;
6626pub const ip_dscp_t__IP_DSCP_CS3: ip_dscp_t_ = 24;
6627pub const ip_dscp_t__IP_DSCP_AF31: ip_dscp_t_ = 26;
6628pub const ip_dscp_t__IP_DSCP_AF32: ip_dscp_t_ = 28;
6629pub const ip_dscp_t__IP_DSCP_AF33: ip_dscp_t_ = 30;
6630pub const ip_dscp_t__IP_DSCP_CS4: ip_dscp_t_ = 32;
6631pub const ip_dscp_t__IP_DSCP_AF41: ip_dscp_t_ = 34;
6632pub const ip_dscp_t__IP_DSCP_AF42: ip_dscp_t_ = 36;
6633pub const ip_dscp_t__IP_DSCP_AF43: ip_dscp_t_ = 38;
6634pub const ip_dscp_t__IP_DSCP_CS5: ip_dscp_t_ = 40;
6635pub const ip_dscp_t__IP_DSCP_EF: ip_dscp_t_ = 46;
6636pub const ip_dscp_t__IP_DSCP_CS6: ip_dscp_t_ = 48;
6637pub const ip_dscp_t__IP_DSCP_CS7: ip_dscp_t_ = 50;
6638pub type ip_dscp_t_ = ::std::os::raw::c_uchar;
6639pub use self::ip_dscp_t_ as ip_dscp_t;
6640#[repr(C)]
6641#[derive(Copy, Clone)]
6642pub union ip4_address_t {
6643 pub data: [u8_; 4usize],
6644 pub data_u32: u32_,
6645 pub as_u8: [u8_; 4usize],
6646 pub as_u16: [u16_; 2usize],
6647 pub as_u32: u32_,
6648}
6649impl Default for ip4_address_t {
6650 fn default() -> Self {
6651 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6652 unsafe {
6653 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6654 s.assume_init()
6655 }
6656 }
6657}
6658#[repr(C)]
6659#[derive(Copy, Clone)]
6660pub struct ip4_address_pair_t {
6661 pub src: ip4_address_t,
6662 pub dst: ip4_address_t,
6663}
6664impl Default for ip4_address_pair_t {
6665 fn default() -> Self {
6666 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6667 unsafe {
6668 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6669 s.assume_init()
6670 }
6671 }
6672}
6673#[repr(C)]
6674#[derive(Copy, Clone)]
6675pub union ip4_header_t {
6676 pub __bindgen_anon_1: ip4_header_t__bindgen_ty_1,
6677 pub __bindgen_anon_2: ip4_header_t__bindgen_ty_2,
6678 pub __bindgen_anon_3: ip4_header_t__bindgen_ty_3,
6679}
6680#[repr(C, packed)]
6681#[derive(Copy, Clone)]
6682pub struct ip4_header_t__bindgen_ty_1 {
6683 pub ip_version_and_header_length: u8_,
6684 pub tos: ip_dscp_t,
6685 pub length: u16_,
6686 pub fragment_id: u16_,
6687 pub flags_and_fragment_offset: u16_,
6688 pub ttl: u8_,
6689 pub protocol: u8_,
6690 pub checksum: u16_,
6691 pub __bindgen_anon_1: ip4_header_t__bindgen_ty_1__bindgen_ty_1,
6692}
6693#[repr(C)]
6694#[derive(Copy, Clone)]
6695pub union ip4_header_t__bindgen_ty_1__bindgen_ty_1 {
6696 pub __bindgen_anon_1: ip4_header_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
6697 pub address_pair: ip4_address_pair_t,
6698}
6699#[repr(C)]
6700#[derive(Copy, Clone)]
6701pub struct ip4_header_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
6702 pub src_address: ip4_address_t,
6703 pub dst_address: ip4_address_t,
6704}
6705impl Default for ip4_header_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
6706 fn default() -> Self {
6707 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6708 unsafe {
6709 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6710 s.assume_init()
6711 }
6712 }
6713}
6714impl Default for ip4_header_t__bindgen_ty_1__bindgen_ty_1 {
6715 fn default() -> Self {
6716 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6717 unsafe {
6718 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6719 s.assume_init()
6720 }
6721 }
6722}
6723impl Default for ip4_header_t__bindgen_ty_1 {
6724 fn default() -> Self {
6725 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6726 unsafe {
6727 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6728 s.assume_init()
6729 }
6730 }
6731}
6732#[repr(C, packed)]
6733#[derive(Debug, Default, Copy, Clone)]
6734pub struct ip4_header_t__bindgen_ty_2 {
6735 pub checksum_data_64: [u64_; 2usize],
6736 pub checksum_data_64_32: [u32_; 1usize],
6737}
6738#[repr(C, packed)]
6739#[derive(Debug, Default, Copy, Clone)]
6740pub struct ip4_header_t__bindgen_ty_3 {
6741 pub checksum_data_32: [u32_; 5usize],
6742}
6743impl Default for ip4_header_t {
6744 fn default() -> Self {
6745 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6746 unsafe {
6747 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6748 s.assume_init()
6749 }
6750 }
6751}
6752#[repr(C, packed)]
6753pub struct ip6_header_t {
6754 pub ip_version_traffic_class_and_flow_label: u32_,
6755 pub payload_length: u16_,
6756 pub protocol: u8_,
6757 pub hop_limit: u8_,
6758 pub src_address: ip6_address_t,
6759 pub dst_address: ip6_address_t,
6760}
6761impl Default for ip6_header_t {
6762 fn default() -> Self {
6763 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6764 unsafe {
6765 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6766 s.assume_init()
6767 }
6768 }
6769}
6770#[repr(C)]
6771#[derive(Copy, Clone)]
6772pub struct svm_region_ {
6773 pub version: uword,
6774 pub mutex: pthread_mutex_t,
6775 pub condvar: pthread_cond_t,
6776 pub mutex_owner_pid: ::std::os::raw::c_int,
6777 pub mutex_owner_tag: ::std::os::raw::c_int,
6778 pub flags: uword,
6779 pub virtual_base: uword,
6780 pub virtual_size: uword,
6781 pub region_heap: *mut ::std::os::raw::c_void,
6782 pub data_base: *mut ::std::os::raw::c_void,
6783 pub data_heap: *mut ::std::os::raw::c_void,
6784 pub user_ctx: *mut ::std::os::raw::c_void,
6785 pub bitmap_size: uword,
6786 pub bitmap: *mut uword,
6787 pub region_name: *mut ::std::os::raw::c_char,
6788 pub backing_file: *mut ::std::os::raw::c_char,
6789 pub filenames: *mut *mut ::std::os::raw::c_char,
6790 pub client_pids: *mut uword,
6791}
6792impl Default for svm_region_ {
6793 fn default() -> Self {
6794 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6795 unsafe {
6796 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6797 s.assume_init()
6798 }
6799 }
6800}
6801pub type svm_region_t = svm_region_;
6802#[repr(C)]
6803pub struct _svm_queue<FAM: ?Sized = [::std::os::raw::c_char; 0]> {
6804 pub mutex: pthread_mutex_t,
6805 pub condvar: pthread_cond_t,
6806 pub head: ::std::os::raw::c_int,
6807 pub tail: ::std::os::raw::c_int,
6808 pub cursize: ::std::os::raw::c_int,
6809 pub maxsize: ::std::os::raw::c_int,
6810 pub elsize: ::std::os::raw::c_int,
6811 pub consumer_pid: ::std::os::raw::c_int,
6812 pub producer_evtfd: ::std::os::raw::c_int,
6813 pub consumer_evtfd: ::std::os::raw::c_int,
6814 pub data: FAM,
6815}
6816impl _svm_queue<[::std::os::raw::c_char]> {}
6817impl _svm_queue<[::std::os::raw::c_char; 0]> {}
6818impl Default for _svm_queue<[::std::os::raw::c_char; 0]> {
6819 fn default() -> Self {
6820 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6821 unsafe {
6822 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6823 s.assume_init()
6824 }
6825 }
6826}
6827pub type svm_queue_t = _svm_queue;
6828#[repr(C)]
6829#[derive(Debug, Copy, Clone)]
6830pub struct cJSON {
6831 pub next: *mut cJSON,
6832 pub prev: *mut cJSON,
6833 pub child: *mut cJSON,
6834 pub type_: ::std::os::raw::c_int,
6835 pub valuestring: *mut ::std::os::raw::c_char,
6836 pub valueint: ::std::os::raw::c_int,
6837 pub valuedouble: f64,
6838 pub string: *mut ::std::os::raw::c_char,
6839}
6840impl Default for cJSON {
6841 fn default() -> Self {
6842 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6843 unsafe {
6844 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6845 s.assume_init()
6846 }
6847 }
6848}
6849pub const vl_registration_type_t_REGISTRATION_TYPE_FREE: vl_registration_type_t = 0;
6850pub const vl_registration_type_t_REGISTRATION_TYPE_SHMEM: vl_registration_type_t = 1;
6851pub const vl_registration_type_t_REGISTRATION_TYPE_SOCKET_LISTEN: vl_registration_type_t = 2;
6852pub const vl_registration_type_t_REGISTRATION_TYPE_SOCKET_SERVER: vl_registration_type_t = 3;
6853pub const vl_registration_type_t_REGISTRATION_TYPE_SOCKET_CLIENT: vl_registration_type_t = 4;
6854pub type vl_registration_type_t = ::std::os::raw::c_uint;
6855#[repr(C)]
6856#[derive(Debug, Copy, Clone)]
6857pub struct vl_api_registration_ {
6858 pub registration_type: vl_registration_type_t,
6859 pub vl_api_registration_pool_index: u32_,
6860 pub name: *mut u8_,
6861 pub last_heard: f64_,
6862 pub last_queue_head: ::std::os::raw::c_int,
6863 pub unanswered_pings: ::std::os::raw::c_int,
6864 pub is_being_removed: ::std::os::raw::c_int,
6865 pub vl_input_queue: *mut svm_queue_t,
6866 pub vlib_rp: *mut svm_region_t,
6867 pub shmem_hdr: *mut ::std::os::raw::c_void,
6868 pub clib_file_index: u32_,
6869 pub unprocessed_input: *mut i8_,
6870 pub unprocessed_msg_length: u32_,
6871 pub output_vector: *mut u8_,
6872 pub additional_fds_to_close: *mut ::std::os::raw::c_int,
6873 pub server_handle: u32_,
6874 pub server_index: u32_,
6875 pub keepalive: bool,
6876}
6877impl Default for vl_api_registration_ {
6878 fn default() -> Self {
6879 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6880 unsafe {
6881 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6882 s.assume_init()
6883 }
6884 }
6885}
6886pub type vl_api_registration_t = vl_api_registration_;
6887#[repr(C)]
6888#[derive(Debug, Copy, Clone)]
6889pub struct vl_api_trace_t {
6890 pub endian: u8_,
6891 pub enabled: u8_,
6892 pub wrapped: u8_,
6893 pub pad: u8_,
6894 pub nitems: u32_,
6895 pub curindex: u32_,
6896 pub traces: *mut *mut u8_,
6897}
6898impl Default for vl_api_trace_t {
6899 fn default() -> Self {
6900 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6901 unsafe {
6902 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6903 s.assume_init()
6904 }
6905 }
6906}
6907pub const vl_api_trace_which_t_VL_API_TRACE_TX: vl_api_trace_which_t = 0;
6908pub const vl_api_trace_which_t_VL_API_TRACE_RX: vl_api_trace_which_t = 1;
6909pub type vl_api_trace_which_t = ::std::os::raw::c_uint;
6910#[repr(C)]
6911#[derive(Debug, Copy, Clone)]
6912pub struct vl_api_msg_range_t {
6913 pub name: *mut u8_,
6914 pub first_msg_id: u16_,
6915 pub last_msg_id: u16_,
6916}
6917impl Default for vl_api_msg_range_t {
6918 fn default() -> Self {
6919 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6920 unsafe {
6921 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6922 s.assume_init()
6923 }
6924 }
6925}
6926#[repr(C)]
6927#[derive(Debug, Copy, Clone)]
6928pub struct vl_msg_api_msg_config_t {
6929 pub id: ::std::os::raw::c_int,
6930 pub name: *mut ::std::os::raw::c_char,
6931 pub crc: u32_,
6932 pub handler: *mut ::std::os::raw::c_void,
6933 pub cleanup: *mut ::std::os::raw::c_void,
6934 pub endian: *mut ::std::os::raw::c_void,
6935 pub format_fn: *mut ::std::os::raw::c_void,
6936 pub tojson: *mut ::std::os::raw::c_void,
6937 pub fromjson: *mut ::std::os::raw::c_void,
6938 pub calc_size: *mut ::std::os::raw::c_void,
6939 pub size: ::std::os::raw::c_int,
6940 pub _bitfield_align_1: [u8; 0],
6941 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6942 pub __bindgen_padding_0: [u8; 3usize],
6943}
6944impl Default for vl_msg_api_msg_config_t {
6945 fn default() -> Self {
6946 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6947 unsafe {
6948 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6949 s.assume_init()
6950 }
6951 }
6952}
6953impl vl_msg_api_msg_config_t {
6954 #[inline]
6955 pub fn traced(&self) -> u32_ {
6956 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6957 }
6958 #[inline]
6959 pub fn set_traced(&mut self, val: u32_) {
6960 unsafe {
6961 let val: u32 = ::std::mem::transmute(val);
6962 self._bitfield_1.set(0usize, 1u8, val as u64)
6963 }
6964 }
6965 #[inline]
6966 pub unsafe fn traced_raw(this: *const Self) -> u32_ {
6967 unsafe {
6968 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
6969 ::std::ptr::addr_of!((*this)._bitfield_1),
6970 0usize,
6971 1u8,
6972 ) as u32)
6973 }
6974 }
6975 #[inline]
6976 pub unsafe fn set_traced_raw(this: *mut Self, val: u32_) {
6977 unsafe {
6978 let val: u32 = ::std::mem::transmute(val);
6979 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
6980 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6981 0usize,
6982 1u8,
6983 val as u64,
6984 )
6985 }
6986 }
6987 #[inline]
6988 pub fn replay(&self) -> u32_ {
6989 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6990 }
6991 #[inline]
6992 pub fn set_replay(&mut self, val: u32_) {
6993 unsafe {
6994 let val: u32 = ::std::mem::transmute(val);
6995 self._bitfield_1.set(1usize, 1u8, val as u64)
6996 }
6997 }
6998 #[inline]
6999 pub unsafe fn replay_raw(this: *const Self) -> u32_ {
7000 unsafe {
7001 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7002 ::std::ptr::addr_of!((*this)._bitfield_1),
7003 1usize,
7004 1u8,
7005 ) as u32)
7006 }
7007 }
7008 #[inline]
7009 pub unsafe fn set_replay_raw(this: *mut Self, val: u32_) {
7010 unsafe {
7011 let val: u32 = ::std::mem::transmute(val);
7012 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7013 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7014 1usize,
7015 1u8,
7016 val as u64,
7017 )
7018 }
7019 }
7020 #[inline]
7021 pub fn message_bounce(&self) -> u32_ {
7022 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
7023 }
7024 #[inline]
7025 pub fn set_message_bounce(&mut self, val: u32_) {
7026 unsafe {
7027 let val: u32 = ::std::mem::transmute(val);
7028 self._bitfield_1.set(2usize, 1u8, val as u64)
7029 }
7030 }
7031 #[inline]
7032 pub unsafe fn message_bounce_raw(this: *const Self) -> u32_ {
7033 unsafe {
7034 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7035 ::std::ptr::addr_of!((*this)._bitfield_1),
7036 2usize,
7037 1u8,
7038 ) as u32)
7039 }
7040 }
7041 #[inline]
7042 pub unsafe fn set_message_bounce_raw(this: *mut Self, val: u32_) {
7043 unsafe {
7044 let val: u32 = ::std::mem::transmute(val);
7045 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7046 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7047 2usize,
7048 1u8,
7049 val as u64,
7050 )
7051 }
7052 }
7053 #[inline]
7054 pub fn is_mp_safe(&self) -> u32_ {
7055 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
7056 }
7057 #[inline]
7058 pub fn set_is_mp_safe(&mut self, val: u32_) {
7059 unsafe {
7060 let val: u32 = ::std::mem::transmute(val);
7061 self._bitfield_1.set(3usize, 1u8, val as u64)
7062 }
7063 }
7064 #[inline]
7065 pub unsafe fn is_mp_safe_raw(this: *const Self) -> u32_ {
7066 unsafe {
7067 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7068 ::std::ptr::addr_of!((*this)._bitfield_1),
7069 3usize,
7070 1u8,
7071 ) as u32)
7072 }
7073 }
7074 #[inline]
7075 pub unsafe fn set_is_mp_safe_raw(this: *mut Self, val: u32_) {
7076 unsafe {
7077 let val: u32 = ::std::mem::transmute(val);
7078 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7079 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7080 3usize,
7081 1u8,
7082 val as u64,
7083 )
7084 }
7085 }
7086 #[inline]
7087 pub fn is_autoendian(&self) -> u32_ {
7088 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
7089 }
7090 #[inline]
7091 pub fn set_is_autoendian(&mut self, val: u32_) {
7092 unsafe {
7093 let val: u32 = ::std::mem::transmute(val);
7094 self._bitfield_1.set(4usize, 1u8, val as u64)
7095 }
7096 }
7097 #[inline]
7098 pub unsafe fn is_autoendian_raw(this: *const Self) -> u32_ {
7099 unsafe {
7100 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7101 ::std::ptr::addr_of!((*this)._bitfield_1),
7102 4usize,
7103 1u8,
7104 ) as u32)
7105 }
7106 }
7107 #[inline]
7108 pub unsafe fn set_is_autoendian_raw(this: *mut Self, val: u32_) {
7109 unsafe {
7110 let val: u32 = ::std::mem::transmute(val);
7111 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7112 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7113 4usize,
7114 1u8,
7115 val as u64,
7116 )
7117 }
7118 }
7119 #[inline]
7120 pub fn new_bitfield_1(
7121 traced: u32_,
7122 replay: u32_,
7123 message_bounce: u32_,
7124 is_mp_safe: u32_,
7125 is_autoendian: u32_,
7126 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7127 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7128 __bindgen_bitfield_unit.set(0usize, 1u8, {
7129 let traced: u32 = unsafe { ::std::mem::transmute(traced) };
7130 traced as u64
7131 });
7132 __bindgen_bitfield_unit.set(1usize, 1u8, {
7133 let replay: u32 = unsafe { ::std::mem::transmute(replay) };
7134 replay as u64
7135 });
7136 __bindgen_bitfield_unit.set(2usize, 1u8, {
7137 let message_bounce: u32 = unsafe { ::std::mem::transmute(message_bounce) };
7138 message_bounce as u64
7139 });
7140 __bindgen_bitfield_unit.set(3usize, 1u8, {
7141 let is_mp_safe: u32 = unsafe { ::std::mem::transmute(is_mp_safe) };
7142 is_mp_safe as u64
7143 });
7144 __bindgen_bitfield_unit.set(4usize, 1u8, {
7145 let is_autoendian: u32 = unsafe { ::std::mem::transmute(is_autoendian) };
7146 is_autoendian as u64
7147 });
7148 __bindgen_bitfield_unit
7149 }
7150}
7151#[repr(C)]
7152#[derive(Debug)]
7153pub struct msgbuf_<FAM: ?Sized = [u8_; 0]> {
7154 pub q: *mut svm_queue_t,
7155 pub data_len: u32_,
7156 pub gc_mark_timestamp: u32_,
7157 pub data: FAM,
7158}
7159impl msgbuf_<[u8_]> {}
7160impl msgbuf_<[u8_; 0]> {}
7161impl Default for msgbuf_<[u8_; 0]> {
7162 fn default() -> Self {
7163 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7164 unsafe {
7165 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7166 s.assume_init()
7167 }
7168 }
7169}
7170pub type msgbuf_t = msgbuf_;
7171unsafe extern "C" {
7172 pub fn vl_msg_api_handler(the_msg: *mut ::std::os::raw::c_void, msg_len: uword);
7173}
7174unsafe extern "C" {
7175 pub fn vl_msg_api_handler_no_free(the_msg: *mut ::std::os::raw::c_void, msg_len: uword);
7176}
7177unsafe extern "C" {
7178 pub fn vl_msg_api_handler_no_trace_no_free(
7179 the_msg: *mut ::std::os::raw::c_void,
7180 msg_len: uword,
7181 );
7182}
7183unsafe extern "C" {
7184 pub fn vl_msg_api_trace_only(the_msg: *mut ::std::os::raw::c_void, msg_len: uword);
7185}
7186unsafe extern "C" {
7187 pub fn vl_msg_api_cleanup_handler(the_msg: *mut ::std::os::raw::c_void);
7188}
7189unsafe extern "C" {
7190 pub fn vl_msg_api_replay_handler(the_msg: *mut ::std::os::raw::c_void);
7191}
7192unsafe extern "C" {
7193 pub fn vl_msg_api_socket_handler(the_msg: *mut ::std::os::raw::c_void, msg_len: uword);
7194}
7195unsafe extern "C" {
7196 pub fn vl_msg_api_clean_handlers(msg_id: ::std::os::raw::c_int);
7197}
7198unsafe extern "C" {
7199 pub fn vl_msg_api_config(arg1: *mut vl_msg_api_msg_config_t);
7200}
7201unsafe extern "C" {
7202 pub fn vl_msg_api_set_cleanup_handler(
7203 msg_id: ::std::os::raw::c_int,
7204 fp: *mut ::std::os::raw::c_void,
7205 );
7206}
7207unsafe extern "C" {
7208 pub fn vl_msg_api_queue_handler(q: *mut svm_queue_t);
7209}
7210unsafe extern "C" {
7211 pub fn vl_msg_api_barrier_sync();
7212}
7213unsafe extern "C" {
7214 pub fn vl_msg_api_barrier_release();
7215}
7216unsafe extern "C" {
7217 pub fn vl_msg_api_free(arg1: *mut ::std::os::raw::c_void);
7218}
7219unsafe extern "C" {
7220 pub fn vl_msg_api_increment_missing_client_counter();
7221}
7222unsafe extern "C" {
7223 pub fn vl_msg_api_post_mortem_dump();
7224}
7225unsafe extern "C" {
7226 pub fn vl_msg_api_post_mortem_dump_enable_disable(enable: ::std::os::raw::c_int);
7227}
7228unsafe extern "C" {
7229 pub fn vl_msg_api_register_pd_handler(
7230 handler: *mut ::std::os::raw::c_void,
7231 msg_id_host_byte_order: u16_,
7232 );
7233}
7234unsafe extern "C" {
7235 pub fn vl_msg_api_set_first_available_msg_id(first_avail: u16_);
7236}
7237unsafe extern "C" {
7238 pub fn vl_msg_api_get_msg_ids(
7239 name: *const ::std::os::raw::c_char,
7240 n: ::std::os::raw::c_int,
7241 ) -> u16_;
7242}
7243unsafe extern "C" {
7244 pub fn vl_msg_api_get_msg_index(name_and_crc: *mut u8_) -> u32_;
7245}
7246unsafe extern "C" {
7247 pub fn vl_msg_push_heap() -> *mut ::std::os::raw::c_void;
7248}
7249unsafe extern "C" {
7250 pub fn vl_msg_push_heap_w_region(vlib_rp: *mut svm_region_t) -> *mut ::std::os::raw::c_void;
7251}
7252unsafe extern "C" {
7253 pub fn vl_msg_pop_heap(oldheap: *mut ::std::os::raw::c_void);
7254}
7255unsafe extern "C" {
7256 pub fn vl_msg_pop_heap_w_region(
7257 vlib_rp: *mut svm_region_t,
7258 oldheap: *mut ::std::os::raw::c_void,
7259 );
7260}
7261pub type vl_msg_api_init_function_t =
7262 ::std::option::Option<unsafe extern "C" fn(client_index: u32_) -> *mut clib_error_t>;
7263#[repr(C)]
7264#[derive(Debug, Copy, Clone)]
7265pub struct _vl_msg_api_init_function_list_elt {
7266 pub next_init_function: *mut _vl_msg_api_init_function_list_elt,
7267 pub f: vl_msg_api_init_function_t,
7268}
7269impl Default for _vl_msg_api_init_function_list_elt {
7270 fn default() -> Self {
7271 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7272 unsafe {
7273 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7274 s.assume_init()
7275 }
7276 }
7277}
7278pub type _vl_msg_api_function_list_elt_t = _vl_msg_api_init_function_list_elt;
7279#[repr(C)]
7280#[derive(Debug, Copy, Clone)]
7281pub struct api_version_t {
7282 pub major: u32_,
7283 pub minor: u32_,
7284 pub patch: u32_,
7285 pub name: [::std::os::raw::c_char; 64usize],
7286}
7287impl Default for api_version_t {
7288 fn default() -> Self {
7289 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7290 unsafe {
7291 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7292 s.assume_init()
7293 }
7294 }
7295}
7296#[repr(C)]
7297#[derive(Debug, Copy, Clone)]
7298pub struct vl_api_msg_data_t {
7299 pub handler: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
7300 pub cleanup_handler:
7301 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
7302 pub name: *const ::std::os::raw::c_char,
7303 pub format_fn: format_function_t,
7304 pub tojson_handler: ::std::option::Option<
7305 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> *mut cJSON,
7306 >,
7307 pub fromjson_handler: ::std::option::Option<
7308 unsafe extern "C" fn(
7309 arg1: *mut cJSON,
7310 arg2: *mut ::std::os::raw::c_int,
7311 ) -> *mut ::std::os::raw::c_void,
7312 >,
7313 pub endian_handler: ::std::option::Option<
7314 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, to_net: bool),
7315 >,
7316 pub calc_size_func:
7317 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> uword>,
7318 pub trace_size: ::std::os::raw::c_int,
7319 pub _bitfield_align_1: [u8; 0],
7320 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7321 pub __bindgen_padding_0: [u8; 3usize],
7322}
7323impl Default for vl_api_msg_data_t {
7324 fn default() -> Self {
7325 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7326 unsafe {
7327 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7328 s.assume_init()
7329 }
7330 }
7331}
7332impl vl_api_msg_data_t {
7333 #[inline]
7334 pub fn bounce(&self) -> u8_ {
7335 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
7336 }
7337 #[inline]
7338 pub fn set_bounce(&mut self, val: u8_) {
7339 unsafe {
7340 let val: u8 = ::std::mem::transmute(val);
7341 self._bitfield_1.set(0usize, 1u8, val as u64)
7342 }
7343 }
7344 #[inline]
7345 pub unsafe fn bounce_raw(this: *const Self) -> u8_ {
7346 unsafe {
7347 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7348 ::std::ptr::addr_of!((*this)._bitfield_1),
7349 0usize,
7350 1u8,
7351 ) as u8)
7352 }
7353 }
7354 #[inline]
7355 pub unsafe fn set_bounce_raw(this: *mut Self, val: u8_) {
7356 unsafe {
7357 let val: u8 = ::std::mem::transmute(val);
7358 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7359 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7360 0usize,
7361 1u8,
7362 val as u64,
7363 )
7364 }
7365 }
7366 #[inline]
7367 pub fn is_mp_safe(&self) -> u8_ {
7368 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
7369 }
7370 #[inline]
7371 pub fn set_is_mp_safe(&mut self, val: u8_) {
7372 unsafe {
7373 let val: u8 = ::std::mem::transmute(val);
7374 self._bitfield_1.set(1usize, 1u8, val as u64)
7375 }
7376 }
7377 #[inline]
7378 pub unsafe fn is_mp_safe_raw(this: *const Self) -> u8_ {
7379 unsafe {
7380 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7381 ::std::ptr::addr_of!((*this)._bitfield_1),
7382 1usize,
7383 1u8,
7384 ) as u8)
7385 }
7386 }
7387 #[inline]
7388 pub unsafe fn set_is_mp_safe_raw(this: *mut Self, val: u8_) {
7389 unsafe {
7390 let val: u8 = ::std::mem::transmute(val);
7391 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7392 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7393 1usize,
7394 1u8,
7395 val as u64,
7396 )
7397 }
7398 }
7399 #[inline]
7400 pub fn is_autoendian(&self) -> u8_ {
7401 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
7402 }
7403 #[inline]
7404 pub fn set_is_autoendian(&mut self, val: u8_) {
7405 unsafe {
7406 let val: u8 = ::std::mem::transmute(val);
7407 self._bitfield_1.set(2usize, 1u8, val as u64)
7408 }
7409 }
7410 #[inline]
7411 pub unsafe fn is_autoendian_raw(this: *const Self) -> u8_ {
7412 unsafe {
7413 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7414 ::std::ptr::addr_of!((*this)._bitfield_1),
7415 2usize,
7416 1u8,
7417 ) as u8)
7418 }
7419 }
7420 #[inline]
7421 pub unsafe fn set_is_autoendian_raw(this: *mut Self, val: u8_) {
7422 unsafe {
7423 let val: u8 = ::std::mem::transmute(val);
7424 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7425 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7426 2usize,
7427 1u8,
7428 val as u64,
7429 )
7430 }
7431 }
7432 #[inline]
7433 pub fn trace_enable(&self) -> u8_ {
7434 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
7435 }
7436 #[inline]
7437 pub fn set_trace_enable(&mut self, val: u8_) {
7438 unsafe {
7439 let val: u8 = ::std::mem::transmute(val);
7440 self._bitfield_1.set(3usize, 1u8, val as u64)
7441 }
7442 }
7443 #[inline]
7444 pub unsafe fn trace_enable_raw(this: *const Self) -> u8_ {
7445 unsafe {
7446 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7447 ::std::ptr::addr_of!((*this)._bitfield_1),
7448 3usize,
7449 1u8,
7450 ) as u8)
7451 }
7452 }
7453 #[inline]
7454 pub unsafe fn set_trace_enable_raw(this: *mut Self, val: u8_) {
7455 unsafe {
7456 let val: u8 = ::std::mem::transmute(val);
7457 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7458 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7459 3usize,
7460 1u8,
7461 val as u64,
7462 )
7463 }
7464 }
7465 #[inline]
7466 pub fn replay_allowed(&self) -> u8_ {
7467 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
7468 }
7469 #[inline]
7470 pub fn set_replay_allowed(&mut self, val: u8_) {
7471 unsafe {
7472 let val: u8 = ::std::mem::transmute(val);
7473 self._bitfield_1.set(4usize, 1u8, val as u64)
7474 }
7475 }
7476 #[inline]
7477 pub unsafe fn replay_allowed_raw(this: *const Self) -> u8_ {
7478 unsafe {
7479 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
7480 ::std::ptr::addr_of!((*this)._bitfield_1),
7481 4usize,
7482 1u8,
7483 ) as u8)
7484 }
7485 }
7486 #[inline]
7487 pub unsafe fn set_replay_allowed_raw(this: *mut Self, val: u8_) {
7488 unsafe {
7489 let val: u8 = ::std::mem::transmute(val);
7490 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
7491 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7492 4usize,
7493 1u8,
7494 val as u64,
7495 )
7496 }
7497 }
7498 #[inline]
7499 pub fn new_bitfield_1(
7500 bounce: u8_,
7501 is_mp_safe: u8_,
7502 is_autoendian: u8_,
7503 trace_enable: u8_,
7504 replay_allowed: u8_,
7505 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7506 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7507 __bindgen_bitfield_unit.set(0usize, 1u8, {
7508 let bounce: u8 = unsafe { ::std::mem::transmute(bounce) };
7509 bounce as u64
7510 });
7511 __bindgen_bitfield_unit.set(1usize, 1u8, {
7512 let is_mp_safe: u8 = unsafe { ::std::mem::transmute(is_mp_safe) };
7513 is_mp_safe as u64
7514 });
7515 __bindgen_bitfield_unit.set(2usize, 1u8, {
7516 let is_autoendian: u8 = unsafe { ::std::mem::transmute(is_autoendian) };
7517 is_autoendian as u64
7518 });
7519 __bindgen_bitfield_unit.set(3usize, 1u8, {
7520 let trace_enable: u8 = unsafe { ::std::mem::transmute(trace_enable) };
7521 trace_enable as u64
7522 });
7523 __bindgen_bitfield_unit.set(4usize, 1u8, {
7524 let replay_allowed: u8 = unsafe { ::std::mem::transmute(replay_allowed) };
7525 replay_allowed as u64
7526 });
7527 __bindgen_bitfield_unit
7528 }
7529}
7530#[repr(C)]
7531#[derive(Debug, Copy, Clone)]
7532pub struct api_main_t {
7533 pub msg_data: *mut vl_api_msg_data_t,
7534 pub msg_id_by_name: *mut uword,
7535 pub arings: *mut ring_alloc_,
7536 pub ring_misses: u32_,
7537 pub garbage_collects: u32_,
7538 pub missing_clients: u32_,
7539 pub rx_trace: *mut vl_api_trace_t,
7540 pub tx_trace: *mut vl_api_trace_t,
7541 pub msg_print_flag: ::std::os::raw::c_int,
7542 pub our_pid: ::std::os::raw::c_int,
7543 pub vlib_rp: *mut svm_region_t,
7544 pub vlib_primary_rp: *mut svm_region_t,
7545 pub vlib_private_rps: *mut *mut svm_region_t,
7546 pub mapped_shmem_regions: *mut *mut svm_region_t,
7547 pub shmem_hdr: *mut vl_shmem_hdr_,
7548 pub vl_clients: *mut *mut vl_api_registration_t,
7549 pub serialized_message_table_in_shmem: *mut u8_,
7550 pub first_available_msg_id: u16_,
7551 pub msg_range_by_name: *mut uword,
7552 pub msg_ranges: *mut vl_api_msg_range_t,
7553 pub api_uid: ::std::os::raw::c_int,
7554 pub api_gid: ::std::os::raw::c_int,
7555 pub global_baseva: u64_,
7556 pub global_size: u64_,
7557 pub api_size: u64_,
7558 pub global_pvt_heap_size: u64_,
7559 pub api_pvt_heap_size: u64_,
7560 pub vl_input_queue: *mut svm_queue_t,
7561 pub my_client_index: ::std::os::raw::c_int,
7562 pub my_registration: *mut vl_api_registration_t,
7563 pub vlib_input_queue_length: u32_,
7564 pub msg_index_by_name_and_crc: *mut uword,
7565 pub json_api_repr: *mut *mut u8_,
7566 pub api_version_list: *mut api_version_t,
7567 pub region_name: *const ::std::os::raw::c_char,
7568 pub root_path: *const ::std::os::raw::c_char,
7569 pub replay_in_progress: ::std::os::raw::c_int,
7570 pub save_msg_table_filename: *mut u8_,
7571 pub reaper_function_registrations: *mut _vl_msg_api_function_list_elt_t,
7572 pub rx_thread_handle: pthread_t,
7573 pub elog_main: *mut elog_main_t,
7574 pub elog_trace_api_messages: ::std::os::raw::c_int,
7575 pub perf_counter_cbs: *mut ::std::option::Option<
7576 unsafe extern "C" fn(
7577 arg1: *mut api_main_t,
7578 id: u32_,
7579 before_or_after: ::std::os::raw::c_int,
7580 ),
7581 >,
7582 pub perf_counter_cbs_tmp: *mut ::std::option::Option<
7583 unsafe extern "C" fn(
7584 arg1: *mut api_main_t,
7585 id: u32_,
7586 before_or_after: ::std::os::raw::c_int,
7587 ),
7588 >,
7589}
7590impl Default for api_main_t {
7591 fn default() -> Self {
7592 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7593 unsafe {
7594 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7595 s.assume_init()
7596 }
7597 }
7598}
7599unsafe extern "C" {
7600 pub static mut my_api_main: *mut api_main_t;
7601}
7602#[repr(C, packed)]
7603#[derive(Debug, Default, Copy, Clone)]
7604pub struct vl_api_trace_file_header_t {
7605 pub nitems: u32_,
7606 pub msgtbl_size: u32_,
7607 pub wrapped: u8_,
7608}
7609unsafe extern "C" {
7610 pub fn vl_msg_api_trace_save(
7611 am: *mut api_main_t,
7612 which: vl_api_trace_which_t,
7613 fp: *mut FILE,
7614 is_json: u8_,
7615 ) -> ::std::os::raw::c_int;
7616}
7617unsafe extern "C" {
7618 pub fn vl_msg_api_rx_trace_enabled(am: *mut api_main_t) -> ::std::os::raw::c_int;
7619}
7620unsafe extern "C" {
7621 pub fn vl_msg_api_tx_trace_enabled(am: *mut api_main_t) -> ::std::os::raw::c_int;
7622}
7623unsafe extern "C" {
7624 pub fn vl_msg_api_trace(
7625 am: *mut api_main_t,
7626 tp: *mut vl_api_trace_t,
7627 msg: *mut ::std::os::raw::c_void,
7628 );
7629}
7630unsafe extern "C" {
7631 pub fn vl_msg_api_trace_onoff(
7632 am: *mut api_main_t,
7633 which: vl_api_trace_which_t,
7634 onoff: ::std::os::raw::c_int,
7635 ) -> ::std::os::raw::c_int;
7636}
7637unsafe extern "C" {
7638 pub fn vl_msg_api_trace_free(
7639 am: *mut api_main_t,
7640 which: vl_api_trace_which_t,
7641 ) -> ::std::os::raw::c_int;
7642}
7643unsafe extern "C" {
7644 pub fn vl_msg_api_trace_configure(
7645 am: *mut api_main_t,
7646 which: vl_api_trace_which_t,
7647 nitems: u32_,
7648 ) -> ::std::os::raw::c_int;
7649}
7650unsafe extern "C" {
7651 pub fn vl_msg_api_max_length(mp: *mut ::std::os::raw::c_void) -> u32_;
7652}
7653unsafe extern "C" {
7654 pub fn vl_msg_api_trace_get(
7655 am: *mut api_main_t,
7656 which: vl_api_trace_which_t,
7657 ) -> *mut vl_api_trace_t;
7658}
7659unsafe extern "C" {
7660 pub fn vl_msg_api_add_msg_name_crc(
7661 am: *mut api_main_t,
7662 string: *const ::std::os::raw::c_char,
7663 id: u32_,
7664 );
7665}
7666unsafe extern "C" {
7667 pub fn vl_msg_api_add_version(
7668 am: *mut api_main_t,
7669 string: *const ::std::os::raw::c_char,
7670 major: u32_,
7671 minor: u32_,
7672 patch: u32_,
7673 );
7674}
7675unsafe extern "C" {
7676 pub fn vlib_node_serialize(
7677 vm: *mut vlib_main_t,
7678 node_dups: *mut *mut *mut vlib_node_t,
7679 vector: *mut u8_,
7680 include_nexts: ::std::os::raw::c_int,
7681 include_stats: ::std::os::raw::c_int,
7682 ) -> *mut u8_;
7683}
7684unsafe extern "C" {
7685 pub fn vlib_node_unserialize(vector: *mut u8_) -> *mut *mut *mut vlib_node_t;
7686}
7687unsafe extern "C" {
7688 pub fn vl_msg_api_get_msg_length(msg_arg: *mut ::std::os::raw::c_void) -> u32_;
7689}
7690pub type vl_msg_traverse_trace_fn = ::std::option::Option<
7691 unsafe extern "C" fn(
7692 arg1: *mut u8_,
7693 arg2: *mut ::std::os::raw::c_void,
7694 ) -> ::std::os::raw::c_int,
7695>;
7696unsafe extern "C" {
7697 pub fn vl_msg_traverse_trace(
7698 tp: *mut vl_api_trace_t,
7699 fn_: vl_msg_traverse_trace_fn,
7700 ctx: *mut ::std::os::raw::c_void,
7701 ) -> ::std::os::raw::c_int;
7702}
7703unsafe extern "C" {
7704 pub fn format_vl_api_msg_text(s: *mut u8_, args: *mut va_list) -> *mut u8_;
7705}
7706unsafe extern "C" {
7707 pub fn format_vl_api_msg_json(s: *mut u8_, args: *mut va_list) -> *mut u8_;
7708}
7709#[repr(C)]
7710#[derive(Debug, Copy, Clone)]
7711pub struct ring_alloc_ {
7712 pub rp: *mut svm_queue_t,
7713 pub size: u16_,
7714 pub nitems: u16_,
7715 pub hits: u32_,
7716 pub misses: u32_,
7717}
7718impl Default for ring_alloc_ {
7719 fn default() -> Self {
7720 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7721 unsafe {
7722 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7723 s.assume_init()
7724 }
7725 }
7726}
7727pub type ring_alloc_t = ring_alloc_;
7728pub const vl_api_shm_config_type_t_VL_API_VLIB_RING: vl_api_shm_config_type_t = 0;
7729pub const vl_api_shm_config_type_t_VL_API_CLIENT_RING: vl_api_shm_config_type_t = 1;
7730pub const vl_api_shm_config_type_t_VL_API_QUEUE: vl_api_shm_config_type_t = 2;
7731pub type vl_api_shm_config_type_t = ::std::os::raw::c_uint;
7732#[repr(C)]
7733#[derive(Debug, Default, Copy, Clone)]
7734pub struct vl_api_shm_elem_config_ {
7735 pub type_: u8_,
7736 pub _pad: u8_,
7737 pub count: u16_,
7738 pub size: u32_,
7739}
7740pub type vl_api_shm_elem_config_t = vl_api_shm_elem_config_;
7741#[repr(C)]
7742#[derive(Debug, Copy, Clone)]
7743pub struct vl_shmem_hdr_ {
7744 pub version: ::std::os::raw::c_int,
7745 pub vl_pid: ::std::os::raw::c_int,
7746 pub vl_input_queue: *mut svm_queue_t,
7747 pub vl_rings: *mut ring_alloc_t,
7748 pub client_rings: *mut ring_alloc_t,
7749 pub application_restarts: u32_,
7750 pub restart_reclaims: u32_,
7751 pub garbage_collects: u32_,
7752 pub clib_file_index: u32_,
7753}
7754impl Default for vl_shmem_hdr_ {
7755 fn default() -> Self {
7756 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7757 unsafe {
7758 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7759 s.assume_init()
7760 }
7761 }
7762}
7763pub type vl_shmem_hdr_t = vl_shmem_hdr_;
7764unsafe extern "C" {
7765 pub fn vl_msg_api_alloc(nbytes: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
7766}
7767unsafe extern "C" {
7768 pub fn vl_msg_api_alloc_zero(nbytes: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
7769}
7770unsafe extern "C" {
7771 pub fn vl_msg_api_alloc_or_null(nbytes: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
7772}
7773unsafe extern "C" {
7774 pub fn vl_msg_api_alloc_as_if_client(
7775 nbytes: ::std::os::raw::c_int,
7776 ) -> *mut ::std::os::raw::c_void;
7777}
7778unsafe extern "C" {
7779 pub fn vl_msg_api_alloc_zero_as_if_client(
7780 nbytes: ::std::os::raw::c_int,
7781 ) -> *mut ::std::os::raw::c_void;
7782}
7783unsafe extern "C" {
7784 pub fn vl_msg_api_alloc_as_if_client_or_null(
7785 nbytes: ::std::os::raw::c_int,
7786 ) -> *mut ::std::os::raw::c_void;
7787}
7788unsafe extern "C" {
7789 pub fn vl_mem_api_alloc_as_if_client_w_reg(
7790 reg: *mut vl_api_registration_t,
7791 nbytes: ::std::os::raw::c_int,
7792 ) -> *mut ::std::os::raw::c_void;
7793}
7794unsafe extern "C" {
7795 pub fn vl_msg_api_free_w_region(vlib_rp: *mut svm_region_t, a: *mut ::std::os::raw::c_void);
7796}
7797unsafe extern "C" {
7798 pub fn vl_map_shmem(
7799 region_name: *const ::std::os::raw::c_char,
7800 is_vlib: ::std::os::raw::c_int,
7801 ) -> ::std::os::raw::c_int;
7802}
7803unsafe extern "C" {
7804 pub fn vl_unmap_shmem();
7805}
7806unsafe extern "C" {
7807 pub fn vl_unmap_shmem_client();
7808}
7809unsafe extern "C" {
7810 pub fn vl_register_mapped_shmem_region(rp: *mut svm_region_t);
7811}
7812unsafe extern "C" {
7813 pub fn vl_msg_api_send_shmem(q: *mut svm_queue_t, elem: *mut u8_);
7814}
7815unsafe extern "C" {
7816 pub fn vl_mem_api_can_send(q: *mut svm_queue_t) -> ::std::os::raw::c_int;
7817}
7818unsafe extern "C" {
7819 pub fn vl_set_memory_region_name(name: *const ::std::os::raw::c_char);
7820}
7821unsafe extern "C" {
7822 pub fn vl_set_memory_root_path(root_path: *const ::std::os::raw::c_char);
7823}
7824unsafe extern "C" {
7825 pub fn vl_set_memory_uid(uid: ::std::os::raw::c_int);
7826}
7827unsafe extern "C" {
7828 pub fn vl_set_memory_gid(gid: ::std::os::raw::c_int);
7829}
7830unsafe extern "C" {
7831 pub fn vl_set_global_memory_baseva(baseva: u64_);
7832}
7833unsafe extern "C" {
7834 pub fn vl_set_global_memory_size(size: u64_);
7835}
7836unsafe extern "C" {
7837 pub fn vl_set_api_memory_size(size: u64_);
7838}
7839unsafe extern "C" {
7840 pub fn vl_set_global_pvt_heap_size(size: u64_);
7841}
7842unsafe extern "C" {
7843 pub fn vl_set_api_pvt_heap_size(size: u64_);
7844}
7845unsafe extern "C" {
7846 pub fn vl_init_shmem(
7847 vlib_rp: *mut svm_region_t,
7848 config: *mut vl_api_shm_elem_config_t,
7849 is_vlib: ::std::os::raw::c_int,
7850 is_private_region: ::std::os::raw::c_int,
7851 );
7852}
7853unsafe extern "C" {
7854 pub fn vlib_helper_get_global_main() -> *mut vlib_global_main_t;
7855}
7856unsafe extern "C" {
7857 pub fn vlib_helper_remove_node_from_registrations(
7858 vgm: *mut vlib_global_main_t,
7859 node: *mut vlib_node_registration_t,
7860 );
7861}
7862unsafe extern "C" {
7863 pub fn vlib_helper_remove_feature_from_registrations(
7864 fm: *mut vnet_feature_main_t,
7865 r: *mut vnet_feature_registration_t,
7866 );
7867}
7868unsafe extern "C" {
7869 pub fn vlib_helper_remove_cli_command(cm: *mut vlib_cli_main_t, x: *mut vlib_cli_command_t);
7870}
7871unsafe extern "C" {
7872 pub fn vlib_helper_buffer_alloc(
7873 vm: *mut vlib_main_t,
7874 buffers: *mut u32_,
7875 n_buffers: u32_,
7876 ) -> u32_;
7877}
7878unsafe extern "C" {
7879 pub fn vlib_helper_buffer_free(vm: *mut vlib_main_t, buffers: *mut u32_, n_buffers: u32_);
7880}
7881unsafe extern "C" {
7882 pub fn vlib_helper_format_vnet_sw_if_index_name(s: *mut u8_, ...) -> *mut u8_;
7883}
7884unsafe extern "C" {
7885 pub fn vlib_helper_unformat_vnet_sw_interface(input: *mut unformat_input_t, ...) -> uword;
7886}
7887unsafe extern "C" {
7888 pub fn vlib_helper_format_ip4_header(s: *mut u8_, ...) -> *mut u8_;
7889}
7890unsafe extern "C" {
7891 pub fn vlib_helper_format_ip6_header(s: *mut u8_, ...) -> *mut u8_;
7892}
7893unsafe extern "C" {
7894 pub fn vlib_helper_unformat_get_input(input: *mut unformat_input_t) -> uword;
7895}
7896unsafe extern "C" {
7897 pub fn vlib_helper_unformat_free(input: *mut unformat_input_t);
7898}
7899unsafe extern "C" {
7900 pub fn vl_api_helper_client_index_to_registration(index: u32_) -> *mut vl_api_registration_t;
7901}
7902unsafe extern "C" {
7903 pub fn vlibapi_helper_get_main() -> *mut api_main_t;
7904}
7905unsafe extern "C" {
7906 pub fn vl_api_helper_send_msg(rp: *mut vl_api_registration_t, elem: *mut u8_);
7907}
7908unsafe extern "C" {
7909 pub fn vlib_helper_zero_simple_counter(cm: *mut vlib_simple_counter_main_t, index: u32_);
7910}
7911unsafe extern "C" {
7912 pub fn vlib_helper_zero_combined_counter(cm: *mut vlib_combined_counter_main_t, index: u32_);
7913}
7914pub type __builtin_va_list = [__va_list_tag; 1usize];
7915#[repr(C)]
7916#[derive(Debug, Copy, Clone)]
7917pub struct __va_list_tag {
7918 pub gp_offset: ::std::os::raw::c_uint,
7919 pub fp_offset: ::std::os::raw::c_uint,
7920 pub overflow_arg_area: *mut ::std::os::raw::c_void,
7921 pub reg_save_area: *mut ::std::os::raw::c_void,
7922}
7923impl Default for __va_list_tag {
7924 fn default() -> Self {
7925 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7926 unsafe {
7927 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7928 s.assume_init()
7929 }
7930 }
7931}