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 (call
->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 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 acked_serial
= ntohl(buf
.ack
.serial
);
861 first_soft_ack
= ntohl(buf
.ack
.firstPacket
);
862 prev_pkt
= ntohl(buf
.ack
.previousPacket
);
863 hard_ack
= first_soft_ack
- 1;
864 nr_acks
= buf
.ack
.nAcks
;
865 summary
.ack_reason
= (buf
.ack
.reason
< RXRPC_ACK__INVALID
?
866 buf
.ack
.reason
: RXRPC_ACK__INVALID
);
868 trace_rxrpc_rx_ack(call
, sp
->hdr
.serial
, acked_serial
,
869 first_soft_ack
, prev_pkt
,
870 summary
.ack_reason
, nr_acks
);
872 if (buf
.ack
.reason
== RXRPC_ACK_PING_RESPONSE
)
873 rxrpc_input_ping_response(call
, skb
->tstamp
, acked_serial
,
875 if (buf
.ack
.reason
== RXRPC_ACK_REQUESTED
)
876 rxrpc_input_requested_ack(call
, skb
->tstamp
, acked_serial
,
879 if (buf
.ack
.reason
== RXRPC_ACK_PING
) {
880 _proto("Rx ACK %%%u PING Request", sp
->hdr
.serial
);
881 rxrpc_propose_ACK(call
, RXRPC_ACK_PING_RESPONSE
,
882 sp
->hdr
.serial
, true, true,
883 rxrpc_propose_ack_respond_to_ping
);
884 } else if (sp
->hdr
.flags
& RXRPC_REQUEST_ACK
) {
885 rxrpc_propose_ACK(call
, RXRPC_ACK_REQUESTED
,
886 sp
->hdr
.serial
, true, true,
887 rxrpc_propose_ack_respond_to_ack
);
890 /* Discard any out-of-order or duplicate ACKs (outside lock). */
891 if (!rxrpc_is_ack_valid(call
, first_soft_ack
, prev_pkt
)) {
892 trace_rxrpc_rx_discard_ack(call
->debug_id
, sp
->hdr
.serial
,
893 first_soft_ack
, call
->ackr_first_seq
,
894 prev_pkt
, call
->ackr_prev_seq
);
899 ioffset
= offset
+ nr_acks
+ 3;
900 if (skb
->len
>= ioffset
+ sizeof(buf
.info
) &&
901 skb_copy_bits(skb
, ioffset
, &buf
.info
, sizeof(buf
.info
)) < 0)
902 return rxrpc_proto_abort("XAI", call
, 0);
904 spin_lock(&call
->input_lock
);
906 /* Discard any out-of-order or duplicate ACKs (inside lock). */
907 if (!rxrpc_is_ack_valid(call
, first_soft_ack
, prev_pkt
)) {
908 trace_rxrpc_rx_discard_ack(call
->debug_id
, sp
->hdr
.serial
,
909 first_soft_ack
, call
->ackr_first_seq
,
910 prev_pkt
, call
->ackr_prev_seq
);
913 call
->acks_latest_ts
= skb
->tstamp
;
915 call
->ackr_first_seq
= first_soft_ack
;
916 call
->ackr_prev_seq
= prev_pkt
;
918 /* Parse rwind and mtu sizes if provided. */
920 rxrpc_input_ackinfo(call
, skb
, &buf
.info
);
922 if (first_soft_ack
== 0) {
923 rxrpc_proto_abort("AK0", call
, 0);
927 /* Ignore ACKs unless we are or have just been transmitting. */
928 switch (READ_ONCE(call
->state
)) {
929 case RXRPC_CALL_CLIENT_SEND_REQUEST
:
930 case RXRPC_CALL_CLIENT_AWAIT_REPLY
:
931 case RXRPC_CALL_SERVER_SEND_REPLY
:
932 case RXRPC_CALL_SERVER_AWAIT_ACK
:
938 if (before(hard_ack
, call
->tx_hard_ack
) ||
939 after(hard_ack
, call
->tx_top
)) {
940 rxrpc_proto_abort("AKW", call
, 0);
943 if (nr_acks
> call
->tx_top
- hard_ack
) {
944 rxrpc_proto_abort("AKN", call
, 0);
948 if (after(hard_ack
, call
->tx_hard_ack
)) {
949 if (rxrpc_rotate_tx_window(call
, hard_ack
, &summary
)) {
950 rxrpc_end_tx_phase(call
, false, "ETA");
956 if (skb_copy_bits(skb
, offset
, buf
.acks
, nr_acks
) < 0) {
957 rxrpc_proto_abort("XSA", call
, 0);
960 rxrpc_input_soft_acks(call
, buf
.acks
, first_soft_ack
, nr_acks
,
964 if (call
->rxtx_annotations
[call
->tx_top
& RXRPC_RXTX_BUFF_MASK
] &
965 RXRPC_TX_ANNO_LAST
&&
966 summary
.nr_acks
== call
->tx_top
- hard_ack
&&
967 rxrpc_is_client_call(call
))
968 rxrpc_propose_ACK(call
, RXRPC_ACK_PING
, sp
->hdr
.serial
,
970 rxrpc_propose_ack_ping_for_lost_reply
);
972 rxrpc_congestion_management(call
, skb
, &summary
, acked_serial
);
974 spin_unlock(&call
->input_lock
);
978 * Process an ACKALL packet.
980 static void rxrpc_input_ackall(struct rxrpc_call
*call
, struct sk_buff
*skb
)
982 struct rxrpc_ack_summary summary
= { 0 };
983 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
985 _proto("Rx ACKALL %%%u", sp
->hdr
.serial
);
987 spin_lock(&call
->input_lock
);
989 if (rxrpc_rotate_tx_window(call
, call
->tx_top
, &summary
))
990 rxrpc_end_tx_phase(call
, false, "ETL");
992 spin_unlock(&call
->input_lock
);
996 * Process an ABORT packet directed at a call.
998 static void rxrpc_input_abort(struct rxrpc_call
*call
, struct sk_buff
*skb
)
1000 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
1002 u32 abort_code
= RX_CALL_DEAD
;
1006 if (skb
->len
>= 4 &&
1007 skb_copy_bits(skb
, sizeof(struct rxrpc_wire_header
),
1008 &wtmp
, sizeof(wtmp
)) >= 0)
1009 abort_code
= ntohl(wtmp
);
1011 trace_rxrpc_rx_abort(call
, sp
->hdr
.serial
, abort_code
);
1013 _proto("Rx ABORT %%%u { %x }", sp
->hdr
.serial
, abort_code
);
1015 if (rxrpc_set_call_completion(call
, RXRPC_CALL_REMOTELY_ABORTED
,
1016 abort_code
, -ECONNABORTED
))
1017 rxrpc_notify_socket(call
);
1021 * Process an incoming call packet.
1023 static void rxrpc_input_call_packet(struct rxrpc_call
*call
,
1024 struct sk_buff
*skb
)
1026 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
1029 _enter("%p,%p", call
, skb
);
1031 timo
= READ_ONCE(call
->next_rx_timo
);
1033 unsigned long now
= jiffies
, expect_rx_by
;
1035 expect_rx_by
= now
+ timo
;
1036 WRITE_ONCE(call
->expect_rx_by
, expect_rx_by
);
1037 rxrpc_reduce_call_timer(call
, expect_rx_by
, now
,
1038 rxrpc_timer_set_for_normal
);
1041 switch (sp
->hdr
.type
) {
1042 case RXRPC_PACKET_TYPE_DATA
:
1043 rxrpc_input_data(call
, skb
);
1046 case RXRPC_PACKET_TYPE_ACK
:
1047 rxrpc_input_ack(call
, skb
);
1050 case RXRPC_PACKET_TYPE_BUSY
:
1051 _proto("Rx BUSY %%%u", sp
->hdr
.serial
);
1053 /* Just ignore BUSY packets from the server; the retry and
1054 * lifespan timers will take care of business. BUSY packets
1055 * from the client don't make sense.
1059 case RXRPC_PACKET_TYPE_ABORT
:
1060 rxrpc_input_abort(call
, skb
);
1063 case RXRPC_PACKET_TYPE_ACKALL
:
1064 rxrpc_input_ackall(call
, skb
);
1071 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1077 * Handle a new service call on a channel implicitly completing the preceding
1078 * call on that channel. This does not apply to client conns.
1080 * TODO: If callNumber > call_id + 1, renegotiate security.
1082 static void rxrpc_input_implicit_end_call(struct rxrpc_sock
*rx
,
1083 struct rxrpc_connection
*conn
,
1084 struct rxrpc_call
*call
)
1086 switch (READ_ONCE(call
->state
)) {
1087 case RXRPC_CALL_SERVER_AWAIT_ACK
:
1088 rxrpc_call_completed(call
);
1090 case RXRPC_CALL_COMPLETE
:
1093 if (rxrpc_abort_call("IMP", call
, 0, RX_CALL_DEAD
, -ESHUTDOWN
)) {
1094 set_bit(RXRPC_CALL_EV_ABORT
, &call
->events
);
1095 rxrpc_queue_call(call
);
1097 trace_rxrpc_improper_term(call
);
1101 spin_lock(&rx
->incoming_lock
);
1102 __rxrpc_disconnect_call(conn
, call
);
1103 spin_unlock(&rx
->incoming_lock
);
1104 rxrpc_notify_socket(call
);
1108 * post connection-level events to the connection
1109 * - this includes challenges, responses, some aborts and call terminal packet
1112 static void rxrpc_post_packet_to_conn(struct rxrpc_connection
*conn
,
1113 struct sk_buff
*skb
)
1115 _enter("%p,%p", conn
, skb
);
1117 skb_queue_tail(&conn
->rx_queue
, skb
);
1118 rxrpc_queue_conn(conn
);
1122 * post endpoint-level events to the local endpoint
1123 * - this includes debug and version messages
1125 static void rxrpc_post_packet_to_local(struct rxrpc_local
*local
,
1126 struct sk_buff
*skb
)
1128 _enter("%p,%p", local
, skb
);
1130 if (rxrpc_get_local_maybe(local
)) {
1131 skb_queue_tail(&local
->event_queue
, skb
);
1132 rxrpc_queue_local(local
);
1134 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1139 * put a packet up for transport-level abort
1141 static void rxrpc_reject_packet(struct rxrpc_local
*local
, struct sk_buff
*skb
)
1143 CHECK_SLAB_OKAY(&local
->usage
);
1145 if (rxrpc_get_local_maybe(local
)) {
1146 skb_queue_tail(&local
->reject_queue
, skb
);
1147 rxrpc_queue_local(local
);
1149 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1154 * Extract the wire header from a packet and translate the byte order.
1157 int rxrpc_extract_header(struct rxrpc_skb_priv
*sp
, struct sk_buff
*skb
)
1159 struct rxrpc_wire_header whdr
;
1161 /* dig out the RxRPC connection details */
1162 if (skb_copy_bits(skb
, 0, &whdr
, sizeof(whdr
)) < 0) {
1163 trace_rxrpc_rx_eproto(NULL
, sp
->hdr
.serial
,
1164 tracepoint_string("bad_hdr"));
1168 memset(sp
, 0, sizeof(*sp
));
1169 sp
->hdr
.epoch
= ntohl(whdr
.epoch
);
1170 sp
->hdr
.cid
= ntohl(whdr
.cid
);
1171 sp
->hdr
.callNumber
= ntohl(whdr
.callNumber
);
1172 sp
->hdr
.seq
= ntohl(whdr
.seq
);
1173 sp
->hdr
.serial
= ntohl(whdr
.serial
);
1174 sp
->hdr
.flags
= whdr
.flags
;
1175 sp
->hdr
.type
= whdr
.type
;
1176 sp
->hdr
.userStatus
= whdr
.userStatus
;
1177 sp
->hdr
.securityIndex
= whdr
.securityIndex
;
1178 sp
->hdr
._rsvd
= ntohs(whdr
._rsvd
);
1179 sp
->hdr
.serviceId
= ntohs(whdr
.serviceId
);
1184 * handle data received on the local endpoint
1185 * - may be called in interrupt context
1187 * [!] Note that as this is called from the encap_rcv hook, the socket is not
1188 * held locked by the caller and nothing prevents sk_user_data on the UDP from
1189 * being cleared in the middle of processing this function.
1191 * Called with the RCU read lock held from the IP layer via UDP.
1193 int rxrpc_input_packet(struct sock
*udp_sk
, struct sk_buff
*skb
)
1195 struct rxrpc_local
*local
= rcu_dereference_sk_user_data(udp_sk
);
1196 struct rxrpc_connection
*conn
;
1197 struct rxrpc_channel
*chan
;
1198 struct rxrpc_call
*call
= NULL
;
1199 struct rxrpc_skb_priv
*sp
;
1200 struct rxrpc_peer
*peer
= NULL
;
1201 struct rxrpc_sock
*rx
= NULL
;
1202 unsigned int channel
;
1204 _enter("%p", udp_sk
);
1206 if (unlikely(!local
)) {
1210 if (skb
->tstamp
== 0)
1211 skb
->tstamp
= ktime_get_real();
1213 rxrpc_new_skb(skb
, rxrpc_skb_received
);
1215 skb_pull(skb
, sizeof(struct udphdr
));
1217 /* The UDP protocol already released all skb resources;
1218 * we are free to add our own data there.
1220 sp
= rxrpc_skb(skb
);
1222 /* dig out the RxRPC connection details */
1223 if (rxrpc_extract_header(sp
, skb
) < 0)
1226 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS
)) {
1228 if ((lose
++ & 7) == 7) {
1229 trace_rxrpc_rx_lose(sp
);
1230 rxrpc_free_skb(skb
, rxrpc_skb_lost
);
1235 if (skb
->tstamp
== 0)
1236 skb
->tstamp
= ktime_get_real();
1237 trace_rxrpc_rx_packet(sp
);
1239 switch (sp
->hdr
.type
) {
1240 case RXRPC_PACKET_TYPE_VERSION
:
1241 if (rxrpc_to_client(sp
))
1243 rxrpc_post_packet_to_local(local
, skb
);
1246 case RXRPC_PACKET_TYPE_BUSY
:
1247 if (rxrpc_to_server(sp
))
1250 case RXRPC_PACKET_TYPE_ACK
:
1251 case RXRPC_PACKET_TYPE_ACKALL
:
1252 if (sp
->hdr
.callNumber
== 0)
1255 case RXRPC_PACKET_TYPE_ABORT
:
1258 case RXRPC_PACKET_TYPE_DATA
:
1259 if (sp
->hdr
.callNumber
== 0 ||
1262 if (!rxrpc_validate_data(skb
))
1265 /* Unshare the packet so that it can be modified for in-place
1268 if (sp
->hdr
.securityIndex
!= 0) {
1269 struct sk_buff
*nskb
= skb_unshare(skb
, GFP_ATOMIC
);
1271 rxrpc_eaten_skb(skb
, rxrpc_skb_unshared_nomem
);
1276 rxrpc_eaten_skb(skb
, rxrpc_skb_received
);
1278 rxrpc_new_skb(skb
, rxrpc_skb_unshared
);
1279 sp
= rxrpc_skb(skb
);
1284 case RXRPC_PACKET_TYPE_CHALLENGE
:
1285 if (rxrpc_to_server(sp
))
1288 case RXRPC_PACKET_TYPE_RESPONSE
:
1289 if (rxrpc_to_client(sp
))
1293 /* Packet types 9-11 should just be ignored. */
1294 case RXRPC_PACKET_TYPE_PARAMS
:
1295 case RXRPC_PACKET_TYPE_10
:
1296 case RXRPC_PACKET_TYPE_11
:
1300 _proto("Rx Bad Packet Type %u", sp
->hdr
.type
);
1304 if (sp
->hdr
.serviceId
== 0)
1307 if (rxrpc_to_server(sp
)) {
1308 /* Weed out packets to services we're not offering. Packets
1309 * that would begin a call are explicitly rejected and the rest
1310 * are just discarded.
1312 rx
= rcu_dereference(local
->service
);
1313 if (!rx
|| (sp
->hdr
.serviceId
!= rx
->srx
.srx_service
&&
1314 sp
->hdr
.serviceId
!= rx
->second_service
)) {
1315 if (sp
->hdr
.type
== RXRPC_PACKET_TYPE_DATA
&&
1317 goto unsupported_service
;
1322 conn
= rxrpc_find_connection_rcu(local
, skb
, &peer
);
1324 if (sp
->hdr
.securityIndex
!= conn
->security_ix
)
1325 goto wrong_security
;
1327 if (sp
->hdr
.serviceId
!= conn
->service_id
) {
1330 if (!test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE
, &conn
->flags
))
1332 old_id
= cmpxchg(&conn
->service_id
, conn
->params
.service_id
,
1335 if (old_id
!= conn
->params
.service_id
&&
1336 old_id
!= sp
->hdr
.serviceId
)
1340 if (sp
->hdr
.callNumber
== 0) {
1341 /* Connection-level packet */
1342 _debug("CONN %p {%d}", conn
, conn
->debug_id
);
1343 rxrpc_post_packet_to_conn(conn
, skb
);
1347 if ((int)sp
->hdr
.serial
- (int)conn
->hi_serial
> 0)
1348 conn
->hi_serial
= sp
->hdr
.serial
;
1350 /* Call-bound packets are routed by connection channel. */
1351 channel
= sp
->hdr
.cid
& RXRPC_CHANNELMASK
;
1352 chan
= &conn
->channels
[channel
];
1354 /* Ignore really old calls */
1355 if (sp
->hdr
.callNumber
< chan
->last_call
)
1358 if (sp
->hdr
.callNumber
== chan
->last_call
) {
1360 sp
->hdr
.type
== RXRPC_PACKET_TYPE_ABORT
)
1363 /* For the previous service call, if completed
1364 * successfully, we discard all further packets.
1366 if (rxrpc_conn_is_service(conn
) &&
1367 chan
->last_type
== RXRPC_PACKET_TYPE_ACK
)
1370 /* But otherwise we need to retransmit the final packet
1371 * from data cached in the connection record.
1373 if (sp
->hdr
.type
== RXRPC_PACKET_TYPE_DATA
)
1374 trace_rxrpc_rx_data(chan
->call_debug_id
,
1378 rxrpc_post_packet_to_conn(conn
, skb
);
1382 call
= rcu_dereference(chan
->call
);
1384 if (sp
->hdr
.callNumber
> chan
->call_id
) {
1385 if (rxrpc_to_client(sp
))
1388 rxrpc_input_implicit_end_call(rx
, conn
, call
);
1393 if (sp
->hdr
.serviceId
!= call
->service_id
)
1394 call
->service_id
= sp
->hdr
.serviceId
;
1395 if ((int)sp
->hdr
.serial
- (int)call
->rx_serial
> 0)
1396 call
->rx_serial
= sp
->hdr
.serial
;
1397 if (!test_bit(RXRPC_CALL_RX_HEARD
, &call
->flags
))
1398 set_bit(RXRPC_CALL_RX_HEARD
, &call
->flags
);
1402 if (!call
|| atomic_read(&call
->usage
) == 0) {
1403 if (rxrpc_to_client(sp
) ||
1404 sp
->hdr
.type
!= RXRPC_PACKET_TYPE_DATA
)
1406 if (sp
->hdr
.seq
!= 1)
1408 call
= rxrpc_new_incoming_call(local
, rx
, skb
);
1413 /* Process a call packet; this either discards or passes on the ref
1416 rxrpc_input_call_packet(call
, skb
);
1420 rxrpc_free_skb(skb
, rxrpc_skb_freed
);
1422 trace_rxrpc_rx_done(0, 0);
1426 trace_rxrpc_abort(0, "SEC", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1427 RXKADINCONSISTENCY
, EBADMSG
);
1428 skb
->priority
= RXKADINCONSISTENCY
;
1431 unsupported_service
:
1432 trace_rxrpc_abort(0, "INV", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1433 RX_INVALID_OPERATION
, EOPNOTSUPP
);
1434 skb
->priority
= RX_INVALID_OPERATION
;
1438 trace_rxrpc_abort(0, "UPG", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1439 RX_PROTOCOL_ERROR
, EBADMSG
);
1440 goto protocol_error
;
1443 trace_rxrpc_abort(0, "BAD", sp
->hdr
.cid
, sp
->hdr
.callNumber
, sp
->hdr
.seq
,
1444 RX_PROTOCOL_ERROR
, EBADMSG
);
1446 skb
->priority
= RX_PROTOCOL_ERROR
;
1448 skb
->mark
= RXRPC_SKB_MARK_REJECT_ABORT
;
1450 trace_rxrpc_rx_done(skb
->mark
, skb
->priority
);
1451 rxrpc_reject_packet(local
, skb
);
1452 _leave(" [badmsg]");