#define LDP_MAX_NWORKERS 32
+#define LDP_F_SHUT_RD (1 << 0)
+#define LDP_F_SHUT_WR (1 << 1)
+
typedef struct ldp_fd_entry_
{
u32 session_index;
u32 fd;
u32 fd_index;
+ u32 flags;
} ldp_fd_entry_t;
typedef struct ldp_worker_ctx_
#define LDBG(_lvl, _fmt, _args...) \
if (ldp->debug > _lvl) \
- clib_warning (_fmt, ##_args)
+ clib_warning ("ldp<%d>: " _fmt, getpid(), ##_args)
static ldp_main_t ldp_main = {
.sid_bit_val = (1 << LDP_SID_BIT_MIN),
rv = vppcom_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;
}
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);
}
}
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);
ldp->sid_bit_val = (1 << sb);
ldp->sid_bit_mask = ldp->sid_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,
+ LDBG (0, "configured LDP sid bit (%u) from "
+ LDP_ENV_SID_BIT "! sid bit value %d (0x%x)", sb,
ldp->sid_bit_val, ldp->sid_bit_val);
}
}
clib_time_init (&ldpw->clib_time);
clib_rwlock_init (&ldp->fd_table_lock);
- LDBG (0, "LDP<%d>: LDP initialization: done!", getpid ());
+ LDBG (0, "LDP initialization: done!");
return 0;
}
int
close (int fd)
{
- int rv;
- const char *func_str;
+ int rv, refcnt;
u32 sid = ldp_sid_from_fd (fd);
if ((errno = -ldp_init ()))
{
int epfd;
- func_str = "vppcom_session_attr[GET_LIBC_EPFD]";
epfd = vppcom_session_attr (sid, 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 (0x%x): calling libc_close: epfd %u (0x%x)",
+ fd, fd, epfd, epfd);
rv = libc_close (epfd);
if (rv < 0)
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 (0x%x): calling vppcom_session_close: sid %u (0x%x)",
+ fd, fd, sid, sid);
+ refcnt = vppcom_session_attr (sid, VPPCOM_ATTR_GET_REFCNT, 0, 0);
rv = vppcom_session_close (sid);
if (rv != VPPCOM_OK)
{
errno = -rv;
rv = -1;
}
- ldp_fd_free_w_sid (sid);
+ if (refcnt <= 1)
+ ldp_fd_free_w_sid (sid);
}
else
{
- func_str = "libc_close";
-
- LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s()", getpid (), fd, fd,
- func_str);
-
+ LDBG (0, "fd %d (0x%x): calling libc_close", fd, 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);
- }
+
+ LDBG (1, "fd %d (0x%x): returning %d (0x%x)", fd, fd, rv, rv);
return rv;
}
read (int fd, void *buf, size_t nbytes)
{
ssize_t size;
- const char *func_str;
u32 sid = ldp_sid_from_fd (fd);
if ((errno = -ldp_init ()))
if (sid != INVALID_SESSION_ID)
{
- 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);
+ LDBG (2, "fd %d (0x%x): calling vppcom_session_read(): sid %u (0x%x),"
+ " buf %p, nbytes %u", fd, fd, sid, sid, buf, nbytes);
size = vppcom_session_read (sid, buf, nbytes);
if (size < 0)
}
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);
+ LDBG (2, "fd %d (0x%x): calling libc_read(): buf %p, nbytes %u",
+ fd, fd, 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);
- }
+ LDBG (2, "fd %d (0x%x): returning %d (0x%x)", fd, fd, size, size);
return size;
}
ssize_t
readv (int fd, const struct iovec * iov, int iovcnt)
{
- const char *func_str;
ssize_t size = 0;
u32 sid = ldp_sid_from_fd (fd);
int rv = 0, i, total = 0;
if (sid != INVALID_SESSION_ID)
{
- func_str = "vppcom_session_read";
do
{
for (i = 0; i < iovcnt; ++i)
{
- 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);
+ LDBG (2, "fd %d (0x%x): calling vppcom_session_read() [%d]:"
+ " sid %u (0x%x), iov %p, iovcnt %d, total %d", fd, fd, i,
+ sid, sid, iov, iovcnt, total);
rv = vppcom_session_read (sid, iov[i].iov_base, iov[i].iov_len);
if (rv < 0)
total += rv;
if (rv < iov[i].iov_len)
{
- 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);
+ LDBG (2, "fd %d (0x%x): rv (%d) < iov[%d].iov_len (%d)",
+ fd, fd, rv, i, iov[i].iov_len);
break;
}
}
}
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);
+ LDBG (2, "fd %d (0x%x): calling libc_readv(): iov %p, iovcnt %d", 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);
- }
+
+ LDBG (2, "fd %d (0x%x): returning %d (0x%x)", fd, fd, size, size);
return size;
}
ssize_t
write (int fd, const void *buf, size_t nbytes)
{
- const char *func_str;
ssize_t size = 0;
u32 sid = ldp_sid_from_fd (fd);
if (sid != INVALID_SESSION_ID)
{
- 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);
+ LDBG (2, "fd %d (0x%x): calling vppcom_session_write(): sid %u (0x%x), "
+ "buf %p, nbytes %u", fd, fd, sid, sid, buf, nbytes);
- size = vppcom_session_write (sid, (void *) buf, nbytes);
+ size = vppcom_session_write_msg (sid, (void *) buf, nbytes);
if (size < 0)
{
errno = -size;
}
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);
+ LDBG (2, "fd %d (0x%x): calling libc_write(): buf %p, nbytes %u",
+ fd, fd, 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);
- }
+ LDBG (2, "fd %d (0x%x): returning %d (0x%x)", 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);
int i, rv = 0;
if (sid != INVALID_SESSION_ID)
{
- func_str = "vppcom_session_write";
do
{
for (i = 0; i < iovcnt; ++i)
{
- 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);
+ rv = vppcom_session_write_msg (sid, iov[i].iov_base,
+ iov[i].iov_len);
if (rv < 0)
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;
- }
+ break;
}
}
}
}
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;
}
{
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,
+ LDBG (2, "fd %d (0x%x): calling %s(): sid %u (0x%x) "
+ "flags %d (0x%x), size %d", fd, fd, func_str, sid,
sid, flags, flags, size);
rv = vppcom_session_attr (sid, VPPCOM_ATTR_SET_FLAGS, &flags,
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,
+ LDBG (2, "fd %d (0x%x): calling %s(): sid %u (0x%x), "
+ "flags %d (0x%x), size %d", fd, fd, func_str, sid,
sid, flags, flags, size);
rv = vppcom_session_attr (sid, VPPCOM_ATTR_GET_FLAGS, &flags,
&size);
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,
+ LDBG (2, "fd %d (0x%x), cmd %d (F_GETFL): %s() "
+ "returned flags %d (0x%x)", fd, fd, cmd,
func_str, flags, flags);
rv = flags;
}
{
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);
+ LDBG (2, "fd %d (0x%x): calling %s(): cmd %d", fd, fd, func_str, cmd);
rv = libc_vfcntl (fd, cmd, ap);
}
/* select as fine grained sleep */
if (!nfds)
{
- LDBG (3, "LDP<%d>: sleeping for %.02f seconds", getpid (),
- time_out);
+ LDBG (3, "sleeping for %.02f seconds", time_out);
time_out += clib_time_now (&ldpw->clib_time);
while (clib_time_now (&ldpw->clib_time) < time_out)
{
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,
+ LDBG (3, "calling %s(): nfds %d, readfds %p, writefds %p, "
+ "exceptfds %p, timeout %p, sigmask %p", func_str, nfds,
readfds, writefds, exceptfds, timeout, sigmask);
rv = libc_pselect (nfds, readfds, writefds, exceptfds,
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);
+ LDBG (3, "readfds: fd %d (0x%x), sid %u (0x%x)", fd, fd, sid, sid);
if (sid == INVALID_SESSION_ID)
clib_bitmap_set_no_check (ldpw->libc_rd_bitmap, fd, 1);
else
libc_bits_set = clib_bitmap_last_set (ldpw->libc_rd_bitmap) + 1;
libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits;
- LDBG (3, "LDP<%d>: readfds: sid_bits_set %d, sid_bits %d, "
- "libc_bits_set %d, libc_bits %d", getpid (), sid_bits_set,
+ LDBG (3, "readfds: sid_bits_set %d, sid_bits %d, "
+ "libc_bits_set %d, libc_bits %d", sid_bits_set,
sid_bits, libc_bits_set, libc_bits);
}
if (writefds)
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);
+ LDBG (3, "writefds: fd %d (0x%x), sid %u (0x%x)", fd, fd, sid, sid);
if (sid == INVALID_SESSION_ID)
clib_bitmap_set_no_check (ldpw->libc_wr_bitmap, fd, 1);
else
libc_bits_set = clib_bitmap_last_set (ldpw->libc_wr_bitmap) + 1;
libc_bits = (libc_bits_set > libc_bits) ? libc_bits_set : libc_bits;
- LDBG (3, "LDP<%d>: writefds: sid_bits_set %d, sid_bits %d, "
- "libc_bits_set %d, libc_bits %d", getpid (),
+ LDBG (3, "writefds: sid_bits_set %d, sid_bits %d, "
+ "libc_bits_set %d, libc_bits %d",
sid_bits_set, sid_bits, libc_bits_set, libc_bits);
}
if (exceptfds)
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);
+ LDBG (3, "exceptfds: fd %d (0x%x), sid %u (0x%x)", fd, fd, sid, sid);
if (sid == INVALID_SESSION_ID)
clib_bitmap_set_no_check (ldpw->libc_ex_bitmap, fd, 1);
else
libc_bits_set = clib_bitmap_last_set (ldpw->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 (),
+ LDBG (3, "exceptfds: sid_bits_set %d, sid_bits %d, "
+ "libc_bits_set %d, libc_bits %d",
sid_bits_set, sid_bits, libc_bits_set, libc_bits);
}
func_str = "vppcom_session_create";
- 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 %s(): proto %u (%s), is_nonblocking %u",
+ func_str, proto, vppcom_proto_str (proto), is_nonblocking);
sid = vppcom_session_create (proto, is_nonblocking);
if (sid < 0)
{
func_str = "libc_socket";
- LDBG (0, "LDP<%d>: : calling %s()", getpid (), func_str);
+ LDBG (0, "calling %s()", func_str);
rv = libc_socket (domain, type, protocol);
}
errno = errno_val;
}
else
- clib_warning ("LDP<%d>: : returning fd %d (0x%x)", getpid (), rv, rv);
+ clib_warning ("returning fd %d (0x%x)", getpid (), rv, rv);
}
return rv;
}
{
func_str = "libc_socket";
- LDBG (1, "LDP<%d>: : calling %s()", getpid (), func_str);
+ LDBG (1, "calling %s()", func_str);
rv = libc_socketpair (domain, type, protocol, fds);
}
bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len)
{
int rv;
- const char *func_str;
u32 sid = ldp_sid_from_fd (fd);
if ((errno = -ldp_init ()))
{
vppcom_endpt_t ep;
- func_str = "vppcom_session_bind";
-
switch (addr->sa_family)
{
case AF_INET:
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 (0x%x): calling vppcom_session_bind(): "
+ "sid %u (0x%x), addr %p, len %u", fd, fd, sid, sid, addr, len);
rv = vppcom_session_bind (sid, &ep);
if (rv != VPPCOM_OK)
}
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 (0x%x): calling libc_bind(): addr %p, len %u",
+ fd, 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 (0x%x): returning %d", fd, fd, rv);
+
return rv;
}
connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len)
{
int rv;
- const char *func_str = __func__;
u32 sid = ldp_sid_from_fd (fd);
if ((errno = -ldp_init ()))
{
vppcom_endpt_t ep;
- func_str = "vppcom_session_connect";
-
switch (addr->sa_family)
{
case AF_INET:
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 (0x%x): calling vppcom_session_connect(): sid %u (0x%x)"
+ " addr %p len %u", fd, fd, sid, sid, addr, len);
rv = vppcom_session_connect (sid, &ep);
if (rv != VPPCOM_OK)
}
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 (0x%x): calling libc_connect(): addr %p, len %u",
+ fd, 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 (0x%x): returning %d (0x%x)", fd, fd, rv, rv);
return rv;
}
recv (int fd, void *buf, size_t n, int flags)
{
ssize_t size;
- const char *func_str;
- u32 sid = ldp_sid_from_fd (fd);
+ u32 sid;
if ((errno = -ldp_init ()))
return -1;
+ sid = ldp_sid_from_fd (fd);
if (sid != INVALID_SESSION_ID)
{
- 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);
+ LDBG (2, "fd %d (0x%x): calling vcl recvfrom: sid %u (0x%x), buf %p,"
+ " n %u, flags 0x%x", fd, fd, sid, sid, buf, n, flags);
size = vppcom_session_recvfrom (sid, buf, n, flags, NULL);
if (size < 0)
- {
- errno = -size;
- size = -1;
- }
+ errno = -size;
}
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);
+ LDBG (2, "fd %d (0x%x): calling libc_recvfrom(): buf %p, n %u, "
+ "flags 0x%x", fd, fd, buf, n, flags);
size = libc_recv (fd, buf, n, flags);
}
- 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;
}
listen (int fd, int n)
{
int rv;
- const char *func_str;
u32 sid = ldp_sid_from_fd (fd);
if ((errno = -ldp_init ()))
if (sid != INVALID_SESSION_ID)
{
- func_str = "vppcom_session_listen";
-
- LDBG (0, "LDP<%d>: fd %d (0x%x): calling %s(): sid %u (0x%x), n %d",
- getpid (), fd, fd, func_str, sid, sid, n);
+ LDBG (0, "fd %d (0x%x): calling vppcom_session_listen():"
+ " sid %u (0x%x), n %d", fd, fd, sid, sid, n);
rv = vppcom_session_listen (sid, n);
if (rv != VPPCOM_OK)
}
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 (0x%x): calling libc_listen(): n %d", fd, 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 (0x%x): returning %d (0x%x)", fd, fd, rv, rv);
return rv;
}
socklen_t * __restrict addr_len, int flags)
{
int rv;
- const char *func_str;
u32 listen_sid = ldp_sid_from_fd (listen_fd);
int accept_sid;
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 (0x%x): calling vppcom_session_accept:"
+ " listen sid %u (0x%x), ep %p, flags 0x%x", listen_fd,
+ listen_fd, listen_sid, listen_sid, ep, flags);
accept_sid = vppcom_session_accept (listen_sid, &ep, flags);
if (accept_sid < 0)
}
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_alloc ((u32) accept_sid);
if (rv < 0)
{
}
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 (0x%x): calling libc_accept4(): "
+ "addr %p, addr_len %p, flags 0x%x", listen_fd,
+ 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 (0x%x): returning %d (0x%x)", listen_fd, listen_fd,
+ rv, rv);
+
return rv;
}
int
shutdown (int fd, int how)
{
- int rv;
- const char *func_str;
- u32 sid = ldp_sid_from_fd (fd);
+ int rv = 0;
if ((errno = -ldp_init ()))
return -1;
- if (sid != INVALID_SESSION_ID)
+ if (ldp_fd_is_sid (fd))
{
- func_str = "vppcom_session_close[TODO]";
- rv = close (fd);
+ u32 fd_index = fd - ldp->sid_bit_val;
+ ldp_fd_entry_t *fde;
+
+ fde = ldp_fd_entry_get_w_lock (fd_index);
+ if (!fde)
+ {
+ clib_rwlock_reader_unlock (&ldp->fd_table_lock);
+ errno = ENOTCONN;
+ return -1;
+ }
+
+ if (how == SHUT_RD)
+ fde->flags |= LDP_F_SHUT_RD;
+ else if (how == SHUT_WR)
+ fde->flags |= LDP_F_SHUT_WR;
+ else if (how == SHUT_RDWR)
+ fde->flags |= (LDP_F_SHUT_RD | LDP_F_SHUT_WR);
+
+ if ((fde->flags & LDP_F_SHUT_RD) && (fde->flags & LDP_F_SHUT_WR))
+ rv = close (fd);
+
+ clib_rwlock_reader_unlock (&ldp->fd_table_lock);
+ LDBG (0, "fd %d (0x%x): calling vcl shutdown: how %d", fd, fd, how);
}
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 (1, "fd %d (0x%x): calling libc_shutdown: how %d", fd, 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;
}
rv = libc_epoll_create1 (flags);
ldp->vcl_needs_real_epoll = 0;
ldpw->vcl_mq_epfd = rv;
- LDBG (0, "LDP<%d>: created vcl epfd %u", getpid (), rv);
+ LDBG (0, "created vcl epfd %u", rv);
return rv;
}
func_str = "vppcom_epoll_create";
- LDBG (1, "LDP<%d>: calling %s()", getpid (), func_str);
+ LDBG (1, "calling %s()", func_str);
rv = vppcom_epoll_create ();
*/
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 (0x%x): calling %s(): op %d, fd %d (0x%x),"
+ " event %p", epfd, epfd, func_str, op, fd, fd, event);
rv = libc_epoll_ctl (epfd, op, fd, event);
goto done;
sid = ldp_sid_from_fd (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 (0x%x), vep_idx %d (0x%x), sid %d (0x%x)",
+ epfd, epfd, vep_idx, vep_idx, sid, sid);
if (sid != INVALID_SESSION_ID)
{
func_str = "vppcom_epoll_ctl";
- 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,
+ LDBG (1, "epfd %d (0x%x): calling %s(): vep_idx %d (0x%x),"
+ " op %d, sid %u (0x%x), event %p", epfd, epfd,
func_str, vep_idx, vep_idx, sid, sid, event);
rv = vppcom_epoll_ctl (vep_idx, op, sid, event);
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,
+ LDBG (1, "epfd %d (0x%x), vep_idx %d (0x%x): %s() "
+ "returned libc_epfd %d (0x%x)", epfd, epfd,
vep_idx, vep_idx, func_str, libc_epfd, libc_epfd);
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,
+ LDBG (1, "epfd %d (0x%x), vep_idx %d (0x%x): "
+ "calling %s(): EPOLL_CLOEXEC", epfd, epfd,
vep_idx, vep_idx, func_str);
libc_epfd = libc_epoll_create1 (EPOLL_CLOEXEC);
}
func_str = "vppcom_session_attr[SET_LIBC_EPFD]";
- LDBG (1, "LDP<%d>: epfd %d (0x%x): calling %s(): vep_idx %d (0x%x),"
+ LDBG (1, "epfd %d (0x%x): calling %s(): vep_idx %d (0x%x),"
" VPPCOM_ATTR_SET_LIBC_EPFD, libc_epfd %d (0x%x), size %d",
- getpid (), epfd, epfd, func_str, vep_idx, vep_idx, libc_epfd,
+ epfd, epfd, func_str, vep_idx, vep_idx, libc_epfd,
libc_epfd, size);
rv = vppcom_session_attr (vep_idx, VPPCOM_ATTR_SET_LIBC_EPFD,
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,
+ LDBG (1, "epfd %d (0x%x): calling %s(): libc_epfd %d (0x%x), "
+ "op %d, fd %d (0x%x), event %p", epfd, epfd, func_str,
libc_epfd, libc_epfd, op, fd, fd, event);
rv = libc_epoll_ctl (libc_epfd, op, fd, event);
double time_to_wait = (double) 0, time_out, now = 0;
u32 vep_idx = ldp_sid_from_fd (epfd);
int libc_epfd, rv = 0;
- const char *func_str;
if ((errno = -ldp_init ()))
return -1;
if (PREDICT_FALSE (vep_idx == INVALID_SESSION_ID))
{
- 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 (0x%x): bad vep_idx %d (0x%x)!", epfd, epfd, vep_idx,
+ vep_idx);
errno = EBADFD;
return -1;
}
- time_to_wait = ((timeout >= 0) ? (double) timeout : 0);
+ time_to_wait = ((timeout >= 0) ? (double) timeout / 1000 : 0);
time_out = 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);
if (PREDICT_FALSE (libc_epfd < 0))
{
goto done;
}
- LDBG (2, "LDP<%d>: epfd %d (0x%x): vep_idx %d (0x%x), libc_epfd %d (0x%x), "
+ LDBG (2, "epfd %d (0x%x): vep_idx %d (0x%x), libc_epfd %d (0x%x), "
"events %p, maxevents %d, timeout %d, sigmask %p: time_to_wait %.02f",
- getpid (), epfd, epfd, vep_idx, vep_idx, libc_epfd, libc_epfd, events,
+ epfd, epfd, vep_idx, vep_idx, libc_epfd, libc_epfd, events,
maxevents, timeout, sigmask, time_to_wait, time_out);
do
{
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);
+ LDBG (3, "epfd %d (0x%x): calling vcl_epoll_wait: vep_idx %d (0x%x)"
+ " events %p, maxevents %d", epfd, epfd, vep_idx, vep_idx,
+ events, maxevents);
rv = vppcom_epoll_wait (vep_idx, events, maxevents, 0);
if (rv > 0)
if (libc_epfd > 0)
{
- func_str = "libc_epoll_pwait";
+ LDBG (3, "epfd %d (0x%x): calling libc_epoll_wait: libc_epfd %d "
+ "(0x%x), events %p, maxevents %d, sigmask %p", epfd, epfd,
+ libc_epfd, libc_epfd, events, maxevents, sigmask);
- 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;
}
while (now < time_out);
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;
}
vcl_poll_t *vp;
double wait_for_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;
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);
+ LDBG (3, "fds[%d] fd %d (0x%0x) events = 0x%x revents = 0x%x",
+ i, fds[i].fd, fds[i].fd, fds[i].events, fds[i].revents);
sid = ldp_sid_from_fd (fds[i].fd);
if (sid != INVALID_SESSION_ID)
{
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, ldpw->vcl_poll,
+ LDBG (3, "calling %s(): vcl_poll %p, n_sids %u (0x%x): "
+ "n_libc_fds %u", func_str, ldpw->vcl_poll,
vec_len (ldpw->vcl_poll), vec_len (ldpw->vcl_poll),
vec_len (ldpw->libc_poll));
{
func_str = "libc_poll";
- LDBG (3, "LDP<%d>: calling %s(): fds %p, nfds %u: n_sids %u",
- getpid (), fds, nfds, vec_len (ldpw->vcl_poll));
+ LDBG (3, "calling %s(): fds %p, nfds %u: n_sids %u",
+ fds, nfds, vec_len (ldpw->vcl_poll));
rv = libc_poll (ldpw->libc_poll, vec_len (ldpw->libc_poll), 0);
if (rv < 0)
{
swrap_destructor ();
if (ldp->init)
- {
- vppcom_app_destroy ();
- ldp->init = 0;
- }
+ ldp->init = 0;
/* Don't use clib_warning() here because that calls writev()
* which will call ldp_init().
Code Review / vpp.git / blobdiff