Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking changes from David S Miller:

 1) Remove the ipv4 routing cache.  Now lookups go directly into the FIB
    trie and use prebuilt routes cached there.

    No more garbage collection, no more rDOS attacks on the routing
    cache.  Instead we now get predictable and consistent performance,
    no matter what the pattern of traffic we service.

    This has been almost 2 years in the making.  Special thanks to
    Julian Anastasov, Eric Dumazet, Steffen Klassert, and others who
    have helped along the way.

    I'm sure that with a change of this magnitude there will be some
    kind of fallout, but such things ought the be simple to fix at this
    point.  Luckily I'm not European so I'll be around all of August to
    fix things :-)

    The major stages of this work here are each fronted by a forced
    merge commit whose commit message contains a top-level description
    of the motivations and implementation issues.

 2) Pre-demux of established ipv4 TCP sockets, saves a route demux on
    input.

 3) TCP SYN/ACK performance tweaks from Eric Dumazet.

 4) Add namespace support for netfilter L4 conntrack helpers, from Gao
    Feng.

 5) Add config mechanism for Energy Efficient Ethernet to ethtool, from
    Yuval Mintz.

 6) Remove quadratic behavior from /proc/net/unix, from Eric Dumazet.

 7) Support for connection tracker helpers in userspace, from Pablo
    Neira Ayuso.

 8) Allow userspace driven TX load balancing functions in TEAM driver,
    from Jiri Pirko.

 9) Kill off NLMSG_PUT and RTA_PUT macros, more gross stuff with
    embedded gotos.

10) TCP Small Queues, essentially minimize the amount of TCP data queued
    up in the packet scheduler layer.  Whereas the existing BQL (Byte
    Queue Limits) limits the pkt_sched --> netdevice queuing levels,
    this controls the TCP --> pkt_sched queueing levels.

    From Eric Dumazet.

11) Reduce the number of get_page/put_page ops done on SKB fragments,
    from Alexander Duyck.

12) Implement protection against blind resets in TCP (RFC 5961), from
    Eric Dumazet.

13) Support the client side of TCP Fast Open, basically the ability to
    send data in the SYN exchange, from Yuchung Cheng.

    Basically, the sender queues up data with a sendmsg() call using
    MSG_FASTOPEN, then they do the connect() which emits the queued up
    fastopen data.

14) Avoid all the problems we get into in TCP when timers or PMTU events
    hit a locked socket.  The TCP Small Queues changes added a
    tcp_release_cb() that allows us to queue work up to the
    release_sock() caller, and that's what we use here too.  From Eric
    Dumazet.

15) Zero copy on TX support for TUN driver, from Michael S. Tsirkin.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1870 commits)
  genetlink: define lockdep_genl_is_held() when CONFIG_LOCKDEP
  r8169: revert "add byte queue limit support".
  ipv4: Change rt->rt_iif encoding.
  net: Make skb->skb_iif always track skb->dev
  ipv4: Prepare for change of rt->rt_iif encoding.
  ipv4: Remove all RTCF_DIRECTSRC handliing.
  ipv4: Really ignore ICMP address requests/replies.
  decnet: Don't set RTCF_DIRECTSRC.
  net/ipv4/ip_vti.c: Fix __rcu warnings detected by sparse.
  ipv4: Remove redundant assignment
  rds: set correct msg_namelen
  openvswitch: potential NULL deref in sample()
  tcp: dont drop MTU reduction indications
  bnx2x: Add new 57840 device IDs
  tcp: avoid oops in tcp_metrics and reset tcpm_stamp
  niu: Change niu_rbr_fill() to use unlikely() to check niu_rbr_add_page() return value
  niu: Fix to check for dma mapping errors.
  net: Fix references to out-of-scope variables in put_cmsg_compat()
  net: ethernet: davinci_emac: add pm_runtime support
  net: ethernet: davinci_emac: Remove unnecessary #include
  ...

11 files changed, 269 insertions, 55 deletions

diff --git a/net/sctp/associola.c b/net/sctp/associola.c
index b16517ee1aaf..ebaef3ed6065 100644
--- a/net/sctp/associola.c
+++ b/net/sctp/associola.c
@@ -124,6 +124,8 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a
          * socket values.
          */
         asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;
+        asoc->pf_retrans  = sctp_pf_retrans;
+
         asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);
         asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);
         asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);
@@ -686,6 +688,9 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
         /* Set the path max_retrans.  */
         peer->pathmaxrxt = asoc->pathmaxrxt;
 
+        /* And the partial failure retrnas threshold */
+        peer->pf_retrans = asoc->pf_retrans;
+
         /* Initialize the peer's SACK delay timeout based on the
          * association configured value.
          */
@@ -841,6 +846,7 @@ void sctp_assoc_control_transport(struct sctp_association *asoc,
         struct sctp_ulpevent *event;
         struct sockaddr_storage addr;
         int spc_state = 0;
+        bool ulp_notify = true;
 
         /* Record the transition on the transport.  */
         switch (command) {
@@ -854,6 +860,14 @@ void sctp_assoc_control_transport(struct sctp_association *asoc,
                         spc_state = SCTP_ADDR_CONFIRMED;
                 else
                         spc_state = SCTP_ADDR_AVAILABLE;
+                /* Don't inform ULP about transition from PF to
+                 * active state and set cwnd to 1, see SCTP
+                 * Quick failover draft section 5.1, point 5
+                 */
+                if (transport->state == SCTP_PF) {
+                        ulp_notify = false;
+                        transport->cwnd = 1;
+                }
                 transport->state = SCTP_ACTIVE;
                 break;
 
@@ -872,6 +886,11 @@ void sctp_assoc_control_transport(struct sctp_association *asoc,
                 spc_state = SCTP_ADDR_UNREACHABLE;
                 break;
 
+        case SCTP_TRANSPORT_PF:
+                transport->state = SCTP_PF;
+                ulp_notify = false;
+                break;
+
         default:
                 return;
         }
@@ -879,12 +898,15 @@ void sctp_assoc_control_transport(struct sctp_association *asoc,
         /* Generate and send a SCTP_PEER_ADDR_CHANGE notification to the
          * user.
          */
-        memset(&addr, 0, sizeof(struct sockaddr_storage));
-        memcpy(&addr, &transport->ipaddr, transport->af_specific->sockaddr_len);
-        event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,
-                                0, spc_state, error, GFP_ATOMIC);
-        if (event)
-                sctp_ulpq_tail_event(&asoc->ulpq, event);
+        if (ulp_notify) {
+                memset(&addr, 0, sizeof(struct sockaddr_storage));
+                memcpy(&addr, &transport->ipaddr,
+                       transport->af_specific->sockaddr_len);
+                event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,
+                                        0, spc_state, error, GFP_ATOMIC);
+                if (event)
+                        sctp_ulpq_tail_event(&asoc->ulpq, event);
+        }
 
         /* Select new active and retran paths. */
 
@@ -900,7 +922,8 @@ void sctp_assoc_control_transport(struct sctp_association *asoc,
                         transports) {
 
                 if ((t->state == SCTP_INACTIVE) ||
-                    (t->state == SCTP_UNCONFIRMED))
+                    (t->state == SCTP_UNCONFIRMED) ||
+                    (t->state == SCTP_PF))
                         continue;
                 if (!first || t->last_time_heard > first->last_time_heard) {
                         second = first;
@@ -1360,7 +1383,7 @@ struct sctp_transport *sctp_assoc_choose_alter_transport(
 /* Update the association's pmtu and frag_point by going through all the
  * transports. This routine is called when a transport's PMTU has changed.
  */
-void sctp_assoc_sync_pmtu(struct sctp_association *asoc)
+void sctp_assoc_sync_pmtu(struct sock *sk, struct sctp_association *asoc)
 {
         struct sctp_transport *t;
         __u32 pmtu = 0;
@@ -1372,7 +1395,7 @@ void sctp_assoc_sync_pmtu(struct sctp_association *asoc)
         list_for_each_entry(t, &asoc->peer.transport_addr_list,
                                 transports) {
                 if (t->pmtu_pending && t->dst) {
-                        sctp_transport_update_pmtu(t, dst_mtu(t->dst));
+                        sctp_transport_update_pmtu(sk, t, dst_mtu(t->dst));
                         t->pmtu_pending = 0;
                 }
                 if (!pmtu || (t->pathmtu < pmtu))
diff --git a/net/sctp/input.c b/net/sctp/input.c
index 8b9b6790a3df..e64d5210ed13 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -408,10 +408,10 @@ void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
 
         if (t->param_flags & SPP_PMTUD_ENABLE) {
                 /* Update transports view of the MTU */
-                sctp_transport_update_pmtu(t, pmtu);
+                sctp_transport_update_pmtu(sk, t, pmtu);
 
                 /* Update association pmtu. */
-                sctp_assoc_sync_pmtu(asoc);
+                sctp_assoc_sync_pmtu(sk, asoc);
         }
 
         /* Retransmit with the new pmtu setting.
@@ -423,6 +423,18 @@ void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
         sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
 }
 
+void sctp_icmp_redirect(struct sock *sk, struct sctp_transport *t,
+                        struct sk_buff *skb)
+{
+        struct dst_entry *dst;
+
+        if (!t)
+                return;
+        dst = sctp_transport_dst_check(t);
+        if (dst)
+                dst->ops->redirect(dst, sk, skb);
+}
+
 /*
  * SCTP Implementer's Guide, 2.37 ICMP handling procedures
  *
@@ -628,6 +640,10 @@ void sctp_v4_err(struct sk_buff *skb, __u32 info)
 
                 err = EHOSTUNREACH;
                 break;
+        case ICMP_REDIRECT:
+                sctp_icmp_redirect(sk, transport, skb);
+                err = 0;
+                break;
         default:
                 goto out_unlock;
         }
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index 91f479121c55..ed7139ea7978 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -185,6 +185,9 @@ SCTP_STATIC void sctp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
                         goto out_unlock;
                 }
                 break;
+        case NDISC_REDIRECT:
+                sctp_icmp_redirect(sk, transport, skb);
+                break;
         default:
                 break;
         }
diff --git a/net/sctp/output.c b/net/sctp/output.c
index 6ae47acaaec6..838e18b4d7ea 100644
--- a/net/sctp/output.c
+++ b/net/sctp/output.c
@@ -64,6 +64,8 @@
 #include <net/sctp/checksum.h>
 
 /* Forward declarations for private helpers. */
+static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
+                                              struct sctp_chunk *chunk);
 static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
                                            struct sctp_chunk *chunk);
 static void sctp_packet_append_data(struct sctp_packet *packet,
@@ -224,7 +226,10 @@ static sctp_xmit_t sctp_packet_bundle_auth(struct sctp_packet *pkt,
         if (!auth)
                 return retval;
 
-        retval = sctp_packet_append_chunk(pkt, auth);
+        retval = __sctp_packet_append_chunk(pkt, auth);
+
+        if (retval != SCTP_XMIT_OK)
+                sctp_chunk_free(auth);
 
         return retval;
 }
@@ -256,48 +261,31 @@ static sctp_xmit_t sctp_packet_bundle_sack(struct sctp_packet *pkt,
                         asoc->a_rwnd = asoc->rwnd;
                         sack = sctp_make_sack(asoc);
                         if (sack) {
-                                retval = sctp_packet_append_chunk(pkt, sack);
+                                retval = __sctp_packet_append_chunk(pkt, sack);
+                                if (retval != SCTP_XMIT_OK) {
+                                        sctp_chunk_free(sack);
+                                        goto out;
+                                }
                                 asoc->peer.sack_needed = 0;
                                 if (del_timer(timer))
                                         sctp_association_put(asoc);
                         }
                 }
         }
+out:
         return retval;
 }
 
+
 /* Append a chunk to the offered packet reporting back any inability to do
  * so.
  */
-sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet,
-                                     struct sctp_chunk *chunk)
+static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
+                                              struct sctp_chunk *chunk)
 {
         sctp_xmit_t retval = SCTP_XMIT_OK;
         __u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length));
 
-        SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__, packet,
-                          chunk);
-
-        /* Data chunks are special.  Before seeing what else we can
-         * bundle into this packet, check to see if we are allowed to
-         * send this DATA.
-         */
-        if (sctp_chunk_is_data(chunk)) {
-                retval = sctp_packet_can_append_data(packet, chunk);
-                if (retval != SCTP_XMIT_OK)
-                        goto finish;
-        }
-
-        /* Try to bundle AUTH chunk */
-        retval = sctp_packet_bundle_auth(packet, chunk);
-        if (retval != SCTP_XMIT_OK)
-                goto finish;
-
-        /* Try to bundle SACK chunk */
-        retval = sctp_packet_bundle_sack(packet, chunk);
-        if (retval != SCTP_XMIT_OK)
-                goto finish;
-
         /* Check to see if this chunk will fit into the packet */
         retval = sctp_packet_will_fit(packet, chunk, chunk_len);
         if (retval != SCTP_XMIT_OK)
@@ -339,6 +327,43 @@ finish:
         return retval;
 }
 
+/* Append a chunk to the offered packet reporting back any inability to do
+ * so.
+ */
+sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet,
+                                     struct sctp_chunk *chunk)
+{
+        sctp_xmit_t retval = SCTP_XMIT_OK;
+
+        SCTP_DEBUG_PRINTK("%s: packet:%p chunk:%p\n", __func__, packet,
+                          chunk);
+
+        /* Data chunks are special.  Before seeing what else we can
+         * bundle into this packet, check to see if we are allowed to
+         * send this DATA.
+         */
+        if (sctp_chunk_is_data(chunk)) {
+                retval = sctp_packet_can_append_data(packet, chunk);
+                if (retval != SCTP_XMIT_OK)
+                        goto finish;
+        }
+
+        /* Try to bundle AUTH chunk */
+        retval = sctp_packet_bundle_auth(packet, chunk);
+        if (retval != SCTP_XMIT_OK)
+                goto finish;
+
+        /* Try to bundle SACK chunk */
+        retval = sctp_packet_bundle_sack(packet, chunk);
+        if (retval != SCTP_XMIT_OK)
+                goto finish;
+
+        retval = __sctp_packet_append_chunk(packet, chunk);
+
+finish:
+        return retval;
+}
+
 /* All packets are sent to the network through this function from
  * sctp_outq_tail().
  *
@@ -385,7 +410,7 @@ int sctp_packet_transmit(struct sctp_packet *packet)
         if (!sctp_transport_dst_check(tp)) {
                 sctp_transport_route(tp, NULL, sctp_sk(sk));
                 if (asoc && (asoc->param_flags & SPP_PMTUD_ENABLE)) {
-                        sctp_assoc_sync_pmtu(asoc);
+                        sctp_assoc_sync_pmtu(sk, asoc);
                 }
         }
         dst = dst_clone(tp->dst);
diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
index a0fa19f5650c..e7aa177c9522 100644
--- a/net/sctp/outqueue.c
+++ b/net/sctp/outqueue.c
@@ -792,7 +792,8 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                         if (!new_transport)
                                 new_transport = asoc->peer.active_path;
                 } else if ((new_transport->state == SCTP_INACTIVE) ||
-                           (new_transport->state == SCTP_UNCONFIRMED)) {
+                           (new_transport->state == SCTP_UNCONFIRMED) ||
+                           (new_transport->state == SCTP_PF)) {
                         /* If the chunk is Heartbeat or Heartbeat Ack,
                          * send it to chunk->transport, even if it's
                          * inactive.
@@ -987,7 +988,8 @@ static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                         new_transport = chunk->transport;
                         if (!new_transport ||
                             ((new_transport->state == SCTP_INACTIVE) ||
-                             (new_transport->state == SCTP_UNCONFIRMED)))
+                             (new_transport->state == SCTP_UNCONFIRMED) ||
+                             (new_transport->state == SCTP_PF)))
                                 new_transport = asoc->peer.active_path;
                         if (new_transport->state == SCTP_UNCONFIRMED)
                                 continue;
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index 9c90811d1134..1f89c4e69645 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -568,7 +568,7 @@ static void sctp_v4_get_saddr(struct sctp_sock *sk,
 /* What interface did this skb arrive on? */
 static int sctp_v4_skb_iif(const struct sk_buff *skb)
 {
-        return skb_rtable(skb)->rt_iif;
+        return inet_iif(skb);
 }
 
 /* Was this packet marked by Explicit Congestion Notification? */
diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c
index b6de71efb140..479a70ef6ff8 100644
--- a/net/sctp/sm_make_chunk.c
+++ b/net/sctp/sm_make_chunk.c
@@ -132,7 +132,7 @@ void  sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,
  * abort chunk.  Differs from sctp_init_cause in that it won't oops
  * if there isn't enough space in the op error chunk
  */
-int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code,
+static int sctp_init_cause_fixed(struct sctp_chunk *chunk, __be16 cause_code,
                       size_t paylen)
 {
         sctp_errhdr_t err;
diff --git a/net/sctp/sm_sideeffect.c b/net/sctp/sm_sideeffect.c
index 8716da1a8592..fe99628e1257 100644
--- a/net/sctp/sm_sideeffect.c
+++ b/net/sctp/sm_sideeffect.c
@@ -76,6 +76,8 @@ static int sctp_side_effects(sctp_event_t event_type, sctp_subtype_t subtype,
                              sctp_cmd_seq_t *commands,
                              gfp_t gfp);
 
+static void sctp_cmd_hb_timer_update(sctp_cmd_seq_t *cmds,
+                                     struct sctp_transport *t);
 /********************************************************************
  * Helper functions
  ********************************************************************/
@@ -470,7 +472,8 @@ sctp_timer_event_t *sctp_timer_events[SCTP_NUM_TIMEOUT_TYPES] = {
  * notification SHOULD be sent to the upper layer.
  *
  */
-static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
+static void sctp_do_8_2_transport_strike(sctp_cmd_seq_t *commands,
+                                         struct sctp_association *asoc,
                                          struct sctp_transport *transport,
                                          int is_hb)
 {
@@ -495,6 +498,23 @@ static void sctp_do_8_2_transport_strike(struct sctp_association *asoc,
                         transport->error_count++;
         }
 
+        /* If the transport error count is greater than the pf_retrans
+         * threshold, and less than pathmaxrtx, then mark this transport
+         * as Partially Failed, ee SCTP Quick Failover Draft, secon 5.1,
+         * point 1
+         */
+        if ((transport->state != SCTP_PF) &&
+           (asoc->pf_retrans < transport->pathmaxrxt) &&
+           (transport->error_count > asoc->pf_retrans)) {
+
+                sctp_assoc_control_transport(asoc, transport,
+                                             SCTP_TRANSPORT_PF,
+                                             0);
+
+                /* Update the hb timer to resend a heartbeat every rto */
+                sctp_cmd_hb_timer_update(commands, transport);
+        }
+
         if (transport->state != SCTP_INACTIVE &&
             (transport->error_count > transport->pathmaxrxt)) {
                 SCTP_DEBUG_PRINTK_IPADDR("transport_strike:association %p",
@@ -699,6 +719,10 @@ static void sctp_cmd_transport_on(sctp_cmd_seq_t *cmds,
                                              SCTP_HEARTBEAT_SUCCESS);
         }
 
+        if (t->state == SCTP_PF)
+                sctp_assoc_control_transport(asoc, t, SCTP_TRANSPORT_UP,
+                                             SCTP_HEARTBEAT_SUCCESS);
+
         /* The receiver of the HEARTBEAT ACK should also perform an
          * RTT measurement for that destination transport address
          * using the time value carried in the HEARTBEAT ACK chunk.
@@ -1565,8 +1589,8 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
 
                 case SCTP_CMD_STRIKE:
                         /* Mark one strike against a transport.  */
-                        sctp_do_8_2_transport_strike(asoc, cmd->obj.transport,
-                                                    0);
+                        sctp_do_8_2_transport_strike(commands, asoc,
+                                                    cmd->obj.transport, 0);
                         break;
 
                 case SCTP_CMD_TRANSPORT_IDLE:
@@ -1576,7 +1600,8 @@ static int sctp_cmd_interpreter(sctp_event_t event_type,
 
                 case SCTP_CMD_TRANSPORT_HB_SENT:
                         t = cmd->obj.transport;
-                        sctp_do_8_2_transport_strike(asoc, t, 1);
+                        sctp_do_8_2_transport_strike(commands, asoc,
+                                                     t, 1);
                         t->hb_sent = 1;
                         break;
 
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 31c7bfcd9b58..5e259817a7f3 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -1859,7 +1859,7 @@ SCTP_STATIC int sctp_sendmsg(struct kiocb *iocb, struct sock *sk,
         }
 
         if (asoc->pmtu_pending)
-                sctp_assoc_pending_pmtu(asoc);
+                sctp_assoc_pending_pmtu(sk, asoc);
 
         /* If fragmentation is disabled and the message length exceeds the
          * association fragmentation point, return EMSGSIZE.  The I-D
@@ -2373,7 +2373,7 @@ static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
         if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
                 if (trans) {
                         trans->pathmtu = params->spp_pathmtu;
-                        sctp_assoc_sync_pmtu(asoc);
+                        sctp_assoc_sync_pmtu(sctp_opt2sk(sp), asoc);
                 } else if (asoc) {
                         asoc->pathmtu = params->spp_pathmtu;
                         sctp_frag_point(asoc, params->spp_pathmtu);
@@ -2390,7 +2390,7 @@ static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
                                 (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
                         if (update) {
                                 sctp_transport_pmtu(trans, sctp_opt2sk(sp));
-                                sctp_assoc_sync_pmtu(asoc);
+                                sctp_assoc_sync_pmtu(sctp_opt2sk(sp), asoc);
                         }
                 } else if (asoc) {
                         asoc->param_flags =
@@ -3478,6 +3478,56 @@ static int sctp_setsockopt_auto_asconf(struct sock *sk, char __user *optval,
 }
 
 
+/*
+ * SCTP_PEER_ADDR_THLDS
+ *
+ * This option allows us to alter the partially failed threshold for one or all
+ * transports in an association.  See Section 6.1 of:
+ * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
+ */
+static int sctp_setsockopt_paddr_thresholds(struct sock *sk,
+                                            char __user *optval,
+                                            unsigned int optlen)
+{
+        struct sctp_paddrthlds val;
+        struct sctp_transport *trans;
+        struct sctp_association *asoc;
+
+        if (optlen < sizeof(struct sctp_paddrthlds))
+                return -EINVAL;
+        if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval,
+                           sizeof(struct sctp_paddrthlds)))
+                return -EFAULT;
+
+
+        if (sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
+                asoc = sctp_id2assoc(sk, val.spt_assoc_id);
+                if (!asoc)
+                        return -ENOENT;
+                list_for_each_entry(trans, &asoc->peer.transport_addr_list,
+                                    transports) {
+                        if (val.spt_pathmaxrxt)
+                                trans->pathmaxrxt = val.spt_pathmaxrxt;
+                        trans->pf_retrans = val.spt_pathpfthld;
+                }
+
+                if (val.spt_pathmaxrxt)
+                        asoc->pathmaxrxt = val.spt_pathmaxrxt;
+                asoc->pf_retrans = val.spt_pathpfthld;
+        } else {
+                trans = sctp_addr_id2transport(sk, &val.spt_address,
+                                               val.spt_assoc_id);
+                if (!trans)
+                        return -ENOENT;
+
+                if (val.spt_pathmaxrxt)
+                        trans->pathmaxrxt = val.spt_pathmaxrxt;
+                trans->pf_retrans = val.spt_pathpfthld;
+        }
+
+        return 0;
+}
+
 /* API 6.2 setsockopt(), getsockopt()
  *
  * Applications use setsockopt() and getsockopt() to set or retrieve
@@ -3627,6 +3677,9 @@ SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
         case SCTP_AUTO_ASCONF:
                 retval = sctp_setsockopt_auto_asconf(sk, optval, optlen);
                 break;
+        case SCTP_PEER_ADDR_THLDS:
+                retval = sctp_setsockopt_paddr_thresholds(sk, optval, optlen);
+                break;
         default:
                 retval = -ENOPROTOOPT;
                 break;
@@ -5498,6 +5551,51 @@ static int sctp_getsockopt_assoc_ids(struct sock *sk, int len,
         return 0;
 }
 
+/*
+ * SCTP_PEER_ADDR_THLDS
+ *
+ * This option allows us to fetch the partially failed threshold for one or all
+ * transports in an association.  See Section 6.1 of:
+ * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
+ */
+static int sctp_getsockopt_paddr_thresholds(struct sock *sk,
+                                            char __user *optval,
+                                            int len,
+                                            int __user *optlen)
+{
+        struct sctp_paddrthlds val;
+        struct sctp_transport *trans;
+        struct sctp_association *asoc;
+
+        if (len < sizeof(struct sctp_paddrthlds))
+                return -EINVAL;
+        len = sizeof(struct sctp_paddrthlds);
+        if (copy_from_user(&val, (struct sctp_paddrthlds __user *)optval, len))
+                return -EFAULT;
+
+        if (sctp_is_any(sk, (const union sctp_addr *)&val.spt_address)) {
+                asoc = sctp_id2assoc(sk, val.spt_assoc_id);
+                if (!asoc)
+                        return -ENOENT;
+
+                val.spt_pathpfthld = asoc->pf_retrans;
+                val.spt_pathmaxrxt = asoc->pathmaxrxt;
+        } else {
+                trans = sctp_addr_id2transport(sk, &val.spt_address,
+                                               val.spt_assoc_id);
+                if (!trans)
+                        return -ENOENT;
+
+                val.spt_pathmaxrxt = trans->pathmaxrxt;
+                val.spt_pathpfthld = trans->pf_retrans;
+        }
+
+        if (put_user(len, optlen) || copy_to_user(optval, &val, len))
+                return -EFAULT;
+
+        return 0;
+}
+
 SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
                                 char __user *optval, int __user *optlen)
 {
@@ -5636,6 +5734,9 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
         case SCTP_AUTO_ASCONF:
                 retval = sctp_getsockopt_auto_asconf(sk, len, optval, optlen);
                 break;
+        case SCTP_PEER_ADDR_THLDS:
+                retval = sctp_getsockopt_paddr_thresholds(sk, optval, len, optlen);
+                break;
         default:
                 retval = -ENOPROTOOPT;
                 break;
diff --git a/net/sctp/sysctl.c b/net/sctp/sysctl.c
index e5fe639c89e7..2b2bfe933ff1 100644
--- a/net/sctp/sysctl.c
+++ b/net/sctp/sysctl.c
@@ -141,6 +141,15 @@ static ctl_table sctp_table[] = {
                 .extra2         = &int_max
         },
         {
+                .procname       = "pf_retrans",
+                .data           = &sctp_pf_retrans,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec_minmax,
+                .extra1         = &zero,
+                .extra2         = &int_max
+        },
+        {
                 .procname       = "max_init_retransmits",
                 .data           = &sctp_max_retrans_init,
                 .maxlen         = sizeof(int),
diff --git a/net/sctp/transport.c b/net/sctp/transport.c
index 1dcceb6e0ce6..c97472b248a2 100644
--- a/net/sctp/transport.c
+++ b/net/sctp/transport.c
@@ -87,6 +87,7 @@ static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
 
         /* Initialize the default path max_retrans.  */
         peer->pathmaxrxt  = sctp_max_retrans_path;
+        peer->pf_retrans  = sctp_pf_retrans;
 
         INIT_LIST_HEAD(&peer->transmitted);
         INIT_LIST_HEAD(&peer->send_ready);
@@ -216,7 +217,7 @@ void sctp_transport_set_owner(struct sctp_transport *transport,
 void sctp_transport_pmtu(struct sctp_transport *transport, struct sock *sk)
 {
         /* If we don't have a fresh route, look one up */
-        if (!transport->dst || transport->dst->obsolete > 1) {
+        if (!transport->dst || transport->dst->obsolete) {
                 dst_release(transport->dst);
                 transport->af_specific->get_dst(transport, &transport->saddr,
                                                 &transport->fl, sk);
@@ -228,7 +229,7 @@ void sctp_transport_pmtu(struct sctp_transport *transport, struct sock *sk)
                 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
 }
 
-void sctp_transport_update_pmtu(struct sctp_transport *t, u32 pmtu)
+void sctp_transport_update_pmtu(struct sock *sk, struct sctp_transport *t, u32 pmtu)
 {
         struct dst_entry *dst;
 
@@ -245,8 +246,16 @@ void sctp_transport_update_pmtu(struct sctp_transport *t, u32 pmtu)
         }
 
         dst = sctp_transport_dst_check(t);
-        if (dst)
-                dst->ops->update_pmtu(dst, pmtu);
+        if (!dst)
+                t->af_specific->get_dst(t, &t->saddr, &t->fl, sk);
+
+        if (dst) {
+                dst->ops->update_pmtu(dst, sk, NULL, pmtu);
+
+                dst = sctp_transport_dst_check(t);
+                if (!dst)
+                        t->af_specific->get_dst(t, &t->saddr, &t->fl, sk);
+        }
 }
 
 /* Caches the dst entry and source address for a transport's destination
@@ -587,7 +596,8 @@ unsigned long sctp_transport_timeout(struct sctp_transport *t)
 {
         unsigned long timeout;
         timeout = t->rto + sctp_jitter(t->rto);
-        if (t->state != SCTP_UNCONFIRMED)
+        if ((t->state != SCTP_UNCONFIRMED) &&
+            (t->state != SCTP_PF))
                 timeout += t->hbinterval;
         timeout += jiffies;
         return timeout;