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 * Arrange for a keepalive ping a certain time after we last transmitted. This
39 * lets the far side know we're still interested in this call and helps keep
40 * the route through any intervening firewall open.
42 * Receiving a response to the ping will prevent the ->expect_rx_by timer from
45 static void rxrpc_set_keepalive(struct rxrpc_call
*call
)
47 unsigned long now
= jiffies
, keepalive_at
= call
->next_rx_timo
/ 6;
50 WRITE_ONCE(call
->keepalive_at
, keepalive_at
);
51 rxrpc_reduce_call_timer(call
, keepalive_at
, now
,
52 rxrpc_timer_set_for_keepalive
);
56 * Fill out an ACK packet.
58 static size_t rxrpc_fill_out_ack(struct rxrpc_connection
*conn
,
59 struct rxrpc_call
*call
,
60 struct rxrpc_ack_buffer
*pkt
,
61 rxrpc_seq_t
*_hard_ack
,
65 rxrpc_serial_t serial
;
66 rxrpc_seq_t hard_ack
, top
, seq
;
71 /* Barrier against rxrpc_input_data(). */
72 serial
= call
->ackr_serial
;
73 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
74 top
= smp_load_acquire(&call
->rx_top
);
75 *_hard_ack
= hard_ack
;
78 pkt
->ack
.bufferSpace
= htons(8);
79 pkt
->ack
.maxSkew
= htons(call
->ackr_skew
);
80 pkt
->ack
.firstPacket
= htonl(hard_ack
+ 1);
81 pkt
->ack
.previousPacket
= htonl(call
->ackr_prev_seq
);
82 pkt
->ack
.serial
= htonl(serial
);
83 pkt
->ack
.reason
= reason
;
84 pkt
->ack
.nAcks
= top
- hard_ack
;
86 if (reason
== RXRPC_ACK_PING
)
87 pkt
->whdr
.flags
|= RXRPC_REQUEST_ACK
;
89 if (after(top
, hard_ack
)) {
92 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
93 if (call
->rxtx_buffer
[ix
])
94 *ackp
++ = RXRPC_ACK_TYPE_ACK
;
96 *ackp
++ = RXRPC_ACK_TYPE_NACK
;
98 } while (before_eq(seq
, top
));
101 mtu
= conn
->params
.peer
->if_mtu
;
102 mtu
-= conn
->params
.peer
->hdrsize
;
103 jmax
= (call
->nr_jumbo_bad
> 3) ? 1 : rxrpc_rx_jumbo_max
;
104 pkt
->ackinfo
.rxMTU
= htonl(rxrpc_rx_mtu
);
105 pkt
->ackinfo
.maxMTU
= htonl(mtu
);
106 pkt
->ackinfo
.rwind
= htonl(call
->rx_winsize
);
107 pkt
->ackinfo
.jumbo_max
= htonl(jmax
);
112 return top
- hard_ack
+ 3;
116 * Send an ACK call packet.
118 int rxrpc_send_ack_packet(struct rxrpc_call
*call
, bool ping
,
119 rxrpc_serial_t
*_serial
)
121 struct rxrpc_connection
*conn
= NULL
;
122 struct rxrpc_ack_buffer
*pkt
;
125 rxrpc_serial_t serial
;
126 rxrpc_seq_t hard_ack
, top
;
131 spin_lock_bh(&call
->lock
);
133 conn
= rxrpc_get_connection_maybe(call
->conn
);
134 spin_unlock_bh(&call
->lock
);
138 pkt
= kzalloc(sizeof(*pkt
), GFP_KERNEL
);
140 rxrpc_put_connection(conn
);
144 msg
.msg_name
= &call
->peer
->srx
.transport
;
145 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
146 msg
.msg_control
= NULL
;
147 msg
.msg_controllen
= 0;
150 pkt
->whdr
.epoch
= htonl(conn
->proto
.epoch
);
151 pkt
->whdr
.cid
= htonl(call
->cid
);
152 pkt
->whdr
.callNumber
= htonl(call
->call_id
);
154 pkt
->whdr
.type
= RXRPC_PACKET_TYPE_ACK
;
155 pkt
->whdr
.flags
= RXRPC_SLOW_START_OK
| conn
->out_clientflag
;
156 pkt
->whdr
.userStatus
= 0;
157 pkt
->whdr
.securityIndex
= call
->security_ix
;
159 pkt
->whdr
.serviceId
= htons(call
->service_id
);
161 spin_lock_bh(&call
->lock
);
163 reason
= RXRPC_ACK_PING
;
165 reason
= call
->ackr_reason
;
166 if (!call
->ackr_reason
) {
167 spin_unlock_bh(&call
->lock
);
171 call
->ackr_reason
= 0;
173 n
= rxrpc_fill_out_ack(conn
, call
, pkt
, &hard_ack
, &top
, reason
);
175 spin_unlock_bh(&call
->lock
);
177 iov
[0].iov_base
= pkt
;
178 iov
[0].iov_len
= sizeof(pkt
->whdr
) + sizeof(pkt
->ack
) + n
;
179 iov
[1].iov_base
= &pkt
->ackinfo
;
180 iov
[1].iov_len
= sizeof(pkt
->ackinfo
);
181 len
= iov
[0].iov_len
+ iov
[1].iov_len
;
183 serial
= atomic_inc_return(&conn
->serial
);
184 pkt
->whdr
.serial
= htonl(serial
);
185 trace_rxrpc_tx_ack(call
->debug_id
, serial
,
186 ntohl(pkt
->ack
.firstPacket
),
187 ntohl(pkt
->ack
.serial
),
188 pkt
->ack
.reason
, pkt
->ack
.nAcks
);
193 call
->ping_serial
= serial
;
195 /* We need to stick a time in before we send the packet in case
196 * the reply gets back before kernel_sendmsg() completes - but
197 * asking UDP to send the packet can take a relatively long
200 call
->ping_time
= ktime_get_real();
201 set_bit(RXRPC_CALL_PINGING
, &call
->flags
);
202 trace_rxrpc_rtt_tx(call
, rxrpc_rtt_tx_ping
, serial
);
205 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 2, len
);
206 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
208 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
209 rxrpc_tx_point_call_ack
);
211 trace_rxrpc_tx_packet(call
->debug_id
, &pkt
->whdr
,
212 rxrpc_tx_point_call_ack
);
214 if (call
->state
< RXRPC_CALL_COMPLETE
) {
217 clear_bit(RXRPC_CALL_PINGING
, &call
->flags
);
218 rxrpc_propose_ACK(call
, pkt
->ack
.reason
,
219 ntohs(pkt
->ack
.maxSkew
),
220 ntohl(pkt
->ack
.serial
),
222 rxrpc_propose_ack_retry_tx
);
224 spin_lock_bh(&call
->lock
);
225 if (after(hard_ack
, call
->ackr_consumed
))
226 call
->ackr_consumed
= hard_ack
;
227 if (after(top
, call
->ackr_seen
))
228 call
->ackr_seen
= top
;
229 spin_unlock_bh(&call
->lock
);
232 rxrpc_set_keepalive(call
);
236 rxrpc_put_connection(conn
);
242 * Send an ABORT call packet.
244 int rxrpc_send_abort_packet(struct rxrpc_call
*call
)
246 struct rxrpc_connection
*conn
= NULL
;
247 struct rxrpc_abort_buffer pkt
;
250 rxrpc_serial_t serial
;
253 /* Don't bother sending aborts for a client call once the server has
254 * hard-ACK'd all of its request data. After that point, we're not
255 * going to stop the operation proceeding, and whilst we might limit
256 * the reply, it's not worth it if we can send a new call on the same
257 * channel instead, thereby closing off this call.
259 if (rxrpc_is_client_call(call
) &&
260 test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
))
263 spin_lock_bh(&call
->lock
);
265 conn
= rxrpc_get_connection_maybe(call
->conn
);
266 spin_unlock_bh(&call
->lock
);
270 msg
.msg_name
= &call
->peer
->srx
.transport
;
271 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
272 msg
.msg_control
= NULL
;
273 msg
.msg_controllen
= 0;
276 pkt
.whdr
.epoch
= htonl(conn
->proto
.epoch
);
277 pkt
.whdr
.cid
= htonl(call
->cid
);
278 pkt
.whdr
.callNumber
= htonl(call
->call_id
);
280 pkt
.whdr
.type
= RXRPC_PACKET_TYPE_ABORT
;
281 pkt
.whdr
.flags
= conn
->out_clientflag
;
282 pkt
.whdr
.userStatus
= 0;
283 pkt
.whdr
.securityIndex
= call
->security_ix
;
285 pkt
.whdr
.serviceId
= htons(call
->service_id
);
286 pkt
.abort_code
= htonl(call
->abort_code
);
288 iov
[0].iov_base
= &pkt
;
289 iov
[0].iov_len
= sizeof(pkt
);
291 serial
= atomic_inc_return(&conn
->serial
);
292 pkt
.whdr
.serial
= htonl(serial
);
294 ret
= kernel_sendmsg(conn
->params
.local
->socket
,
295 &msg
, iov
, 1, sizeof(pkt
));
296 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
298 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
299 rxrpc_tx_point_call_abort
);
301 trace_rxrpc_tx_packet(call
->debug_id
, &pkt
.whdr
,
302 rxrpc_tx_point_call_abort
);
305 rxrpc_put_connection(conn
);
310 * send a packet through the transport endpoint
312 int rxrpc_send_data_packet(struct rxrpc_call
*call
, struct sk_buff
*skb
,
315 struct rxrpc_connection
*conn
= call
->conn
;
316 struct rxrpc_wire_header whdr
;
317 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
320 rxrpc_serial_t serial
;
325 _enter(",{%d}", skb
->len
);
327 /* Each transmission of a Tx packet needs a new serial number */
328 serial
= atomic_inc_return(&conn
->serial
);
330 whdr
.epoch
= htonl(conn
->proto
.epoch
);
331 whdr
.cid
= htonl(call
->cid
);
332 whdr
.callNumber
= htonl(call
->call_id
);
333 whdr
.seq
= htonl(sp
->hdr
.seq
);
334 whdr
.serial
= htonl(serial
);
335 whdr
.type
= RXRPC_PACKET_TYPE_DATA
;
336 whdr
.flags
= sp
->hdr
.flags
;
338 whdr
.securityIndex
= call
->security_ix
;
339 whdr
._rsvd
= htons(sp
->hdr
._rsvd
);
340 whdr
.serviceId
= htons(call
->service_id
);
342 if (test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE
, &conn
->flags
) &&
344 whdr
.userStatus
= RXRPC_USERSTATUS_SERVICE_UPGRADE
;
346 iov
[0].iov_base
= &whdr
;
347 iov
[0].iov_len
= sizeof(whdr
);
348 iov
[1].iov_base
= skb
->head
;
349 iov
[1].iov_len
= skb
->len
;
350 len
= iov
[0].iov_len
+ iov
[1].iov_len
;
352 msg
.msg_name
= &call
->peer
->srx
.transport
;
353 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
354 msg
.msg_control
= NULL
;
355 msg
.msg_controllen
= 0;
358 /* If our RTT cache needs working on, request an ACK. Also request
359 * ACKs if a DATA packet appears to have been lost.
361 * However, we mustn't request an ACK on the last reply packet of a
362 * service call, lest OpenAFS incorrectly send us an ACK with some
363 * soft-ACKs in it and then never follow up with a proper hard ACK.
365 if ((!(sp
->hdr
.flags
& RXRPC_LAST_PACKET
) ||
368 (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST
, &call
->events
) ||
370 call
->cong_mode
== RXRPC_CALL_SLOW_START
||
371 (call
->peer
->rtt_usage
< 3 && sp
->hdr
.seq
& 1) ||
372 ktime_before(ktime_add_ms(call
->peer
->rtt_last_req
, 1000),
374 whdr
.flags
|= RXRPC_REQUEST_ACK
;
376 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS
)) {
378 if ((lose
++ & 7) == 7) {
384 trace_rxrpc_tx_data(call
, sp
->hdr
.seq
, serial
, whdr
.flags
,
389 /* send the packet with the don't fragment bit set if we currently
390 * think it's small enough */
391 if (iov
[1].iov_len
>= call
->peer
->maxdata
)
392 goto send_fragmentable
;
394 down_read(&conn
->params
.local
->defrag_sem
);
396 sp
->hdr
.serial
= serial
;
397 smp_wmb(); /* Set serial before timestamp */
398 skb
->tstamp
= ktime_get_real();
400 /* send the packet by UDP
401 * - returns -EMSGSIZE if UDP would have to fragment the packet
402 * to go out of the interface
403 * - in which case, we'll have processed the ICMP error
404 * message and update the peer record
406 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 2, len
);
407 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
409 up_read(&conn
->params
.local
->defrag_sem
);
411 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
412 rxrpc_tx_point_call_data_nofrag
);
414 trace_rxrpc_tx_packet(call
->debug_id
, &whdr
,
415 rxrpc_tx_point_call_data_nofrag
);
416 if (ret
== -EMSGSIZE
)
417 goto send_fragmentable
;
421 if (whdr
.flags
& RXRPC_REQUEST_ACK
) {
422 call
->peer
->rtt_last_req
= skb
->tstamp
;
423 trace_rxrpc_rtt_tx(call
, rxrpc_rtt_tx_data
, serial
);
424 if (call
->peer
->rtt_usage
> 1) {
425 unsigned long nowj
= jiffies
, ack_lost_at
;
427 ack_lost_at
= nsecs_to_jiffies(2 * call
->peer
->rtt
);
432 WRITE_ONCE(call
->ack_lost_at
, ack_lost_at
);
433 rxrpc_reduce_call_timer(call
, ack_lost_at
, nowj
,
434 rxrpc_timer_set_for_lost_ack
);
438 if (sp
->hdr
.seq
== 1 &&
439 !test_and_set_bit(RXRPC_CALL_BEGAN_RX_TIMER
,
441 unsigned long nowj
= jiffies
, expect_rx_by
;
443 expect_rx_by
= nowj
+ call
->next_rx_timo
;
444 WRITE_ONCE(call
->expect_rx_by
, expect_rx_by
);
445 rxrpc_reduce_call_timer(call
, expect_rx_by
, nowj
,
446 rxrpc_timer_set_for_normal
);
450 rxrpc_set_keepalive(call
);
452 _leave(" = %d [%u]", ret
, call
->peer
->maxdata
);
456 /* attempt to send this message with fragmentation enabled */
457 _debug("send fragment");
459 down_write(&conn
->params
.local
->defrag_sem
);
461 sp
->hdr
.serial
= serial
;
462 smp_wmb(); /* Set serial before timestamp */
463 skb
->tstamp
= ktime_get_real();
465 switch (conn
->params
.local
->srx
.transport
.family
) {
467 opt
= IP_PMTUDISC_DONT
;
468 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
469 SOL_IP
, IP_MTU_DISCOVER
,
470 (char *)&opt
, sizeof(opt
));
472 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
,
474 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
476 opt
= IP_PMTUDISC_DO
;
477 kernel_setsockopt(conn
->params
.local
->socket
, SOL_IP
,
479 (char *)&opt
, sizeof(opt
));
483 #ifdef CONFIG_AF_RXRPC_IPV6
485 opt
= IPV6_PMTUDISC_DONT
;
486 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
487 SOL_IPV6
, IPV6_MTU_DISCOVER
,
488 (char *)&opt
, sizeof(opt
));
490 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
,
492 conn
->params
.peer
->last_tx_at
= ktime_get_seconds();
494 opt
= IPV6_PMTUDISC_DO
;
495 kernel_setsockopt(conn
->params
.local
->socket
,
496 SOL_IPV6
, IPV6_MTU_DISCOVER
,
497 (char *)&opt
, sizeof(opt
));
504 trace_rxrpc_tx_fail(call
->debug_id
, serial
, ret
,
505 rxrpc_tx_point_call_data_frag
);
507 trace_rxrpc_tx_packet(call
->debug_id
, &whdr
,
508 rxrpc_tx_point_call_data_frag
);
510 up_write(&conn
->params
.local
->defrag_sem
);
515 * reject packets through the local endpoint
517 void rxrpc_reject_packets(struct rxrpc_local
*local
)
519 struct sockaddr_rxrpc srx
;
520 struct rxrpc_skb_priv
*sp
;
521 struct rxrpc_wire_header whdr
;
529 _enter("%d", local
->debug_id
);
531 iov
[0].iov_base
= &whdr
;
532 iov
[0].iov_len
= sizeof(whdr
);
533 iov
[1].iov_base
= &code
;
534 iov
[1].iov_len
= sizeof(code
);
536 msg
.msg_name
= &srx
.transport
;
537 msg
.msg_control
= NULL
;
538 msg
.msg_controllen
= 0;
541 memset(&whdr
, 0, sizeof(whdr
));
543 while ((skb
= skb_dequeue(&local
->reject_queue
))) {
544 rxrpc_see_skb(skb
, rxrpc_skb_rx_seen
);
548 case RXRPC_SKB_MARK_REJECT_BUSY
:
549 whdr
.type
= RXRPC_PACKET_TYPE_BUSY
;
553 case RXRPC_SKB_MARK_REJECT_ABORT
:
554 whdr
.type
= RXRPC_PACKET_TYPE_ABORT
;
555 code
= htonl(skb
->priority
);
556 size
= sizeof(whdr
) + sizeof(code
);
560 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
564 if (rxrpc_extract_addr_from_skb(&srx
, skb
) == 0) {
565 msg
.msg_namelen
= srx
.transport_len
;
567 whdr
.epoch
= htonl(sp
->hdr
.epoch
);
568 whdr
.cid
= htonl(sp
->hdr
.cid
);
569 whdr
.callNumber
= htonl(sp
->hdr
.callNumber
);
570 whdr
.serviceId
= htons(sp
->hdr
.serviceId
);
571 whdr
.flags
= sp
->hdr
.flags
;
572 whdr
.flags
^= RXRPC_CLIENT_INITIATED
;
573 whdr
.flags
&= RXRPC_CLIENT_INITIATED
;
575 ret
= kernel_sendmsg(local
->socket
, &msg
,
578 trace_rxrpc_tx_fail(local
->debug_id
, 0, ret
,
579 rxrpc_tx_point_reject
);
581 trace_rxrpc_tx_packet(local
->debug_id
, &whdr
,
582 rxrpc_tx_point_reject
);
585 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
592 * Send a VERSION reply to a peer as a keepalive.
594 void rxrpc_send_keepalive(struct rxrpc_peer
*peer
)
596 struct rxrpc_wire_header whdr
;
604 msg
.msg_name
= &peer
->srx
.transport
;
605 msg
.msg_namelen
= peer
->srx
.transport_len
;
606 msg
.msg_control
= NULL
;
607 msg
.msg_controllen
= 0;
610 whdr
.epoch
= htonl(peer
->local
->rxnet
->epoch
);
615 whdr
.type
= RXRPC_PACKET_TYPE_VERSION
; /* Not client-initiated */
616 whdr
.flags
= RXRPC_LAST_PACKET
;
618 whdr
.securityIndex
= 0;
622 iov
[0].iov_base
= &whdr
;
623 iov
[0].iov_len
= sizeof(whdr
);
624 iov
[1].iov_base
= (char *)rxrpc_keepalive_string
;
625 iov
[1].iov_len
= sizeof(rxrpc_keepalive_string
);
627 len
= iov
[0].iov_len
+ iov
[1].iov_len
;
629 _proto("Tx VERSION (keepalive)");
631 ret
= kernel_sendmsg(peer
->local
->socket
, &msg
, iov
, 2, len
);
633 trace_rxrpc_tx_fail(peer
->debug_id
, 0, ret
,
634 rxrpc_tx_point_version_keepalive
);
636 trace_rxrpc_tx_packet(peer
->debug_id
, &whdr
,
637 rxrpc_tx_point_version_keepalive
);
639 peer
->last_tx_at
= ktime_get_seconds();