diff options
author | Yu Ping <ping.yu@intel.com> | 2020-02-21 22:36:20 +0800 |
---|---|---|
committer | Florin Coras <fcoras@cisco.com> | 2020-02-22 00:30:48 +0000 |
commit | 54346b61f91008c5098243b588f184ad92ad29c9 (patch) | |
tree | 60116fad568970aee2538a081de0560b0487db8c /vpp_patches | |
parent | 4b0794f139564682503fcd2f59c7bcd3238e6633 (diff) |
initial version of VSAP
Signed-off-by: Yu Ping <ping.yu@intel.com>
Change-Id: I04d9150f0c7607ba20de9096b452476eff1622fc
Diffstat (limited to 'vpp_patches')
-rw-r--r-- | vpp_patches/common/0001-session-pinning.patch | 168 | ||||
-rw-r--r-- | vpp_patches/ldp/0001-LDP-remove-lock.patch | 1700 | ||||
-rw-r--r-- | vpp_patches/vcl/0001-ngxvcl-api.patch | 1713 |
3 files changed, 3581 insertions, 0 deletions
diff --git a/vpp_patches/common/0001-session-pinning.patch b/vpp_patches/common/0001-session-pinning.patch new file mode 100644 index 0000000..22faa0b --- /dev/null +++ b/vpp_patches/common/0001-session-pinning.patch @@ -0,0 +1,168 @@ +From 310c46798bdfe655ea35eabec57215568b3632ec Mon Sep 17 00:00:00 2001 +From: SunGuoao <guoao.sun@intel.com> +Date: Thu, 17 Oct 2019 00:16:31 +0800 +Subject: [PATCH] session: pinning + +Change-Id: Ic3600bc293bdae7ff62611da8d1241afccdac02a +--- + src/vnet/session/application.c | 83 ++++++++++++++++++++++++++++++++-- + src/vnet/session/application.h | 13 ++++++ + 2 files changed, 92 insertions(+), 4 deletions(-) + +diff --git a/src/vnet/session/application.c b/src/vnet/session/application.c +index 396470ae6..869fec45c 100644 +--- a/src/vnet/session/application.c ++++ b/src/vnet/session/application.c +@@ -32,13 +32,19 @@ static app_listener_t * + app_listener_alloc (application_t * app) + { + app_listener_t *app_listener; ++ vpp_app_worker_map_t *current_thread_map; + pool_get (app->listeners, app_listener); ++ pool_get (app->app_worker_thread_map, current_thread_map); + clib_memset (app_listener, 0, sizeof (*app_listener)); ++ clib_memset (current_thread_map, 0, sizeof (*current_thread_map)); ++ current_thread_map->map_index = current_thread_map - app->app_worker_thread_map; + app_listener->al_index = app_listener - app->listeners; + app_listener->app_index = app->app_index; + app_listener->session_index = SESSION_INVALID_INDEX; + app_listener->local_index = SESSION_INVALID_INDEX; + app_listener->ls_handle = SESSION_INVALID_HANDLE; ++ app_listener->app_worker_thread_map = app->app_worker_thread_map; ++ app_listener->all_selected = 0; + return app_listener; + } + +@@ -253,18 +259,87 @@ app_listener_cleanup (app_listener_t * al) + app_listener_free (app, al); + } + ++static void ++app_listener_select_worker_add_worker (application_t * app, u32 wrk_index) ++{ ++ u32 current_thread = vlib_get_thread_index (); ++ u32 *added_wrk_index; ++ vpp_app_worker_map_t *current_thread_map; ++ ++ while (pool_is_free_index (app->app_worker_thread_map, current_thread)) ++ { ++ vpp_app_worker_map_t *the_thread_map; ++ ++ pool_get (app->app_worker_thread_map, the_thread_map); ++ clib_memset (the_thread_map, 0, sizeof (*the_thread_map)); ++ the_thread_map->map_index = the_thread_map - app->app_worker_thread_map; ++ } ++ current_thread_map = ++ pool_elt_at_index (app->app_worker_thread_map, current_thread); ++ pool_get (current_thread_map->app_worker_map, added_wrk_index); ++ *added_wrk_index = wrk_index; ++ current_thread_map->total_workers += 1; ++} ++ ++static u32 ++app_listener_select_worker_interval (application_t * app) ++{ ++ u32 current_thread = vlib_get_thread_index (); ++ u32 wrk_index; ++ vpp_app_worker_map_t *current_map; ++ ++ if (PREDICT_FALSE(pool_is_free_index (app->app_worker_thread_map, current_thread))) ++ return 0; ++ ++ current_map = ++ pool_elt_at_index (app->app_worker_thread_map, current_thread); ++ ++ /** If the number of app worker(s) is smaller than vpp worker/thread(s) */ ++ if (PREDICT_FALSE (current_map->total_workers == 0)) ++ return 0; ++ ++ current_map->last_accept_wrk += 1; ++ if (current_map->last_accept_wrk == current_map->total_workers) ++ current_map->last_accept_wrk = 0; ++ ++ wrk_index = current_map->app_worker_map[current_map->last_accept_wrk]; ++ return wrk_index; ++} ++ + static app_worker_t * + app_listener_select_worker (application_t * app, app_listener_t * al) + { + u32 wrk_index; + + app = application_get (al->app_index); +- wrk_index = clib_bitmap_next_set (al->workers, al->accept_rotor + 1); +- if (wrk_index == ~0) +- wrk_index = clib_bitmap_first_set (al->workers); ++ if (PREDICT_FALSE (al->all_selected == 0)) ++ { ++ wrk_index = clib_bitmap_next_set (al->workers, al->accept_rotor + 1); ++ if (wrk_index == ~0) ++ { ++ al->all_selected = 1; ++ wrk_index = app_listener_select_worker_interval (app); ++ if (wrk_index == 0) ++ wrk_index = clib_bitmap_first_set (al->workers); ++ } ++ else ++ { ++ app_listener_select_worker_add_worker (app, wrk_index); ++ al->accept_rotor = wrk_index; ++ } ++ } ++ else ++ { ++ wrk_index = app_listener_select_worker_interval (app); ++ if (PREDICT_FALSE (wrk_index == 0)){ ++ wrk_index = clib_bitmap_next_set (al->workers, al->accept_rotor + 1); ++ if (wrk_index == ~0) ++ wrk_index = clib_bitmap_first_set (al->workers); ++ al->accept_rotor = wrk_index; ++ } ++ } + + ASSERT (wrk_index != ~0); +- al->accept_rotor = wrk_index; + return application_get_worker (app, wrk_index); + } + +diff --git a/src/vnet/session/application.h b/src/vnet/session/application.h +index a853c3cb7..5da3ce84a 100644 +--- a/src/vnet/session/application.h ++++ b/src/vnet/session/application.h +@@ -70,6 +70,14 @@ typedef struct app_worker_map_ + u32 wrk_index; + } app_worker_map_t; + ++typedef struct vpp_app_worker_map_ ++{ ++ u32 map_index; ++ u32 *app_worker_map; /** app worker(s) pinned to the thread */ ++ u32 last_accept_wrk; /** last selected app worker by the thread */ ++ u32 total_workers; /** total app worker(s) pinned to the thread */ ++}vpp_app_worker_map_t; ++ + typedef struct app_listener_ + { + clib_bitmap_t *workers; /**< workers accepting connections */ +@@ -81,6 +89,8 @@ typedef struct app_listener_ + session_handle_t ls_handle; /**< session handle of the local or global + listening session that also identifies + the app listener */ ++ u8 all_selected; ++ vpp_app_worker_map_t *app_worker_thread_map; /** app worker map for the vpp thread */ + } app_listener_t; + + typedef struct application_ +@@ -111,6 +121,9 @@ typedef struct application_ + /** Pool of listeners for the app */ + app_listener_t *listeners; + ++ /** app worker(s) selected by this VPP thread */ ++ vpp_app_worker_map_t *app_worker_thread_map; ++ + /** Preferred tls engine */ + u8 tls_engine; + +-- +2.17.1 + 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 <ping.yu@intel.com> +Date: Wed, 23 Oct 2019 17:56:55 +0800 +Subject: [PATCH] LDP remove lock + +Change-Id: I3b5135194ed93c5e4a259fb2d3f8cae7ef8de4c5 +Signed-off-by: Yu Ping <ping.yu@intel.com> +--- + 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 <vcl/ldp_socket_wrapper.h> + #include <vcl/ldp.h> ++#include <vcl/vppcom.h> ++#include <vcl/vcl_private.h> + #include <sys/time.h> + +-#include <vcl/vcl_locked.h> + #include <vppinfra/time.h> + #include <vppinfra/bitmap.h> + #include <vppinfra/lock.h> +@@ -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 + diff --git a/vpp_patches/vcl/0001-ngxvcl-api.patch b/vpp_patches/vcl/0001-ngxvcl-api.patch new file mode 100644 index 0000000..f294b36 --- /dev/null +++ b/vpp_patches/vcl/0001-ngxvcl-api.patch @@ -0,0 +1,1713 @@ +From 1c07c530f6308362f32c686a571a577380a1b7d8 Mon Sep 17 00:00:00 2001 +From: Zeyu Zhang <zeyu.zhang@intel.com> +Date: Wed, 16 Oct 2019 16:51:22 +0800 +Subject: [PATCH] ngxvcl + +--- + src/vcl/CMakeLists.txt | 10 +- + src/vcl/ngxvcl.c | 1590 ++++++++++++++++++++++++++++++++++++++++ + src/vcl/ngxvcl.h | 70 ++ + 3 files changed, 1669 insertions(+), 1 deletion(-) + create mode 100644 src/vcl/ngxvcl.c + create mode 100644 src/vcl/ngxvcl.h + +diff --git a/src/vcl/CMakeLists.txt b/src/vcl/CMakeLists.txt +index ab0a6ad6a..1b6a9f351 100644 +--- a/src/vcl/CMakeLists.txt ++++ b/src/vcl/CMakeLists.txt +@@ -38,10 +38,18 @@ add_vpp_library(vcl_ldpreload + vppinfra svm vlibmemoryclient rt pthread vppcom dl + ) + ++add_vpp_library(ngxvcl ++ SOURCES ++ ngxvcl.c ++ ++ LINK_LIBRARIES ++ vppinfra svm vlibmemoryclient rt pthread vppcom dl ++) ++ + add_vpp_headers(vcl + ldp.h + ldp_glibc_socket.h + vppcom.h + vcl_locked.h + ldp_socket_wrapper.h +-) +\ No newline at end of file ++) +diff --git a/src/vcl/ngxvcl.c b/src/vcl/ngxvcl.c +new file mode 100644 +index 000000000..157c05246 +--- /dev/null ++++ b/src/vcl/ngxvcl.c +@@ -0,0 +1,1590 @@ ++#include <vcl/ngxvcl.h> ++#include <vcl/vcl_private.h> ++ ++#define MAX_NGX_WORKERS 100 ++#define VFD_OFFSET 0X003F3F3F ++#define NGXVCL_TLS_ON "NGXVCL_TLS_ON" ++#define NGXVCL_TLS_CERT "NGXVCL_TLS_CERT" ++#define NGXVCL_TLS_KEY "NGXVCL_TLS_KEY" ++ ++typedef unsigned char u8; ++typedef unsigned short u16; ++typedef unsigned int u32; ++ ++typedef struct ngxvcl_main_t_ ++{ ++ u32 listen_session_index; ++ u32 master_worker_index; ++ /** Not include master worker index. */ ++ u32 *workers_subscribed_by_ls; ++ clib_bitmap_t *listeners; ++ uword *worker_index_by_pid; ++ int wait_vep_only; ++ int intercepted_sigchld; ++ u8 transparent_tls; ++} ngxvcl_main_t; ++ ++static ngxvcl_main_t *nvm = NULL; ++ ++static u8 *sendfile_io_buffer = NULL; ++ ++static int epoll_fd_for_evtfd = 0; ++ ++static u8 use_mq_eventfd = 0; ++ ++static int wait_kep_next = 0; ++ ++static inline _Bool is_offset_vfd(int fd) ++{ ++ return fd >= VFD_OFFSET; ++} ++static inline int vfd_to_offset_vfd(int vfd) ++{ ++ return vfd + VFD_OFFSET; ++} ++static inline int offset_vfd_to_vfd(int offset_fd) ++{ ++ int vfd = offset_fd - VFD_OFFSET; ++ ++ return (vcl_get_worker_index () << 24) | (vfd & 0X00FFFFFF); ++} ++ ++static int copy_ep_to_sockaddr(struct sockaddr *addr, socklen_t *len, ++ vppcom_endpt_t *ep) ++{ ++ int rv = 0; ++ int sa_len, copy_len; ++ ++ if (addr && len && ep) ++ { ++ addr->sa_family = (ep->is_ip4 == VPPCOM_IS_IP4) ? AF_INET : AF_INET6; ++ ++ switch (addr->sa_family) ++ { ++ case AF_INET: ++ ((struct sockaddr_in *)addr)->sin_port = ep->port; ++ if (*len > sizeof(struct sockaddr_in)) ++ *len = sizeof(struct sockaddr_in); ++ sa_len = sizeof(struct sockaddr_in) - sizeof(struct in_addr); ++ copy_len = *len - sa_len; ++ if (copy_len > 0) ++ memcpy(&((struct sockaddr_in *)addr)->sin_addr, ep->ip, ++ copy_len); ++ break; ++ ++ case AF_INET6: ++ ((struct sockaddr_in6 *)addr)->sin6_port = ep->port; ++ if (*len > sizeof(struct sockaddr_in6)) ++ *len = sizeof(struct sockaddr_in6); ++ sa_len = sizeof(struct sockaddr_in6) - sizeof(struct in6_addr); ++ copy_len = *len - sa_len; ++ if (copy_len > 0) ++ memcpy( ++ ((struct sockaddr_in6 *)addr)->sin6_addr.__in6_u.__u6_addr8, ++ ep->ip, copy_len); ++ break; ++ ++ default: ++ /* Not possible */ ++ rv = -EAFNOSUPPORT; ++ break; ++ } ++ } ++ ++ return rv; ++} ++ ++static void listener_wrk_stop_listen(u32 wrk_index) { ++ vcl_worker_t *wrk; ++ vcl_session_t *s; ++ ++ wrk = vcl_worker_get(wrk_index); ++ s = vcl_session_get (wrk, nvm->listen_session_index); ++ if (s->session_state != STATE_LISTEN) ++ return; ++ vcl_send_session_unlisten(wrk, s); ++ s->session_state = STATE_LISTEN_NO_MQ; ++ clib_bitmap_set(nvm->listeners, wrk_index, 0); ++} ++ ++static void ++share_listen_session (vcl_worker_t * wrk) ++{ ++ vcl_session_t *s; ++ ++ s = vcl_session_get (wrk, nvm->listen_session_index); ++ s->session_state = STATE_LISTEN_NO_MQ; ++ vppcom_session_listen((vcl_get_worker_index() << 24 | nvm->listen_session_index), ~0); ++ clib_bitmap_set(nvm->listeners, vcl_get_worker_index(), 1); ++ if (clib_bitmap_get(nvm->listeners, 0) == 1) ++ listener_wrk_stop_listen (0); ++ vec_add1 (nvm->workers_subscribed_by_ls, wrk->wrk_index); ++} ++ ++static void ++worker_copy_on_fork (vcl_worker_t * parent_wrk) ++{ ++ vcl_worker_t *wrk = vcl_worker_get_current (); ++ ++ 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); ++ ++ share_listen_session (wrk); ++} ++ ++static void ++ngxvcl_cleanup_child_worker (u32 child_wrk_index) ++{ ++ vcl_worker_t *child_wrk = vcl_worker_get(child_wrk_index); ++ vcl_session_t *s; ++ ++ /** Unshare listen session. */ ++ s = vcl_session_get (child_wrk, nvm->listen_session_index); ++ clib_bitmap_set (nvm->listeners, child_wrk_index, 0); ++ vec_del1 (nvm->workers_subscribed_by_ls, child_wrk_index); ++ vcl_session_cleanup (child_wrk, s, vcl_session_handle (s), 1); ++ ++ hash_unset (nvm->worker_index_by_pid, child_wrk->current_pid); ++ vcl_worker_cleanup (child_wrk, 1 /* notify vpp */); ++} ++ ++static struct sigaction old_sa; ++ ++static void ++ngxvcl_intercept_sigchld_handler (int signum, siginfo_t * si, void *uc) ++{ ++ vcl_worker_t *wrk; ++ u32 child_wrk_index; ++ ++ if (vcl_get_worker_index () == ~0) ++ return; ++ ++ if (sigaction (SIGCHLD, &old_sa, 0)) ++ { ++ VERR ("couldn't restore sigchld"); ++ exit (-1); ++ } ++ ++ wrk = vcl_worker_get_current (); ++ child_wrk_index = *(hash_get (nvm->worker_index_by_pid, si->si_pid)); ++ ++ if (si->si_pid != vcl_worker_get(child_wrk_index)->current_pid) ++ { ++ VDBG (0, "unexpected child pid %u", si->si_pid); ++ goto done; ++ } ++ ++ ngxvcl_cleanup_child_worker (child_wrk_index); ++ wrk->forked_child = ~0; ++ ++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); ++ } ++} ++ ++static void ++ngxvcl_incercept_sigchld () ++{ ++ if (!nvm->intercepted_sigchld) ++ { ++ struct sigaction sa; ++ clib_memset (&sa, 0, sizeof (sa)); ++ sa.sa_sigaction = ngxvcl_intercept_sigchld_handler; ++ sa.sa_flags = SA_SIGINFO; ++ if (sigaction (SIGCHLD, &sa, &old_sa)) ++ { ++ VERR ("couldn't intercept sigchld"); ++ exit (-1); ++ } ++ nvm->intercepted_sigchld = 1; ++ } ++} ++ ++static void ++app_pre_fork (void) ++{ ++ ngxvcl_incercept_sigchld (); ++ vcl_flush_mq_events (); ++} ++ ++static void ++app_fork_parent_handler (void) ++{ ++ vcm->forking = 1; ++ while (vcm->forking) ++ ; ++} ++ ++static void ++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 %u with parent wrk %u", getpid (), ++ parent_wrk_index); ++ ++ /* ++ * Allocate worker ++ */ ++ vcl_set_worker_index (~0); ++ if (!vcl_worker_alloc_and_init ()) ++ VERR ("couldn't allocate new worker"); ++ ++ /* ++ * 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 worker with vpp and share listen session ++ */ ++ vcl_worker_register_with_vpp (); ++ parent_wrk = vcl_worker_get (parent_wrk_index); ++ worker_copy_on_fork (parent_wrk); ++ hash_set(nvm->worker_index_by_pid, getpid(), vcl_get_worker_index()); ++ parent_wrk->forked_child = vcl_get_worker_index (); ++ ++ sendfile_io_buffer = NULL; ++ ++ VDBG (0, "forked child main worker initialized"); ++ vcm->forking = 0; ++} ++ ++static void ++sendfile_io_buffer_free (void) ++{ ++ vec_free (sendfile_io_buffer); ++} ++ ++void ngxvcl_wait_vep_only() ++{ ++ if (use_mq_eventfd) ++ return; ++ nvm->wait_vep_only = 1; ++} ++ ++void ngxvcl_wait_kep_and_vep() ++{ ++ if (use_mq_eventfd) ++ return; ++ nvm->wait_vep_only = 0; ++} ++ ++void ngxvcl_app_create(char *app_name) ++{ ++ int rv = vppcom_app_create(app_name); ++ ++ if (rv) ++ { ++ errno = -rv; ++ perror("ERROR when calling ngxvcl_app_create()!"); ++ fprintf(stderr, "\nERROR: ngxvcl_app_create() failed (errno = %d)!\n", -rv); ++ exit(1); ++ } ++ ++ pthread_atfork(app_pre_fork, app_fork_parent_handler, ++ app_fork_child_handler); ++ atexit(sendfile_io_buffer_free); ++ ++ nvm = clib_mem_alloc (sizeof (ngxvcl_main_t)); ++ if (!nvm) ++ { ++ clib_warning ("NgxVCL<%d>: ERROR: clib_mem_alloc() failed!", getpid ()); ++ ASSERT (nvm); ++ return; ++ } ++ clib_memset(nvm, 0, sizeof(ngxvcl_main_t)); ++ clib_bitmap_validate(nvm->listeners, MAX_NGX_WORKERS + 1); ++ clib_bitmap_set(nvm->listeners, vcl_get_worker_index(), 1); ++ hash_set(nvm->worker_index_by_pid, getpid(), vcl_get_worker_index()); ++ ++ if (getenv (NGXVCL_TLS_ON)) ++ nvm->transparent_tls = 1; ++ ++ use_mq_eventfd = vcm->cfg.use_mq_eventfd; ++} ++ ++void ngxvcl_app_destroy(void) ++{ ++ vec_free(nvm->workers_subscribed_by_ls); ++ clib_bitmap_free(nvm->listeners); ++ hash_free(nvm->worker_index_by_pid); ++ clib_mem_free(nvm); ++ vppcom_app_destroy(); ++} ++ ++static int ++ngxvcl_load_tls_cert (uint32_t sh) ++{ ++ char *env_var_str = getenv (NGXVCL_TLS_CERT); ++ char inbuf[4096]; ++ char *tls_cert; ++ int cert_size; ++ FILE *fp; ++ ++ if (env_var_str) ++ { ++ fp = fopen (env_var_str, "r"); ++ if (fp == NULL) ++ { ++ VDBG (0, "ERROR: failed to open cert file %s \n", env_var_str); ++ return -1; ++ } ++ cert_size = fread (inbuf, sizeof (char), sizeof (inbuf), fp); ++ tls_cert = inbuf; ++ vppcom_session_tls_add_cert (sh, tls_cert, ++ cert_size); ++ fclose (fp); ++ } ++ else ++ { ++ VDBG (0, "ERROR: failed to read LDP environment %s\n", ++ NGXVCL_TLS_CERT); ++ return -1; ++ } ++ return 0; ++} ++ ++static int ++ngxvcl_load_tls_key (uint32_t sh) ++{ ++ char *env_var_str = getenv (NGXVCL_TLS_KEY); ++ char inbuf[4096]; ++ char *tls_key; ++ int key_size; ++ FILE *fp; ++ ++ if (env_var_str) ++ { ++ fp = fopen (env_var_str, "r"); ++ if (fp == NULL) ++ { ++ VDBG (0, "ERROR: failed to open key file %s \n", env_var_str); ++ return -1; ++ } ++ key_size = fread (inbuf, sizeof (char), sizeof (inbuf), fp); ++ tls_key = inbuf; ++ vppcom_session_tls_add_key (sh, tls_key, ++ key_size); ++ fclose (fp); ++ } ++ else ++ { ++ VDBG (0, "ERROR: failed to read NGXVCL environment %s\n", NGXVCL_TLS_KEY); ++ return -1; ++ } ++ return 0; ++} ++ ++int ngxvcl_socket(int domain, int type, int protocol) ++{ ++ int rv, sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); ++ u8 is_nonblocking = type & SOCK_NONBLOCK ? 1 : 0; ++ ++ if (((domain == AF_INET) || (domain == AF_INET6)) && ++ ((sock_type == SOCK_STREAM) || (sock_type == SOCK_DGRAM))) ++ { ++ u8 proto; ++ ++ if (nvm->transparent_tls) ++ proto = VPPCOM_PROTO_TLS; ++ else ++ proto = ((sock_type == SOCK_DGRAM) ? VPPCOM_PROTO_UDP : VPPCOM_PROTO_TCP); ++ ++ rv = vppcom_session_create(proto, is_nonblocking); ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ else { ++ if (nvm->transparent_tls) ++ if (ngxvcl_load_tls_cert (rv) < 0 || ngxvcl_load_tls_key (rv) < 0) ++ return -1; ++ ++ rv = vfd_to_offset_vfd(rv); ++ } ++ } ++ else ++ { ++ rv = -1; ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_close(int offset_vfd) ++{ ++ int rv, epfd, vfd = offset_vfd_to_vfd(offset_vfd); ++ ++ epfd = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); ++ if (epfd > 0) { ++ rv = close(epfd); ++ if (rv < 0) { ++ u32 size = sizeof(epfd); ++ epfd = 0; ++ vppcom_session_attr(vfd, VPPCOM_ATTR_SET_LIBC_EPFD, &epfd, &size); ++ } ++ } ++ else if (epfd < 0) { ++ errno = -epfd; ++ rv = -1; ++ return rv; ++ } ++ ++ rv = vppcom_session_close(offset_vfd_to_vfd(offset_vfd)); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_kvfd_close(int fd) ++{ ++ int rv; ++ ++ if (is_offset_vfd(fd)) ++ rv = ngxvcl_close(fd); ++ else ++ rv = close(fd); ++ ++ return rv; ++} ++ ++int ngxvcl_bind(int offset_vfd, const struct sockaddr *addr, socklen_t addrlen) ++{ ++ int rv; ++ vppcom_endpt_t ep; ++ ++ switch (addr->sa_family) ++ { ++ case AF_INET: ++ if (addrlen != sizeof(struct sockaddr_in)) ++ { ++ errno = EINVAL; ++ rv = -1; ++ goto done; ++ } ++ ep.is_ip4 = VPPCOM_IS_IP4; ++ ep.ip = (u8 *)&((const struct sockaddr_in *)addr)->sin_addr; ++ ep.port = (u16)((const struct sockaddr_in *)addr)->sin_port; ++ break; ++ case AF_INET6: ++ if (addrlen != sizeof(struct sockaddr_in6)) ++ { ++ errno = EINVAL; ++ rv = -1; ++ goto done; ++ } ++ ep.is_ip4 = VPPCOM_IS_IP6; ++ ep.ip = (u8 *)&((const struct sockaddr_in6 *)addr)->sin6_addr; ++ ep.port = (u16)((const struct sockaddr_in6 *)addr)->sin6_port; ++ break; ++ default: ++ errno = EAFNOSUPPORT; ++ rv = -1; ++ goto done; ++ } ++ ++ rv = vppcom_session_bind(offset_vfd_to_vfd(offset_vfd), &ep); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ goto done; ++ } ++ ++ nvm->master_worker_index = offset_vfd_to_vfd(offset_vfd) >> 24; ++ nvm->listen_session_index = offset_vfd_to_vfd(offset_vfd) & 0X00FFFFFF; ++ ++done: ++ return rv; ++} ++ ++int ngxvcl_listen(int offset_vfd, int backlog) ++{ ++ int rv; ++ ++ ASSERT((u32)(offset_vfd_to_vfd(offset_vfd) & 0X00FFFFFF) == nvm->listen_session_index); ++ ++ rv = vppcom_session_listen(offset_vfd_to_vfd(offset_vfd), backlog); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_accept4(int offset_vfd, struct sockaddr *addr, socklen_t *addrlen, ++ int flags) ++{ ++ int accepted_fd, rv; ++ vppcom_endpt_t ep; ++ u8 src_addr[sizeof(struct sockaddr_in6)]; ++ memset(&ep, 0, sizeof(ep)); ++ ep.ip = src_addr; ++ ++ accepted_fd = vppcom_session_accept(offset_vfd_to_vfd(offset_vfd), &ep, flags); ++ ++ if (accepted_fd < 0) ++ { ++ errno = -accepted_fd; ++ rv = -1; ++ } ++ else ++ { ++ rv = copy_ep_to_sockaddr(addr, addrlen, &ep); ++ ++ if (rv != VPPCOM_OK) ++ { ++ (void)vppcom_session_close(accepted_fd); ++ errno = -rv; ++ rv = -1; ++ } ++ else ++ { ++ rv = vfd_to_offset_vfd(accepted_fd); ++ } ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_accept(int offset_vfd, struct sockaddr *addr, socklen_t *addrlen) ++{ ++ return ngxvcl_accept4(offset_vfd, addr, addrlen, 0); ++} ++ ++int ngxvcl_connect(int offset_vfd, const struct sockaddr *addr, socklen_t addrlen) ++{ ++ int rv; ++ ++ if (!addr) ++ { ++ errno = EINVAL; ++ rv = -1; ++ goto done; ++ } ++ ++ vppcom_endpt_t ep; ++ ++ switch (addr->sa_family) ++ { ++ case AF_INET: ++ if (addrlen != sizeof(struct sockaddr_in)) ++ { ++ errno = EINVAL; ++ rv = -1; ++ goto done; ++ } ++ ep.is_ip4 = VPPCOM_IS_IP4; ++ ep.ip = (u8 *)&((const struct sockaddr_in *)addr)->sin_addr; ++ ep.port = (u16)((const struct sockaddr_in *)addr)->sin_port; ++ break; ++ case AF_INET6: ++ if (addrlen != sizeof(struct sockaddr_in6)) ++ { ++ errno = EINVAL; ++ rv = -1; ++ goto done; ++ } ++ ep.is_ip4 = VPPCOM_IS_IP6; ++ ep.ip = (u8 *)&((const struct sockaddr_in6 *)addr)->sin6_addr; ++ ep.port = (u16)((const struct sockaddr_in6 *)addr)->sin6_port; ++ break; ++ default: ++ errno = EAFNOSUPPORT; ++ rv = -1; ++ goto done; ++ } ++ ++ rv = vppcom_session_connect(offset_vfd_to_vfd(offset_vfd), &ep); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ ++done: ++ return rv; ++} ++ ++int ngxvcl_read(int offset_vfd, void *buf, size_t count) ++{ ++ ssize_t size; ++ ++ size = vppcom_session_read(offset_vfd_to_vfd(offset_vfd), buf, count); ++ ++ if (size < 0) ++ { ++ errno = -size; ++ size = -1; ++ } ++ ++ return size; ++} ++ ++int ngxvcl_write(int offset_vfd, const void *buf, size_t count) ++{ ++ ssize_t size = 0; ++ ++ size = vppcom_session_write_msg(offset_vfd_to_vfd(offset_vfd), (void *)buf, count); ++ ++ if (size < 0) ++ { ++ errno = -size; ++ size = -1; ++ } ++ ++ return size; ++} ++ ++int ngxvcl_epoll_create(int size) ++{ ++ int rv, vepfd; ++ ++ rv = vppcom_epoll_create(); ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ return -1; ++ } ++ else ++ vepfd = rv; ++ ++ if (use_mq_eventfd) { ++ int libc_epfd; ++ u32 size = sizeof (u32); ++ struct epoll_event e = { 0 }; ++ ++ libc_epfd = epoll_create1 (EPOLL_CLOEXEC); ++ if (libc_epfd < 0) ++ return libc_epfd; ++ rv = vppcom_session_attr (vepfd, VPPCOM_ATTR_SET_LIBC_EPFD, &libc_epfd, &size); ++ if (rv < 0) ++ { ++ errno = -rv; ++ return -1; ++ } ++ e.events = EPOLLIN; ++ if (epoll_ctl (libc_epfd, EPOLL_CTL_ADD, vcl_worker_get_current ()->app_event_queue->q->consumer_evtfd, &e) < 0) ++ return -1; ++ epoll_fd_for_evtfd = libc_epfd; ++ } ++ ++ return vfd_to_offset_vfd (vepfd); ++} ++ ++int ngxvcl_kvfd_epoll_ctl(int offset_vepfd, int op, int fd, struct epoll_event *event) ++{ ++ int rv, vepfd = offset_vfd_to_vfd(offset_vepfd); ++ ++ if (is_offset_vfd(fd)) { ++ rv = vppcom_epoll_ctl(vepfd, op, offset_vfd_to_vfd(fd), ++ event); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ } ++ else { ++ int libc_epfd; ++ u32 size = sizeof (vepfd); ++ ++ libc_epfd = vppcom_session_attr (vepfd, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); ++ if (!libc_epfd) { ++ libc_epfd = epoll_create1 (EPOLL_CLOEXEC); ++ if (libc_epfd < 0) ++ { ++ rv = libc_epfd; ++ return rv; ++ } ++ rv = vppcom_session_attr (vepfd, VPPCOM_ATTR_SET_LIBC_EPFD, &libc_epfd, &size); ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ return rv; ++ } ++ } ++ else if (libc_epfd < 0) { ++ errno = -vepfd; ++ rv = -1; ++ return rv; ++ } ++ ++ rv = epoll_ctl (libc_epfd, op, fd, event); ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_kvfd_epoll_wait(int offset_vepfd, struct epoll_event *events, int maxevents, ++ int timeout) ++{ ++ int rv = 0, vepfd = offset_vfd_to_vfd (offset_vepfd); ++ ++ if (use_mq_eventfd) { ++ int i, n_evts = 0, veprv; ++ struct epoll_event temp_evts[2]; ++ ++again: ++ rv = epoll_wait (epoll_fd_for_evtfd, temp_evts, 2, timeout); ++ ++ if (PREDICT_TRUE (rv > 0)) ++ for (i = 0; i < rv; i++) { ++ if (PREDICT_FALSE (n_evts == maxevents)) ++ return n_evts; ++ if (PREDICT_TRUE (temp_evts[i].data.u32 == 0)) { ++ veprv = vppcom_epoll_wait(vepfd, events + n_evts, maxevents - n_evts, 0); ++ if (PREDICT_FALSE (veprv < 0)) { ++ errno = -veprv; ++ return -1; ++ } ++ n_evts += veprv; ++ } ++ else { ++ events[n_evts] = temp_evts[i]; ++ n_evts += 1; ++ } ++ } ++ ++ if (PREDICT_FALSE (!n_evts && rv > 0)) ++ goto again; ++ ++ return n_evts; ++ } ++ ++ if (nvm->wait_vep_only) ++ { ++ rv = vppcom_epoll_wait(vepfd, events, maxevents, timeout); ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ ++ return rv; ++ } ++ else ++ { ++ double time_to_wait = (double) 0, max_time; ++ int libc_epfd; ++ clib_time_t clib_time = {}; ++ ++ if (clib_time.init_cpu_time == 0) ++ clib_time_init (&clib_time); ++ time_to_wait = ((timeout >= 0) ? (double) timeout / 1000 : 0); ++ max_time = clib_time_now (&clib_time) + time_to_wait; ++ ++ libc_epfd = vppcom_session_attr (vepfd, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); ++ if (libc_epfd < 0) ++ { ++ errno = -libc_epfd; ++ rv = -1; ++ return rv; ++ } ++ ++ do { ++ if (nvm->wait_vep_only) { ++ int time_remained = 0; ++ if (timeout > 0) { ++ time_remained = (int)(1000 * (max_time - clib_time_now (&clib_time))); ++ } ++ else ++ time_remained = timeout; ++ rv = vppcom_epoll_wait(vepfd, events, maxevents, time_remained); ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ return rv; ++ } ++ ++ if (!wait_kep_next) ++ { ++ rv = vppcom_epoll_wait(vepfd, events, maxevents, 0); ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ return rv; ++ } ++ else if (rv > 0) ++ { ++ wait_kep_next = 1; ++ return rv; ++ } ++ } ++ else ++ wait_kep_next = 0; ++ ++ if (libc_epfd > 0) { ++ rv = epoll_wait(libc_epfd, events, maxevents, 0); ++ if (rv != 0) ++ return rv; ++ } ++ } while ((timeout == -1) || (clib_time_now (&clib_time) < max_time)); ++ ++ return rv; ++ } ++} ++ ++ssize_t ngxvcl_readv(int offset_vfd, const struct iovec *iov, int iovcnt) ++{ ++ int rv = 0, i, total = 0; ++ ssize_t size = 0; ++ ++ do ++ { ++ for (i = 0; i < iovcnt; ++i) ++ { ++ rv = vppcom_session_read(offset_vfd_to_vfd(offset_vfd), iov[i].iov_base, ++ iov[i].iov_len); ++ if (rv < 0) ++ break; ++ else ++ { ++ total += rv; ++ if ((size_t)rv < iov[i].iov_len) ++ break; ++ } ++ } ++ } while ((rv >= 0) && (total == 0)); ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ size = -1; ++ } ++ else ++ size = total; ++ ++ return size; ++} ++ ++ssize_t ngxvcl_writev(int offset_vfd, const struct iovec *iov, int iovcnt) ++{ ++ ssize_t size = 0, total = 0; ++ int i, rv = 0; ++ ++ do ++ { ++ for (i = 0; i < iovcnt; ++i) ++ { ++ rv = vppcom_session_write_msg(offset_vfd_to_vfd(offset_vfd), ++ iov[i].iov_base, iov[i].iov_len); ++ if (rv < 0) ++ break; ++ else ++ { ++ total += rv; ++ if ((size_t)rv < iov[i].iov_len) ++ break; ++ } ++ } ++ } while ((rv >= 0) && (total == 0)); ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ size = -1; ++ } ++ else ++ size = total; ++ ++ return size; ++} ++ ++int ngxvcl_kvfd_fcntl(int fd, int cmd, ...) ++{ ++ int rv = 0; ++ va_list ap; ++ ++ va_start(ap, cmd); ++ ++ if (is_offset_vfd(fd)) ++ { ++ int flags = va_arg(ap, int), vfd = offset_vfd_to_vfd(fd); ++ u32 size; ++ ++ size = sizeof(flags); ++ rv = -EOPNOTSUPP; ++ ++ switch (cmd) ++ { ++ case F_SETFL: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_FLAGS, &flags, &size); ++ break; ++ case F_GETFL: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_FLAGS, &flags, &size); ++ if (rv == VPPCOM_OK) ++ rv = flags; ++ break; ++ case F_SETFD: ++ /* TODO handle this */ ++ rv = 0; ++ break; ++ default: ++ rv = -EOPNOTSUPP; ++ break; ++ } ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ } ++ else ++ { ++ long int args[4]; ++ ++ for (int i = 0; i < 4; i++) ++ args[i] = va_arg(ap, long int); ++ ++ rv = fcntl(fd, cmd, args[0], args[1], args[2], args[3]); ++ } ++ ++ va_end(ap); ++ ++ return rv; ++} ++ ++int ngxvcl_kvfd_ioctl(int fd, unsigned long int cmd, ...) ++{ ++ va_list ap; ++ int rv; ++ ++ va_start(ap, cmd); ++ ++ if (is_offset_vfd(fd)) ++ { ++ int vfd = offset_vfd_to_vfd(fd); ++ ++ switch (cmd) ++ { ++ case FIONREAD: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_NREAD, 0, 0); ++ break; ++ ++ case FIONBIO: ++ { ++ u32 flags = va_arg(ap, int) ? O_NONBLOCK : 0; ++ u32 size = sizeof(flags); ++ ++ /* TBD: When VPPCOM_ATTR_[GS]ET_FLAGS supports flags other than ++ * non-blocking, the flags should be read here and merged ++ * with O_NONBLOCK. ++ */ ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_FLAGS, &flags, &size); ++ } ++ break; ++ ++ default: ++ rv = -EOPNOTSUPP; ++ break; ++ } ++ ++ if (rv < 0) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ } ++ else ++ { ++ long int args[4]; ++ ++ for (int i = 0; i < 4; i++) ++ args[i] = va_arg(ap, long int); ++ ++ rv = ioctl(fd, cmd, args[0], args[1], args[2], args[3]); ++ } ++ ++ va_end(ap); ++ ++ return rv; ++} ++ ++int ngxvcl_socketpair(int domain, int type, int protocol, int fds[2]) ++{ ++ int rv, sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); ++ ++ if (((domain == AF_INET) || (domain == AF_INET6)) && ++ ((sock_type == SOCK_STREAM) || (sock_type == SOCK_DGRAM))) ++ { ++ errno = ENOSYS; ++ rv = -1; ++ } ++ else ++ { ++ rv = socketpair(domain, type, protocol, fds); ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_kvfd_getsockname(int fd, struct sockaddr *addr, socklen_t *len) ++{ ++ int rv; ++ ++ if (is_offset_vfd(fd)) ++ { ++ vppcom_endpt_t ep; ++ u8 addr_buf[sizeof(struct in6_addr)]; ++ u32 size = sizeof(ep); ++ ++ ep.ip = addr_buf; ++ ++ rv = vppcom_session_attr(offset_vfd_to_vfd(fd), ++ VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ else ++ { ++ rv = copy_ep_to_sockaddr(addr, len, &ep); ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ } ++ } ++ else ++ { ++ rv = getsockname(fd, addr, len); ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_kvfd_getsockopt(int fd, int level, int optname, void *optval, ++ socklen_t *optlen) ++{ ++ int rv; ++ ++ if (is_offset_vfd(fd)) ++ { ++ int vfd = offset_vfd_to_vfd(fd); ++ ++ rv = -EOPNOTSUPP; ++ ++ switch (level) ++ { ++ case SOL_TCP: ++ switch (optname) ++ { ++ case TCP_NODELAY: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_TCP_NODELAY, ++ optval, optlen); ++ break; ++ case TCP_MAXSEG: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_TCP_USER_MSS, ++ optval, optlen); ++ break; ++ case TCP_KEEPIDLE: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_TCP_KEEPIDLE, ++ optval, optlen); ++ break; ++ case TCP_KEEPINTVL: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_TCP_KEEPINTVL, ++ optval, optlen); ++ break; ++ case TCP_INFO: ++ if (optval && optlen && (*optlen == sizeof(struct tcp_info))) ++ { ++ memset(optval, 0, *optlen); ++ rv = VPPCOM_OK; ++ } ++ else ++ rv = -EFAULT; ++ break; ++ case TCP_CONGESTION: ++ strcpy(optval, "cubic"); ++ *optlen = strlen("cubic"); ++ rv = 0; ++ break; ++ default: ++ break; ++ } ++ break; ++ case SOL_IPV6: ++ switch (optname) ++ { ++ case IPV6_V6ONLY: ++ rv = ++ vppcom_session_attr(vfd, VPPCOM_ATTR_GET_V6ONLY, ++ optval, optlen); ++ break; ++ default: ++ break; ++ } ++ break; ++ case SOL_SOCKET: ++ switch (optname) ++ { ++ case SO_ACCEPTCONN: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_LISTEN, ++ optval, optlen); ++ break; ++ case SO_KEEPALIVE: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_KEEPALIVE, ++ optval, optlen); ++ break; ++ case SO_PROTOCOL: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_PROTOCOL, ++ optval, optlen); ++ *(int *)optval = *(int *)optval ? SOCK_DGRAM : SOCK_STREAM; ++ break; ++ case SO_SNDBUF: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_TX_FIFO_LEN, ++ optval, optlen); ++ break; ++ case SO_RCVBUF: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_RX_FIFO_LEN, ++ optval, optlen); ++ break; ++ case SO_REUSEADDR: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_REUSEADDR, ++ optval, optlen); ++ break; ++ case SO_BROADCAST: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_BROADCAST, ++ optval, optlen); ++ break; ++ case SO_ERROR: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_GET_ERROR, ++ optval, optlen); ++ break; ++ default: ++ break; ++ } ++ break; ++ default: ++ break; ++ } ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ } ++ else ++ { ++ rv = getsockopt(fd, level, optname, optval, optlen); ++ } ++ ++ return rv; ++} ++ ++int ngxvcl_kvfd_setsockopt(int fd, int level, int optname, const void *optval, ++ socklen_t optlen) ++{ ++ int rv; ++ ++ if (is_offset_vfd(fd)) ++ { ++ int vfd = offset_vfd_to_vfd(fd); ++ ++ rv = -EOPNOTSUPP; ++ ++ switch (level) ++ { ++ case SOL_TCP: ++ switch (optname) ++ { ++ case TCP_NODELAY: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_TCP_NODELAY, ++ (void *)optval, &optlen); ++ break; ++ case TCP_MAXSEG: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_TCP_USER_MSS, ++ (void *)optval, &optlen); ++ break; ++ case TCP_KEEPIDLE: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_TCP_KEEPIDLE, ++ (void *)optval, &optlen); ++ break; ++ case TCP_KEEPINTVL: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_TCP_KEEPINTVL, ++ (void *)optval, &optlen); ++ break; ++ case TCP_CONGESTION: ++ case TCP_CORK: ++ /* Ignore */ ++ rv = 0; ++ break; ++ default: ++ break; ++ } ++ break; ++ case SOL_IPV6: ++ switch (optname) ++ { ++ case IPV6_V6ONLY: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_V6ONLY, ++ (void *)optval, &optlen); ++ break; ++ default: ++ break; ++ } ++ break; ++ case SOL_SOCKET: ++ switch (optname) ++ { ++ case SO_KEEPALIVE: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_KEEPALIVE, ++ (void *)optval, &optlen); ++ break; ++ case SO_REUSEADDR: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_REUSEADDR, ++ (void *)optval, &optlen); ++ break; ++ case SO_BROADCAST: ++ rv = vppcom_session_attr(vfd, VPPCOM_ATTR_SET_BROADCAST, ++ (void *)optval, &optlen); ++ break; ++ default: ++ break; ++ } ++ break; ++ default: ++ break; ++ } ++ ++ if (rv != VPPCOM_OK) ++ { ++ errno = -rv; ++ rv = -1; ++ } ++ } ++ else ++ { ++ rv = setsockopt(fd, level, optname, optval, optlen); ++ } ++ ++ return rv; ++} ++ ++ssize_t ngxvcl_send(int offset_vfd, const void *buf, size_t n, int flags) ++{ ++ ssize_t size; ++ ++ size = vppcom_session_sendto(offset_vfd_to_vfd(offset_vfd), (void *)buf, ++ n, flags, NULL); ++ ++ if (size < VPPCOM_OK) ++ { ++ errno = -size; ++ size = -1; ++ } ++ ++ return size; ++} ++ ++ssize_t ngxvcl_sendfile(int out_offset_vfd, int in_kfd, off_t *offset, size_t len) ++{ ++ ssize_t size = 0; ++ int rv, out_vfd = offset_vfd_to_vfd(out_offset_vfd); ++ ssize_t results = 0; ++ size_t n_bytes_left = len; ++ size_t bytes_to_read; ++ int nbytes; ++ u8 eagain = 0; ++ u32 flags, flags_len = sizeof(flags); ++ ++ rv = vppcom_session_attr(out_vfd, VPPCOM_ATTR_GET_FLAGS, &flags, ++ &flags_len); ++ ++ if (rv != VPPCOM_OK) ++ { ++ vec_reset_length (sendfile_io_buffer); ++ errno = -rv; ++ size = -1; ++ goto done; ++ } ++ ++ if (offset) ++ { ++ off_t off = lseek(in_kfd, *offset, SEEK_SET); ++ ++ if (off == -1) ++ { ++ size = -1; ++ goto done; ++ } ++ } ++ ++ do ++ { ++ size = vppcom_session_attr(out_vfd, VPPCOM_ATTR_GET_NWRITE, 0, 0); ++ ++ if (size < 0) ++ { ++ vec_reset_length (sendfile_io_buffer); ++ errno = -size; ++ size = -1; ++ goto done; ++ } ++ ++ bytes_to_read = size; ++ ++ if (bytes_to_read == 0) ++ { ++ if (flags & O_NONBLOCK) ++ { ++ if (!results) ++ eagain = 1; ++ goto update_offset; ++ } ++ else ++ continue; ++ } ++ ++ bytes_to_read = clib_min (n_bytes_left, bytes_to_read); ++ vec_validate (sendfile_io_buffer, bytes_to_read); ++ nbytes = read (in_kfd, sendfile_io_buffer, bytes_to_read); ++ ++ if (nbytes < 0) ++ { ++ if (results == 0) ++ { ++ vec_reset_length (sendfile_io_buffer); ++ size = -1; ++ goto done; ++ } ++ goto update_offset; ++ } ++ ++ size = vppcom_session_write(out_vfd, sendfile_io_buffer, nbytes); ++ ++ if (size < 0) ++ { ++ if (size == VPPCOM_EAGAIN) ++ { ++ if (flags & O_NONBLOCK) ++ { ++ if (!results) ++ eagain = 1; ++ goto update_offset; ++ } ++ else ++ continue; ++ } ++ if (results == 0) ++ { ++ vec_reset_length (sendfile_io_buffer); ++ errno = -size; ++ size = -1; ++ goto done; ++ } ++ goto update_offset; ++ } ++ ++ results += nbytes; ++ n_bytes_left = n_bytes_left - nbytes; ++ } while (n_bytes_left > 0); ++ ++update_offset: ++ vec_reset_length (sendfile_io_buffer); ++ if (offset) ++ { ++ off_t off = lseek(in_kfd, *offset, SEEK_SET); ++ ++ if (off == -1) ++ { ++ size = -1; ++ goto done; ++ } ++ ++ *offset += results + 1; ++ } ++ if (eagain) ++ { ++ errno = EAGAIN; ++ size = -1; ++ } ++ else ++ size = results; ++ ++done: ++ return size; ++} ++ ++ssize_t ngxvcl_recv(int offset_vfd, void *buf, size_t n, int flags) ++{ ++ ssize_t size; ++ ++ size = vppcom_session_recvfrom(offset_vfd_to_vfd(offset_vfd), buf, n, flags, NULL); ++ ++ if (size < 0) ++ errno = -size; ++ ++ return size; ++} ++ ++ssize_t ngxvcl_sendto(int offset_vfd, const void *buf, size_t n, int flags, ++ const struct sockaddr *addr, socklen_t addr_len) ++{ ++ ssize_t size; ++ ++ vppcom_endpt_t *ep = 0; ++ vppcom_endpt_t _ep; ++ ++ if (addr) ++ { ++ ep = &_ep; ++ switch (addr->sa_family) ++ { ++ case AF_INET: ++ ep->is_ip4 = VPPCOM_IS_IP4; ++ ep->ip = (uint8_t *)&((const struct sockaddr_in *)addr)->sin_addr; ++ ep->port = (uint16_t)((const struct sockaddr_in *)addr)->sin_port; ++ break; ++ case AF_INET6: ++ ep->is_ip4 = VPPCOM_IS_IP6; ++ ep->ip = (uint8_t *)&((const struct sockaddr_in6 *)addr)->sin6_addr; ++ ep->port = (uint16_t)((const struct sockaddr_in6 *)addr)->sin6_port; ++ break; ++ default: ++ errno = EAFNOSUPPORT; ++ size = -1; ++ goto done; ++ } ++ } ++ ++ size = vppcom_session_sendto(offset_vfd_to_vfd(offset_vfd), (void *)buf, n, flags, ep); ++ ++ if (size < 0) ++ { ++ errno = -size; ++ size = -1; ++ } ++ ++done: ++ return size; ++} ++ ++ssize_t ngxvcl_recvfrom(int offset_vfd, void *buf, size_t n, int flags, ++ struct sockaddr *addr, socklen_t *addr_len) ++{ ++ int vfd = offset_vfd_to_vfd(offset_vfd); ++ ssize_t size, rv; ++ ++ vppcom_endpt_t ep; ++ u8 src_addr[sizeof(struct sockaddr_in6)]; ++ ++ if (addr) ++ { ++ ep.ip = src_addr; ++ size = vppcom_session_recvfrom(vfd, buf, n, flags, &ep); ++ ++ if (size > 0) ++ { ++ rv = copy_ep_to_sockaddr(addr, addr_len, &ep); ++ ++ if (rv < 0) ++ size = rv; ++ } ++ } ++ else ++ size = vppcom_session_recvfrom(vfd, buf, n, flags, NULL); ++ ++ if (size < 0) ++ { ++ errno = -size; ++ size = -1; ++ } ++ ++ return size; ++} ++ ++ssize_t ngxvcl_sendmsg(int offset_vfd, const struct msghdr *message, int flags) ++{ ++ ssize_t size; ++ ++ errno = ENOSYS; ++ size = -1; ++ ++ return size; ++} ++ ++ssize_t ngxvcl_recvmsg(int offset_vfd, struct msghdr *message, int flags) ++{ ++ ssize_t size; ++ ++ errno = ENOSYS; ++ size = -1; ++ ++ return size; ++} ++ ++int ngxvcl_shutdown(int offset_vfd, int how) ++{ ++ int rv = 0, flags, vfd = offset_vfd_to_vfd(offset_vfd); ++ u32 flags_len = sizeof(flags); ++ ++ if (vppcom_session_attr(vfd, VPPCOM_ATTR_SET_SHUT, &how, &flags_len)) ++ { ++ vppcom_session_close(vfd); ++ return -1; ++ } ++ ++ if (vppcom_session_attr(vfd, VPPCOM_ATTR_GET_SHUT, &flags, &flags_len)) ++ { ++ vppcom_session_close(vfd); ++ return -1; ++ } ++ ++ if (flags == SHUT_RDWR) ++ rv = vppcom_session_close(vfd); ++ ++ return rv; ++} +diff --git a/src/vcl/ngxvcl.h b/src/vcl/ngxvcl.h +new file mode 100644 +index 000000000..60b5116a8 +--- /dev/null ++++ b/src/vcl/ngxvcl.h +@@ -0,0 +1,70 @@ ++#ifndef _NGXVCL_H_ ++#define _NGXVCL_H_ ++ ++#define _GNU_SOURCE ++#include <arpa/inet.h> ++#include <fcntl.h> ++#include <netinet/tcp.h> ++#include <stdarg.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <sys/errno.h> ++#include <sys/ioctl.h> ++#include <sys/sendfile.h> ++#include <sys/socket.h> ++#include <sys/uio.h> ++#include <unistd.h> ++#include <vcl/vppcom.h> ++ ++void ngxvcl_wait_vep_only(); ++void ngxvcl_wait_kep_and_vep(); ++ ++void ngxvcl_app_create(char *app_name); ++void ngxvcl_app_destroy(void); ++ ++int ngxvcl_socket(int domain, int type, int protocol); ++int ngxvcl_close(int offset_vfd); ++int ngxvcl_kvfd_close(int fd); ++int ngxvcl_bind(int offset_vfd, const struct sockaddr *addr, socklen_t addrlen); ++int ngxvcl_listen(int offset_vfd, int backlog); ++ ++int ngxvcl_accept4(int offset_vfd, struct sockaddr *addr, socklen_t *addrlen, ++ int flags); ++int ngxvcl_accept(int offset_vfd, struct sockaddr *addr, socklen_t *addrlen); ++ ++int ngxvcl_connect(int offset_vfd, const struct sockaddr *addr, socklen_t addrlen); ++int ngxvcl_read(int offset_vfd, void *buf, size_t count); ++int ngxvcl_write(int offset_vfd, const void *buf, size_t count); ++ ++int ngxvcl_epoll_create(int size); ++int ngxvcl_kvfd_epoll_ctl(int offset_vepfd, int op, int fd, struct epoll_event *event); ++int ngxvcl_kvfd_epoll_wait(int offset_vepfd, struct epoll_event *events, int maxevents, ++ int timeout); ++ ++ssize_t ngxvcl_readv(int offset_vfd, const struct iovec *iov, int iovcnt); ++ssize_t ngxvcl_writev(int offset_vfd, const struct iovec *iov, int iovcnt); ++ ++int ngxvcl_kvfd_fcntl(int fd, int cmd, ...); ++int ngxvcl_kvfd_ioctl(int fd, unsigned long int cmd, ...); ++ ++int ngxvcl_socketpair(int domain, int type, int protocol, int fds[2]); ++int ngxvcl_kvfd_getsockname(int fd, struct sockaddr *addr, socklen_t *len); ++int ngxvcl_kvfd_getsockopt(int fd, int level, int optname, void *optval, ++ socklen_t *optlen); ++int ngxvcl_kvfd_setsockopt(int fd, int level, int optname, const void *optval, ++ socklen_t optlen); ++ ++ssize_t ngxvcl_send(int fd, const void *buf, size_t n, int flags); ++ssize_t ngxvcl_sendfile(int out_offset_vfd, int in_kfd, off_t *offset, size_t len); ++ssize_t ngxvcl_recv(int offset_vfd, void *buf, size_t n, int flags); ++ssize_t ngxvcl_sendto(int offset_vfd, const void *buf, size_t n, int flags, ++ const struct sockaddr *addr, socklen_t addr_len); ++ssize_t ngxvcl_recvfrom(int offset_vfd, void *buf, size_t n, int flags, ++ struct sockaddr *addr, socklen_t *addr_len); ++ssize_t ngxvcl_sendmsg(int offset_vfd, const struct msghdr *message, int flags); ++ssize_t ngxvcl_recvmsg(int offset_vfd, struct msghdr *message, int flags); ++ ++int ngxvcl_shutdown(int offset_vfd, int how); ++ ++#endif +-- +2.17.1 + |