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