1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* RxRPC packet reception
4 * Copyright (C) 2007, 2016 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/module.h>
11 #include <linux/net.h>
12 #include <linux/skbuff.h>
13 #include <linux/errqueue.h>
14 #include <linux/udp.h>
16 #include <linux/in6.h>
17 #include <linux/icmp.h>
18 #include <linux/gfp.h>
20 #include <net/af_rxrpc.h>
23 #include <net/net_namespace.h>
24 #include "ar-internal.h"
26 static void rxrpc_proto_abort(const char *why
,
27 struct rxrpc_call
*call
, rxrpc_seq_t seq
)
29 if (rxrpc_abort_call(why
, call
, seq
, RX_PROTOCOL_ERROR
, -EBADMSG
)) {
30 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
31 rxrpc_queue_call(call
);
36 * Do TCP-style congestion management [RFC 5681].
38 static void rxrpc_congestion_management(struct rxrpc_call
*call
,
40 struct rxrpc_ack_summary
*summary
,
41 rxrpc_serial_t acked_serial
)
43 enum rxrpc_congest_change change
= rxrpc_cong_no_change
;
44 unsigned int cumulative_acks
= call
->cong_cumul_acks
;
45 unsigned int cwnd
= call
->cong_cwnd
;
48 summary
->flight_size
=
49 (call
->tx_top
- call
->tx_hard_ack
) - summary
->nr_acks
;
51 if (test_and_clear_bit(RXRPC_CALL_RETRANS_TIMEOUT
, &call
->flags
)) {
52 summary
->retrans_timeo
= true;
53 call
->cong_ssthresh
= max_t(unsigned int,
54 summary
->flight_size
/ 2, 2);
56 if (cwnd
>= call
->cong_ssthresh
&&
57 call
->cong_mode
== RXRPC_CALL_SLOW_START
) {
58 call
->cong_mode
= RXRPC_CALL_CONGEST_AVOIDANCE
;
59 call
->cong_tstamp
= skb
->tstamp
;
64 cumulative_acks
+= summary
->nr_new_acks
;
65 cumulative_acks
+= summary
->nr_rot_new_acks
;
66 if (cumulative_acks
> 255)
67 cumulative_acks
= 255;
69 summary
->mode
= call
->cong_mode
;
70 summary
->cwnd
= call
->cong_cwnd
;
71 summary
->ssthresh
= call
->cong_ssthresh
;
72 summary
->cumulative_acks
= cumulative_acks
;
73 summary
->dup_acks
= call
->cong_dup_acks
;
75 switch (call
->cong_mode
) {
76 case RXRPC_CALL_SLOW_START
:
77 if (summary
->nr_nacks
> 0)
78 goto packet_loss_detected
;
79 if (summary
->cumulative_acks
> 0)
81 if (cwnd
>= call
->cong_ssthresh
) {
82 call
->cong_mode
= RXRPC_CALL_CONGEST_AVOIDANCE
;
83 call
->cong_tstamp
= skb
->tstamp
;
87 case RXRPC_CALL_CONGEST_AVOIDANCE
:
88 if (summary
->nr_nacks
> 0)
89 goto packet_loss_detected
;
91 /* We analyse the number of packets that get ACK'd per RTT
92 * period and increase the window if we managed to fill it.
94 if (call
->peer
->rtt_count
== 0)
96 if (ktime_before(skb
->tstamp
,
97 ktime_add_us(call
->cong_tstamp
,
98 call
->peer
->srtt_us
>> 3)))
100 change
= rxrpc_cong_rtt_window_end
;
101 call
->cong_tstamp
= skb
->tstamp
;
102 if (cumulative_acks
>= cwnd
)
106 case RXRPC_CALL_PACKET_LOSS
:
107 if (summary
->nr_nacks
== 0)
108 goto resume_normality
;
110 if (summary
->new_low_nack
) {
111 change
= rxrpc_cong_new_low_nack
;
112 call
->cong_dup_acks
= 1;
113 if (call
->cong_extra
> 1)
114 call
->cong_extra
= 1;
115 goto send_extra_data
;
118 call
->cong_dup_acks
++;
119 if (call
->cong_dup_acks
< 3)
120 goto send_extra_data
;
122 change
= rxrpc_cong_begin_retransmission
;
123 call
->cong_mode
= RXRPC_CALL_FAST_RETRANSMIT
;
124 call
->cong_ssthresh
= max_t(unsigned int,
125 summary
->flight_size
/ 2, 2);
126 cwnd
= call
->cong_ssthresh
+ 3;
127 call
->cong_extra
= 0;
128 call
->cong_dup_acks
= 0;
132 case RXRPC_CALL_FAST_RETRANSMIT
:
133 if (!summary
->new_low_nack
) {
134 if (summary
->nr_new_acks
== 0)
136 call
->cong_dup_acks
++;
137 if (call
->cong_dup_acks
== 2) {
138 change
= rxrpc_cong_retransmit_again
;
139 call
->cong_dup_acks
= 0;
143 change
= rxrpc_cong_progress
;
144 cwnd
= call
->cong_ssthresh
;
145 if (summary
->nr_nacks
== 0)
146 goto resume_normality
;
156 change
= rxrpc_cong_cleared_nacks
;
157 call
->cong_dup_acks
= 0;
158 call
->cong_extra
= 0;
159 call
->cong_tstamp
= skb
->tstamp
;
160 if (cwnd
< call
->cong_ssthresh
)
161 call
->cong_mode
= RXRPC_CALL_SLOW_START
;
163 call
->cong_mode
= RXRPC_CALL_CONGEST_AVOIDANCE
;
167 if (cwnd
>= RXRPC_RXTX_BUFF_SIZE
- 1)
168 cwnd
= RXRPC_RXTX_BUFF_SIZE
- 1;
169 call
->cong_cwnd
= cwnd
;
170 call
->cong_cumul_acks
= cumulative_acks
;
171 trace_rxrpc_congest(call
, summary
, acked_serial
, change
);
172 if (resend
&& !test_and_set_bit(RXRPC_CALL_EV_RESEND
, &call
->events
))
173 rxrpc_queue_call(call
);
176 packet_loss_detected
:
177 change
= rxrpc_cong_saw_nack
;
178 call
->cong_mode
= RXRPC_CALL_PACKET_LOSS
;
179 call
->cong_dup_acks
= 0;
180 goto send_extra_data
;
183 /* Send some previously unsent DATA if we have some to advance the ACK
186 if (call
->rxtx_annotations
[call
->tx_top
& RXRPC_RXTX_BUFF_MASK
] &
187 RXRPC_TX_ANNO_LAST
||
188 summary
->nr_acks
!= call
->tx_top
- call
->tx_hard_ack
) {
190 wake_up(&call
->waitq
);
192 goto out_no_clear_ca
;
196 * Apply a hard ACK by advancing the Tx window.
198 static bool rxrpc_rotate_tx_window(struct rxrpc_call
*call
, rxrpc_seq_t to
,
199 struct rxrpc_ack_summary
*summary
)
201 struct sk_buff
*skb
, *list
= NULL
;
202 bool rot_last
= false;
206 if (call
->acks_lowest_nak
== call
->tx_hard_ack
) {
207 call
->acks_lowest_nak
= to
;
208 } else if (before_eq(call
->acks_lowest_nak
, to
)) {
209 summary
->new_low_nack
= true;
210 call
->acks_lowest_nak
= to
;
213 spin_lock(&call
->lock
);
215 while (before(call
->tx_hard_ack
, to
)) {
217 ix
= call
->tx_hard_ack
& RXRPC_RXTX_BUFF_MASK
;
218 skb
= call
->rxtx_buffer
[ix
];
219 annotation
= call
->rxtx_annotations
[ix
];
220 rxrpc_see_skb(skb
, rxrpc_skb_rotated
);
221 call
->rxtx_buffer
[ix
] = NULL
;
222 call
->rxtx_annotations
[ix
] = 0;
226 if (annotation
& RXRPC_TX_ANNO_LAST
) {
227 set_bit(RXRPC_CALL_TX_LAST
, &call
->flags
);
230 if ((annotation
& RXRPC_TX_ANNO_MASK
) != RXRPC_TX_ANNO_ACK
)
231 summary
->nr_rot_new_acks
++;
234 spin_unlock(&call
->lock
);
236 trace_rxrpc_transmit(call
, (rot_last
?
237 rxrpc_transmit_rotate_last
:
238 rxrpc_transmit_rotate
));
239 wake_up(&call
->waitq
);
244 skb_mark_not_on_list(skb
);
245 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
252 * End the transmission phase of a call.
254 * This occurs when we get an ACKALL packet, the first DATA packet of a reply,
255 * or a final ACK packet.
257 static bool rxrpc_end_tx_phase(struct rxrpc_call
*call
, bool reply_begun
,
258 const char *abort_why
)
262 ASSERT(test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
));
264 write_lock(&call
->state_lock
);
268 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
269 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
271 call
->state
= state
= RXRPC_CALL_CLIENT_RECV_REPLY
;
273 call
->state
= state
= RXRPC_CALL_CLIENT_AWAIT_REPLY
;
276 case RXRPC_CALL_SERVER_AWAIT_ACK
:
277 __rxrpc_call_completed(call
);
278 rxrpc_notify_socket(call
);
286 write_unlock(&call
->state_lock
);
287 if (state
== RXRPC_CALL_CLIENT_AWAIT_REPLY
)
288 trace_rxrpc_transmit(call
, rxrpc_transmit_await_reply
);
290 trace_rxrpc_transmit(call
, rxrpc_transmit_end
);
295 write_unlock(&call
->state_lock
);
296 kdebug("end_tx %s", rxrpc_call_states
[call
->state
]);
297 rxrpc_proto_abort(abort_why
, call
, call
->tx_top
);
302 * Begin the reply reception phase of a call.
304 static bool rxrpc_receiving_reply(struct rxrpc_call
*call
)
306 struct rxrpc_ack_summary summary
= { 0 };
307 unsigned long now
, timo
;
308 rxrpc_seq_t top
= READ_ONCE(call
->tx_top
);
310 if (call
->ackr_reason
) {
311 spin_lock_bh(&call
->lock
);
312 call
->ackr_reason
= 0;
313 spin_unlock_bh(&call
->lock
);
315 timo
= now
+ MAX_JIFFY_OFFSET
;
316 WRITE_ONCE(call
->resend_at
, timo
);
317 WRITE_ONCE(call
->ack_at
, timo
);
318 trace_rxrpc_timer(call
, rxrpc_timer_init_for_reply
, now
);
321 if (!test_bit(RXRPC_CALL_TX_LAST
, &call
->flags
)) {
322 if (!rxrpc_rotate_tx_window(call
, top
, &summary
)) {
323 rxrpc_proto_abort("TXL", call
, top
);
327 if (!rxrpc_end_tx_phase(call
, true, "ETD"))
329 call
->tx_phase
= false;
334 * Scan a data packet to validate its structure and to work out how many
335 * subpackets it contains.
337 * A jumbo packet is a collection of consecutive packets glued together with
338 * little headers between that indicate how to change the initial header for
341 * RXRPC_JUMBO_PACKET must be set on all but the last subpacket - and all but
342 * the last are RXRPC_JUMBO_DATALEN in size. The last subpacket may be of any
345 static bool rxrpc_validate_data(struct sk_buff
*skb
)
347 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
348 unsigned int offset
= sizeof(struct rxrpc_wire_header
);
349 unsigned int len
= skb
->len
;
350 u8 flags
= sp
->hdr
.flags
;
353 if (flags
& RXRPC_REQUEST_ACK
)
354 __set_bit(sp
->nr_subpackets
, sp
->rx_req_ack
);
357 if (!(flags
& RXRPC_JUMBO_PACKET
))
360 if (len
- offset
< RXRPC_JUMBO_SUBPKTLEN
)
362 if (flags
& RXRPC_LAST_PACKET
)
364 offset
+= RXRPC_JUMBO_DATALEN
;
365 if (skb_copy_bits(skb
, offset
, &flags
, 1) < 0)
367 offset
+= sizeof(struct rxrpc_jumbo_header
);
370 if (flags
& RXRPC_LAST_PACKET
)
371 sp
->rx_flags
|= RXRPC_SKB_INCL_LAST
;
379 * Handle reception of a duplicate packet.
381 * We have to take care to avoid an attack here whereby we're given a series of
382 * jumbograms, each with a sequence number one before the preceding one and
383 * filled up to maximum UDP size. If they never send us the first packet in
384 * the sequence, they can cause us to have to hold on to around 2MiB of kernel
385 * space until the call times out.
387 * We limit the space usage by only accepting three duplicate jumbo packets per
388 * call. After that, we tell the other side we're no longer accepting jumbos
389 * (that information is encoded in the ACK packet).
391 static void rxrpc_input_dup_data(struct rxrpc_call
*call
, rxrpc_seq_t seq
,
392 bool is_jumbo
, bool *_jumbo_bad
)
394 /* Discard normal packets that are duplicates. */
398 /* Skip jumbo subpackets that are duplicates. When we've had three or
399 * more partially duplicate jumbo packets, we refuse to take any more
400 * jumbos for this call.
403 call
->nr_jumbo_bad
++;
409 * Process a DATA packet, adding the packet to the Rx ring. The caller's
410 * packet ref must be passed on or discarded.
412 static void rxrpc_input_data(struct rxrpc_call
*call
, struct sk_buff
*skb
)
414 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
415 enum rxrpc_call_state state
;
416 unsigned int j
, nr_subpackets
;
417 rxrpc_serial_t serial
= sp
->hdr
.serial
, ack_serial
= 0;
418 rxrpc_seq_t seq0
= sp
->hdr
.seq
, hard_ack
;
419 bool immediate_ack
= false, jumbo_bad
= false;
422 _enter("{%u,%u},{%u,%u}",
423 call
->rx_hard_ack
, call
->rx_top
, skb
->len
, seq0
);
425 _proto("Rx DATA %%%u { #%u f=%02x n=%u }",
426 sp
->hdr
.serial
, seq0
, sp
->hdr
.flags
, sp
->nr_subpackets
);
428 state
= READ_ONCE(call
->state
);
429 if (state
>= RXRPC_CALL_COMPLETE
) {
430 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
434 if (state
== RXRPC_CALL_SERVER_RECV_REQUEST
) {
435 unsigned long timo
= READ_ONCE(call
->next_req_timo
);
436 unsigned long now
, expect_req_by
;
440 expect_req_by
= now
+ timo
;
441 WRITE_ONCE(call
->expect_req_by
, expect_req_by
);
442 rxrpc_reduce_call_timer(call
, expect_req_by
, now
,
443 rxrpc_timer_set_for_idle
);
447 spin_lock(&call
->input_lock
);
449 /* Received data implicitly ACKs all of the request packets we sent
450 * when we're acting as a client.
452 if ((state
== RXRPC_CALL_CLIENT_SEND_REQUEST
||
453 state
== RXRPC_CALL_CLIENT_AWAIT_REPLY
) &&
454 !rxrpc_receiving_reply(call
))
457 call
->ackr_prev_seq
= seq0
;
458 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
460 nr_subpackets
= sp
->nr_subpackets
;
461 if (nr_subpackets
> 1) {
462 if (call
->nr_jumbo_bad
> 3) {
463 ack
= RXRPC_ACK_NOSPACE
;
469 for (j
= 0; j
< nr_subpackets
; j
++) {
470 rxrpc_serial_t serial
= sp
->hdr
.serial
+ j
;
471 rxrpc_seq_t seq
= seq0
+ j
;
472 unsigned int ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
473 bool terminal
= (j
== nr_subpackets
- 1);
474 bool last
= terminal
&& (sp
->rx_flags
& RXRPC_SKB_INCL_LAST
);
475 u8 flags
, annotation
= j
;
477 _proto("Rx DATA+%u %%%u { #%x t=%u l=%u }",
478 j
, serial
, seq
, terminal
, last
);
481 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
482 seq
!= call
->rx_top
) {
483 rxrpc_proto_abort("LSN", call
, seq
);
487 if (test_bit(RXRPC_CALL_RX_LAST
, &call
->flags
) &&
488 after_eq(seq
, call
->rx_top
)) {
489 rxrpc_proto_abort("LSA", call
, seq
);
496 flags
|= RXRPC_LAST_PACKET
;
498 flags
|= RXRPC_JUMBO_PACKET
;
499 if (test_bit(j
, sp
->rx_req_ack
))
500 flags
|= RXRPC_REQUEST_ACK
;
501 trace_rxrpc_rx_data(call
->debug_id
, seq
, serial
, flags
, annotation
);
503 if (before_eq(seq
, hard_ack
)) {
504 ack
= RXRPC_ACK_DUPLICATE
;
509 if (call
->rxtx_buffer
[ix
]) {
510 rxrpc_input_dup_data(call
, seq
, nr_subpackets
> 1,
512 if (ack
!= RXRPC_ACK_DUPLICATE
) {
513 ack
= RXRPC_ACK_DUPLICATE
;
516 immediate_ack
= true;
520 if (after(seq
, hard_ack
+ call
->rx_winsize
)) {
521 ack
= RXRPC_ACK_EXCEEDS_WINDOW
;
523 if (flags
& RXRPC_JUMBO_PACKET
) {
525 call
->nr_jumbo_bad
++;
533 if (flags
& RXRPC_REQUEST_ACK
&& !ack
) {
534 ack
= RXRPC_ACK_REQUESTED
;
538 /* Queue the packet. We use a couple of memory barriers here as need
539 * to make sure that rx_top is perceived to be set after the buffer
540 * pointer and that the buffer pointer is set after the annotation and
543 * Barriers against rxrpc_recvmsg_data() and rxrpc_rotate_rx_window()
544 * and also rxrpc_fill_out_ack().
547 rxrpc_get_skb(skb
, rxrpc_skb_got
);
548 call
->rxtx_annotations
[ix
] = annotation
;
550 call
->rxtx_buffer
[ix
] = skb
;
551 if (after(seq
, call
->rx_top
)) {
552 smp_store_release(&call
->rx_top
, seq
);
553 } else if (before(seq
, call
->rx_top
)) {
554 /* Send an immediate ACK if we fill in a hole */
556 ack
= RXRPC_ACK_DELAY
;
559 immediate_ack
= true;
563 /* From this point on, we're not allowed to touch the
564 * packet any longer as its ref now belongs to the Rx
572 set_bit(RXRPC_CALL_RX_LAST
, &call
->flags
);
574 ack
= RXRPC_ACK_DELAY
;
577 trace_rxrpc_receive(call
, rxrpc_receive_queue_last
, serial
, seq
);
579 trace_rxrpc_receive(call
, rxrpc_receive_queue
, serial
, seq
);
582 if (after_eq(seq
, call
->rx_expect_next
)) {
583 if (after(seq
, call
->rx_expect_next
)) {
584 _net("OOS %u > %u", seq
, call
->rx_expect_next
);
585 ack
= RXRPC_ACK_OUT_OF_SEQUENCE
;
588 call
->rx_expect_next
= seq
+ 1;
594 rxrpc_propose_ACK(call
, ack
, ack_serial
,
596 rxrpc_propose_ack_input_data
);
598 rxrpc_propose_ACK(call
, RXRPC_ACK_DELAY
, serial
,
600 rxrpc_propose_ack_input_data
);
602 trace_rxrpc_notify_socket(call
->debug_id
, serial
);
603 rxrpc_notify_socket(call
);
606 spin_unlock(&call
->input_lock
);
607 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
612 * Process a requested ACK.
614 static void rxrpc_input_requested_ack(struct rxrpc_call
*call
,
616 rxrpc_serial_t orig_serial
,
617 rxrpc_serial_t ack_serial
)
619 struct rxrpc_skb_priv
*sp
;
624 for (ix
= 0; ix
< RXRPC_RXTX_BUFF_SIZE
; ix
++) {
625 skb
= call
->rxtx_buffer
[ix
];
629 sent_at
= skb
->tstamp
;
630 smp_rmb(); /* Read timestamp before serial. */
632 if (sp
->hdr
.serial
!= orig_serial
)
640 rxrpc_peer_add_rtt(call
, rxrpc_rtt_rx_requested_ack
,
641 orig_serial
, ack_serial
, sent_at
, resp_time
);
645 * Process the response to a ping that we sent to find out if we lost an ACK.
647 * If we got back a ping response that indicates a lower tx_top than what we
648 * had at the time of the ping transmission, we adjudge all the DATA packets
649 * sent between the response tx_top and the ping-time tx_top to have been lost.
651 static void rxrpc_input_check_for_lost_ack(struct rxrpc_call
*call
)
653 rxrpc_seq_t top
, bottom
, seq
;
656 spin_lock_bh(&call
->lock
);
658 bottom
= call
->tx_hard_ack
+ 1;
659 top
= call
->acks_lost_top
;
660 if (before(bottom
, top
)) {
661 for (seq
= bottom
; before_eq(seq
, top
); seq
++) {
662 int ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
663 u8 annotation
= call
->rxtx_annotations
[ix
];
664 u8 anno_type
= annotation
& RXRPC_TX_ANNO_MASK
;
666 if (anno_type
!= RXRPC_TX_ANNO_UNACK
)
668 annotation
&= ~RXRPC_TX_ANNO_MASK
;
669 annotation
|= RXRPC_TX_ANNO_RETRANS
;
670 call
->rxtx_annotations
[ix
] = annotation
;
675 spin_unlock_bh(&call
->lock
);
677 if (resend
&& !test_and_set_bit(RXRPC_CALL_EV_RESEND
, &call
->events
))
678 rxrpc_queue_call(call
);
682 * Process a ping response.
684 static void rxrpc_input_ping_response(struct rxrpc_call
*call
,
686 rxrpc_serial_t orig_serial
,
687 rxrpc_serial_t ack_serial
)
689 rxrpc_serial_t ping_serial
;
692 ping_time
= call
->ping_time
;
694 ping_serial
= READ_ONCE(call
->ping_serial
);
696 if (orig_serial
== call
->acks_lost_ping
)
697 rxrpc_input_check_for_lost_ack(call
);
699 if (before(orig_serial
, ping_serial
) ||
700 !test_and_clear_bit(RXRPC_CALL_PINGING
, &call
->flags
))
702 if (after(orig_serial
, ping_serial
))
705 rxrpc_peer_add_rtt(call
, rxrpc_rtt_rx_ping_response
,
706 orig_serial
, ack_serial
, ping_time
, resp_time
);
710 * Process the extra information that may be appended to an ACK packet
712 static void rxrpc_input_ackinfo(struct rxrpc_call
*call
, struct sk_buff
*skb
,
713 struct rxrpc_ackinfo
*ackinfo
)
715 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
716 struct rxrpc_peer
*peer
;
719 u32 rwind
= ntohl(ackinfo
->rwind
);
721 _proto("Rx ACK %%%u Info { rx=%u max=%u rwin=%u jm=%u }",
723 ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
),
724 rwind
, ntohl(ackinfo
->jumbo_max
));
726 if (rwind
> RXRPC_RXTX_BUFF_SIZE
- 1)
727 rwind
= RXRPC_RXTX_BUFF_SIZE
- 1;
728 if (call
->tx_winsize
!= rwind
) {
729 if (rwind
> call
->tx_winsize
)
731 trace_rxrpc_rx_rwind_change(call
, sp
->hdr
.serial
, rwind
, wake
);
732 call
->tx_winsize
= rwind
;
735 if (call
->cong_ssthresh
> rwind
)
736 call
->cong_ssthresh
= rwind
;
738 mtu
= min(ntohl(ackinfo
->rxMTU
), ntohl(ackinfo
->maxMTU
));
741 if (mtu
< peer
->maxdata
) {
742 spin_lock_bh(&peer
->lock
);
744 peer
->mtu
= mtu
+ peer
->hdrsize
;
745 spin_unlock_bh(&peer
->lock
);
746 _net("Net MTU %u (maxdata %u)", peer
->mtu
, peer
->maxdata
);
750 wake_up(&call
->waitq
);
754 * Process individual soft ACKs.
756 * Each ACK in the array corresponds to one packet and can be either an ACK or
757 * a NAK. If we get find an explicitly NAK'd packet we resend immediately;
758 * packets that lie beyond the end of the ACK list are scheduled for resend by
759 * the timer on the basis that the peer might just not have processed them at
760 * the time the ACK was sent.
762 static void rxrpc_input_soft_acks(struct rxrpc_call
*call
, u8
*acks
,
763 rxrpc_seq_t seq
, int nr_acks
,
764 struct rxrpc_ack_summary
*summary
)
767 u8 annotation
, anno_type
;
769 for (; nr_acks
> 0; nr_acks
--, seq
++) {
770 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
771 annotation
= call
->rxtx_annotations
[ix
];
772 anno_type
= annotation
& RXRPC_TX_ANNO_MASK
;
773 annotation
&= ~RXRPC_TX_ANNO_MASK
;
775 case RXRPC_ACK_TYPE_ACK
:
777 if (anno_type
== RXRPC_TX_ANNO_ACK
)
779 summary
->nr_new_acks
++;
780 call
->rxtx_annotations
[ix
] =
781 RXRPC_TX_ANNO_ACK
| annotation
;
783 case RXRPC_ACK_TYPE_NACK
:
784 if (!summary
->nr_nacks
&&
785 call
->acks_lowest_nak
!= seq
) {
786 call
->acks_lowest_nak
= seq
;
787 summary
->new_low_nack
= true;
790 if (anno_type
== RXRPC_TX_ANNO_NAK
)
792 summary
->nr_new_nacks
++;
793 if (anno_type
== RXRPC_TX_ANNO_RETRANS
)
795 call
->rxtx_annotations
[ix
] =
796 RXRPC_TX_ANNO_NAK
| annotation
;
799 return rxrpc_proto_abort("SFT", call
, 0);
805 * Return true if the ACK is valid - ie. it doesn't appear to have regressed
806 * with respect to the ack state conveyed by preceding ACKs.
808 static bool rxrpc_is_ack_valid(struct rxrpc_call
*call
,
809 rxrpc_seq_t first_pkt
, rxrpc_seq_t prev_pkt
)
811 rxrpc_seq_t base
= READ_ONCE(call
->ackr_first_seq
);
813 if (after(first_pkt
, base
))
814 return true; /* The window advanced */
816 if (before(first_pkt
, base
))
817 return false; /* firstPacket regressed */
819 if (after_eq(prev_pkt
, call
->ackr_prev_seq
))
820 return true; /* previousPacket hasn't regressed. */
822 /* Some rx implementations put a serial number in previousPacket. */
823 if (after_eq(prev_pkt
, base
+ call
->tx_winsize
))
829 * Process an ACK packet.
831 * ack.firstPacket is the sequence number of the first soft-ACK'd/NAK'd packet
832 * in the ACK array. Anything before that is hard-ACK'd and may be discarded.
834 * A hard-ACK means that a packet has been processed and may be discarded; a
835 * soft-ACK means that the packet may be discarded and retransmission
836 * requested. A phase is complete when all packets are hard-ACK'd.
838 static void rxrpc_input_ack(struct rxrpc_call
*call
, struct sk_buff
*skb
)
840 struct rxrpc_ack_summary summary
= { 0 };
841 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
843 struct rxrpc_ackpacket ack
;
844 struct rxrpc_ackinfo info
;
845 u8 acks
[RXRPC_MAXACKS
];
847 rxrpc_serial_t ack_serial
, acked_serial
;
848 rxrpc_seq_t first_soft_ack
, hard_ack
, prev_pkt
;
849 int nr_acks
, offset
, ioffset
;
853 offset
= sizeof(struct rxrpc_wire_header
);
854 if (skb_copy_bits(skb
, offset
, &buf
.ack
, sizeof(buf
.ack
)) < 0) {
855 _debug("extraction failure");
856 return rxrpc_proto_abort("XAK", call
, 0);
858 offset
+= sizeof(buf
.ack
);
860 ack_serial
= sp
->hdr
.serial
;
861 acked_serial
= ntohl(buf
.ack
.serial
);
862 first_soft_ack
= ntohl(buf
.ack
.firstPacket
);
863 prev_pkt
= ntohl(buf
.ack
.previousPacket
);
864 hard_ack
= first_soft_ack
- 1;
865 nr_acks
= buf
.ack
.nAcks
;
866 summary
.ack_reason
= (buf
.ack
.reason
< RXRPC_ACK__INVALID
?
867 buf
.ack
.reason
: RXRPC_ACK__INVALID
);
869 trace_rxrpc_rx_ack(call
, ack_serial
, acked_serial
,
870 first_soft_ack
, prev_pkt
,
871 summary
.ack_reason
, nr_acks
);
873 if (buf
.ack
.reason
== RXRPC_ACK_PING_RESPONSE
)
874 rxrpc_input_ping_response(call
, skb
->tstamp
, acked_serial
,
876 if (buf
.ack
.reason
== RXRPC_ACK_REQUESTED
)
877 rxrpc_input_requested_ack(call
, skb
->tstamp
, acked_serial
,
880 if (buf
.ack
.reason
== RXRPC_ACK_PING
) {
881 _proto("Rx ACK %%%u PING Request", ack_serial
);
882 rxrpc_propose_ACK(call
, RXRPC_ACK_PING_RESPONSE
,
883 ack_serial
, true, true,
884 rxrpc_propose_ack_respond_to_ping
);
885 } else if (sp
->hdr
.flags
& RXRPC_REQUEST_ACK
) {
886 rxrpc_propose_ACK(call
, RXRPC_ACK_REQUESTED
,
887 ack_serial
, true, true,
888 rxrpc_propose_ack_respond_to_ack
);
891 /* Discard any out-of-order or duplicate ACKs (outside lock). */
892 if (!rxrpc_is_ack_valid(call
, first_soft_ack
, prev_pkt
)) {
893 trace_rxrpc_rx_discard_ack(call
->debug_id
, ack_serial
,
894 first_soft_ack
, call
->ackr_first_seq
,
895 prev_pkt
, call
->ackr_prev_seq
);
900 ioffset
= offset
+ nr_acks
+ 3;
901 if (skb
->len
>= ioffset
+ sizeof(buf
.info
) &&
902 skb_copy_bits(skb
, ioffset
, &buf
.info
, sizeof(buf
.info
)) < 0)
903 return rxrpc_proto_abort("XAI", call
, 0);
905 spin_lock(&call
->input_lock
);
907 /* Discard any out-of-order or duplicate ACKs (inside lock). */
908 if (!rxrpc_is_ack_valid(call
, first_soft_ack
, prev_pkt
)) {
909 trace_rxrpc_rx_discard_ack(call
->debug_id
, ack_serial
,
910 first_soft_ack
, call
->ackr_first_seq
,
911 prev_pkt
, call
->ackr_prev_seq
);
914 call
->acks_latest_ts
= skb
->tstamp
;
916 call
->ackr_first_seq
= first_soft_ack
;
917 call
->ackr_prev_seq
= prev_pkt
;
919 /* Parse rwind and mtu sizes if provided. */
921 rxrpc_input_ackinfo(call
, skb
, &buf
.info
);
923 if (first_soft_ack
== 0) {
924 rxrpc_proto_abort("AK0", call
, 0);
928 /* Ignore ACKs unless we are or have just been transmitting. */
929 switch (READ_ONCE(call
->state
)) {
930 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
931 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
932 case RXRPC_CALL_SERVER_SEND_REPLY
:
933 case RXRPC_CALL_SERVER_AWAIT_ACK
:
939 if (before(hard_ack
, call
->tx_hard_ack
) ||
940 after(hard_ack
, call
->tx_top
)) {
941 rxrpc_proto_abort("AKW", call
, 0);
944 if (nr_acks
> call
->tx_top
- hard_ack
) {
945 rxrpc_proto_abort("AKN", call
, 0);
949 if (after(hard_ack
, call
->tx_hard_ack
)) {
950 if (rxrpc_rotate_tx_window(call
, hard_ack
, &summary
)) {
951 rxrpc_end_tx_phase(call
, false, "ETA");
957 if (skb_copy_bits(skb
, offset
, buf
.acks
, nr_acks
) < 0) {
958 rxrpc_proto_abort("XSA", call
, 0);
961 rxrpc_input_soft_acks(call
, buf
.acks
, first_soft_ack
, nr_acks
,
965 if (call
->rxtx_annotations
[call
->tx_top
& RXRPC_RXTX_BUFF_MASK
] &
966 RXRPC_TX_ANNO_LAST
&&
967 summary
.nr_acks
== call
->tx_top
- hard_ack
&&
968 rxrpc_is_client_call(call
))
969 rxrpc_propose_ACK(call
, RXRPC_ACK_PING
, ack_serial
,
971 rxrpc_propose_ack_ping_for_lost_reply
);
973 rxrpc_congestion_management(call
, skb
, &summary
, acked_serial
);
975 spin_unlock(&call
->input_lock
);
979 * Process an ACKALL packet.
981 static void rxrpc_input_ackall(struct rxrpc_call
*call
, struct sk_buff
*skb
)
983 struct rxrpc_ack_summary summary
= { 0 };
984 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
986 _proto("Rx ACKALL %%%u", sp
->hdr
.serial
);
988 spin_lock(&call
->input_lock
);
990 if (rxrpc_rotate_tx_window(call
, call
->tx_top
, &summary
))
991 rxrpc_end_tx_phase(call
, false, "ETL");
993 spin_unlock(&call
->input_lock
);
997 * Process an ABORT packet directed at a call.
999 static void rxrpc_input_abort(struct rxrpc_call
*call
, struct sk_buff
*skb
)
1001 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
1003 u32 abort_code
= RX_CALL_DEAD
;
1007 if (skb
->len
>= 4 &&
1008 skb_copy_bits(skb
, sizeof(struct rxrpc_wire_header
),
1009 &wtmp
, sizeof(wtmp
)) >= 0)
1010 abort_code
= ntohl(wtmp
);
1012 trace_rxrpc_rx_abort(call
, sp
->hdr
.serial
, abort_code
);
1014 _proto("Rx ABORT %%%u { %x }", sp
->hdr
.serial
, abort_code
);
1016 if (rxrpc_set_call_completion(call
, RXRPC_CALL_REMOTELY_ABORTED
,
1017 abort_code
, -ECONNABORTED
))
1018 rxrpc_notify_socket(call
);
1022 * Process an incoming call packet.
1024 static void rxrpc_input_call_packet(struct rxrpc_call
*call
,
1025 struct sk_buff
*skb
)
1027 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
1030 _enter("%p,%p", call
, skb
);
1032 timo
= READ_ONCE(call
->next_rx_timo
);
1034 unsigned long now
= jiffies
, expect_rx_by
;
1036 expect_rx_by
= now
+ timo
;
1037 WRITE_ONCE(call
->expect_rx_by
, expect_rx_by
);
1038 rxrpc_reduce_call_timer(call
, expect_rx_by
, now
,
1039 rxrpc_timer_set_for_normal
);
1042 switch (sp
->hdr
.type
) {
1043 case RXRPC_PACKET_TYPE_DATA
:
1044 rxrpc_input_data(call
, skb
);
1047 case RXRPC_PACKET_TYPE_ACK
:
1048 rxrpc_input_ack(call
, skb
);
1051 case RXRPC_PACKET_TYPE_BUSY
:
1052 _proto("Rx BUSY %%%u", sp
->hdr
.serial
);
1054 /* Just ignore BUSY packets from the server; the retry and
1055 * lifespan timers will take care of business. BUSY packets
1056 * from the client don't make sense.
1060 case RXRPC_PACKET_TYPE_ABORT
:
1061 rxrpc_input_abort(call
, skb
);
1064 case RXRPC_PACKET_TYPE_ACKALL
:
1065 rxrpc_input_ackall(call
, skb
);
1072 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1078 * Handle a new service call on a channel implicitly completing the preceding
1079 * call on that channel. This does not apply to client conns.
1081 * TODO: If callNumber > call_id + 1, renegotiate security.
1083 static void rxrpc_input_implicit_end_call(struct rxrpc_sock
*rx
,
1084 struct rxrpc_connection
*conn
,
1085 struct rxrpc_call
*call
)
1087 switch (READ_ONCE(call
->state
)) {
1088 case RXRPC_CALL_SERVER_AWAIT_ACK
:
1089 rxrpc_call_completed(call
);
1091 case RXRPC_CALL_COMPLETE
:
1094 if (rxrpc_abort_call("IMP", call
, 0, RX_CALL_DEAD
, -ESHUTDOWN
)) {
1095 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
1096 rxrpc_queue_call(call
);
1098 trace_rxrpc_improper_term(call
);
1102 spin_lock(&rx
->incoming_lock
);
1103 __rxrpc_disconnect_call(conn
, call
);
1104 spin_unlock(&rx
->incoming_lock
);
1105 rxrpc_notify_socket(call
);
1109 * post connection-level events to the connection
1110 * - this includes challenges, responses, some aborts and call terminal packet
1113 static void rxrpc_post_packet_to_conn(struct rxrpc_connection
*conn
,
1114 struct sk_buff
*skb
)
1116 _enter("%p,%p", conn
, skb
);
1118 skb_queue_tail(&conn
->rx_queue
, skb
);
1119 rxrpc_queue_conn(conn
);
1123 * post endpoint-level events to the local endpoint
1124 * - this includes debug and version messages
1126 static void rxrpc_post_packet_to_local(struct rxrpc_local
*local
,
1127 struct sk_buff
*skb
)
1129 _enter("%p,%p", local
, skb
);
1131 if (rxrpc_get_local_maybe(local
)) {
1132 skb_queue_tail(&local
->event_queue
, skb
);
1133 rxrpc_queue_local(local
);
1135 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1140 * put a packet up for transport-level abort
1142 static void rxrpc_reject_packet(struct rxrpc_local
*local
, struct sk_buff
*skb
)
1144 CHECK_SLAB_OKAY(&local
->usage
);
1146 if (rxrpc_get_local_maybe(local
)) {
1147 skb_queue_tail(&local
->reject_queue
, skb
);
1148 rxrpc_queue_local(local
);
1150 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1155 * Extract the wire header from a packet and translate the byte order.
1158 int rxrpc_extract_header(struct rxrpc_skb_priv
*sp
, struct sk_buff
*skb
)
1160 struct rxrpc_wire_header whdr
;
1162 /* dig out the RxRPC connection details */
1163 if (skb_copy_bits(skb
, 0, &whdr
, sizeof(whdr
)) < 0) {
1164 trace_rxrpc_rx_eproto(NULL
, sp
->hdr
.serial
,
1165 tracepoint_string("bad_hdr"));
1169 memset(sp
, 0, sizeof(*sp
));
1170 sp
->hdr
.epoch
= ntohl(whdr
.epoch
);
1171 sp
->hdr
.cid
= ntohl(whdr
.cid
);
1172 sp
->hdr
.callNumber
= ntohl(whdr
.callNumber
);
1173 sp
->hdr
.seq
= ntohl(whdr
.seq
);
1174 sp
->hdr
.serial
= ntohl(whdr
.serial
);
1175 sp
->hdr
.flags
= whdr
.flags
;
1176 sp
->hdr
.type
= whdr
.type
;
1177 sp
->hdr
.userStatus
= whdr
.userStatus
;
1178 sp
->hdr
.securityIndex
= whdr
.securityIndex
;
1179 sp
->hdr
._rsvd
= ntohs(whdr
._rsvd
);
1180 sp
->hdr
.serviceId
= ntohs(whdr
.serviceId
);
1185 * handle data received on the local endpoint
1186 * - may be called in interrupt context
1188 * [!] Note that as this is called from the encap_rcv hook, the socket is not
1189 * held locked by the caller and nothing prevents sk_user_data on the UDP from
1190 * being cleared in the middle of processing this function.
1192 * Called with the RCU read lock held from the IP layer via UDP.
1194 int rxrpc_input_packet(struct sock
*udp_sk
, struct sk_buff
*skb
)
1196 struct rxrpc_local
*local
= rcu_dereference_sk_user_data(udp_sk
);
1197 struct rxrpc_connection
*conn
;
1198 struct rxrpc_channel
*chan
;
1199 struct rxrpc_call
*call
= NULL
;
1200 struct rxrpc_skb_priv
*sp
;
1201 struct rxrpc_peer
*peer
= NULL
;
1202 struct rxrpc_sock
*rx
= NULL
;
1203 unsigned int channel
;
1205 _enter("%p", udp_sk
);
1207 if (unlikely(!local
)) {
1211 if (skb
->tstamp
== 0)
1212 skb
->tstamp
= ktime_get_real();
1214 rxrpc_new_skb(skb
, rxrpc_skb_received
);
1216 skb_pull(skb
, sizeof(struct udphdr
));
1218 /* The UDP protocol already released all skb resources;
1219 * we are free to add our own data there.
1221 sp
= rxrpc_skb(skb
);
1223 /* dig out the RxRPC connection details */
1224 if (rxrpc_extract_header(sp
, skb
) < 0)
1227 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS
)) {
1229 if ((lose
++ & 7) == 7) {
1230 trace_rxrpc_rx_lose(sp
);
1231 rxrpc_free_skb(skb
, rxrpc_skb_lost
);
1236 if (skb
->tstamp
== 0)
1237 skb
->tstamp
= ktime_get_real();
1238 trace_rxrpc_rx_packet(sp
);
1240 switch (sp
->hdr
.type
) {
1241 case RXRPC_PACKET_TYPE_VERSION
:
1242 if (rxrpc_to_client(sp
))
1244 rxrpc_post_packet_to_local(local
, skb
);
1247 case RXRPC_PACKET_TYPE_BUSY
:
1248 if (rxrpc_to_server(sp
))
1251 case RXRPC_PACKET_TYPE_ACK
:
1252 case RXRPC_PACKET_TYPE_ACKALL
:
1253 if (sp
->hdr
.callNumber
== 0)
1256 case RXRPC_PACKET_TYPE_ABORT
:
1259 case RXRPC_PACKET_TYPE_DATA
:
1260 if (sp
->hdr
.callNumber
== 0 ||
1263 if (!rxrpc_validate_data(skb
))
1266 /* Unshare the packet so that it can be modified for in-place
1269 if (sp
->hdr
.securityIndex
!= 0) {
1270 struct sk_buff
*nskb
= skb_unshare(skb
, GFP_ATOMIC
);
1272 rxrpc_eaten_skb(skb
, rxrpc_skb_unshared_nomem
);
1277 rxrpc_eaten_skb(skb
, rxrpc_skb_received
);
1279 rxrpc_new_skb(skb
, rxrpc_skb_unshared
);
1280 sp
= rxrpc_skb(skb
);
1285 case RXRPC_PACKET_TYPE_CHALLENGE
:
1286 if (rxrpc_to_server(sp
))
1289 case RXRPC_PACKET_TYPE_RESPONSE
:
1290 if (rxrpc_to_client(sp
))
1294 /* Packet types 9-11 should just be ignored. */
1295 case RXRPC_PACKET_TYPE_PARAMS
:
1296 case RXRPC_PACKET_TYPE_10
:
1297 case RXRPC_PACKET_TYPE_11
:
1301 _proto("Rx Bad Packet Type %u", sp
->hdr
.type
);
1305 if (sp
->hdr
.serviceId
== 0)
1308 if (rxrpc_to_server(sp
)) {
1309 /* Weed out packets to services we're not offering. Packets
1310 * that would begin a call are explicitly rejected and the rest
1311 * are just discarded.
1313 rx
= rcu_dereference(local
->service
);
1314 if (!rx
|| (sp
->hdr
.serviceId
!= rx
->srx
.srx_service
&&
1315 sp
->hdr
.serviceId
!= rx
->second_service
)) {
1316 if (sp
->hdr
.type
== RXRPC_PACKET_TYPE_DATA
&&
1318 goto unsupported_service
;
1323 conn
= rxrpc_find_connection_rcu(local
, skb
, &peer
);
1325 if (sp
->hdr
.securityIndex
!= conn
->security_ix
)
1326 goto wrong_security
;
1328 if (sp
->hdr
.serviceId
!= conn
->service_id
) {
1331 if (!test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE
, &conn
->flags
))
1333 old_id
= cmpxchg(&conn
->service_id
, conn
->params
.service_id
,
1336 if (old_id
!= conn
->params
.service_id
&&
1337 old_id
!= sp
->hdr
.serviceId
)
1341 if (sp
->hdr
.callNumber
== 0) {
1342 /* Connection-level packet */
1343 _debug("CONN %p {%d}", conn
, conn
->debug_id
);
1344 rxrpc_post_packet_to_conn(conn
, skb
);
1348 if ((int)sp
->hdr
.serial
- (int)conn
->hi_serial
> 0)
1349 conn
->hi_serial
= sp
->hdr
.serial
;
1351 /* Call-bound packets are routed by connection channel. */
1352 channel
= sp
->hdr
.cid
& RXRPC_CHANNELMASK
;
1353 chan
= &conn
->channels
[channel
];
1355 /* Ignore really old calls */
1356 if (sp
->hdr
.callNumber
< chan
->last_call
)
1359 if (sp
->hdr
.callNumber
== chan
->last_call
) {
1361 sp
->hdr
.type
== RXRPC_PACKET_TYPE_ABORT
)
1364 /* For the previous service call, if completed
1365 * successfully, we discard all further packets.
1367 if (rxrpc_conn_is_service(conn
) &&
1368 chan
->last_type
== RXRPC_PACKET_TYPE_ACK
)
1371 /* But otherwise we need to retransmit the final packet
1372 * from data cached in the connection record.
1374 if (sp
->hdr
.type
== RXRPC_PACKET_TYPE_DATA
)
1375 trace_rxrpc_rx_data(chan
->call_debug_id
,
1379 rxrpc_post_packet_to_conn(conn
, skb
);
1383 call
= rcu_dereference(chan
->call
);
1385 if (sp
->hdr
.callNumber
> chan
->call_id
) {
1386 if (rxrpc_to_client(sp
))
1389 rxrpc_input_implicit_end_call(rx
, conn
, call
);
1394 if (sp
->hdr
.serviceId
!= call
->service_id
)
1395 call
->service_id
= sp
->hdr
.serviceId
;
1396 if ((int)sp
->hdr
.serial
- (int)call
->rx_serial
> 0)
1397 call
->rx_serial
= sp
->hdr
.serial
;
1398 if (!test_bit(RXRPC_CALL_RX_HEARD
, &call
->flags
))
1399 set_bit(RXRPC_CALL_RX_HEARD
, &call
->flags
);
1403 if (!call
|| atomic_read(&call
->usage
) == 0) {
1404 if (rxrpc_to_client(sp
) ||
1405 sp
->hdr
.type
!= RXRPC_PACKET_TYPE_DATA
)
1407 if (sp
->hdr
.seq
!= 1)
1409 call
= rxrpc_new_incoming_call(local
, rx
, skb
);
1414 /* Process a call packet; this either discards or passes on the ref
1417 rxrpc_input_call_packet(call
, skb
);
1421 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1423 trace_rxrpc_rx_done(0, 0);
1427 trace_rxrpc_abort(0, "SEC", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1428 RXKADINCONSISTENCY
, EBADMSG
);
1429 skb
->priority
= RXKADINCONSISTENCY
;
1432 unsupported_service
:
1433 trace_rxrpc_abort(0, "INV", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1434 RX_INVALID_OPERATION
, EOPNOTSUPP
);
1435 skb
->priority
= RX_INVALID_OPERATION
;
1439 trace_rxrpc_abort(0, "UPG", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1440 RX_PROTOCOL_ERROR
, EBADMSG
);
1441 goto protocol_error
;
1444 trace_rxrpc_abort(0, "BAD", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1445 RX_PROTOCOL_ERROR
, EBADMSG
);
1447 skb
->priority
= RX_PROTOCOL_ERROR
;
1449 skb
->mark
= RXRPC_SKB_MARK_REJECT_ABORT
;
1451 trace_rxrpc_rx_done(skb
->mark
, skb
->priority
);
1452 rxrpc_reject_packet(local
, skb
);
1453 _leave(" [badmsg]");