From 54346b61f91008c5098243b588f184ad92ad29c9 Mon Sep 17 00:00:00 2001 From: Yu Ping Date: Fri, 21 Feb 2020 22:36:20 +0800 Subject: initial version of VSAP Signed-off-by: Yu Ping Change-Id: I04d9150f0c7607ba20de9096b452476eff1622fc --- vpp_patches/ldp/0001-LDP-remove-lock.patch | 1700 ++++++++++++++++++++++++++++ 1 file changed, 1700 insertions(+) create mode 100644 vpp_patches/ldp/0001-LDP-remove-lock.patch (limited to 'vpp_patches/ldp') diff --git a/vpp_patches/ldp/0001-LDP-remove-lock.patch b/vpp_patches/ldp/0001-LDP-remove-lock.patch new file mode 100644 index 0000000..091bc78 --- /dev/null +++ b/vpp_patches/ldp/0001-LDP-remove-lock.patch @@ -0,0 +1,1700 @@ +From dea792cdf1af0b343180846c33be14681323f5a3 Mon Sep 17 00:00:00 2001 +From: Yu Ping +Date: Wed, 23 Oct 2019 17:56:55 +0800 +Subject: [PATCH] LDP remove lock + +Change-Id: I3b5135194ed93c5e4a259fb2d3f8cae7ef8de4c5 +Signed-off-by: Yu Ping +--- + src/vcl/CMakeLists.txt | 5 +- + src/vcl/ldp.c | 740 +++++++++++++++++++++++++++-------------- + src/vcl/ldp.h | 2 +- + src/vcl/vcl_private.h | 7 +- + 4 files changed, 495 insertions(+), 259 deletions(-) + +diff --git a/src/vcl/CMakeLists.txt b/src/vcl/CMakeLists.txt +index ab0a6ad6a..0d30eb6af 100644 +--- a/src/vcl/CMakeLists.txt ++++ b/src/vcl/CMakeLists.txt +@@ -20,7 +20,6 @@ add_vpp_library(vppcom + vcl_bapi.c + vcl_cfg.c + vcl_private.c +- vcl_locked.c + + LINK_LIBRARIES + vppinfra svm vlibmemoryclient rt pthread +@@ -41,7 +40,7 @@ add_vpp_library(vcl_ldpreload + add_vpp_headers(vcl + ldp.h + ldp_glibc_socket.h ++ vcl_private.h + vppcom.h +- vcl_locked.h + ldp_socket_wrapper.h +-) +\ No newline at end of file ++) +diff --git a/src/vcl/ldp.c b/src/vcl/ldp.c +index 7aa383052..4e7695454 100644 +--- a/src/vcl/ldp.c ++++ b/src/vcl/ldp.c +@@ -24,9 +24,10 @@ + + #include + #include ++#include ++#include + #include + +-#include + #include + #include + #include +@@ -96,8 +97,8 @@ typedef struct + ldp_worker_ctx_t *workers; + int init; + char app_name[LDP_APP_NAME_MAX]; +- u32 vlsh_bit_val; +- u32 vlsh_bit_mask; ++ u32 vcl_bit_val; ++ u32 vcl_bit_mask; + u32 debug; + u8 transparent_tls; + +@@ -112,8 +113,8 @@ typedef struct + clib_warning ("ldp<%d>: " _fmt, getpid(), ##_args) + + static ldp_main_t ldp_main = { +- .vlsh_bit_val = (1 << LDP_SID_BIT_MIN), +- .vlsh_bit_mask = (1 << LDP_SID_BIT_MIN) - 1, ++ .vcl_bit_val = (1 << LDP_SID_BIT_MIN), ++ .vcl_bit_mask = (1 << LDP_SID_BIT_MIN) - 1, + .debug = LDP_DEBUG_INIT, + .transparent_tls = 0, + }; +@@ -146,18 +147,18 @@ ldp_get_app_name () + } + + static inline int +-ldp_vlsh_to_fd (vls_handle_t vlsh) ++ldp_vclsh_to_fd (vcl_session_handle_t vclsh) + { +- return (vlsh + ldp->vlsh_bit_val); ++ return (vclsh + ldp->vcl_bit_val); + } + +-static inline vls_handle_t +-ldp_fd_to_vlsh (int fd) ++static inline vcl_session_handle_t ++ldp_fd_to_vclsh (int fd) + { +- if (fd < ldp->vlsh_bit_val) +- return VLS_INVALID_HANDLE; ++ if (fd < (ldp->vcl_bit_val)) ++ return INVALID_SESSION_ID; + +- return (fd - ldp->vlsh_bit_val); ++ return (fd - ldp->vcl_bit_val); + } + + static void +@@ -168,6 +169,194 @@ ldp_alloc_workers (void) + pool_alloc (ldp->workers, LDP_MAX_NWORKERS); + } + ++static void ++ldp_share_listen_session (vcl_worker_t * parent_wrk, ++ vcl_worker_t * child_wrk, ++ vcl_session_t * listen_session) ++{ ++/*Find the listen session of parent worker*/ ++ if (listen_session->session_index == parent_wrk->listen_session_index) ++ { ++ listen_session->session_state = STATE_LISTEN_NO_MQ; ++ vppcom_session_listen (vcl_session_handle_from_index ++ (parent_wrk->listen_session_index), ++ parent_wrk->listen_queue_size); ++ } ++} ++ ++void ++ldp_vcl_worker_copy_on_fork (vcl_worker_t * parent_wrk) ++{ ++ vcl_worker_t *wrk = vcl_worker_get_current (); ++ vcl_session_t *listen_session; ++ wrk->vpp_event_queues = vec_dup (parent_wrk->vpp_event_queues); ++ wrk->sessions = pool_dup (parent_wrk->sessions); ++ wrk->session_index_by_vpp_handles = ++ hash_dup (parent_wrk->session_index_by_vpp_handles); ++/*Update listen session for child*/ ++ pool_foreach (listen_session, wrk->sessions, ( ++ { ++ ldp_share_listen_session ++ (parent_wrk, wrk, ++ listen_session);})); ++} ++ ++static void ++ldp_cleanup_vcl_worker (vcl_worker_t * wrk) ++{ ++ vcl_worker_cleanup (wrk, 1 /* notify vpp */ ); ++} ++ ++static void ++ldp_cleanup_forked_child (vcl_worker_t * wrk, vcl_worker_t * child_wrk) ++{ ++ vcl_worker_t *sub_child; ++ int tries = 0; ++ ++ if (child_wrk->forked_child != ~0) ++ { ++ sub_child = vcl_worker_get_if_valid (child_wrk->forked_child); ++ if (sub_child) ++ { ++ /* Wait a bit, maybe the process is going away */ ++ while (kill (sub_child->current_pid, 0) >= 0 && tries++ < 50) ++ usleep (1e3); ++ if (kill (sub_child->current_pid, 0) < 0) ++ ldp_cleanup_forked_child (child_wrk, sub_child); ++ } ++ } ++ ldp_cleanup_vcl_worker (child_wrk); ++ VDBG (0, "Cleaned up forked child wrk %u", child_wrk->wrk_index); ++ wrk->forked_child = ~0; ++} ++ ++static struct sigaction old_sa; ++ ++static void ++ldp_intercept_sigchld_handler (int signum, siginfo_t * si, void *uc) ++{ ++ vcl_worker_t *wrk, *child_wrk; ++ ++ if (vcl_get_worker_index () == ~0) ++ return; ++ ++ /*restore sigchld */ ++ if (sigaction (SIGCHLD, &old_sa, 0)) ++ { ++ VERR ("couldn't restore sigchld"); ++ exit (-1); ++ } ++ ++ wrk = vcl_worker_get_current (); ++ if (wrk->forked_child == ~0) ++ return; ++ ++ child_wrk = vcl_worker_get_if_valid (wrk->forked_child); ++ if (!child_wrk) ++ goto done; ++ ++ if (si && si->si_pid != child_wrk->current_pid) ++ { ++ VDBG (0, "unexpected child pid %u", si->si_pid); ++ goto done; ++ } ++ ldp_cleanup_forked_child (wrk, child_wrk); ++ ++done: ++ if (old_sa.sa_flags & SA_SIGINFO) ++ { ++ void (*fn) (int, siginfo_t *, void *) = old_sa.sa_sigaction; ++ fn (signum, si, uc); ++ } ++ else ++ { ++ void (*fn) (int) = old_sa.sa_handler; ++ if (fn) ++ fn (signum); ++ } ++} ++ ++/*Intercept signal SIGCHLD*/ ++static void ++ldp_intercept_sigchld () ++{ ++ struct sigaction sa; ++ clib_memset (&sa, 0, sizeof (sa)); ++ /*set SA_SIGINFO to validate sa.sa_sigaction rather than sa.sa_handler */ ++ sa.sa_sigaction = ldp_intercept_sigchld_handler; ++ sa.sa_flags = SA_SIGINFO; ++ /*When current process receive the SIGCHLD signal, it would call ++ **ldp_intercept_sigchld_handler. ++ */ ++ if (sigaction (SIGCHLD, &sa, &old_sa)) ++ { ++ VERR ("couldn't intercept sigchld"); ++ exit (-1); ++ } ++} ++ ++static void ++ldp_app_pre_fork (void) ++{ ++ ldp_intercept_sigchld (); ++ vcl_flush_mq_events (); ++} ++ ++static void ++ldp_app_fork_parent_handler (void) ++{ ++ vcl_session_t *listen_session; ++ vcl_worker_t *wrk = vcl_worker_get_current (); ++ listen_session = vcl_session_get (wrk, wrk->listen_session_index); ++ listen_session->session_state = STATE_LISTEN_NO_MQ; ++ vcl_send_session_unlisten (wrk, listen_session); ++ vcm->forking = 1; ++ while (vcm->forking) ++ ; ++ ++} ++ ++static void ++ldp_app_fork_child_handler (void) ++{ ++ vcl_worker_t *parent_wrk; ++ int rv, parent_wrk_index; ++ u8 *child_name; ++ ++ parent_wrk_index = vcl_get_worker_index (); ++ VDBG (0, ++ "initializing forked child (pid) %u with parent wrk (vcl worker index) %u", ++ getpid (), parent_wrk_index); ++ ++/*Allocate vcl worker for child*/ ++ vcl_set_worker_index (~0); ++ if (!vcl_worker_alloc_and_init ()) ++ VERR ("couldn't allocate new worker for child process %u", getpid ()); ++ ++/*Attach to binary api*/ ++ child_name = format (0, "%v-child-%u%c", vcm->app_name, getpid (), 0); ++ vcl_cleanup_bapi (); ++ vppcom_api_hookup (); ++ vcm->app_state = STATE_APP_START; ++ rv = vppcom_connect_to_vpp ((char *) child_name); ++ vec_free (child_name); ++ if (rv) ++ { ++ VERR ("couldn't connect to VPP!"); ++ return; ++ } ++ ++/* ++**Register new allocated vcl worker with VPP ++*/ ++ vcl_worker_register_with_vpp (); ++ parent_wrk = vcl_worker_get (parent_wrk_index); ++ ldp_vcl_worker_copy_on_fork (parent_wrk); ++ parent_wrk->forked_child = vcl_get_worker_index (); ++ VDBG (0, "forked child main worker initialized"); ++ vcm->forking = 0; ++} ++ + static inline int + ldp_init (void) + { +@@ -179,7 +368,9 @@ ldp_init (void) + + ldp->init = 1; + ldp->vcl_needs_real_epoll = 1; +- rv = vls_app_create (ldp_get_app_name ()); ++ rv = vppcom_app_create (ldp_get_app_name ()); ++ pthread_atfork (ldp_app_pre_fork, ldp_app_fork_parent_handler, ++ ldp_app_fork_child_handler); + if (rv != VPPCOM_OK) + { + ldp->vcl_needs_real_epoll = 0; +@@ -226,43 +417,43 @@ ldp_init (void) + { + LDBG (0, "WARNING: Invalid LDP sid bit specified in the env var " + LDP_ENV_SID_BIT " (%s)! sid bit value %d (0x%x)", env_var_str, +- ldp->vlsh_bit_val, ldp->vlsh_bit_val); ++ ldp->vcl_bit_val, ldp->vcl_bit_val); + } + else if (sb < LDP_SID_BIT_MIN) + { +- ldp->vlsh_bit_val = (1 << LDP_SID_BIT_MIN); +- ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; ++ ldp->vcl_bit_val = (1 << LDP_SID_BIT_MIN); ++ ldp->vcl_bit_mask = ldp->vcl_bit_val - 1; + + LDBG (0, "WARNING: LDP sid bit (%u) specified in the env var " + LDP_ENV_SID_BIT " (%s) is too small. Using LDP_SID_BIT_MIN" + " (%d)! sid bit value %d (0x%x)", sb, env_var_str, +- LDP_SID_BIT_MIN, ldp->vlsh_bit_val, ldp->vlsh_bit_val); ++ LDP_SID_BIT_MIN, ldp->vcl_bit_val, ldp->vcl_bit_val); + } + else if (sb > LDP_SID_BIT_MAX) + { +- ldp->vlsh_bit_val = (1 << LDP_SID_BIT_MAX); +- ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; ++ ldp->vcl_bit_val = (1 << LDP_SID_BIT_MAX); ++ ldp->vcl_bit_mask = ldp->vcl_bit_val - 1; + + LDBG (0, "WARNING: LDP sid bit (%u) specified in the env var " + LDP_ENV_SID_BIT " (%s) is too big. Using LDP_SID_BIT_MAX" + " (%d)! sid bit value %d (0x%x)", sb, env_var_str, +- LDP_SID_BIT_MAX, ldp->vlsh_bit_val, ldp->vlsh_bit_val); ++ LDP_SID_BIT_MAX, ldp->vcl_bit_val, ldp->vcl_bit_val); + } + else + { +- ldp->vlsh_bit_val = (1 << sb); +- ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; ++ ldp->vcl_bit_val = (1 << sb); ++ ldp->vcl_bit_mask = ldp->vcl_bit_val - 1; + + LDBG (0, "configured LDP sid bit (%u) from " + LDP_ENV_SID_BIT "! sid bit value %d (0x%x)", sb, +- ldp->vlsh_bit_val, ldp->vlsh_bit_val); ++ ldp->vcl_bit_val, ldp->vcl_bit_val); + } + + /* Make sure there are enough bits in the fd set for vcl sessions */ +- if (ldp->vlsh_bit_val > FD_SETSIZE / 2) ++ if (ldp->vcl_bit_val > FD_SETSIZE / 2) + { +- LDBG (0, "ERROR: LDP vlsh bit value %d > FD_SETSIZE/2 %d!", +- ldp->vlsh_bit_val, FD_SETSIZE / 2); ++ LDBG (0, "ERROR: LDP vclsh bit value %d > FD_SETSIZE/2 %d!", ++ ldp->vcl_bit_val, FD_SETSIZE / 2); + ldp->init = 0; + return -1; + } +@@ -287,16 +478,16 @@ ldp_init (void) + int + close (int fd) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv, epfd; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { +- epfd = vls_attr (vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); ++ epfd = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + if (epfd > 0) + { + LDBG (0, "fd %d: calling libc_close: epfd %u", fd, epfd); +@@ -307,7 +498,8 @@ close (int fd) + u32 size = sizeof (epfd); + epfd = 0; + +- (void) vls_attr (vlsh, VPPCOM_ATTR_SET_LIBC_EPFD, &epfd, &size); ++ (void) vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_LIBC_EPFD, ++ &epfd, &size); + } + } + else if (PREDICT_FALSE (epfd < 0)) +@@ -317,9 +509,9 @@ close (int fd) + goto done; + } + +- LDBG (0, "fd %d: calling vls_close: vlsh %u", fd, vlsh); ++ LDBG (0, "fd %d: calling vppcom_session_close: vclsh %u", fd, vclsh); + +- rv = vls_close (vlsh); ++ rv = vppcom_session_close (vclsh); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -339,16 +531,16 @@ done: + ssize_t + read (int fd, void *buf, size_t nbytes) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { +- size = vls_read (vlsh, buf, nbytes); ++ size = vppcom_session_read (vclsh, buf, nbytes); + if (size < 0) + { + errno = -size; +@@ -367,20 +559,21 @@ ssize_t + readv (int fd, const struct iovec * iov, int iovcnt) + { + int rv = 0, i, total = 0; +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size = 0; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + do + { + for (i = 0; i < iovcnt; ++i) + { +- rv = vls_read (vlsh, iov[i].iov_base, iov[i].iov_len); ++ rv = ++ vppcom_session_read (vclsh, iov[i].iov_base, iov[i].iov_len); + if (rv < 0) + break; + else +@@ -412,16 +605,16 @@ readv (int fd, const struct iovec * iov, int iovcnt) + ssize_t + write (int fd, const void *buf, size_t nbytes) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size = 0; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { +- size = vls_write_msg (vlsh, (void *) buf, nbytes); ++ size = vppcom_session_write_msg (vclsh, (void *) buf, nbytes); + if (size < 0) + { + errno = -size; +@@ -440,20 +633,22 @@ ssize_t + writev (int fd, const struct iovec * iov, int iovcnt) + { + ssize_t size = 0, total = 0; +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int i, rv = 0; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + do + { + for (i = 0; i < iovcnt; ++i) + { +- rv = vls_write_msg (vlsh, iov[i].iov_base, iov[i].iov_len); ++ rv = ++ vppcom_session_write_msg (vclsh, iov[i].iov_base, ++ iov[i].iov_len); + if (rv < 0) + break; + else +@@ -485,7 +680,7 @@ writev (int fd, const struct iovec * iov, int iovcnt) + int + fcntl (int fd, int cmd, ...) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv = 0; + va_list ap; + +@@ -494,9 +689,9 @@ fcntl (int fd, int cmd, ...) + + va_start (ap, cmd); + +- vlsh = ldp_fd_to_vlsh (fd); +- LDBG (0, "fd %u vlsh %d, cmd %u", fd, vlsh, cmd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ LDBG (0, "fd %u vclsh %d, cmd %u", fd, vclsh, cmd); ++ if (vclsh != INVALID_SESSION_ID) + { + int flags = va_arg (ap, int); + u32 size; +@@ -506,11 +701,13 @@ fcntl (int fd, int cmd, ...) + switch (cmd) + { + case F_SETFL: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_FLAGS, &flags, &size); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_FLAGS, &flags, &size); + break; + + case F_GETFL: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_FLAGS, &flags, &size); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_FLAGS, &flags, &size); + if (rv == VPPCOM_OK) + rv = flags; + break; +@@ -542,7 +739,7 @@ fcntl (int fd, int cmd, ...) + int + ioctl (int fd, unsigned long int cmd, ...) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + va_list ap; + int rv; + +@@ -551,13 +748,13 @@ ioctl (int fd, unsigned long int cmd, ...) + + va_start (ap, cmd); + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + switch (cmd) + { + case FIONREAD: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_NREAD, 0, 0); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_NREAD, 0, 0); + break; + + case FIONBIO: +@@ -569,7 +766,9 @@ ioctl (int fd, unsigned long int cmd, ...) + * non-blocking, the flags should be read here and merged + * with O_NONBLOCK. + */ +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_FLAGS, &flags, &size); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_FLAGS, &flags, ++ &size); + } + break; + +@@ -599,7 +798,7 @@ ldp_select_init_maps (fd_set * __restrict original, + u32 n_bytes, uword * si_bits, uword * libc_bits) + { + uword si_bits_set, libc_bits_set; +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int fd; + + clib_bitmap_validate (*vclb, minbits); +@@ -612,11 +811,11 @@ ldp_select_init_maps (fd_set * __restrict original, + clib_bitmap_foreach (fd, *resultb, ({ + if (fd > nfds) + break; +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh == VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh == INVALID_SESSION_ID) + clib_bitmap_set_no_check (*libcb, fd, 1); + else +- clib_bitmap_set_no_check (*vclb, vlsh_to_session_index (vlsh), 1); ++ clib_bitmap_set_no_check (*vclb, vppcom_session_index (vclsh), 1); + })); + /* *INDENT-ON* */ + +@@ -630,7 +829,7 @@ ldp_select_init_maps (fd_set * __restrict original, + always_inline int + ldp_select_vcl_map_to_libc (clib_bitmap_t * vclb, fd_set * __restrict libcb) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + uword si; + int fd; + +@@ -639,8 +838,8 @@ ldp_select_vcl_map_to_libc (clib_bitmap_t * vclb, fd_set * __restrict libcb) + + /* *INDENT-OFF* */ + clib_bitmap_foreach (si, vclb, ({ +- vlsh = vls_session_index_to_vlsh (si); +- fd = ldp_vlsh_to_fd (vlsh); ++ vclsh = vcl_session_handle_from_index (si); ++ fd = ldp_vclsh_to_fd (vclsh); + if (PREDICT_FALSE (fd < 0)) + { + errno = EBADFD; +@@ -713,7 +912,7 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, + else + time_out = -1; + +- if (nfds <= ldp->vlsh_bit_val) ++ if (nfds <= ldp->vcl_bit_val) + { + rv = libc_pselect (nfds, readfds, writefds, exceptfds, + timeout, sigmask); +@@ -763,9 +962,10 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, + vec_len (ldpw->ex_bitmap) * + sizeof (clib_bitmap_t)); + +- rv = vls_select (si_bits, readfds ? ldpw->rd_bitmap : NULL, +- writefds ? ldpw->wr_bitmap : NULL, +- exceptfds ? ldpw->ex_bitmap : NULL, vcl_timeout); ++ rv = vppcom_select (si_bits, readfds ? ldpw->rd_bitmap : NULL, ++ writefds ? ldpw->wr_bitmap : NULL, ++ exceptfds ? ldpw->ex_bitmap : NULL, ++ vcl_timeout); + if (rv < 0) + { + errno = -rv; +@@ -877,7 +1077,7 @@ pselect (int nfds, fd_set * __restrict readfds, + /* If transparent TLS mode is turned on, then ldp will load key and cert. + */ + static int +-load_tls_cert (vls_handle_t vlsh) ++load_tls_cert (vcl_session_handle_t vclsh) + { + char *env_var_str = getenv (LDP_ENV_TLS_CERT); + char inbuf[4096]; +@@ -895,7 +1095,7 @@ load_tls_cert (vls_handle_t vlsh) + } + cert_size = fread (inbuf, sizeof (char), sizeof (inbuf), fp); + tls_cert = inbuf; +- vppcom_session_tls_add_cert (vlsh_to_session_index (vlsh), tls_cert, ++ vppcom_session_tls_add_cert (vppcom_session_index (vclsh), tls_cert, + cert_size); + fclose (fp); + } +@@ -909,7 +1109,7 @@ load_tls_cert (vls_handle_t vlsh) + } + + static int +-load_tls_key (vls_handle_t vlsh) ++load_tls_key (vcl_session_handle_t vclsh) + { + char *env_var_str = getenv (LDP_ENV_TLS_KEY); + char inbuf[4096]; +@@ -927,7 +1127,7 @@ load_tls_key (vls_handle_t vlsh) + } + key_size = fread (inbuf, sizeof (char), sizeof (inbuf), fp); + tls_key = inbuf; +- vppcom_session_tls_add_key (vlsh_to_session_index (vlsh), tls_key, ++ vppcom_session_tls_add_key (vppcom_session_index (vclsh), tls_key, + key_size); + fclose (fp); + } +@@ -944,7 +1144,7 @@ socket (int domain, int type, int protocol) + { + int rv, sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); + u8 is_nonblocking = type & SOCK_NONBLOCK ? 1 : 0; +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + + if ((errno = -ldp_init ())) + return -1; +@@ -961,25 +1161,26 @@ socket (int domain, int type, int protocol) + proto = ((sock_type == SOCK_DGRAM) ? + VPPCOM_PROTO_UDP : VPPCOM_PROTO_TCP); + +- LDBG (0, "calling vls_create: proto %u (%s), is_nonblocking %u", ++ LDBG (0, ++ "calling vppcom_session_create: proto %u (%s), is_nonblocking %u", + proto, vppcom_proto_str (proto), is_nonblocking); + +- vlsh = vls_create (proto, is_nonblocking); +- if (vlsh < 0) ++ vclsh = vppcom_session_create (proto, is_nonblocking); ++ if (vclsh < 0) + { +- errno = -vlsh; ++ errno = -vclsh; + rv = -1; + } + else + { + if (ldp->transparent_tls) + { +- if (load_tls_cert (vlsh) < 0 || load_tls_key (vlsh) < 0) ++ if (load_tls_cert (vclsh) < 0 || load_tls_key (vclsh) < 0) + { + return -1; + } + } +- rv = ldp_vlsh_to_fd (vlsh); ++ rv = ldp_vclsh_to_fd (vclsh); + } + } + else +@@ -1025,14 +1226,14 @@ socketpair (int domain, int type, int protocol, int fds[2]) + int + bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + vppcom_endpt_t ep; + +@@ -1041,8 +1242,8 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + case AF_INET: + if (len != sizeof (struct sockaddr_in)) + { +- LDBG (0, "ERROR: fd %d: vlsh %u: Invalid AF_INET addr len %u!", +- fd, vlsh, len); ++ LDBG (0, "ERROR: fd %d: vclsh %u: Invalid AF_INET addr len %u!", ++ fd, vclsh, len); + errno = EINVAL; + rv = -1; + goto done; +@@ -1055,8 +1256,9 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + case AF_INET6: + if (len != sizeof (struct sockaddr_in6)) + { +- LDBG (0, "ERROR: fd %d: vlsh %u: Invalid AF_INET6 addr len %u!", +- fd, vlsh, len); ++ LDBG (0, ++ "ERROR: fd %d: vclsh %u: Invalid AF_INET6 addr len %u!", ++ fd, vclsh, len); + errno = EINVAL; + rv = -1; + goto done; +@@ -1067,16 +1269,17 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + break; + + default: +- LDBG (0, "ERROR: fd %d: vlsh %u: Unsupported address family %u!", +- fd, vlsh, addr->sa_family); ++ LDBG (0, "ERROR: fd %d: vclsh %u: Unsupported address family %u!", ++ fd, vclsh, addr->sa_family); + errno = EAFNOSUPPORT; + rv = -1; + goto done; + } +- LDBG (0, "fd %d: calling vls_bind: vlsh %u, addr %p, len %u", fd, vlsh, +- addr, len); ++ LDBG (0, ++ "fd %d: calling vppcom_session_bind: vclsh %u, addr %p, len %u", ++ fd, vclsh, addr, len); + +- rv = vls_bind (vlsh, &ep); ++ rv = vppcom_session_bind (vclsh, &ep); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -1144,14 +1347,14 @@ ldp_copy_ep_to_sockaddr (__SOCKADDR_ARG addr, socklen_t * __restrict len, + int + getsockname (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + vppcom_endpt_t ep; + u8 addr_buf[sizeof (struct in6_addr)]; +@@ -1159,7 +1362,7 @@ getsockname (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) + + ep.ip = addr_buf; + +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -1186,7 +1389,7 @@ getsockname (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) + int + connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) +@@ -1200,8 +1403,8 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + goto done; + } + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + vppcom_endpt_t ep; + +@@ -1210,8 +1413,8 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + case AF_INET: + if (len != sizeof (struct sockaddr_in)) + { +- LDBG (0, "fd %d: ERROR vlsh %u: Invalid AF_INET addr len %u!", +- fd, vlsh, len); ++ LDBG (0, "fd %d: ERROR vclsh %u: Invalid AF_INET addr len %u!", ++ fd, vclsh, len); + errno = EINVAL; + rv = -1; + goto done; +@@ -1224,8 +1427,8 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + case AF_INET6: + if (len != sizeof (struct sockaddr_in6)) + { +- LDBG (0, "fd %d: ERROR vlsh %u: Invalid AF_INET6 addr len %u!", +- fd, vlsh, len); ++ LDBG (0, "fd %d: ERROR vclsh %u: Invalid AF_INET6 addr len %u!", ++ fd, vclsh, len); + errno = EINVAL; + rv = -1; + goto done; +@@ -1236,16 +1439,17 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) + break; + + default: +- LDBG (0, "fd %d: ERROR vlsh %u: Unsupported address family %u!", +- fd, vlsh, addr->sa_family); ++ LDBG (0, "fd %d: ERROR vclsh %u: Unsupported address family %u!", ++ fd, vclsh, addr->sa_family); + errno = EAFNOSUPPORT; + rv = -1; + goto done; + } +- LDBG (0, "fd %d: calling vls_connect(): vlsh %u addr %p len %u", fd, +- vlsh, addr, len); ++ LDBG (0, ++ "fd %d: calling vppcom_session_connect(): vclsh %u addr %p len %u", ++ fd, vclsh, addr, len); + +- rv = vls_connect (vlsh, &ep); ++ rv = vppcom_session_connect (vclsh, &ep); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -1268,21 +1472,21 @@ done: + int + getpeername (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + vppcom_endpt_t ep; + u8 addr_buf[sizeof (struct in6_addr)]; + u32 size = sizeof (ep); + + ep.ip = addr_buf; +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_PEER_ADDR, &ep, &size); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_PEER_ADDR, &ep, &size); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -1309,15 +1513,15 @@ getpeername (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) + ssize_t + send (int fd, const void *buf, size_t n, int flags) + { +- vls_handle_t vlsh = ldp_fd_to_vlsh (fd); ++ vcl_session_handle_t vclsh = ldp_fd_to_vclsh (fd); + ssize_t size; + + if ((errno = -ldp_init ())) + return -1; + +- if (vlsh != VLS_INVALID_HANDLE) ++ if (vclsh != INVALID_SESSION_ID) + { +- size = vls_sendto (vlsh, (void *) buf, n, flags, NULL); ++ size = vppcom_session_sendto (vclsh, (void *) buf, n, flags, NULL); + if (size < VPPCOM_OK) + { + errno = -size; +@@ -1336,14 +1540,14 @@ ssize_t + sendfile (int out_fd, int in_fd, off_t * offset, size_t len) + { + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size = 0; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (out_fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (out_fd); ++ if (vclsh != INVALID_SESSION_ID) + { + int rv; + ssize_t results = 0; +@@ -1353,11 +1557,14 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) + u8 eagain = 0; + u32 flags, flags_len = sizeof (flags); + +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_FLAGS, &flags, &flags_len); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_FLAGS, &flags, ++ &flags_len); + if (PREDICT_FALSE (rv != VPPCOM_OK)) + { +- LDBG (0, "ERROR: out fd %d: vls_attr: vlsh %u, returned %d (%s)!", +- out_fd, vlsh, rv, vppcom_retval_str (rv)); ++ LDBG (0, ++ "ERROR: out fd %d: vppcom_session_attr: vclsh %u, returned %d (%s)!", ++ out_fd, vclsh, rv, vppcom_retval_str (rv)); + + vec_reset_length (ldpw->io_buffer); + errno = -rv; +@@ -1379,11 +1586,12 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) + + do + { +- size = vls_attr (vlsh, VPPCOM_ATTR_GET_NWRITE, 0, 0); ++ size = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_NWRITE, 0, 0); + if (size < 0) + { +- LDBG (0, "ERROR: fd %d: vls_attr: vlsh %u returned %d (%s)!", +- out_fd, vlsh, size, vppcom_retval_str (size)); ++ LDBG (0, ++ "ERROR: fd %d: voocom_session_attr: vclsh %u returned %d (%s)!", ++ out_fd, vclsh, size, vppcom_retval_str (size)); + vec_reset_length (ldpw->io_buffer); + errno = -size; + size = -1; +@@ -1416,7 +1624,7 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) + goto update_offset; + } + +- size = vls_write (vlsh, ldpw->io_buffer, nbytes); ++ size = vppcom_session_write (vclsh, ldpw->io_buffer, nbytes); + if (size < 0) + { + if (size == VPPCOM_EAGAIN) +@@ -1486,16 +1694,16 @@ sendfile64 (int out_fd, int in_fd, off_t * offset, size_t len) + ssize_t + recv (int fd, void *buf, size_t n, int flags) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { +- size = vls_recvfrom (vlsh, buf, n, flags, NULL); ++ size = vppcom_session_recvfrom (vclsh, buf, n, flags, NULL); + if (size < 0) + errno = -size; + } +@@ -1511,14 +1719,14 @@ ssize_t + sendto (int fd, const void *buf, size_t n, int flags, + __CONST_SOCKADDR_ARG addr, socklen_t addr_len) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != INVALID_SESSION_ID) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + vppcom_endpt_t *ep = 0; + vppcom_endpt_t _ep; +@@ -1551,7 +1759,7 @@ sendto (int fd, const void *buf, size_t n, int flags, + } + } + +- size = vls_sendto (vlsh, (void *) buf, n, flags, ep); ++ size = vppcom_session_sendto (vclsh, (void *) buf, n, flags, ep); + if (size < 0) + { + errno = -size; +@@ -1571,14 +1779,14 @@ ssize_t + recvfrom (int fd, void *__restrict buf, size_t n, int flags, + __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) + { +- vls_handle_t sid; ++ vcl_session_handle_t sid; + ssize_t size, rv; + + if ((errno = -ldp_init ())) + return -1; + +- sid = ldp_fd_to_vlsh (fd); +- if (sid != VLS_INVALID_HANDLE) ++ sid = ldp_fd_to_vclsh (fd); ++ if (sid != INVALID_SESSION_ID) + { + vppcom_endpt_t ep; + u8 src_addr[sizeof (struct sockaddr_in6)]; +@@ -1586,7 +1794,7 @@ recvfrom (int fd, void *__restrict buf, size_t n, int flags, + if (addr) + { + ep.ip = src_addr; +- size = vls_recvfrom (sid, buf, n, flags, &ep); ++ size = vppcom_session_recvfrom (sid, buf, n, flags, &ep); + + if (size > 0) + { +@@ -1596,7 +1804,7 @@ recvfrom (int fd, void *__restrict buf, size_t n, int flags, + } + } + else +- size = vls_recvfrom (sid, buf, n, flags, NULL); ++ size = vppcom_session_recvfrom (sid, buf, n, flags, NULL); + + if (size < 0) + { +@@ -1615,14 +1823,14 @@ recvfrom (int fd, void *__restrict buf, size_t n, int flags, + ssize_t + sendmsg (int fd, const struct msghdr * message, int flags) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + LDBG (0, "LDP-TBD"); + errno = ENOSYS; +@@ -1642,7 +1850,7 @@ sendmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags) + { + ssize_t size; + const char *func_str; +- u32 sh = ldp_fd_to_vlsh (fd); ++ u32 sh = ldp_fd_to_vclsh (fd); + + if ((errno = -ldp_init ())) + return -1; +@@ -1687,14 +1895,14 @@ sendmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags) + ssize_t + recvmsg (int fd, struct msghdr * message, int flags) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + ssize_t size; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + LDBG (0, "LDP-TBD"); + errno = ENOSYS; +@@ -1715,7 +1923,7 @@ recvmmsg (int fd, struct mmsghdr *vmessages, + { + ssize_t size; + const char *func_str; +- u32 sh = ldp_fd_to_vlsh (fd); ++ u32 sh = ldp_fd_to_vclsh (fd); + + if ((errno = -ldp_init ())) + return -1; +@@ -1762,14 +1970,14 @@ int + getsockopt (int fd, int level, int optname, + void *__restrict optval, socklen_t * __restrict optlen) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + rv = -EOPNOTSUPP; + +@@ -1779,26 +1987,26 @@ getsockopt (int fd, int level, int optname, + switch (optname) + { + case TCP_NODELAY: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_NODELAY, +- optval, optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_TCP_NODELAY, ++ optval, optlen); + break; + case TCP_MAXSEG: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_USER_MSS, +- optval, optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_TCP_USER_MSS, ++ optval, optlen); + break; + case TCP_KEEPIDLE: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_KEEPIDLE, +- optval, optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_TCP_KEEPIDLE, ++ optval, optlen); + break; + case TCP_KEEPINTVL: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_KEEPINTVL, +- optval, optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_TCP_KEEPINTVL, ++ optval, optlen); + break; + case TCP_INFO: + if (optval && optlen && (*optlen == sizeof (struct tcp_info))) + { +- LDBG (1, "fd %d: vlsh %u SOL_TCP, TCP_INFO, optval %p, " +- "optlen %d: #LDP-NOP#", fd, vlsh, optval, *optlen); ++ LDBG (1, "fd %d: vclsh %u SOL_TCP, TCP_INFO, optval %p, " ++ "optlen %d: #LDP-NOP#", fd, vclsh, optval, *optlen); + memset (optval, 0, *optlen); + rv = VPPCOM_OK; + } +@@ -1812,7 +2020,7 @@ getsockopt (int fd, int level, int optname, + break; + default: + LDBG (0, "ERROR: fd %d: getsockopt SOL_TCP: sid %u, " +- "optname %d unsupported!", fd, vlsh, optname); ++ "optname %d unsupported!", fd, vclsh, optname); + break; + } + break; +@@ -1820,11 +2028,13 @@ getsockopt (int fd, int level, int optname, + switch (optname) + { + case IPV6_V6ONLY: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_V6ONLY, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_V6ONLY, optval, ++ optlen); + break; + default: +- LDBG (0, "ERROR: fd %d: getsockopt SOL_IPV6: vlsh %u " +- "optname %d unsupported!", fd, vlsh, optname); ++ LDBG (0, "ERROR: fd %d: getsockopt SOL_IPV6: vclsh %u " ++ "optname %d unsupported!", fd, vclsh, optname); + break; + } + break; +@@ -1832,35 +2042,47 @@ getsockopt (int fd, int level, int optname, + switch (optname) + { + case SO_ACCEPTCONN: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_LISTEN, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_LISTEN, optval, ++ optlen); + break; + case SO_KEEPALIVE: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_KEEPALIVE, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_KEEPALIVE, optval, ++ optlen); + break; + case SO_PROTOCOL: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_PROTOCOL, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_PROTOCOL, optval, ++ optlen); + *(int *) optval = *(int *) optval ? SOCK_DGRAM : SOCK_STREAM; + break; + case SO_SNDBUF: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TX_FIFO_LEN, +- optval, optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_TX_FIFO_LEN, ++ optval, optlen); + break; + case SO_RCVBUF: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_RX_FIFO_LEN, +- optval, optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_RX_FIFO_LEN, ++ optval, optlen); + break; + case SO_REUSEADDR: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_REUSEADDR, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_REUSEADDR, optval, ++ optlen); + break; + case SO_BROADCAST: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_BROADCAST, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_BROADCAST, optval, ++ optlen); + break; + case SO_ERROR: +- rv = vls_attr (vlsh, VPPCOM_ATTR_GET_ERROR, optval, optlen); ++ rv = ++ vppcom_session_attr (vclsh, VPPCOM_ATTR_GET_ERROR, optval, ++ optlen); + break; + default: +- LDBG (0, "ERROR: fd %d: getsockopt SOL_SOCKET: vlsh %u " +- "optname %d unsupported!", fd, vlsh, optname); ++ LDBG (0, "ERROR: fd %d: getsockopt SOL_SOCKET: vclsh %u " ++ "optname %d unsupported!", fd, vclsh, optname); + break; + } + break; +@@ -1886,14 +2108,14 @@ int + setsockopt (int fd, int level, int optname, + const void *optval, socklen_t optlen) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { + rv = -EOPNOTSUPP; + +@@ -1903,20 +2125,20 @@ setsockopt (int fd, int level, int optname, + switch (optname) + { + case TCP_NODELAY: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_NODELAY, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_TCP_NODELAY, ++ (void *) optval, &optlen); + break; + case TCP_MAXSEG: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_USER_MSS, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_TCP_USER_MSS, ++ (void *) optval, &optlen); + break; + case TCP_KEEPIDLE: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_KEEPIDLE, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_TCP_KEEPIDLE, ++ (void *) optval, &optlen); + break; + case TCP_KEEPINTVL: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_KEEPINTVL, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_TCP_KEEPINTVL, ++ (void *) optval, &optlen); + break; + case TCP_CONGESTION: + case TCP_CORK: +@@ -1924,8 +2146,8 @@ setsockopt (int fd, int level, int optname, + rv = 0; + break; + default: +- LDBG (0, "ERROR: fd %d: setsockopt() SOL_TCP: vlsh %u" +- "optname %d unsupported!", fd, vlsh, optname); ++ LDBG (0, "ERROR: fd %d: setsockopt() SOL_TCP: vclsh %u" ++ "optname %d unsupported!", fd, vclsh, optname); + break; + } + break; +@@ -1933,12 +2155,12 @@ setsockopt (int fd, int level, int optname, + switch (optname) + { + case IPV6_V6ONLY: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_V6ONLY, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_V6ONLY, ++ (void *) optval, &optlen); + break; + default: +- LDBG (0, "ERROR: fd %d: setsockopt SOL_IPV6: vlsh %u" +- "optname %d unsupported!", fd, vlsh, optname); ++ LDBG (0, "ERROR: fd %d: setsockopt SOL_IPV6: vclsh %u" ++ "optname %d unsupported!", fd, vclsh, optname); + break; + } + break; +@@ -1946,20 +2168,20 @@ setsockopt (int fd, int level, int optname, + switch (optname) + { + case SO_KEEPALIVE: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_KEEPALIVE, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_KEEPALIVE, ++ (void *) optval, &optlen); + break; + case SO_REUSEADDR: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_REUSEADDR, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_REUSEADDR, ++ (void *) optval, &optlen); + break; + case SO_BROADCAST: +- rv = vls_attr (vlsh, VPPCOM_ATTR_SET_BROADCAST, +- (void *) optval, &optlen); ++ rv = vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_BROADCAST, ++ (void *) optval, &optlen); + break; + default: +- LDBG (0, "ERROR: fd %d: setsockopt SOL_SOCKET: vlsh %u " +- "optname %d unsupported!", fd, vlsh, optname); ++ LDBG (0, "ERROR: fd %d: setsockopt SOL_SOCKET: vclsh %u " ++ "optname %d unsupported!", fd, vclsh, optname); + break; + } + break; +@@ -1984,18 +2206,20 @@ setsockopt (int fd, int level, int optname, + int + listen (int fd, int n) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; ++ vcl_worker_t *wrk = vcl_worker_get_current (); + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { +- LDBG (0, "fd %d: calling vls_listen: vlsh %u, n %d", fd, vlsh, n); ++ LDBG (0, "fd %d: calling vppcom_session_listen: vclsh %u, n %d", fd, ++ vclsh, n); + +- rv = vls_listen (vlsh, n); ++ rv = vppcom_session_listen (vclsh, n); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -2009,6 +2233,10 @@ listen (int fd, int n) + } + + LDBG (1, "fd %d: returning %d", fd, rv); ++/*Update listen info in vcl worker*/ ++ wrk->listen_fd = fd; ++ wrk->listen_queue_size = n; ++ wrk->listen_session_index = vppcom_session_index (vclsh); + return rv; + } + +@@ -2016,14 +2244,14 @@ static inline int + ldp_accept4 (int listen_fd, __SOCKADDR_ARG addr, + socklen_t * __restrict addr_len, int flags) + { +- vls_handle_t listen_vlsh, accept_vlsh; ++ vcl_session_handle_t listen_vclsh, accept_vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- listen_vlsh = ldp_fd_to_vlsh (listen_fd); +- if (listen_vlsh != VLS_INVALID_HANDLE) ++ listen_vclsh = ldp_fd_to_vclsh (listen_fd); ++ if (listen_vclsh != INVALID_SESSION_ID) + { + vppcom_endpt_t ep; + u8 src_addr[sizeof (struct sockaddr_in6)]; +@@ -2031,12 +2259,12 @@ ldp_accept4 (int listen_fd, __SOCKADDR_ARG addr, + ep.ip = src_addr; + + LDBG (0, "listen fd %d: calling vppcom_session_accept: listen sid %u," +- " ep %p, flags 0x%x", listen_fd, listen_vlsh, ep, flags); ++ " ep %p, flags 0x%x", listen_fd, listen_vclsh, ep, flags); + +- accept_vlsh = vls_accept (listen_vlsh, &ep, flags); +- if (accept_vlsh < 0) ++ accept_vclsh = vppcom_session_accept (listen_vclsh, &ep, flags); ++ if (accept_vclsh < 0) + { +- errno = -accept_vlsh; ++ errno = -accept_vclsh; + rv = -1; + } + else +@@ -2044,13 +2272,13 @@ ldp_accept4 (int listen_fd, __SOCKADDR_ARG addr, + rv = ldp_copy_ep_to_sockaddr (addr, addr_len, &ep); + if (rv != VPPCOM_OK) + { +- (void) vls_close (accept_vlsh); ++ (void) vppcom_session_close (accept_vclsh); + errno = -rv; + rv = -1; + } + else + { +- rv = ldp_vlsh_to_fd (accept_vlsh); ++ rv = ldp_vclsh_to_fd (accept_vclsh); + } + } + } +@@ -2083,25 +2311,26 @@ accept (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) + int + shutdown (int fd, int how) + { +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv = 0, flags; + u32 flags_len = sizeof (flags); + + if ((errno = -ldp_init ())) + return -1; + +- vlsh = ldp_fd_to_vlsh (fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fd); ++ if (vclsh != INVALID_SESSION_ID) + { +- LDBG (0, "called shutdown: fd %u vlsh %u how %d", fd, vlsh, how); ++ LDBG (0, "called shutdown: fd %u vclsh %u how %d", fd, vclsh, how); + +- if (vls_attr (vlsh, VPPCOM_ATTR_SET_SHUT, &how, &flags_len)) ++ if (vppcom_session_attr (vclsh, VPPCOM_ATTR_SET_SHUT, &how, &flags_len)) + { + close (fd); + return -1; + } + +- if (vls_attr (vlsh, VPPCOM_ATTR_GET_SHUT, &flags, &flags_len)) ++ if (vppcom_session_attr ++ (vclsh, VPPCOM_ATTR_GET_SHUT, &flags, &flags_len)) + { + close (fd); + return -1; +@@ -2123,7 +2352,7 @@ int + epoll_create1 (int flags) + { + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + int rv; + + if ((errno = -ldp_init ())) +@@ -2144,17 +2373,17 @@ epoll_create1 (int flags) + return rv; + } + +- vlsh = vls_epoll_create (); +- if (PREDICT_FALSE (vlsh == VLS_INVALID_HANDLE)) ++ vclsh = vppcom_epoll_create (); ++ if (PREDICT_FALSE (vclsh == INVALID_SESSION_ID)) + { +- errno = -vlsh; ++ errno = -vclsh; + rv = -1; + } + else + { +- rv = ldp_vlsh_to_fd (vlsh); ++ rv = ldp_vclsh_to_fd (vclsh); + } +- LDBG (0, "epoll_create epfd %u vlsh %u", rv, vlsh); ++ LDBG (0, "epoll_create epfd %u vclsh %u", rv, vclsh); + return rv; + } + +@@ -2167,14 +2396,14 @@ epoll_create (int size) + int + epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) + { +- vls_handle_t vep_vlsh, vlsh; ++ vcl_session_handle_t vep_vclsh, vclsh; + int rv; + + if ((errno = -ldp_init ())) + return -1; + +- vep_vlsh = ldp_fd_to_vlsh (epfd); +- if (PREDICT_FALSE (vep_vlsh == VLS_INVALID_HANDLE)) ++ vep_vclsh = ldp_fd_to_vclsh (epfd); ++ if (PREDICT_FALSE (vep_vclsh == INVALID_SESSION_ID)) + { + /* The LDP epoll_create1 always creates VCL epfd's. + * The app should never have a kernel base epoll fd unless it +@@ -2188,17 +2417,18 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) + goto done; + } + +- vlsh = ldp_fd_to_vlsh (fd); ++ vclsh = ldp_fd_to_vclsh (fd); + +- LDBG (0, "epfd %d ep_vlsh %d, fd %u vlsh %d, op %u", epfd, vep_vlsh, fd, +- vlsh, op); ++ LDBG (0, "epfd %d ep_vclsh %d, fd %u vclsh %d, op %u", epfd, vep_vclsh, fd, ++ vclsh, op); + +- if (vlsh != VLS_INVALID_HANDLE) ++ if (vclsh != INVALID_SESSION_ID) + { +- LDBG (1, "epfd %d: calling vls_epoll_ctl: ep_vlsh %d op %d, vlsh %u," +- " event %p", epfd, vep_vlsh, vlsh, event); ++ LDBG (1, ++ "epfd %d: calling vppcom_epoll_ctl: ep_vclsh %d op %d, vclsh %u," ++ " event %p", epfd, vep_vclsh, vclsh, event); + +- rv = vls_epoll_ctl (vep_vlsh, op, vlsh, event); ++ rv = vppcom_epoll_ctl (vep_vclsh, op, vclsh, event); + if (rv != VPPCOM_OK) + { + errno = -rv; +@@ -2210,11 +2440,12 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) + int libc_epfd; + u32 size = sizeof (epfd); + +- libc_epfd = vls_attr (vep_vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); ++ libc_epfd = ++ vppcom_session_attr (vep_vclsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + if (!libc_epfd) + { +- LDBG (1, "epfd %d, vep_vlsh %d calling libc_epoll_create1: " +- "EPOLL_CLOEXEC", epfd, vep_vlsh); ++ LDBG (1, "epfd %d, vep_vclsh %d calling libc_epoll_create1: " ++ "EPOLL_CLOEXEC", epfd, vep_vclsh); + + libc_epfd = libc_epoll_create1 (EPOLL_CLOEXEC); + if (libc_epfd < 0) +@@ -2223,8 +2454,9 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) + goto done; + } + +- rv = vls_attr (vep_vlsh, VPPCOM_ATTR_SET_LIBC_EPFD, &libc_epfd, +- &size); ++ rv = ++ vppcom_session_attr (vep_vclsh, VPPCOM_ATTR_SET_LIBC_EPFD, ++ &libc_epfd, &size); + if (rv < 0) + { + errno = -rv; +@@ -2256,7 +2488,7 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); + double time_to_wait = (double) 0, max_time; + int libc_epfd, rv = 0; +- vls_handle_t ep_vlsh; ++ vcl_session_handle_t ep_vclsh; + + if ((errno = -ldp_init ())) + return -1; +@@ -2270,10 +2502,10 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, + if (epfd == ldpw->vcl_mq_epfd) + return libc_epoll_pwait (epfd, events, maxevents, timeout, sigmask); + +- ep_vlsh = ldp_fd_to_vlsh (epfd); +- if (PREDICT_FALSE (ep_vlsh == VLS_INVALID_HANDLE)) ++ ep_vclsh = ldp_fd_to_vclsh (epfd); ++ if (PREDICT_FALSE (ep_vclsh == INVALID_SESSION_ID)) + { +- LDBG (0, "epfd %d: bad ep_vlsh %d!", epfd, ep_vlsh); ++ LDBG (0, "epfd %d: bad ep_vclsh %d!", epfd, ep_vclsh); + errno = EBADFD; + return -1; + } +@@ -2283,7 +2515,7 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, + time_to_wait = ((timeout >= 0) ? (double) timeout / 1000 : 0); + max_time = clib_time_now (&ldpw->clib_time) + time_to_wait; + +- libc_epfd = vls_attr (ep_vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); ++ libc_epfd = vppcom_session_attr (ep_vclsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + if (PREDICT_FALSE (libc_epfd < 0)) + { + errno = -libc_epfd; +@@ -2292,13 +2524,13 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, + } + + LDBG (2, "epfd %d: vep_idx %d, libc_epfd %d, events %p, maxevents %d, " +- "timeout %d, sigmask %p: time_to_wait %.02f", epfd, ep_vlsh, ++ "timeout %d, sigmask %p: time_to_wait %.02f", epfd, ep_vclsh, + libc_epfd, events, maxevents, timeout, sigmask, time_to_wait); + do + { + if (!ldpw->epoll_wait_vcl) + { +- rv = vls_epoll_wait (ep_vlsh, events, maxevents, 0); ++ rv = vppcom_epoll_wait (ep_vclsh, events, maxevents, 0); + if (rv > 0) + { + ldpw->epoll_wait_vcl = 1; +@@ -2345,7 +2577,7 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) + { + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); + int rv, i, n_revents = 0; +- vls_handle_t vlsh; ++ vcl_session_handle_t vclsh; + vcl_poll_t *vp; + double max_time; + +@@ -2362,13 +2594,13 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) + if (fds[i].fd < 0) + continue; + +- vlsh = ldp_fd_to_vlsh (fds[i].fd); +- if (vlsh != VLS_INVALID_HANDLE) ++ vclsh = ldp_fd_to_vclsh (fds[i].fd); ++ if (vclsh != INVALID_SESSION_ID) + { + fds[i].fd = -fds[i].fd; + vec_add2 (ldpw->vcl_poll, vp, 1); + vp->fds_ndx = i; +- vp->sh = vlsh_to_sh (vlsh); ++ vp->sh = vclsh; + vp->events = fds[i].events; + #ifdef __USE_XOPEN2K + if (fds[i].events & POLLRDNORM) +diff --git a/src/vcl/ldp.h b/src/vcl/ldp.h +index 8d78ead08..0a03f442d 100644 +--- a/src/vcl/ldp.h ++++ b/src/vcl/ldp.h +@@ -34,7 +34,7 @@ + #define LDP_ENV_TLS_KEY "LDP_TLS_KEY_FILE" + #define LDP_ENV_TLS_TRANS "LDP_TRANSPARENT_TLS" + +-#define LDP_SID_BIT_MIN 5 ++#define LDP_SID_BIT_MIN 16 + #define LDP_SID_BIT_MAX 30 + + #define LDP_APP_NAME_MAX 256 +diff --git a/src/vcl/vcl_private.h b/src/vcl/vcl_private.h +index 8fdf7551c..16c23de82 100644 +--- a/src/vcl/vcl_private.h ++++ b/src/vcl/vcl_private.h +@@ -238,7 +238,12 @@ typedef struct vcl_worker_ + /* Session pool */ + vcl_session_t *sessions; + +- /** Worker/thread index in current process */ ++ u32 listen_session_index; ++ ++ u32 listen_fd; ++ ++ u32 listen_queue_size; ++/** Worker/thread index in current process */ + u32 wrk_index; + + /** Worker index in vpp*/ +-- +2.17.1 + -- cgit 1.2.3-korg