1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* RxRPC packet transmission 3 * 4 * Copyright (C) 2007 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 <net/sock.h> 15 #include <net/af_rxrpc.h> 16 #include <net/udp.h> 17 #include "ar-internal.h" 18 19 extern int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len); 20 21 static ssize_t do_udp_sendmsg(struct socket *socket, struct msghdr *msg, size_t len) 22 { 23 struct sockaddr *sa = msg->msg_name; 24 struct sock *sk = socket->sk; 25 26 if (IS_ENABLED(CONFIG_AF_RXRPC_IPV6)) { 27 if (sa->sa_family == AF_INET6) { 28 if (sk->sk_family != AF_INET6) { 29 pr_warn("AF_INET6 address on AF_INET socket\n"); 30 return -ENOPROTOOPT; 31 } 32 return udpv6_sendmsg(sk, msg, len); 33 } 34 } 35 return udp_sendmsg(sk, msg, len); 36 } 37 38 struct rxrpc_abort_buffer { 39 struct rxrpc_wire_header whdr; 40 __be32 abort_code; 41 }; 42 43 static const char rxrpc_keepalive_string[] = ""; 44 45 /* 46 * Increase Tx backoff on transmission failure and clear it on success. 47 */ 48 static void rxrpc_tx_backoff(struct rxrpc_call *call, int ret) 49 { 50 if (ret < 0) { 51 u16 tx_backoff = READ_ONCE(call->tx_backoff); 52 53 if (tx_backoff < HZ) 54 WRITE_ONCE(call->tx_backoff, tx_backoff + 1); 55 } else { 56 WRITE_ONCE(call->tx_backoff, 0); 57 } 58 } 59 60 /* 61 * Arrange for a keepalive ping a certain time after we last transmitted. This 62 * lets the far side know we're still interested in this call and helps keep 63 * the route through any intervening firewall open. 64 * 65 * Receiving a response to the ping will prevent the ->expect_rx_by timer from 66 * expiring. 67 */ 68 static void rxrpc_set_keepalive(struct rxrpc_call *call) 69 { 70 unsigned long now = jiffies, keepalive_at = call->next_rx_timo / 6; 71 72 keepalive_at += now; 73 WRITE_ONCE(call->keepalive_at, keepalive_at); 74 rxrpc_reduce_call_timer(call, keepalive_at, now, 75 rxrpc_timer_set_for_keepalive); 76 } 77 78 /* 79 * Fill out an ACK packet. 80 */ 81 static size_t rxrpc_fill_out_ack(struct rxrpc_connection *conn, 82 struct rxrpc_call *call, 83 struct rxrpc_txbuf *txb) 84 { 85 struct rxrpc_ackinfo ackinfo; 86 unsigned int qsize, sack, wrap, to; 87 rxrpc_seq_t window, wtop; 88 int rsize; 89 u32 mtu, jmax; 90 u8 *ackp = txb->acks; 91 92 call->ackr_nr_unacked = 0; 93 atomic_set(&call->ackr_nr_consumed, 0); 94 rxrpc_inc_stat(call->rxnet, stat_tx_ack_fill); 95 clear_bit(RXRPC_CALL_RX_IS_IDLE, &call->flags); 96 97 window = call->ackr_window; 98 wtop = call->ackr_wtop; 99 sack = call->ackr_sack_base % RXRPC_SACK_SIZE; 100 txb->ack.firstPacket = htonl(window); 101 txb->ack.nAcks = wtop - window; 102 103 if (after(wtop, window)) { 104 wrap = RXRPC_SACK_SIZE - sack; 105 to = min_t(unsigned int, txb->ack.nAcks, RXRPC_SACK_SIZE); 106 107 if (sack + txb->ack.nAcks <= RXRPC_SACK_SIZE) { 108 memcpy(txb->acks, call->ackr_sack_table + sack, txb->ack.nAcks); 109 } else { 110 memcpy(txb->acks, call->ackr_sack_table + sack, wrap); 111 memcpy(txb->acks + wrap, call->ackr_sack_table, 112 to - wrap); 113 } 114 115 ackp += to; 116 } else if (before(wtop, window)) { 117 pr_warn("ack window backward %x %x", window, wtop); 118 } else if (txb->ack.reason == RXRPC_ACK_DELAY) { 119 txb->ack.reason = RXRPC_ACK_IDLE; 120 } 121 122 mtu = conn->peer->if_mtu; 123 mtu -= conn->peer->hdrsize; 124 jmax = rxrpc_rx_jumbo_max; 125 qsize = (window - 1) - call->rx_consumed; 126 rsize = max_t(int, call->rx_winsize - qsize, 0); 127 ackinfo.rxMTU = htonl(rxrpc_rx_mtu); 128 ackinfo.maxMTU = htonl(mtu); 129 ackinfo.rwind = htonl(rsize); 130 ackinfo.jumbo_max = htonl(jmax); 131 132 *ackp++ = 0; 133 *ackp++ = 0; 134 *ackp++ = 0; 135 memcpy(ackp, &ackinfo, sizeof(ackinfo)); 136 return txb->ack.nAcks + 3 + sizeof(ackinfo); 137 } 138 139 /* 140 * Record the beginning of an RTT probe. 141 */ 142 static int rxrpc_begin_rtt_probe(struct rxrpc_call *call, rxrpc_serial_t serial, 143 enum rxrpc_rtt_tx_trace why) 144 { 145 unsigned long avail = call->rtt_avail; 146 int rtt_slot = 9; 147 148 if (!(avail & RXRPC_CALL_RTT_AVAIL_MASK)) 149 goto no_slot; 150 151 rtt_slot = __ffs(avail & RXRPC_CALL_RTT_AVAIL_MASK); 152 if (!test_and_clear_bit(rtt_slot, &call->rtt_avail)) 153 goto no_slot; 154 155 call->rtt_serial[rtt_slot] = serial; 156 call->rtt_sent_at[rtt_slot] = ktime_get_real(); 157 smp_wmb(); /* Write data before avail bit */ 158 set_bit(rtt_slot + RXRPC_CALL_RTT_PEND_SHIFT, &call->rtt_avail); 159 160 trace_rxrpc_rtt_tx(call, why, rtt_slot, serial); 161 return rtt_slot; 162 163 no_slot: 164 trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_no_slot, rtt_slot, serial); 165 return -1; 166 } 167 168 /* 169 * Cancel an RTT probe. 170 */ 171 static void rxrpc_cancel_rtt_probe(struct rxrpc_call *call, 172 rxrpc_serial_t serial, int rtt_slot) 173 { 174 if (rtt_slot != -1) { 175 clear_bit(rtt_slot + RXRPC_CALL_RTT_PEND_SHIFT, &call->rtt_avail); 176 smp_wmb(); /* Clear pending bit before setting slot */ 177 set_bit(rtt_slot, &call->rtt_avail); 178 trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_cancel, rtt_slot, serial); 179 } 180 } 181 182 /* 183 * Transmit an ACK packet. 184 */ 185 int rxrpc_send_ack_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb) 186 { 187 struct rxrpc_connection *conn; 188 struct msghdr msg; 189 struct kvec iov[1]; 190 rxrpc_serial_t serial; 191 size_t len, n; 192 int ret, rtt_slot = -1; 193 194 if (test_bit(RXRPC_CALL_DISCONNECTED, &call->flags)) 195 return -ECONNRESET; 196 197 conn = call->conn; 198 199 msg.msg_name = &call->peer->srx.transport; 200 msg.msg_namelen = call->peer->srx.transport_len; 201 msg.msg_control = NULL; 202 msg.msg_controllen = 0; 203 msg.msg_flags = 0; 204 205 if (txb->ack.reason == RXRPC_ACK_PING) 206 txb->wire.flags |= RXRPC_REQUEST_ACK; 207 208 n = rxrpc_fill_out_ack(conn, call, txb); 209 if (n == 0) 210 return 0; 211 212 iov[0].iov_base = &txb->wire; 213 iov[0].iov_len = sizeof(txb->wire) + sizeof(txb->ack) + n; 214 len = iov[0].iov_len; 215 216 serial = atomic_inc_return(&conn->serial); 217 txb->wire.serial = htonl(serial); 218 trace_rxrpc_tx_ack(call->debug_id, serial, 219 ntohl(txb->ack.firstPacket), 220 ntohl(txb->ack.serial), txb->ack.reason, txb->ack.nAcks); 221 222 if (txb->ack.reason == RXRPC_ACK_PING) 223 rtt_slot = rxrpc_begin_rtt_probe(call, serial, rxrpc_rtt_tx_ping); 224 225 rxrpc_inc_stat(call->rxnet, stat_tx_ack_send); 226 227 /* Grab the highest received seq as late as possible */ 228 txb->ack.previousPacket = htonl(call->rx_highest_seq); 229 230 iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, len); 231 ret = do_udp_sendmsg(conn->local->socket, &msg, len); 232 call->peer->last_tx_at = ktime_get_seconds(); 233 if (ret < 0) { 234 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 235 rxrpc_tx_point_call_ack); 236 } else { 237 trace_rxrpc_tx_packet(call->debug_id, &txb->wire, 238 rxrpc_tx_point_call_ack); 239 if (txb->wire.flags & RXRPC_REQUEST_ACK) 240 call->peer->rtt_last_req = ktime_get_real(); 241 } 242 rxrpc_tx_backoff(call, ret); 243 244 if (!__rxrpc_call_is_complete(call)) { 245 if (ret < 0) 246 rxrpc_cancel_rtt_probe(call, serial, rtt_slot); 247 rxrpc_set_keepalive(call); 248 } 249 250 return ret; 251 } 252 253 /* 254 * Send an ABORT call packet. 255 */ 256 int rxrpc_send_abort_packet(struct rxrpc_call *call) 257 { 258 struct rxrpc_connection *conn; 259 struct rxrpc_abort_buffer pkt; 260 struct msghdr msg; 261 struct kvec iov[1]; 262 rxrpc_serial_t serial; 263 int ret; 264 265 /* Don't bother sending aborts for a client call once the server has 266 * hard-ACK'd all of its request data. After that point, we're not 267 * going to stop the operation proceeding, and whilst we might limit 268 * the reply, it's not worth it if we can send a new call on the same 269 * channel instead, thereby closing off this call. 270 */ 271 if (rxrpc_is_client_call(call) && 272 test_bit(RXRPC_CALL_TX_ALL_ACKED, &call->flags)) 273 return 0; 274 275 if (test_bit(RXRPC_CALL_DISCONNECTED, &call->flags)) 276 return -ECONNRESET; 277 278 conn = call->conn; 279 280 msg.msg_name = &call->peer->srx.transport; 281 msg.msg_namelen = call->peer->srx.transport_len; 282 msg.msg_control = NULL; 283 msg.msg_controllen = 0; 284 msg.msg_flags = 0; 285 286 pkt.whdr.epoch = htonl(conn->proto.epoch); 287 pkt.whdr.cid = htonl(call->cid); 288 pkt.whdr.callNumber = htonl(call->call_id); 289 pkt.whdr.seq = 0; 290 pkt.whdr.type = RXRPC_PACKET_TYPE_ABORT; 291 pkt.whdr.flags = conn->out_clientflag; 292 pkt.whdr.userStatus = 0; 293 pkt.whdr.securityIndex = call->security_ix; 294 pkt.whdr._rsvd = 0; 295 pkt.whdr.serviceId = htons(call->dest_srx.srx_service); 296 pkt.abort_code = htonl(call->abort_code); 297 298 iov[0].iov_base = &pkt; 299 iov[0].iov_len = sizeof(pkt); 300 301 serial = atomic_inc_return(&conn->serial); 302 pkt.whdr.serial = htonl(serial); 303 304 iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, sizeof(pkt)); 305 ret = do_udp_sendmsg(conn->local->socket, &msg, sizeof(pkt)); 306 conn->peer->last_tx_at = ktime_get_seconds(); 307 if (ret < 0) 308 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 309 rxrpc_tx_point_call_abort); 310 else 311 trace_rxrpc_tx_packet(call->debug_id, &pkt.whdr, 312 rxrpc_tx_point_call_abort); 313 rxrpc_tx_backoff(call, ret); 314 return ret; 315 } 316 317 /* 318 * send a packet through the transport endpoint 319 */ 320 int rxrpc_send_data_packet(struct rxrpc_call *call, struct rxrpc_txbuf *txb) 321 { 322 enum rxrpc_req_ack_trace why; 323 struct rxrpc_connection *conn = call->conn; 324 struct msghdr msg; 325 struct kvec iov[1]; 326 rxrpc_serial_t serial; 327 size_t len; 328 int ret, rtt_slot = -1; 329 330 _enter("%x,{%d}", txb->seq, txb->len); 331 332 /* Each transmission of a Tx packet needs a new serial number */ 333 serial = atomic_inc_return(&conn->serial); 334 txb->wire.serial = htonl(serial); 335 336 if (test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags) && 337 txb->seq == 1) 338 txb->wire.userStatus = RXRPC_USERSTATUS_SERVICE_UPGRADE; 339 340 iov[0].iov_base = &txb->wire; 341 iov[0].iov_len = sizeof(txb->wire) + txb->len; 342 len = iov[0].iov_len; 343 iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, len); 344 345 msg.msg_name = &call->peer->srx.transport; 346 msg.msg_namelen = call->peer->srx.transport_len; 347 msg.msg_control = NULL; 348 msg.msg_controllen = 0; 349 msg.msg_flags = 0; 350 351 /* If our RTT cache needs working on, request an ACK. Also request 352 * ACKs if a DATA packet appears to have been lost. 353 * 354 * However, we mustn't request an ACK on the last reply packet of a 355 * service call, lest OpenAFS incorrectly send us an ACK with some 356 * soft-ACKs in it and then never follow up with a proper hard ACK. 357 */ 358 if (txb->wire.flags & RXRPC_REQUEST_ACK) 359 why = rxrpc_reqack_already_on; 360 else if (test_bit(RXRPC_TXBUF_LAST, &txb->flags) && rxrpc_sending_to_client(txb)) 361 why = rxrpc_reqack_no_srv_last; 362 else if (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events)) 363 why = rxrpc_reqack_ack_lost; 364 else if (test_bit(RXRPC_TXBUF_RESENT, &txb->flags)) 365 why = rxrpc_reqack_retrans; 366 else if (call->cong_mode == RXRPC_CALL_SLOW_START && call->cong_cwnd <= 2) 367 why = rxrpc_reqack_slow_start; 368 else if (call->tx_winsize <= 2) 369 why = rxrpc_reqack_small_txwin; 370 else if (call->peer->rtt_count < 3 && txb->seq & 1) 371 why = rxrpc_reqack_more_rtt; 372 else if (ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), ktime_get_real())) 373 why = rxrpc_reqack_old_rtt; 374 else 375 goto dont_set_request_ack; 376 377 rxrpc_inc_stat(call->rxnet, stat_why_req_ack[why]); 378 trace_rxrpc_req_ack(call->debug_id, txb->seq, why); 379 if (why != rxrpc_reqack_no_srv_last) 380 txb->wire.flags |= RXRPC_REQUEST_ACK; 381 dont_set_request_ack: 382 383 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS)) { 384 static int lose; 385 if ((lose++ & 7) == 7) { 386 ret = 0; 387 trace_rxrpc_tx_data(call, txb->seq, serial, 388 txb->wire.flags, 389 test_bit(RXRPC_TXBUF_RESENT, &txb->flags), 390 true); 391 goto done; 392 } 393 } 394 395 trace_rxrpc_tx_data(call, txb->seq, serial, txb->wire.flags, 396 test_bit(RXRPC_TXBUF_RESENT, &txb->flags), false); 397 398 /* Track what we've attempted to transmit at least once so that the 399 * retransmission algorithm doesn't try to resend what we haven't sent 400 * yet. However, this can race as we can receive an ACK before we get 401 * to this point. But, OTOH, if we won't get an ACK mentioning this 402 * packet unless the far side received it (though it could have 403 * discarded it anyway and NAK'd it). 404 */ 405 cmpxchg(&call->tx_transmitted, txb->seq - 1, txb->seq); 406 407 /* send the packet with the don't fragment bit set if we currently 408 * think it's small enough */ 409 if (txb->len >= call->peer->maxdata) 410 goto send_fragmentable; 411 412 txb->last_sent = ktime_get_real(); 413 if (txb->wire.flags & RXRPC_REQUEST_ACK) 414 rtt_slot = rxrpc_begin_rtt_probe(call, serial, rxrpc_rtt_tx_data); 415 416 /* send the packet by UDP 417 * - returns -EMSGSIZE if UDP would have to fragment the packet 418 * to go out of the interface 419 * - in which case, we'll have processed the ICMP error 420 * message and update the peer record 421 */ 422 rxrpc_inc_stat(call->rxnet, stat_tx_data_send); 423 ret = do_udp_sendmsg(conn->local->socket, &msg, len); 424 conn->peer->last_tx_at = ktime_get_seconds(); 425 426 if (ret < 0) { 427 rxrpc_inc_stat(call->rxnet, stat_tx_data_send_fail); 428 rxrpc_cancel_rtt_probe(call, serial, rtt_slot); 429 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 430 rxrpc_tx_point_call_data_nofrag); 431 } else { 432 trace_rxrpc_tx_packet(call->debug_id, &txb->wire, 433 rxrpc_tx_point_call_data_nofrag); 434 } 435 436 rxrpc_tx_backoff(call, ret); 437 if (ret == -EMSGSIZE) 438 goto send_fragmentable; 439 440 done: 441 if (ret >= 0) { 442 call->tx_last_sent = txb->last_sent; 443 if (txb->wire.flags & RXRPC_REQUEST_ACK) { 444 call->peer->rtt_last_req = txb->last_sent; 445 if (call->peer->rtt_count > 1) { 446 unsigned long nowj = jiffies, ack_lost_at; 447 448 ack_lost_at = rxrpc_get_rto_backoff(call->peer, false); 449 ack_lost_at += nowj; 450 WRITE_ONCE(call->ack_lost_at, ack_lost_at); 451 rxrpc_reduce_call_timer(call, ack_lost_at, nowj, 452 rxrpc_timer_set_for_lost_ack); 453 } 454 } 455 456 if (txb->seq == 1 && 457 !test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER, 458 &call->flags)) { 459 unsigned long nowj = jiffies, expect_rx_by; 460 461 expect_rx_by = nowj + call->next_rx_timo; 462 WRITE_ONCE(call->expect_rx_by, expect_rx_by); 463 rxrpc_reduce_call_timer(call, expect_rx_by, nowj, 464 rxrpc_timer_set_for_normal); 465 } 466 467 rxrpc_set_keepalive(call); 468 } else { 469 /* Cancel the call if the initial transmission fails, 470 * particularly if that's due to network routing issues that 471 * aren't going away anytime soon. The layer above can arrange 472 * the retransmission. 473 */ 474 if (!test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER, &call->flags)) 475 rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR, 476 RX_USER_ABORT, ret); 477 } 478 479 _leave(" = %d [%u]", ret, call->peer->maxdata); 480 return ret; 481 482 send_fragmentable: 483 /* attempt to send this message with fragmentation enabled */ 484 _debug("send fragment"); 485 486 txb->last_sent = ktime_get_real(); 487 if (txb->wire.flags & RXRPC_REQUEST_ACK) 488 rtt_slot = rxrpc_begin_rtt_probe(call, serial, rxrpc_rtt_tx_data); 489 490 switch (conn->local->srx.transport.family) { 491 case AF_INET6: 492 case AF_INET: 493 ip_sock_set_mtu_discover(conn->local->socket->sk, 494 IP_PMTUDISC_DONT); 495 rxrpc_inc_stat(call->rxnet, stat_tx_data_send_frag); 496 ret = do_udp_sendmsg(conn->local->socket, &msg, len); 497 conn->peer->last_tx_at = ktime_get_seconds(); 498 499 ip_sock_set_mtu_discover(conn->local->socket->sk, 500 IP_PMTUDISC_DO); 501 break; 502 503 default: 504 BUG(); 505 } 506 507 if (ret < 0) { 508 rxrpc_inc_stat(call->rxnet, stat_tx_data_send_fail); 509 rxrpc_cancel_rtt_probe(call, serial, rtt_slot); 510 trace_rxrpc_tx_fail(call->debug_id, serial, ret, 511 rxrpc_tx_point_call_data_frag); 512 } else { 513 trace_rxrpc_tx_packet(call->debug_id, &txb->wire, 514 rxrpc_tx_point_call_data_frag); 515 } 516 rxrpc_tx_backoff(call, ret); 517 goto done; 518 } 519 520 /* 521 * Transmit a connection-level abort. 522 */ 523 void rxrpc_send_conn_abort(struct rxrpc_connection *conn) 524 { 525 struct rxrpc_wire_header whdr; 526 struct msghdr msg; 527 struct kvec iov[2]; 528 __be32 word; 529 size_t len; 530 u32 serial; 531 int ret; 532 533 msg.msg_name = &conn->peer->srx.transport; 534 msg.msg_namelen = conn->peer->srx.transport_len; 535 msg.msg_control = NULL; 536 msg.msg_controllen = 0; 537 msg.msg_flags = 0; 538 539 whdr.epoch = htonl(conn->proto.epoch); 540 whdr.cid = htonl(conn->proto.cid); 541 whdr.callNumber = 0; 542 whdr.seq = 0; 543 whdr.type = RXRPC_PACKET_TYPE_ABORT; 544 whdr.flags = conn->out_clientflag; 545 whdr.userStatus = 0; 546 whdr.securityIndex = conn->security_ix; 547 whdr._rsvd = 0; 548 whdr.serviceId = htons(conn->service_id); 549 550 word = htonl(conn->abort_code); 551 552 iov[0].iov_base = &whdr; 553 iov[0].iov_len = sizeof(whdr); 554 iov[1].iov_base = &word; 555 iov[1].iov_len = sizeof(word); 556 557 len = iov[0].iov_len + iov[1].iov_len; 558 559 serial = atomic_inc_return(&conn->serial); 560 whdr.serial = htonl(serial); 561 562 iov_iter_kvec(&msg.msg_iter, WRITE, iov, 2, len); 563 ret = do_udp_sendmsg(conn->local->socket, &msg, len); 564 if (ret < 0) { 565 trace_rxrpc_tx_fail(conn->debug_id, serial, ret, 566 rxrpc_tx_point_conn_abort); 567 _debug("sendmsg failed: %d", ret); 568 return; 569 } 570 571 trace_rxrpc_tx_packet(conn->debug_id, &whdr, rxrpc_tx_point_conn_abort); 572 573 conn->peer->last_tx_at = ktime_get_seconds(); 574 } 575 576 /* 577 * Reject a packet through the local endpoint. 578 */ 579 void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb) 580 { 581 struct rxrpc_wire_header whdr; 582 struct sockaddr_rxrpc srx; 583 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 584 struct msghdr msg; 585 struct kvec iov[2]; 586 size_t size; 587 __be32 code; 588 int ret, ioc; 589 590 rxrpc_see_skb(skb, rxrpc_skb_see_reject); 591 592 iov[0].iov_base = &whdr; 593 iov[0].iov_len = sizeof(whdr); 594 iov[1].iov_base = &code; 595 iov[1].iov_len = sizeof(code); 596 597 msg.msg_name = &srx.transport; 598 msg.msg_control = NULL; 599 msg.msg_controllen = 0; 600 msg.msg_flags = 0; 601 602 memset(&whdr, 0, sizeof(whdr)); 603 604 switch (skb->mark) { 605 case RXRPC_SKB_MARK_REJECT_BUSY: 606 whdr.type = RXRPC_PACKET_TYPE_BUSY; 607 size = sizeof(whdr); 608 ioc = 1; 609 break; 610 case RXRPC_SKB_MARK_REJECT_ABORT: 611 whdr.type = RXRPC_PACKET_TYPE_ABORT; 612 code = htonl(skb->priority); 613 size = sizeof(whdr) + sizeof(code); 614 ioc = 2; 615 break; 616 default: 617 return; 618 } 619 620 if (rxrpc_extract_addr_from_skb(&srx, skb) == 0) { 621 msg.msg_namelen = srx.transport_len; 622 623 whdr.epoch = htonl(sp->hdr.epoch); 624 whdr.cid = htonl(sp->hdr.cid); 625 whdr.callNumber = htonl(sp->hdr.callNumber); 626 whdr.serviceId = htons(sp->hdr.serviceId); 627 whdr.flags = sp->hdr.flags; 628 whdr.flags ^= RXRPC_CLIENT_INITIATED; 629 whdr.flags &= RXRPC_CLIENT_INITIATED; 630 631 iov_iter_kvec(&msg.msg_iter, WRITE, iov, ioc, size); 632 ret = do_udp_sendmsg(local->socket, &msg, size); 633 if (ret < 0) 634 trace_rxrpc_tx_fail(local->debug_id, 0, ret, 635 rxrpc_tx_point_reject); 636 else 637 trace_rxrpc_tx_packet(local->debug_id, &whdr, 638 rxrpc_tx_point_reject); 639 } 640 } 641 642 /* 643 * Send a VERSION reply to a peer as a keepalive. 644 */ 645 void rxrpc_send_keepalive(struct rxrpc_peer *peer) 646 { 647 struct rxrpc_wire_header whdr; 648 struct msghdr msg; 649 struct kvec iov[2]; 650 size_t len; 651 int ret; 652 653 _enter(""); 654 655 msg.msg_name = &peer->srx.transport; 656 msg.msg_namelen = peer->srx.transport_len; 657 msg.msg_control = NULL; 658 msg.msg_controllen = 0; 659 msg.msg_flags = 0; 660 661 whdr.epoch = htonl(peer->local->rxnet->epoch); 662 whdr.cid = 0; 663 whdr.callNumber = 0; 664 whdr.seq = 0; 665 whdr.serial = 0; 666 whdr.type = RXRPC_PACKET_TYPE_VERSION; /* Not client-initiated */ 667 whdr.flags = RXRPC_LAST_PACKET; 668 whdr.userStatus = 0; 669 whdr.securityIndex = 0; 670 whdr._rsvd = 0; 671 whdr.serviceId = 0; 672 673 iov[0].iov_base = &whdr; 674 iov[0].iov_len = sizeof(whdr); 675 iov[1].iov_base = (char *)rxrpc_keepalive_string; 676 iov[1].iov_len = sizeof(rxrpc_keepalive_string); 677 678 len = iov[0].iov_len + iov[1].iov_len; 679 680 iov_iter_kvec(&msg.msg_iter, WRITE, iov, 2, len); 681 ret = do_udp_sendmsg(peer->local->socket, &msg, len); 682 if (ret < 0) 683 trace_rxrpc_tx_fail(peer->debug_id, 0, ret, 684 rxrpc_tx_point_version_keepalive); 685 else 686 trace_rxrpc_tx_packet(peer->debug_id, &whdr, 687 rxrpc_tx_point_version_keepalive); 688 689 peer->last_tx_at = ktime_get_seconds(); 690 _leave(""); 691 } 692 693 /* 694 * Schedule an instant Tx resend. 695 */ 696 static inline void rxrpc_instant_resend(struct rxrpc_call *call, 697 struct rxrpc_txbuf *txb) 698 { 699 if (!__rxrpc_call_is_complete(call)) 700 kdebug("resend"); 701 } 702 703 /* 704 * Transmit one packet. 705 */ 706 void rxrpc_transmit_one(struct rxrpc_call *call, struct rxrpc_txbuf *txb) 707 { 708 int ret; 709 710 ret = rxrpc_send_data_packet(call, txb); 711 if (ret < 0) { 712 switch (ret) { 713 case -ENETUNREACH: 714 case -EHOSTUNREACH: 715 case -ECONNREFUSED: 716 rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR, 717 0, ret); 718 break; 719 default: 720 _debug("need instant resend %d", ret); 721 rxrpc_instant_resend(call, txb); 722 } 723 } else { 724 unsigned long now = jiffies; 725 unsigned long resend_at = now + call->peer->rto_j; 726 727 WRITE_ONCE(call->resend_at, resend_at); 728 rxrpc_reduce_call_timer(call, resend_at, now, 729 rxrpc_timer_set_for_send); 730 } 731 } 732