4 files changed, 120 insertions, 4 deletions

diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index fe7f5ae1c513..37b4a24e589b 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -307,6 +307,7 @@ struct sctp_sock {
         __u8 v4mapped;
         __u8 frag_interleave;
         __u32 adaptation_ind;
+        __u32 pd_point;
 
         atomic_t pd_mode;
         /* Receive to here while partial delivery is in effect. */
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index e77316088dc7..9a8352710631 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -99,6 +99,8 @@ enum sctp_optname {
 #define SCTP_CONTEXT SCTP_CONTEXT
         SCTP_FRAGMENT_INTERLEAVE,
 #define SCTP_FRAGMENT_INTERLEAVE SCTP_FRAGMENT_INTERLEAVE
+        SCTP_PARTIAL_DELIVERY_POINT,    /* Set/Get partial delivery point */
+#define SCTP_PARTIAL_DELIVERY_POINT SCTP_PARTIAL_DELIVERY_POINT
 
         /* Internal Socket Options. Some of the sctp library functions are 
          * implemented using these socket options.
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index b4be473c68b0..1e787a2d0b5f 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -2832,6 +2832,32 @@ static int sctp_setsockopt_fragment_interleave(struct sock *sk,
         return 0;
 }
 
+/*
+ * 7.1.25.  Set or Get the sctp partial delivery point
+ *       (SCTP_PARTIAL_DELIVERY_POINT)
+ * This option will set or get the SCTP partial delivery point.  This
+ * point is the size of a message where the partial delivery API will be
+ * invoked to help free up rwnd space for the peer.  Setting this to a
+ * lower value will cause partial delivery's to happen more often.  The
+ * calls argument is an integer that sets or gets the partial delivery
+ * point.
+ */
+static int sctp_setsockopt_partial_delivery_point(struct sock *sk,
+                                                  char __user *optval,
+                                                  int optlen)
+{
+        u32 val;
+
+        if (optlen != sizeof(u32))
+                return -EINVAL;
+        if (get_user(val, (int __user *)optval))
+                return -EFAULT;
+
+        sctp_sk(sk)->pd_point = val;
+
+        return 0; /* is this the right error code? */
+}
+
 /* API 6.2 setsockopt(), getsockopt()
  *
  * Applications use setsockopt() and getsockopt() to set or retrieve
@@ -2911,6 +2937,9 @@ SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
         case SCTP_DELAYED_ACK_TIME:
                 retval = sctp_setsockopt_delayed_ack_time(sk, optval, optlen);
                 break;
+        case SCTP_PARTIAL_DELIVERY_POINT:
+                retval = sctp_setsockopt_partial_delivery_point(sk, optval, optlen);
+                break;
 
         case SCTP_INITMSG:
                 retval = sctp_setsockopt_initmsg(sk, optval, optlen);
@@ -4602,6 +4631,30 @@ static int sctp_getsockopt_fragment_interleave(struct sock *sk, int len,
         return 0;
 }
 
+/*
+ * 7.1.25.  Set or Get the sctp partial delivery point
+ * (chapter and verse is quoted at sctp_setsockopt_partial_delivery_point())
+ */
+static int sctp_getsockopt_partial_delivery_point(struct sock *sk, int len,
+                                                  char __user *optval,
+                                                  int __user *optlen)
+{
+        u32 val;
+
+        if (len < sizeof(u32))
+                return -EINVAL;
+
+        len = sizeof(u32);
+
+        val = sctp_sk(sk)->pd_point;
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, &val, len))
+                return -EFAULT;
+
+        return -ENOTSUPP;
+}
+
 SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
                                 char __user *optval, int __user *optlen)
 {
@@ -4718,6 +4771,10 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
                 retval = sctp_getsockopt_fragment_interleave(sk, len, optval,
                                                              optlen);
                 break;
+        case SCTP_PARTIAL_DELIVERY_POINT:
+                retval = sctp_getsockopt_partial_delivery_point(sk, len, optval,
+                                                                optlen);
+                break;
         default:
                 retval = -ENOPROTOOPT;
                 break;
diff --git a/net/sctp/ulpqueue.c b/net/sctp/ulpqueue.c
index ac80c34f6c2c..0fa4d4d4df17 100644
--- a/net/sctp/ulpqueue.c
+++ b/net/sctp/ulpqueue.c
@@ -177,6 +177,15 @@ int sctp_clear_pd(struct sock *sk, struct sctp_association *asoc)
         return 0;
 }
 
+/* Set the pd_mode on the socket and ulpq */
+static void sctp_ulpq_set_pd(struct sctp_ulpq *ulpq)
+{
+        struct sctp_sock *sp = sctp_sk(ulpq->asoc->base.sk);
+
+        atomic_inc(&sp->pd_mode);
+        ulpq->pd_mode = 1;
+}
+
 /* Clear the pd_mode and restart any pending messages waiting for delivery. */
 static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq)
 {
@@ -401,6 +410,11 @@ static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_u
         struct sk_buff *first_frag = NULL;
         __u32 ctsn, next_tsn;
         struct sctp_ulpevent *retval = NULL;
+        struct sk_buff *pd_first = NULL;
+        struct sk_buff *pd_last = NULL;
+        size_t pd_len = 0;
+        struct sctp_association *asoc;
+        u32 pd_point;
 
         /* Initialized to 0 just to avoid compiler warning message.  Will
          * never be used with this value. It is referenced only after it
@@ -416,6 +430,10 @@ static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_u
          * we expect to find the remaining middle fragments and the last
          * fragment in order. If not, first_frag is reset to NULL and we
          * start the next pass when we find another first fragment.
+         *
+         * There is a potential to do partial delivery if user sets
+         * SCTP_PARTIAL_DELIVERY_POINT option. Lets count some things here
+         * to see if can do PD.
          */
         skb_queue_walk(&ulpq->reasm, pos) {
                 cevent = sctp_skb2event(pos);
@@ -423,14 +441,32 @@ static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_u
 
                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
                 case SCTP_DATA_FIRST_FRAG:
+                        /* If this "FIRST_FRAG" is the first
+                         * element in the queue, then count it towards
+                         * possible PD.
+                         */
+                        if (pos == ulpq->reasm.next) {
+                            pd_first = pos;
+                            pd_last = pos;
+                            pd_len = pos->len;
+                        } else {
+                            pd_first = NULL;
+                            pd_last = NULL;
+                            pd_len = 0;
+                        }
+
                         first_frag = pos;
                         next_tsn = ctsn + 1;
                         break;
 
                 case SCTP_DATA_MIDDLE_FRAG:
-                        if ((first_frag) && (ctsn == next_tsn))
+                        if ((first_frag) && (ctsn == next_tsn)) {
                                 next_tsn++;
-                        else
+                                if (pd_first) {
+                                    pd_last = pos;
+                                    pd_len += pos->len;
+                                }
+                        } else
                                 first_frag = NULL;
                         break;
 
@@ -441,7 +477,28 @@ static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_u
                                 first_frag = NULL;
                         break;
                 };
+        }
+
+        asoc = ulpq->asoc;
+        if (pd_first) {
+                /* Make sure we can enter partial deliver.
+                 * We can trigger partial delivery only if framgent
+                 * interleave is set, or the socket is not already
+                 * in  partial delivery.
+                 */
+                if (!sctp_sk(asoc->base.sk)->frag_interleave &&
+                    atomic_read(&sctp_sk(asoc->base.sk)->pd_mode))
+                        goto done;
 
+                cevent = sctp_skb2event(pd_first);
+                pd_point = sctp_sk(asoc->base.sk)->pd_point;
+                if (pd_point && pd_point <= pd_len) {
+                        retval = sctp_make_reassembled_event(&ulpq->reasm,
+                                                             pd_first,
+                                                             pd_last);
+                        if (retval)
+                                sctp_ulpq_set_pd(ulpq);
+                }
         }
 done:
         return retval;
@@ -882,8 +939,7 @@ void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq,
                 /* Send event to the ULP.   */
                 if (event) {
                         sctp_ulpq_tail_event(ulpq, event);
-                        atomic_inc(&sp->pd_mode);
-                        ulpq->pd_mode = 1;
+                        sctp_ulpq_set_pd(ulpq);
                         return;
                 }
         }