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); 6313228238SXin Long skb_queue_head_init(&ulpq->reasm_uo); 641da177e4SLinus Torvalds skb_queue_head_init(&ulpq->lobby); 651da177e4SLinus Torvalds ulpq->pd_mode = 0; 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds return ulpq; 681da177e4SLinus Torvalds } 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* Flush the reassembly and ordering queues. */ 720b58a811SVlad Yasevich void sctp_ulpq_flush(struct sctp_ulpq *ulpq) 731da177e4SLinus Torvalds { 741da177e4SLinus Torvalds struct sk_buff *skb; 751da177e4SLinus Torvalds struct sctp_ulpevent *event; 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds while ((skb = __skb_dequeue(&ulpq->lobby)) != NULL) { 781da177e4SLinus Torvalds event = sctp_skb2event(skb); 791da177e4SLinus Torvalds sctp_ulpevent_free(event); 801da177e4SLinus Torvalds } 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds while ((skb = __skb_dequeue(&ulpq->reasm)) != NULL) { 831da177e4SLinus Torvalds event = sctp_skb2event(skb); 841da177e4SLinus Torvalds sctp_ulpevent_free(event); 851da177e4SLinus Torvalds } 861da177e4SLinus Torvalds 8713228238SXin Long while ((skb = __skb_dequeue(&ulpq->reasm_uo)) != NULL) { 8813228238SXin Long event = sctp_skb2event(skb); 8913228238SXin Long sctp_ulpevent_free(event); 9013228238SXin Long } 911da177e4SLinus Torvalds } 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds /* Dispose of a ulpqueue. */ 941da177e4SLinus Torvalds void sctp_ulpq_free(struct sctp_ulpq *ulpq) 951da177e4SLinus Torvalds { 961da177e4SLinus Torvalds sctp_ulpq_flush(ulpq); 971da177e4SLinus Torvalds } 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds /* Process an incoming DATA chunk. */ 1001da177e4SLinus Torvalds int sctp_ulpq_tail_data(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 101dd0fc66fSAl Viro gfp_t gfp) 1021da177e4SLinus Torvalds { 1031da177e4SLinus Torvalds struct sk_buff_head temp; 1041da177e4SLinus Torvalds struct sctp_ulpevent *event; 105d003b41bSLee A. Roberts int event_eor = 0; 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds /* Create an event from the incoming chunk. */ 1081da177e4SLinus Torvalds event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp); 1091da177e4SLinus Torvalds if (!event) 1101da177e4SLinus Torvalds return -ENOMEM; 1111da177e4SLinus Torvalds 112bd4d627dSXin Long event->ssn = ntohs(chunk->subh.data_hdr->ssn); 113bd4d627dSXin Long event->ppid = chunk->subh.data_hdr->ppid; 114bd4d627dSXin Long 1151da177e4SLinus Torvalds /* Do reassembly if needed. */ 1161da177e4SLinus Torvalds event = sctp_ulpq_reasm(ulpq, event); 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds /* Do ordering if needed. */ 1191da177e4SLinus Torvalds if ((event) && (event->msg_flags & MSG_EOR)) { 1201da177e4SLinus Torvalds /* Create a temporary list to collect chunks on. */ 1211da177e4SLinus Torvalds skb_queue_head_init(&temp); 1221da177e4SLinus Torvalds __skb_queue_tail(&temp, sctp_event2skb(event)); 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds event = sctp_ulpq_order(ulpq, event); 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 1278728b834SDavid S. Miller /* Send event to the ULP. 'event' is the sctp_ulpevent for 1288728b834SDavid S. Miller * very first SKB on the 'temp' list. 1298728b834SDavid S. Miller */ 130d003b41bSLee A. Roberts if (event) { 131d003b41bSLee A. Roberts event_eor = (event->msg_flags & MSG_EOR) ? 1 : 0; 1321da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 133d003b41bSLee A. Roberts } 1341da177e4SLinus Torvalds 135d003b41bSLee A. Roberts return event_eor; 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds /* Add a new event for propagation to the ULP. */ 1391da177e4SLinus Torvalds /* Clear the partial delivery mode for this socket. Note: This 1401da177e4SLinus Torvalds * assumes that no association is currently in partial delivery mode. 1411da177e4SLinus Torvalds */ 142b6e1331fSVlad Yasevich int sctp_clear_pd(struct sock *sk, struct sctp_association *asoc) 1431da177e4SLinus Torvalds { 1441da177e4SLinus Torvalds struct sctp_sock *sp = sctp_sk(sk); 1451da177e4SLinus Torvalds 146b6e1331fSVlad Yasevich if (atomic_dec_and_test(&sp->pd_mode)) { 147b6e1331fSVlad Yasevich /* This means there are no other associations in PD, so 148b6e1331fSVlad Yasevich * we can go ahead and clear out the lobby in one shot 149b6e1331fSVlad Yasevich */ 1501da177e4SLinus Torvalds if (!skb_queue_empty(&sp->pd_lobby)) { 151311b2177SMarcelo Ricardo Leitner skb_queue_splice_tail_init(&sp->pd_lobby, 152311b2177SMarcelo Ricardo Leitner &sk->sk_receive_queue); 1531da177e4SLinus Torvalds return 1; 1541da177e4SLinus Torvalds } 155b6e1331fSVlad Yasevich } else { 156b6e1331fSVlad Yasevich /* There are other associations in PD, so we only need to 157b6e1331fSVlad Yasevich * pull stuff out of the lobby that belongs to the 158b6e1331fSVlad Yasevich * associations that is exiting PD (all of its notifications 159b6e1331fSVlad Yasevich * are posted here). 160b6e1331fSVlad Yasevich */ 161b6e1331fSVlad Yasevich if (!skb_queue_empty(&sp->pd_lobby) && asoc) { 162b6e1331fSVlad Yasevich struct sk_buff *skb, *tmp; 163b6e1331fSVlad Yasevich struct sctp_ulpevent *event; 164b6e1331fSVlad Yasevich 165b6e1331fSVlad Yasevich sctp_skb_for_each(skb, &sp->pd_lobby, tmp) { 166b6e1331fSVlad Yasevich event = sctp_skb2event(skb); 167b6e1331fSVlad Yasevich if (event->asoc == asoc) { 168b6e1331fSVlad Yasevich __skb_unlink(skb, &sp->pd_lobby); 169b6e1331fSVlad Yasevich __skb_queue_tail(&sk->sk_receive_queue, 170b6e1331fSVlad Yasevich skb); 171b6e1331fSVlad Yasevich } 172b6e1331fSVlad Yasevich } 173b6e1331fSVlad Yasevich } 174b6e1331fSVlad Yasevich } 175b6e1331fSVlad Yasevich 1761da177e4SLinus Torvalds return 0; 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds 179d49d91d7SVlad Yasevich /* Set the pd_mode on the socket and ulpq */ 180d49d91d7SVlad Yasevich static void sctp_ulpq_set_pd(struct sctp_ulpq *ulpq) 181d49d91d7SVlad Yasevich { 182d49d91d7SVlad Yasevich struct sctp_sock *sp = sctp_sk(ulpq->asoc->base.sk); 183d49d91d7SVlad Yasevich 184d49d91d7SVlad Yasevich atomic_inc(&sp->pd_mode); 185d49d91d7SVlad Yasevich ulpq->pd_mode = 1; 186d49d91d7SVlad Yasevich } 187d49d91d7SVlad Yasevich 1881da177e4SLinus Torvalds /* Clear the pd_mode and restart any pending messages waiting for delivery. */ 1891da177e4SLinus Torvalds static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq) 1901da177e4SLinus Torvalds { 1911da177e4SLinus Torvalds ulpq->pd_mode = 0; 192ef5d4cf2SVlad Yasevich sctp_ulpq_reasm_drain(ulpq); 193b6e1331fSVlad Yasevich return sctp_clear_pd(ulpq->asoc->base.sk, ulpq->asoc); 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1968728b834SDavid S. Miller /* If the SKB of 'event' is on a list, it is the first such member 1978728b834SDavid S. Miller * of that list. 1988728b834SDavid S. Miller */ 1991da177e4SLinus Torvalds int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event) 2001da177e4SLinus Torvalds { 2011da177e4SLinus Torvalds struct sock *sk = ulpq->asoc->base.sk; 2020970f5b3SMarcelo Ricardo Leitner struct sctp_sock *sp = sctp_sk(sk); 2038728b834SDavid S. Miller struct sk_buff_head *queue, *skb_list; 2048728b834SDavid S. Miller struct sk_buff *skb = sctp_event2skb(event); 2051da177e4SLinus Torvalds int clear_pd = 0; 2061da177e4SLinus Torvalds 2078728b834SDavid S. Miller skb_list = (struct sk_buff_head *) skb->prev; 2088728b834SDavid S. Miller 2091da177e4SLinus Torvalds /* If the socket is just going to throw this away, do not 2101da177e4SLinus Torvalds * even try to deliver it. 2111da177e4SLinus Torvalds */ 212a0fc6843SXin Long if (sk->sk_shutdown & RCV_SHUTDOWN && 213a0fc6843SXin Long (sk->sk_shutdown & SEND_SHUTDOWN || 214a0fc6843SXin Long !sctp_ulpevent_is_notification(event))) 2151da177e4SLinus Torvalds goto out_free; 2161da177e4SLinus Torvalds 2172c8c56e1SEric Dumazet if (!sctp_ulpevent_is_notification(event)) { 2188465a5fcSNeil Horman sk_mark_napi_id(sk, skb); 2192c8c56e1SEric Dumazet sk_incoming_cpu_update(sk); 2202c8c56e1SEric Dumazet } 2211da177e4SLinus Torvalds /* Check if the user wishes to receive this event. */ 222a1e3a059SXin Long if (!sctp_ulpevent_is_enabled(event, ulpq->asoc->subscribe)) 2231da177e4SLinus Torvalds goto out_free; 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds /* If we are in partial delivery mode, post to the lobby until 2261da177e4SLinus Torvalds * partial delivery is cleared, unless, of course _this_ is 2271da177e4SLinus Torvalds * the association the cause of the partial delivery. 2281da177e4SLinus Torvalds */ 2291da177e4SLinus Torvalds 2300970f5b3SMarcelo Ricardo Leitner if (atomic_read(&sp->pd_mode) == 0) { 2311da177e4SLinus Torvalds queue = &sk->sk_receive_queue; 232b6e1331fSVlad Yasevich } else { 233b6e1331fSVlad Yasevich if (ulpq->pd_mode) { 234d0cf0d99SVlad Yasevich /* If the association is in partial delivery, we 235d0cf0d99SVlad Yasevich * need to finish delivering the partially processed 236d0cf0d99SVlad Yasevich * packet before passing any other data. This is 237d0cf0d99SVlad Yasevich * because we don't truly support stream interleaving. 238d0cf0d99SVlad Yasevich */ 239d0cf0d99SVlad Yasevich if ((event->msg_flags & MSG_NOTIFICATION) || 240d0cf0d99SVlad Yasevich (SCTP_DATA_NOT_FRAG == 241d0cf0d99SVlad Yasevich (event->msg_flags & SCTP_DATA_FRAG_MASK))) 2420970f5b3SMarcelo Ricardo Leitner queue = &sp->pd_lobby; 2431da177e4SLinus Torvalds else { 2441da177e4SLinus Torvalds clear_pd = event->msg_flags & MSG_EOR; 2451da177e4SLinus Torvalds queue = &sk->sk_receive_queue; 2461da177e4SLinus Torvalds } 247b6e1331fSVlad Yasevich } else { 248b6e1331fSVlad Yasevich /* 249b6e1331fSVlad Yasevich * If fragment interleave is enabled, we 25025985edcSLucas De Marchi * can queue this to the receive queue instead 251b6e1331fSVlad Yasevich * of the lobby. 252b6e1331fSVlad Yasevich */ 2530970f5b3SMarcelo Ricardo Leitner if (sp->frag_interleave) 254b6e1331fSVlad Yasevich queue = &sk->sk_receive_queue; 255b6e1331fSVlad Yasevich else 2560970f5b3SMarcelo Ricardo Leitner queue = &sp->pd_lobby; 257b6e1331fSVlad Yasevich } 258b6e1331fSVlad Yasevich } 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds /* If we are harvesting multiple skbs they will be 2611da177e4SLinus Torvalds * collected on a list. 2621da177e4SLinus Torvalds */ 2638728b834SDavid S. Miller if (skb_list) 264311b2177SMarcelo Ricardo Leitner skb_queue_splice_tail_init(skb_list, queue); 2651da177e4SLinus Torvalds else 2668728b834SDavid S. Miller __skb_queue_tail(queue, skb); 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds /* Did we just complete partial delivery and need to get 2691da177e4SLinus Torvalds * rolling again? Move pending data to the receive 2701da177e4SLinus Torvalds * queue. 2711da177e4SLinus Torvalds */ 2721da177e4SLinus Torvalds if (clear_pd) 2731da177e4SLinus Torvalds sctp_ulpq_clear_pd(ulpq); 2741da177e4SLinus Torvalds 2750970f5b3SMarcelo Ricardo Leitner if (queue == &sk->sk_receive_queue && !sp->data_ready_signalled) { 2767906b00fSMarcelo Ricardo Leitner if (!sock_owned_by_user(sk)) 2770970f5b3SMarcelo Ricardo Leitner sp->data_ready_signalled = 1; 2780970f5b3SMarcelo Ricardo Leitner sk->sk_data_ready(sk); 2790970f5b3SMarcelo Ricardo Leitner } 2801da177e4SLinus Torvalds return 1; 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds out_free: 2838728b834SDavid S. Miller if (skb_list) 2848728b834SDavid S. Miller sctp_queue_purge_ulpevents(skb_list); 2851da177e4SLinus Torvalds else 2861da177e4SLinus Torvalds sctp_ulpevent_free(event); 2878728b834SDavid S. Miller 2881da177e4SLinus Torvalds return 0; 2891da177e4SLinus Torvalds } 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds /* 2nd Level Abstractions */ 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds /* Helper function to store chunks that need to be reassembled. */ 29401f2d384SVlad Yasevich static void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq, 2951da177e4SLinus Torvalds struct sctp_ulpevent *event) 2961da177e4SLinus Torvalds { 2971da177e4SLinus Torvalds struct sk_buff *pos; 2981da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 2991da177e4SLinus Torvalds __u32 tsn, ctsn; 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds tsn = event->tsn; 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds /* See if it belongs at the end. */ 3041da177e4SLinus Torvalds pos = skb_peek_tail(&ulpq->reasm); 3051da177e4SLinus Torvalds if (!pos) { 3061da177e4SLinus Torvalds __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 3071da177e4SLinus Torvalds return; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds /* Short circuit just dropping it at the end. */ 3111da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 3121da177e4SLinus Torvalds ctsn = cevent->tsn; 3131da177e4SLinus Torvalds if (TSN_lt(ctsn, tsn)) { 3141da177e4SLinus Torvalds __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 3151da177e4SLinus Torvalds return; 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds /* Find the right place in this list. We store them by TSN. */ 3191da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 3201da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 3211da177e4SLinus Torvalds ctsn = cevent->tsn; 3221da177e4SLinus Torvalds 3231da177e4SLinus Torvalds if (TSN_lt(tsn, ctsn)) 3241da177e4SLinus Torvalds break; 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds /* Insert before pos. */ 32843f59c89SDavid S. Miller __skb_queue_before(&ulpq->reasm, pos, sctp_event2skb(event)); 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds /* Helper function to return an event corresponding to the reassembled 3331da177e4SLinus Torvalds * datagram. 3341da177e4SLinus Torvalds * This routine creates a re-assembled skb given the first and last skb's 3351da177e4SLinus Torvalds * as stored in the reassembly queue. The skb's may be non-linear if the sctp 3361da177e4SLinus Torvalds * payload was fragmented on the way and ip had to reassemble them. 3371da177e4SLinus Torvalds * We add the rest of skb's to the first skb's fraglist. 3381da177e4SLinus Torvalds */ 339bd4d627dSXin Long struct sctp_ulpevent *sctp_make_reassembled_event(struct net *net, 340bd4d627dSXin Long struct sk_buff_head *queue, 341bd4d627dSXin Long struct sk_buff *f_frag, 342b01a2407SEric W. Biederman struct sk_buff *l_frag) 3431da177e4SLinus Torvalds { 3441da177e4SLinus Torvalds struct sk_buff *pos; 345672e7ccaSVladislav Yasevich struct sk_buff *new = NULL; 3461da177e4SLinus Torvalds struct sctp_ulpevent *event; 3471da177e4SLinus Torvalds struct sk_buff *pnext, *last; 3481da177e4SLinus Torvalds struct sk_buff *list = skb_shinfo(f_frag)->frag_list; 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds /* Store the pointer to the 2nd skb */ 3511da177e4SLinus Torvalds if (f_frag == l_frag) 3521da177e4SLinus Torvalds pos = NULL; 3531da177e4SLinus Torvalds else 3541da177e4SLinus Torvalds pos = f_frag->next; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds /* Get the last skb in the f_frag's frag_list if present. */ 3578d72651dSwangweidong for (last = list; list; last = list, list = list->next) 3588d72651dSwangweidong ; 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds /* Add the list of remaining fragments to the first fragments 3611da177e4SLinus Torvalds * frag_list. 3621da177e4SLinus Torvalds */ 3631da177e4SLinus Torvalds if (last) 3641da177e4SLinus Torvalds last->next = pos; 365672e7ccaSVladislav Yasevich else { 366672e7ccaSVladislav Yasevich if (skb_cloned(f_frag)) { 367672e7ccaSVladislav Yasevich /* This is a cloned skb, we can't just modify 368672e7ccaSVladislav Yasevich * the frag_list. We need a new skb to do that. 369672e7ccaSVladislav Yasevich * Instead of calling skb_unshare(), we'll do it 370672e7ccaSVladislav Yasevich * ourselves since we need to delay the free. 371672e7ccaSVladislav Yasevich */ 372672e7ccaSVladislav Yasevich new = skb_copy(f_frag, GFP_ATOMIC); 373672e7ccaSVladislav Yasevich if (!new) 374672e7ccaSVladislav Yasevich return NULL; /* try again later */ 375672e7ccaSVladislav Yasevich 376331c4ee7SVlad Yasevich sctp_skb_set_owner_r(new, f_frag->sk); 377672e7ccaSVladislav Yasevich 378672e7ccaSVladislav Yasevich skb_shinfo(new)->frag_list = pos; 379672e7ccaSVladislav Yasevich } else 3801da177e4SLinus Torvalds skb_shinfo(f_frag)->frag_list = pos; 381672e7ccaSVladislav Yasevich } 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds /* Remove the first fragment from the reassembly queue. */ 3848728b834SDavid S. Miller __skb_unlink(f_frag, queue); 385672e7ccaSVladislav Yasevich 386672e7ccaSVladislav Yasevich /* if we did unshare, then free the old skb and re-assign */ 387672e7ccaSVladislav Yasevich if (new) { 388672e7ccaSVladislav Yasevich kfree_skb(f_frag); 389672e7ccaSVladislav Yasevich f_frag = new; 390672e7ccaSVladislav Yasevich } 391672e7ccaSVladislav Yasevich 3921da177e4SLinus Torvalds while (pos) { 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds pnext = pos->next; 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds /* Update the len and data_len fields of the first fragment. */ 3971da177e4SLinus Torvalds f_frag->len += pos->len; 3981da177e4SLinus Torvalds f_frag->data_len += pos->len; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds /* Remove the fragment from the reassembly queue. */ 4018728b834SDavid S. Miller __skb_unlink(pos, queue); 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds /* Break if we have reached the last fragment. */ 4041da177e4SLinus Torvalds if (pos == l_frag) 4051da177e4SLinus Torvalds break; 4061da177e4SLinus Torvalds pos->next = pnext; 4071da177e4SLinus Torvalds pos = pnext; 4083ff50b79SStephen Hemminger } 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds event = sctp_skb2event(f_frag); 411b01a2407SEric W. Biederman SCTP_INC_STATS(net, SCTP_MIB_REASMUSRMSGS); 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds return event; 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds /* Helper function to check if an incoming chunk has filled up the last 4181da177e4SLinus Torvalds * missing fragment in a SCTP datagram and return the corresponding event. 4191da177e4SLinus Torvalds */ 42001f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq) 4211da177e4SLinus Torvalds { 4221da177e4SLinus Torvalds struct sk_buff *pos; 4231da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 4241da177e4SLinus Torvalds struct sk_buff *first_frag = NULL; 4251da177e4SLinus Torvalds __u32 ctsn, next_tsn; 4261da177e4SLinus Torvalds struct sctp_ulpevent *retval = NULL; 427d49d91d7SVlad Yasevich struct sk_buff *pd_first = NULL; 428d49d91d7SVlad Yasevich struct sk_buff *pd_last = NULL; 429d49d91d7SVlad Yasevich size_t pd_len = 0; 430d49d91d7SVlad Yasevich struct sctp_association *asoc; 431d49d91d7SVlad Yasevich u32 pd_point; 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds /* Initialized to 0 just to avoid compiler warning message. Will 4341da177e4SLinus Torvalds * never be used with this value. It is referenced only after it 4351da177e4SLinus Torvalds * is set when we find the first fragment of a message. 4361da177e4SLinus Torvalds */ 4371da177e4SLinus Torvalds next_tsn = 0; 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 4401da177e4SLinus Torvalds * Walk through the queue sequentially and look for a sequence of 4411da177e4SLinus Torvalds * fragmented chunks that complete a datagram. 4421da177e4SLinus Torvalds * 'first_frag' and next_tsn are reset when we find a chunk which 4431da177e4SLinus Torvalds * is the first fragment of a datagram. Once these 2 fields are set 4441da177e4SLinus Torvalds * we expect to find the remaining middle fragments and the last 4451da177e4SLinus Torvalds * fragment in order. If not, first_frag is reset to NULL and we 4461da177e4SLinus Torvalds * start the next pass when we find another first fragment. 447d49d91d7SVlad Yasevich * 448d49d91d7SVlad Yasevich * There is a potential to do partial delivery if user sets 449d49d91d7SVlad Yasevich * SCTP_PARTIAL_DELIVERY_POINT option. Lets count some things here 450d49d91d7SVlad Yasevich * to see if can do PD. 4511da177e4SLinus Torvalds */ 4521da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 4531da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 4541da177e4SLinus Torvalds ctsn = cevent->tsn; 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 4571da177e4SLinus Torvalds case SCTP_DATA_FIRST_FRAG: 458d49d91d7SVlad Yasevich /* If this "FIRST_FRAG" is the first 459d49d91d7SVlad Yasevich * element in the queue, then count it towards 460d49d91d7SVlad Yasevich * possible PD. 461d49d91d7SVlad Yasevich */ 4621181d629SDavid S. Miller if (skb_queue_is_first(&ulpq->reasm, pos)) { 463d49d91d7SVlad Yasevich pd_first = pos; 464d49d91d7SVlad Yasevich pd_last = pos; 465d49d91d7SVlad Yasevich pd_len = pos->len; 466d49d91d7SVlad Yasevich } else { 467d49d91d7SVlad Yasevich pd_first = NULL; 468d49d91d7SVlad Yasevich pd_last = NULL; 469d49d91d7SVlad Yasevich pd_len = 0; 470d49d91d7SVlad Yasevich } 471d49d91d7SVlad Yasevich 4721da177e4SLinus Torvalds first_frag = pos; 4731da177e4SLinus Torvalds next_tsn = ctsn + 1; 4741da177e4SLinus Torvalds break; 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 477d49d91d7SVlad Yasevich if ((first_frag) && (ctsn == next_tsn)) { 4781da177e4SLinus Torvalds next_tsn++; 479d49d91d7SVlad Yasevich if (pd_first) { 480d49d91d7SVlad Yasevich pd_last = pos; 481d49d91d7SVlad Yasevich pd_len += pos->len; 482d49d91d7SVlad Yasevich } 483d49d91d7SVlad Yasevich } else 4841da177e4SLinus Torvalds first_frag = NULL; 4851da177e4SLinus Torvalds break; 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds case SCTP_DATA_LAST_FRAG: 4881da177e4SLinus Torvalds if (first_frag && (ctsn == next_tsn)) 4891da177e4SLinus Torvalds goto found; 4901da177e4SLinus Torvalds else 4911da177e4SLinus Torvalds first_frag = NULL; 4921da177e4SLinus Torvalds break; 4933ff50b79SStephen Hemminger } 494d49d91d7SVlad Yasevich } 4951da177e4SLinus Torvalds 496d49d91d7SVlad Yasevich asoc = ulpq->asoc; 497d49d91d7SVlad Yasevich if (pd_first) { 498d49d91d7SVlad Yasevich /* Make sure we can enter partial deliver. 499d49d91d7SVlad Yasevich * We can trigger partial delivery only if framgent 500d49d91d7SVlad Yasevich * interleave is set, or the socket is not already 501d49d91d7SVlad Yasevich * in partial delivery. 502d49d91d7SVlad Yasevich */ 503d49d91d7SVlad Yasevich if (!sctp_sk(asoc->base.sk)->frag_interleave && 504d49d91d7SVlad Yasevich atomic_read(&sctp_sk(asoc->base.sk)->pd_mode)) 505d49d91d7SVlad Yasevich goto done; 506d49d91d7SVlad Yasevich 507d49d91d7SVlad Yasevich cevent = sctp_skb2event(pd_first); 508d49d91d7SVlad Yasevich pd_point = sctp_sk(asoc->base.sk)->pd_point; 509d49d91d7SVlad Yasevich if (pd_point && pd_point <= pd_len) { 510b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 511b01a2407SEric W. Biederman &ulpq->reasm, 512d49d91d7SVlad Yasevich pd_first, 513d49d91d7SVlad Yasevich pd_last); 514d49d91d7SVlad Yasevich if (retval) 515d49d91d7SVlad Yasevich sctp_ulpq_set_pd(ulpq); 516d49d91d7SVlad Yasevich } 5171da177e4SLinus Torvalds } 5181da177e4SLinus Torvalds done: 5191da177e4SLinus Torvalds return retval; 5201da177e4SLinus Torvalds found: 521b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 522b01a2407SEric W. Biederman &ulpq->reasm, first_frag, pos); 5231da177e4SLinus Torvalds if (retval) 5241da177e4SLinus Torvalds retval->msg_flags |= MSG_EOR; 5251da177e4SLinus Torvalds goto done; 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds /* Retrieve the next set of fragments of a partial message. */ 52901f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq) 5301da177e4SLinus Torvalds { 5311da177e4SLinus Torvalds struct sk_buff *pos, *last_frag, *first_frag; 5321da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 5331da177e4SLinus Torvalds __u32 ctsn, next_tsn; 5341da177e4SLinus Torvalds int is_last; 5351da177e4SLinus Torvalds struct sctp_ulpevent *retval; 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 5381da177e4SLinus Torvalds * Walk through the queue sequentially and look for the first 5391da177e4SLinus Torvalds * sequence of fragmented chunks. 5401da177e4SLinus Torvalds */ 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds if (skb_queue_empty(&ulpq->reasm)) 5431da177e4SLinus Torvalds return NULL; 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds last_frag = first_frag = NULL; 5461da177e4SLinus Torvalds retval = NULL; 5471da177e4SLinus Torvalds next_tsn = 0; 5481da177e4SLinus Torvalds is_last = 0; 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 5511da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 5521da177e4SLinus Torvalds ctsn = cevent->tsn; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 555d003b41bSLee A. Roberts case SCTP_DATA_FIRST_FRAG: 556d003b41bSLee A. Roberts if (!first_frag) 557d003b41bSLee A. Roberts return NULL; 558d003b41bSLee A. Roberts goto done; 5591da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 5601da177e4SLinus Torvalds if (!first_frag) { 5611da177e4SLinus Torvalds first_frag = pos; 5621da177e4SLinus Torvalds next_tsn = ctsn + 1; 5631da177e4SLinus Torvalds last_frag = pos; 564d003b41bSLee A. Roberts } else if (next_tsn == ctsn) { 5651da177e4SLinus Torvalds next_tsn++; 566d003b41bSLee A. Roberts last_frag = pos; 567d003b41bSLee A. Roberts } else 5681da177e4SLinus Torvalds goto done; 5691da177e4SLinus Torvalds break; 5701da177e4SLinus Torvalds case SCTP_DATA_LAST_FRAG: 5711da177e4SLinus Torvalds if (!first_frag) 5721da177e4SLinus Torvalds first_frag = pos; 5731da177e4SLinus Torvalds else if (ctsn != next_tsn) 5741da177e4SLinus Torvalds goto done; 5751da177e4SLinus Torvalds last_frag = pos; 5761da177e4SLinus Torvalds is_last = 1; 5771da177e4SLinus Torvalds goto done; 5781da177e4SLinus Torvalds default: 5791da177e4SLinus Torvalds return NULL; 5803ff50b79SStephen Hemminger } 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds /* We have the reassembled event. There is no need to look 5841da177e4SLinus Torvalds * further. 5851da177e4SLinus Torvalds */ 5861da177e4SLinus Torvalds done: 587b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 588b01a2407SEric W. Biederman &ulpq->reasm, first_frag, last_frag); 5891da177e4SLinus Torvalds if (retval && is_last) 5901da177e4SLinus Torvalds retval->msg_flags |= MSG_EOR; 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds return retval; 5931da177e4SLinus Torvalds } 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds /* Helper function to reassemble chunks. Hold chunks on the reasm queue that 5971da177e4SLinus Torvalds * need reassembling. 5981da177e4SLinus Torvalds */ 5991da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq, 6001da177e4SLinus Torvalds struct sctp_ulpevent *event) 6011da177e4SLinus Torvalds { 6021da177e4SLinus Torvalds struct sctp_ulpevent *retval = NULL; 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds /* Check if this is part of a fragmented message. */ 6051da177e4SLinus Torvalds if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) { 6061da177e4SLinus Torvalds event->msg_flags |= MSG_EOR; 6071da177e4SLinus Torvalds return event; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds sctp_ulpq_store_reasm(ulpq, event); 6111da177e4SLinus Torvalds if (!ulpq->pd_mode) 6121da177e4SLinus Torvalds retval = sctp_ulpq_retrieve_reassembled(ulpq); 6131da177e4SLinus Torvalds else { 6141da177e4SLinus Torvalds __u32 ctsn, ctsnap; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds /* Do not even bother unless this is the next tsn to 6171da177e4SLinus Torvalds * be delivered. 6181da177e4SLinus Torvalds */ 6191da177e4SLinus Torvalds ctsn = event->tsn; 6201da177e4SLinus Torvalds ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map); 6211da177e4SLinus Torvalds if (TSN_lte(ctsn, ctsnap)) 6221da177e4SLinus Torvalds retval = sctp_ulpq_retrieve_partial(ulpq); 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds return retval; 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds /* Retrieve the first part (sequential fragments) for partial delivery. */ 62901f2d384SVlad Yasevich static struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq) 6301da177e4SLinus Torvalds { 6311da177e4SLinus Torvalds struct sk_buff *pos, *last_frag, *first_frag; 6321da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 6331da177e4SLinus Torvalds __u32 ctsn, next_tsn; 6341da177e4SLinus Torvalds struct sctp_ulpevent *retval; 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* The chunks are held in the reasm queue sorted by TSN. 6371da177e4SLinus Torvalds * Walk through the queue sequentially and look for a sequence of 6381da177e4SLinus Torvalds * fragmented chunks that start a datagram. 6391da177e4SLinus Torvalds */ 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds if (skb_queue_empty(&ulpq->reasm)) 6421da177e4SLinus Torvalds return NULL; 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds last_frag = first_frag = NULL; 6451da177e4SLinus Torvalds retval = NULL; 6461da177e4SLinus Torvalds next_tsn = 0; 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds skb_queue_walk(&ulpq->reasm, pos) { 6491da177e4SLinus Torvalds cevent = sctp_skb2event(pos); 6501da177e4SLinus Torvalds ctsn = cevent->tsn; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 6531da177e4SLinus Torvalds case SCTP_DATA_FIRST_FRAG: 6541da177e4SLinus Torvalds if (!first_frag) { 6551da177e4SLinus Torvalds first_frag = pos; 6561da177e4SLinus Torvalds next_tsn = ctsn + 1; 6571da177e4SLinus Torvalds last_frag = pos; 6581da177e4SLinus Torvalds } else 6591da177e4SLinus Torvalds goto done; 6601da177e4SLinus Torvalds break; 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds case SCTP_DATA_MIDDLE_FRAG: 6631da177e4SLinus Torvalds if (!first_frag) 6641da177e4SLinus Torvalds return NULL; 6651da177e4SLinus Torvalds if (ctsn == next_tsn) { 6661da177e4SLinus Torvalds next_tsn++; 6671da177e4SLinus Torvalds last_frag = pos; 6681da177e4SLinus Torvalds } else 6691da177e4SLinus Torvalds goto done; 6701da177e4SLinus Torvalds break; 671d003b41bSLee A. Roberts 672d003b41bSLee A. Roberts case SCTP_DATA_LAST_FRAG: 673d003b41bSLee A. Roberts if (!first_frag) 674d003b41bSLee A. Roberts return NULL; 675d003b41bSLee A. Roberts else 676d003b41bSLee A. Roberts goto done; 677d003b41bSLee A. Roberts break; 678d003b41bSLee A. Roberts 6791da177e4SLinus Torvalds default: 6801da177e4SLinus Torvalds return NULL; 6813ff50b79SStephen Hemminger } 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds /* We have the reassembled event. There is no need to look 6851da177e4SLinus Torvalds * further. 6861da177e4SLinus Torvalds */ 6871da177e4SLinus Torvalds done: 688b01a2407SEric W. Biederman retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 689b01a2407SEric W. Biederman &ulpq->reasm, first_frag, last_frag); 6901da177e4SLinus Torvalds return retval; 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 693ea2dfb37SVlad Yasevich /* 694ea2dfb37SVlad Yasevich * Flush out stale fragments from the reassembly queue when processing 695ea2dfb37SVlad Yasevich * a Forward TSN. 696ea2dfb37SVlad Yasevich * 697ea2dfb37SVlad Yasevich * RFC 3758, Section 3.6 698ea2dfb37SVlad Yasevich * 699ea2dfb37SVlad Yasevich * After receiving and processing a FORWARD TSN, the data receiver MUST 700ea2dfb37SVlad Yasevich * take cautions in updating its re-assembly queue. The receiver MUST 701ea2dfb37SVlad Yasevich * remove any partially reassembled message, which is still missing one 702ea2dfb37SVlad Yasevich * or more TSNs earlier than or equal to the new cumulative TSN point. 703ea2dfb37SVlad Yasevich * In the event that the receiver has invoked the partial delivery API, 704ea2dfb37SVlad Yasevich * a notification SHOULD also be generated to inform the upper layer API 705ea2dfb37SVlad Yasevich * that the message being partially delivered will NOT be completed. 706ea2dfb37SVlad Yasevich */ 707ea2dfb37SVlad Yasevich void sctp_ulpq_reasm_flushtsn(struct sctp_ulpq *ulpq, __u32 fwd_tsn) 708ea2dfb37SVlad Yasevich { 709ea2dfb37SVlad Yasevich struct sk_buff *pos, *tmp; 710ea2dfb37SVlad Yasevich struct sctp_ulpevent *event; 711ea2dfb37SVlad Yasevich __u32 tsn; 712ea2dfb37SVlad Yasevich 713ea2dfb37SVlad Yasevich if (skb_queue_empty(&ulpq->reasm)) 714ea2dfb37SVlad Yasevich return; 715ea2dfb37SVlad Yasevich 716ea2dfb37SVlad Yasevich skb_queue_walk_safe(&ulpq->reasm, pos, tmp) { 717ea2dfb37SVlad Yasevich event = sctp_skb2event(pos); 718ea2dfb37SVlad Yasevich tsn = event->tsn; 719ea2dfb37SVlad Yasevich 720ea2dfb37SVlad Yasevich /* Since the entire message must be abandoned by the 721ea2dfb37SVlad Yasevich * sender (item A3 in Section 3.5, RFC 3758), we can 722ea2dfb37SVlad Yasevich * free all fragments on the list that are less then 723ea2dfb37SVlad Yasevich * or equal to ctsn_point 724ea2dfb37SVlad Yasevich */ 725ea2dfb37SVlad Yasevich if (TSN_lte(tsn, fwd_tsn)) { 726ea2dfb37SVlad Yasevich __skb_unlink(pos, &ulpq->reasm); 727ea2dfb37SVlad Yasevich sctp_ulpevent_free(event); 728ea2dfb37SVlad Yasevich } else 729ea2dfb37SVlad Yasevich break; 730ea2dfb37SVlad Yasevich } 731ea2dfb37SVlad Yasevich } 732ea2dfb37SVlad Yasevich 733ef5d4cf2SVlad Yasevich /* 734ef5d4cf2SVlad Yasevich * Drain the reassembly queue. If we just cleared parted delivery, it 735ef5d4cf2SVlad Yasevich * is possible that the reassembly queue will contain already reassembled 736ef5d4cf2SVlad Yasevich * messages. Retrieve any such messages and give them to the user. 737ef5d4cf2SVlad Yasevich */ 738ef5d4cf2SVlad Yasevich static void sctp_ulpq_reasm_drain(struct sctp_ulpq *ulpq) 739ef5d4cf2SVlad Yasevich { 740ef5d4cf2SVlad Yasevich struct sctp_ulpevent *event = NULL; 741ef5d4cf2SVlad Yasevich 742ef5d4cf2SVlad Yasevich if (skb_queue_empty(&ulpq->reasm)) 743ef5d4cf2SVlad Yasevich return; 744ef5d4cf2SVlad Yasevich 745ef5d4cf2SVlad Yasevich while ((event = sctp_ulpq_retrieve_reassembled(ulpq)) != NULL) { 746925b9374SDavid Miller struct sk_buff_head temp; 747925b9374SDavid Miller 748ef5d4cf2SVlad Yasevich skb_queue_head_init(&temp); 749ef5d4cf2SVlad Yasevich __skb_queue_tail(&temp, sctp_event2skb(event)); 750ef5d4cf2SVlad Yasevich 751925b9374SDavid Miller /* Do ordering if needed. */ 752925b9374SDavid Miller if (event->msg_flags & MSG_EOR) 753ef5d4cf2SVlad Yasevich event = sctp_ulpq_order(ulpq, event); 754ef5d4cf2SVlad Yasevich 755ef5d4cf2SVlad Yasevich /* Send event to the ULP. 'event' is the 756ef5d4cf2SVlad Yasevich * sctp_ulpevent for very first SKB on the temp' list. 757ef5d4cf2SVlad Yasevich */ 758ef5d4cf2SVlad Yasevich if (event) 759ef5d4cf2SVlad Yasevich sctp_ulpq_tail_event(ulpq, event); 760ef5d4cf2SVlad Yasevich } 761ef5d4cf2SVlad Yasevich } 762ef5d4cf2SVlad Yasevich 763ef5d4cf2SVlad Yasevich 7641da177e4SLinus Torvalds /* Helper function to gather skbs that have possibly become 7651da177e4SLinus Torvalds * ordered by an an incoming chunk. 7661da177e4SLinus Torvalds */ 76701f2d384SVlad Yasevich static void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq, 7681da177e4SLinus Torvalds struct sctp_ulpevent *event) 7691da177e4SLinus Torvalds { 7708728b834SDavid S. Miller struct sk_buff_head *event_list; 7711da177e4SLinus Torvalds struct sk_buff *pos, *tmp; 7721da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 773a8386317SXin Long struct sctp_stream *stream; 774efea2c6bSHagen Paul Pfeifer __u16 sid, csid, cssn; 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds sid = event->stream; 777cee360abSXin Long stream = &ulpq->asoc->stream; 7781da177e4SLinus Torvalds 7798728b834SDavid S. Miller event_list = (struct sk_buff_head *) sctp_event2skb(event)->prev; 7808728b834SDavid S. Miller 7811da177e4SLinus Torvalds /* We are holding the chunks by stream, by SSN. */ 7821da177e4SLinus Torvalds sctp_skb_for_each(pos, &ulpq->lobby, tmp) { 7831da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 7841da177e4SLinus Torvalds csid = cevent->stream; 7851da177e4SLinus Torvalds cssn = cevent->ssn; 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds /* Have we gone too far? */ 7881da177e4SLinus Torvalds if (csid > sid) 7891da177e4SLinus Torvalds break; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds /* Have we not gone far enough? */ 7921da177e4SLinus Torvalds if (csid < sid) 7931da177e4SLinus Torvalds continue; 7941da177e4SLinus Torvalds 795a8386317SXin Long if (cssn != sctp_ssn_peek(stream, in, sid)) 7961da177e4SLinus Torvalds break; 7971da177e4SLinus Torvalds 798a8386317SXin Long /* Found it, so mark in the stream. */ 799a8386317SXin Long sctp_ssn_next(stream, in, sid); 8001da177e4SLinus Torvalds 8018728b834SDavid S. Miller __skb_unlink(pos, &ulpq->lobby); 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds /* Attach all gathered skbs to the event. */ 8048728b834SDavid S. Miller __skb_queue_tail(event_list, pos); 8051da177e4SLinus Torvalds } 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds /* Helper function to store chunks needing ordering. */ 80901f2d384SVlad Yasevich static void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq, 8101da177e4SLinus Torvalds struct sctp_ulpevent *event) 8111da177e4SLinus Torvalds { 8121da177e4SLinus Torvalds struct sk_buff *pos; 8131da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 8141da177e4SLinus Torvalds __u16 sid, csid; 8151da177e4SLinus Torvalds __u16 ssn, cssn; 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds pos = skb_peek_tail(&ulpq->lobby); 8181da177e4SLinus Torvalds if (!pos) { 8191da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8201da177e4SLinus Torvalds return; 8211da177e4SLinus Torvalds } 8221da177e4SLinus Torvalds 8231da177e4SLinus Torvalds sid = event->stream; 8241da177e4SLinus Torvalds ssn = event->ssn; 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 8271da177e4SLinus Torvalds csid = cevent->stream; 8281da177e4SLinus Torvalds cssn = cevent->ssn; 8291da177e4SLinus Torvalds if (sid > csid) { 8301da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8311da177e4SLinus Torvalds return; 8321da177e4SLinus Torvalds } 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds if ((sid == csid) && SSN_lt(cssn, ssn)) { 8351da177e4SLinus Torvalds __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 8361da177e4SLinus Torvalds return; 8371da177e4SLinus Torvalds } 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds /* Find the right place in this list. We store them by 8401da177e4SLinus Torvalds * stream ID and then by SSN. 8411da177e4SLinus Torvalds */ 8421da177e4SLinus Torvalds skb_queue_walk(&ulpq->lobby, pos) { 8431da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 8441da177e4SLinus Torvalds csid = cevent->stream; 8451da177e4SLinus Torvalds cssn = cevent->ssn; 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds if (csid > sid) 8481da177e4SLinus Torvalds break; 8491da177e4SLinus Torvalds if (csid == sid && SSN_lt(ssn, cssn)) 8501da177e4SLinus Torvalds break; 8511da177e4SLinus Torvalds } 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds /* Insert before pos. */ 85543f59c89SDavid S. Miller __skb_queue_before(&ulpq->lobby, pos, sctp_event2skb(event)); 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq, 8591da177e4SLinus Torvalds struct sctp_ulpevent *event) 8601da177e4SLinus Torvalds { 8611da177e4SLinus Torvalds __u16 sid, ssn; 862a8386317SXin Long struct sctp_stream *stream; 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds /* Check if this message needs ordering. */ 865bd4d627dSXin Long if (event->msg_flags & SCTP_DATA_UNORDERED) 8661da177e4SLinus Torvalds return event; 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds /* Note: The stream ID must be verified before this routine. */ 8691da177e4SLinus Torvalds sid = event->stream; 8701da177e4SLinus Torvalds ssn = event->ssn; 871cee360abSXin Long stream = &ulpq->asoc->stream; 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds /* Is this the expected SSN for this stream ID? */ 874a8386317SXin Long if (ssn != sctp_ssn_peek(stream, in, sid)) { 8751da177e4SLinus Torvalds /* We've received something out of order, so find where it 8761da177e4SLinus Torvalds * needs to be placed. We order by stream and then by SSN. 8771da177e4SLinus Torvalds */ 8781da177e4SLinus Torvalds sctp_ulpq_store_ordered(ulpq, event); 8791da177e4SLinus Torvalds return NULL; 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds /* Mark that the next chunk has been found. */ 883a8386317SXin Long sctp_ssn_next(stream, in, sid); 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds /* Go find any other chunks that were waiting for 8861da177e4SLinus Torvalds * ordering. 8871da177e4SLinus Torvalds */ 8881da177e4SLinus Torvalds sctp_ulpq_retrieve_ordered(ulpq, event); 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds return event; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds /* Helper function to gather skbs that have possibly become 8941da177e4SLinus Torvalds * ordered by forward tsn skipping their dependencies. 8951da177e4SLinus Torvalds */ 89601f2d384SVlad Yasevich static void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq, __u16 sid) 8971da177e4SLinus Torvalds { 8981da177e4SLinus Torvalds struct sk_buff *pos, *tmp; 8991da177e4SLinus Torvalds struct sctp_ulpevent *cevent; 9008728b834SDavid S. Miller struct sctp_ulpevent *event; 901a8386317SXin Long struct sctp_stream *stream; 9021da177e4SLinus Torvalds struct sk_buff_head temp; 903c068be54SVlad Yasevich struct sk_buff_head *lobby = &ulpq->lobby; 9041da177e4SLinus Torvalds __u16 csid, cssn; 9051da177e4SLinus Torvalds 906cee360abSXin Long stream = &ulpq->asoc->stream; 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds /* We are holding the chunks by stream, by SSN. */ 9098728b834SDavid S. Miller skb_queue_head_init(&temp); 9108728b834SDavid S. Miller event = NULL; 911c068be54SVlad Yasevich sctp_skb_for_each(pos, lobby, tmp) { 9121da177e4SLinus Torvalds cevent = (struct sctp_ulpevent *) pos->cb; 9131da177e4SLinus Torvalds csid = cevent->stream; 9141da177e4SLinus Torvalds cssn = cevent->ssn; 9151da177e4SLinus Torvalds 916ea2dfb37SVlad Yasevich /* Have we gone too far? */ 917ea2dfb37SVlad Yasevich if (csid > sid) 9181da177e4SLinus Torvalds break; 9191da177e4SLinus Torvalds 920ea2dfb37SVlad Yasevich /* Have we not gone far enough? */ 921ea2dfb37SVlad Yasevich if (csid < sid) 922ea2dfb37SVlad Yasevich continue; 923ea2dfb37SVlad Yasevich 924ea2dfb37SVlad Yasevich /* see if this ssn has been marked by skipping */ 925a8386317SXin Long if (!SSN_lt(cssn, sctp_ssn_peek(stream, in, csid))) 926ea2dfb37SVlad Yasevich break; 9271da177e4SLinus Torvalds 928c068be54SVlad Yasevich __skb_unlink(pos, lobby); 929ea2dfb37SVlad Yasevich if (!event) 9301da177e4SLinus Torvalds /* Create a temporary list to collect chunks on. */ 9311da177e4SLinus Torvalds event = sctp_skb2event(pos); 932ea2dfb37SVlad Yasevich 9331da177e4SLinus Torvalds /* Attach all gathered skbs to the event. */ 9348728b834SDavid S. Miller __skb_queue_tail(&temp, pos); 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds 937c068be54SVlad Yasevich /* If we didn't reap any data, see if the next expected SSN 938c068be54SVlad Yasevich * is next on the queue and if so, use that. 939c068be54SVlad Yasevich */ 940c068be54SVlad Yasevich if (event == NULL && pos != (struct sk_buff *)lobby) { 941c068be54SVlad Yasevich cevent = (struct sctp_ulpevent *) pos->cb; 942c068be54SVlad Yasevich csid = cevent->stream; 943c068be54SVlad Yasevich cssn = cevent->ssn; 944c068be54SVlad Yasevich 945a8386317SXin Long if (csid == sid && cssn == sctp_ssn_peek(stream, in, csid)) { 946a8386317SXin Long sctp_ssn_next(stream, in, csid); 947c068be54SVlad Yasevich __skb_unlink(pos, lobby); 948c068be54SVlad Yasevich __skb_queue_tail(&temp, pos); 949c068be54SVlad Yasevich event = sctp_skb2event(pos); 950c068be54SVlad Yasevich } 951c068be54SVlad Yasevich } 952c068be54SVlad Yasevich 9538728b834SDavid S. Miller /* Send event to the ULP. 'event' is the sctp_ulpevent for 9548728b834SDavid S. Miller * very first SKB on the 'temp' list. 9558728b834SDavid S. Miller */ 956ea2dfb37SVlad Yasevich if (event) { 957ea2dfb37SVlad Yasevich /* see if we have more ordered that we can deliver */ 958ea2dfb37SVlad Yasevich sctp_ulpq_retrieve_ordered(ulpq, event); 9591da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 9601da177e4SLinus Torvalds } 961ea2dfb37SVlad Yasevich } 9621da177e4SLinus Torvalds 963ea2dfb37SVlad Yasevich /* Skip over an SSN. This is used during the processing of 964ea2dfb37SVlad Yasevich * Forwared TSN chunk to skip over the abandoned ordered data 965ea2dfb37SVlad Yasevich */ 9661da177e4SLinus Torvalds void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn) 9671da177e4SLinus Torvalds { 968a8386317SXin Long struct sctp_stream *stream; 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds /* Note: The stream ID must be verified before this routine. */ 971cee360abSXin Long stream = &ulpq->asoc->stream; 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds /* Is this an old SSN? If so ignore. */ 974a8386317SXin Long if (SSN_lt(ssn, sctp_ssn_peek(stream, in, sid))) 9751da177e4SLinus Torvalds return; 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds /* Mark that we are no longer expecting this SSN or lower. */ 978a8386317SXin Long sctp_ssn_skip(stream, in, sid, ssn); 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds /* Go find any other chunks that were waiting for 9811da177e4SLinus Torvalds * ordering and deliver them if needed. 9821da177e4SLinus Torvalds */ 983ea2dfb37SVlad Yasevich sctp_ulpq_reap_ordered(ulpq, sid); 9841da177e4SLinus Torvalds } 9851da177e4SLinus Torvalds 98694014e8dSXin Long __u16 sctp_ulpq_renege_list(struct sctp_ulpq *ulpq, struct sk_buff_head *list, 98794014e8dSXin Long __u16 needed) 9881da177e4SLinus Torvalds { 9891da177e4SLinus Torvalds __u16 freed = 0; 99095ac7b85SLee A. Roberts __u32 tsn, last_tsn; 99195ac7b85SLee A. Roberts struct sk_buff *skb, *flist, *last; 9921da177e4SLinus Torvalds struct sctp_ulpevent *event; 9931da177e4SLinus Torvalds struct sctp_tsnmap *tsnmap; 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds tsnmap = &ulpq->asoc->peer.tsn_map; 9961da177e4SLinus Torvalds 997e67f85ecSLee A. Roberts while ((skb = skb_peek_tail(list)) != NULL) { 9981da177e4SLinus Torvalds event = sctp_skb2event(skb); 9991da177e4SLinus Torvalds tsn = event->tsn; 10001da177e4SLinus Torvalds 1001e67f85ecSLee A. Roberts /* Don't renege below the Cumulative TSN ACK Point. */ 1002e67f85ecSLee A. Roberts if (TSN_lte(tsn, sctp_tsnmap_get_ctsn(tsnmap))) 1003e67f85ecSLee A. Roberts break; 1004e67f85ecSLee A. Roberts 100595ac7b85SLee A. Roberts /* Events in ordering queue may have multiple fragments 100695ac7b85SLee A. Roberts * corresponding to additional TSNs. Sum the total 100795ac7b85SLee A. Roberts * freed space; find the last TSN. 100895ac7b85SLee A. Roberts */ 1009e67f85ecSLee A. Roberts freed += skb_headlen(skb); 101095ac7b85SLee A. Roberts flist = skb_shinfo(skb)->frag_list; 101195ac7b85SLee A. Roberts for (last = flist; flist; flist = flist->next) { 101295ac7b85SLee A. Roberts last = flist; 101395ac7b85SLee A. Roberts freed += skb_headlen(last); 101495ac7b85SLee A. Roberts } 101595ac7b85SLee A. Roberts if (last) 101695ac7b85SLee A. Roberts last_tsn = sctp_skb2event(last)->tsn; 101795ac7b85SLee A. Roberts else 101895ac7b85SLee A. Roberts last_tsn = tsn; 101995ac7b85SLee A. Roberts 102095ac7b85SLee A. Roberts /* Unlink the event, then renege all applicable TSNs. */ 102195ac7b85SLee A. Roberts __skb_unlink(skb, list); 10221da177e4SLinus Torvalds sctp_ulpevent_free(event); 102395ac7b85SLee A. Roberts while (TSN_lte(tsn, last_tsn)) { 10241da177e4SLinus Torvalds sctp_tsnmap_renege(tsnmap, tsn); 102595ac7b85SLee A. Roberts tsn++; 102695ac7b85SLee A. Roberts } 10271da177e4SLinus Torvalds if (freed >= needed) 10281da177e4SLinus Torvalds return freed; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 10311da177e4SLinus Torvalds return freed; 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds 103416d14ef9SPavel Emelyanov /* Renege 'needed' bytes from the ordering queue. */ 103516d14ef9SPavel Emelyanov static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed) 103616d14ef9SPavel Emelyanov { 103716d14ef9SPavel Emelyanov return sctp_ulpq_renege_list(ulpq, &ulpq->lobby, needed); 103816d14ef9SPavel Emelyanov } 103916d14ef9SPavel Emelyanov 10401da177e4SLinus Torvalds /* Renege 'needed' bytes from the reassembly queue. */ 10411da177e4SLinus Torvalds static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed) 10421da177e4SLinus Torvalds { 104316d14ef9SPavel Emelyanov return sctp_ulpq_renege_list(ulpq, &ulpq->reasm, needed); 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds /* Partial deliver the first message as there is pressure on rwnd. */ 10471da177e4SLinus Torvalds void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq, 1048dd0fc66fSAl Viro gfp_t gfp) 10491da177e4SLinus Torvalds { 10501da177e4SLinus Torvalds struct sctp_ulpevent *event; 10511da177e4SLinus Torvalds struct sctp_association *asoc; 1052b6e1331fSVlad Yasevich struct sctp_sock *sp; 1053d003b41bSLee A. Roberts __u32 ctsn; 1054d003b41bSLee A. Roberts struct sk_buff *skb; 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds asoc = ulpq->asoc; 1057b6e1331fSVlad Yasevich sp = sctp_sk(asoc->base.sk); 10581da177e4SLinus Torvalds 1059b6e1331fSVlad Yasevich /* If the association is already in Partial Delivery mode 1060d003b41bSLee A. Roberts * we have nothing to do. 1061b6e1331fSVlad Yasevich */ 1062b6e1331fSVlad Yasevich if (ulpq->pd_mode) 1063b6e1331fSVlad Yasevich return; 10641da177e4SLinus Torvalds 1065d003b41bSLee A. Roberts /* Data must be at or below the Cumulative TSN ACK Point to 1066d003b41bSLee A. Roberts * start partial delivery. 1067d003b41bSLee A. Roberts */ 1068d003b41bSLee A. Roberts skb = skb_peek(&asoc->ulpq.reasm); 1069d003b41bSLee A. Roberts if (skb != NULL) { 1070d003b41bSLee A. Roberts ctsn = sctp_skb2event(skb)->tsn; 1071d003b41bSLee A. Roberts if (!TSN_lte(ctsn, sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map))) 1072d003b41bSLee A. Roberts return; 1073d003b41bSLee A. Roberts } 1074d003b41bSLee A. Roberts 1075b6e1331fSVlad Yasevich /* If the user enabled fragment interleave socket option, 1076b6e1331fSVlad Yasevich * multiple associations can enter partial delivery. 1077b6e1331fSVlad Yasevich * Otherwise, we can only enter partial delivery if the 1078b6e1331fSVlad Yasevich * socket is not in partial deliver mode. 1079b6e1331fSVlad Yasevich */ 1080b6e1331fSVlad Yasevich if (sp->frag_interleave || atomic_read(&sp->pd_mode) == 0) { 10811da177e4SLinus Torvalds /* Is partial delivery possible? */ 10821da177e4SLinus Torvalds event = sctp_ulpq_retrieve_first(ulpq); 10831da177e4SLinus Torvalds /* Send event to the ULP. */ 10841da177e4SLinus Torvalds if (event) { 1085925b9374SDavid Miller struct sk_buff_head temp; 1086925b9374SDavid Miller 1087925b9374SDavid Miller skb_queue_head_init(&temp); 1088925b9374SDavid Miller __skb_queue_tail(&temp, sctp_event2skb(event)); 10891da177e4SLinus Torvalds sctp_ulpq_tail_event(ulpq, event); 1090d49d91d7SVlad Yasevich sctp_ulpq_set_pd(ulpq); 10911da177e4SLinus Torvalds return; 10921da177e4SLinus Torvalds } 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds } 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds /* Renege some packets to make room for an incoming chunk. */ 10971da177e4SLinus Torvalds void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 1098dd0fc66fSAl Viro gfp_t gfp) 10991da177e4SLinus Torvalds { 11005c468674SXin Long struct sctp_association *asoc = ulpq->asoc; 11015c468674SXin Long __u32 freed = 0; 11025c468674SXin Long __u16 needed; 11031da177e4SLinus Torvalds 11045c468674SXin Long needed = ntohs(chunk->chunk_hdr->length) - 11055c468674SXin Long sizeof(struct sctp_data_chunk); 11061da177e4SLinus Torvalds 11071da177e4SLinus Torvalds if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) { 11081da177e4SLinus Torvalds freed = sctp_ulpq_renege_order(ulpq, needed); 11095c468674SXin Long if (freed < needed) 11101da177e4SLinus Torvalds freed += sctp_ulpq_renege_frags(ulpq, needed - freed); 11111da177e4SLinus Torvalds } 11121da177e4SLinus Torvalds /* If able to free enough room, accept this chunk. */ 11135c468674SXin Long if (freed >= needed) { 11145c468674SXin Long int retval = sctp_ulpq_tail_data(ulpq, chunk, gfp); 1115d003b41bSLee A. Roberts /* 1116d003b41bSLee A. Roberts * Enter partial delivery if chunk has not been 1117d003b41bSLee A. Roberts * delivered; otherwise, drain the reassembly queue. 1118d003b41bSLee A. Roberts */ 1119d003b41bSLee A. Roberts if (retval <= 0) 1120b26ddd81SNeil Horman sctp_ulpq_partial_delivery(ulpq, gfp); 1121d003b41bSLee A. Roberts else if (retval == 1) 1122d003b41bSLee A. Roberts sctp_ulpq_reasm_drain(ulpq); 11231da177e4SLinus Torvalds } 11241da177e4SLinus Torvalds 11253ab224beSHideo Aoki sk_mem_reclaim(asoc->base.sk); 11261da177e4SLinus Torvalds } 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds /* Notify the application if an association is aborted and in 11311da177e4SLinus Torvalds * partial delivery mode. Send up any pending received messages. 11321da177e4SLinus Torvalds */ 1133dd0fc66fSAl Viro void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, gfp_t gfp) 11341da177e4SLinus Torvalds { 11351da177e4SLinus Torvalds struct sctp_ulpevent *ev = NULL; 11360970f5b3SMarcelo Ricardo Leitner struct sctp_sock *sp; 11372cc0eeb6SXin Long struct sock *sk; 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds if (!ulpq->pd_mode) 11401da177e4SLinus Torvalds return; 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds sk = ulpq->asoc->base.sk; 11430970f5b3SMarcelo Ricardo Leitner sp = sctp_sk(sk); 1144a1e3a059SXin Long if (sctp_ulpevent_type_enabled(ulpq->asoc->subscribe, 11452cc0eeb6SXin Long SCTP_PARTIAL_DELIVERY_EVENT)) 11461da177e4SLinus Torvalds ev = sctp_ulpevent_make_pdapi(ulpq->asoc, 11471da177e4SLinus Torvalds SCTP_PARTIAL_DELIVERY_ABORTED, 114865f5e357SXin Long 0, 0, 0, gfp); 11491da177e4SLinus Torvalds if (ev) 11501da177e4SLinus Torvalds __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev)); 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds /* If there is data waiting, send it up the socket now. */ 11530970f5b3SMarcelo Ricardo Leitner if ((sctp_ulpq_clear_pd(ulpq) || ev) && !sp->data_ready_signalled) { 11540970f5b3SMarcelo Ricardo Leitner sp->data_ready_signalled = 1; 11550970f5b3SMarcelo Ricardo Leitner sk->sk_data_ready(sk); 11560970f5b3SMarcelo Ricardo Leitner } 11571da177e4SLinus Torvalds } 1158