20 files changed, 222 insertions, 141 deletions

diff --git a/include/net/af_unix.h b/include/net/af_unix.h
index 0864a775de24..a1c805d7f488 100644
--- a/include/net/af_unix.h
+++ b/include/net/af_unix.h
@@ -12,7 +12,7 @@ extern void unix_gc(void);
 
 #define UNIX_HASH_SIZE  256
 
-extern atomic_t unix_tot_inflight;
+extern unsigned int unix_tot_inflight;
 
 struct unix_address {
         atomic_t        refcnt;
diff --git a/include/net/dst.h b/include/net/dst.h
index e9ff4a4caef9..2f65e894b829 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -143,6 +143,13 @@ static inline void dst_hold(struct dst_entry * dst)
         atomic_inc(&dst->__refcnt);
 }
 
+static inline void dst_use(struct dst_entry *dst, unsigned long time)
+{
+        dst_hold(dst);
+        dst->__use++;
+        dst->lastuse = time;
+}
+
 static inline
 struct dst_entry * dst_clone(struct dst_entry * dst)
 {
diff --git a/include/net/esp.h b/include/net/esp.h
index c1bc529809da..c05f529bff28 100644
--- a/include/net/esp.h
+++ b/include/net/esp.h
@@ -3,7 +3,7 @@
 
 #include <linux/crypto.h>
 #include <net/xfrm.h>
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 
 #define ESP_NUM_FAST_SG         4
 
diff --git a/include/net/fib_rules.h b/include/net/fib_rules.h
index 017aebd90683..41a301e38643 100644
--- a/include/net/fib_rules.h
+++ b/include/net/fib_rules.h
@@ -107,4 +107,7 @@ extern int			fib_rules_unregister(struct fib_rules_ops *);
 extern int                      fib_rules_lookup(struct fib_rules_ops *,
                                                  struct flowi *, int flags,
                                                  struct fib_lookup_arg *);
+extern int                      fib_default_rule_add(struct fib_rules_ops *,
+                                                     u32 pref, u32 table,
+                                                     u32 flags);
 #endif
diff --git a/include/net/ieee80211.h b/include/net/ieee80211.h
index 164d13211165..d8ae48439f12 100644
--- a/include/net/ieee80211.h
+++ b/include/net/ieee80211.h
@@ -115,8 +115,16 @@ extern u32 ieee80211_debug_level;
 do { if (ieee80211_debug_level & (level)) \
   printk(KERN_DEBUG "ieee80211: %c %s " fmt, \
          in_interrupt() ? 'I' : 'U', __FUNCTION__ , ## args); } while (0)
+static inline bool ieee80211_ratelimit_debug(u32 level)
+{
+        return (ieee80211_debug_level & level) && net_ratelimit();
+}
 #else
 #define IEEE80211_DEBUG(level, fmt, args...) do {} while (0)
+static inline bool ieee80211_ratelimit_debug(u32 level)
+{
+        return false;
+}
 #endif                          /* CONFIG_IEEE80211_DEBUG */
 
 /* escape_essid() is intended to be used in debug (and possibly error)
diff --git a/include/net/inet_common.h b/include/net/inet_common.h
index 227adcbdfec8..38d5a1e9980d 100644
--- a/include/net/inet_common.h
+++ b/include/net/inet_common.h
@@ -13,9 +13,6 @@ struct sock;
 struct sockaddr;
 struct socket;
 
-extern void                     inet_remove_sock(struct sock *sk1);
-extern void                     inet_put_sock(unsigned short num, 
-                                              struct sock *sk);
 extern int                      inet_release(struct socket *sock);
 extern int                      inet_stream_connect(struct socket *sock,
                                                     struct sockaddr * uaddr,
@@ -30,7 +27,6 @@ extern int			inet_sendmsg(struct kiocb *iocb,
                                              struct msghdr *msg, 
                                              size_t size);
 extern int                      inet_shutdown(struct socket *sock, int how);
-extern unsigned int             inet_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait);
 extern int                      inet_listen(struct socket *sock, int backlog);
 
 extern void                     inet_sock_destruct(struct sock *sk);
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 4427dcd1e53a..37f6cb112127 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -23,6 +23,7 @@
 #include <linux/spinlock.h>
 #include <linux/types.h>
 #include <linux/wait.h>
+#include <linux/vmalloc.h>
 
 #include <net/inet_connection_sock.h>
 #include <net/inet_sock.h>
@@ -37,7 +38,6 @@
  * I'll experiment with dynamic table growth later.
  */
 struct inet_ehash_bucket {
-        rwlock_t          lock;
         struct hlist_head chain;
         struct hlist_head twchain;
 };
@@ -100,6 +100,9 @@ struct inet_hashinfo {
          * TIME_WAIT sockets use a separate chain (twchain).
          */
         struct inet_ehash_bucket        *ehash;
+        rwlock_t                        *ehash_locks;
+        unsigned int                    ehash_size;
+        unsigned int                    ehash_locks_mask;
 
         /* Ok, let's try this, I give up, we do need a local binding
          * TCP hash as well as the others for fast bind/connect.
@@ -107,7 +110,7 @@ struct inet_hashinfo {
         struct inet_bind_hashbucket     *bhash;
 
         unsigned int                    bhash_size;
-        unsigned int                    ehash_size;
+        /* Note : 4 bytes padding on 64 bit arches */
 
         /* All sockets in TCP_LISTEN state will be in here.  This is the only
          * table where wildcard'd TCP sockets can exist.  Hash function here
@@ -134,6 +137,61 @@ static inline struct inet_ehash_bucket *inet_ehash_bucket(
         return &hashinfo->ehash[hash & (hashinfo->ehash_size - 1)];
 }
 
+static inline rwlock_t *inet_ehash_lockp(
+        struct inet_hashinfo *hashinfo,
+        unsigned int hash)
+{
+        return &hashinfo->ehash_locks[hash & hashinfo->ehash_locks_mask];
+}
+
+static inline int inet_ehash_locks_alloc(struct inet_hashinfo *hashinfo)
+{
+        unsigned int i, size = 256;
+#if defined(CONFIG_PROVE_LOCKING)
+        unsigned int nr_pcpus = 2;
+#else
+        unsigned int nr_pcpus = num_possible_cpus();
+#endif
+        if (nr_pcpus >= 4)
+                size = 512;
+        if (nr_pcpus >= 8)
+                size = 1024;
+        if (nr_pcpus >= 16)
+                size = 2048;
+        if (nr_pcpus >= 32)
+                size = 4096;
+        if (sizeof(rwlock_t) != 0) {
+#ifdef CONFIG_NUMA
+                if (size * sizeof(rwlock_t) > PAGE_SIZE)
+                        hashinfo->ehash_locks = vmalloc(size * sizeof(rwlock_t));
+                else
+#endif
+                hashinfo->ehash_locks = kmalloc(size * sizeof(rwlock_t),
+                                                GFP_KERNEL);
+                if (!hashinfo->ehash_locks)
+                        return ENOMEM;
+                for (i = 0; i < size; i++)
+                        rwlock_init(&hashinfo->ehash_locks[i]);
+        }
+        hashinfo->ehash_locks_mask = size - 1;
+        return 0;
+}
+
+static inline void inet_ehash_locks_free(struct inet_hashinfo *hashinfo)
+{
+        if (hashinfo->ehash_locks) {
+#ifdef CONFIG_NUMA
+                unsigned int size = (hashinfo->ehash_locks_mask + 1) *
+                                                        sizeof(rwlock_t);
+                if (size > PAGE_SIZE)
+                        vfree(hashinfo->ehash_locks);
+                else
+#endif
+                kfree(hashinfo->ehash_locks);
+                hashinfo->ehash_locks = NULL;
+        }
+}
+
 extern struct inet_bind_bucket *
                     inet_bind_bucket_create(struct kmem_cache *cachep,
                                             struct inet_bind_hashbucket *head,
@@ -222,7 +280,7 @@ static inline void __inet_hash(struct inet_hashinfo *hashinfo,
                 sk->sk_hash = inet_sk_ehashfn(sk);
                 head = inet_ehash_bucket(hashinfo, sk->sk_hash);
                 list = &head->chain;
-                lock = &head->lock;
+                lock = inet_ehash_lockp(hashinfo, sk->sk_hash);
                 write_lock(lock);
         }
         __sk_add_node(sk, list);
@@ -253,7 +311,7 @@ static inline void inet_unhash(struct inet_hashinfo *hashinfo, struct sock *sk)
                 inet_listen_wlock(hashinfo);
                 lock = &hashinfo->lhash_lock;
         } else {
-                lock = &inet_ehash_bucket(hashinfo, sk->sk_hash)->lock;
+                lock = inet_ehash_lockp(hashinfo, sk->sk_hash);
                 write_lock_bh(lock);
         }
 
@@ -354,9 +412,10 @@ static inline struct sock *
          */
         unsigned int hash = inet_ehashfn(daddr, hnum, saddr, sport);
         struct inet_ehash_bucket *head = inet_ehash_bucket(hashinfo, hash);
+        rwlock_t *lock = inet_ehash_lockp(hashinfo, hash);
 
         prefetch(head->chain.first);
-        read_lock(&head->lock);
+        read_lock(lock);
         sk_for_each(sk, node, &head->chain) {
                 if (INET_MATCH(sk, hash, acookie, saddr, daddr, ports, dif))
                         goto hit; /* You sunk my battleship! */
@@ -369,7 +428,7 @@ static inline struct sock *
         }
         sk = NULL;
 out:
-        read_unlock(&head->lock);
+        read_unlock(lock);
         return sk;
 hit:
         sock_hold(sk);
diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h
index aa10a8178e70..ad8404b56113 100644
--- a/include/net/inetpeer.h
+++ b/include/net/inetpeer.h
@@ -22,7 +22,7 @@ struct inet_peer
         __be32                  v4daddr;        /* peer's address */
         __u16                   avl_height;
         __u16                   ip_id_count;    /* IP ID for the next packet */
-        struct inet_peer        *unused_next, **unused_prevp;
+        struct list_head        unused;
         __u32                   dtime;          /* the time of last use of not
                                                  * referenced entries */
         atomic_t                refcnt;
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index 8cadc77c7df4..ed514bfb61ba 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -185,6 +185,12 @@ static inline void fib_select_default(const struct flowi *flp, struct fib_result
 }
 
 #else /* CONFIG_IP_MULTIPLE_TABLES */
+extern void __init fib4_rules_init(void);
+
+#ifdef CONFIG_NET_CLS_ROUTE
+extern u32 fib_rules_tclass(struct fib_result *res);
+#endif
+
 #define ip_fib_local_table fib_get_table(RT_TABLE_LOCAL)
 #define ip_fib_main_table fib_get_table(RT_TABLE_MAIN)
 
@@ -214,15 +220,6 @@ extern __be32  __fib_res_prefsrc(struct fib_result *res);
 /* Exported by fib_hash.c */
 extern struct fib_table *fib_hash_init(u32 id);
 
-#ifdef CONFIG_IP_MULTIPLE_TABLES
-extern void __init fib4_rules_init(void);
-
-#ifdef CONFIG_NET_CLS_ROUTE
-extern u32 fib_rules_tclass(struct fib_result *res);
-#endif
-
-#endif
-
 static inline void fib_combine_itag(u32 *itag, struct fib_result *res)
 {
 #ifdef CONFIG_NET_CLS_ROUTE
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h
index 41870564df8e..8a7d59be8a0d 100644
--- a/include/net/ip_vs.h
+++ b/include/net/ip_vs.h
@@ -328,40 +328,6 @@ extern int ip_vs_get_debug_level(void);
 #define FTPDATA  __constant_htons(20)
 
 /*
- *      IPVS sysctl variables under the /proc/sys/net/ipv4/vs/
- */
-#define NET_IPV4_VS              21
-
-enum {
-        NET_IPV4_VS_DEBUG_LEVEL=1,
-        NET_IPV4_VS_AMEMTHRESH=2,
-        NET_IPV4_VS_AMDROPRATE=3,
-        NET_IPV4_VS_DROP_ENTRY=4,
-        NET_IPV4_VS_DROP_PACKET=5,
-        NET_IPV4_VS_SECURE_TCP=6,
-        NET_IPV4_VS_TO_ES=7,
-        NET_IPV4_VS_TO_SS=8,
-        NET_IPV4_VS_TO_SR=9,
-        NET_IPV4_VS_TO_FW=10,
-        NET_IPV4_VS_TO_TW=11,
-        NET_IPV4_VS_TO_CL=12,
-        NET_IPV4_VS_TO_CW=13,
-        NET_IPV4_VS_TO_LA=14,
-        NET_IPV4_VS_TO_LI=15,
-        NET_IPV4_VS_TO_SA=16,
-        NET_IPV4_VS_TO_UDP=17,
-        NET_IPV4_VS_TO_ICMP=18,
-        NET_IPV4_VS_LBLC_EXPIRE=19,
-        NET_IPV4_VS_LBLCR_EXPIRE=20,
-        NET_IPV4_VS_CACHE_BYPASS=22,
-        NET_IPV4_VS_EXPIRE_NODEST_CONN=23,
-        NET_IPV4_VS_SYNC_THRESHOLD=24,
-        NET_IPV4_VS_NAT_ICMP_SEND=25,
-        NET_IPV4_VS_EXPIRE_QUIESCENT_TEMPLATE=26,
-        NET_IPV4_VS_LAST
-};
-
-/*
  *      TCP State Values
  */
 enum {
@@ -520,6 +486,10 @@ struct ip_vs_conn {
         spinlock_t              lock;           /* lock for state transition */
         volatile __u16          flags;          /* status flags */
         volatile __u16          state;          /* state info */
+        volatile __u16          old_state;      /* old state, to be used for
+                                                 * state transition triggerd
+                                                 * synchronization
+                                                 */
 
         /* Control members */
         struct ip_vs_conn       *control;       /* Master control connection */
@@ -901,6 +871,10 @@ extern int ip_vs_use_count_inc(void);
 extern void ip_vs_use_count_dec(void);
 extern int ip_vs_control_init(void);
 extern void ip_vs_control_cleanup(void);
+extern struct ip_vs_dest *
+ip_vs_find_dest(__be32 daddr, __be16 dport,
+                 __be32 vaddr, __be16 vport, __u16 protocol);
+extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp);
 
 
 /*
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 5fcc4c104340..17b60391fcd6 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -706,11 +706,16 @@ enum ieee80211_hw_flags {
  *
  * @queues: number of available hardware transmit queues for
  *      data packets. WMM/QoS requires at least four.
+ *
+ * @rate_control_algorithm: rate control algorithm for this hardware.
+ *      If unset (NULL), the default algorithm will be used. Must be
+ *      set before calling ieee80211_register_hw().
  */
 struct ieee80211_hw {
         struct ieee80211_conf conf;
         struct wiphy *wiphy;
         struct workqueue_struct *workqueue;
+        const char *rate_control_algorithm;
         void *priv;
         u32 flags;
         unsigned int extra_tx_headroom;
@@ -936,27 +941,11 @@ enum ieee80211_erp_change_flags {
  *      and remove_interface calls, i.e. while the interface with the
  *      given local_address is enabled.
  *
- * @set_ieee8021x: Enable/disable IEEE 802.1X. This item requests wlan card
- *      to pass unencrypted EAPOL-Key frames even when encryption is
- *      configured. If the wlan card does not require such a configuration,
- *      this function pointer can be set to NULL.
- *
- * @set_port_auth: Set port authorization state (IEEE 802.1X PAE) to be
- *      authorized (@authorized=1) or unauthorized (=0). This function can be
- *      used if the wlan hardware or low-level driver implements PAE.
- *      mac80211 will filter frames based on authorization state in any case,
- *      so this function pointer can be NULL if low-level driver does not
- *      require event notification about port state changes.
- *
  * @hw_scan: Ask the hardware to service the scan request, no need to start
  *      the scan state machine in stack.
  *
  * @get_stats: return low-level statistics
  *
- * @set_privacy_invoked: For devices that generate their own beacons and probe
- *      response or association responses this updates the state of privacy_invoked
- *      returns 0 for success or an error number.
- *
  * @get_sequence_counter: For devices that have internal sequence counters this
  *      callback allows mac80211 to access the current value of a counter.
  *      This callback seems not well-defined, tell us if you need it.
@@ -1029,14 +1018,9 @@ struct ieee80211_ops {
         int (*set_key)(struct ieee80211_hw *hw, enum set_key_cmd cmd,
                        const u8 *local_address, const u8 *address,
                        struct ieee80211_key_conf *key);
-        int (*set_ieee8021x)(struct ieee80211_hw *hw, int use_ieee8021x);
-        int (*set_port_auth)(struct ieee80211_hw *hw, u8 *addr,
-                             int authorized);
         int (*hw_scan)(struct ieee80211_hw *hw, u8 *ssid, size_t len);
         int (*get_stats)(struct ieee80211_hw *hw,
                          struct ieee80211_low_level_stats *stats);
-        int (*set_privacy_invoked)(struct ieee80211_hw *hw,
-                                   int privacy_invoked);
         int (*get_sequence_counter)(struct ieee80211_hw *hw,
                                     u8* addr, u8 keyidx, u8 txrx,
                                     u32* iv32, u16* iv16);
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 5279466606d2..5dd6d90b37eb 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -51,13 +51,12 @@ static inline struct net *copy_net_ns(unsigned long flags, struct net *net_ns)
 }
 #endif
 
+#ifdef CONFIG_NET_NS
 extern void __put_net(struct net *net);
 
 static inline struct net *get_net(struct net *net)
 {
-#ifdef CONFIG_NET
         atomic_inc(&net->count);
-#endif
         return net;
 }
 
@@ -75,26 +74,44 @@ static inline struct net *maybe_get_net(struct net *net)
 
 static inline void put_net(struct net *net)
 {
-#ifdef CONFIG_NET
         if (atomic_dec_and_test(&net->count))
                 __put_net(net);
-#endif
 }
 
 static inline struct net *hold_net(struct net *net)
 {
-#ifdef CONFIG_NET
         atomic_inc(&net->use_count);
-#endif
         return net;
 }
 
 static inline void release_net(struct net *net)
 {
-#ifdef CONFIG_NET
         atomic_dec(&net->use_count);
-#endif
 }
+#else
+static inline struct net *get_net(struct net *net)
+{
+        return net;
+}
+
+static inline void put_net(struct net *net)
+{
+}
+
+static inline struct net *hold_net(struct net *net)
+{
+        return net;
+}
+
+static inline void release_net(struct net *net)
+{
+}
+
+static inline struct net *maybe_get_net(struct net *net)
+{
+        return net;
+}
+#endif
 
 #define for_each_net(VAR)                               \
         list_for_each_entry(VAR, &net_namespace_list, list)
@@ -102,9 +119,11 @@ static inline void release_net(struct net *net)
 #ifdef CONFIG_NET_NS
 #define __net_init
 #define __net_exit
+#define __net_initdata
 #else
 #define __net_init      __init
 #define __net_exit      __exit_refok
+#define __net_initdata  __initdata
 #endif
 
 struct pernet_operations {
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 7aed02ce2b65..cff4608179c1 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -124,23 +124,7 @@ struct request_sock_queue {
 extern int reqsk_queue_alloc(struct request_sock_queue *queue,
                              unsigned int nr_table_entries);
 
-static inline struct listen_sock *reqsk_queue_yank_listen_sk(struct request_sock_queue *queue)
-{
-        struct listen_sock *lopt;
-
-        write_lock_bh(&queue->syn_wait_lock);
-        lopt = queue->listen_opt;
-        queue->listen_opt = NULL;
-        write_unlock_bh(&queue->syn_wait_lock);
-
-        return lopt;
-}
-
-static inline void __reqsk_queue_destroy(struct request_sock_queue *queue)
-{
-        kfree(reqsk_queue_yank_listen_sk(queue));
-}
-
+extern void __reqsk_queue_destroy(struct request_sock_queue *queue);
 extern void reqsk_queue_destroy(struct request_sock_queue *queue);
 
 static inline struct request_sock *
diff --git a/include/net/sctp/auth.h b/include/net/sctp/auth.h
index 9e8f13b7da5a..5db261a1e85e 100644
--- a/include/net/sctp/auth.h
+++ b/include/net/sctp/auth.h
@@ -103,7 +103,7 @@ struct sctp_hmac *sctp_auth_asoc_get_hmac(const struct sctp_association *asoc);
 void sctp_auth_asoc_set_default_hmac(struct sctp_association *asoc,
                                      struct sctp_hmac_algo_param *hmacs);
 int sctp_auth_asoc_verify_hmac_id(const struct sctp_association *asoc,
-                                    __u16 hmac_id);
+                                    __be16 hmac_id);
 int sctp_auth_send_cid(sctp_cid_t chunk, const struct sctp_association *asoc);
 int sctp_auth_recv_cid(sctp_cid_t chunk, const struct sctp_association *asoc);
 void sctp_auth_calculate_hmac(const struct sctp_association *asoc,
diff --git a/include/net/sctp/command.h b/include/net/sctp/command.h
index b8733364557f..c1f797673571 100644
--- a/include/net/sctp/command.h
+++ b/include/net/sctp/command.h
@@ -103,6 +103,7 @@ typedef enum {
         SCTP_CMD_ASSOC_CHANGE,   /* generate and send assoc_change event */
         SCTP_CMD_ADAPTATION_IND, /* generate and send adaptation event */
         SCTP_CMD_ASSOC_SHKEY,    /* generate the association shared keys */
+        SCTP_CMD_T1_RETRAN,      /* Mark for retransmission after T1 timeout  */
         SCTP_CMD_LAST
 } sctp_verb_t;
 
diff --git a/include/net/sctp/constants.h b/include/net/sctp/constants.h
index da8354e8e33c..f30b537d6952 100644
--- a/include/net/sctp/constants.h
+++ b/include/net/sctp/constants.h
@@ -186,6 +186,8 @@ typedef enum {
         SCTP_IERROR_AUTH_BAD_HMAC,
         SCTP_IERROR_AUTH_BAD_KEYID,
         SCTP_IERROR_PROTO_VIOLATION,
+        SCTP_IERROR_ERROR,
+        SCTP_IERROR_ABORT,
 } sctp_ierror_t;
 
 
@@ -407,6 +409,7 @@ typedef enum {
         SCTP_RTXR_T3_RTX,
         SCTP_RTXR_FAST_RTX,
         SCTP_RTXR_PMTUD,
+        SCTP_RTXR_T1_RTX,
 } sctp_retransmit_reason_t;
 
 /* Reasons to lower cwnd. */
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 93eb708609e7..34318a33a94c 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -65,7 +65,6 @@
 
 
 #ifdef TEST_FRAME
-#undef CONFIG_PROC_FS
 #undef CONFIG_SCTP_DBG_OBJCNT
 #undef CONFIG_SYSCTL
 #endif /* TEST_FRAME */
@@ -267,6 +266,7 @@ enum
         SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS,
         SCTP_MIB_DELAY_SACK_EXPIREDS,
         SCTP_MIB_AUTOCLOSE_EXPIREDS,
+        SCTP_MIB_T1_RETRANSMITS,
         SCTP_MIB_T3_RETRANSMITS,
         SCTP_MIB_PMTUD_RETRANSMITS,
         SCTP_MIB_FAST_RETRANSMITS,
@@ -664,6 +664,9 @@ static inline int sctp_vtag_hashfn(__u16 lport, __u16 rport, __u32 vtag)
         return (h & (sctp_assoc_hashsize-1));
 }
 
+#define sctp_for_each_hentry(epb, node, head) \
+        hlist_for_each_entry(epb, node, head, node)
+
 /* Is a socket of this style? */
 #define sctp_style(sk, style) __sctp_style((sk), (SCTP_SOCKET_##style))
 static inline int __sctp_style(const struct sock *sk, sctp_socket_type_t style)
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index ef892e00c833..eb3113c38a94 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -100,20 +100,19 @@ struct crypto_hash;
 struct sctp_bind_bucket {
         unsigned short  port;
         unsigned short  fastreuse;
-        struct sctp_bind_bucket *next;
-        struct sctp_bind_bucket **pprev;
+        struct hlist_node       node;
         struct hlist_head       owner;
 };
 
 struct sctp_bind_hashbucket {
         spinlock_t      lock;
-        struct sctp_bind_bucket *chain;
+        struct hlist_head       chain;
 };
 
 /* Used for hashing all associations.  */
 struct sctp_hashbucket {
         rwlock_t        lock;
-        struct sctp_ep_common  *chain;
+        struct hlist_head       chain;
 } __attribute__((__aligned__(8)));
 
 
@@ -212,6 +211,7 @@ extern struct sctp_globals {
         
         /* Flag to indicate if addip is enabled. */
         int addip_enable;
+        int addip_noauth_enable;
 
         /* Flag to indicate if PR-SCTP is enabled. */
         int prsctp_enable;
@@ -249,6 +249,7 @@ extern struct sctp_globals {
 #define sctp_local_addr_list            (sctp_globals.local_addr_list)
 #define sctp_local_addr_lock            (sctp_globals.addr_list_lock)
 #define sctp_addip_enable               (sctp_globals.addip_enable)
+#define sctp_addip_noauth               (sctp_globals.addip_noauth_enable)
 #define sctp_prsctp_enable              (sctp_globals.prsctp_enable)
 #define sctp_auth_enable                (sctp_globals.auth_enable)
 
@@ -873,10 +874,11 @@ struct sctp_transport {
          * address list derived from the INIT or INIT ACK chunk, a
          * number of data elements needs to be maintained including:
          */
-        __u32 rtt;              /* This is the most recent RTT.  */
-
         /* RTO         : The current retransmission timeout value.  */
         unsigned long rto;
+        unsigned long last_rto;
+
+        __u32 rtt;              /* This is the most recent RTT.  */
 
         /* RTTVAR      : The current RTT variation.  */
         __u32 rttvar;
@@ -1184,9 +1186,7 @@ int sctp_bind_addr_copy(struct sctp_bind_addr *dest,
                         int flags);
 int sctp_add_bind_addr(struct sctp_bind_addr *, union sctp_addr *,
                        __u8 use_as_src, gfp_t gfp);
-int sctp_del_bind_addr(struct sctp_bind_addr *, union sctp_addr *,
-                        void fastcall (*rcu_call)(struct rcu_head *,
-                                          void (*func)(struct rcu_head *)));
+int sctp_del_bind_addr(struct sctp_bind_addr *, union sctp_addr *);
 int sctp_bind_addr_match(struct sctp_bind_addr *, const union sctp_addr *,
                          struct sctp_sock *);
 union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr   *bp,
@@ -1229,8 +1229,7 @@ typedef enum {
 
 struct sctp_ep_common {
         /* Fields to help us manage our entries in the hash tables. */
-        struct sctp_ep_common *next;
-        struct sctp_ep_common **pprev;
+        struct hlist_node node;
         int hashent;
 
         /* Runtime type information.  What kind of endpoint is this? */
@@ -1541,7 +1540,6 @@ struct sctp_association {
                 __u8    asconf_capable;  /* Does peer support ADDIP? */
                 __u8    prsctp_capable;  /* Can peer do PR-SCTP? */
                 __u8    auth_capable;    /* Is peer doing SCTP-AUTH? */
-                __u8    addip_capable;   /* Can peer do ADD-IP */
 
                 __u32   adaptation_ind;  /* Adaptation Code point. */
 
diff --git a/include/net/sock.h b/include/net/sock.h
index 43fc3fa50d62..67e35c7e230c 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -560,6 +560,14 @@ struct proto {
         void                    (*unhash)(struct sock *sk);
         int                     (*get_port)(struct sock *sk, unsigned short snum);
 
+#ifdef CONFIG_SMP
+        /* Keeping track of sockets in use */
+        void                    (*inuse_add)(struct proto *prot, int inc);
+        int                     (*inuse_getval)(const struct proto *prot);
+        int                     *inuse_ptr;
+#else
+        int                     inuse;
+#endif
         /* Memory pressure */
         void                    (*enter_memory_pressure)(void);
         atomic_t                *memory_allocated;      /* Current allocated memory. */
@@ -592,12 +600,38 @@ struct proto {
 #ifdef SOCK_REFCNT_DEBUG
         atomic_t                socks;
 #endif
-        struct {
-                int inuse;
-                u8  __pad[SMP_CACHE_BYTES - sizeof(int)];
-        } stats[NR_CPUS];
 };
 
+/*
+ * Special macros to let protos use a fast version of inuse{get|add}
+ * using a static percpu variable per proto instead of an allocated one,
+ * saving one dereference.
+ * This might be changed if/when dynamic percpu vars become fast.
+ */
+#ifdef CONFIG_SMP
+# define DEFINE_PROTO_INUSE(NAME)                       \
+static DEFINE_PER_CPU(int, NAME##_inuse);               \
+static void NAME##_inuse_add(struct proto *prot, int inc)       \
+{                                                       \
+        __get_cpu_var(NAME##_inuse) += inc;             \
+}                                                       \
+                                                        \
+static int NAME##_inuse_getval(const struct proto *prot)\
+{                                                       \
+        int res = 0, cpu;                               \
+                                                        \
+        for_each_possible_cpu(cpu)                      \
+                res += per_cpu(NAME##_inuse, cpu);      \
+        return res;                                     \
+}
+# define REF_PROTO_INUSE(NAME)                          \
+        .inuse_add = NAME##_inuse_add,                  \
+        .inuse_getval = NAME##_inuse_getval,
+#else
+# define DEFINE_PROTO_INUSE(NAME)
+# define REF_PROTO_INUSE(NAME)
+#endif
+
 extern int proto_register(struct proto *prot, int alloc_slab);
 extern void proto_unregister(struct proto *prot);
 
@@ -629,12 +663,29 @@ static inline void sk_refcnt_debug_release(const struct sock *sk)
 /* Called with local bh disabled */
 static __inline__ void sock_prot_inc_use(struct proto *prot)
 {
-        prot->stats[smp_processor_id()].inuse++;
+#ifdef CONFIG_SMP
+        prot->inuse_add(prot, 1);
+#else
+        prot->inuse++;
+#endif
 }
 
 static __inline__ void sock_prot_dec_use(struct proto *prot)
 {
-        prot->stats[smp_processor_id()].inuse--;
+#ifdef CONFIG_SMP
+        prot->inuse_add(prot, -1);
+#else
+        prot->inuse--;
+#endif
+}
+
+static __inline__ int sock_prot_inuse(struct proto *proto)
+{
+#ifdef CONFIG_SMP
+        return proto->inuse_getval(proto);
+#else
+        return proto->inuse;
+#endif
 }
 
 /* With per-bucket locks this operation is not-atomic, so that
@@ -779,7 +830,7 @@ extern void FASTCALL(release_sock(struct sock *sk));
 
 extern struct sock              *sk_alloc(struct net *net, int family,
                                           gfp_t priority,
-                                          struct proto *prot, int zero_it);
+                                          struct proto *prot);
 extern void                     sk_free(struct sock *sk);
 extern struct sock              *sk_clone(const struct sock *sk,
                                           const gfp_t priority);
@@ -993,20 +1044,6 @@ static inline void sock_graft(struct sock *sk, struct socket *parent)
         write_unlock_bh(&sk->sk_callback_lock);
 }
 
-static inline void sock_copy(struct sock *nsk, const struct sock *osk)
-{
-#ifdef CONFIG_SECURITY_NETWORK
-        void *sptr = nsk->sk_security;
-#endif
-
-        memcpy(nsk, osk, osk->sk_prot->obj_size);
-        get_net(nsk->sk_net);
-#ifdef CONFIG_SECURITY_NETWORK
-        nsk->sk_security = sptr;
-        security_sk_clone(osk, nsk);
-#endif
-}
-
 extern int sock_i_uid(struct sock *sk);
 extern unsigned long sock_i_ino(struct sock *sk);
 
@@ -1198,14 +1235,19 @@ static inline struct sk_buff *sk_stream_alloc_pskb(struct sock *sk,
                                                    gfp_t gfp)
 {
         struct sk_buff *skb;
-        int hdr_len;
 
-        hdr_len = SKB_DATA_ALIGN(sk->sk_prot->max_header);
-        skb = alloc_skb_fclone(size + hdr_len, gfp);
+        /* The TCP header must be at least 32-bit aligned.  */
+        size = ALIGN(size, 4);
+
+        skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
         if (skb) {
                 skb->truesize += mem;
                 if (sk_stream_wmem_schedule(sk, skb->truesize)) {
-                        skb_reserve(skb, hdr_len);
+                        /*
+                         * Make sure that we have exactly size bytes
+                         * available to the caller, no more, no less.
+                         */
+                        skb_reserve(skb, skb_tailroom(skb) - size);
                         return skb;
                 }
                 __kfree_skb(skb);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index d695cea7730d..cb5b033e0e59 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -1288,6 +1288,9 @@ static inline void tcp_insert_write_queue_before(struct sk_buff *new,
                                                   struct sock *sk)
 {
         __skb_insert(new, skb->prev, skb, &sk->sk_write_queue);
+
+        if (sk->sk_send_head == skb)
+                sk->sk_send_head = new;
 }
 
 static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk)