X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fsessiond-comm%2Finet6.c;h=a29adad4214c941d3287c6dc7f6851559c2d8af5;hp=0d96c31c21c98eca65812feeb2e31c91fa6b60d6;hb=14b88ccfe8d51fe8a19e525d8b6a5e4614eccb46;hpb=de5e90863d3824dd3a5bc52d4cba1cd9b0329200 diff --git a/src/common/sessiond-comm/inet6.c b/src/common/sessiond-comm/inet6.c index 0d96c31c2..a29adad42 100644 --- a/src/common/sessiond-comm/inet6.c +++ b/src/common/sessiond-comm/inet6.c @@ -15,7 +15,7 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -25,12 +25,18 @@ #include #include #include +#include +#include +#include -#include -#include +#include #include "inet6.h" +#define MSEC_PER_SEC 1000 +#define NSEC_PER_MSEC 1000000 +#define RECONNECT_DELAY 200 /* ms */ + /* * INET protocol operations. */ @@ -47,12 +53,14 @@ static const struct lttcomm_proto_ops inet6_ops = { /* * Creates an PF_INET socket. */ +LTTNG_HIDDEN int lttcomm_create_inet6_sock(struct lttcomm_sock *sock, int type, int proto) { int val = 1, ret; + unsigned long timeout; /* Create server socket */ - if ((sock->fd = socket(PF_INET, type, proto)) < 0) { + if ((sock->fd = socket(PF_INET6, type, proto)) < 0) { PERROR("socket inet6"); goto error; } @@ -67,6 +75,17 @@ int lttcomm_create_inet6_sock(struct lttcomm_sock *sock, int type, int proto) PERROR("setsockopt inet6"); goto error; } + timeout = lttcomm_get_network_timeout(); + if (timeout) { + ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout); + if (ret) { + goto error; + } + ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout); + if (ret) { + goto error; + } + } return 0; @@ -77,11 +96,12 @@ error: /* * Bind socket and return. */ +LTTNG_HIDDEN int lttcomm_bind_inet6_sock(struct lttcomm_sock *sock) { int ret; - ret = bind(sock->fd, &sock->sockaddr.addr.sin6, + ret = bind(sock->fd, (const struct sockaddr *) &sock->sockaddr.addr.sin6, sizeof(sock->sockaddr.addr.sin6)); if (ret < 0) { PERROR("bind inet6"); @@ -90,20 +110,145 @@ int lttcomm_bind_inet6_sock(struct lttcomm_sock *sock) return ret; } +static +int connect_no_timeout(struct lttcomm_sock *sock) +{ + return connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin6, + sizeof(sock->sockaddr.addr.sin6)); +} + +/* + * Return time_a - time_b in milliseconds. + */ +static +unsigned long time_diff_ms(struct timespec *time_a, + struct timespec *time_b) +{ + time_t sec_diff; + long nsec_diff; + unsigned long result_ms; + + sec_diff = time_a->tv_sec - time_b->tv_sec; + nsec_diff = time_a->tv_nsec - time_b->tv_nsec; + + result_ms = sec_diff * MSEC_PER_SEC; + result_ms += nsec_diff / NSEC_PER_MSEC; + return result_ms; +} + +static +int connect_with_timeout(struct lttcomm_sock *sock) +{ + unsigned long timeout = lttcomm_get_network_timeout(); + int ret, flags, connect_ret; + struct timespec orig_time, cur_time; + + ret = fcntl(sock->fd, F_GETFL, 0); + if (ret == -1) { + PERROR("fcntl"); + return -1; + } + flags = ret; + + /* Set socket to nonblock */ + ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK); + if (ret == -1) { + PERROR("fcntl"); + return -1; + } + + ret = clock_gettime(CLOCK_MONOTONIC, &orig_time); + if (ret == -1) { + PERROR("clock_gettime"); + return -1; + } + + connect_ret = connect(sock->fd, + (struct sockaddr *) &sock->sockaddr.addr.sin6, + sizeof(sock->sockaddr.addr.sin6)); + if (connect_ret == -1 && errno != EAGAIN + && errno != EWOULDBLOCK + && errno != EINPROGRESS) { + goto error; + } else if (!connect_ret) { + /* Connect succeeded */ + goto success; + } + + /* + * Perform poll loop following EINPROGRESS recommendation from + * connect(2) man page. + */ + do { + struct pollfd fds; + + fds.fd = sock->fd; + fds.events = POLLOUT; + fds.revents = 0; + ret = poll(&fds, 1, RECONNECT_DELAY); + if (ret < 0) { + goto error; + } else if (ret > 0) { + int optval; + socklen_t optval_len = sizeof(optval); + + if (!(fds.revents & POLLOUT)) { + /* Either hup or error */ + errno = EPIPE; + goto error; + } + /* got something */ + ret = getsockopt(sock->fd, SOL_SOCKET, + SO_ERROR, &optval, &optval_len); + if (ret) { + goto error; + } + if (!optval) { + connect_ret = 0; + goto success; + } else { + goto error; + } + } + /* ret == 0: timeout */ + ret = clock_gettime(CLOCK_MONOTONIC, &cur_time); + if (ret == -1) { + PERROR("clock_gettime"); + connect_ret = ret; + goto error; + } + } while (time_diff_ms(&cur_time, &orig_time) < timeout); + + /* Timeout */ + errno = ETIMEDOUT; + connect_ret = -1; + +success: + /* Restore initial flags */ + ret = fcntl(sock->fd, F_SETFL, flags); + if (ret == -1) { + PERROR("fcntl"); + /* Continue anyway */ + } +error: + return connect_ret; +} + /* * Connect PF_INET socket. */ +LTTNG_HIDDEN int lttcomm_connect_inet6_sock(struct lttcomm_sock *sock) { int ret, closeret; - ret = connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin6, - sizeof(sock->sockaddr.addr.sin6)); + if (lttcomm_get_network_timeout()) { + ret = connect_with_timeout(sock); + } else { + ret = connect_no_timeout(sock); + } if (ret < 0) { - /* - * Don't print message on connect error, because connect is used in - * normal execution to detect if sessiond is alive. - */ + PERROR("connect inet6"); goto error_connect; } @@ -122,10 +267,11 @@ error_connect: * Do an accept(2) on the sock and return the new lttcomm socket. The socket * MUST be bind(2) before. */ +LTTNG_HIDDEN struct lttcomm_sock *lttcomm_accept_inet6_sock(struct lttcomm_sock *sock) { int new_fd; - socklen_t len = 0; + socklen_t len; struct lttcomm_sock *new_sock; if (sock->proto == LTTCOMM_SOCK_UDP) { @@ -141,6 +287,8 @@ struct lttcomm_sock *lttcomm_accept_inet6_sock(struct lttcomm_sock *sock) goto error; } + len = sizeof(new_sock->sockaddr.addr.sin6); + /* Blocking call */ new_fd = accept(sock->fd, (struct sockaddr *) &new_sock->sockaddr.addr.sin6, &len); @@ -163,6 +311,7 @@ error: /* * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN. */ +LTTNG_HIDDEN int lttcomm_listen_inet6_sock(struct lttcomm_sock *sock, int backlog) { int ret; @@ -193,12 +342,14 @@ end: * * Return the size of received data. */ +LTTNG_HIDDEN ssize_t lttcomm_recvmsg_inet6_sock(struct lttcomm_sock *sock, void *buf, size_t len, int flags) { struct msghdr msg; struct iovec iov[1]; ssize_t ret = -1; + size_t len_last; memset(&msg, 0, sizeof(msg)); @@ -210,16 +361,21 @@ ssize_t lttcomm_recvmsg_inet6_sock(struct lttcomm_sock *sock, void *buf, msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin6; msg.msg_namelen = sizeof(sock->sockaddr.addr.sin6); - if (flags == 0) { - flags = MSG_WAITALL; - } - do { + len_last = iov[0].iov_len; ret = recvmsg(sock->fd, &msg, flags); - } while (ret < 0 && errno == EINTR); + if (ret > 0) { + iov[0].iov_base += ret; + iov[0].iov_len -= ret; + assert(ret <= len_last); + } + } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR)); if (ret < 0) { - PERROR("recvmsg inet6"); + PERROR("recvmsg inet"); + } else if (ret > 0) { + ret = len; } + /* Else ret = 0 meaning an orderly shutdown. */ return ret; } @@ -229,6 +385,7 @@ ssize_t lttcomm_recvmsg_inet6_sock(struct lttcomm_sock *sock, void *buf, * * Return the size of sent data. */ +LTTNG_HIDDEN ssize_t lttcomm_sendmsg_inet6_sock(struct lttcomm_sock *sock, void *buf, size_t len, int flags) { @@ -271,6 +428,7 @@ ssize_t lttcomm_sendmsg_inet6_sock(struct lttcomm_sock *sock, void *buf, /* * Shutdown cleanly and close. */ +LTTNG_HIDDEN int lttcomm_close_inet6_sock(struct lttcomm_sock *sock) { int ret;