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