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