1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* AF_RXRPC sendmsg() implementation. 3 * 4 * Copyright (C) 2007, 2016 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/net.h> 11 #include <linux/gfp.h> 12 #include <linux/skbuff.h> 13 #include <linux/export.h> 14 #include <linux/sched/signal.h> 15 16 #include <net/sock.h> 17 #include <net/af_rxrpc.h> 18 #include "ar-internal.h" 19 20 /* 21 * Propose an abort to be made in the I/O thread. 22 */ 23 bool rxrpc_propose_abort(struct rxrpc_call *call, s32 abort_code, int error, 24 enum rxrpc_abort_reason why) 25 { 26 _enter("{%d},%d,%d,%u", call->debug_id, abort_code, error, why); 27 28 if (!call->send_abort && !rxrpc_call_is_complete(call)) { 29 call->send_abort_why = why; 30 call->send_abort_err = error; 31 call->send_abort_seq = 0; 32 trace_rxrpc_abort_call(call, abort_code); 33 /* Request abort locklessly vs rxrpc_input_call_event(). */ 34 smp_store_release(&call->send_abort, abort_code); 35 rxrpc_poke_call(call, rxrpc_call_poke_abort); 36 return true; 37 } 38 39 return false; 40 } 41 42 /* 43 * Wait for a call to become connected. Interruption here doesn't cause the 44 * call to be aborted. 45 */ 46 static int rxrpc_wait_to_be_connected(struct rxrpc_call *call, long *timeo) 47 { 48 DECLARE_WAITQUEUE(myself, current); 49 int ret = 0; 50 51 _enter("%d", call->debug_id); 52 53 if (rxrpc_call_state(call) != RXRPC_CALL_CLIENT_AWAIT_CONN) 54 goto no_wait; 55 56 add_wait_queue_exclusive(&call->waitq, &myself); 57 58 for (;;) { 59 switch (call->interruptibility) { 60 case RXRPC_INTERRUPTIBLE: 61 case RXRPC_PREINTERRUPTIBLE: 62 set_current_state(TASK_INTERRUPTIBLE); 63 break; 64 case RXRPC_UNINTERRUPTIBLE: 65 default: 66 set_current_state(TASK_UNINTERRUPTIBLE); 67 break; 68 } 69 70 if (rxrpc_call_state(call) != RXRPC_CALL_CLIENT_AWAIT_CONN) 71 break; 72 if ((call->interruptibility == RXRPC_INTERRUPTIBLE || 73 call->interruptibility == RXRPC_PREINTERRUPTIBLE) && 74 signal_pending(current)) { 75 ret = sock_intr_errno(*timeo); 76 break; 77 } 78 *timeo = schedule_timeout(*timeo); 79 } 80 81 remove_wait_queue(&call->waitq, &myself); 82 __set_current_state(TASK_RUNNING); 83 84 no_wait: 85 if (ret == 0 && rxrpc_call_is_complete(call)) 86 ret = call->error; 87 88 _leave(" = %d", ret); 89 return ret; 90 } 91 92 /* 93 * Return true if there's sufficient Tx queue space. 94 */ 95 static bool rxrpc_check_tx_space(struct rxrpc_call *call, rxrpc_seq_t *_tx_win) 96 { 97 rxrpc_seq_t tx_bottom = READ_ONCE(call->tx_bottom); 98 99 if (_tx_win) 100 *_tx_win = tx_bottom; 101 return call->send_top - tx_bottom < 256; 102 } 103 104 /* 105 * Wait for space to appear in the Tx queue or a signal to occur. 106 */ 107 static int rxrpc_wait_for_tx_window_intr(struct rxrpc_sock *rx, 108 struct rxrpc_call *call, 109 long *timeo) 110 { 111 for (;;) { 112 set_current_state(TASK_INTERRUPTIBLE); 113 if (rxrpc_check_tx_space(call, NULL)) 114 return 0; 115 116 if (rxrpc_call_is_complete(call)) 117 return call->error; 118 119 if (signal_pending(current)) 120 return sock_intr_errno(*timeo); 121 122 trace_rxrpc_txqueue(call, rxrpc_txqueue_wait); 123 *timeo = schedule_timeout(*timeo); 124 } 125 } 126 127 /* 128 * Wait for space to appear in the Tx queue uninterruptibly, but with 129 * a timeout of 2*RTT if no progress was made and a signal occurred. 130 */ 131 static int rxrpc_wait_for_tx_window_waitall(struct rxrpc_sock *rx, 132 struct rxrpc_call *call) 133 { 134 rxrpc_seq_t tx_start, tx_win; 135 signed long rtt, timeout; 136 137 rtt = READ_ONCE(call->srtt_us) >> 3; 138 rtt = usecs_to_jiffies(rtt) * 2; 139 if (rtt < 2) 140 rtt = 2; 141 142 timeout = rtt; 143 tx_start = READ_ONCE(call->tx_bottom); 144 145 for (;;) { 146 set_current_state(TASK_UNINTERRUPTIBLE); 147 148 if (rxrpc_check_tx_space(call, &tx_win)) 149 return 0; 150 151 if (rxrpc_call_is_complete(call)) 152 return call->error; 153 154 if (timeout == 0 && 155 tx_win == tx_start && signal_pending(current)) 156 return -EINTR; 157 158 if (tx_win != tx_start) { 159 timeout = rtt; 160 tx_start = tx_win; 161 } 162 163 trace_rxrpc_txqueue(call, rxrpc_txqueue_wait); 164 timeout = schedule_timeout(timeout); 165 } 166 } 167 168 /* 169 * Wait for space to appear in the Tx queue uninterruptibly. 170 */ 171 static int rxrpc_wait_for_tx_window_nonintr(struct rxrpc_sock *rx, 172 struct rxrpc_call *call, 173 long *timeo) 174 { 175 for (;;) { 176 set_current_state(TASK_UNINTERRUPTIBLE); 177 if (rxrpc_check_tx_space(call, NULL)) 178 return 0; 179 180 if (rxrpc_call_is_complete(call)) 181 return call->error; 182 183 trace_rxrpc_txqueue(call, rxrpc_txqueue_wait); 184 *timeo = schedule_timeout(*timeo); 185 } 186 } 187 188 /* 189 * wait for space to appear in the transmit/ACK window 190 * - caller holds the socket locked 191 */ 192 static int rxrpc_wait_for_tx_window(struct rxrpc_sock *rx, 193 struct rxrpc_call *call, 194 long *timeo, 195 bool waitall) 196 { 197 DECLARE_WAITQUEUE(myself, current); 198 int ret; 199 200 _enter(",{%u,%u,%u}", 201 call->tx_bottom, call->tx_top, call->tx_winsize); 202 203 add_wait_queue(&call->waitq, &myself); 204 205 switch (call->interruptibility) { 206 case RXRPC_INTERRUPTIBLE: 207 if (waitall) 208 ret = rxrpc_wait_for_tx_window_waitall(rx, call); 209 else 210 ret = rxrpc_wait_for_tx_window_intr(rx, call, timeo); 211 break; 212 case RXRPC_PREINTERRUPTIBLE: 213 case RXRPC_UNINTERRUPTIBLE: 214 default: 215 ret = rxrpc_wait_for_tx_window_nonintr(rx, call, timeo); 216 break; 217 } 218 219 remove_wait_queue(&call->waitq, &myself); 220 set_current_state(TASK_RUNNING); 221 _leave(" = %d", ret); 222 return ret; 223 } 224 225 /* 226 * Notify the owner of the call that the transmit phase is ended and the last 227 * packet has been queued. 228 */ 229 static void rxrpc_notify_end_tx(struct rxrpc_sock *rx, struct rxrpc_call *call, 230 rxrpc_notify_end_tx_t notify_end_tx) 231 { 232 if (notify_end_tx) 233 notify_end_tx(&rx->sk, call, call->user_call_ID); 234 } 235 236 /* 237 * Queue a DATA packet for transmission, set the resend timeout and send 238 * the packet immediately. Returns the error from rxrpc_send_data_packet() 239 * in case the caller wants to do something with it. 240 */ 241 static void rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call, 242 struct rxrpc_txbuf *txb, 243 rxrpc_notify_end_tx_t notify_end_tx) 244 { 245 struct rxrpc_txqueue *sq = call->send_queue; 246 rxrpc_seq_t seq = txb->seq; 247 bool poke, last = txb->flags & RXRPC_LAST_PACKET; 248 int ix = seq & RXRPC_TXQ_MASK; 249 rxrpc_inc_stat(call->rxnet, stat_tx_data); 250 251 ASSERTCMP(txb->seq, ==, call->send_top + 1); 252 253 if (last) 254 trace_rxrpc_txqueue(call, rxrpc_txqueue_queue_last); 255 else 256 trace_rxrpc_txqueue(call, rxrpc_txqueue_queue); 257 258 if (WARN_ON_ONCE(sq->bufs[ix])) 259 trace_rxrpc_tq(call, sq, seq, rxrpc_tq_queue_dup); 260 else 261 trace_rxrpc_tq(call, sq, seq, rxrpc_tq_queue); 262 263 /* Add the packet to the call's output buffer */ 264 poke = (READ_ONCE(call->tx_bottom) == call->send_top); 265 sq->bufs[ix] = txb; 266 /* Order send_top after the queue->next pointer and txb content. */ 267 smp_store_release(&call->send_top, seq); 268 if (last) { 269 set_bit(RXRPC_CALL_TX_NO_MORE, &call->flags); 270 rxrpc_notify_end_tx(rx, call, notify_end_tx); 271 call->send_queue = NULL; 272 } 273 274 if (poke) 275 rxrpc_poke_call(call, rxrpc_call_poke_start); 276 } 277 278 /* 279 * Allocate a new txqueue unit and add it to the transmission queue. 280 */ 281 static int rxrpc_alloc_txqueue(struct sock *sk, struct rxrpc_call *call) 282 { 283 struct rxrpc_txqueue *tq; 284 285 tq = kzalloc_obj(*tq, sk->sk_allocation); 286 if (!tq) 287 return -ENOMEM; 288 289 tq->xmit_ts_base = KTIME_MIN; 290 for (int i = 0; i < RXRPC_NR_TXQUEUE; i++) 291 tq->segment_xmit_ts[i] = UINT_MAX; 292 293 if (call->send_queue) { 294 tq->qbase = call->send_top + 1; 295 call->send_queue->next = tq; 296 call->send_queue = tq; 297 } else if (WARN_ON(call->tx_queue)) { 298 kfree(tq); 299 return -ENOMEM; 300 } else { 301 /* We start at seq 1, so pretend seq 0 is hard-acked. */ 302 tq->nr_reported_acks = 1; 303 tq->segment_acked = 1UL; 304 tq->qbase = 0; 305 call->tx_qbase = 0; 306 call->send_queue = tq; 307 call->tx_qtail = tq; 308 call->tx_queue = tq; 309 } 310 311 trace_rxrpc_tq(call, tq, call->send_top, rxrpc_tq_alloc); 312 return 0; 313 } 314 315 /* 316 * send data through a socket 317 * - must be called in process context 318 * - The caller holds the call user access mutex, but not the socket lock. 319 */ 320 static int rxrpc_send_data(struct rxrpc_sock *rx, 321 struct rxrpc_call *call, 322 struct msghdr *msg, size_t len, 323 rxrpc_notify_end_tx_t notify_end_tx) 324 __releases(&call->user_mutex) 325 { 326 struct sock *sk = &rx->sk; 327 enum rxrpc_call_state state; 328 long timeo; 329 bool more = msg->msg_flags & MSG_MORE; 330 int ret, copied = 0; 331 332 if (test_bit(RXRPC_CALL_TX_NO_MORE, &call->flags)) { 333 trace_rxrpc_abort(call->debug_id, rxrpc_sendmsg_late_send, 334 call->cid, call->call_id, call->rx_consumed, 335 0, -EPROTO); 336 ret = -EPROTO; 337 goto out_unlock; 338 } 339 340 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT); 341 342 ret = rxrpc_wait_to_be_connected(call, &timeo); 343 if (ret < 0) 344 goto out_unlock; 345 346 if (call->conn->state == RXRPC_CONN_CLIENT_UNSECURED) { 347 ret = rxrpc_init_client_conn_security(call->conn); 348 if (ret < 0) 349 goto out_unlock; 350 } 351 352 /* this should be in poll */ 353 sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk); 354 355 reload: 356 ret = -EPIPE; 357 if (sk->sk_shutdown & SEND_SHUTDOWN) 358 goto maybe_error; 359 state = rxrpc_call_state(call); 360 ret = -ESHUTDOWN; 361 if (state >= RXRPC_CALL_COMPLETE) 362 goto maybe_error; 363 ret = -EPROTO; 364 if (state != RXRPC_CALL_CLIENT_PRE_SEND && 365 state != RXRPC_CALL_CLIENT_SEND_REQUEST && 366 state != RXRPC_CALL_SERVER_ACK_REQUEST && 367 state != RXRPC_CALL_SERVER_SEND_REPLY) { 368 /* Request phase complete for this client call */ 369 trace_rxrpc_abort(call->debug_id, rxrpc_sendmsg_late_send, 370 call->cid, call->call_id, call->rx_consumed, 371 0, -EPROTO); 372 goto maybe_error; 373 } 374 375 ret = -EMSGSIZE; 376 if (call->tx_total_len != -1) { 377 if (len > call->tx_total_len) 378 goto maybe_error; 379 if (!more && len != call->tx_total_len) 380 goto maybe_error; 381 } 382 383 do { 384 struct rxrpc_txbuf *txb = call->tx_pending; 385 386 if (!txb) { 387 size_t remain; 388 389 _debug("alloc"); 390 391 if (!rxrpc_check_tx_space(call, NULL)) 392 goto wait_for_space; 393 394 /* See if we need to begin/extend the Tx queue. */ 395 if (!call->send_queue || !((call->send_top + 1) & RXRPC_TXQ_MASK)) { 396 ret = rxrpc_alloc_txqueue(sk, call); 397 if (ret < 0) 398 goto maybe_error; 399 } 400 401 /* Work out the maximum size of a packet. Assume that 402 * the security header is going to be in the padded 403 * region (enc blocksize), but the trailer is not. 404 */ 405 remain = more ? INT_MAX : len; 406 txb = call->conn->security->alloc_txbuf(call, remain, sk->sk_allocation); 407 if (!txb) { 408 ret = -ENOMEM; 409 goto maybe_error; 410 } 411 call->tx_pending = txb; 412 } else { 413 rxrpc_see_txbuf(txb, rxrpc_txbuf_see_send_more); 414 } 415 416 _debug("append"); 417 418 /* append next segment of data to the current buffer */ 419 if (len > 0) { 420 size_t copy = min3(txb->space, len, msg_data_left(msg)); 421 422 _debug("add %zu", copy); 423 if (!copy_from_iter_full(txb->data + txb->offset, 424 copy, &msg->msg_iter)) 425 goto efault; 426 _debug("added"); 427 txb->space -= copy; 428 txb->len += copy; 429 txb->offset += copy; 430 copied += copy; 431 len -= copy; 432 if (call->tx_total_len != -1) 433 call->tx_total_len -= copy; 434 } 435 436 /* check for the far side aborting the call or a network error 437 * occurring */ 438 if (rxrpc_call_is_complete(call)) 439 goto call_terminated; 440 441 /* add the packet to the send queue if it's now full */ 442 if (!txb->space || 443 (len == 0 && !more)) { 444 if (len == 0 && !more) 445 txb->flags |= RXRPC_LAST_PACKET; 446 447 ret = call->security->secure_packet(call, txb); 448 if (ret < 0) 449 goto out_unlock; 450 rxrpc_queue_packet(rx, call, txb, notify_end_tx); 451 call->tx_pending = NULL; 452 } 453 } while (len > 0 && msg_data_left(msg) > 0); 454 455 success: 456 ret = copied; 457 if (rxrpc_call_is_complete(call) && 458 call->error < 0) 459 ret = call->error; 460 out_unlock: 461 mutex_unlock(&call->user_mutex); 462 _leave(" = %d", ret); 463 return ret; 464 465 call_terminated: 466 ret = call->error; 467 goto out_unlock; 468 469 maybe_error: 470 if (copied) 471 goto success; 472 goto out_unlock; 473 474 efault: 475 ret = -EFAULT; 476 goto out_unlock; 477 478 wait_for_space: 479 ret = -EAGAIN; 480 if (msg->msg_flags & MSG_DONTWAIT) 481 goto maybe_error; 482 mutex_unlock(&call->user_mutex); 483 484 ret = rxrpc_wait_for_tx_window(rx, call, &timeo, 485 msg->msg_flags & MSG_WAITALL); 486 if (ret < 0) 487 goto out_nolock; 488 if (call->interruptibility == RXRPC_INTERRUPTIBLE) { 489 if (mutex_lock_interruptible(&call->user_mutex) < 0) { 490 ret = sock_intr_errno(timeo); 491 goto out_nolock; 492 } 493 } else { 494 mutex_lock(&call->user_mutex); 495 } 496 goto reload; 497 out_nolock: 498 _leave(" = %d [intr]", ret); 499 return copied ?: ret; 500 } 501 502 /* 503 * extract control messages from the sendmsg() control buffer 504 */ 505 static int rxrpc_sendmsg_cmsg(struct msghdr *msg, struct rxrpc_send_params *p) 506 { 507 struct cmsghdr *cmsg; 508 bool got_user_ID = false; 509 int len; 510 511 if (msg->msg_controllen == 0) 512 return -EINVAL; 513 514 for_each_cmsghdr(cmsg, msg) { 515 if (!CMSG_OK(msg, cmsg)) 516 return -EINVAL; 517 518 len = cmsg->cmsg_len - sizeof(struct cmsghdr); 519 _debug("CMSG %d, %d, %d", 520 cmsg->cmsg_level, cmsg->cmsg_type, len); 521 522 if (cmsg->cmsg_level != SOL_RXRPC) 523 continue; 524 525 switch (cmsg->cmsg_type) { 526 case RXRPC_USER_CALL_ID: 527 if (msg->msg_flags & MSG_CMSG_COMPAT) { 528 if (len != sizeof(u32)) 529 return -EINVAL; 530 p->call.user_call_ID = *(u32 *)CMSG_DATA(cmsg); 531 } else { 532 if (len != sizeof(unsigned long)) 533 return -EINVAL; 534 p->call.user_call_ID = *(unsigned long *) 535 CMSG_DATA(cmsg); 536 } 537 got_user_ID = true; 538 break; 539 540 case RXRPC_ABORT: 541 if (p->command != RXRPC_CMD_SEND_DATA) 542 return -EINVAL; 543 p->command = RXRPC_CMD_SEND_ABORT; 544 if (len != sizeof(p->abort_code)) 545 return -EINVAL; 546 p->abort_code = *(unsigned int *)CMSG_DATA(cmsg); 547 if (p->abort_code == 0) 548 return -EINVAL; 549 break; 550 551 case RXRPC_CHARGE_ACCEPT: 552 if (p->command != RXRPC_CMD_SEND_DATA) 553 return -EINVAL; 554 p->command = RXRPC_CMD_CHARGE_ACCEPT; 555 if (len != 0) 556 return -EINVAL; 557 break; 558 559 case RXRPC_EXCLUSIVE_CALL: 560 p->exclusive = true; 561 if (len != 0) 562 return -EINVAL; 563 break; 564 565 case RXRPC_UPGRADE_SERVICE: 566 p->upgrade = true; 567 if (len != 0) 568 return -EINVAL; 569 break; 570 571 case RXRPC_TX_LENGTH: 572 if (p->call.tx_total_len != -1 || len != sizeof(__s64)) 573 return -EINVAL; 574 p->call.tx_total_len = *(__s64 *)CMSG_DATA(cmsg); 575 if (p->call.tx_total_len < 0) 576 return -EINVAL; 577 break; 578 579 case RXRPC_SET_CALL_TIMEOUT: 580 if (len & 3 || len < 4 || len > 12) 581 return -EINVAL; 582 memcpy(&p->call.timeouts, CMSG_DATA(cmsg), len); 583 p->call.nr_timeouts = len / 4; 584 if (p->call.timeouts.hard > INT_MAX / HZ) 585 return -ERANGE; 586 if (p->call.nr_timeouts >= 2 && p->call.timeouts.idle > 60 * 60 * 1000) 587 return -ERANGE; 588 if (p->call.nr_timeouts >= 3 && p->call.timeouts.normal > 60 * 60 * 1000) 589 return -ERANGE; 590 break; 591 592 default: 593 return -EINVAL; 594 } 595 } 596 597 if (!got_user_ID) 598 return -EINVAL; 599 if (p->call.tx_total_len != -1 && p->command != RXRPC_CMD_SEND_DATA) 600 return -EINVAL; 601 _leave(" = 0"); 602 return 0; 603 } 604 605 /* 606 * Create a new client call for sendmsg(). 607 * - Called with the socket lock held, which it must release. 608 * - If it returns a call, the call's lock will need releasing by the caller. 609 */ 610 static struct rxrpc_call * 611 rxrpc_new_client_call_for_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, 612 struct rxrpc_send_params *p) 613 __releases(&rx->sk.sk_lock) 614 __acquires(&call->user_mutex) 615 { 616 struct rxrpc_conn_parameters cp; 617 struct rxrpc_peer *peer; 618 struct rxrpc_call *call; 619 struct key *key; 620 621 DECLARE_SOCKADDR(struct sockaddr_rxrpc *, srx, msg->msg_name); 622 623 _enter(""); 624 625 if (!msg->msg_name) { 626 release_sock(&rx->sk); 627 return ERR_PTR(-EDESTADDRREQ); 628 } 629 630 peer = rxrpc_lookup_peer(rx->local, srx, GFP_KERNEL); 631 if (!peer) { 632 release_sock(&rx->sk); 633 return ERR_PTR(-ENOMEM); 634 } 635 636 key = rx->key; 637 if (key && !rx->key->payload.data[0]) 638 key = NULL; 639 640 memset(&cp, 0, sizeof(cp)); 641 cp.local = rx->local; 642 cp.peer = peer; 643 cp.key = key; 644 cp.security_level = rx->min_sec_level; 645 cp.exclusive = rx->exclusive | p->exclusive; 646 cp.upgrade = p->upgrade; 647 cp.service_id = srx->srx_service; 648 call = rxrpc_new_client_call(rx, &cp, &p->call, GFP_KERNEL, 649 atomic_inc_return(&rxrpc_debug_id)); 650 /* The socket is now unlocked */ 651 652 rxrpc_put_peer(peer, rxrpc_peer_put_application); 653 _leave(" = %p\n", call); 654 return call; 655 } 656 657 /* 658 * send a message forming part of a client call through an RxRPC socket 659 * - caller holds the socket locked 660 * - the socket may be either a client socket or a server socket 661 */ 662 int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) 663 { 664 struct rxrpc_call *call; 665 int ret; 666 667 struct rxrpc_send_params p = { 668 .call.tx_total_len = -1, 669 .call.user_call_ID = 0, 670 .call.nr_timeouts = 0, 671 .call.interruptibility = RXRPC_INTERRUPTIBLE, 672 .abort_code = 0, 673 .command = RXRPC_CMD_SEND_DATA, 674 .exclusive = false, 675 .upgrade = false, 676 }; 677 678 _enter(""); 679 680 ret = rxrpc_sendmsg_cmsg(msg, &p); 681 if (ret < 0) 682 goto error_release_sock; 683 684 if (p.command == RXRPC_CMD_CHARGE_ACCEPT) { 685 ret = -EINVAL; 686 if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) 687 goto error_release_sock; 688 ret = rxrpc_user_charge_accept(rx, p.call.user_call_ID); 689 goto error_release_sock; 690 } 691 692 call = rxrpc_find_call_by_user_ID(rx, p.call.user_call_ID); 693 if (!call) { 694 ret = -EBADSLT; 695 if (p.command != RXRPC_CMD_SEND_DATA) 696 goto error_release_sock; 697 call = rxrpc_new_client_call_for_sendmsg(rx, msg, &p); 698 /* The socket is now unlocked... */ 699 if (IS_ERR(call)) 700 return PTR_ERR(call); 701 /* ... and we have the call lock. */ 702 p.call.nr_timeouts = 0; 703 ret = 0; 704 if (rxrpc_call_is_complete(call)) 705 goto out_put_unlock; 706 } else { 707 switch (rxrpc_call_state(call)) { 708 case RXRPC_CALL_CLIENT_AWAIT_CONN: 709 case RXRPC_CALL_SERVER_RECV_REQUEST: 710 if (p.command == RXRPC_CMD_SEND_ABORT) 711 break; 712 fallthrough; 713 case RXRPC_CALL_UNINITIALISED: 714 case RXRPC_CALL_SERVER_PREALLOC: 715 rxrpc_put_call(call, rxrpc_call_put_sendmsg); 716 ret = -EBUSY; 717 goto error_release_sock; 718 default: 719 break; 720 } 721 722 ret = mutex_lock_interruptible(&call->user_mutex); 723 release_sock(&rx->sk); 724 if (ret < 0) { 725 ret = -ERESTARTSYS; 726 goto error_put; 727 } 728 729 if (p.call.tx_total_len != -1) { 730 ret = -EINVAL; 731 if (call->tx_total_len != -1 || 732 call->tx_pending || 733 call->tx_top != 0) 734 goto out_put_unlock; 735 call->tx_total_len = p.call.tx_total_len; 736 } 737 } 738 739 switch (p.call.nr_timeouts) { 740 case 3: 741 WRITE_ONCE(call->next_rx_timo, p.call.timeouts.normal); 742 fallthrough; 743 case 2: 744 WRITE_ONCE(call->next_req_timo, p.call.timeouts.idle); 745 fallthrough; 746 case 1: 747 if (p.call.timeouts.hard > 0) { 748 ktime_t delay = ms_to_ktime(p.call.timeouts.hard * MSEC_PER_SEC); 749 750 WRITE_ONCE(call->expect_term_by, 751 ktime_add(p.call.timeouts.hard, 752 ktime_get_real())); 753 trace_rxrpc_timer_set(call, delay, rxrpc_timer_trace_hard); 754 rxrpc_poke_call(call, rxrpc_call_poke_set_timeout); 755 756 } 757 break; 758 } 759 760 if (rxrpc_call_is_complete(call)) { 761 /* it's too late for this call */ 762 ret = -ESHUTDOWN; 763 goto out_put_unlock; 764 } 765 766 switch (p.command) { 767 case RXRPC_CMD_SEND_ABORT: 768 rxrpc_propose_abort(call, p.abort_code, -ECONNABORTED, 769 rxrpc_abort_call_sendmsg); 770 ret = 0; 771 break; 772 case RXRPC_CMD_SEND_DATA: 773 ret = rxrpc_send_data(rx, call, msg, len, NULL); 774 goto error_put; 775 default: 776 ret = -EINVAL; 777 break; 778 } 779 780 out_put_unlock: 781 mutex_unlock(&call->user_mutex); 782 error_put: 783 rxrpc_put_call(call, rxrpc_call_put_sendmsg); 784 _leave(" = %d", ret); 785 return ret; 786 787 error_release_sock: 788 release_sock(&rx->sk); 789 return ret; 790 } 791 792 /** 793 * rxrpc_kernel_send_data - Allow a kernel service to send data on a call 794 * @sock: The socket the call is on 795 * @call: The call to send data through 796 * @msg: The data to send 797 * @notify_end_tx: Notification that the last packet is queued. 798 * 799 * Allow a kernel service to send data on a call. The call must be in an state 800 * appropriate to sending data. No control data should be supplied in @msg, 801 * nor should an address be supplied. MSG_MORE should be flagged if there's 802 * more data to come, otherwise this data will end the transmission phase. 803 * 804 * Return: %0 if successful and a negative error code otherwise. 805 */ 806 int rxrpc_kernel_send_data(struct socket *sock, struct rxrpc_call *call, 807 struct msghdr *msg, rxrpc_notify_end_tx_t notify_end_tx) 808 { 809 int ret; 810 811 _enter("{%d},", call->debug_id); 812 813 ASSERTCMP(msg->msg_name, ==, NULL); 814 ASSERTCMP(msg->msg_control, ==, NULL); 815 816 for (;;) { 817 mutex_lock(&call->user_mutex); 818 819 ret = rxrpc_send_data(rxrpc_sk(sock->sk), call, msg, 820 msg_data_left(msg), notify_end_tx); 821 if (ret == -ESHUTDOWN) 822 ret = call->error; 823 if (ret < 0) 824 break; 825 if (msg_data_left(msg) == 0) { 826 ret = 0; 827 break; 828 } 829 if (ret == 0) { 830 ret = -EIO; 831 break; 832 } 833 } 834 835 _leave(" = %d", ret); 836 return ret; 837 } 838 EXPORT_SYMBOL(rxrpc_kernel_send_data); 839 840 /** 841 * rxrpc_kernel_abort_call - Allow a kernel service to abort a call 842 * @sock: The socket the call is on 843 * @call: The call to be aborted 844 * @abort_code: The abort code to stick into the ABORT packet 845 * @error: Local error value 846 * @why: Indication as to why. 847 * 848 * Allow a kernel service to abort a call if it's still in an abortable state. 849 * 850 * Return: %true if the call was aborted, %false if it was already complete. 851 */ 852 bool rxrpc_kernel_abort_call(struct socket *sock, struct rxrpc_call *call, 853 u32 abort_code, int error, enum rxrpc_abort_reason why) 854 { 855 bool aborted; 856 857 _enter("{%d},%d,%d,%u", call->debug_id, abort_code, error, why); 858 859 mutex_lock(&call->user_mutex); 860 aborted = rxrpc_propose_abort(call, abort_code, error, why); 861 mutex_unlock(&call->user_mutex); 862 return aborted; 863 } 864 EXPORT_SYMBOL(rxrpc_kernel_abort_call); 865 866 /** 867 * rxrpc_kernel_set_tx_length - Set the total Tx length on a call 868 * @sock: The socket the call is on 869 * @call: The call to be informed 870 * @tx_total_len: The amount of data to be transmitted for this call 871 * 872 * Allow a kernel service to set the total transmit length on a call. This 873 * allows buffer-to-packet encrypt-and-copy to be performed. 874 * 875 * This function is primarily for use for setting the reply length since the 876 * request length can be set when beginning the call. 877 */ 878 void rxrpc_kernel_set_tx_length(struct socket *sock, struct rxrpc_call *call, 879 s64 tx_total_len) 880 { 881 WARN_ON(call->tx_total_len != -1); 882 call->tx_total_len = tx_total_len; 883 } 884 EXPORT_SYMBOL(rxrpc_kernel_set_tx_length); 885