1 /* 2 * QEMU I/O channels sockets driver 3 * 4 * Copyright (c) 2015 Red Hat, Inc. 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include "qemu/osdep.h" 21 #include "qapi/error.h" 22 #include "qapi/qapi-visit-sockets.h" 23 #include "qemu/module.h" 24 #include "io/channel-socket.h" 25 #include "io/channel-watch.h" 26 #include "trace.h" 27 #include "qapi/clone-visitor.h" 28 #ifdef CONFIG_LINUX 29 #include <linux/errqueue.h> 30 #include <sys/socket.h> 31 32 #if (defined(MSG_ZEROCOPY) && defined(SO_ZEROCOPY)) 33 #define QEMU_MSG_ZEROCOPY 34 #endif 35 #endif 36 37 #define SOCKET_MAX_FDS 16 38 39 SocketAddress * 40 qio_channel_socket_get_local_address(QIOChannelSocket *ioc, 41 Error **errp) 42 { 43 return socket_sockaddr_to_address(&ioc->localAddr, 44 ioc->localAddrLen, 45 errp); 46 } 47 48 SocketAddress * 49 qio_channel_socket_get_remote_address(QIOChannelSocket *ioc, 50 Error **errp) 51 { 52 return socket_sockaddr_to_address(&ioc->remoteAddr, 53 ioc->remoteAddrLen, 54 errp); 55 } 56 57 QIOChannelSocket * 58 qio_channel_socket_new(void) 59 { 60 QIOChannelSocket *sioc; 61 QIOChannel *ioc; 62 63 sioc = QIO_CHANNEL_SOCKET(object_new(TYPE_QIO_CHANNEL_SOCKET)); 64 sioc->fd = -1; 65 sioc->zero_copy_queued = 0; 66 sioc->zero_copy_sent = 0; 67 68 ioc = QIO_CHANNEL(sioc); 69 qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_SHUTDOWN); 70 71 #ifdef WIN32 72 ioc->event = CreateEvent(NULL, FALSE, FALSE, NULL); 73 #endif 74 75 trace_qio_channel_socket_new(sioc); 76 77 return sioc; 78 } 79 80 81 static int 82 qio_channel_socket_set_fd(QIOChannelSocket *sioc, 83 int fd, 84 Error **errp) 85 { 86 if (sioc->fd != -1) { 87 error_setg(errp, "Socket is already open"); 88 return -1; 89 } 90 91 sioc->fd = fd; 92 sioc->remoteAddrLen = sizeof(sioc->remoteAddr); 93 sioc->localAddrLen = sizeof(sioc->localAddr); 94 95 96 if (getpeername(fd, (struct sockaddr *)&sioc->remoteAddr, 97 &sioc->remoteAddrLen) < 0) { 98 if (errno == ENOTCONN) { 99 memset(&sioc->remoteAddr, 0, sizeof(sioc->remoteAddr)); 100 sioc->remoteAddrLen = sizeof(sioc->remoteAddr); 101 } else { 102 error_setg_errno(errp, errno, 103 "Unable to query remote socket address"); 104 goto error; 105 } 106 } 107 108 if (getsockname(fd, (struct sockaddr *)&sioc->localAddr, 109 &sioc->localAddrLen) < 0) { 110 error_setg_errno(errp, errno, 111 "Unable to query local socket address"); 112 goto error; 113 } 114 115 #ifndef WIN32 116 if (sioc->localAddr.ss_family == AF_UNIX) { 117 QIOChannel *ioc = QIO_CHANNEL(sioc); 118 qio_channel_set_feature(ioc, QIO_CHANNEL_FEATURE_FD_PASS); 119 } 120 #endif /* WIN32 */ 121 122 return 0; 123 124 error: 125 sioc->fd = -1; /* Let the caller close FD on failure */ 126 return -1; 127 } 128 129 QIOChannelSocket * 130 qio_channel_socket_new_fd(int fd, 131 Error **errp) 132 { 133 QIOChannelSocket *ioc; 134 135 ioc = qio_channel_socket_new(); 136 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 137 object_unref(OBJECT(ioc)); 138 return NULL; 139 } 140 141 trace_qio_channel_socket_new_fd(ioc, fd); 142 143 return ioc; 144 } 145 146 147 int qio_channel_socket_connect_sync(QIOChannelSocket *ioc, 148 SocketAddress *addr, 149 Error **errp) 150 { 151 int fd; 152 153 trace_qio_channel_socket_connect_sync(ioc, addr); 154 fd = socket_connect(addr, errp); 155 if (fd < 0) { 156 trace_qio_channel_socket_connect_fail(ioc); 157 return -1; 158 } 159 160 trace_qio_channel_socket_connect_complete(ioc, fd); 161 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 162 close(fd); 163 return -1; 164 } 165 166 #ifdef QEMU_MSG_ZEROCOPY 167 int ret, v = 1; 168 ret = setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &v, sizeof(v)); 169 if (ret == 0) { 170 /* Zero copy available on host */ 171 qio_channel_set_feature(QIO_CHANNEL(ioc), 172 QIO_CHANNEL_FEATURE_WRITE_ZERO_COPY); 173 } 174 #endif 175 176 return 0; 177 } 178 179 180 static void qio_channel_socket_connect_worker(QIOTask *task, 181 gpointer opaque) 182 { 183 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); 184 SocketAddress *addr = opaque; 185 Error *err = NULL; 186 187 qio_channel_socket_connect_sync(ioc, addr, &err); 188 189 qio_task_set_error(task, err); 190 } 191 192 193 void qio_channel_socket_connect_async(QIOChannelSocket *ioc, 194 SocketAddress *addr, 195 QIOTaskFunc callback, 196 gpointer opaque, 197 GDestroyNotify destroy, 198 GMainContext *context) 199 { 200 QIOTask *task = qio_task_new( 201 OBJECT(ioc), callback, opaque, destroy); 202 SocketAddress *addrCopy; 203 204 addrCopy = QAPI_CLONE(SocketAddress, addr); 205 206 /* socket_connect() does a non-blocking connect(), but it 207 * still blocks in DNS lookups, so we must use a thread */ 208 trace_qio_channel_socket_connect_async(ioc, addr); 209 qio_task_run_in_thread(task, 210 qio_channel_socket_connect_worker, 211 addrCopy, 212 (GDestroyNotify)qapi_free_SocketAddress, 213 context); 214 } 215 216 217 int qio_channel_socket_listen_sync(QIOChannelSocket *ioc, 218 SocketAddress *addr, 219 int num, 220 Error **errp) 221 { 222 int fd; 223 224 trace_qio_channel_socket_listen_sync(ioc, addr, num); 225 fd = socket_listen(addr, num, errp); 226 if (fd < 0) { 227 trace_qio_channel_socket_listen_fail(ioc); 228 return -1; 229 } 230 231 trace_qio_channel_socket_listen_complete(ioc, fd); 232 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 233 close(fd); 234 return -1; 235 } 236 qio_channel_set_feature(QIO_CHANNEL(ioc), QIO_CHANNEL_FEATURE_LISTEN); 237 238 return 0; 239 } 240 241 242 struct QIOChannelListenWorkerData { 243 SocketAddress *addr; 244 int num; /* amount of expected connections */ 245 }; 246 247 static void qio_channel_listen_worker_free(gpointer opaque) 248 { 249 struct QIOChannelListenWorkerData *data = opaque; 250 251 qapi_free_SocketAddress(data->addr); 252 g_free(data); 253 } 254 255 static void qio_channel_socket_listen_worker(QIOTask *task, 256 gpointer opaque) 257 { 258 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); 259 struct QIOChannelListenWorkerData *data = opaque; 260 Error *err = NULL; 261 262 qio_channel_socket_listen_sync(ioc, data->addr, data->num, &err); 263 264 qio_task_set_error(task, err); 265 } 266 267 268 void qio_channel_socket_listen_async(QIOChannelSocket *ioc, 269 SocketAddress *addr, 270 int num, 271 QIOTaskFunc callback, 272 gpointer opaque, 273 GDestroyNotify destroy, 274 GMainContext *context) 275 { 276 QIOTask *task = qio_task_new( 277 OBJECT(ioc), callback, opaque, destroy); 278 struct QIOChannelListenWorkerData *data; 279 280 data = g_new0(struct QIOChannelListenWorkerData, 1); 281 data->addr = QAPI_CLONE(SocketAddress, addr); 282 data->num = num; 283 284 /* socket_listen() blocks in DNS lookups, so we must use a thread */ 285 trace_qio_channel_socket_listen_async(ioc, addr, num); 286 qio_task_run_in_thread(task, 287 qio_channel_socket_listen_worker, 288 data, 289 qio_channel_listen_worker_free, 290 context); 291 } 292 293 294 int qio_channel_socket_dgram_sync(QIOChannelSocket *ioc, 295 SocketAddress *localAddr, 296 SocketAddress *remoteAddr, 297 Error **errp) 298 { 299 int fd; 300 301 trace_qio_channel_socket_dgram_sync(ioc, localAddr, remoteAddr); 302 fd = socket_dgram(remoteAddr, localAddr, errp); 303 if (fd < 0) { 304 trace_qio_channel_socket_dgram_fail(ioc); 305 return -1; 306 } 307 308 trace_qio_channel_socket_dgram_complete(ioc, fd); 309 if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { 310 close(fd); 311 return -1; 312 } 313 314 return 0; 315 } 316 317 318 struct QIOChannelSocketDGramWorkerData { 319 SocketAddress *localAddr; 320 SocketAddress *remoteAddr; 321 }; 322 323 324 static void qio_channel_socket_dgram_worker_free(gpointer opaque) 325 { 326 struct QIOChannelSocketDGramWorkerData *data = opaque; 327 qapi_free_SocketAddress(data->localAddr); 328 qapi_free_SocketAddress(data->remoteAddr); 329 g_free(data); 330 } 331 332 static void qio_channel_socket_dgram_worker(QIOTask *task, 333 gpointer opaque) 334 { 335 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); 336 struct QIOChannelSocketDGramWorkerData *data = opaque; 337 Error *err = NULL; 338 339 /* socket_dgram() blocks in DNS lookups, so we must use a thread */ 340 qio_channel_socket_dgram_sync(ioc, data->localAddr, 341 data->remoteAddr, &err); 342 343 qio_task_set_error(task, err); 344 } 345 346 347 void qio_channel_socket_dgram_async(QIOChannelSocket *ioc, 348 SocketAddress *localAddr, 349 SocketAddress *remoteAddr, 350 QIOTaskFunc callback, 351 gpointer opaque, 352 GDestroyNotify destroy, 353 GMainContext *context) 354 { 355 QIOTask *task = qio_task_new( 356 OBJECT(ioc), callback, opaque, destroy); 357 struct QIOChannelSocketDGramWorkerData *data = g_new0( 358 struct QIOChannelSocketDGramWorkerData, 1); 359 360 data->localAddr = QAPI_CLONE(SocketAddress, localAddr); 361 data->remoteAddr = QAPI_CLONE(SocketAddress, remoteAddr); 362 363 trace_qio_channel_socket_dgram_async(ioc, localAddr, remoteAddr); 364 qio_task_run_in_thread(task, 365 qio_channel_socket_dgram_worker, 366 data, 367 qio_channel_socket_dgram_worker_free, 368 context); 369 } 370 371 372 QIOChannelSocket * 373 qio_channel_socket_accept(QIOChannelSocket *ioc, 374 Error **errp) 375 { 376 QIOChannelSocket *cioc; 377 378 cioc = qio_channel_socket_new(); 379 cioc->remoteAddrLen = sizeof(ioc->remoteAddr); 380 cioc->localAddrLen = sizeof(ioc->localAddr); 381 382 retry: 383 trace_qio_channel_socket_accept(ioc); 384 cioc->fd = qemu_accept(ioc->fd, (struct sockaddr *)&cioc->remoteAddr, 385 &cioc->remoteAddrLen); 386 if (cioc->fd < 0) { 387 if (errno == EINTR) { 388 goto retry; 389 } 390 error_setg_errno(errp, errno, "Unable to accept connection"); 391 trace_qio_channel_socket_accept_fail(ioc); 392 goto error; 393 } 394 395 if (getsockname(cioc->fd, (struct sockaddr *)&cioc->localAddr, 396 &cioc->localAddrLen) < 0) { 397 error_setg_errno(errp, errno, 398 "Unable to query local socket address"); 399 goto error; 400 } 401 402 #ifndef WIN32 403 if (cioc->localAddr.ss_family == AF_UNIX) { 404 QIOChannel *ioc_local = QIO_CHANNEL(cioc); 405 qio_channel_set_feature(ioc_local, QIO_CHANNEL_FEATURE_FD_PASS); 406 } 407 #endif /* WIN32 */ 408 409 trace_qio_channel_socket_accept_complete(ioc, cioc, cioc->fd); 410 return cioc; 411 412 error: 413 object_unref(OBJECT(cioc)); 414 return NULL; 415 } 416 417 static void qio_channel_socket_init(Object *obj) 418 { 419 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(obj); 420 ioc->fd = -1; 421 } 422 423 static void qio_channel_socket_finalize(Object *obj) 424 { 425 QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(obj); 426 427 if (ioc->fd != -1) { 428 QIOChannel *ioc_local = QIO_CHANNEL(ioc); 429 if (qio_channel_has_feature(ioc_local, QIO_CHANNEL_FEATURE_LISTEN)) { 430 Error *err = NULL; 431 432 socket_listen_cleanup(ioc->fd, &err); 433 if (err) { 434 error_report_err(err); 435 err = NULL; 436 } 437 } 438 #ifdef WIN32 439 WSAEventSelect(ioc->fd, NULL, 0); 440 #endif 441 closesocket(ioc->fd); 442 ioc->fd = -1; 443 } 444 } 445 446 447 #ifndef WIN32 448 static void qio_channel_socket_copy_fds(struct msghdr *msg, 449 int **fds, size_t *nfds) 450 { 451 struct cmsghdr *cmsg; 452 453 *nfds = 0; 454 *fds = NULL; 455 456 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) { 457 int fd_size, i; 458 int gotfds; 459 460 if (cmsg->cmsg_len < CMSG_LEN(sizeof(int)) || 461 cmsg->cmsg_level != SOL_SOCKET || 462 cmsg->cmsg_type != SCM_RIGHTS) { 463 continue; 464 } 465 466 fd_size = cmsg->cmsg_len - CMSG_LEN(0); 467 468 if (!fd_size) { 469 continue; 470 } 471 472 gotfds = fd_size / sizeof(int); 473 *fds = g_renew(int, *fds, *nfds + gotfds); 474 memcpy(*fds + *nfds, CMSG_DATA(cmsg), fd_size); 475 476 for (i = 0; i < gotfds; i++) { 477 int fd = (*fds)[*nfds + i]; 478 if (fd < 0) { 479 continue; 480 } 481 482 /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */ 483 qemu_socket_set_block(fd); 484 485 #ifndef MSG_CMSG_CLOEXEC 486 qemu_set_cloexec(fd); 487 #endif 488 } 489 *nfds += gotfds; 490 } 491 } 492 493 494 static ssize_t qio_channel_socket_readv(QIOChannel *ioc, 495 const struct iovec *iov, 496 size_t niov, 497 int **fds, 498 size_t *nfds, 499 Error **errp) 500 { 501 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 502 ssize_t ret; 503 struct msghdr msg = { NULL, }; 504 char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)]; 505 int sflags = 0; 506 507 memset(control, 0, CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)); 508 509 msg.msg_iov = (struct iovec *)iov; 510 msg.msg_iovlen = niov; 511 if (fds && nfds) { 512 msg.msg_control = control; 513 msg.msg_controllen = sizeof(control); 514 #ifdef MSG_CMSG_CLOEXEC 515 sflags |= MSG_CMSG_CLOEXEC; 516 #endif 517 518 } 519 520 retry: 521 ret = recvmsg(sioc->fd, &msg, sflags); 522 if (ret < 0) { 523 if (errno == EAGAIN) { 524 return QIO_CHANNEL_ERR_BLOCK; 525 } 526 if (errno == EINTR) { 527 goto retry; 528 } 529 530 error_setg_errno(errp, errno, 531 "Unable to read from socket"); 532 return -1; 533 } 534 535 if (fds && nfds) { 536 qio_channel_socket_copy_fds(&msg, fds, nfds); 537 } 538 539 return ret; 540 } 541 542 static ssize_t qio_channel_socket_writev(QIOChannel *ioc, 543 const struct iovec *iov, 544 size_t niov, 545 int *fds, 546 size_t nfds, 547 int flags, 548 Error **errp) 549 { 550 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 551 ssize_t ret; 552 struct msghdr msg = { NULL, }; 553 char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)]; 554 size_t fdsize = sizeof(int) * nfds; 555 struct cmsghdr *cmsg; 556 int sflags = 0; 557 558 memset(control, 0, CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)); 559 560 msg.msg_iov = (struct iovec *)iov; 561 msg.msg_iovlen = niov; 562 563 if (nfds) { 564 if (nfds > SOCKET_MAX_FDS) { 565 error_setg_errno(errp, EINVAL, 566 "Only %d FDs can be sent, got %zu", 567 SOCKET_MAX_FDS, nfds); 568 return -1; 569 } 570 571 msg.msg_control = control; 572 msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds); 573 574 cmsg = CMSG_FIRSTHDR(&msg); 575 cmsg->cmsg_len = CMSG_LEN(fdsize); 576 cmsg->cmsg_level = SOL_SOCKET; 577 cmsg->cmsg_type = SCM_RIGHTS; 578 memcpy(CMSG_DATA(cmsg), fds, fdsize); 579 } 580 581 if (flags & QIO_CHANNEL_WRITE_FLAG_ZERO_COPY) { 582 #ifdef QEMU_MSG_ZEROCOPY 583 sflags = MSG_ZEROCOPY; 584 #else 585 /* 586 * We expect QIOChannel class entry point to have 587 * blocked this code path already 588 */ 589 g_assert_not_reached(); 590 #endif 591 } 592 593 retry: 594 ret = sendmsg(sioc->fd, &msg, sflags); 595 if (ret <= 0) { 596 switch (errno) { 597 case EAGAIN: 598 return QIO_CHANNEL_ERR_BLOCK; 599 case EINTR: 600 goto retry; 601 case ENOBUFS: 602 if (flags & QIO_CHANNEL_WRITE_FLAG_ZERO_COPY) { 603 error_setg_errno(errp, errno, 604 "Process can't lock enough memory for using MSG_ZEROCOPY"); 605 return -1; 606 } 607 break; 608 } 609 610 error_setg_errno(errp, errno, 611 "Unable to write to socket"); 612 return -1; 613 } 614 615 if (flags & QIO_CHANNEL_WRITE_FLAG_ZERO_COPY) { 616 sioc->zero_copy_queued++; 617 } 618 619 return ret; 620 } 621 #else /* WIN32 */ 622 static ssize_t qio_channel_socket_readv(QIOChannel *ioc, 623 const struct iovec *iov, 624 size_t niov, 625 int **fds, 626 size_t *nfds, 627 Error **errp) 628 { 629 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 630 ssize_t done = 0; 631 ssize_t i; 632 633 for (i = 0; i < niov; i++) { 634 ssize_t ret; 635 retry: 636 ret = recv(sioc->fd, 637 iov[i].iov_base, 638 iov[i].iov_len, 639 0); 640 if (ret < 0) { 641 if (errno == EAGAIN) { 642 if (done) { 643 return done; 644 } else { 645 return QIO_CHANNEL_ERR_BLOCK; 646 } 647 } else if (errno == EINTR) { 648 goto retry; 649 } else { 650 error_setg_errno(errp, errno, 651 "Unable to read from socket"); 652 return -1; 653 } 654 } 655 done += ret; 656 if (ret < iov[i].iov_len) { 657 return done; 658 } 659 } 660 661 return done; 662 } 663 664 static ssize_t qio_channel_socket_writev(QIOChannel *ioc, 665 const struct iovec *iov, 666 size_t niov, 667 int *fds, 668 size_t nfds, 669 int flags, 670 Error **errp) 671 { 672 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 673 ssize_t done = 0; 674 ssize_t i; 675 676 for (i = 0; i < niov; i++) { 677 ssize_t ret; 678 retry: 679 ret = send(sioc->fd, 680 iov[i].iov_base, 681 iov[i].iov_len, 682 0); 683 if (ret < 0) { 684 if (errno == EAGAIN) { 685 if (done) { 686 return done; 687 } else { 688 return QIO_CHANNEL_ERR_BLOCK; 689 } 690 } else if (errno == EINTR) { 691 goto retry; 692 } else { 693 error_setg_errno(errp, errno, 694 "Unable to write to socket"); 695 return -1; 696 } 697 } 698 done += ret; 699 if (ret < iov[i].iov_len) { 700 return done; 701 } 702 } 703 704 return done; 705 } 706 #endif /* WIN32 */ 707 708 709 #ifdef QEMU_MSG_ZEROCOPY 710 static int qio_channel_socket_flush(QIOChannel *ioc, 711 Error **errp) 712 { 713 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 714 struct msghdr msg = {}; 715 struct sock_extended_err *serr; 716 struct cmsghdr *cm; 717 char control[CMSG_SPACE(sizeof(*serr))]; 718 int received; 719 int ret = 1; 720 721 msg.msg_control = control; 722 msg.msg_controllen = sizeof(control); 723 memset(control, 0, sizeof(control)); 724 725 while (sioc->zero_copy_sent < sioc->zero_copy_queued) { 726 received = recvmsg(sioc->fd, &msg, MSG_ERRQUEUE); 727 if (received < 0) { 728 switch (errno) { 729 case EAGAIN: 730 /* Nothing on errqueue, wait until something is available */ 731 qio_channel_wait(ioc, G_IO_ERR); 732 continue; 733 case EINTR: 734 continue; 735 default: 736 error_setg_errno(errp, errno, 737 "Unable to read errqueue"); 738 return -1; 739 } 740 } 741 742 cm = CMSG_FIRSTHDR(&msg); 743 if (cm->cmsg_level != SOL_IP && 744 cm->cmsg_type != IP_RECVERR) { 745 error_setg_errno(errp, EPROTOTYPE, 746 "Wrong cmsg in errqueue"); 747 return -1; 748 } 749 750 serr = (void *) CMSG_DATA(cm); 751 if (serr->ee_errno != SO_EE_ORIGIN_NONE) { 752 error_setg_errno(errp, serr->ee_errno, 753 "Error on socket"); 754 return -1; 755 } 756 if (serr->ee_origin != SO_EE_ORIGIN_ZEROCOPY) { 757 error_setg_errno(errp, serr->ee_origin, 758 "Error not from zero copy"); 759 return -1; 760 } 761 762 /* No errors, count successfully finished sendmsg()*/ 763 sioc->zero_copy_sent += serr->ee_data - serr->ee_info + 1; 764 765 /* If any sendmsg() succeeded using zero copy, return 0 at the end */ 766 if (serr->ee_code != SO_EE_CODE_ZEROCOPY_COPIED) { 767 ret = 0; 768 } 769 } 770 771 return ret; 772 } 773 774 #endif /* QEMU_MSG_ZEROCOPY */ 775 776 static int 777 qio_channel_socket_set_blocking(QIOChannel *ioc, 778 bool enabled, 779 Error **errp) 780 { 781 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 782 783 if (enabled) { 784 qemu_socket_set_block(sioc->fd); 785 } else { 786 qemu_socket_set_nonblock(sioc->fd); 787 } 788 return 0; 789 } 790 791 792 static void 793 qio_channel_socket_set_delay(QIOChannel *ioc, 794 bool enabled) 795 { 796 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 797 int v = enabled ? 0 : 1; 798 799 setsockopt(sioc->fd, 800 IPPROTO_TCP, TCP_NODELAY, 801 &v, sizeof(v)); 802 } 803 804 805 static void 806 qio_channel_socket_set_cork(QIOChannel *ioc, 807 bool enabled) 808 { 809 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 810 int v = enabled ? 1 : 0; 811 812 socket_set_cork(sioc->fd, v); 813 } 814 815 816 static int 817 qio_channel_socket_close(QIOChannel *ioc, 818 Error **errp) 819 { 820 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 821 int rc = 0; 822 Error *err = NULL; 823 824 if (sioc->fd != -1) { 825 #ifdef WIN32 826 WSAEventSelect(sioc->fd, NULL, 0); 827 #endif 828 if (qio_channel_has_feature(ioc, QIO_CHANNEL_FEATURE_LISTEN)) { 829 socket_listen_cleanup(sioc->fd, errp); 830 } 831 832 if (closesocket(sioc->fd) < 0) { 833 sioc->fd = -1; 834 error_setg_errno(&err, errno, "Unable to close socket"); 835 error_propagate(errp, err); 836 return -1; 837 } 838 sioc->fd = -1; 839 } 840 return rc; 841 } 842 843 static int 844 qio_channel_socket_shutdown(QIOChannel *ioc, 845 QIOChannelShutdown how, 846 Error **errp) 847 { 848 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 849 int sockhow; 850 851 switch (how) { 852 case QIO_CHANNEL_SHUTDOWN_READ: 853 sockhow = SHUT_RD; 854 break; 855 case QIO_CHANNEL_SHUTDOWN_WRITE: 856 sockhow = SHUT_WR; 857 break; 858 case QIO_CHANNEL_SHUTDOWN_BOTH: 859 default: 860 sockhow = SHUT_RDWR; 861 break; 862 } 863 864 if (shutdown(sioc->fd, sockhow) < 0) { 865 error_setg_errno(errp, errno, 866 "Unable to shutdown socket"); 867 return -1; 868 } 869 return 0; 870 } 871 872 static void qio_channel_socket_set_aio_fd_handler(QIOChannel *ioc, 873 AioContext *ctx, 874 IOHandler *io_read, 875 IOHandler *io_write, 876 void *opaque) 877 { 878 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 879 aio_set_fd_handler(ctx, sioc->fd, false, 880 io_read, io_write, NULL, NULL, opaque); 881 } 882 883 static GSource *qio_channel_socket_create_watch(QIOChannel *ioc, 884 GIOCondition condition) 885 { 886 QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc); 887 return qio_channel_create_socket_watch(ioc, 888 sioc->fd, 889 condition); 890 } 891 892 static void qio_channel_socket_class_init(ObjectClass *klass, 893 void *class_data G_GNUC_UNUSED) 894 { 895 QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass); 896 897 ioc_klass->io_writev = qio_channel_socket_writev; 898 ioc_klass->io_readv = qio_channel_socket_readv; 899 ioc_klass->io_set_blocking = qio_channel_socket_set_blocking; 900 ioc_klass->io_close = qio_channel_socket_close; 901 ioc_klass->io_shutdown = qio_channel_socket_shutdown; 902 ioc_klass->io_set_cork = qio_channel_socket_set_cork; 903 ioc_klass->io_set_delay = qio_channel_socket_set_delay; 904 ioc_klass->io_create_watch = qio_channel_socket_create_watch; 905 ioc_klass->io_set_aio_fd_handler = qio_channel_socket_set_aio_fd_handler; 906 #ifdef QEMU_MSG_ZEROCOPY 907 ioc_klass->io_flush = qio_channel_socket_flush; 908 #endif 909 } 910 911 static const TypeInfo qio_channel_socket_info = { 912 .parent = TYPE_QIO_CHANNEL, 913 .name = TYPE_QIO_CHANNEL_SOCKET, 914 .instance_size = sizeof(QIOChannelSocket), 915 .instance_init = qio_channel_socket_init, 916 .instance_finalize = qio_channel_socket_finalize, 917 .class_init = qio_channel_socket_class_init, 918 }; 919 920 static void qio_channel_socket_register_types(void) 921 { 922 type_register_static(&qio_channel_socket_info); 923 } 924 925 type_init(qio_channel_socket_register_types); 926