| #![allow( |
| dead_code, |
| non_snake_case, |
| non_camel_case_types, |
| non_upper_case_globals |
| )] |
| |
| #[repr(C)] |
| #[derive(Default)] |
| pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]); |
| impl<T> __IncompleteArrayField<T> { |
| #[inline] |
| pub const fn new() -> Self { |
| __IncompleteArrayField(::std::marker::PhantomData, []) |
| } |
| #[inline] |
| pub fn as_ptr(&self) -> *const T { |
| self as *const _ as *const T |
| } |
| #[inline] |
| pub fn as_mut_ptr(&mut self) -> *mut T { |
| self as *mut _ as *mut T |
| } |
| #[inline] |
| pub unsafe fn as_slice(&self, len: usize) -> &[T] { |
| ::std::slice::from_raw_parts(self.as_ptr(), len) |
| } |
| #[inline] |
| pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { |
| ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) |
| } |
| } |
| impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> { |
| fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| fmt.write_str("__IncompleteArrayField") |
| } |
| } |
| pub const RTE_CACHE_LINE_SIZE: u32 = 64; |
| pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4; |
| pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX; |
| pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX; |
| pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM; |
| pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM; |
| #[repr(u32)] |
| #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] |
| pub enum _bindgen_ty_1 { |
| ///< index of last fragment |
| IP_LAST_FRAG_IDX = 0, |
| ///< index of first fragment |
| IP_FIRST_FRAG_IDX = 1, |
| ///< minimum number of fragments |
| IP_MIN_FRAG_NUM = 2, |
| IP_MAX_FRAG_NUM = 4, |
| } |
| /// @internal fragmented mbuf |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct ip_frag { |
| ///< offset into the packet |
| pub ofs: u16, |
| ///< length of fragment |
| pub len: u16, |
| ///< fragment mbuf |
| pub mb: *mut rte_mbuf, |
| } |
| #[test] |
| fn bindgen_test_layout_ip_frag() { |
| assert_eq!( |
| ::std::mem::size_of::<ip_frag>(), |
| 16usize, |
| concat!("Size of: ", stringify!(ip_frag)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<ip_frag>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(ip_frag)) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<ip_frag>())).ofs as *const _ as usize }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag), |
| "::", |
| stringify!(ofs) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<ip_frag>())).len as *const _ as usize }, |
| 2usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag), |
| "::", |
| stringify!(len) |
| ) |
| ); |
| assert_eq!( |
| unsafe { &(*(::std::ptr::null::<ip_frag>())).mb as *const _ as usize }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag), |
| "::", |
| stringify!(mb) |
| ) |
| ); |
| } |
| impl Default for ip_frag { |
| 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() |
| } |
| } |
| } |
| /// @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram. |
| #[repr(C)] |
| #[derive(Debug, Default, Copy, Clone)] |
| pub struct ip_frag_key { |
| ///< src address, first 8 bytes used for IPv4 |
| pub src_dst: [u64; 4usize], |
| ///< dst address |
| pub id: u32, |
| ///< src/dst key length |
| pub key_len: u32, |
| } |
| #[test] |
| fn bindgen_test_layout_ip_frag_key() { |
| assert_eq!( |
| ::std::mem::size_of::<ip_frag_key>(), |
| 40usize, |
| concat!("Size of: ", stringify!(ip_frag_key)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<ip_frag_key>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(ip_frag_key)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_key>())).src_dst as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_key), |
| "::", |
| stringify!(src_dst) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_key>())).id as *const _ as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_key), |
| "::", |
| stringify!(id) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_key>())).key_len as *const _ as usize |
| }, |
| 36usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_key), |
| "::", |
| stringify!(key_len) |
| ) |
| ); |
| } |
| /// @internal Fragmented packet to reassemble. |
| /// First two entries in the frags[] array are for the last and first fragments. |
| #[repr(C)] |
| #[repr(align(64))] |
| #[derive(Copy, Clone)] |
| pub struct ip_frag_pkt { |
| ///< LRU list |
| pub lru: ip_frag_pkt__bindgen_ty_1, |
| ///< fragmentation key |
| pub key: ip_frag_key, |
| ///< creation timestamp |
| pub start: u64, |
| ///< expected reassembled size |
| pub total_size: u32, |
| ///< size of fragments received |
| pub frag_size: u32, |
| ///< index of next entry to fill |
| pub last_idx: u32, |
| ///< fragments |
| pub frags: [ip_frag; 4usize], |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct ip_frag_pkt__bindgen_ty_1 { |
| pub tqe_next: *mut ip_frag_pkt, |
| pub tqe_prev: *mut *mut ip_frag_pkt, |
| } |
| #[test] |
| fn bindgen_test_layout_ip_frag_pkt__bindgen_ty_1() { |
| assert_eq!( |
| ::std::mem::size_of::<ip_frag_pkt__bindgen_ty_1>(), |
| 16usize, |
| concat!("Size of: ", stringify!(ip_frag_pkt__bindgen_ty_1)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<ip_frag_pkt__bindgen_ty_1>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(ip_frag_pkt__bindgen_ty_1)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt__bindgen_ty_1>())).tqe_next |
| as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt__bindgen_ty_1), |
| "::", |
| stringify!(tqe_next) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt__bindgen_ty_1>())).tqe_prev |
| as *const _ as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt__bindgen_ty_1), |
| "::", |
| stringify!(tqe_prev) |
| ) |
| ); |
| } |
| impl Default for ip_frag_pkt__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() |
| } |
| } |
| } |
| #[test] |
| fn bindgen_test_layout_ip_frag_pkt() { |
| assert_eq!( |
| ::std::mem::size_of::<ip_frag_pkt>(), |
| 192usize, |
| concat!("Size of: ", stringify!(ip_frag_pkt)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<ip_frag_pkt>(), |
| 64usize, |
| concat!("Alignment of ", stringify!(ip_frag_pkt)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).lru as *const _ as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(lru) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).key as *const _ as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(key) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).start as *const _ as usize |
| }, |
| 56usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(start) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).total_size as *const _ |
| as usize |
| }, |
| 64usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(total_size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).frag_size as *const _ |
| as usize |
| }, |
| 68usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(frag_size) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).last_idx as *const _ |
| as usize |
| }, |
| 72usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(last_idx) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_pkt>())).frags as *const _ as usize |
| }, |
| 80usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_pkt), |
| "::", |
| stringify!(frags) |
| ) |
| ); |
| } |
| impl Default for ip_frag_pkt { |
| 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() |
| } |
| } |
| } |
| #[repr(C)] |
| #[derive(Debug, Copy, Clone)] |
| pub struct ip_pkt_list { |
| pub tqh_first: *mut ip_frag_pkt, |
| pub tqh_last: *mut *mut ip_frag_pkt, |
| } |
| #[test] |
| fn bindgen_test_layout_ip_pkt_list() { |
| assert_eq!( |
| ::std::mem::size_of::<ip_pkt_list>(), |
| 16usize, |
| concat!("Size of: ", stringify!(ip_pkt_list)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<ip_pkt_list>(), |
| 8usize, |
| concat!("Alignment of ", stringify!(ip_pkt_list)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_pkt_list>())).tqh_first as *const _ |
| as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_pkt_list), |
| "::", |
| stringify!(tqh_first) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_pkt_list>())).tqh_last as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_pkt_list), |
| "::", |
| stringify!(tqh_last) |
| ) |
| ); |
| } |
| impl Default for ip_pkt_list { |
| 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() |
| } |
| } |
| } |
| /// fragmentation table statistics |
| #[repr(C)] |
| #[repr(align(64))] |
| #[derive(Copy, Clone)] |
| pub struct ip_frag_tbl_stat { |
| ///< total # of find/insert attempts. |
| pub find_num: u64, |
| ///< # of add ops. |
| pub add_num: u64, |
| ///< # of del ops. |
| pub del_num: u64, |
| ///< # of reuse (del/add) ops. |
| pub reuse_num: u64, |
| ///< total # of add failures. |
| pub fail_total: u64, |
| ///< # of 'no space' add failures. |
| pub fail_nospace: u64, |
| } |
| #[test] |
| fn bindgen_test_layout_ip_frag_tbl_stat() { |
| assert_eq!( |
| ::std::mem::size_of::<ip_frag_tbl_stat>(), |
| 64usize, |
| concat!("Size of: ", stringify!(ip_frag_tbl_stat)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<ip_frag_tbl_stat>(), |
| 64usize, |
| concat!("Alignment of ", stringify!(ip_frag_tbl_stat)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_tbl_stat>())).find_num as *const _ |
| as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_tbl_stat), |
| "::", |
| stringify!(find_num) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_tbl_stat>())).add_num as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_tbl_stat), |
| "::", |
| stringify!(add_num) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_tbl_stat>())).del_num as *const _ |
| as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_tbl_stat), |
| "::", |
| stringify!(del_num) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_tbl_stat>())).reuse_num as *const _ |
| as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_tbl_stat), |
| "::", |
| stringify!(reuse_num) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_tbl_stat>())).fail_total as *const _ |
| as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_tbl_stat), |
| "::", |
| stringify!(fail_total) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<ip_frag_tbl_stat>())).fail_nospace |
| as *const _ as usize |
| }, |
| 40usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(ip_frag_tbl_stat), |
| "::", |
| stringify!(fail_nospace) |
| ) |
| ); |
| } |
| impl Default for ip_frag_tbl_stat { |
| 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() |
| } |
| } |
| } |
| /// fragmentation table |
| #[repr(C)] |
| #[repr(align(64))] |
| pub struct rte_ip_frag_tbl { |
| ///< ttl for table entries. |
| pub max_cycles: u64, |
| ///< hash value mask. |
| pub entry_mask: u32, |
| ///< max entries allowed. |
| pub max_entries: u32, |
| ///< entries in use. |
| pub use_entries: u32, |
| ///< hash assocaitivity. |
| pub bucket_entries: u32, |
| ///< total size of the table. |
| pub nb_entries: u32, |
| ///< num of associativity lines. |
| pub nb_buckets: u32, |
| ///< last used entry. |
| pub last: *mut ip_frag_pkt, |
| ///< LRU list for table entries. |
| pub lru: ip_pkt_list, |
| pub __bindgen_padding_0: u64, |
| ///< statistics counters. |
| pub stat: ip_frag_tbl_stat, |
| ///< hash table. |
| pub pkt: __IncompleteArrayField<ip_frag_pkt>, |
| } |
| #[test] |
| fn bindgen_test_layout_rte_ip_frag_tbl() { |
| assert_eq!( |
| ::std::mem::size_of::<rte_ip_frag_tbl>(), |
| 128usize, |
| concat!("Size of: ", stringify!(rte_ip_frag_tbl)) |
| ); |
| assert_eq!( |
| ::std::mem::align_of::<rte_ip_frag_tbl>(), |
| 64usize, |
| concat!("Alignment of ", stringify!(rte_ip_frag_tbl)) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).max_cycles as *const _ |
| as usize |
| }, |
| 0usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(max_cycles) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).entry_mask as *const _ |
| as usize |
| }, |
| 8usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(entry_mask) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).max_entries as *const _ |
| as usize |
| }, |
| 12usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(max_entries) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).use_entries as *const _ |
| as usize |
| }, |
| 16usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(use_entries) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).bucket_entries |
| as *const _ as usize |
| }, |
| 20usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(bucket_entries) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).nb_entries as *const _ |
| as usize |
| }, |
| 24usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(nb_entries) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).nb_buckets as *const _ |
| as usize |
| }, |
| 28usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(nb_buckets) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).last as *const _ |
| as usize |
| }, |
| 32usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(last) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).lru as *const _ as usize |
| }, |
| 40usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(lru) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).stat as *const _ |
| as usize |
| }, |
| 64usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(stat) |
| ) |
| ); |
| assert_eq!( |
| unsafe { |
| &(*(::std::ptr::null::<rte_ip_frag_tbl>())).pkt as *const _ as usize |
| }, |
| 128usize, |
| concat!( |
| "Offset of field: ", |
| stringify!(rte_ip_frag_tbl), |
| "::", |
| stringify!(pkt) |
| ) |
| ); |
| } |
| impl Default for rte_ip_frag_tbl { |
| 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() |
| } |
| } |
| } |
| ///< fragment mbuf |
| #[repr(C)] |
| #[derive(Debug, Default, Copy, Clone)] |
| pub struct rte_mbuf { |
| pub _address: u8, |
| } |
