io_uring/net.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/errno.h>
   4 #include <linux/file.h>
   5 #include <linux/slab.h>
   6 #include <linux/net.h>
   7 #include <linux/compat.h>
   8 #include <net/compat.h>
   9 #include <linux/io_uring.h>
  10
  11 #include <uapi/linux/io_uring.h>
  12
  13 #include "io_uring.h"
  14 #include "kbuf.h"
  15 #include "alloc_cache.h"
  16 #include "net.h"
  17 #include "notif.h"
  18
  19 #if defined(CONFIG_NET)
  20 struct io_shutdown {
  21         struct file                     *file;
  22         int                             how;
  23 };
  24
  25 struct io_accept {
  26         struct file                     *file;
  27         struct sockaddr __user          *addr;
  28         int __user                      *addr_len;
  29         int                             flags;
  30         u32                             file_slot;
  31         unsigned long                   nofile;
  32 };
  33
  34 struct io_socket {
  35         struct file                     *file;
  36         int                             domain;
  37         int                             type;
  38         int                             protocol;
  39         int                             flags;
  40         u32                             file_slot;
  41         unsigned long                   nofile;
  42 };
  43
  44 struct io_connect {
  45         struct file                     *file;
  46         struct sockaddr __user          *addr;
  47         int                             addr_len;
  48 };
  49
  50 struct io_sr_msg {
  51         struct file                     *file;
  52         union {
  53                 struct compat_msghdr __user     *umsg_compat;
  54                 struct user_msghdr __user       *umsg;
  55                 void __user                     *buf;
  56         };
  57         int                             msg_flags;
  58         size_t                          len;
  59         size_t                          done_io;
  60         unsigned int                    flags;
  61 };
  62
  63 struct io_sendzc {
  64         struct file                     *file;
  65         void __user                     *buf;
  66         size_t                          len;
  67         u16                             slot_idx;
  68         unsigned                        msg_flags;
  69         unsigned                        flags;
  70         unsigned                        addr_len;
  71         void __user                     *addr;
  72 };
  73
  74 #define IO_APOLL_MULTI_POLLED (REQ_F_APOLL_MULTISHOT | REQ_F_POLLED)
  75
  76 int io_shutdown_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
  77 {
  78         struct io_shutdown *shutdown = io_kiocb_to_cmd(req);
  79
  80         if (unlikely(sqe->off || sqe->addr || sqe->rw_flags ||
  81                      sqe->buf_index || sqe->splice_fd_in))
  82                 return -EINVAL;
  83
  84         shutdown->how = READ_ONCE(sqe->len);
  85         return 0;
  86 }
  87
  88 int io_shutdown(struct io_kiocb *req, unsigned int issue_flags)
  89 {
  90         struct io_shutdown *shutdown = io_kiocb_to_cmd(req);
  91         struct socket *sock;
  92         int ret;
  93
  94         if (issue_flags & IO_URING_F_NONBLOCK)
  95                 return -EAGAIN;
  96
  97         sock = sock_from_file(req->file);
  98         if (unlikely(!sock))
  99                 return -ENOTSOCK;
 100
 101         ret = __sys_shutdown_sock(sock, shutdown->how);
 102         io_req_set_res(req, ret, 0);
 103         return IOU_OK;
 104 }
 105
 106 static bool io_net_retry(struct socket *sock, int flags)
 107 {
 108         if (!(flags & MSG_WAITALL))
 109                 return false;
 110         return sock->type == SOCK_STREAM || sock->type == SOCK_SEQPACKET;
 111 }
 112
 113 static void io_netmsg_recycle(struct io_kiocb *req, unsigned int issue_flags)
 114 {
 115         struct io_async_msghdr *hdr = req->async_data;
 116
 117         if (!hdr || issue_flags & IO_URING_F_UNLOCKED)
 118                 return;
 119
 120         /* Let normal cleanup path reap it if we fail adding to the cache */
 121         if (io_alloc_cache_put(&req->ctx->netmsg_cache, &hdr->cache)) {
 122                 req->async_data = NULL;
 123                 req->flags &= ~REQ_F_ASYNC_DATA;
 124         }
 125 }
 126
 127 static struct io_async_msghdr *io_recvmsg_alloc_async(struct io_kiocb *req,
 128                                                       unsigned int issue_flags)
 129 {
 130         struct io_ring_ctx *ctx = req->ctx;
 131         struct io_cache_entry *entry;
 132
 133         if (!(issue_flags & IO_URING_F_UNLOCKED) &&
 134             (entry = io_alloc_cache_get(&ctx->netmsg_cache)) != NULL) {
 135                 struct io_async_msghdr *hdr;
 136
 137                 hdr = container_of(entry, struct io_async_msghdr, cache);
 138                 req->flags |= REQ_F_ASYNC_DATA;
 139                 req->async_data = hdr;
 140                 return hdr;
 141         }
 142
 143         if (!io_alloc_async_data(req))
 144                 return req->async_data;
 145
 146         return NULL;
 147 }
 148
 149 static int io_setup_async_msg(struct io_kiocb *req,
 150                               struct io_async_msghdr *kmsg,
 151                               unsigned int issue_flags)
 152 {
 153         struct io_async_msghdr *async_msg = req->async_data;
 154
 155         if (async_msg)
 156                 return -EAGAIN;
 157         async_msg = io_recvmsg_alloc_async(req, issue_flags);
 158         if (!async_msg) {
 159                 kfree(kmsg->free_iov);
 160                 return -ENOMEM;
 161         }
 162         req->flags |= REQ_F_NEED_CLEANUP;
 163         memcpy(async_msg, kmsg, sizeof(*kmsg));
 164         async_msg->msg.msg_name = &async_msg->addr;
 165         /* if were using fast_iov, set it to the new one */
 166         if (!async_msg->free_iov)
 167                 async_msg->msg.msg_iter.iov = async_msg->fast_iov;
 168
 169         return -EAGAIN;
 170 }
 171
 172 static int io_sendmsg_copy_hdr(struct io_kiocb *req,
 173                                struct io_async_msghdr *iomsg)
 174 {
 175         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 176
 177         iomsg->msg.msg_name = &iomsg->addr;
 178         iomsg->free_iov = iomsg->fast_iov;
 179         return sendmsg_copy_msghdr(&iomsg->msg, sr->umsg, sr->msg_flags,
 180                                         &iomsg->free_iov);
 181 }
 182
 183 int io_sendmsg_prep_async(struct io_kiocb *req)
 184 {
 185         int ret;
 186
 187         ret = io_sendmsg_copy_hdr(req, req->async_data);
 188         if (!ret)
 189                 req->flags |= REQ_F_NEED_CLEANUP;
 190         return ret;
 191 }
 192
 193 void io_sendmsg_recvmsg_cleanup(struct io_kiocb *req)
 194 {
 195         struct io_async_msghdr *io = req->async_data;
 196
 197         kfree(io->free_iov);
 198 }
 199
 200 int io_sendmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 201 {
 202         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 203
 204         if (unlikely(sqe->file_index || sqe->addr2))
 205                 return -EINVAL;
 206
 207         sr->umsg = u64_to_user_ptr(READ_ONCE(sqe->addr));
 208         sr->len = READ_ONCE(sqe->len);
 209         sr->flags = READ_ONCE(sqe->ioprio);
 210         if (sr->flags & ~IORING_RECVSEND_POLL_FIRST)
 211                 return -EINVAL;
 212         sr->msg_flags = READ_ONCE(sqe->msg_flags) | MSG_NOSIGNAL;
 213         if (sr->msg_flags & MSG_DONTWAIT)
 214                 req->flags |= REQ_F_NOWAIT;
 215
 216 #ifdef CONFIG_COMPAT
 217         if (req->ctx->compat)
 218                 sr->msg_flags |= MSG_CMSG_COMPAT;
 219 #endif
 220         sr->done_io = 0;
 221         return 0;
 222 }
 223
 224 int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags)
 225 {
 226         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 227         struct io_async_msghdr iomsg, *kmsg;
 228         struct socket *sock;
 229         unsigned flags;
 230         int min_ret = 0;
 231         int ret;
 232
 233         sock = sock_from_file(req->file);
 234         if (unlikely(!sock))
 235                 return -ENOTSOCK;
 236
 237         if (req_has_async_data(req)) {
 238                 kmsg = req->async_data;
 239         } else {
 240                 ret = io_sendmsg_copy_hdr(req, &iomsg);
 241                 if (ret)
 242                         return ret;
 243                 kmsg = &iomsg;
 244         }
 245
 246         if (!(req->flags & REQ_F_POLLED) &&
 247             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 248                 return io_setup_async_msg(req, kmsg, issue_flags);
 249
 250         flags = sr->msg_flags;
 251         if (issue_flags & IO_URING_F_NONBLOCK)
 252                 flags |= MSG_DONTWAIT;
 253         if (flags & MSG_WAITALL)
 254                 min_ret = iov_iter_count(&kmsg->msg.msg_iter);
 255
 256         ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
 257
 258         if (ret < min_ret) {
 259                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
 260                         return io_setup_async_msg(req, kmsg, issue_flags);
 261                 if (ret == -ERESTARTSYS)
 262                         ret = -EINTR;
 263                 if (ret > 0 && io_net_retry(sock, flags)) {
 264                         sr->done_io += ret;
 265                         req->flags |= REQ_F_PARTIAL_IO;
 266                         return io_setup_async_msg(req, kmsg, issue_flags);
 267                 }
 268                 req_set_fail(req);
 269         }
 270         /* fast path, check for non-NULL to avoid function call */
 271         if (kmsg->free_iov)
 272                 kfree(kmsg->free_iov);
 273         req->flags &= ~REQ_F_NEED_CLEANUP;
 274         io_netmsg_recycle(req, issue_flags);
 275         if (ret >= 0)
 276                 ret += sr->done_io;
 277         else if (sr->done_io)
 278                 ret = sr->done_io;
 279         io_req_set_res(req, ret, 0);
 280         return IOU_OK;
 281 }
 282
 283 int io_send(struct io_kiocb *req, unsigned int issue_flags)
 284 {
 285         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 286         struct msghdr msg;
 287         struct iovec iov;
 288         struct socket *sock;
 289         unsigned flags;
 290         int min_ret = 0;
 291         int ret;
 292
 293         if (!(req->flags & REQ_F_POLLED) &&
 294             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 295                 return -EAGAIN;
 296
 297         sock = sock_from_file(req->file);
 298         if (unlikely(!sock))
 299                 return -ENOTSOCK;
 300
 301         ret = import_single_range(WRITE, sr->buf, sr->len, &iov, &msg.msg_iter);
 302         if (unlikely(ret))
 303                 return ret;
 304
 305         msg.msg_name = NULL;
 306         msg.msg_control = NULL;
 307         msg.msg_controllen = 0;
 308         msg.msg_namelen = 0;
 309         msg.msg_ubuf = NULL;
 310
 311         flags = sr->msg_flags;
 312         if (issue_flags & IO_URING_F_NONBLOCK)
 313                 flags |= MSG_DONTWAIT;
 314         if (flags & MSG_WAITALL)
 315                 min_ret = iov_iter_count(&msg.msg_iter);
 316
 317         msg.msg_flags = flags;
 318         ret = sock_sendmsg(sock, &msg);
 319         if (ret < min_ret) {
 320                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
 321                         return -EAGAIN;
 322                 if (ret == -ERESTARTSYS)
 323                         ret = -EINTR;
 324                 if (ret > 0 && io_net_retry(sock, flags)) {
 325                         sr->len -= ret;
 326                         sr->buf += ret;
 327                         sr->done_io += ret;
 328                         req->flags |= REQ_F_PARTIAL_IO;
 329                         return -EAGAIN;
 330                 }
 331                 req_set_fail(req);
 332         }
 333         if (ret >= 0)
 334                 ret += sr->done_io;
 335         else if (sr->done_io)
 336                 ret = sr->done_io;
 337         io_req_set_res(req, ret, 0);
 338         return IOU_OK;
 339 }
 340
 341 static bool io_recvmsg_multishot_overflow(struct io_async_msghdr *iomsg)
 342 {
 343         int hdr;
 344
 345         if (iomsg->namelen < 0)
 346                 return true;
 347         if (check_add_overflow((int)sizeof(struct io_uring_recvmsg_out),
 348                                iomsg->namelen, &hdr))
 349                 return true;
 350         if (check_add_overflow(hdr, (int)iomsg->controllen, &hdr))
 351                 return true;
 352
 353         return false;
 354 }
 355
 356 static int __io_recvmsg_copy_hdr(struct io_kiocb *req,
 357                                  struct io_async_msghdr *iomsg)
 358 {
 359         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 360         struct user_msghdr msg;
 361         int ret;
 362
 363         if (copy_from_user(&msg, sr->umsg, sizeof(*sr->umsg)))
 364                 return -EFAULT;
 365
 366         ret = __copy_msghdr(&iomsg->msg, &msg, &iomsg->uaddr);
 367         if (ret)
 368                 return ret;
 369
 370         if (req->flags & REQ_F_BUFFER_SELECT) {
 371                 if (msg.msg_iovlen == 0) {
 372                         sr->len = iomsg->fast_iov[0].iov_len = 0;
 373                         iomsg->fast_iov[0].iov_base = NULL;
 374                         iomsg->free_iov = NULL;
 375                 } else if (msg.msg_iovlen > 1) {
 376                         return -EINVAL;
 377                 } else {
 378                         if (copy_from_user(iomsg->fast_iov, msg.msg_iov, sizeof(*msg.msg_iov)))
 379                                 return -EFAULT;
 380                         sr->len = iomsg->fast_iov[0].iov_len;
 381                         iomsg->free_iov = NULL;
 382                 }
 383
 384                 if (req->flags & REQ_F_APOLL_MULTISHOT) {
 385                         iomsg->namelen = msg.msg_namelen;
 386                         iomsg->controllen = msg.msg_controllen;
 387                         if (io_recvmsg_multishot_overflow(iomsg))
 388                                 return -EOVERFLOW;
 389                 }
 390         } else {
 391                 iomsg->free_iov = iomsg->fast_iov;
 392                 ret = __import_iovec(READ, msg.msg_iov, msg.msg_iovlen, UIO_FASTIOV,
 393                                      &iomsg->free_iov, &iomsg->msg.msg_iter,
 394                                      false);
 395                 if (ret > 0)
 396                         ret = 0;
 397         }
 398
 399         return ret;
 400 }
 401
 402 #ifdef CONFIG_COMPAT
 403 static int __io_compat_recvmsg_copy_hdr(struct io_kiocb *req,
 404                                         struct io_async_msghdr *iomsg)
 405 {
 406         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 407         struct compat_msghdr msg;
 408         struct compat_iovec __user *uiov;
 409         int ret;
 410
 411         if (copy_from_user(&msg, sr->umsg_compat, sizeof(msg)))
 412                 return -EFAULT;
 413
 414         ret = __get_compat_msghdr(&iomsg->msg, &msg, &iomsg->uaddr);
 415         if (ret)
 416                 return ret;
 417
 418         uiov = compat_ptr(msg.msg_iov);
 419         if (req->flags & REQ_F_BUFFER_SELECT) {
 420                 compat_ssize_t clen;
 421
 422                 if (msg.msg_iovlen == 0) {
 423                         sr->len = 0;
 424                         iomsg->free_iov = NULL;
 425                 } else if (msg.msg_iovlen > 1) {
 426                         return -EINVAL;
 427                 } else {
 428                         if (!access_ok(uiov, sizeof(*uiov)))
 429                                 return -EFAULT;
 430                         if (__get_user(clen, &uiov->iov_len))
 431                                 return -EFAULT;
 432                         if (clen < 0)
 433                                 return -EINVAL;
 434                         sr->len = clen;
 435                         iomsg->free_iov = NULL;
 436                 }
 437
 438                 if (req->flags & REQ_F_APOLL_MULTISHOT) {
 439                         iomsg->namelen = msg.msg_namelen;
 440                         iomsg->controllen = msg.msg_controllen;
 441                         if (io_recvmsg_multishot_overflow(iomsg))
 442                                 return -EOVERFLOW;
 443                 }
 444         } else {
 445                 iomsg->free_iov = iomsg->fast_iov;
 446                 ret = __import_iovec(READ, (struct iovec __user *)uiov, msg.msg_iovlen,
 447                                    UIO_FASTIOV, &iomsg->free_iov,
 448                                    &iomsg->msg.msg_iter, true);
 449                 if (ret < 0)
 450                         return ret;
 451         }
 452
 453         return 0;
 454 }
 455 #endif
 456
 457 static int io_recvmsg_copy_hdr(struct io_kiocb *req,
 458                                struct io_async_msghdr *iomsg)
 459 {
 460         iomsg->msg.msg_name = &iomsg->addr;
 461
 462 #ifdef CONFIG_COMPAT
 463         if (req->ctx->compat)
 464                 return __io_compat_recvmsg_copy_hdr(req, iomsg);
 465 #endif
 466
 467         return __io_recvmsg_copy_hdr(req, iomsg);
 468 }
 469
 470 int io_recvmsg_prep_async(struct io_kiocb *req)
 471 {
 472         int ret;
 473
 474         ret = io_recvmsg_copy_hdr(req, req->async_data);
 475         if (!ret)
 476                 req->flags |= REQ_F_NEED_CLEANUP;
 477         return ret;
 478 }
 479
 480 #define RECVMSG_FLAGS (IORING_RECVSEND_POLL_FIRST | IORING_RECV_MULTISHOT)
 481
 482 int io_recvmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 483 {
 484         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 485
 486         if (unlikely(sqe->file_index || sqe->addr2))
 487                 return -EINVAL;
 488
 489         sr->umsg = u64_to_user_ptr(READ_ONCE(sqe->addr));
 490         sr->len = READ_ONCE(sqe->len);
 491         sr->flags = READ_ONCE(sqe->ioprio);
 492         if (sr->flags & ~(RECVMSG_FLAGS))
 493                 return -EINVAL;
 494         sr->msg_flags = READ_ONCE(sqe->msg_flags) | MSG_NOSIGNAL;
 495         if (sr->msg_flags & MSG_DONTWAIT)
 496                 req->flags |= REQ_F_NOWAIT;
 497         if (sr->msg_flags & MSG_ERRQUEUE)
 498                 req->flags |= REQ_F_CLEAR_POLLIN;
 499         if (sr->flags & IORING_RECV_MULTISHOT) {
 500                 if (!(req->flags & REQ_F_BUFFER_SELECT))
 501                         return -EINVAL;
 502                 if (sr->msg_flags & MSG_WAITALL)
 503                         return -EINVAL;
 504                 if (req->opcode == IORING_OP_RECV && sr->len)
 505                         return -EINVAL;
 506                 req->flags |= REQ_F_APOLL_MULTISHOT;
 507         }
 508
 509 #ifdef CONFIG_COMPAT
 510         if (req->ctx->compat)
 511                 sr->msg_flags |= MSG_CMSG_COMPAT;
 512 #endif
 513         sr->done_io = 0;
 514         return 0;
 515 }
 516
 517 static inline void io_recv_prep_retry(struct io_kiocb *req)
 518 {
 519         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 520
 521         sr->done_io = 0;
 522         sr->len = 0; /* get from the provided buffer */
 523 }
 524
 525 /*
 526  * Finishes io_recv and io_recvmsg.
 527  *
 528  * Returns true if it is actually finished, or false if it should run
 529  * again (for multishot).
 530  */
 531 static inline bool io_recv_finish(struct io_kiocb *req, int *ret,
 532                                   unsigned int cflags, bool mshot_finished)
 533 {
 534         if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
 535                 io_req_set_res(req, *ret, cflags);
 536                 *ret = IOU_OK;
 537                 return true;
 538         }
 539
 540         if (!mshot_finished) {
 541                 if (io_post_aux_cqe(req->ctx, req->cqe.user_data, *ret,
 542                                     cflags | IORING_CQE_F_MORE, false)) {
 543                         io_recv_prep_retry(req);
 544                         return false;
 545                 }
 546                 /*
 547                  * Otherwise stop multishot but use the current result.
 548                  * Probably will end up going into overflow, but this means
 549                  * we cannot trust the ordering anymore
 550                  */
 551         }
 552
 553         io_req_set_res(req, *ret, cflags);
 554
 555         if (req->flags & REQ_F_POLLED)
 556                 *ret = IOU_STOP_MULTISHOT;
 557         else
 558                 *ret = IOU_OK;
 559         return true;
 560 }
 561
 562 static int io_recvmsg_prep_multishot(struct io_async_msghdr *kmsg,
 563                                      struct io_sr_msg *sr, void __user **buf,
 564                                      size_t *len)
 565 {
 566         unsigned long ubuf = (unsigned long) *buf;
 567         unsigned long hdr;
 568
 569         hdr = sizeof(struct io_uring_recvmsg_out) + kmsg->namelen +
 570                 kmsg->controllen;
 571         if (*len < hdr)
 572                 return -EFAULT;
 573
 574         if (kmsg->controllen) {
 575                 unsigned long control = ubuf + hdr - kmsg->controllen;
 576
 577                 kmsg->msg.msg_control_user = (void *) control;
 578                 kmsg->msg.msg_controllen = kmsg->controllen;
 579         }
 580
 581         sr->buf = *buf; /* stash for later copy */
 582         *buf = (void *) (ubuf + hdr);
 583         kmsg->payloadlen = *len = *len - hdr;
 584         return 0;
 585 }
 586
 587 struct io_recvmsg_multishot_hdr {
 588         struct io_uring_recvmsg_out msg;
 589         struct sockaddr_storage addr;
 590 };
 591
 592 static int io_recvmsg_multishot(struct socket *sock, struct io_sr_msg *io,
 593                                 struct io_async_msghdr *kmsg,
 594                                 unsigned int flags, bool *finished)
 595 {
 596         int err;
 597         int copy_len;
 598         struct io_recvmsg_multishot_hdr hdr;
 599
 600         if (kmsg->namelen)
 601                 kmsg->msg.msg_name = &hdr.addr;
 602         kmsg->msg.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
 603         kmsg->msg.msg_namelen = 0;
 604
 605         if (sock->file->f_flags & O_NONBLOCK)
 606                 flags |= MSG_DONTWAIT;
 607
 608         err = sock_recvmsg(sock, &kmsg->msg, flags);
 609         *finished = err <= 0;
 610         if (err < 0)
 611                 return err;
 612
 613         hdr.msg = (struct io_uring_recvmsg_out) {
 614                 .controllen = kmsg->controllen - kmsg->msg.msg_controllen,
 615                 .flags = kmsg->msg.msg_flags & ~MSG_CMSG_COMPAT
 616         };
 617
 618         hdr.msg.payloadlen = err;
 619         if (err > kmsg->payloadlen)
 620                 err = kmsg->payloadlen;
 621
 622         copy_len = sizeof(struct io_uring_recvmsg_out);
 623         if (kmsg->msg.msg_namelen > kmsg->namelen)
 624                 copy_len += kmsg->namelen;
 625         else
 626                 copy_len += kmsg->msg.msg_namelen;
 627
 628         /*
 629          *      "fromlen shall refer to the value before truncation.."
 630          *                      1003.1g
 631          */
 632         hdr.msg.namelen = kmsg->msg.msg_namelen;
 633
 634         /* ensure that there is no gap between hdr and sockaddr_storage */
 635         BUILD_BUG_ON(offsetof(struct io_recvmsg_multishot_hdr, addr) !=
 636                      sizeof(struct io_uring_recvmsg_out));
 637         if (copy_to_user(io->buf, &hdr, copy_len)) {
 638                 *finished = true;
 639                 return -EFAULT;
 640         }
 641
 642         return sizeof(struct io_uring_recvmsg_out) + kmsg->namelen +
 643                         kmsg->controllen + err;
 644 }
 645
 646 int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags)
 647 {
 648         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 649         struct io_async_msghdr iomsg, *kmsg;
 650         struct socket *sock;
 651         unsigned int cflags;
 652         unsigned flags;
 653         int ret, min_ret = 0;
 654         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
 655         bool mshot_finished = true;
 656
 657         sock = sock_from_file(req->file);
 658         if (unlikely(!sock))
 659                 return -ENOTSOCK;
 660
 661         if (req_has_async_data(req)) {
 662                 kmsg = req->async_data;
 663         } else {
 664                 ret = io_recvmsg_copy_hdr(req, &iomsg);
 665                 if (ret)
 666                         return ret;
 667                 kmsg = &iomsg;
 668         }
 669
 670         if (!(req->flags & REQ_F_POLLED) &&
 671             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 672                 return io_setup_async_msg(req, kmsg, issue_flags);
 673
 674 retry_multishot:
 675         if (io_do_buffer_select(req)) {
 676                 void __user *buf;
 677                 size_t len = sr->len;
 678
 679                 buf = io_buffer_select(req, &len, issue_flags);
 680                 if (!buf)
 681                         return -ENOBUFS;
 682
 683                 if (req->flags & REQ_F_APOLL_MULTISHOT) {
 684                         ret = io_recvmsg_prep_multishot(kmsg, sr, &buf, &len);
 685                         if (ret) {
 686                                 io_kbuf_recycle(req, issue_flags);
 687                                 return ret;
 688                         }
 689                 }
 690
 691                 kmsg->fast_iov[0].iov_base = buf;
 692                 kmsg->fast_iov[0].iov_len = len;
 693                 iov_iter_init(&kmsg->msg.msg_iter, READ, kmsg->fast_iov, 1,
 694                                 len);
 695         }
 696
 697         flags = sr->msg_flags;
 698         if (force_nonblock)
 699                 flags |= MSG_DONTWAIT;
 700         if (flags & MSG_WAITALL)
 701                 min_ret = iov_iter_count(&kmsg->msg.msg_iter);
 702
 703         kmsg->msg.msg_get_inq = 1;
 704         if (req->flags & REQ_F_APOLL_MULTISHOT)
 705                 ret = io_recvmsg_multishot(sock, sr, kmsg, flags,
 706                                            &mshot_finished);
 707         else
 708                 ret = __sys_recvmsg_sock(sock, &kmsg->msg, sr->umsg,
 709                                          kmsg->uaddr, flags);
 710
 711         if (ret < min_ret) {
 712                 if (ret == -EAGAIN && force_nonblock) {
 713                         ret = io_setup_async_msg(req, kmsg, issue_flags);
 714                         if (ret == -EAGAIN && (req->flags & IO_APOLL_MULTI_POLLED) ==
 715                                                IO_APOLL_MULTI_POLLED) {
 716                                 io_kbuf_recycle(req, issue_flags);
 717                                 return IOU_ISSUE_SKIP_COMPLETE;
 718                         }
 719                         return ret;
 720                 }
 721                 if (ret == -ERESTARTSYS)
 722                         ret = -EINTR;
 723                 if (ret > 0 && io_net_retry(sock, flags)) {
 724                         sr->done_io += ret;
 725                         req->flags |= REQ_F_PARTIAL_IO;
 726                         return io_setup_async_msg(req, kmsg, issue_flags);
 727                 }
 728                 req_set_fail(req);
 729         } else if ((flags & MSG_WAITALL) && (kmsg->msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC))) {
 730                 req_set_fail(req);
 731         }
 732
 733         if (ret > 0)
 734                 ret += sr->done_io;
 735         else if (sr->done_io)
 736                 ret = sr->done_io;
 737         else
 738                 io_kbuf_recycle(req, issue_flags);
 739
 740         cflags = io_put_kbuf(req, issue_flags);
 741         if (kmsg->msg.msg_inq)
 742                 cflags |= IORING_CQE_F_SOCK_NONEMPTY;
 743
 744         if (!io_recv_finish(req, &ret, cflags, mshot_finished))
 745                 goto retry_multishot;
 746
 747         if (mshot_finished) {
 748                 io_netmsg_recycle(req, issue_flags);
 749                 /* fast path, check for non-NULL to avoid function call */
 750                 if (kmsg->free_iov)
 751                         kfree(kmsg->free_iov);
 752                 req->flags &= ~REQ_F_NEED_CLEANUP;
 753         }
 754
 755         return ret;
 756 }
 757
 758 int io_recv(struct io_kiocb *req, unsigned int issue_flags)
 759 {
 760         struct io_sr_msg *sr = io_kiocb_to_cmd(req);
 761         struct msghdr msg;
 762         struct socket *sock;
 763         struct iovec iov;
 764         unsigned int cflags;
 765         unsigned flags;
 766         int ret, min_ret = 0;
 767         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
 768         size_t len = sr->len;
 769
 770         if (!(req->flags & REQ_F_POLLED) &&
 771             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 772                 return -EAGAIN;
 773
 774         sock = sock_from_file(req->file);
 775         if (unlikely(!sock))
 776                 return -ENOTSOCK;
 777
 778 retry_multishot:
 779         if (io_do_buffer_select(req)) {
 780                 void __user *buf;
 781
 782                 buf = io_buffer_select(req, &len, issue_flags);
 783                 if (!buf)
 784                         return -ENOBUFS;
 785                 sr->buf = buf;
 786         }
 787
 788         ret = import_single_range(READ, sr->buf, len, &iov, &msg.msg_iter);
 789         if (unlikely(ret))
 790                 goto out_free;
 791
 792         msg.msg_name = NULL;
 793         msg.msg_namelen = 0;
 794         msg.msg_control = NULL;
 795         msg.msg_get_inq = 1;
 796         msg.msg_flags = 0;
 797         msg.msg_controllen = 0;
 798         msg.msg_iocb = NULL;
 799         msg.msg_ubuf = NULL;
 800
 801         flags = sr->msg_flags;
 802         if (force_nonblock)
 803                 flags |= MSG_DONTWAIT;
 804         if (flags & MSG_WAITALL)
 805                 min_ret = iov_iter_count(&msg.msg_iter);
 806
 807         ret = sock_recvmsg(sock, &msg, flags);
 808         if (ret < min_ret) {
 809                 if (ret == -EAGAIN && force_nonblock) {
 810                         if ((req->flags & IO_APOLL_MULTI_POLLED) == IO_APOLL_MULTI_POLLED) {
 811                                 io_kbuf_recycle(req, issue_flags);
 812                                 return IOU_ISSUE_SKIP_COMPLETE;
 813                         }
 814
 815                         return -EAGAIN;
 816                 }
 817                 if (ret == -ERESTARTSYS)
 818                         ret = -EINTR;
 819                 if (ret > 0 && io_net_retry(sock, flags)) {
 820                         sr->len -= ret;
 821                         sr->buf += ret;
 822                         sr->done_io += ret;
 823                         req->flags |= REQ_F_PARTIAL_IO;
 824                         return -EAGAIN;
 825                 }
 826                 req_set_fail(req);
 827         } else if ((flags & MSG_WAITALL) && (msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC))) {
 828 out_free:
 829                 req_set_fail(req);
 830         }
 831
 832         if (ret > 0)
 833                 ret += sr->done_io;
 834         else if (sr->done_io)
 835                 ret = sr->done_io;
 836         else
 837                 io_kbuf_recycle(req, issue_flags);
 838
 839         cflags = io_put_kbuf(req, issue_flags);
 840         if (msg.msg_inq)
 841                 cflags |= IORING_CQE_F_SOCK_NONEMPTY;
 842
 843         if (!io_recv_finish(req, &ret, cflags, ret <= 0))
 844                 goto retry_multishot;
 845
 846         return ret;
 847 }
 848
 849 int io_sendzc_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 850 {
 851         struct io_sendzc *zc = io_kiocb_to_cmd(req);
 852
 853         if (READ_ONCE(sqe->__pad2[0]) || READ_ONCE(sqe->addr3))
 854                 return -EINVAL;
 855
 856         zc->flags = READ_ONCE(sqe->ioprio);
 857         if (zc->flags & ~IORING_RECVSEND_POLL_FIRST)
 858                 return -EINVAL;
 859
 860         zc->buf = u64_to_user_ptr(READ_ONCE(sqe->addr));
 861         zc->len = READ_ONCE(sqe->len);
 862         zc->msg_flags = READ_ONCE(sqe->msg_flags) | MSG_NOSIGNAL;
 863         zc->slot_idx = READ_ONCE(sqe->notification_idx);
 864         if (zc->msg_flags & MSG_DONTWAIT)
 865                 req->flags |= REQ_F_NOWAIT;
 866
 867         zc->addr = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 868         zc->addr_len = READ_ONCE(sqe->addr_len);
 869
 870 #ifdef CONFIG_COMPAT
 871         if (req->ctx->compat)
 872                 zc->msg_flags |= MSG_CMSG_COMPAT;
 873 #endif
 874         return 0;
 875 }
 876
 877 int io_sendzc(struct io_kiocb *req, unsigned int issue_flags)
 878 {
 879         struct sockaddr_storage address;
 880         struct io_ring_ctx *ctx = req->ctx;
 881         struct io_sendzc *zc = io_kiocb_to_cmd(req);
 882         struct io_notif_slot *notif_slot;
 883         struct io_notif *notif;
 884         struct msghdr msg;
 885         struct iovec iov;
 886         struct socket *sock;
 887         unsigned msg_flags;
 888         int ret, min_ret = 0;
 889
 890         if (!(req->flags & REQ_F_POLLED) &&
 891             (zc->flags & IORING_RECVSEND_POLL_FIRST))
 892                 return -EAGAIN;
 893
 894         if (issue_flags & IO_URING_F_UNLOCKED)
 895                 return -EAGAIN;
 896         sock = sock_from_file(req->file);
 897         if (unlikely(!sock))
 898                 return -ENOTSOCK;
 899
 900         notif_slot = io_get_notif_slot(ctx, zc->slot_idx);
 901         if (!notif_slot)
 902                 return -EINVAL;
 903         notif = io_get_notif(ctx, notif_slot);
 904         if (!notif)
 905                 return -ENOMEM;
 906
 907         msg.msg_name = NULL;
 908         msg.msg_control = NULL;
 909         msg.msg_controllen = 0;
 910         msg.msg_namelen = 0;
 911
 912         ret = import_single_range(WRITE, zc->buf, zc->len, &iov, &msg.msg_iter);
 913         if (unlikely(ret))
 914                 return ret;
 915         mm_account_pinned_pages(&notif->uarg.mmp, zc->len);
 916
 917         if (zc->addr) {
 918                 ret = move_addr_to_kernel(zc->addr, zc->addr_len, &address);
 919                 if (unlikely(ret < 0))
 920                         return ret;
 921                 msg.msg_name = (struct sockaddr *)&address;
 922                 msg.msg_namelen = zc->addr_len;
 923         }
 924
 925         msg_flags = zc->msg_flags | MSG_ZEROCOPY;
 926         if (issue_flags & IO_URING_F_NONBLOCK)
 927                 msg_flags |= MSG_DONTWAIT;
 928         if (msg_flags & MSG_WAITALL)
 929                 min_ret = iov_iter_count(&msg.msg_iter);
 930
 931         msg.msg_flags = msg_flags;
 932         msg.msg_ubuf = &notif->uarg;
 933         msg.sg_from_iter = NULL;
 934         ret = sock_sendmsg(sock, &msg);
 935
 936         if (unlikely(ret < min_ret)) {
 937                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
 938                         return -EAGAIN;
 939                 return ret == -ERESTARTSYS ? -EINTR : ret;
 940         }
 941
 942         io_req_set_res(req, ret, 0);
 943         return IOU_OK;
 944 }
 945
 946 int io_accept_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 947 {
 948         struct io_accept *accept = io_kiocb_to_cmd(req);
 949         unsigned flags;
 950
 951         if (sqe->len || sqe->buf_index)
 952                 return -EINVAL;
 953
 954         accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
 955         accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 956         accept->flags = READ_ONCE(sqe->accept_flags);
 957         accept->nofile = rlimit(RLIMIT_NOFILE);
 958         flags = READ_ONCE(sqe->ioprio);
 959         if (flags & ~IORING_ACCEPT_MULTISHOT)
 960                 return -EINVAL;
 961
 962         accept->file_slot = READ_ONCE(sqe->file_index);
 963         if (accept->file_slot) {
 964                 if (accept->flags & SOCK_CLOEXEC)
 965                         return -EINVAL;
 966                 if (flags & IORING_ACCEPT_MULTISHOT &&
 967                     accept->file_slot != IORING_FILE_INDEX_ALLOC)
 968                         return -EINVAL;
 969         }
 970         if (accept->flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
 971                 return -EINVAL;
 972         if (SOCK_NONBLOCK != O_NONBLOCK && (accept->flags & SOCK_NONBLOCK))
 973                 accept->flags = (accept->flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
 974         if (flags & IORING_ACCEPT_MULTISHOT)
 975                 req->flags |= REQ_F_APOLL_MULTISHOT;
 976         return 0;
 977 }
 978
 979 int io_accept(struct io_kiocb *req, unsigned int issue_flags)
 980 {
 981         struct io_ring_ctx *ctx = req->ctx;
 982         struct io_accept *accept = io_kiocb_to_cmd(req);
 983         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
 984         unsigned int file_flags = force_nonblock ? O_NONBLOCK : 0;
 985         bool fixed = !!accept->file_slot;
 986         struct file *file;
 987         int ret, fd;
 988
 989 retry:
 990         if (!fixed) {
 991                 fd = __get_unused_fd_flags(accept->flags, accept->nofile);
 992                 if (unlikely(fd < 0))
 993                         return fd;
 994         }
 995         file = do_accept(req->file, file_flags, accept->addr, accept->addr_len,
 996                          accept->flags);
 997         if (IS_ERR(file)) {
 998                 if (!fixed)
 999                         put_unused_fd(fd);
1000                 ret = PTR_ERR(file);
1001                 if (ret == -EAGAIN && force_nonblock) {
1002                         /*
1003                          * if it's multishot and polled, we don't need to
1004                          * return EAGAIN to arm the poll infra since it
1005                          * has already been done
1006                          */
1007                         if ((req->flags & IO_APOLL_MULTI_POLLED) ==
1008                             IO_APOLL_MULTI_POLLED)
1009                                 ret = IOU_ISSUE_SKIP_COMPLETE;
1010                         return ret;
1011                 }
1012                 if (ret == -ERESTARTSYS)
1013                         ret = -EINTR;
1014                 req_set_fail(req);
1015         } else if (!fixed) {
1016                 fd_install(fd, file);
1017                 ret = fd;
1018         } else {
1019                 ret = io_fixed_fd_install(req, issue_flags, file,
1020                                                 accept->file_slot);
1021         }
1022
1023         if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
1024                 io_req_set_res(req, ret, 0);
1025                 return IOU_OK;
1026         }
1027
1028         if (ret >= 0 &&
1029             io_post_aux_cqe(ctx, req->cqe.user_data, ret, IORING_CQE_F_MORE, false))
1030                 goto retry;
1031
1032         io_req_set_res(req, ret, 0);
1033         if (req->flags & REQ_F_POLLED)
1034                 return IOU_STOP_MULTISHOT;
1035         return IOU_OK;
1036 }
1037
1038 int io_socket_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
1039 {
1040         struct io_socket *sock = io_kiocb_to_cmd(req);
1041
1042         if (sqe->addr || sqe->rw_flags || sqe->buf_index)
1043                 return -EINVAL;
1044
1045         sock->domain = READ_ONCE(sqe->fd);
1046         sock->type = READ_ONCE(sqe->off);
1047         sock->protocol = READ_ONCE(sqe->len);
1048         sock->file_slot = READ_ONCE(sqe->file_index);
1049         sock->nofile = rlimit(RLIMIT_NOFILE);
1050
1051         sock->flags = sock->type & ~SOCK_TYPE_MASK;
1052         if (sock->file_slot && (sock->flags & SOCK_CLOEXEC))
1053                 return -EINVAL;
1054         if (sock->flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1055                 return -EINVAL;
1056         return 0;
1057 }
1058
1059 int io_socket(struct io_kiocb *req, unsigned int issue_flags)
1060 {
1061         struct io_socket *sock = io_kiocb_to_cmd(req);
1062         bool fixed = !!sock->file_slot;
1063         struct file *file;
1064         int ret, fd;
1065
1066         if (!fixed) {
1067                 fd = __get_unused_fd_flags(sock->flags, sock->nofile);
1068                 if (unlikely(fd < 0))
1069                         return fd;
1070         }
1071         file = __sys_socket_file(sock->domain, sock->type, sock->protocol);
1072         if (IS_ERR(file)) {
1073                 if (!fixed)
1074                         put_unused_fd(fd);
1075                 ret = PTR_ERR(file);
1076                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
1077                         return -EAGAIN;
1078                 if (ret == -ERESTARTSYS)
1079                         ret = -EINTR;
1080                 req_set_fail(req);
1081         } else if (!fixed) {
1082                 fd_install(fd, file);
1083                 ret = fd;
1084         } else {
1085                 ret = io_fixed_fd_install(req, issue_flags, file,
1086                                             sock->file_slot);
1087         }
1088         io_req_set_res(req, ret, 0);
1089         return IOU_OK;
1090 }
1091
1092 int io_connect_prep_async(struct io_kiocb *req)
1093 {
1094         struct io_async_connect *io = req->async_data;
1095         struct io_connect *conn = io_kiocb_to_cmd(req);
1096
1097         return move_addr_to_kernel(conn->addr, conn->addr_len, &io->address);
1098 }
1099
1100 int io_connect_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
1101 {
1102         struct io_connect *conn = io_kiocb_to_cmd(req);
1103
1104         if (sqe->len || sqe->buf_index || sqe->rw_flags || sqe->splice_fd_in)
1105                 return -EINVAL;
1106
1107         conn->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
1108         conn->addr_len =  READ_ONCE(sqe->addr2);
1109         return 0;
1110 }
1111
1112 int io_connect(struct io_kiocb *req, unsigned int issue_flags)
1113 {
1114         struct io_connect *connect = io_kiocb_to_cmd(req);
1115         struct io_async_connect __io, *io;
1116         unsigned file_flags;
1117         int ret;
1118         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
1119
1120         if (req_has_async_data(req)) {
1121                 io = req->async_data;
1122         } else {
1123                 ret = move_addr_to_kernel(connect->addr,
1124                                                 connect->addr_len,
1125                                                 &__io.address);
1126                 if (ret)
1127                         goto out;
1128                 io = &__io;
1129         }
1130
1131         file_flags = force_nonblock ? O_NONBLOCK : 0;
1132
1133         ret = __sys_connect_file(req->file, &io->address,
1134                                         connect->addr_len, file_flags);
1135         if ((ret == -EAGAIN || ret == -EINPROGRESS) && force_nonblock) {
1136                 if (req_has_async_data(req))
1137                         return -EAGAIN;
1138                 if (io_alloc_async_data(req)) {
1139                         ret = -ENOMEM;
1140                         goto out;
1141                 }
1142                 memcpy(req->async_data, &__io, sizeof(__io));
1143                 return -EAGAIN;
1144         }
1145         if (ret == -ERESTARTSYS)
1146                 ret = -EINTR;
1147 out:
1148         if (ret < 0)
1149                 req_set_fail(req);
1150         io_req_set_res(req, ret, 0);
1151         return IOU_OK;
1152 }
1153
1154 void io_netmsg_cache_free(struct io_cache_entry *entry)
1155 {
1156         kfree(container_of(entry, struct io_async_msghdr, cache));
1157 }
1158 #endif