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; 1441da177e4SLinus Torvalds sctp_skb_list_tail(&sp->pd_lobby, &sk->sk_receive_queue); 1451da177e4SLinus Torvalds list = (struct list_head *)&sctp_sk(sk)->pd_lobby; 1461da177e4SLinus Torvalds INIT_LIST_HEAD(list); 1471da177e4SLinus Torvalds return 1; 1481da177e4SLinus Torvalds } 149b6e1331fSVlad Yasevich } else { 150b6e1331fSVlad Yasevich /* There are other associations in PD, so we only need to 151b6e1331fSVlad Yasevich * pull stuff out of the lobby that belongs to the 152b6e1331fSVlad Yasevich * associations that is exiting PD (all of its notifications 153b6e1331fSVlad Yasevich * are posted here). 154b6e1331fSVlad Yasevich */ 155b6e1331fSVlad Yasevich if (!skb_queue_empty(&sp->pd_lobby) && asoc) { 156b6e1331fSVlad Yasevich struct sk_buff *skb, *tmp; 157b6e1331fSVlad Yasevich struct sctp_ulpevent *event; 158b6e1331fSVlad Yasevich 159b6e1331fSVlad Yasevich sctp_skb_for_each(skb, &sp->pd_lobby, tmp) { 160b6e1331fSVlad Yasevich event = sctp_skb2event(skb); 161b6e1331fSVlad Yasevich if (event->asoc == asoc) { 162b6e1331fSVlad Yasevich __skb_unlink(skb, &sp->pd_lobby); 163b6e1331fSVlad Yasevich __skb_queue_tail(&sk->sk_receive_queue, 164b6e1331fSVlad Yasevich skb); 165b6e1331fSVlad Yasevich } 166b6e1331fSVlad Yasevich } 167b6e1331fSVlad Yasevich } 168b6e1331fSVlad Yasevich } 169b6e1331fSVlad Yasevich 1701da177e4SLinus Torvalds return 0; 1711da177e4SLinus Torvalds } 1721da177e4SLinus Torvalds 173d49d91d7SVlad Yasevich /* Set the pd_mode on the socket and ulpq */ 174d49d91d7SVlad Yasevich static void sctp_ulpq_set_pd(struct sctp_ulpq *ulpq) 175d49d91d7SVlad Yasevich { 176d49d91d7SVlad Yasevich struct sctp_sock *sp = sctp_sk(ulpq->asoc->base.sk); 177d49d91d7SVlad Yasevich 178d49d91d7SVlad Yasevich atomic_inc(&sp->pd_mode); 179d49d91d7SVlad Yasevich ulpq->pd_mode = 1; 180d49d91d7SVlad Yasevich } 181d49d91d7SVlad Yasevich 1821da177e4SLinus Torvalds /* Clear the pd_mode and restart any pending messages waiting for delivery. */ 1831da177e4SLinus Torvalds static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds ulpq->pd_mode = 0; 186ef5d4cf2SVlad Yasevich sctp_ulpq_reasm_drain(ulpq); 187b6e1331fSVlad Yasevich return sctp_clear_pd(ulpq->asoc->base.sk, ulpq->asoc); 1881da177e4SLinus Torvalds } 1891da177e4SLinus Torvalds 1908728b834SDavid S. Miller /* If the SKB of 'event' is on a list, it is the first such member 1918728b834SDavid S. Miller * of that list. 1928728b834SDavid S. Miller */ 1931da177e4SLinus Torvalds int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event) 1941da177e4SLinus Torvalds { 1951da177e4SLinus Torvalds struct sock *sk = ulpq->asoc->base.sk; 1968728b834SDavid S. Miller struct sk_buff_head *queue, *skb_list; 1978728b834SDavid S. Miller struct sk_buff *skb = sctp_event2skb(event); 1981da177e4SLinus Torvalds int clear_pd = 0; 1991da177e4SLinus Torvalds 2008728b834SDavid S. Miller skb_list = (struct sk_buff_head *) skb->prev; 2018728b834SDavid S. Miller 2021da177e4SLinus Torvalds /* If the socket is just going to throw this away, do not 2031da177e4SLinus Torvalds * even try to deliver it. 2041da177e4SLinus Torvalds */ 2051da177e4SLinus Torvalds if (sock_flag(sk, SOCK_DEAD) || (sk->sk_shutdown & RCV_SHUTDOWN)) 2061da177e4SLinus Torvalds goto out_free; 2071da177e4SLinus Torvalds 2082c8c56e1SEric Dumazet if (!sctp_ulpevent_is_notification(event)) { 2098465a5fcSNeil Horman sk_mark_napi_id(sk, skb); 2102c8c56e1SEric Dumazet sk_incoming_cpu_update(sk); 2112c8c56e1SEric Dumazet } 2121da177e4SLinus Torvalds /* Check if the user wishes to receive this event. */ 2131da177e4SLinus Torvalds if (!sctp_ulpevent_is_enabled(event, &sctp_sk(sk)->subscribe)) 2141da177e4SLinus Torvalds goto out_free; 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds /* If we are in partial delivery mode, post to the lobby until 2171da177e4SLinus Torvalds * partial delivery is cleared, unless, of course _this_ is 2181da177e4SLinus Torvalds * the association the cause of the partial delivery. 2191da177e4SLinus Torvalds */ 2201da177e4SLinus Torvalds 221b6e1331fSVlad Yasevich if (atomic_read(&sctp_sk(sk)->pd_mode) == 0) { 2221da177e4SLinus Torvalds queue = &sk->sk_receive_queue; 223b6e1331fSVlad Yasevich } else { 224b6e1331fSVlad Yasevich if (ulpq->pd_mode) { 225d0cf0d99SVlad Yasevich /* If the association is in partial delivery, we 226d0cf0d99SVlad Yasevich * need to finish delivering the partially processed 227d0cf0d99SVlad Yasevich * packet before passing any other data. This is 228d0cf0d99SVlad Yasevich * because we don't truly support stream interleaving. 229d0cf0d99SVlad Yasevich */ 230d0cf0d99SVlad Yasevich if ((event->msg_flags & MSG_NOTIFICATION) || 231d0cf0d99SVlad Yasevich (SCTP_DATA_NOT_FRAG == 232d0cf0d99SVlad Yasevich (event->msg_flags & SCTP_DATA_FRAG_MASK))) 2331da177e4SLinus Torvalds queue = &sctp_sk(sk)->pd_lobby; 2341da177e4SLinus Torvalds else { 2351da177e4SLinus Torvalds clear_pd = event->msg_flags & MSG_EOR; 2361da177e4SLinus Torvalds queue = &sk->sk_receive_queue; 2371da177e4SLinus Torvalds } 238b6e1331fSVlad Yasevich } else { 239b6e1331fSVlad Yasevich /* 240b6e1331fSVlad Yasevich * If fragment interleave is enabled, we 24125985edcSLucas De Marchi * can queue this to the receive queue instead 242b6e1331fSVlad Yasevich * of the lobby. 243b6e1331fSVlad Yasevich */ 244b6e1331fSVlad Yasevich if (sctp_sk(sk)->frag_interleave) 245b6e1331fSVlad Yasevich queue = &sk->sk_receive_queue; 246b6e1331fSVlad Yasevich else 2471da177e4SLinus Torvalds queue = &sctp_sk(sk)->pd_lobby; 248b6e1331fSVlad Yasevich } 249b6e1331fSVlad Yasevich } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* If we are harvesting multiple skbs they will be 2521da177e4SLinus Torvalds * collected on a list. 2531da177e4SLinus Torvalds */ 2548728b834SDavid S. Miller if (skb_list) 2558728b834SDavid S. Miller sctp_skb_list_tail(skb_list, queue); 2561da177e4SLinus Torvalds else 2578728b834SDavid S. Miller __skb_queue_tail(queue, skb); 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds /* Did we just complete partial delivery and need to get 2601da177e4SLinus Torvalds * rolling again? Move pending data to the receive 2611da177e4SLinus Torvalds * queue. 2621da177e4SLinus Torvalds */ 2631da177e4SLinus Torvalds if (clear_pd) 2641da177e4SLinus Torvalds sctp_ulpq_clear_pd(ulpq); 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds if (queue == &sk->sk_receive_queue) 267676d2369SDavid S. Miller sk->sk_data_ready(sk); 2681da177e4SLinus Torvalds return 1; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds out_free: 2718728b834SDavid S. Miller if (skb_list) 2728728b834SDavid S. Miller sctp_queue_purge_ulpevents(skb_list); 2731da177e4SLinus Torvalds else 2741da177e4SLinus Torvalds sctp_ulpevent_free(event); 2758728b834SDavid S. Miller 2761da177e4SLinus Torvalds return 0; 2771da177e4SLinus Torvalds } 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds /* 2nd Level Abstractions */ 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds /* Helper function to store chunks that need to be reassembled. */ 28201f2d384SVlad Yasevich static void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq, 2831da177e4SLinus Torvalds struct sctp_ulpevent *event) 2841da177e4SLinus Torvalds { 2851da177e4SLinus Torvalds struct sk_buff *pos; 2861da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 2871da177e4SLinus Torvalds __u32 tsn, ctsn; 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds tsn = event->tsn; 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds /* See if it belongs at the end. */ 2921da177e4SLinus Torvalds pos = skb_peek_tail(&ulpq->reasm); 2931da177e4SLinus Torvalds if (!pos) { 2941da177e4SLinus Torvalds __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 2951da177e4SLinus Torvalds return; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds /* Short circuit just dropping it at the end. */ 2991da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 3001da177e4SLinus Torvalds ctsn = cevent->tsn; 3011da177e4SLinus Torvalds if (TSN_lt(ctsn, tsn)) { 3021da177e4SLinus Torvalds __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 3031da177e4SLinus Torvalds return; 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds /* Find the right place in this list. We store them by TSN. */ 3071da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 3081da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 3091da177e4SLinus Torvalds ctsn = cevent->tsn; 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds if (TSN_lt(tsn, ctsn)) 3121da177e4SLinus Torvalds break; 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds /* Insert before pos. */ 31643f59c89SDavid S. Miller __skb_queue_before(&ulpq->reasm, pos, sctp_event2skb(event)); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds } 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* Helper function to return an event corresponding to the reassembled 3211da177e4SLinus Torvalds * datagram. 3221da177e4SLinus Torvalds * This routine creates a re-assembled skb given the first and last skb's 3231da177e4SLinus Torvalds * as stored in the reassembly queue. The skb's may be non-linear if the sctp 3241da177e4SLinus Torvalds * payload was fragmented on the way and ip had to reassemble them. 3251da177e4SLinus Torvalds * We add the rest of skb's to the first skb's fraglist. 3261da177e4SLinus Torvalds */ 327b01a2407SEric W. Biederman static struct sctp_ulpevent *sctp_make_reassembled_event(struct net *net, 328b01a2407SEric W. Biederman struct sk_buff_head *queue, struct sk_buff *f_frag, 329b01a2407SEric W. Biederman struct sk_buff *l_frag) 3301da177e4SLinus Torvalds { 3311da177e4SLinus Torvalds struct sk_buff *pos; 332672e7ccaSVladislav Yasevich struct sk_buff *new = NULL; 3331da177e4SLinus Torvalds struct sctp_ulpevent *event; 3341da177e4SLinus Torvalds struct sk_buff *pnext, *last; 3351da177e4SLinus Torvalds struct sk_buff *list = skb_shinfo(f_frag)->frag_list; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds /* Store the pointer to the 2nd skb */ 3381da177e4SLinus Torvalds if (f_frag == l_frag) 3391da177e4SLinus Torvalds pos = NULL; 3401da177e4SLinus Torvalds else 3411da177e4SLinus Torvalds pos = f_frag->next; 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds /* Get the last skb in the f_frag's frag_list if present. */ 3448d72651dSwangweidong for (last = list; list; last = list, list = list->next) 3458d72651dSwangweidong ; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds /* Add the list of remaining fragments to the first fragments 3481da177e4SLinus Torvalds * frag_list. 3491da177e4SLinus Torvalds */ 3501da177e4SLinus Torvalds if (last) 3511da177e4SLinus Torvalds last->next = pos; 352672e7ccaSVladislav Yasevich else { 353672e7ccaSVladislav Yasevich if (skb_cloned(f_frag)) { 354672e7ccaSVladislav Yasevich /* This is a cloned skb, we can't just modify 355672e7ccaSVladislav Yasevich * the frag_list. We need a new skb to do that. 356672e7ccaSVladislav Yasevich * Instead of calling skb_unshare(), we'll do it 357672e7ccaSVladislav Yasevich * ourselves since we need to delay the free. 358672e7ccaSVladislav Yasevich */ 359672e7ccaSVladislav Yasevich new = skb_copy(f_frag, GFP_ATOMIC); 360672e7ccaSVladislav Yasevich if (!new) 361672e7ccaSVladislav Yasevich return NULL; /* try again later */ 362672e7ccaSVladislav Yasevich 363331c4ee7SVlad Yasevich sctp_skb_set_owner_r(new, f_frag->sk); 364672e7ccaSVladislav Yasevich 365672e7ccaSVladislav Yasevich skb_shinfo(new)->frag_list = pos; 366672e7ccaSVladislav Yasevich } else 3671da177e4SLinus Torvalds skb_shinfo(f_frag)->frag_list = pos; 368672e7ccaSVladislav Yasevich } 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds /* Remove the first fragment from the reassembly queue. */ 3718728b834SDavid S. Miller __skb_unlink(f_frag, queue); 372672e7ccaSVladislav Yasevich 373672e7ccaSVladislav Yasevich /* if we did unshare, then free the old skb and re-assign */ 374672e7ccaSVladislav Yasevich if (new) { 375672e7ccaSVladislav Yasevich kfree_skb(f_frag); 376672e7ccaSVladislav Yasevich f_frag = new; 377672e7ccaSVladislav Yasevich } 378672e7ccaSVladislav Yasevich 3791da177e4SLinus Torvalds while (pos) { 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds pnext = pos->next; 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds /* Update the len and data_len fields of the first fragment. */ 3841da177e4SLinus Torvalds f_frag->len += pos->len; 3851da177e4SLinus Torvalds f_frag->data_len += pos->len; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds /* Remove the fragment from the reassembly queue. */ 3888728b834SDavid S. Miller __skb_unlink(pos, queue); 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds /* Break if we have reached the last fragment. */ 3911da177e4SLinus Torvalds if (pos == l_frag) 3921da177e4SLinus Torvalds break; 3931da177e4SLinus Torvalds pos->next = pnext; 3941da177e4SLinus Torvalds pos = pnext; 3953ff50b79SStephen Hemminger } 3961da177e4SLinus Torvalds 3971da177e4SLinus Torvalds event = sctp_skb2event(f_frag); 398b01a2407SEric W. Biederman SCTP_INC_STATS(net, SCTP_MIB_REASMUSRMSGS); 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds return event; 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds /* Helper function to check if an incoming chunk has filled up the last 4051da177e4SLinus Torvalds * missing fragment in a SCTP datagram and return the corresponding event. 4061da177e4SLinus Torvalds */ 40701f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq) 4081da177e4SLinus Torvalds { 4091da177e4SLinus Torvalds struct sk_buff *pos; 4101da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 4111da177e4SLinus Torvalds struct sk_buff *first_frag = NULL; 4121da177e4SLinus Torvalds __u32 ctsn, next_tsn; 4131da177e4SLinus Torvalds struct sctp_ulpevent *retval = NULL; 414d49d91d7SVlad Yasevich struct sk_buff *pd_first = NULL; 415d49d91d7SVlad Yasevich struct sk_buff *pd_last = NULL; 416d49d91d7SVlad Yasevich size_t pd_len = 0; 417d49d91d7SVlad Yasevich struct sctp_association *asoc; 418d49d91d7SVlad Yasevich u32 pd_point; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds /* Initialized to 0 just to avoid compiler warning message. Will 4211da177e4SLinus Torvalds * never be used with this value. It is referenced only after it 4221da177e4SLinus Torvalds * is set when we find the first fragment of a message. 4231da177e4SLinus Torvalds */ 4241da177e4SLinus Torvalds next_tsn = 0; 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 4271da177e4SLinus Torvalds * Walk through the queue sequentially and look for a sequence of 4281da177e4SLinus Torvalds * fragmented chunks that complete a datagram. 4291da177e4SLinus Torvalds * 'first_frag' and next_tsn are reset when we find a chunk which 4301da177e4SLinus Torvalds * is the first fragment of a datagram. Once these 2 fields are set 4311da177e4SLinus Torvalds * we expect to find the remaining middle fragments and the last 4321da177e4SLinus Torvalds * fragment in order. If not, first_frag is reset to NULL and we 4331da177e4SLinus Torvalds * start the next pass when we find another first fragment. 434d49d91d7SVlad Yasevich * 435d49d91d7SVlad Yasevich * There is a potential to do partial delivery if user sets 436d49d91d7SVlad Yasevich * SCTP_PARTIAL_DELIVERY_POINT option. Lets count some things here 437d49d91d7SVlad Yasevich * to see if can do PD. 4381da177e4SLinus Torvalds */ 4391da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 4401da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 4411da177e4SLinus Torvalds ctsn = cevent->tsn; 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 4441da177e4SLinus Torvalds case SCTP_DATA_FIRST_FRAG: 445d49d91d7SVlad Yasevich /* If this "FIRST_FRAG" is the first 446d49d91d7SVlad Yasevich * element in the queue, then count it towards 447d49d91d7SVlad Yasevich * possible PD. 448d49d91d7SVlad Yasevich */ 449d49d91d7SVlad Yasevich if (pos == ulpq->reasm.next) { 450d49d91d7SVlad Yasevich pd_first = pos; 451d49d91d7SVlad Yasevich pd_last = pos; 452d49d91d7SVlad Yasevich pd_len = pos->len; 453d49d91d7SVlad Yasevich } else { 454d49d91d7SVlad Yasevich pd_first = NULL; 455d49d91d7SVlad Yasevich pd_last = NULL; 456d49d91d7SVlad Yasevich pd_len = 0; 457d49d91d7SVlad Yasevich } 458d49d91d7SVlad Yasevich 4591da177e4SLinus Torvalds first_frag = pos; 4601da177e4SLinus Torvalds next_tsn = ctsn + 1; 4611da177e4SLinus Torvalds break; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 464d49d91d7SVlad Yasevich if ((first_frag) && (ctsn == next_tsn)) { 4651da177e4SLinus Torvalds next_tsn++; 466d49d91d7SVlad Yasevich if (pd_first) { 467d49d91d7SVlad Yasevich pd_last = pos; 468d49d91d7SVlad Yasevich pd_len += pos->len; 469d49d91d7SVlad Yasevich } 470d49d91d7SVlad Yasevich } else 4711da177e4SLinus Torvalds first_frag = NULL; 4721da177e4SLinus Torvalds break; 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds case SCTP_DATA_LAST_FRAG: 4751da177e4SLinus Torvalds if (first_frag && (ctsn == next_tsn)) 4761da177e4SLinus Torvalds goto found; 4771da177e4SLinus Torvalds else 4781da177e4SLinus Torvalds first_frag = NULL; 4791da177e4SLinus Torvalds break; 4803ff50b79SStephen Hemminger } 481d49d91d7SVlad Yasevich } 4821da177e4SLinus Torvalds 483d49d91d7SVlad Yasevich asoc = ulpq->asoc; 484d49d91d7SVlad Yasevich if (pd_first) { 485d49d91d7SVlad Yasevich /* Make sure we can enter partial deliver. 486d49d91d7SVlad Yasevich * We can trigger partial delivery only if framgent 487d49d91d7SVlad Yasevich * interleave is set, or the socket is not already 488d49d91d7SVlad Yasevich * in partial delivery. 489d49d91d7SVlad Yasevich */ 490d49d91d7SVlad Yasevich if (!sctp_sk(asoc->base.sk)->frag_interleave && 491d49d91d7SVlad Yasevich atomic_read(&sctp_sk(asoc->base.sk)->pd_mode)) 492d49d91d7SVlad Yasevich goto done; 493d49d91d7SVlad Yasevich 494d49d91d7SVlad Yasevich cevent = sctp_skb2event(pd_first); 495d49d91d7SVlad Yasevich pd_point = sctp_sk(asoc->base.sk)->pd_point; 496d49d91d7SVlad Yasevich if (pd_point && pd_point <= pd_len) { 497b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 498b01a2407SEric W. Biederman &ulpq->reasm, 499d49d91d7SVlad Yasevich pd_first, 500d49d91d7SVlad Yasevich pd_last); 501d49d91d7SVlad Yasevich if (retval) 502d49d91d7SVlad Yasevich sctp_ulpq_set_pd(ulpq); 503d49d91d7SVlad Yasevich } 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds done: 5061da177e4SLinus Torvalds return retval; 5071da177e4SLinus Torvalds found: 508b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 509b01a2407SEric W. Biederman &ulpq->reasm, first_frag, pos); 5101da177e4SLinus Torvalds if (retval) 5111da177e4SLinus Torvalds retval->msg_flags |= MSG_EOR; 5121da177e4SLinus Torvalds goto done; 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds /* Retrieve the next set of fragments of a partial message. */ 51601f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq) 5171da177e4SLinus Torvalds { 5181da177e4SLinus Torvalds struct sk_buff *pos, *last_frag, *first_frag; 5191da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 5201da177e4SLinus Torvalds __u32 ctsn, next_tsn; 5211da177e4SLinus Torvalds int is_last; 5221da177e4SLinus Torvalds struct sctp_ulpevent *retval; 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 5251da177e4SLinus Torvalds * Walk through the queue sequentially and look for the first 5261da177e4SLinus Torvalds * sequence of fragmented chunks. 5271da177e4SLinus Torvalds */ 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds if (skb_queue_empty(&ulpq->reasm)) 5301da177e4SLinus Torvalds return NULL; 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds last_frag = first_frag = NULL; 5331da177e4SLinus Torvalds retval = NULL; 5341da177e4SLinus Torvalds next_tsn = 0; 5351da177e4SLinus Torvalds is_last = 0; 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 5381da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 5391da177e4SLinus Torvalds ctsn = cevent->tsn; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 542d003b41bSLee A. Roberts case SCTP_DATA_FIRST_FRAG: 543d003b41bSLee A. Roberts if (!first_frag) 544d003b41bSLee A. Roberts return NULL; 545d003b41bSLee A. Roberts goto done; 5461da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 5471da177e4SLinus Torvalds if (!first_frag) { 5481da177e4SLinus Torvalds first_frag = pos; 5491da177e4SLinus Torvalds next_tsn = ctsn + 1; 5501da177e4SLinus Torvalds last_frag = pos; 551d003b41bSLee A. Roberts } else if (next_tsn == ctsn) { 5521da177e4SLinus Torvalds next_tsn++; 553d003b41bSLee A. Roberts last_frag = pos; 554d003b41bSLee A. Roberts } else 5551da177e4SLinus Torvalds goto done; 5561da177e4SLinus Torvalds break; 5571da177e4SLinus Torvalds case SCTP_DATA_LAST_FRAG: 5581da177e4SLinus Torvalds if (!first_frag) 5591da177e4SLinus Torvalds first_frag = pos; 5601da177e4SLinus Torvalds else if (ctsn != next_tsn) 5611da177e4SLinus Torvalds goto done; 5621da177e4SLinus Torvalds last_frag = pos; 5631da177e4SLinus Torvalds is_last = 1; 5641da177e4SLinus Torvalds goto done; 5651da177e4SLinus Torvalds default: 5661da177e4SLinus Torvalds return NULL; 5673ff50b79SStephen Hemminger } 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds /* We have the reassembled event. There is no need to look 5711da177e4SLinus Torvalds * further. 5721da177e4SLinus Torvalds */ 5731da177e4SLinus Torvalds done: 574b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 575b01a2407SEric W. Biederman &ulpq->reasm, first_frag, last_frag); 5761da177e4SLinus Torvalds if (retval && is_last) 5771da177e4SLinus Torvalds retval->msg_flags |= MSG_EOR; 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds return retval; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds /* Helper function to reassemble chunks. Hold chunks on the reasm queue that 5841da177e4SLinus Torvalds * need reassembling. 5851da177e4SLinus Torvalds */ 5861da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq, 5871da177e4SLinus Torvalds struct sctp_ulpevent *event) 5881da177e4SLinus Torvalds { 5891da177e4SLinus Torvalds struct sctp_ulpevent *retval = NULL; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds /* Check if this is part of a fragmented message. */ 5921da177e4SLinus Torvalds if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) { 5931da177e4SLinus Torvalds event->msg_flags |= MSG_EOR; 5941da177e4SLinus Torvalds return event; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds sctp_ulpq_store_reasm(ulpq, event); 5981da177e4SLinus Torvalds if (!ulpq->pd_mode) 5991da177e4SLinus Torvalds retval = sctp_ulpq_retrieve_reassembled(ulpq); 6001da177e4SLinus Torvalds else { 6011da177e4SLinus Torvalds __u32 ctsn, ctsnap; 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds /* Do not even bother unless this is the next tsn to 6041da177e4SLinus Torvalds * be delivered. 6051da177e4SLinus Torvalds */ 6061da177e4SLinus Torvalds ctsn = event->tsn; 6071da177e4SLinus Torvalds ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map); 6081da177e4SLinus Torvalds if (TSN_lte(ctsn, ctsnap)) 6091da177e4SLinus Torvalds retval = sctp_ulpq_retrieve_partial(ulpq); 6101da177e4SLinus Torvalds } 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds return retval; 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds /* Retrieve the first part (sequential fragments) for partial delivery. */ 61601f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq) 6171da177e4SLinus Torvalds { 6181da177e4SLinus Torvalds struct sk_buff *pos, *last_frag, *first_frag; 6191da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 6201da177e4SLinus Torvalds __u32 ctsn, next_tsn; 6211da177e4SLinus Torvalds struct sctp_ulpevent *retval; 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 6241da177e4SLinus Torvalds * Walk through the queue sequentially and look for a sequence of 6251da177e4SLinus Torvalds * fragmented chunks that start a datagram. 6261da177e4SLinus Torvalds */ 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds if (skb_queue_empty(&ulpq->reasm)) 6291da177e4SLinus Torvalds return NULL; 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds last_frag = first_frag = NULL; 6321da177e4SLinus Torvalds retval = NULL; 6331da177e4SLinus Torvalds next_tsn = 0; 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 6361da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 6371da177e4SLinus Torvalds ctsn = cevent->tsn; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 6401da177e4SLinus Torvalds case SCTP_DATA_FIRST_FRAG: 6411da177e4SLinus Torvalds if (!first_frag) { 6421da177e4SLinus Torvalds first_frag = pos; 6431da177e4SLinus Torvalds next_tsn = ctsn + 1; 6441da177e4SLinus Torvalds last_frag = pos; 6451da177e4SLinus Torvalds } else 6461da177e4SLinus Torvalds goto done; 6471da177e4SLinus Torvalds break; 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 6501da177e4SLinus Torvalds if (!first_frag) 6511da177e4SLinus Torvalds return NULL; 6521da177e4SLinus Torvalds if (ctsn == next_tsn) { 6531da177e4SLinus Torvalds next_tsn++; 6541da177e4SLinus Torvalds last_frag = pos; 6551da177e4SLinus Torvalds } else 6561da177e4SLinus Torvalds goto done; 6571da177e4SLinus Torvalds break; 658d003b41bSLee A. Roberts 659d003b41bSLee A. Roberts case SCTP_DATA_LAST_FRAG: 660d003b41bSLee A. Roberts if (!first_frag) 661d003b41bSLee A. Roberts return NULL; 662d003b41bSLee A. Roberts else 663d003b41bSLee A. Roberts goto done; 664d003b41bSLee A. Roberts break; 665d003b41bSLee A. Roberts 6661da177e4SLinus Torvalds default: 6671da177e4SLinus Torvalds return NULL; 6683ff50b79SStephen Hemminger } 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds /* We have the reassembled event. There is no need to look 6721da177e4SLinus Torvalds * further. 6731da177e4SLinus Torvalds */ 6741da177e4SLinus Torvalds done: 675b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 676b01a2407SEric W. Biederman &ulpq->reasm, first_frag, last_frag); 6771da177e4SLinus Torvalds return retval; 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds 680ea2dfb37SVlad Yasevich /* 681ea2dfb37SVlad Yasevich * Flush out stale fragments from the reassembly queue when processing 682ea2dfb37SVlad Yasevich * a Forward TSN. 683ea2dfb37SVlad Yasevich * 684ea2dfb37SVlad Yasevich * RFC 3758, Section 3.6 685ea2dfb37SVlad Yasevich * 686ea2dfb37SVlad Yasevich * After receiving and processing a FORWARD TSN, the data receiver MUST 687ea2dfb37SVlad Yasevich * take cautions in updating its re-assembly queue. The receiver MUST 688ea2dfb37SVlad Yasevich * remove any partially reassembled message, which is still missing one 689ea2dfb37SVlad Yasevich * or more TSNs earlier than or equal to the new cumulative TSN point. 690ea2dfb37SVlad Yasevich * In the event that the receiver has invoked the partial delivery API, 691ea2dfb37SVlad Yasevich * a notification SHOULD also be generated to inform the upper layer API 692ea2dfb37SVlad Yasevich * that the message being partially delivered will NOT be completed. 693ea2dfb37SVlad Yasevich */ 694ea2dfb37SVlad Yasevich void sctp_ulpq_reasm_flushtsn(struct sctp_ulpq *ulpq, __u32 fwd_tsn) 695ea2dfb37SVlad Yasevich { 696ea2dfb37SVlad Yasevich struct sk_buff *pos, *tmp; 697ea2dfb37SVlad Yasevich struct sctp_ulpevent *event; 698ea2dfb37SVlad Yasevich __u32 tsn; 699ea2dfb37SVlad Yasevich 700ea2dfb37SVlad Yasevich if (skb_queue_empty(&ulpq->reasm)) 701ea2dfb37SVlad Yasevich return; 702ea2dfb37SVlad Yasevich 703ea2dfb37SVlad Yasevich skb_queue_walk_safe(&ulpq->reasm, pos, tmp) { 704ea2dfb37SVlad Yasevich event = sctp_skb2event(pos); 705ea2dfb37SVlad Yasevich tsn = event->tsn; 706ea2dfb37SVlad Yasevich 707ea2dfb37SVlad Yasevich /* Since the entire message must be abandoned by the 708ea2dfb37SVlad Yasevich * sender (item A3 in Section 3.5, RFC 3758), we can 709ea2dfb37SVlad Yasevich * free all fragments on the list that are less then 710ea2dfb37SVlad Yasevich * or equal to ctsn_point 711ea2dfb37SVlad Yasevich */ 712ea2dfb37SVlad Yasevich if (TSN_lte(tsn, fwd_tsn)) { 713ea2dfb37SVlad Yasevich __skb_unlink(pos, &ulpq->reasm); 714ea2dfb37SVlad Yasevich sctp_ulpevent_free(event); 715ea2dfb37SVlad Yasevich } else 716ea2dfb37SVlad Yasevich break; 717ea2dfb37SVlad Yasevich } 718ea2dfb37SVlad Yasevich } 719ea2dfb37SVlad Yasevich 720ef5d4cf2SVlad Yasevich /* 721ef5d4cf2SVlad Yasevich * Drain the reassembly queue. If we just cleared parted delivery, it 722ef5d4cf2SVlad Yasevich * is possible that the reassembly queue will contain already reassembled 723ef5d4cf2SVlad Yasevich * messages. Retrieve any such messages and give them to the user. 724ef5d4cf2SVlad Yasevich */ 725ef5d4cf2SVlad Yasevich static void sctp_ulpq_reasm_drain(struct sctp_ulpq *ulpq) 726ef5d4cf2SVlad Yasevich { 727ef5d4cf2SVlad Yasevich struct sctp_ulpevent *event = NULL; 728ef5d4cf2SVlad Yasevich struct sk_buff_head temp; 729ef5d4cf2SVlad Yasevich 730ef5d4cf2SVlad Yasevich if (skb_queue_empty(&ulpq->reasm)) 731ef5d4cf2SVlad Yasevich return; 732ef5d4cf2SVlad Yasevich 733ef5d4cf2SVlad Yasevich while ((event = sctp_ulpq_retrieve_reassembled(ulpq)) != NULL) { 734ef5d4cf2SVlad Yasevich /* Do ordering if needed. */ 735ef5d4cf2SVlad Yasevich if ((event) && (event->msg_flags & MSG_EOR)) { 736ef5d4cf2SVlad Yasevich skb_queue_head_init(&temp); 737ef5d4cf2SVlad Yasevich __skb_queue_tail(&temp, sctp_event2skb(event)); 738ef5d4cf2SVlad Yasevich 739ef5d4cf2SVlad Yasevich event = sctp_ulpq_order(ulpq, event); 740ef5d4cf2SVlad Yasevich } 741ef5d4cf2SVlad Yasevich 742ef5d4cf2SVlad Yasevich /* Send event to the ULP. 'event' is the 743ef5d4cf2SVlad Yasevich * sctp_ulpevent for very first SKB on the temp' list. 744ef5d4cf2SVlad Yasevich */ 745ef5d4cf2SVlad Yasevich if (event) 746ef5d4cf2SVlad Yasevich sctp_ulpq_tail_event(ulpq, event); 747ef5d4cf2SVlad Yasevich } 748ef5d4cf2SVlad Yasevich } 749ef5d4cf2SVlad Yasevich 750ef5d4cf2SVlad Yasevich 7511da177e4SLinus Torvalds /* Helper function to gather skbs that have possibly become 7521da177e4SLinus Torvalds * ordered by an an incoming chunk. 7531da177e4SLinus Torvalds */ 75401f2d384SVlad Yasevich static void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq, 7551da177e4SLinus Torvalds struct sctp_ulpevent *event) 7561da177e4SLinus Torvalds { 7578728b834SDavid S. Miller struct sk_buff_head *event_list; 7581da177e4SLinus Torvalds struct sk_buff *pos, *tmp; 7591da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 7601da177e4SLinus Torvalds struct sctp_stream *in; 761efea2c6bSHagen Paul Pfeifer __u16 sid, csid, cssn; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds sid = event->stream; 7641da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 7651da177e4SLinus Torvalds 7668728b834SDavid S. Miller event_list = (struct sk_buff_head *) sctp_event2skb(event)->prev; 7678728b834SDavid S. Miller 7681da177e4SLinus Torvalds /* We are holding the chunks by stream, by SSN. */ 7691da177e4SLinus Torvalds sctp_skb_for_each(pos, &ulpq->lobby, tmp) { 7701da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 7711da177e4SLinus Torvalds csid = cevent->stream; 7721da177e4SLinus Torvalds cssn = cevent->ssn; 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds /* Have we gone too far? */ 7751da177e4SLinus Torvalds if (csid > sid) 7761da177e4SLinus Torvalds break; 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds /* Have we not gone far enough? */ 7791da177e4SLinus Torvalds if (csid < sid) 7801da177e4SLinus Torvalds continue; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds if (cssn != sctp_ssn_peek(in, sid)) 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds /* Found it, so mark in the ssnmap. */ 7861da177e4SLinus Torvalds sctp_ssn_next(in, sid); 7871da177e4SLinus Torvalds 7888728b834SDavid S. Miller __skb_unlink(pos, &ulpq->lobby); 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds /* Attach all gathered skbs to the event. */ 7918728b834SDavid S. Miller __skb_queue_tail(event_list, pos); 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds } 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds /* Helper function to store chunks needing ordering. */ 79601f2d384SVlad Yasevich static void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq, 7971da177e4SLinus Torvalds struct sctp_ulpevent *event) 7981da177e4SLinus Torvalds { 7991da177e4SLinus Torvalds struct sk_buff *pos; 8001da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 8011da177e4SLinus Torvalds __u16 sid, csid; 8021da177e4SLinus Torvalds __u16 ssn, cssn; 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds pos = skb_peek_tail(&ulpq->lobby); 8051da177e4SLinus Torvalds if (!pos) { 8061da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8071da177e4SLinus Torvalds return; 8081da177e4SLinus Torvalds } 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds sid = event->stream; 8111da177e4SLinus Torvalds ssn = event->ssn; 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 8141da177e4SLinus Torvalds csid = cevent->stream; 8151da177e4SLinus Torvalds cssn = cevent->ssn; 8161da177e4SLinus Torvalds if (sid > csid) { 8171da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8181da177e4SLinus Torvalds return; 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds if ((sid == csid) && SSN_lt(cssn, ssn)) { 8221da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8231da177e4SLinus Torvalds return; 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds /* Find the right place in this list. We store them by 8271da177e4SLinus Torvalds * stream ID and then by SSN. 8281da177e4SLinus Torvalds */ 8291da177e4SLinus Torvalds skb_queue_walk(&ulpq->lobby, pos) { 8301da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 8311da177e4SLinus Torvalds csid = cevent->stream; 8321da177e4SLinus Torvalds cssn = cevent->ssn; 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds if (csid > sid) 8351da177e4SLinus Torvalds break; 8361da177e4SLinus Torvalds if (csid == sid && SSN_lt(ssn, cssn)) 8371da177e4SLinus Torvalds break; 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds /* Insert before pos. */ 84243f59c89SDavid S. Miller __skb_queue_before(&ulpq->lobby, pos, sctp_event2skb(event)); 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq, 8461da177e4SLinus Torvalds struct sctp_ulpevent *event) 8471da177e4SLinus Torvalds { 8481da177e4SLinus Torvalds __u16 sid, ssn; 8491da177e4SLinus Torvalds struct sctp_stream *in; 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds /* Check if this message needs ordering. */ 8521da177e4SLinus Torvalds if (SCTP_DATA_UNORDERED & event->msg_flags) 8531da177e4SLinus Torvalds return event; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds /* Note: The stream ID must be verified before this routine. */ 8561da177e4SLinus Torvalds sid = event->stream; 8571da177e4SLinus Torvalds ssn = event->ssn; 8581da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds /* Is this the expected SSN for this stream ID? */ 8611da177e4SLinus Torvalds if (ssn != sctp_ssn_peek(in, sid)) { 8621da177e4SLinus Torvalds /* We've received something out of order, so find where it 8631da177e4SLinus Torvalds * needs to be placed. We order by stream and then by SSN. 8641da177e4SLinus Torvalds */ 8651da177e4SLinus Torvalds sctp_ulpq_store_ordered(ulpq, event); 8661da177e4SLinus Torvalds return NULL; 8671da177e4SLinus Torvalds } 8681da177e4SLinus Torvalds 8691da177e4SLinus Torvalds /* Mark that the next chunk has been found. */ 8701da177e4SLinus Torvalds sctp_ssn_next(in, sid); 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds /* Go find any other chunks that were waiting for 8731da177e4SLinus Torvalds * ordering. 8741da177e4SLinus Torvalds */ 8751da177e4SLinus Torvalds sctp_ulpq_retrieve_ordered(ulpq, event); 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds return event; 8781da177e4SLinus Torvalds } 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds /* Helper function to gather skbs that have possibly become 8811da177e4SLinus Torvalds * ordered by forward tsn skipping their dependencies. 8821da177e4SLinus Torvalds */ 88301f2d384SVlad Yasevich static void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq, __u16 sid) 8841da177e4SLinus Torvalds { 8851da177e4SLinus Torvalds struct sk_buff *pos, *tmp; 8861da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 8878728b834SDavid S. Miller struct sctp_ulpevent *event; 8881da177e4SLinus Torvalds struct sctp_stream *in; 8891da177e4SLinus Torvalds struct sk_buff_head temp; 890c068be54SVlad Yasevich struct sk_buff_head *lobby = &ulpq->lobby; 8911da177e4SLinus Torvalds __u16 csid, cssn; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds /* We are holding the chunks by stream, by SSN. */ 8968728b834SDavid S. Miller skb_queue_head_init(&temp); 8978728b834SDavid S. Miller event = NULL; 898c068be54SVlad Yasevich sctp_skb_for_each(pos, lobby, tmp) { 8991da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 9001da177e4SLinus Torvalds csid = cevent->stream; 9011da177e4SLinus Torvalds cssn = cevent->ssn; 9021da177e4SLinus Torvalds 903ea2dfb37SVlad Yasevich /* Have we gone too far? */ 904ea2dfb37SVlad Yasevich if (csid > sid) 9051da177e4SLinus Torvalds break; 9061da177e4SLinus Torvalds 907ea2dfb37SVlad Yasevich /* Have we not gone far enough? */ 908ea2dfb37SVlad Yasevich if (csid < sid) 909ea2dfb37SVlad Yasevich continue; 910ea2dfb37SVlad Yasevich 911ea2dfb37SVlad Yasevich /* see if this ssn has been marked by skipping */ 912c068be54SVlad Yasevich if (!SSN_lt(cssn, sctp_ssn_peek(in, csid))) 913ea2dfb37SVlad Yasevich break; 9141da177e4SLinus Torvalds 915c068be54SVlad Yasevich __skb_unlink(pos, lobby); 916ea2dfb37SVlad Yasevich if (!event) 9171da177e4SLinus Torvalds /* Create a temporary list to collect chunks on. */ 9181da177e4SLinus Torvalds event = sctp_skb2event(pos); 919ea2dfb37SVlad Yasevich 9201da177e4SLinus Torvalds /* Attach all gathered skbs to the event. */ 9218728b834SDavid S. Miller __skb_queue_tail(&temp, pos); 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds 924c068be54SVlad Yasevich /* If we didn't reap any data, see if the next expected SSN 925c068be54SVlad Yasevich * is next on the queue and if so, use that. 926c068be54SVlad Yasevich */ 927c068be54SVlad Yasevich if (event == NULL && pos != (struct sk_buff *)lobby) { 928c068be54SVlad Yasevich cevent = (struct sctp_ulpevent *) pos->cb; 929c068be54SVlad Yasevich csid = cevent->stream; 930c068be54SVlad Yasevich cssn = cevent->ssn; 931c068be54SVlad Yasevich 932c068be54SVlad Yasevich if (csid == sid && cssn == sctp_ssn_peek(in, csid)) { 933c068be54SVlad Yasevich sctp_ssn_next(in, csid); 934c068be54SVlad Yasevich __skb_unlink(pos, lobby); 935c068be54SVlad Yasevich __skb_queue_tail(&temp, pos); 936c068be54SVlad Yasevich event = sctp_skb2event(pos); 937c068be54SVlad Yasevich } 938c068be54SVlad Yasevich } 939c068be54SVlad Yasevich 9408728b834SDavid S. Miller /* Send event to the ULP. 'event' is the sctp_ulpevent for 9418728b834SDavid S. Miller * very first SKB on the 'temp' list. 9428728b834SDavid S. Miller */ 943ea2dfb37SVlad Yasevich if (event) { 944ea2dfb37SVlad Yasevich /* see if we have more ordered that we can deliver */ 945ea2dfb37SVlad Yasevich sctp_ulpq_retrieve_ordered(ulpq, event); 9461da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 9471da177e4SLinus Torvalds } 948ea2dfb37SVlad Yasevich } 9491da177e4SLinus Torvalds 950ea2dfb37SVlad Yasevich /* Skip over an SSN. This is used during the processing of 951ea2dfb37SVlad Yasevich * Forwared TSN chunk to skip over the abandoned ordered data 952ea2dfb37SVlad Yasevich */ 9531da177e4SLinus Torvalds void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn) 9541da177e4SLinus Torvalds { 9551da177e4SLinus Torvalds struct sctp_stream *in; 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds /* Note: The stream ID must be verified before this routine. */ 9581da177e4SLinus Torvalds in = &ulpq->asoc->ssnmap->in; 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds /* Is this an old SSN? If so ignore. */ 9611da177e4SLinus Torvalds if (SSN_lt(ssn, sctp_ssn_peek(in, sid))) 9621da177e4SLinus Torvalds return; 9631da177e4SLinus Torvalds 9641da177e4SLinus Torvalds /* Mark that we are no longer expecting this SSN or lower. */ 9651da177e4SLinus Torvalds sctp_ssn_skip(in, sid, ssn); 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds /* Go find any other chunks that were waiting for 9681da177e4SLinus Torvalds * ordering and deliver them if needed. 9691da177e4SLinus Torvalds */ 970ea2dfb37SVlad Yasevich sctp_ulpq_reap_ordered(ulpq, sid); 9711da177e4SLinus Torvalds } 9721da177e4SLinus Torvalds 97316d14ef9SPavel Emelyanov static __u16 sctp_ulpq_renege_list(struct sctp_ulpq *ulpq, 97416d14ef9SPavel Emelyanov struct sk_buff_head *list, __u16 needed) 9751da177e4SLinus Torvalds { 9761da177e4SLinus Torvalds __u16 freed = 0; 97795ac7b85SLee A. Roberts __u32 tsn, last_tsn; 97895ac7b85SLee A. Roberts struct sk_buff *skb, *flist, *last; 9791da177e4SLinus Torvalds struct sctp_ulpevent *event; 9801da177e4SLinus Torvalds struct sctp_tsnmap *tsnmap; 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds tsnmap = &ulpq->asoc->peer.tsn_map; 9831da177e4SLinus Torvalds 984e67f85ecSLee A. Roberts while ((skb = skb_peek_tail(list)) != NULL) { 9851da177e4SLinus Torvalds event = sctp_skb2event(skb); 9861da177e4SLinus Torvalds tsn = event->tsn; 9871da177e4SLinus Torvalds 988e67f85ecSLee A. Roberts /* Don't renege below the Cumulative TSN ACK Point. */ 989e67f85ecSLee A. Roberts if (TSN_lte(tsn, sctp_tsnmap_get_ctsn(tsnmap))) 990e67f85ecSLee A. Roberts break; 991e67f85ecSLee A. Roberts 99295ac7b85SLee A. Roberts /* Events in ordering queue may have multiple fragments 99395ac7b85SLee A. Roberts * corresponding to additional TSNs. Sum the total 99495ac7b85SLee A. Roberts * freed space; find the last TSN. 99595ac7b85SLee A. Roberts */ 996e67f85ecSLee A. Roberts freed += skb_headlen(skb); 99795ac7b85SLee A. Roberts flist = skb_shinfo(skb)->frag_list; 99895ac7b85SLee A. Roberts for (last = flist; flist; flist = flist->next) { 99995ac7b85SLee A. Roberts last = flist; 100095ac7b85SLee A. Roberts freed += skb_headlen(last); 100195ac7b85SLee A. Roberts } 100295ac7b85SLee A. Roberts if (last) 100395ac7b85SLee A. Roberts last_tsn = sctp_skb2event(last)->tsn; 100495ac7b85SLee A. Roberts else 100595ac7b85SLee A. Roberts last_tsn = tsn; 100695ac7b85SLee A. Roberts 100795ac7b85SLee A. Roberts /* Unlink the event, then renege all applicable TSNs. */ 100895ac7b85SLee A. Roberts __skb_unlink(skb, list); 10091da177e4SLinus Torvalds sctp_ulpevent_free(event); 101095ac7b85SLee A. Roberts while (TSN_lte(tsn, last_tsn)) { 10111da177e4SLinus Torvalds sctp_tsnmap_renege(tsnmap, tsn); 101295ac7b85SLee A. Roberts tsn++; 101395ac7b85SLee A. Roberts } 10141da177e4SLinus Torvalds if (freed >= needed) 10151da177e4SLinus Torvalds return freed; 10161da177e4SLinus Torvalds } 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds return freed; 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds 102116d14ef9SPavel Emelyanov /* Renege 'needed' bytes from the ordering queue. */ 102216d14ef9SPavel Emelyanov static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed) 102316d14ef9SPavel Emelyanov { 102416d14ef9SPavel Emelyanov return sctp_ulpq_renege_list(ulpq, &ulpq->lobby, needed); 102516d14ef9SPavel Emelyanov } 102616d14ef9SPavel Emelyanov 10271da177e4SLinus Torvalds /* Renege 'needed' bytes from the reassembly queue. */ 10281da177e4SLinus Torvalds static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed) 10291da177e4SLinus Torvalds { 103016d14ef9SPavel Emelyanov return sctp_ulpq_renege_list(ulpq, &ulpq->reasm, needed); 10311da177e4SLinus Torvalds } 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds /* Partial deliver the first message as there is pressure on rwnd. */ 10341da177e4SLinus Torvalds void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq, 1035dd0fc66fSAl Viro gfp_t gfp) 10361da177e4SLinus Torvalds { 10371da177e4SLinus Torvalds struct sctp_ulpevent *event; 10381da177e4SLinus Torvalds struct sctp_association *asoc; 1039b6e1331fSVlad Yasevich struct sctp_sock *sp; 1040d003b41bSLee A. Roberts __u32 ctsn; 1041d003b41bSLee A. Roberts struct sk_buff *skb; 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds asoc = ulpq->asoc; 1044b6e1331fSVlad Yasevich sp = sctp_sk(asoc->base.sk); 10451da177e4SLinus Torvalds 1046b6e1331fSVlad Yasevich /* If the association is already in Partial Delivery mode 1047d003b41bSLee A. Roberts * we have nothing to do. 1048b6e1331fSVlad Yasevich */ 1049b6e1331fSVlad Yasevich if (ulpq->pd_mode) 1050b6e1331fSVlad Yasevich return; 10511da177e4SLinus Torvalds 1052d003b41bSLee A. Roberts /* Data must be at or below the Cumulative TSN ACK Point to 1053d003b41bSLee A. Roberts * start partial delivery. 1054d003b41bSLee A. Roberts */ 1055d003b41bSLee A. Roberts skb = skb_peek(&asoc->ulpq.reasm); 1056d003b41bSLee A. Roberts if (skb != NULL) { 1057d003b41bSLee A. Roberts ctsn = sctp_skb2event(skb)->tsn; 1058d003b41bSLee A. Roberts if (!TSN_lte(ctsn, sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map))) 1059d003b41bSLee A. Roberts return; 1060d003b41bSLee A. Roberts } 1061d003b41bSLee A. Roberts 1062b6e1331fSVlad Yasevich /* If the user enabled fragment interleave socket option, 1063b6e1331fSVlad Yasevich * multiple associations can enter partial delivery. 1064b6e1331fSVlad Yasevich * Otherwise, we can only enter partial delivery if the 1065b6e1331fSVlad Yasevich * socket is not in partial deliver mode. 1066b6e1331fSVlad Yasevich */ 1067b6e1331fSVlad Yasevich if (sp->frag_interleave || atomic_read(&sp->pd_mode) == 0) { 10681da177e4SLinus Torvalds /* Is partial delivery possible? */ 10691da177e4SLinus Torvalds event = sctp_ulpq_retrieve_first(ulpq); 10701da177e4SLinus Torvalds /* Send event to the ULP. */ 10711da177e4SLinus Torvalds if (event) { 10721da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 1073d49d91d7SVlad Yasevich sctp_ulpq_set_pd(ulpq); 10741da177e4SLinus Torvalds return; 10751da177e4SLinus Torvalds } 10761da177e4SLinus Torvalds } 10771da177e4SLinus Torvalds } 10781da177e4SLinus Torvalds 10791da177e4SLinus Torvalds /* Renege some packets to make room for an incoming chunk. */ 10801da177e4SLinus Torvalds void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 1081dd0fc66fSAl Viro gfp_t gfp) 10821da177e4SLinus Torvalds { 10831da177e4SLinus Torvalds struct sctp_association *asoc; 10841da177e4SLinus Torvalds __u16 needed, freed; 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds asoc = ulpq->asoc; 10871da177e4SLinus Torvalds 10881da177e4SLinus Torvalds if (chunk) { 10891da177e4SLinus Torvalds needed = ntohs(chunk->chunk_hdr->length); 10901da177e4SLinus Torvalds needed -= sizeof(sctp_data_chunk_t); 10911da177e4SLinus Torvalds } else 10921da177e4SLinus Torvalds needed = SCTP_DEFAULT_MAXWINDOW; 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds freed = 0; 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) { 10971da177e4SLinus Torvalds freed = sctp_ulpq_renege_order(ulpq, needed); 10981da177e4SLinus Torvalds if (freed < needed) { 10991da177e4SLinus Torvalds freed += sctp_ulpq_renege_frags(ulpq, needed - freed); 11001da177e4SLinus Torvalds } 11011da177e4SLinus Torvalds } 11021da177e4SLinus Torvalds /* If able to free enough room, accept this chunk. */ 11031da177e4SLinus Torvalds if (chunk && (freed >= needed)) { 1104d003b41bSLee A. Roberts int retval; 1105d003b41bSLee A. Roberts retval = sctp_ulpq_tail_data(ulpq, chunk, gfp); 1106d003b41bSLee A. Roberts /* 1107d003b41bSLee A. Roberts * Enter partial delivery if chunk has not been 1108d003b41bSLee A. Roberts * delivered; otherwise, drain the reassembly queue. 1109d003b41bSLee A. Roberts */ 1110d003b41bSLee A. Roberts if (retval <= 0) 1111b26ddd81SNeil Horman sctp_ulpq_partial_delivery(ulpq, gfp); 1112d003b41bSLee A. Roberts else if (retval == 1) 1113d003b41bSLee A. Roberts sctp_ulpq_reasm_drain(ulpq); 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds 11163ab224beSHideo Aoki sk_mem_reclaim(asoc->base.sk); 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds /* Notify the application if an association is aborted and in 11221da177e4SLinus Torvalds * partial delivery mode. Send up any pending received messages. 11231da177e4SLinus Torvalds */ 1124dd0fc66fSAl Viro void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, gfp_t gfp) 11251da177e4SLinus Torvalds { 11261da177e4SLinus Torvalds struct sctp_ulpevent *ev = NULL; 11271da177e4SLinus Torvalds struct sock *sk; 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds if (!ulpq->pd_mode) 11301da177e4SLinus Torvalds return; 11311da177e4SLinus Torvalds 11321da177e4SLinus Torvalds sk = ulpq->asoc->base.sk; 11331da177e4SLinus Torvalds if (sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT, 11341da177e4SLinus Torvalds &sctp_sk(sk)->subscribe)) 11351da177e4SLinus Torvalds ev = sctp_ulpevent_make_pdapi(ulpq->asoc, 11361da177e4SLinus Torvalds SCTP_PARTIAL_DELIVERY_ABORTED, 11371da177e4SLinus Torvalds gfp); 11381da177e4SLinus Torvalds if (ev) 11391da177e4SLinus Torvalds __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev)); 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds /* If there is data waiting, send it up the socket now. */ 11421da177e4SLinus Torvalds if (sctp_ulpq_clear_pd(ulpq) || ev) 1143676d2369SDavid S. Miller sk->sk_data_ready(sk); 11441da177e4SLinus Torvalds } 1145