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 #include "rsrc.h"
  19
  20 #if defined(CONFIG_NET)
  21 struct io_shutdown {
  22         struct file                     *file;
  23         int                             how;
  24 };
  25
  26 struct io_accept {
  27         struct file                     *file;
  28         struct sockaddr __user          *addr;
  29         int __user                      *addr_len;
  30         int                             flags;
  31         u32                             file_slot;
  32         unsigned long                   nofile;
  33 };
  34
  35 struct io_socket {
  36         struct file                     *file;
  37         int                             domain;
  38         int                             type;
  39         int                             protocol;
  40         int                             flags;
  41         u32                             file_slot;
  42         unsigned long                   nofile;
  43 };
  44
  45 struct io_connect {
  46         struct file                     *file;
  47         struct sockaddr __user          *addr;
  48         int                             addr_len;
  49         bool                            in_progress;
  50         bool                            seen_econnaborted;
  51 };
  52
  53 struct io_sr_msg {
  54         struct file                     *file;
  55         union {
  56                 struct compat_msghdr __user     *umsg_compat;
  57                 struct user_msghdr __user       *umsg;
  58                 void __user                     *buf;
  59         };
  60         unsigned                        len;
  61         unsigned                        done_io;
  62         unsigned                        msg_flags;
  63         u16                             flags;
  64         /* initialised and used only by !msg send variants */
  65         u16                             addr_len;
  66         u16                             buf_group;
  67         void __user                     *addr;
  68         void __user                     *msg_control;
  69         /* used only for send zerocopy */
  70         struct io_kiocb                 *notif;
  71 };
  72
  73 int io_shutdown_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
  74 {
  75         struct io_shutdown *shutdown = io_kiocb_to_cmd(req, struct io_shutdown);
  76
  77         if (unlikely(sqe->off || sqe->addr || sqe->rw_flags ||
  78                      sqe->buf_index || sqe->splice_fd_in))
  79                 return -EINVAL;
  80
  81         shutdown->how = READ_ONCE(sqe->len);
  82         return 0;
  83 }
  84
  85 int io_shutdown(struct io_kiocb *req, unsigned int issue_flags)
  86 {
  87         struct io_shutdown *shutdown = io_kiocb_to_cmd(req, struct io_shutdown);
  88         struct socket *sock;
  89         int ret;
  90
  91         if (issue_flags & IO_URING_F_NONBLOCK)
  92                 return -EAGAIN;
  93
  94         sock = sock_from_file(req->file);
  95         if (unlikely(!sock))
  96                 return -ENOTSOCK;
  97
  98         ret = __sys_shutdown_sock(sock, shutdown->how);
  99         io_req_set_res(req, ret, 0);
 100         return IOU_OK;
 101 }
 102
 103 static bool io_net_retry(struct socket *sock, int flags)
 104 {
 105         if (!(flags & MSG_WAITALL))
 106                 return false;
 107         return sock->type == SOCK_STREAM || sock->type == SOCK_SEQPACKET;
 108 }
 109
 110 static void io_netmsg_recycle(struct io_kiocb *req, unsigned int issue_flags)
 111 {
 112         struct io_async_msghdr *hdr = req->async_data;
 113
 114         if (!req_has_async_data(req) || issue_flags & IO_URING_F_UNLOCKED)
 115                 return;
 116
 117         /* Let normal cleanup path reap it if we fail adding to the cache */
 118         if (io_alloc_cache_put(&req->ctx->netmsg_cache, &hdr->cache)) {
 119                 req->async_data = NULL;
 120                 req->flags &= ~REQ_F_ASYNC_DATA;
 121         }
 122 }
 123
 124 static struct io_async_msghdr *io_msg_alloc_async(struct io_kiocb *req,
 125                                                   unsigned int issue_flags)
 126 {
 127         struct io_ring_ctx *ctx = req->ctx;
 128         struct io_cache_entry *entry;
 129         struct io_async_msghdr *hdr;
 130
 131         if (!(issue_flags & IO_URING_F_UNLOCKED)) {
 132                 entry = io_alloc_cache_get(&ctx->netmsg_cache);
 133                 if (entry) {
 134                         hdr = container_of(entry, struct io_async_msghdr, cache);
 135                         hdr->free_iov = NULL;
 136                         req->flags |= REQ_F_ASYNC_DATA;
 137                         req->async_data = hdr;
 138                         return hdr;
 139                 }
 140         }
 141
 142         if (!io_alloc_async_data(req)) {
 143                 hdr = req->async_data;
 144                 hdr->free_iov = NULL;
 145                 return hdr;
 146         }
 147         return NULL;
 148 }
 149
 150 static inline struct io_async_msghdr *io_msg_alloc_async_prep(struct io_kiocb *req)
 151 {
 152         /* ->prep_async is always called from the submission context */
 153         return io_msg_alloc_async(req, 0);
 154 }
 155
 156 static int io_setup_async_msg(struct io_kiocb *req,
 157                               struct io_async_msghdr *kmsg,
 158                               unsigned int issue_flags)
 159 {
 160         struct io_async_msghdr *async_msg;
 161
 162         if (req_has_async_data(req))
 163                 return -EAGAIN;
 164         async_msg = io_msg_alloc_async(req, issue_flags);
 165         if (!async_msg) {
 166                 kfree(kmsg->free_iov);
 167                 return -ENOMEM;
 168         }
 169         req->flags |= REQ_F_NEED_CLEANUP;
 170         memcpy(async_msg, kmsg, sizeof(*kmsg));
 171         if (async_msg->msg.msg_name)
 172                 async_msg->msg.msg_name = &async_msg->addr;
 173
 174         if ((req->flags & REQ_F_BUFFER_SELECT) && !async_msg->msg.msg_iter.nr_segs)
 175                 return -EAGAIN;
 176
 177         /* if were using fast_iov, set it to the new one */
 178         if (!kmsg->free_iov) {
 179                 size_t fast_idx = kmsg->msg.msg_iter.iov - kmsg->fast_iov;
 180                 async_msg->msg.msg_iter.iov = &async_msg->fast_iov[fast_idx];
 181         }
 182
 183         return -EAGAIN;
 184 }
 185
 186 #ifdef CONFIG_COMPAT
 187 static int io_compat_msg_copy_hdr(struct io_kiocb *req,
 188                                   struct io_async_msghdr *iomsg,
 189                                   struct compat_msghdr *msg, int ddir)
 190 {
 191         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 192         struct compat_iovec __user *uiov;
 193         int ret;
 194
 195         if (copy_from_user(msg, sr->umsg_compat, sizeof(*msg)))
 196                 return -EFAULT;
 197
 198         uiov = compat_ptr(msg->msg_iov);
 199         if (req->flags & REQ_F_BUFFER_SELECT) {
 200                 compat_ssize_t clen;
 201
 202                 iomsg->free_iov = NULL;
 203                 if (msg->msg_iovlen == 0) {
 204                         sr->len = 0;
 205                 } else if (msg->msg_iovlen > 1) {
 206                         return -EINVAL;
 207                 } else {
 208                         if (!access_ok(uiov, sizeof(*uiov)))
 209                                 return -EFAULT;
 210                         if (__get_user(clen, &uiov->iov_len))
 211                                 return -EFAULT;
 212                         if (clen < 0)
 213                                 return -EINVAL;
 214                         sr->len = clen;
 215                 }
 216
 217                 return 0;
 218         }
 219
 220         iomsg->free_iov = iomsg->fast_iov;
 221         ret = __import_iovec(ddir, (struct iovec __user *)uiov, msg->msg_iovlen,
 222                                 UIO_FASTIOV, &iomsg->free_iov,
 223                                 &iomsg->msg.msg_iter, true);
 224         if (unlikely(ret < 0))
 225                 return ret;
 226
 227         return 0;
 228 }
 229 #endif
 230
 231 static int io_msg_copy_hdr(struct io_kiocb *req, struct io_async_msghdr *iomsg,
 232                            struct user_msghdr *msg, int ddir)
 233 {
 234         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 235         int ret;
 236
 237         if (copy_from_user(msg, sr->umsg, sizeof(*sr->umsg)))
 238                 return -EFAULT;
 239
 240         if (req->flags & REQ_F_BUFFER_SELECT) {
 241                 if (msg->msg_iovlen == 0) {
 242                         sr->len = iomsg->fast_iov[0].iov_len = 0;
 243                         iomsg->fast_iov[0].iov_base = NULL;
 244                         iomsg->free_iov = NULL;
 245                 } else if (msg->msg_iovlen > 1) {
 246                         return -EINVAL;
 247                 } else {
 248                         if (copy_from_user(iomsg->fast_iov, msg->msg_iov,
 249                                            sizeof(*msg->msg_iov)))
 250                                 return -EFAULT;
 251                         sr->len = iomsg->fast_iov[0].iov_len;
 252                         iomsg->free_iov = NULL;
 253                 }
 254
 255                 return 0;
 256         }
 257
 258         iomsg->free_iov = iomsg->fast_iov;
 259         ret = __import_iovec(ddir, msg->msg_iov, msg->msg_iovlen, UIO_FASTIOV,
 260                                 &iomsg->free_iov, &iomsg->msg.msg_iter, false);
 261         if (unlikely(ret < 0))
 262                 return ret;
 263
 264         return 0;
 265 }
 266
 267 static int io_sendmsg_copy_hdr(struct io_kiocb *req,
 268                                struct io_async_msghdr *iomsg)
 269 {
 270         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 271         struct user_msghdr msg;
 272         int ret;
 273
 274         iomsg->msg.msg_name = &iomsg->addr;
 275         iomsg->msg.msg_iter.nr_segs = 0;
 276
 277 #ifdef CONFIG_COMPAT
 278         if (unlikely(req->ctx->compat)) {
 279                 struct compat_msghdr cmsg;
 280
 281                 ret = io_compat_msg_copy_hdr(req, iomsg, &cmsg, ITER_SOURCE);
 282                 if (unlikely(ret))
 283                         return ret;
 284
 285                 return __get_compat_msghdr(&iomsg->msg, &cmsg, NULL);
 286         }
 287 #endif
 288
 289         ret = io_msg_copy_hdr(req, iomsg, &msg, ITER_SOURCE);
 290         if (unlikely(ret))
 291                 return ret;
 292
 293         ret = __copy_msghdr(&iomsg->msg, &msg, NULL);
 294
 295         /* save msg_control as sys_sendmsg() overwrites it */
 296         sr->msg_control = iomsg->msg.msg_control_user;
 297         return ret;
 298 }
 299
 300 int io_send_prep_async(struct io_kiocb *req)
 301 {
 302         struct io_sr_msg *zc = io_kiocb_to_cmd(req, struct io_sr_msg);
 303         struct io_async_msghdr *io;
 304         int ret;
 305
 306         if (!zc->addr || req_has_async_data(req))
 307                 return 0;
 308         io = io_msg_alloc_async_prep(req);
 309         if (!io)
 310                 return -ENOMEM;
 311         ret = move_addr_to_kernel(zc->addr, zc->addr_len, &io->addr);
 312         return ret;
 313 }
 314
 315 static int io_setup_async_addr(struct io_kiocb *req,
 316                               struct sockaddr_storage *addr_storage,
 317                               unsigned int issue_flags)
 318 {
 319         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 320         struct io_async_msghdr *io;
 321
 322         if (!sr->addr || req_has_async_data(req))
 323                 return -EAGAIN;
 324         io = io_msg_alloc_async(req, issue_flags);
 325         if (!io)
 326                 return -ENOMEM;
 327         memcpy(&io->addr, addr_storage, sizeof(io->addr));
 328         return -EAGAIN;
 329 }
 330
 331 int io_sendmsg_prep_async(struct io_kiocb *req)
 332 {
 333         int ret;
 334
 335         if (!io_msg_alloc_async_prep(req))
 336                 return -ENOMEM;
 337         ret = io_sendmsg_copy_hdr(req, req->async_data);
 338         if (!ret)
 339                 req->flags |= REQ_F_NEED_CLEANUP;
 340         return ret;
 341 }
 342
 343 void io_sendmsg_recvmsg_cleanup(struct io_kiocb *req)
 344 {
 345         struct io_async_msghdr *io = req->async_data;
 346
 347         kfree(io->free_iov);
 348 }
 349
 350 int io_sendmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 351 {
 352         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 353
 354         if (req->opcode == IORING_OP_SEND) {
 355                 if (READ_ONCE(sqe->__pad3[0]))
 356                         return -EINVAL;
 357                 sr->addr = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 358                 sr->addr_len = READ_ONCE(sqe->addr_len);
 359         } else if (sqe->addr2 || sqe->file_index) {
 360                 return -EINVAL;
 361         }
 362
 363         sr->umsg = u64_to_user_ptr(READ_ONCE(sqe->addr));
 364         sr->len = READ_ONCE(sqe->len);
 365         sr->flags = READ_ONCE(sqe->ioprio);
 366         if (sr->flags & ~IORING_RECVSEND_POLL_FIRST)
 367                 return -EINVAL;
 368         sr->msg_flags = READ_ONCE(sqe->msg_flags) | MSG_NOSIGNAL;
 369         if (sr->msg_flags & MSG_DONTWAIT)
 370                 req->flags |= REQ_F_NOWAIT;
 371
 372 #ifdef CONFIG_COMPAT
 373         if (req->ctx->compat)
 374                 sr->msg_flags |= MSG_CMSG_COMPAT;
 375 #endif
 376         sr->done_io = 0;
 377         return 0;
 378 }
 379
 380 int io_sendmsg(struct io_kiocb *req, unsigned int issue_flags)
 381 {
 382         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 383         struct io_async_msghdr iomsg, *kmsg;
 384         struct socket *sock;
 385         unsigned flags;
 386         int min_ret = 0;
 387         int ret;
 388
 389         sock = sock_from_file(req->file);
 390         if (unlikely(!sock))
 391                 return -ENOTSOCK;
 392
 393         if (req_has_async_data(req)) {
 394                 kmsg = req->async_data;
 395                 kmsg->msg.msg_control_user = sr->msg_control;
 396         } else {
 397                 ret = io_sendmsg_copy_hdr(req, &iomsg);
 398                 if (ret)
 399                         return ret;
 400                 kmsg = &iomsg;
 401         }
 402
 403         if (!(req->flags & REQ_F_POLLED) &&
 404             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 405                 return io_setup_async_msg(req, kmsg, issue_flags);
 406
 407         flags = sr->msg_flags;
 408         if (issue_flags & IO_URING_F_NONBLOCK)
 409                 flags |= MSG_DONTWAIT;
 410         if (flags & MSG_WAITALL)
 411                 min_ret = iov_iter_count(&kmsg->msg.msg_iter);
 412
 413         ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
 414
 415         if (ret < min_ret) {
 416                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
 417                         return io_setup_async_msg(req, kmsg, issue_flags);
 418                 if (ret > 0 && io_net_retry(sock, flags)) {
 419                         kmsg->msg.msg_controllen = 0;
 420                         kmsg->msg.msg_control = NULL;
 421                         sr->done_io += ret;
 422                         req->flags |= REQ_F_PARTIAL_IO;
 423                         return io_setup_async_msg(req, kmsg, issue_flags);
 424                 }
 425                 if (ret == -ERESTARTSYS)
 426                         ret = -EINTR;
 427                 req_set_fail(req);
 428         }
 429         /* fast path, check for non-NULL to avoid function call */
 430         if (kmsg->free_iov)
 431                 kfree(kmsg->free_iov);
 432         req->flags &= ~REQ_F_NEED_CLEANUP;
 433         io_netmsg_recycle(req, issue_flags);
 434         if (ret >= 0)
 435                 ret += sr->done_io;
 436         else if (sr->done_io)
 437                 ret = sr->done_io;
 438         io_req_set_res(req, ret, 0);
 439         return IOU_OK;
 440 }
 441
 442 int io_send(struct io_kiocb *req, unsigned int issue_flags)
 443 {
 444         struct sockaddr_storage __address;
 445         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 446         struct msghdr msg;
 447         struct iovec iov;
 448         struct socket *sock;
 449         unsigned flags;
 450         int min_ret = 0;
 451         int ret;
 452
 453         msg.msg_name = NULL;
 454         msg.msg_control = NULL;
 455         msg.msg_controllen = 0;
 456         msg.msg_namelen = 0;
 457         msg.msg_ubuf = NULL;
 458
 459         if (sr->addr) {
 460                 if (req_has_async_data(req)) {
 461                         struct io_async_msghdr *io = req->async_data;
 462
 463                         msg.msg_name = &io->addr;
 464                 } else {
 465                         ret = move_addr_to_kernel(sr->addr, sr->addr_len, &__address);
 466                         if (unlikely(ret < 0))
 467                                 return ret;
 468                         msg.msg_name = (struct sockaddr *)&__address;
 469                 }
 470                 msg.msg_namelen = sr->addr_len;
 471         }
 472
 473         if (!(req->flags & REQ_F_POLLED) &&
 474             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 475                 return io_setup_async_addr(req, &__address, issue_flags);
 476
 477         sock = sock_from_file(req->file);
 478         if (unlikely(!sock))
 479                 return -ENOTSOCK;
 480
 481         ret = import_single_range(ITER_SOURCE, sr->buf, sr->len, &iov, &msg.msg_iter);
 482         if (unlikely(ret))
 483                 return ret;
 484
 485         flags = sr->msg_flags;
 486         if (issue_flags & IO_URING_F_NONBLOCK)
 487                 flags |= MSG_DONTWAIT;
 488         if (flags & MSG_WAITALL)
 489                 min_ret = iov_iter_count(&msg.msg_iter);
 490
 491         flags &= ~MSG_INTERNAL_SENDMSG_FLAGS;
 492         msg.msg_flags = flags;
 493         ret = sock_sendmsg(sock, &msg);
 494         if (ret < min_ret) {
 495                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
 496                         return io_setup_async_addr(req, &__address, issue_flags);
 497
 498                 if (ret > 0 && io_net_retry(sock, flags)) {
 499                         sr->len -= ret;
 500                         sr->buf += ret;
 501                         sr->done_io += ret;
 502                         req->flags |= REQ_F_PARTIAL_IO;
 503                         return io_setup_async_addr(req, &__address, issue_flags);
 504                 }
 505                 if (ret == -ERESTARTSYS)
 506                         ret = -EINTR;
 507                 req_set_fail(req);
 508         }
 509         if (ret >= 0)
 510                 ret += sr->done_io;
 511         else if (sr->done_io)
 512                 ret = sr->done_io;
 513         io_req_set_res(req, ret, 0);
 514         return IOU_OK;
 515 }
 516
 517 static int io_recvmsg_mshot_prep(struct io_kiocb *req,
 518                                  struct io_async_msghdr *iomsg,
 519                                  int namelen, size_t controllen)
 520 {
 521         if ((req->flags & (REQ_F_APOLL_MULTISHOT|REQ_F_BUFFER_SELECT)) ==
 522                           (REQ_F_APOLL_MULTISHOT|REQ_F_BUFFER_SELECT)) {
 523                 int hdr;
 524
 525                 if (unlikely(namelen < 0))
 526                         return -EOVERFLOW;
 527                 if (check_add_overflow(sizeof(struct io_uring_recvmsg_out),
 528                                         namelen, &hdr))
 529                         return -EOVERFLOW;
 530                 if (check_add_overflow(hdr, controllen, &hdr))
 531                         return -EOVERFLOW;
 532
 533                 iomsg->namelen = namelen;
 534                 iomsg->controllen = controllen;
 535                 return 0;
 536         }
 537
 538         return 0;
 539 }
 540
 541 static int io_recvmsg_copy_hdr(struct io_kiocb *req,
 542                                struct io_async_msghdr *iomsg)
 543 {
 544         struct user_msghdr msg;
 545         int ret;
 546
 547         iomsg->msg.msg_name = &iomsg->addr;
 548         iomsg->msg.msg_iter.nr_segs = 0;
 549
 550 #ifdef CONFIG_COMPAT
 551         if (unlikely(req->ctx->compat)) {
 552                 struct compat_msghdr cmsg;
 553
 554                 ret = io_compat_msg_copy_hdr(req, iomsg, &cmsg, ITER_DEST);
 555                 if (unlikely(ret))
 556                         return ret;
 557
 558                 ret = __get_compat_msghdr(&iomsg->msg, &cmsg, &iomsg->uaddr);
 559                 if (unlikely(ret))
 560                         return ret;
 561
 562                 return io_recvmsg_mshot_prep(req, iomsg, cmsg.msg_namelen,
 563                                                 cmsg.msg_controllen);
 564         }
 565 #endif
 566
 567         ret = io_msg_copy_hdr(req, iomsg, &msg, ITER_DEST);
 568         if (unlikely(ret))
 569                 return ret;
 570
 571         ret = __copy_msghdr(&iomsg->msg, &msg, &iomsg->uaddr);
 572         if (unlikely(ret))
 573                 return ret;
 574
 575         return io_recvmsg_mshot_prep(req, iomsg, msg.msg_namelen,
 576                                         msg.msg_controllen);
 577 }
 578
 579 int io_recvmsg_prep_async(struct io_kiocb *req)
 580 {
 581         struct io_async_msghdr *iomsg;
 582         int ret;
 583
 584         if (!io_msg_alloc_async_prep(req))
 585                 return -ENOMEM;
 586         iomsg = req->async_data;
 587         ret = io_recvmsg_copy_hdr(req, iomsg);
 588         if (!ret)
 589                 req->flags |= REQ_F_NEED_CLEANUP;
 590         return ret;
 591 }
 592
 593 #define RECVMSG_FLAGS (IORING_RECVSEND_POLL_FIRST | IORING_RECV_MULTISHOT)
 594
 595 int io_recvmsg_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 596 {
 597         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 598
 599         if (unlikely(sqe->file_index || sqe->addr2))
 600                 return -EINVAL;
 601
 602         sr->umsg = u64_to_user_ptr(READ_ONCE(sqe->addr));
 603         sr->len = READ_ONCE(sqe->len);
 604         sr->flags = READ_ONCE(sqe->ioprio);
 605         if (sr->flags & ~(RECVMSG_FLAGS))
 606                 return -EINVAL;
 607         sr->msg_flags = READ_ONCE(sqe->msg_flags);
 608         if (sr->msg_flags & MSG_DONTWAIT)
 609                 req->flags |= REQ_F_NOWAIT;
 610         if (sr->msg_flags & MSG_ERRQUEUE)
 611                 req->flags |= REQ_F_CLEAR_POLLIN;
 612         if (sr->flags & IORING_RECV_MULTISHOT) {
 613                 if (!(req->flags & REQ_F_BUFFER_SELECT))
 614                         return -EINVAL;
 615                 if (sr->msg_flags & MSG_WAITALL)
 616                         return -EINVAL;
 617                 if (req->opcode == IORING_OP_RECV && sr->len)
 618                         return -EINVAL;
 619                 req->flags |= REQ_F_APOLL_MULTISHOT;
 620                 /*
 621                  * Store the buffer group for this multishot receive separately,
 622                  * as if we end up doing an io-wq based issue that selects a
 623                  * buffer, it has to be committed immediately and that will
 624                  * clear ->buf_list. This means we lose the link to the buffer
 625                  * list, and the eventual buffer put on completion then cannot
 626                  * restore it.
 627                  */
 628                 sr->buf_group = req->buf_index;
 629         }
 630
 631 #ifdef CONFIG_COMPAT
 632         if (req->ctx->compat)
 633                 sr->msg_flags |= MSG_CMSG_COMPAT;
 634 #endif
 635         sr->done_io = 0;
 636         return 0;
 637 }
 638
 639 static inline void io_recv_prep_retry(struct io_kiocb *req)
 640 {
 641         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 642
 643         sr->done_io = 0;
 644         sr->len = 0; /* get from the provided buffer */
 645         req->buf_index = sr->buf_group;
 646 }
 647
 648 /*
 649  * Finishes io_recv and io_recvmsg.
 650  *
 651  * Returns true if it is actually finished, or false if it should run
 652  * again (for multishot).
 653  */
 654 static inline bool io_recv_finish(struct io_kiocb *req, int *ret,
 655                                   unsigned int cflags, bool mshot_finished,
 656                                   unsigned issue_flags)
 657 {
 658         if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
 659                 io_req_set_res(req, *ret, cflags);
 660                 *ret = IOU_OK;
 661                 return true;
 662         }
 663
 664         if (!mshot_finished) {
 665                 if (io_post_aux_cqe(req->ctx, req->cqe.user_data, *ret,
 666                                     cflags | IORING_CQE_F_MORE, false)) {
 667                         io_recv_prep_retry(req);
 668                         return false;
 669                 }
 670                 /*
 671                  * Otherwise stop multishot but use the current result.
 672                  * Probably will end up going into overflow, but this means
 673                  * we cannot trust the ordering anymore
 674                  */
 675         }
 676
 677         io_req_set_res(req, *ret, cflags);
 678
 679         if (issue_flags & IO_URING_F_MULTISHOT)
 680                 *ret = IOU_STOP_MULTISHOT;
 681         else
 682                 *ret = IOU_OK;
 683         return true;
 684 }
 685
 686 static int io_recvmsg_prep_multishot(struct io_async_msghdr *kmsg,
 687                                      struct io_sr_msg *sr, void __user **buf,
 688                                      size_t *len)
 689 {
 690         unsigned long ubuf = (unsigned long) *buf;
 691         unsigned long hdr;
 692
 693         hdr = sizeof(struct io_uring_recvmsg_out) + kmsg->namelen +
 694                 kmsg->controllen;
 695         if (*len < hdr)
 696                 return -EFAULT;
 697
 698         if (kmsg->controllen) {
 699                 unsigned long control = ubuf + hdr - kmsg->controllen;
 700
 701                 kmsg->msg.msg_control_user = (void __user *) control;
 702                 kmsg->msg.msg_controllen = kmsg->controllen;
 703         }
 704
 705         sr->buf = *buf; /* stash for later copy */
 706         *buf = (void __user *) (ubuf + hdr);
 707         kmsg->payloadlen = *len = *len - hdr;
 708         return 0;
 709 }
 710
 711 struct io_recvmsg_multishot_hdr {
 712         struct io_uring_recvmsg_out msg;
 713         struct sockaddr_storage addr;
 714 };
 715
 716 static int io_recvmsg_multishot(struct socket *sock, struct io_sr_msg *io,
 717                                 struct io_async_msghdr *kmsg,
 718                                 unsigned int flags, bool *finished)
 719 {
 720         int err;
 721         int copy_len;
 722         struct io_recvmsg_multishot_hdr hdr;
 723
 724         if (kmsg->namelen)
 725                 kmsg->msg.msg_name = &hdr.addr;
 726         kmsg->msg.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
 727         kmsg->msg.msg_namelen = 0;
 728
 729         if (sock->file->f_flags & O_NONBLOCK)
 730                 flags |= MSG_DONTWAIT;
 731
 732         err = sock_recvmsg(sock, &kmsg->msg, flags);
 733         *finished = err <= 0;
 734         if (err < 0)
 735                 return err;
 736
 737         hdr.msg = (struct io_uring_recvmsg_out) {
 738                 .controllen = kmsg->controllen - kmsg->msg.msg_controllen,
 739                 .flags = kmsg->msg.msg_flags & ~MSG_CMSG_COMPAT
 740         };
 741
 742         hdr.msg.payloadlen = err;
 743         if (err > kmsg->payloadlen)
 744                 err = kmsg->payloadlen;
 745
 746         copy_len = sizeof(struct io_uring_recvmsg_out);
 747         if (kmsg->msg.msg_namelen > kmsg->namelen)
 748                 copy_len += kmsg->namelen;
 749         else
 750                 copy_len += kmsg->msg.msg_namelen;
 751
 752         /*
 753          *      "fromlen shall refer to the value before truncation.."
 754          *                      1003.1g
 755          */
 756         hdr.msg.namelen = kmsg->msg.msg_namelen;
 757
 758         /* ensure that there is no gap between hdr and sockaddr_storage */
 759         BUILD_BUG_ON(offsetof(struct io_recvmsg_multishot_hdr, addr) !=
 760                      sizeof(struct io_uring_recvmsg_out));
 761         if (copy_to_user(io->buf, &hdr, copy_len)) {
 762                 *finished = true;
 763                 return -EFAULT;
 764         }
 765
 766         return sizeof(struct io_uring_recvmsg_out) + kmsg->namelen +
 767                         kmsg->controllen + err;
 768 }
 769
 770 int io_recvmsg(struct io_kiocb *req, unsigned int issue_flags)
 771 {
 772         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 773         struct io_async_msghdr iomsg, *kmsg;
 774         struct socket *sock;
 775         unsigned int cflags;
 776         unsigned flags;
 777         int ret, min_ret = 0;
 778         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
 779         bool mshot_finished = true;
 780
 781         sock = sock_from_file(req->file);
 782         if (unlikely(!sock))
 783                 return -ENOTSOCK;
 784
 785         if (req_has_async_data(req)) {
 786                 kmsg = req->async_data;
 787         } else {
 788                 ret = io_recvmsg_copy_hdr(req, &iomsg);
 789                 if (ret)
 790                         return ret;
 791                 kmsg = &iomsg;
 792         }
 793
 794         if (!(req->flags & REQ_F_POLLED) &&
 795             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 796                 return io_setup_async_msg(req, kmsg, issue_flags);
 797
 798 retry_multishot:
 799         if (io_do_buffer_select(req)) {
 800                 void __user *buf;
 801                 size_t len = sr->len;
 802
 803                 buf = io_buffer_select(req, &len, issue_flags);
 804                 if (!buf)
 805                         return -ENOBUFS;
 806
 807                 if (req->flags & REQ_F_APOLL_MULTISHOT) {
 808                         ret = io_recvmsg_prep_multishot(kmsg, sr, &buf, &len);
 809                         if (ret) {
 810                                 io_kbuf_recycle(req, issue_flags);
 811                                 return ret;
 812                         }
 813                 }
 814
 815                 kmsg->fast_iov[0].iov_base = buf;
 816                 kmsg->fast_iov[0].iov_len = len;
 817                 iov_iter_init(&kmsg->msg.msg_iter, ITER_DEST, kmsg->fast_iov, 1,
 818                                 len);
 819         }
 820
 821         flags = sr->msg_flags;
 822         if (force_nonblock)
 823                 flags |= MSG_DONTWAIT;
 824
 825         kmsg->msg.msg_get_inq = 1;
 826         if (req->flags & REQ_F_APOLL_MULTISHOT) {
 827                 ret = io_recvmsg_multishot(sock, sr, kmsg, flags,
 828                                            &mshot_finished);
 829         } else {
 830                 /* disable partial retry for recvmsg with cmsg attached */
 831                 if (flags & MSG_WAITALL && !kmsg->msg.msg_controllen)
 832                         min_ret = iov_iter_count(&kmsg->msg.msg_iter);
 833
 834                 ret = __sys_recvmsg_sock(sock, &kmsg->msg, sr->umsg,
 835                                          kmsg->uaddr, flags);
 836         }
 837
 838         if (ret < min_ret) {
 839                 if (ret == -EAGAIN && force_nonblock) {
 840                         ret = io_setup_async_msg(req, kmsg, issue_flags);
 841                         if (ret == -EAGAIN && (issue_flags & IO_URING_F_MULTISHOT)) {
 842                                 io_kbuf_recycle(req, issue_flags);
 843                                 return IOU_ISSUE_SKIP_COMPLETE;
 844                         }
 845                         return ret;
 846                 }
 847                 if (ret > 0 && io_net_retry(sock, flags)) {
 848                         sr->done_io += ret;
 849                         req->flags |= REQ_F_PARTIAL_IO;
 850                         return io_setup_async_msg(req, kmsg, issue_flags);
 851                 }
 852                 if (ret == -ERESTARTSYS)
 853                         ret = -EINTR;
 854                 req_set_fail(req);
 855         } else if ((flags & MSG_WAITALL) && (kmsg->msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC))) {
 856                 req_set_fail(req);
 857         }
 858
 859         if (ret > 0)
 860                 ret += sr->done_io;
 861         else if (sr->done_io)
 862                 ret = sr->done_io;
 863         else
 864                 io_kbuf_recycle(req, issue_flags);
 865
 866         cflags = io_put_kbuf(req, issue_flags);
 867         if (kmsg->msg.msg_inq)
 868                 cflags |= IORING_CQE_F_SOCK_NONEMPTY;
 869
 870         if (!io_recv_finish(req, &ret, cflags, mshot_finished, issue_flags))
 871                 goto retry_multishot;
 872
 873         if (mshot_finished) {
 874                 /* fast path, check for non-NULL to avoid function call */
 875                 if (kmsg->free_iov)
 876                         kfree(kmsg->free_iov);
 877                 io_netmsg_recycle(req, issue_flags);
 878                 req->flags &= ~REQ_F_NEED_CLEANUP;
 879         } else if (ret == -EAGAIN)
 880                 return io_setup_async_msg(req, kmsg, issue_flags);
 881
 882         return ret;
 883 }
 884
 885 int io_recv(struct io_kiocb *req, unsigned int issue_flags)
 886 {
 887         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
 888         struct msghdr msg;
 889         struct socket *sock;
 890         struct iovec iov;
 891         unsigned int cflags;
 892         unsigned flags;
 893         int ret, min_ret = 0;
 894         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
 895         size_t len = sr->len;
 896
 897         if (!(req->flags & REQ_F_POLLED) &&
 898             (sr->flags & IORING_RECVSEND_POLL_FIRST))
 899                 return -EAGAIN;
 900
 901         sock = sock_from_file(req->file);
 902         if (unlikely(!sock))
 903                 return -ENOTSOCK;
 904
 905 retry_multishot:
 906         if (io_do_buffer_select(req)) {
 907                 void __user *buf;
 908
 909                 buf = io_buffer_select(req, &len, issue_flags);
 910                 if (!buf)
 911                         return -ENOBUFS;
 912                 sr->buf = buf;
 913                 sr->len = len;
 914         }
 915
 916         ret = import_single_range(ITER_DEST, sr->buf, len, &iov, &msg.msg_iter);
 917         if (unlikely(ret))
 918                 goto out_free;
 919
 920         msg.msg_name = NULL;
 921         msg.msg_namelen = 0;
 922         msg.msg_control = NULL;
 923         msg.msg_get_inq = 1;
 924         msg.msg_flags = 0;
 925         msg.msg_controllen = 0;
 926         msg.msg_iocb = NULL;
 927         msg.msg_ubuf = NULL;
 928
 929         flags = sr->msg_flags;
 930         if (force_nonblock)
 931                 flags |= MSG_DONTWAIT;
 932         if (flags & MSG_WAITALL)
 933                 min_ret = iov_iter_count(&msg.msg_iter);
 934
 935         ret = sock_recvmsg(sock, &msg, flags);
 936         if (ret < min_ret) {
 937                 if (ret == -EAGAIN && force_nonblock) {
 938                         if (issue_flags & IO_URING_F_MULTISHOT) {
 939                                 io_kbuf_recycle(req, issue_flags);
 940                                 return IOU_ISSUE_SKIP_COMPLETE;
 941                         }
 942
 943                         return -EAGAIN;
 944                 }
 945                 if (ret > 0 && io_net_retry(sock, flags)) {
 946                         sr->len -= ret;
 947                         sr->buf += ret;
 948                         sr->done_io += ret;
 949                         req->flags |= REQ_F_PARTIAL_IO;
 950                         return -EAGAIN;
 951                 }
 952                 if (ret == -ERESTARTSYS)
 953                         ret = -EINTR;
 954                 req_set_fail(req);
 955         } else if ((flags & MSG_WAITALL) && (msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC))) {
 956 out_free:
 957                 req_set_fail(req);
 958         }
 959
 960         if (ret > 0)
 961                 ret += sr->done_io;
 962         else if (sr->done_io)
 963                 ret = sr->done_io;
 964         else
 965                 io_kbuf_recycle(req, issue_flags);
 966
 967         cflags = io_put_kbuf(req, issue_flags);
 968         if (msg.msg_inq)
 969                 cflags |= IORING_CQE_F_SOCK_NONEMPTY;
 970
 971         if (!io_recv_finish(req, &ret, cflags, ret <= 0, issue_flags))
 972                 goto retry_multishot;
 973
 974         return ret;
 975 }
 976
 977 void io_send_zc_cleanup(struct io_kiocb *req)
 978 {
 979         struct io_sr_msg *zc = io_kiocb_to_cmd(req, struct io_sr_msg);
 980         struct io_async_msghdr *io;
 981
 982         if (req_has_async_data(req)) {
 983                 io = req->async_data;
 984                 /* might be ->fast_iov if *msg_copy_hdr failed */
 985                 if (io->free_iov != io->fast_iov)
 986                         kfree(io->free_iov);
 987         }
 988         if (zc->notif) {
 989                 io_notif_flush(zc->notif);
 990                 zc->notif = NULL;
 991         }
 992 }
 993
 994 int io_send_zc_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 995 {
 996         struct io_sr_msg *zc = io_kiocb_to_cmd(req, struct io_sr_msg);
 997         struct io_ring_ctx *ctx = req->ctx;
 998         struct io_kiocb *notif;
 999
1000         if (unlikely(READ_ONCE(sqe->__pad2[0]) || READ_ONCE(sqe->addr3)))
1001                 return -EINVAL;
1002         /* we don't support IOSQE_CQE_SKIP_SUCCESS just yet */
1003         if (req->flags & REQ_F_CQE_SKIP)
1004                 return -EINVAL;
1005
1006         zc->flags = READ_ONCE(sqe->ioprio);
1007         if (zc->flags & ~(IORING_RECVSEND_POLL_FIRST |
1008                           IORING_RECVSEND_FIXED_BUF |
1009                           IORING_SEND_ZC_REPORT_USAGE))
1010                 return -EINVAL;
1011         notif = zc->notif = io_alloc_notif(ctx);
1012         if (!notif)
1013                 return -ENOMEM;
1014         notif->cqe.user_data = req->cqe.user_data;
1015         notif->cqe.res = 0;
1016         notif->cqe.flags = IORING_CQE_F_NOTIF;
1017         req->flags |= REQ_F_NEED_CLEANUP;
1018         if (zc->flags & IORING_RECVSEND_FIXED_BUF) {
1019                 unsigned idx = READ_ONCE(sqe->buf_index);
1020
1021                 if (unlikely(idx >= ctx->nr_user_bufs))
1022                         return -EFAULT;
1023                 idx = array_index_nospec(idx, ctx->nr_user_bufs);
1024                 req->imu = READ_ONCE(ctx->user_bufs[idx]);
1025                 io_req_set_rsrc_node(notif, ctx, 0);
1026         }
1027         if (zc->flags & IORING_SEND_ZC_REPORT_USAGE) {
1028                 io_notif_to_data(notif)->zc_report = true;
1029         }
1030
1031         if (req->opcode == IORING_OP_SEND_ZC) {
1032                 if (READ_ONCE(sqe->__pad3[0]))
1033                         return -EINVAL;
1034                 zc->addr = u64_to_user_ptr(READ_ONCE(sqe->addr2));
1035                 zc->addr_len = READ_ONCE(sqe->addr_len);
1036         } else {
1037                 if (unlikely(sqe->addr2 || sqe->file_index))
1038                         return -EINVAL;
1039                 if (unlikely(zc->flags & IORING_RECVSEND_FIXED_BUF))
1040                         return -EINVAL;
1041         }
1042
1043         zc->buf = u64_to_user_ptr(READ_ONCE(sqe->addr));
1044         zc->len = READ_ONCE(sqe->len);
1045         zc->msg_flags = READ_ONCE(sqe->msg_flags) | MSG_NOSIGNAL;
1046         if (zc->msg_flags & MSG_DONTWAIT)
1047                 req->flags |= REQ_F_NOWAIT;
1048
1049         zc->done_io = 0;
1050
1051 #ifdef CONFIG_COMPAT
1052         if (req->ctx->compat)
1053                 zc->msg_flags |= MSG_CMSG_COMPAT;
1054 #endif
1055         return 0;
1056 }
1057
1058 static int io_sg_from_iter_iovec(struct sock *sk, struct sk_buff *skb,
1059                                  struct iov_iter *from, size_t length)
1060 {
1061         skb_zcopy_downgrade_managed(skb);
1062         return __zerocopy_sg_from_iter(NULL, sk, skb, from, length);
1063 }
1064
1065 static int io_sg_from_iter(struct sock *sk, struct sk_buff *skb,
1066                            struct iov_iter *from, size_t length)
1067 {
1068         struct skb_shared_info *shinfo = skb_shinfo(skb);
1069         int frag = shinfo->nr_frags;
1070         int ret = 0;
1071         struct bvec_iter bi;
1072         ssize_t copied = 0;
1073         unsigned long truesize = 0;
1074
1075         if (!frag)
1076                 shinfo->flags |= SKBFL_MANAGED_FRAG_REFS;
1077         else if (unlikely(!skb_zcopy_managed(skb)))
1078                 return __zerocopy_sg_from_iter(NULL, sk, skb, from, length);
1079
1080         bi.bi_size = min(from->count, length);
1081         bi.bi_bvec_done = from->iov_offset;
1082         bi.bi_idx = 0;
1083
1084         while (bi.bi_size && frag < MAX_SKB_FRAGS) {
1085                 struct bio_vec v = mp_bvec_iter_bvec(from->bvec, bi);
1086
1087                 copied += v.bv_len;
1088                 truesize += PAGE_ALIGN(v.bv_len + v.bv_offset);
1089                 __skb_fill_page_desc_noacc(shinfo, frag++, v.bv_page,
1090                                            v.bv_offset, v.bv_len);
1091                 bvec_iter_advance_single(from->bvec, &bi, v.bv_len);
1092         }
1093         if (bi.bi_size)
1094                 ret = -EMSGSIZE;
1095
1096         shinfo->nr_frags = frag;
1097         from->bvec += bi.bi_idx;
1098         from->nr_segs -= bi.bi_idx;
1099         from->count -= copied;
1100         from->iov_offset = bi.bi_bvec_done;
1101
1102         skb->data_len += copied;
1103         skb->len += copied;
1104         skb->truesize += truesize;
1105
1106         if (sk && sk->sk_type == SOCK_STREAM) {
1107                 sk_wmem_queued_add(sk, truesize);
1108                 if (!skb_zcopy_pure(skb))
1109                         sk_mem_charge(sk, truesize);
1110         } else {
1111                 refcount_add(truesize, &skb->sk->sk_wmem_alloc);
1112         }
1113         return ret;
1114 }
1115
1116 int io_send_zc(struct io_kiocb *req, unsigned int issue_flags)
1117 {
1118         struct sockaddr_storage __address;
1119         struct io_sr_msg *zc = io_kiocb_to_cmd(req, struct io_sr_msg);
1120         struct msghdr msg;
1121         struct iovec iov;
1122         struct socket *sock;
1123         unsigned msg_flags;
1124         int ret, min_ret = 0;
1125
1126         sock = sock_from_file(req->file);
1127         if (unlikely(!sock))
1128                 return -ENOTSOCK;
1129         if (!test_bit(SOCK_SUPPORT_ZC, &sock->flags))
1130                 return -EOPNOTSUPP;
1131
1132         msg.msg_name = NULL;
1133         msg.msg_control = NULL;
1134         msg.msg_controllen = 0;
1135         msg.msg_namelen = 0;
1136
1137         if (zc->addr) {
1138                 if (req_has_async_data(req)) {
1139                         struct io_async_msghdr *io = req->async_data;
1140
1141                         msg.msg_name = &io->addr;
1142                 } else {
1143                         ret = move_addr_to_kernel(zc->addr, zc->addr_len, &__address);
1144                         if (unlikely(ret < 0))
1145                                 return ret;
1146                         msg.msg_name = (struct sockaddr *)&__address;
1147                 }
1148                 msg.msg_namelen = zc->addr_len;
1149         }
1150
1151         if (!(req->flags & REQ_F_POLLED) &&
1152             (zc->flags & IORING_RECVSEND_POLL_FIRST))
1153                 return io_setup_async_addr(req, &__address, issue_flags);
1154
1155         if (zc->flags & IORING_RECVSEND_FIXED_BUF) {
1156                 ret = io_import_fixed(ITER_SOURCE, &msg.msg_iter, req->imu,
1157                                         (u64)(uintptr_t)zc->buf, zc->len);
1158                 if (unlikely(ret))
1159                         return ret;
1160                 msg.sg_from_iter = io_sg_from_iter;
1161         } else {
1162                 ret = import_single_range(ITER_SOURCE, zc->buf, zc->len, &iov,
1163                                           &msg.msg_iter);
1164                 if (unlikely(ret))
1165                         return ret;
1166                 ret = io_notif_account_mem(zc->notif, zc->len);
1167                 if (unlikely(ret))
1168                         return ret;
1169                 msg.sg_from_iter = io_sg_from_iter_iovec;
1170         }
1171
1172         msg_flags = zc->msg_flags | MSG_ZEROCOPY;
1173         if (issue_flags & IO_URING_F_NONBLOCK)
1174                 msg_flags |= MSG_DONTWAIT;
1175         if (msg_flags & MSG_WAITALL)
1176                 min_ret = iov_iter_count(&msg.msg_iter);
1177         msg_flags &= ~MSG_INTERNAL_SENDMSG_FLAGS;
1178
1179         msg.msg_flags = msg_flags;
1180         msg.msg_ubuf = &io_notif_to_data(zc->notif)->uarg;
1181         ret = sock_sendmsg(sock, &msg);
1182
1183         if (unlikely(ret < min_ret)) {
1184                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
1185                         return io_setup_async_addr(req, &__address, issue_flags);
1186
1187                 if (ret > 0 && io_net_retry(sock, msg.msg_flags)) {
1188                         zc->len -= ret;
1189                         zc->buf += ret;
1190                         zc->done_io += ret;
1191                         req->flags |= REQ_F_PARTIAL_IO;
1192                         return io_setup_async_addr(req, &__address, issue_flags);
1193                 }
1194                 if (ret == -ERESTARTSYS)
1195                         ret = -EINTR;
1196                 req_set_fail(req);
1197         }
1198
1199         if (ret >= 0)
1200                 ret += zc->done_io;
1201         else if (zc->done_io)
1202                 ret = zc->done_io;
1203
1204         /*
1205          * If we're in io-wq we can't rely on tw ordering guarantees, defer
1206          * flushing notif to io_send_zc_cleanup()
1207          */
1208         if (!(issue_flags & IO_URING_F_UNLOCKED)) {
1209                 io_notif_flush(zc->notif);
1210                 req->flags &= ~REQ_F_NEED_CLEANUP;
1211         }
1212         io_req_set_res(req, ret, IORING_CQE_F_MORE);
1213         return IOU_OK;
1214 }
1215
1216 int io_sendmsg_zc(struct io_kiocb *req, unsigned int issue_flags)
1217 {
1218         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
1219         struct io_async_msghdr iomsg, *kmsg;
1220         struct socket *sock;
1221         unsigned flags;
1222         int ret, min_ret = 0;
1223
1224         sock = sock_from_file(req->file);
1225         if (unlikely(!sock))
1226                 return -ENOTSOCK;
1227         if (!test_bit(SOCK_SUPPORT_ZC, &sock->flags))
1228                 return -EOPNOTSUPP;
1229
1230         if (req_has_async_data(req)) {
1231                 kmsg = req->async_data;
1232                 kmsg->msg.msg_control_user = sr->msg_control;
1233         } else {
1234                 ret = io_sendmsg_copy_hdr(req, &iomsg);
1235                 if (ret)
1236                         return ret;
1237                 kmsg = &iomsg;
1238         }
1239
1240         if (!(req->flags & REQ_F_POLLED) &&
1241             (sr->flags & IORING_RECVSEND_POLL_FIRST))
1242                 return io_setup_async_msg(req, kmsg, issue_flags);
1243
1244         flags = sr->msg_flags | MSG_ZEROCOPY;
1245         if (issue_flags & IO_URING_F_NONBLOCK)
1246                 flags |= MSG_DONTWAIT;
1247         if (flags & MSG_WAITALL)
1248                 min_ret = iov_iter_count(&kmsg->msg.msg_iter);
1249
1250         kmsg->msg.msg_ubuf = &io_notif_to_data(sr->notif)->uarg;
1251         kmsg->msg.sg_from_iter = io_sg_from_iter_iovec;
1252         ret = __sys_sendmsg_sock(sock, &kmsg->msg, flags);
1253
1254         if (unlikely(ret < min_ret)) {
1255                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
1256                         return io_setup_async_msg(req, kmsg, issue_flags);
1257
1258                 if (ret > 0 && io_net_retry(sock, flags)) {
1259                         sr->done_io += ret;
1260                         req->flags |= REQ_F_PARTIAL_IO;
1261                         return io_setup_async_msg(req, kmsg, issue_flags);
1262                 }
1263                 if (ret == -ERESTARTSYS)
1264                         ret = -EINTR;
1265                 req_set_fail(req);
1266         }
1267         /* fast path, check for non-NULL to avoid function call */
1268         if (kmsg->free_iov) {
1269                 kfree(kmsg->free_iov);
1270                 kmsg->free_iov = NULL;
1271         }
1272
1273         io_netmsg_recycle(req, issue_flags);
1274         if (ret >= 0)
1275                 ret += sr->done_io;
1276         else if (sr->done_io)
1277                 ret = sr->done_io;
1278
1279         /*
1280          * If we're in io-wq we can't rely on tw ordering guarantees, defer
1281          * flushing notif to io_send_zc_cleanup()
1282          */
1283         if (!(issue_flags & IO_URING_F_UNLOCKED)) {
1284                 io_notif_flush(sr->notif);
1285                 req->flags &= ~REQ_F_NEED_CLEANUP;
1286         }
1287         io_req_set_res(req, ret, IORING_CQE_F_MORE);
1288         return IOU_OK;
1289 }
1290
1291 void io_sendrecv_fail(struct io_kiocb *req)
1292 {
1293         struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
1294
1295         if (req->flags & REQ_F_PARTIAL_IO)
1296                 req->cqe.res = sr->done_io;
1297
1298         if ((req->flags & REQ_F_NEED_CLEANUP) &&
1299             (req->opcode == IORING_OP_SEND_ZC || req->opcode == IORING_OP_SENDMSG_ZC))
1300                 req->cqe.flags |= IORING_CQE_F_MORE;
1301 }
1302
1303 int io_accept_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
1304 {
1305         struct io_accept *accept = io_kiocb_to_cmd(req, struct io_accept);
1306         unsigned flags;
1307
1308         if (sqe->len || sqe->buf_index)
1309                 return -EINVAL;
1310
1311         accept->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
1312         accept->addr_len = u64_to_user_ptr(READ_ONCE(sqe->addr2));
1313         accept->flags = READ_ONCE(sqe->accept_flags);
1314         accept->nofile = rlimit(RLIMIT_NOFILE);
1315         flags = READ_ONCE(sqe->ioprio);
1316         if (flags & ~IORING_ACCEPT_MULTISHOT)
1317                 return -EINVAL;
1318
1319         accept->file_slot = READ_ONCE(sqe->file_index);
1320         if (accept->file_slot) {
1321                 if (accept->flags & SOCK_CLOEXEC)
1322                         return -EINVAL;
1323                 if (flags & IORING_ACCEPT_MULTISHOT &&
1324                     accept->file_slot != IORING_FILE_INDEX_ALLOC)
1325                         return -EINVAL;
1326         }
1327         if (accept->flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1328                 return -EINVAL;
1329         if (SOCK_NONBLOCK != O_NONBLOCK && (accept->flags & SOCK_NONBLOCK))
1330                 accept->flags = (accept->flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1331         if (flags & IORING_ACCEPT_MULTISHOT)
1332                 req->flags |= REQ_F_APOLL_MULTISHOT;
1333         return 0;
1334 }
1335
1336 int io_accept(struct io_kiocb *req, unsigned int issue_flags)
1337 {
1338         struct io_ring_ctx *ctx = req->ctx;
1339         struct io_accept *accept = io_kiocb_to_cmd(req, struct io_accept);
1340         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
1341         unsigned int file_flags = force_nonblock ? O_NONBLOCK : 0;
1342         bool fixed = !!accept->file_slot;
1343         struct file *file;
1344         int ret, fd;
1345
1346 retry:
1347         if (!fixed) {
1348                 fd = __get_unused_fd_flags(accept->flags, accept->nofile);
1349                 if (unlikely(fd < 0))
1350                         return fd;
1351         }
1352         file = do_accept(req->file, file_flags, accept->addr, accept->addr_len,
1353                          accept->flags);
1354         if (IS_ERR(file)) {
1355                 if (!fixed)
1356                         put_unused_fd(fd);
1357                 ret = PTR_ERR(file);
1358                 if (ret == -EAGAIN && force_nonblock) {
1359                         /*
1360                          * if it's multishot and polled, we don't need to
1361                          * return EAGAIN to arm the poll infra since it
1362                          * has already been done
1363                          */
1364                         if (issue_flags & IO_URING_F_MULTISHOT)
1365                                 return IOU_ISSUE_SKIP_COMPLETE;
1366                         return ret;
1367                 }
1368                 if (ret == -ERESTARTSYS)
1369                         ret = -EINTR;
1370                 req_set_fail(req);
1371         } else if (!fixed) {
1372                 fd_install(fd, file);
1373                 ret = fd;
1374         } else {
1375                 ret = io_fixed_fd_install(req, issue_flags, file,
1376                                                 accept->file_slot);
1377         }
1378
1379         if (!(req->flags & REQ_F_APOLL_MULTISHOT)) {
1380                 io_req_set_res(req, ret, 0);
1381                 return IOU_OK;
1382         }
1383
1384         if (ret < 0)
1385                 return ret;
1386         if (io_post_aux_cqe(ctx, req->cqe.user_data, ret, IORING_CQE_F_MORE, false))
1387                 goto retry;
1388
1389         io_req_set_res(req, ret, 0);
1390         return IOU_STOP_MULTISHOT;
1391 }
1392
1393 int io_socket_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
1394 {
1395         struct io_socket *sock = io_kiocb_to_cmd(req, struct io_socket);
1396
1397         if (sqe->addr || sqe->rw_flags || sqe->buf_index)
1398                 return -EINVAL;
1399
1400         sock->domain = READ_ONCE(sqe->fd);
1401         sock->type = READ_ONCE(sqe->off);
1402         sock->protocol = READ_ONCE(sqe->len);
1403         sock->file_slot = READ_ONCE(sqe->file_index);
1404         sock->nofile = rlimit(RLIMIT_NOFILE);
1405
1406         sock->flags = sock->type & ~SOCK_TYPE_MASK;
1407         if (sock->file_slot && (sock->flags & SOCK_CLOEXEC))
1408                 return -EINVAL;
1409         if (sock->flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1410                 return -EINVAL;
1411         return 0;
1412 }
1413
1414 int io_socket(struct io_kiocb *req, unsigned int issue_flags)
1415 {
1416         struct io_socket *sock = io_kiocb_to_cmd(req, struct io_socket);
1417         bool fixed = !!sock->file_slot;
1418         struct file *file;
1419         int ret, fd;
1420
1421         if (!fixed) {
1422                 fd = __get_unused_fd_flags(sock->flags, sock->nofile);
1423                 if (unlikely(fd < 0))
1424                         return fd;
1425         }
1426         file = __sys_socket_file(sock->domain, sock->type, sock->protocol);
1427         if (IS_ERR(file)) {
1428                 if (!fixed)
1429                         put_unused_fd(fd);
1430                 ret = PTR_ERR(file);
1431                 if (ret == -EAGAIN && (issue_flags & IO_URING_F_NONBLOCK))
1432                         return -EAGAIN;
1433                 if (ret == -ERESTARTSYS)
1434                         ret = -EINTR;
1435                 req_set_fail(req);
1436         } else if (!fixed) {
1437                 fd_install(fd, file);
1438                 ret = fd;
1439         } else {
1440                 ret = io_fixed_fd_install(req, issue_flags, file,
1441                                             sock->file_slot);
1442         }
1443         io_req_set_res(req, ret, 0);
1444         return IOU_OK;
1445 }
1446
1447 int io_connect_prep_async(struct io_kiocb *req)
1448 {
1449         struct io_async_connect *io = req->async_data;
1450         struct io_connect *conn = io_kiocb_to_cmd(req, struct io_connect);
1451
1452         return move_addr_to_kernel(conn->addr, conn->addr_len, &io->address);
1453 }
1454
1455 int io_connect_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
1456 {
1457         struct io_connect *conn = io_kiocb_to_cmd(req, struct io_connect);
1458
1459         if (sqe->len || sqe->buf_index || sqe->rw_flags || sqe->splice_fd_in)
1460                 return -EINVAL;
1461
1462         conn->addr = u64_to_user_ptr(READ_ONCE(sqe->addr));
1463         conn->addr_len =  READ_ONCE(sqe->addr2);
1464         conn->in_progress = conn->seen_econnaborted = false;
1465         return 0;
1466 }
1467
1468 int io_connect(struct io_kiocb *req, unsigned int issue_flags)
1469 {
1470         struct io_connect *connect = io_kiocb_to_cmd(req, struct io_connect);
1471         struct io_async_connect __io, *io;
1472         unsigned file_flags;
1473         int ret;
1474         bool force_nonblock = issue_flags & IO_URING_F_NONBLOCK;
1475
1476         if (req_has_async_data(req)) {
1477                 io = req->async_data;
1478         } else {
1479                 ret = move_addr_to_kernel(connect->addr,
1480                                                 connect->addr_len,
1481                                                 &__io.address);
1482                 if (ret)
1483                         goto out;
1484                 io = &__io;
1485         }
1486
1487         file_flags = force_nonblock ? O_NONBLOCK : 0;
1488
1489         ret = __sys_connect_file(req->file, &io->address,
1490                                         connect->addr_len, file_flags);
1491         if ((ret == -EAGAIN || ret == -EINPROGRESS || ret == -ECONNABORTED)
1492             && force_nonblock) {
1493                 if (ret == -EINPROGRESS) {
1494                         connect->in_progress = true;
1495                 } else if (ret == -ECONNABORTED) {
1496                         if (connect->seen_econnaborted)
1497                                 goto out;
1498                         connect->seen_econnaborted = true;
1499                 }
1500                 if (req_has_async_data(req))
1501                         return -EAGAIN;
1502                 if (io_alloc_async_data(req)) {
1503                         ret = -ENOMEM;
1504                         goto out;
1505                 }
1506                 memcpy(req->async_data, &__io, sizeof(__io));
1507                 return -EAGAIN;
1508         }
1509         if (connect->in_progress) {
1510                 /*
1511                  * At least bluetooth will return -EBADFD on a re-connect
1512                  * attempt, and it's (supposedly) also valid to get -EISCONN
1513                  * which means the previous result is good. For both of these,
1514                  * grab the sock_error() and use that for the completion.
1515                  */
1516                 if (ret == -EBADFD || ret == -EISCONN)
1517                         ret = sock_error(sock_from_file(req->file)->sk);
1518         }
1519         if (ret == -ERESTARTSYS)
1520                 ret = -EINTR;
1521 out:
1522         if (ret < 0)
1523                 req_set_fail(req);
1524         io_req_set_res(req, ret, 0);
1525         return IOU_OK;
1526 }
1527
1528 void io_netmsg_cache_free(struct io_cache_entry *entry)
1529 {
1530         kfree(container_of(entry, struct io_async_msghdr, cache));
1531 }
1532 #endif