aboutsummaryrefslogtreecommitdiffstats
AgeCommit message (Expand)AuthorFilesLines
2023-09-16misc: VPP 23.06 Release NotesAndrew Yourtchenko2-0/+620
2023-09-15vpp-swan: fix configuration of policiesGabriel Oginski1-15/+16
2023-09-13nat: fix nat44_ed set_session_limit crashVladislav Grishenko2-10/+9
2023-09-13quic: fix quic sessions state updatesFlorin Coras2-11/+6
2023-09-13sr: mark sr_policies_v2_details message as productionAndrew Yourtchenko1-1/+0
2023-09-13adl: stabilize the APIAndrew Yourtchenko1-1/+1
2023-09-13flow: mark API as productionAndrew Yourtchenko1-1/+1
2023-09-13wireguard: stabilize the APIAndrew Yourtchenko1-1/+1
2023-09-13crypto-sw-scheduler: stabilize the APIAndrew Yourtchenko1-1/+1
2023-09-13hsa: fix coverity issue CID-313635Dave Wallace2-2/+8
2023-09-13api: fix vlibmemory coverity warning CID-300152Dave Wallace1-0/+4
2023-09-13vppinfra: add ARM Neoverse-N2 supportDamjan Marion3-94/+131
2023-09-13build: fix clang-16 buildDamjan Marion1-1/+3
2023-09-13idpf: make plugin default disabled until issues are fixedDamjan Marion1-0/+1
2023-09-13docs: mention how to build VPP outside gitVratko Polak3-2/+22
2023-09-13build: add vpp_plugins include directoryBenoît Ganne1-0/+1
2023-09-13vppinfra: fix coverity warning CID-313632Dave Wallace1-2/+0
2023-09-13vlib: deuglify the offset finding loop in pci.cVratko Polak1-5/+2
2023-09-13perfmon: fix perf_user_access_enabled typeTianyu Li1-1/+1
2023-09-13vppinfra: fix setns typoArtem Glazychev1-1/+1
2023-09-13pci: fix coverity issue CID-322372Dave Wallace1-1/+1
2023-09-12ipsec: improve fast path policy searching performanceXiaoming Jiang2-35/+59
2023-09-12crypto: allow changing dispatch modeVratko Polak4-2/+51
2023-09-12crypto-sw-scheduler: improve function indentationVratko Polak1-159/+156
2023-09-07session: make sure rx evt flag is cleared for builtin rxFlorin Coras1-0/+1
2023-09-07ipsec: clear L4-cksum flags when decap'ing packetsFrédéric Perrin2-1/+5
2023-09-07dpdk-cryptodev: fix cache ring stats cli commandPiotr Bronowski1-14/+12
2023-09-06build: add option to specify native -march= flag with VPP_BUILD_NATIVE_ARCHDamjan Marion1-8/+8
2023-09-06nat: improve nat44-ed outside address distributionVladislav Grishenko2-14/+15
2023-09-06virtio: add support for tx-queue-sizeMohsin Kazmi5-10/+27
2023-09-06ip: punt add punt socket support for icmp6Ole Troan3-31/+77
2023-09-06api: fix mp-safe mark for some messages and add moreVladislav Grishenko6-14/+35
2023-09-06vapi: fix verification for reply messageSylvain Cadilhac1-1/+1
2023-09-05hs-test: point gdb to vpp source filesFilip Tehlar4-1/+15
2023-09-05hs-test: verbose output on single test runFilip Tehlar1-1/+1
2023-09-05npt66: make plugin default disabledOle Troan2-0/+5
2023-09-04hs-test: log external appsFilip Tehlar7-94/+97
2023-09-04hs-test: fix gdb attachFilip Tehlar1-3/+2
2023-09-04udp: buffer packets for connections in accepting stateFlorin Coras1-1/+2
2023-09-04arping: api to return responder mac addressOle Troan3-0/+68
2023-09-04npt66: checksum applied to src address instead of dst address on rxOle Troan2-21/+28
2023-09-04tracenode: filtering featureMaxime Peim13-17/+812
2023-09-04session: fix allocation of proxy fifosFlorin Coras9-21/+50
2023-09-01map: test fix feature disablingMaxime Peim1-0/+5
2023-09-01vcl: set min threshold for tx ntfFlorin Coras1-1/+5
2023-08-31fateshare: a plugin for managing child processesAndrew Yourtchenko7-0/+628
2023-08-31session: fix compilation when SESSION_DEBUG is onFlorin Coras1-3/+7
2023-08-29mpls: add mpls_interface_dumpPim van Pelt2-0/+68
2023-08-26perftool: fix delsvec use of _vec_lenFlorin Coras1-225/+271
2023-08-26nat: nat44-ed bug fixWei Li1-3/+4
buffer_bytes) { return s->buffer + i; } else { s->current_buffer_index = i; return serialize_read_write_not_inline (header, s, n_bytes, flags); } } typedef struct { serialize_main_header_t header; serialize_stream_t stream; } serialize_main_t; always_inline void serialize_set_end_of_stream (serialize_main_t * m) { serialize_stream_set_end_of_stream (&m->stream); } always_inline uword serialize_is_end_of_stream (serialize_main_t * m) { return serialize_stream_is_end_of_stream (&m->stream); } typedef struct { serialize_main_header_t header; serialize_stream_t *streams; } serialize_multiple_main_t; typedef void (serialize_function_t) (serialize_main_t * m, va_list * va); always_inline void * unserialize_get (serialize_main_t * m, uword n_bytes) { return serialize_stream_read_write (&m->header, &m->stream, n_bytes, SERIALIZE_FLAG_IS_READ); } always_inline void * serialize_get (serialize_main_t * m, uword n_bytes) { return serialize_stream_read_write (&m->header, &m->stream, n_bytes, SERIALIZE_FLAG_IS_WRITE); } always_inline void serialize_integer (serialize_main_t * m, u64 x, u32 n_bytes) { u8 *p = serialize_get (m, n_bytes); if (n_bytes == 1) p[0] = x; else if (n_bytes == 2) clib_mem_unaligned (p, u16) = clib_host_to_net_u16 (x); else if (n_bytes == 4) clib_mem_unaligned (p, u32) = clib_host_to_net_u32 (x); else if (n_bytes == 8) clib_mem_unaligned (p, u64) = clib_host_to_net_u64 (x); else ASSERT (0); } always_inline void unserialize_integer (serialize_main_t * m, void *x, u32 n_bytes) { u8 *p = unserialize_get (m, n_bytes); if (n_bytes == 1) *(u8 *) x = p[0]; else if (n_bytes == 2) *(u16 *) x = clib_net_to_host_unaligned_mem_u16 ((u16 *) p); else if (n_bytes == 4) *(u32 *) x = clib_net_to_host_unaligned_mem_u32 ((u32 *) p); else if (n_bytes == 8) *(u64 *) x = clib_net_to_host_unaligned_mem_u64 ((u64 *) p); else ASSERT (0); } /* As above but tries to be more compact. */ always_inline void serialize_likely_small_unsigned_integer (serialize_main_t * m, u64 x) { u64 r = x; u8 *p; /* Low bit set means it fits into 1 byte. */ if (r < (1 << 7)) { p = serialize_get (m, 1); p[0] = 1 + 2 * r; return; } /* Low 2 bits 1 0 means it fits into 2 bytes. */ r -= (1 << 7); if (r < (1 << 14)) { p = serialize_get (m, 2); clib_mem_unaligned (p, u16) = clib_host_to_little_u16 (4 * r + 2); return; } r -= (1 << 14); if (r < (1 << 29)) { p = serialize_get (m, 4); clib_mem_unaligned (p, u32) = clib_host_to_little_u32 (8 * r + 4); return; } p = serialize_get (m, 9); p[0] = 0; /* Only low 3 bits are used. */ clib_mem_unaligned (p + 1, u64) = clib_host_to_little_u64 (x); } always_inline u64 unserialize_likely_small_unsigned_integer (serialize_main_t * m) { u8 *p = unserialize_get (m, 1); u64 r; u32 y = p[0]; if (y & 1) return y / 2; r = 1 << 7; if (y & 2) { p = unserialize_get (m, 1); r += (y / 4) + (p[0] << 6); return r; } r += 1 << 14; if (y & 4) { p = unserialize_get (m, 3); r += ((y / 8) + (p[0] << (5 + 8 * 0)) + (p[1] << (5 + 8 * 1)) + (p[2] << (5 + 8 * 2))); return r; } p = unserialize_get (m, 8); r = clib_mem_unaligned (p, u64); r = clib_little_to_host_u64 (r); return r; } always_inline void serialize_likely_small_signed_integer (serialize_main_t * m, i64 s) { u64 u = s < 0 ? -(2 * s + 1) : 2 * s; serialize_likely_small_unsigned_integer (m, u); } always_inline i64 unserialize_likely_small_signed_integer (serialize_main_t * m) { u64 u = unserialize_likely_small_unsigned_integer (m); i64 s = u / 2; return (u & 1) ? -s : s; } void serialize_multiple_1 (serialize_main_t * m, void *data, uword data_stride, uword n_data); void serialize_multiple_2 (serialize_main_t * m, void *data, uword data_stride, uword n_data); void serialize_multiple_4 (serialize_main_t * m, void *data, uword data_stride, uword n_data); void unserialize_multiple_1 (serialize_main_t * m, void *data, uword data_stride, uword n_data); void unserialize_multiple_2 (serialize_main_t * m, void *data, uword data_stride, uword n_data); void unserialize_multiple_4 (serialize_main_t * m, void *data, uword data_stride, uword n_data); always_inline void serialize_multiple (serialize_main_t * m, void *data, uword n_data_bytes, uword data_stride, uword n_data) { if (n_data_bytes == 1) serialize_multiple_1 (m, data, data_stride, n_data); else if (n_data_bytes == 2) serialize_multiple_2 (m, data, data_stride, n_data); else if (n_data_bytes == 4) serialize_multiple_4 (m, data, data_stride, n_data); else ASSERT (0); } always_inline void unserialize_multiple (serialize_main_t * m, void *data, uword n_data_bytes, uword data_stride, uword n_data) { if (n_data_bytes == 1) unserialize_multiple_1 (m, data, data_stride, n_data); else if (n_data_bytes == 2) unserialize_multiple_2 (m, data, data_stride, n_data); else if (n_data_bytes == 4) unserialize_multiple_4 (m, data, data_stride, n_data); else ASSERT (0); } /* Basic types. */ serialize_function_t serialize_64, unserialize_64; serialize_function_t serialize_32, unserialize_32; serialize_function_t serialize_16, unserialize_16; serialize_function_t serialize_8, unserialize_8; serialize_function_t serialize_f64, unserialize_f64; serialize_function_t serialize_f32, unserialize_f32; /* Basic vector types. */ serialize_function_t serialize_vec_8, unserialize_vec_8; serialize_function_t serialize_vec_16, unserialize_vec_16; serialize_function_t serialize_vec_32, unserialize_vec_32; serialize_function_t serialize_vec_64, unserialize_vec_64; /* Serialize generic vectors. */ serialize_function_t serialize_vector, unserialize_vector, unserialize_aligned_vector; #define vec_serialize(m,v,f) \ serialize ((m), serialize_vector, (v), sizeof ((v)[0]), (f)) #define vec_unserialize(m,v,f) \ unserialize ((m), unserialize_vector, (v), sizeof ((*(v))[0]), (f)) #define vec_unserialize_aligned(m,v,f) \ unserialize ((m), unserialize_aligned_vector, (v), sizeof ((*(v))[0]), (f)) /* Serialize pools. */ serialize_function_t serialize_pool, unserialize_pool, unserialize_aligned_pool; #define pool_serialize(m,v,f) \ serialize ((m), serialize_pool, (v), sizeof ((v)[0]), (f)) #define pool_unserialize(m,v,f) \ unserialize ((m), unserialize_pool, (v), sizeof ((*(v))[0]), (f)) #define pool_unserialize_aligned(m,v,a,f) \ unserialize ((m), unserialize_aligned_pool, (v), sizeof ((*(v))[0]), (a), (f)) /* Serialize heaps. */ serialize_function_t serialize_heap, unserialize_heap; void serialize_bitmap (serialize_main_t * m, uword * b); uword *unserialize_bitmap (serialize_main_t * m); void serialize_cstring (serialize_main_t * m, char *string); void unserialize_cstring (serialize_main_t * m, char **string); void serialize_close (serialize_main_t * m); void unserialize_close (serialize_main_t * m); void serialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes); void unserialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes); /* Starts serialization with expanding vector as buffer. */ void serialize_open_vector (serialize_main_t * m, u8 * vector); /* Serialization is done: returns vector buffer to caller. */ void *serialize_close_vector (serialize_main_t * m); void unserialize_open_vector (serialize_main_t * m, u8 * vector); #ifdef CLIB_UNIX clib_error_t *serialize_open_clib_file (serialize_main_t * m, char *file); clib_error_t *unserialize_open_clib_file (serialize_main_t * m, char *file); void serialize_open_clib_file_descriptor (serialize_main_t * m, int fd); void unserialize_open_clib_file_descriptor (serialize_main_t * m, int fd); #endif /* CLIB_UNIX */ /* Main routines. */ clib_error_t *serialize (serialize_main_t * m, ...); clib_error_t *unserialize (serialize_main_t * m, ...); clib_error_t *va_serialize (serialize_main_t * m, va_list * va); void serialize_magic (serialize_main_t * m, void *magic, u32 magic_bytes); void unserialize_check_magic (serialize_main_t * m, void *magic, u32 magic_bytes); #endif /* included_clib_serialize_h */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */