1 /* RxRPC packet transmission
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/net.h>
15 #include <linux/gfp.h>
16 #include <linux/skbuff.h>
17 #include <linux/export.h>
19 #include <net/af_rxrpc.h>
20 #include "ar-internal.h"
22 struct rxrpc_ack_buffer
{
23 struct rxrpc_wire_header whdr
;
24 struct rxrpc_ackpacket ack
;
27 struct rxrpc_ackinfo ackinfo
;
30 struct rxrpc_abort_buffer
{
31 struct rxrpc_wire_header whdr
;
35 static const char rxrpc_keepalive_string
[] = "";
38 * Increase Tx backoff on transmission failure and clear it on success.
40 static void rxrpc_tx_backoff(struct rxrpc_call
*call
, int ret
)
43 u16 tx_backoff
= READ_ONCE(call
->tx_backoff
);
46 WRITE_ONCE(call
->tx_backoff
, tx_backoff
+ 1);
48 WRITE_ONCE(call
->tx_backoff
, 0);
53 * Arrange for a keepalive ping a certain time after we last transmitted. This
54 * lets the far side know we're still interested in this call and helps keep
55 * the route through any intervening firewall open.
57 * Receiving a response to the ping will prevent the ->expect_rx_by timer from
60 static void rxrpc_set_keepalive(struct rxrpc_call
*call
)
62 unsigned long now
= jiffies
, keepalive_at
= call
->next_rx_timo
/ 6;
65 WRITE_ONCE(call
->keepalive_at
, keepalive_at
);
66 rxrpc_reduce_call_timer(call
, keepalive_at
, now
,
67 rxrpc_timer_set_for_keepalive
);
71 * Fill out an ACK packet.
73 static size_t rxrpc_fill_out_ack(struct rxrpc_connection
*conn
,
74 struct rxrpc_call
*call
,
75 struct rxrpc_ack_buffer
*pkt
,
76 rxrpc_seq_t
*_hard_ack
,
80 rxrpc_serial_t serial
;
81 rxrpc_seq_t hard_ack
, top
, seq
;
86 /* Barrier against rxrpc_input_data(). */
87 serial
= call
->ackr_serial
;
88 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
89 top
= smp_load_acquire(&call
->rx_top
);
90 *_hard_ack
= hard_ack
;
93 pkt
->ack
.bufferSpace
= htons(8);
94 pkt
->ack
.maxSkew
= htons(call
->ackr_skew
);
95 pkt
->ack
.firstPacket
= htonl(hard_ack
+ 1);
96 pkt
->ack
.previousPacket
= htonl(call
->ackr_prev_seq
);
97 pkt
->ack
.serial
= htonl(serial
);
98 pkt
->ack
.reason
= reason
;
99 pkt
->ack
.nAcks
= top
- hard_ack
;
101 if (reason
== RXRPC_ACK_PING
)
102 pkt
->whdr
.flags
|= RXRPC_REQUEST_ACK
;
104 if (after(top
, hard_ack
)) {
107 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
108 if (call
->rxtx_buffer
[ix
])
109 *ackp
++ = RXRPC_ACK_TYPE_ACK
;
111 *ackp
++ = RXRPC_ACK_TYPE_NACK
;
113 } while (before_eq(seq
, top
));
116 mtu
= conn
->params
.peer
->if_mtu
;
117 mtu
-= conn
->params
.peer
->hdrsize
;
118 jmax
= (call
->nr_jumbo_bad
> 3) ? 1 : rxrpc_rx_jumbo_max
;
119 pkt
->ackinfo
.rxMTU
= htonl(rxrpc_rx_mtu
);
120 pkt
->ackinfo
.maxMTU
= htonl(mtu
);
121 pkt
->ackinfo
.rwind
= htonl(call
->rx_winsize
);
122 pkt
->ackinfo
.jumbo_max
= htonl(jmax
);
127 return top
- hard_ack
+ 3;
131 * Send an ACK call packet.
133 int rxrpc_send_ack_packet(struct rxrpc_call
*call
, bool ping
,
134 rxrpc_serial_t
*_serial
)
136 struct rxrpc_connection
*conn
= NULL
;
137 struct rxrpc_ack_buffer
*pkt
;
140 rxrpc_serial_t serial
;
141 rxrpc_seq_t hard_ack
, top
;
146 spin_lock_bh(&call
->lock
);
148 conn
= rxrpc_get_connection_maybe(call
->conn
);
149 spin_unlock_bh(&call
->lock
);
153 pkt
= kzalloc(sizeof(*pkt
), GFP_KERNEL
);
155 rxrpc_put_connection(conn
);
159 msg
.msg_name
= &call
->peer
->srx
.transport
;
160 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
161 msg
.msg_control
= NULL
;
162 msg
.msg_controllen
= 0;
165 pkt
->whdr
.epoch
= htonl(conn
->proto
.epoch
);
166 pkt
->whdr
.cid
= htonl(call
->cid
);
167 pkt
->whdr
.callNumber
= htonl(call
->call_id
);
169 pkt
->whdr
.type
= RXRPC_PACKET_TYPE_ACK
;
170 pkt
->whdr
.flags
= RXRPC_SLOW_START_OK
| conn
->out_clientflag
;
171 pkt
->whdr
.userStatus
= 0;
172 pkt
->whdr
.securityIndex
= call
->security_ix
;
174 pkt
->whdr
.serviceId
= htons(call
->service_id
);
176 spin_lock_bh(&call
->lock
);
178 reason
= RXRPC_ACK_PING
;
180 reason
= call
->ackr_reason
;
181 if (!call
->ackr_reason
) {
182 spin_unlock_bh(&call
->lock
);
186 call
->ackr_reason
= 0;
188 n
= rxrpc_fill_out_ack(conn
, call
, pkt
, &hard_ack
, &top
, reason
);
190 spin_unlock_bh(&call
->lock
);
192 iov
[0].iov_base
= pkt
;
193 iov
[0].iov_len
= sizeof(pkt
->whdr
) + sizeof(pkt
->ack
) + n
;
194 iov
[1].iov_base
= &pkt
->ackinfo
;
195 iov
[1].iov_len
= sizeof(pkt
->ackinfo
);
196 len
= iov
[0].iov_len
+ iov
[1].iov_len
;
198 serial
= atomic_inc_return(&conn
->serial
);
199 pkt
->whdr
.serial
= htonl(serial
);
200 trace_rxrpc_tx_ack(call
->debug_id
, serial
,
201 ntohl(pkt
->ack
.firstPacket
),
202 ntohl(pkt
->ack
.serial
),
203 pkt
->ack
.reason
, pkt
->ack
.nAcks
);
208 call
->ping_serial
= serial
;
210 /* We need to stick a time in before we send the packet in case
211 * the reply gets back before kernel_sendmsg() completes - but
212 * asking UDP to send the packet can take a relatively long
215 call
->ping_time
= ktime_get_real();
216 set_bit(RXRPC_CALL_PINGING
, &call
->flags
);
217 trace_rxrpc_rtt_tx(call
, rxrpc_rtt_tx_ping
, serial
);
220 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 2, len
);
221 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
223 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
224 rxrpc_tx_point_call_ack
);
226 trace_rxrpc_tx_packet(call
->debug_id
, &pkt
->whdr
,
227 rxrpc_tx_point_call_ack
);
228 rxrpc_tx_backoff(call
, ret
);
230 if (call
->state
< RXRPC_CALL_COMPLETE
) {
233 clear_bit(RXRPC_CALL_PINGING
, &call
->flags
);
234 rxrpc_propose_ACK(call
, pkt
->ack
.reason
,
235 ntohs(pkt
->ack
.maxSkew
),
236 ntohl(pkt
->ack
.serial
),
238 rxrpc_propose_ack_retry_tx
);
240 spin_lock_bh(&call
->lock
);
241 if (after(hard_ack
, call
->ackr_consumed
))
242 call
->ackr_consumed
= hard_ack
;
243 if (after(top
, call
->ackr_seen
))
244 call
->ackr_seen
= top
;
245 spin_unlock_bh(&call
->lock
);
248 rxrpc_set_keepalive(call
);
252 rxrpc_put_connection(conn
);
258 * Send an ABORT call packet.
260 int rxrpc_send_abort_packet(struct rxrpc_call
*call
)
262 struct rxrpc_connection
*conn
= NULL
;
263 struct rxrpc_abort_buffer pkt
;
266 rxrpc_serial_t serial
;
269 /* Don't bother sending aborts for a client call once the server has
270 * hard-ACK'd all of its request data. After that point, we're not
271 * going to stop the operation proceeding, and whilst we might limit
272 * the reply, it's not worth it if we can send a new call on the same
273 * channel instead, thereby closing off this call.
275 if (rxrpc_is_client_call(call
) &&
276 test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
))
279 spin_lock_bh(&call
->lock
);
281 conn
= rxrpc_get_connection_maybe(call
->conn
);
282 spin_unlock_bh(&call
->lock
);
286 msg
.msg_name
= &call
->peer
->srx
.transport
;
287 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
288 msg
.msg_control
= NULL
;
289 msg
.msg_controllen
= 0;
292 pkt
.whdr
.epoch
= htonl(conn
->proto
.epoch
);
293 pkt
.whdr
.cid
= htonl(call
->cid
);
294 pkt
.whdr
.callNumber
= htonl(call
->call_id
);
296 pkt
.whdr
.type
= RXRPC_PACKET_TYPE_ABORT
;
297 pkt
.whdr
.flags
= conn
->out_clientflag
;
298 pkt
.whdr
.userStatus
= 0;
299 pkt
.whdr
.securityIndex
= call
->security_ix
;
301 pkt
.whdr
.serviceId
= htons(call
->service_id
);
302 pkt
.abort_code
= htonl(call
->abort_code
);
304 iov
[0].iov_base
= &pkt
;
305 iov
[0].iov_len
= sizeof(pkt
);
307 serial
= atomic_inc_return(&conn
->serial
);
308 pkt
.whdr
.serial
= htonl(serial
);
310 ret
= kernel_sendmsg(conn
->params
.local
->socket
,
311 &msg
, iov
, 1, sizeof(pkt
));
312 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
314 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
315 rxrpc_tx_point_call_abort
);
317 trace_rxrpc_tx_packet(call
->debug_id
, &pkt
.whdr
,
318 rxrpc_tx_point_call_abort
);
319 rxrpc_tx_backoff(call
, ret
);
321 rxrpc_put_connection(conn
);
326 * send a packet through the transport endpoint
328 int rxrpc_send_data_packet(struct rxrpc_call
*call
, struct sk_buff
*skb
,
331 struct rxrpc_connection
*conn
= call
->conn
;
332 struct rxrpc_wire_header whdr
;
333 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
336 rxrpc_serial_t serial
;
340 _enter(",{%d}", skb
->len
);
342 /* Each transmission of a Tx packet needs a new serial number */
343 serial
= atomic_inc_return(&conn
->serial
);
345 whdr
.epoch
= htonl(conn
->proto
.epoch
);
346 whdr
.cid
= htonl(call
->cid
);
347 whdr
.callNumber
= htonl(call
->call_id
);
348 whdr
.seq
= htonl(sp
->hdr
.seq
);
349 whdr
.serial
= htonl(serial
);
350 whdr
.type
= RXRPC_PACKET_TYPE_DATA
;
351 whdr
.flags
= sp
->hdr
.flags
;
353 whdr
.securityIndex
= call
->security_ix
;
354 whdr
._rsvd
= htons(sp
->hdr
._rsvd
);
355 whdr
.serviceId
= htons(call
->service_id
);
357 if (test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE
, &conn
->flags
) &&
359 whdr
.userStatus
= RXRPC_USERSTATUS_SERVICE_UPGRADE
;
361 iov
[0].iov_base
= &whdr
;
362 iov
[0].iov_len
= sizeof(whdr
);
363 iov
[1].iov_base
= skb
->head
;
364 iov
[1].iov_len
= skb
->len
;
365 len
= iov
[0].iov_len
+ iov
[1].iov_len
;
367 msg
.msg_name
= &call
->peer
->srx
.transport
;
368 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
369 msg
.msg_control
= NULL
;
370 msg
.msg_controllen
= 0;
373 /* If our RTT cache needs working on, request an ACK. Also request
374 * ACKs if a DATA packet appears to have been lost.
376 * However, we mustn't request an ACK on the last reply packet of a
377 * service call, lest OpenAFS incorrectly send us an ACK with some
378 * soft-ACKs in it and then never follow up with a proper hard ACK.
380 if ((!(sp
->hdr
.flags
& RXRPC_LAST_PACKET
) ||
383 (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST
, &call
->events
) ||
385 call
->cong_mode
== RXRPC_CALL_SLOW_START
||
386 (call
->peer
->rtt_usage
< 3 && sp
->hdr
.seq
& 1) ||
387 ktime_before(ktime_add_ms(call
->peer
->rtt_last_req
, 1000),
389 whdr
.flags
|= RXRPC_REQUEST_ACK
;
391 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS
)) {
393 if ((lose
++ & 7) == 7) {
395 trace_rxrpc_tx_data(call
, sp
->hdr
.seq
, serial
,
396 whdr
.flags
, retrans
, true);
401 trace_rxrpc_tx_data(call
, sp
->hdr
.seq
, serial
, whdr
.flags
, retrans
,
404 /* send the packet with the don't fragment bit set if we currently
405 * think it's small enough */
406 if (iov
[1].iov_len
>= call
->peer
->maxdata
)
407 goto send_fragmentable
;
409 down_read(&conn
->params
.local
->defrag_sem
);
411 sp
->hdr
.serial
= serial
;
412 smp_wmb(); /* Set serial before timestamp */
413 skb
->tstamp
= ktime_get_real();
415 /* send the packet by UDP
416 * - returns -EMSGSIZE if UDP would have to fragment the packet
417 * to go out of the interface
418 * - in which case, we'll have processed the ICMP error
419 * message and update the peer record
421 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 2, len
);
422 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
424 up_read(&conn
->params
.local
->defrag_sem
);
426 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
427 rxrpc_tx_point_call_data_nofrag
);
429 trace_rxrpc_tx_packet(call
->debug_id
, &whdr
,
430 rxrpc_tx_point_call_data_nofrag
);
431 rxrpc_tx_backoff(call
, ret
);
432 if (ret
== -EMSGSIZE
)
433 goto send_fragmentable
;
437 if (whdr
.flags
& RXRPC_REQUEST_ACK
) {
438 call
->peer
->rtt_last_req
= skb
->tstamp
;
439 trace_rxrpc_rtt_tx(call
, rxrpc_rtt_tx_data
, serial
);
440 if (call
->peer
->rtt_usage
> 1) {
441 unsigned long nowj
= jiffies
, ack_lost_at
;
443 ack_lost_at
= nsecs_to_jiffies(2 * call
->peer
->rtt
);
448 WRITE_ONCE(call
->ack_lost_at
, ack_lost_at
);
449 rxrpc_reduce_call_timer(call
, ack_lost_at
, nowj
,
450 rxrpc_timer_set_for_lost_ack
);
454 if (sp
->hdr
.seq
== 1 &&
455 !test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER
,
457 unsigned long nowj
= jiffies
, expect_rx_by
;
459 expect_rx_by
= nowj
+ call
->next_rx_timo
;
460 WRITE_ONCE(call
->expect_rx_by
, expect_rx_by
);
461 rxrpc_reduce_call_timer(call
, expect_rx_by
, nowj
,
462 rxrpc_timer_set_for_normal
);
465 rxrpc_set_keepalive(call
);
467 /* Cancel the call if the initial transmission fails,
468 * particularly if that's due to network routing issues that
469 * aren't going away anytime soon. The layer above can arrange
470 * the retransmission.
472 if (!test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER
, &call
->flags
))
473 rxrpc_set_call_completion(call
, RXRPC_CALL_LOCAL_ERROR
,
477 _leave(" = %d [%u]", ret
, call
->peer
->maxdata
);
481 /* attempt to send this message with fragmentation enabled */
482 _debug("send fragment");
484 down_write(&conn
->params
.local
->defrag_sem
);
486 sp
->hdr
.serial
= serial
;
487 smp_wmb(); /* Set serial before timestamp */
488 skb
->tstamp
= ktime_get_real();
490 switch (conn
->params
.local
->srx
.transport
.family
) {
492 opt
= IP_PMTUDISC_DONT
;
493 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
494 SOL_IP
, IP_MTU_DISCOVER
,
495 (char *)&opt
, sizeof(opt
));
497 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
,
499 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
501 opt
= IP_PMTUDISC_DO
;
502 kernel_setsockopt(conn
->params
.local
->socket
, SOL_IP
,
504 (char *)&opt
, sizeof(opt
));
508 #ifdef CONFIG_AF_RXRPC_IPV6
510 opt
= IPV6_PMTUDISC_DONT
;
511 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
512 SOL_IPV6
, IPV6_MTU_DISCOVER
,
513 (char *)&opt
, sizeof(opt
));
515 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
,
517 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
519 opt
= IPV6_PMTUDISC_DO
;
520 kernel_setsockopt(conn
->params
.local
->socket
,
521 SOL_IPV6
, IPV6_MTU_DISCOVER
,
522 (char *)&opt
, sizeof(opt
));
529 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
530 rxrpc_tx_point_call_data_frag
);
532 trace_rxrpc_tx_packet(call
->debug_id
, &whdr
,
533 rxrpc_tx_point_call_data_frag
);
534 rxrpc_tx_backoff(call
, ret
);
536 up_write(&conn
->params
.local
->defrag_sem
);
541 * reject packets through the local endpoint
543 void rxrpc_reject_packets(struct rxrpc_local
*local
)
545 struct sockaddr_rxrpc srx
;
546 struct rxrpc_skb_priv
*sp
;
547 struct rxrpc_wire_header whdr
;
555 _enter("%d", local
->debug_id
);
557 iov
[0].iov_base
= &whdr
;
558 iov
[0].iov_len
= sizeof(whdr
);
559 iov
[1].iov_base
= &code
;
560 iov
[1].iov_len
= sizeof(code
);
562 msg
.msg_name
= &srx
.transport
;
563 msg
.msg_control
= NULL
;
564 msg
.msg_controllen
= 0;
567 memset(&whdr
, 0, sizeof(whdr
));
569 while ((skb
= skb_dequeue(&local
->reject_queue
))) {
570 rxrpc_see_skb(skb
, rxrpc_skb_rx_seen
);
574 case RXRPC_SKB_MARK_REJECT_BUSY
:
575 whdr
.type
= RXRPC_PACKET_TYPE_BUSY
;
579 case RXRPC_SKB_MARK_REJECT_ABORT
:
580 whdr
.type
= RXRPC_PACKET_TYPE_ABORT
;
581 code
= htonl(skb
->priority
);
582 size
= sizeof(whdr
) + sizeof(code
);
586 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
590 if (rxrpc_extract_addr_from_skb(&srx
, skb
) == 0) {
591 msg
.msg_namelen
= srx
.transport_len
;
593 whdr
.epoch
= htonl(sp
->hdr
.epoch
);
594 whdr
.cid
= htonl(sp
->hdr
.cid
);
595 whdr
.callNumber
= htonl(sp
->hdr
.callNumber
);
596 whdr
.serviceId
= htons(sp
->hdr
.serviceId
);
597 whdr
.flags
= sp
->hdr
.flags
;
598 whdr
.flags
^= RXRPC_CLIENT_INITIATED
;
599 whdr
.flags
&= RXRPC_CLIENT_INITIATED
;
601 ret
= kernel_sendmsg(local
->socket
, &msg
,
604 trace_rxrpc_tx_fail(local
->debug_id
, 0, ret
,
605 rxrpc_tx_point_reject
);
607 trace_rxrpc_tx_packet(local
->debug_id
, &whdr
,
608 rxrpc_tx_point_reject
);
611 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
618 * Send a VERSION reply to a peer as a keepalive.
620 void rxrpc_send_keepalive(struct rxrpc_peer
*peer
)
622 struct rxrpc_wire_header whdr
;
630 msg
.msg_name
= &peer
->srx
.transport
;
631 msg
.msg_namelen
= peer
->srx
.transport_len
;
632 msg
.msg_control
= NULL
;
633 msg
.msg_controllen
= 0;
636 whdr
.epoch
= htonl(peer
->local
->rxnet
->epoch
);
641 whdr
.type
= RXRPC_PACKET_TYPE_VERSION
; /* Not client-initiated */
642 whdr
.flags
= RXRPC_LAST_PACKET
;
644 whdr
.securityIndex
= 0;
648 iov
[0].iov_base
= &whdr
;
649 iov
[0].iov_len
= sizeof(whdr
);
650 iov
[1].iov_base
= (char *)rxrpc_keepalive_string
;
651 iov
[1].iov_len
= sizeof(rxrpc_keepalive_string
);
653 len
= iov
[0].iov_len
+ iov
[1].iov_len
;
655 _proto("Tx VERSION (keepalive)");
657 ret
= kernel_sendmsg(peer
->local
->socket
, &msg
, iov
, 2, len
);
659 trace_rxrpc_tx_fail(peer
->debug_id
, 0, ret
,
660 rxrpc_tx_point_version_keepalive
);
662 trace_rxrpc_tx_packet(peer
->debug_id
, &whdr
,
663 rxrpc_tx_point_version_keepalive
);
665 peer
->last_tx_at
= ktime_get_seconds();