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