X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvcl%2Fldp.c;h=b72c0c54acd4d64afffaf1c0b6af7f929fbb1116;hb=a5a9efd4d;hp=a61acb9a6abdf6b7c9c9960960cb48ac488db32b;hpb=30e79c2e388a98160a3660f4f03103890c9b1b7c;p=vpp.git diff --git a/src/vcl/ldp.c b/src/vcl/ldp.c index a61acb9a6ab..b72c0c54acd 100644 --- a/src/vcl/ldp.c +++ b/src/vcl/ldp.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Cisco and/or its affiliates. + * Copyright (c) 2016-2019 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: @@ -26,7 +26,7 @@ #include #include -#include +#include #include #include #include @@ -51,19 +51,6 @@ #define LDP_MAX_NWORKERS 32 -#define LDP_F_SHUT_RD (1 << 0) -#define LDP_F_SHUT_WR (1 << 1) - -typedef struct ldp_fd_entry_ -{ - u32 session_index; - u32 worker_index; - u32 fd; - u32 fd_index; - u32 flags; - clib_spinlock_t lock; -} ldp_fd_entry_t; - typedef struct ldp_worker_ctx_ { u8 *io_buffer; @@ -75,13 +62,12 @@ typedef struct ldp_worker_ctx_ clib_bitmap_t *rd_bitmap; clib_bitmap_t *wr_bitmap; clib_bitmap_t *ex_bitmap; - clib_bitmap_t *sid_rd_bitmap; - clib_bitmap_t *sid_wr_bitmap; - clib_bitmap_t *sid_ex_bitmap; + clib_bitmap_t *si_rd_bitmap; + clib_bitmap_t *si_wr_bitmap; + clib_bitmap_t *si_ex_bitmap; clib_bitmap_t *libc_rd_bitmap; clib_bitmap_t *libc_wr_bitmap; clib_bitmap_t *libc_ex_bitmap; - u8 select_vcl; /* * Poll state @@ -94,36 +80,53 @@ typedef struct ldp_worker_ctx_ * Epoll state */ u8 epoll_wait_vcl; + u8 mq_epfd_added; int vcl_mq_epfd; } ldp_worker_ctx_t; +/* clib_bitmap_t, fd_mask and vcl_si_set are used interchangeably. Make sure + * they are the same size */ +STATIC_ASSERT (sizeof (clib_bitmap_t) == sizeof (fd_mask), + "ldp bitmap size mismatch"); +STATIC_ASSERT (sizeof (vcl_si_set) == sizeof (fd_mask), + "ldp bitmap size mismatch"); + typedef struct { ldp_worker_ctx_t *workers; int init; char app_name[LDP_APP_NAME_MAX]; - u32 sh_bit_val; - u32 sid_bit_mask; + u32 vlsh_bit_val; + u32 vlsh_bit_mask; u32 debug; - ldp_fd_entry_t *fd_pool; - clib_rwlock_t fd_table_lock; - uword *session_index_to_fd_table; /** vcl needs next epoll_create to go to libc_epoll */ u8 vcl_needs_real_epoll; + + /** + * crypto state used only for testing + */ + u8 transparent_tls; + u32 ckpair_index; } ldp_main_t; #define LDP_DEBUG ldp->debug #define LDBG(_lvl, _fmt, _args...) \ if (ldp->debug > _lvl) \ - clib_warning ("ldp<%d>: " _fmt, getpid(), ##_args) + { \ + int errno_saved = errno; \ + fprintf (stderr, "ldp<%d>: " _fmt "\n", getpid(), ##_args); \ + errno = errno_saved; \ + } static ldp_main_t ldp_main = { - .sh_bit_val = (1 << LDP_SID_BIT_MIN), - .sid_bit_mask = (1 << LDP_SID_BIT_MIN) - 1, + .vlsh_bit_val = (1 << LDP_SID_BIT_MIN), + .vlsh_bit_mask = (1 << LDP_SID_BIT_MIN) - 1, .debug = LDP_DEBUG_INIT, + .transparent_tls = 0, + .ckpair_index = ~0, }; static ldp_main_t *ldp = &ldp_main; @@ -140,11 +143,8 @@ ldp_worker_get_current (void) static inline void ldp_set_app_name (char *app_name) { - int rv = snprintf (ldp->app_name, LDP_APP_NAME_MAX, - "ldp-%d-%s", getpid (), app_name); - - if (rv >= LDP_APP_NAME_MAX) - app_name[LDP_APP_NAME_MAX - 1] = 0; + snprintf (ldp->app_name, LDP_APP_NAME_MAX, + "ldp-%d-%s", getpid (), app_name); } static inline char * @@ -156,138 +156,27 @@ ldp_get_app_name () return ldp->app_name; } -static inline vcl_session_handle_t -ldp_fd_entry_sh (ldp_fd_entry_t * fde) -{ - return vppcom_session_handle (fde->session_index); -} - -static int -ldp_fd_alloc (vcl_session_handle_t sh) -{ - ldp_fd_entry_t *fde; - - clib_rwlock_writer_lock (&ldp->fd_table_lock); - if (pool_elts (ldp->fd_pool) >= (1ULL << 32) - ldp->sh_bit_val) - { - clib_rwlock_writer_unlock (&ldp->fd_table_lock); - return -1; - } - pool_get (ldp->fd_pool, fde); - fde->session_index = vppcom_session_index (sh); - fde->worker_index = vppcom_session_worker (sh); - fde->fd_index = fde - ldp->fd_pool; - fde->fd = fde->fd_index + ldp->sh_bit_val; - hash_set (ldp->session_index_to_fd_table, fde->session_index, fde->fd); - clib_spinlock_init (&fde->lock); - clib_rwlock_writer_unlock (&ldp->fd_table_lock); - return fde->fd; -} - -static ldp_fd_entry_t * -ldp_fd_entry_get (u32 fd_index) -{ - if (pool_is_free_index (ldp->fd_pool, fd_index)) - return 0; - return pool_elt_at_index (ldp->fd_pool, fd_index); -} - -static ldp_fd_entry_t * -ldp_fd_entry_lock (u32 fd_index) -{ - ldp_fd_entry_t *fe; - clib_rwlock_reader_lock (&ldp->fd_table_lock); - if (pool_is_free_index (ldp->fd_pool, fd_index)) - { - clib_rwlock_reader_unlock (&ldp->fd_table_lock); - return 0; - } - - fe = pool_elt_at_index (ldp->fd_pool, fd_index); - clib_spinlock_lock (&fe->lock); - return fe; -} - -static void -ldp_fd_entry_unlock (ldp_fd_entry_t * fde) -{ - clib_spinlock_unlock (&fde->lock); - clib_rwlock_reader_unlock (&ldp->fd_table_lock); -} - static inline int -ldp_fd_from_sh (vcl_session_handle_t sh) +ldp_vlsh_to_fd (vls_handle_t vlsh) { - uword *fdp; - int fd; - - clib_rwlock_reader_lock (&ldp->fd_table_lock); - fdp = hash_get (ldp->session_index_to_fd_table, vppcom_session_index (sh)); - fd = fdp ? *fdp : -EMFILE; - clib_rwlock_reader_unlock (&ldp->fd_table_lock); - - return fd; + return (vlsh + ldp->vlsh_bit_val); } -static inline int -ldp_fd_is_sh (int fd) +static inline vls_handle_t +ldp_fd_to_vlsh (int fd) { - return fd >= ldp->sh_bit_val; -} + if (fd < ldp->vlsh_bit_val) + return VLS_INVALID_HANDLE; -static inline u32 -ldp_sh_from_fd (int fd) -{ - u32 fd_index, session_index; - ldp_fd_entry_t *fde; - - if (!ldp_fd_is_sh (fd)) - return INVALID_SESSION_ID; - - fd_index = fd - ldp->sh_bit_val; - fde = ldp_fd_entry_lock (fd_index); - if (!fde) - { - LDBG (0, "unknown fd %d", fd); - return INVALID_SESSION_ID; - } - session_index = fde->session_index; - ldp_fd_entry_unlock (fde); - - return vppcom_session_handle (session_index); -} - -static ldp_fd_entry_t * -ldp_fd_entry_lock_w_fd (int fd) -{ - u32 fd_index; - - if (!ldp_fd_is_sh (fd)) - return 0; - - fd_index = fd - ldp->sh_bit_val; - return ldp_fd_entry_lock (fd_index); + return (fd - ldp->vlsh_bit_val); } static void -ldp_fd_free_w_sh (vcl_session_handle_t sh) +ldp_alloc_workers (void) { - ldp_fd_entry_t *fde; - u32 fd_index; - int fd; - - fd = ldp_fd_from_sh (sh); - if (!fd) + if (ldp->workers) return; - - fd_index = fd - ldp->sh_bit_val; - clib_rwlock_writer_lock (&ldp->fd_table_lock); - fde = ldp_fd_entry_get (fd_index); - ASSERT (fde != 0); - hash_unset (ldp->session_index_to_fd_table, fde->session_index); - clib_spinlock_free (&fde->lock); - pool_put (ldp->fd_pool, fde); - clib_rwlock_writer_unlock (&ldp->fd_table_lock); + pool_alloc (ldp->workers, LDP_MAX_NWORKERS); } static inline int @@ -301,7 +190,7 @@ ldp_init (void) ldp->init = 1; ldp->vcl_needs_real_epoll = 1; - rv = vppcom_app_create (ldp_get_app_name ()); + rv = vls_app_create (ldp_get_app_name ()); if (rv != VPPCOM_OK) { ldp->vcl_needs_real_epoll = 0; @@ -313,7 +202,7 @@ ldp_init (void) return rv; } ldp->vcl_needs_real_epoll = 0; - pool_alloc (ldp->workers, LDP_MAX_NWORKERS); + ldp_alloc_workers (); ldpw = ldp_worker_get_current (); char *env_var_str = getenv (LDP_ENV_DEBUG); @@ -346,46 +235,61 @@ ldp_init (void) u32 sb; if (sscanf (env_var_str, "%u", &sb) != 1) { - clib_warning ("LDP<%d>: WARNING: Invalid LDP sid bit specified in" - " the env var " LDP_ENV_SID_BIT " (%s)! sid bit " - "value %d (0x%x)", getpid (), env_var_str, - ldp->sh_bit_val, ldp->sh_bit_val); + 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); } else if (sb < LDP_SID_BIT_MIN) { - ldp->sh_bit_val = (1 << LDP_SID_BIT_MIN); - ldp->sid_bit_mask = ldp->sh_bit_val - 1; + ldp->vlsh_bit_val = (1 << LDP_SID_BIT_MIN); + ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; - clib_warning ("LDP<%d>: 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)", - getpid (), sb, env_var_str, LDP_SID_BIT_MIN, - ldp->sh_bit_val, ldp->sh_bit_val); + 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); } else if (sb > LDP_SID_BIT_MAX) { - ldp->sh_bit_val = (1 << LDP_SID_BIT_MAX); - ldp->sid_bit_mask = ldp->sh_bit_val - 1; + ldp->vlsh_bit_val = (1 << LDP_SID_BIT_MAX); + ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; - clib_warning ("LDP<%d>: 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)", - getpid (), sb, env_var_str, LDP_SID_BIT_MAX, - ldp->sh_bit_val, ldp->sh_bit_val); + 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); } else { - ldp->sh_bit_val = (1 << sb); - ldp->sid_bit_mask = ldp->sh_bit_val - 1; + ldp->vlsh_bit_val = (1 << sb); + ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; LDBG (0, "configured LDP sid bit (%u) from " LDP_ENV_SID_BIT "! sid bit value %d (0x%x)", sb, - ldp->sh_bit_val, ldp->sh_bit_val); + ldp->vlsh_bit_val, ldp->vlsh_bit_val); } + + /* Make sure there are enough bits in the fd set for vcl sessions */ + if (ldp->vlsh_bit_val > FD_SETSIZE / 2) + { + LDBG (0, "ERROR: LDP vlsh bit value %d > FD_SETSIZE/2 %d!", + ldp->vlsh_bit_val, FD_SETSIZE / 2); + ldp->init = 0; + return -1; + } + } + env_var_str = getenv (LDP_ENV_TLS_TRANS); + if (env_var_str) + { + ldp->transparent_tls = 1; } - clib_time_init (&ldpw->clib_time); - clib_rwlock_init (&ldp->fd_table_lock); + /* *INDENT-OFF* */ + pool_foreach (ldpw, ldp->workers) { + clib_memset (&ldpw->clib_time, 0, sizeof (ldpw->clib_time)); + } + /* *INDENT-ON* */ + LDBG (0, "LDP initialization: done!"); return 0; @@ -394,22 +298,19 @@ ldp_init (void) int close (int fd) { - int rv, refcnt, epfd; - ldp_fd_entry_t *fde; - u32 sh; + vls_handle_t vlsh; + int rv, epfd; if ((errno = -ldp_init ())) return -1; - fde = ldp_fd_entry_lock_w_fd (fd); - if (fde) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - sh = ldp_fd_entry_sh (fde); - epfd = vppcom_session_attr (sh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + epfd = vls_attr (vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); if (epfd > 0) { - LDBG (0, "fd %d (0x%x): calling libc_close: epfd %u (0x%x)", - fd, fd, epfd, epfd); + LDBG (0, "fd %d: calling libc_close: epfd %u", fd, epfd); rv = libc_close (epfd); if (rv < 0) @@ -417,120 +318,88 @@ close (int fd) u32 size = sizeof (epfd); epfd = 0; - (void) vppcom_session_attr (sh, VPPCOM_ATTR_SET_LIBC_EPFD, - &epfd, &size); + (void) vls_attr (vlsh, VPPCOM_ATTR_SET_LIBC_EPFD, &epfd, &size); } } else if (PREDICT_FALSE (epfd < 0)) { errno = -epfd; rv = -1; - ldp_fd_entry_unlock (fde); goto done; } - LDBG (0, "fd %d (0x%x): calling vppcom_session_close: sid %u (0x%x)", - fd, fd, sh, sh); + LDBG (0, "fd %d: calling vls_close: vlsh %u", fd, vlsh); - refcnt = vppcom_session_attr (sh, VPPCOM_ATTR_GET_REFCNT, 0, 0); - rv = vppcom_session_close (sh); + rv = vls_close (vlsh); if (rv != VPPCOM_OK) { errno = -rv; rv = -1; } - - ldp_fd_entry_unlock (fde); - if (refcnt <= 1) - ldp_fd_free_w_sh (sh); } else { - LDBG (0, "fd %d (0x%x): calling libc_close", fd, fd); + LDBG (0, "fd %d: calling libc_close", fd); rv = libc_close (fd); } done: - - LDBG (1, "fd %d (0x%x): returning %d (0x%x)", fd, fd, rv, rv); return rv; } ssize_t read (int fd, void *buf, size_t nbytes) { - vcl_session_handle_t sh; - ldp_fd_entry_t *fde; + vls_handle_t vlsh; ssize_t size; if ((errno = -ldp_init ())) return -1; - fde = ldp_fd_entry_lock_w_fd (fd); - if (fde) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - sh = ldp_fd_entry_sh (fde); - LDBG (2, "fd %d (0x%x): calling vppcom_session_read(): sid %u (0x%x)," - " buf %p, nbytes %u", fd, fd, sh, sh, buf, nbytes); - - size = vppcom_session_read (sh, buf, nbytes); + size = vls_read (vlsh, buf, nbytes); if (size < 0) { errno = -size; size = -1; } - ldp_fd_entry_unlock (fde); } else { - LDBG (2, "fd %d (0x%x): calling libc_read(): buf %p, nbytes %u", - fd, fd, buf, nbytes); - size = libc_read (fd, buf, nbytes); } - LDBG (2, "fd %d (0x%x): returning %d (0x%x)", fd, fd, size, size); return size; } ssize_t readv (int fd, const struct iovec * iov, int iovcnt) { - ssize_t size = 0; - u32 sid = ldp_sh_from_fd (fd); int rv = 0, i, total = 0; + vls_handle_t vlsh; + ssize_t size = 0; if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - do + for (i = 0; i < iovcnt; ++i) { - for (i = 0; i < iovcnt; ++i) + rv = vls_read (vlsh, iov[i].iov_base, iov[i].iov_len); + if (rv <= 0) + break; + else { - LDBG (2, "fd %d (0x%x): calling vppcom_session_read() [%d]:" - " sid %u (0x%x), iov %p, iovcnt %d, total %d", fd, fd, i, - sid, sid, iov, iovcnt, total); - - rv = vppcom_session_read (sid, iov[i].iov_base, iov[i].iov_len); - if (rv < 0) + total += rv; + if (rv < iov[i].iov_len) break; - else - { - total += rv; - if (rv < iov[i].iov_len) - { - LDBG (2, "fd %d (0x%x): rv (%d) < iov[%d].iov_len (%d)", - fd, fd, rv, i, iov[i].iov_len); - break; - } - } } } - while ((rv >= 0) && (total == 0)); - - if (rv < 0) + if (rv < 0 && total == 0) { errno = -rv; size = -1; @@ -540,51 +409,36 @@ readv (int fd, const struct iovec * iov, int iovcnt) } else { - LDBG (2, "fd %d (0x%x): calling libc_readv(): iov %p, iovcnt %d", fd, - fd, iov, iovcnt); - size = libc_readv (fd, iov, iovcnt); } - - LDBG (2, "fd %d (0x%x): returning %d (0x%x)", fd, fd, size, size); return size; } ssize_t write (int fd, const void *buf, size_t nbytes) { - vcl_session_handle_t sh; - ldp_fd_entry_t *fde; + vls_handle_t vlsh; ssize_t size = 0; if ((errno = -ldp_init ())) return -1; - fde = ldp_fd_entry_lock_w_fd (fd); - if (fde) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - sh = ldp_fd_entry_sh (fde); - LDBG (2, "fd %d (0x%x): calling vppcom_session_write(): sid %u (0x%x), " - "buf %p, nbytes %u", fd, fd, sh, sh, buf, nbytes); - - size = vppcom_session_write_msg (sh, (void *) buf, nbytes); + size = vls_write_msg (vlsh, (void *) buf, nbytes); if (size < 0) { errno = -size; size = -1; } - ldp_fd_entry_unlock (fde); } else { - LDBG (2, "fd %d (0x%x): calling libc_write(): buf %p, nbytes %u", - fd, fd, buf, nbytes); - size = libc_write (fd, buf, nbytes); } - LDBG (2, "fd %d (0x%x): returning %d (0x%x)", fd, fd, size, size); return size; } @@ -592,37 +446,29 @@ ssize_t writev (int fd, const struct iovec * iov, int iovcnt) { ssize_t size = 0, total = 0; - u32 sid = ldp_sh_from_fd (fd); + vls_handle_t vlsh; int i, rv = 0; - /* - * Use [f]printf() instead of clib_warning() to prevent recursion SIGSEGV. - */ - if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - do + for (i = 0; i < iovcnt; ++i) { - for (i = 0; i < iovcnt; ++i) + rv = vls_write_msg (vlsh, iov[i].iov_base, iov[i].iov_len); + if (rv < 0) + break; + else { - rv = vppcom_session_write_msg (sid, iov[i].iov_base, - iov[i].iov_len); - if (rv < 0) + total += rv; + if (rv < iov[i].iov_len) break; - else - { - total += rv; - if (rv < iov[i].iov_len) - break; - } } } - while ((rv >= 0) && (total == 0)); - if (rv < 0) + if (rv < 0 && total == 0) { errno = -rv; size = -1; @@ -638,19 +484,15 @@ writev (int fd, const struct iovec * iov, int iovcnt) return size; } -int -fcntl (int fd, int cmd, ...) +static int +fcntl_internal (int fd, int cmd, va_list ap) { - const char *func_str = __func__; + vls_handle_t vlsh; int rv = 0; - va_list ap; - u32 sid = ldp_sh_from_fd (fd); - - if ((errno = -ldp_init ())) - return -1; - va_start (ap, cmd); - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + LDBG (0, "fd %u vlsh %d, cmd %u", fd, vlsh, cmd); + if (vlsh != VLS_INVALID_HANDLE) { int flags = va_arg (ap, int); u32 size; @@ -660,30 +502,13 @@ fcntl (int fd, int cmd, ...) switch (cmd) { case F_SETFL: - func_str = "vppcom_session_attr[SET_FLAGS]"; - LDBG (2, "fd %d (0x%x): calling %s(): sid %u (0x%x) " - "flags %d (0x%x), size %d", fd, fd, func_str, sid, - sid, flags, flags, size); - - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_FLAGS, &flags, - &size); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_FLAGS, &flags, &size); break; case F_GETFL: - func_str = "vppcom_session_attr[GET_FLAGS]"; - LDBG (2, "fd %d (0x%x): calling %s(): sid %u (0x%x), " - "flags %d (0x%x), size %d", fd, fd, func_str, sid, - sid, flags, flags, size); - - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_FLAGS, &flags, - &size); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_FLAGS, &flags, &size); if (rv == VPPCOM_OK) - { - LDBG (2, "fd %d (0x%x), cmd %d (F_GETFL): %s() " - "returned flags %d (0x%x)", fd, fd, cmd, - func_str, flags, flags); - rv = flags; - } + rv = flags; break; case F_SETFD: /* TODO handle this */ @@ -702,58 +527,66 @@ fcntl (int fd, int cmd, ...) } else { - func_str = "libc_vfcntl"; - - LDBG (2, "fd %d (0x%x): calling %s(): cmd %d", fd, fd, func_str, cmd); - +#ifdef HAVE_FCNTL64 + rv = libc_vfcntl64 (fd, cmd, ap); +#else rv = libc_vfcntl (fd, cmd, ap); +#endif } + return rv; +} + +int +fcntl (int fd, int cmd, ...) +{ + va_list ap; + int rv; + + if ((errno = -ldp_init ())) + return -1; + + va_start (ap, cmd); + rv = fcntl_internal (fd, cmd, ap); va_end (ap); - if (LDP_DEBUG > 2) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } return rv; } int -ioctl (int fd, unsigned long int cmd, ...) +fcntl64 (int fd, int cmd, ...) { - const char *func_str; + va_list ap; int rv; + + if ((errno = -ldp_init ())) + return -1; + + va_start (ap, cmd); + rv = fcntl_internal (fd, cmd, ap); + va_end (ap); + return rv; +} + +int +ioctl (int fd, unsigned long int cmd, ...) +{ + vls_handle_t vlsh; va_list ap; - u32 sid = ldp_sh_from_fd (fd); + int rv; if ((errno = -ldp_init ())) return -1; va_start (ap, cmd); - if (sid != INVALID_SESSION_ID) - { - func_str = "vppcom_session_attr[GET_NREAD]"; + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) + { switch (cmd) { case FIONREAD: - if (LDP_DEBUG > 2) - clib_warning - ("LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_NREAD, 0, 0); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_NREAD, 0, 0); break; case FIONBIO: @@ -765,14 +598,7 @@ ioctl (int fd, unsigned long int cmd, ...) * non-blocking, the flags should be read here and merged * with O_NONBLOCK. */ - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), flags %d (0x%x), size %d", - getpid (), fd, fd, func_str, sid, sid, - flags, flags, size); - - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_FLAGS, &flags, - &size); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_FLAGS, &flags, &size); } break; @@ -788,34 +614,90 @@ ioctl (int fd, unsigned long int cmd, ...) } else { - func_str = "libc_vioctl"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): cmd %d", - getpid (), fd, fd, func_str, cmd); - rv = libc_vioctl (fd, cmd, ap); } - if (LDP_DEBUG > 2) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } va_end (ap); return rv; } +always_inline void +ldp_select_init_maps (fd_set * __restrict original, + clib_bitmap_t ** resultb, clib_bitmap_t ** libcb, + clib_bitmap_t ** vclb, int nfds, u32 minbits, + u32 n_bytes, uword * si_bits, uword * libc_bits) +{ + uword si_bits_set, libc_bits_set; + vls_handle_t vlsh; + int fd; + + clib_bitmap_validate (*vclb, minbits); + clib_bitmap_validate (*libcb, minbits); + clib_bitmap_validate (*resultb, minbits); + clib_memcpy_fast (*resultb, original, n_bytes); + memset (original, 0, n_bytes); + + /* *INDENT-OFF* */ + clib_bitmap_foreach (fd, *resultb) { + if (fd > nfds) + break; + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh == VLS_INVALID_HANDLE) + clib_bitmap_set_no_check (*libcb, fd, 1); + else + *vclb = clib_bitmap_set (*vclb, vlsh_to_session_index (vlsh), 1); + } + /* *INDENT-ON* */ + + si_bits_set = clib_bitmap_last_set (*vclb) + 1; + *si_bits = (si_bits_set > *si_bits) ? si_bits_set : *si_bits; + clib_bitmap_validate (*resultb, *si_bits); + + libc_bits_set = clib_bitmap_last_set (*libcb) + 1; + *libc_bits = (libc_bits_set > *libc_bits) ? libc_bits_set : *libc_bits; +} + +always_inline int +ldp_select_vcl_map_to_libc (clib_bitmap_t * vclb, fd_set * __restrict libcb) +{ + vls_handle_t vlsh; + uword si; + int fd; + + if (!libcb) + return 0; + + /* *INDENT-OFF* */ + clib_bitmap_foreach (si, vclb) { + vlsh = vls_session_index_to_vlsh (si); + ASSERT (vlsh != VLS_INVALID_HANDLE); + fd = ldp_vlsh_to_fd (vlsh); + if (PREDICT_FALSE (fd < 0)) + { + errno = EBADFD; + return -1; + } + FD_SET (fd, libcb); + } + /* *INDENT-ON* */ + + return 0; +} + +always_inline void +ldp_select_libc_map_merge (clib_bitmap_t * result, fd_set * __restrict libcb) +{ + uword fd; + + if (!libcb) + return; + + /* *INDENT-OFF* */ + clib_bitmap_foreach (fd, result) + FD_SET ((int)fd, libcb); + /* *INDENT-ON* */ +} + int ldp_pselect (int nfds, fd_set * __restrict readfds, fd_set * __restrict writefds, @@ -823,12 +705,12 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, const struct timespec *__restrict timeout, const __sigset_t * __restrict sigmask) { - uword sid_bits, sid_bits_set, libc_bits, libc_bits_set; + u32 minbits = clib_max (nfds, BITS (uword)), n_bytes; ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); - u32 minbits = clib_max (nfds, BITS (uword)), sid; - char *func_str = "##"; - f64 time_out; - int rv, fd; + struct timespec libc_tspec = { 0 }; + f64 time_out, vcl_timeout = 0; + uword si_bits, libc_bits; + int rv, bits_set = 0; if (nfds < 0) { @@ -836,17 +718,17 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, return -1; } + if (PREDICT_FALSE (ldpw->clib_time.init_cpu_time == 0)) + clib_time_init (&ldpw->clib_time); + if (timeout) { time_out = (timeout->tv_sec == 0 && timeout->tv_nsec == 0) ? - (f64) 0 : (f64) timeout->tv_sec + - (f64) timeout->tv_nsec / (f64) 1000000000; + (f64) 0 : (f64) timeout->tv_sec + (f64) timeout->tv_nsec / (f64) 1e9; /* select as fine grained sleep */ if (!nfds) { - LDBG (3, "sleeping for %.02f seconds", time_out); - time_out += clib_time_now (&ldpw->clib_time); while (clib_time_now (&ldpw->clib_time) < time_out) ; @@ -861,251 +743,120 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, else time_out = -1; - - if (nfds <= ldp->sh_bit_val) + if (nfds <= ldp->vlsh_bit_val) { - func_str = "libc_pselect"; - - LDBG (3, "calling %s(): nfds %d, readfds %p, writefds %p, " - "exceptfds %p, timeout %p, sigmask %p", func_str, nfds, - readfds, writefds, exceptfds, timeout, sigmask); - rv = libc_pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask); goto done; } - if (PREDICT_FALSE (ldp->sh_bit_val > FD_SETSIZE / 2)) - { - clib_warning ("LDP<%d>: ERROR: LDP sid bit value %d (0x%x) > " - "FD_SETSIZE/2 %d (0x%x)!", getpid (), - ldp->sh_bit_val, ldp->sh_bit_val, - FD_SETSIZE / 2, FD_SETSIZE / 2); - errno = EOVERFLOW; - return -1; - } + si_bits = libc_bits = 0; + n_bytes = nfds / 8 + ((nfds % 8) ? 1 : 0); - sid_bits = libc_bits = 0; - u32 n_bytes = nfds / 8 + ((nfds % 8) ? 1 : 0); if (readfds) - { - clib_bitmap_validate (ldpw->sid_rd_bitmap, minbits); - clib_bitmap_validate (ldpw->libc_rd_bitmap, minbits); - clib_bitmap_validate (ldpw->rd_bitmap, minbits); - clib_memcpy_fast (ldpw->rd_bitmap, readfds, n_bytes); - memset (readfds, 0, n_bytes); - - /* *INDENT-OFF* */ - clib_bitmap_foreach (fd, ldpw->rd_bitmap, ({ - if (fd > nfds) - break; - sid = ldp_sh_from_fd (fd); - LDBG (3, "readfds: fd %d (0x%x), sid %u (0x%x)", fd, fd, sid, sid); - if (sid == INVALID_SESSION_ID) - clib_bitmap_set_no_check (ldpw->libc_rd_bitmap, fd, 1); - else - clib_bitmap_set_no_check (ldpw->sid_rd_bitmap, - vppcom_session_index (sid), 1); - })); - /* *INDENT-ON* */ - - sid_bits_set = clib_bitmap_last_set (ldpw->sid_rd_bitmap) + 1; - sid_bits = (sid_bits_set > sid_bits) ? sid_bits_set : sid_bits; - - libc_bits_set = clib_bitmap_last_set (ldpw->libc_rd_bitmap) + 1; - libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits; - - LDBG (3, "readfds: sid_bits_set %d, sid_bits %d, " - "libc_bits_set %d, libc_bits %d", sid_bits_set, - sid_bits, libc_bits_set, libc_bits); - } + ldp_select_init_maps (readfds, &ldpw->rd_bitmap, &ldpw->libc_rd_bitmap, + &ldpw->si_rd_bitmap, nfds, minbits, n_bytes, + &si_bits, &libc_bits); if (writefds) - { - clib_bitmap_validate (ldpw->sid_wr_bitmap, minbits); - clib_bitmap_validate (ldpw->libc_wr_bitmap, minbits); - clib_bitmap_validate (ldpw->wr_bitmap, minbits); - clib_memcpy_fast (ldpw->wr_bitmap, writefds, n_bytes); - memset (writefds, 0, n_bytes); - - /* *INDENT-OFF* */ - clib_bitmap_foreach (fd, ldpw->wr_bitmap, ({ - if (fd > nfds) - break; - sid = ldp_sh_from_fd (fd); - LDBG (3, "writefds: fd %d (0x%x), sid %u (0x%x)", fd, fd, sid, sid); - if (sid == INVALID_SESSION_ID) - clib_bitmap_set_no_check (ldpw->libc_wr_bitmap, fd, 1); - else - clib_bitmap_set_no_check (ldpw->sid_wr_bitmap, - vppcom_session_index (sid), 1); - })); - /* *INDENT-ON* */ - - sid_bits_set = clib_bitmap_last_set (ldpw->sid_wr_bitmap) + 1; - sid_bits = (sid_bits_set > sid_bits) ? sid_bits_set : sid_bits; - - libc_bits_set = clib_bitmap_last_set (ldpw->libc_wr_bitmap) + 1; - libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits; - - LDBG (3, "writefds: sid_bits_set %d, sid_bits %d, " - "libc_bits_set %d, libc_bits %d", - sid_bits_set, sid_bits, libc_bits_set, libc_bits); - } + ldp_select_init_maps (writefds, &ldpw->wr_bitmap, + &ldpw->libc_wr_bitmap, &ldpw->si_wr_bitmap, nfds, + minbits, n_bytes, &si_bits, &libc_bits); if (exceptfds) - { - clib_bitmap_validate (ldpw->sid_ex_bitmap, minbits); - clib_bitmap_validate (ldpw->libc_ex_bitmap, minbits); - clib_bitmap_validate (ldpw->ex_bitmap, minbits); - clib_memcpy_fast (ldpw->ex_bitmap, exceptfds, n_bytes); - memset (exceptfds, 0, n_bytes); - - /* *INDENT-OFF* */ - clib_bitmap_foreach (fd, ldpw->ex_bitmap, ({ - if (fd > nfds) - break; - sid = ldp_sh_from_fd (fd); - LDBG (3, "exceptfds: fd %d (0x%x), sid %u (0x%x)", fd, fd, sid, sid); - if (sid == INVALID_SESSION_ID) - clib_bitmap_set_no_check (ldpw->libc_ex_bitmap, fd, 1); - else - clib_bitmap_set_no_check (ldpw->sid_ex_bitmap, - vppcom_session_index (sid), 1); - })); - /* *INDENT-ON* */ - - sid_bits_set = clib_bitmap_last_set (ldpw->sid_ex_bitmap) + 1; - sid_bits = (sid_bits_set > sid_bits) ? sid_bits_set : sid_bits; - - libc_bits_set = clib_bitmap_last_set (ldpw->libc_ex_bitmap) + 1; - libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits; + ldp_select_init_maps (exceptfds, &ldpw->ex_bitmap, + &ldpw->libc_ex_bitmap, &ldpw->si_ex_bitmap, nfds, + minbits, n_bytes, &si_bits, &libc_bits); - LDBG (3, "exceptfds: sid_bits_set %d, sid_bits %d, " - "libc_bits_set %d, libc_bits %d", - sid_bits_set, sid_bits, libc_bits_set, libc_bits); - } - - if (PREDICT_FALSE (!sid_bits && !libc_bits)) + if (PREDICT_FALSE (!si_bits && !libc_bits)) { errno = EINVAL; rv = -1; goto done; } + if (!si_bits) + libc_tspec = timeout ? *timeout : libc_tspec; + do { - if (sid_bits) + if (si_bits) { - if (!ldpw->select_vcl) + if (readfds) + clib_memcpy_fast (ldpw->rd_bitmap, ldpw->si_rd_bitmap, + vec_len (ldpw->si_rd_bitmap) * + sizeof (clib_bitmap_t)); + if (writefds) + clib_memcpy_fast (ldpw->wr_bitmap, ldpw->si_wr_bitmap, + vec_len (ldpw->si_wr_bitmap) * + sizeof (clib_bitmap_t)); + if (exceptfds) + clib_memcpy_fast (ldpw->ex_bitmap, ldpw->si_ex_bitmap, + vec_len (ldpw->si_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); + if (rv < 0) + { + errno = -rv; + rv = -1; + goto done; + } + else if (rv > 0) { - func_str = "vppcom_select"; - - if (readfds) - clib_memcpy_fast (ldpw->rd_bitmap, ldpw->sid_rd_bitmap, - vec_len (ldpw->rd_bitmap) * - sizeof (clib_bitmap_t)); - if (writefds) - clib_memcpy_fast (ldpw->wr_bitmap, ldpw->sid_wr_bitmap, - vec_len (ldpw->wr_bitmap) * - sizeof (clib_bitmap_t)); - if (exceptfds) - clib_memcpy_fast (ldpw->ex_bitmap, ldpw->sid_ex_bitmap, - vec_len (ldpw->ex_bitmap) * - sizeof (clib_bitmap_t)); - - rv = vppcom_select (sid_bits, - readfds ? (unsigned long *) ldpw->rd_bitmap - : NULL, - writefds ? (unsigned long *) ldpw->wr_bitmap - : NULL, - exceptfds ? (unsigned long *) - ldpw->ex_bitmap : NULL, 0); - if (rv < 0) + if (ldp_select_vcl_map_to_libc (ldpw->rd_bitmap, readfds)) { - errno = -rv; rv = -1; + goto done; } - else if (rv > 0) + + if (ldp_select_vcl_map_to_libc (ldpw->wr_bitmap, writefds)) { - if (readfds) - { - /* *INDENT-OFF* */ - clib_bitmap_foreach (sid, ldpw->rd_bitmap, - ({ - fd = ldp_fd_from_sh (vppcom_session_handle (sid)); - if (PREDICT_FALSE (fd < 0)) - { - errno = EBADFD; - rv = -1; - goto done; - } - FD_SET (fd, readfds); - })); - /* *INDENT-ON* */ - } - if (writefds) - { - /* *INDENT-OFF* */ - clib_bitmap_foreach (sid, ldpw->wr_bitmap, - ({ - fd = ldp_fd_from_sh (vppcom_session_handle (sid)); - if (PREDICT_FALSE (fd < 0)) - { - errno = EBADFD; - rv = -1; - goto done; - } - FD_SET (fd, writefds); - })); - /* *INDENT-ON* */ - } - if (exceptfds) - { - /* *INDENT-OFF* */ - clib_bitmap_foreach (sid, ldpw->ex_bitmap, - ({ - fd = ldp_fd_from_sh (vppcom_session_handle (sid)); - if (PREDICT_FALSE (fd < 0)) - { - errno = EBADFD; - rv = -1; - goto done; - } - FD_SET (fd, exceptfds); - })); - /* *INDENT-ON* */ - } - ldpw->select_vcl = 1; + rv = -1; goto done; } + + if (ldp_select_vcl_map_to_libc (ldpw->ex_bitmap, exceptfds)) + { + rv = -1; + goto done; + } + bits_set = rv; } - else - ldpw->select_vcl = 0; } if (libc_bits) { - struct timespec tspec; - - func_str = "libc_pselect"; - if (readfds) - clib_memcpy_fast (readfds, ldpw->libc_rd_bitmap, - vec_len (ldpw->rd_bitmap) * + clib_memcpy_fast (ldpw->rd_bitmap, ldpw->libc_rd_bitmap, + vec_len (ldpw->libc_rd_bitmap) * sizeof (clib_bitmap_t)); if (writefds) - clib_memcpy_fast (writefds, ldpw->libc_wr_bitmap, - vec_len (ldpw->wr_bitmap) * + clib_memcpy_fast (ldpw->wr_bitmap, ldpw->libc_wr_bitmap, + vec_len (ldpw->libc_wr_bitmap) * sizeof (clib_bitmap_t)); if (exceptfds) - clib_memcpy_fast (exceptfds, ldpw->libc_ex_bitmap, - vec_len (ldpw->ex_bitmap) * + clib_memcpy_fast (ldpw->ex_bitmap, ldpw->libc_ex_bitmap, + vec_len (ldpw->libc_ex_bitmap) * sizeof (clib_bitmap_t)); - tspec.tv_sec = tspec.tv_nsec = 0; + rv = libc_pselect (libc_bits, - readfds ? readfds : NULL, - writefds ? writefds : NULL, - exceptfds ? exceptfds : NULL, &tspec, sigmask); - if (rv != 0) - goto done; + readfds ? (fd_set *) ldpw->rd_bitmap : NULL, + writefds ? (fd_set *) ldpw->wr_bitmap : NULL, + exceptfds ? (fd_set *) ldpw->ex_bitmap : NULL, + &libc_tspec, sigmask); + if (rv > 0) + { + ldp_select_libc_map_merge (ldpw->rd_bitmap, readfds); + ldp_select_libc_map_merge (ldpw->wr_bitmap, writefds); + ldp_select_libc_map_merge (ldpw->ex_bitmap, exceptfds); + bits_set += rv; + } + } + + if (bits_set) + { + rv = bits_set; + goto done; } } while ((time_out == -1) || (clib_time_now (&ldpw->clib_time) < time_out)); @@ -1114,29 +865,15 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, done: /* TBD: set timeout to amount of time left */ clib_bitmap_zero (ldpw->rd_bitmap); - clib_bitmap_zero (ldpw->sid_rd_bitmap); + clib_bitmap_zero (ldpw->si_rd_bitmap); clib_bitmap_zero (ldpw->libc_rd_bitmap); clib_bitmap_zero (ldpw->wr_bitmap); - clib_bitmap_zero (ldpw->sid_wr_bitmap); + clib_bitmap_zero (ldpw->si_wr_bitmap); clib_bitmap_zero (ldpw->libc_wr_bitmap); clib_bitmap_zero (ldpw->ex_bitmap); - clib_bitmap_zero (ldpw->sid_ex_bitmap); + clib_bitmap_zero (ldpw->si_ex_bitmap); clib_bitmap_zero (ldpw->libc_ex_bitmap); - if (LDP_DEBUG > 3) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: %s() failed! " - "rv %d, errno = %d", getpid (), - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: returning %d (0x%x)", getpid (), rv, rv); - } return rv; } @@ -1152,29 +889,96 @@ select (int nfds, fd_set * __restrict readfds, tspec.tv_sec = timeout->tv_sec; tspec.tv_nsec = timeout->tv_usec * 1000; } - return ldp_pselect (nfds, readfds, writefds, exceptfds, - timeout ? &tspec : NULL, NULL); + return ldp_pselect (nfds, readfds, writefds, exceptfds, + timeout ? &tspec : NULL, NULL); +} + +#ifdef __USE_XOPEN2K +int +pselect (int nfds, fd_set * __restrict readfds, + fd_set * __restrict writefds, + fd_set * __restrict exceptfds, + const struct timespec *__restrict timeout, + const __sigset_t * __restrict sigmask) +{ + return ldp_pselect (nfds, readfds, writefds, exceptfds, timeout, 0); +} +#endif + +/* If transparent TLS mode is turned on, then ldp will load key and cert. + */ +static int +load_cert_key_pair (void) +{ + char *cert_str = getenv (LDP_ENV_TLS_CERT); + char *key_str = getenv (LDP_ENV_TLS_KEY); + char cert_buf[4096], key_buf[4096]; + int cert_size, key_size; + vppcom_cert_key_pair_t crypto; + int ckp_index; + FILE *fp; + + if (!cert_str || !key_str) + { + LDBG (0, "ERROR: failed to read LDP environment %s\n", + LDP_ENV_TLS_CERT); + return -1; + } + + fp = fopen (cert_str, "r"); + if (fp == NULL) + { + LDBG (0, "ERROR: failed to open cert file %s \n", cert_str); + return -1; + } + cert_size = fread (cert_buf, sizeof (char), sizeof (cert_buf), fp); + fclose (fp); + + fp = fopen (key_str, "r"); + if (fp == NULL) + { + LDBG (0, "ERROR: failed to open key file %s \n", key_str); + return -1; + } + key_size = fread (key_buf, sizeof (char), sizeof (key_buf), fp); + fclose (fp); + + crypto.cert = cert_buf; + crypto.key = key_buf; + crypto.cert_len = cert_size; + crypto.key_len = key_size; + ckp_index = vppcom_add_cert_key_pair (&crypto); + if (ckp_index < 0) + { + LDBG (0, "ERROR: failed to add cert key pair\n"); + return -1; + } + + ldp->ckpair_index = ckp_index; + + return 0; } -#ifdef __USE_XOPEN2K -int -pselect (int nfds, fd_set * __restrict readfds, - fd_set * __restrict writefds, - fd_set * __restrict exceptfds, - const struct timespec *__restrict timeout, - const __sigset_t * __restrict sigmask) +static int +assign_cert_key_pair (vls_handle_t vlsh) { - return ldp_pselect (nfds, readfds, writefds, exceptfds, timeout, 0); + uint32_t ckp_len; + + if (ldp->ckpair_index == ~0 && load_cert_key_pair () < 0) + return -1; + + ckp_len = sizeof (ldp->ckpair_index); + return vppcom_session_attr (vlsh_to_session_index (vlsh), + VPPCOM_ATTR_SET_CKPAIR, &ldp->ckpair_index, + &ckp_len); } -#endif int socket (int domain, int type, int protocol) { - const char *func_str; - int rv; + int rv, sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); u8 is_nonblocking = type & SOCK_NONBLOCK ? 1 : 0; - int sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); + vls_handle_t vlsh; if ((errno = -ldp_init ())) return -1; @@ -1182,56 +986,40 @@ socket (int domain, int type, int protocol) if (((domain == AF_INET) || (domain == AF_INET6)) && ((sock_type == SOCK_STREAM) || (sock_type == SOCK_DGRAM))) { - int sid; - u8 proto = ((sock_type == SOCK_DGRAM) ? - VPPCOM_PROTO_UDP : VPPCOM_PROTO_TCP); - - func_str = "vppcom_session_create"; + u8 proto; + if (ldp->transparent_tls) + { + proto = VPPCOM_PROTO_TLS; + } + else + proto = ((sock_type == SOCK_DGRAM) ? + VPPCOM_PROTO_UDP : VPPCOM_PROTO_TCP); - LDBG (0, "calling %s(): proto %u (%s), is_nonblocking %u", - func_str, proto, vppcom_proto_str (proto), is_nonblocking); + LDBG (0, "calling vls_create: proto %u (%s), is_nonblocking %u", + proto, vppcom_proto_str (proto), is_nonblocking); - sid = vppcom_session_create (proto, is_nonblocking); - if (sid < 0) + vlsh = vls_create (proto, is_nonblocking); + if (vlsh < 0) { - errno = -sid; + errno = -vlsh; rv = -1; } else { - func_str = "ldp_fd_from_sid"; - rv = ldp_fd_alloc (sid); - if (rv < 0) + if (ldp->transparent_tls) { - (void) vppcom_session_close (sid); - errno = -rv; - rv = -1; + if (assign_cert_key_pair (vlsh) < 0) + return -1; } + rv = ldp_vlsh_to_fd (vlsh); } } else { - func_str = "libc_socket"; - - LDBG (0, "calling %s()", func_str); - + LDBG (0, "calling libc_socket"); rv = libc_socket (domain, type, protocol); } - if (LDP_DEBUG > 0) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: %s() failed! " - "rv %d, errno = %d", - getpid (), func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("returning fd %d (0x%x)", getpid (), rv, rv); - } return rv; } @@ -1245,9 +1033,7 @@ socket (int domain, int type, int protocol) int socketpair (int domain, int type, int protocol, int fds[2]) { - const char *func_str; - int rv; - int sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); + int rv, sock_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); if ((errno = -ldp_init ())) return -1; @@ -1255,48 +1041,30 @@ socketpair (int domain, int type, int protocol, int fds[2]) if (((domain == AF_INET) || (domain == AF_INET6)) && ((sock_type == SOCK_STREAM) || (sock_type == SOCK_DGRAM))) { - func_str = __func__; - - clib_warning ("LDP<%d>: LDP-TBD", getpid ()); + LDBG (0, "LDP-TBD"); errno = ENOSYS; rv = -1; } else { - func_str = "libc_socket"; - - LDBG (1, "calling %s()", func_str); - + LDBG (1, "calling libc_socketpair"); rv = libc_socketpair (domain, type, protocol, fds); } - if (LDP_DEBUG > 1) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: %s() failed! " - "rv %d, errno = %d", - getpid (), func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: : returning fd %d (0x%x)", getpid (), rv, rv); - } return rv; } int bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) { + vls_handle_t vlsh; int rv; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { vppcom_endpt_t ep; @@ -1305,9 +1073,8 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) case AF_INET: if (len != sizeof (struct sockaddr_in)) { - clib_warning - ("LDP<%d>: ERROR: fd %d (0x%x): sid %u (0x%x): Invalid " - "AF_INET addr len %u!", getpid (), fd, fd, sid, sid, len); + LDBG (0, "ERROR: fd %d: vlsh %u: Invalid AF_INET addr len %u!", + fd, vlsh, len); errno = EINVAL; rv = -1; goto done; @@ -1320,9 +1087,8 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) case AF_INET6: if (len != sizeof (struct sockaddr_in6)) { - clib_warning - ("LDP<%d>: ERROR: fd %d (0x%x): sid %u (0x%x): Invalid " - "AF_INET6 addr len %u!", getpid (), fd, fd, sid, sid, len); + LDBG (0, "ERROR: fd %d: vlsh %u: Invalid AF_INET6 addr len %u!", + fd, vlsh, len); errno = EINVAL; rv = -1; goto done; @@ -1333,17 +1099,16 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) break; default: - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): sid %u (0x%x): " - "Unsupported address family %u!", - getpid (), fd, fd, sid, sid, addr->sa_family); + LDBG (0, "ERROR: fd %d: vlsh %u: Unsupported address family %u!", + fd, vlsh, addr->sa_family); errno = EAFNOSUPPORT; rv = -1; goto done; } - LDBG (0, "fd %d (0x%x): calling vppcom_session_bind(): " - "sid %u (0x%x), addr %p, len %u", fd, fd, sid, sid, addr, len); + LDBG (0, "fd %d: calling vls_bind: vlsh %u, addr %p, len %u", fd, vlsh, + addr, len); - rv = vppcom_session_bind (sid, &ep); + rv = vls_bind (vlsh, &ep); if (rv != VPPCOM_OK) { errno = -rv; @@ -1352,14 +1117,12 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) } else { - LDBG (0, "fd %d (0x%x): calling libc_bind(): addr %p, len %u", - fd, fd, addr, len); - + LDBG (0, "fd %d: calling libc_bind: addr %p, len %u", fd, addr, len); rv = libc_bind (fd, addr, len); } done: - LDBG (1, "fd %d (0x%x): returning %d", fd, fd, rv); + LDBG (1, "fd %d: returning %d", fd, rv); return rv; } @@ -1413,28 +1176,22 @@ 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; int rv; - const char *func_str; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { vppcom_endpt_t ep; u8 addr_buf[sizeof (struct in6_addr)]; u32 size = sizeof (ep); ep.ip = addr_buf; - func_str = "vppcom_session_attr[GET_LCL_ADDR]"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x), " - "addr %p, len %u", - getpid (), fd, fd, func_str, sid, sid, addr, len); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size); if (rv != VPPCOM_OK) { errno = -rv; @@ -1452,53 +1209,31 @@ getsockname (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) } else { - func_str = "libc_getsockname"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "addr %p, len %u", - getpid (), fd, fd, func_str, addr, len); - rv = libc_getsockname (fd, addr, len); } - if (LDP_DEBUG > 2) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } return rv; } int connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) { + vls_handle_t vlsh; int rv; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; if (!addr) { - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): NULL addr, len %u", - getpid (), fd, fd, len); + LDBG (0, "ERROR: fd %d: NULL addr, len %u", fd, len); errno = EINVAL; rv = -1; goto done; } - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { vppcom_endpt_t ep; @@ -1507,9 +1242,8 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) case AF_INET: if (len != sizeof (struct sockaddr_in)) { - clib_warning - ("LDP<%d>: fd %d (0x%x): ERROR sid %u (0x%x): Invalid " - "AF_INET addr len %u!", getpid (), fd, fd, sid, sid, len); + LDBG (0, "fd %d: ERROR vlsh %u: Invalid AF_INET addr len %u!", + fd, vlsh, len); errno = EINVAL; rv = -1; goto done; @@ -1522,9 +1256,8 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) case AF_INET6: if (len != sizeof (struct sockaddr_in6)) { - clib_warning - ("LDP<%d>: fd %d (0x%x): ERROR sid %u (0x%x): Invalid " - "AF_INET6 addr len %u!", getpid (), fd, fd, sid, sid, len); + LDBG (0, "fd %d: ERROR vlsh %u: Invalid AF_INET6 addr len %u!", + fd, vlsh, len); errno = EINVAL; rv = -1; goto done; @@ -1535,17 +1268,16 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) break; default: - clib_warning ("LDP<%d>: fd %d (0x%x): ERROR sid %u (0x%x): " - "Unsupported address family %u!", - getpid (), fd, fd, sid, sid, addr->sa_family); + LDBG (0, "fd %d: ERROR vlsh %u: Unsupported address family %u!", + fd, vlsh, addr->sa_family); errno = EAFNOSUPPORT; rv = -1; goto done; } - LDBG (0, "fd %d (0x%x): calling vppcom_session_connect(): sid %u (0x%x)" - " addr %p len %u", fd, fd, sid, sid, addr, len); + LDBG (0, "fd %d: calling vls_connect(): vlsh %u addr %p len %u", fd, + vlsh, addr, len); - rv = vppcom_session_connect (sid, &ep); + rv = vls_connect (vlsh, &ep); if (rv != VPPCOM_OK) { errno = -rv; @@ -1554,42 +1286,35 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) } else { - LDBG (0, "fd %d (0x%x): calling libc_connect(): addr %p, len %u", - fd, fd, addr, len); + LDBG (0, "fd %d: calling libc_connect(): addr %p, len %u", + fd, addr, len); rv = libc_connect (fd, addr, len); } done: - LDBG (1, "fd %d (0x%x): returning %d (0x%x)", fd, fd, rv, rv); + LDBG (1, "fd %d: returning %d (0x%x)", fd, rv, rv); return rv; } int getpeername (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) { + vls_handle_t vlsh; int rv; - const char *func_str; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { vppcom_endpt_t ep; u8 addr_buf[sizeof (struct in6_addr)]; u32 size = sizeof (ep); ep.ip = addr_buf; - func_str = "vppcom_session_attr[GET_PEER_ADDR]"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x), " - "addr %p, len %u", - getpid (), fd, fd, func_str, sid, sid, addr, len); - - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_PEER_ADDR, &ep, &size); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_PEER_ADDR, &ep, &size); if (rv != VPPCOM_OK) { errno = -rv; @@ -1607,55 +1332,24 @@ getpeername (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict len) } else { - func_str = "libc_getpeername"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "addr %p, len %u", - getpid (), fd, fd, func_str, addr, len); - rv = libc_getpeername (fd, addr, len); } - if (LDP_DEBUG > 2) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } return rv; } ssize_t send (int fd, const void *buf, size_t n, int flags) { + vls_handle_t vlsh = ldp_fd_to_vlsh (fd); ssize_t size; - const char *func_str; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + if (vlsh != VLS_INVALID_HANDLE) { - - func_str = "vppcom_session_sendto"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x), " - "buf %p, n %u, flags 0x%x", - getpid (), fd, fd, func_str, sid, sid, buf, n, flags); - - size = vppcom_session_sendto (sid, (void *) buf, n, flags, NULL); + size = vls_sendto (vlsh, (void *) buf, n, flags, NULL); if (size < VPPCOM_OK) { errno = -size; @@ -1664,31 +1358,9 @@ send (int fd, const void *buf, size_t n, int flags) } else { - func_str = "libc_send"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "buf %p, n %u, flags 0x%x", - getpid (), fd, fd, func_str, buf, n, flags); - size = libc_send (fd, buf, n, flags); } - if (LDP_DEBUG > 2) - { - if (size < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, size, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, size, size); - } return size; } @@ -1696,33 +1368,28 @@ 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; ssize_t size = 0; - const char *func_str; - u32 sid = ldp_sh_from_fd (out_fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (out_fd); + if (vlsh != VLS_INVALID_HANDLE) { int rv; ssize_t results = 0; size_t n_bytes_left = len; size_t bytes_to_read; int nbytes; - int errno_val; u8 eagain = 0; u32 flags, flags_len = sizeof (flags); - func_str = "vppcom_session_attr[GET_FLAGS]"; - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_FLAGS, &flags, - &flags_len); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_FLAGS, &flags, &flags_len); if (PREDICT_FALSE (rv != VPPCOM_OK)) { - clib_warning ("LDP<%d>: ERROR: out fd %d (0x%x): %s(): " - "sid %u (0x%x), returned %d (%s)!", getpid (), - out_fd, out_fd, func_str, sid, sid, rv, - vppcom_retval_str (rv)); + LDBG (0, "ERROR: out fd %d: vls_attr: vlsh %u, returned %d (%s)!", + out_fd, vlsh, rv, vppcom_retval_str (rv)); vec_reset_length (ldpw->io_buffer); errno = -rv; @@ -1735,14 +1402,6 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) off_t off = lseek (in_fd, *offset, SEEK_SET); if (PREDICT_FALSE (off == -1)) { - func_str = "lseek"; - errno_val = errno; - clib_warning ("LDP<%d>: ERROR: out fd %d (0x%x): %s(): " - "SEEK_SET failed: in_fd %d, offset %p, " - "*offset %ld, rv %ld, errno %d", getpid (), - out_fd, out_fd, in_fd, offset, *offset, off, - errno_val); - errno = errno_val; size = -1; goto done; } @@ -1752,14 +1411,11 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) do { - func_str = "vppcom_session_attr[GET_NWRITE]"; - size = vppcom_session_attr (sid, VPPCOM_ATTR_GET_NWRITE, 0, 0); + size = vls_attr (vlsh, VPPCOM_ATTR_GET_NWRITE, 0, 0); if (size < 0) { - clib_warning - ("LDP<%d>: ERROR: fd %d (0x%x): %s(): sid %u (0x%x), " - "returned %d (%s)!", getpid (), out_fd, out_fd, func_str, - sid, sid, size, vppcom_retval_str (size)); + LDBG (0, "ERROR: fd %d: vls_attr: vlsh %u returned %ld (%s)!", + out_fd, vlsh, size, vppcom_retval_str (size)); vec_reset_length (ldpw->io_buffer); errno = -size; size = -1; @@ -1767,25 +1423,12 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) } bytes_to_read = size; - if (LDP_DEBUG > 2) - clib_warning - ("LDP<%d>: fd %d (0x%x): called %s(): sid %u (0x%x), " - "results %ld, n_bytes_left %lu, bytes_to_read %lu", getpid (), - out_fd, out_fd, func_str, sid, sid, results, n_bytes_left, - bytes_to_read); - if (bytes_to_read == 0) { if (flags & O_NONBLOCK) { if (!results) - { - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): sid %u (0x%x): " - "EAGAIN", - getpid (), out_fd, out_fd, sid, sid); - eagain = 1; - } + eagain = 1; goto update_offset; } else @@ -1796,15 +1439,6 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) nbytes = libc_read (in_fd, ldpw->io_buffer, bytes_to_read); if (nbytes < 0) { - func_str = "libc_read"; - errno_val = errno; - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): in_fd (%d), " - "io_buffer %p, bytes_to_read %lu, rv %d, " - "errno %d", getpid (), out_fd, out_fd, func_str, - in_fd, ldpw->io_buffer, bytes_to_read, nbytes, - errno_val); - errno = errno_val; - if (results == 0) { vec_reset_length (ldpw->io_buffer); @@ -1813,15 +1447,8 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) } goto update_offset; } - func_str = "vppcom_session_write"; - if (LDP_DEBUG > 2) - clib_warning - ("LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x), " - "buf %p, nbytes %u: results %d, n_bytes_left %d", getpid (), - out_fd, out_fd, func_str, sid, sid, ldpw->io_buffer, nbytes, - results, n_bytes_left); - - size = vppcom_session_write (sid, ldpw->io_buffer, nbytes); + + size = vls_write (vlsh, ldpw->io_buffer, nbytes); if (size < 0) { if (size == VPPCOM_EAGAIN) @@ -1829,27 +1456,12 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) if (flags & O_NONBLOCK) { if (!results) - { - if (LDP_DEBUG > 2) - clib_warning - ("LDP<%d>: fd %d (0x%x): sid %u (0x%x): " - "EAGAIN", getpid (), out_fd, out_fd, sid, sid); - eagain = 1; - } + eagain = 1; goto update_offset; } else continue; } - else - { - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s():" - "sid %u, io_buffer %p, nbytes %u " - "returned %d (%s)", - getpid (), out_fd, out_fd, func_str, - sid, ldpw->io_buffer, nbytes, - size, vppcom_retval_str (size)); - } if (results == 0) { vec_reset_length (ldpw->io_buffer); @@ -1873,13 +1485,6 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) off_t off = lseek (in_fd, *offset, SEEK_SET); if (PREDICT_FALSE (off == -1)) { - func_str = "lseek"; - errno_val = errno; - clib_warning ("LDP<%d>: ERROR: %s(): SEEK_SET failed: " - "in_fd %d, offset %p, *offset %ld, " - "rv %ld, errno %d", getpid (), in_fd, - offset, *offset, off, errno_val); - errno = errno_val; size = -1; goto done; } @@ -1897,33 +1502,10 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) } else { - func_str = "libc_send"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "in_fd %d, offset %p, len %u", - getpid (), out_fd, out_fd, func_str, - in_fd, offset, len); - size = libc_sendfile (out_fd, in_fd, offset, len); } done: - if (LDP_DEBUG > 2) - { - if (size < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), out_fd, out_fd, - func_str, size, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), out_fd, out_fd, size, size); - } return size; } @@ -1936,158 +1518,107 @@ 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; ssize_t size; - u32 sid; if ((errno = -ldp_init ())) return -1; - sid = ldp_sh_from_fd (fd); - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - LDBG (2, "fd %d (0x%x): calling vcl recvfrom: sid %u (0x%x), buf %p," - " n %u, flags 0x%x", fd, fd, sid, sid, buf, n, flags); - - size = vppcom_session_recvfrom (sid, buf, n, flags, NULL); + size = vls_recvfrom (vlsh, buf, n, flags, NULL); if (size < 0) - errno = -size; + { + errno = -size; + size = -1; + } } else { - LDBG (2, "fd %d (0x%x): calling libc_recvfrom(): buf %p, n %u, " - "flags 0x%x", fd, fd, buf, n, flags); - size = libc_recv (fd, buf, n, flags); } return size; } -ssize_t -sendto (int fd, const void *buf, size_t n, int flags, - __CONST_SOCKADDR_ARG addr, socklen_t addr_len) +static int +ldp_vls_sendo (vls_handle_t vlsh, const void *buf, size_t n, int flags, + __CONST_SOCKADDR_ARG addr, socklen_t addr_len) { - ssize_t size; - const char *func_str = __func__; - u32 sid = ldp_sh_from_fd (fd); - - if ((errno = -ldp_init ())) - return -1; + vppcom_endpt_t *ep = 0; + vppcom_endpt_t _ep; - if (sid != INVALID_SESSION_ID) + if (addr) { - vppcom_endpt_t *ep = 0; - vppcom_endpt_t _ep; - - if (addr) + ep = &_ep; + switch (addr->sa_family) { - 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; - } - } - - func_str = "vppcom_session_sendto"; + 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; - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), buf %p, n %u, flags 0x%x, ep %p", - getpid (), fd, fd, func_str, sid, sid, buf, n, - flags, ep); + 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; - size = vppcom_session_sendto (sid, (void *) buf, n, flags, ep); - if (size < 0) - { - errno = -size; - size = -1; + default: + return EAFNOSUPPORT; } } - else - { - func_str = "libc_sendto"; - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "buf %p, n %u, flags 0x%x, addr %p, addr_len %d", - getpid (), fd, fd, func_str, buf, n, flags, - addr, addr_len); + return vls_sendto (vlsh, (void *) buf, n, flags, ep); +} - size = libc_sendto (fd, buf, n, flags, addr, addr_len); - } +static int +ldp_vls_recvfrom (vls_handle_t vlsh, void *__restrict buf, size_t n, + int flags, __SOCKADDR_ARG addr, + socklen_t * __restrict addr_len) +{ + u8 src_addr[sizeof (struct sockaddr_in6)]; + vppcom_endpt_t ep; + ssize_t size; + int rv; -done: - if (LDP_DEBUG > 2) + if (addr) { - if (size < 0) + ep.ip = src_addr; + size = vls_recvfrom (vlsh, buf, n, flags, &ep); + + if (size > 0) { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, size, errno_val); - errno = errno_val; + rv = ldp_copy_ep_to_sockaddr (addr, addr_len, &ep); + if (rv < 0) + size = rv; } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, size, size); } + else + size = vls_recvfrom (vlsh, buf, n, flags, NULL); + return size; } ssize_t -recvfrom (int fd, void *__restrict buf, size_t n, int flags, - __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) +sendto (int fd, const void *buf, size_t n, int flags, + __CONST_SOCKADDR_ARG addr, socklen_t addr_len) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != INVALID_SESSION_ID) { - vppcom_endpt_t ep; - u8 src_addr[sizeof (struct sockaddr_in6)]; - - func_str = "vppcom_session_recvfrom"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), buf %p, n %u, flags 0x%x, ep %p", - getpid (), fd, fd, func_str, sid, sid, buf, n, - flags, &ep); - if (addr) - { - ep.ip = src_addr; - size = vppcom_session_recvfrom (sid, buf, n, flags, &ep); - - if (size > 0) - size = ldp_copy_ep_to_sockaddr (addr, addr_len, &ep); - } - else - size = vppcom_session_recvfrom (sid, buf, n, flags, NULL); - + size = ldp_vls_sendo (vlsh, buf, n, flags, addr, addr_len); if (size < 0) { errno = -size; @@ -2096,80 +1627,83 @@ recvfrom (int fd, void *__restrict buf, size_t n, int flags, } else { - func_str = "libc_recvfrom"; + size = libc_sendto (fd, buf, n, flags, addr, addr_len); + } - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "buf %p, n %u, flags 0x%x, addr %p, addr_len %d", - getpid (), fd, fd, func_str, buf, n, flags, - addr, addr_len); + return size; +} - size = libc_recvfrom (fd, buf, n, flags, addr, addr_len); - } +ssize_t +recvfrom (int fd, void *__restrict buf, size_t n, int flags, + __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) +{ + vls_handle_t vlsh; + ssize_t size; - if (LDP_DEBUG > 2) + if ((errno = -ldp_init ())) + return -1; + + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - if (size < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, size, errno_val); - errno = errno_val; + size = ldp_vls_recvfrom (vlsh, buf, n, flags, addr, addr_len); + if (size < 0) + { + errno = -size; + size = -1; } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, size, size); } + else + { + size = libc_recvfrom (fd, buf, n, flags, addr, addr_len); + } + return size; } ssize_t -sendmsg (int fd, const struct msghdr * message, int flags) +sendmsg (int fd, const struct msghdr * msg, int flags) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) - { - func_str = __func__; - - clib_warning ("LDP<%d>: LDP-TBD", getpid ()); - errno = ENOSYS; - size = -1; - } - else + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - func_str = "libc_sendmsg"; + struct iovec *iov = msg->msg_iov; + ssize_t total = 0; + int i, rv; - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "message %p, flags 0x%x", - getpid (), fd, fd, func_str, message, flags); - - size = libc_sendmsg (fd, message, flags); - } + for (i = 0; i < msg->msg_iovlen; ++i) + { + rv = ldp_vls_sendo (vlsh, iov[i].iov_base, iov[i].iov_len, flags, + msg->msg_name, msg->msg_namelen); + if (rv < 0) + break; + else + { + total += rv; + if (rv < iov[i].iov_len) + break; + } + } - if (LDP_DEBUG > 2) - { - if (size < 0) + if (rv < 0 && total == 0) { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, size, errno_val); - errno = errno_val; + errno = -rv; + size = -1; } else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, size, size); + size = total; + } + else + { + size = libc_sendmsg (fd, msg, flags); } + return size; } @@ -2179,12 +1713,12 @@ sendmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags) { ssize_t size; const char *func_str; - u32 sid = ldp_sh_from_fd (fd); + u32 sh = ldp_fd_to_vlsh (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + if (sh != INVALID_SESSION_ID) { clib_warning ("LDP<%d>: LDP-TBD", getpid ()); errno = ENOSYS; @@ -2222,50 +1756,55 @@ sendmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags) #endif ssize_t -recvmsg (int fd, struct msghdr * message, int flags) +recvmsg (int fd, struct msghdr * msg, int flags) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) - { - func_str = __func__; - - clib_warning ("LDP<%d>: LDP-TBD", getpid ()); - errno = ENOSYS; - size = -1; - } - else + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - func_str = "libc_recvmsg"; + struct iovec *iov = msg->msg_iov; + ssize_t max_deq, total = 0; + int i, rv; - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "message %p, flags 0x%x", - getpid (), fd, fd, func_str, message, flags); + max_deq = vls_attr (vlsh, VPPCOM_ATTR_GET_NREAD, 0, 0); + if (!max_deq) + return 0; - size = libc_recvmsg (fd, message, flags); - } + for (i = 0; i < msg->msg_iovlen; i++) + { + rv = ldp_vls_recvfrom (vlsh, iov[i].iov_base, iov[i].iov_len, flags, + (i == 0 ? msg->msg_name : NULL), + (i == 0 ? &msg->msg_namelen : NULL)); + if (rv <= 0) + break; + else + { + total += rv; + if (rv < iov[i].iov_len) + break; + } + if (total >= max_deq) + break; + } - if (LDP_DEBUG > 2) - { - if (size < 0) + if (rv < 0 && total == 0) { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, size, errno_val); - errno = errno_val; + errno = -rv; + size = -1; } else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, size, size); + size = total; + } + else + { + size = libc_recvmsg (fd, msg, flags); } + return size; } @@ -2276,12 +1815,12 @@ recvmmsg (int fd, struct mmsghdr *vmessages, { ssize_t size; const char *func_str; - u32 sid = ldp_sh_from_fd (fd); + u32 sh = ldp_fd_to_vlsh (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + if (sh != INVALID_SESSION_ID) { clib_warning ("LDP<%d>: LDP-TBD", getpid ()); errno = ENOSYS; @@ -2323,15 +1862,14 @@ int getsockopt (int fd, int level, int optname, void *__restrict optval, socklen_t * __restrict optlen) { + vls_handle_t vlsh; int rv; - const char *func_str = __func__; - u32 sid = ldp_sh_from_fd (fd); - u32 buflen = optlen ? (u32) * optlen : 0; if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { rv = -EOPNOTSUPP; @@ -2341,62 +1879,40 @@ getsockopt (int fd, int level, int optname, switch (optname) { case TCP_NODELAY: - func_str = "vppcom_session_attr[SOL_TCP,GET_TCP_NODELAY]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_TCP_NODELAY, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_NODELAY, + optval, optlen); break; case TCP_MAXSEG: - func_str = "vppcom_session_attr[SOL_TCP,GET_TCP_USER_MSS]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_TCP_USER_MSS, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_USER_MSS, + optval, optlen); break; case TCP_KEEPIDLE: - func_str = "vppcom_session_attr[SOL_TCP,GET_TCP_KEEPIDLE]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_TCP_KEEPIDLE, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_KEEPIDLE, + optval, optlen); break; case TCP_KEEPINTVL: - func_str = "vppcom_session_attr[SOL_TCP,GET_TCP_KEEPINTVL]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), SOL_TCP", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_TCP_KEEPINTVL, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TCP_KEEPINTVL, + optval, optlen); break; case TCP_INFO: if (optval && optlen && (*optlen == sizeof (struct tcp_info))) { - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): sid %u (0x%x), " - "SOL_TCP, TCP_INFO, optval %p, " - "optlen %d: #LDP-NOP#", - getpid (), fd, fd, sid, sid, - optval, *optlen); + LDBG (1, "fd %d: vlsh %u SOL_TCP, TCP_INFO, optval %p, " + "optlen %d: #LDP-NOP#", fd, vlsh, optval, *optlen); memset (optval, 0, *optlen); rv = VPPCOM_OK; } else rv = -EFAULT; break; + case TCP_CONGESTION: + *optlen = strlen ("cubic"); + strncpy (optval, "cubic", *optlen + 1); + rv = 0; + break; default: - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): " - "sid %u (0x%x), SOL_TCP, " - "optname %d unsupported!", - getpid (), fd, fd, func_str, sid, sid, optname); + LDBG (0, "ERROR: fd %d: getsockopt SOL_TCP: sid %u, " + "optname %d unsupported!", fd, vlsh, optname); break; } break; @@ -2404,20 +1920,11 @@ getsockopt (int fd, int level, int optname, switch (optname) { case IPV6_V6ONLY: - func_str = "vppcom_session_attr[SOL_IPV6,GET_V6ONLY]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_V6ONLY, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_V6ONLY, optval, optlen); break; default: - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): " - "sid %u (0x%x), SOL_IPV6, " - "optname %d unsupported!", - getpid (), fd, fd, func_str, sid, sid, optname); + LDBG (0, "ERROR: fd %d: getsockopt SOL_IPV6: vlsh %u " + "optname %d unsupported!", fd, vlsh, optname); break; } break; @@ -2425,84 +1932,35 @@ getsockopt (int fd, int level, int optname, switch (optname) { case SO_ACCEPTCONN: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_ACCEPTCONN]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_LISTEN, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_LISTEN, optval, optlen); break; case SO_KEEPALIVE: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_KEEPALIVE]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_KEEPALIVE, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_KEEPALIVE, optval, optlen); break; case SO_PROTOCOL: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_PROTOCOL]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_PROTOCOL, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_PROTOCOL, optval, optlen); *(int *) optval = *(int *) optval ? SOCK_DGRAM : SOCK_STREAM; break; case SO_SNDBUF: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_TX_FIFO_LEN]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), optlen %d", - getpid (), fd, fd, func_str, sid, sid, buflen); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_TX_FIFO_LEN, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_TX_FIFO_LEN, + optval, optlen); break; case SO_RCVBUF: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_RX_FIFO_LEN]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), optlen %d", - getpid (), fd, fd, func_str, sid, sid, buflen); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_RX_FIFO_LEN, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_RX_FIFO_LEN, + optval, optlen); break; case SO_REUSEADDR: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_REUSEADDR]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_REUSEADDR, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_REUSEADDR, optval, optlen); break; case SO_BROADCAST: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_BROADCAST]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_BROADCAST, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_BROADCAST, optval, optlen); break; case SO_ERROR: - func_str = "vppcom_session_attr[SOL_SOCKET,GET_ERROR]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_ERROR, - optval, optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_ERROR, optval, optlen); break; default: - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): " - "sid %u (0x%x), SOL_SOCKET, " - "optname %d unsupported!", - getpid (), fd, fd, func_str, sid, sid, optname); + LDBG (0, "ERROR: fd %d: getsockopt SOL_SOCKET: vlsh %u " + "optname %d unsupported!", fd, vlsh, optname); break; } break; @@ -2518,32 +1976,9 @@ getsockopt (int fd, int level, int optname, } else { - func_str = "libc_getsockopt"; - - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): level %d, " - "optname %d, optval %p, optlen %d", - getpid (), fd, fd, func_str, level, optname, - optval, optlen); - rv = libc_getsockopt (fd, level, optname, optval, optlen); } - if (LDP_DEBUG > 1) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } return rv; } @@ -2551,14 +1986,14 @@ int setsockopt (int fd, int level, int optname, const void *optval, socklen_t optlen) { + vls_handle_t vlsh; int rv; - const char *func_str = __func__; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { rv = -EOPNOTSUPP; @@ -2568,47 +2003,29 @@ setsockopt (int fd, int level, int optname, switch (optname) { case TCP_NODELAY: - func_str = "vppcom_session_attr[SOL_TCP,SET_TCP_NODELAY]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_TCP_NODELAY, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_NODELAY, + (void *) optval, &optlen); break; case TCP_MAXSEG: - func_str = "vppcom_session_attr[SOL_TCP,SET_TCP_USER_MSS]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_TCP_USER_MSS, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_USER_MSS, + (void *) optval, &optlen); break; case TCP_KEEPIDLE: - func_str = "vppcom_session_attr[SOL_TCP,SET_TCP_KEEPIDLE]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_TCP_KEEPIDLE, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_KEEPIDLE, + (void *) optval, &optlen); break; case TCP_KEEPINTVL: - func_str = "vppcom_session_attr[SOL_TCP,SET_TCP_KEEPINTVL]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), SOL_TCP", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_TCP_KEEPINTVL, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_TCP_KEEPINTVL, + (void *) optval, &optlen); + break; + case TCP_CONGESTION: + case TCP_CORK: + /* Ignore */ + rv = 0; break; default: - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): " - "sid %u (0x%x), SOL_TCP, " - "optname %d unsupported!", - getpid (), fd, fd, func_str, sid, sid, optname); + LDBG (0, "ERROR: fd %d: setsockopt() SOL_TCP: vlsh %u" + "optname %d unsupported!", fd, vlsh, optname); break; } break; @@ -2616,20 +2033,12 @@ setsockopt (int fd, int level, int optname, switch (optname) { case IPV6_V6ONLY: - func_str = "vppcom_session_attr[SOL_IPV6,SET_V6ONLY]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_V6ONLY, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_V6ONLY, + (void *) optval, &optlen); break; default: - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): " - "sid %u (0x%x), SOL_IPV6, " - "optname %d unsupported!", - getpid (), fd, fd, func_str, sid, sid, optname); + LDBG (0, "ERROR: fd %d: setsockopt SOL_IPV6: vlsh %u" + "optname %d unsupported!", fd, vlsh, optname); break; } break; @@ -2637,38 +2046,20 @@ setsockopt (int fd, int level, int optname, switch (optname) { case SO_KEEPALIVE: - func_str = "vppcom_session_attr[SOL_SOCKET,SET_KEEPALIVE]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_KEEPALIVE, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_KEEPALIVE, + (void *) optval, &optlen); break; case SO_REUSEADDR: - func_str = "vppcom_session_attr[SOL_SOCKET,SET_REUSEADDR]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_REUSEADDR, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_REUSEADDR, + (void *) optval, &optlen); break; case SO_BROADCAST: - func_str = "vppcom_session_attr[SOL_SOCKET,SET_BROADCAST]"; - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); - rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_BROADCAST, - (void *) optval, &optlen); + rv = vls_attr (vlsh, VPPCOM_ATTR_SET_BROADCAST, + (void *) optval, &optlen); break; default: - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s(): " - "sid %u (0x%x), SOL_SOCKET, " - "optname %d unsupported!", - getpid (), fd, fd, func_str, sid, sid, optname); + LDBG (0, "ERROR: fd %d: setsockopt SOL_SOCKET: vlsh %u " + "optname %d unsupported!", fd, vlsh, optname); break; } break; @@ -2684,50 +2075,27 @@ setsockopt (int fd, int level, int optname, } else { - func_str = "libc_setsockopt"; - - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): level %d, " - "optname %d, optval %p, optlen %d", - getpid (), fd, fd, func_str, level, optname, - optval, optlen); - rv = libc_setsockopt (fd, level, optname, optval, optlen); } - if (LDP_DEBUG > 1) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } return rv; } int listen (int fd, int n) { + vls_handle_t vlsh; int rv; - u32 sid = ldp_sh_from_fd (fd); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - LDBG (0, "fd %d (0x%x): calling vppcom_session_listen():" - " sid %u (0x%x), n %d", fd, fd, sid, sid, n); + LDBG (0, "fd %d: calling vls_listen: vlsh %u, n %d", fd, vlsh, n); - rv = vppcom_session_listen (sid, n); + rv = vls_listen (vlsh, n); if (rv != VPPCOM_OK) { errno = -rv; @@ -2736,12 +2104,11 @@ listen (int fd, int n) } else { - LDBG (0, "fd %d (0x%x): calling libc_listen(): n %d", fd, fd, n); - + LDBG (0, "fd %d: calling libc_listen(): n %d", fd, n); rv = libc_listen (fd, n); } - LDBG (1, "fd %d (0x%x): returning %d (0x%x)", fd, fd, rv, rv); + LDBG (1, "fd %d: returning %d", fd, rv); return rv; } @@ -2749,29 +2116,27 @@ 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; int rv; - u32 listen_sh; - int accept_sh; if ((errno = -ldp_init ())) return -1; - listen_sh = ldp_sh_from_fd (listen_fd); - if (listen_sh != INVALID_SESSION_ID) + listen_vlsh = ldp_fd_to_vlsh (listen_fd); + if (listen_vlsh != VLS_INVALID_HANDLE) { vppcom_endpt_t ep; u8 src_addr[sizeof (struct sockaddr_in6)]; memset (&ep, 0, sizeof (ep)); ep.ip = src_addr; - LDBG (0, "listen fd %d (0x%x): calling vppcom_session_accept:" - " listen sid %u (0x%x), ep %p, flags 0x%x", listen_fd, - listen_fd, listen_sh, listen_sh, ep, flags); + LDBG (0, "listen fd %d: calling vppcom_session_accept: listen sid %u," + " ep %p, flags 0x%x", listen_fd, listen_vlsh, &ep, flags); - accept_sh = vppcom_session_accept (listen_sh, &ep, flags); - if (accept_sh < 0) + accept_vlsh = vls_accept (listen_vlsh, &ep, flags); + if (accept_vlsh < 0) { - errno = -accept_sh; + errno = -accept_vlsh; rv = -1; } else @@ -2779,33 +2144,25 @@ ldp_accept4 (int listen_fd, __SOCKADDR_ARG addr, rv = ldp_copy_ep_to_sockaddr (addr, addr_len, &ep); if (rv != VPPCOM_OK) { - (void) vppcom_session_close ((u32) accept_sh); + (void) vls_close (accept_vlsh); errno = -rv; rv = -1; } else { - rv = ldp_fd_alloc ((u32) accept_sh); - if (rv < 0) - { - (void) vppcom_session_close ((u32) accept_sh); - errno = -rv; - rv = -1; - } + rv = ldp_vlsh_to_fd (accept_vlsh); } } } else { - LDBG (0, "listen fd %d (0x%x): calling libc_accept4(): " - "addr %p, addr_len %p, flags 0x%x", listen_fd, - listen_fd, addr, addr_len, flags); + LDBG (0, "listen fd %d: calling libc_accept4(): addr %p, addr_len %p," + " flags 0x%x", listen_fd, addr, addr_len, flags); rv = libc_accept4 (listen_fd, addr, addr_len, flags); } - LDBG (1, "listen fd %d (0x%x): returning %d (0x%x)", listen_fd, listen_fd, - rv, rv); + LDBG (1, "listen fd %d: accept returning %d", listen_fd, rv); return rv; } @@ -2826,39 +2183,36 @@ accept (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) int shutdown (int fd, int how) { - int rv = 0; + vls_handle_t vlsh; + int rv = 0, flags; + u32 flags_len = sizeof (flags); if ((errno = -ldp_init ())) return -1; - if (ldp_fd_is_sh (fd)) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - u32 fd_index = fd - ldp->sh_bit_val; - ldp_fd_entry_t *fde; + LDBG (0, "called shutdown: fd %u vlsh %u how %d", fd, vlsh, how); - fde = ldp_fd_entry_lock (fd_index); - if (!fde) + if (vls_attr (vlsh, VPPCOM_ATTR_SET_SHUT, &how, &flags_len)) { - errno = ENOTCONN; + close (fd); return -1; } - if (how == SHUT_RD) - fde->flags |= LDP_F_SHUT_RD; - else if (how == SHUT_WR) - fde->flags |= LDP_F_SHUT_WR; - else if (how == SHUT_RDWR) - fde->flags |= (LDP_F_SHUT_RD | LDP_F_SHUT_WR); + if (vls_attr (vlsh, VPPCOM_ATTR_GET_SHUT, &flags, &flags_len)) + { + close (fd); + return -1; + } - if ((fde->flags & LDP_F_SHUT_RD) && (fde->flags & LDP_F_SHUT_WR)) + if (flags == SHUT_RDWR) rv = close (fd); - - ldp_fd_entry_unlock (fde); - LDBG (0, "fd %d (0x%x): calling vcl shutdown: how %d", fd, fd, how); } else { - LDBG (1, "fd %d (0x%x): calling libc_shutdown: how %d", fd, fd, how); + LDBG (0, "fd %d: calling libc_shutdown: how %d", fd, how); rv = libc_shutdown (fd, how); } @@ -2869,48 +2223,38 @@ int epoll_create1 (int flags) { ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); - const char *func_str; + vls_handle_t vlsh; int rv; if ((errno = -ldp_init ())) return -1; - if (ldp->vcl_needs_real_epoll) + if (ldp->vcl_needs_real_epoll || vls_use_real_epoll ()) { + /* Make sure workers have been allocated */ + if (!ldp->workers) + { + ldp_alloc_workers (); + ldpw = ldp_worker_get_current (); + } rv = libc_epoll_create1 (flags); ldp->vcl_needs_real_epoll = 0; ldpw->vcl_mq_epfd = rv; LDBG (0, "created vcl epfd %u", rv); return rv; } - func_str = "vppcom_epoll_create"; - - LDBG (1, "calling %s()", func_str); - rv = vppcom_epoll_create (); - - if (PREDICT_FALSE (rv < 0)) + vlsh = vls_epoll_create (); + if (PREDICT_FALSE (vlsh == VLS_INVALID_HANDLE)) { - errno = -rv; + errno = -vlsh; rv = -1; } else - rv = ldp_fd_alloc ((u32) rv); - - if (LDP_DEBUG > 1) { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: %s() failed! " - "rv %d, errno = %d", - getpid (), func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: returning epfd %d (0x%x)", getpid (), rv, rv); + rv = ldp_vlsh_to_fd (vlsh); } + LDBG (0, "epoll_create epfd %u vlsh %u", rv, vlsh); return rv; } @@ -2923,43 +2267,38 @@ epoll_create (int size) int epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) { - u32 vep_idx = ldp_sh_from_fd (epfd), sid; - const char *func_str; + vls_handle_t vep_vlsh, vlsh; int rv; if ((errno = -ldp_init ())) return -1; - if (PREDICT_FALSE (vep_idx == INVALID_SESSION_ID)) + vep_vlsh = ldp_fd_to_vlsh (epfd); + if (PREDICT_FALSE (vep_vlsh == VLS_INVALID_HANDLE)) { /* The LDP epoll_create1 always creates VCL epfd's. * The app should never have a kernel base epoll fd unless it * was acquired outside of the LD_PRELOAD process context. * In any case, if we get one, punt it to libc_epoll_ctl. */ - func_str = "libc_epoll_ctl"; - - LDBG (1, "epfd %d (0x%x): calling %s(): op %d, fd %d (0x%x)," - " event %p", epfd, epfd, func_str, op, fd, fd, event); + LDBG (1, "epfd %d: calling libc_epoll_ctl: op %d, fd %d" + " event %p", epfd, op, fd, event); rv = libc_epoll_ctl (epfd, op, fd, event); goto done; } - sid = ldp_sh_from_fd (fd); + vlsh = ldp_fd_to_vlsh (fd); - LDBG (0, "epfd %d (0x%x), vep_idx %d (0x%x), sid %d (0x%x)", - epfd, epfd, vep_idx, vep_idx, sid, sid); + LDBG (0, "epfd %d ep_vlsh %d, fd %u vlsh %d, op %u", epfd, vep_vlsh, fd, + vlsh, op); - if (sid != INVALID_SESSION_ID) + if (vlsh != VLS_INVALID_HANDLE) { - func_str = "vppcom_epoll_ctl"; + LDBG (1, "epfd %d: calling vls_epoll_ctl: ep_vlsh %d op %d, vlsh %u," + " event %p", epfd, vep_vlsh, op, vlsh, event); - LDBG (1, "epfd %d (0x%x): calling %s(): vep_idx %d (0x%x)," - " op %d, sid %u (0x%x), event %p", epfd, epfd, - func_str, vep_idx, vep_idx, sid, sid, event); - - rv = vppcom_epoll_ctl (vep_idx, op, sid, event); + rv = vls_epoll_ctl (vep_vlsh, op, vlsh, event); if (rv != VPPCOM_OK) { errno = -rv; @@ -2971,20 +2310,11 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) int libc_epfd; u32 size = sizeof (epfd); - func_str = "vppcom_session_attr[GET_LIBC_EPFD]"; - libc_epfd = vppcom_session_attr (vep_idx, VPPCOM_ATTR_GET_LIBC_EPFD, 0, - 0); - LDBG (1, "epfd %d (0x%x), vep_idx %d (0x%x): %s() " - "returned libc_epfd %d (0x%x)", epfd, epfd, - vep_idx, vep_idx, func_str, libc_epfd, libc_epfd); - + libc_epfd = vls_attr (vep_vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); if (!libc_epfd) { - func_str = "libc_epoll_create1"; - - LDBG (1, "epfd %d (0x%x), vep_idx %d (0x%x): " - "calling %s(): EPOLL_CLOEXEC", epfd, epfd, - vep_idx, vep_idx, func_str); + LDBG (1, "epfd %d, vep_vlsh %d calling libc_epoll_create1: " + "EPOLL_CLOEXEC", epfd, vep_vlsh); libc_epfd = libc_epoll_create1 (EPOLL_CLOEXEC); if (libc_epfd < 0) @@ -2993,14 +2323,8 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) goto done; } - func_str = "vppcom_session_attr[SET_LIBC_EPFD]"; - LDBG (1, "epfd %d (0x%x): calling %s(): vep_idx %d (0x%x)," - " VPPCOM_ATTR_SET_LIBC_EPFD, libc_epfd %d (0x%x), size %d", - epfd, epfd, func_str, vep_idx, vep_idx, libc_epfd, - libc_epfd, size); - - rv = vppcom_session_attr (vep_idx, VPPCOM_ATTR_SET_LIBC_EPFD, - &libc_epfd, &size); + rv = vls_attr (vep_vlsh, VPPCOM_ATTR_SET_LIBC_EPFD, &libc_epfd, + &size); if (rv < 0) { errno = -rv; @@ -3015,31 +2339,13 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) goto done; } - func_str = "libc_epoll_ctl"; - - LDBG (1, "epfd %d (0x%x): calling %s(): libc_epfd %d (0x%x), " - "op %d, fd %d (0x%x), event %p", epfd, epfd, func_str, - libc_epfd, libc_epfd, op, fd, fd, event); + LDBG (1, "epfd %d: calling libc_epoll_ctl: libc_epfd %d, op %d, fd %d," + " event %p", epfd, libc_epfd, op, fd, event); rv = libc_epoll_ctl (libc_epfd, op, fd, event); } done: - if (LDP_DEBUG > 1) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), fd, fd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: fd %d (0x%x): returning %d (0x%x)", - getpid (), fd, fd, rv, rv); - } return rv; } @@ -3048,9 +2354,9 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, int timeout, const sigset_t * sigmask) { ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); - double time_to_wait = (double) 0, time_out, now = 0; - u32 vep_idx = ldp_sh_from_fd (epfd); + double time_to_wait = (double) 0, max_time; int libc_epfd, rv = 0; + vls_handle_t ep_vlsh; if ((errno = -ldp_init ())) return -1; @@ -3064,18 +2370,20 @@ 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); - if (PREDICT_FALSE (vep_idx == INVALID_SESSION_ID)) + ep_vlsh = ldp_fd_to_vlsh (epfd); + if (PREDICT_FALSE (ep_vlsh == VLS_INVALID_HANDLE)) { - LDBG (0, "epfd %d (0x%x): bad vep_idx %d (0x%x)!", epfd, epfd, vep_idx, - vep_idx); + LDBG (0, "epfd %d: bad ep_vlsh %d!", epfd, ep_vlsh); errno = EBADFD; return -1; } + if (PREDICT_FALSE (ldpw->clib_time.init_cpu_time == 0)) + clib_time_init (&ldpw->clib_time); time_to_wait = ((timeout >= 0) ? (double) timeout / 1000 : 0); - time_out = clib_time_now (&ldpw->clib_time) + time_to_wait; + max_time = clib_time_now (&ldpw->clib_time) + time_to_wait; - libc_epfd = vppcom_session_attr (vep_idx, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + libc_epfd = vls_attr (ep_vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); if (PREDICT_FALSE (libc_epfd < 0)) { errno = -libc_epfd; @@ -3083,19 +2391,14 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, goto done; } - LDBG (2, "epfd %d (0x%x): vep_idx %d (0x%x), libc_epfd %d (0x%x), " - "events %p, maxevents %d, timeout %d, sigmask %p: time_to_wait %.02f", - epfd, epfd, vep_idx, vep_idx, libc_epfd, libc_epfd, events, - maxevents, timeout, sigmask, time_to_wait, time_out); + 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, + libc_epfd, events, maxevents, timeout, sigmask, time_to_wait); do { if (!ldpw->epoll_wait_vcl) { - LDBG (3, "epfd %d (0x%x): calling vcl_epoll_wait: vep_idx %d (0x%x)" - " events %p, maxevents %d", epfd, epfd, vep_idx, vep_idx, - events, maxevents); - - rv = vppcom_epoll_wait (vep_idx, events, maxevents, 0); + rv = vls_epoll_wait (ep_vlsh, events, maxevents, 0); if (rv > 0) { ldpw->epoll_wait_vcl = 1; @@ -3113,19 +2416,126 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, if (libc_epfd > 0) { - LDBG (3, "epfd %d (0x%x): calling libc_epoll_wait: libc_epfd %d " - "(0x%x), events %p, maxevents %d, sigmask %p", epfd, epfd, - libc_epfd, libc_epfd, events, maxevents, sigmask); - rv = libc_epoll_pwait (libc_epfd, events, maxevents, 0, sigmask); if (rv != 0) goto done; } + } + while ((timeout == -1) || (clib_time_now (&ldpw->clib_time) < max_time)); + +done: + return rv; +} + +static inline int +ldp_epoll_pwait_eventfd (int epfd, struct epoll_event *events, + int maxevents, int timeout, const sigset_t * sigmask) +{ + ldp_worker_ctx_t *ldpw; + int libc_epfd, rv = 0, num_ev; + vls_handle_t ep_vlsh; + + if ((errno = -ldp_init ())) + return -1; + + if (PREDICT_FALSE (!events || (timeout < -1))) + { + errno = EFAULT; + return -1; + } + + /* Make sure the vcl worker is valid. Could be that epoll fd was created on + * one thread but it is now used on another */ + if (PREDICT_FALSE (vppcom_worker_index () == ~0)) + vls_register_vcl_worker (); + + ldpw = ldp_worker_get_current (); + 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)) + { + LDBG (0, "epfd %d: bad ep_vlsh %d!", epfd, ep_vlsh); + errno = EBADFD; + return -1; + } + + libc_epfd = vls_attr (ep_vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + if (PREDICT_FALSE (!libc_epfd)) + { + u32 size = sizeof (epfd); + + LDBG (1, "epfd %d, vep_vlsh %d calling libc_epoll_create1: " + "EPOLL_CLOEXEC", epfd, ep_vlsh); + libc_epfd = libc_epoll_create1 (EPOLL_CLOEXEC); + if (libc_epfd < 0) + { + rv = libc_epfd; + goto done; + } + + rv = vls_attr (ep_vlsh, VPPCOM_ATTR_SET_LIBC_EPFD, &libc_epfd, &size); + if (rv < 0) + { + errno = -rv; + rv = -1; + goto done; + } + } + if (PREDICT_FALSE (libc_epfd <= 0)) + { + errno = -libc_epfd; + rv = -1; + goto done; + } + + if (PREDICT_FALSE (!ldpw->mq_epfd_added)) + { + struct epoll_event e = { 0 }; + e.events = EPOLLIN; + e.data.fd = ldpw->vcl_mq_epfd; + if (libc_epoll_ctl (libc_epfd, EPOLL_CTL_ADD, ldpw->vcl_mq_epfd, &e) < + 0) + { + LDBG (0, "epfd %d, add libc mq epoll fd %d to libc epoll fd %d", + epfd, ldpw->vcl_mq_epfd, libc_epfd); + rv = -1; + goto done; + } + ldpw->mq_epfd_added = 1; + } + + rv = vls_epoll_wait (ep_vlsh, events, maxevents, 0); + if (rv > 0) + goto done; + else if (PREDICT_FALSE (rv < 0)) + { + errno = -rv; + rv = -1; + goto done; + } - if (timeout != -1) - now = clib_time_now (&ldpw->clib_time); + rv = libc_epoll_pwait (libc_epfd, events, maxevents, timeout, sigmask); + if (rv <= 0) + goto done; + for (int i = 0; i < rv; i++) + { + if (events[i].data.fd == ldpw->vcl_mq_epfd) + { + /* We should remove mq epoll fd from events. */ + rv--; + if (i != rv) + { + events[i].events = events[rv].events; + events[i].data.u64 = events[rv].data.u64; + } + num_ev = vls_epoll_wait (ep_vlsh, &events[rv], maxevents - rv, 0); + if (PREDICT_TRUE (num_ev > 0)) + rv += num_ev; + break; + } } - while (now < time_out); done: return rv; @@ -3135,47 +2545,51 @@ int epoll_pwait (int epfd, struct epoll_event *events, int maxevents, int timeout, const sigset_t * sigmask) { - return ldp_epoll_pwait (epfd, events, maxevents, timeout, sigmask); + if (vls_use_eventfd ()) + return ldp_epoll_pwait_eventfd (epfd, events, maxevents, timeout, + sigmask); + else + return ldp_epoll_pwait (epfd, events, maxevents, timeout, sigmask); } int epoll_wait (int epfd, struct epoll_event *events, int maxevents, int timeout) { - return ldp_epoll_pwait (epfd, events, maxevents, timeout, NULL); + if (vls_use_eventfd ()) + return ldp_epoll_pwait_eventfd (epfd, events, maxevents, timeout, NULL); + else + return ldp_epoll_pwait (epfd, events, maxevents, timeout, NULL); } int poll (struct pollfd *fds, nfds_t nfds, int timeout) { ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); - const char *func_str = __func__; int rv, i, n_revents = 0; - u32 sid; + vls_handle_t vlsh; vcl_poll_t *vp; - double wait_for_time; + double max_time; - LDBG (3, "fds %p, nfds %d, timeout %d", fds, nfds, timeout); + LDBG (3, "fds %p, nfds %ld, timeout %d", fds, nfds, timeout); - if (timeout >= 0) - wait_for_time = (f64) timeout / 1000; - else - wait_for_time = -1; + if (PREDICT_FALSE (ldpw->clib_time.init_cpu_time == 0)) + clib_time_init (&ldpw->clib_time); + + max_time = (timeout >= 0) ? (f64) timeout / 1000 : 0; + max_time += clib_time_now (&ldpw->clib_time); for (i = 0; i < nfds; i++) { if (fds[i].fd < 0) continue; - LDBG (3, "fds[%d] fd %d (0x%0x) events = 0x%x revents = 0x%x", - i, fds[i].fd, fds[i].fd, fds[i].events, fds[i].revents); - - sid = ldp_sh_from_fd (fds[i].fd); - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fds[i].fd); + if (vlsh != VLS_INVALID_HANDLE) { fds[i].fd = -fds[i].fd; vec_add2 (ldpw->vcl_poll, vp, 1); vp->fds_ndx = i; - vp->sid = sid; + vp->sh = vlsh_to_sh (vlsh); vp->events = fds[i].events; #ifdef __USE_XOPEN2K if (fds[i].events & POLLRDNORM) @@ -3196,13 +2610,6 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) { if (vec_len (ldpw->vcl_poll)) { - func_str = "vppcom_poll"; - - LDBG (3, "calling %s(): vcl_poll %p, n_sids %u (0x%x): " - "n_libc_fds %u", func_str, ldpw->vcl_poll, - vec_len (ldpw->vcl_poll), vec_len (ldpw->vcl_poll), - vec_len (ldpw->libc_poll)); - rv = vppcom_poll (ldpw->vcl_poll, vec_len (ldpw->vcl_poll), 0); if (rv < 0) { @@ -3216,11 +2623,6 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) if (vec_len (ldpw->libc_poll)) { - func_str = "libc_poll"; - - LDBG (3, "calling %s(): fds %p, nfds %u: n_sids %u", - fds, nfds, vec_len (ldpw->vcl_poll)); - rv = libc_poll (ldpw->libc_poll, vec_len (ldpw->libc_poll), 0); if (rv < 0) goto done; @@ -3234,8 +2636,7 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) goto done; } } - while ((wait_for_time == -1) || - (clib_time_now (&ldpw->clib_time) < wait_for_time)); + while ((timeout < 0) || (clib_time_now (&ldpw->clib_time) < max_time)); rv = 0; done: @@ -3261,37 +2662,6 @@ done: vec_reset_length (ldpw->libc_poll_idxs); vec_reset_length (ldpw->libc_poll); - if (LDP_DEBUG > 3) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: %s() failed! " - "rv %d, errno = %d", getpid (), - func_str, rv, errno_val); - errno = errno_val; - } - else - { - clib_warning ("LDP<%d>: returning %d (0x%x): n_sids %u, " - "n_libc_fds %d", getpid (), rv, rv, - vec_len (ldpw->vcl_poll), vec_len (ldpw->libc_poll)); - - for (i = 0; i < nfds; i++) - { - if (fds[i].fd >= 0) - { - if (LDP_DEBUG > 3) - clib_warning ("LDP<%d>: fds[%d].fd %d (0x%0x), " - ".events = 0x%x, .revents = 0x%x", - getpid (), i, fds[i].fd, fds[i].fd, - fds[i].events, fds[i].revents); - } - } - } - } - return rv; } @@ -3323,8 +2693,11 @@ ldp_constructor (void) { swrap_constructor (); if (ldp_init () != 0) - fprintf (stderr, "\nLDP<%d>: ERROR: ldp_constructor: failed!\n", - getpid ()); + { + fprintf (stderr, "\nLDP<%d>: ERROR: ldp_constructor: failed!\n", + getpid ()); + _exit (1); + } else if (LDP_DEBUG > 0) clib_warning ("LDP<%d>: LDP constructor: done!\n", getpid ()); } @@ -3335,16 +2708,18 @@ ldp_constructor (void) void ldp_destructor (void) { - swrap_destructor (); - if (ldp->init) - ldp->init = 0; + /* + swrap_destructor (); + if (ldp->init) + ldp->init = 0; + */ /* Don't use clib_warning() here because that calls writev() * which will call ldp_init(). */ if (LDP_DEBUG > 0) - printf ("%s:%d: LDP<%d>: LDP destructor: done!\n", - __func__, __LINE__, getpid ()); + fprintf (stderr, "%s:%d: LDP<%d>: LDP destructor: done!\n", + __func__, __LINE__, getpid ()); }