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

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (29 commits)
  tcp: Restore ordering of TCP options for the sake of inter-operability
  net: Fix disjunct computation of netdev features
  sctp: Fix to handle SHUTDOWN in SHUTDOWN_RECEIVED state
  sctp: Fix to handle SHUTDOWN in SHUTDOWN-PENDING state
  sctp: Add check for the TSN field of the SHUTDOWN chunk
  sctp: Drop ICMP packet too big message with MTU larger than current PMTU
  p54: enable 2.4/5GHz spectrum by eeprom bits.
  orinoco: reduce stack usage in firmware download path
  ath5k: fix suspend-related oops on rmmod
  [netdrvr] fec_mpc52xx: Implement polling, to make netconsole work.
  qlge: Fix MSI/legacy single interrupt bug.
  smc911x: Make the driver safer on SMP
  smc911x: Add IRQ polarity configuration
  smc911x: Allow Kconfig dependency on ARM
  sis190: add identifier for Atheros AR8021 PHY
  8139x: reduce message severity on driver overlap
  igb: add IGB_DCA instead of selecting INTEL_IOATDMA
  igb: fix tx data corruption with transition to L0s on 82575
  ehea: Fix memory hotplug support
  netdev: DM9000: remove BLACKFIN hacking in DM9000 netdev driver
  ...

7 files changed, 157 insertions, 79 deletions

diff --git a/net/bridge/br_device.c b/net/bridge/br_device.c
index 22ba8632196f..6c023f0f8252 100644
--- a/net/bridge/br_device.c
+++ b/net/bridge/br_device.c
@@ -179,5 +179,5 @@ void br_dev_setup(struct net_device *dev)
 
         dev->features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
                         NETIF_F_GSO_MASK | NETIF_F_NO_CSUM | NETIF_F_LLTX |
-                        NETIF_F_NETNS_LOCAL;
+                        NETIF_F_NETNS_LOCAL | NETIF_F_GSO;
 }
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index 573e20f7dba4..0a09ccf68c1c 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -347,15 +347,21 @@ int br_min_mtu(const struct net_bridge *br)
 void br_features_recompute(struct net_bridge *br)
 {
         struct net_bridge_port *p;
-        unsigned long features;
+        unsigned long features, mask;
 
-        features = br->feature_mask;
+        features = mask = br->feature_mask;
+        if (list_empty(&br->port_list))
+                goto done;
+
+        features &= ~NETIF_F_ONE_FOR_ALL;
 
         list_for_each_entry(p, &br->port_list, list) {
-                features = netdev_compute_features(features, p->dev->features);
+                features = netdev_increment_features(features,
+                                                     p->dev->features, mask);
         }
 
-        br->dev->features = features;
+done:
+        br->dev->features = netdev_fix_features(features, NULL);
 }
 
 /* called with RTNL */
diff --git a/net/core/dev.c b/net/core/dev.c
index b8a4fd0806af..d9038e328cc1 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -3947,6 +3947,46 @@ static void netdev_init_queue_locks(struct net_device *dev)
         __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
 }
 
+unsigned long netdev_fix_features(unsigned long features, const char *name)
+{
+        /* Fix illegal SG+CSUM combinations. */
+        if ((features & NETIF_F_SG) &&
+            !(features & NETIF_F_ALL_CSUM)) {
+                if (name)
+                        printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
+                               "checksum feature.\n", name);
+                features &= ~NETIF_F_SG;
+        }
+
+        /* TSO requires that SG is present as well. */
+        if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
+                if (name)
+                        printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
+                               "SG feature.\n", name);
+                features &= ~NETIF_F_TSO;
+        }
+
+        if (features & NETIF_F_UFO) {
+                if (!(features & NETIF_F_GEN_CSUM)) {
+                        if (name)
+                                printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
+                                       "since no NETIF_F_HW_CSUM feature.\n",
+                                       name);
+                        features &= ~NETIF_F_UFO;
+                }
+
+                if (!(features & NETIF_F_SG)) {
+                        if (name)
+                                printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
+                                       "since no NETIF_F_SG feature.\n", name);
+                        features &= ~NETIF_F_UFO;
+                }
+        }
+
+        return features;
+}
+EXPORT_SYMBOL(netdev_fix_features);
+
 /**
  *      register_netdevice      - register a network device
  *      @dev: device to register
@@ -4032,36 +4072,7 @@ int register_netdevice(struct net_device *dev)
                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
         }
 
-
-        /* Fix illegal SG+CSUM combinations. */
-        if ((dev->features & NETIF_F_SG) &&
-            !(dev->features & NETIF_F_ALL_CSUM)) {
-                printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
-                       dev->name);
-                dev->features &= ~NETIF_F_SG;
-        }
-
-        /* TSO requires that SG is present as well. */
-        if ((dev->features & NETIF_F_TSO) &&
-            !(dev->features & NETIF_F_SG)) {
-                printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
-                       dev->name);
-                dev->features &= ~NETIF_F_TSO;
-        }
-        if (dev->features & NETIF_F_UFO) {
-                if (!(dev->features & NETIF_F_HW_CSUM)) {
-                        printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
-                                        "NETIF_F_HW_CSUM feature.\n",
-                                                        dev->name);
-                        dev->features &= ~NETIF_F_UFO;
-                }
-                if (!(dev->features & NETIF_F_SG)) {
-                        printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
-                                        "NETIF_F_SG feature.\n",
-                                        dev->name);
-                        dev->features &= ~NETIF_F_UFO;
-                }
-        }
+        dev->features = netdev_fix_features(dev->features, dev->name);
 
         /* Enable software GSO if SG is supported. */
         if (dev->features & NETIF_F_SG)
@@ -4700,49 +4711,45 @@ static int __init netdev_dma_register(void) { return -ENODEV; }
 #endif /* CONFIG_NET_DMA */
 
 /**
- *      netdev_compute_feature - compute conjunction of two feature sets
- *      @all: first feature set
- *      @one: second feature set
+ *      netdev_increment_features - increment feature set by one
+ *      @all: current feature set
+ *      @one: new feature set
+ *      @mask: mask feature set
  *
  *      Computes a new feature set after adding a device with feature set
- *      @one to the master device with current feature set @all.  Returns
- *      the new feature set.
+ *      @one to the master device with current feature set @all.  Will not
+ *      enable anything that is off in @mask. Returns the new feature set.
  */
-int netdev_compute_features(unsigned long all, unsigned long one)
-{
-        /* if device needs checksumming, downgrade to hw checksumming */
-        if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
-                all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
-
-        /* if device can't do all checksum, downgrade to ipv4/ipv6 */
-        if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
-                all ^= NETIF_F_HW_CSUM
-                        | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
-
-        if (one & NETIF_F_GSO)
-                one |= NETIF_F_GSO_SOFTWARE;
-        one |= NETIF_F_GSO;
-
-        /*
-         * If even one device supports a GSO protocol with software fallback,
-         * enable it for all.
-         */
-        all |= one & NETIF_F_GSO_SOFTWARE;
+unsigned long netdev_increment_features(unsigned long all, unsigned long one,
+                                        unsigned long mask)
+{
+        /* If device needs checksumming, downgrade to it. */
+        if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
+                all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
+        else if (mask & NETIF_F_ALL_CSUM) {
+                /* If one device supports v4/v6 checksumming, set for all. */
+                if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
+                    !(all & NETIF_F_GEN_CSUM)) {
+                        all &= ~NETIF_F_ALL_CSUM;
+                        all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
+                }
 
-        /* If even one device supports robust GSO, enable it for all. */
-        if (one & NETIF_F_GSO_ROBUST)
-                all |= NETIF_F_GSO_ROBUST;
+                /* If one device supports hw checksumming, set for all. */
+                if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
+                        all &= ~NETIF_F_ALL_CSUM;
+                        all |= NETIF_F_HW_CSUM;
+                }
+        }
 
-        all &= one | NETIF_F_LLTX;
+        one |= NETIF_F_ALL_CSUM;
 
-        if (!(all & NETIF_F_ALL_CSUM))
-                all &= ~NETIF_F_SG;
-        if (!(all & NETIF_F_SG))
-                all &= ~NETIF_F_GSO_MASK;
+        one |= all & NETIF_F_ONE_FOR_ALL;
+        all &= one | NETIF_F_LLTX | NETIF_F_GSO;
+        all |= one & mask & NETIF_F_ONE_FOR_ALL;
 
         return all;
 }
-EXPORT_SYMBOL(netdev_compute_features);
+EXPORT_SYMBOL(netdev_increment_features);
 
 static struct hlist_head *netdev_create_hash(void)
 {
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 990a58493235..e4c5ac9fe89b 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -362,6 +362,17 @@ struct tcp_out_options {
         __u32 tsval, tsecr;     /* need to include OPTION_TS */
 };
 
+/* Beware: Something in the Internet is very sensitive to the ordering of
+ * TCP options, we learned this through the hard way, so be careful here.
+ * Luckily we can at least blame others for their non-compliance but from
+ * inter-operatibility perspective it seems that we're somewhat stuck with
+ * the ordering which we have been using if we want to keep working with
+ * those broken things (not that it currently hurts anybody as there isn't
+ * particular reason why the ordering would need to be changed).
+ *
+ * At least SACK_PERM as the first option is known to lead to a disaster
+ * (but it may well be that other scenarios fail similarly).
+ */
 static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
                               const struct tcp_out_options *opts,
                               __u8 **md5_hash) {
@@ -376,6 +387,12 @@ static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
                 *md5_hash = NULL;
         }
 
+        if (unlikely(opts->mss)) {
+                *ptr++ = htonl((TCPOPT_MSS << 24) |
+                               (TCPOLEN_MSS << 16) |
+                               opts->mss);
+        }
+
         if (likely(OPTION_TS & opts->options)) {
                 if (unlikely(OPTION_SACK_ADVERTISE & opts->options)) {
                         *ptr++ = htonl((TCPOPT_SACK_PERM << 24) |
@@ -392,12 +409,6 @@ static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
                 *ptr++ = htonl(opts->tsecr);
         }
 
-        if (unlikely(opts->mss)) {
-                *ptr++ = htonl((TCPOPT_MSS << 24) |
-                               (TCPOLEN_MSS << 16) |
-                               opts->mss);
-        }
-
         if (unlikely(OPTION_SACK_ADVERTISE & opts->options &&
                      !(OPTION_TS & opts->options))) {
                 *ptr++ = htonl((TCPOPT_NOP << 24) |
@@ -432,7 +443,7 @@ static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
 
                 if (tp->rx_opt.dsack) {
                         tp->rx_opt.dsack = 0;
-                        tp->rx_opt.eff_sacks--;
+                        tp->rx_opt.eff_sacks = tp->rx_opt.num_sacks;
                 }
         }
 }
diff --git a/net/sctp/input.c b/net/sctp/input.c
index a49fa80b57b9..bf612d954d41 100644
--- a/net/sctp/input.c
+++ b/net/sctp/input.c
@@ -369,7 +369,7 @@ static void sctp_add_backlog(struct sock *sk, struct sk_buff *skb)
 void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
                            struct sctp_transport *t, __u32 pmtu)
 {
-        if (!t || (t->pathmtu == pmtu))
+        if (!t || (t->pathmtu <= pmtu))
                 return;
 
         if (sock_owned_by_user(sk)) {
diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
index d4c3fbc4671e..a6a0ea71ae93 100644
--- a/net/sctp/sm_statefuns.c
+++ b/net/sctp/sm_statefuns.c
@@ -2544,6 +2544,7 @@ sctp_disposition_t sctp_sf_do_9_2_shutdown(const struct sctp_endpoint *ep,
         sctp_shutdownhdr_t *sdh;
         sctp_disposition_t disposition;
         struct sctp_ulpevent *ev;
+        __u32 ctsn;
 
         if (!sctp_vtag_verify(chunk, asoc))
                 return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
@@ -2558,6 +2559,14 @@ sctp_disposition_t sctp_sf_do_9_2_shutdown(const struct sctp_endpoint *ep,
         sdh = (sctp_shutdownhdr_t *)chunk->skb->data;
         skb_pull(chunk->skb, sizeof(sctp_shutdownhdr_t));
         chunk->subh.shutdown_hdr = sdh;
+        ctsn = ntohl(sdh->cum_tsn_ack);
+
+        /* If Cumulative TSN Ack beyond the max tsn currently
+         * send, terminating the association and respond to the
+         * sender with an ABORT.
+         */
+        if (!TSN_lt(ctsn, asoc->next_tsn))
+                return sctp_sf_violation_ctsn(ep, asoc, type, arg, commands);
 
         /* API 5.3.1.5 SCTP_SHUTDOWN_EVENT
          * When a peer sends a SHUTDOWN, SCTP delivers this notification to
@@ -2599,6 +2608,51 @@ out:
         return disposition;
 }
 
+/*
+ * sctp_sf_do_9_2_shut_ctsn
+ *
+ * Once an endpoint has reached the SHUTDOWN-RECEIVED state,
+ * it MUST NOT send a SHUTDOWN in response to a ULP request.
+ * The Cumulative TSN Ack of the received SHUTDOWN chunk
+ * MUST be processed.
+ */
+sctp_disposition_t sctp_sf_do_9_2_shut_ctsn(const struct sctp_endpoint *ep,
+                                           const struct sctp_association *asoc,
+                                           const sctp_subtype_t type,
+                                           void *arg,
+                                           sctp_cmd_seq_t *commands)
+{
+        struct sctp_chunk *chunk = arg;
+        sctp_shutdownhdr_t *sdh;
+
+        if (!sctp_vtag_verify(chunk, asoc))
+                return sctp_sf_pdiscard(ep, asoc, type, arg, commands);
+
+        /* Make sure that the SHUTDOWN chunk has a valid length. */
+        if (!sctp_chunk_length_valid(chunk,
+                                      sizeof(struct sctp_shutdown_chunk_t)))
+                return sctp_sf_violation_chunklen(ep, asoc, type, arg,
+                                                  commands);
+
+        sdh = (sctp_shutdownhdr_t *)chunk->skb->data;
+
+        /* If Cumulative TSN Ack beyond the max tsn currently
+         * send, terminating the association and respond to the
+         * sender with an ABORT.
+         */
+        if (!TSN_lt(ntohl(sdh->cum_tsn_ack), asoc->next_tsn))
+                return sctp_sf_violation_ctsn(ep, asoc, type, arg, commands);
+
+        /* verify, by checking the Cumulative TSN Ack field of the
+         * chunk, that all its outstanding DATA chunks have been
+         * received by the SHUTDOWN sender.
+         */
+        sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_CTSN,
+                        SCTP_BE32(sdh->cum_tsn_ack));
+
+        return SCTP_DISPOSITION_CONSUME;
+}
+
 /* RFC 2960 9.2
  * If an endpoint is in SHUTDOWN-ACK-SENT state and receives an INIT chunk
  * (e.g., if the SHUTDOWN COMPLETE was lost) with source and destination
diff --git a/net/sctp/sm_statetable.c b/net/sctp/sm_statetable.c
index dd4ddc40c0ad..5c8186d88c61 100644
--- a/net/sctp/sm_statetable.c
+++ b/net/sctp/sm_statetable.c
@@ -266,11 +266,11 @@ const sctp_sm_table_entry_t *sctp_sm_lookup_event(sctp_event_t event_type,
         /* SCTP_STATE_ESTABLISHED */ \
         TYPE_SCTP_FUNC(sctp_sf_do_9_2_shutdown), \
         /* SCTP_STATE_SHUTDOWN_PENDING */ \
-        TYPE_SCTP_FUNC(sctp_sf_discard_chunk), \
+        TYPE_SCTP_FUNC(sctp_sf_do_9_2_shutdown), \
         /* SCTP_STATE_SHUTDOWN_SENT */ \
         TYPE_SCTP_FUNC(sctp_sf_do_9_2_shutdown_ack), \
         /* SCTP_STATE_SHUTDOWN_RECEIVED */ \
-        TYPE_SCTP_FUNC(sctp_sf_discard_chunk), \
+        TYPE_SCTP_FUNC(sctp_sf_do_9_2_shut_ctsn), \
         /* SCTP_STATE_SHUTDOWN_ACK_SENT */ \
         TYPE_SCTP_FUNC(sctp_sf_discard_chunk), \
 } /* TYPE_SCTP_SHUTDOWN */