1 /* RxRPC packet reception
3 * Copyright (C) 2007, 2016 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/module.h>
15 #include <linux/net.h>
16 #include <linux/skbuff.h>
17 #include <linux/errqueue.h>
18 #include <linux/udp.h>
20 #include <linux/in6.h>
21 #include <linux/icmp.h>
22 #include <linux/gfp.h>
24 #include <net/af_rxrpc.h>
27 #include <net/net_namespace.h>
28 #include "ar-internal.h"
30 static void rxrpc_proto_abort(const char *why
,
31 struct rxrpc_call
*call
, rxrpc_seq_t seq
)
33 if (rxrpc_abort_call(why
, call
, seq
, RX_PROTOCOL_ERROR
, -EBADMSG
)) {
34 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
35 rxrpc_queue_call(call
);
40 * Do TCP-style congestion management [RFC 5681].
42 static void rxrpc_congestion_management(struct rxrpc_call
*call
,
44 struct rxrpc_ack_summary
*summary
,
45 rxrpc_serial_t acked_serial
)
47 enum rxrpc_congest_change change
= rxrpc_cong_no_change
;
48 unsigned int cumulative_acks
= call
->cong_cumul_acks
;
49 unsigned int cwnd
= call
->cong_cwnd
;
52 summary
->flight_size
=
53 (call
->tx_top
- call
->tx_hard_ack
) - summary
->nr_acks
;
55 if (test_and_clear_bit(RXRPC_CALL_RETRANS_TIMEOUT
, &call
->flags
)) {
56 summary
->retrans_timeo
= true;
57 call
->cong_ssthresh
= max_t(unsigned int,
58 summary
->flight_size
/ 2, 2);
60 if (cwnd
>= call
->cong_ssthresh
&&
61 call
->cong_mode
== RXRPC_CALL_SLOW_START
) {
62 call
->cong_mode
= RXRPC_CALL_CONGEST_AVOIDANCE
;
63 call
->cong_tstamp
= skb
->tstamp
;
68 cumulative_acks
+= summary
->nr_new_acks
;
69 cumulative_acks
+= summary
->nr_rot_new_acks
;
70 if (cumulative_acks
> 255)
71 cumulative_acks
= 255;
73 summary
->mode
= call
->cong_mode
;
74 summary
->cwnd
= call
->cong_cwnd
;
75 summary
->ssthresh
= call
->cong_ssthresh
;
76 summary
->cumulative_acks
= cumulative_acks
;
77 summary
->dup_acks
= call
->cong_dup_acks
;
79 switch (call
->cong_mode
) {
80 case RXRPC_CALL_SLOW_START
:
81 if (summary
->nr_nacks
> 0)
82 goto packet_loss_detected
;
83 if (summary
->cumulative_acks
> 0)
85 if (cwnd
>= call
->cong_ssthresh
) {
86 call
->cong_mode
= RXRPC_CALL_CONGEST_AVOIDANCE
;
87 call
->cong_tstamp
= skb
->tstamp
;
91 case RXRPC_CALL_CONGEST_AVOIDANCE
:
92 if (summary
->nr_nacks
> 0)
93 goto packet_loss_detected
;
95 /* We analyse the number of packets that get ACK'd per RTT
96 * period and increase the window if we managed to fill it.
98 if (call
->peer
->rtt_usage
== 0)
100 if (ktime_before(skb
->tstamp
,
101 ktime_add_ns(call
->cong_tstamp
,
103 goto out_no_clear_ca
;
104 change
= rxrpc_cong_rtt_window_end
;
105 call
->cong_tstamp
= skb
->tstamp
;
106 if (cumulative_acks
>= cwnd
)
110 case RXRPC_CALL_PACKET_LOSS
:
111 if (summary
->nr_nacks
== 0)
112 goto resume_normality
;
114 if (summary
->new_low_nack
) {
115 change
= rxrpc_cong_new_low_nack
;
116 call
->cong_dup_acks
= 1;
117 if (call
->cong_extra
> 1)
118 call
->cong_extra
= 1;
119 goto send_extra_data
;
122 call
->cong_dup_acks
++;
123 if (call
->cong_dup_acks
< 3)
124 goto send_extra_data
;
126 change
= rxrpc_cong_begin_retransmission
;
127 call
->cong_mode
= RXRPC_CALL_FAST_RETRANSMIT
;
128 call
->cong_ssthresh
= max_t(unsigned int,
129 summary
->flight_size
/ 2, 2);
130 cwnd
= call
->cong_ssthresh
+ 3;
131 call
->cong_extra
= 0;
132 call
->cong_dup_acks
= 0;
136 case RXRPC_CALL_FAST_RETRANSMIT
:
137 if (!summary
->new_low_nack
) {
138 if (summary
->nr_new_acks
== 0)
140 call
->cong_dup_acks
++;
141 if (call
->cong_dup_acks
== 2) {
142 change
= rxrpc_cong_retransmit_again
;
143 call
->cong_dup_acks
= 0;
147 change
= rxrpc_cong_progress
;
148 cwnd
= call
->cong_ssthresh
;
149 if (summary
->nr_nacks
== 0)
150 goto resume_normality
;
160 change
= rxrpc_cong_cleared_nacks
;
161 call
->cong_dup_acks
= 0;
162 call
->cong_extra
= 0;
163 call
->cong_tstamp
= skb
->tstamp
;
164 if (cwnd
< call
->cong_ssthresh
)
165 call
->cong_mode
= RXRPC_CALL_SLOW_START
;
167 call
->cong_mode
= RXRPC_CALL_CONGEST_AVOIDANCE
;
171 if (cwnd
>= RXRPC_RXTX_BUFF_SIZE
- 1)
172 cwnd
= RXRPC_RXTX_BUFF_SIZE
- 1;
173 call
->cong_cwnd
= cwnd
;
174 call
->cong_cumul_acks
= cumulative_acks
;
175 trace_rxrpc_congest(call
, summary
, acked_serial
, change
);
176 if (resend
&& !test_and_set_bit(RXRPC_CALL_EV_RESEND
, &call
->events
))
177 rxrpc_queue_call(call
);
180 packet_loss_detected
:
181 change
= rxrpc_cong_saw_nack
;
182 call
->cong_mode
= RXRPC_CALL_PACKET_LOSS
;
183 call
->cong_dup_acks
= 0;
184 goto send_extra_data
;
187 /* Send some previously unsent DATA if we have some to advance the ACK
190 if (call
->rxtx_annotations
[call
->tx_top
& RXRPC_RXTX_BUFF_MASK
] &
191 RXRPC_TX_ANNO_LAST
||
192 summary
->nr_acks
!= call
->tx_top
- call
->tx_hard_ack
) {
194 wake_up(&call
->waitq
);
196 goto out_no_clear_ca
;
200 * Ping the other end to fill our RTT cache and to retrieve the rwind
201 * and MTU parameters.
203 static void rxrpc_send_ping(struct rxrpc_call
*call
, struct sk_buff
*skb
,
206 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
207 ktime_t now
= skb
->tstamp
;
209 if (call
->peer
->rtt_usage
< 3 ||
210 ktime_before(ktime_add_ms(call
->peer
->rtt_last_req
, 1000), now
))
211 rxrpc_propose_ACK(call
, RXRPC_ACK_PING
, skew
, sp
->hdr
.serial
,
213 rxrpc_propose_ack_ping_for_params
);
217 * Apply a hard ACK by advancing the Tx window.
219 static void rxrpc_rotate_tx_window(struct rxrpc_call
*call
, rxrpc_seq_t to
,
220 struct rxrpc_ack_summary
*summary
)
222 struct sk_buff
*skb
, *list
= NULL
;
226 if (call
->acks_lowest_nak
== call
->tx_hard_ack
) {
227 call
->acks_lowest_nak
= to
;
228 } else if (before_eq(call
->acks_lowest_nak
, to
)) {
229 summary
->new_low_nack
= true;
230 call
->acks_lowest_nak
= to
;
233 spin_lock(&call
->lock
);
235 while (before(call
->tx_hard_ack
, to
)) {
237 ix
= call
->tx_hard_ack
& RXRPC_RXTX_BUFF_MASK
;
238 skb
= call
->rxtx_buffer
[ix
];
239 annotation
= call
->rxtx_annotations
[ix
];
240 rxrpc_see_skb(skb
, rxrpc_skb_tx_rotated
);
241 call
->rxtx_buffer
[ix
] = NULL
;
242 call
->rxtx_annotations
[ix
] = 0;
246 if (annotation
& RXRPC_TX_ANNO_LAST
)
247 set_bit(RXRPC_CALL_TX_LAST
, &call
->flags
);
248 if ((annotation
& RXRPC_TX_ANNO_MASK
) != RXRPC_TX_ANNO_ACK
)
249 summary
->nr_rot_new_acks
++;
252 spin_unlock(&call
->lock
);
254 trace_rxrpc_transmit(call
, (test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
) ?
255 rxrpc_transmit_rotate_last
:
256 rxrpc_transmit_rotate
));
257 wake_up(&call
->waitq
);
263 rxrpc_free_skb(skb
, rxrpc_skb_tx_freed
);
268 * End the transmission phase of a call.
270 * This occurs when we get an ACKALL packet, the first DATA packet of a reply,
271 * or a final ACK packet.
273 static bool rxrpc_end_tx_phase(struct rxrpc_call
*call
, bool reply_begun
,
274 const char *abort_why
)
277 ASSERT(test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
));
279 write_lock(&call
->state_lock
);
281 switch (call
->state
) {
282 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
283 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
285 call
->state
= RXRPC_CALL_CLIENT_RECV_REPLY
;
287 call
->state
= RXRPC_CALL_CLIENT_AWAIT_REPLY
;
290 case RXRPC_CALL_SERVER_AWAIT_ACK
:
291 __rxrpc_call_completed(call
);
292 rxrpc_notify_socket(call
);
299 write_unlock(&call
->state_lock
);
300 if (call
->state
== RXRPC_CALL_CLIENT_AWAIT_REPLY
) {
301 trace_rxrpc_transmit(call
, rxrpc_transmit_await_reply
);
303 trace_rxrpc_transmit(call
, rxrpc_transmit_end
);
309 write_unlock(&call
->state_lock
);
310 kdebug("end_tx %s", rxrpc_call_states
[call
->state
]);
311 rxrpc_proto_abort(abort_why
, call
, call
->tx_top
);
316 * Begin the reply reception phase of a call.
318 static bool rxrpc_receiving_reply(struct rxrpc_call
*call
)
320 struct rxrpc_ack_summary summary
= { 0 };
321 rxrpc_seq_t top
= READ_ONCE(call
->tx_top
);
323 if (call
->ackr_reason
) {
324 spin_lock_bh(&call
->lock
);
325 call
->ackr_reason
= 0;
326 call
->resend_at
= call
->expire_at
;
327 call
->ack_at
= call
->expire_at
;
328 spin_unlock_bh(&call
->lock
);
329 rxrpc_set_timer(call
, rxrpc_timer_init_for_reply
,
333 if (!test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
))
334 rxrpc_rotate_tx_window(call
, top
, &summary
);
335 if (!test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
)) {
336 rxrpc_proto_abort("TXL", call
, top
);
339 if (!rxrpc_end_tx_phase(call
, true, "ETD"))
341 call
->tx_phase
= false;
346 * Scan a jumbo packet to validate its structure and to work out how many
347 * subpackets it contains.
349 * A jumbo packet is a collection of consecutive packets glued together with
350 * little headers between that indicate how to change the initial header for
353 * RXRPC_JUMBO_PACKET must be set on all but the last subpacket - and all but
354 * the last are RXRPC_JUMBO_DATALEN in size. The last subpacket may be of any
357 static bool rxrpc_validate_jumbo(struct sk_buff
*skb
)
359 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
360 unsigned int offset
= sizeof(struct rxrpc_wire_header
);
361 unsigned int len
= skb
->len
;
363 u8 flags
= sp
->hdr
.flags
;
367 if (len
- offset
< RXRPC_JUMBO_SUBPKTLEN
)
369 if (flags
& RXRPC_LAST_PACKET
)
371 offset
+= RXRPC_JUMBO_DATALEN
;
372 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
374 offset
+= sizeof(struct rxrpc_jumbo_header
);
375 } while (flags
& RXRPC_JUMBO_PACKET
);
377 sp
->nr_jumbo
= nr_jumbo
;
385 * Handle reception of a duplicate packet.
387 * We have to take care to avoid an attack here whereby we're given a series of
388 * jumbograms, each with a sequence number one before the preceding one and
389 * filled up to maximum UDP size. If they never send us the first packet in
390 * the sequence, they can cause us to have to hold on to around 2MiB of kernel
391 * space until the call times out.
393 * We limit the space usage by only accepting three duplicate jumbo packets per
394 * call. After that, we tell the other side we're no longer accepting jumbos
395 * (that information is encoded in the ACK packet).
397 static void rxrpc_input_dup_data(struct rxrpc_call
*call
, rxrpc_seq_t seq
,
398 u8 annotation
, bool *_jumbo_bad
)
400 /* Discard normal packets that are duplicates. */
404 /* Skip jumbo subpackets that are duplicates. When we've had three or
405 * more partially duplicate jumbo packets, we refuse to take any more
406 * jumbos for this call.
409 call
->nr_jumbo_bad
++;
415 * Process a DATA packet, adding the packet to the Rx ring.
417 static void rxrpc_input_data(struct rxrpc_call
*call
, struct sk_buff
*skb
,
420 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
421 enum rxrpc_call_state state
;
422 unsigned int offset
= sizeof(struct rxrpc_wire_header
);
424 rxrpc_serial_t serial
= sp
->hdr
.serial
, ack_serial
= 0;
425 rxrpc_seq_t seq
= sp
->hdr
.seq
, hard_ack
;
426 bool immediate_ack
= false, jumbo_bad
= false, queued
;
428 u8 ack
= 0, flags
, annotation
= 0;
430 _enter("{%u,%u},{%u,%u}",
431 call
->rx_hard_ack
, call
->rx_top
, skb
->len
, seq
);
433 _proto("Rx DATA %%%u { #%u f=%02x }",
434 sp
->hdr
.serial
, seq
, sp
->hdr
.flags
);
436 state
= READ_ONCE(call
->state
);
437 if (state
>= RXRPC_CALL_COMPLETE
)
440 /* Received data implicitly ACKs all of the request packets we sent
441 * when we're acting as a client.
443 if ((state
== RXRPC_CALL_CLIENT_SEND_REQUEST
||
444 state
== RXRPC_CALL_CLIENT_AWAIT_REPLY
) &&
445 !rxrpc_receiving_reply(call
))
448 call
->ackr_prev_seq
= seq
;
450 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
451 if (after(seq
, hard_ack
+ call
->rx_winsize
)) {
452 ack
= RXRPC_ACK_EXCEEDS_WINDOW
;
457 flags
= sp
->hdr
.flags
;
458 if (flags
& RXRPC_JUMBO_PACKET
) {
459 if (call
->nr_jumbo_bad
> 3) {
460 ack
= RXRPC_ACK_NOSPACE
;
469 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
471 if (flags
& RXRPC_JUMBO_PACKET
)
472 len
= RXRPC_JUMBO_DATALEN
;
474 if (flags
& RXRPC_LAST_PACKET
) {
475 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
477 return rxrpc_proto_abort("LSN", call
, seq
);
479 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
480 after_eq(seq
, call
->rx_top
))
481 return rxrpc_proto_abort("LSA", call
, seq
);
484 trace_rxrpc_rx_data(call
, seq
, serial
, flags
, annotation
);
485 if (before_eq(seq
, hard_ack
)) {
486 ack
= RXRPC_ACK_DUPLICATE
;
491 if (flags
& RXRPC_REQUEST_ACK
&& !ack
) {
492 ack
= RXRPC_ACK_REQUESTED
;
496 if (call
->rxtx_buffer
[ix
]) {
497 rxrpc_input_dup_data(call
, seq
, annotation
, &jumbo_bad
);
498 if (ack
!= RXRPC_ACK_DUPLICATE
) {
499 ack
= RXRPC_ACK_DUPLICATE
;
502 immediate_ack
= true;
506 /* Queue the packet. We use a couple of memory barriers here as need
507 * to make sure that rx_top is perceived to be set after the buffer
508 * pointer and that the buffer pointer is set after the annotation and
511 * Barriers against rxrpc_recvmsg_data() and rxrpc_rotate_rx_window()
512 * and also rxrpc_fill_out_ack().
514 rxrpc_get_skb(skb
, rxrpc_skb_rx_got
);
515 call
->rxtx_annotations
[ix
] = annotation
;
517 call
->rxtx_buffer
[ix
] = skb
;
518 if (after(seq
, call
->rx_top
)) {
519 smp_store_release(&call
->rx_top
, seq
);
520 } else if (before(seq
, call
->rx_top
)) {
521 /* Send an immediate ACK if we fill in a hole */
523 ack
= RXRPC_ACK_DELAY
;
526 immediate_ack
= true;
528 if (flags
& RXRPC_LAST_PACKET
) {
529 set_bit(RXRPC_CALL_RX_LAST
, &call
->flags
);
530 trace_rxrpc_receive(call
, rxrpc_receive_queue_last
, serial
, seq
);
532 trace_rxrpc_receive(call
, rxrpc_receive_queue
, serial
, seq
);
536 if (after_eq(seq
, call
->rx_expect_next
)) {
537 if (after(seq
, call
->rx_expect_next
)) {
538 _net("OOS %u > %u", seq
, call
->rx_expect_next
);
539 ack
= RXRPC_ACK_OUT_OF_SEQUENCE
;
542 call
->rx_expect_next
= seq
+ 1;
547 if (flags
& RXRPC_JUMBO_PACKET
) {
548 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
549 return rxrpc_proto_abort("XJF", call
, seq
);
550 offset
+= sizeof(struct rxrpc_jumbo_header
);
554 if (flags
& RXRPC_JUMBO_PACKET
)
555 annotation
|= RXRPC_RX_ANNO_JLAST
;
556 if (after(seq
, hard_ack
+ call
->rx_winsize
)) {
557 ack
= RXRPC_ACK_EXCEEDS_WINDOW
;
560 call
->nr_jumbo_bad
++;
566 _proto("Rx DATA Jumbo %%%u", serial
);
570 if (queued
&& flags
& RXRPC_LAST_PACKET
&& !ack
) {
571 ack
= RXRPC_ACK_DELAY
;
577 rxrpc_propose_ACK(call
, ack
, skew
, ack_serial
,
579 rxrpc_propose_ack_input_data
);
581 if (sp
->hdr
.seq
== READ_ONCE(call
->rx_hard_ack
) + 1)
582 rxrpc_notify_socket(call
);
587 * Process a requested ACK.
589 static void rxrpc_input_requested_ack(struct rxrpc_call
*call
,
591 rxrpc_serial_t orig_serial
,
592 rxrpc_serial_t ack_serial
)
594 struct rxrpc_skb_priv
*sp
;
599 for (ix
= 0; ix
< RXRPC_RXTX_BUFF_SIZE
; ix
++) {
600 skb
= call
->rxtx_buffer
[ix
];
605 if (sp
->hdr
.serial
!= orig_serial
)
608 sent_at
= skb
->tstamp
;
614 rxrpc_peer_add_rtt(call
, rxrpc_rtt_rx_requested_ack
,
615 orig_serial
, ack_serial
, sent_at
, resp_time
);
619 * Process a ping response.
621 static void rxrpc_input_ping_response(struct rxrpc_call
*call
,
623 rxrpc_serial_t orig_serial
,
624 rxrpc_serial_t ack_serial
)
626 rxrpc_serial_t ping_serial
;
629 ping_time
= call
->ping_time
;
631 ping_serial
= call
->ping_serial
;
633 if (!test_bit(RXRPC_CALL_PINGING
, &call
->flags
) ||
634 before(orig_serial
, ping_serial
))
636 clear_bit(RXRPC_CALL_PINGING
, &call
->flags
);
637 if (after(orig_serial
, ping_serial
))
640 rxrpc_peer_add_rtt(call
, rxrpc_rtt_rx_ping_response
,
641 orig_serial
, ack_serial
, ping_time
, resp_time
);
645 * Process the extra information that may be appended to an ACK packet
647 static void rxrpc_input_ackinfo(struct rxrpc_call
*call
, struct sk_buff
*skb
,
648 struct rxrpc_ackinfo
*ackinfo
)
650 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
651 struct rxrpc_peer
*peer
;
654 u32 rwind
= ntohl(ackinfo
->rwind
);
656 _proto("Rx ACK %%%u Info { rx=%u max=%u rwin=%u jm=%u }",
658 ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
),
659 rwind
, ntohl(ackinfo
->jumbo_max
));
661 if (call
->tx_winsize
!= rwind
) {
662 if (rwind
> RXRPC_RXTX_BUFF_SIZE
- 1)
663 rwind
= RXRPC_RXTX_BUFF_SIZE
- 1;
664 if (rwind
> call
->tx_winsize
)
666 trace_rxrpc_rx_rwind_change(call
, sp
->hdr
.serial
,
667 ntohl(ackinfo
->rwind
), wake
);
668 call
->tx_winsize
= rwind
;
671 if (call
->cong_ssthresh
> rwind
)
672 call
->cong_ssthresh
= rwind
;
674 mtu
= min(ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
));
677 if (mtu
< peer
->maxdata
) {
678 spin_lock_bh(&peer
->lock
);
680 peer
->mtu
= mtu
+ peer
->hdrsize
;
681 spin_unlock_bh(&peer
->lock
);
682 _net("Net MTU %u (maxdata %u)", peer
->mtu
, peer
->maxdata
);
686 wake_up(&call
->waitq
);
690 * Process individual soft ACKs.
692 * Each ACK in the array corresponds to one packet and can be either an ACK or
693 * a NAK. If we get find an explicitly NAK'd packet we resend immediately;
694 * packets that lie beyond the end of the ACK list are scheduled for resend by
695 * the timer on the basis that the peer might just not have processed them at
696 * the time the ACK was sent.
698 static void rxrpc_input_soft_acks(struct rxrpc_call
*call
, u8
*acks
,
699 rxrpc_seq_t seq
, int nr_acks
,
700 struct rxrpc_ack_summary
*summary
)
703 u8 annotation
, anno_type
;
705 for (; nr_acks
> 0; nr_acks
--, seq
++) {
706 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
707 annotation
= call
->rxtx_annotations
[ix
];
708 anno_type
= annotation
& RXRPC_TX_ANNO_MASK
;
709 annotation
&= ~RXRPC_TX_ANNO_MASK
;
711 case RXRPC_ACK_TYPE_ACK
:
713 if (anno_type
== RXRPC_TX_ANNO_ACK
)
715 summary
->nr_new_acks
++;
716 call
->rxtx_annotations
[ix
] =
717 RXRPC_TX_ANNO_ACK
| annotation
;
719 case RXRPC_ACK_TYPE_NACK
:
720 if (!summary
->nr_nacks
&&
721 call
->acks_lowest_nak
!= seq
) {
722 call
->acks_lowest_nak
= seq
;
723 summary
->new_low_nack
= true;
726 if (anno_type
== RXRPC_TX_ANNO_NAK
)
728 summary
->nr_new_nacks
++;
729 if (anno_type
== RXRPC_TX_ANNO_RETRANS
)
731 call
->rxtx_annotations
[ix
] =
732 RXRPC_TX_ANNO_NAK
| annotation
;
735 return rxrpc_proto_abort("SFT", call
, 0);
741 * Process an ACK packet.
743 * ack.firstPacket is the sequence number of the first soft-ACK'd/NAK'd packet
744 * in the ACK array. Anything before that is hard-ACK'd and may be discarded.
746 * A hard-ACK means that a packet has been processed and may be discarded; a
747 * soft-ACK means that the packet may be discarded and retransmission
748 * requested. A phase is complete when all packets are hard-ACK'd.
750 static void rxrpc_input_ack(struct rxrpc_call
*call
, struct sk_buff
*skb
,
753 struct rxrpc_ack_summary summary
= { 0 };
754 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
756 struct rxrpc_ackpacket ack
;
757 struct rxrpc_ackinfo info
;
758 u8 acks
[RXRPC_MAXACKS
];
760 rxrpc_serial_t acked_serial
;
761 rxrpc_seq_t first_soft_ack
, hard_ack
;
762 int nr_acks
, offset
, ioffset
;
766 offset
= sizeof(struct rxrpc_wire_header
);
767 if (skb_copy_bits(skb
, offset
, &buf
.ack
, sizeof(buf
.ack
)) < 0) {
768 _debug("extraction failure");
769 return rxrpc_proto_abort("XAK", call
, 0);
771 offset
+= sizeof(buf
.ack
);
773 acked_serial
= ntohl(buf
.ack
.serial
);
774 first_soft_ack
= ntohl(buf
.ack
.firstPacket
);
775 hard_ack
= first_soft_ack
- 1;
776 nr_acks
= buf
.ack
.nAcks
;
777 summary
.ack_reason
= (buf
.ack
.reason
< RXRPC_ACK__INVALID
?
778 buf
.ack
.reason
: RXRPC_ACK__INVALID
);
780 trace_rxrpc_rx_ack(call
, sp
->hdr
.serial
, acked_serial
,
781 first_soft_ack
, ntohl(buf
.ack
.previousPacket
),
782 summary
.ack_reason
, nr_acks
);
784 if (buf
.ack
.reason
== RXRPC_ACK_PING_RESPONSE
)
785 rxrpc_input_ping_response(call
, skb
->tstamp
, acked_serial
,
787 if (buf
.ack
.reason
== RXRPC_ACK_REQUESTED
)
788 rxrpc_input_requested_ack(call
, skb
->tstamp
, acked_serial
,
791 if (buf
.ack
.reason
== RXRPC_ACK_PING
) {
792 _proto("Rx ACK %%%u PING Request", sp
->hdr
.serial
);
793 rxrpc_propose_ACK(call
, RXRPC_ACK_PING_RESPONSE
,
794 skew
, sp
->hdr
.serial
, true, true,
795 rxrpc_propose_ack_respond_to_ping
);
796 } else if (sp
->hdr
.flags
& RXRPC_REQUEST_ACK
) {
797 rxrpc_propose_ACK(call
, RXRPC_ACK_REQUESTED
,
798 skew
, sp
->hdr
.serial
, true, true,
799 rxrpc_propose_ack_respond_to_ack
);
802 ioffset
= offset
+ nr_acks
+ 3;
803 if (skb
->len
>= ioffset
+ sizeof(buf
.info
)) {
804 if (skb_copy_bits(skb
, ioffset
, &buf
.info
, sizeof(buf
.info
)) < 0)
805 return rxrpc_proto_abort("XAI", call
, 0);
806 rxrpc_input_ackinfo(call
, skb
, &buf
.info
);
809 if (first_soft_ack
== 0)
810 return rxrpc_proto_abort("AK0", call
, 0);
812 /* Ignore ACKs unless we are or have just been transmitting. */
813 switch (READ_ONCE(call
->state
)) {
814 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
815 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
816 case RXRPC_CALL_SERVER_SEND_REPLY
:
817 case RXRPC_CALL_SERVER_AWAIT_ACK
:
823 /* Discard any out-of-order or duplicate ACKs. */
824 if (before_eq(sp
->hdr
.serial
, call
->acks_latest
)) {
825 _debug("discard ACK %d <= %d",
826 sp
->hdr
.serial
, call
->acks_latest
);
829 call
->acks_latest_ts
= skb
->tstamp
;
830 call
->acks_latest
= sp
->hdr
.serial
;
832 if (before(hard_ack
, call
->tx_hard_ack
) ||
833 after(hard_ack
, call
->tx_top
))
834 return rxrpc_proto_abort("AKW", call
, 0);
835 if (nr_acks
> call
->tx_top
- hard_ack
)
836 return rxrpc_proto_abort("AKN", call
, 0);
838 if (after(hard_ack
, call
->tx_hard_ack
))
839 rxrpc_rotate_tx_window(call
, hard_ack
, &summary
);
842 if (skb_copy_bits(skb
, offset
, buf
.acks
, nr_acks
) < 0)
843 return rxrpc_proto_abort("XSA", call
, 0);
844 rxrpc_input_soft_acks(call
, buf
.acks
, first_soft_ack
, nr_acks
,
848 if (test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
)) {
849 rxrpc_end_tx_phase(call
, false, "ETA");
853 if (call
->rxtx_annotations
[call
->tx_top
& RXRPC_RXTX_BUFF_MASK
] &
854 RXRPC_TX_ANNO_LAST
&&
855 summary
.nr_acks
== call
->tx_top
- hard_ack
&&
856 rxrpc_is_client_call(call
))
857 rxrpc_propose_ACK(call
, RXRPC_ACK_PING
, skew
, sp
->hdr
.serial
,
859 rxrpc_propose_ack_ping_for_lost_reply
);
861 return rxrpc_congestion_management(call
, skb
, &summary
, acked_serial
);
865 * Process an ACKALL packet.
867 static void rxrpc_input_ackall(struct rxrpc_call
*call
, struct sk_buff
*skb
)
869 struct rxrpc_ack_summary summary
= { 0 };
870 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
872 _proto("Rx ACKALL %%%u", sp
->hdr
.serial
);
874 rxrpc_rotate_tx_window(call
, call
->tx_top
, &summary
);
875 if (test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
))
876 rxrpc_end_tx_phase(call
, false, "ETL");
880 * Process an ABORT packet directed at a call.
882 static void rxrpc_input_abort(struct rxrpc_call
*call
, struct sk_buff
*skb
)
884 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
886 u32 abort_code
= RX_CALL_DEAD
;
891 skb_copy_bits(skb
, sizeof(struct rxrpc_wire_header
),
892 &wtmp
, sizeof(wtmp
)) >= 0)
893 abort_code
= ntohl(wtmp
);
895 trace_rxrpc_rx_abort(call
, sp
->hdr
.serial
, abort_code
);
897 _proto("Rx ABORT %%%u { %x }", sp
->hdr
.serial
, abort_code
);
899 if (rxrpc_set_call_completion(call
, RXRPC_CALL_REMOTELY_ABORTED
,
900 abort_code
, -ECONNABORTED
))
901 rxrpc_notify_socket(call
);
905 * Process an incoming call packet.
907 static void rxrpc_input_call_packet(struct rxrpc_call
*call
,
908 struct sk_buff
*skb
, u16 skew
)
910 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
912 _enter("%p,%p", call
, skb
);
914 switch (sp
->hdr
.type
) {
915 case RXRPC_PACKET_TYPE_DATA
:
916 rxrpc_input_data(call
, skb
, skew
);
919 case RXRPC_PACKET_TYPE_ACK
:
920 rxrpc_input_ack(call
, skb
, skew
);
923 case RXRPC_PACKET_TYPE_BUSY
:
924 _proto("Rx BUSY %%%u", sp
->hdr
.serial
);
926 /* Just ignore BUSY packets from the server; the retry and
927 * lifespan timers will take care of business. BUSY packets
928 * from the client don't make sense.
932 case RXRPC_PACKET_TYPE_ABORT
:
933 rxrpc_input_abort(call
, skb
);
936 case RXRPC_PACKET_TYPE_ACKALL
:
937 rxrpc_input_ackall(call
, skb
);
948 * Handle a new call on a channel implicitly completing the preceding call on
951 * TODO: If callNumber > call_id + 1, renegotiate security.
953 static void rxrpc_input_implicit_end_call(struct rxrpc_connection
*conn
,
954 struct rxrpc_call
*call
)
956 switch (READ_ONCE(call
->state
)) {
957 case RXRPC_CALL_SERVER_AWAIT_ACK
:
958 rxrpc_call_completed(call
);
960 case RXRPC_CALL_COMPLETE
:
963 if (rxrpc_abort_call("IMP", call
, 0, RX_CALL_DEAD
, -ESHUTDOWN
)) {
964 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
965 rxrpc_queue_call(call
);
970 trace_rxrpc_improper_term(call
);
971 __rxrpc_disconnect_call(conn
, call
);
972 rxrpc_notify_socket(call
);
976 * post connection-level events to the connection
977 * - this includes challenges, responses, some aborts and call terminal packet
980 static void rxrpc_post_packet_to_conn(struct rxrpc_connection
*conn
,
983 _enter("%p,%p", conn
, skb
);
985 skb_queue_tail(&conn
->rx_queue
, skb
);
986 rxrpc_queue_conn(conn
);
990 * post endpoint-level events to the local endpoint
991 * - this includes debug and version messages
993 static void rxrpc_post_packet_to_local(struct rxrpc_local
*local
,
996 _enter("%p,%p", local
, skb
);
998 skb_queue_tail(&local
->event_queue
, skb
);
999 rxrpc_queue_local(local
);
1003 * put a packet up for transport-level abort
1005 static void rxrpc_reject_packet(struct rxrpc_local
*local
, struct sk_buff
*skb
)
1007 CHECK_SLAB_OKAY(&local
->usage
);
1009 skb_queue_tail(&local
->reject_queue
, skb
);
1010 rxrpc_queue_local(local
);
1014 * Extract the wire header from a packet and translate the byte order.
1017 int rxrpc_extract_header(struct rxrpc_skb_priv
*sp
, struct sk_buff
*skb
)
1019 struct rxrpc_wire_header whdr
;
1021 /* dig out the RxRPC connection details */
1022 if (skb_copy_bits(skb
, 0, &whdr
, sizeof(whdr
)) < 0) {
1023 trace_rxrpc_rx_eproto(NULL
, sp
->hdr
.serial
,
1024 tracepoint_string("bad_hdr"));
1028 memset(sp
, 0, sizeof(*sp
));
1029 sp
->hdr
.epoch
= ntohl(whdr
.epoch
);
1030 sp
->hdr
.cid
= ntohl(whdr
.cid
);
1031 sp
->hdr
.callNumber
= ntohl(whdr
.callNumber
);
1032 sp
->hdr
.seq
= ntohl(whdr
.seq
);
1033 sp
->hdr
.serial
= ntohl(whdr
.serial
);
1034 sp
->hdr
.flags
= whdr
.flags
;
1035 sp
->hdr
.type
= whdr
.type
;
1036 sp
->hdr
.userStatus
= whdr
.userStatus
;
1037 sp
->hdr
.securityIndex
= whdr
.securityIndex
;
1038 sp
->hdr
._rsvd
= ntohs(whdr
._rsvd
);
1039 sp
->hdr
.serviceId
= ntohs(whdr
.serviceId
);
1044 * handle data received on the local endpoint
1045 * - may be called in interrupt context
1047 * The socket is locked by the caller and this prevents the socket from being
1048 * shut down and the local endpoint from going away, thus sk_user_data will not
1049 * be cleared until this function returns.
1051 void rxrpc_data_ready(struct sock
*udp_sk
)
1053 struct rxrpc_connection
*conn
;
1054 struct rxrpc_channel
*chan
;
1055 struct rxrpc_call
*call
;
1056 struct rxrpc_skb_priv
*sp
;
1057 struct rxrpc_local
*local
= udp_sk
->sk_user_data
;
1058 struct sk_buff
*skb
;
1059 unsigned int channel
;
1062 _enter("%p", udp_sk
);
1064 ASSERT(!irqs_disabled());
1066 skb
= skb_recv_udp(udp_sk
, 0, 1, &ret
);
1070 _debug("UDP socket error %d", ret
);
1074 rxrpc_new_skb(skb
, rxrpc_skb_rx_received
);
1076 _net("recv skb %p", skb
);
1078 /* we'll probably need to checksum it (didn't call sock_recvmsg) */
1079 if (skb_checksum_complete(skb
)) {
1080 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
1081 __UDP_INC_STATS(&init_net
, UDP_MIB_INERRORS
, 0);
1082 _leave(" [CSUM failed]");
1086 __UDP_INC_STATS(&init_net
, UDP_MIB_INDATAGRAMS
, 0);
1088 /* The UDP protocol already released all skb resources;
1089 * we are free to add our own data there.
1091 sp
= rxrpc_skb(skb
);
1093 /* dig out the RxRPC connection details */
1094 if (rxrpc_extract_header(sp
, skb
) < 0)
1097 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS
)) {
1099 if ((lose
++ & 7) == 7) {
1100 trace_rxrpc_rx_lose(sp
);
1101 rxrpc_lose_skb(skb
, rxrpc_skb_rx_lost
);
1106 trace_rxrpc_rx_packet(sp
);
1108 _net("Rx RxRPC %s ep=%x call=%x:%x",
1109 sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
? "ToServer" : "ToClient",
1110 sp
->hdr
.epoch
, sp
->hdr
.cid
, sp
->hdr
.callNumber
);
1112 if (sp
->hdr
.type
>= RXRPC_N_PACKET_TYPES
||
1113 !((RXRPC_SUPPORTED_PACKET_TYPES
>> sp
->hdr
.type
) & 1)) {
1114 _proto("Rx Bad Packet Type %u", sp
->hdr
.type
);
1118 switch (sp
->hdr
.type
) {
1119 case RXRPC_PACKET_TYPE_VERSION
:
1120 rxrpc_post_packet_to_local(local
, skb
);
1123 case RXRPC_PACKET_TYPE_BUSY
:
1124 if (sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
)
1128 case RXRPC_PACKET_TYPE_DATA
:
1129 if (sp
->hdr
.callNumber
== 0)
1131 if (sp
->hdr
.flags
& RXRPC_JUMBO_PACKET
&&
1132 !rxrpc_validate_jumbo(skb
))
1139 conn
= rxrpc_find_connection_rcu(local
, skb
);
1141 if (sp
->hdr
.securityIndex
!= conn
->security_ix
)
1142 goto wrong_security
;
1144 if (sp
->hdr
.serviceId
!= conn
->service_id
) {
1145 if (!test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE
, &conn
->flags
) ||
1146 conn
->service_id
!= conn
->params
.service_id
)
1148 conn
->service_id
= sp
->hdr
.serviceId
;
1151 if (sp
->hdr
.callNumber
== 0) {
1152 /* Connection-level packet */
1153 _debug("CONN %p {%d}", conn
, conn
->debug_id
);
1154 rxrpc_post_packet_to_conn(conn
, skb
);
1158 /* Note the serial number skew here */
1159 skew
= (int)sp
->hdr
.serial
- (int)conn
->hi_serial
;
1162 conn
->hi_serial
= sp
->hdr
.serial
;
1165 skew
= min(skew
, 65535);
1168 /* Call-bound packets are routed by connection channel. */
1169 channel
= sp
->hdr
.cid
& RXRPC_CHANNELMASK
;
1170 chan
= &conn
->channels
[channel
];
1172 /* Ignore really old calls */
1173 if (sp
->hdr
.callNumber
< chan
->last_call
)
1174 goto discard_unlock
;
1176 if (sp
->hdr
.callNumber
== chan
->last_call
) {
1177 /* For the previous service call, if completed successfully, we
1178 * discard all further packets.
1180 if (rxrpc_conn_is_service(conn
) &&
1181 (chan
->last_type
== RXRPC_PACKET_TYPE_ACK
||
1182 sp
->hdr
.type
== RXRPC_PACKET_TYPE_ABORT
))
1183 goto discard_unlock
;
1185 /* But otherwise we need to retransmit the final packet from
1186 * data cached in the connection record.
1188 rxrpc_post_packet_to_conn(conn
, skb
);
1192 call
= rcu_dereference(chan
->call
);
1194 if (sp
->hdr
.callNumber
> chan
->call_id
) {
1195 if (!(sp
->hdr
.flags
& RXRPC_CLIENT_INITIATED
)) {
1200 rxrpc_input_implicit_end_call(conn
, call
);
1204 if (call
&& sp
->hdr
.serviceId
!= call
->service_id
)
1205 call
->service_id
= sp
->hdr
.serviceId
;
1211 if (!call
|| atomic_read(&call
->usage
) == 0) {
1212 if (!(sp
->hdr
.type
& RXRPC_CLIENT_INITIATED
) ||
1213 sp
->hdr
.callNumber
== 0 ||
1214 sp
->hdr
.type
!= RXRPC_PACKET_TYPE_DATA
)
1215 goto bad_message_unlock
;
1216 if (sp
->hdr
.seq
!= 1)
1217 goto discard_unlock
;
1218 call
= rxrpc_new_incoming_call(local
, conn
, skb
);
1223 rxrpc_send_ping(call
, skb
, skew
);
1224 mutex_unlock(&call
->user_mutex
);
1227 rxrpc_input_call_packet(call
, skb
, skew
);
1228 goto discard_unlock
;
1233 rxrpc_free_skb(skb
, rxrpc_skb_rx_freed
);
1235 trace_rxrpc_rx_done(0, 0);
1244 trace_rxrpc_abort("SEC", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1245 RXKADINCONSISTENCY
, EBADMSG
);
1246 skb
->priority
= RXKADINCONSISTENCY
;
1251 trace_rxrpc_abort("UPG", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1252 RX_PROTOCOL_ERROR
, EBADMSG
);
1253 goto protocol_error
;
1258 trace_rxrpc_abort("BAD", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1259 RX_PROTOCOL_ERROR
, EBADMSG
);
1261 skb
->priority
= RX_PROTOCOL_ERROR
;
1263 skb
->mark
= RXRPC_SKB_MARK_LOCAL_ABORT
;
1265 trace_rxrpc_rx_done(skb
->mark
, skb
->priority
);
1266 rxrpc_reject_packet(local
, skb
);
1267 _leave(" [badmsg]");