160c778b2SVlad Yasevich /* SCTP kernel implementation 21da177e4SLinus Torvalds * (C) Copyright IBM Corp. 2001, 2004 31da177e4SLinus Torvalds * Copyright (c) 1999-2000 Cisco, Inc. 41da177e4SLinus Torvalds * Copyright (c) 1999-2001 Motorola, Inc. 51da177e4SLinus Torvalds * Copyright (c) 2001 Intel Corp. 61da177e4SLinus Torvalds * Copyright (c) 2001 Nokia, Inc. 71da177e4SLinus Torvalds * Copyright (c) 2001 La Monte H.P. Yarroll 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * This abstraction carries sctp events to the ULP (sockets). 101da177e4SLinus Torvalds * 1160c778b2SVlad Yasevich * This SCTP implementation is free software; 121da177e4SLinus Torvalds * you can redistribute it and/or modify it under the terms of 131da177e4SLinus Torvalds * the GNU General Public License as published by 141da177e4SLinus Torvalds * the Free Software Foundation; either version 2, or (at your option) 151da177e4SLinus Torvalds * any later version. 161da177e4SLinus Torvalds * 1760c778b2SVlad Yasevich * This SCTP implementation is distributed in the hope that it 181da177e4SLinus Torvalds * will be useful, but WITHOUT ANY WARRANTY; without even the implied 191da177e4SLinus Torvalds * ************************ 201da177e4SLinus Torvalds * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 211da177e4SLinus Torvalds * See the GNU General Public License for more details. 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 244b2f13a2SJeff Kirsher * along with GNU CC; see the file COPYING. If not, see 254b2f13a2SJeff Kirsher * <http://www.gnu.org/licenses/>. 261da177e4SLinus Torvalds * 271da177e4SLinus Torvalds * Please send any bug reports or fixes you make to the 281da177e4SLinus Torvalds * email address(es): 2991705c61SDaniel Borkmann * lksctp developers <linux-sctp@vger.kernel.org> 301da177e4SLinus Torvalds * 311da177e4SLinus Torvalds * Written or modified by: 321da177e4SLinus Torvalds * Jon Grimm <jgrimm@us.ibm.com> 331da177e4SLinus Torvalds * La Monte H.P. Yarroll <piggy@acm.org> 341da177e4SLinus Torvalds * Sridhar Samudrala <sri@us.ibm.com> 351da177e4SLinus Torvalds */ 361da177e4SLinus Torvalds 375a0e3ad6STejun Heo #include <linux/slab.h> 381da177e4SLinus Torvalds #include <linux/types.h> 391da177e4SLinus Torvalds #include <linux/skbuff.h> 401da177e4SLinus Torvalds #include <net/sock.h> 418465a5fcSNeil Horman #include <net/busy_poll.h> 421da177e4SLinus Torvalds #include <net/sctp/structs.h> 431da177e4SLinus Torvalds #include <net/sctp/sctp.h> 441da177e4SLinus Torvalds #include <net/sctp/sm.h> 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds /* Forward declarations for internal helpers. */ 471da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq, 481da177e4SLinus Torvalds struct sctp_ulpevent *); 491da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *, 501da177e4SLinus Torvalds struct sctp_ulpevent *); 51ef5d4cf2SVlad Yasevich static void sctp_ulpq_reasm_drain(struct sctp_ulpq *ulpq); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds /* 1st Level Abstractions */ 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds /* Initialize a ULP queue from a block of memory. */ 561da177e4SLinus Torvalds struct sctp_ulpq *sctp_ulpq_init(struct sctp_ulpq *ulpq, 571da177e4SLinus Torvalds struct sctp_association *asoc) 581da177e4SLinus Torvalds { 591da177e4SLinus Torvalds memset(ulpq, 0, sizeof(struct sctp_ulpq)); 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds ulpq->asoc = asoc; 621da177e4SLinus Torvalds skb_queue_head_init(&ulpq->reasm); 631da177e4SLinus Torvalds skb_queue_head_init(&ulpq->lobby); 641da177e4SLinus Torvalds ulpq->pd_mode = 0; 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds return ulpq; 671da177e4SLinus Torvalds } 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /* Flush the reassembly and ordering queues. */ 710b58a811SVlad Yasevich void sctp_ulpq_flush(struct sctp_ulpq *ulpq) 721da177e4SLinus Torvalds { 731da177e4SLinus Torvalds struct sk_buff *skb; 741da177e4SLinus Torvalds struct sctp_ulpevent *event; 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds while ((skb = __skb_dequeue(&ulpq->lobby)) != NULL) { 771da177e4SLinus Torvalds event = sctp_skb2event(skb); 781da177e4SLinus Torvalds sctp_ulpevent_free(event); 791da177e4SLinus Torvalds } 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds while ((skb = __skb_dequeue(&ulpq->reasm)) != NULL) { 821da177e4SLinus Torvalds event = sctp_skb2event(skb); 831da177e4SLinus Torvalds sctp_ulpevent_free(event); 841da177e4SLinus Torvalds } 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds } 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds /* Dispose of a ulpqueue. */ 891da177e4SLinus Torvalds void sctp_ulpq_free(struct sctp_ulpq *ulpq) 901da177e4SLinus Torvalds { 911da177e4SLinus Torvalds sctp_ulpq_flush(ulpq); 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* Process an incoming DATA chunk. */ 951da177e4SLinus Torvalds int sctp_ulpq_tail_data(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 96dd0fc66fSAl Viro gfp_t gfp) 971da177e4SLinus Torvalds { 981da177e4SLinus Torvalds struct sk_buff_head temp; 991da177e4SLinus Torvalds struct sctp_ulpevent *event; 100d003b41bSLee A. Roberts int event_eor = 0; 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds /* Create an event from the incoming chunk. */ 1031da177e4SLinus Torvalds event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp); 1041da177e4SLinus Torvalds if (!event) 1051da177e4SLinus Torvalds return -ENOMEM; 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds /* Do reassembly if needed. */ 1081da177e4SLinus Torvalds event = sctp_ulpq_reasm(ulpq, event); 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds /* Do ordering if needed. */ 1111da177e4SLinus Torvalds if ((event) && (event->msg_flags & MSG_EOR)) { 1121da177e4SLinus Torvalds /* Create a temporary list to collect chunks on. */ 1131da177e4SLinus Torvalds skb_queue_head_init(&temp); 1141da177e4SLinus Torvalds __skb_queue_tail(&temp, sctp_event2skb(event)); 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds event = sctp_ulpq_order(ulpq, event); 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1198728b834SDavid S. Miller /* Send event to the ULP. 'event' is the sctp_ulpevent for 1208728b834SDavid S. Miller * very first SKB on the 'temp' list. 1218728b834SDavid S. Miller */ 122d003b41bSLee A. Roberts if (event) { 123d003b41bSLee A. Roberts event_eor = (event->msg_flags & MSG_EOR) ? 1 : 0; 1241da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 125d003b41bSLee A. Roberts } 1261da177e4SLinus Torvalds 127d003b41bSLee A. Roberts return event_eor; 1281da177e4SLinus Torvalds } 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds /* Add a new event for propagation to the ULP. */ 1311da177e4SLinus Torvalds /* Clear the partial delivery mode for this socket. Note: This 1321da177e4SLinus Torvalds * assumes that no association is currently in partial delivery mode. 1331da177e4SLinus Torvalds */ 134b6e1331fSVlad Yasevich int sctp_clear_pd(struct sock *sk, struct sctp_association *asoc) 1351da177e4SLinus Torvalds { 1361da177e4SLinus Torvalds struct sctp_sock *sp = sctp_sk(sk); 1371da177e4SLinus Torvalds 138b6e1331fSVlad Yasevich if (atomic_dec_and_test(&sp->pd_mode)) { 139b6e1331fSVlad Yasevich /* This means there are no other associations in PD, so 140b6e1331fSVlad Yasevich * we can go ahead and clear out the lobby in one shot 141b6e1331fSVlad Yasevich */ 1421da177e4SLinus Torvalds if (!skb_queue_empty(&sp->pd_lobby)) { 1431da177e4SLinus Torvalds struct list_head *list; 144311b2177SMarcelo Ricardo Leitner skb_queue_splice_tail_init(&sp->pd_lobby, 145311b2177SMarcelo Ricardo Leitner &sk->sk_receive_queue); 1461da177e4SLinus Torvalds list = (struct list_head *)&sctp_sk(sk)->pd_lobby; 1471da177e4SLinus Torvalds INIT_LIST_HEAD(list); 1481da177e4SLinus Torvalds return 1; 1491da177e4SLinus Torvalds } 150b6e1331fSVlad Yasevich } else { 151b6e1331fSVlad Yasevich /* There are other associations in PD, so we only need to 152b6e1331fSVlad Yasevich * pull stuff out of the lobby that belongs to the 153b6e1331fSVlad Yasevich * associations that is exiting PD (all of its notifications 154b6e1331fSVlad Yasevich * are posted here). 155b6e1331fSVlad Yasevich */ 156b6e1331fSVlad Yasevich if (!skb_queue_empty(&sp->pd_lobby) && asoc) { 157b6e1331fSVlad Yasevich struct sk_buff *skb, *tmp; 158b6e1331fSVlad Yasevich struct sctp_ulpevent *event; 159b6e1331fSVlad Yasevich 160b6e1331fSVlad Yasevich sctp_skb_for_each(skb, &sp->pd_lobby, tmp) { 161b6e1331fSVlad Yasevich event = sctp_skb2event(skb); 162b6e1331fSVlad Yasevich if (event->asoc == asoc) { 163b6e1331fSVlad Yasevich __skb_unlink(skb, &sp->pd_lobby); 164b6e1331fSVlad Yasevich __skb_queue_tail(&sk->sk_receive_queue, 165b6e1331fSVlad Yasevich skb); 166b6e1331fSVlad Yasevich } 167b6e1331fSVlad Yasevich } 168b6e1331fSVlad Yasevich } 169b6e1331fSVlad Yasevich } 170b6e1331fSVlad Yasevich 1711da177e4SLinus Torvalds return 0; 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds 174d49d91d7SVlad Yasevich /* Set the pd_mode on the socket and ulpq */ 175d49d91d7SVlad Yasevich static void sctp_ulpq_set_pd(struct sctp_ulpq *ulpq) 176d49d91d7SVlad Yasevich { 177d49d91d7SVlad Yasevich struct sctp_sock *sp = sctp_sk(ulpq->asoc->base.sk); 178d49d91d7SVlad Yasevich 179d49d91d7SVlad Yasevich atomic_inc(&sp->pd_mode); 180d49d91d7SVlad Yasevich ulpq->pd_mode = 1; 181d49d91d7SVlad Yasevich } 182d49d91d7SVlad Yasevich 1831da177e4SLinus Torvalds /* Clear the pd_mode and restart any pending messages waiting for delivery. */ 1841da177e4SLinus Torvalds static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq) 1851da177e4SLinus Torvalds { 1861da177e4SLinus Torvalds ulpq->pd_mode = 0; 187ef5d4cf2SVlad Yasevich sctp_ulpq_reasm_drain(ulpq); 188b6e1331fSVlad Yasevich return sctp_clear_pd(ulpq->asoc->base.sk, ulpq->asoc); 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1918728b834SDavid S. Miller /* If the SKB of 'event' is on a list, it is the first such member 1928728b834SDavid S. Miller * of that list. 1938728b834SDavid S. Miller */ 1941da177e4SLinus Torvalds int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event) 1951da177e4SLinus Torvalds { 1961da177e4SLinus Torvalds struct sock *sk = ulpq->asoc->base.sk; 1970970f5b3SMarcelo Ricardo Leitner struct sctp_sock *sp = sctp_sk(sk); 1988728b834SDavid S. Miller struct sk_buff_head *queue, *skb_list; 1998728b834SDavid S. Miller struct sk_buff *skb = sctp_event2skb(event); 2001da177e4SLinus Torvalds int clear_pd = 0; 2011da177e4SLinus Torvalds 2028728b834SDavid S. Miller skb_list = (struct sk_buff_head *) skb->prev; 2038728b834SDavid S. Miller 2041da177e4SLinus Torvalds /* If the socket is just going to throw this away, do not 2051da177e4SLinus Torvalds * even try to deliver it. 2061da177e4SLinus Torvalds */ 2071da177e4SLinus Torvalds if (sock_flag(sk, SOCK_DEAD) || (sk->sk_shutdown & RCV_SHUTDOWN)) 2081da177e4SLinus Torvalds goto out_free; 2091da177e4SLinus Torvalds 2102c8c56e1SEric Dumazet if (!sctp_ulpevent_is_notification(event)) { 2118465a5fcSNeil Horman sk_mark_napi_id(sk, skb); 2122c8c56e1SEric Dumazet sk_incoming_cpu_update(sk); 2132c8c56e1SEric Dumazet } 2141da177e4SLinus Torvalds /* Check if the user wishes to receive this event. */ 2150970f5b3SMarcelo Ricardo Leitner if (!sctp_ulpevent_is_enabled(event, &sp->subscribe)) 2161da177e4SLinus Torvalds goto out_free; 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds /* If we are in partial delivery mode, post to the lobby until 2191da177e4SLinus Torvalds * partial delivery is cleared, unless, of course _this_ is 2201da177e4SLinus Torvalds * the association the cause of the partial delivery. 2211da177e4SLinus Torvalds */ 2221da177e4SLinus Torvalds 2230970f5b3SMarcelo Ricardo Leitner if (atomic_read(&sp->pd_mode) == 0) { 2241da177e4SLinus Torvalds queue = &sk->sk_receive_queue; 225b6e1331fSVlad Yasevich } else { 226b6e1331fSVlad Yasevich if (ulpq->pd_mode) { 227d0cf0d99SVlad Yasevich /* If the association is in partial delivery, we 228d0cf0d99SVlad Yasevich * need to finish delivering the partially processed 229d0cf0d99SVlad Yasevich * packet before passing any other data. This is 230d0cf0d99SVlad Yasevich * because we don't truly support stream interleaving. 231d0cf0d99SVlad Yasevich */ 232d0cf0d99SVlad Yasevich if ((event->msg_flags & MSG_NOTIFICATION) || 233d0cf0d99SVlad Yasevich (SCTP_DATA_NOT_FRAG == 234d0cf0d99SVlad Yasevich (event->msg_flags & SCTP_DATA_FRAG_MASK))) 2350970f5b3SMarcelo Ricardo Leitner queue = &sp->pd_lobby; 2361da177e4SLinus Torvalds else { 2371da177e4SLinus Torvalds clear_pd = event->msg_flags & MSG_EOR; 2381da177e4SLinus Torvalds queue = &sk->sk_receive_queue; 2391da177e4SLinus Torvalds } 240b6e1331fSVlad Yasevich } else { 241b6e1331fSVlad Yasevich /* 242b6e1331fSVlad Yasevich * If fragment interleave is enabled, we 24325985edcSLucas De Marchi * can queue this to the receive queue instead 244b6e1331fSVlad Yasevich * of the lobby. 245b6e1331fSVlad Yasevich */ 2460970f5b3SMarcelo Ricardo Leitner if (sp->frag_interleave) 247b6e1331fSVlad Yasevich queue = &sk->sk_receive_queue; 248b6e1331fSVlad Yasevich else 2490970f5b3SMarcelo Ricardo Leitner queue = &sp->pd_lobby; 250b6e1331fSVlad Yasevich } 251b6e1331fSVlad Yasevich } 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* If we are harvesting multiple skbs they will be 2541da177e4SLinus Torvalds * collected on a list. 2551da177e4SLinus Torvalds */ 2568728b834SDavid S. Miller if (skb_list) 257311b2177SMarcelo Ricardo Leitner skb_queue_splice_tail_init(skb_list, queue); 2581da177e4SLinus Torvalds else 2598728b834SDavid S. Miller __skb_queue_tail(queue, skb); 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds /* Did we just complete partial delivery and need to get 2621da177e4SLinus Torvalds * rolling again? Move pending data to the receive 2631da177e4SLinus Torvalds * queue. 2641da177e4SLinus Torvalds */ 2651da177e4SLinus Torvalds if (clear_pd) 2661da177e4SLinus Torvalds sctp_ulpq_clear_pd(ulpq); 2671da177e4SLinus Torvalds 2680970f5b3SMarcelo Ricardo Leitner if (queue == &sk->sk_receive_queue && !sp->data_ready_signalled) { 2690970f5b3SMarcelo Ricardo Leitner sp->data_ready_signalled = 1; 2700970f5b3SMarcelo Ricardo Leitner sk->sk_data_ready(sk); 2710970f5b3SMarcelo Ricardo Leitner } 2721da177e4SLinus Torvalds return 1; 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds out_free: 2758728b834SDavid S. Miller if (skb_list) 2768728b834SDavid S. Miller sctp_queue_purge_ulpevents(skb_list); 2771da177e4SLinus Torvalds else 2781da177e4SLinus Torvalds sctp_ulpevent_free(event); 2798728b834SDavid S. Miller 2801da177e4SLinus Torvalds return 0; 2811da177e4SLinus Torvalds } 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds /* 2nd Level Abstractions */ 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds /* Helper function to store chunks that need to be reassembled. */ 28601f2d384SVlad Yasevich static void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq, 2871da177e4SLinus Torvalds struct sctp_ulpevent *event) 2881da177e4SLinus Torvalds { 2891da177e4SLinus Torvalds struct sk_buff *pos; 2901da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 2911da177e4SLinus Torvalds __u32 tsn, ctsn; 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds tsn = event->tsn; 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds /* See if it belongs at the end. */ 2961da177e4SLinus Torvalds pos = skb_peek_tail(&ulpq->reasm); 2971da177e4SLinus Torvalds if (!pos) { 2981da177e4SLinus Torvalds __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 2991da177e4SLinus Torvalds return; 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds /* Short circuit just dropping it at the end. */ 3031da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 3041da177e4SLinus Torvalds ctsn = cevent->tsn; 3051da177e4SLinus Torvalds if (TSN_lt(ctsn, tsn)) { 3061da177e4SLinus Torvalds __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 3071da177e4SLinus Torvalds return; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds /* Find the right place in this list. We store them by TSN. */ 3111da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 3121da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 3131da177e4SLinus Torvalds ctsn = cevent->tsn; 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds if (TSN_lt(tsn, ctsn)) 3161da177e4SLinus Torvalds break; 3171da177e4SLinus Torvalds } 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds /* Insert before pos. */ 32043f59c89SDavid S. Miller __skb_queue_before(&ulpq->reasm, pos, sctp_event2skb(event)); 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds /* Helper function to return an event corresponding to the reassembled 3251da177e4SLinus Torvalds * datagram. 3261da177e4SLinus Torvalds * This routine creates a re-assembled skb given the first and last skb's 3271da177e4SLinus Torvalds * as stored in the reassembly queue. The skb's may be non-linear if the sctp 3281da177e4SLinus Torvalds * payload was fragmented on the way and ip had to reassemble them. 3291da177e4SLinus Torvalds * We add the rest of skb's to the first skb's fraglist. 3301da177e4SLinus Torvalds */ 331b01a2407SEric W. Biederman static struct sctp_ulpevent *sctp_make_reassembled_event(struct net *net, 332b01a2407SEric W. Biederman struct sk_buff_head *queue, struct sk_buff *f_frag, 333b01a2407SEric W. Biederman struct sk_buff *l_frag) 3341da177e4SLinus Torvalds { 3351da177e4SLinus Torvalds struct sk_buff *pos; 336672e7ccaSVladislav Yasevich struct sk_buff *new = NULL; 3371da177e4SLinus Torvalds struct sctp_ulpevent *event; 3381da177e4SLinus Torvalds struct sk_buff *pnext, *last; 3391da177e4SLinus Torvalds struct sk_buff *list = skb_shinfo(f_frag)->frag_list; 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds /* Store the pointer to the 2nd skb */ 3421da177e4SLinus Torvalds if (f_frag == l_frag) 3431da177e4SLinus Torvalds pos = NULL; 3441da177e4SLinus Torvalds else 3451da177e4SLinus Torvalds pos = f_frag->next; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds /* Get the last skb in the f_frag's frag_list if present. */ 3488d72651dSwangweidong for (last = list; list; last = list, list = list->next) 3498d72651dSwangweidong ; 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds /* Add the list of remaining fragments to the first fragments 3521da177e4SLinus Torvalds * frag_list. 3531da177e4SLinus Torvalds */ 3541da177e4SLinus Torvalds if (last) 3551da177e4SLinus Torvalds last->next = pos; 356672e7ccaSVladislav Yasevich else { 357672e7ccaSVladislav Yasevich if (skb_cloned(f_frag)) { 358672e7ccaSVladislav Yasevich /* This is a cloned skb, we can't just modify 359672e7ccaSVladislav Yasevich * the frag_list. We need a new skb to do that. 360672e7ccaSVladislav Yasevich * Instead of calling skb_unshare(), we'll do it 361672e7ccaSVladislav Yasevich * ourselves since we need to delay the free. 362672e7ccaSVladislav Yasevich */ 363672e7ccaSVladislav Yasevich new = skb_copy(f_frag, GFP_ATOMIC); 364672e7ccaSVladislav Yasevich if (!new) 365672e7ccaSVladislav Yasevich return NULL; /* try again later */ 366672e7ccaSVladislav Yasevich 367331c4ee7SVlad Yasevich sctp_skb_set_owner_r(new, f_frag->sk); 368672e7ccaSVladislav Yasevich 369672e7ccaSVladislav Yasevich skb_shinfo(new)->frag_list = pos; 370672e7ccaSVladislav Yasevich } else 3711da177e4SLinus Torvalds skb_shinfo(f_frag)->frag_list = pos; 372672e7ccaSVladislav Yasevich } 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds /* Remove the first fragment from the reassembly queue. */ 3758728b834SDavid S. Miller __skb_unlink(f_frag, queue); 376672e7ccaSVladislav Yasevich 377672e7ccaSVladislav Yasevich /* if we did unshare, then free the old skb and re-assign */ 378672e7ccaSVladislav Yasevich if (new) { 379672e7ccaSVladislav Yasevich kfree_skb(f_frag); 380672e7ccaSVladislav Yasevich f_frag = new; 381672e7ccaSVladislav Yasevich } 382672e7ccaSVladislav Yasevich 3831da177e4SLinus Torvalds while (pos) { 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds pnext = pos->next; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds /* Update the len and data_len fields of the first fragment. */ 3881da177e4SLinus Torvalds f_frag->len += pos->len; 3891da177e4SLinus Torvalds f_frag->data_len += pos->len; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds /* Remove the fragment from the reassembly queue. */ 3928728b834SDavid S. Miller __skb_unlink(pos, queue); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds /* Break if we have reached the last fragment. */ 3951da177e4SLinus Torvalds if (pos == l_frag) 3961da177e4SLinus Torvalds break; 3971da177e4SLinus Torvalds pos->next = pnext; 3981da177e4SLinus Torvalds pos = pnext; 3993ff50b79SStephen Hemminger } 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds event = sctp_skb2event(f_frag); 402b01a2407SEric W. Biederman SCTP_INC_STATS(net, SCTP_MIB_REASMUSRMSGS); 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds return event; 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds /* Helper function to check if an incoming chunk has filled up the last 4091da177e4SLinus Torvalds * missing fragment in a SCTP datagram and return the corresponding event. 4101da177e4SLinus Torvalds */ 41101f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq) 4121da177e4SLinus Torvalds { 4131da177e4SLinus Torvalds struct sk_buff *pos; 4141da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 4151da177e4SLinus Torvalds struct sk_buff *first_frag = NULL; 4161da177e4SLinus Torvalds __u32 ctsn, next_tsn; 4171da177e4SLinus Torvalds struct sctp_ulpevent *retval = NULL; 418d49d91d7SVlad Yasevich struct sk_buff *pd_first = NULL; 419d49d91d7SVlad Yasevich struct sk_buff *pd_last = NULL; 420d49d91d7SVlad Yasevich size_t pd_len = 0; 421d49d91d7SVlad Yasevich struct sctp_association *asoc; 422d49d91d7SVlad Yasevich u32 pd_point; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds /* Initialized to 0 just to avoid compiler warning message. Will 4251da177e4SLinus Torvalds * never be used with this value. It is referenced only after it 4261da177e4SLinus Torvalds * is set when we find the first fragment of a message. 4271da177e4SLinus Torvalds */ 4281da177e4SLinus Torvalds next_tsn = 0; 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 4311da177e4SLinus Torvalds * Walk through the queue sequentially and look for a sequence of 4321da177e4SLinus Torvalds * fragmented chunks that complete a datagram. 4331da177e4SLinus Torvalds * 'first_frag' and next_tsn are reset when we find a chunk which 4341da177e4SLinus Torvalds * is the first fragment of a datagram. Once these 2 fields are set 4351da177e4SLinus Torvalds * we expect to find the remaining middle fragments and the last 4361da177e4SLinus Torvalds * fragment in order. If not, first_frag is reset to NULL and we 4371da177e4SLinus Torvalds * start the next pass when we find another first fragment. 438d49d91d7SVlad Yasevich * 439d49d91d7SVlad Yasevich * There is a potential to do partial delivery if user sets 440d49d91d7SVlad Yasevich * SCTP_PARTIAL_DELIVERY_POINT option. Lets count some things here 441d49d91d7SVlad Yasevich * to see if can do PD. 4421da177e4SLinus Torvalds */ 4431da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 4441da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 4451da177e4SLinus Torvalds ctsn = cevent->tsn; 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 4481da177e4SLinus Torvalds case SCTP_DATA_FIRST_FRAG: 449d49d91d7SVlad Yasevich /* If this "FIRST_FRAG" is the first 450d49d91d7SVlad Yasevich * element in the queue, then count it towards 451d49d91d7SVlad Yasevich * possible PD. 452d49d91d7SVlad Yasevich */ 453d49d91d7SVlad Yasevich if (pos == ulpq->reasm.next) { 454d49d91d7SVlad Yasevich pd_first = pos; 455d49d91d7SVlad Yasevich pd_last = pos; 456d49d91d7SVlad Yasevich pd_len = pos->len; 457d49d91d7SVlad Yasevich } else { 458d49d91d7SVlad Yasevich pd_first = NULL; 459d49d91d7SVlad Yasevich pd_last = NULL; 460d49d91d7SVlad Yasevich pd_len = 0; 461d49d91d7SVlad Yasevich } 462d49d91d7SVlad Yasevich 4631da177e4SLinus Torvalds first_frag = pos; 4641da177e4SLinus Torvalds next_tsn = ctsn + 1; 4651da177e4SLinus Torvalds break; 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 468d49d91d7SVlad Yasevich if ((first_frag) && (ctsn == next_tsn)) { 4691da177e4SLinus Torvalds next_tsn++; 470d49d91d7SVlad Yasevich if (pd_first) { 471d49d91d7SVlad Yasevich pd_last = pos; 472d49d91d7SVlad Yasevich pd_len += pos->len; 473d49d91d7SVlad Yasevich } 474d49d91d7SVlad Yasevich } else 4751da177e4SLinus Torvalds first_frag = NULL; 4761da177e4SLinus Torvalds break; 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds case SCTP_DATA_LAST_FRAG: 4791da177e4SLinus Torvalds if (first_frag && (ctsn == next_tsn)) 4801da177e4SLinus Torvalds goto found; 4811da177e4SLinus Torvalds else 4821da177e4SLinus Torvalds first_frag = NULL; 4831da177e4SLinus Torvalds break; 4843ff50b79SStephen Hemminger } 485d49d91d7SVlad Yasevich } 4861da177e4SLinus Torvalds 487d49d91d7SVlad Yasevich asoc = ulpq->asoc; 488d49d91d7SVlad Yasevich if (pd_first) { 489d49d91d7SVlad Yasevich /* Make sure we can enter partial deliver. 490d49d91d7SVlad Yasevich * We can trigger partial delivery only if framgent 491d49d91d7SVlad Yasevich * interleave is set, or the socket is not already 492d49d91d7SVlad Yasevich * in partial delivery. 493d49d91d7SVlad Yasevich */ 494d49d91d7SVlad Yasevich if (!sctp_sk(asoc->base.sk)->frag_interleave && 495d49d91d7SVlad Yasevich atomic_read(&sctp_sk(asoc->base.sk)->pd_mode)) 496d49d91d7SVlad Yasevich goto done; 497d49d91d7SVlad Yasevich 498d49d91d7SVlad Yasevich cevent = sctp_skb2event(pd_first); 499d49d91d7SVlad Yasevich pd_point = sctp_sk(asoc->base.sk)->pd_point; 500d49d91d7SVlad Yasevich if (pd_point && pd_point <= pd_len) { 501b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 502b01a2407SEric W. Biederman &ulpq->reasm, 503d49d91d7SVlad Yasevich pd_first, 504d49d91d7SVlad Yasevich pd_last); 505d49d91d7SVlad Yasevich if (retval) 506d49d91d7SVlad Yasevich sctp_ulpq_set_pd(ulpq); 507d49d91d7SVlad Yasevich } 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds done: 5101da177e4SLinus Torvalds return retval; 5111da177e4SLinus Torvalds found: 512b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 513b01a2407SEric W. Biederman &ulpq->reasm, first_frag, pos); 5141da177e4SLinus Torvalds if (retval) 5151da177e4SLinus Torvalds retval->msg_flags |= MSG_EOR; 5161da177e4SLinus Torvalds goto done; 5171da177e4SLinus Torvalds } 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds /* Retrieve the next set of fragments of a partial message. */ 52001f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq) 5211da177e4SLinus Torvalds { 5221da177e4SLinus Torvalds struct sk_buff *pos, *last_frag, *first_frag; 5231da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 5241da177e4SLinus Torvalds __u32 ctsn, next_tsn; 5251da177e4SLinus Torvalds int is_last; 5261da177e4SLinus Torvalds struct sctp_ulpevent *retval; 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 5291da177e4SLinus Torvalds * Walk through the queue sequentially and look for the first 5301da177e4SLinus Torvalds * sequence of fragmented chunks. 5311da177e4SLinus Torvalds */ 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds if (skb_queue_empty(&ulpq->reasm)) 5341da177e4SLinus Torvalds return NULL; 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds last_frag = first_frag = NULL; 5371da177e4SLinus Torvalds retval = NULL; 5381da177e4SLinus Torvalds next_tsn = 0; 5391da177e4SLinus Torvalds is_last = 0; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 5421da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 5431da177e4SLinus Torvalds ctsn = cevent->tsn; 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 546d003b41bSLee A. Roberts case SCTP_DATA_FIRST_FRAG: 547d003b41bSLee A. Roberts if (!first_frag) 548d003b41bSLee A. Roberts return NULL; 549d003b41bSLee A. Roberts goto done; 5501da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 5511da177e4SLinus Torvalds if (!first_frag) { 5521da177e4SLinus Torvalds first_frag = pos; 5531da177e4SLinus Torvalds next_tsn = ctsn + 1; 5541da177e4SLinus Torvalds last_frag = pos; 555d003b41bSLee A. Roberts } else if (next_tsn == ctsn) { 5561da177e4SLinus Torvalds next_tsn++; 557d003b41bSLee A. Roberts last_frag = pos; 558d003b41bSLee A. Roberts } else 5591da177e4SLinus Torvalds goto done; 5601da177e4SLinus Torvalds break; 5611da177e4SLinus Torvalds case SCTP_DATA_LAST_FRAG: 5621da177e4SLinus Torvalds if (!first_frag) 5631da177e4SLinus Torvalds first_frag = pos; 5641da177e4SLinus Torvalds else if (ctsn != next_tsn) 5651da177e4SLinus Torvalds goto done; 5661da177e4SLinus Torvalds last_frag = pos; 5671da177e4SLinus Torvalds is_last = 1; 5681da177e4SLinus Torvalds goto done; 5691da177e4SLinus Torvalds default: 5701da177e4SLinus Torvalds return NULL; 5713ff50b79SStephen Hemminger } 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds /* We have the reassembled event. There is no need to look 5751da177e4SLinus Torvalds * further. 5761da177e4SLinus Torvalds */ 5771da177e4SLinus Torvalds done: 578b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 579b01a2407SEric W. Biederman &ulpq->reasm, first_frag, last_frag); 5801da177e4SLinus Torvalds if (retval && is_last) 5811da177e4SLinus Torvalds retval->msg_flags |= MSG_EOR; 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds return retval; 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds /* Helper function to reassemble chunks. Hold chunks on the reasm queue that 5881da177e4SLinus Torvalds * need reassembling. 5891da177e4SLinus Torvalds */ 5901da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq, 5911da177e4SLinus Torvalds struct sctp_ulpevent *event) 5921da177e4SLinus Torvalds { 5931da177e4SLinus Torvalds struct sctp_ulpevent *retval = NULL; 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds /* Check if this is part of a fragmented message. */ 5961da177e4SLinus Torvalds if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) { 5971da177e4SLinus Torvalds event->msg_flags |= MSG_EOR; 5981da177e4SLinus Torvalds return event; 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds sctp_ulpq_store_reasm(ulpq, event); 6021da177e4SLinus Torvalds if (!ulpq->pd_mode) 6031da177e4SLinus Torvalds retval = sctp_ulpq_retrieve_reassembled(ulpq); 6041da177e4SLinus Torvalds else { 6051da177e4SLinus Torvalds __u32 ctsn, ctsnap; 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds /* Do not even bother unless this is the next tsn to 6081da177e4SLinus Torvalds * be delivered. 6091da177e4SLinus Torvalds */ 6101da177e4SLinus Torvalds ctsn = event->tsn; 6111da177e4SLinus Torvalds ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map); 6121da177e4SLinus Torvalds if (TSN_lte(ctsn, ctsnap)) 6131da177e4SLinus Torvalds retval = sctp_ulpq_retrieve_partial(ulpq); 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds return retval; 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* Retrieve the first part (sequential fragments) for partial delivery. */ 62001f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq) 6211da177e4SLinus Torvalds { 6221da177e4SLinus Torvalds struct sk_buff *pos, *last_frag, *first_frag; 6231da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 6241da177e4SLinus Torvalds __u32 ctsn, next_tsn; 6251da177e4SLinus Torvalds struct sctp_ulpevent *retval; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 6281da177e4SLinus Torvalds * Walk through the queue sequentially and look for a sequence of 6291da177e4SLinus Torvalds * fragmented chunks that start a datagram. 6301da177e4SLinus Torvalds */ 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds if (skb_queue_empty(&ulpq->reasm)) 6331da177e4SLinus Torvalds return NULL; 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds last_frag = first_frag = NULL; 6361da177e4SLinus Torvalds retval = NULL; 6371da177e4SLinus Torvalds next_tsn = 0; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 6401da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 6411da177e4SLinus Torvalds ctsn = cevent->tsn; 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 6441da177e4SLinus Torvalds case SCTP_DATA_FIRST_FRAG: 6451da177e4SLinus Torvalds if (!first_frag) { 6461da177e4SLinus Torvalds first_frag = pos; 6471da177e4SLinus Torvalds next_tsn = ctsn + 1; 6481da177e4SLinus Torvalds last_frag = pos; 6491da177e4SLinus Torvalds } else 6501da177e4SLinus Torvalds goto done; 6511da177e4SLinus Torvalds break; 6521da177e4SLinus Torvalds 6531da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 6541da177e4SLinus Torvalds if (!first_frag) 6551da177e4SLinus Torvalds return NULL; 6561da177e4SLinus Torvalds if (ctsn == next_tsn) { 6571da177e4SLinus Torvalds next_tsn++; 6581da177e4SLinus Torvalds last_frag = pos; 6591da177e4SLinus Torvalds } else 6601da177e4SLinus Torvalds goto done; 6611da177e4SLinus Torvalds break; 662d003b41bSLee A. Roberts 663d003b41bSLee A. Roberts case SCTP_DATA_LAST_FRAG: 664d003b41bSLee A. Roberts if (!first_frag) 665d003b41bSLee A. Roberts return NULL; 666d003b41bSLee A. Roberts else 667d003b41bSLee A. Roberts goto done; 668d003b41bSLee A. Roberts break; 669d003b41bSLee A. Roberts 6701da177e4SLinus Torvalds default: 6711da177e4SLinus Torvalds return NULL; 6723ff50b79SStephen Hemminger } 6731da177e4SLinus Torvalds } 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds /* We have the reassembled event. There is no need to look 6761da177e4SLinus Torvalds * further. 6771da177e4SLinus Torvalds */ 6781da177e4SLinus Torvalds done: 679b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 680b01a2407SEric W. Biederman &ulpq->reasm, first_frag, last_frag); 6811da177e4SLinus Torvalds return retval; 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds 684ea2dfb37SVlad Yasevich /* 685ea2dfb37SVlad Yasevich * Flush out stale fragments from the reassembly queue when processing 686ea2dfb37SVlad Yasevich * a Forward TSN. 687ea2dfb37SVlad Yasevich * 688ea2dfb37SVlad Yasevich * RFC 3758, Section 3.6 689ea2dfb37SVlad Yasevich * 690ea2dfb37SVlad Yasevich * After receiving and processing a FORWARD TSN, the data receiver MUST 691ea2dfb37SVlad Yasevich * take cautions in updating its re-assembly queue. The receiver MUST 692ea2dfb37SVlad Yasevich * remove any partially reassembled message, which is still missing one 693ea2dfb37SVlad Yasevich * or more TSNs earlier than or equal to the new cumulative TSN point. 694ea2dfb37SVlad Yasevich * In the event that the receiver has invoked the partial delivery API, 695ea2dfb37SVlad Yasevich * a notification SHOULD also be generated to inform the upper layer API 696ea2dfb37SVlad Yasevich * that the message being partially delivered will NOT be completed. 697ea2dfb37SVlad Yasevich */ 698ea2dfb37SVlad Yasevich void sctp_ulpq_reasm_flushtsn(struct sctp_ulpq *ulpq, __u32 fwd_tsn) 699ea2dfb37SVlad Yasevich { 700ea2dfb37SVlad Yasevich struct sk_buff *pos, *tmp; 701ea2dfb37SVlad Yasevich struct sctp_ulpevent *event; 702ea2dfb37SVlad Yasevich __u32 tsn; 703ea2dfb37SVlad Yasevich 704ea2dfb37SVlad Yasevich if (skb_queue_empty(&ulpq->reasm)) 705ea2dfb37SVlad Yasevich return; 706ea2dfb37SVlad Yasevich 707ea2dfb37SVlad Yasevich skb_queue_walk_safe(&ulpq->reasm, pos, tmp) { 708ea2dfb37SVlad Yasevich event = sctp_skb2event(pos); 709ea2dfb37SVlad Yasevich tsn = event->tsn; 710ea2dfb37SVlad Yasevich 711ea2dfb37SVlad Yasevich /* Since the entire message must be abandoned by the 712ea2dfb37SVlad Yasevich * sender (item A3 in Section 3.5, RFC 3758), we can 713ea2dfb37SVlad Yasevich * free all fragments on the list that are less then 714ea2dfb37SVlad Yasevich * or equal to ctsn_point 715ea2dfb37SVlad Yasevich */ 716ea2dfb37SVlad Yasevich if (TSN_lte(tsn, fwd_tsn)) { 717ea2dfb37SVlad Yasevich __skb_unlink(pos, &ulpq->reasm); 718ea2dfb37SVlad Yasevich sctp_ulpevent_free(event); 719ea2dfb37SVlad Yasevich } else 720ea2dfb37SVlad Yasevich break; 721ea2dfb37SVlad Yasevich } 722ea2dfb37SVlad Yasevich } 723ea2dfb37SVlad Yasevich 724ef5d4cf2SVlad Yasevich /* 725ef5d4cf2SVlad Yasevich * Drain the reassembly queue. If we just cleared parted delivery, it 726ef5d4cf2SVlad Yasevich * is possible that the reassembly queue will contain already reassembled 727ef5d4cf2SVlad Yasevich * messages. Retrieve any such messages and give them to the user. 728ef5d4cf2SVlad Yasevich */ 729ef5d4cf2SVlad Yasevich static void sctp_ulpq_reasm_drain(struct sctp_ulpq *ulpq) 730ef5d4cf2SVlad Yasevich { 731ef5d4cf2SVlad Yasevich struct sctp_ulpevent *event = NULL; 732ef5d4cf2SVlad Yasevich struct sk_buff_head temp; 733ef5d4cf2SVlad Yasevich 734ef5d4cf2SVlad Yasevich if (skb_queue_empty(&ulpq->reasm)) 735ef5d4cf2SVlad Yasevich return; 736ef5d4cf2SVlad Yasevich 737ef5d4cf2SVlad Yasevich while ((event = sctp_ulpq_retrieve_reassembled(ulpq)) != NULL) { 738ef5d4cf2SVlad Yasevich /* Do ordering if needed. */ 739ef5d4cf2SVlad Yasevich if ((event) && (event->msg_flags & MSG_EOR)) { 740ef5d4cf2SVlad Yasevich skb_queue_head_init(&temp); 741ef5d4cf2SVlad Yasevich __skb_queue_tail(&temp, sctp_event2skb(event)); 742ef5d4cf2SVlad Yasevich 743ef5d4cf2SVlad Yasevich event = sctp_ulpq_order(ulpq, event); 744ef5d4cf2SVlad Yasevich } 745ef5d4cf2SVlad Yasevich 746ef5d4cf2SVlad Yasevich /* Send event to the ULP. 'event' is the 747ef5d4cf2SVlad Yasevich * sctp_ulpevent for very first SKB on the temp' list. 748ef5d4cf2SVlad Yasevich */ 749ef5d4cf2SVlad Yasevich if (event) 750ef5d4cf2SVlad Yasevich sctp_ulpq_tail_event(ulpq, event); 751ef5d4cf2SVlad Yasevich } 752ef5d4cf2SVlad Yasevich } 753ef5d4cf2SVlad Yasevich 754ef5d4cf2SVlad Yasevich 7551da177e4SLinus Torvalds /* Helper function to gather skbs that have possibly become 7561da177e4SLinus Torvalds * ordered by an an incoming chunk. 7571da177e4SLinus Torvalds */ 75801f2d384SVlad Yasevich static void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq, 7591da177e4SLinus Torvalds struct sctp_ulpevent *event) 7601da177e4SLinus Torvalds { 7618728b834SDavid S. Miller struct sk_buff_head *event_list; 7621da177e4SLinus Torvalds struct sk_buff *pos, *tmp; 7631da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 7641da177e4SLinus Torvalds struct sctp_stream *in; 765efea2c6bSHagen Paul Pfeifer __u16 sid, csid, cssn; 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds sid = event->stream; 7681da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 7691da177e4SLinus Torvalds 7708728b834SDavid S. Miller event_list = (struct sk_buff_head *) sctp_event2skb(event)->prev; 7718728b834SDavid S. Miller 7721da177e4SLinus Torvalds /* We are holding the chunks by stream, by SSN. */ 7731da177e4SLinus Torvalds sctp_skb_for_each(pos, &ulpq->lobby, tmp) { 7741da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 7751da177e4SLinus Torvalds csid = cevent->stream; 7761da177e4SLinus Torvalds cssn = cevent->ssn; 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds /* Have we gone too far? */ 7791da177e4SLinus Torvalds if (csid > sid) 7801da177e4SLinus Torvalds break; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds /* Have we not gone far enough? */ 7831da177e4SLinus Torvalds if (csid < sid) 7841da177e4SLinus Torvalds continue; 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds if (cssn != sctp_ssn_peek(in, sid)) 7871da177e4SLinus Torvalds break; 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds /* Found it, so mark in the ssnmap. */ 7901da177e4SLinus Torvalds sctp_ssn_next(in, sid); 7911da177e4SLinus Torvalds 7928728b834SDavid S. Miller __skb_unlink(pos, &ulpq->lobby); 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds /* Attach all gathered skbs to the event. */ 7958728b834SDavid S. Miller __skb_queue_tail(event_list, pos); 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds } 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds /* Helper function to store chunks needing ordering. */ 80001f2d384SVlad Yasevich static void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq, 8011da177e4SLinus Torvalds struct sctp_ulpevent *event) 8021da177e4SLinus Torvalds { 8031da177e4SLinus Torvalds struct sk_buff *pos; 8041da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 8051da177e4SLinus Torvalds __u16 sid, csid; 8061da177e4SLinus Torvalds __u16 ssn, cssn; 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds pos = skb_peek_tail(&ulpq->lobby); 8091da177e4SLinus Torvalds if (!pos) { 8101da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8111da177e4SLinus Torvalds return; 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds sid = event->stream; 8151da177e4SLinus Torvalds ssn = event->ssn; 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 8181da177e4SLinus Torvalds csid = cevent->stream; 8191da177e4SLinus Torvalds cssn = cevent->ssn; 8201da177e4SLinus Torvalds if (sid > csid) { 8211da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8221da177e4SLinus Torvalds return; 8231da177e4SLinus Torvalds } 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds if ((sid == csid) && SSN_lt(cssn, ssn)) { 8261da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8271da177e4SLinus Torvalds return; 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds /* Find the right place in this list. We store them by 8311da177e4SLinus Torvalds * stream ID and then by SSN. 8321da177e4SLinus Torvalds */ 8331da177e4SLinus Torvalds skb_queue_walk(&ulpq->lobby, pos) { 8341da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 8351da177e4SLinus Torvalds csid = cevent->stream; 8361da177e4SLinus Torvalds cssn = cevent->ssn; 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds if (csid > sid) 8391da177e4SLinus Torvalds break; 8401da177e4SLinus Torvalds if (csid == sid && SSN_lt(ssn, cssn)) 8411da177e4SLinus Torvalds break; 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds /* Insert before pos. */ 84643f59c89SDavid S. Miller __skb_queue_before(&ulpq->lobby, pos, sctp_event2skb(event)); 8471da177e4SLinus Torvalds } 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq, 8501da177e4SLinus Torvalds struct sctp_ulpevent *event) 8511da177e4SLinus Torvalds { 8521da177e4SLinus Torvalds __u16 sid, ssn; 8531da177e4SLinus Torvalds struct sctp_stream *in; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds /* Check if this message needs ordering. */ 8561da177e4SLinus Torvalds if (SCTP_DATA_UNORDERED & event->msg_flags) 8571da177e4SLinus Torvalds return event; 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds /* Note: The stream ID must be verified before this routine. */ 8601da177e4SLinus Torvalds sid = event->stream; 8611da177e4SLinus Torvalds ssn = event->ssn; 8621da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds /* Is this the expected SSN for this stream ID? */ 8651da177e4SLinus Torvalds if (ssn != sctp_ssn_peek(in, sid)) { 8661da177e4SLinus Torvalds /* We've received something out of order, so find where it 8671da177e4SLinus Torvalds * needs to be placed. We order by stream and then by SSN. 8681da177e4SLinus Torvalds */ 8691da177e4SLinus Torvalds sctp_ulpq_store_ordered(ulpq, event); 8701da177e4SLinus Torvalds return NULL; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds /* Mark that the next chunk has been found. */ 8741da177e4SLinus Torvalds sctp_ssn_next(in, sid); 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds /* Go find any other chunks that were waiting for 8771da177e4SLinus Torvalds * ordering. 8781da177e4SLinus Torvalds */ 8791da177e4SLinus Torvalds sctp_ulpq_retrieve_ordered(ulpq, event); 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds return event; 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds /* Helper function to gather skbs that have possibly become 8851da177e4SLinus Torvalds * ordered by forward tsn skipping their dependencies. 8861da177e4SLinus Torvalds */ 88701f2d384SVlad Yasevich static void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq, __u16 sid) 8881da177e4SLinus Torvalds { 8891da177e4SLinus Torvalds struct sk_buff *pos, *tmp; 8901da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 8918728b834SDavid S. Miller struct sctp_ulpevent *event; 8921da177e4SLinus Torvalds struct sctp_stream *in; 8931da177e4SLinus Torvalds struct sk_buff_head temp; 894c068be54SVlad Yasevich struct sk_buff_head *lobby = &ulpq->lobby; 8951da177e4SLinus Torvalds __u16 csid, cssn; 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds /* We are holding the chunks by stream, by SSN. */ 9008728b834SDavid S. Miller skb_queue_head_init(&temp); 9018728b834SDavid S. Miller event = NULL; 902c068be54SVlad Yasevich sctp_skb_for_each(pos, lobby, tmp) { 9031da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 9041da177e4SLinus Torvalds csid = cevent->stream; 9051da177e4SLinus Torvalds cssn = cevent->ssn; 9061da177e4SLinus Torvalds 907ea2dfb37SVlad Yasevich /* Have we gone too far? */ 908ea2dfb37SVlad Yasevich if (csid > sid) 9091da177e4SLinus Torvalds break; 9101da177e4SLinus Torvalds 911ea2dfb37SVlad Yasevich /* Have we not gone far enough? */ 912ea2dfb37SVlad Yasevich if (csid < sid) 913ea2dfb37SVlad Yasevich continue; 914ea2dfb37SVlad Yasevich 915ea2dfb37SVlad Yasevich /* see if this ssn has been marked by skipping */ 916c068be54SVlad Yasevich if (!SSN_lt(cssn, sctp_ssn_peek(in, csid))) 917ea2dfb37SVlad Yasevich break; 9181da177e4SLinus Torvalds 919c068be54SVlad Yasevich __skb_unlink(pos, lobby); 920ea2dfb37SVlad Yasevich if (!event) 9211da177e4SLinus Torvalds /* Create a temporary list to collect chunks on. */ 9221da177e4SLinus Torvalds event = sctp_skb2event(pos); 923ea2dfb37SVlad Yasevich 9241da177e4SLinus Torvalds /* Attach all gathered skbs to the event. */ 9258728b834SDavid S. Miller __skb_queue_tail(&temp, pos); 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds 928c068be54SVlad Yasevich /* If we didn't reap any data, see if the next expected SSN 929c068be54SVlad Yasevich * is next on the queue and if so, use that. 930c068be54SVlad Yasevich */ 931c068be54SVlad Yasevich if (event == NULL && pos != (struct sk_buff *)lobby) { 932c068be54SVlad Yasevich cevent = (struct sctp_ulpevent *) pos->cb; 933c068be54SVlad Yasevich csid = cevent->stream; 934c068be54SVlad Yasevich cssn = cevent->ssn; 935c068be54SVlad Yasevich 936c068be54SVlad Yasevich if (csid == sid && cssn == sctp_ssn_peek(in, csid)) { 937c068be54SVlad Yasevich sctp_ssn_next(in, csid); 938c068be54SVlad Yasevich __skb_unlink(pos, lobby); 939c068be54SVlad Yasevich __skb_queue_tail(&temp, pos); 940c068be54SVlad Yasevich event = sctp_skb2event(pos); 941c068be54SVlad Yasevich } 942c068be54SVlad Yasevich } 943c068be54SVlad Yasevich 9448728b834SDavid S. Miller /* Send event to the ULP. 'event' is the sctp_ulpevent for 9458728b834SDavid S. Miller * very first SKB on the 'temp' list. 9468728b834SDavid S. Miller */ 947ea2dfb37SVlad Yasevich if (event) { 948ea2dfb37SVlad Yasevich /* see if we have more ordered that we can deliver */ 949ea2dfb37SVlad Yasevich sctp_ulpq_retrieve_ordered(ulpq, event); 9501da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 9511da177e4SLinus Torvalds } 952ea2dfb37SVlad Yasevich } 9531da177e4SLinus Torvalds 954ea2dfb37SVlad Yasevich /* Skip over an SSN. This is used during the processing of 955ea2dfb37SVlad Yasevich * Forwared TSN chunk to skip over the abandoned ordered data 956ea2dfb37SVlad Yasevich */ 9571da177e4SLinus Torvalds void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn) 9581da177e4SLinus Torvalds { 9591da177e4SLinus Torvalds struct sctp_stream *in; 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds /* Note: The stream ID must be verified before this routine. */ 9621da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 9631da177e4SLinus Torvalds 9641da177e4SLinus Torvalds /* Is this an old SSN? If so ignore. */ 9651da177e4SLinus Torvalds if (SSN_lt(ssn, sctp_ssn_peek(in, sid))) 9661da177e4SLinus Torvalds return; 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds /* Mark that we are no longer expecting this SSN or lower. */ 9691da177e4SLinus Torvalds sctp_ssn_skip(in, sid, ssn); 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds /* Go find any other chunks that were waiting for 9721da177e4SLinus Torvalds * ordering and deliver them if needed. 9731da177e4SLinus Torvalds */ 974ea2dfb37SVlad Yasevich sctp_ulpq_reap_ordered(ulpq, sid); 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds 97716d14ef9SPavel Emelyanov static __u16 sctp_ulpq_renege_list(struct sctp_ulpq *ulpq, 97816d14ef9SPavel Emelyanov struct sk_buff_head *list, __u16 needed) 9791da177e4SLinus Torvalds { 9801da177e4SLinus Torvalds __u16 freed = 0; 98195ac7b85SLee A. Roberts __u32 tsn, last_tsn; 98295ac7b85SLee A. Roberts struct sk_buff *skb, *flist, *last; 9831da177e4SLinus Torvalds struct sctp_ulpevent *event; 9841da177e4SLinus Torvalds struct sctp_tsnmap *tsnmap; 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds tsnmap = &ulpq->asoc->peer.tsn_map; 9871da177e4SLinus Torvalds 988e67f85ecSLee A. Roberts while ((skb = skb_peek_tail(list)) != NULL) { 9891da177e4SLinus Torvalds event = sctp_skb2event(skb); 9901da177e4SLinus Torvalds tsn = event->tsn; 9911da177e4SLinus Torvalds 992e67f85ecSLee A. Roberts /* Don't renege below the Cumulative TSN ACK Point. */ 993e67f85ecSLee A. Roberts if (TSN_lte(tsn, sctp_tsnmap_get_ctsn(tsnmap))) 994e67f85ecSLee A. Roberts break; 995e67f85ecSLee A. Roberts 99695ac7b85SLee A. Roberts /* Events in ordering queue may have multiple fragments 99795ac7b85SLee A. Roberts * corresponding to additional TSNs. Sum the total 99895ac7b85SLee A. Roberts * freed space; find the last TSN. 99995ac7b85SLee A. Roberts */ 1000e67f85ecSLee A. Roberts freed += skb_headlen(skb); 100195ac7b85SLee A. Roberts flist = skb_shinfo(skb)->frag_list; 100295ac7b85SLee A. Roberts for (last = flist; flist; flist = flist->next) { 100395ac7b85SLee A. Roberts last = flist; 100495ac7b85SLee A. Roberts freed += skb_headlen(last); 100595ac7b85SLee A. Roberts } 100695ac7b85SLee A. Roberts if (last) 100795ac7b85SLee A. Roberts last_tsn = sctp_skb2event(last)->tsn; 100895ac7b85SLee A. Roberts else 100995ac7b85SLee A. Roberts last_tsn = tsn; 101095ac7b85SLee A. Roberts 101195ac7b85SLee A. Roberts /* Unlink the event, then renege all applicable TSNs. */ 101295ac7b85SLee A. Roberts __skb_unlink(skb, list); 10131da177e4SLinus Torvalds sctp_ulpevent_free(event); 101495ac7b85SLee A. Roberts while (TSN_lte(tsn, last_tsn)) { 10151da177e4SLinus Torvalds sctp_tsnmap_renege(tsnmap, tsn); 101695ac7b85SLee A. Roberts tsn++; 101795ac7b85SLee A. Roberts } 10181da177e4SLinus Torvalds if (freed >= needed) 10191da177e4SLinus Torvalds return freed; 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds 10221da177e4SLinus Torvalds return freed; 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 102516d14ef9SPavel Emelyanov /* Renege 'needed' bytes from the ordering queue. */ 102616d14ef9SPavel Emelyanov static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed) 102716d14ef9SPavel Emelyanov { 102816d14ef9SPavel Emelyanov return sctp_ulpq_renege_list(ulpq, &ulpq->lobby, needed); 102916d14ef9SPavel Emelyanov } 103016d14ef9SPavel Emelyanov 10311da177e4SLinus Torvalds /* Renege 'needed' bytes from the reassembly queue. */ 10321da177e4SLinus Torvalds static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed) 10331da177e4SLinus Torvalds { 103416d14ef9SPavel Emelyanov return sctp_ulpq_renege_list(ulpq, &ulpq->reasm, needed); 10351da177e4SLinus Torvalds } 10361da177e4SLinus Torvalds 10371da177e4SLinus Torvalds /* Partial deliver the first message as there is pressure on rwnd. */ 10381da177e4SLinus Torvalds void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq, 1039dd0fc66fSAl Viro gfp_t gfp) 10401da177e4SLinus Torvalds { 10411da177e4SLinus Torvalds struct sctp_ulpevent *event; 10421da177e4SLinus Torvalds struct sctp_association *asoc; 1043b6e1331fSVlad Yasevich struct sctp_sock *sp; 1044d003b41bSLee A. Roberts __u32 ctsn; 1045d003b41bSLee A. Roberts struct sk_buff *skb; 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds asoc = ulpq->asoc; 1048b6e1331fSVlad Yasevich sp = sctp_sk(asoc->base.sk); 10491da177e4SLinus Torvalds 1050b6e1331fSVlad Yasevich /* If the association is already in Partial Delivery mode 1051d003b41bSLee A. Roberts * we have nothing to do. 1052b6e1331fSVlad Yasevich */ 1053b6e1331fSVlad Yasevich if (ulpq->pd_mode) 1054b6e1331fSVlad Yasevich return; 10551da177e4SLinus Torvalds 1056d003b41bSLee A. Roberts /* Data must be at or below the Cumulative TSN ACK Point to 1057d003b41bSLee A. Roberts * start partial delivery. 1058d003b41bSLee A. Roberts */ 1059d003b41bSLee A. Roberts skb = skb_peek(&asoc->ulpq.reasm); 1060d003b41bSLee A. Roberts if (skb != NULL) { 1061d003b41bSLee A. Roberts ctsn = sctp_skb2event(skb)->tsn; 1062d003b41bSLee A. Roberts if (!TSN_lte(ctsn, sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map))) 1063d003b41bSLee A. Roberts return; 1064d003b41bSLee A. Roberts } 1065d003b41bSLee A. Roberts 1066b6e1331fSVlad Yasevich /* If the user enabled fragment interleave socket option, 1067b6e1331fSVlad Yasevich * multiple associations can enter partial delivery. 1068b6e1331fSVlad Yasevich * Otherwise, we can only enter partial delivery if the 1069b6e1331fSVlad Yasevich * socket is not in partial deliver mode. 1070b6e1331fSVlad Yasevich */ 1071b6e1331fSVlad Yasevich if (sp->frag_interleave || atomic_read(&sp->pd_mode) == 0) { 10721da177e4SLinus Torvalds /* Is partial delivery possible? */ 10731da177e4SLinus Torvalds event = sctp_ulpq_retrieve_first(ulpq); 10741da177e4SLinus Torvalds /* Send event to the ULP. */ 10751da177e4SLinus Torvalds if (event) { 10761da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 1077d49d91d7SVlad Yasevich sctp_ulpq_set_pd(ulpq); 10781da177e4SLinus Torvalds return; 10791da177e4SLinus Torvalds } 10801da177e4SLinus Torvalds } 10811da177e4SLinus Torvalds } 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds /* Renege some packets to make room for an incoming chunk. */ 10841da177e4SLinus Torvalds void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 1085dd0fc66fSAl Viro gfp_t gfp) 10861da177e4SLinus Torvalds { 10871da177e4SLinus Torvalds struct sctp_association *asoc; 10881da177e4SLinus Torvalds __u16 needed, freed; 10891da177e4SLinus Torvalds 10901da177e4SLinus Torvalds asoc = ulpq->asoc; 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds if (chunk) { 10931da177e4SLinus Torvalds needed = ntohs(chunk->chunk_hdr->length); 10941da177e4SLinus Torvalds needed -= sizeof(sctp_data_chunk_t); 10951da177e4SLinus Torvalds } else 10961da177e4SLinus Torvalds needed = SCTP_DEFAULT_MAXWINDOW; 10971da177e4SLinus Torvalds 10981da177e4SLinus Torvalds freed = 0; 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) { 11011da177e4SLinus Torvalds freed = sctp_ulpq_renege_order(ulpq, needed); 11021da177e4SLinus Torvalds if (freed < needed) { 11031da177e4SLinus Torvalds freed += sctp_ulpq_renege_frags(ulpq, needed - freed); 11041da177e4SLinus Torvalds } 11051da177e4SLinus Torvalds } 11061da177e4SLinus Torvalds /* If able to free enough room, accept this chunk. */ 11071da177e4SLinus Torvalds if (chunk && (freed >= needed)) { 1108d003b41bSLee A. Roberts int retval; 1109d003b41bSLee A. Roberts retval = sctp_ulpq_tail_data(ulpq, chunk, gfp); 1110d003b41bSLee A. Roberts /* 1111d003b41bSLee A. Roberts * Enter partial delivery if chunk has not been 1112d003b41bSLee A. Roberts * delivered; otherwise, drain the reassembly queue. 1113d003b41bSLee A. Roberts */ 1114d003b41bSLee A. Roberts if (retval <= 0) 1115b26ddd81SNeil Horman sctp_ulpq_partial_delivery(ulpq, gfp); 1116d003b41bSLee A. Roberts else if (retval == 1) 1117d003b41bSLee A. Roberts sctp_ulpq_reasm_drain(ulpq); 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds 11203ab224beSHideo Aoki sk_mem_reclaim(asoc->base.sk); 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds /* Notify the application if an association is aborted and in 11261da177e4SLinus Torvalds * partial delivery mode. Send up any pending received messages. 11271da177e4SLinus Torvalds */ 1128dd0fc66fSAl Viro void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, gfp_t gfp) 11291da177e4SLinus Torvalds { 11301da177e4SLinus Torvalds struct sctp_ulpevent *ev = NULL; 11311da177e4SLinus Torvalds struct sock *sk; 11320970f5b3SMarcelo Ricardo Leitner struct sctp_sock *sp; 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds if (!ulpq->pd_mode) 11351da177e4SLinus Torvalds return; 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds sk = ulpq->asoc->base.sk; 11380970f5b3SMarcelo Ricardo Leitner sp = sctp_sk(sk); 11391da177e4SLinus Torvalds if (sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT, 11401da177e4SLinus Torvalds &sctp_sk(sk)->subscribe)) 11411da177e4SLinus Torvalds ev = sctp_ulpevent_make_pdapi(ulpq->asoc, 11421da177e4SLinus Torvalds SCTP_PARTIAL_DELIVERY_ABORTED, 11431da177e4SLinus Torvalds gfp); 11441da177e4SLinus Torvalds if (ev) 11451da177e4SLinus Torvalds __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev)); 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds /* If there is data waiting, send it up the socket now. */ 11480970f5b3SMarcelo Ricardo Leitner if ((sctp_ulpq_clear_pd(ulpq) || ev) && !sp->data_ready_signalled) { 11490970f5b3SMarcelo Ricardo Leitner sp->data_ready_signalled = 1; 11500970f5b3SMarcelo Ricardo Leitner sk->sk_data_ready(sk); 11510970f5b3SMarcelo Ricardo Leitner } 11521da177e4SLinus Torvalds } 1153