1 /* SCTP kernel implementation
2 * (C) Copyright IBM Corp. 2001, 2004
3 * Copyright (c) 1999-2000 Cisco, Inc.
4 * Copyright (c) 1999-2001 Motorola, Inc.
6 * This file is part of the SCTP kernel implementation
8 * These functions handle output processing.
10 * This SCTP implementation is free software;
11 * you can redistribute it and/or modify it under the terms of
12 * the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
16 * This SCTP implementation is distributed in the hope that it
17 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
18 * ************************
19 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
20 * See the GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with GNU CC; see the file COPYING. If not, see
24 * <http://www.gnu.org/licenses/>.
26 * Please send any bug reports or fixes you make to the
28 * lksctp developers <linux-sctp@vger.kernel.org>
30 * Written or modified by:
31 * La Monte H.P. Yarroll <piggy@acm.org>
32 * Karl Knutson <karl@athena.chicago.il.us>
33 * Jon Grimm <jgrimm@austin.ibm.com>
34 * Sridhar Samudrala <sri@us.ibm.com>
37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
39 #include <linux/types.h>
40 #include <linux/kernel.h>
41 #include <linux/wait.h>
42 #include <linux/time.h>
44 #include <linux/ipv6.h>
45 #include <linux/init.h>
46 #include <linux/slab.h>
47 #include <net/inet_ecn.h>
50 #include <net/net_namespace.h>
52 #include <linux/socket.h> /* for sa_family_t */
55 #include <net/sctp/sctp.h>
56 #include <net/sctp/sm.h>
57 #include <net/sctp/checksum.h>
59 /* Forward declarations for private helpers. */
60 static enum sctp_xmit
__sctp_packet_append_chunk(struct sctp_packet
*packet
,
61 struct sctp_chunk
*chunk
);
62 static enum sctp_xmit
sctp_packet_can_append_data(struct sctp_packet
*packet
,
63 struct sctp_chunk
*chunk
);
64 static void sctp_packet_append_data(struct sctp_packet
*packet
,
65 struct sctp_chunk
*chunk
);
66 static enum sctp_xmit
sctp_packet_will_fit(struct sctp_packet
*packet
,
67 struct sctp_chunk
*chunk
,
70 static void sctp_packet_reset(struct sctp_packet
*packet
)
72 packet
->size
= packet
->overhead
;
73 packet
->has_cookie_echo
= 0;
82 * This appears to be a followup set of initializations.
84 void sctp_packet_config(struct sctp_packet
*packet
, __u32 vtag
,
87 struct sctp_transport
*tp
= packet
->transport
;
88 struct sctp_association
*asoc
= tp
->asoc
;
91 pr_debug("%s: packet:%p vtag:0x%x\n", __func__
, packet
, vtag
);
94 /* do the following jobs only once for a flush schedule */
95 if (!sctp_packet_empty(packet
))
98 /* set packet max_size with pathmtu */
99 packet
->max_size
= tp
->pathmtu
;
103 /* update dst or transport pathmtu if in need */
105 if (!sctp_transport_dst_check(tp
)) {
106 sctp_transport_route(tp
, NULL
, sctp_sk(sk
));
107 if (asoc
->param_flags
& SPP_PMTUD_ENABLE
)
108 sctp_assoc_sync_pmtu(asoc
);
109 } else if (!sctp_transport_pmtu_check(tp
)) {
110 if (asoc
->param_flags
& SPP_PMTUD_ENABLE
)
111 sctp_assoc_sync_pmtu(asoc
);
114 /* If there a is a prepend chunk stick it on the list before
115 * any other chunks get appended.
118 struct sctp_chunk
*chunk
= sctp_get_ecne_prepend(asoc
);
121 sctp_packet_append_chunk(packet
, chunk
);
127 /* set packet max_size with gso_max_size if gso is enabled*/
129 if (__sk_dst_get(sk
) != tp
->dst
) {
131 sk_setup_caps(sk
, tp
->dst
);
133 packet
->max_size
= sk_can_gso(sk
) ? tp
->dst
->dev
->gso_max_size
138 /* Initialize the packet structure. */
139 void sctp_packet_init(struct sctp_packet
*packet
,
140 struct sctp_transport
*transport
,
141 __u16 sport
, __u16 dport
)
143 struct sctp_association
*asoc
= transport
->asoc
;
146 pr_debug("%s: packet:%p transport:%p\n", __func__
, packet
, transport
);
148 packet
->transport
= transport
;
149 packet
->source_port
= sport
;
150 packet
->destination_port
= dport
;
151 INIT_LIST_HEAD(&packet
->chunk_list
);
153 struct sctp_sock
*sp
= sctp_sk(asoc
->base
.sk
);
154 overhead
= sp
->pf
->af
->net_header_len
;
156 overhead
= sizeof(struct ipv6hdr
);
158 overhead
+= sizeof(struct sctphdr
);
159 packet
->overhead
= overhead
;
160 sctp_packet_reset(packet
);
165 void sctp_packet_free(struct sctp_packet
*packet
)
167 struct sctp_chunk
*chunk
, *tmp
;
169 pr_debug("%s: packet:%p\n", __func__
, packet
);
171 list_for_each_entry_safe(chunk
, tmp
, &packet
->chunk_list
, list
) {
172 list_del_init(&chunk
->list
);
173 sctp_chunk_free(chunk
);
177 /* This routine tries to append the chunk to the offered packet. If adding
178 * the chunk causes the packet to exceed the path MTU and COOKIE_ECHO chunk
179 * is not present in the packet, it transmits the input packet.
180 * Data can be bundled with a packet containing a COOKIE_ECHO chunk as long
181 * as it can fit in the packet, but any more data that does not fit in this
182 * packet can be sent only after receiving the COOKIE_ACK.
184 enum sctp_xmit
sctp_packet_transmit_chunk(struct sctp_packet
*packet
,
185 struct sctp_chunk
*chunk
,
186 int one_packet
, gfp_t gfp
)
188 enum sctp_xmit retval
;
190 pr_debug("%s: packet:%p size:%zu chunk:%p size:%d\n", __func__
,
191 packet
, packet
->size
, chunk
, chunk
->skb
? chunk
->skb
->len
: -1);
193 switch ((retval
= (sctp_packet_append_chunk(packet
, chunk
)))) {
194 case SCTP_XMIT_PMTU_FULL
:
195 if (!packet
->has_cookie_echo
) {
198 error
= sctp_packet_transmit(packet
, gfp
);
200 chunk
->skb
->sk
->sk_err
= -error
;
202 /* If we have an empty packet, then we can NOT ever
206 retval
= sctp_packet_append_chunk(packet
,
211 case SCTP_XMIT_RWND_FULL
:
213 case SCTP_XMIT_DELAY
:
220 /* Try to bundle an auth chunk into the packet. */
221 static enum sctp_xmit
sctp_packet_bundle_auth(struct sctp_packet
*pkt
,
222 struct sctp_chunk
*chunk
)
224 struct sctp_association
*asoc
= pkt
->transport
->asoc
;
225 enum sctp_xmit retval
= SCTP_XMIT_OK
;
226 struct sctp_chunk
*auth
;
228 /* if we don't have an association, we can't do authentication */
232 /* See if this is an auth chunk we are bundling or if
233 * auth is already bundled.
235 if (chunk
->chunk_hdr
->type
== SCTP_CID_AUTH
|| pkt
->has_auth
)
238 /* if the peer did not request this chunk to be authenticated,
244 auth
= sctp_make_auth(asoc
);
248 retval
= __sctp_packet_append_chunk(pkt
, auth
);
250 if (retval
!= SCTP_XMIT_OK
)
251 sctp_chunk_free(auth
);
256 /* Try to bundle a SACK with the packet. */
257 static enum sctp_xmit
sctp_packet_bundle_sack(struct sctp_packet
*pkt
,
258 struct sctp_chunk
*chunk
)
260 enum sctp_xmit retval
= SCTP_XMIT_OK
;
262 /* If sending DATA and haven't aleady bundled a SACK, try to
263 * bundle one in to the packet.
265 if (sctp_chunk_is_data(chunk
) && !pkt
->has_sack
&&
266 !pkt
->has_cookie_echo
) {
267 struct sctp_association
*asoc
;
268 struct timer_list
*timer
;
269 asoc
= pkt
->transport
->asoc
;
270 timer
= &asoc
->timers
[SCTP_EVENT_TIMEOUT_SACK
];
272 /* If the SACK timer is running, we have a pending SACK */
273 if (timer_pending(timer
)) {
274 struct sctp_chunk
*sack
;
276 if (pkt
->transport
->sack_generation
!=
277 pkt
->transport
->asoc
->peer
.sack_generation
)
280 asoc
->a_rwnd
= asoc
->rwnd
;
281 sack
= sctp_make_sack(asoc
);
283 retval
= __sctp_packet_append_chunk(pkt
, sack
);
284 if (retval
!= SCTP_XMIT_OK
) {
285 sctp_chunk_free(sack
);
288 asoc
->peer
.sack_needed
= 0;
289 if (del_timer(timer
))
290 sctp_association_put(asoc
);
299 /* Append a chunk to the offered packet reporting back any inability to do
302 static enum sctp_xmit
__sctp_packet_append_chunk(struct sctp_packet
*packet
,
303 struct sctp_chunk
*chunk
)
305 __u16 chunk_len
= SCTP_PAD4(ntohs(chunk
->chunk_hdr
->length
));
306 enum sctp_xmit retval
= SCTP_XMIT_OK
;
308 /* Check to see if this chunk will fit into the packet */
309 retval
= sctp_packet_will_fit(packet
, chunk
, chunk_len
);
310 if (retval
!= SCTP_XMIT_OK
)
313 /* We believe that this chunk is OK to add to the packet */
314 switch (chunk
->chunk_hdr
->type
) {
316 /* Account for the data being in the packet */
317 sctp_packet_append_data(packet
, chunk
);
318 /* Disallow SACK bundling after DATA. */
319 packet
->has_sack
= 1;
320 /* Disallow AUTH bundling after DATA */
321 packet
->has_auth
= 1;
322 /* Let it be knows that packet has DATA in it */
323 packet
->has_data
= 1;
324 /* timestamp the chunk for rtx purposes */
325 chunk
->sent_at
= jiffies
;
326 /* Mainly used for prsctp RTX policy */
329 case SCTP_CID_COOKIE_ECHO
:
330 packet
->has_cookie_echo
= 1;
334 packet
->has_sack
= 1;
336 chunk
->asoc
->stats
.osacks
++;
340 packet
->has_auth
= 1;
341 packet
->auth
= chunk
;
345 /* It is OK to send this chunk. */
346 list_add_tail(&chunk
->list
, &packet
->chunk_list
);
347 packet
->size
+= chunk_len
;
348 chunk
->transport
= packet
->transport
;
353 /* Append a chunk to the offered packet reporting back any inability to do
356 enum sctp_xmit
sctp_packet_append_chunk(struct sctp_packet
*packet
,
357 struct sctp_chunk
*chunk
)
359 enum sctp_xmit retval
= SCTP_XMIT_OK
;
361 pr_debug("%s: packet:%p chunk:%p\n", __func__
, packet
, chunk
);
363 /* Data chunks are special. Before seeing what else we can
364 * bundle into this packet, check to see if we are allowed to
367 if (sctp_chunk_is_data(chunk
)) {
368 retval
= sctp_packet_can_append_data(packet
, chunk
);
369 if (retval
!= SCTP_XMIT_OK
)
373 /* Try to bundle AUTH chunk */
374 retval
= sctp_packet_bundle_auth(packet
, chunk
);
375 if (retval
!= SCTP_XMIT_OK
)
378 /* Try to bundle SACK chunk */
379 retval
= sctp_packet_bundle_sack(packet
, chunk
);
380 if (retval
!= SCTP_XMIT_OK
)
383 retval
= __sctp_packet_append_chunk(packet
, chunk
);
389 static void sctp_packet_release_owner(struct sk_buff
*skb
)
394 static void sctp_packet_set_owner_w(struct sk_buff
*skb
, struct sock
*sk
)
398 skb
->destructor
= sctp_packet_release_owner
;
401 * The data chunks have already been accounted for in sctp_sendmsg(),
402 * therefore only reserve a single byte to keep socket around until
403 * the packet has been transmitted.
405 refcount_inc(&sk
->sk_wmem_alloc
);
408 static int sctp_packet_pack(struct sctp_packet
*packet
,
409 struct sk_buff
*head
, int gso
, gfp_t gfp
)
411 struct sctp_transport
*tp
= packet
->transport
;
412 struct sctp_auth_chunk
*auth
= NULL
;
413 struct sctp_chunk
*chunk
, *tmp
;
414 int pkt_count
= 0, pkt_size
;
415 struct sock
*sk
= head
->sk
;
416 struct sk_buff
*nskb
;
420 skb_shinfo(head
)->gso_type
= sk
->sk_gso_type
;
421 NAPI_GRO_CB(head
)->last
= head
;
424 pkt_size
= packet
->size
;
429 /* calculate the pkt_size and alloc nskb */
430 pkt_size
= packet
->overhead
;
431 list_for_each_entry_safe(chunk
, tmp
, &packet
->chunk_list
,
433 int padded
= SCTP_PAD4(chunk
->skb
->len
);
435 if (chunk
== packet
->auth
)
437 else if (auth_len
+ padded
+ packet
->overhead
>
440 else if (pkt_size
+ padded
> tp
->pathmtu
)
444 nskb
= alloc_skb(pkt_size
+ MAX_HEADER
, gfp
);
447 skb_reserve(nskb
, packet
->overhead
+ MAX_HEADER
);
450 /* merge chunks into nskb and append nskb into head list */
451 pkt_size
-= packet
->overhead
;
452 list_for_each_entry_safe(chunk
, tmp
, &packet
->chunk_list
, list
) {
455 list_del_init(&chunk
->list
);
456 if (sctp_chunk_is_data(chunk
)) {
457 if (!sctp_chunk_retransmitted(chunk
) &&
459 chunk
->rtt_in_progress
= 1;
464 padding
= SCTP_PAD4(chunk
->skb
->len
) - chunk
->skb
->len
;
466 skb_put_zero(chunk
->skb
, padding
);
468 if (chunk
== packet
->auth
)
469 auth
= (struct sctp_auth_chunk
*)
470 skb_tail_pointer(nskb
);
472 skb_put_data(nskb
, chunk
->skb
->data
, chunk
->skb
->len
);
474 pr_debug("*** Chunk:%p[%s] %s 0x%x, length:%d, chunk->skb->len:%d, rtt_in_progress:%d\n",
476 sctp_cname(SCTP_ST_CHUNK(chunk
->chunk_hdr
->type
)),
477 chunk
->has_tsn
? "TSN" : "No TSN",
478 chunk
->has_tsn
? ntohl(chunk
->subh
.data_hdr
->tsn
) : 0,
479 ntohs(chunk
->chunk_hdr
->length
), chunk
->skb
->len
,
480 chunk
->rtt_in_progress
);
482 pkt_size
-= SCTP_PAD4(chunk
->skb
->len
);
484 if (!sctp_chunk_is_data(chunk
) && chunk
!= packet
->auth
)
485 sctp_chunk_free(chunk
);
492 sctp_auth_calculate_hmac(tp
->asoc
, nskb
, auth
, gfp
);
493 /* free auth if no more chunks, or add it back */
494 if (list_empty(&packet
->chunk_list
))
495 sctp_chunk_free(packet
->auth
);
497 list_add(&packet
->auth
->list
,
498 &packet
->chunk_list
);
502 if (skb_gro_receive(&head
, nskb
)) {
506 if (WARN_ON_ONCE(skb_shinfo(head
)->gso_segs
>=
507 sk
->sk_gso_max_segs
))
512 } while (!list_empty(&packet
->chunk_list
));
515 memset(head
->cb
, 0, max(sizeof(struct inet_skb_parm
),
516 sizeof(struct inet6_skb_parm
)));
517 skb_shinfo(head
)->gso_segs
= pkt_count
;
518 skb_shinfo(head
)->gso_size
= GSO_BY_FRAGS
;
520 if (skb_dst(head
) != tp
->dst
) {
522 sk_setup_caps(sk
, tp
->dst
);
528 if (sctp_checksum_disable
)
531 if (!(skb_dst(head
)->dev
->features
& NETIF_F_SCTP_CRC
) ||
532 dst_xfrm(skb_dst(head
)) || packet
->ipfragok
) {
534 (struct sctphdr
*)skb_transport_header(head
);
536 sh
->checksum
= sctp_compute_cksum(head
, 0);
539 head
->ip_summed
= CHECKSUM_PARTIAL
;
540 head
->csum_not_inet
= 1;
541 head
->csum_start
= skb_transport_header(head
) - head
->head
;
542 head
->csum_offset
= offsetof(struct sctphdr
, checksum
);
548 /* All packets are sent to the network through this function from
551 * The return value is always 0 for now.
553 int sctp_packet_transmit(struct sctp_packet
*packet
, gfp_t gfp
)
555 struct sctp_transport
*tp
= packet
->transport
;
556 struct sctp_association
*asoc
= tp
->asoc
;
557 struct sctp_chunk
*chunk
, *tmp
;
558 int pkt_count
, gso
= 0;
559 struct dst_entry
*dst
;
560 struct sk_buff
*head
;
564 pr_debug("%s: packet:%p\n", __func__
, packet
);
565 if (list_empty(&packet
->chunk_list
))
567 chunk
= list_entry(packet
->chunk_list
.next
, struct sctp_chunk
, list
);
571 if (packet
->size
> tp
->pathmtu
&& !packet
->ipfragok
) {
572 if (!sk_can_gso(sk
)) {
573 pr_err_once("Trying to GSO but underlying device doesn't support it.");
580 head
= alloc_skb((gso
? packet
->overhead
: packet
->size
) +
584 skb_reserve(head
, packet
->overhead
+ MAX_HEADER
);
585 sctp_packet_set_owner_w(head
, sk
);
587 /* set sctp header */
588 sh
= skb_push(head
, sizeof(struct sctphdr
));
589 skb_reset_transport_header(head
);
590 sh
->source
= htons(packet
->source_port
);
591 sh
->dest
= htons(packet
->destination_port
);
592 sh
->vtag
= htonl(packet
->vtag
);
595 /* drop packet if no dst */
596 dst
= dst_clone(tp
->dst
);
598 IP_INC_STATS(sock_net(sk
), IPSTATS_MIB_OUTNOROUTES
);
602 skb_dst_set(head
, dst
);
605 pkt_count
= sctp_packet_pack(packet
, head
, gso
, gfp
);
610 pr_debug("***sctp_transmit_packet*** skb->len:%d\n", head
->len
);
612 /* start autoclose timer */
613 if (packet
->has_data
&& sctp_state(asoc
, ESTABLISHED
) &&
614 asoc
->timeouts
[SCTP_EVENT_TIMEOUT_AUTOCLOSE
]) {
615 struct timer_list
*timer
=
616 &asoc
->timers
[SCTP_EVENT_TIMEOUT_AUTOCLOSE
];
617 unsigned long timeout
=
618 asoc
->timeouts
[SCTP_EVENT_TIMEOUT_AUTOCLOSE
];
620 if (!mod_timer(timer
, jiffies
+ timeout
))
621 sctp_association_hold(asoc
);
625 tp
->af_specific
->ecn_capable(sk
);
627 asoc
->stats
.opackets
+= pkt_count
;
628 if (asoc
->peer
.last_sent_to
!= tp
)
629 asoc
->peer
.last_sent_to
= tp
;
631 head
->ignore_df
= packet
->ipfragok
;
632 if (tp
->dst_pending_confirm
)
633 skb_set_dst_pending_confirm(head
, 1);
634 /* neighbour should be confirmed on successful transmission or
637 if (tp
->af_specific
->sctp_xmit(head
, tp
) >= 0 &&
638 tp
->dst_pending_confirm
)
639 tp
->dst_pending_confirm
= 0;
642 list_for_each_entry_safe(chunk
, tmp
, &packet
->chunk_list
, list
) {
643 list_del_init(&chunk
->list
);
644 if (!sctp_chunk_is_data(chunk
))
645 sctp_chunk_free(chunk
);
647 sctp_packet_reset(packet
);
651 /********************************************************************
652 * 2nd Level Abstractions
653 ********************************************************************/
655 /* This private function check to see if a chunk can be added */
656 static enum sctp_xmit
sctp_packet_can_append_data(struct sctp_packet
*packet
,
657 struct sctp_chunk
*chunk
)
659 size_t datasize
, rwnd
, inflight
, flight_size
;
660 struct sctp_transport
*transport
= packet
->transport
;
661 struct sctp_association
*asoc
= transport
->asoc
;
662 struct sctp_outq
*q
= &asoc
->outqueue
;
664 /* RFC 2960 6.1 Transmission of DATA Chunks
666 * A) At any given time, the data sender MUST NOT transmit new data to
667 * any destination transport address if its peer's rwnd indicates
668 * that the peer has no buffer space (i.e. rwnd is 0, see Section
669 * 6.2.1). However, regardless of the value of rwnd (including if it
670 * is 0), the data sender can always have one DATA chunk in flight to
671 * the receiver if allowed by cwnd (see rule B below). This rule
672 * allows the sender to probe for a change in rwnd that the sender
673 * missed due to the SACK having been lost in transit from the data
674 * receiver to the data sender.
677 rwnd
= asoc
->peer
.rwnd
;
678 inflight
= q
->outstanding_bytes
;
679 flight_size
= transport
->flight_size
;
681 datasize
= sctp_data_size(chunk
);
683 if (datasize
> rwnd
&& inflight
> 0)
684 /* We have (at least) one data chunk in flight,
685 * so we can't fall back to rule 6.1 B).
687 return SCTP_XMIT_RWND_FULL
;
689 /* RFC 2960 6.1 Transmission of DATA Chunks
691 * B) At any given time, the sender MUST NOT transmit new data
692 * to a given transport address if it has cwnd or more bytes
693 * of data outstanding to that transport address.
695 /* RFC 7.2.4 & the Implementers Guide 2.8.
698 * When a Fast Retransmit is being performed the sender SHOULD
699 * ignore the value of cwnd and SHOULD NOT delay retransmission.
701 if (chunk
->fast_retransmit
!= SCTP_NEED_FRTX
&&
702 flight_size
>= transport
->cwnd
)
703 return SCTP_XMIT_RWND_FULL
;
705 /* Nagle's algorithm to solve small-packet problem:
706 * Inhibit the sending of new chunks when new outgoing data arrives
707 * if any previously transmitted data on the connection remains
711 if ((sctp_sk(asoc
->base
.sk
)->nodelay
|| inflight
== 0) &&
713 /* Nothing unacked */
716 if (!sctp_packet_empty(packet
))
717 /* Append to packet */
720 if (!sctp_state(asoc
, ESTABLISHED
))
723 /* Check whether this chunk and all the rest of pending data will fit
724 * or delay in hopes of bundling a full sized packet.
726 if (chunk
->skb
->len
+ q
->out_qlen
> transport
->pathmtu
-
727 packet
->overhead
- sizeof(struct sctp_data_chunk
) - 4)
728 /* Enough data queued to fill a packet */
731 /* Don't delay large message writes that may have been fragmented */
732 if (!chunk
->msg
->can_delay
)
735 /* Defer until all data acked or packet full */
736 return SCTP_XMIT_DELAY
;
739 /* This private function does management things when adding DATA chunk */
740 static void sctp_packet_append_data(struct sctp_packet
*packet
,
741 struct sctp_chunk
*chunk
)
743 struct sctp_transport
*transport
= packet
->transport
;
744 size_t datasize
= sctp_data_size(chunk
);
745 struct sctp_association
*asoc
= transport
->asoc
;
746 u32 rwnd
= asoc
->peer
.rwnd
;
748 /* Keep track of how many bytes are in flight over this transport. */
749 transport
->flight_size
+= datasize
;
751 /* Keep track of how many bytes are in flight to the receiver. */
752 asoc
->outqueue
.outstanding_bytes
+= datasize
;
754 /* Update our view of the receiver's rwnd. */
760 asoc
->peer
.rwnd
= rwnd
;
761 sctp_chunk_assign_tsn(chunk
);
762 sctp_chunk_assign_ssn(chunk
);
765 static enum sctp_xmit
sctp_packet_will_fit(struct sctp_packet
*packet
,
766 struct sctp_chunk
*chunk
,
769 enum sctp_xmit retval
= SCTP_XMIT_OK
;
770 size_t psize
, pmtu
, maxsize
;
772 psize
= packet
->size
;
773 if (packet
->transport
->asoc
)
774 pmtu
= packet
->transport
->asoc
->pathmtu
;
776 pmtu
= packet
->transport
->pathmtu
;
778 /* Decide if we need to fragment or resubmit later. */
779 if (psize
+ chunk_len
> pmtu
) {
780 /* It's OK to fragment at IP level if any one of the following
782 * 1. The packet is empty (meaning this chunk is greater
784 * 2. The packet doesn't have any data in it yet and data
785 * requires authentication.
787 if (sctp_packet_empty(packet
) ||
788 (!packet
->has_data
&& chunk
->auth
)) {
789 /* We no longer do re-fragmentation.
790 * Just fragment at the IP layer, if we
791 * actually hit this condition
793 packet
->ipfragok
= 1;
797 /* Similarly, if this chunk was built before a PMTU
798 * reduction, we have to fragment it at IP level now. So
799 * if the packet already contains something, we need to
802 maxsize
= pmtu
- packet
->overhead
;
804 maxsize
-= SCTP_PAD4(packet
->auth
->skb
->len
);
805 if (chunk_len
> maxsize
)
806 retval
= SCTP_XMIT_PMTU_FULL
;
808 /* It is also okay to fragment if the chunk we are
809 * adding is a control chunk, but only if current packet
810 * is not a GSO one otherwise it causes fragmentation of
811 * a large frame. So in this case we allow the
812 * fragmentation by forcing it to be in a new packet.
814 if (!sctp_chunk_is_data(chunk
) && packet
->has_data
)
815 retval
= SCTP_XMIT_PMTU_FULL
;
817 if (psize
+ chunk_len
> packet
->max_size
)
818 /* Hit GSO/PMTU limit, gotta flush */
819 retval
= SCTP_XMIT_PMTU_FULL
;
821 if (!packet
->transport
->burst_limited
&&
822 psize
+ chunk_len
> (packet
->transport
->cwnd
>> 1))
823 /* Do not allow a single GSO packet to use more
826 retval
= SCTP_XMIT_PMTU_FULL
;
828 if (packet
->transport
->burst_limited
&&
829 psize
+ chunk_len
> (packet
->transport
->burst_limited
>> 1))
830 /* Do not allow a single GSO packet to use more
831 * than half of original cwnd.
833 retval
= SCTP_XMIT_PMTU_FULL
;
834 /* Otherwise it will fit in the GSO packet */