X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvcl%2Fldp.c;h=c23f995d5674edfcd01e5024b9e3811b01f3fbb4;hb=cbce80aaa3f1853856d4d64c95f10d65caa4d786;hp=beaa988185d8d9021c4e87c97543a4f86f3afa5a;hpb=173bae3d178d96cd14e0cc1b191a575c4aaff299;p=vpp.git diff --git a/src/vcl/ldp.c b/src/vcl/ldp.c index beaa988185d..c23f995d567 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,9 +26,12 @@ #include #include -#include +#include #include #include +#include +#include +#include #define HAVE_CONSTRUCTOR_ATTRIBUTE #ifdef HAVE_CONSTRUCTOR_ATTRIBUTE @@ -46,59 +49,95 @@ #define DESTRUCTOR_ATTRIBUTE #endif -typedef struct +#define LDP_MAX_NWORKERS 32 + +typedef struct ldp_worker_ctx_ { - int init; - char app_name[LDP_APP_NAME_MAX]; - u32 sid_bit_val; - u32 sid_bit_mask; - u32 debug; u8 *io_buffer; clib_time_t clib_time; + + /* + * Select state + */ 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; + + /* + * Poll state + */ vcl_poll_t *vcl_poll; struct pollfd *libc_poll; u16 *libc_poll_idxs; - u8 select_vcl; + + /* + * Epoll state + */ u8 epoll_wait_vcl; - u8 vcl_needs_real_epoll; /*< vcl needs next epoll_create to - go to libc_epoll */ 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 vlsh_bit_val; + u32 vlsh_bit_mask; + u32 debug; + u8 transparent_tls; + + /** vcl needs next epoll_create to go to libc_epoll */ + u8 vcl_needs_real_epoll; } ldp_main_t; + #define LDP_DEBUG ldp->debug #define LDBG(_lvl, _fmt, _args...) \ if (ldp->debug > _lvl) \ - clib_warning (_fmt, ##_args) + { \ + int errno_saved = errno; \ + clib_warning ("ldp<%d>: " _fmt, getpid(), ##_args); \ + errno = errno_saved; \ + } static ldp_main_t ldp_main = { - .sid_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, }; static ldp_main_t *ldp = &ldp_main; +static inline ldp_worker_ctx_t * +ldp_worker_get_current (void) +{ + return (ldp->workers + vppcom_worker_index ()); +} + /* * RETURN: 0 on success or -1 on error. * */ 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 * @@ -111,30 +150,32 @@ ldp_get_app_name () } static inline int -ldp_fd_from_sid (u32 sid) +ldp_vlsh_to_fd (vls_handle_t vlsh) { - if (PREDICT_FALSE (sid >= ldp->sid_bit_val)) - return -EMFILE; - else - return (sid | ldp->sid_bit_val); + return (vlsh + ldp->vlsh_bit_val); } -static inline int -ldp_fd_is_sid (int fd) +static inline vls_handle_t +ldp_fd_to_vlsh (int fd) { - return ((u32) fd & ldp->sid_bit_val) ? 1 : 0; + if (fd < ldp->vlsh_bit_val) + return VLS_INVALID_HANDLE; + + return (fd - ldp->vlsh_bit_val); } -static inline u32 -ldp_sid_from_fd (int fd) +static void +ldp_alloc_workers (void) { - return (ldp_fd_is_sid (fd) ? ((u32) fd & ldp->sid_bit_mask) : - INVALID_SESSION_ID); + if (ldp->workers) + return; + pool_alloc (ldp->workers, LDP_MAX_NWORKERS); } static inline int ldp_init (void) { + ldp_worker_ctx_t *ldpw; int rv; if (PREDICT_TRUE (ldp->init)) @@ -142,16 +183,20 @@ 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) { - fprintf (stderr, "\nLDP<%d>: ERROR: ldp_init: vppcom_app_create()" - " failed! rv = %d (%s)\n", - getpid (), rv, vppcom_retval_str (rv)); + ldp->vcl_needs_real_epoll = 0; + if (rv == VPPCOM_EEXIST) + return 0; + LDBG (2, "\nERROR: ldp_init: vppcom_app_create()" + " failed! rv = %d (%s)\n", rv, vppcom_retval_str (rv)); ldp->init = 0; return rv; } ldp->vcl_needs_real_epoll = 0; + ldp_alloc_workers (); + ldpw = ldp_worker_get_current (); char *env_var_str = getenv (LDP_ENV_DEBUG); if (env_var_str) @@ -164,8 +209,8 @@ ldp_init (void) else { ldp->debug = tmp; - LDBG (0, "LDP<%d>: configured LDP debug level (%u) from env var " - LDP_ENV_DEBUG "!", getpid (), ldp->debug); + LDBG (0, "configured LDP debug level (%u) from env var " + LDP_ENV_DEBUG "!", ldp->debug); } } @@ -173,8 +218,8 @@ ldp_init (void) if (env_var_str) { ldp_set_app_name (env_var_str); - LDBG (0, "LDP<%d>: configured LDP app name (%s) from the env var " - LDP_ENV_APP_NAME "!", getpid (), ldp->app_name); + LDBG (0, "configured LDP app name (%s) from the env var " + LDP_ENV_APP_NAME "!", ldp->app_name); } env_var_str = getenv (LDP_ENV_SID_BIT); @@ -183,46 +228,62 @@ 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->sid_bit_val, ldp->sid_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->sid_bit_val = (1 << LDP_SID_BIT_MIN); - ldp->sid_bit_mask = ldp->sid_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->sid_bit_val, ldp->sid_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->sid_bit_val = (1 << LDP_SID_BIT_MAX); - ldp->sid_bit_mask = ldp->sid_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->sid_bit_val, ldp->sid_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->sid_bit_val = (1 << sb); - ldp->sid_bit_mask = ldp->sid_bit_val - 1; + ldp->vlsh_bit_val = (1 << sb); + ldp->vlsh_bit_mask = ldp->vlsh_bit_val - 1; - LDBG (0, "LDP<%d>: configured LDP sid bit (%u) from " - LDP_ENV_SID_BIT "! sid bit value %d (0x%x)", getpid (), sb, - ldp->sid_bit_val, ldp->sid_bit_val); + LDBG (0, "configured LDP sid bit (%u) from " + LDP_ENV_SID_BIT "! sid bit value %d (0x%x)", sb, + ldp->vlsh_bit_val, ldp->vlsh_bit_val); + } + + /* 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; + } + + /* *INDENT-OFF* */ + pool_foreach (ldpw, ldp->workers, ({ + clib_memset (&ldpw->clib_time, 0, sizeof (ldpw->clib_time)); + })); + /* *INDENT-ON* */ - clib_time_init (&ldp->clib_time); - LDBG (0, "LDP<%d>: LDP initialization: done!", getpid ()); + LDBG (0, "LDP initialization: done!"); return 0; } @@ -230,25 +291,19 @@ ldp_init (void) int close (int fd) { - int rv; - const char *func_str; - u32 sid = ldp_sid_from_fd (fd); + vls_handle_t vlsh; + int rv, epfd; if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - int epfd; - - func_str = "vppcom_session_attr[GET_LIBC_EPFD]"; - epfd = vppcom_session_attr (sid, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); + epfd = vls_attr (vlsh, VPPCOM_ATTR_GET_LIBC_EPFD, 0, 0); if (epfd > 0) { - func_str = "libc_close"; - - LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s(): epfd %u (0x%x)", - getpid (), fd, fd, func_str, epfd, epfd); + LDBG (0, "fd %d: calling libc_close: epfd %u", fd, epfd); rv = libc_close (epfd); if (rv < 0) @@ -256,8 +311,7 @@ close (int fd) u32 size = sizeof (epfd); epfd = 0; - (void) vppcom_session_attr (sid, VPPCOM_ATTR_SET_LIBC_EPFD, - &epfd, &size); + (void) vls_attr (vlsh, VPPCOM_ATTR_SET_LIBC_EPFD, &epfd, &size); } } else if (PREDICT_FALSE (epfd < 0)) @@ -267,12 +321,9 @@ close (int fd) goto done; } - func_str = "vppcom_session_close"; - - LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x)", - getpid (), fd, fd, func_str, sid, sid); + LDBG (0, "fd %d: calling vls_close: vlsh %u", fd, vlsh); - rv = vppcom_session_close (sid); + rv = vls_close (vlsh); if (rv != VPPCOM_OK) { errno = -rv; @@ -281,53 +332,27 @@ close (int fd) } else { - func_str = "libc_close"; - - LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s()", getpid (), fd, fd, - func_str); - + LDBG (0, "fd %d: calling libc_close", fd); rv = libc_close (fd); } done: - if (LDP_DEBUG > 0) - { - 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 read (int fd, void *buf, size_t nbytes) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sid_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) { - func_str = "vppcom_session_read"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "sid %u (0x%x), buf %p, nbytes %u", getpid (), - fd, fd, func_str, sid, sid, buf, nbytes); - - size = vppcom_session_read (sid, buf, nbytes); + size = vls_read (vlsh, buf, nbytes); if (size < 0) { errno = -size; @@ -336,79 +361,38 @@ read (int fd, void *buf, size_t nbytes) } else { - func_str = "libc_read"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "buf %p, nbytes %u", getpid (), - fd, fd, func_str, buf, nbytes); - size = libc_read (fd, buf, nbytes); } - 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; } ssize_t readv (int fd, const struct iovec * iov, int iovcnt) { - const char *func_str; - ssize_t size = 0; - u32 sid = ldp_sid_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) { - func_str = "vppcom_session_read"; - 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 { - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s() [%d]: " - "sid %u (0x%x), iov %p, iovcnt %d, total %d", - getpid (), fd, fd, func_str, 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) - { - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): " - "rv (%d) < iov[%d].iov_len (%d)", - getpid (), 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; @@ -418,53 +402,25 @@ readv (int fd, const struct iovec * iov, int iovcnt) } else { - func_str = "libc_readv"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "iov %p, iovcnt %d", getpid (), fd, fd, iov, iovcnt); - size = libc_readv (fd, iov, iovcnt); } - 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; } ssize_t write (int fd, const void *buf, size_t nbytes) { - const char *func_str; + vls_handle_t vlsh; ssize_t size = 0; - u32 sid = ldp_sid_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) { - 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", getpid (), - fd, fd, func_str, sid, sid, buf, nbytes); - - size = vppcom_session_write (sid, (void *) buf, nbytes); + size = vls_write_msg (vlsh, (void *) buf, nbytes); if (size < 0) { errno = -size; @@ -473,84 +429,39 @@ write (int fd, const void *buf, size_t nbytes) } else { - func_str = "libc_write"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "buf %p, nbytes %u", getpid (), - fd, fd, func_str, buf, nbytes); - size = libc_write (fd, buf, nbytes); } - 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; } ssize_t writev (int fd, const struct iovec * iov, int iovcnt) { - const char *func_str; ssize_t size = 0, total = 0; - u32 sid = ldp_sid_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) { - func_str = "vppcom_session_write"; - 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 { - if (LDP_DEBUG > 4) - printf ("%s:%d: LDP<%d>: fd %d (0x%x): calling %s() [%d]: " - "sid %u (0x%x), buf %p, nbytes %ld, total %ld", - __func__, __LINE__, getpid (), fd, fd, func_str, - i, sid, sid, iov[i].iov_base, iov[i].iov_len, total); - - rv = vppcom_session_write (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) - { - if (LDP_DEBUG > 4) - printf ("%s:%d: LDP<%d>: fd %d (0x%x): " - "rv (%d) < iov[%d].iov_len (%ld)", - __func__, __LINE__, getpid (), 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; @@ -560,48 +471,32 @@ writev (int fd, const struct iovec * iov, int iovcnt) } else { - func_str = "libc_writev"; - - if (LDP_DEBUG > 4) - printf ("%s:%d: LDP<%d>: fd %d (0x%x): calling %s(): " - "iov %p, iovcnt %d\n", __func__, __LINE__, getpid (), - fd, fd, func_str, iov, iovcnt); - size = libc_writev (fd, iov, iovcnt); } - if (LDP_DEBUG > 4) - { - if (size < 0) - { - int errno_val = errno; - perror (func_str); - fprintf (stderr, - "%s:%d: LDP<%d>: ERROR: fd %d (0x%x): %s() failed! " - "rv %ld, errno = %d\n", __func__, __LINE__, getpid (), fd, - fd, func_str, size, errno_val); - errno = errno_val; - } - else - printf ("%s:%d: LDP<%d>: fd %d (0x%x): returning %ld\n", - __func__, __LINE__, getpid (), fd, fd, size); - } return size; } +#ifdef HAVE_FCNTL64 +int +fcntl64 (int fd, int cmd, ...) +#else int fcntl (int fd, int cmd, ...) +#endif { - const char *func_str = __func__; + vls_handle_t vlsh; int rv = 0; va_list ap; - u32 sid = ldp_sid_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; @@ -611,30 +506,13 @@ fcntl (int fd, int cmd, ...) switch (cmd) { case F_SETFL: - func_str = "vppcom_session_attr[SET_FLAGS]"; - LDBG (2, "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; case F_GETFL: - func_str = "vppcom_session_attr[GET_FLAGS]"; - LDBG (2, "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_GET_FLAGS, &flags, - &size); + rv = vls_attr (vlsh, VPPCOM_ATTR_GET_FLAGS, &flags, &size); if (rv == VPPCOM_OK) - { - LDBG (2, "LDP<%d>: fd %d (0x%x), cmd %d (F_GETFL): %s() " - "returned flags %d (0x%x)", getpid (), fd, fd, cmd, - func_str, flags, flags); - rv = flags; - } + rv = flags; break; case F_SETFD: /* TODO handle this */ @@ -653,60 +531,37 @@ fcntl (int fd, int cmd, ...) } else { - func_str = "libc_vfcntl"; - - if (LDP_DEBUG > 2) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): cmd %d", - getpid (), fd, fd, func_str, cmd); - +#ifdef HAVE_FCNTL64 + rv = libc_vfcntl64 (fd, cmd, ap); +#else rv = libc_vfcntl (fd, cmd, ap); +#endif } 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, ...) { - const char *func_str; - int rv; + vls_handle_t vlsh; va_list ap; - u32 sid = ldp_sid_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: @@ -718,14 +573,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; @@ -741,34 +589,91 @@ 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, @@ -776,13 +681,12 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, const struct timespec *__restrict timeout, const __sigset_t * __restrict sigmask) { - int rv; - char *func_str = "##"; - f64 time_out; - int fd; - uword sid_bits, sid_bits_set, libc_bits, libc_bits_set; - u32 minbits = clib_max (nfds, BITS (uword)); - u32 sid; + u32 minbits = clib_max (nfds, BITS (uword)), n_bytes; + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); + struct timespec libc_tspec = { 0 }; + f64 time_out, vcl_timeout = 0; + uword si_bits, libc_bits; + int rv, bits_set = 0; if (nfds < 0) { @@ -790,20 +694,19 @@ 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, "LDP<%d>: sleeping for %.02f seconds", getpid (), - time_out); - - time_out += clib_time_now (&ldp->clib_time); - while (clib_time_now (&ldp->clib_time) < time_out) + time_out += clib_time_now (&ldpw->clib_time); + while (clib_time_now (&ldpw->clib_time) < time_out) ; return 0; } @@ -816,279 +719,136 @@ ldp_pselect (int nfds, fd_set * __restrict readfds, else time_out = -1; - - if (nfds <= ldp->sid_bit_val) + if (nfds <= ldp->vlsh_bit_val) { - func_str = "libc_pselect"; - - LDBG (3, "LDP<%d>: calling %s(): nfds %d, readfds %p, writefds %p, " - "exceptfds %p, timeout %p, sigmask %p", getpid (), func_str, nfds, - readfds, writefds, exceptfds, timeout, sigmask); - rv = libc_pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask); goto done; } - if (PREDICT_FALSE (ldp->sid_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->sid_bit_val, ldp->sid_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 (ldp->sid_rd_bitmap, minbits); - clib_bitmap_validate (ldp->libc_rd_bitmap, minbits); - clib_bitmap_validate (ldp->rd_bitmap, minbits); - clib_memcpy_fast (ldp->rd_bitmap, readfds, n_bytes); - memset (readfds, 0, n_bytes); - - /* *INDENT-OFF* */ - clib_bitmap_foreach (fd, ldp->rd_bitmap, ({ - if (fd > nfds) - break; - sid = ldp_sid_from_fd (fd); - LDBG (3, "LDP<%d>: readfds: fd %d (0x%x), sid %u (0x%x)", - getpid (), fd, fd, sid, sid); - if (sid == INVALID_SESSION_ID) - clib_bitmap_set_no_check (ldp->libc_rd_bitmap, fd, 1); - else - clib_bitmap_set_no_check (ldp->sid_rd_bitmap, sid, 1); - })); - /* *INDENT-ON* */ - - sid_bits_set = clib_bitmap_last_set (ldp->sid_rd_bitmap) + 1; - sid_bits = (sid_bits_set > sid_bits) ? sid_bits_set : sid_bits; - - libc_bits_set = clib_bitmap_last_set (ldp->libc_rd_bitmap) + 1; - libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits; - - LDBG (3, "LDP<%d>: readfds: sid_bits_set %d, sid_bits %d, " - "libc_bits_set %d, libc_bits %d", getpid (), 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 (ldp->sid_wr_bitmap, minbits); - clib_bitmap_validate (ldp->libc_wr_bitmap, minbits); - clib_bitmap_validate (ldp->wr_bitmap, minbits); - clib_memcpy_fast (ldp->wr_bitmap, writefds, n_bytes); - memset (writefds, 0, n_bytes); - - /* *INDENT-OFF* */ - clib_bitmap_foreach (fd, ldp->wr_bitmap, ({ - if (fd > nfds) - break; - sid = ldp_sid_from_fd (fd); - LDBG (3, "LDP<%d>: writefds: fd %d (0x%x), sid %u (0x%x)", - getpid (), fd, fd, sid, sid); - if (sid == INVALID_SESSION_ID) - clib_bitmap_set_no_check (ldp->libc_wr_bitmap, fd, 1); - else - clib_bitmap_set_no_check (ldp->sid_wr_bitmap, sid, 1); - })); - /* *INDENT-ON* */ - - sid_bits_set = clib_bitmap_last_set (ldp->sid_wr_bitmap) + 1; - sid_bits = (sid_bits_set > sid_bits) ? sid_bits_set : sid_bits; - - libc_bits_set = clib_bitmap_last_set (ldp->libc_wr_bitmap) + 1; - libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits; - - LDBG (3, "LDP<%d>: writefds: sid_bits_set %d, sid_bits %d, " - "libc_bits_set %d, libc_bits %d", getpid (), - 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 (ldp->sid_ex_bitmap, minbits); - clib_bitmap_validate (ldp->libc_ex_bitmap, minbits); - clib_bitmap_validate (ldp->ex_bitmap, minbits); - clib_memcpy_fast (ldp->ex_bitmap, exceptfds, n_bytes); - memset (exceptfds, 0, n_bytes); + ldp_select_init_maps (exceptfds, &ldpw->ex_bitmap, + &ldpw->libc_ex_bitmap, &ldpw->si_ex_bitmap, nfds, + minbits, n_bytes, &si_bits, &libc_bits); - /* *INDENT-OFF* */ - clib_bitmap_foreach (fd, ldp->ex_bitmap, ({ - if (fd > nfds) - break; - sid = ldp_sid_from_fd (fd); - LDBG (3, "LDP<%d>: exceptfds: fd %d (0x%x), sid %u (0x%x)", - getpid (), fd, fd, sid, sid); - if (sid == INVALID_SESSION_ID) - clib_bitmap_set_no_check (ldp->libc_ex_bitmap, fd, 1); - else - clib_bitmap_set_no_check (ldp->sid_ex_bitmap, sid, 1); - })); - /* *INDENT-ON* */ - - sid_bits_set = clib_bitmap_last_set (ldp->sid_ex_bitmap) + 1; - sid_bits = (sid_bits_set > sid_bits) ? sid_bits_set : sid_bits; - - libc_bits_set = clib_bitmap_last_set (ldp->libc_ex_bitmap) + 1; - libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits; - - LDBG (3, "LDP<%d>: exceptfds: sid_bits_set %d, sid_bits %d, " - "libc_bits_set %d, libc_bits %d", getpid (), - 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 (!ldp->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) { - func_str = "vppcom_select"; - - if (readfds) - clib_memcpy_fast (ldp->rd_bitmap, ldp->sid_rd_bitmap, - vec_len (ldp->rd_bitmap) * - sizeof (clib_bitmap_t)); - if (writefds) - clib_memcpy_fast (ldp->wr_bitmap, ldp->sid_wr_bitmap, - vec_len (ldp->wr_bitmap) * - sizeof (clib_bitmap_t)); - if (exceptfds) - clib_memcpy_fast (ldp->ex_bitmap, ldp->sid_ex_bitmap, - vec_len (ldp->ex_bitmap) * - sizeof (clib_bitmap_t)); - - rv = vppcom_select (sid_bits, - readfds ? ldp->rd_bitmap : NULL, - writefds ? ldp->wr_bitmap : NULL, - exceptfds ? ldp->ex_bitmap : NULL, 0); - if (rv < 0) + errno = -rv; + rv = -1; + } + else 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, ldp->rd_bitmap, - ({ - fd = ldp_fd_from_sid (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, ldp->wr_bitmap, - ({ - fd = ldp_fd_from_sid (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, ldp->ex_bitmap, - ({ - fd = ldp_fd_from_sid (sid); - if (PREDICT_FALSE (fd < 0)) - { - errno = EBADFD; - rv = -1; - goto done; - } - FD_SET (fd, exceptfds); - })); - /* *INDENT-ON* */ - } - ldp->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 - ldp->select_vcl = 0; } if (libc_bits) { - struct timespec tspec; - - func_str = "libc_pselect"; - if (readfds) - clib_memcpy_fast (readfds, ldp->libc_rd_bitmap, - vec_len (ldp->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, ldp->libc_wr_bitmap, - vec_len (ldp->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, ldp->libc_ex_bitmap, - vec_len (ldp->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 (&ldp->clib_time) < time_out)); + while ((time_out == -1) || (clib_time_now (&ldpw->clib_time) < time_out)); rv = 0; done: /* TBD: set timeout to amount of time left */ - clib_bitmap_zero (ldp->rd_bitmap); - clib_bitmap_zero (ldp->sid_rd_bitmap); - clib_bitmap_zero (ldp->libc_rd_bitmap); - clib_bitmap_zero (ldp->wr_bitmap); - clib_bitmap_zero (ldp->sid_wr_bitmap); - clib_bitmap_zero (ldp->libc_wr_bitmap); - clib_bitmap_zero (ldp->ex_bitmap); - clib_bitmap_zero (ldp->sid_ex_bitmap); - clib_bitmap_zero (ldp->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); - } + clib_bitmap_zero (ldpw->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->si_wr_bitmap); + clib_bitmap_zero (ldpw->libc_wr_bitmap); + clib_bitmap_zero (ldpw->ex_bitmap); + clib_bitmap_zero (ldpw->si_ex_bitmap); + clib_bitmap_zero (ldpw->libc_ex_bitmap); + return rv; } @@ -1120,13 +880,77 @@ pselect (int nfds, fd_set * __restrict readfds, } #endif +/* If transparent TLS mode is turned on, then ldp will load key and cert. + */ +static int +load_tls_cert (vls_handle_t vlsh) +{ + char *env_var_str = getenv (LDP_ENV_TLS_CERT); + char inbuf[4096]; + char *tls_cert; + int cert_size; + FILE *fp; + + if (env_var_str) + { + fp = fopen (env_var_str, "r"); + if (fp == NULL) + { + LDBG (0, "ERROR: failed to open cert file %s \n", env_var_str); + return -1; + } + cert_size = fread (inbuf, sizeof (char), sizeof (inbuf), fp); + tls_cert = inbuf; + vppcom_session_tls_add_cert (vlsh_to_session_index (vlsh), tls_cert, + cert_size); + fclose (fp); + } + else + { + LDBG (0, "ERROR: failed to read LDP environment %s\n", + LDP_ENV_TLS_CERT); + return -1; + } + return 0; +} + +static int +load_tls_key (vls_handle_t vlsh) +{ + char *env_var_str = getenv (LDP_ENV_TLS_KEY); + char inbuf[4096]; + char *tls_key; + int key_size; + FILE *fp; + + if (env_var_str) + { + fp = fopen (env_var_str, "r"); + if (fp == NULL) + { + LDBG (0, "ERROR: failed to open key file %s \n", env_var_str); + return -1; + } + key_size = fread (inbuf, sizeof (char), sizeof (inbuf), fp); + tls_key = inbuf; + vppcom_session_tls_add_key (vlsh_to_session_index (vlsh), tls_key, + key_size); + fclose (fp); + } + else + { + LDBG (0, "ERROR: failed to read LDP environment %s\n", LDP_ENV_TLS_KEY); + return -1; + } + return 0; +} + 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; @@ -1134,57 +958,42 @@ 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, "LDP<%d>: : calling %s(): proto %u (%s), is_nonblocking %u", - getpid (), 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_from_sid (sid); - if (rv < 0) + if (ldp->transparent_tls) { - (void) vppcom_session_close (sid); - errno = -rv; - rv = -1; + if (load_tls_cert (vlsh) < 0 || load_tls_key (vlsh) < 0) + { + return -1; + } } + rv = ldp_vlsh_to_fd (vlsh); } } else { - func_str = "libc_socket"; - - LDBG (0, "LDP<%d>: : calling %s()", getpid (), 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 ("LDP<%d>: : returning fd %d (0x%x)", getpid (), rv, rv); - } return rv; } @@ -1198,9 +1007,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; @@ -1208,62 +1015,40 @@ 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, "LDP<%d>: : calling %s()", getpid (), 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; - const char *func_str; - u32 sid = ldp_sid_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; - func_str = "vppcom_session_bind"; - switch (addr->sa_family) { 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; @@ -1276,9 +1061,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; @@ -1289,19 +1073,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; } - if (LDP_DEBUG > 0) - 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); + 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; @@ -1310,32 +1091,13 @@ bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) } else { - func_str = "libc_bind"; - - if (LDP_DEBUG > 0) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "addr %p, len %u", - getpid (), fd, fd, func_str, addr, len); - + LDBG (0, "fd %d: calling libc_bind: addr %p, len %u", fd, addr, len); rv = libc_bind (fd, addr, len); } done: - if (LDP_DEBUG > 0) - { - 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); - } + LDBG (1, "fd %d: returning %d", fd, rv); + return rv; } @@ -1388,28 +1150,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_sid_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; @@ -1427,67 +1183,41 @@ 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; - const char *func_str = __func__; - u32 sid = ldp_sid_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; - func_str = "vppcom_session_connect"; - switch (addr->sa_family) { 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; @@ -1500,9 +1230,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; @@ -1513,19 +1242,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; } - if (LDP_DEBUG > 0) - 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); + 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; @@ -1534,60 +1260,35 @@ connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len) } else { - func_str = "libc_connect"; - - if (LDP_DEBUG > 0) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): " - "addr %p, len %u", - getpid (), fd, fd, func_str, addr, len); + LDBG (0, "fd %d: calling libc_connect(): addr %p, len %u", + fd, addr, len); rv = libc_connect (fd, addr, len); } done: - if (LDP_DEBUG > 0) - { - 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); - } + 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_sid_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; @@ -1605,55 +1306,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_sid_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; @@ -1662,66 +1332,40 @@ 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; } 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_sid_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 (ldp->io_buffer); + vec_reset_length (ldpw->io_buffer); errno = -rv; size = -1; goto done; @@ -1732,14 +1376,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; } @@ -1749,76 +1385,44 @@ 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)); - vec_reset_length (ldp->io_buffer); + LDBG (0, "ERROR: fd %d: vls_attr: vlsh %u returned %d (%s)!", + out_fd, vlsh, size, vppcom_retval_str (size)); + vec_reset_length (ldpw->io_buffer); errno = -size; size = -1; goto done; } 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 continue; } bytes_to_read = clib_min (n_bytes_left, bytes_to_read); - vec_validate (ldp->io_buffer, bytes_to_read); - nbytes = libc_read (in_fd, ldp->io_buffer, bytes_to_read); + vec_validate (ldpw->io_buffer, bytes_to_read); + 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, ldp->io_buffer, bytes_to_read, nbytes, - errno_val); - errno = errno_val; - if (results == 0) { - vec_reset_length (ldp->io_buffer); + vec_reset_length (ldpw->io_buffer); size = -1; goto done; } 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, ldp->io_buffer, nbytes, - results, n_bytes_left); - - size = vppcom_session_write (sid, ldp->io_buffer, nbytes); + + size = vls_write (vlsh, ldpw->io_buffer, nbytes); if (size < 0) { if (size == VPPCOM_EAGAIN) @@ -1826,30 +1430,15 @@ 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, ldp->io_buffer, nbytes, - size, vppcom_retval_str (size)); - } if (results == 0) { - vec_reset_length (ldp->io_buffer); + vec_reset_length (ldpw->io_buffer); errno = -size; size = -1; goto done; @@ -1864,19 +1453,12 @@ sendfile (int out_fd, int in_fd, off_t * offset, size_t len) while (n_bytes_left > 0); update_offset: - vec_reset_length (ldp->io_buffer); + vec_reset_length (ldpw->io_buffer); if (offset) { 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; } @@ -1894,33 +1476,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; } @@ -1933,23 +1492,16 @@ sendfile64 (int out_fd, int in_fd, off_t * offset, size_t len) ssize_t recv (int fd, void *buf, size_t n, int flags) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sid_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) { - 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", getpid (), - fd, fd, func_str, 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; @@ -1958,31 +1510,9 @@ recv (int fd, void *buf, size_t n, int flags) } else { - func_str = "libc_recv"; - - 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_recv (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; } @@ -1990,14 +1520,14 @@ ssize_t sendto (int fd, const void *buf, size_t n, int flags, __CONST_SOCKADDR_ARG addr, socklen_t addr_len) { + vls_handle_t vlsh; ssize_t size; - const char *func_str = __func__; - u32 sid = ldp_sid_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 = 0; vppcom_endpt_t _ep; @@ -2029,51 +1559,20 @@ sendto (int fd, const void *buf, size_t n, int flags, goto done; } } - - 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, ep %p", - getpid (), fd, fd, func_str, sid, sid, buf, n, - flags, ep); - - size = vppcom_session_sendto (sid, (void *) buf, n, flags, ep); - if (size < 0) - { - errno = -size; - size = -1; - } - } - 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); - - size = libc_sendto (fd, buf, n, flags, addr, addr_len); - } - -done: - if (LDP_DEBUG > 2) - { + + size = vls_sendto (vlsh, (void *) 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; + 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_sendto (fd, buf, n, flags, addr, addr_len); + } + +done: return size; } @@ -2081,35 +1580,32 @@ ssize_t recvfrom (int fd, void *__restrict buf, size_t n, int flags, __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) { - ssize_t size; - const char *func_str; - u32 sid = ldp_sid_from_fd (fd); + vls_handle_t sid; + ssize_t size, rv; if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + sid = ldp_fd_to_vlsh (fd); + if (sid != VLS_INVALID_HANDLE) { 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); + size = vls_recvfrom (sid, buf, n, flags, &ep); if (size > 0) - size = ldp_copy_ep_to_sockaddr (addr, addr_len, &ep); + { + rv = ldp_copy_ep_to_sockaddr (addr, addr_len, &ep); + if (rv < 0) + size = rv; + } } else - size = vppcom_session_recvfrom (sid, buf, n, flags, NULL); + size = vls_recvfrom (sid, buf, n, flags, NULL); if (size < 0) { @@ -2119,80 +1615,33 @@ recvfrom (int fd, void *__restrict buf, size_t n, int flags, } else { - func_str = "libc_recvfrom"; - - 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); - size = libc_recvfrom (fd, buf, n, flags, addr, addr_len); } - 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; } ssize_t sendmsg (int fd, const struct msghdr * message, int flags) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sid_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) { - func_str = __func__; - - clib_warning ("LDP<%d>: LDP-TBD", getpid ()); + LDBG (0, "LDP-TBD"); errno = ENOSYS; size = -1; } else { - func_str = "libc_sendmsg"; - - 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); } - 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; } @@ -2202,12 +1651,12 @@ sendmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags) { ssize_t size; const char *func_str; - u32 sid = ldp_sid_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; @@ -2247,48 +1696,24 @@ sendmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags) ssize_t recvmsg (int fd, struct msghdr * message, int flags) { + vls_handle_t vlsh; ssize_t size; - const char *func_str; - u32 sid = ldp_sid_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) { - func_str = __func__; - - clib_warning ("LDP<%d>: LDP-TBD", getpid ()); + LDBG (0, "LDP-TBD"); errno = ENOSYS; size = -1; } else { - func_str = "libc_recvmsg"; - - 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_recvmsg (fd, message, 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; } @@ -2299,12 +1724,12 @@ recvmmsg (int fd, struct mmsghdr *vmessages, { ssize_t size; const char *func_str; - u32 sid = ldp_sid_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; @@ -2346,15 +1771,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_sid_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; @@ -2364,62 +1788,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; @@ -2427,20 +1829,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; @@ -2448,84 +1841,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; @@ -2541,32 +1885,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; } @@ -2574,14 +1895,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_sid_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; @@ -2591,47 +1912,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; @@ -2639,20 +1942,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; @@ -2660,38 +1955,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; @@ -2707,53 +1984,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; - const char *func_str; - u32 sid = ldp_sid_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) { - func_str = "vppcom_session_listen"; + LDBG (0, "fd %d: calling vls_listen: vlsh %u, n %d", fd, vlsh, n); - LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x), n %d", - getpid (), fd, fd, func_str, sid, sid, n); - - rv = vppcom_session_listen (sid, n); + rv = vls_listen (vlsh, n); if (rv != VPPCOM_OK) { errno = -rv; @@ -2762,29 +2013,11 @@ listen (int fd, int n) } else { - func_str = "libc_listen"; - - LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s(): n %d", getpid (), fd, - fd, func_str, n); - + LDBG (0, "fd %d: calling libc_listen(): n %d", fd, n); rv = libc_listen (fd, n); } - if (LDP_DEBUG > 0) - { - 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); - } + LDBG (1, "fd %d: returning %d", fd, rv); return rv; } @@ -2792,33 +2025,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; - const char *func_str; - u32 listen_sid = ldp_sid_from_fd (listen_fd); - int accept_sid; if ((errno = -ldp_init ())) return -1; - if (listen_sid != 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; - func_str = "vppcom_session_accept"; - - if (LDP_DEBUG > 0) - clib_warning ("LDP<%d>: listen fd %d (0x%x): calling %s(): " - "listen sid %u (0x%x), ep %p, flags 0x%x", - getpid (), listen_fd, listen_fd, func_str, - listen_sid, listen_sid, 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_sid = vppcom_session_accept (listen_sid, &ep, flags); - if (accept_sid < 0) + accept_vlsh = vls_accept (listen_vlsh, &ep, flags); + if (accept_vlsh < 0) { - errno = -accept_sid; + errno = -accept_vlsh; rv = -1; } else @@ -2826,56 +2053,26 @@ 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_sid); + (void) vls_close (accept_vlsh); errno = -rv; rv = -1; } else { - func_str = "ldp_fd_from_sid"; - if (LDP_DEBUG > 0) - clib_warning ("LDP<%d>: listen fd %d (0x%x): calling %s(): " - "accept sid %u (0x%x), ep %p, flags 0x%x", - getpid (), listen_fd, listen_fd, - func_str, accept_sid, accept_sid, ep, flags); - rv = ldp_fd_from_sid ((u32) accept_sid); - if (rv < 0) - { - (void) vppcom_session_close ((u32) accept_sid); - errno = -rv; - rv = -1; - } + rv = ldp_vlsh_to_fd (accept_vlsh); } } } else { - func_str = "libc_accept4"; - - if (LDP_DEBUG > 0) - clib_warning ("LDP<%d>: listen fd %d (0x%x): calling %s(): " - "addr %p, addr_len %p, flags 0x%x", - getpid (), listen_fd, listen_fd, func_str, - 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); } - if (LDP_DEBUG > 0) - { - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: listen fd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), listen_fd, - listen_fd, func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: listen fd %d (0x%x): returning %d (0x%x)", - getpid (), listen_fd, listen_fd, rv, rv); - } + LDBG (1, "listen fd %d: accept returning %d", listen_fd, rv); + return rv; } @@ -2895,51 +2092,47 @@ accept (int fd, __SOCKADDR_ARG addr, socklen_t * __restrict addr_len) int shutdown (int fd, int how) { - int rv; - const char *func_str; - u32 sid = ldp_sid_from_fd (fd); + vls_handle_t vlsh; + int rv = 0, flags; + u32 flags_len = sizeof (flags); if ((errno = -ldp_init ())) return -1; - if (sid != INVALID_SESSION_ID) + vlsh = ldp_fd_to_vlsh (fd); + if (vlsh != VLS_INVALID_HANDLE) { - func_str = "vppcom_session_close[TODO]"; - rv = close (fd); + LDBG (0, "called shutdown: fd %u vlsh %u how %d", fd, vlsh, how); + + if (vls_attr (vlsh, VPPCOM_ATTR_SET_SHUT, &how, &flags_len)) + { + close (fd); + return -1; + } + + if (vls_attr (vlsh, VPPCOM_ATTR_GET_SHUT, &flags, &flags_len)) + { + close (fd); + return -1; + } + + if (flags == SHUT_RDWR) + rv = close (fd); } else { - func_str = "libc_shutdown"; - - if (LDP_DEBUG > 1) - clib_warning ("LDP<%d>: fd %d (0x%x): calling %s(): how %d", - getpid (), fd, fd, func_str, how); - + LDBG (0, "fd %d: calling libc_shutdown: how %d", fd, how); rv = libc_shutdown (fd, how); } - 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 epoll_create1 (int flags) { - const char *func_str; + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); + vls_handle_t vlsh; int rv; if ((errno = -ldp_init ())) @@ -2947,40 +2140,30 @@ epoll_create1 (int flags) if (ldp->vcl_needs_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; - ldp->vcl_mq_epfd = rv; - LDBG (0, "LDP<%d>: created vcl epfd %u", getpid (), rv); + ldpw->vcl_mq_epfd = rv; + LDBG (0, "created vcl epfd %u", rv); return rv; } - func_str = "vppcom_epoll_create"; - LDBG (1, "LDP<%d>: calling %s()", getpid (), 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_from_sid ((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; } @@ -2993,43 +2176,38 @@ epoll_create (int size) int epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) { - u32 vep_idx = ldp_sid_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, "LDP<%d>: epfd %d (0x%x): calling %s(): op %d, fd %d (0x%x)," - " event %p", getpid (), 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_sid_from_fd (fd); + vlsh = ldp_fd_to_vlsh (fd); - LDBG (0, "LDP<%d>: epfd %d (0x%x), vep_idx %d (0x%x), sid %d (0x%x)", - getpid (), 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, vlsh, event); - LDBG (1, "LDP<%d>: epfd %d (0x%x): calling %s(): vep_idx %d (0x%x)," - " op %d, sid %u (0x%x), event %p", getpid (), 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; @@ -3041,20 +2219,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, "LDP<%d>: epfd %d (0x%x), vep_idx %d (0x%x): %s() " - "returned libc_epfd %d (0x%x)", getpid (), 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, "LDP<%d>: epfd %d (0x%x), vep_idx %d (0x%x): " - "calling %s(): EPOLL_CLOEXEC", getpid (), 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) @@ -3063,14 +2232,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, "LDP<%d>: epfd %d (0x%x): calling %s(): vep_idx %d (0x%x)," - " VPPCOM_ATTR_SET_LIBC_EPFD, libc_epfd %d (0x%x), size %d", - getpid (), 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; @@ -3085,31 +2248,13 @@ epoll_ctl (int epfd, int op, int fd, struct epoll_event *event) goto done; } - func_str = "libc_epoll_ctl"; - - LDBG (1, "LDP<%d>: epfd %d (0x%x): calling %s(): libc_epfd %d (0x%x), " - "op %d, fd %d (0x%x), event %p", getpid (), 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; } @@ -3117,10 +2262,10 @@ static inline int ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, int timeout, const sigset_t * sigmask) { - double time_to_wait = (double) 0, time_out, now = 0; - u32 vep_idx = ldp_sid_from_fd (epfd); + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); + double time_to_wait = (double) 0, max_time; int libc_epfd, rv = 0; - const char *func_str; + vls_handle_t ep_vlsh; if ((errno = -ldp_init ())) return -1; @@ -3131,22 +2276,23 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, return -1; } - if (epfd == ldp->vcl_mq_epfd) + 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)) { - clib_warning ("LDP<%d>: ERROR: epfd %d (0x%x): bad vep_idx %d (0x%x)!", - getpid (), epfd, epfd, vep_idx, vep_idx); + LDBG (0, "epfd %d: bad ep_vlsh %d!", epfd, ep_vlsh); errno = EBADFD; return -1; } - time_to_wait = ((timeout >= 0) ? (double) timeout : 0); - time_out = clib_time_now (&ldp->clib_time) + time_to_wait; + 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); + max_time = clib_time_now (&ldpw->clib_time) + time_to_wait; - func_str = "vppcom_session_attr[GET_LIBC_EPFD]"; - 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; @@ -3154,24 +2300,17 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, goto done; } - LDBG (2, "LDP<%d>: 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", - getpid (), 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 (!ldp->epoll_wait_vcl) + if (!ldpw->epoll_wait_vcl) { - func_str = "vppcom_epoll_wait"; - - LDBG (3, "LDP<%d>: epfd %d (0x%x): calling %s(): vep_idx %d (0x%x)," - " events %p, maxevents %d", getpid (), epfd, epfd, func_str, - 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) { - ldp->epoll_wait_vcl = 1; + ldpw->epoll_wait_vcl = 1; goto done; } else if (rv < 0) @@ -3182,45 +2321,18 @@ ldp_epoll_pwait (int epfd, struct epoll_event *events, int maxevents, } } else - ldp->epoll_wait_vcl = 0; + ldpw->epoll_wait_vcl = 0; if (libc_epfd > 0) { - func_str = "libc_epoll_pwait"; - - LDBG (3, "LDP<%d>: epfd %d (0x%x): calling %s(): libc_epfd %d " - "(0x%x), events %p, maxevents %d, sigmask %p", getpid (), - epfd, epfd, func_str, libc_epfd, libc_epfd, events, - maxevents, sigmask); - - rv = libc_epoll_pwait (libc_epfd, events, maxevents, 1, sigmask); + rv = libc_epoll_pwait (libc_epfd, events, maxevents, 0, sigmask); if (rv != 0) goto done; } - - if (timeout != -1) - now = clib_time_now (&ldp->clib_time); } - while (now < time_out); + while ((timeout == -1) || (clib_time_now (&ldpw->clib_time) < max_time)); done: - if (LDP_DEBUG > 3) - { - if (libc_epfd > 0) - epfd = libc_epfd; - if (rv < 0) - { - int errno_val = errno; - perror (func_str); - clib_warning ("LDP<%d>: ERROR: epfd %d (0x%x): %s() failed! " - "rv %d, errno = %d", getpid (), epfd, epfd, - func_str, rv, errno_val); - errno = errno_val; - } - else - clib_warning ("LDP<%d>: epfd %d (0x%x): returning %d (0x%x)", - getpid (), epfd, epfd, rv, rv); - } return rv; } @@ -3240,36 +2352,32 @@ epoll_wait (int epfd, struct epoll_event *events, int maxevents, int timeout) int poll (struct pollfd *fds, nfds_t nfds, int timeout) { - const char *func_str = __func__; + ldp_worker_ctx_t *ldpw = ldp_worker_get_current (); 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, "LDP<%d>: fds %p, nfds %d, timeout %d", getpid (), fds, nfds, - timeout); + LDBG (3, "fds %p, nfds %d, 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, "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); - - sid = ldp_sid_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 (ldp->vcl_poll, vp, 1); + 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) @@ -3281,23 +2389,16 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) } else { - vec_add1 (ldp->libc_poll, fds[i]); - vec_add1 (ldp->libc_poll_idxs, i); + vec_add1 (ldpw->libc_poll, fds[i]); + vec_add1 (ldpw->libc_poll_idxs, i); } } do { - if (vec_len (ldp->vcl_poll)) + if (vec_len (ldpw->vcl_poll)) { - func_str = "vppcom_poll"; - - LDBG (3, "LDP<%d>: calling %s(): vcl_poll %p, n_sids %u (0x%x): " - "n_libc_fds %u", getpid (), func_str, ldp->vcl_poll, - vec_len (ldp->vcl_poll), vec_len (ldp->vcl_poll), - vec_len (ldp->libc_poll)); - - rv = vppcom_poll (ldp->vcl_poll, vec_len (ldp->vcl_poll), 0); + rv = vppcom_poll (ldpw->vcl_poll, vec_len (ldpw->vcl_poll), 0); if (rv < 0) { errno = -rv; @@ -3308,14 +2409,9 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) n_revents += rv; } - if (vec_len (ldp->libc_poll)) + if (vec_len (ldpw->libc_poll)) { - func_str = "libc_poll"; - - LDBG (3, "LDP<%d>: calling %s(): fds %p, nfds %u: n_sids %u", - getpid (), fds, nfds, vec_len (ldp->vcl_poll)); - - rv = libc_poll (ldp->libc_poll, vec_len (ldp->libc_poll), 0); + rv = libc_poll (ldpw->libc_poll, vec_len (ldpw->libc_poll), 0); if (rv < 0) goto done; else @@ -3328,12 +2424,11 @@ poll (struct pollfd *fds, nfds_t nfds, int timeout) goto done; } } - while ((wait_for_time == -1) || - (clib_time_now (&ldp->clib_time) < wait_for_time)); + while ((timeout < 0) || (clib_time_now (&ldpw->clib_time) < max_time)); rv = 0; done: - vec_foreach (vp, ldp->vcl_poll) + vec_foreach (vp, ldpw->vcl_poll) { fds[vp->fds_ndx].fd = -fds[vp->fds_ndx].fd; fds[vp->fds_ndx].revents = vp->revents; @@ -3346,45 +2441,14 @@ done: fds[vp->fds_ndx].revents |= POLLWRNORM; #endif } - vec_reset_length (ldp->vcl_poll); + vec_reset_length (ldpw->vcl_poll); - for (i = 0; i < vec_len (ldp->libc_poll); i++) + for (i = 0; i < vec_len (ldpw->libc_poll); i++) { - fds[ldp->libc_poll_idxs[i]].revents = ldp->libc_poll[i].revents; - } - vec_reset_length (ldp->libc_poll_idxs); - vec_reset_length (ldp->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 (ldp->vcl_poll), vec_len (ldp->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); - } - } - } + fds[ldpw->libc_poll_idxs[i]].revents = ldpw->libc_poll[i].revents; } + vec_reset_length (ldpw->libc_poll_idxs); + vec_reset_length (ldpw->libc_poll); return rv; } @@ -3417,8 +2481,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 ()); } @@ -3429,19 +2496,18 @@ ldp_constructor (void) void ldp_destructor (void) { - swrap_destructor (); - if (ldp->init) - { - vppcom_app_destroy (); - 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 ()); }