falso
/
qemu-irix
mirror of https://github.com/n64decomp/qemu-irix.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

util: remove the obsolete non-blocking connect 

The non-blocking connect mechanism is obsolete, and it doesn't
work well in inet connection, because it will call getaddrinfo
first and getaddrinfo will blocks on DNS lookups. Since commit
e65c67e4 & d984464e, the non-blocking connect of migration goes
through QIOChannel in a different manner(using a thread), and
nobody use this old non-blocking connect anymore.

Any newly written code which needs a non-blocking connect should
use the QIOChannel code, so we can drop NonBlockingConnectHandler
as a concept entirely.

Suggested-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Cao jin <caoj.fnst@cn.fujitsu.com>
Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Cao jin 2017-06-16 16:54:45 +08:00 committed by Daniel P. Berrange
parent d4adf96758
commit b258793258
5 changed files with 28 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
block/sheepdog.c
View File

@ -591,7 +591,7 @@ static int connect_to_sdog(BDRVSheepdogState *s, Error **errp)
{ {
int fd; int fd;
fd = socket_connect(s->addr, NULL, NULL, errp); fd = socket_connect(s->addr, errp);
if (s->addr->type == SOCKET_ADDRESS_TYPE_INET && fd >= 0) { if (s->addr->type == SOCKET_ADDRESS_TYPE_INET && fd >= 0) {
int ret = socket_set_nodelay(fd); int ret = socket_set_nodelay(fd);

2
block/ssh.c
View File

@ -678,7 +678,7 @@ static int connect_to_ssh(BDRVSSHState *s, QDict *options,
} }
/* Open the socket and connect. */ /* Open the socket and connect. */
s->sock = inet_connect_saddr(s->inet, NULL, NULL, errp); s->sock = inet_connect_saddr(s->inet, errp);
if (s->sock < 0) { if (s->sock < 0) {
ret = -EIO; ret = -EIO;
goto err; goto err;

12
include/qemu/sockets.h
View File

@ -27,18 +27,11 @@ int socket_set_fast_reuse(int fd);
#define SHUT_RDWR 2 #define SHUT_RDWR 2
#endif #endif
/* callback function for nonblocking connect
* valid fd on success, negative error code on failure
*/
typedef void NonBlockingConnectHandler(int fd, Error *err, void *opaque);
int inet_ai_family_from_address(InetSocketAddress *addr, int inet_ai_family_from_address(InetSocketAddress *addr,
Error **errp); Error **errp);
int inet_parse(InetSocketAddress *addr, const char *str, Error **errp); int inet_parse(InetSocketAddress *addr, const char *str, Error **errp);
int inet_connect(const char *str, Error **errp); int inet_connect(const char *str, Error **errp);
int inet_connect_saddr(InetSocketAddress *saddr, int inet_connect_saddr(InetSocketAddress *saddr, Error **errp);
NonBlockingConnectHandler *callback, void *opaque,
Error **errp);
NetworkAddressFamily inet_netfamily(int family); NetworkAddressFamily inet_netfamily(int family);
@ -46,8 +39,7 @@ int unix_listen(const char *path, char *ostr, int olen, Error **errp);
int unix_connect(const char *path, Error **errp); int unix_connect(const char *path, Error **errp);
SocketAddress *socket_parse(const char *str, Error **errp); SocketAddress *socket_parse(const char *str, Error **errp);
int socket_connect(SocketAddress *addr, NonBlockingConnectHandler *callback, int socket_connect(SocketAddress *addr, Error **errp);
void *opaque, Error **errp);
int socket_listen(SocketAddress *addr, Error **errp); int socket_listen(SocketAddress *addr, Error **errp);
void socket_listen_cleanup(int fd, Error **errp); void socket_listen_cleanup(int fd, Error **errp);
int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp); int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp);

2
io/channel-socket.c
View File

@ -140,7 +140,7 @@ int qio_channel_socket_connect_sync(QIOChannelSocket *ioc,
int fd; int fd;
trace_qio_channel_socket_connect_sync(ioc, addr); trace_qio_channel_socket_connect_sync(ioc, addr);
fd = socket_connect(addr, NULL, NULL, errp); fd = socket_connect(addr, errp);
if (fd < 0) { if (fd < 0) {
trace_qio_channel_socket_connect_fail(ioc); trace_qio_channel_socket_connect_fail(ioc);
return -1; return -1;

205
util/qemu-sockets.c
View File

@ -300,88 +300,19 @@ listen:
((rc) == -EINPROGRESS) ((rc) == -EINPROGRESS)
#endif #endif
/* Struct to store connect state for non blocking connect */ static int inet_connect_addr(struct addrinfo *addr, Error **errp);
typedef struct ConnectState {
int fd;
struct addrinfo *addr_list;
struct addrinfo *current_addr;
NonBlockingConnectHandler *callback;
void *opaque;
} ConnectState;
static int inet_connect_addr(struct addrinfo *addr, bool *in_progress, static int inet_connect_addr(struct addrinfo *addr, Error **errp)
ConnectState *connect_state, Error **errp);
static void wait_for_connect(void *opaque)
{
ConnectState *s = opaque;
int val = 0, rc = 0;
socklen_t valsize = sizeof(val);
bool in_progress;
Error *err = NULL;
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
do {
rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
} while (rc == -1 && errno == EINTR);
/* update rc to contain error */
if (!rc && val) {
rc = -1;
errno = val;
}
/* connect error */
if (rc < 0) {
error_setg_errno(&err, errno, "Error connecting to socket");
closesocket(s->fd);
s->fd = rc;
}
/* try to connect to the next address on the list */
if (s->current_addr) {
while (s->current_addr->ai_next != NULL && s->fd < 0) {
s->current_addr = s->current_addr->ai_next;
s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
if (s->fd < 0) {
error_free(err);
err = NULL;
error_setg_errno(&err, errno, "Unable to start socket connect");
}
/* connect in progress */
if (in_progress) {
goto out;
}
}
freeaddrinfo(s->addr_list);
}
if (s->callback) {
s->callback(s->fd, err, s->opaque);
}
g_free(s);
out:
error_free(err);
}
static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
ConnectState *connect_state, Error **errp)
{ {
int sock, rc; int sock, rc;
*in_progress = false;
sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
if (sock < 0) { if (sock < 0) {
error_setg_errno(errp, errno, "Failed to create socket"); error_setg_errno(errp, errno, "Failed to create socket");
return -1; return -1;
} }
socket_set_fast_reuse(sock); socket_set_fast_reuse(sock);
if (connect_state != NULL) {
qemu_set_nonblock(sock);
}
/* connect to peer */ /* connect to peer */
do { do {
rc = 0; rc = 0;
@ -390,15 +321,12 @@ static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
} }
} while (rc == -EINTR); } while (rc == -EINTR);
if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { if (rc < 0) {
connect_state->fd = sock;
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
*in_progress = true;
} else if (rc < 0) {
error_setg_errno(errp, errno, "Failed to connect socket"); error_setg_errno(errp, errno, "Failed to connect socket");
closesocket(sock); closesocket(sock);
return -1; return -1;
} }
return sock; return sock;
} }
@ -456,44 +384,24 @@ static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr,
* *
* @saddr: Inet socket address specification * @saddr: Inet socket address specification
* @errp: set on error * @errp: set on error
* @callback: callback function for non-blocking connect
* @opaque: opaque for callback function
* *
* Returns: -1 on error, file descriptor on success. * Returns: -1 on error, file descriptor on success.
*
* If @callback is non-null, the connect is non-blocking. If this
* function succeeds, callback will be called when the connection
* completes, with the file descriptor on success, or -1 on error.
*/ */
int inet_connect_saddr(InetSocketAddress *saddr, int inet_connect_saddr(InetSocketAddress *saddr, Error **errp)
NonBlockingConnectHandler *callback, void *opaque,
Error **errp)
{ {
Error *local_err = NULL; Error *local_err = NULL;
struct addrinfo *res, *e; struct addrinfo *res, *e;
int sock = -1; int sock = -1;
bool in_progress;
ConnectState *connect_state = NULL;
res = inet_parse_connect_saddr(saddr, errp); res = inet_parse_connect_saddr(saddr, errp);
if (!res) { if (!res) {
return -1; return -1;
} }
if (callback != NULL) {
connect_state = g_malloc0(sizeof(*connect_state));
connect_state->addr_list = res;
connect_state->callback = callback;
connect_state->opaque = opaque;
}
for (e = res; e != NULL; e = e->ai_next) { for (e = res; e != NULL; e = e->ai_next) {
error_free(local_err); error_free(local_err);
local_err = NULL; local_err = NULL;
if (connect_state != NULL) { sock = inet_connect_addr(e, &local_err);
connect_state->current_addr = e;
}
sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
if (sock >= 0) { if (sock >= 0) {
break; break;
} }
@ -501,15 +409,8 @@ int inet_connect_saddr(InetSocketAddress *saddr,
if (sock < 0) { if (sock < 0) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
} else if (in_progress) {
/* wait_for_connect() will do the rest */
return sock;
} else {
if (callback) {
callback(sock, NULL, opaque);
} }
}
g_free(connect_state);
freeaddrinfo(res); freeaddrinfo(res);
return sock; return sock;
} }
@ -688,7 +589,7 @@ int inet_connect(const char *str, Error **errp)
InetSocketAddress *addr = g_new(InetSocketAddress, 1); InetSocketAddress *addr = g_new(InetSocketAddress, 1);
if (!inet_parse(addr, str, errp)) { if (!inet_parse(addr, str, errp)) {
sock = inet_connect_saddr(addr, NULL, NULL, errp); sock = inet_connect_saddr(addr, errp);
} }
qapi_free_InetSocketAddress(addr); qapi_free_InetSocketAddress(addr);
return sock; return sock;
@ -721,21 +622,16 @@ static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr,
return true; return true;
} }
static int vsock_connect_addr(const struct sockaddr_vm *svm, bool *in_progress, static int vsock_connect_addr(const struct sockaddr_vm *svm, Error **errp)
ConnectState *connect_state, Error **errp)
{ {
int sock, rc; int sock, rc;
*in_progress = false;
sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0);
if (sock < 0) { if (sock < 0) {
error_setg_errno(errp, errno, "Failed to create socket"); error_setg_errno(errp, errno, "Failed to create socket");
return -1; return -1;
} }
if (connect_state != NULL) {
qemu_set_nonblock(sock);
}
/* connect to peer */ /* connect to peer */
do { do {
rc = 0; rc = 0;
@ -744,50 +640,26 @@ static int vsock_connect_addr(const struct sockaddr_vm *svm, bool *in_progress,
} }
} while (rc == -EINTR); } while (rc == -EINTR);
if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) { if (rc < 0) {
connect_state->fd = sock;
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
*in_progress = true;
} else if (rc < 0) {
error_setg_errno(errp, errno, "Failed to connect socket"); error_setg_errno(errp, errno, "Failed to connect socket");
closesocket(sock); closesocket(sock);
return -1; return -1;
} }
return sock; return sock;
} }
static int vsock_connect_saddr(VsockSocketAddress *vaddr, static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp)
NonBlockingConnectHandler *callback,
void *opaque,
Error **errp)
{ {
struct sockaddr_vm svm; struct sockaddr_vm svm;
int sock = -1; int sock = -1;
bool in_progress;
ConnectState *connect_state = NULL;
if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) {
return -1; return -1;
} }
if (callback != NULL) { sock = vsock_connect_addr(&svm, errp);
connect_state = g_malloc0(sizeof(*connect_state));
connect_state->callback = callback;
connect_state->opaque = opaque;
}
sock = vsock_connect_addr(&svm, &in_progress, connect_state, errp);
if (sock < 0) {
/* do nothing */
} else if (in_progress) {
/* wait_for_connect() will do the rest */
return sock;
} else {
if (callback) {
callback(sock, NULL, opaque);
}
}
g_free(connect_state);
return sock; return sock;
} }
@ -847,9 +719,7 @@ static void vsock_unsupported(Error **errp)
error_setg(errp, "socket family AF_VSOCK unsupported"); error_setg(errp, "socket family AF_VSOCK unsupported");
} }
static int vsock_connect_saddr(VsockSocketAddress *vaddr, static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp)
NonBlockingConnectHandler *callback,
void *opaque, Error **errp)
{ {
vsock_unsupported(errp); vsock_unsupported(errp);
return -1; return -1;
@ -952,12 +822,9 @@ err:
return -1; return -1;
} }
static int unix_connect_saddr(UnixSocketAddress *saddr, static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp)
NonBlockingConnectHandler *callback, void *opaque,
Error **errp)
{ {
struct sockaddr_un un; struct sockaddr_un un;
ConnectState *connect_state = NULL;
int sock, rc; int sock, rc;
if (saddr->path == NULL) { if (saddr->path == NULL) {
@ -970,12 +837,6 @@ static int unix_connect_saddr(UnixSocketAddress *saddr,
error_setg_errno(errp, errno, "Failed to create socket"); error_setg_errno(errp, errno, "Failed to create socket");
return -1; return -1;
} }
if (callback != NULL) {
connect_state = g_malloc0(sizeof(*connect_state));
connect_state->callback = callback;
connect_state->opaque = opaque;
qemu_set_nonblock(sock);
}
if (strlen(saddr->path) > sizeof(un.sun_path)) { if (strlen(saddr->path) > sizeof(un.sun_path)) {
error_setg(errp, "UNIX socket path '%s' is too long", saddr->path); error_setg(errp, "UNIX socket path '%s' is too long", saddr->path);
@ -996,29 +857,16 @@ static int unix_connect_saddr(UnixSocketAddress *saddr,
} }
} while (rc == -EINTR); } while (rc == -EINTR);
if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
connect_state->fd = sock;
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
return sock;
} else if (rc >= 0) {
/* non blocking socket immediate success, call callback */
if (callback != NULL) {
callback(sock, NULL, opaque);
}
}
if (rc < 0) { if (rc < 0) {
error_setg_errno(errp, -rc, "Failed to connect socket %s", error_setg_errno(errp, -rc, "Failed to connect socket %s",
saddr->path); saddr->path);
goto err; goto err;
} }
g_free(connect_state);
return sock; return sock;
err: err:
close(sock); close(sock);
g_free(connect_state);
return -1; return -1;
} }
@ -1033,9 +881,7 @@ static int unix_listen_saddr(UnixSocketAddress *saddr,
return -1; return -1;
} }
static int unix_connect_saddr(UnixSocketAddress *saddr, static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp)
NonBlockingConnectHandler *callback, void *opaque,
Error **errp)
{ {
error_setg(errp, "unix sockets are not available on windows"); error_setg(errp, "unix sockets are not available on windows");
errno = ENOTSUP; errno = ENOTSUP;
@ -1081,7 +927,7 @@ int unix_connect(const char *path, Error **errp)
saddr = g_new0(UnixSocketAddress, 1); saddr = g_new0(UnixSocketAddress, 1);
saddr->path = g_strdup(path); saddr->path = g_strdup(path);
sock = unix_connect_saddr(saddr, NULL, NULL, errp); sock = unix_connect_saddr(saddr, errp);
qapi_free_UnixSocketAddress(saddr); qapi_free_UnixSocketAddress(saddr);
return sock; return sock;
} }
@ -1126,30 +972,25 @@ fail:
return NULL; return NULL;
} }
int socket_connect(SocketAddress *addr, NonBlockingConnectHandler *callback, int socket_connect(SocketAddress *addr, Error **errp)
void *opaque, Error **errp)
{ {
int fd; int fd;
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_TYPE_INET: case SOCKET_ADDRESS_TYPE_INET:
fd = inet_connect_saddr(&addr->u.inet, callback, opaque, errp); fd = inet_connect_saddr(&addr->u.inet, errp);
break; break;
case SOCKET_ADDRESS_TYPE_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
fd = unix_connect_saddr(&addr->u.q_unix, callback, opaque, errp); fd = unix_connect_saddr(&addr->u.q_unix, errp);
break; break;
case SOCKET_ADDRESS_TYPE_FD: case SOCKET_ADDRESS_TYPE_FD:
fd = monitor_get_fd(cur_mon, addr->u.fd.str, errp); fd = monitor_get_fd(cur_mon, addr->u.fd.str, errp);
if (fd >= 0 && callback) {
qemu_set_nonblock(fd);
callback(fd, NULL, opaque);
}
break; break;
case SOCKET_ADDRESS_TYPE_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
fd = vsock_connect_saddr(&addr->u.vsock, callback, opaque, errp); fd = vsock_connect_saddr(&addr->u.vsock, errp);
break; break;
default: default: