X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fsessiond-comm%2Finet.c;h=57ffbe45c28ed1ae68bded38f4713f901a23deb1;hp=6d729238a575e8ae149d85a8f25693f7a2554400;hb=c2e8c3663b99ba900f4733696c70e7a5e32ae1a7;hpb=a655f4cf59f557aef3f0a975988d87bdd3b199fd diff --git a/src/common/sessiond-comm/inet.c b/src/common/sessiond-comm/inet.c index 6d729238a..57ffbe45c 100644 --- a/src/common/sessiond-comm/inet.c +++ b/src/common/sessiond-comm/inet.c @@ -15,7 +15,7 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -26,15 +26,14 @@ #include #include #include -#include +#include #include #include +#include #include "inet.h" -#define MSEC_PER_SEC 1000 -#define NSEC_PER_MSEC 1000000 #define RECONNECT_DELAY 200 /* ms */ /* @@ -50,6 +49,8 @@ static const struct lttcomm_proto_ops inet_ops = { .sendmsg = lttcomm_sendmsg_inet_sock, }; +unsigned long lttcomm_inet_tcp_timeout; + /* * Creates an PF_INET socket. */ @@ -57,6 +58,7 @@ LTTNG_HIDDEN int lttcomm_create_inet_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) { @@ -74,6 +76,17 @@ int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto) PERROR("setsockopt inet"); 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; @@ -87,15 +100,9 @@ error: LTTNG_HIDDEN int lttcomm_bind_inet_sock(struct lttcomm_sock *sock) { - int ret; - - ret = bind(sock->fd, &sock->sockaddr.addr.sin, + return bind(sock->fd, + (const struct sockaddr *) &sock->sockaddr.addr.sin, sizeof(sock->sockaddr.addr.sin)); - if (ret < 0) { - PERROR("bind inet"); - } - - return ret; } static @@ -105,31 +112,13 @@ int connect_no_timeout(struct lttcomm_sock *sock) sizeof(sock->sockaddr.addr.sin)); } -/* - * 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; + unsigned long diff_ms; ret = fcntl(sock->fd, F_GETFL, 0); if (ret == -1) { @@ -145,7 +134,7 @@ int connect_with_timeout(struct lttcomm_sock *sock) return -1; } - ret = clock_gettime(CLOCK_MONOTONIC, &orig_time); + ret = lttng_clock_gettime(CLOCK_MONOTONIC, &orig_time); if (ret == -1) { PERROR("clock_gettime"); return -1; @@ -163,6 +152,8 @@ int connect_with_timeout(struct lttcomm_sock *sock) goto success; } + DBG("Asynchronous connect for sock %d, performing polling with" + " timeout: %lums", sock->fd, timeout); /* * Perform poll loop following EINPROGRESS recommendation from * connect(2) man page. @@ -189,23 +180,31 @@ int connect_with_timeout(struct lttcomm_sock *sock) ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &optval, &optval_len); if (ret) { + PERROR("getsockopt"); goto error; } if (!optval) { connect_ret = 0; goto success; } else { + /* Get actual connect() errno from opt_val */ + errno = optval; goto error; } } /* ret == 0: timeout */ - ret = clock_gettime(CLOCK_MONOTONIC, &cur_time); + ret = lttng_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); + if (timespec_to_ms(timespec_abs_diff(cur_time, orig_time), &diff_ms) < 0) { + ERR("timespec_to_ms input overflows milliseconds output"); + connect_ret = -1; + goto error; + } + } while (diff_ms < timeout); /* Timeout */ errno = ETIMEDOUT; @@ -261,6 +260,7 @@ struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock) int new_fd; socklen_t len; struct lttcomm_sock *new_sock; + unsigned long timeout; if (sock->proto == LTTCOMM_SOCK_UDP) { /* @@ -284,6 +284,19 @@ struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock) PERROR("accept inet"); goto error; } + timeout = lttcomm_get_network_timeout(); + if (timeout) { + int ret; + + ret = lttcomm_setsockopt_rcv_timeout(new_fd, timeout); + if (ret) { + goto error_close; + } + ret = lttcomm_setsockopt_snd_timeout(new_fd, timeout); + if (ret) { + goto error_close; + } + } new_sock->fd = new_fd; new_sock->ops = &inet_ops; @@ -291,6 +304,11 @@ struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock) end: return new_sock; +error_close: + if (close(new_fd) < 0) { + PERROR("accept inet close fd"); + } + error: free(new_sock); return NULL; @@ -353,18 +371,31 @@ ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf, len_last = iov[0].iov_len; ret = recvmsg(sock->fd, &msg, flags); if (ret > 0) { + if (flags & MSG_DONTWAIT) { + goto end; + } 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) { + if (errno == EAGAIN && flags & MSG_DONTWAIT) { + /* + * EAGAIN is expected in non-blocking mode and should + * not be reported as an error. Moreover, if no data + * was read, 0 must not be returned as it would be + * interpreted as an orderly shutdown of the socket. + */ + goto end; + } PERROR("recvmsg inet"); } else if (ret > 0) { ret = len; } /* Else ret = 0 meaning an orderly shutdown. */ - +end: return ret; } @@ -374,7 +405,7 @@ ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf, * Return the size of sent data. */ LTTNG_HIDDEN -ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, void *buf, +ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, const void *buf, size_t len, int flags) { struct msghdr msg; @@ -383,7 +414,7 @@ ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, void *buf, memset(&msg, 0, sizeof(msg)); - iov[0].iov_base = buf; + iov[0].iov_base = (void *) buf; iov[0].iov_len = len; msg.msg_iov = iov; msg.msg_iovlen = 1; @@ -436,3 +467,81 @@ int lttcomm_close_inet_sock(struct lttcomm_sock *sock) return ret; } + +/* + * Return value read from /proc or else 0 if value is not found. + */ +static unsigned long read_proc_value(const char *path) +{ + int ret, fd; + ssize_t size_ret; + long r_val; + unsigned long val = 0; + char buf[64]; + + fd = open(path, O_RDONLY); + if (fd < 0) { + goto error; + } + + size_ret = lttng_read(fd, buf, sizeof(buf)); + /* + * Allow reading a file smaller than buf, but keep space for + * final \0. + */ + if (size_ret < 0 || size_ret >= sizeof(buf)) { + PERROR("read proc failed"); + goto error_close; + } + buf[size_ret] = '\0'; + + errno = 0; + r_val = strtol(buf, NULL, 10); + if (errno != 0 || r_val < -1L) { + val = 0; + goto error_close; + } else { + if (r_val > 0) { + val = r_val; + } + } + +error_close: + ret = close(fd); + if (ret) { + PERROR("close /proc value"); + } +error: + return val; +} + +LTTNG_HIDDEN +void lttcomm_inet_init(void) +{ + unsigned long syn_retries, fin_timeout, syn_timeout, env; + + env = lttcomm_get_network_timeout(); + if (env) { + lttcomm_inet_tcp_timeout = env; + goto end; + } + + /* Assign default value and see if we can change it. */ + lttcomm_inet_tcp_timeout = DEFAULT_INET_TCP_TIMEOUT; + + syn_retries = read_proc_value(LTTCOMM_INET_PROC_SYN_RETRIES_PATH); + fin_timeout = read_proc_value(LTTCOMM_INET_PROC_FIN_TIMEOUT_PATH); + + syn_timeout = syn_retries * LTTCOMM_INET_SYN_TIMEOUT_FACTOR; + + /* + * Get the maximum between the two possible timeout value and use that to + * get the maximum with the default timeout. + */ + lttcomm_inet_tcp_timeout = max_t(unsigned long, + max_t(unsigned long, syn_timeout, fin_timeout), + lttcomm_inet_tcp_timeout); + +end: + DBG("TCP inet operation timeout set to %lu sec", lttcomm_inet_tcp_timeout); +}