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

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6: (1480 commits) bonding: enable netpoll without checking link status xfrm: Refcount destination entry on xfrm_lookup net: introduce rx_handler results and logic around that bonding: get rid of IFF_SLAVE_INACTIVE netdev->priv_flag bonding: wrap slave state work net: get rid of multiple bond-related netdevice->priv_flags bonding: register slave pointer for rx_handler be2net: Bump up the version number be2net: Copyright notice change. Update to Emulex instead of ServerEngines e1000e: fix kconfig for crc32 dependency netfilter ebtables: fix xt_AUDIT to work with ebtables xen network backend driver bonding: Improve syslog message at device creation time bonding: Call netif_carrier_off after register_netdevice bonding: Incorrect TX queue offset net_sched: fix ip_tos2prio xfrm: fix __xfrm_route_forward() be2net: Fix UDP packet detected status in RX compl Phonet: fix aligned-mode pipe socket buffer header reserve netxen: support for GbE port settings ... Fix up conflicts in drivers/staging/brcm80211/brcmsmac/wl_mac80211.c with the staging updates.
author: Linus Torvalds <torvalds@linux-foundation.org> 2011-03-16 19:29:25 -0400
committer: Linus Torvalds <torvalds@linux-foundation.org> 2011-03-16 19:29:25 -0400
commit: 7a6362800cb7d1d618a697a650c7aaed3eb39320 (patch)
tree: 087f9bc6c13ef1fad4b392c5cf9325cd28fa8523 /include
parent: 6445ced8670f37cfc2c5e24a9de9b413dbfc788d (diff)
parent: ceda86a108671294052cbf51660097b6534672f5 (diff)
139 files changed, 5016 insertions, 831 deletions
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 359df0487690..9d339eb27881 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -103,6 +103,8 @@
 #define AUDIT_BPRM_FCAPS        1321    /* Information about fcaps increasing perms */
 #define AUDIT_CAPSET            1322    /* Record showing argument to sys_capset */
 #define AUDIT_MMAP              1323    /* Record showing descriptor and flags in mmap */
+#define AUDIT_NETFILTER_PKT     1324    /* Packets traversing netfilter chains */
+#define AUDIT_NETFILTER_CFG     1325    /* Netfilter chain modifications */
 #define AUDIT_AVC               1400    /* SE Linux avc denial or grant */
 #define AUDIT_SELINUX_ERR       1401    /* Internal SE Linux Errors */
diff --git a/include/linux/cpu_rmap.h b/include/linux/cpu_rmap.h
new file mode 100644
index 000000000000..473771a528c0
--- /dev/null
+++ b/include/linux/cpu_rmap.h
@@ -0,0 +1,73 @@
+/*
+ * cpu_rmap.c: CPU affinity reverse-map support
+ * Copyright 2011 Solarflare Communications Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation, incorporated herein by reference.
+ */
+#include <linux/cpumask.h>
+#include <linux/gfp.h>
+#include <linux/slab.h>
+/**
+ * struct cpu_rmap - CPU affinity reverse-map
+ * @size: Number of objects to be reverse-mapped
+ * @used: Number of objects added
+ * @obj: Pointer to array of object pointers
+ * @near: For each CPU, the index and distance to the nearest object,
+ *      based on affinity masks
+ */
+struct cpu_rmap {
+        u16             size, used;
+        void            **obj;
+        struct {
+                u16     index;
+                u16     dist;
+        }               near[0];
+};
+#define CPU_RMAP_DIST_INF 0xffff
+extern struct cpu_rmap *alloc_cpu_rmap(unsigned int size, gfp_t flags);
+/**
+ * free_cpu_rmap - free CPU affinity reverse-map
+ * @rmap: Reverse-map allocated with alloc_cpu_rmap(), or %NULL
+ */
+static inline void free_cpu_rmap(struct cpu_rmap *rmap)
+{
+        kfree(rmap);
+}
+extern int cpu_rmap_add(struct cpu_rmap *rmap, void *obj);
+extern int cpu_rmap_update(struct cpu_rmap *rmap, u16 index,
+                           const struct cpumask *affinity);
+static inline u16 cpu_rmap_lookup_index(struct cpu_rmap *rmap, unsigned int cpu)
+{
+        return rmap->near[cpu].index;
+}
+static inline void *cpu_rmap_lookup_obj(struct cpu_rmap *rmap, unsigned int cpu)
+{
+        return rmap->obj[rmap->near[cpu].index];
+}
+#ifdef CONFIG_GENERIC_HARDIRQS
+/**
+ * alloc_irq_cpu_rmap - allocate CPU affinity reverse-map for IRQs
+ * @size: Number of objects to be mapped
+ *
+ * Must be called in process context.
+ */
+static inline struct cpu_rmap *alloc_irq_cpu_rmap(unsigned int size)
+{
+        return alloc_cpu_rmap(size, GFP_KERNEL);
+}
+extern void free_irq_cpu_rmap(struct cpu_rmap *rmap);
+extern int irq_cpu_rmap_add(struct cpu_rmap *rmap, int irq);
+#endif
diff --git a/include/linux/dcbnl.h b/include/linux/dcbnl.h
index 66900e3c6eb1..c52280047e2c 100644
--- a/include/linux/dcbnl.h
+++ b/include/linux/dcbnl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, Intel Corporation.
+ * Copyright (c) 2008-2011, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
@@ -25,9 +25,14 @@
 /* IEEE 802.1Qaz std supported values */
 #define IEEE_8021QAZ_MAX_TCS    8
+#define IEEE_8021QAZ_TSA_STRICT         0
+#define IEEE_8021QAZ_TSA_CB_SHAPER      1
+#define IEEE_8021QAZ_TSA_ETS            2
+#define IEEE_8021QAZ_TSA_VENDOR         255
 /* This structure contains the IEEE 802.1Qaz ETS managed object
 *
- * @willing: willing bit in ETS configuratin TLV
+ * @willing: willing bit in ETS configuration TLV
 * @ets_cap: indicates supported capacity of ets feature
 * @cbs: credit based shaper ets algorithm supported
 * @tc_tx_bw: tc tx bandwidth indexed by traffic class
@@ -82,6 +87,50 @@ struct ieee_pfc {
        __u64   indications[IEEE_8021QAZ_MAX_TCS];
 };
+/* CEE DCBX std supported values */
+#define CEE_DCBX_MAX_PGS        8
+#define CEE_DCBX_MAX_PRIO       8
+/**
+ * struct cee_pg - CEE Priority-Group managed object
+ *
+ * @willing: willing bit in the PG tlv
+ * @error: error bit in the PG tlv
+ * @pg_en: enable bit of the PG feature
+ * @tcs_supported: number of traffic classes supported
+ * @pg_bw: bandwidth percentage for each priority group
+ * @prio_pg: priority to PG mapping indexed by priority
+ */
+struct cee_pg {
+        __u8    willing;
+        __u8    error;
+        __u8    pg_en;
+        __u8    tcs_supported;
+        __u8    pg_bw[CEE_DCBX_MAX_PGS];
+        __u8    prio_pg[CEE_DCBX_MAX_PGS];
+};
+/**
+ * struct cee_pfc - CEE PFC managed object
+ *
+ * @willing: willing bit in the PFC tlv
+ * @error: error bit in the PFC tlv
+ * @pfc_en: bitmap indicating pfc enabled traffic classes
+ * @tcs_supported: number of traffic classes supported
+ */
+struct cee_pfc {
+        __u8    willing;
+        __u8    error;
+        __u8    pfc_en;
+        __u8    tcs_supported;
+};
+/* IEEE 802.1Qaz std supported values */
+#define IEEE_8021QAZ_APP_SEL_ETHERTYPE  1
+#define IEEE_8021QAZ_APP_SEL_STREAM     2
+#define IEEE_8021QAZ_APP_SEL_DGRAM      3
+#define IEEE_8021QAZ_APP_SEL_ANY        4
 /* This structure contains the IEEE 802.1Qaz APP managed object. This
 * object is also used for the CEE std as well. There is no difference
 * between the objects.
@@ -105,6 +154,20 @@ struct dcb_app {
        __u16   protocol;
 };
+/**
+ * struct dcb_peer_app_info - APP feature information sent by the peer
+ *
+ * @willing: willing bit in the peer APP tlv
+ * @error: error bit in the peer APP tlv
+ *
+ * In addition to this information the full peer APP tlv also contains
+ * a table of 'app_count' APP objects defined above.
+ */
+struct dcb_peer_app_info {
+        __u8    willing;
+        __u8    error;
+};
 struct dcbmsg {
        __u8               dcb_family;
        __u8               cmd;
@@ -139,6 +202,7 @@ struct dcbmsg {
 * @DCB_CMD_SDCBX: set DCBX engine configuration
 * @DCB_CMD_GFEATCFG: get DCBX features flags
 * @DCB_CMD_SFEATCFG: set DCBX features negotiation flags
+ * @DCB_CMD_CEE_GET: get CEE aggregated configuration
 */
 enum dcbnl_commands {
        DCB_CMD_UNDEFINED,
@@ -181,6 +245,8 @@ enum dcbnl_commands {
        DCB_CMD_GFEATCFG,
        DCB_CMD_SFEATCFG,
+        DCB_CMD_CEE_GET,
        __DCB_CMD_ENUM_MAX,
        DCB_CMD_MAX = __DCB_CMD_ENUM_MAX - 1,
 };
@@ -203,6 +269,7 @@ enum dcbnl_commands {
 * @DCB_ATTR_IEEE: IEEE 802.1Qaz supported attributes (NLA_NESTED)
 * @DCB_ATTR_DCBX: DCBX engine configuration in the device (NLA_U8)
 * @DCB_ATTR_FEATCFG: DCBX features flags (NLA_NESTED)
+ * @DCB_ATTR_CEE: CEE std supported attributes (NLA_NESTED)
 */
 enum dcbnl_attrs {
        DCB_ATTR_UNDEFINED,
@@ -226,15 +293,32 @@ enum dcbnl_attrs {
        DCB_ATTR_DCBX,
        DCB_ATTR_FEATCFG,
+        /* CEE nested attributes */
+        DCB_ATTR_CEE,
        __DCB_ATTR_ENUM_MAX,
        DCB_ATTR_MAX = __DCB_ATTR_ENUM_MAX - 1,
 };
+/**
+ * enum ieee_attrs - IEEE 802.1Qaz get/set attributes
+ *
+ * @DCB_ATTR_IEEE_UNSPEC: unspecified
+ * @DCB_ATTR_IEEE_ETS: negotiated ETS configuration
+ * @DCB_ATTR_IEEE_PFC: negotiated PFC configuration
+ * @DCB_ATTR_IEEE_APP_TABLE: negotiated APP configuration
+ * @DCB_ATTR_IEEE_PEER_ETS: peer ETS configuration - get only
+ * @DCB_ATTR_IEEE_PEER_PFC: peer PFC configuration - get only
+ * @DCB_ATTR_IEEE_PEER_APP: peer APP tlv - get only
+ */
 enum ieee_attrs {
        DCB_ATTR_IEEE_UNSPEC,
        DCB_ATTR_IEEE_ETS,
        DCB_ATTR_IEEE_PFC,
        DCB_ATTR_IEEE_APP_TABLE,
+        DCB_ATTR_IEEE_PEER_ETS,
+        DCB_ATTR_IEEE_PEER_PFC,
+        DCB_ATTR_IEEE_PEER_APP,
        __DCB_ATTR_IEEE_MAX
 };
 #define DCB_ATTR_IEEE_MAX (__DCB_ATTR_IEEE_MAX - 1)
@@ -247,6 +331,31 @@ enum ieee_attrs_app {
 #define DCB_ATTR_IEEE_APP_MAX (__DCB_ATTR_IEEE_APP_MAX - 1)
 /**
+ * enum cee_attrs - CEE DCBX get attributes
+ *
+ * @DCB_ATTR_CEE_UNSPEC: unspecified
+ * @DCB_ATTR_CEE_PEER_PG: peer PG configuration - get only
+ * @DCB_ATTR_CEE_PEER_PFC: peer PFC configuration - get only
+ * @DCB_ATTR_CEE_PEER_APP: peer APP tlv - get only
+ */
+enum cee_attrs {
+        DCB_ATTR_CEE_UNSPEC,
+        DCB_ATTR_CEE_PEER_PG,
+        DCB_ATTR_CEE_PEER_PFC,
+        DCB_ATTR_CEE_PEER_APP_TABLE,
+        __DCB_ATTR_CEE_MAX
+};
+#define DCB_ATTR_CEE_MAX (__DCB_ATTR_CEE_MAX - 1)
+enum peer_app_attr {
+        DCB_ATTR_CEE_PEER_APP_UNSPEC,
+        DCB_ATTR_CEE_PEER_APP_INFO,
+        DCB_ATTR_CEE_PEER_APP,
+        __DCB_ATTR_CEE_PEER_APP_MAX
+};
+#define DCB_ATTR_CEE_PEER_APP_MAX (__DCB_ATTR_CEE_PEER_APP_MAX - 1)
+/**
 * enum dcbnl_pfc_attrs - DCB Priority Flow Control user priority nested attrs
 *
 * @DCB_PFC_UP_ATTR_UNDEFINED: unspecified attribute to catch errors
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 010e2d87ed75..d638e85dc501 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -279,8 +279,6 @@ enum dccp_state {
        DCCP_MAX_STATES
 };
-#define DCCP_STATE_MASK 0x1f
 enum {
        DCCPF_OPEN            = TCPF_ESTABLISHED,
        DCCPF_REQUESTING      = TCPF_SYN_SENT,
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 1908929204a9..aac3e2eeb4fd 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -251,6 +251,7 @@ enum ethtool_stringset {
        ETH_SS_STATS,
        ETH_SS_PRIV_FLAGS,
        ETH_SS_NTUPLE_FILTERS,
+        ETH_SS_FEATURES,
 };
 /* for passing string sets for data tagging */
@@ -523,6 +524,92 @@ struct ethtool_flash {
        char    data[ETHTOOL_FLASH_MAX_FILENAME];
 };
+/* for returning and changing feature sets */
+/**
+ * struct ethtool_get_features_block - block with state of 32 features
+ * @available: mask of changeable features
+ * @requested: mask of features requested to be enabled if possible
+ * @active: mask of currently enabled features
+ * @never_changed: mask of features not changeable for any device
+ */
+struct ethtool_get_features_block {
+        __u32   available;
+        __u32   requested;
+        __u32   active;
+        __u32   never_changed;
+};
+/**
+ * struct ethtool_gfeatures - command to get state of device's features
+ * @cmd: command number = %ETHTOOL_GFEATURES
+ * @size: in: number of elements in the features[] array;
+ *       out: number of elements in features[] needed to hold all features
+ * @features: state of features
+ */
+struct ethtool_gfeatures {
+        __u32   cmd;
+        __u32   size;
+        struct ethtool_get_features_block features[0];
+};
+/**
+ * struct ethtool_set_features_block - block with request for 32 features
+ * @valid: mask of features to be changed
+ * @requested: values of features to be changed
+ */
+struct ethtool_set_features_block {
+        __u32   valid;
+        __u32   requested;
+};
+/**
+ * struct ethtool_sfeatures - command to request change in device's features
+ * @cmd: command number = %ETHTOOL_SFEATURES
+ * @size: array size of the features[] array
+ * @features: feature change masks
+ */
+struct ethtool_sfeatures {
+        __u32   cmd;
+        __u32   size;
+        struct ethtool_set_features_block features[0];
+};
+/*
+ * %ETHTOOL_SFEATURES changes features present in features[].valid to the
+ * values of corresponding bits in features[].requested. Bits in .requested
+ * not set in .valid or not changeable are ignored.
+ *
+ * Returns %EINVAL when .valid contains undefined or never-changable bits
+ * or size is not equal to required number of features words (32-bit blocks).
+ * Returns >= 0 if request was completed; bits set in the value mean:
+ *   %ETHTOOL_F_UNSUPPORTED - there were bits set in .valid that are not
+ *      changeable (not present in %ETHTOOL_GFEATURES' features[].available)
+ *      those bits were ignored.
+ *   %ETHTOOL_F_WISH - some or all changes requested were recorded but the
+ *      resulting state of bits masked by .valid is not equal to .requested.
+ *      Probably there are other device-specific constraints on some features
+ *      in the set. When %ETHTOOL_F_UNSUPPORTED is set, .valid is considered
+ *      here as though ignored bits were cleared.
+ *   %ETHTOOL_F_COMPAT - some or all changes requested were made by calling
+ *      compatibility functions. Requested offload state cannot be properly
+ *      managed by kernel.
+ *
+ * Meaning of bits in the masks are obtained by %ETHTOOL_GSSET_INFO (number of
+ * bits in the arrays - always multiple of 32) and %ETHTOOL_GSTRINGS commands
+ * for ETH_SS_FEATURES string set. First entry in the table corresponds to least
+ * significant bit in features[0] fields. Empty strings mark undefined features.
+ */
+enum ethtool_sfeatures_retval_bits {
+        ETHTOOL_F_UNSUPPORTED__BIT,
+        ETHTOOL_F_WISH__BIT,
+        ETHTOOL_F_COMPAT__BIT,
+};
+#define ETHTOOL_F_UNSUPPORTED   (1 << ETHTOOL_F_UNSUPPORTED__BIT)
+#define ETHTOOL_F_WISH          (1 << ETHTOOL_F_WISH__BIT)
+#define ETHTOOL_F_COMPAT        (1 << ETHTOOL_F_COMPAT__BIT)
 #ifdef __KERNEL__
 #include <linux/rculist.h>
@@ -543,7 +630,6 @@ struct net_device;
 /* Some generic methods drivers may use in their ethtool_ops */
 u32 ethtool_op_get_link(struct net_device *dev);
-u32 ethtool_op_get_rx_csum(struct net_device *dev);
 u32 ethtool_op_get_tx_csum(struct net_device *dev);
 int ethtool_op_set_tx_csum(struct net_device *dev, u32 data);
 int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data);
@@ -744,6 +830,9 @@ struct ethtool_ops {
 #define ETHTOOL_GRXFHINDIR      0x00000038 /* Get RX flow hash indir'n table */
 #define ETHTOOL_SRXFHINDIR      0x00000039 /* Set RX flow hash indir'n table */
+#define ETHTOOL_GFEATURES       0x0000003a /* Get device offload settings */
+#define ETHTOOL_SFEATURES       0x0000003b /* Change device offload settings */
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
 #define SPARC_ETH_SSET          ETHTOOL_SSET
diff --git a/include/linux/icmpv6.h b/include/linux/icmpv6.h
index 4c4c74ec5987..ba45e6bc0764 100644
--- a/include/linux/icmpv6.h
+++ b/include/linux/icmpv6.h
@@ -183,10 +183,10 @@ extern void				icmpv6_cleanup(void);
 extern void                             icmpv6_param_prob(struct sk_buff *skb,
                                                          u8 code, int pos);
-struct flowi;
+struct flowi6;
 struct in6_addr;
 extern void                             icmpv6_flow_init(struct sock *sk,
-                                                         struct flowi *fl,
+                                                         struct flowi6 *fl6,
                                                         u8 type,
                                                         const struct in6_addr *saddr,
                                                         const struct in6_addr *daddr,
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 294169e31364..2d1c6117d92c 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -1325,6 +1325,9 @@ enum {
 /* Although the spec says 8 I'm seeing 6 in practice */
 #define IEEE80211_COUNTRY_IE_MIN_LEN    6
+/* The Country String field of the element shall be 3 octets in length */
+#define IEEE80211_COUNTRY_STRING_LEN    3
 /*
 * For regulatory extension stuff see IEEE 802.11-2007
 * Annex I (page 1141) and Annex J (page 1147). Also
diff --git a/include/linux/if.h b/include/linux/if.h
index 123959927745..3bc63e6a02f7 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -71,11 +71,10 @@
                                         * release skb->dst
                                         */
 #define IFF_DONT_BRIDGE 0x800           /* disallow bridging this ether dev */
-#define IFF_IN_NETPOLL  0x1000          /* whether we are processing netpoll */
+#define IFF_DISABLE_NETPOLL     0x1000  /* disable netpoll at run-time */
-#define IFF_DISABLE_NETPOLL     0x2000  /* disable netpoll at run-time */
+#define IFF_MACVLAN_PORT        0x2000  /* device used as macvlan port */
-#define IFF_MACVLAN_PORT        0x4000  /* device used as macvlan port */
+#define IFF_BRIDGE_PORT 0x4000          /* device used as bridge port */
-#define IFF_BRIDGE_PORT 0x8000          /* device used as bridge port */
+#define IFF_OVS_DATAPATH        0x8000  /* device used as Open vSwitch
-#define IFF_OVS_DATAPATH        0x10000 /* device used as Open vSwitch
                                         * datapath port */
 #define IF_GET_IFACE    0x0001          /* for querying only */
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index 6485d2a89bec..f4a2e6b1b864 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -135,6 +135,7 @@ enum {
        IFLA_VF_PORTS,
        IFLA_PORT_SELF,
        IFLA_AF_SPEC,
+        IFLA_GROUP,             /* Group the device belongs to */
        __IFLA_MAX
 };
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index 74cfcff0148b..82de336b8155 100644
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -217,7 +217,7 @@ struct ip_mc_list {
 #define IGMPV3_QQIC(value) IGMPV3_EXP(0x80, 4, 3, value)
 #define IGMPV3_MRC(value) IGMPV3_EXP(0x80, 4, 3, value)
-extern int ip_check_mc(struct in_device *dev, __be32 mc_addr, __be32 src_addr, u16 proto);
+extern int ip_check_mc_rcu(struct in_device *dev, __be32 mc_addr, __be32 src_addr, u16 proto);
 extern int igmp_rcv(struct sk_buff *);
 extern int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr);
 extern int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr);
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index ae8fdc54e0c0..5f8146695b7f 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -144,6 +144,7 @@ static inline void ipv4_devconf_setall(struct in_device *in_dev)
 #define IN_DEV_ARP_NOTIFY(in_dev)       IN_DEV_MAXCONF((in_dev), ARP_NOTIFY)
 struct in_ifaddr {
+        struct hlist_node       hash;
        struct in_ifaddr        *ifa_next;
        struct in_device        *ifa_dev;
        struct rcu_head         rcu_head;
diff --git a/include/linux/ip_vs.h b/include/linux/ip_vs.h
index 5f43a3b2e3ad..4deb3834d62c 100644
--- a/include/linux/ip_vs.h
+++ b/include/linux/ip_vs.h
@@ -89,6 +89,14 @@
 #define IP_VS_CONN_F_TEMPLATE   0x1000          /* template, not connection */
 #define IP_VS_CONN_F_ONE_PACKET 0x2000          /* forward only one packet */
+#define IP_VS_CONN_F_BACKUP_MASK (IP_VS_CONN_F_FWD_MASK | \
+                                  IP_VS_CONN_F_NOOUTPUT | \
+                                  IP_VS_CONN_F_INACTIVE | \
+                                  IP_VS_CONN_F_SEQ_MASK | \
+                                  IP_VS_CONN_F_NO_CPORT | \
+                                  IP_VS_CONN_F_TEMPLATE \
+                                 )
 /* Flags that are not sent to backup server start from bit 16 */
 #define IP_VS_CONN_F_NFCT       (1 << 16)       /* use netfilter conntrack */
diff --git a/include/linux/micrel_phy.h b/include/linux/micrel_phy.h
new file mode 100644
index 000000000000..dd8da342a991
--- /dev/null
+++ b/include/linux/micrel_phy.h
@@ -0,0 +1,16 @@
+#ifndef _MICREL_PHY_H
+#define _MICREL_PHY_H
+#define MICREL_PHY_ID_MASK      0x00fffff0
+#define PHY_ID_KSZ9021          0x00221611
+#define PHY_ID_KS8737           0x00221720
+#define PHY_ID_KS8041           0x00221510
+#define PHY_ID_KS8051           0x00221550
+/* both for ks8001 Rev. A/B, and for ks8721 Rev 3. */
+#define PHY_ID_KS8001           0x0022161A
+/* struct phy_device dev_flags definitions */
+#define MICREL_PHY_50MHZ_CLK    0x00000001
+#endif /* _MICREL_PHY_H */
diff --git a/include/linux/net.h b/include/linux/net.h
index 16faa130088c..94de83c0f877 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -118,6 +118,7 @@ enum sock_shutdown_cmd {
 };
 struct socket_wq {
+        /* Note: wait MUST be first field of socket_wq */
        wait_queue_head_t       wait;
        struct fasync_struct    *fasync_list;
        struct rcu_head         rcu;
@@ -142,7 +143,7 @@ struct socket {
        unsigned long           flags;
-        struct socket_wq        *wq;
+        struct socket_wq __rcu  *wq;
        struct file             *file;
        struct sock             *sk;
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 71caf7a5e6c6..5eeb2cd3631c 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -138,6 +138,9 @@ static inline bool dev_xmit_complete(int rc)
 #define MAX_ADDR_LEN    32              /* Largest hardware address length */
+/* Initial net device group. All devices belong to group 0 by default. */
+#define INIT_NETDEV_GROUP       0
 #ifdef  __KERNEL__
 /*
 *      Compute the worst case header length according to the protocols
@@ -387,7 +390,55 @@ enum gro_result {
 };
 typedef enum gro_result gro_result_t;
-typedef struct sk_buff *rx_handler_func_t(struct sk_buff *skb);
+/*
+ * enum rx_handler_result - Possible return values for rx_handlers.
+ * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
+ * further.
+ * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
+ * case skb->dev was changed by rx_handler.
+ * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
+ * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
+ *
+ * rx_handlers are functions called from inside __netif_receive_skb(), to do
+ * special processing of the skb, prior to delivery to protocol handlers.
+ *
+ * Currently, a net_device can only have a single rx_handler registered. Trying
+ * to register a second rx_handler will return -EBUSY.
+ *
+ * To register a rx_handler on a net_device, use netdev_rx_handler_register().
+ * To unregister a rx_handler on a net_device, use
+ * netdev_rx_handler_unregister().
+ *
+ * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
+ * do with the skb.
+ *
+ * If the rx_handler consumed to skb in some way, it should return
+ * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
+ * the skb to be delivered in some other ways.
+ *
+ * If the rx_handler changed skb->dev, to divert the skb to another
+ * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
+ * new device will be called if it exists.
+ *
+ * If the rx_handler consider the skb should be ignored, it should return
+ * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
+ * are registred on exact device (ptype->dev == skb->dev).
+ *
+ * If the rx_handler didn't changed skb->dev, but want the skb to be normally
+ * delivered, it should return RX_HANDLER_PASS.
+ *
+ * A device without a registered rx_handler will behave as if rx_handler
+ * returned RX_HANDLER_PASS.
+ */
+enum rx_handler_result {
+        RX_HANDLER_CONSUMED,
+        RX_HANDLER_ANOTHER,
+        RX_HANDLER_EXACT,
+        RX_HANDLER_PASS,
+};
+typedef enum rx_handler_result rx_handler_result_t;
+typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
 extern void __napi_schedule(struct napi_struct *n);
@@ -551,14 +602,16 @@ struct rps_map {
 #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
 /*
- * The rps_dev_flow structure contains the mapping of a flow to a CPU and the
+ * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
- * tail pointer for that CPU's input queue at the time of last enqueue.
+ * tail pointer for that CPU's input queue at the time of last enqueue, and
+ * a hardware filter index.
 */
 struct rps_dev_flow {
        u16 cpu;
-        u16 fill;
+        u16 filter;
        unsigned int last_qtail;
 };
+#define RPS_NO_FILTER 0xffff
 /*
 * The rps_dev_flow_table structure contains a table of flow mappings.
@@ -608,6 +661,11 @@ static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
 extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
+#ifdef CONFIG_RFS_ACCEL
+extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
+                                u32 flow_id, u16 filter_id);
+#endif
 /* This structure contains an instance of an RX queue. */
 struct netdev_rx_queue {
        struct rps_map __rcu            *rps_map;
@@ -643,6 +701,14 @@ struct xps_dev_maps {
    (nr_cpu_ids * sizeof(struct xps_map *)))
 #endif /* CONFIG_XPS */
+#define TC_MAX_QUEUE    16
+#define TC_BITMASK      15
+/* HW offloaded queuing disciplines txq count and offset maps */
+struct netdev_tc_txq {
+        u16 count;
+        u16 offset;
+};
 /*
 * This structure defines the management hooks for network devices.
 * The following hooks can be defined; unless noted otherwise, they are
@@ -753,6 +819,74 @@ struct xps_dev_maps {
 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
 *                        struct nlattr *port[]);
 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
+ * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
+ *      Called to setup 'tc' number of traffic classes in the net device. This
+ *      is always called from the stack with the rtnl lock held and netif tx
+ *      queues stopped. This allows the netdevice to perform queue management
+ *      safely.
+ *
+ *      Fiber Channel over Ethernet (FCoE) offload functions.
+ * int (*ndo_fcoe_enable)(struct net_device *dev);
+ *      Called when the FCoE protocol stack wants to start using LLD for FCoE
+ *      so the underlying device can perform whatever needed configuration or
+ *      initialization to support acceleration of FCoE traffic.
+ *
+ * int (*ndo_fcoe_disable)(struct net_device *dev);
+ *      Called when the FCoE protocol stack wants to stop using LLD for FCoE
+ *      so the underlying device can perform whatever needed clean-ups to
+ *      stop supporting acceleration of FCoE traffic.
+ *
+ * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
+ *                           struct scatterlist *sgl, unsigned int sgc);
+ *      Called when the FCoE Initiator wants to initialize an I/O that
+ *      is a possible candidate for Direct Data Placement (DDP). The LLD can
+ *      perform necessary setup and returns 1 to indicate the device is set up
+ *      successfully to perform DDP on this I/O, otherwise this returns 0.
+ *
+ * int (*ndo_fcoe_ddp_done)(struct net_device *dev,  u16 xid);
+ *      Called when the FCoE Initiator/Target is done with the DDPed I/O as
+ *      indicated by the FC exchange id 'xid', so the underlying device can
+ *      clean up and reuse resources for later DDP requests.
+ *
+ * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
+ *                            struct scatterlist *sgl, unsigned int sgc);
+ *      Called when the FCoE Target wants to initialize an I/O that
+ *      is a possible candidate for Direct Data Placement (DDP). The LLD can
+ *      perform necessary setup and returns 1 to indicate the device is set up
+ *      successfully to perform DDP on this I/O, otherwise this returns 0.
+ *
+ * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
+ *      Called when the underlying device wants to override default World Wide
+ *      Name (WWN) generation mechanism in FCoE protocol stack to pass its own
+ *      World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
+ *      protocol stack to use.
+ *
+ *      RFS acceleration.
+ * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
+ *                          u16 rxq_index, u32 flow_id);
+ *      Set hardware filter for RFS.  rxq_index is the target queue index;
+ *      flow_id is a flow ID to be passed to rps_may_expire_flow() later.
+ *      Return the filter ID on success, or a negative error code.
+ *
+ *      Slave management functions (for bridge, bonding, etc). User should
+ *      call netdev_set_master() to set dev->master properly.
+ * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
+ *      Called to make another netdev an underling.
+ *
+ * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
+ *      Called to release previously enslaved netdev.
+ *
+ *      Feature/offload setting functions.
+ * u32 (*ndo_fix_features)(struct net_device *dev, u32 features);
+ *      Adjusts the requested feature flags according to device-specific
+ *      constraints, and returns the resulting flags. Must not modify
+ *      the device state.
+ *
+ * int (*ndo_set_features)(struct net_device *dev, u32 features);
+ *      Called to update device configuration to new features. Passed
+ *      feature set might be less than what was returned by ndo_fix_features()).
+ *      Must return >0 or -errno if it changed dev->features itself.
+ *
 */
 #define HAVE_NET_DEVICE_OPS
 struct net_device_ops {
@@ -811,6 +945,7 @@ struct net_device_ops {
                                                   struct nlattr *port[]);
        int                     (*ndo_get_vf_port)(struct net_device *dev,
                                                   int vf, struct sk_buff *skb);
+        int                     (*ndo_setup_tc)(struct net_device *dev, u8 tc);
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
        int                     (*ndo_fcoe_enable)(struct net_device *dev);
        int                     (*ndo_fcoe_disable)(struct net_device *dev);
@@ -820,11 +955,29 @@ struct net_device_ops {
                                                      unsigned int sgc);
        int                     (*ndo_fcoe_ddp_done)(struct net_device *dev,
                                                     u16 xid);
+        int                     (*ndo_fcoe_ddp_target)(struct net_device *dev,
+                                                       u16 xid,
+                                                       struct scatterlist *sgl,
+                                                       unsigned int sgc);
 #define NETDEV_FCOE_WWNN 0
 #define NETDEV_FCOE_WWPN 1
        int                     (*ndo_fcoe_get_wwn)(struct net_device *dev,
                                                    u64 *wwn, int type);
 #endif
+#ifdef CONFIG_RFS_ACCEL
+        int                     (*ndo_rx_flow_steer)(struct net_device *dev,
+                                                     const struct sk_buff *skb,
+                                                     u16 rxq_index,
+                                                     u32 flow_id);
+#endif
+        int                     (*ndo_add_slave)(struct net_device *dev,
+                                                 struct net_device *slave_dev);
+        int                     (*ndo_del_slave)(struct net_device *dev,
+                                                 struct net_device *slave_dev);
+        u32                     (*ndo_fix_features)(struct net_device *dev,
+                                                    u32 features);
+        int                     (*ndo_set_features)(struct net_device *dev,
+                                                    u32 features);
 };
 /*
@@ -876,8 +1029,18 @@ struct net_device {
        struct list_head        napi_list;
        struct list_head        unreg_list;
-        /* Net device features */
+        /* currently active device features */
-        unsigned long           features;
+        u32                     features;
+        /* user-changeable features */
+        u32                     hw_features;
+        /* user-requested features */
+        u32                     wanted_features;
+        /* VLAN feature mask */
+        u32                     vlan_features;
+        /* Net device feature bits; if you change something,
+         * also update netdev_features_strings[] in ethtool.c */
 #define NETIF_F_SG              1       /* Scatter/gather IO. */
 #define NETIF_F_IP_CSUM         2       /* Can checksum TCP/UDP over IPv4. */
 #define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
@@ -902,6 +1065,7 @@ struct net_device {
 #define NETIF_F_FCOE_MTU        (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
 #define NETIF_F_NTUPLE          (1 << 27) /* N-tuple filters supported */
 #define NETIF_F_RXHASH          (1 << 28) /* Receive hashing offload */
+#define NETIF_F_RXCSUM          (1 << 29) /* Receive checksumming offload */
        /* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT       16
@@ -913,6 +1077,12 @@ struct net_device {
 #define NETIF_F_TSO6            (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
 #define NETIF_F_FSO             (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
+        /* Features valid for ethtool to change */
+        /* = all defined minus driver/device-class-related */
+#define NETIF_F_NEVER_CHANGE    (NETIF_F_HIGHDMA | NETIF_F_VLAN_CHALLENGED | \
+                                  NETIF_F_LLTX | NETIF_F_NETNS_LOCAL)
+#define NETIF_F_ETHTOOL_BITS    (0x3f3fffff & ~NETIF_F_NEVER_CHANGE)
        /* List of features with software fallbacks. */
 #define NETIF_F_GSO_SOFTWARE    (NETIF_F_TSO | NETIF_F_TSO_ECN | \
                                 NETIF_F_TSO6 | NETIF_F_UFO)
@@ -923,6 +1093,12 @@ struct net_device {
 #define NETIF_F_V6_CSUM         (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
 #define NETIF_F_ALL_CSUM        (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
+#define NETIF_F_ALL_TSO         (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
+#define NETIF_F_ALL_TX_OFFLOADS (NETIF_F_ALL_CSUM | NETIF_F_SG | \
+                                 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
+                                 NETIF_F_SCTP_CSUM | NETIF_F_FCOE_CRC)
        /*
         * If one device supports one of these features, then enable them
         * for all in netdev_increment_features.
@@ -931,6 +1107,9 @@ struct net_device {
                                 NETIF_F_SG | NETIF_F_HIGHDMA |         \
                                 NETIF_F_FRAGLIST)
+        /* changeable features with no special hardware requirements */
+#define NETIF_F_SOFT_FEATURES   (NETIF_F_GSO | NETIF_F_GRO)
        /* Interface index. Unique device identifier    */
        int                     ifindex;
        int                     iflink;
@@ -1039,6 +1218,13 @@ struct net_device {
        /* Number of RX queues currently active in device */
        unsigned int            real_num_rx_queues;
+#ifdef CONFIG_RFS_ACCEL
+        /* CPU reverse-mapping for RX completion interrupts, indexed
+         * by RX queue number.  Assigned by driver.  This must only be
+         * set if the ndo_rx_flow_steer operation is defined. */
+        struct cpu_rmap         *rx_cpu_rmap;
+#endif
 #endif
        rx_handler_func_t __rcu *rx_handler;
@@ -1132,9 +1318,6 @@ struct net_device {
        /* rtnetlink link ops */
        const struct rtnl_link_ops *rtnl_link_ops;
-        /* VLAN feature mask */
-        unsigned long vlan_features;
        /* for setting kernel sock attribute on TCP connection setup */
 #define GSO_MAX_SIZE            65536
        unsigned int            gso_max_size;
@@ -1143,6 +1326,9 @@ struct net_device {
        /* Data Center Bridging netlink ops */
        const struct dcbnl_rtnl_ops *dcbnl_ops;
 #endif
+        u8 num_tc;
+        struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
+        u8 prio_tc_map[TC_BITMASK + 1];
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
        /* max exchange id for FCoE LRO by ddp */
@@ -1153,12 +1339,66 @@ struct net_device {
        /* phy device may attach itself for hardware timestamping */
        struct phy_device *phydev;
+        /* group the device belongs to */
+        int group;
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 #define NETDEV_ALIGN            32
 static inline
+int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
+{
+        return dev->prio_tc_map[prio & TC_BITMASK];
+}
+static inline
+int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
+{
+        if (tc >= dev->num_tc)
+                return -EINVAL;
+        dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
+        return 0;
+}
+static inline
+void netdev_reset_tc(struct net_device *dev)
+{
+        dev->num_tc = 0;
+        memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
+        memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
+}
+static inline
+int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
+{
+        if (tc >= dev->num_tc)
+                return -EINVAL;
+        dev->tc_to_txq[tc].count = count;
+        dev->tc_to_txq[tc].offset = offset;
+        return 0;
+}
+static inline
+int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
+{
+        if (num_tc > TC_MAX_QUEUE)
+                return -EINVAL;
+        dev->num_tc = num_tc;
+        return 0;
+}
+static inline
+int netdev_get_num_tc(struct net_device *dev)
+{
+        return dev->num_tc;
+}
+static inline
 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
                                         unsigned int index)
 {
@@ -1300,7 +1540,7 @@ struct packet_type {
                                         struct packet_type *,
                                         struct net_device *);
        struct sk_buff          *(*gso_segment)(struct sk_buff *skb,
-                                                int features);
+                                                u32 features);
        int                     (*gso_send_check)(struct sk_buff *skb);
        struct sk_buff          **(*gro_receive)(struct sk_buff **head,
                                               struct sk_buff *skb);
@@ -1345,7 +1585,7 @@ static inline struct net_device *next_net_device_rcu(struct net_device *dev)
        struct net *net;
        net = dev_net(dev);
-        lh = rcu_dereference(dev->dev_list.next);
+        lh = rcu_dereference(list_next_rcu(&dev->dev_list));
        return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
 }
@@ -1355,6 +1595,13 @@ static inline struct net_device *first_net_device(struct net *net)
                net_device_entry(net->dev_base_head.next);
 }
+static inline struct net_device *first_net_device_rcu(struct net *net)
+{
+        struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
+        return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
+}
 extern int                      netdev_boot_setup_check(struct net_device *dev);
 extern unsigned long            netdev_boot_base(const char *prefix, int unit);
 extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
@@ -1606,8 +1853,7 @@ static inline void netif_tx_wake_all_queues(struct net_device *dev)
 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
 {
        if (WARN_ON(!dev_queue)) {
-                printk(KERN_INFO "netif_stop_queue() cannot be called before "
+                pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
-                       "register_netdev()");
                return;
        }
        set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
@@ -1844,6 +2090,7 @@ extern int		dev_set_alias(struct net_device *, const char *, size_t);
 extern int              dev_change_net_namespace(struct net_device *,
                                                 struct net *, const char *);
 extern int              dev_set_mtu(struct net_device *, int);
+extern void             dev_set_group(struct net_device *, int);
 extern int              dev_set_mac_address(struct net_device *,
                                            struct sockaddr *);
 extern int              dev_hard_start_xmit(struct sk_buff *skb,
@@ -2267,8 +2514,10 @@ extern int		netdev_max_backlog;
 extern int              netdev_tstamp_prequeue;
 extern int              weight_p;
 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
+extern int netdev_set_bond_master(struct net_device *dev,
+                                  struct net_device *master);
 extern int skb_checksum_help(struct sk_buff *skb);
-extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
+extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features);
 #ifdef CONFIG_BUG
 extern void netdev_rx_csum_fault(struct net_device *dev);
 #else
@@ -2295,22 +2544,26 @@ extern char *netdev_drivername(const struct net_device *dev, char *buffer, int l
 extern void linkwatch_run_queue(void);
-unsigned long netdev_increment_features(unsigned long all, unsigned long one,
+static inline u32 netdev_get_wanted_features(struct net_device *dev)
-                                        unsigned long mask);
+{
-unsigned long netdev_fix_features(unsigned long features, const char *name);
+        return (dev->features & ~dev->hw_features) | dev->wanted_features;
+}
+u32 netdev_increment_features(u32 all, u32 one, u32 mask);
+u32 netdev_fix_features(struct net_device *dev, u32 features);
+void netdev_update_features(struct net_device *dev);
 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
                                        struct net_device *dev);
-int netif_skb_features(struct sk_buff *skb);
+u32 netif_skb_features(struct sk_buff *skb);
-static inline int net_gso_ok(int features, int gso_type)
+static inline int net_gso_ok(u32 features, int gso_type)
 {
        int feature = gso_type << NETIF_F_GSO_SHIFT;
        return (features & feature) == feature;
 }
-static inline int skb_gso_ok(struct sk_buff *skb, int features)
+static inline int skb_gso_ok(struct sk_buff *skb, u32 features)
 {
        return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
               (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
@@ -2328,15 +2581,9 @@ static inline void netif_set_gso_max_size(struct net_device *dev,
        dev->gso_max_size = size;
 }
-extern int __skb_bond_should_drop(struct sk_buff *skb,
+static inline int netif_is_bond_slave(struct net_device *dev)
-                                  struct net_device *master);
-static inline int skb_bond_should_drop(struct sk_buff *skb,
-                                       struct net_device *master)
 {
-        if (master)
+        return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
-                return __skb_bond_should_drop(skb, master);
-        return 0;
 }
 extern struct pernet_operations __net_initdata loopback_net_ops;
@@ -2351,6 +2598,8 @@ static inline int dev_ethtool_get_settings(struct net_device *dev,
 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
 {
+        if (dev->hw_features & NETIF_F_RXCSUM)
+                return !!(dev->features & NETIF_F_RXCSUM);
        if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
                return 0;
        return dev->ethtool_ops->get_rx_csum(dev);
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 1893837b3966..eeec00abb664 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -24,16 +24,20 @@
 #define NF_MAX_VERDICT NF_STOP
 /* we overload the higher bits for encoding auxiliary data such as the queue
- * number. Not nice, but better than additional function arguments. */
+ * number or errno values. Not nice, but better than additional function
-#define NF_VERDICT_MASK 0x0000ffff
+ * arguments. */
-#define NF_VERDICT_BITS 16
+#define NF_VERDICT_MASK 0x000000ff
+/* extra verdict flags have mask 0x0000ff00 */
+#define NF_VERDICT_FLAG_QUEUE_BYPASS    0x00008000
+/* queue number (NF_QUEUE) or errno (NF_DROP) */
 #define NF_VERDICT_QMASK 0xffff0000
 #define NF_VERDICT_QBITS 16
-#define NF_QUEUE_NR(x) ((((x) << NF_VERDICT_BITS) & NF_VERDICT_QMASK) | NF_QUEUE)
+#define NF_QUEUE_NR(x) ((((x) << 16) & NF_VERDICT_QMASK) | NF_QUEUE)
-#define NF_DROP_ERR(x) (((-x) << NF_VERDICT_BITS) | NF_DROP)
+#define NF_DROP_ERR(x) (((-x) << 16) | NF_DROP)
 /* only for userspace compatibility */
 #ifndef __KERNEL__
@@ -41,6 +45,9 @@
   <= 0x2000 is used for protocol-flags. */
 #define NFC_UNKNOWN 0x4000
 #define NFC_ALTERED 0x8000
+/* NF_VERDICT_BITS should be 8 now, but userspace might break if this changes */
+#define NF_VERDICT_BITS 16
 #endif
 enum nf_inet_hooks {
@@ -72,6 +79,10 @@ union nf_inet_addr {
 #ifdef __KERNEL__
 #ifdef CONFIG_NETFILTER
+static inline int NF_DROP_GETERR(int verdict)
+{
+        return -(verdict >> NF_VERDICT_QBITS);
+}
 static inline int nf_inet_addr_cmp(const union nf_inet_addr *a1,
                                   const union nf_inet_addr *a2)
@@ -267,7 +278,7 @@ struct nf_afinfo {
        int             route_key_size;
 };
-extern const struct nf_afinfo *nf_afinfo[NFPROTO_NUMPROTO];
+extern const struct nf_afinfo __rcu *nf_afinfo[NFPROTO_NUMPROTO];
 static inline const struct nf_afinfo *nf_get_afinfo(unsigned short family)
 {
        return rcu_dereference(nf_afinfo[family]);
@@ -357,9 +368,9 @@ nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
 #endif /*CONFIG_NETFILTER*/
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
-extern void (*ip_ct_attach)(struct sk_buff *, struct sk_buff *);
+extern void (*ip_ct_attach)(struct sk_buff *, struct sk_buff *) __rcu;
 extern void nf_ct_attach(struct sk_buff *, struct sk_buff *);
-extern void (*nf_ct_destroy)(struct nf_conntrack *);
+extern void (*nf_ct_destroy)(struct nf_conntrack *) __rcu;
 #else
 static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
 #endif
diff --git a/include/linux/netfilter/Kbuild b/include/linux/netfilter/Kbuild
index 9d40effe7ca7..a1b410c76fc3 100644
--- a/include/linux/netfilter/Kbuild
+++ b/include/linux/netfilter/Kbuild
@@ -1,3 +1,5 @@
+header-y += ipset/
 header-y += nf_conntrack_common.h
 header-y += nf_conntrack_ftp.h
 header-y += nf_conntrack_sctp.h
@@ -9,6 +11,7 @@ header-y += nfnetlink_conntrack.h
 header-y += nfnetlink_log.h
 header-y += nfnetlink_queue.h
 header-y += x_tables.h
+header-y += xt_AUDIT.h
 header-y += xt_CHECKSUM.h
 header-y += xt_CLASSIFY.h
 header-y += xt_CONNMARK.h
@@ -26,6 +29,7 @@ header-y += xt_TCPMSS.h
 header-y += xt_TCPOPTSTRIP.h
 header-y += xt_TEE.h
 header-y += xt_TPROXY.h
+header-y += xt_addrtype.h
 header-y += xt_cluster.h
 header-y += xt_comment.h
 header-y += xt_connbytes.h
@@ -34,6 +38,7 @@ header-y += xt_connmark.h
 header-y += xt_conntrack.h
 header-y += xt_cpu.h
 header-y += xt_dccp.h
+header-y += xt_devgroup.h
 header-y += xt_dscp.h
 header-y += xt_esp.h
 header-y += xt_hashlimit.h
@@ -54,7 +59,9 @@ header-y += xt_quota.h
 header-y += xt_rateest.h
 header-y += xt_realm.h
 header-y += xt_recent.h
+header-y += xt_set.h
 header-y += xt_sctp.h
+header-y += xt_socket.h
 header-y += xt_state.h
 header-y += xt_statistic.h
 header-y += xt_string.h
diff --git a/include/linux/netfilter/ipset/Kbuild b/include/linux/netfilter/ipset/Kbuild
new file mode 100644
index 000000000000..601fe71d34d5
--- /dev/null
+++ b/include/linux/netfilter/ipset/Kbuild
@@ -0,0 +1,4 @@
+header-y += ip_set.h
+header-y += ip_set_bitmap.h
+header-y += ip_set_hash.h
+header-y += ip_set_list.h
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
new file mode 100644
index 000000000000..ec333d83f3b4
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -0,0 +1,452 @@
+#ifndef _IP_SET_H
+#define _IP_SET_H
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ *                         Martin Josefsson <gandalf@wlug.westbo.se>
+ * Copyright (C) 2003-2011 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+/* The protocol version */
+#define IPSET_PROTOCOL          6
+/* The max length of strings including NUL: set and type identifiers */
+#define IPSET_MAXNAMELEN        32
+/* Message types and commands */
+enum ipset_cmd {
+        IPSET_CMD_NONE,
+        IPSET_CMD_PROTOCOL,     /* 1: Return protocol version */
+        IPSET_CMD_CREATE,       /* 2: Create a new (empty) set */
+        IPSET_CMD_DESTROY,      /* 3: Destroy a (empty) set */
+        IPSET_CMD_FLUSH,        /* 4: Remove all elements from a set */
+        IPSET_CMD_RENAME,       /* 5: Rename a set */
+        IPSET_CMD_SWAP,         /* 6: Swap two sets */
+        IPSET_CMD_LIST,         /* 7: List sets */
+        IPSET_CMD_SAVE,         /* 8: Save sets */
+        IPSET_CMD_ADD,          /* 9: Add an element to a set */
+        IPSET_CMD_DEL,          /* 10: Delete an element from a set */
+        IPSET_CMD_TEST,         /* 11: Test an element in a set */
+        IPSET_CMD_HEADER,       /* 12: Get set header data only */
+        IPSET_CMD_TYPE,         /* 13: Get set type */
+        IPSET_MSG_MAX,          /* Netlink message commands */
+        /* Commands in userspace: */
+        IPSET_CMD_RESTORE = IPSET_MSG_MAX, /* 14: Enter restore mode */
+        IPSET_CMD_HELP,         /* 15: Get help */
+        IPSET_CMD_VERSION,      /* 16: Get program version */
+        IPSET_CMD_QUIT,         /* 17: Quit from interactive mode */
+        IPSET_CMD_MAX,
+        IPSET_CMD_COMMIT = IPSET_CMD_MAX, /* 18: Commit buffered commands */
+};
+/* Attributes at command level */
+enum {
+        IPSET_ATTR_UNSPEC,
+        IPSET_ATTR_PROTOCOL,    /* 1: Protocol version */
+        IPSET_ATTR_SETNAME,     /* 2: Name of the set */
+        IPSET_ATTR_TYPENAME,    /* 3: Typename */
+        IPSET_ATTR_SETNAME2 = IPSET_ATTR_TYPENAME, /* Setname at rename/swap */
+        IPSET_ATTR_REVISION,    /* 4: Settype revision */
+        IPSET_ATTR_FAMILY,      /* 5: Settype family */
+        IPSET_ATTR_FLAGS,       /* 6: Flags at command level */
+        IPSET_ATTR_DATA,        /* 7: Nested attributes */
+        IPSET_ATTR_ADT,         /* 8: Multiple data containers */
+        IPSET_ATTR_LINENO,      /* 9: Restore lineno */
+        IPSET_ATTR_PROTOCOL_MIN, /* 10: Minimal supported version number */
+        IPSET_ATTR_REVISION_MIN = IPSET_ATTR_PROTOCOL_MIN, /* type rev min */
+        __IPSET_ATTR_CMD_MAX,
+};
+#define IPSET_ATTR_CMD_MAX      (__IPSET_ATTR_CMD_MAX - 1)
+/* CADT specific attributes */
+enum {
+        IPSET_ATTR_IP = IPSET_ATTR_UNSPEC + 1,
+        IPSET_ATTR_IP_FROM = IPSET_ATTR_IP,
+        IPSET_ATTR_IP_TO,       /* 2 */
+        IPSET_ATTR_CIDR,        /* 3 */
+        IPSET_ATTR_PORT,        /* 4 */
+        IPSET_ATTR_PORT_FROM = IPSET_ATTR_PORT,
+        IPSET_ATTR_PORT_TO,     /* 5 */
+        IPSET_ATTR_TIMEOUT,     /* 6 */
+        IPSET_ATTR_PROTO,       /* 7 */
+        IPSET_ATTR_CADT_FLAGS,  /* 8 */
+        IPSET_ATTR_CADT_LINENO = IPSET_ATTR_LINENO,     /* 9 */
+        /* Reserve empty slots */
+        IPSET_ATTR_CADT_MAX = 16,
+        /* Create-only specific attributes */
+        IPSET_ATTR_GC,
+        IPSET_ATTR_HASHSIZE,
+        IPSET_ATTR_MAXELEM,
+        IPSET_ATTR_NETMASK,
+        IPSET_ATTR_PROBES,
+        IPSET_ATTR_RESIZE,
+        IPSET_ATTR_SIZE,
+        /* Kernel-only */
+        IPSET_ATTR_ELEMENTS,
+        IPSET_ATTR_REFERENCES,
+        IPSET_ATTR_MEMSIZE,
+        __IPSET_ATTR_CREATE_MAX,
+};
+#define IPSET_ATTR_CREATE_MAX   (__IPSET_ATTR_CREATE_MAX - 1)
+/* ADT specific attributes */
+enum {
+        IPSET_ATTR_ETHER = IPSET_ATTR_CADT_MAX + 1,
+        IPSET_ATTR_NAME,
+        IPSET_ATTR_NAMEREF,
+        IPSET_ATTR_IP2,
+        IPSET_ATTR_CIDR2,
+        __IPSET_ATTR_ADT_MAX,
+};
+#define IPSET_ATTR_ADT_MAX      (__IPSET_ATTR_ADT_MAX - 1)
+/* IP specific attributes */
+enum {
+        IPSET_ATTR_IPADDR_IPV4 = IPSET_ATTR_UNSPEC + 1,
+        IPSET_ATTR_IPADDR_IPV6,
+        __IPSET_ATTR_IPADDR_MAX,
+};
+#define IPSET_ATTR_IPADDR_MAX   (__IPSET_ATTR_IPADDR_MAX - 1)
+/* Error codes */
+enum ipset_errno {
+        IPSET_ERR_PRIVATE = 4096,
+        IPSET_ERR_PROTOCOL,
+        IPSET_ERR_FIND_TYPE,
+        IPSET_ERR_MAX_SETS,
+        IPSET_ERR_BUSY,
+        IPSET_ERR_EXIST_SETNAME2,
+        IPSET_ERR_TYPE_MISMATCH,
+        IPSET_ERR_EXIST,
+        IPSET_ERR_INVALID_CIDR,
+        IPSET_ERR_INVALID_NETMASK,
+        IPSET_ERR_INVALID_FAMILY,
+        IPSET_ERR_TIMEOUT,
+        IPSET_ERR_REFERENCED,
+        IPSET_ERR_IPADDR_IPV4,
+        IPSET_ERR_IPADDR_IPV6,
+        /* Type specific error codes */
+        IPSET_ERR_TYPE_SPECIFIC = 4352,
+};
+/* Flags at command level */
+enum ipset_cmd_flags {
+        IPSET_FLAG_BIT_EXIST    = 0,
+        IPSET_FLAG_EXIST        = (1 << IPSET_FLAG_BIT_EXIST),
+};
+/* Flags at CADT attribute level */
+enum ipset_cadt_flags {
+        IPSET_FLAG_BIT_BEFORE   = 0,
+        IPSET_FLAG_BEFORE       = (1 << IPSET_FLAG_BIT_BEFORE),
+};
+/* Commands with settype-specific attributes */
+enum ipset_adt {
+        IPSET_ADD,
+        IPSET_DEL,
+        IPSET_TEST,
+        IPSET_ADT_MAX,
+        IPSET_CREATE = IPSET_ADT_MAX,
+        IPSET_CADT_MAX,
+};
+#ifdef __KERNEL__
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/netlink.h>
+#include <linux/netfilter.h>
+#include <linux/vmalloc.h>
+#include <net/netlink.h>
+/* Sets are identified by an index in kernel space. Tweak with ip_set_id_t
+ * and IPSET_INVALID_ID if you want to increase the max number of sets.
+ */
+typedef u16 ip_set_id_t;
+#define IPSET_INVALID_ID                65535
+enum ip_set_dim {
+        IPSET_DIM_ZERO = 0,
+        IPSET_DIM_ONE,
+        IPSET_DIM_TWO,
+        IPSET_DIM_THREE,
+        /* Max dimension in elements.
+         * If changed, new revision of iptables match/target is required.
+         */
+        IPSET_DIM_MAX = 6,
+};
+/* Option flags for kernel operations */
+enum ip_set_kopt {
+        IPSET_INV_MATCH = (1 << IPSET_DIM_ZERO),
+        IPSET_DIM_ONE_SRC = (1 << IPSET_DIM_ONE),
+        IPSET_DIM_TWO_SRC = (1 << IPSET_DIM_TWO),
+        IPSET_DIM_THREE_SRC = (1 << IPSET_DIM_THREE),
+};
+/* Set features */
+enum ip_set_feature {
+        IPSET_TYPE_IP_FLAG = 0,
+        IPSET_TYPE_IP = (1 << IPSET_TYPE_IP_FLAG),
+        IPSET_TYPE_PORT_FLAG = 1,
+        IPSET_TYPE_PORT = (1 << IPSET_TYPE_PORT_FLAG),
+        IPSET_TYPE_MAC_FLAG = 2,
+        IPSET_TYPE_MAC = (1 << IPSET_TYPE_MAC_FLAG),
+        IPSET_TYPE_IP2_FLAG = 3,
+        IPSET_TYPE_IP2 = (1 << IPSET_TYPE_IP2_FLAG),
+        IPSET_TYPE_NAME_FLAG = 4,
+        IPSET_TYPE_NAME = (1 << IPSET_TYPE_NAME_FLAG),
+        /* Strictly speaking not a feature, but a flag for dumping:
+         * this settype must be dumped last */
+        IPSET_DUMP_LAST_FLAG = 7,
+        IPSET_DUMP_LAST = (1 << IPSET_DUMP_LAST_FLAG),
+};
+struct ip_set;
+typedef int (*ipset_adtfn)(struct ip_set *set, void *value, u32 timeout);
+/* Set type, variant-specific part */
+struct ip_set_type_variant {
+        /* Kernelspace: test/add/del entries
+         *              returns negative error code,
+         *                      zero for no match/success to add/delete
+         *                      positive for matching element */
+        int (*kadt)(struct ip_set *set, const struct sk_buff * skb,
+                    enum ipset_adt adt, u8 pf, u8 dim, u8 flags);
+        /* Userspace: test/add/del entries
+         *              returns negative error code,
+         *                      zero for no match/success to add/delete
+         *                      positive for matching element */
+        int (*uadt)(struct ip_set *set, struct nlattr *tb[],
+                    enum ipset_adt adt, u32 *lineno, u32 flags);
+        /* Low level add/del/test functions */
+        ipset_adtfn adt[IPSET_ADT_MAX];
+        /* When adding entries and set is full, try to resize the set */
+        int (*resize)(struct ip_set *set, bool retried);
+        /* Destroy the set */
+        void (*destroy)(struct ip_set *set);
+        /* Flush the elements */
+        void (*flush)(struct ip_set *set);
+        /* Expire entries before listing */
+        void (*expire)(struct ip_set *set);
+        /* List set header data */
+        int (*head)(struct ip_set *set, struct sk_buff *skb);
+        /* List elements */
+        int (*list)(const struct ip_set *set, struct sk_buff *skb,
+                    struct netlink_callback *cb);
+        /* Return true if "b" set is the same as "a"
+         * according to the create set parameters */
+        bool (*same_set)(const struct ip_set *a, const struct ip_set *b);
+};
+/* The core set type structure */
+struct ip_set_type {
+        struct list_head list;
+        /* Typename */
+        char name[IPSET_MAXNAMELEN];
+        /* Protocol version */
+        u8 protocol;
+        /* Set features to control swapping */
+        u8 features;
+        /* Set type dimension */
+        u8 dimension;
+        /* Supported family: may be AF_UNSPEC for both AF_INET/AF_INET6 */
+        u8 family;
+        /* Type revision */
+        u8 revision;
+        /* Create set */
+        int (*create)(struct ip_set *set, struct nlattr *tb[], u32 flags);
+        /* Attribute policies */
+        const struct nla_policy create_policy[IPSET_ATTR_CREATE_MAX + 1];
+        const struct nla_policy adt_policy[IPSET_ATTR_ADT_MAX + 1];
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+/* register and unregister set type */
+extern int ip_set_type_register(struct ip_set_type *set_type);
+extern void ip_set_type_unregister(struct ip_set_type *set_type);
+/* A generic IP set */
+struct ip_set {
+        /* The name of the set */
+        char name[IPSET_MAXNAMELEN];
+        /* Lock protecting the set data */
+        rwlock_t lock;
+        /* References to the set */
+        atomic_t ref;
+        /* The core set type */
+        struct ip_set_type *type;
+        /* The type variant doing the real job */
+        const struct ip_set_type_variant *variant;
+        /* The actual INET family of the set */
+        u8 family;
+        /* The type specific data */
+        void *data;
+};
+/* register and unregister set references */
+extern ip_set_id_t ip_set_get_byname(const char *name, struct ip_set **set);
+extern void ip_set_put_byindex(ip_set_id_t index);
+extern const char * ip_set_name_byindex(ip_set_id_t index);
+extern ip_set_id_t ip_set_nfnl_get(const char *name);
+extern ip_set_id_t ip_set_nfnl_get_byindex(ip_set_id_t index);
+extern void ip_set_nfnl_put(ip_set_id_t index);
+/* API for iptables set match, and SET target */
+extern int ip_set_add(ip_set_id_t id, const struct sk_buff *skb,
+                      u8 family, u8 dim, u8 flags);
+extern int ip_set_del(ip_set_id_t id, const struct sk_buff *skb,
+                      u8 family, u8 dim, u8 flags);
+extern int ip_set_test(ip_set_id_t id, const struct sk_buff *skb,
+                       u8 family, u8 dim, u8 flags);
+/* Utility functions */
+extern void * ip_set_alloc(size_t size);
+extern void ip_set_free(void *members);
+extern int ip_set_get_ipaddr4(struct nlattr *nla,  __be32 *ipaddr);
+extern int ip_set_get_ipaddr6(struct nlattr *nla, union nf_inet_addr *ipaddr);
+static inline int
+ip_set_get_hostipaddr4(struct nlattr *nla, u32 *ipaddr)
+{
+        __be32 ip;
+        int ret = ip_set_get_ipaddr4(nla, &ip);
+        
+        if (ret)
+                return ret;
+        *ipaddr = ntohl(ip);
+        return 0;
+}
+/* Ignore IPSET_ERR_EXIST errors if asked to do so? */
+static inline bool
+ip_set_eexist(int ret, u32 flags)
+{
+        return ret == -IPSET_ERR_EXIST && (flags & IPSET_FLAG_EXIST);
+}
+/* Check the NLA_F_NET_BYTEORDER flag */
+static inline bool
+ip_set_attr_netorder(struct nlattr *tb[], int type)
+{
+        return tb[type] && (tb[type]->nla_type & NLA_F_NET_BYTEORDER);
+}
+static inline bool
+ip_set_optattr_netorder(struct nlattr *tb[], int type)
+{
+        return !tb[type] || (tb[type]->nla_type & NLA_F_NET_BYTEORDER);
+}
+/* Useful converters */
+static inline u32
+ip_set_get_h32(const struct nlattr *attr)
+{
+        return ntohl(nla_get_be32(attr));
+}
+static inline u16
+ip_set_get_h16(const struct nlattr *attr)
+{
+        return ntohs(nla_get_be16(attr));
+}
+#define ipset_nest_start(skb, attr) nla_nest_start(skb, attr | NLA_F_NESTED)
+#define ipset_nest_end(skb, start)  nla_nest_end(skb, start)
+#define NLA_PUT_IPADDR4(skb, type, ipaddr)                      \
+do {                                                            \
+        struct nlattr *__nested = ipset_nest_start(skb, type);  \
+                                                                \
+        if (!__nested)                                          \
+                goto nla_put_failure;                           \
+        NLA_PUT_NET32(skb, IPSET_ATTR_IPADDR_IPV4, ipaddr);     \
+        ipset_nest_end(skb, __nested);                          \
+} while (0)
+#define NLA_PUT_IPADDR6(skb, type, ipaddrptr)                   \
+do {                                                            \
+        struct nlattr *__nested = ipset_nest_start(skb, type);  \
+                                                                \
+        if (!__nested)                                          \
+                goto nla_put_failure;                           \
+        NLA_PUT(skb, IPSET_ATTR_IPADDR_IPV6,                    \
+                sizeof(struct in6_addr), ipaddrptr);            \
+        ipset_nest_end(skb, __nested);                          \
+} while (0)
+/* Get address from skbuff */
+static inline __be32
+ip4addr(const struct sk_buff *skb, bool src)
+{
+        return src ? ip_hdr(skb)->saddr : ip_hdr(skb)->daddr;
+}
+static inline void
+ip4addrptr(const struct sk_buff *skb, bool src, __be32 *addr)
+{
+        *addr = src ? ip_hdr(skb)->saddr : ip_hdr(skb)->daddr;
+}
+static inline void
+ip6addrptr(const struct sk_buff *skb, bool src, struct in6_addr *addr)
+{
+        memcpy(addr, src ? &ipv6_hdr(skb)->saddr : &ipv6_hdr(skb)->daddr,
+               sizeof(*addr));
+}
+/* Calculate the bytes required to store the inclusive range of a-b */
+static inline int
+bitmap_bytes(u32 a, u32 b)
+{
+        return 4 * ((((b - a + 8) / 8) + 3) / 4);
+}
+/* Interface to iptables/ip6tables */
+#define SO_IP_SET               83
+union ip_set_name_index {
+        char name[IPSET_MAXNAMELEN];
+        ip_set_id_t index;
+};
+#define IP_SET_OP_GET_BYNAME    0x00000006      /* Get set index by name */
+struct ip_set_req_get_set {
+        unsigned op;
+        unsigned version;
+        union ip_set_name_index set;
+};
+#define IP_SET_OP_GET_BYINDEX   0x00000007      /* Get set name by index */
+/* Uses ip_set_req_get_set */
+#define IP_SET_OP_VERSION       0x00000100      /* Ask kernel version */
+struct ip_set_req_version {
+        unsigned op;
+        unsigned version;
+};
+#endif  /* __KERNEL__ */
+#endif /*_IP_SET_H */
diff --git a/include/linux/netfilter/ipset/ip_set_ahash.h b/include/linux/netfilter/ipset/ip_set_ahash.h
new file mode 100644
index 000000000000..ec9d9bea1e37
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set_ahash.h
@@ -0,0 +1,1074 @@
+#ifndef _IP_SET_AHASH_H
+#define _IP_SET_AHASH_H
+#include <linux/rcupdate.h>
+#include <linux/jhash.h>
+#include <linux/netfilter/ipset/ip_set_timeout.h>
+/* Hashing which uses arrays to resolve clashing. The hash table is resized
+ * (doubled) when searching becomes too long.
+ * Internally jhash is used with the assumption that the size of the
+ * stored data is a multiple of sizeof(u32). If storage supports timeout,
+ * the timeout field must be the last one in the data structure - that field
+ * is ignored when computing the hash key.
+ *
+ * Readers and resizing
+ *
+ * Resizing can be triggered by userspace command only, and those
+ * are serialized by the nfnl mutex. During resizing the set is
+ * read-locked, so the only possible concurrent operations are
+ * the kernel side readers. Those must be protected by proper RCU locking.
+ */
+/* Number of elements to store in an initial array block */
+#define AHASH_INIT_SIZE                 4
+/* Max number of elements to store in an array block */
+#define AHASH_MAX_SIZE                  (3*4)
+/* A hash bucket */
+struct hbucket {
+        void *value;            /* the array of the values */
+        u8 size;                /* size of the array */
+        u8 pos;                 /* position of the first free entry */
+};
+/* The hash table: the table size stored here in order to make resizing easy */
+struct htable {
+        u8 htable_bits;         /* size of hash table == 2^htable_bits */
+        struct hbucket bucket[0]; /* hashtable buckets */
+};
+#define hbucket(h, i)           &((h)->bucket[i])
+/* Book-keeping of the prefixes added to the set */
+struct ip_set_hash_nets {
+        u8 cidr;                /* the different cidr values in the set */
+        u32 nets;               /* number of elements per cidr */
+};
+/* The generic ip_set hash structure */
+struct ip_set_hash {
+        struct htable *table;   /* the hash table */
+        u32 maxelem;            /* max elements in the hash */
+        u32 elements;           /* current element (vs timeout) */
+        u32 initval;            /* random jhash init value */
+        u32 timeout;            /* timeout value, if enabled */
+        struct timer_list gc;   /* garbage collection when timeout enabled */
+#ifdef IP_SET_HASH_WITH_NETMASK
+        u8 netmask;             /* netmask value for subnets to store */
+#endif
+#ifdef IP_SET_HASH_WITH_NETS
+        struct ip_set_hash_nets nets[0]; /* book-keeping of prefixes */
+#endif
+};
+/* Compute htable_bits from the user input parameter hashsize */
+static u8
+htable_bits(u32 hashsize)
+{
+        /* Assume that hashsize == 2^htable_bits */
+        u8 bits = fls(hashsize - 1);
+        if (jhash_size(bits) != hashsize)
+                /* Round up to the first 2^n value */
+                bits = fls(hashsize);
+        return bits;
+}
+#ifdef IP_SET_HASH_WITH_NETS
+#define SET_HOST_MASK(family)   (family == AF_INET ? 32 : 128)
+/* Network cidr size book keeping when the hash stores different
+ * sized networks */
+static void
+add_cidr(struct ip_set_hash *h, u8 cidr, u8 host_mask)
+{
+        u8 i;
+        ++h->nets[cidr-1].nets;
+        pr_debug("add_cidr added %u: %u\n", cidr, h->nets[cidr-1].nets);
+        if (h->nets[cidr-1].nets > 1)
+                return;
+        /* New cidr size */
+        for (i = 0; i < host_mask && h->nets[i].cidr; i++) {
+                /* Add in increasing prefix order, so larger cidr first */
+                if (h->nets[i].cidr < cidr)
+                        swap(h->nets[i].cidr, cidr);
+        }
+        if (i < host_mask)
+                h->nets[i].cidr = cidr;
+}
+static void
+del_cidr(struct ip_set_hash *h, u8 cidr, u8 host_mask)
+{
+        u8 i;
+        --h->nets[cidr-1].nets;
+        pr_debug("del_cidr deleted %u: %u\n", cidr, h->nets[cidr-1].nets);
+        if (h->nets[cidr-1].nets != 0)
+                return;
+        /* All entries with this cidr size deleted, so cleanup h->cidr[] */
+        for (i = 0; i < host_mask - 1 && h->nets[i].cidr; i++) {
+                if (h->nets[i].cidr == cidr)
+                        h->nets[i].cidr = cidr = h->nets[i+1].cidr;
+        }
+        h->nets[i - 1].cidr = 0;
+}
+#endif
+/* Destroy the hashtable part of the set */
+static void
+ahash_destroy(struct htable *t)
+{
+        struct hbucket *n;
+        u32 i;
+        for (i = 0; i < jhash_size(t->htable_bits); i++) {
+                n = hbucket(t, i);
+                if (n->size)
+                        /* FIXME: use slab cache */
+                        kfree(n->value);
+        }
+        ip_set_free(t);
+}
+/* Calculate the actual memory size of the set data */
+static size_t
+ahash_memsize(const struct ip_set_hash *h, size_t dsize, u8 host_mask)
+{
+        u32 i;
+        struct htable *t = h->table;
+        size_t memsize = sizeof(*h)
+                         + sizeof(*t)
+#ifdef IP_SET_HASH_WITH_NETS
+                         + sizeof(struct ip_set_hash_nets) * host_mask
+#endif
+                         + jhash_size(t->htable_bits) * sizeof(struct hbucket);
+        for (i = 0; i < jhash_size(t->htable_bits); i++)
+                        memsize += t->bucket[i].size * dsize;
+        return memsize;
+}
+/* Flush a hash type of set: destroy all elements */
+static void
+ip_set_hash_flush(struct ip_set *set)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        struct hbucket *n;
+        u32 i;
+        for (i = 0; i < jhash_size(t->htable_bits); i++) {
+                n = hbucket(t, i);
+                if (n->size) {
+                        n->size = n->pos = 0;
+                        /* FIXME: use slab cache */
+                        kfree(n->value);
+                }
+        }
+#ifdef IP_SET_HASH_WITH_NETS
+        memset(h->nets, 0, sizeof(struct ip_set_hash_nets)
+                           * SET_HOST_MASK(set->family));
+#endif
+        h->elements = 0;
+}
+/* Destroy a hash type of set */
+static void
+ip_set_hash_destroy(struct ip_set *set)
+{
+        struct ip_set_hash *h = set->data;
+        if (with_timeout(h->timeout))
+                del_timer_sync(&h->gc);
+        ahash_destroy(h->table);
+        kfree(h);
+        set->data = NULL;
+}
+#define HKEY(data, initval, htable_bits)                                 \
+(jhash2((u32 *)(data), sizeof(struct type_pf_elem)/sizeof(u32), initval) \
+        & jhash_mask(htable_bits))
+#endif /* _IP_SET_AHASH_H */
+#define CONCAT(a, b, c)         a##b##c
+#define TOKEN(a, b, c)          CONCAT(a, b, c)
+/* Type/family dependent function prototypes */
+#define type_pf_data_equal      TOKEN(TYPE, PF, _data_equal)
+#define type_pf_data_isnull     TOKEN(TYPE, PF, _data_isnull)
+#define type_pf_data_copy       TOKEN(TYPE, PF, _data_copy)
+#define type_pf_data_zero_out   TOKEN(TYPE, PF, _data_zero_out)
+#define type_pf_data_netmask    TOKEN(TYPE, PF, _data_netmask)
+#define type_pf_data_list       TOKEN(TYPE, PF, _data_list)
+#define type_pf_data_tlist      TOKEN(TYPE, PF, _data_tlist)
+#define type_pf_elem            TOKEN(TYPE, PF, _elem)
+#define type_pf_telem           TOKEN(TYPE, PF, _telem)
+#define type_pf_data_timeout    TOKEN(TYPE, PF, _data_timeout)
+#define type_pf_data_expired    TOKEN(TYPE, PF, _data_expired)
+#define type_pf_data_timeout_set TOKEN(TYPE, PF, _data_timeout_set)
+#define type_pf_elem_add        TOKEN(TYPE, PF, _elem_add)
+#define type_pf_add             TOKEN(TYPE, PF, _add)
+#define type_pf_del             TOKEN(TYPE, PF, _del)
+#define type_pf_test_cidrs      TOKEN(TYPE, PF, _test_cidrs)
+#define type_pf_test            TOKEN(TYPE, PF, _test)
+#define type_pf_elem_tadd       TOKEN(TYPE, PF, _elem_tadd)
+#define type_pf_del_telem       TOKEN(TYPE, PF, _ahash_del_telem)
+#define type_pf_expire          TOKEN(TYPE, PF, _expire)
+#define type_pf_tadd            TOKEN(TYPE, PF, _tadd)
+#define type_pf_tdel            TOKEN(TYPE, PF, _tdel)
+#define type_pf_ttest_cidrs     TOKEN(TYPE, PF, _ahash_ttest_cidrs)
+#define type_pf_ttest           TOKEN(TYPE, PF, _ahash_ttest)
+#define type_pf_resize          TOKEN(TYPE, PF, _resize)
+#define type_pf_tresize         TOKEN(TYPE, PF, _tresize)
+#define type_pf_flush           ip_set_hash_flush
+#define type_pf_destroy         ip_set_hash_destroy
+#define type_pf_head            TOKEN(TYPE, PF, _head)
+#define type_pf_list            TOKEN(TYPE, PF, _list)
+#define type_pf_tlist           TOKEN(TYPE, PF, _tlist)
+#define type_pf_same_set        TOKEN(TYPE, PF, _same_set)
+#define type_pf_kadt            TOKEN(TYPE, PF, _kadt)
+#define type_pf_uadt            TOKEN(TYPE, PF, _uadt)
+#define type_pf_gc              TOKEN(TYPE, PF, _gc)
+#define type_pf_gc_init         TOKEN(TYPE, PF, _gc_init)
+#define type_pf_variant         TOKEN(TYPE, PF, _variant)
+#define type_pf_tvariant        TOKEN(TYPE, PF, _tvariant)
+/* Flavour without timeout */
+/* Get the ith element from the array block n */
+#define ahash_data(n, i)        \
+        ((struct type_pf_elem *)((n)->value) + (i))
+/* Add an element to the hash table when resizing the set:
+ * we spare the maintenance of the internal counters. */
+static int
+type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value)
+{
+        if (n->pos >= n->size) {
+                void *tmp;
+                if (n->size >= AHASH_MAX_SIZE)
+                        /* Trigger rehashing */
+                        return -EAGAIN;
+                tmp = kzalloc((n->size + AHASH_INIT_SIZE)
+                              * sizeof(struct type_pf_elem),
+                              GFP_ATOMIC);
+                if (!tmp)
+                        return -ENOMEM;
+                if (n->size) {
+                        memcpy(tmp, n->value,
+                               sizeof(struct type_pf_elem) * n->size);
+                        kfree(n->value);
+                }
+                n->value = tmp;
+                n->size += AHASH_INIT_SIZE;
+        }
+        type_pf_data_copy(ahash_data(n, n->pos++), value);
+        return 0;
+}
+/* Resize a hash: create a new hash table with doubling the hashsize
+ * and inserting the elements to it. Repeat until we succeed or
+ * fail due to memory pressures. */
+static int
+type_pf_resize(struct ip_set *set, bool retried)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t, *orig = h->table;
+        u8 htable_bits = orig->htable_bits;
+        const struct type_pf_elem *data;
+        struct hbucket *n, *m;
+        u32 i, j;
+        int ret;
+retry:
+        ret = 0;
+        htable_bits++;
+        pr_debug("attempt to resize set %s from %u to %u, t %p\n",
+                 set->name, orig->htable_bits, htable_bits, orig);
+        if (!htable_bits)
+                /* In case we have plenty of memory :-) */
+                return -IPSET_ERR_HASH_FULL;
+        t = ip_set_alloc(sizeof(*t)
+                         + jhash_size(htable_bits) * sizeof(struct hbucket));
+        if (!t)
+                return -ENOMEM;
+        t->htable_bits = htable_bits;
+        read_lock_bh(&set->lock);
+        for (i = 0; i < jhash_size(orig->htable_bits); i++) {
+                n = hbucket(orig, i);
+                for (j = 0; j < n->pos; j++) {
+                        data = ahash_data(n, j);
+                        m = hbucket(t, HKEY(data, h->initval, htable_bits));
+                        ret = type_pf_elem_add(m, data);
+                        if (ret < 0) {
+                                read_unlock_bh(&set->lock);
+                                ahash_destroy(t);
+                                if (ret == -EAGAIN)
+                                        goto retry;
+                                return ret;
+                        }
+                }
+        }
+        rcu_assign_pointer(h->table, t);
+        read_unlock_bh(&set->lock);
+        /* Give time to other readers of the set */
+        synchronize_rcu_bh();
+        pr_debug("set %s resized from %u (%p) to %u (%p)\n", set->name,
+                 orig->htable_bits, orig, t->htable_bits, t);
+        ahash_destroy(orig);
+        return 0;
+}
+/* Add an element to a hash and update the internal counters when succeeded,
+ * otherwise report the proper error code. */
+static int
+type_pf_add(struct ip_set *set, void *value, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t;
+        const struct type_pf_elem *d = value;
+        struct hbucket *n;
+        int i, ret = 0;
+        u32 key;
+        if (h->elements >= h->maxelem)
+                return -IPSET_ERR_HASH_FULL;
+        rcu_read_lock_bh();
+        t = rcu_dereference_bh(h->table);
+        key = HKEY(value, h->initval, t->htable_bits);
+        n = hbucket(t, key);
+        for (i = 0; i < n->pos; i++)
+                if (type_pf_data_equal(ahash_data(n, i), d)) {
+                        ret = -IPSET_ERR_EXIST;
+                        goto out;
+                }
+        ret = type_pf_elem_add(n, value);
+        if (ret != 0)
+                goto out;
+#ifdef IP_SET_HASH_WITH_NETS
+        add_cidr(h, d->cidr, HOST_MASK);
+#endif
+        h->elements++;
+out:
+        rcu_read_unlock_bh();
+        return ret;
+}
+/* Delete an element from the hash: swap it with the last element
+ * and free up space if possible.
+ */
+static int
+type_pf_del(struct ip_set *set, void *value, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        const struct type_pf_elem *d = value;
+        struct hbucket *n;
+        int i;
+        struct type_pf_elem *data;
+        u32 key;
+        key = HKEY(value, h->initval, t->htable_bits);
+        n = hbucket(t, key);
+        for (i = 0; i < n->pos; i++) {
+                data = ahash_data(n, i);
+                if (!type_pf_data_equal(data, d))
+                        continue;
+                if (i != n->pos - 1)
+                        /* Not last one */
+                        type_pf_data_copy(data, ahash_data(n, n->pos - 1));
+                n->pos--;
+                h->elements--;
+#ifdef IP_SET_HASH_WITH_NETS
+                del_cidr(h, d->cidr, HOST_MASK);
+#endif
+                if (n->pos + AHASH_INIT_SIZE < n->size) {
+                        void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
+                                            * sizeof(struct type_pf_elem),
+                                            GFP_ATOMIC);
+                        if (!tmp)
+                                return 0;
+                        n->size -= AHASH_INIT_SIZE;
+                        memcpy(tmp, n->value,
+                               n->size * sizeof(struct type_pf_elem));
+                        kfree(n->value);
+                        n->value = tmp;
+                }
+                return 0;
+        }
+        return -IPSET_ERR_EXIST;
+}
+#ifdef IP_SET_HASH_WITH_NETS
+/* Special test function which takes into account the different network
+ * sizes added to the set */
+static int
+type_pf_test_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        struct hbucket *n;
+        const struct type_pf_elem *data;
+        int i, j = 0;
+        u32 key;
+        u8 host_mask = SET_HOST_MASK(set->family);
+        pr_debug("test by nets\n");
+        for (; j < host_mask && h->nets[j].cidr; j++) {
+                type_pf_data_netmask(d, h->nets[j].cidr);
+                key = HKEY(d, h->initval, t->htable_bits);
+                n = hbucket(t, key);
+                for (i = 0; i < n->pos; i++) {
+                        data = ahash_data(n, i);
+                        if (type_pf_data_equal(data, d))
+                                return 1;
+                }
+        }
+        return 0;
+}
+#endif
+/* Test whether the element is added to the set */
+static int
+type_pf_test(struct ip_set *set, void *value, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        struct type_pf_elem *d = value;
+        struct hbucket *n;
+        const struct type_pf_elem *data;
+        int i;
+        u32 key;
+#ifdef IP_SET_HASH_WITH_NETS
+        /* If we test an IP address and not a network address,
+         * try all possible network sizes */
+        if (d->cidr == SET_HOST_MASK(set->family))
+                return type_pf_test_cidrs(set, d, timeout);
+#endif
+        key = HKEY(d, h->initval, t->htable_bits);
+        n = hbucket(t, key);
+        for (i = 0; i < n->pos; i++) {
+                data = ahash_data(n, i);
+                if (type_pf_data_equal(data, d))
+                        return 1;
+        }
+        return 0;
+}
+/* Reply a HEADER request: fill out the header part of the set */
+static int
+type_pf_head(struct ip_set *set, struct sk_buff *skb)
+{
+        const struct ip_set_hash *h = set->data;
+        struct nlattr *nested;
+        size_t memsize;
+        read_lock_bh(&set->lock);
+        memsize = ahash_memsize(h, with_timeout(h->timeout)
+                                        ? sizeof(struct type_pf_telem)
+                                        : sizeof(struct type_pf_elem),
+                                set->family == AF_INET ? 32 : 128);
+        read_unlock_bh(&set->lock);
+        nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
+        if (!nested)
+                goto nla_put_failure;
+        NLA_PUT_NET32(skb, IPSET_ATTR_HASHSIZE,
+                      htonl(jhash_size(h->table->htable_bits)));
+        NLA_PUT_NET32(skb, IPSET_ATTR_MAXELEM, htonl(h->maxelem));
+#ifdef IP_SET_HASH_WITH_NETMASK
+        if (h->netmask != HOST_MASK)
+                NLA_PUT_U8(skb, IPSET_ATTR_NETMASK, h->netmask);
+#endif
+        NLA_PUT_NET32(skb, IPSET_ATTR_REFERENCES,
+                      htonl(atomic_read(&set->ref) - 1));
+        NLA_PUT_NET32(skb, IPSET_ATTR_MEMSIZE, htonl(memsize));
+        if (with_timeout(h->timeout))
+                NLA_PUT_NET32(skb, IPSET_ATTR_TIMEOUT, htonl(h->timeout));
+        ipset_nest_end(skb, nested);
+        return 0;
+nla_put_failure:
+        return -EMSGSIZE;
+}
+/* Reply a LIST/SAVE request: dump the elements of the specified set */
+static int
+type_pf_list(const struct ip_set *set,
+             struct sk_buff *skb, struct netlink_callback *cb)
+{
+        const struct ip_set_hash *h = set->data;
+        const struct htable *t = h->table;
+        struct nlattr *atd, *nested;
+        const struct hbucket *n;
+        const struct type_pf_elem *data;
+        u32 first = cb->args[2];
+        /* We assume that one hash bucket fills into one page */
+        void *incomplete;
+        int i;
+        atd = ipset_nest_start(skb, IPSET_ATTR_ADT);
+        if (!atd)
+                return -EMSGSIZE;
+        pr_debug("list hash set %s\n", set->name);
+        for (; cb->args[2] < jhash_size(t->htable_bits); cb->args[2]++) {
+                incomplete = skb_tail_pointer(skb);
+                n = hbucket(t, cb->args[2]);
+                pr_debug("cb->args[2]: %lu, t %p n %p\n", cb->args[2], t, n);
+                for (i = 0; i < n->pos; i++) {
+                        data = ahash_data(n, i);
+                        pr_debug("list hash %lu hbucket %p i %u, data %p\n",
+                                 cb->args[2], n, i, data);
+                        nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
+                        if (!nested) {
+                                if (cb->args[2] == first) {
+                                        nla_nest_cancel(skb, atd);
+                                        return -EMSGSIZE;
+                                } else
+                                        goto nla_put_failure;
+                        }
+                        if (type_pf_data_list(skb, data))
+                                goto nla_put_failure;
+                        ipset_nest_end(skb, nested);
+                }
+        }
+        ipset_nest_end(skb, atd);
+        /* Set listing finished */
+        cb->args[2] = 0;
+        return 0;
+nla_put_failure:
+        nlmsg_trim(skb, incomplete);
+        ipset_nest_end(skb, atd);
+        if (unlikely(first == cb->args[2])) {
+                pr_warning("Can't list set %s: one bucket does not fit into "
+                           "a message. Please report it!\n", set->name);
+                cb->args[2] = 0;
+                return -EMSGSIZE;
+        }
+        return 0;
+}
+static int
+type_pf_kadt(struct ip_set *set, const struct sk_buff * skb,
+             enum ipset_adt adt, u8 pf, u8 dim, u8 flags);
+static int
+type_pf_uadt(struct ip_set *set, struct nlattr *tb[],
+             enum ipset_adt adt, u32 *lineno, u32 flags);
+static const struct ip_set_type_variant type_pf_variant = {
+        .kadt   = type_pf_kadt,
+        .uadt   = type_pf_uadt,
+        .adt    = {
+                [IPSET_ADD] = type_pf_add,
+                [IPSET_DEL] = type_pf_del,
+                [IPSET_TEST] = type_pf_test,
+        },
+        .destroy = type_pf_destroy,
+        .flush  = type_pf_flush,
+        .head   = type_pf_head,
+        .list   = type_pf_list,
+        .resize = type_pf_resize,
+        .same_set = type_pf_same_set,
+};
+/* Flavour with timeout support */
+#define ahash_tdata(n, i) \
+        (struct type_pf_elem *)((struct type_pf_telem *)((n)->value) + (i))
+static inline u32
+type_pf_data_timeout(const struct type_pf_elem *data)
+{
+        const struct type_pf_telem *tdata =
+                (const struct type_pf_telem *) data;
+        return tdata->timeout;
+}
+static inline bool
+type_pf_data_expired(const struct type_pf_elem *data)
+{
+        const struct type_pf_telem *tdata =
+                (const struct type_pf_telem *) data;
+        return ip_set_timeout_expired(tdata->timeout);
+}
+static inline void
+type_pf_data_timeout_set(struct type_pf_elem *data, u32 timeout)
+{
+        struct type_pf_telem *tdata = (struct type_pf_telem *) data;
+        tdata->timeout = ip_set_timeout_set(timeout);
+}
+static int
+type_pf_elem_tadd(struct hbucket *n, const struct type_pf_elem *value,
+                  u32 timeout)
+{
+        struct type_pf_elem *data;
+        if (n->pos >= n->size) {
+                void *tmp;
+                if (n->size >= AHASH_MAX_SIZE)
+                        /* Trigger rehashing */
+                        return -EAGAIN;
+                tmp = kzalloc((n->size + AHASH_INIT_SIZE)
+                              * sizeof(struct type_pf_telem),
+                              GFP_ATOMIC);
+                if (!tmp)
+                        return -ENOMEM;
+                if (n->size) {
+                        memcpy(tmp, n->value,
+                               sizeof(struct type_pf_telem) * n->size);
+                        kfree(n->value);
+                }
+                n->value = tmp;
+                n->size += AHASH_INIT_SIZE;
+        }
+        data = ahash_tdata(n, n->pos++);
+        type_pf_data_copy(data, value);
+        type_pf_data_timeout_set(data, timeout);
+        return 0;
+}
+/* Delete expired elements from the hashtable */
+static void
+type_pf_expire(struct ip_set_hash *h)
+{
+        struct htable *t = h->table;
+        struct hbucket *n;
+        struct type_pf_elem *data;
+        u32 i;
+        int j;
+        for (i = 0; i < jhash_size(t->htable_bits); i++) {
+                n = hbucket(t, i);
+                for (j = 0; j < n->pos; j++) {
+                        data = ahash_tdata(n, j);
+                        if (type_pf_data_expired(data)) {
+                                pr_debug("expired %u/%u\n", i, j);
+#ifdef IP_SET_HASH_WITH_NETS
+                                del_cidr(h, data->cidr, HOST_MASK);
+#endif
+                                if (j != n->pos - 1)
+                                        /* Not last one */
+                                        type_pf_data_copy(data,
+                                                ahash_tdata(n, n->pos - 1));
+                                n->pos--;
+                                h->elements--;
+                        }
+                }
+                if (n->pos + AHASH_INIT_SIZE < n->size) {
+                        void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
+                                            * sizeof(struct type_pf_telem),
+                                            GFP_ATOMIC);
+                        if (!tmp)
+                                /* Still try to delete expired elements */
+                                continue;
+                        n->size -= AHASH_INIT_SIZE;
+                        memcpy(tmp, n->value,
+                               n->size * sizeof(struct type_pf_telem));
+                        kfree(n->value);
+                        n->value = tmp;
+                }
+        }
+}
+static int
+type_pf_tresize(struct ip_set *set, bool retried)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t, *orig = h->table;
+        u8 htable_bits = orig->htable_bits;
+        const struct type_pf_elem *data;
+        struct hbucket *n, *m;
+        u32 i, j;
+        int ret;
+        /* Try to cleanup once */
+        if (!retried) {
+                i = h->elements;
+                write_lock_bh(&set->lock);
+                type_pf_expire(set->data);
+                write_unlock_bh(&set->lock);
+                if (h->elements <  i)
+                        return 0;
+        }
+retry:
+        ret = 0;
+        htable_bits++;
+        if (!htable_bits)
+                /* In case we have plenty of memory :-) */
+                return -IPSET_ERR_HASH_FULL;
+        t = ip_set_alloc(sizeof(*t)
+                         + jhash_size(htable_bits) * sizeof(struct hbucket));
+        if (!t)
+                return -ENOMEM;
+        t->htable_bits = htable_bits;
+        read_lock_bh(&set->lock);
+        for (i = 0; i < jhash_size(orig->htable_bits); i++) {
+                n = hbucket(orig, i);
+                for (j = 0; j < n->pos; j++) {
+                        data = ahash_tdata(n, j);
+                        m = hbucket(t, HKEY(data, h->initval, htable_bits));
+                        ret = type_pf_elem_tadd(m, data,
+                                                type_pf_data_timeout(data));
+                        if (ret < 0) {
+                                read_unlock_bh(&set->lock);
+                                ahash_destroy(t);
+                                if (ret == -EAGAIN)
+                                        goto retry;
+                                return ret;
+                        }
+                }
+        }
+        rcu_assign_pointer(h->table, t);
+        read_unlock_bh(&set->lock);
+        /* Give time to other readers of the set */
+        synchronize_rcu_bh();
+        ahash_destroy(orig);
+        return 0;
+}
+static int
+type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        const struct type_pf_elem *d = value;
+        struct hbucket *n;
+        struct type_pf_elem *data;
+        int ret = 0, i, j = AHASH_MAX_SIZE + 1;
+        u32 key;
+        if (h->elements >= h->maxelem)
+                /* FIXME: when set is full, we slow down here */
+                type_pf_expire(h);
+        if (h->elements >= h->maxelem)
+                return -IPSET_ERR_HASH_FULL;
+        rcu_read_lock_bh();
+        t = rcu_dereference_bh(h->table);
+        key = HKEY(d, h->initval, t->htable_bits);
+        n = hbucket(t, key);
+        for (i = 0; i < n->pos; i++) {
+                data = ahash_tdata(n, i);
+                if (type_pf_data_equal(data, d)) {
+                        if (type_pf_data_expired(data))
+                                j = i;
+                        else {
+                                ret = -IPSET_ERR_EXIST;
+                                goto out;
+                        }
+                } else if (j == AHASH_MAX_SIZE + 1 &&
+                           type_pf_data_expired(data))
+                        j = i;
+        }
+        if (j != AHASH_MAX_SIZE + 1) {
+                data = ahash_tdata(n, j);
+#ifdef IP_SET_HASH_WITH_NETS
+                del_cidr(h, data->cidr, HOST_MASK);
+                add_cidr(h, d->cidr, HOST_MASK);
+#endif
+                type_pf_data_copy(data, d);
+                type_pf_data_timeout_set(data, timeout);
+                goto out;
+        }
+        ret = type_pf_elem_tadd(n, d, timeout);
+        if (ret != 0)
+                goto out;
+#ifdef IP_SET_HASH_WITH_NETS
+        add_cidr(h, d->cidr, HOST_MASK);
+#endif
+        h->elements++;
+out:
+        rcu_read_unlock_bh();
+        return ret;
+}
+static int
+type_pf_tdel(struct ip_set *set, void *value, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        const struct type_pf_elem *d = value;
+        struct hbucket *n;
+        int i, ret = 0;
+        struct type_pf_elem *data;
+        u32 key;
+        key = HKEY(value, h->initval, t->htable_bits);
+        n = hbucket(t, key);
+        for (i = 0; i < n->pos; i++) {
+                data = ahash_tdata(n, i);
+                if (!type_pf_data_equal(data, d))
+                        continue;
+                if (type_pf_data_expired(data))
+                        ret = -IPSET_ERR_EXIST;
+                if (i != n->pos - 1)
+                        /* Not last one */
+                        type_pf_data_copy(data, ahash_tdata(n, n->pos - 1));
+                n->pos--;
+                h->elements--;
+#ifdef IP_SET_HASH_WITH_NETS
+                del_cidr(h, d->cidr, HOST_MASK);
+#endif
+                if (n->pos + AHASH_INIT_SIZE < n->size) {
+                        void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
+                                            * sizeof(struct type_pf_telem),
+                                            GFP_ATOMIC);
+                        if (!tmp)
+                                return 0;
+                        n->size -= AHASH_INIT_SIZE;
+                        memcpy(tmp, n->value,
+                               n->size * sizeof(struct type_pf_telem));
+                        kfree(n->value);
+                        n->value = tmp;
+                }
+                return 0;
+        }
+        return -IPSET_ERR_EXIST;
+}
+#ifdef IP_SET_HASH_WITH_NETS
+static int
+type_pf_ttest_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        struct type_pf_elem *data;
+        struct hbucket *n;
+        int i, j = 0;
+        u32 key;
+        u8 host_mask = SET_HOST_MASK(set->family);
+        for (; j < host_mask && h->nets[j].cidr; j++) {
+                type_pf_data_netmask(d, h->nets[j].cidr);
+                key = HKEY(d, h->initval, t->htable_bits);
+                n = hbucket(t, key);
+                for (i = 0; i < n->pos; i++) {
+                        data = ahash_tdata(n, i);
+                        if (type_pf_data_equal(data, d))
+                                return !type_pf_data_expired(data);
+                }
+        }
+        return 0;
+}
+#endif
+static int
+type_pf_ttest(struct ip_set *set, void *value, u32 timeout)
+{
+        struct ip_set_hash *h = set->data;
+        struct htable *t = h->table;
+        struct type_pf_elem *data, *d = value;
+        struct hbucket *n;
+        int i;
+        u32 key;
+#ifdef IP_SET_HASH_WITH_NETS
+        if (d->cidr == SET_HOST_MASK(set->family))
+                return type_pf_ttest_cidrs(set, d, timeout);
+#endif
+        key = HKEY(d, h->initval, t->htable_bits);
+        n = hbucket(t, key);
+        for (i = 0; i < n->pos; i++) {
+                data = ahash_tdata(n, i);
+                if (type_pf_data_equal(data, d))
+                        return !type_pf_data_expired(data);
+        }
+        return 0;
+}
+static int
+type_pf_tlist(const struct ip_set *set,
+              struct sk_buff *skb, struct netlink_callback *cb)
+{
+        const struct ip_set_hash *h = set->data;
+        const struct htable *t = h->table;
+        struct nlattr *atd, *nested;
+        const struct hbucket *n;
+        const struct type_pf_elem *data;
+        u32 first = cb->args[2];
+        /* We assume that one hash bucket fills into one page */
+        void *incomplete;
+        int i;
+        atd = ipset_nest_start(skb, IPSET_ATTR_ADT);
+        if (!atd)
+                return -EMSGSIZE;
+        for (; cb->args[2] < jhash_size(t->htable_bits); cb->args[2]++) {
+                incomplete = skb_tail_pointer(skb);
+                n = hbucket(t, cb->args[2]);
+                for (i = 0; i < n->pos; i++) {
+                        data = ahash_tdata(n, i);
+                        pr_debug("list %p %u\n", n, i);
+                        if (type_pf_data_expired(data))
+                                continue;
+                        pr_debug("do list %p %u\n", n, i);
+                        nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
+                        if (!nested) {
+                                if (cb->args[2] == first) {
+                                        nla_nest_cancel(skb, atd);
+                                        return -EMSGSIZE;
+                                } else
+                                        goto nla_put_failure;
+                        }
+                        if (type_pf_data_tlist(skb, data))
+                                goto nla_put_failure;
+                        ipset_nest_end(skb, nested);
+                }
+        }
+        ipset_nest_end(skb, atd);
+        /* Set listing finished */
+        cb->args[2] = 0;
+        return 0;
+nla_put_failure:
+        nlmsg_trim(skb, incomplete);
+        ipset_nest_end(skb, atd);
+        if (unlikely(first == cb->args[2])) {
+                pr_warning("Can't list set %s: one bucket does not fit into "
+                           "a message. Please report it!\n", set->name);
+                cb->args[2] = 0;
+                return -EMSGSIZE;
+        }
+        return 0;
+}
+static const struct ip_set_type_variant type_pf_tvariant = {
+        .kadt   = type_pf_kadt,
+        .uadt   = type_pf_uadt,
+        .adt    = {
+                [IPSET_ADD] = type_pf_tadd,
+                [IPSET_DEL] = type_pf_tdel,
+                [IPSET_TEST] = type_pf_ttest,
+        },
+        .destroy = type_pf_destroy,
+        .flush  = type_pf_flush,
+        .head   = type_pf_head,
+        .list   = type_pf_tlist,
+        .resize = type_pf_tresize,
+        .same_set = type_pf_same_set,
+};
+static void
+type_pf_gc(unsigned long ul_set)
+{
+        struct ip_set *set = (struct ip_set *) ul_set;
+        struct ip_set_hash *h = set->data;
+        pr_debug("called\n");
+        write_lock_bh(&set->lock);
+        type_pf_expire(h);
+        write_unlock_bh(&set->lock);
+        h->gc.expires = jiffies + IPSET_GC_PERIOD(h->timeout) * HZ;
+        add_timer(&h->gc);
+}
+static void
+type_pf_gc_init(struct ip_set *set)
+{
+        struct ip_set_hash *h = set->data;
+        init_timer(&h->gc);
+        h->gc.data = (unsigned long) set;
+        h->gc.function = type_pf_gc;
+        h->gc.expires = jiffies + IPSET_GC_PERIOD(h->timeout) * HZ;
+        add_timer(&h->gc);
+        pr_debug("gc initialized, run in every %u\n",
+                 IPSET_GC_PERIOD(h->timeout));
+}
+#undef type_pf_data_equal
+#undef type_pf_data_isnull
+#undef type_pf_data_copy
+#undef type_pf_data_zero_out
+#undef type_pf_data_list
+#undef type_pf_data_tlist
+#undef type_pf_elem
+#undef type_pf_telem
+#undef type_pf_data_timeout
+#undef type_pf_data_expired
+#undef type_pf_data_netmask
+#undef type_pf_data_timeout_set
+#undef type_pf_elem_add
+#undef type_pf_add
+#undef type_pf_del
+#undef type_pf_test_cidrs
+#undef type_pf_test
+#undef type_pf_elem_tadd
+#undef type_pf_expire
+#undef type_pf_tadd
+#undef type_pf_tdel
+#undef type_pf_ttest_cidrs
+#undef type_pf_ttest
+#undef type_pf_resize
+#undef type_pf_tresize
+#undef type_pf_flush
+#undef type_pf_destroy
+#undef type_pf_head
+#undef type_pf_list
+#undef type_pf_tlist
+#undef type_pf_same_set
+#undef type_pf_kadt
+#undef type_pf_uadt
+#undef type_pf_gc
+#undef type_pf_gc_init
+#undef type_pf_variant
+#undef type_pf_tvariant
diff --git a/include/linux/netfilter/ipset/ip_set_bitmap.h b/include/linux/netfilter/ipset/ip_set_bitmap.h
new file mode 100644
index 000000000000..61a9e8746c83
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set_bitmap.h
@@ -0,0 +1,31 @@
+#ifndef __IP_SET_BITMAP_H
+#define __IP_SET_BITMAP_H
+/* Bitmap type specific error codes */
+enum {
+        /* The element is out of the range of the set */
+        IPSET_ERR_BITMAP_RANGE = IPSET_ERR_TYPE_SPECIFIC,
+        /* The range exceeds the size limit of the set type */
+        IPSET_ERR_BITMAP_RANGE_SIZE,
+};
+#ifdef __KERNEL__
+#define IPSET_BITMAP_MAX_RANGE  0x0000FFFF
+/* Common functions */
+static inline u32
+range_to_mask(u32 from, u32 to, u8 *bits)
+{
+        u32 mask = 0xFFFFFFFE;
+        *bits = 32;
+        while (--(*bits) > 0 && mask && (to & mask) != from)
+                mask <<= 1;
+        return mask;
+}
+#endif /* __KERNEL__ */
+#endif /* __IP_SET_BITMAP_H */
diff --git a/include/linux/netfilter/ipset/ip_set_getport.h b/include/linux/netfilter/ipset/ip_set_getport.h
new file mode 100644
index 000000000000..3882a81a3b3c
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set_getport.h
@@ -0,0 +1,21 @@
+#ifndef _IP_SET_GETPORT_H
+#define _IP_SET_GETPORT_H
+extern bool ip_set_get_ip4_port(const struct sk_buff *skb, bool src,
+                                __be16 *port, u8 *proto);
+#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
+extern bool ip_set_get_ip6_port(const struct sk_buff *skb, bool src,
+                                __be16 *port, u8 *proto);
+#else
+static inline bool ip_set_get_ip6_port(const struct sk_buff *skb, bool src,
+                                       __be16 *port, u8 *proto)
+{
+        return false;
+}
+#endif
+extern bool ip_set_get_ip_port(const struct sk_buff *skb, u8 pf, bool src,
+                                __be16 *port);
+#endif /*_IP_SET_GETPORT_H*/
diff --git a/include/linux/netfilter/ipset/ip_set_hash.h b/include/linux/netfilter/ipset/ip_set_hash.h
new file mode 100644
index 000000000000..b86f15c04524
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set_hash.h
@@ -0,0 +1,26 @@
+#ifndef __IP_SET_HASH_H
+#define __IP_SET_HASH_H
+/* Hash type specific error codes */
+enum {
+        /* Hash is full */
+        IPSET_ERR_HASH_FULL = IPSET_ERR_TYPE_SPECIFIC,
+        /* Null-valued element */
+        IPSET_ERR_HASH_ELEM,
+        /* Invalid protocol */
+        IPSET_ERR_INVALID_PROTO,
+        /* Protocol missing but must be specified */
+        IPSET_ERR_MISSING_PROTO,
+};
+#ifdef __KERNEL__
+#define IPSET_DEFAULT_HASHSIZE          1024
+#define IPSET_MIMINAL_HASHSIZE          64
+#define IPSET_DEFAULT_MAXELEM           65536
+#define IPSET_DEFAULT_PROBES            4
+#define IPSET_DEFAULT_RESIZE            100
+#endif /* __KERNEL__ */
+#endif /* __IP_SET_HASH_H */
diff --git a/include/linux/netfilter/ipset/ip_set_list.h b/include/linux/netfilter/ipset/ip_set_list.h
new file mode 100644
index 000000000000..40a63f302613
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set_list.h
@@ -0,0 +1,27 @@
+#ifndef __IP_SET_LIST_H
+#define __IP_SET_LIST_H
+/* List type specific error codes */
+enum {
+        /* Set name to be added/deleted/tested does not exist. */
+        IPSET_ERR_NAME = IPSET_ERR_TYPE_SPECIFIC,
+        /* list:set type is not permitted to add */
+        IPSET_ERR_LOOP,
+        /* Missing reference set */
+        IPSET_ERR_BEFORE,
+        /* Reference set does not exist */
+        IPSET_ERR_NAMEREF,
+        /* Set is full */
+        IPSET_ERR_LIST_FULL,
+        /* Reference set is not added to the set */
+        IPSET_ERR_REF_EXIST,
+};
+#ifdef __KERNEL__
+#define IP_SET_LIST_DEFAULT_SIZE        8
+#define IP_SET_LIST_MIN_SIZE            4
+#endif /* __KERNEL__ */
+#endif /* __IP_SET_LIST_H */
diff --git a/include/linux/netfilter/ipset/ip_set_timeout.h b/include/linux/netfilter/ipset/ip_set_timeout.h
new file mode 100644
index 000000000000..9f30c5f2ec1c
--- /dev/null
+++ b/include/linux/netfilter/ipset/ip_set_timeout.h
@@ -0,0 +1,127 @@
+#ifndef _IP_SET_TIMEOUT_H
+#define _IP_SET_TIMEOUT_H
+/* Copyright (C) 2003-2011 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifdef __KERNEL__
+/* How often should the gc be run by default */
+#define IPSET_GC_TIME                   (3 * 60)
+/* Timeout period depending on the timeout value of the given set */
+#define IPSET_GC_PERIOD(timeout) \
+        ((timeout/3) ? min_t(u32, (timeout)/3, IPSET_GC_TIME) : 1)
+/* Set is defined without timeout support: timeout value may be 0 */
+#define IPSET_NO_TIMEOUT        UINT_MAX
+#define with_timeout(timeout)   ((timeout) != IPSET_NO_TIMEOUT)
+static inline unsigned int
+ip_set_timeout_uget(struct nlattr *tb)
+{
+        unsigned int timeout = ip_set_get_h32(tb);
+        /* Userspace supplied TIMEOUT parameter: adjust crazy size */
+        return timeout == IPSET_NO_TIMEOUT ? IPSET_NO_TIMEOUT - 1 : timeout;
+}
+#ifdef IP_SET_BITMAP_TIMEOUT
+/* Bitmap specific timeout constants and macros for the entries */
+/* Bitmap entry is unset */
+#define IPSET_ELEM_UNSET        0
+/* Bitmap entry is set with no timeout value */
+#define IPSET_ELEM_PERMANENT    (UINT_MAX/2)
+static inline bool
+ip_set_timeout_test(unsigned long timeout)
+{
+        return timeout != IPSET_ELEM_UNSET &&
+               (timeout == IPSET_ELEM_PERMANENT ||
+                time_after(timeout, jiffies));
+}
+static inline bool
+ip_set_timeout_expired(unsigned long timeout)
+{
+        return timeout != IPSET_ELEM_UNSET &&
+               timeout != IPSET_ELEM_PERMANENT &&
+               time_before(timeout, jiffies);
+}
+static inline unsigned long
+ip_set_timeout_set(u32 timeout)
+{
+        unsigned long t;
+        if (!timeout)
+                return IPSET_ELEM_PERMANENT;
+        t = timeout * HZ + jiffies;
+        if (t == IPSET_ELEM_UNSET || t == IPSET_ELEM_PERMANENT)
+                /* Bingo! */
+                t++;
+        return t;
+}
+static inline u32
+ip_set_timeout_get(unsigned long timeout)
+{
+        return timeout == IPSET_ELEM_PERMANENT ? 0 : (timeout - jiffies)/HZ;
+}
+#else
+/* Hash specific timeout constants and macros for the entries */
+/* Hash entry is set with no timeout value */
+#define IPSET_ELEM_PERMANENT    0
+static inline bool
+ip_set_timeout_test(unsigned long timeout)
+{
+        return timeout == IPSET_ELEM_PERMANENT ||
+               time_after(timeout, jiffies);
+}
+static inline bool
+ip_set_timeout_expired(unsigned long timeout)
+{
+        return timeout != IPSET_ELEM_PERMANENT &&
+               time_before(timeout, jiffies);
+}
+static inline unsigned long
+ip_set_timeout_set(u32 timeout)
+{
+        unsigned long t;
+        if (!timeout)
+                return IPSET_ELEM_PERMANENT;
+        t = timeout * HZ + jiffies;
+        if (t == IPSET_ELEM_PERMANENT)
+                /* Bingo! :-) */
+                t++;
+        return t;
+}
+static inline u32
+ip_set_timeout_get(unsigned long timeout)
+{
+        return timeout == IPSET_ELEM_PERMANENT ? 0 : (timeout - jiffies)/HZ;
+}
+#endif /* ! IP_SET_BITMAP_TIMEOUT */
+#endif  /* __KERNEL__ */
+#endif /* _IP_SET_TIMEOUT_H */
diff --git a/include/linux/netfilter/ipset/pfxlen.h b/include/linux/netfilter/ipset/pfxlen.h
new file mode 100644
index 000000000000..0e1fb50da562
--- /dev/null
+++ b/include/linux/netfilter/ipset/pfxlen.h
@@ -0,0 +1,35 @@
+#ifndef _PFXLEN_H
+#define _PFXLEN_H
+#include <asm/byteorder.h>
+#include <linux/netfilter.h> 
+/* Prefixlen maps, by Jan Engelhardt  */
+extern const union nf_inet_addr ip_set_netmask_map[];
+extern const union nf_inet_addr ip_set_hostmask_map[];
+static inline __be32
+ip_set_netmask(u8 pfxlen)
+{
+        return ip_set_netmask_map[pfxlen].ip;
+}
+static inline const __be32 *
+ip_set_netmask6(u8 pfxlen)
+{
+        return &ip_set_netmask_map[pfxlen].ip6[0];
+}
+static inline u32
+ip_set_hostmask(u8 pfxlen)
+{
+        return (__force u32) ip_set_hostmask_map[pfxlen].ip;
+}
+static inline const __be32 *
+ip_set_hostmask6(u8 pfxlen)
+{
+        return &ip_set_hostmask_map[pfxlen].ip6[0];
+}
+#endif /*_PFXLEN_H */
diff --git a/include/linux/netfilter/nf_conntrack_snmp.h b/include/linux/netfilter/nf_conntrack_snmp.h
new file mode 100644
index 000000000000..064bc63a5346
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_snmp.h
@@ -0,0 +1,9 @@
+#ifndef _NF_CONNTRACK_SNMP_H
+#define _NF_CONNTRACK_SNMP_H
+extern int (*nf_nat_snmp_hook)(struct sk_buff *skb,
+                                unsigned int protoff,
+                                struct nf_conn *ct,
+                                enum ip_conntrack_info ctinfo);
+#endif /* _NF_CONNTRACK_SNMP_H */
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 361d6b5630ee..2b11fc1a86be 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -47,7 +47,8 @@ struct nfgenmsg {
 #define NFNL_SUBSYS_QUEUE               3
 #define NFNL_SUBSYS_ULOG                4
 #define NFNL_SUBSYS_OSF                 5
-#define NFNL_SUBSYS_COUNT               6
+#define NFNL_SUBSYS_IPSET               6
+#define NFNL_SUBSYS_COUNT               7
 #ifdef __KERNEL__
diff --git a/include/linux/netfilter/nfnetlink_conntrack.h b/include/linux/netfilter/nfnetlink_conntrack.h
index 19711e3ffd42..debf1aefd753 100644
--- a/include/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/linux/netfilter/nfnetlink_conntrack.h
@@ -42,6 +42,7 @@ enum ctattr_type {
        CTA_SECMARK,            /* obsolete */
        CTA_ZONE,
        CTA_SECCTX,
+        CTA_TIMESTAMP,
        __CTA_MAX
 };
 #define CTA_MAX (__CTA_MAX - 1)
@@ -127,6 +128,14 @@ enum ctattr_counters {
 };
 #define CTA_COUNTERS_MAX (__CTA_COUNTERS_MAX - 1)
+enum ctattr_tstamp {
+        CTA_TIMESTAMP_UNSPEC,
+        CTA_TIMESTAMP_START,
+        CTA_TIMESTAMP_STOP,
+        __CTA_TIMESTAMP_MAX
+};
+#define CTA_TIMESTAMP_MAX (__CTA_TIMESTAMP_MAX - 1)
 enum ctattr_nat {
        CTA_NAT_UNSPEC,
        CTA_NAT_MINIP,
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 6712e713b299..37219525ff6f 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -611,8 +611,9 @@ struct _compat_xt_align {
 extern void xt_compat_lock(u_int8_t af);
 extern void xt_compat_unlock(u_int8_t af);
-extern int xt_compat_add_offset(u_int8_t af, unsigned int offset, short delta);
+extern int xt_compat_add_offset(u_int8_t af, unsigned int offset, int delta);
 extern void xt_compat_flush_offsets(u_int8_t af);
+extern void xt_compat_init_offsets(u_int8_t af, unsigned int number);
 extern int xt_compat_calc_jump(u_int8_t af, unsigned int offset);
 extern int xt_compat_match_offset(const struct xt_match *match);
diff --git a/include/linux/netfilter/xt_AUDIT.h b/include/linux/netfilter/xt_AUDIT.h
new file mode 100644
index 000000000000..38751d2ea52b
--- /dev/null
+++ b/include/linux/netfilter/xt_AUDIT.h
@@ -0,0 +1,30 @@
+/*
+ * Header file for iptables xt_AUDIT target
+ *
+ * (C) 2010-2011 Thomas Graf <tgraf@redhat.com>
+ * (C) 2010-2011 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _XT_AUDIT_TARGET_H
+#define _XT_AUDIT_TARGET_H
+#include <linux/types.h>
+enum {
+        XT_AUDIT_TYPE_ACCEPT = 0,
+        XT_AUDIT_TYPE_DROP,
+        XT_AUDIT_TYPE_REJECT,
+        __XT_AUDIT_TYPE_MAX,
+};
+#define XT_AUDIT_TYPE_MAX (__XT_AUDIT_TYPE_MAX - 1)
+struct xt_audit_info {
+        __u8 type; /* XT_AUDIT_TYPE_* */
+};
+#endif /* _XT_AUDIT_TARGET_H */
diff --git a/include/linux/netfilter/xt_CT.h b/include/linux/netfilter/xt_CT.h
index 1b564106891d..b56e76811c04 100644
--- a/include/linux/netfilter/xt_CT.h
+++ b/include/linux/netfilter/xt_CT.h
@@ -1,14 +1,16 @@
 #ifndef _XT_CT_H
 #define _XT_CT_H
+#include <linux/types.h>
 #define XT_CT_NOTRACK   0x1
 struct xt_ct_target_info {
-        u_int16_t       flags;
+        __u16 flags;
-        u_int16_t       zone;
+        __u16 zone;
-        u_int32_t       ct_events;
+        __u32 ct_events;
-        u_int32_t       exp_events;
+        __u32 exp_events;
-        char            helper[16];
+        char helper[16];
        /* Used internally by the kernel */
        struct nf_conn  *ct __attribute__((aligned(8)));
diff --git a/include/linux/netfilter/xt_NFQUEUE.h b/include/linux/netfilter/xt_NFQUEUE.h
index 2584f4a777de..9eafdbbb401c 100644
--- a/include/linux/netfilter/xt_NFQUEUE.h
+++ b/include/linux/netfilter/xt_NFQUEUE.h
@@ -20,4 +20,10 @@ struct xt_NFQ_info_v1 {
        __u16 queues_total;
 };
+struct xt_NFQ_info_v2 {
+        __u16 queuenum;
+        __u16 queues_total;
+        __u16 bypass;
+};
 #endif /* _XT_NFQ_TARGET_H */
diff --git a/include/linux/netfilter/xt_TCPOPTSTRIP.h b/include/linux/netfilter/xt_TCPOPTSTRIP.h
index 2db543214ff5..7157318499c2 100644
--- a/include/linux/netfilter/xt_TCPOPTSTRIP.h
+++ b/include/linux/netfilter/xt_TCPOPTSTRIP.h
@@ -1,13 +1,15 @@
 #ifndef _XT_TCPOPTSTRIP_H
 #define _XT_TCPOPTSTRIP_H
+#include <linux/types.h>
 #define tcpoptstrip_set_bit(bmap, idx) \
        (bmap[(idx) >> 5] |= 1U << (idx & 31))
 #define tcpoptstrip_test_bit(bmap, idx) \
        (((1U << (idx & 31)) & bmap[(idx) >> 5]) != 0)
 struct xt_tcpoptstrip_target_info {
-        u_int32_t strip_bmap[8];
+        __u32 strip_bmap[8];
 };
 #endif /* _XT_TCPOPTSTRIP_H */
diff --git a/include/linux/netfilter/xt_TPROXY.h b/include/linux/netfilter/xt_TPROXY.h
index 3f3d69361289..902043c2073f 100644
--- a/include/linux/netfilter/xt_TPROXY.h
+++ b/include/linux/netfilter/xt_TPROXY.h
@@ -1,19 +1,21 @@
 #ifndef _XT_TPROXY_H
 #define _XT_TPROXY_H
+#include <linux/types.h>
 /* TPROXY target is capable of marking the packet to perform
 * redirection. We can get rid of that whenever we get support for
 * mutliple targets in the same rule. */
 struct xt_tproxy_target_info {
-        u_int32_t mark_mask;
+        __u32 mark_mask;
-        u_int32_t mark_value;
+        __u32 mark_value;
        __be32 laddr;
        __be16 lport;
 };
 struct xt_tproxy_target_info_v1 {
-        u_int32_t mark_mask;
+        __u32 mark_mask;
-        u_int32_t mark_value;
+        __u32 mark_value;
        union nf_inet_addr laddr;
        __be16 lport;
 };
diff --git a/include/linux/netfilter/xt_addrtype.h b/include/linux/netfilter/xt_addrtype.h
new file mode 100644
index 000000000000..b156baa9d55e
--- /dev/null
+++ b/include/linux/netfilter/xt_addrtype.h
@@ -0,0 +1,44 @@
+#ifndef _XT_ADDRTYPE_H
+#define _XT_ADDRTYPE_H
+#include <linux/types.h>
+enum {
+        XT_ADDRTYPE_INVERT_SOURCE       = 0x0001,
+        XT_ADDRTYPE_INVERT_DEST         = 0x0002,
+        XT_ADDRTYPE_LIMIT_IFACE_IN      = 0x0004,
+        XT_ADDRTYPE_LIMIT_IFACE_OUT     = 0x0008,
+};
+/* rtn_type enum values from rtnetlink.h, but shifted */
+enum {
+        XT_ADDRTYPE_UNSPEC = 1 << 0,
+        XT_ADDRTYPE_UNICAST = 1 << 1,   /* 1 << RTN_UNICAST */
+        XT_ADDRTYPE_LOCAL  = 1 << 2,    /* 1 << RTN_LOCAL, etc */
+        XT_ADDRTYPE_BROADCAST = 1 << 3,
+        XT_ADDRTYPE_ANYCAST = 1 << 4,
+        XT_ADDRTYPE_MULTICAST = 1 << 5,
+        XT_ADDRTYPE_BLACKHOLE = 1 << 6,
+        XT_ADDRTYPE_UNREACHABLE = 1 << 7,
+        XT_ADDRTYPE_PROHIBIT = 1 << 8,
+        XT_ADDRTYPE_THROW = 1 << 9,
+        XT_ADDRTYPE_NAT = 1 << 10,
+        XT_ADDRTYPE_XRESOLVE = 1 << 11,
+};
+struct xt_addrtype_info_v1 {
+        __u16   source;         /* source-type mask */
+        __u16   dest;           /* dest-type mask */
+        __u32   flags;
+};
+/* revision 0 */
+struct xt_addrtype_info {
+        __u16   source;         /* source-type mask */
+        __u16   dest;           /* dest-type mask */
+        __u32   invert_source;
+        __u32   invert_dest;
+};
+#endif
diff --git a/include/linux/netfilter/xt_cluster.h b/include/linux/netfilter/xt_cluster.h
index 886682656f09..9b883c8fbf54 100644
--- a/include/linux/netfilter/xt_cluster.h
+++ b/include/linux/netfilter/xt_cluster.h
@@ -1,15 +1,17 @@
 #ifndef _XT_CLUSTER_MATCH_H
 #define _XT_CLUSTER_MATCH_H
+#include <linux/types.h>
 enum xt_cluster_flags {
        XT_CLUSTER_F_INV        = (1 << 0)
 };
 struct xt_cluster_match_info {
-        u_int32_t               total_nodes;
+        __u32 total_nodes;
-        u_int32_t               node_mask;
+        __u32 node_mask;
-        u_int32_t               hash_seed;
+        __u32 hash_seed;
-        u_int32_t               flags;
+        __u32 flags;
 };
 #define XT_CLUSTER_NODES_MAX    32
diff --git a/include/linux/netfilter/xt_comment.h b/include/linux/netfilter/xt_comment.h
index eacfedc6b5d0..0ea5e79f5bd7 100644
--- a/include/linux/netfilter/xt_comment.h
+++ b/include/linux/netfilter/xt_comment.h
@@ -4,7 +4,7 @@
 #define XT_MAX_COMMENT_LEN 256
 struct xt_comment_info {
-        unsigned char comment[XT_MAX_COMMENT_LEN];
+        char comment[XT_MAX_COMMENT_LEN];
 };
 #endif /* XT_COMMENT_H */
diff --git a/include/linux/netfilter/xt_connlimit.h b/include/linux/netfilter/xt_connlimit.h
index 7e3284bcbd2b..0ca66e97acbc 100644
--- a/include/linux/netfilter/xt_connlimit.h
+++ b/include/linux/netfilter/xt_connlimit.h
@@ -1,8 +1,15 @@
 #ifndef _XT_CONNLIMIT_H
 #define _XT_CONNLIMIT_H
+#include <linux/types.h>
 struct xt_connlimit_data;
+enum {
+        XT_CONNLIMIT_INVERT = 1 << 0,
+        XT_CONNLIMIT_DADDR  = 1 << 1,
+};
 struct xt_connlimit_info {
        union {
                union nf_inet_addr mask;
@@ -13,7 +20,14 @@ struct xt_connlimit_info {
                };
 #endif
        };
-        unsigned int limit, inverse;
+        unsigned int limit;
+        union {
+                /* revision 0 */
+                unsigned int inverse;
+                /* revision 1 */
+                __u32 flags;
+        };
        /* Used internally by the kernel */
        struct xt_connlimit_data *data __attribute__((aligned(8)));
diff --git a/include/linux/netfilter/xt_conntrack.h b/include/linux/netfilter/xt_conntrack.h
index 54f47a2f6152..74b904d8f99c 100644
--- a/include/linux/netfilter/xt_conntrack.h
+++ b/include/linux/netfilter/xt_conntrack.h
@@ -58,4 +58,19 @@ struct xt_conntrack_mtinfo2 {
        __u16 state_mask, status_mask;
 };
+struct xt_conntrack_mtinfo3 {
+        union nf_inet_addr origsrc_addr, origsrc_mask;
+        union nf_inet_addr origdst_addr, origdst_mask;
+        union nf_inet_addr replsrc_addr, replsrc_mask;
+        union nf_inet_addr repldst_addr, repldst_mask;
+        __u32 expires_min, expires_max;
+        __u16 l4proto;
+        __u16 origsrc_port, origdst_port;
+        __u16 replsrc_port, repldst_port;
+        __u16 match_flags, invert_flags;
+        __u16 state_mask, status_mask;
+        __u16 origsrc_port_high, origdst_port_high;
+        __u16 replsrc_port_high, repldst_port_high;
+};
 #endif /*_XT_CONNTRACK_H*/
diff --git a/include/linux/netfilter/xt_devgroup.h b/include/linux/netfilter/xt_devgroup.h
new file mode 100644
index 000000000000..1babde0ec900
--- /dev/null
+++ b/include/linux/netfilter/xt_devgroup.h
@@ -0,0 +1,21 @@
+#ifndef _XT_DEVGROUP_H
+#define _XT_DEVGROUP_H
+#include <linux/types.h>
+enum xt_devgroup_flags {
+        XT_DEVGROUP_MATCH_SRC   = 0x1,
+        XT_DEVGROUP_INVERT_SRC  = 0x2,
+        XT_DEVGROUP_MATCH_DST   = 0x4,
+        XT_DEVGROUP_INVERT_DST  = 0x8,
+};
+struct xt_devgroup_info {
+        __u32   flags;
+        __u32   src_group;
+        __u32   src_mask;
+        __u32   dst_group;
+        __u32   dst_mask;
+};
+#endif /* _XT_DEVGROUP_H */
diff --git a/include/linux/netfilter/xt_quota.h b/include/linux/netfilter/xt_quota.h
index b0d28c659ab7..ca6e03e47a17 100644
--- a/include/linux/netfilter/xt_quota.h
+++ b/include/linux/netfilter/xt_quota.h
@@ -1,6 +1,8 @@
 #ifndef _XT_QUOTA_H
 #define _XT_QUOTA_H
+#include <linux/types.h>
 enum xt_quota_flags {
        XT_QUOTA_INVERT         = 0x1,
 };
@@ -9,9 +11,9 @@ enum xt_quota_flags {
 struct xt_quota_priv;
 struct xt_quota_info {
-        u_int32_t               flags;
+        __u32 flags;
-        u_int32_t               pad;
+        __u32 pad;
-        aligned_u64             quota;
+        aligned_u64 quota;
        /* Used internally by the kernel */
        struct xt_quota_priv    *master;
diff --git a/include/linux/netfilter/xt_set.h b/include/linux/netfilter/xt_set.h
new file mode 100644
index 000000000000..081f1ded2842
--- /dev/null
+++ b/include/linux/netfilter/xt_set.h
@@ -0,0 +1,56 @@
+#ifndef _XT_SET_H
+#define _XT_SET_H
+#include <linux/types.h>
+#include <linux/netfilter/ipset/ip_set.h>
+/* Revision 0 interface: backward compatible with netfilter/iptables */
+/*
+ * Option flags for kernel operations (xt_set_info_v0)
+ */
+#define IPSET_SRC               0x01    /* Source match/add */
+#define IPSET_DST               0x02    /* Destination match/add */
+#define IPSET_MATCH_INV         0x04    /* Inverse matching */
+struct xt_set_info_v0 {
+        ip_set_id_t index;
+        union {
+                __u32 flags[IPSET_DIM_MAX + 1];
+                struct {
+                        __u32 __flags[IPSET_DIM_MAX];
+                        __u8 dim;
+                        __u8 flags;
+                } compat;
+        } u;
+};
+/* match and target infos */
+struct xt_set_info_match_v0 {
+        struct xt_set_info_v0 match_set;
+};
+struct xt_set_info_target_v0 {
+        struct xt_set_info_v0 add_set;
+        struct xt_set_info_v0 del_set;
+};
+/* Revision 1: current interface to netfilter/iptables */
+struct xt_set_info {
+        ip_set_id_t index;
+        __u8 dim;
+        __u8 flags;
+};
+/* match and target infos */
+struct xt_set_info_match {
+        struct xt_set_info match_set;
+};
+struct xt_set_info_target {
+        struct xt_set_info add_set;
+        struct xt_set_info del_set;
+};
+#endif /*_XT_SET_H*/
diff --git a/include/linux/netfilter/xt_socket.h b/include/linux/netfilter/xt_socket.h
index 6f475b8ff34b..26d7217bd4f1 100644
--- a/include/linux/netfilter/xt_socket.h
+++ b/include/linux/netfilter/xt_socket.h
@@ -1,6 +1,8 @@
 #ifndef _XT_SOCKET_H
 #define _XT_SOCKET_H
+#include <linux/types.h>
 enum {
        XT_SOCKET_TRANSPARENT = 1 << 0,
 };
diff --git a/include/linux/netfilter/xt_time.h b/include/linux/netfilter/xt_time.h
index 14b6df412c9f..7c37fac576c4 100644
--- a/include/linux/netfilter/xt_time.h
+++ b/include/linux/netfilter/xt_time.h
@@ -1,14 +1,16 @@
 #ifndef _XT_TIME_H
 #define _XT_TIME_H 1
+#include <linux/types.h>
 struct xt_time_info {
-        u_int32_t date_start;
+        __u32 date_start;
-        u_int32_t date_stop;
+        __u32 date_stop;
-        u_int32_t daytime_start;
+        __u32 daytime_start;
-        u_int32_t daytime_stop;
+        __u32 daytime_stop;
-        u_int32_t monthdays_match;
+        __u32 monthdays_match;
-        u_int8_t weekdays_match;
+        __u8 weekdays_match;
-        u_int8_t flags;
+        __u8 flags;
 };
 enum {
diff --git a/include/linux/netfilter/xt_u32.h b/include/linux/netfilter/xt_u32.h
index 9947f56cdbdd..04d1bfea03c2 100644
--- a/include/linux/netfilter/xt_u32.h
+++ b/include/linux/netfilter/xt_u32.h
@@ -1,6 +1,8 @@
 #ifndef _XT_U32_H
 #define _XT_U32_H 1
+#include <linux/types.h>
 enum xt_u32_ops {
        XT_U32_AND,
        XT_U32_LEFTSH,
@@ -9,13 +11,13 @@ enum xt_u32_ops {
 };
 struct xt_u32_location_element {
-        u_int32_t number;
+        __u32 number;
-        u_int8_t nextop;
+        __u8 nextop;
 };
 struct xt_u32_value_element {
-        u_int32_t min;
+        __u32 min;
-        u_int32_t max;
+        __u32 max;
 };
 /*
@@ -27,14 +29,14 @@ struct xt_u32_value_element {
 struct xt_u32_test {
        struct xt_u32_location_element location[XT_U32_MAXSIZE+1];
        struct xt_u32_value_element value[XT_U32_MAXSIZE+1];
-        u_int8_t nnums;
+        __u8 nnums;
-        u_int8_t nvalues;
+        __u8 nvalues;
 };
 struct xt_u32 {
        struct xt_u32_test tests[XT_U32_MAXSIZE+1];
-        u_int8_t ntests;
+        __u8 ntests;
-        u_int8_t invert;
+        __u8 invert;
 };
 #endif /* _XT_U32_H */
diff --git a/include/linux/netfilter_bridge/ebt_802_3.h b/include/linux/netfilter_bridge/ebt_802_3.h
index c73ef0b18bdc..be5be1577a56 100644
--- a/include/linux/netfilter_bridge/ebt_802_3.h
+++ b/include/linux/netfilter_bridge/ebt_802_3.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_802_3_H
 #define __LINUX_BRIDGE_EBT_802_3_H
+#include <linux/types.h>
 #define EBT_802_3_SAP 0x01
 #define EBT_802_3_TYPE 0x02
@@ -24,24 +26,24 @@
 /* ui has one byte ctrl, ni has two */
 struct hdr_ui {
-        uint8_t dsap;
+        __u8 dsap;
-        uint8_t ssap;
+        __u8 ssap;
-        uint8_t ctrl;
+        __u8 ctrl;
-        uint8_t orig[3];
+        __u8 orig[3];
        __be16 type;
 };
 struct hdr_ni {
-        uint8_t dsap;
+        __u8 dsap;
-        uint8_t ssap;
+        __u8 ssap;
        __be16 ctrl;
-        uint8_t  orig[3];
+        __u8  orig[3];
        __be16 type;
 };
 struct ebt_802_3_hdr {
-        uint8_t  daddr[6];
+        __u8  daddr[6];
-        uint8_t  saddr[6];
+        __u8  saddr[6];
        __be16 len;
        union {
                struct hdr_ui ui;
@@ -59,10 +61,10 @@ static inline struct ebt_802_3_hdr *ebt_802_3_hdr(const struct sk_buff *skb)
 #endif
 struct ebt_802_3_info {
-        uint8_t  sap;
+        __u8  sap;
        __be16 type;
-        uint8_t  bitmask;
+        __u8  bitmask;
-        uint8_t  invflags;
+        __u8  invflags;
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_among.h b/include/linux/netfilter_bridge/ebt_among.h
index 0009558609a7..bd4e3ad0b706 100644
--- a/include/linux/netfilter_bridge/ebt_among.h
+++ b/include/linux/netfilter_bridge/ebt_among.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_AMONG_H
 #define __LINUX_BRIDGE_EBT_AMONG_H
+#include <linux/types.h>
 #define EBT_AMONG_DST 0x01
 #define EBT_AMONG_SRC 0x02
@@ -30,7 +32,7 @@
 */
 struct ebt_mac_wormhash_tuple {
-        uint32_t cmp[2];
+        __u32 cmp[2];
        __be32 ip;
 };
diff --git a/include/linux/netfilter_bridge/ebt_arp.h b/include/linux/netfilter_bridge/ebt_arp.h
index cbf4843b6b0f..522f3e427f49 100644
--- a/include/linux/netfilter_bridge/ebt_arp.h
+++ b/include/linux/netfilter_bridge/ebt_arp.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_ARP_H
 #define __LINUX_BRIDGE_EBT_ARP_H
+#include <linux/types.h>
 #define EBT_ARP_OPCODE 0x01
 #define EBT_ARP_HTYPE 0x02
 #define EBT_ARP_PTYPE 0x04
@@ -27,8 +29,8 @@ struct ebt_arp_info
        unsigned char smmsk[ETH_ALEN];
        unsigned char dmaddr[ETH_ALEN];
        unsigned char dmmsk[ETH_ALEN];
-        uint8_t  bitmask;
+        __u8  bitmask;
-        uint8_t  invflags;
+        __u8  invflags;
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_ip.h b/include/linux/netfilter_bridge/ebt_ip.h
index 6a708fb92241..c4bbc41b0ea4 100644
--- a/include/linux/netfilter_bridge/ebt_ip.h
+++ b/include/linux/netfilter_bridge/ebt_ip.h
@@ -15,6 +15,8 @@
 #ifndef __LINUX_BRIDGE_EBT_IP_H
 #define __LINUX_BRIDGE_EBT_IP_H
+#include <linux/types.h>
 #define EBT_IP_SOURCE 0x01
 #define EBT_IP_DEST 0x02
 #define EBT_IP_TOS 0x04
@@ -31,12 +33,12 @@ struct ebt_ip_info {
        __be32 daddr;
        __be32 smsk;
        __be32 dmsk;
-        uint8_t  tos;
+        __u8  tos;
-        uint8_t  protocol;
+        __u8  protocol;
-        uint8_t  bitmask;
+        __u8  bitmask;
-        uint8_t  invflags;
+        __u8  invflags;
-        uint16_t sport[2];
+        __u16 sport[2];
-        uint16_t dport[2];
+        __u16 dport[2];
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_ip6.h b/include/linux/netfilter_bridge/ebt_ip6.h
index e5de98701519..42b889682721 100644
--- a/include/linux/netfilter_bridge/ebt_ip6.h
+++ b/include/linux/netfilter_bridge/ebt_ip6.h
@@ -12,14 +12,19 @@
 #ifndef __LINUX_BRIDGE_EBT_IP6_H
 #define __LINUX_BRIDGE_EBT_IP6_H
+#include <linux/types.h>
 #define EBT_IP6_SOURCE 0x01
 #define EBT_IP6_DEST 0x02
 #define EBT_IP6_TCLASS 0x04
 #define EBT_IP6_PROTO 0x08
 #define EBT_IP6_SPORT 0x10
 #define EBT_IP6_DPORT 0x20
+#define EBT_IP6_ICMP6 0x40
 #define EBT_IP6_MASK (EBT_IP6_SOURCE | EBT_IP6_DEST | EBT_IP6_TCLASS |\
-                      EBT_IP6_PROTO | EBT_IP6_SPORT | EBT_IP6_DPORT)
+                      EBT_IP6_PROTO | EBT_IP6_SPORT | EBT_IP6_DPORT | \
+                      EBT_IP6_ICMP6)
 #define EBT_IP6_MATCH "ip6"
 /* the same values are used for the invflags */
@@ -28,12 +33,18 @@ struct ebt_ip6_info {
        struct in6_addr daddr;
        struct in6_addr smsk;
        struct in6_addr dmsk;
-        uint8_t  tclass;
+        __u8  tclass;
-        uint8_t  protocol;
+        __u8  protocol;
-        uint8_t  bitmask;
+        __u8  bitmask;
-        uint8_t  invflags;
+        __u8  invflags;
-        uint16_t sport[2];
+        union {
-        uint16_t dport[2];
+                __u16 sport[2];
+                __u8 icmpv6_type[2];
+        };
+        union {
+                __u16 dport[2];
+                __u8 icmpv6_code[2];
+        };
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_limit.h b/include/linux/netfilter_bridge/ebt_limit.h
index 4bf76b751676..66d80b30ba0e 100644
--- a/include/linux/netfilter_bridge/ebt_limit.h
+++ b/include/linux/netfilter_bridge/ebt_limit.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_LIMIT_H
 #define __LINUX_BRIDGE_EBT_LIMIT_H
+#include <linux/types.h>
 #define EBT_LIMIT_MATCH "limit"
 /* timings are in milliseconds. */
@@ -10,13 +12,13 @@
   seconds, or one every 59 hours. */
 struct ebt_limit_info {
-        u_int32_t avg;    /* Average secs between packets * scale */
+        __u32 avg;    /* Average secs between packets * scale */
-        u_int32_t burst;  /* Period multiplier for upper limit. */
+        __u32 burst;  /* Period multiplier for upper limit. */
        /* Used internally by the kernel */
        unsigned long prev;
-        u_int32_t credit;
+        __u32 credit;
-        u_int32_t credit_cap, cost;
+        __u32 credit_cap, cost;
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_log.h b/include/linux/netfilter_bridge/ebt_log.h
index cc2cdfb764bc..7e7f1d1fe494 100644
--- a/include/linux/netfilter_bridge/ebt_log.h
+++ b/include/linux/netfilter_bridge/ebt_log.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_LOG_H
 #define __LINUX_BRIDGE_EBT_LOG_H
+#include <linux/types.h>
 #define EBT_LOG_IP 0x01 /* if the frame is made by ip, log the ip information */
 #define EBT_LOG_ARP 0x02
 #define EBT_LOG_NFLOG 0x04
@@ -10,9 +12,9 @@
 #define EBT_LOG_WATCHER "log"
 struct ebt_log_info {
-        uint8_t loglevel;
+        __u8 loglevel;
-        uint8_t prefix[EBT_LOG_PREFIX_SIZE];
+        __u8 prefix[EBT_LOG_PREFIX_SIZE];
-        uint32_t bitmask;
+        __u32 bitmask;
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_mark_m.h b/include/linux/netfilter_bridge/ebt_mark_m.h
index 9ceb10ec0ed6..410f9e5a71d4 100644
--- a/include/linux/netfilter_bridge/ebt_mark_m.h
+++ b/include/linux/netfilter_bridge/ebt_mark_m.h
@@ -1,13 +1,15 @@
 #ifndef __LINUX_BRIDGE_EBT_MARK_M_H
 #define __LINUX_BRIDGE_EBT_MARK_M_H
+#include <linux/types.h>
 #define EBT_MARK_AND 0x01
 #define EBT_MARK_OR 0x02
 #define EBT_MARK_MASK (EBT_MARK_AND | EBT_MARK_OR)
 struct ebt_mark_m_info {
        unsigned long mark, mask;
-        uint8_t invert;
+        __u8 invert;
-        uint8_t bitmask;
+        __u8 bitmask;
 };
 #define EBT_MARK_MATCH "mark_m"
diff --git a/include/linux/netfilter_bridge/ebt_nflog.h b/include/linux/netfilter_bridge/ebt_nflog.h
index 052817849b83..df829fce9125 100644
--- a/include/linux/netfilter_bridge/ebt_nflog.h
+++ b/include/linux/netfilter_bridge/ebt_nflog.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_NFLOG_H
 #define __LINUX_BRIDGE_EBT_NFLOG_H
+#include <linux/types.h>
 #define EBT_NFLOG_MASK 0x0
 #define EBT_NFLOG_PREFIX_SIZE 64
@@ -10,11 +12,11 @@
 #define EBT_NFLOG_DEFAULT_THRESHOLD     1
 struct ebt_nflog_info {
-        u_int32_t len;
+        __u32 len;
-        u_int16_t group;
+        __u16 group;
-        u_int16_t threshold;
+        __u16 threshold;
-        u_int16_t flags;
+        __u16 flags;
-        u_int16_t pad;
+        __u16 pad;
        char prefix[EBT_NFLOG_PREFIX_SIZE];
 };
diff --git a/include/linux/netfilter_bridge/ebt_pkttype.h b/include/linux/netfilter_bridge/ebt_pkttype.h
index 51a799840931..c241badcd036 100644
--- a/include/linux/netfilter_bridge/ebt_pkttype.h
+++ b/include/linux/netfilter_bridge/ebt_pkttype.h
@@ -1,9 +1,11 @@
 #ifndef __LINUX_BRIDGE_EBT_PKTTYPE_H
 #define __LINUX_BRIDGE_EBT_PKTTYPE_H
+#include <linux/types.h>
 struct ebt_pkttype_info {
-        uint8_t pkt_type;
+        __u8 pkt_type;
-        uint8_t invert;
+        __u8 invert;
 };
 #define EBT_PKTTYPE_MATCH "pkttype"
diff --git a/include/linux/netfilter_bridge/ebt_stp.h b/include/linux/netfilter_bridge/ebt_stp.h
index e503a0aa2728..1025b9f5fb7d 100644
--- a/include/linux/netfilter_bridge/ebt_stp.h
+++ b/include/linux/netfilter_bridge/ebt_stp.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_STP_H
 #define __LINUX_BRIDGE_EBT_STP_H
+#include <linux/types.h>
 #define EBT_STP_TYPE            0x0001
 #define EBT_STP_FLAGS           0x0002
@@ -21,24 +23,24 @@
 #define EBT_STP_MATCH "stp"
 struct ebt_stp_config_info {
-        uint8_t flags;
+        __u8 flags;
-        uint16_t root_priol, root_priou;
+        __u16 root_priol, root_priou;
        char root_addr[6], root_addrmsk[6];
-        uint32_t root_costl, root_costu;
+        __u32 root_costl, root_costu;
-        uint16_t sender_priol, sender_priou;
+        __u16 sender_priol, sender_priou;
        char sender_addr[6], sender_addrmsk[6];
-        uint16_t portl, portu;
+        __u16 portl, portu;
-        uint16_t msg_agel, msg_ageu;
+        __u16 msg_agel, msg_ageu;
-        uint16_t max_agel, max_ageu;
+        __u16 max_agel, max_ageu;
-        uint16_t hello_timel, hello_timeu;
+        __u16 hello_timel, hello_timeu;
-        uint16_t forward_delayl, forward_delayu;
+        __u16 forward_delayl, forward_delayu;
 };
 struct ebt_stp_info {
-        uint8_t type;
+        __u8 type;
        struct ebt_stp_config_info config;
-        uint16_t bitmask;
+        __u16 bitmask;
-        uint16_t invflags;
+        __u16 invflags;
 };
 #endif
diff --git a/include/linux/netfilter_bridge/ebt_ulog.h b/include/linux/netfilter_bridge/ebt_ulog.h
index b677e2671541..89a6becb5269 100644
--- a/include/linux/netfilter_bridge/ebt_ulog.h
+++ b/include/linux/netfilter_bridge/ebt_ulog.h
@@ -1,6 +1,8 @@
 #ifndef _EBT_ULOG_H
 #define _EBT_ULOG_H
+#include <linux/types.h>
 #define EBT_ULOG_DEFAULT_NLGROUP 0
 #define EBT_ULOG_DEFAULT_QTHRESHOLD 1
 #define EBT_ULOG_MAXNLGROUPS 32 /* hardcoded netlink max */
@@ -10,7 +12,7 @@
 #define EBT_ULOG_VERSION 1
 struct ebt_ulog_info {
-        uint32_t nlgroup;
+        __u32 nlgroup;
        unsigned int cprange;
        unsigned int qthreshold;
        char prefix[EBT_ULOG_PREFIX_LEN];
diff --git a/include/linux/netfilter_bridge/ebt_vlan.h b/include/linux/netfilter_bridge/ebt_vlan.h
index 1d98be4031e7..967d1d5cf98d 100644
--- a/include/linux/netfilter_bridge/ebt_vlan.h
+++ b/include/linux/netfilter_bridge/ebt_vlan.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_BRIDGE_EBT_VLAN_H
 #define __LINUX_BRIDGE_EBT_VLAN_H
+#include <linux/types.h>
 #define EBT_VLAN_ID     0x01
 #define EBT_VLAN_PRIO   0x02
 #define EBT_VLAN_ENCAP  0x04
@@ -8,12 +10,12 @@
 #define EBT_VLAN_MATCH "vlan"
 struct ebt_vlan_info {
-        uint16_t id;            /* VLAN ID {1-4095} */
+        __u16 id;               /* VLAN ID {1-4095} */
-        uint8_t prio;           /* VLAN User Priority {0-7} */
+        __u8 prio;              /* VLAN User Priority {0-7} */
        __be16 encap;           /* VLAN Encapsulated frame code {0-65535} */
-        uint8_t bitmask;                /* Args bitmask bit 1=1 - ID arg,
+        __u8 bitmask;           /* Args bitmask bit 1=1 - ID arg,
                                   bit 2=1 User-Priority arg, bit 3=1 encap*/
-        uint8_t invflags;               /* Inverse bitmask  bit 1=1 - inversed ID arg, 
+        __u8 invflags;          /* Inverse bitmask  bit 1=1 - inversed ID arg, 
                                   bit 2=1 - inversed Pirority arg */
 };
diff --git a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
index e5a3687c8a72..c6a204c97047 100644
--- a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
+++ b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
@@ -1,6 +1,8 @@
 #ifndef _IPT_CLUSTERIP_H_target
 #define _IPT_CLUSTERIP_H_target
+#include <linux/types.h>
 enum clusterip_hashmode {
    CLUSTERIP_HASHMODE_SIP = 0,
    CLUSTERIP_HASHMODE_SIP_SPT,
@@ -17,15 +19,15 @@ struct clusterip_config;
 struct ipt_clusterip_tgt_info {
-        u_int32_t flags;
+        __u32 flags;
        /* only relevant for new ones */
-        u_int8_t clustermac[6];
+        __u8 clustermac[6];
-        u_int16_t num_total_nodes;
+        __u16 num_total_nodes;
-        u_int16_t num_local_nodes;
+        __u16 num_local_nodes;
-        u_int16_t local_nodes[CLUSTERIP_MAX_NODES];
+        __u16 local_nodes[CLUSTERIP_MAX_NODES];
-        u_int32_t hash_mode;
+        __u32 hash_mode;
-        u_int32_t hash_initval;
+        __u32 hash_initval;
        /* Used internally by the kernel */
        struct clusterip_config *config;
diff --git a/include/linux/netfilter_ipv4/ipt_ECN.h b/include/linux/netfilter_ipv4/ipt_ECN.h
index 7ca45918ab8e..bb88d5315a4d 100644
--- a/include/linux/netfilter_ipv4/ipt_ECN.h
+++ b/include/linux/netfilter_ipv4/ipt_ECN.h
@@ -8,6 +8,8 @@
 */
 #ifndef _IPT_ECN_TARGET_H
 #define _IPT_ECN_TARGET_H
+#include <linux/types.h>
 #include <linux/netfilter/xt_DSCP.h>
 #define IPT_ECN_IP_MASK (~XT_DSCP_MASK)
@@ -19,11 +21,11 @@
 #define IPT_ECN_OP_MASK         0xce
 struct ipt_ECN_info {
-        u_int8_t operation;     /* bitset of operations */
+        __u8 operation; /* bitset of operations */
-        u_int8_t ip_ect;        /* ECT codepoint of IPv4 header, pre-shifted */
+        __u8 ip_ect;    /* ECT codepoint of IPv4 header, pre-shifted */
        union {
                struct {
-                        u_int8_t ece:1, cwr:1; /* TCP ECT bits */
+                        __u8 ece:1, cwr:1; /* TCP ECT bits */
                } tcp;
        } proto;
 };
diff --git a/include/linux/netfilter_ipv4/ipt_SAME.h b/include/linux/netfilter_ipv4/ipt_SAME.h
index 2529660c5b38..5bca78267afd 100644
--- a/include/linux/netfilter_ipv4/ipt_SAME.h
+++ b/include/linux/netfilter_ipv4/ipt_SAME.h
@@ -1,15 +1,17 @@
 #ifndef _IPT_SAME_H
 #define _IPT_SAME_H
+#include <linux/types.h>
 #define IPT_SAME_MAX_RANGE      10
 #define IPT_SAME_NODST          0x01
 struct ipt_same_info {
        unsigned char info;
-        u_int32_t rangesize;
+        __u32 rangesize;
-        u_int32_t ipnum;
+        __u32 ipnum;
-        u_int32_t *iparray;
+        __u32 *iparray;
        /* hangs off end. */
        struct nf_nat_range range[IPT_SAME_MAX_RANGE];
diff --git a/include/linux/netfilter_ipv4/ipt_TTL.h b/include/linux/netfilter_ipv4/ipt_TTL.h
index ee6611edc112..f6ac169d92f9 100644
--- a/include/linux/netfilter_ipv4/ipt_TTL.h
+++ b/include/linux/netfilter_ipv4/ipt_TTL.h
@@ -4,6 +4,8 @@
 #ifndef _IPT_TTL_H
 #define _IPT_TTL_H
+#include <linux/types.h>
 enum {
        IPT_TTL_SET = 0,
        IPT_TTL_INC,
@@ -13,8 +15,8 @@ enum {
 #define IPT_TTL_MAXMODE IPT_TTL_DEC
 struct ipt_TTL_info {
-        u_int8_t        mode;
+        __u8    mode;
-        u_int8_t        ttl;
+        __u8    ttl;
 };
diff --git a/include/linux/netfilter_ipv4/ipt_addrtype.h b/include/linux/netfilter_ipv4/ipt_addrtype.h
index 446de6aef983..0da42237c8da 100644
--- a/include/linux/netfilter_ipv4/ipt_addrtype.h
+++ b/include/linux/netfilter_ipv4/ipt_addrtype.h
@@ -1,6 +1,8 @@
 #ifndef _IPT_ADDRTYPE_H
 #define _IPT_ADDRTYPE_H
+#include <linux/types.h>
 enum {
        IPT_ADDRTYPE_INVERT_SOURCE      = 0x0001,
        IPT_ADDRTYPE_INVERT_DEST        = 0x0002,
@@ -9,17 +11,17 @@ enum {
 };
 struct ipt_addrtype_info_v1 {
-        u_int16_t       source;         /* source-type mask */
+        __u16   source;         /* source-type mask */
-        u_int16_t       dest;           /* dest-type mask */
+        __u16   dest;           /* dest-type mask */
-        u_int32_t       flags;
+        __u32   flags;
 };
 /* revision 0 */
 struct ipt_addrtype_info {
-        u_int16_t       source;         /* source-type mask */
+        __u16   source;         /* source-type mask */
-        u_int16_t       dest;           /* dest-type mask */
+        __u16   dest;           /* dest-type mask */
-        u_int32_t       invert_source;
+        __u32   invert_source;
-        u_int32_t       invert_dest;
+        __u32   invert_dest;
 };
 #endif
diff --git a/include/linux/netfilter_ipv4/ipt_ah.h b/include/linux/netfilter_ipv4/ipt_ah.h
index 2e555b4d05e3..4e02bb0119e3 100644
--- a/include/linux/netfilter_ipv4/ipt_ah.h
+++ b/include/linux/netfilter_ipv4/ipt_ah.h
@@ -1,9 +1,11 @@
 #ifndef _IPT_AH_H
 #define _IPT_AH_H
+#include <linux/types.h>
 struct ipt_ah {
-        u_int32_t spis[2];                      /* Security Parameter Index */
+        __u32 spis[2];                  /* Security Parameter Index */
-        u_int8_t  invflags;                     /* Inverse flags */
+        __u8  invflags;                 /* Inverse flags */
 };
diff --git a/include/linux/netfilter_ipv4/ipt_ecn.h b/include/linux/netfilter_ipv4/ipt_ecn.h
index 9945baa4ccd7..eabf95fb7d3e 100644
--- a/include/linux/netfilter_ipv4/ipt_ecn.h
+++ b/include/linux/netfilter_ipv4/ipt_ecn.h
@@ -8,6 +8,8 @@
 */
 #ifndef _IPT_ECN_H
 #define _IPT_ECN_H
+#include <linux/types.h>
 #include <linux/netfilter/xt_dscp.h>
 #define IPT_ECN_IP_MASK (~XT_DSCP_MASK)
@@ -20,12 +22,12 @@
 /* match info */
 struct ipt_ecn_info {
-        u_int8_t operation;
+        __u8 operation;
-        u_int8_t invert;
+        __u8 invert;
-        u_int8_t ip_ect;
+        __u8 ip_ect;
        union {
                struct {
-                        u_int8_t ect;
+                        __u8 ect;
                } tcp;
        } proto;
 };
diff --git a/include/linux/netfilter_ipv4/ipt_ttl.h b/include/linux/netfilter_ipv4/ipt_ttl.h
index ee24fd86a3aa..37bee4442486 100644
--- a/include/linux/netfilter_ipv4/ipt_ttl.h
+++ b/include/linux/netfilter_ipv4/ipt_ttl.h
@@ -4,6 +4,8 @@
 #ifndef _IPT_TTL_H
 #define _IPT_TTL_H
+#include <linux/types.h>
 enum {
        IPT_TTL_EQ = 0,         /* equals */
        IPT_TTL_NE,             /* not equals */
@@ -13,8 +15,8 @@ enum {
 struct ipt_ttl_info {
-        u_int8_t        mode;
+        __u8    mode;
-        u_int8_t        ttl;
+        __u8    ttl;
 };
diff --git a/include/linux/netfilter_ipv6/ip6t_HL.h b/include/linux/netfilter_ipv6/ip6t_HL.h
index afb7813d45ab..ebd8ead1bb63 100644
--- a/include/linux/netfilter_ipv6/ip6t_HL.h
+++ b/include/linux/netfilter_ipv6/ip6t_HL.h
@@ -5,6 +5,8 @@
 #ifndef _IP6T_HL_H
 #define _IP6T_HL_H
+#include <linux/types.h>
 enum {
        IP6T_HL_SET = 0,
        IP6T_HL_INC,
@@ -14,8 +16,8 @@ enum {
 #define IP6T_HL_MAXMODE IP6T_HL_DEC
 struct ip6t_HL_info {
-        u_int8_t        mode;
+        __u8    mode;
-        u_int8_t        hop_limit;
+        __u8    hop_limit;
 };
diff --git a/include/linux/netfilter_ipv6/ip6t_REJECT.h b/include/linux/netfilter_ipv6/ip6t_REJECT.h
index 6be6504162bb..205ed62e4605 100644
--- a/include/linux/netfilter_ipv6/ip6t_REJECT.h
+++ b/include/linux/netfilter_ipv6/ip6t_REJECT.h
@@ -1,6 +1,8 @@
 #ifndef _IP6T_REJECT_H
 #define _IP6T_REJECT_H
+#include <linux/types.h>
 enum ip6t_reject_with {
        IP6T_ICMP6_NO_ROUTE,
        IP6T_ICMP6_ADM_PROHIBITED,
@@ -12,7 +14,7 @@ enum ip6t_reject_with {
 };
 struct ip6t_reject_info {
-        u_int32_t       with;   /* reject type */
+        __u32   with;   /* reject type */
 };
 #endif /*_IP6T_REJECT_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_ah.h b/include/linux/netfilter_ipv6/ip6t_ah.h
index 17a745cfb2c7..5da2b65cb3ad 100644
--- a/include/linux/netfilter_ipv6/ip6t_ah.h
+++ b/include/linux/netfilter_ipv6/ip6t_ah.h
@@ -1,11 +1,13 @@
 #ifndef _IP6T_AH_H
 #define _IP6T_AH_H
+#include <linux/types.h>
 struct ip6t_ah {
-        u_int32_t spis[2];                      /* Security Parameter Index */
+        __u32 spis[2];                  /* Security Parameter Index */
-        u_int32_t hdrlen;                       /* Header Length */
+        __u32 hdrlen;                   /* Header Length */
-        u_int8_t  hdrres;                       /* Test of the Reserved Filed */
+        __u8  hdrres;                   /* Test of the Reserved Filed */
-        u_int8_t  invflags;                     /* Inverse flags */
+        __u8  invflags;                 /* Inverse flags */
 };
 #define IP6T_AH_SPI 0x01
diff --git a/include/linux/netfilter_ipv6/ip6t_frag.h b/include/linux/netfilter_ipv6/ip6t_frag.h
index 3724d0850920..b47f61b9e082 100644
--- a/include/linux/netfilter_ipv6/ip6t_frag.h
+++ b/include/linux/netfilter_ipv6/ip6t_frag.h
@@ -1,11 +1,13 @@
 #ifndef _IP6T_FRAG_H
 #define _IP6T_FRAG_H
+#include <linux/types.h>
 struct ip6t_frag {
-        u_int32_t ids[2];                       /* Security Parameter Index */
+        __u32 ids[2];                   /* Security Parameter Index */
-        u_int32_t hdrlen;                       /* Header Length */
+        __u32 hdrlen;                   /* Header Length */
-        u_int8_t  flags;                        /*  */
+        __u8  flags;                    /*  */
-        u_int8_t  invflags;                     /* Inverse flags */
+        __u8  invflags;                 /* Inverse flags */
 };
 #define IP6T_FRAG_IDS           0x01
diff --git a/include/linux/netfilter_ipv6/ip6t_hl.h b/include/linux/netfilter_ipv6/ip6t_hl.h
index 5ef91b8319a8..6e76dbc6c19a 100644
--- a/include/linux/netfilter_ipv6/ip6t_hl.h
+++ b/include/linux/netfilter_ipv6/ip6t_hl.h
@@ -5,6 +5,8 @@
 #ifndef _IP6T_HL_H
 #define _IP6T_HL_H
+#include <linux/types.h>
 enum {
        IP6T_HL_EQ = 0,         /* equals */
        IP6T_HL_NE,             /* not equals */
@@ -14,8 +16,8 @@ enum {
 struct ip6t_hl_info {
-        u_int8_t        mode;
+        __u8    mode;
-        u_int8_t        hop_limit;
+        __u8    hop_limit;
 };
diff --git a/include/linux/netfilter_ipv6/ip6t_ipv6header.h b/include/linux/netfilter_ipv6/ip6t_ipv6header.h
index 01dfd445596a..efae3a20c214 100644
--- a/include/linux/netfilter_ipv6/ip6t_ipv6header.h
+++ b/include/linux/netfilter_ipv6/ip6t_ipv6header.h
@@ -8,10 +8,12 @@ on whether they contain certain headers */
 #ifndef __IPV6HEADER_H
 #define __IPV6HEADER_H
+#include <linux/types.h>
 struct ip6t_ipv6header_info {
-        u_int8_t matchflags;
+        __u8 matchflags;
-        u_int8_t invflags;
+        __u8 invflags;
-        u_int8_t modeflag;
+        __u8 modeflag;
 };
 #define MASK_HOPOPTS    128
diff --git a/include/linux/netfilter_ipv6/ip6t_mh.h b/include/linux/netfilter_ipv6/ip6t_mh.h
index 18549bca2d1f..a7729a5025cd 100644
--- a/include/linux/netfilter_ipv6/ip6t_mh.h
+++ b/include/linux/netfilter_ipv6/ip6t_mh.h
@@ -1,10 +1,12 @@
 #ifndef _IP6T_MH_H
 #define _IP6T_MH_H
+#include <linux/types.h>
 /* MH matching stuff */
 struct ip6t_mh {
-        u_int8_t types[2];      /* MH type range */
+        __u8 types[2];  /* MH type range */
-        u_int8_t invflags;      /* Inverse flags */
+        __u8 invflags;  /* Inverse flags */
 };
 /* Values for "invflags" field in struct ip6t_mh. */
diff --git a/include/linux/netfilter_ipv6/ip6t_opts.h b/include/linux/netfilter_ipv6/ip6t_opts.h
index 62d89bcd9f9c..17d419a811fd 100644
--- a/include/linux/netfilter_ipv6/ip6t_opts.h
+++ b/include/linux/netfilter_ipv6/ip6t_opts.h
@@ -1,14 +1,16 @@
 #ifndef _IP6T_OPTS_H
 #define _IP6T_OPTS_H
+#include <linux/types.h>
 #define IP6T_OPTS_OPTSNR 16
 struct ip6t_opts {
-        u_int32_t hdrlen;                       /* Header Length */
+        __u32 hdrlen;                   /* Header Length */
-        u_int8_t flags;                         /*  */
+        __u8 flags;                             /*  */
-        u_int8_t invflags;                      /* Inverse flags */
+        __u8 invflags;                  /* Inverse flags */
-        u_int16_t opts[IP6T_OPTS_OPTSNR];       /* opts */
+        __u16 opts[IP6T_OPTS_OPTSNR];   /* opts */
-        u_int8_t optsnr;                        /* Nr of OPts */
+        __u8 optsnr;                    /* Nr of OPts */
 };
 #define IP6T_OPTS_LEN           0x01
diff --git a/include/linux/netfilter_ipv6/ip6t_rt.h b/include/linux/netfilter_ipv6/ip6t_rt.h
index ab91bfd2cd00..7605a5ff81cd 100644
--- a/include/linux/netfilter_ipv6/ip6t_rt.h
+++ b/include/linux/netfilter_ipv6/ip6t_rt.h
@@ -1,18 +1,19 @@
 #ifndef _IP6T_RT_H
 #define _IP6T_RT_H
+#include <linux/types.h>
 /*#include <linux/in6.h>*/
 #define IP6T_RT_HOPS 16
 struct ip6t_rt {
-        u_int32_t rt_type;                      /* Routing Type */
+        __u32 rt_type;                  /* Routing Type */
-        u_int32_t segsleft[2];                  /* Segments Left */
+        __u32 segsleft[2];                      /* Segments Left */
-        u_int32_t hdrlen;                       /* Header Length */
+        __u32 hdrlen;                   /* Header Length */
-        u_int8_t  flags;                        /*  */
+        __u8  flags;                    /*  */
-        u_int8_t  invflags;                     /* Inverse flags */
+        __u8  invflags;                 /* Inverse flags */
        struct in6_addr addrs[IP6T_RT_HOPS];    /* Hops */
-        u_int8_t addrnr;                        /* Nr of Addresses */
+        __u8 addrnr;                    /* Nr of Addresses */
 };
 #define IP6T_RT_TYP             0x01
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index e2b9e63afa68..4c4ac3f3ce5a 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -160,10 +160,6 @@ struct netlink_skb_parms {
        struct ucred            creds;          /* Skb credentials      */
        __u32                   pid;
        __u32                   dst_group;
-        kernel_cap_t            eff_cap;
-        __u32                   loginuid;       /* Login (audit) uid */
-        __u32                   sessionid;      /* Session id (audit) */
-        __u32                   sid;            /* SELinux security id */
 };
 #define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb))
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index 821ffb954f14..30022189104d 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -1243,6 +1243,8 @@ enum nl80211_rate_info {
 * @NL80211_STA_INFO_LLID: the station's mesh LLID
 * @NL80211_STA_INFO_PLID: the station's mesh PLID
 * @NL80211_STA_INFO_PLINK_STATE: peer link state for the station
+ * @NL80211_STA_INFO_RX_BITRATE: last unicast data frame rx rate, nested
+ *      attribute, like NL80211_STA_INFO_TX_BITRATE.
 * @__NL80211_STA_INFO_AFTER_LAST: internal
 * @NL80211_STA_INFO_MAX: highest possible station info attribute
 */
@@ -1261,6 +1263,7 @@ enum nl80211_sta_info {
        NL80211_STA_INFO_TX_RETRIES,
        NL80211_STA_INFO_TX_FAILED,
        NL80211_STA_INFO_SIGNAL_AVG,
+        NL80211_STA_INFO_RX_BITRATE,
        /* keep last */
        __NL80211_STA_INFO_AFTER_LAST,
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 559d02897075..ff5bccb87136 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -1479,6 +1479,7 @@ void pci_request_acs(void);
 #define PCI_VPD_RO_KEYWORD_PARTNO       "PN"
 #define PCI_VPD_RO_KEYWORD_MFR_ID       "MN"
 #define PCI_VPD_RO_KEYWORD_VENDOR0      "V0"
+#define PCI_VPD_RO_KEYWORD_CHKSUM       "RV"
 /**
 * pci_vpd_lrdt_size - Extracts the Large Resource Data Type length
diff --git a/include/linux/phonet.h b/include/linux/phonet.h
index 26c8df786918..6fb13841db45 100644
--- a/include/linux/phonet.h
+++ b/include/linux/phonet.h
@@ -36,9 +36,7 @@
 /* Socket options for SOL_PNPIPE level */
 #define PNPIPE_ENCAP            1
 #define PNPIPE_IFINDEX          2
-#define PNPIPE_PIPE_HANDLE      3
+#define PNPIPE_HANDLE           3
-#define PNPIPE_ENABLE           4
-/* unused slot */
 #define PNADDR_ANY              0
 #define PNADDR_BROADCAST        0xFC
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index 2cfa4bc8dea6..b1032a3fafdc 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -247,6 +247,35 @@ struct tc_gred_sopt {
        __u16           pad1;
 };
+/* CHOKe section */
+enum {
+        TCA_CHOKE_UNSPEC,
+        TCA_CHOKE_PARMS,
+        TCA_CHOKE_STAB,
+        __TCA_CHOKE_MAX,
+};
+#define TCA_CHOKE_MAX (__TCA_CHOKE_MAX - 1)
+struct tc_choke_qopt {
+        __u32           limit;          /* Hard queue length (packets)  */
+        __u32           qth_min;        /* Min average threshold (packets) */
+        __u32           qth_max;        /* Max average threshold (packets) */
+        unsigned char   Wlog;           /* log(W)               */
+        unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+        unsigned char   Scell_log;      /* cell size for idle damping */
+        unsigned char   flags;          /* see RED flags */
+};
+struct tc_choke_xstats {
+        __u32           early;          /* Early drops */
+        __u32           pdrop;          /* Drops due to queue limits */
+        __u32           other;          /* Drops due to drop() calls */
+        __u32           marked;         /* Marked packets */
+        __u32           matched;        /* Drops due to flow match */
+};
 /* HTB section */
 #define TC_HTB_NUMPRIO          8
 #define TC_HTB_MAXDEPTH         8
@@ -435,6 +464,7 @@ enum {
        TCA_NETEM_DELAY_DIST,
        TCA_NETEM_REORDER,
        TCA_NETEM_CORRUPT,
+        TCA_NETEM_LOSS,
        __TCA_NETEM_MAX,
 };
@@ -465,7 +495,33 @@ struct tc_netem_corrupt {
        __u32   correlation;
 };
+enum {
+        NETEM_LOSS_UNSPEC,
+        NETEM_LOSS_GI,          /* General Intuitive - 4 state model */
+        NETEM_LOSS_GE,          /* Gilbert Elliot models */
+        __NETEM_LOSS_MAX
+};
+#define NETEM_LOSS_MAX (__NETEM_LOSS_MAX - 1)
+/* State transition probablities for 4 state model */
+struct tc_netem_gimodel {
+        __u32   p13;
+        __u32   p31;
+        __u32   p32;
+        __u32   p14;
+        __u32   p23;
+};
+/* Gilbert-Elliot models */
+struct tc_netem_gemodel {
+        __u32 p;
+        __u32 r;
+        __u32 h;
+        __u32 k1;
+};
 #define NETEM_DIST_SCALE        8192
+#define NETEM_DIST_MAX          16384
 /* DRR */
@@ -481,4 +537,55 @@ struct tc_drr_stats {
        __u32   deficit;
 };
+/* MQPRIO */
+#define TC_QOPT_BITMASK 15
+#define TC_QOPT_MAX_QUEUE 16
+struct tc_mqprio_qopt {
+        __u8    num_tc;
+        __u8    prio_tc_map[TC_QOPT_BITMASK + 1];
+        __u8    hw;
+        __u16   count[TC_QOPT_MAX_QUEUE];
+        __u16   offset[TC_QOPT_MAX_QUEUE];
+};
+/* SFB */
+enum {
+        TCA_SFB_UNSPEC,
+        TCA_SFB_PARMS,
+        __TCA_SFB_MAX,
+};
+#define TCA_SFB_MAX (__TCA_SFB_MAX - 1)
+/*
+ * Note: increment, decrement are Q0.16 fixed-point values.
+ */
+struct tc_sfb_qopt {
+        __u32 rehash_interval;  /* delay between hash move, in ms */
+        __u32 warmup_time;      /* double buffering warmup time in ms (warmup_time < rehash_interval) */
+        __u32 max;              /* max len of qlen_min */
+        __u32 bin_size;         /* maximum queue length per bin */
+        __u32 increment;        /* probability increment, (d1 in Blue) */
+        __u32 decrement;        /* probability decrement, (d2 in Blue) */
+        __u32 limit;            /* max SFB queue length */
+        __u32 penalty_rate;     /* inelastic flows are rate limited to 'rate' pps */
+        __u32 penalty_burst;
+};
+struct tc_sfb_xstats {
+        __u32 earlydrop;
+        __u32 penaltydrop;
+        __u32 bucketdrop;
+        __u32 queuedrop;
+        __u32 childdrop; /* drops in child qdisc */
+        __u32 marked;
+        __u32 maxqlen;
+        __u32 maxprob;
+        __u32 avgprob;
+};
+#define SFB_MAX_PROB 0xFFFF
 #endif
diff --git a/include/linux/security.h b/include/linux/security.h
index 83d9227abf02..56cac520d014 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1626,7 +1626,7 @@ struct security_operations {
        int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
        int (*xfrm_state_pol_flow_match) (struct xfrm_state *x,
                                          struct xfrm_policy *xp,
-                                          struct flowi *fl);
+                                          const struct flowi *fl);
        int (*xfrm_decode_session) (struct sk_buff *skb, u32 *secid, int ckall);
 #endif  /* CONFIG_SECURITY_NETWORK_XFRM */
@@ -2767,7 +2767,8 @@ int security_xfrm_state_delete(struct xfrm_state *x);
 void security_xfrm_state_free(struct xfrm_state *x);
 int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
 int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
-                                       struct xfrm_policy *xp, struct flowi *fl);
+                                       struct xfrm_policy *xp,
+                                       const struct flowi *fl);
 int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid);
 void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl);
@@ -2819,7 +2820,7 @@ static inline int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_s
 }
 static inline int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
-                        struct xfrm_policy *xp, struct flowi *fl)
+                        struct xfrm_policy *xp, const struct flowi *fl)
 {
        return 1;
 }
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index bf221d65d9ad..24cfa626931e 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -388,10 +388,7 @@ struct sk_buff {
        kmemcheck_bitfield_begin(flags2);
        __u16                   queue_mapping:16;
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
-        __u8                    ndisc_nodetype:2,
+        __u8                    ndisc_nodetype:2;
-                                deliver_no_wcard:1;
-#else
-        __u8                    deliver_no_wcard:1;
 #endif
        __u8                    ooo_okay:1;
        kmemcheck_bitfield_end(flags2);
@@ -1801,6 +1798,15 @@ static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
                     prefetch(skb->prev), (skb != (struct sk_buff *)(queue));   \
                     skb = skb->prev)
+#define skb_queue_reverse_walk_safe(queue, skb, tmp)                            \
+                for (skb = (queue)->prev, tmp = skb->prev;                      \
+                     skb != (struct sk_buff *)(queue);                          \
+                     skb = tmp, tmp = skb->prev)
+#define skb_queue_reverse_walk_from_safe(queue, skb, tmp)                       \
+                for (tmp = skb->prev;                                           \
+                     skb != (struct sk_buff *)(queue);                          \
+                     skb = tmp, tmp = skb->prev)
 static inline bool skb_has_frag_list(const struct sk_buff *skb)
 {
@@ -1868,7 +1874,7 @@ extern void	       skb_split(struct sk_buff *skb,
 extern int             skb_shift(struct sk_buff *tgt, struct sk_buff *skb,
                                 int shiftlen);
-extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
+extern struct sk_buff *skb_segment(struct sk_buff *skb, u32 features);
 static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
                                       int len, void *buffer)
diff --git a/include/linux/sockios.h b/include/linux/sockios.h
index 241f179347d9..7997a506ad41 100644
--- a/include/linux/sockios.h
+++ b/include/linux/sockios.h
@@ -22,7 +22,7 @@
 /* Linux-specific socket ioctls */
 #define SIOCINQ         FIONREAD
-#define SIOCOUTQ        TIOCOUTQ
+#define SIOCOUTQ        TIOCOUTQ        /* output queue size (not sent + not acked) */
 /* Routing table calls. */
 #define SIOCADDRT       0x890B          /* add routing table entry      */
@@ -83,6 +83,8 @@
 #define SIOCWANDEV      0x894A          /* get/set netdev parameters    */
+#define SIOCOUTQNSD     0x894B          /* output queue size (not sent only) */
 /* ARP cache control calls. */
                    /*  0x8950 - 0x8952  * obsolete calls, don't re-use */
 #define SIOCDARP        0x8953          /* delete ARP table entry       */
diff --git a/include/linux/ssb/ssb_regs.h b/include/linux/ssb/ssb_regs.h
index 489f7b6d61c5..402955ae48ce 100644
--- a/include/linux/ssb/ssb_regs.h
+++ b/include/linux/ssb/ssb_regs.h
@@ -85,6 +85,8 @@
 #define  SSB_IMSTATE_AP_RSV     0x00000030 /* Reserved */
 #define  SSB_IMSTATE_IBE        0x00020000 /* In Band Error */
 #define  SSB_IMSTATE_TO         0x00040000 /* Timeout */
+#define  SSB_IMSTATE_BUSY       0x01800000 /* Busy (Backplane rev >= 2.3 only) */
+#define  SSB_IMSTATE_REJECT     0x02000000 /* Reject (Backplane rev >= 2.3 only) */
 #define SSB_INTVEC              0x0F94     /* SB Interrupt Mask */
 #define  SSB_INTVEC_PCI         0x00000001 /* Enable interrupts for PCI */
 #define  SSB_INTVEC_ENET0       0x00000002 /* Enable interrupts for enet 0 */
@@ -97,7 +99,6 @@
 #define  SSB_TMSLOW_RESET       0x00000001 /* Reset */
 #define  SSB_TMSLOW_REJECT_22   0x00000002 /* Reject (Backplane rev 2.2) */
 #define  SSB_TMSLOW_REJECT_23   0x00000004 /* Reject (Backplane rev 2.3) */
-#define  SSB_TMSLOW_PHYCLK      0x00000010 /* MAC PHY Clock Control Enable */
 #define  SSB_TMSLOW_CLOCK       0x00010000 /* Clock Enable */
 #define  SSB_TMSLOW_FGC         0x00020000 /* Force Gated Clocks On */
 #define  SSB_TMSLOW_PE          0x40000000 /* Power Management Enable */
@@ -268,6 +269,8 @@
 /* SPROM Revision 4 */
 #define SSB_SPROM4_BFLLO                0x0044  /* Boardflags (low 16 bits) */
 #define SSB_SPROM4_BFLHI                0x0046  /* Board Flags Hi */
+#define SSB_SPROM4_BFL2LO               0x0048  /* Board flags 2 (low 16 bits) */
+#define SSB_SPROM4_BFL2HI               0x004A  /* Board flags 2 Hi */
 #define SSB_SPROM4_IL0MAC               0x004C  /* 6 byte MAC address for a/b/g/n */
 #define SSB_SPROM4_CCODE                0x0052  /* Country Code (2 bytes) */
 #define SSB_SPROM4_GPIOA                0x0056  /* Gen. Purpose IO # 0 and 1 */
@@ -358,6 +361,8 @@
 #define SSB_SPROM5_CCODE                0x0044  /* Country Code (2 bytes) */
 #define SSB_SPROM5_BFLLO                0x004A  /* Boardflags (low 16 bits) */
 #define SSB_SPROM5_BFLHI                0x004C  /* Board Flags Hi */
+#define SSB_SPROM5_BFL2LO               0x004E  /* Board flags 2 (low 16 bits) */
+#define SSB_SPROM5_BFL2HI               0x0050  /* Board flags 2 Hi */
 #define SSB_SPROM5_IL0MAC               0x0052  /* 6 byte MAC address for a/b/g/n */
 #define SSB_SPROM5_GPIOA                0x0076  /* Gen. Purpose IO # 0 and 1 */
 #define  SSB_SPROM5_GPIOA_P0            0x00FF  /* Pin 0 */
diff --git a/include/linux/tipc.h b/include/linux/tipc.h
index 1eefa3f6d1f4..a5b994a204d2 100644
--- a/include/linux/tipc.h
+++ b/include/linux/tipc.h
@@ -2,7 +2,7 @@
 * include/linux/tipc.h: Include file for TIPC socket interface
 *
 * Copyright (c) 2003-2006, Ericsson AB
- * Copyright (c) 2005, Wind River Systems
+ * Copyright (c) 2005, 2010-2011, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -130,12 +130,6 @@ static inline unsigned int tipc_node(__u32 addr)
 #define TIPC_SUB_PORTS          0x01    /* filter for port availability */
 #define TIPC_SUB_SERVICE        0x02    /* filter for service availability */
 #define TIPC_SUB_CANCEL         0x04    /* cancel a subscription */
-#if 0
-/* The following filter options are not currently implemented */
-#define TIPC_SUB_NO_BIND_EVTS   0x04    /* filter out "publish" events */
-#define TIPC_SUB_NO_UNBIND_EVTS 0x08    /* filter out "withdraw" events */
-#define TIPC_SUB_SINGLE_EVT     0x10    /* expire after first event */
-#endif
 #define TIPC_WAIT_FOREVER       (~0)    /* timeout for permanent subscription */
diff --git a/include/linux/tipc_config.h b/include/linux/tipc_config.h
index 7d42460a5e3c..0db239590b4d 100644
--- a/include/linux/tipc_config.h
+++ b/include/linux/tipc_config.h
@@ -2,7 +2,7 @@
 * include/linux/tipc_config.h: Include file for TIPC configuration interface
 *
 * Copyright (c) 2003-2006, Ericsson AB
- * Copyright (c) 2005-2007, Wind River Systems
+ * Copyright (c) 2005-2007, 2010-2011, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -76,13 +76,6 @@
 #define  TIPC_CMD_SHOW_LINK_STATS   0x000B    /* tx link_name, rx ultra_string */
 #define  TIPC_CMD_SHOW_STATS        0x000F    /* tx unsigned, rx ultra_string */
-#if 0
-#define  TIPC_CMD_SHOW_PORT_STATS   0x0008    /* tx port_ref, rx ultra_string */
-#define  TIPC_CMD_RESET_PORT_STATS  0x0009    /* tx port_ref, rx none */
-#define  TIPC_CMD_GET_ROUTES        0x000A    /* tx ?, rx ? */
-#define  TIPC_CMD_GET_LINK_PEER     0x000D    /* tx link_name, rx ? */
-#endif
 /*
 * Protected commands:
 * May only be issued by "network administration capable" process.
@@ -96,7 +89,7 @@
 #define  TIPC_CMD_GET_MAX_SUBSCR    0x4006    /* tx none, rx unsigned */
 #define  TIPC_CMD_GET_MAX_ZONES     0x4007    /* obsoleted */
 #define  TIPC_CMD_GET_MAX_CLUSTERS  0x4008    /* obsoleted */
-#define  TIPC_CMD_GET_MAX_NODES     0x4009    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_NODES     0x4009    /* obsoleted */
 #define  TIPC_CMD_GET_MAX_SLAVES    0x400A    /* obsoleted */
 #define  TIPC_CMD_GET_NETID         0x400B    /* tx none, rx unsigned */
@@ -109,13 +102,6 @@
 #define  TIPC_CMD_DUMP_LOG          0x410B    /* tx none, rx ultra_string */
 #define  TIPC_CMD_RESET_LINK_STATS  0x410C    /* tx link_name, rx none */
-#if 0
-#define  TIPC_CMD_CREATE_LINK       0x4103    /* tx link_create, rx none */
-#define  TIPC_CMD_REMOVE_LINK       0x4104    /* tx link_name, rx none */
-#define  TIPC_CMD_BLOCK_LINK        0x4105    /* tx link_name, rx none */
-#define  TIPC_CMD_UNBLOCK_LINK      0x4106    /* tx link_name, rx none */
-#endif
 /*
 * Private commands:
 * May only be issued by "network administration capable" process.
@@ -123,16 +109,13 @@
 */
 #define  TIPC_CMD_SET_NODE_ADDR     0x8001    /* tx net_addr, rx none */
-#if 0
-#define  TIPC_CMD_SET_ZONE_MASTER   0x8002    /* tx none, rx none */
-#endif
 #define  TIPC_CMD_SET_REMOTE_MNG    0x8003    /* tx unsigned, rx none */
 #define  TIPC_CMD_SET_MAX_PORTS     0x8004    /* tx unsigned, rx none */
 #define  TIPC_CMD_SET_MAX_PUBL      0x8005    /* tx unsigned, rx none */
 #define  TIPC_CMD_SET_MAX_SUBSCR    0x8006    /* tx unsigned, rx none */
 #define  TIPC_CMD_SET_MAX_ZONES     0x8007    /* obsoleted */
 #define  TIPC_CMD_SET_MAX_CLUSTERS  0x8008    /* obsoleted */
-#define  TIPC_CMD_SET_MAX_NODES     0x8009    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_NODES     0x8009    /* obsoleted */
 #define  TIPC_CMD_SET_MAX_SLAVES    0x800A    /* obsoleted */
 #define  TIPC_CMD_SET_NETID         0x800B    /* tx unsigned, rx none */
@@ -193,6 +176,10 @@
 #define TIPC_DEF_LINK_TOL 1500
 #define TIPC_MAX_LINK_TOL 30000
+#if (TIPC_MIN_LINK_TOL < 16)
+#error "TIPC_MIN_LINK_TOL is too small (abort limit may be NaN)"
+#endif
 /*
 * Link window limits (min, default, max), in packets
 */
@@ -215,7 +202,7 @@ struct tipc_link_info {
 struct tipc_bearer_config {
        __be32 priority;                /* Range [1,31]. Override per link  */
-        __be32 detect_scope;
+        __be32 disc_domain;             /* <Z.C.N> describing desired nodes */
        char name[TIPC_MAX_BEARER_NAME];
 };
@@ -247,15 +234,6 @@ struct tipc_name_table_query {
 #define TIPC_CFG_NOT_SUPPORTED  "\x84"  /* request is not supported by TIPC */
 #define TIPC_CFG_INVALID_VALUE  "\x85"  /* request has invalid argument value */
-#if 0
-/* prototypes TLV structures for proposed commands */
-struct tipc_link_create {
-        __u32   domain;
-        struct tipc_media_addr peer_addr;
-        char bearer_name[TIPC_MAX_BEARER_NAME];
-};
-#endif
 /*
 * A TLV consists of a descriptor, followed by the TLV value.
 * TLV descriptor fields are stored in network byte order;
diff --git a/include/linux/xfrm.h b/include/linux/xfrm.h
index 930fdd2de79c..22e61fdf75a2 100644
--- a/include/linux/xfrm.h
+++ b/include/linux/xfrm.h
@@ -84,6 +84,16 @@ struct xfrm_replay_state {
        __u32   bitmap;
 };
+struct xfrm_replay_state_esn {
+        unsigned int    bmp_len;
+        __u32           oseq;
+        __u32           seq;
+        __u32           oseq_hi;
+        __u32           seq_hi;
+        __u32           replay_window;
+        __u32           bmp[0];
+};
 struct xfrm_algo {
        char            alg_name[64];
        unsigned int    alg_key_len;    /* in bits */
@@ -284,6 +294,7 @@ enum xfrm_attr_type_t {
        XFRMA_ALG_AUTH_TRUNC,   /* struct xfrm_algo_auth */
        XFRMA_MARK,             /* struct xfrm_mark */
        XFRMA_TFCPAD,           /* __u32 */
+        XFRMA_REPLAY_ESN_VAL,   /* struct xfrm_replay_esn */
        __XFRMA_MAX
 #define XFRMA_MAX (__XFRMA_MAX - 1)
@@ -350,6 +361,8 @@ struct xfrm_usersa_info {
 #define XFRM_STATE_WILDRECV     8
 #define XFRM_STATE_ICMP         16
 #define XFRM_STATE_AF_UNSPEC    32
+#define XFRM_STATE_ALIGN4       64
+#define XFRM_STATE_ESN          128
 };
 struct xfrm_usersa_id {
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 0c5e72503b77..43750439c521 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -64,6 +64,11 @@ struct bt_security {
 #define BT_DEFER_SETUP  7
+#define BT_FLUSHABLE    8
+#define BT_FLUSHABLE_OFF        0
+#define BT_FLUSHABLE_ON         1
 #define BT_INFO(fmt, arg...) printk(KERN_INFO "Bluetooth: " fmt "\n" , ## arg)
 #define BT_ERR(fmt, arg...)  printk(KERN_ERR "%s: " fmt "\n" , __func__ , ## arg)
 #define BT_DBG(fmt, arg...)  pr_debug("%s: " fmt "\n" , __func__ , ## arg)
@@ -200,4 +205,32 @@ extern void bt_sysfs_cleanup(void);
 extern struct dentry *bt_debugfs;
+#ifdef CONFIG_BT_L2CAP
+int l2cap_init(void);
+void l2cap_exit(void);
+#else
+static inline int l2cap_init(void)
+{
+        return 0;
+}
+static inline void l2cap_exit(void)
+{
+}
+#endif
+#ifdef CONFIG_BT_SCO
+int sco_init(void);
+void sco_exit(void);
+#else
+static inline int sco_init(void)
+{
+        return 0;
+}
+static inline void sco_exit(void)
+{
+}
+#endif
 #endif /* __BLUETOOTH_H */
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index 29a7a8ca0438..ec6acf2f1c0b 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -76,6 +76,14 @@ enum {
        HCI_INQUIRY,
        HCI_RAW,
+        HCI_SETUP,
+        HCI_AUTO_OFF,
+        HCI_MGMT,
+        HCI_PAIRABLE,
+        HCI_SERVICE_CACHE,
+        HCI_LINK_KEYS,
+        HCI_DEBUG_KEYS,
 };
 /* HCI ioctl defines */
@@ -111,6 +119,7 @@ enum {
 #define HCI_PAIRING_TIMEOUT     (60000) /* 60 seconds */
 #define HCI_IDLE_TIMEOUT        (6000)  /* 6 seconds */
 #define HCI_INIT_TIMEOUT        (10000) /* 10 seconds */
+#define HCI_CMD_TIMEOUT         (1000)  /* 1 seconds */
 /* HCI data types */
 #define HCI_COMMAND_PKT         0x01
@@ -150,6 +159,7 @@ enum {
 #define EDR_ESCO_MASK  (ESCO_2EV3 | ESCO_3EV3 | ESCO_2EV5 | ESCO_3EV5)
 /* ACL flags */
+#define ACL_START_NO_FLUSH      0x00
 #define ACL_CONT                0x01
 #define ACL_START               0x02
 #define ACL_ACTIVE_BCAST        0x04
@@ -159,6 +169,8 @@ enum {
 #define SCO_LINK        0x00
 #define ACL_LINK        0x01
 #define ESCO_LINK       0x02
+/* Low Energy links do not have defined link type. Use invented one */
+#define LE_LINK         0x80
 /* LMP features */
 #define LMP_3SLOT       0x01
@@ -183,17 +195,25 @@ enum {
 #define LMP_PSCHEME     0x02
 #define LMP_PCONTROL    0x04
+#define LMP_RSSI_INQ    0x40
 #define LMP_ESCO        0x80
 #define LMP_EV4         0x01
 #define LMP_EV5         0x02
+#define LMP_LE          0x40
 #define LMP_SNIFF_SUBR  0x02
+#define LMP_PAUSE_ENC   0x04
 #define LMP_EDR_ESCO_2M 0x20
 #define LMP_EDR_ESCO_3M 0x40
 #define LMP_EDR_3S_ESCO 0x80
+#define LMP_EXT_INQ     0x01
 #define LMP_SIMPLE_PAIR 0x08
+#define LMP_NO_FLUSH    0x40
+#define LMP_LSTO        0x01
+#define LMP_INQ_TX_PWR  0x02
 /* Connection modes */
 #define HCI_CM_ACTIVE   0x0000
@@ -225,6 +245,8 @@ enum {
 #define HCI_AT_GENERAL_BONDING_MITM     0x05
 /* -----  HCI Commands ---- */
+#define HCI_OP_NOP                      0x0000
 #define HCI_OP_INQUIRY                  0x0401
 struct hci_cp_inquiry {
        __u8     lap[3];
@@ -292,11 +314,19 @@ struct hci_cp_pin_code_reply {
        __u8     pin_len;
        __u8     pin_code[16];
 } __packed;
+struct hci_rp_pin_code_reply {
+        __u8     status;
+        bdaddr_t bdaddr;
+} __packed;
 #define HCI_OP_PIN_CODE_NEG_REPLY       0x040e
 struct hci_cp_pin_code_neg_reply {
        bdaddr_t bdaddr;
 } __packed;
+struct hci_rp_pin_code_neg_reply {
+        __u8     status;
+        bdaddr_t bdaddr;
+} __packed;
 #define HCI_OP_CHANGE_CONN_PTYPE        0x040f
 struct hci_cp_change_conn_ptype {
@@ -377,6 +407,31 @@ struct hci_cp_reject_sync_conn_req {
        __u8     reason;
 } __packed;
+#define HCI_OP_IO_CAPABILITY_REPLY      0x042b
+struct hci_cp_io_capability_reply {
+        bdaddr_t bdaddr;
+        __u8     capability;
+        __u8     oob_data;
+        __u8     authentication;
+} __packed;
+#define HCI_OP_USER_CONFIRM_REPLY               0x042c
+struct hci_cp_user_confirm_reply {
+        bdaddr_t bdaddr;
+} __packed;
+struct hci_rp_user_confirm_reply {
+        __u8     status;
+        bdaddr_t bdaddr;
+} __packed;
+#define HCI_OP_USER_CONFIRM_NEG_REPLY   0x042d
+#define HCI_OP_IO_CAPABILITY_NEG_REPLY  0x0434
+struct hci_cp_io_capability_neg_reply {
+        bdaddr_t bdaddr;
+        __u8     reason;
+} __packed;
 #define HCI_OP_SNIFF_MODE               0x0803
 struct hci_cp_sniff_mode {
        __le16   handle;
@@ -474,6 +529,12 @@ struct hci_cp_set_event_flt {
 #define HCI_CONN_SETUP_AUTO_OFF 0x01
 #define HCI_CONN_SETUP_AUTO_ON  0x02
+#define HCI_OP_DELETE_STORED_LINK_KEY   0x0c12
+struct hci_cp_delete_stored_link_key {
+        bdaddr_t bdaddr;
+        __u8     delete_all;
+} __packed;
 #define HCI_OP_WRITE_LOCAL_NAME         0x0c13
 struct hci_cp_write_local_name {
        __u8     name[248];
@@ -537,6 +598,8 @@ struct hci_cp_host_buffer_size {
        __le16   sco_max_pkt;
 } __packed;
+#define HCI_OP_WRITE_INQUIRY_MODE       0x0c45
 #define HCI_OP_READ_SSP_MODE            0x0c55
 struct hci_rp_read_ssp_mode {
        __u8     status;
@@ -548,6 +611,8 @@ struct hci_cp_write_ssp_mode {
        __u8     mode;
 } __packed;
+#define HCI_OP_READ_INQ_RSP_TX_POWER    0x0c58
 #define HCI_OP_READ_LOCAL_VERSION       0x1001
 struct hci_rp_read_local_version {
        __u8     status;
@@ -593,6 +658,47 @@ struct hci_rp_read_bd_addr {
        bdaddr_t bdaddr;
 } __packed;
+#define HCI_OP_LE_SET_EVENT_MASK        0x2001
+struct hci_cp_le_set_event_mask {
+        __u8     mask[8];
+} __packed;
+#define HCI_OP_LE_READ_BUFFER_SIZE      0x2002
+struct hci_rp_le_read_buffer_size {
+        __u8     status;
+        __le16   le_mtu;
+        __u8     le_max_pkt;
+} __packed;
+#define HCI_OP_LE_CREATE_CONN           0x200d
+struct hci_cp_le_create_conn {
+        __le16   scan_interval;
+        __le16   scan_window;
+        __u8     filter_policy;
+        __u8     peer_addr_type;
+        bdaddr_t peer_addr;
+        __u8     own_address_type;
+        __le16   conn_interval_min;
+        __le16   conn_interval_max;
+        __le16   conn_latency;
+        __le16   supervision_timeout;
+        __le16   min_ce_len;
+        __le16   max_ce_len;
+} __packed;
+#define HCI_OP_LE_CREATE_CONN_CANCEL    0x200e
+#define HCI_OP_LE_CONN_UPDATE           0x2013
+struct hci_cp_le_conn_update {
+        __le16   handle;
+        __le16   conn_interval_min;
+        __le16   conn_interval_max;
+        __le16   conn_latency;
+        __le16   supervision_timeout;
+        __le16   min_ce_len;
+        __le16   max_ce_len;
+} __packed;
 /* ---- HCI Events ---- */
 #define HCI_EV_INQUIRY_COMPLETE         0x01
@@ -833,6 +939,20 @@ struct hci_ev_io_capa_request {
        bdaddr_t bdaddr;
 } __packed;
+#define HCI_EV_IO_CAPA_REPLY            0x32
+struct hci_ev_io_capa_reply {
+        bdaddr_t bdaddr;
+        __u8     capability;
+        __u8     oob_data;
+        __u8     authentication;
+} __packed;
+#define HCI_EV_USER_CONFIRM_REQUEST     0x33
+struct hci_ev_user_confirm_req {
+        bdaddr_t        bdaddr;
+        __le32          passkey;
+} __packed;
 #define HCI_EV_SIMPLE_PAIR_COMPLETE     0x36
 struct hci_ev_simple_pair_complete {
        __u8     status;
@@ -845,6 +965,25 @@ struct hci_ev_remote_host_features {
        __u8     features[8];
 } __packed;
+#define HCI_EV_LE_META                  0x3e
+struct hci_ev_le_meta {
+        __u8     subevent;
+} __packed;
+/* Low energy meta events */
+#define HCI_EV_LE_CONN_COMPLETE         0x01
+struct hci_ev_le_conn_complete {
+        __u8     status;
+        __le16   handle;
+        __u8     role;
+        __u8     bdaddr_type;
+        bdaddr_t bdaddr;
+        __le16   interval;
+        __le16   latency;
+        __le16   supervision_timeout;
+        __u8     clk_accurancy;
+} __packed;
 /* Internal events generated by Bluetooth stack */
 #define HCI_EV_STACK_INTERNAL   0xfd
 struct hci_ev_stack_internal {
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index d2cf88407690..441dadbf6a89 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -60,12 +60,28 @@ struct hci_conn_hash {
        spinlock_t       lock;
        unsigned int     acl_num;
        unsigned int     sco_num;
+        unsigned int     le_num;
 };
 struct bdaddr_list {
        struct list_head list;
        bdaddr_t bdaddr;
 };
+struct bt_uuid {
+        struct list_head list;
+        u8 uuid[16];
+        u8 svc_hint;
+};
+struct link_key {
+        struct list_head list;
+        bdaddr_t bdaddr;
+        u8 type;
+        u8 val[16];
+        u8 pin_len;
+};
 #define NUM_REASSEMBLY 4
 struct hci_dev {
        struct list_head list;
@@ -80,13 +96,18 @@ struct hci_dev {
        bdaddr_t        bdaddr;
        __u8            dev_name[248];
        __u8            dev_class[3];
+        __u8            major_class;
+        __u8            minor_class;
        __u8            features[8];
        __u8            commands[64];
        __u8            ssp_mode;
        __u8            hci_ver;
        __u16           hci_rev;
+        __u8            lmp_ver;
        __u16           manufacturer;
+        __le16          lmp_subver;
        __u16           voice_setting;
+        __u8            io_capability;
        __u16           pkt_type;
        __u16           esco_type;
@@ -102,18 +123,26 @@ struct hci_dev {
        atomic_t        cmd_cnt;
        unsigned int    acl_cnt;
        unsigned int    sco_cnt;
+        unsigned int    le_cnt;
        unsigned int    acl_mtu;
        unsigned int    sco_mtu;
+        unsigned int    le_mtu;
        unsigned int    acl_pkts;
        unsigned int    sco_pkts;
+        unsigned int    le_pkts;
-        unsigned long   cmd_last_tx;
        unsigned long   acl_last_tx;
        unsigned long   sco_last_tx;
+        unsigned long   le_last_tx;
        struct workqueue_struct *workqueue;
+        struct work_struct      power_on;
+        struct work_struct      power_off;
+        struct timer_list       off_timer;
+        struct timer_list       cmd_timer;
        struct tasklet_struct   cmd_task;
        struct tasklet_struct   rx_task;
        struct tasklet_struct   tx_task;
@@ -129,12 +158,17 @@ struct hci_dev {
        wait_queue_head_t       req_wait_q;
        __u32                   req_status;
        __u32                   req_result;
-        __u16                   req_last_cmd;
+        __u16                   init_last_cmd;
        struct inquiry_cache    inq_cache;
        struct hci_conn_hash    conn_hash;
        struct list_head        blacklist;
+        struct list_head        uuids;
+        struct list_head        link_keys;
        struct hci_dev_stats    stat;
        struct sk_buff_head     driver_init;
@@ -165,31 +199,37 @@ struct hci_dev {
 struct hci_conn {
        struct list_head list;
-        atomic_t         refcnt;
+        atomic_t        refcnt;
-        spinlock_t       lock;
+        spinlock_t      lock;
-        bdaddr_t         dst;
+        bdaddr_t        dst;
-        __u16            handle;
+        __u16           handle;
-        __u16            state;
+        __u16           state;
-        __u8             mode;
+        __u8            mode;
-        __u8             type;
+        __u8            type;
-        __u8             out;
+        __u8            out;
-        __u8             attempt;
+        __u8            attempt;
-        __u8             dev_class[3];
+        __u8            dev_class[3];
-        __u8             features[8];
+        __u8            features[8];
-        __u8             ssp_mode;
+        __u8            ssp_mode;
-        __u16            interval;
+        __u16           interval;
-        __u16            pkt_type;
+        __u16           pkt_type;
-        __u16            link_policy;
+        __u16           link_policy;
-        __u32            link_mode;
+        __u32           link_mode;
-        __u8             auth_type;
+        __u8            auth_type;
-        __u8             sec_level;
+        __u8            sec_level;
-        __u8             pending_sec_level;
+        __u8            pending_sec_level;
-        __u8             power_save;
+        __u8            pin_length;
-        __u16            disc_timeout;
+        __u8            io_capability;
-        unsigned long    pend;
+        __u8            power_save;
+        __u16           disc_timeout;
-        unsigned int     sent;
+        unsigned long   pend;
+        __u8            remote_cap;
+        __u8            remote_oob;
+        __u8            remote_auth;
+        unsigned int    sent;
        struct sk_buff_head data_q;
@@ -208,6 +248,10 @@ struct hci_conn {
        void            *priv;
        struct hci_conn *link;
+        void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
+        void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
+        void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 };
 extern struct hci_proto *hci_proto[];
@@ -274,24 +318,40 @@ static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        list_add(&c->list, &h->list);
-        if (c->type == ACL_LINK)
+        switch (c->type) {
+        case ACL_LINK:
                h->acl_num++;
-        else
+                break;
+        case LE_LINK:
+                h->le_num++;
+                break;
+        case SCO_LINK:
+        case ESCO_LINK:
                h->sco_num++;
+                break;
+        }
 }
 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        list_del(&c->list);
-        if (c->type == ACL_LINK)
+        switch (c->type) {
+        case ACL_LINK:
                h->acl_num--;
-        else
+                break;
+        case LE_LINK:
+                h->le_num--;
+                break;
+        case SCO_LINK:
+        case ESCO_LINK:
                h->sco_num--;
+                break;
+        }
 }
 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
-                                        __u16 handle)
+                                                                __u16 handle)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        struct list_head *p;
@@ -306,7 +366,7 @@ static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 }
 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
-                                        __u8 type, bdaddr_t *ba)
+                                                        __u8 type, bdaddr_t *ba)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        struct list_head *p;
@@ -321,7 +381,7 @@ static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 }
 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
-                                        __u8 type, __u16 state)
+                                                        __u8 type, __u16 state)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        struct list_head *p;
@@ -437,6 +497,16 @@ int hci_inquiry(void __user *arg);
 struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
 int hci_blacklist_clear(struct hci_dev *hdev);
+int hci_uuids_clear(struct hci_dev *hdev);
+int hci_link_keys_clear(struct hci_dev *hdev);
+struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
+int hci_add_link_key(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr,
+                                                u8 *key, u8 type, u8 pin_len);
+int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
+void hci_del_off_timer(struct hci_dev *hdev);
 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 int hci_recv_frame(struct sk_buff *skb);
@@ -458,6 +528,8 @@ void hci_conn_del_sysfs(struct hci_conn *conn);
 #define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
 #define lmp_esco_capable(dev)      ((dev)->features[3] & LMP_ESCO)
 #define lmp_ssp_capable(dev)       ((dev)->features[6] & LMP_SIMPLE_PAIR)
+#define lmp_no_flush_capable(dev)  ((dev)->features[6] & LMP_NO_FLUSH)
+#define lmp_le_capable(dev)        ((dev)->features[4] & LMP_LE)
 /* ----- HCI protocols ----- */
 struct hci_proto {
@@ -503,6 +575,9 @@ static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
        hp = hci_proto[HCI_PROTO_SCO];
        if (hp && hp->connect_cfm)
                hp->connect_cfm(conn, status);
+        if (conn->connect_cfm_cb)
+                conn->connect_cfm_cb(conn, status);
 }
 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
@@ -532,6 +607,9 @@ static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
        hp = hci_proto[HCI_PROTO_SCO];
        if (hp && hp->disconn_cfm)
                hp->disconn_cfm(conn, reason);
+        if (conn->disconn_cfm_cb)
+                conn->disconn_cfm_cb(conn, reason);
 }
 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
@@ -551,6 +629,9 @@ static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
        hp = hci_proto[HCI_PROTO_SCO];
        if (hp && hp->security_cfm)
                hp->security_cfm(conn, status, encrypt);
+        if (conn->security_cfm_cb)
+                conn->security_cfm_cb(conn, status);
 }
 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
@@ -564,6 +645,9 @@ static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status, __u
        hp = hci_proto[HCI_PROTO_SCO];
        if (hp && hp->security_cfm)
                hp->security_cfm(conn, status, encrypt);
+        if (conn->security_cfm_cb)
+                conn->security_cfm_cb(conn, status);
 }
 int hci_register_proto(struct hci_proto *hproto);
@@ -660,12 +744,29 @@ void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
 /* ----- HCI Sockets ----- */
-void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
+void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb,
+                                                        struct sock *skip_sk);
 /* Management interface */
 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
 int mgmt_index_added(u16 index);
 int mgmt_index_removed(u16 index);
+int mgmt_powered(u16 index, u8 powered);
+int mgmt_discoverable(u16 index, u8 discoverable);
+int mgmt_connectable(u16 index, u8 connectable);
+int mgmt_new_key(u16 index, struct link_key *key, u8 old_key_type);
+int mgmt_connected(u16 index, bdaddr_t *bdaddr);
+int mgmt_disconnected(u16 index, bdaddr_t *bdaddr);
+int mgmt_disconnect_failed(u16 index);
+int mgmt_connect_failed(u16 index, bdaddr_t *bdaddr, u8 status);
+int mgmt_pin_code_request(u16 index, bdaddr_t *bdaddr);
+int mgmt_pin_code_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status);
+int mgmt_pin_code_neg_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status);
+int mgmt_user_confirm_request(u16 index, bdaddr_t *bdaddr, __le32 value);
+int mgmt_user_confirm_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status);
+int mgmt_user_confirm_neg_reply_complete(u16 index, bdaddr_t *bdaddr,
+                                                                u8 status);
+int mgmt_auth_failed(u16 index, bdaddr_t *bdaddr, u8 status);
 /* HCI info for socket */
 #define hci_pi(sk) ((struct hci_pinfo *) sk)
@@ -697,4 +798,6 @@ struct hci_sec_filter {
 void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result);
+void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
+                                        u16 latency, u16 to_multiplier);
 #endif /* __HCI_CORE_H */
diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
index 7ad25ca60ec0..4f4bff1eaed6 100644
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -38,6 +38,7 @@
 #define L2CAP_DEFAULT_MAX_PDU_SIZE      1009    /* Sized for 3-DH5 packet */
 #define L2CAP_DEFAULT_ACK_TO            200
 #define L2CAP_LOCAL_BUSY_TRIES          12
+#define L2CAP_LE_DEFAULT_MTU            23
 #define L2CAP_CONN_TIMEOUT      (40000) /* 40 seconds */
 #define L2CAP_INFO_TIMEOUT      (4000)  /*  4 seconds */
@@ -88,6 +89,8 @@ struct l2cap_conninfo {
 #define L2CAP_ECHO_RSP          0x09
 #define L2CAP_INFO_REQ          0x0a
 #define L2CAP_INFO_RSP          0x0b
+#define L2CAP_CONN_PARAM_UPDATE_REQ     0x12
+#define L2CAP_CONN_PARAM_UPDATE_RSP     0x13
 /* L2CAP feature mask */
 #define L2CAP_FEAT_FLOWCTL      0x00000001
@@ -160,6 +163,9 @@ struct l2cap_conn_rsp {
 /* channel indentifier */
 #define L2CAP_CID_SIGNALING     0x0001
 #define L2CAP_CID_CONN_LESS     0x0002
+#define L2CAP_CID_LE_DATA       0x0004
+#define L2CAP_CID_LE_SIGNALING  0x0005
+#define L2CAP_CID_SMP           0x0006
 #define L2CAP_CID_DYN_START     0x0040
 #define L2CAP_CID_DYN_END       0xffff
@@ -255,6 +261,21 @@ struct l2cap_info_rsp {
 #define L2CAP_IR_SUCCESS    0x0000
 #define L2CAP_IR_NOTSUPP    0x0001
+struct l2cap_conn_param_update_req {
+        __le16      min;
+        __le16      max;
+        __le16      latency;
+        __le16      to_multiplier;
+} __packed;
+struct l2cap_conn_param_update_rsp {
+        __le16      result;
+} __packed;
+/* Connection Parameters result */
+#define L2CAP_CONN_PARAM_ACCEPTED       0x0000
+#define L2CAP_CONN_PARAM_REJECTED       0x0001
 /* ----- L2CAP connections ----- */
 struct l2cap_chan_list {
        struct sock     *head;
@@ -327,6 +348,7 @@ struct l2cap_pinfo {
        __u8            sec_level;
        __u8            role_switch;
        __u8            force_reliable;
+        __u8            flushable;
        __u8            conf_req[64];
        __u8            conf_len;
@@ -423,6 +445,35 @@ static inline int l2cap_tx_window_full(struct sock *sk)
 #define __is_sframe(ctrl)       ((ctrl) & L2CAP_CTRL_FRAME_TYPE)
 #define __is_sar_start(ctrl)    (((ctrl) & L2CAP_CTRL_SAR) == L2CAP_SDU_START)
-void l2cap_load(void);
+extern int disable_ertm;
+extern const struct proto_ops l2cap_sock_ops;
+extern struct bt_sock_list l2cap_sk_list;
+int l2cap_init_sockets(void);
+void l2cap_cleanup_sockets(void);
+u8 l2cap_get_ident(struct l2cap_conn *conn);
+void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data);
+int l2cap_build_conf_req(struct sock *sk, void *data);
+int __l2cap_wait_ack(struct sock *sk);
+struct sk_buff *l2cap_create_connless_pdu(struct sock *sk, struct msghdr *msg, size_t len);
+struct sk_buff *l2cap_create_basic_pdu(struct sock *sk, struct msghdr *msg, size_t len);
+struct sk_buff *l2cap_create_iframe_pdu(struct sock *sk, struct msghdr *msg, size_t len, u16 control, u16 sdulen);
+int l2cap_sar_segment_sdu(struct sock *sk, struct msghdr *msg, size_t len);
+void l2cap_do_send(struct sock *sk, struct sk_buff *skb);
+void l2cap_streaming_send(struct sock *sk);
+int l2cap_ertm_send(struct sock *sk);
+void l2cap_sock_set_timer(struct sock *sk, long timeout);
+void l2cap_sock_clear_timer(struct sock *sk);
+void __l2cap_sock_close(struct sock *sk, int reason);
+void l2cap_sock_kill(struct sock *sk);
+void l2cap_sock_init(struct sock *sk, struct sock *parent);
+struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
+                                                        int proto, gfp_t prio);
+void l2cap_send_disconn_req(struct l2cap_conn *conn, struct sock *sk, int err);
+void l2cap_chan_del(struct sock *sk, int err);
+int l2cap_do_connect(struct sock *sk);
 #endif /* __L2CAP_H */
diff --git a/include/net/bluetooth/mgmt.h b/include/net/bluetooth/mgmt.h
index ca29c1367ffd..5fabfa886b3e 100644
--- a/include/net/bluetooth/mgmt.h
+++ b/include/net/bluetooth/mgmt.h
@@ -21,11 +21,13 @@
   SOFTWARE IS DISCLAIMED.
 */
+#define MGMT_INDEX_NONE                 0xFFFF
 struct mgmt_hdr {
        __le16 opcode;
+        __le16 index;
        __le16 len;
 } __packed;
-#define MGMT_HDR_SIZE                   4
 #define MGMT_OP_READ_VERSION            0x0001
 struct mgmt_rp_read_version {
@@ -40,13 +42,10 @@ struct mgmt_rp_read_index_list {
 } __packed;
 #define MGMT_OP_READ_INFO               0x0004
-struct mgmt_cp_read_info {
-        __le16 index;
-} __packed;
 struct mgmt_rp_read_info {
-        __le16 index;
        __u8 type;
        __u8 powered;
+        __u8 connectable;
        __u8 discoverable;
        __u8 pairable;
        __u8 sec_mode;
@@ -58,6 +57,116 @@ struct mgmt_rp_read_info {
        __u16 hci_rev;
 } __packed;
+struct mgmt_mode {
+        __u8 val;
+} __packed;
+#define MGMT_OP_SET_POWERED             0x0005
+#define MGMT_OP_SET_DISCOVERABLE        0x0006
+#define MGMT_OP_SET_CONNECTABLE         0x0007
+#define MGMT_OP_SET_PAIRABLE            0x0008
+#define MGMT_OP_ADD_UUID                0x0009
+struct mgmt_cp_add_uuid {
+        __u8 uuid[16];
+        __u8 svc_hint;
+} __packed;
+#define MGMT_OP_REMOVE_UUID             0x000A
+struct mgmt_cp_remove_uuid {
+        __u8 uuid[16];
+} __packed;
+#define MGMT_OP_SET_DEV_CLASS           0x000B
+struct mgmt_cp_set_dev_class {
+        __u8 major;
+        __u8 minor;
+} __packed;
+#define MGMT_OP_SET_SERVICE_CACHE       0x000C
+struct mgmt_cp_set_service_cache {
+        __u8 enable;
+} __packed;
+struct mgmt_key_info {
+        bdaddr_t bdaddr;
+        u8 type;
+        u8 val[16];
+        u8 pin_len;
+} __packed;
+#define MGMT_OP_LOAD_KEYS               0x000D
+struct mgmt_cp_load_keys {
+        __u8 debug_keys;
+        __le16 key_count;
+        struct mgmt_key_info keys[0];
+} __packed;
+#define MGMT_OP_REMOVE_KEY              0x000E
+struct mgmt_cp_remove_key {
+        bdaddr_t bdaddr;
+        __u8 disconnect;
+} __packed;
+#define MGMT_OP_DISCONNECT              0x000F
+struct mgmt_cp_disconnect {
+        bdaddr_t bdaddr;
+} __packed;
+struct mgmt_rp_disconnect {
+        bdaddr_t bdaddr;
+} __packed;
+#define MGMT_OP_GET_CONNECTIONS         0x0010
+struct mgmt_rp_get_connections {
+        __le16 conn_count;
+        bdaddr_t conn[0];
+} __packed;
+#define MGMT_OP_PIN_CODE_REPLY          0x0011
+struct mgmt_cp_pin_code_reply {
+        bdaddr_t bdaddr;
+        __u8 pin_len;
+        __u8 pin_code[16];
+} __packed;
+struct mgmt_rp_pin_code_reply {
+        bdaddr_t bdaddr;
+        uint8_t status;
+} __packed;
+#define MGMT_OP_PIN_CODE_NEG_REPLY      0x0012
+struct mgmt_cp_pin_code_neg_reply {
+        bdaddr_t bdaddr;
+} __packed;
+#define MGMT_OP_SET_IO_CAPABILITY       0x0013
+struct mgmt_cp_set_io_capability {
+        __u8 io_capability;
+} __packed;
+#define MGMT_OP_PAIR_DEVICE             0x0014
+struct mgmt_cp_pair_device {
+        bdaddr_t bdaddr;
+        __u8 io_cap;
+} __packed;
+struct mgmt_rp_pair_device {
+        bdaddr_t bdaddr;
+        __u8 status;
+} __packed;
+#define MGMT_OP_USER_CONFIRM_REPLY      0x0015
+struct mgmt_cp_user_confirm_reply {
+        bdaddr_t bdaddr;
+} __packed;
+struct mgmt_rp_user_confirm_reply {
+        bdaddr_t bdaddr;
+        __u8 status;
+} __packed;
+#define MGMT_OP_USER_CONFIRM_NEG_REPLY  0x0016
 #define MGMT_EV_CMD_COMPLETE            0x0001
 struct mgmt_ev_cmd_complete {
        __le16 opcode;
@@ -72,16 +181,56 @@ struct mgmt_ev_cmd_status {
 #define MGMT_EV_CONTROLLER_ERROR        0x0003
 struct mgmt_ev_controller_error {
-        __le16 index;
        __u8 error_code;
 } __packed;
 #define MGMT_EV_INDEX_ADDED             0x0004
-struct mgmt_ev_index_added {
-        __le16 index;
-} __packed;
 #define MGMT_EV_INDEX_REMOVED           0x0005
-struct mgmt_ev_index_removed {
-        __le16 index;
+#define MGMT_EV_POWERED                 0x0006
+#define MGMT_EV_DISCOVERABLE            0x0007
+#define MGMT_EV_CONNECTABLE             0x0008
+#define MGMT_EV_PAIRABLE                0x0009
+#define MGMT_EV_NEW_KEY                 0x000A
+struct mgmt_ev_new_key {
+        struct mgmt_key_info key;
+        __u8 old_key_type;
+} __packed;
+#define MGMT_EV_CONNECTED               0x000B
+struct mgmt_ev_connected {
+        bdaddr_t bdaddr;
+} __packed;
+#define MGMT_EV_DISCONNECTED            0x000C
+struct mgmt_ev_disconnected {
+        bdaddr_t bdaddr;
+} __packed;
+#define MGMT_EV_CONNECT_FAILED          0x000D
+struct mgmt_ev_connect_failed {
+        bdaddr_t bdaddr;
+        __u8 status;
+} __packed;
+#define MGMT_EV_PIN_CODE_REQUEST        0x000E
+struct mgmt_ev_pin_code_request {
+        bdaddr_t bdaddr;
+} __packed;
+#define MGMT_EV_USER_CONFIRM_REQUEST    0x000F
+struct mgmt_ev_user_confirm_request {
+        bdaddr_t bdaddr;
+        __le32 value;
+} __packed;
+#define MGMT_EV_AUTH_FAILED             0x0010
+struct mgmt_ev_auth_failed {
+        bdaddr_t bdaddr;
+        __u8 status;
 } __packed;
diff --git a/include/net/bluetooth/smp.h b/include/net/bluetooth/smp.h
new file mode 100644
index 000000000000..8f2edbf979dc
--- /dev/null
+++ b/include/net/bluetooth/smp.h
@@ -0,0 +1,76 @@
+#ifndef __SMP_H
+#define __SMP_H
+struct smp_command_hdr {
+        __u8    code;
+} __packed;
+#define SMP_CMD_PAIRING_REQ     0x01
+#define SMP_CMD_PAIRING_RSP     0x02
+struct smp_cmd_pairing {
+        __u8    io_capability;
+        __u8    oob_flag;
+        __u8    auth_req;
+        __u8    max_key_size;
+        __u8    init_key_dist;
+        __u8    resp_key_dist;
+} __packed;
+#define SMP_CMD_PAIRING_CONFIRM 0x03
+struct smp_cmd_pairing_confirm {
+        __u8    confirm_val[16];
+} __packed;
+#define SMP_CMD_PAIRING_RANDOM  0x04
+struct smp_cmd_pairing_random {
+        __u8    rand_val[16];
+} __packed;
+#define SMP_CMD_PAIRING_FAIL    0x05
+struct smp_cmd_pairing_fail {
+        __u8    reason;
+} __packed;
+#define SMP_CMD_ENCRYPT_INFO    0x06
+struct smp_cmd_encrypt_info {
+        __u8    ltk[16];
+} __packed;
+#define SMP_CMD_MASTER_IDENT    0x07
+struct smp_cmd_master_ident {
+        __u16   ediv;
+        __u8    rand[8];
+} __packed;
+#define SMP_CMD_IDENT_INFO      0x08
+struct smp_cmd_ident_info {
+        __u8    irk[16];
+} __packed;
+#define SMP_CMD_IDENT_ADDR_INFO 0x09
+struct smp_cmd_ident_addr_info {
+        __u8    addr_type;
+        bdaddr_t bdaddr;
+} __packed;
+#define SMP_CMD_SIGN_INFO       0x0a
+struct smp_cmd_sign_info {
+        __u8    csrk[16];
+} __packed;
+#define SMP_CMD_SECURITY_REQ    0x0b
+struct smp_cmd_security_req {
+        __u8    auth_req;
+} __packed;
+#define SMP_PASSKEY_ENTRY_FAILED        0x01
+#define SMP_OOB_NOT_AVAIL               0x02
+#define SMP_AUTH_REQUIREMENTS           0x03
+#define SMP_CONFIRM_FAILED              0x04
+#define SMP_PAIRING_NOTSUPP             0x05
+#define SMP_ENC_KEY_SIZE                0x06
+#define SMP_CMD_NOTSUPP         0x07
+#define SMP_UNSPECIFIED         0x08
+#define SMP_REPEATED_ATTEMPTS           0x09
+#endif /* __SMP_H */
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 1322695beb52..60f7876b6da8 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -413,7 +413,7 @@ struct station_parameters {
 * @STATION_INFO_PLID: @plid filled
 * @STATION_INFO_PLINK_STATE: @plink_state filled
 * @STATION_INFO_SIGNAL: @signal filled
- * @STATION_INFO_TX_BITRATE: @tx_bitrate fields are filled
+ * @STATION_INFO_TX_BITRATE: @txrate fields are filled
 *  (tx_bitrate, tx_bitrate_flags and tx_bitrate_mcs)
 * @STATION_INFO_RX_PACKETS: @rx_packets filled
 * @STATION_INFO_TX_PACKETS: @tx_packets filled
@@ -421,6 +421,7 @@ struct station_parameters {
 * @STATION_INFO_TX_FAILED: @tx_failed filled
 * @STATION_INFO_RX_DROP_MISC: @rx_dropped_misc filled
 * @STATION_INFO_SIGNAL_AVG: @signal_avg filled
+ * @STATION_INFO_RX_BITRATE: @rxrate fields are filled
 */
 enum station_info_flags {
        STATION_INFO_INACTIVE_TIME      = 1<<0,
@@ -437,6 +438,7 @@ enum station_info_flags {
        STATION_INFO_TX_FAILED          = 1<<11,
        STATION_INFO_RX_DROP_MISC       = 1<<12,
        STATION_INFO_SIGNAL_AVG         = 1<<13,
+        STATION_INFO_RX_BITRATE         = 1<<14,
 };
 /**
@@ -506,6 +508,7 @@ struct station_info {
        s8 signal;
        s8 signal_avg;
        struct rate_info txrate;
+        struct rate_info rxrate;
        u32 rx_packets;
        u32 tx_packets;
        u32 tx_retries;
@@ -1194,6 +1197,10 @@ struct cfg80211_pmksa {
 *      (also see nl80211.h @NL80211_ATTR_WIPHY_ANTENNA_TX).
 *
 * @get_antenna: Get current antenna configuration from device (tx_ant, rx_ant).
+ *
+ * @set_ringparam: Set tx and rx ring sizes.
+ *
+ * @get_ringparam: Get tx and rx ring current and maximum sizes.
 */
 struct cfg80211_ops {
        int     (*suspend)(struct wiphy *wiphy);
@@ -1361,6 +1368,10 @@ struct cfg80211_ops {
        int     (*set_antenna)(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant);
        int     (*get_antenna)(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant);
+        int     (*set_ringparam)(struct wiphy *wiphy, u32 tx, u32 rx);
+        void    (*get_ringparam)(struct wiphy *wiphy,
+                                 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max);
 };
 /*
@@ -1790,8 +1801,9 @@ static inline void *wdev_priv(struct wireless_dev *wdev)
 /**
 * ieee80211_channel_to_frequency - convert channel number to frequency
 * @chan: channel number
+ * @band: band, necessary due to channel number overlap
 */
-extern int ieee80211_channel_to_frequency(int chan);
+extern int ieee80211_channel_to_frequency(int chan, enum ieee80211_band band);
 /**
 * ieee80211_frequency_to_channel - convert frequency to channel number
diff --git a/include/net/dcbnl.h b/include/net/dcbnl.h
index a8e7852b10ab..e5983c9053dc 100644
--- a/include/net/dcbnl.h
+++ b/include/net/dcbnl.h
@@ -43,6 +43,8 @@ struct dcbnl_rtnl_ops {
        int (*ieee_setpfc) (struct net_device *, struct ieee_pfc *);
        int (*ieee_getapp) (struct net_device *, struct dcb_app *);
        int (*ieee_setapp) (struct net_device *, struct dcb_app *);
+        int (*ieee_peer_getets) (struct net_device *, struct ieee_ets *);
+        int (*ieee_peer_getpfc) (struct net_device *, struct ieee_pfc *);
        /* CEE std */
        u8   (*getstate)(struct net_device *);
@@ -77,7 +79,14 @@ struct dcbnl_rtnl_ops {
        u8   (*getdcbx)(struct net_device *);
        u8   (*setdcbx)(struct net_device *, u8);
+        /* peer apps */
+        int (*peer_getappinfo)(struct net_device *, struct dcb_peer_app_info *,
+                               u16 *);
+        int (*peer_getapptable)(struct net_device *, struct dcb_app *);
+        /* CEE peer */
+        int (*cee_peer_getpg) (struct net_device *, struct cee_pg *);
+        int (*cee_peer_getpfc) (struct net_device *, struct cee_pfc *);
 };
 #endif /* __NET_DCBNL_H__ */
diff --git a/include/net/dn.h b/include/net/dn.h
index a514a3cf4573..298521e0d8a2 100644
--- a/include/net/dn.h
+++ b/include/net/dn.h
@@ -192,10 +192,10 @@ static inline void dn_dn2eth(unsigned char *ethaddr, __le16 addr)
        ethaddr[5] = (__u8)(a >> 8);
 }
-static inline void dn_sk_ports_copy(struct flowi *fl, struct dn_scp *scp)
+static inline void dn_sk_ports_copy(struct flowidn *fld, struct dn_scp *scp)
 {
-        fl->uli_u.dnports.sport = scp->addrloc;
+        fld->fld_sport = scp->addrloc;
-        fl->uli_u.dnports.dport = scp->addrrem;
+        fld->fld_dport = scp->addrrem;
 }
 extern unsigned dn_mss_from_pmtu(struct net_device *dev, int mtu);
diff --git a/include/net/dn_fib.h b/include/net/dn_fib.h
index bbcde3238e58..782ef7cb4930 100644
--- a/include/net/dn_fib.h
+++ b/include/net/dn_fib.h
@@ -98,7 +98,7 @@ struct dn_fib_table {
        int (*delete)(struct dn_fib_table *t, struct rtmsg *r,
                        struct dn_kern_rta *rta, struct nlmsghdr *n,
                        struct netlink_skb_parms *req);
-        int (*lookup)(struct dn_fib_table *t, const struct flowi *fl,
+        int (*lookup)(struct dn_fib_table *t, const struct flowidn *fld,
                        struct dn_fib_res *res);
        int (*flush)(struct dn_fib_table *t);
        int (*dump)(struct dn_fib_table *t, struct sk_buff *skb, struct netlink_callback *cb);
@@ -119,12 +119,12 @@ extern struct dn_fib_info *dn_fib_create_info(const struct rtmsg *r,
                                struct dn_kern_rta *rta, 
                                const struct nlmsghdr *nlh, int *errp);
 extern int dn_fib_semantic_match(int type, struct dn_fib_info *fi, 
-                        const struct flowi *fl,
+                        const struct flowidn *fld,
                        struct dn_fib_res *res);
 extern void dn_fib_release_info(struct dn_fib_info *fi);
 extern __le16 dn_fib_get_attr16(struct rtattr *attr, int attrlen, int type);
 extern void dn_fib_flush(void);
-extern void dn_fib_select_multipath(const struct flowi *fl,
+extern void dn_fib_select_multipath(const struct flowidn *fld,
                                        struct dn_fib_res *res);
 /*
@@ -141,7 +141,7 @@ extern void dn_fib_table_cleanup(void);
 extern void dn_fib_rules_init(void);
 extern void dn_fib_rules_cleanup(void);
 extern unsigned dnet_addr_type(__le16 addr);
-extern int dn_fib_lookup(struct flowi *fl, struct dn_fib_res *res);
+extern int dn_fib_lookup(struct flowidn *fld, struct dn_fib_res *res);
 extern int dn_fib_dump(struct sk_buff *skb, struct netlink_callback *cb);
diff --git a/include/net/dn_route.h b/include/net/dn_route.h
index 9b185df265fb..81712cfa1ddf 100644
--- a/include/net/dn_route.h
+++ b/include/net/dn_route.h
@@ -16,7 +16,7 @@
 *******************************************************************************/
 extern struct sk_buff *dn_alloc_skb(struct sock *sk, int size, gfp_t pri);
-extern int dn_route_output_sock(struct dst_entry **pprt, struct flowi *, struct sock *sk, int flags);
+extern int dn_route_output_sock(struct dst_entry **pprt, struct flowidn *, struct sock *sk, int flags);
 extern int dn_cache_dump(struct sk_buff *skb, struct netlink_callback *cb);
 extern void dn_rt_cache_flush(int delay);
@@ -67,7 +67,7 @@ extern void dn_rt_cache_flush(int delay);
 struct dn_route {
        struct dst_entry dst;
-        struct flowi fl;
+        struct flowidn fld;
        __le16 rt_saddr;
        __le16 rt_daddr;
@@ -82,12 +82,12 @@ struct dn_route {
 static inline bool dn_is_input_route(struct dn_route *rt)
 {
-        return rt->fl.iif != 0;
+        return rt->fld.flowidn_iif != 0;
 }
 static inline bool dn_is_output_route(struct dn_route *rt)
 {
-        return rt->fl.iif == 0;
+        return rt->fld.flowidn_iif == 0;
 }
 extern void dn_route_init(void);
diff --git a/include/net/dst.h b/include/net/dst.h
index 93b0310317be..2a46cbaef92d 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -40,24 +40,10 @@ struct dst_entry {
        struct rcu_head         rcu_head;
        struct dst_entry        *child;
        struct net_device       *dev;
-        short                   error;
+        struct  dst_ops         *ops;
-        short                   obsolete;
+        unsigned long           _metrics;
-        int                     flags;
-#define DST_HOST                0x0001
-#define DST_NOXFRM              0x0002
-#define DST_NOPOLICY            0x0004
-#define DST_NOHASH              0x0008
-#define DST_NOCACHE             0x0010
        unsigned long           expires;
-        unsigned short          header_len;     /* more space at head required */
-        unsigned short          trailer_len;    /* space to reserve at tail */
-        unsigned int            rate_tokens;
-        unsigned long           rate_last;      /* rate limiting for ICMP */
        struct dst_entry        *path;
        struct neighbour        *neighbour;
        struct hh_cache         *hh;
 #ifdef CONFIG_XFRM
@@ -68,17 +54,16 @@ struct dst_entry {
        int                     (*input)(struct sk_buff*);
        int                     (*output)(struct sk_buff*);
-        struct  dst_ops         *ops;
+        short                   error;
+        short                   obsolete;
-        u32                     _metrics[RTAX_MAX];
+        unsigned short          header_len;     /* more space at head required */
+        unsigned short          trailer_len;    /* space to reserve at tail */
-#ifdef CONFIG_NET_CLS_ROUTE
+#ifdef CONFIG_IP_ROUTE_CLASSID
        __u32                   tclassid;
 #else
        __u32                   __pad2;
 #endif
        /*
         * Align __refcnt to a 64 bytes alignment
         * (L1_CACHE_SIZE would be too much)
@@ -93,6 +78,12 @@ struct dst_entry {
        atomic_t                __refcnt;       /* client references    */
        int                     __use;
        unsigned long           lastuse;
+        int                     flags;
+#define DST_HOST                0x0001
+#define DST_NOXFRM              0x0002
+#define DST_NOPOLICY            0x0004
+#define DST_NOHASH              0x0008
+#define DST_NOCACHE             0x0010
        union {
                struct dst_entry        *next;
                struct rtable __rcu     *rt_next;
@@ -103,10 +94,70 @@ struct dst_entry {
 #ifdef __KERNEL__
+extern u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);
+extern const u32 dst_default_metrics[RTAX_MAX];
+#define DST_METRICS_READ_ONLY   0x1UL
+#define __DST_METRICS_PTR(Y)    \
+        ((u32 *)((Y) & ~DST_METRICS_READ_ONLY))
+#define DST_METRICS_PTR(X)      __DST_METRICS_PTR((X)->_metrics)
+static inline bool dst_metrics_read_only(const struct dst_entry *dst)
+{
+        return dst->_metrics & DST_METRICS_READ_ONLY;
+}
+extern void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old);
+static inline void dst_destroy_metrics_generic(struct dst_entry *dst)
+{
+        unsigned long val = dst->_metrics;
+        if (!(val & DST_METRICS_READ_ONLY))
+                __dst_destroy_metrics_generic(dst, val);
+}
+static inline u32 *dst_metrics_write_ptr(struct dst_entry *dst)
+{
+        unsigned long p = dst->_metrics;
+        if (p & DST_METRICS_READ_ONLY)
+                return dst->ops->cow_metrics(dst, p);
+        return __DST_METRICS_PTR(p);
+}
+/* This may only be invoked before the entry has reached global
+ * visibility.
+ */
+static inline void dst_init_metrics(struct dst_entry *dst,
+                                    const u32 *src_metrics,
+                                    bool read_only)
+{
+        dst->_metrics = ((unsigned long) src_metrics) |
+                (read_only ? DST_METRICS_READ_ONLY : 0);
+}
+static inline void dst_copy_metrics(struct dst_entry *dest, const struct dst_entry *src)
+{
+        u32 *dst_metrics = dst_metrics_write_ptr(dest);
+        if (dst_metrics) {
+                u32 *src_metrics = DST_METRICS_PTR(src);
+                memcpy(dst_metrics, src_metrics, RTAX_MAX * sizeof(u32));
+        }
+}
+static inline u32 *dst_metrics_ptr(struct dst_entry *dst)
+{
+        return DST_METRICS_PTR(dst);
+}
 static inline u32
 dst_metric_raw(const struct dst_entry *dst, const int metric)
 {
-        return dst->_metrics[metric-1];
+        u32 *p = DST_METRICS_PTR(dst);
+        return p[metric-1];
 }
 static inline u32
@@ -131,22 +182,10 @@ dst_metric_advmss(const struct dst_entry *dst)
 static inline void dst_metric_set(struct dst_entry *dst, int metric, u32 val)
 {
-        dst->_metrics[metric-1] = val;
+        u32 *p = dst_metrics_write_ptr(dst);
-}
-static inline void dst_import_metrics(struct dst_entry *dst, const u32 *src_metrics)
+        if (p)
-{
+                p[metric-1] = val;
-        memcpy(dst->_metrics, src_metrics, RTAX_MAX * sizeof(u32));
-}
-static inline void dst_copy_metrics(struct dst_entry *dest, const struct dst_entry *src)
-{
-        dst_import_metrics(dest, src->_metrics);
-}
-static inline u32 *dst_metrics_ptr(struct dst_entry *dst)
-{
-        return dst->_metrics;
 }
 static inline u32
@@ -181,8 +220,6 @@ static inline u32
 dst_allfrag(const struct dst_entry *dst)
 {
        int ret = dst_feature(dst,  RTAX_FEATURE_ALLFRAG);
-        /* Yes, _exactly_. This is paranoia. */
-        barrier();
        return ret;
 }
@@ -315,7 +352,7 @@ static inline struct dst_entry *skb_dst_pop(struct sk_buff *skb)
 }
 extern int dst_discard(struct sk_buff *skb);
-extern void * dst_alloc(struct dst_ops * ops);
+extern void *dst_alloc(struct dst_ops * ops, int initial_ref);
 extern void __dst_free(struct dst_entry * dst);
 extern struct dst_entry *dst_destroy(struct dst_entry * dst);
@@ -384,27 +421,22 @@ extern void		dst_init(void);
 /* Flags for xfrm_lookup flags argument. */
 enum {
-        XFRM_LOOKUP_WAIT = 1 << 0,
+        XFRM_LOOKUP_ICMP = 1 << 0,
-        XFRM_LOOKUP_ICMP = 1 << 1,
 };
 struct flowi;
 #ifndef CONFIG_XFRM
-static inline int xfrm_lookup(struct net *net, struct dst_entry **dst_p,
+static inline struct dst_entry *xfrm_lookup(struct net *net,
-                              struct flowi *fl, struct sock *sk, int flags)
+                                            struct dst_entry *dst_orig,
+                                            const struct flowi *fl, struct sock *sk,
+                                            int flags)
 {
-        return 0;
+        return dst_orig;
 } 
-static inline int __xfrm_lookup(struct net *net, struct dst_entry **dst_p,
-                                struct flowi *fl, struct sock *sk, int flags)
-{
-        return 0;
-}
 #else
-extern int xfrm_lookup(struct net *net, struct dst_entry **dst_p,
+extern struct dst_entry *xfrm_lookup(struct net *net, struct dst_entry *dst_orig,
-                       struct flowi *fl, struct sock *sk, int flags);
+                                     const struct flowi *fl, struct sock *sk,
-extern int __xfrm_lookup(struct net *net, struct dst_entry **dst_p,
+                                     int flags);
-                         struct flowi *fl, struct sock *sk, int flags);
 #endif
 #endif
diff --git a/include/net/dst_ops.h b/include/net/dst_ops.h
index 21a320b8708e..dc0746328947 100644
--- a/include/net/dst_ops.h
+++ b/include/net/dst_ops.h
@@ -18,6 +18,7 @@ struct dst_ops {
        struct dst_entry *      (*check)(struct dst_entry *, __u32 cookie);
        unsigned int            (*default_advmss)(const struct dst_entry *);
        unsigned int            (*default_mtu)(const struct dst_entry *);
+        u32 *                   (*cow_metrics)(struct dst_entry *, unsigned long);
        void                    (*destroy)(struct dst_entry *);
        void                    (*ifdown)(struct dst_entry *,
                                          struct net_device *dev, int how);
diff --git a/include/net/flow.h b/include/net/flow.h
index 240b7f356c71..7fe5a0f9483a 100644
--- a/include/net/flow.h
+++ b/include/net/flow.h
@@ -10,78 +10,136 @@
 #include <linux/in6.h>
 #include <asm/atomic.h>
-struct flowi {
+struct flowi_common {
-        int     oif;
+        int     flowic_oif;
-        int     iif;
+        int     flowic_iif;
-        __u32   mark;
+        __u32   flowic_mark;
+        __u8    flowic_tos;
+        __u8    flowic_scope;
+        __u8    flowic_proto;
+        __u8    flowic_flags;
+#define FLOWI_FLAG_ANYSRC               0x01
+#define FLOWI_FLAG_PRECOW_METRICS       0x02
+#define FLOWI_FLAG_CAN_SLEEP            0x04
+        __u32   flowic_secid;
+};
+union flowi_uli {
+        struct {
+                __be16  sport;
+                __be16  dport;
+        } ports;
+        struct {
+                __u8    type;
+                __u8    code;
+        } icmpt;
+        struct {
+                __le16  sport;
+                __le16  dport;
+        } dnports;
+        __be32          spi;
+        __be32          gre_key;
+        struct {
+                __u8    type;
+        } mht;
+};
+struct flowi4 {
+        struct flowi_common     __fl_common;
+#define flowi4_oif              __fl_common.flowic_oif
+#define flowi4_iif              __fl_common.flowic_iif
+#define flowi4_mark             __fl_common.flowic_mark
+#define flowi4_tos              __fl_common.flowic_tos
+#define flowi4_scope            __fl_common.flowic_scope
+#define flowi4_proto            __fl_common.flowic_proto
+#define flowi4_flags            __fl_common.flowic_flags
+#define flowi4_secid            __fl_common.flowic_secid
+        __be32                  daddr;
+        __be32                  saddr;
+        union flowi_uli         uli;
+#define fl4_sport               uli.ports.sport
+#define fl4_dport               uli.ports.dport
+#define fl4_icmp_type           uli.icmpt.type
+#define fl4_icmp_code           uli.icmpt.code
+#define fl4_ipsec_spi           uli.spi
+#define fl4_mh_type             uli.mht.type
+#define fl4_gre_key             uli.gre_key
+};
+struct flowi6 {
+        struct flowi_common     __fl_common;
+#define flowi6_oif              __fl_common.flowic_oif
+#define flowi6_iif              __fl_common.flowic_iif
+#define flowi6_mark             __fl_common.flowic_mark
+#define flowi6_tos              __fl_common.flowic_tos
+#define flowi6_scope            __fl_common.flowic_scope
+#define flowi6_proto            __fl_common.flowic_proto
+#define flowi6_flags            __fl_common.flowic_flags
+#define flowi6_secid            __fl_common.flowic_secid
+        struct in6_addr         daddr;
+        struct in6_addr         saddr;
+        __be32                  flowlabel;
+        union flowi_uli         uli;
+#define fl6_sport               uli.ports.sport
+#define fl6_dport               uli.ports.dport
+#define fl6_icmp_type           uli.icmpt.type
+#define fl6_icmp_code           uli.icmpt.code
+#define fl6_ipsec_spi           uli.spi
+#define fl6_mh_type             uli.mht.type
+#define fl6_gre_key             uli.gre_key
+};
+struct flowidn {
+        struct flowi_common     __fl_common;
+#define flowidn_oif             __fl_common.flowic_oif
+#define flowidn_iif             __fl_common.flowic_iif
+#define flowidn_mark            __fl_common.flowic_mark
+#define flowidn_scope           __fl_common.flowic_scope
+#define flowidn_proto           __fl_common.flowic_proto
+#define flowidn_flags           __fl_common.flowic_flags
+        __le16                  daddr;
+        __le16                  saddr;
+        union flowi_uli         uli;
+#define fld_sport               uli.ports.sport
+#define fld_dport               uli.ports.dport
+};
+struct flowi {
        union {
-                struct {
+                struct flowi_common     __fl_common;
-                        __be32                  daddr;
+                struct flowi4           ip4;
-                        __be32                  saddr;
+                struct flowi6           ip6;
-                        __u8                    tos;
+                struct flowidn          dn;
-                        __u8                    scope;
+        } u;
-                } ip4_u;
+#define flowi_oif       u.__fl_common.flowic_oif
-                
+#define flowi_iif       u.__fl_common.flowic_iif
-                struct {
+#define flowi_mark      u.__fl_common.flowic_mark
-                        struct in6_addr         daddr;
+#define flowi_tos       u.__fl_common.flowic_tos
-                        struct in6_addr         saddr;
+#define flowi_scope     u.__fl_common.flowic_scope
-                        __be32                  flowlabel;
+#define flowi_proto     u.__fl_common.flowic_proto
-                } ip6_u;
+#define flowi_flags     u.__fl_common.flowic_flags
+#define flowi_secid     u.__fl_common.flowic_secid
-                struct {
-                        __le16                  daddr;
-                        __le16                  saddr;
-                        __u8                    scope;
-                } dn_u;
-        } nl_u;
-#define fld_dst         nl_u.dn_u.daddr
-#define fld_src         nl_u.dn_u.saddr
-#define fld_scope       nl_u.dn_u.scope
-#define fl6_dst         nl_u.ip6_u.daddr
-#define fl6_src         nl_u.ip6_u.saddr
-#define fl6_flowlabel   nl_u.ip6_u.flowlabel
-#define fl4_dst         nl_u.ip4_u.daddr
-#define fl4_src         nl_u.ip4_u.saddr
-#define fl4_tos         nl_u.ip4_u.tos
-#define fl4_scope       nl_u.ip4_u.scope
-        __u8    proto;
-        __u8    flags;
-#define FLOWI_FLAG_ANYSRC 0x01
-        union {
-                struct {
-                        __be16  sport;
-                        __be16  dport;
-                } ports;
-                struct {
-                        __u8    type;
-                        __u8    code;
-                } icmpt;
-                struct {
-                        __le16  sport;
-                        __le16  dport;
-                } dnports;
-                __be32          spi;
-                __be32          gre_key;
-                struct {
-                        __u8    type;
-                } mht;
-        } uli_u;
-#define fl_ip_sport     uli_u.ports.sport
-#define fl_ip_dport     uli_u.ports.dport
-#define fl_icmp_type    uli_u.icmpt.type
-#define fl_icmp_code    uli_u.icmpt.code
-#define fl_ipsec_spi    uli_u.spi
-#define fl_mh_type      uli_u.mht.type
-#define fl_gre_key      uli_u.gre_key
-        __u32           secid;  /* used by xfrm; see secid.txt */
 } __attribute__((__aligned__(BITS_PER_LONG/8)));
+static inline struct flowi *flowi4_to_flowi(struct flowi4 *fl4)
+{
+        return container_of(fl4, struct flowi, u.ip4);
+}
+static inline struct flowi *flowi6_to_flowi(struct flowi6 *fl6)
+{
+        return container_of(fl6, struct flowi, u.ip6);
+}
+static inline struct flowi *flowidn_to_flowi(struct flowidn *fldn)
+{
+        return container_of(fldn, struct flowi, u.dn);
+}
 #define FLOW_DIR_IN     0
 #define FLOW_DIR_OUT    1
 #define FLOW_DIR_FWD    2
@@ -101,20 +159,14 @@ struct flow_cache_ops {
 };
 typedef struct flow_cache_object *(*flow_resolve_t)(
-                struct net *net, struct flowi *key, u16 family,
+                struct net *net, const struct flowi *key, u16 family,
                u8 dir, struct flow_cache_object *oldobj, void *ctx);
 extern struct flow_cache_object *flow_cache_lookup(
-                struct net *net, struct flowi *key, u16 family,
+                struct net *net, const struct flowi *key, u16 family,
                u8 dir, flow_resolve_t resolver, void *ctx);
 extern void flow_cache_flush(void);
 extern atomic_t flow_cache_genid;
-static inline int flow_cache_uli_match(struct flowi *fl1, struct flowi *fl2)
-{
-        return (fl1->proto == fl2->proto &&
-                !memcmp(&fl1->uli_u, &fl2->uli_u, sizeof(fl1->uli_u)));
-}
 #endif
diff --git a/include/net/icmp.h b/include/net/icmp.h
index 6e991e0d0d6f..f0698b955b73 100644
--- a/include/net/icmp.h
+++ b/include/net/icmp.h
@@ -45,7 +45,4 @@ extern int	icmp_ioctl(struct sock *sk, int cmd, unsigned long arg);
 extern int      icmp_init(void);
 extern void     icmp_out_count(struct net *net, unsigned char type);
-/* Move into dst.h ? */
-extern int      xrlim_allow(struct dst_entry *dst, int timeout);
 #endif  /* _ICMP_H */
diff --git a/include/net/ieee80211_radiotap.h b/include/net/ieee80211_radiotap.h
index af49f8ab7f81..b0be5fb9de19 100644
--- a/include/net/ieee80211_radiotap.h
+++ b/include/net/ieee80211_radiotap.h
@@ -178,6 +178,11 @@ struct ieee80211_radiotap_header {
 *
 *     Number of unicast retries a transmitted frame used.
 *
+ * IEEE80211_RADIOTAP_MCS       u8, u8, u8              unitless
+ *
+ *     Contains a bitmap of known fields/flags, the flags, and
+ *     the MCS index.
+ *
 */
 enum ieee80211_radiotap_type {
        IEEE80211_RADIOTAP_TSFT = 0,
@@ -199,6 +204,8 @@ enum ieee80211_radiotap_type {
        IEEE80211_RADIOTAP_RTS_RETRIES = 16,
        IEEE80211_RADIOTAP_DATA_RETRIES = 17,
+        IEEE80211_RADIOTAP_MCS = 19,
        /* valid in every it_present bitmap, even vendor namespaces */
        IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE = 29,
        IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
@@ -245,6 +252,24 @@ enum ieee80211_radiotap_type {
 #define IEEE80211_RADIOTAP_F_TX_CTS     0x0002  /* used cts 'protection' */
 #define IEEE80211_RADIOTAP_F_TX_RTS     0x0004  /* used rts/cts handshake */
+/* For IEEE80211_RADIOTAP_MCS */
+#define IEEE80211_RADIOTAP_MCS_HAVE_BW          0x01
+#define IEEE80211_RADIOTAP_MCS_HAVE_MCS         0x02
+#define IEEE80211_RADIOTAP_MCS_HAVE_GI          0x04
+#define IEEE80211_RADIOTAP_MCS_HAVE_FMT         0x08
+#define IEEE80211_RADIOTAP_MCS_HAVE_FEC         0x10
+#define IEEE80211_RADIOTAP_MCS_BW_MASK          0x03
+#define         IEEE80211_RADIOTAP_MCS_BW_20    0
+#define         IEEE80211_RADIOTAP_MCS_BW_40    1
+#define         IEEE80211_RADIOTAP_MCS_BW_20L   2
+#define         IEEE80211_RADIOTAP_MCS_BW_20U   3
+#define IEEE80211_RADIOTAP_MCS_SGI              0x04
+#define IEEE80211_RADIOTAP_MCS_FMT_GF           0x08
+#define IEEE80211_RADIOTAP_MCS_FEC_LDPC         0x10
 /* Ugly macro to convert literal channel numbers into their mhz equivalents
 * There are certianly some conditions that will break this (like feeding it '30')
 * but they shouldn't arise since nothing talks on channel 30. */
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index 8181498fa96c..7a37369f8ea3 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -86,6 +86,19 @@ static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
        return (struct inet_request_sock *)sk;
 }
+struct inet_cork {
+        unsigned int            flags;
+        unsigned int            fragsize;
+        struct ip_options       *opt;
+        struct dst_entry        *dst;
+        int                     length; /* Total length of all frames */
+        __be32                  addr;
+        struct flowi            fl;
+        struct page             *page;
+        u32                     off;
+        u8                      tx_flags;
+};
 struct ip_mc_socklist;
 struct ipv6_pinfo;
 struct rtable;
@@ -143,15 +156,7 @@ struct inet_sock {
        int                     mc_index;
        __be32                  mc_addr;
        struct ip_mc_socklist __rcu     *mc_list;
-        struct {
+        struct inet_cork        cork;
-                unsigned int            flags;
-                unsigned int            fragsize;
-                struct ip_options       *opt;
-                struct dst_entry        *dst;
-                int                     length; /* Total length of all frames */
-                __be32                  addr;
-                struct flowi            fl;
-        } cork;
 };
 #define IPCORK_OPT      1       /* ip-options has been held in ipcork.opt */
@@ -219,7 +224,13 @@ static inline struct request_sock *inet_reqsk_alloc(struct request_sock_ops *ops
 static inline __u8 inet_sk_flowi_flags(const struct sock *sk)
 {
-        return inet_sk(sk)->transparent ? FLOWI_FLAG_ANYSRC : 0;
+        __u8 flags = 0;
+        if (inet_sk(sk)->transparent)
+                flags |= FLOWI_FLAG_ANYSRC;
+        if (sk->sk_protocol == IPPROTO_TCP)
+                flags |= FLOWI_FLAG_PRECOW_METRICS;
+        return flags;
 }
 #endif  /* _INET_SOCK_H */
diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h
index 599d96e74114..e6dd8da6b2ad 100644
--- a/include/net/inetpeer.h
+++ b/include/net/inetpeer.h
@@ -11,15 +11,20 @@
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/spinlock.h>
+#include <linux/rtnetlink.h>
 #include <net/ipv6.h>
 #include <asm/atomic.h>
-struct inetpeer_addr {
+struct inetpeer_addr_base {
        union {
-                __be32          a4;
+                __be32                  a4;
-                __be32          a6[4];
+                __be32                  a6[4];
        };
-        __u16   family;
+};
+struct inetpeer_addr {
+        struct inetpeer_addr_base       addr;
+        __u16                           family;
 };
 struct inet_peer {
@@ -33,15 +38,22 @@ struct inet_peer {
        atomic_t                refcnt;
        /*
         * Once inet_peer is queued for deletion (refcnt == -1), following fields
-         * are not available: rid, ip_id_count, tcp_ts, tcp_ts_stamp
+         * are not available: rid, ip_id_count, tcp_ts, tcp_ts_stamp, metrics
-         * We can share memory with rcu_head to keep inet_peer small
+         * We can share memory with rcu_head to help keep inet_peer small.
         */
        union {
                struct {
-                        atomic_t        rid;            /* Frag reception counter */
+                        atomic_t                        rid;            /* Frag reception counter */
-                        atomic_t        ip_id_count;    /* IP ID for the next packet */
+                        atomic_t                        ip_id_count;    /* IP ID for the next packet */
-                        __u32           tcp_ts;
+                        __u32                           tcp_ts;
-                        __u32           tcp_ts_stamp;
+                        __u32                           tcp_ts_stamp;
+                        u32                             metrics[RTAX_MAX];
+                        u32                             rate_tokens;    /* rate limiting for ICMP */
+                        unsigned long                   rate_last;
+                        unsigned long                   pmtu_expires;
+                        u32                             pmtu_orig;
+                        u32                             pmtu_learned;
+                        struct inetpeer_addr_base       redirect_learned;
                };
                struct rcu_head         rcu;
        };
@@ -49,6 +61,13 @@ struct inet_peer {
 void                    inet_initpeers(void) __init;
+#define INETPEER_METRICS_NEW    (~(u32) 0)
+static inline bool inet_metrics_new(const struct inet_peer *p)
+{
+        return p->metrics[RTAX_LOCK-1] == INETPEER_METRICS_NEW;
+}
 /* can be called with or without local BH being disabled */
 struct inet_peer        *inet_getpeer(struct inetpeer_addr *daddr, int create);
@@ -56,7 +75,7 @@ static inline struct inet_peer *inet_getpeer_v4(__be32 v4daddr, int create)
 {
        struct inetpeer_addr daddr;
-        daddr.a4 = v4daddr;
+        daddr.addr.a4 = v4daddr;
        daddr.family = AF_INET;
        return inet_getpeer(&daddr, create);
 }
@@ -65,13 +84,14 @@ static inline struct inet_peer *inet_getpeer_v6(struct in6_addr *v6daddr, int cr
 {
        struct inetpeer_addr daddr;
-        ipv6_addr_copy((struct in6_addr *)daddr.a6, v6daddr);
+        ipv6_addr_copy((struct in6_addr *)daddr.addr.a6, v6daddr);
        daddr.family = AF_INET6;
        return inet_getpeer(&daddr, create);
 }
 /* can be called from BH context or outside */
 extern void inet_putpeer(struct inet_peer *p);
+extern bool inet_peer_xrlim_allow(struct inet_peer *peer, int timeout);
 /*
 * temporary check to make sure we dont access rid, ip_id_count, tcp_ts,
diff --git a/include/net/ip.h b/include/net/ip.h
index 67fac78a186b..a4f631108c54 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -116,8 +116,24 @@ extern int		ip_append_data(struct sock *sk,
 extern int              ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb);
 extern ssize_t          ip_append_page(struct sock *sk, struct page *page,
                                int offset, size_t size, int flags);
+extern struct sk_buff  *__ip_make_skb(struct sock *sk,
+                                      struct sk_buff_head *queue,
+                                      struct inet_cork *cork);
+extern int              ip_send_skb(struct sk_buff *skb);
 extern int              ip_push_pending_frames(struct sock *sk);
 extern void             ip_flush_pending_frames(struct sock *sk);
+extern struct sk_buff  *ip_make_skb(struct sock *sk,
+                                    int getfrag(void *from, char *to, int offset, int len,
+                                                int odd, struct sk_buff *skb),
+                                    void *from, int length, int transhdrlen,
+                                    struct ipcm_cookie *ipc,
+                                    struct rtable **rtp,
+                                    unsigned int flags);
+static inline struct sk_buff *ip_finish_skb(struct sock *sk)
+{
+        return __ip_make_skb(sk, &sk->sk_write_queue, &inet_sk(sk)->cork);
+}
 /* datagram.c */
 extern int              ip4_datagram_connect(struct sock *sk, 
diff --git a/include/net/ip6_fib.h b/include/net/ip6_fib.h
index 708ff7cb8806..bc3cde0a810c 100644
--- a/include/net/ip6_fib.h
+++ b/include/net/ip6_fib.h
@@ -108,6 +108,7 @@ struct rt6_info {
        u32                             rt6i_flags;
        struct rt6key                   rt6i_src;
        u32                             rt6i_metric;
+        u32                             rt6i_peer_genid;
        struct inet6_dev                *rt6i_idev;
        struct inet_peer                *rt6i_peer;
@@ -182,7 +183,7 @@ struct fib6_table {
 typedef struct rt6_info *(*pol_lookup_t)(struct net *,
                                         struct fib6_table *,
-                                         struct flowi *, int);
+                                         struct flowi6 *, int);
 /*
 *      exported functions
@@ -191,7 +192,7 @@ typedef struct rt6_info *(*pol_lookup_t)(struct net *,
 extern struct fib6_table        *fib6_get_table(struct net *net, u32 id);
 extern struct fib6_table        *fib6_new_table(struct net *net, u32 id);
 extern struct dst_entry         *fib6_rule_lookup(struct net *net,
-                                                  struct flowi *fl, int flags,
+                                                  struct flowi6 *fl6, int flags,
                                                  pol_lookup_t lookup);
 extern struct fib6_node         *fib6_lookup(struct fib6_node *root,
diff --git a/include/net/ip6_route.h b/include/net/ip6_route.h
index 8552f0a2e854..642a80bb42cf 100644
--- a/include/net/ip6_route.h
+++ b/include/net/ip6_route.h
@@ -71,7 +71,7 @@ extern void			ip6_route_input(struct sk_buff *skb);
 extern struct dst_entry *       ip6_route_output(struct net *net,
                                                 struct sock *sk,
-                                                 struct flowi *fl);
+                                                 struct flowi6 *fl6);
 extern int                      ip6_route_init(void);
 extern void                     ip6_route_cleanup(void);
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index 07bdb5e9e8ac..a1a858035913 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -51,15 +51,17 @@ struct fib_nh {
        struct fib_info         *nh_parent;
        unsigned                nh_flags;
        unsigned char           nh_scope;
+        unsigned char           nh_cfg_scope;
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
        int                     nh_weight;
        int                     nh_power;
 #endif
-#ifdef CONFIG_NET_CLS_ROUTE
+#ifdef CONFIG_IP_ROUTE_CLASSID
        __u32                   nh_tclassid;
 #endif
        int                     nh_oif;
        __be32                  nh_gw;
+        __be32                  nh_saddr;
 };
 /*
@@ -77,7 +79,7 @@ struct fib_info {
        int                     fib_protocol;
        __be32                  fib_prefsrc;
        u32                     fib_priority;
-        u32                     fib_metrics[RTAX_MAX];
+        u32                     *fib_metrics;
 #define fib_mtu fib_metrics[RTAX_MTU-1]
 #define fib_window fib_metrics[RTAX_WINDOW-1]
 #define fib_rtt fib_metrics[RTAX_RTT-1]
@@ -96,12 +98,15 @@ struct fib_info {
 struct fib_rule;
 #endif
+struct fib_table;
 struct fib_result {
        unsigned char   prefixlen;
        unsigned char   nh_sel;
        unsigned char   type;
        unsigned char   scope;
        struct fib_info *fi;
+        struct fib_table *table;
+        struct list_head *fa_head;
 #ifdef CONFIG_IP_MULTIPLE_TABLES
        struct fib_rule *r;
 #endif
@@ -136,11 +141,13 @@ struct fib_result_nl {
 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
-#define FIB_RES_PREFSRC(res)            ((res).fi->fib_prefsrc ? : __fib_res_prefsrc(&res))
+#define FIB_RES_SADDR(res)              (FIB_RES_NH(res).nh_saddr)
 #define FIB_RES_GW(res)                 (FIB_RES_NH(res).nh_gw)
 #define FIB_RES_DEV(res)                (FIB_RES_NH(res).nh_dev)
 #define FIB_RES_OIF(res)                (FIB_RES_NH(res).nh_oif)
+#define FIB_RES_PREFSRC(res)            ((res).fi->fib_prefsrc ? : FIB_RES_SADDR(res))
 struct fib_table {
        struct hlist_node tb_hlist;
        u32             tb_id;
@@ -148,16 +155,13 @@ struct fib_table {
        unsigned char   tb_data[0];
 };
-extern int fib_table_lookup(struct fib_table *tb, const struct flowi *flp,
+extern int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
                            struct fib_result *res, int fib_flags);
 extern int fib_table_insert(struct fib_table *, struct fib_config *);
 extern int fib_table_delete(struct fib_table *, struct fib_config *);
 extern int fib_table_dump(struct fib_table *table, struct sk_buff *skb,
                          struct netlink_callback *cb);
 extern int fib_table_flush(struct fib_table *table);
-extern void fib_table_select_default(struct fib_table *table,
-                                     const struct flowi *flp,
-                                     struct fib_result *res);
 extern void fib_free_table(struct fib_table *tb);
@@ -182,7 +186,7 @@ static inline struct fib_table *fib_new_table(struct net *net, u32 id)
        return fib_get_table(net, id);
 }
-static inline int fib_lookup(struct net *net, const struct flowi *flp,
+static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
                             struct fib_result *res)
 {
        struct fib_table *table;
@@ -201,11 +205,11 @@ static inline int fib_lookup(struct net *net, const struct flowi *flp,
 extern int __net_init fib4_rules_init(struct net *net);
 extern void __net_exit fib4_rules_exit(struct net *net);
-#ifdef CONFIG_NET_CLS_ROUTE
+#ifdef CONFIG_IP_ROUTE_CLASSID
-extern u32 fib_rules_tclass(struct fib_result *res);
+extern u32 fib_rules_tclass(const struct fib_result *res);
 #endif
-extern int fib_lookup(struct net *n, struct flowi *flp, struct fib_result *res);
+extern int fib_lookup(struct net *n, struct flowi4 *flp, struct fib_result *res);
 extern struct fib_table *fib_new_table(struct net *net, u32 id);
 extern struct fib_table *fib_get_table(struct net *net, u32 id);
@@ -218,24 +222,23 @@ extern void		ip_fib_init(void);
 extern int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
                               struct net_device *dev, __be32 *spec_dst,
                               u32 *itag, u32 mark);
-extern void fib_select_default(struct net *net, const struct flowi *flp,
+extern void fib_select_default(struct fib_result *res);
-                               struct fib_result *res);
 /* Exported by fib_semantics.c */
 extern int ip_fib_check_default(__be32 gw, struct net_device *dev);
 extern int fib_sync_down_dev(struct net_device *dev, int force);
 extern int fib_sync_down_addr(struct net *net, __be32 local);
+extern void fib_update_nh_saddrs(struct net_device *dev);
 extern int fib_sync_up(struct net_device *dev);
-extern __be32  __fib_res_prefsrc(struct fib_result *res);
+extern void fib_select_multipath(struct fib_result *res);
-extern void fib_select_multipath(const struct flowi *flp, struct fib_result *res);
-/* Exported by fib_{hash|trie}.c */
+/* Exported by fib_trie.c */
-extern void fib_hash_init(void);
+extern void fib_trie_init(void);
-extern struct fib_table *fib_hash_table(u32 id);
+extern struct fib_table *fib_trie_table(u32 id);
-static inline void fib_combine_itag(u32 *itag, struct fib_result *res)
+static inline void fib_combine_itag(u32 *itag, const struct fib_result *res)
 {
-#ifdef CONFIG_NET_CLS_ROUTE
+#ifdef CONFIG_IP_ROUTE_CLASSID
 #ifdef CONFIG_IP_MULTIPLE_TABLES
        u32 rtag;
 #endif
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h
index b7bbd6c28cfa..272f59336b73 100644
--- a/include/net/ip_vs.h
+++ b/include/net/ip_vs.h
@@ -28,6 +28,80 @@
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 #include <net/netfilter/nf_conntrack.h>
 #endif
+#include <net/net_namespace.h>          /* Netw namespace */
+/*
+ * Generic access of ipvs struct
+ */
+static inline struct netns_ipvs *net_ipvs(struct net* net)
+{
+        return net->ipvs;
+}
+/*
+ * Get net ptr from skb in traffic cases
+ * use skb_sknet when call is from userland (ioctl or netlink)
+ */
+static inline struct net *skb_net(const struct sk_buff *skb)
+{
+#ifdef CONFIG_NET_NS
+#ifdef CONFIG_IP_VS_DEBUG
+        /*
+         * This is used for debug only.
+         * Start with the most likely hit
+         * End with BUG
+         */
+        if (likely(skb->dev && skb->dev->nd_net))
+                return dev_net(skb->dev);
+        if (skb_dst(skb)->dev)
+                return dev_net(skb_dst(skb)->dev);
+        WARN(skb->sk, "Maybe skb_sknet should be used in %s() at line:%d\n",
+                      __func__, __LINE__);
+        if (likely(skb->sk && skb->sk->sk_net))
+                return sock_net(skb->sk);
+        pr_err("There is no net ptr to find in the skb in %s() line:%d\n",
+                __func__, __LINE__);
+        BUG();
+#else
+        return dev_net(skb->dev ? : skb_dst(skb)->dev);
+#endif
+#else
+        return &init_net;
+#endif
+}
+static inline struct net *skb_sknet(const struct sk_buff *skb)
+{
+#ifdef CONFIG_NET_NS
+#ifdef CONFIG_IP_VS_DEBUG
+        /* Start with the most likely hit */
+        if (likely(skb->sk && skb->sk->sk_net))
+                return sock_net(skb->sk);
+        WARN(skb->dev, "Maybe skb_net should be used instead in %s() line:%d\n",
+                       __func__, __LINE__);
+        if (likely(skb->dev && skb->dev->nd_net))
+                return dev_net(skb->dev);
+        pr_err("There is no net ptr to find in the skb in %s() line:%d\n",
+                __func__, __LINE__);
+        BUG();
+#else
+        return sock_net(skb->sk);
+#endif
+#else
+        return &init_net;
+#endif
+}
+/*
+ * This one needed for single_open_net since net is stored directly in
+ * private not as a struct i.e. seq_file_net cant be used.
+ */
+static inline struct net *seq_file_single_net(struct seq_file *seq)
+{
+#ifdef CONFIG_NET_NS
+        return (struct net *)seq->private;
+#else
+        return &init_net;
+#endif
+}
 /* Connections' size value needed by ip_vs_ctl.c */
 extern int ip_vs_conn_tab_size;
@@ -258,6 +332,23 @@ struct ip_vs_seq {
                                                   before last resized pkt */
 };
+/*
+ * counters per cpu
+ */
+struct ip_vs_counters {
+        __u32           conns;          /* connections scheduled */
+        __u32           inpkts;         /* incoming packets */
+        __u32           outpkts;        /* outgoing packets */
+        __u64           inbytes;        /* incoming bytes */
+        __u64           outbytes;       /* outgoing bytes */
+};
+/*
+ * Stats per cpu
+ */
+struct ip_vs_cpu_stats {
+        struct ip_vs_counters   ustats;
+        struct u64_stats_sync   syncp;
+};
 /*
 *      IPVS statistics objects
@@ -279,10 +370,11 @@ struct ip_vs_estimator {
 };
 struct ip_vs_stats {
-        struct ip_vs_stats_user ustats;         /* statistics */
+        struct ip_vs_stats_user ustats;         /* statistics */
        struct ip_vs_estimator  est;            /* estimator */
+        struct ip_vs_cpu_stats  *cpustats;      /* per cpu counters */
-        spinlock_t              lock;           /* spin lock */
+        spinlock_t              lock;           /* spin lock */
+        struct ip_vs_stats_user ustats0;        /* reset values */
 };
 struct dst_entry;
@@ -290,6 +382,7 @@ struct iphdr;
 struct ip_vs_conn;
 struct ip_vs_app;
 struct sk_buff;
+struct ip_vs_proto_data;
 struct ip_vs_protocol {
        struct ip_vs_protocol   *next;
@@ -297,21 +390,22 @@ struct ip_vs_protocol {
        u16                     protocol;
        u16                     num_states;
        int                     dont_defrag;
-        atomic_t                appcnt;         /* counter of proto app incs */
-        int                     *timeout_table; /* protocol timeout table */
        void (*init)(struct ip_vs_protocol *pp);
        void (*exit)(struct ip_vs_protocol *pp);
+        void (*init_netns)(struct net *net, struct ip_vs_proto_data *pd);
+        void (*exit_netns)(struct net *net, struct ip_vs_proto_data *pd);
        int (*conn_schedule)(int af, struct sk_buff *skb,
-                             struct ip_vs_protocol *pp,
+                             struct ip_vs_proto_data *pd,
                             int *verdict, struct ip_vs_conn **cpp);
        struct ip_vs_conn *
        (*conn_in_get)(int af,
                       const struct sk_buff *skb,
-                       struct ip_vs_protocol *pp,
                       const struct ip_vs_iphdr *iph,
                       unsigned int proto_off,
                       int inverse);
@@ -319,7 +413,6 @@ struct ip_vs_protocol {
        struct ip_vs_conn *
        (*conn_out_get)(int af,
                        const struct sk_buff *skb,
-                        struct ip_vs_protocol *pp,
                        const struct ip_vs_iphdr *iph,
                        unsigned int proto_off,
                        int inverse);
@@ -337,11 +430,11 @@ struct ip_vs_protocol {
        int (*state_transition)(struct ip_vs_conn *cp, int direction,
                                const struct sk_buff *skb,
-                                struct ip_vs_protocol *pp);
+                                struct ip_vs_proto_data *pd);
-        int (*register_app)(struct ip_vs_app *inc);
+        int (*register_app)(struct net *net, struct ip_vs_app *inc);
-        void (*unregister_app)(struct ip_vs_app *inc);
+        void (*unregister_app)(struct net *net, struct ip_vs_app *inc);
        int (*app_conn_bind)(struct ip_vs_conn *cp);
@@ -350,14 +443,26 @@ struct ip_vs_protocol {
                             int offset,
                             const char *msg);
-        void (*timeout_change)(struct ip_vs_protocol *pp, int flags);
+        void (*timeout_change)(struct ip_vs_proto_data *pd, int flags);
+};
-        int (*set_state_timeout)(struct ip_vs_protocol *pp, char *sname, int to);
+/*
+ * protocol data per netns
+ */
+struct ip_vs_proto_data {
+        struct ip_vs_proto_data *next;
+        struct ip_vs_protocol   *pp;
+        int                     *timeout_table; /* protocol timeout table */
+        atomic_t                appcnt;         /* counter of proto app incs. */
+        struct tcp_states_t     *tcp_state_table;
 };
-extern struct ip_vs_protocol * ip_vs_proto_get(unsigned short proto);
+extern struct ip_vs_protocol   *ip_vs_proto_get(unsigned short proto);
+extern struct ip_vs_proto_data *ip_vs_proto_data_get(struct net *net,
+                                                     unsigned short proto);
 struct ip_vs_conn_param {
+        struct net                      *net;
        const union nf_inet_addr        *caddr;
        const union nf_inet_addr        *vaddr;
        __be16                          cport;
@@ -374,17 +479,20 @@ struct ip_vs_conn_param {
 *      IP_VS structure allocated for each dynamically scheduled connection
 */
 struct ip_vs_conn {
-        struct list_head        c_list;         /* hashed list heads */
+        struct hlist_node       c_list;         /* hashed list heads */
+#ifdef CONFIG_NET_NS
+        struct net              *net;           /* Name space */
+#endif
        /* Protocol, addresses and port numbers */
-        u16                      af;            /* address family */
+        u16                     af;             /* address family */
-        union nf_inet_addr       caddr;          /* client address */
+        __be16                  cport;
-        union nf_inet_addr       vaddr;          /* virtual address */
+        __be16                  vport;
-        union nf_inet_addr       daddr;          /* destination address */
+        __be16                  dport;
-        volatile __u32           flags;          /* status flags */
+        __u32                   fwmark;         /* Fire wall mark from skb */
-        __be16                   cport;
+        union nf_inet_addr      caddr;          /* client address */
-        __be16                   vport;
+        union nf_inet_addr      vaddr;          /* virtual address */
-        __be16                   dport;
+        union nf_inet_addr      daddr;          /* destination address */
+        volatile __u32          flags;          /* status flags */
        __u16                   protocol;       /* Which protocol (TCP/UDP) */
        /* counter and timer */
@@ -422,10 +530,38 @@ struct ip_vs_conn {
        struct ip_vs_seq        in_seq;         /* incoming seq. struct */
        struct ip_vs_seq        out_seq;        /* outgoing seq. struct */
+        const struct ip_vs_pe   *pe;
        char                    *pe_data;
        __u8                    pe_data_len;
 };
+/*
+ *  To save some memory in conn table when name space is disabled.
+ */
+static inline struct net *ip_vs_conn_net(const struct ip_vs_conn *cp)
+{
+#ifdef CONFIG_NET_NS
+        return cp->net;
+#else
+        return &init_net;
+#endif
+}
+static inline void ip_vs_conn_net_set(struct ip_vs_conn *cp, struct net *net)
+{
+#ifdef CONFIG_NET_NS
+        cp->net = net;
+#endif
+}
+static inline int ip_vs_conn_net_eq(const struct ip_vs_conn *cp,
+                                    struct net *net)
+{
+#ifdef CONFIG_NET_NS
+        return cp->net == net;
+#else
+        return 1;
+#endif
+}
 /*
 *      Extended internal versions of struct ip_vs_service_user and
@@ -485,6 +621,7 @@ struct ip_vs_service {
        unsigned                flags;    /* service status flags */
        unsigned                timeout;  /* persistent timeout in ticks */
        __be32                  netmask;  /* grouping granularity */
+        struct net              *net;
        struct list_head        destinations;  /* real server d-linked list */
        __u32                   num_dests;     /* number of servers */
@@ -510,8 +647,8 @@ struct ip_vs_dest {
        struct list_head        d_list;   /* for table with all the dests */
        u16                     af;             /* address family */
-        union nf_inet_addr      addr;           /* IP address of the server */
        __be16                  port;           /* port number of the server */
+        union nf_inet_addr      addr;           /* IP address of the server */
        volatile unsigned       flags;          /* dest status flags */
        atomic_t                conn_flags;     /* flags to copy to conn */
        atomic_t                weight;         /* server weight */
@@ -538,8 +675,8 @@ struct ip_vs_dest {
        /* for virtual service */
        struct ip_vs_service    *svc;           /* service it belongs to */
        __u16                   protocol;       /* which protocol (TCP/UDP) */
-        union nf_inet_addr      vaddr;          /* virtual IP address */
        __be16                  vport;          /* virtual port number */
+        union nf_inet_addr      vaddr;          /* virtual IP address */
        __u32                   vfwmark;        /* firewall mark of service */
 };
@@ -651,6 +788,171 @@ struct ip_vs_app {
        void (*timeout_change)(struct ip_vs_app *app, int flags);
 };
+/* IPVS in network namespace */
+struct netns_ipvs {
+        int                     gen;            /* Generation */
+        /*
+         *      Hash table: for real service lookups
+         */
+        #define IP_VS_RTAB_BITS 4
+        #define IP_VS_RTAB_SIZE (1 << IP_VS_RTAB_BITS)
+        #define IP_VS_RTAB_MASK (IP_VS_RTAB_SIZE - 1)
+        struct list_head        rs_table[IP_VS_RTAB_SIZE];
+        /* ip_vs_app */
+        struct list_head        app_list;
+        struct mutex            app_mutex;
+        struct lock_class_key   app_key;        /* mutex debuging */
+        /* ip_vs_proto */
+        #define IP_VS_PROTO_TAB_SIZE    32      /* must be power of 2 */
+        struct ip_vs_proto_data *proto_data_table[IP_VS_PROTO_TAB_SIZE];
+        /* ip_vs_proto_tcp */
+#ifdef CONFIG_IP_VS_PROTO_TCP
+        #define TCP_APP_TAB_BITS        4
+        #define TCP_APP_TAB_SIZE        (1 << TCP_APP_TAB_BITS)
+        #define TCP_APP_TAB_MASK        (TCP_APP_TAB_SIZE - 1)
+        struct list_head        tcp_apps[TCP_APP_TAB_SIZE];
+        spinlock_t              tcp_app_lock;
+#endif
+        /* ip_vs_proto_udp */
+#ifdef CONFIG_IP_VS_PROTO_UDP
+        #define UDP_APP_TAB_BITS        4
+        #define UDP_APP_TAB_SIZE        (1 << UDP_APP_TAB_BITS)
+        #define UDP_APP_TAB_MASK        (UDP_APP_TAB_SIZE - 1)
+        struct list_head        udp_apps[UDP_APP_TAB_SIZE];
+        spinlock_t              udp_app_lock;
+#endif
+        /* ip_vs_proto_sctp */
+#ifdef CONFIG_IP_VS_PROTO_SCTP
+        #define SCTP_APP_TAB_BITS       4
+        #define SCTP_APP_TAB_SIZE       (1 << SCTP_APP_TAB_BITS)
+        #define SCTP_APP_TAB_MASK       (SCTP_APP_TAB_SIZE - 1)
+        /* Hash table for SCTP application incarnations  */
+        struct list_head        sctp_apps[SCTP_APP_TAB_SIZE];
+        spinlock_t              sctp_app_lock;
+#endif
+        /* ip_vs_conn */
+        atomic_t                conn_count;      /*  connection counter */
+        /* ip_vs_ctl */
+        struct ip_vs_stats              tot_stats;  /* Statistics & est. */
+        int                     num_services;    /* no of virtual services */
+        rwlock_t                rs_lock;         /* real services table */
+        /* semaphore for IPVS sockopts. And, [gs]etsockopt may sleep. */
+        struct lock_class_key   ctl_key;        /* ctl_mutex debuging */
+        /* Trash for destinations */
+        struct list_head        dest_trash;
+        /* Service counters */
+        atomic_t                ftpsvc_counter;
+        atomic_t                nullsvc_counter;
+#ifdef CONFIG_SYSCTL
+        /* 1/rate drop and drop-entry variables */
+        struct delayed_work     defense_work;   /* Work handler */
+        int                     drop_rate;
+        int                     drop_counter;
+        atomic_t                dropentry;
+        /* locks in ctl.c */
+        spinlock_t              dropentry_lock;  /* drop entry handling */
+        spinlock_t              droppacket_lock; /* drop packet handling */
+        spinlock_t              securetcp_lock;  /* state and timeout tables */
+        /* sys-ctl struct */
+        struct ctl_table_header *sysctl_hdr;
+        struct ctl_table        *sysctl_tbl;
+#endif
+        /* sysctl variables */
+        int                     sysctl_amemthresh;
+        int                     sysctl_am_droprate;
+        int                     sysctl_drop_entry;
+        int                     sysctl_drop_packet;
+        int                     sysctl_secure_tcp;
+#ifdef CONFIG_IP_VS_NFCT
+        int                     sysctl_conntrack;
+#endif
+        int                     sysctl_snat_reroute;
+        int                     sysctl_sync_ver;
+        int                     sysctl_cache_bypass;
+        int                     sysctl_expire_nodest_conn;
+        int                     sysctl_expire_quiescent_template;
+        int                     sysctl_sync_threshold[2];
+        int                     sysctl_nat_icmp_send;
+        /* ip_vs_lblc */
+        int                     sysctl_lblc_expiration;
+        struct ctl_table_header *lblc_ctl_header;
+        struct ctl_table        *lblc_ctl_table;
+        /* ip_vs_lblcr */
+        int                     sysctl_lblcr_expiration;
+        struct ctl_table_header *lblcr_ctl_header;
+        struct ctl_table        *lblcr_ctl_table;
+        /* ip_vs_est */
+        struct list_head        est_list;       /* estimator list */
+        spinlock_t              est_lock;
+        struct timer_list       est_timer;      /* Estimation timer */
+        /* ip_vs_sync */
+        struct list_head        sync_queue;
+        spinlock_t              sync_lock;
+        struct ip_vs_sync_buff  *sync_buff;
+        spinlock_t              sync_buff_lock;
+        struct sockaddr_in      sync_mcast_addr;
+        struct task_struct      *master_thread;
+        struct task_struct      *backup_thread;
+        int                     send_mesg_maxlen;
+        int                     recv_mesg_maxlen;
+        volatile int            sync_state;
+        volatile int            master_syncid;
+        volatile int            backup_syncid;
+        /* multicast interface name */
+        char                    master_mcast_ifn[IP_VS_IFNAME_MAXLEN];
+        char                    backup_mcast_ifn[IP_VS_IFNAME_MAXLEN];
+        /* net name space ptr */
+        struct net              *net;            /* Needed by timer routines */
+};
+#define DEFAULT_SYNC_THRESHOLD  3
+#define DEFAULT_SYNC_PERIOD     50
+#define DEFAULT_SYNC_VER        1
+#ifdef CONFIG_SYSCTL
+static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs)
+{
+        return ipvs->sysctl_sync_threshold[0];
+}
+static inline int sysctl_sync_period(struct netns_ipvs *ipvs)
+{
+        return ipvs->sysctl_sync_threshold[1];
+}
+static inline int sysctl_sync_ver(struct netns_ipvs *ipvs)
+{
+        return ipvs->sysctl_sync_ver;
+}
+#else
+static inline int sysctl_sync_threshold(struct netns_ipvs *ipvs)
+{
+        return DEFAULT_SYNC_THRESHOLD;
+}
+static inline int sysctl_sync_period(struct netns_ipvs *ipvs)
+{
+        return DEFAULT_SYNC_PERIOD;
+}
+static inline int sysctl_sync_ver(struct netns_ipvs *ipvs)
+{
+        return DEFAULT_SYNC_VER;
+}
+#endif
 /*
 *      IPVS core functions
@@ -674,13 +976,14 @@ enum {
        IP_VS_DIR_LAST,
 };
-static inline void ip_vs_conn_fill_param(int af, int protocol,
+static inline void ip_vs_conn_fill_param(struct net *net, int af, int protocol,
                                         const union nf_inet_addr *caddr,
                                         __be16 cport,
                                         const union nf_inet_addr *vaddr,
                                         __be16 vport,
                                         struct ip_vs_conn_param *p)
 {
+        p->net = net;
        p->af = af;
        p->protocol = protocol;
        p->caddr = caddr;
@@ -695,7 +998,6 @@ struct ip_vs_conn *ip_vs_conn_in_get(const struct ip_vs_conn_param *p);
 struct ip_vs_conn *ip_vs_ct_in_get(const struct ip_vs_conn_param *p);
 struct ip_vs_conn * ip_vs_conn_in_get_proto(int af, const struct sk_buff *skb,
-                                            struct ip_vs_protocol *pp,
                                            const struct ip_vs_iphdr *iph,
                                            unsigned int proto_off,
                                            int inverse);
@@ -703,7 +1005,6 @@ struct ip_vs_conn * ip_vs_conn_in_get_proto(int af, const struct sk_buff *skb,
 struct ip_vs_conn *ip_vs_conn_out_get(const struct ip_vs_conn_param *p);
 struct ip_vs_conn * ip_vs_conn_out_get_proto(int af, const struct sk_buff *skb,
-                                             struct ip_vs_protocol *pp,
                                             const struct ip_vs_iphdr *iph,
                                             unsigned int proto_off,
                                             int inverse);
@@ -719,14 +1020,14 @@ extern void ip_vs_conn_fill_cport(struct ip_vs_conn *cp, __be16 cport);
 struct ip_vs_conn *ip_vs_conn_new(const struct ip_vs_conn_param *p,
                                  const union nf_inet_addr *daddr,
                                  __be16 dport, unsigned flags,
-                                  struct ip_vs_dest *dest);
+                                  struct ip_vs_dest *dest, __u32 fwmark);
 extern void ip_vs_conn_expire_now(struct ip_vs_conn *cp);
 extern const char * ip_vs_state_name(__u16 proto, int state);
-extern void ip_vs_tcp_conn_listen(struct ip_vs_conn *cp);
+extern void ip_vs_tcp_conn_listen(struct net *net, struct ip_vs_conn *cp);
 extern int ip_vs_check_template(struct ip_vs_conn *ct);
-extern void ip_vs_random_dropentry(void);
+extern void ip_vs_random_dropentry(struct net *net);
 extern int ip_vs_conn_init(void);
 extern void ip_vs_conn_cleanup(void);
@@ -796,12 +1097,12 @@ ip_vs_control_add(struct ip_vs_conn *cp, struct ip_vs_conn *ctl_cp)
 *      (from ip_vs_app.c)
 */
 #define IP_VS_APP_MAX_PORTS  8
-extern int register_ip_vs_app(struct ip_vs_app *app);
+extern int register_ip_vs_app(struct net *net, struct ip_vs_app *app);
-extern void unregister_ip_vs_app(struct ip_vs_app *app);
+extern void unregister_ip_vs_app(struct net *net, struct ip_vs_app *app);
 extern int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp);
 extern void ip_vs_unbind_app(struct ip_vs_conn *cp);
-extern int
+extern int register_ip_vs_app_inc(struct net *net, struct ip_vs_app *app,
-register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port);
+                                  __u16 proto, __u16 port);
 extern int ip_vs_app_inc_get(struct ip_vs_app *inc);
 extern void ip_vs_app_inc_put(struct ip_vs_app *inc);
@@ -814,15 +1115,27 @@ void ip_vs_bind_pe(struct ip_vs_service *svc, struct ip_vs_pe *pe);
 void ip_vs_unbind_pe(struct ip_vs_service *svc);
 int register_ip_vs_pe(struct ip_vs_pe *pe);
 int unregister_ip_vs_pe(struct ip_vs_pe *pe);
-extern struct ip_vs_pe *ip_vs_pe_get(const char *name);
+struct ip_vs_pe *ip_vs_pe_getbyname(const char *name);
-extern void ip_vs_pe_put(struct ip_vs_pe *pe);
+struct ip_vs_pe *__ip_vs_pe_getbyname(const char *pe_name);
+static inline void ip_vs_pe_get(const struct ip_vs_pe *pe)
+{
+        if (pe && pe->module)
+                __module_get(pe->module);
+}
+static inline void ip_vs_pe_put(const struct ip_vs_pe *pe)
+{
+        if (pe && pe->module)
+                module_put(pe->module);
+}
 /*
 *      IPVS protocol functions (from ip_vs_proto.c)
 */
 extern int ip_vs_protocol_init(void);
 extern void ip_vs_protocol_cleanup(void);
-extern void ip_vs_protocol_timeout_change(int flags);
+extern void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags);
 extern int *ip_vs_create_timeout_table(int *table, int size);
 extern int
 ip_vs_set_state_timeout(int *table, int num, const char *const *names,
@@ -852,26 +1165,23 @@ extern struct ip_vs_scheduler *ip_vs_scheduler_get(const char *sched_name);
 extern void ip_vs_scheduler_put(struct ip_vs_scheduler *scheduler);
 extern struct ip_vs_conn *
 ip_vs_schedule(struct ip_vs_service *svc, struct sk_buff *skb,
-               struct ip_vs_protocol *pp, int *ignored);
+               struct ip_vs_proto_data *pd, int *ignored);
 extern int ip_vs_leave(struct ip_vs_service *svc, struct sk_buff *skb,
-                        struct ip_vs_protocol *pp);
+                        struct ip_vs_proto_data *pd);
+extern void ip_vs_scheduler_err(struct ip_vs_service *svc, const char *msg);
 /*
 *      IPVS control data and functions (from ip_vs_ctl.c)
 */
-extern int sysctl_ip_vs_cache_bypass;
-extern int sysctl_ip_vs_expire_nodest_conn;
-extern int sysctl_ip_vs_expire_quiescent_template;
-extern int sysctl_ip_vs_sync_threshold[2];
-extern int sysctl_ip_vs_nat_icmp_send;
-extern int sysctl_ip_vs_conntrack;
-extern int sysctl_ip_vs_snat_reroute;
 extern struct ip_vs_stats ip_vs_stats;
 extern const struct ctl_path net_vs_ctl_path[];
+extern int sysctl_ip_vs_sync_ver;
+extern void ip_vs_sync_switch_mode(struct net *net, int mode);
 extern struct ip_vs_service *
-ip_vs_service_get(int af, __u32 fwmark, __u16 protocol,
+ip_vs_service_get(struct net *net, int af, __u32 fwmark, __u16 protocol,
                  const union nf_inet_addr *vaddr, __be16 vport);
 static inline void ip_vs_service_put(struct ip_vs_service *svc)
@@ -880,7 +1190,7 @@ static inline void ip_vs_service_put(struct ip_vs_service *svc)
 }
 extern struct ip_vs_dest *
-ip_vs_lookup_real_service(int af, __u16 protocol,
+ip_vs_lookup_real_service(struct net *net, int af, __u16 protocol,
                          const union nf_inet_addr *daddr, __be16 dport);
 extern int ip_vs_use_count_inc(void);
@@ -888,8 +1198,9 @@ 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(int af, const union nf_inet_addr *daddr, __be16 dport,
+ip_vs_find_dest(struct net *net, int af, const union nf_inet_addr *daddr,
-                const union nf_inet_addr *vaddr, __be16 vport, __u16 protocol);
+                __be16 dport, const union nf_inet_addr *vaddr, __be16 vport,
+                __u16 protocol, __u32 fwmark);
 extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp);
@@ -897,14 +1208,12 @@ extern struct ip_vs_dest *ip_vs_try_bind_dest(struct ip_vs_conn *cp);
 *      IPVS sync daemon data and function prototypes
 *      (from ip_vs_sync.c)
 */
-extern volatile int ip_vs_sync_state;
+extern int start_sync_thread(struct net *net, int state, char *mcast_ifn,
-extern volatile int ip_vs_master_syncid;
+                             __u8 syncid);
-extern volatile int ip_vs_backup_syncid;
+extern int stop_sync_thread(struct net *net, int state);
-extern char ip_vs_master_mcast_ifn[IP_VS_IFNAME_MAXLEN];
+extern void ip_vs_sync_conn(struct net *net, struct ip_vs_conn *cp);
-extern char ip_vs_backup_mcast_ifn[IP_VS_IFNAME_MAXLEN];
+extern int ip_vs_sync_init(void);
-extern int start_sync_thread(int state, char *mcast_ifn, __u8 syncid);
+extern void ip_vs_sync_cleanup(void);
-extern int stop_sync_thread(int state);
-extern void ip_vs_sync_conn(struct ip_vs_conn *cp);
 /*
@@ -912,9 +1221,11 @@ extern void ip_vs_sync_conn(struct ip_vs_conn *cp);
 */
 extern int ip_vs_estimator_init(void);
 extern void ip_vs_estimator_cleanup(void);
-extern void ip_vs_new_estimator(struct ip_vs_stats *stats);
+extern void ip_vs_start_estimator(struct net *net, struct ip_vs_stats *stats);
-extern void ip_vs_kill_estimator(struct ip_vs_stats *stats);
+extern void ip_vs_stop_estimator(struct net *net, struct ip_vs_stats *stats);
 extern void ip_vs_zero_estimator(struct ip_vs_stats *stats);
+extern void ip_vs_read_estimator(struct ip_vs_stats_user *dst,
+                                 struct ip_vs_stats *stats);
 /*
 *      Various IPVS packet transmitters (from ip_vs_xmit.c)
@@ -947,21 +1258,25 @@ extern int ip_vs_icmp_xmit_v6
 int offset);
 #endif
+#ifdef CONFIG_SYSCTL
 /*
 *      This is a simple mechanism to ignore packets when
 *      we are loaded. Just set ip_vs_drop_rate to 'n' and
 *      we start to drop 1/rate of the packets
 */
-extern int ip_vs_drop_rate;
-extern int ip_vs_drop_counter;
-static __inline__ int ip_vs_todrop(void)
+static inline int ip_vs_todrop(struct netns_ipvs *ipvs)
 {
-        if (!ip_vs_drop_rate) return 0;
+        if (!ipvs->drop_rate)
-        if (--ip_vs_drop_counter > 0) return 0;
+                return 0;
-        ip_vs_drop_counter = ip_vs_drop_rate;
+        if (--ipvs->drop_counter > 0)
+                return 0;
+        ipvs->drop_counter = ipvs->drop_rate;
        return 1;
 }
+#else
+static inline int ip_vs_todrop(struct netns_ipvs *ipvs) { return 0; }
+#endif
 /*
 *      ip_vs_fwd_tag returns the forwarding tag of the connection
@@ -1031,7 +1346,7 @@ static inline void ip_vs_notrack(struct sk_buff *skb)
 {
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
        enum ip_conntrack_info ctinfo;
-        struct nf_conn *ct = ct = nf_ct_get(skb, &ctinfo);
+        struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
        if (!ct || !nf_ct_is_untracked(ct)) {
                nf_reset(skb);
@@ -1047,9 +1362,13 @@ static inline void ip_vs_notrack(struct sk_buff *skb)
 *      Netfilter connection tracking
 *      (from ip_vs_nfct.c)
 */
-static inline int ip_vs_conntrack_enabled(void)
+static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
 {
-        return sysctl_ip_vs_conntrack;
+#ifdef CONFIG_SYSCTL
+        return ipvs->sysctl_conntrack;
+#else
+        return 0;
+#endif
 }
 extern void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp,
@@ -1062,7 +1381,7 @@ extern void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp);
 #else
-static inline int ip_vs_conntrack_enabled(void)
+static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
 {
        return 0;
 }
@@ -1084,6 +1403,20 @@ static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp)
 /* CONFIG_IP_VS_NFCT */
 #endif
+static inline unsigned int
+ip_vs_dest_conn_overhead(struct ip_vs_dest *dest)
+{
+        /*
+         * We think the overhead of processing active connections is 256
+         * times higher than that of inactive connections in average. (This
+         * 256 times might not be accurate, we will change it later) We
+         * use the following formula to estimate the overhead now:
+         *                dest->activeconns*256 + dest->inactconns
+         */
+        return (atomic_read(&dest->activeconns) << 8) +
+                atomic_read(&dest->inactconns);
+}
 #endif /* __KERNEL__ */
 #endif  /* _NET_IP_VS_H */
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index 96e50e0ce3ca..34200f9e6805 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -492,7 +492,7 @@ extern int			ip6_rcv_finish(struct sk_buff *skb);
 */
 extern int                      ip6_xmit(struct sock *sk,
                                         struct sk_buff *skb,
-                                         struct flowi *fl,
+                                         struct flowi6 *fl6,
                                         struct ipv6_txoptions *opt);
 extern int                      ip6_nd_hdr(struct sock *sk,
@@ -512,7 +512,7 @@ extern int			ip6_append_data(struct sock *sk,
                                                int hlimit,
                                                int tclass,
                                                struct ipv6_txoptions *opt,
-                                                struct flowi *fl,
+                                                struct flowi6 *fl6,
                                                struct rt6_info *rt,
                                                unsigned int flags,
                                                int dontfrag);
@@ -523,13 +523,17 @@ extern void			ip6_flush_pending_frames(struct sock *sk);
 extern int                      ip6_dst_lookup(struct sock *sk,
                                               struct dst_entry **dst,
-                                               struct flowi *fl);
+                                               struct flowi6 *fl6);
-extern int                      ip6_dst_blackhole(struct sock *sk,
+extern struct dst_entry *       ip6_dst_lookup_flow(struct sock *sk,
-                                                  struct dst_entry **dst,
+                                                    struct flowi6 *fl6,
-                                                  struct flowi *fl);
+                                                    const struct in6_addr *final_dst,
-extern int                      ip6_sk_dst_lookup(struct sock *sk,
+                                                    bool can_sleep);
-                                                  struct dst_entry **dst,
+extern struct dst_entry *       ip6_sk_dst_lookup_flow(struct sock *sk,
-                                                  struct flowi *fl);
+                                                       struct flowi6 *fl6,
+                                                       const struct in6_addr *final_dst,
+                                                       bool can_sleep);
+extern struct dst_entry *       ip6_blackhole_route(struct net *net,
+                                                    struct dst_entry *orig_dst);
 /*
 *      skb processing functions
@@ -562,7 +566,7 @@ extern int 			ipv6_ext_hdr(u8 nexthdr);
 extern int ipv6_find_tlv(struct sk_buff *skb, int offset, int type);
-extern struct in6_addr *fl6_update_dst(struct flowi *fl,
+extern struct in6_addr *fl6_update_dst(struct flowi6 *fl6,
                                       const struct ipv6_txoptions *opt,
                                       struct in6_addr *orig);
@@ -596,8 +600,8 @@ extern int 			ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len);
 extern int                      ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len);
 extern void                     ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err, __be16 port,
                                                u32 info, u8 *payload);
-extern void                     ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info);
+extern void                     ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info);
-extern void                     ipv6_local_rxpmtu(struct sock *sk, struct flowi *fl, u32 mtu);
+extern void                     ipv6_local_rxpmtu(struct sock *sk, struct flowi6 *fl6, u32 mtu);
 extern int inet6_release(struct socket *sock);
 extern int inet6_bind(struct socket *sock, struct sockaddr *uaddr, 
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 62c0ce2d1dc8..8650e7bf2ed0 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -341,6 +341,9 @@ struct ieee80211_bss_conf {
 *      the off-channel channel when a remain-on-channel offload is done
 *      in hardware -- normal packets still flow and are expected to be
 *      handled properly by the device.
+ * @IEEE80211_TX_INTFL_TKIP_MIC_FAILURE: Marks this packet to be used for TKIP
+ *      testing. It will be sent out with incorrect Michael MIC key to allow
+ *      TKIP countermeasures to be tested.
 *
 * Note: If you have to add new flags to the enumeration, then don't
 *       forget to update %IEEE80211_TX_TEMPORARY_FLAGS when necessary.
@@ -370,6 +373,7 @@ enum mac80211_tx_control_flags {
        IEEE80211_TX_CTL_LDPC                   = BIT(22),
        IEEE80211_TX_CTL_STBC                   = BIT(23) | BIT(24),
        IEEE80211_TX_CTL_TX_OFFCHAN             = BIT(25),
+        IEEE80211_TX_INTFL_TKIP_MIC_FAILURE     = BIT(26),
 };
 #define IEEE80211_TX_CTL_STBC_SHIFT             23
@@ -595,9 +599,10 @@ ieee80211_tx_info_clear_status(struct ieee80211_tx_info *info)
 *      the frame.
 * @RX_FLAG_FAILED_PLCP_CRC: Set this flag if the PCLP check failed on
 *      the frame.
- * @RX_FLAG_TSFT: The timestamp passed in the RX status (@mactime field)
+ * @RX_FLAG_MACTIME_MPDU: The timestamp passed in the RX status (@mactime
- *      is valid. This is useful in monitor mode and necessary for beacon frames
+ *      field) is valid and contains the time the first symbol of the MPDU
- *      to enable IBSS merging.
+ *      was received. This is useful in monitor mode and for proper IBSS
+ *      merging.
 * @RX_FLAG_SHORTPRE: Short preamble was used for this frame
 * @RX_FLAG_HT: HT MCS was used and rate_idx is MCS index
 * @RX_FLAG_40MHZ: HT40 (40 MHz) was used
@@ -610,7 +615,7 @@ enum mac80211_rx_flags {
        RX_FLAG_IV_STRIPPED     = 1<<4,
        RX_FLAG_FAILED_FCS_CRC  = 1<<5,
        RX_FLAG_FAILED_PLCP_CRC = 1<<6,
-        RX_FLAG_TSFT            = 1<<7,
+        RX_FLAG_MACTIME_MPDU    = 1<<7,
        RX_FLAG_SHORTPRE        = 1<<8,
        RX_FLAG_HT              = 1<<9,
        RX_FLAG_40MHZ           = 1<<10,
@@ -1069,6 +1074,13 @@ enum ieee80211_tkip_key_type {
 *      to decrypt group addressed frames, then IBSS RSN support is still
 *      possible but software crypto will be used. Advertise the wiphy flag
 *      only in that case.
+ *
+ * @IEEE80211_HW_AP_LINK_PS: When operating in AP mode the device
+ *      autonomously manages the PS status of connected stations. When
+ *      this flag is set mac80211 will not trigger PS mode for connected
+ *      stations based on the PM bit of incoming frames.
+ *      Use ieee80211_start_ps()/ieee8021_end_ps() to manually configure
+ *      the PS mode of connected stations.
 */
 enum ieee80211_hw_flags {
        IEEE80211_HW_HAS_RATE_CONTROL                   = 1<<0,
@@ -1093,6 +1105,7 @@ enum ieee80211_hw_flags {
        IEEE80211_HW_CONNECTION_MONITOR                 = 1<<19,
        IEEE80211_HW_SUPPORTS_CQM_RSSI                  = 1<<20,
        IEEE80211_HW_SUPPORTS_PER_STA_GTK               = 1<<21,
+        IEEE80211_HW_AP_LINK_PS                         = 1<<22,
 };
 /**
@@ -1147,6 +1160,17 @@ enum ieee80211_hw_flags {
 * @napi_weight: weight used for NAPI polling.  You must specify an
 *      appropriate value here if a napi_poll operation is provided
 *      by your driver.
+ * @max_rx_aggregation_subframes: maximum buffer size (number of
+ *      sub-frames) to be used for A-MPDU block ack receiver
+ *      aggregation.
+ *      This is only relevant if the device has restrictions on the
+ *      number of subframes, if it relies on mac80211 to do reordering
+ *      it shouldn't be set.
+ *
+ * @max_tx_aggregation_subframes: maximum number of subframes in an
+ *      aggregate an HT driver will transmit, used by the peer as a
+ *      hint to size its reorder buffer.
 */
 struct ieee80211_hw {
        struct ieee80211_conf conf;
@@ -1165,6 +1189,8 @@ struct ieee80211_hw {
        u8 max_rates;
        u8 max_report_rates;
        u8 max_rate_tries;
+        u8 max_rx_aggregation_subframes;
+        u8 max_tx_aggregation_subframes;
 };
 /**
@@ -1688,7 +1714,9 @@ enum ieee80211_ampdu_mlme_action {
 *      station, AP, IBSS/WDS/mesh peer etc. This callback can sleep.
 *
 * @sta_notify: Notifies low level driver about power state transition of an
- *      associated station, AP,  IBSS/WDS/mesh peer etc. Must be atomic.
+ *      associated station, AP,  IBSS/WDS/mesh peer etc. For a VIF operating
+ *      in AP mode, this callback will not be called when the flag
+ *      %IEEE80211_HW_AP_LINK_PS is set. Must be atomic.
 *
 * @conf_tx: Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
 *      bursting) for a hardware TX queue.
@@ -1723,6 +1751,10 @@ enum ieee80211_ampdu_mlme_action {
 *      ieee80211_ampdu_mlme_action. Starting sequence number (@ssn)
 *      is the first frame we expect to perform the action on. Notice
 *      that TX/RX_STOP can pass NULL for this parameter.
+ *      The @buf_size parameter is only valid when the action is set to
+ *      %IEEE80211_AMPDU_TX_OPERATIONAL and indicates the peer's reorder
+ *      buffer size (number of subframes) for this session -- aggregates
+ *      containing more subframes than this may not be transmitted to the peer.
 *      Returns a negative error code on failure.
 *      The callback can sleep.
 *
@@ -1767,9 +1799,18 @@ enum ieee80211_ampdu_mlme_action {
 *      ieee80211_remain_on_channel_expired(). This callback may sleep.
 * @cancel_remain_on_channel: Requests that an ongoing off-channel period is
 *      aborted before it expires. This callback may sleep.
+ * @offchannel_tx: Transmit frame on another channel, wait for a response
+ *      and return. Reliable TX status must be reported for the frame. If the
+ *      return value is 1, then the @remain_on_channel will be used with a
+ *      regular transmission (if supported.)
+ * @offchannel_tx_cancel_wait: cancel wait associated with offchannel TX
+ *
+ * @set_ringparam: Set tx and rx ring sizes.
+ *
+ * @get_ringparam: Get tx and rx ring current and maximum sizes.
 */
 struct ieee80211_ops {
-        int (*tx)(struct ieee80211_hw *hw, struct sk_buff *skb);
+        void (*tx)(struct ieee80211_hw *hw, struct sk_buff *skb);
        int (*start)(struct ieee80211_hw *hw);
        void (*stop)(struct ieee80211_hw *hw);
        int (*add_interface)(struct ieee80211_hw *hw,
@@ -1825,7 +1866,8 @@ struct ieee80211_ops {
        int (*ampdu_action)(struct ieee80211_hw *hw,
                            struct ieee80211_vif *vif,
                            enum ieee80211_ampdu_mlme_action action,
-                            struct ieee80211_sta *sta, u16 tid, u16 *ssn);
+                            struct ieee80211_sta *sta, u16 tid, u16 *ssn,
+                            u8 buf_size);
        int (*get_survey)(struct ieee80211_hw *hw, int idx,
                struct survey_info *survey);
        void (*rfkill_poll)(struct ieee80211_hw *hw);
@@ -1845,6 +1887,14 @@ struct ieee80211_ops {
                                 enum nl80211_channel_type channel_type,
                                 int duration);
        int (*cancel_remain_on_channel)(struct ieee80211_hw *hw);
+        int (*offchannel_tx)(struct ieee80211_hw *hw, struct sk_buff *skb,
+                             struct ieee80211_channel *chan,
+                             enum nl80211_channel_type channel_type,
+                             unsigned int wait);
+        int (*offchannel_tx_cancel_wait)(struct ieee80211_hw *hw);
+        int (*set_ringparam)(struct ieee80211_hw *hw, u32 tx, u32 rx);
+        void (*get_ringparam)(struct ieee80211_hw *hw,
+                              u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max);
 };
 /**
@@ -2113,6 +2163,48 @@ static inline void ieee80211_rx_ni(struct ieee80211_hw *hw,
        local_bh_enable();
 }
+/**
+ * ieee80211_sta_ps_transition - PS transition for connected sta
+ *
+ * When operating in AP mode with the %IEEE80211_HW_AP_LINK_PS
+ * flag set, use this function to inform mac80211 about a connected station
+ * entering/leaving PS mode.
+ *
+ * This function may not be called in IRQ context or with softirqs enabled.
+ *
+ * Calls to this function for a single hardware must be synchronized against
+ * each other.
+ *
+ * The function returns -EINVAL when the requested PS mode is already set.
+ *
+ * @sta: currently connected sta
+ * @start: start or stop PS
+ */
+int ieee80211_sta_ps_transition(struct ieee80211_sta *sta, bool start);
+/**
+ * ieee80211_sta_ps_transition_ni - PS transition for connected sta
+ *                                  (in process context)
+ *
+ * Like ieee80211_sta_ps_transition() but can be called in process context
+ * (internally disables bottom halves). Concurrent call restriction still
+ * applies.
+ *
+ * @sta: currently connected sta
+ * @start: start or stop PS
+ */
+static inline int ieee80211_sta_ps_transition_ni(struct ieee80211_sta *sta,
+                                                  bool start)
+{
+        int ret;
+        local_bh_disable();
+        ret = ieee80211_sta_ps_transition(sta, start);
+        local_bh_enable();
+        return ret;
+}
 /*
 * The TX headroom reserved by mac80211 for its own tx_status functions.
 * This is enough for the radiotap header.
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 1bf812b21fb7..3ae491932bc8 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -27,6 +27,7 @@ struct sock;
 struct ctl_table_header;
 struct net_generic;
 struct sock;
+struct netns_ipvs;
 #define NETDEV_HASHBITS    8
@@ -94,6 +95,7 @@ struct net {
 #ifdef CONFIG_XFRM
        struct netns_xfrm       xfrm;
 #endif
+        struct netns_ipvs       *ipvs;
 };
diff --git a/include/net/netevent.h b/include/net/netevent.h
index e82b7bab3ff3..22b239c17eaa 100644
--- a/include/net/netevent.h
+++ b/include/net/netevent.h
@@ -21,7 +21,6 @@ struct netevent_redirect {
 enum netevent_notif_type {
        NETEVENT_NEIGH_UPDATE = 1, /* arg is struct neighbour ptr */
-        NETEVENT_PMTU_UPDATE,      /* arg is struct dst_entry ptr */
        NETEVENT_REDIRECT,         /* arg is struct netevent_redirect ptr */
 };
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index d85cff10e169..d0d13378991e 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -50,11 +50,24 @@ union nf_conntrack_expect_proto {
 /* per conntrack: application helper private data */
 union nf_conntrack_help {
        /* insert conntrack helper private data (master) here */
+#if defined(CONFIG_NF_CONNTRACK_FTP) || defined(CONFIG_NF_CONNTRACK_FTP_MODULE)
        struct nf_ct_ftp_master ct_ftp_info;
+#endif
+#if defined(CONFIG_NF_CONNTRACK_PPTP) || \
+    defined(CONFIG_NF_CONNTRACK_PPTP_MODULE)
        struct nf_ct_pptp_master ct_pptp_info;
+#endif
+#if defined(CONFIG_NF_CONNTRACK_H323) || \
+    defined(CONFIG_NF_CONNTRACK_H323_MODULE)
        struct nf_ct_h323_master ct_h323_info;
+#endif
+#if defined(CONFIG_NF_CONNTRACK_SANE) || \
+    defined(CONFIG_NF_CONNTRACK_SANE_MODULE)
        struct nf_ct_sane_master ct_sane_info;
+#endif
+#if defined(CONFIG_NF_CONNTRACK_SIP) || defined(CONFIG_NF_CONNTRACK_SIP_MODULE)
        struct nf_ct_sip_master ct_sip_info;
+#endif
 };
 #include <linux/types.h>
@@ -116,14 +129,14 @@ struct nf_conn {
        u_int32_t secmark;
 #endif
-        /* Storage reserved for other modules: */
-        union nf_conntrack_proto proto;
        /* Extensions */
        struct nf_ct_ext *ext;
 #ifdef CONFIG_NET_NS
        struct net *ct_net;
 #endif
+        /* Storage reserved for other modules, must be the last member */
+        union nf_conntrack_proto proto;
 };
 static inline struct nf_conn *
@@ -189,9 +202,9 @@ extern void nf_ct_l3proto_module_put(unsigned short l3proto);
 * Allocate a hashtable of hlist_head (if nulls == 0),
 * or hlist_nulls_head (if nulls == 1)
 */
-extern void *nf_ct_alloc_hashtable(unsigned int *sizep, int *vmalloced, int nulls);
+extern void *nf_ct_alloc_hashtable(unsigned int *sizep, int nulls);
-extern void nf_ct_free_hashtable(void *hash, int vmalloced, unsigned int size);
+extern void nf_ct_free_hashtable(void *hash, unsigned int size);
 extern struct nf_conntrack_tuple_hash *
 __nf_conntrack_find(struct net *net, u16 zone,
diff --git a/include/net/netfilter/nf_conntrack_ecache.h b/include/net/netfilter/nf_conntrack_ecache.h
index 349cefedc9f3..4283508b3e18 100644
--- a/include/net/netfilter/nf_conntrack_ecache.h
+++ b/include/net/netfilter/nf_conntrack_ecache.h
@@ -23,12 +23,17 @@ struct nf_conntrack_ecache {
 static inline struct nf_conntrack_ecache *
 nf_ct_ecache_find(const struct nf_conn *ct)
 {
+#ifdef CONFIG_NF_CONNTRACK_EVENTS
        return nf_ct_ext_find(ct, NF_CT_EXT_ECACHE);
+#else
+        return NULL;
+#endif
 }
 static inline struct nf_conntrack_ecache *
 nf_ct_ecache_ext_add(struct nf_conn *ct, u16 ctmask, u16 expmask, gfp_t gfp)
 {
+#ifdef CONFIG_NF_CONNTRACK_EVENTS
        struct net *net = nf_ct_net(ct);
        struct nf_conntrack_ecache *e;
@@ -45,6 +50,9 @@ nf_ct_ecache_ext_add(struct nf_conn *ct, u16 ctmask, u16 expmask, gfp_t gfp)
                e->expmask = expmask;
        }
        return e;
+#else
+        return NULL;
+#endif
 };
 #ifdef CONFIG_NF_CONNTRACK_EVENTS
@@ -59,7 +67,7 @@ struct nf_ct_event_notifier {
        int (*fcn)(unsigned int events, struct nf_ct_event *item);
 };
-extern struct nf_ct_event_notifier *nf_conntrack_event_cb;
+extern struct nf_ct_event_notifier __rcu *nf_conntrack_event_cb;
 extern int nf_conntrack_register_notifier(struct nf_ct_event_notifier *nb);
 extern void nf_conntrack_unregister_notifier(struct nf_ct_event_notifier *nb);
@@ -156,7 +164,7 @@ struct nf_exp_event_notifier {
        int (*fcn)(unsigned int events, struct nf_exp_event *item);
 };
-extern struct nf_exp_event_notifier *nf_expect_event_cb;
+extern struct nf_exp_event_notifier __rcu *nf_expect_event_cb;
 extern int nf_ct_expect_register_notifier(struct nf_exp_event_notifier *nb);
 extern void nf_ct_expect_unregister_notifier(struct nf_exp_event_notifier *nb);
diff --git a/include/net/netfilter/nf_conntrack_extend.h b/include/net/netfilter/nf_conntrack_extend.h
index 0772d296dfdb..2dcf31703acb 100644
--- a/include/net/netfilter/nf_conntrack_extend.h
+++ b/include/net/netfilter/nf_conntrack_extend.h
@@ -7,10 +7,19 @@
 enum nf_ct_ext_id {
        NF_CT_EXT_HELPER,
+#if defined(CONFIG_NF_NAT) || defined(CONFIG_NF_NAT_MODULE)
        NF_CT_EXT_NAT,
+#endif
        NF_CT_EXT_ACCT,
+#ifdef CONFIG_NF_CONNTRACK_EVENTS
        NF_CT_EXT_ECACHE,
+#endif
+#ifdef CONFIG_NF_CONNTRACK_ZONES
        NF_CT_EXT_ZONE,
+#endif
+#ifdef CONFIG_NF_CONNTRACK_TIMESTAMP
+        NF_CT_EXT_TSTAMP,
+#endif
        NF_CT_EXT_NUM,
 };
@@ -19,6 +28,7 @@ enum nf_ct_ext_id {
 #define NF_CT_EXT_ACCT_TYPE struct nf_conn_counter
 #define NF_CT_EXT_ECACHE_TYPE struct nf_conntrack_ecache
 #define NF_CT_EXT_ZONE_TYPE struct nf_conntrack_zone
+#define NF_CT_EXT_TSTAMP_TYPE struct nf_conn_tstamp
 /* Extensions: optional stuff which isn't permanently in struct. */
 struct nf_ct_ext {
diff --git a/include/net/netfilter/nf_conntrack_helper.h b/include/net/netfilter/nf_conntrack_helper.h
index 32c305dbdab6..f1c1311adc2c 100644
--- a/include/net/netfilter/nf_conntrack_helper.h
+++ b/include/net/netfilter/nf_conntrack_helper.h
@@ -63,4 +63,10 @@ static inline struct nf_conn_help *nfct_help(const struct nf_conn *ct)
 extern int nf_conntrack_helper_init(void);
 extern void nf_conntrack_helper_fini(void);
+extern int nf_conntrack_broadcast_help(struct sk_buff *skb,
+                                       unsigned int protoff,
+                                       struct nf_conn *ct,
+                                       enum ip_conntrack_info ctinfo,
+                                       unsigned int timeout);
 #endif /*_NF_CONNTRACK_HELPER_H*/
diff --git a/include/net/netfilter/nf_conntrack_l3proto.h b/include/net/netfilter/nf_conntrack_l3proto.h
index a7547611e8f1..e8010f445ae1 100644
--- a/include/net/netfilter/nf_conntrack_l3proto.h
+++ b/include/net/netfilter/nf_conntrack_l3proto.h
@@ -73,7 +73,7 @@ struct nf_conntrack_l3proto {
        struct module *me;
 };
-extern struct nf_conntrack_l3proto *nf_ct_l3protos[AF_MAX];
+extern struct nf_conntrack_l3proto __rcu *nf_ct_l3protos[AF_MAX];
 /* Protocol registration. */
 extern int nf_conntrack_l3proto_register(struct nf_conntrack_l3proto *proto);
diff --git a/include/net/netfilter/nf_conntrack_timestamp.h b/include/net/netfilter/nf_conntrack_timestamp.h
new file mode 100644
index 000000000000..fc9c82b1f06b
--- /dev/null
+++ b/include/net/netfilter/nf_conntrack_timestamp.h
@@ -0,0 +1,65 @@
+#ifndef _NF_CONNTRACK_TSTAMP_H
+#define _NF_CONNTRACK_TSTAMP_H
+#include <net/net_namespace.h>
+#include <linux/netfilter/nf_conntrack_common.h>
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+#include <net/netfilter/nf_conntrack.h>
+#include <net/netfilter/nf_conntrack_extend.h>
+struct nf_conn_tstamp {
+        u_int64_t start;
+        u_int64_t stop;
+};
+static inline
+struct nf_conn_tstamp *nf_conn_tstamp_find(const struct nf_conn *ct)
+{
+#ifdef CONFIG_NF_CONNTRACK_TIMESTAMP
+        return nf_ct_ext_find(ct, NF_CT_EXT_TSTAMP);
+#else
+        return NULL;
+#endif
+}
+static inline
+struct nf_conn_tstamp *nf_ct_tstamp_ext_add(struct nf_conn *ct, gfp_t gfp)
+{
+#ifdef CONFIG_NF_CONNTRACK_TIMESTAMP
+        struct net *net = nf_ct_net(ct);
+        if (!net->ct.sysctl_tstamp)
+                return NULL;
+        return nf_ct_ext_add(ct, NF_CT_EXT_TSTAMP, gfp);
+#else
+        return NULL;
+#endif
+};
+static inline bool nf_ct_tstamp_enabled(struct net *net)
+{
+        return net->ct.sysctl_tstamp != 0;
+}
+static inline void nf_ct_set_tstamp(struct net *net, bool enable)
+{
+        net->ct.sysctl_tstamp = enable;
+}
+#ifdef CONFIG_NF_CONNTRACK_TIMESTAMP
+extern int nf_conntrack_tstamp_init(struct net *net);
+extern void nf_conntrack_tstamp_fini(struct net *net);
+#else
+static inline int nf_conntrack_tstamp_init(struct net *net)
+{
+        return 0;
+}
+static inline void nf_conntrack_tstamp_fini(struct net *net)
+{
+        return;
+}
+#endif /* CONFIG_NF_CONNTRACK_TIMESTAMP */
+#endif /* _NF_CONNTRACK_TSTAMP_H */
diff --git a/include/net/netfilter/nf_nat.h b/include/net/netfilter/nf_nat.h
index f5f09f032a90..aff80b190c12 100644
--- a/include/net/netfilter/nf_nat.h
+++ b/include/net/netfilter/nf_nat.h
@@ -56,7 +56,9 @@ struct nf_nat_multi_range_compat {
 /* per conntrack: nat application helper private data */
 union nf_conntrack_nat_help {
        /* insert nat helper private data here */
+#if defined(CONFIG_NF_NAT_PPTP) || defined(CONFIG_NF_NAT_PPTP_MODULE)
        struct nf_nat_pptp nat_pptp_info;
+#endif
 };
 struct nf_conn;
@@ -84,7 +86,11 @@ extern int nf_nat_used_tuple(const struct nf_conntrack_tuple *tuple,
 static inline struct nf_conn_nat *nfct_nat(const struct nf_conn *ct)
 {
+#if defined(CONFIG_NF_NAT) || defined(CONFIG_NF_NAT_MODULE)
        return nf_ct_ext_find(ct, NF_CT_EXT_NAT);
+#else
+        return NULL;
+#endif
 }
 #else  /* !__KERNEL__: iptables wants this to compile. */
diff --git a/include/net/netfilter/nf_nat_core.h b/include/net/netfilter/nf_nat_core.h
index 33602ab66190..3dc7b98effeb 100644
--- a/include/net/netfilter/nf_nat_core.h
+++ b/include/net/netfilter/nf_nat_core.h
@@ -21,9 +21,9 @@ static inline int nf_nat_initialized(struct nf_conn *ct,
                                     enum nf_nat_manip_type manip)
 {
        if (manip == IP_NAT_MANIP_SRC)
-                return test_bit(IPS_SRC_NAT_DONE_BIT, &ct->status);
+                return ct->status & IPS_SRC_NAT_DONE;
        else
-                return test_bit(IPS_DST_NAT_DONE_BIT, &ct->status);
+                return ct->status & IPS_DST_NAT_DONE;
 }
 struct nlattr;
diff --git a/include/net/netlink.h b/include/net/netlink.h
index 373f1a900cf4..8a3906a08f5f 100644
--- a/include/net/netlink.h
+++ b/include/net/netlink.h
@@ -856,18 +856,27 @@ static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
 #define NLA_PUT_BE16(skb, attrtype, value) \
        NLA_PUT_TYPE(skb, __be16, attrtype, value)
+#define NLA_PUT_NET16(skb, attrtype, value) \
+        NLA_PUT_BE16(skb, attrtype | NLA_F_NET_BYTEORDER, value)
 #define NLA_PUT_U32(skb, attrtype, value) \
        NLA_PUT_TYPE(skb, u32, attrtype, value)
 #define NLA_PUT_BE32(skb, attrtype, value) \
        NLA_PUT_TYPE(skb, __be32, attrtype, value)
+#define NLA_PUT_NET32(skb, attrtype, value) \
+        NLA_PUT_BE32(skb, attrtype | NLA_F_NET_BYTEORDER, value)
 #define NLA_PUT_U64(skb, attrtype, value) \
        NLA_PUT_TYPE(skb, u64, attrtype, value)
 #define NLA_PUT_BE64(skb, attrtype, value) \
        NLA_PUT_TYPE(skb, __be64, attrtype, value)
+#define NLA_PUT_NET64(skb, attrtype, value) \
+        NLA_PUT_BE64(skb, attrtype | NLA_F_NET_BYTEORDER, value)
 #define NLA_PUT_STRING(skb, attrtype, value) \
        NLA_PUT(skb, attrtype, strlen(value) + 1, value)
diff --git a/include/net/netns/conntrack.h b/include/net/netns/conntrack.h
index d4958d4c6574..341eb089349e 100644
--- a/include/net/netns/conntrack.h
+++ b/include/net/netns/conntrack.h
@@ -21,15 +21,15 @@ struct netns_ct {
        int                     sysctl_events;
        unsigned int            sysctl_events_retry_timeout;
        int                     sysctl_acct;
+        int                     sysctl_tstamp;
        int                     sysctl_checksum;
        unsigned int            sysctl_log_invalid; /* Log invalid packets */
 #ifdef CONFIG_SYSCTL
        struct ctl_table_header *sysctl_header;
        struct ctl_table_header *acct_sysctl_header;
+        struct ctl_table_header *tstamp_sysctl_header;
        struct ctl_table_header *event_sysctl_header;
 #endif
-        int                     hash_vmalloc;
-        int                     expect_vmalloc;
        char                    *slabname;
 };
 #endif
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index d68c3f121774..e2e2ef57eca2 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -43,7 +43,6 @@ struct netns_ipv4 {
        struct xt_table         *nat_table;
        struct hlist_head       *nat_bysource;
        unsigned int            nat_htable_size;
-        int                     nat_vmalloced;
 #endif
        int sysctl_icmp_echo_ignore_all;
diff --git a/include/net/phonet/pep.h b/include/net/phonet/pep.h
index b60b28c99e87..b669fe6dbc3b 100644
--- a/include/net/phonet/pep.h
+++ b/include/net/phonet/pep.h
@@ -28,7 +28,6 @@ struct pep_sock {
        /* XXX: union-ify listening vs connected stuff ? */
        /* Listening socket stuff: */
-        struct hlist_head       ackq;
        struct hlist_head       hlist;
        /* Connected socket stuff: */
@@ -45,10 +44,6 @@ struct pep_sock {
        u8                      tx_fc;  /* TX flow control */
        u8                      init_enable;    /* auto-enable at creation */
        u8                      aligned;
-#ifdef CONFIG_PHONET_PIPECTRLR
-        u8                      pipe_state;
-        struct sockaddr_pn      remote_pep;
-#endif
 };
 static inline struct pep_sock *pep_sk(struct sock *sk)
@@ -158,6 +153,7 @@ enum {
        PN_LEGACY_FLOW_CONTROL,
        PN_ONE_CREDIT_FLOW_CONTROL,
        PN_MULTI_CREDIT_FLOW_CONTROL,
+        PN_MAX_FLOW_CONTROL,
 };
 #define pn_flow_safe(fc) ((fc) >> 1)
@@ -169,21 +165,4 @@ enum {
        PEP_IND_READY,
 };
-#ifdef CONFIG_PHONET_PIPECTRLR
-#define PNS_PEP_CONNECT_UTID           0x02
-#define PNS_PIPE_CREATED_IND_UTID      0x04
-#define PNS_PIPE_ENABLE_UTID           0x0A
-#define PNS_PIPE_ENABLED_IND_UTID      0x0C
-#define PNS_PIPE_DISABLE_UTID          0x0F
-#define PNS_PIPE_DISABLED_IND_UTID     0x11
-#define PNS_PEP_DISCONNECT_UTID        0x06
-/* Used for tracking state of a pipe */
-enum {
-        PIPE_IDLE,
-        PIPE_DISABLED,
-        PIPE_ENABLED,
-};
-#endif /* CONFIG_PHONET_PIPECTRLR */
 #endif
diff --git a/include/net/phonet/phonet.h b/include/net/phonet/phonet.h
index 5395e09187df..68e509750caa 100644
--- a/include/net/phonet/phonet.h
+++ b/include/net/phonet/phonet.h
@@ -36,6 +36,7 @@
 struct pn_sock {
        struct sock     sk;
        u16             sobject;
+        u16             dobject;
        u8              resource;
 };
diff --git a/include/net/protocol.h b/include/net/protocol.h
index dc07495bce4c..6f7eb800974a 100644
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
@@ -38,7 +38,7 @@ struct net_protocol {
        void                    (*err_handler)(struct sk_buff *skb, u32 info);
        int                     (*gso_send_check)(struct sk_buff *skb);
        struct sk_buff         *(*gso_segment)(struct sk_buff *skb,
-                                               int features);
+                                               u32 features);
        struct sk_buff        **(*gro_receive)(struct sk_buff **head,
                                               struct sk_buff *skb);
        int                     (*gro_complete)(struct sk_buff *skb);
@@ -57,7 +57,7 @@ struct inet6_protocol {
        int     (*gso_send_check)(struct sk_buff *skb);
        struct sk_buff *(*gso_segment)(struct sk_buff *skb,
-                                       int features);
+                                       u32 features);
        struct sk_buff **(*gro_receive)(struct sk_buff **head,
                                        struct sk_buff *skb);
        int     (*gro_complete)(struct sk_buff *skb);
diff --git a/include/net/route.h b/include/net/route.h
index 93e10c453f6b..30d6cae3841a 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -49,36 +49,43 @@
 struct fib_nh;
 struct inet_peer;
+struct fib_info;
 struct rtable {
        struct dst_entry        dst;
-        /* Cache lookup keys */
+        /* Lookup key. */
-        struct flowi            fl;
+        __be32                  rt_key_dst;
+        __be32                  rt_key_src;
        int                     rt_genid;
        unsigned                rt_flags;
        __u16                   rt_type;
+        __u8                    rt_tos;
        __be32                  rt_dst; /* Path destination     */
        __be32                  rt_src; /* Path source          */
        int                     rt_iif;
+        int                     rt_oif;
+        __u32                   rt_mark;
        /* Info on neighbour */
        __be32                  rt_gateway;
        /* Miscellaneous cached information */
        __be32                  rt_spec_dst; /* RFC1122 specific destination */
+        u32                     rt_peer_genid;
        struct inet_peer        *peer; /* long-living peer info */
+        struct fib_info         *fi; /* for client ref to shared metrics */
 };
 static inline bool rt_is_input_route(struct rtable *rt)
 {
-        return rt->fl.iif != 0;
+        return rt->rt_iif != 0;
 }
 static inline bool rt_is_output_route(struct rtable *rt)
 {
-        return rt->fl.iif == 0;
+        return rt->rt_iif == 0;
 }
 struct ip_rt_acct {
@@ -115,9 +122,63 @@ extern void		ip_rt_redirect(__be32 old_gw, __be32 dst, __be32 new_gw,
                                       __be32 src, struct net_device *dev);
 extern void             rt_cache_flush(struct net *net, int how);
 extern void             rt_cache_flush_batch(struct net *net);
-extern int              __ip_route_output_key(struct net *, struct rtable **, const struct flowi *flp);
+extern struct rtable *__ip_route_output_key(struct net *, const struct flowi4 *flp);
-extern int              ip_route_output_key(struct net *, struct rtable **, struct flowi *flp);
+extern struct rtable *ip_route_output_flow(struct net *, struct flowi4 *flp,
-extern int              ip_route_output_flow(struct net *, struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
+                                           struct sock *sk);
+extern struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig);
+static inline struct rtable *ip_route_output_key(struct net *net, struct flowi4 *flp)
+{
+        return ip_route_output_flow(net, flp, NULL);
+}
+static inline struct rtable *ip_route_output(struct net *net, __be32 daddr,
+                                             __be32 saddr, u8 tos, int oif)
+{
+        struct flowi4 fl4 = {
+                .flowi4_oif = oif,
+                .daddr = daddr,
+                .saddr = saddr,
+                .flowi4_tos = tos,
+        };
+        return ip_route_output_key(net, &fl4);
+}
+static inline struct rtable *ip_route_output_ports(struct net *net, struct sock *sk,
+                                                   __be32 daddr, __be32 saddr,
+                                                   __be16 dport, __be16 sport,
+                                                   __u8 proto, __u8 tos, int oif)
+{
+        struct flowi4 fl4 = {
+                .flowi4_oif = oif,
+                .flowi4_flags = sk ? inet_sk_flowi_flags(sk) : 0,
+                .flowi4_mark = sk ? sk->sk_mark : 0,
+                .daddr = daddr,
+                .saddr = saddr,
+                .flowi4_tos = tos,
+                .flowi4_proto = proto,
+                .fl4_dport = dport,
+                .fl4_sport = sport,
+        };
+        if (sk)
+                security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
+        return ip_route_output_flow(net, &fl4, sk);
+}
+static inline struct rtable *ip_route_output_gre(struct net *net,
+                                                 __be32 daddr, __be32 saddr,
+                                                 __be32 gre_key, __u8 tos, int oif)
+{
+        struct flowi4 fl4 = {
+                .flowi4_oif = oif,
+                .daddr = daddr,
+                .saddr = saddr,
+                .flowi4_tos = tos,
+                .flowi4_proto = IPPROTO_GRE,
+                .fl4_gre_key = gre_key,
+        };
+        return ip_route_output_key(net, &fl4);
+}
 extern int ip_route_input_common(struct sk_buff *skb, __be32 dst, __be32 src,
                                 u8 tos, struct net_device *devin, bool noref);
@@ -162,57 +223,68 @@ static inline char rt_tos2priority(u8 tos)
        return ip_tos2prio[IPTOS_TOS(tos)>>1];
 }
-static inline int ip_route_connect(struct rtable **rp, __be32 dst,
+static inline struct rtable *ip_route_connect(__be32 dst, __be32 src, u32 tos,
-                                   __be32 src, u32 tos, int oif, u8 protocol,
+                                              int oif, u8 protocol,
-                                   __be16 sport, __be16 dport, struct sock *sk,
+                                              __be16 sport, __be16 dport,
-                                   int flags)
+                                              struct sock *sk, bool can_sleep)
 {
-        struct flowi fl = { .oif = oif,
+        struct flowi4 fl4 = {
-                            .mark = sk->sk_mark,
+                .flowi4_oif = oif,
-                            .fl4_dst = dst,
+                .flowi4_mark = sk->sk_mark,
-                            .fl4_src = src,
+                .daddr = dst,
-                            .fl4_tos = tos,
+                .saddr = src,
-                            .proto = protocol,
+                .flowi4_tos = tos,
-                            .fl_ip_sport = sport,
+                .flowi4_proto = protocol,
-                            .fl_ip_dport = dport };
+                .fl4_sport = sport,
-        int err;
+                .fl4_dport = dport,
+        };
        struct net *net = sock_net(sk);
+        struct rtable *rt;
        if (inet_sk(sk)->transparent)
-                fl.flags |= FLOWI_FLAG_ANYSRC;
+                fl4.flowi4_flags |= FLOWI_FLAG_ANYSRC;
+        if (protocol == IPPROTO_TCP)
+                fl4.flowi4_flags |= FLOWI_FLAG_PRECOW_METRICS;
+        if (can_sleep)
+                fl4.flowi4_flags |= FLOWI_FLAG_CAN_SLEEP;
        if (!dst || !src) {
-                err = __ip_route_output_key(net, rp, &fl);
+                rt = __ip_route_output_key(net, &fl4);
-                if (err)
+                if (IS_ERR(rt))
-                        return err;
+                        return rt;
-                fl.fl4_dst = (*rp)->rt_dst;
+                fl4.daddr = rt->rt_dst;
-                fl.fl4_src = (*rp)->rt_src;
+                fl4.saddr = rt->rt_src;
-                ip_rt_put(*rp);
+                ip_rt_put(rt);
-                *rp = NULL;
        }
-        security_sk_classify_flow(sk, &fl);
+        security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
-        return ip_route_output_flow(net, rp, &fl, sk, flags);
+        return ip_route_output_flow(net, &fl4, sk);
 }
-static inline int ip_route_newports(struct rtable **rp, u8 protocol,
+static inline struct rtable *ip_route_newports(struct rtable *rt,
-                                    __be16 sport, __be16 dport, struct sock *sk)
+                                               u8 protocol, __be16 orig_sport,
+                                               __be16 orig_dport, __be16 sport,
+                                               __be16 dport, struct sock *sk)
 {
-        if (sport != (*rp)->fl.fl_ip_sport ||
+        if (sport != orig_sport || dport != orig_dport) {
-            dport != (*rp)->fl.fl_ip_dport) {
+                struct flowi4 fl4 = {
-                struct flowi fl;
+                        .flowi4_oif = rt->rt_oif,
+                        .flowi4_mark = rt->rt_mark,
-                memcpy(&fl, &(*rp)->fl, sizeof(fl));
+                        .daddr = rt->rt_key_dst,
-                fl.fl_ip_sport = sport;
+                        .saddr = rt->rt_key_src,
-                fl.fl_ip_dport = dport;
+                        .flowi4_tos = rt->rt_tos,
-                fl.proto = protocol;
+                        .flowi4_proto = protocol,
+                        .fl4_sport = sport,
+                        .fl4_dport = dport
+                };
                if (inet_sk(sk)->transparent)
-                        fl.flags |= FLOWI_FLAG_ANYSRC;
+                        fl4.flowi4_flags |= FLOWI_FLAG_ANYSRC;
-                ip_rt_put(*rp);
+                if (protocol == IPPROTO_TCP)
-                *rp = NULL;
+                        fl4.flowi4_flags |= FLOWI_FLAG_PRECOW_METRICS;
-                security_sk_classify_flow(sk, &fl);
+                ip_rt_put(rt);
-                return ip_route_output_flow(sock_net(sk), rp, &fl, sk, 0);
+                security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
+                return ip_route_output_flow(sock_net(sk), &fl4, sk);
        }
-        return 0;
+        return rt;
 }
 extern void rt_bind_peer(struct rtable *rt, int create);
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 04f8556313d5..a9505b6a18e3 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -31,10 +31,12 @@ enum qdisc_state_t {
 * following bits are only changed while qdisc lock is held
 */
 enum qdisc___state_t {
-        __QDISC___STATE_RUNNING,
+        __QDISC___STATE_RUNNING = 1,
+        __QDISC___STATE_THROTTLED = 2,
 };
 struct qdisc_size_table {
+        struct rcu_head         rcu;
        struct list_head        list;
        struct tc_sizespec      szopts;
        int                     refcnt;
@@ -46,14 +48,13 @@ struct Qdisc {
        struct sk_buff *        (*dequeue)(struct Qdisc *dev);
        unsigned                flags;
 #define TCQ_F_BUILTIN           1
-#define TCQ_F_THROTTLED         2
+#define TCQ_F_INGRESS           2
-#define TCQ_F_INGRESS           4
+#define TCQ_F_CAN_BYPASS        4
-#define TCQ_F_CAN_BYPASS        8
+#define TCQ_F_MQROOT            8
-#define TCQ_F_MQROOT            16
 #define TCQ_F_WARN_NONWC        (1 << 16)
        int                     padded;
        struct Qdisc_ops        *ops;
-        struct qdisc_size_table *stab;
+        struct qdisc_size_table __rcu *stab;
        struct list_head        list;
        u32                     handle;
        u32                     parent;
@@ -78,25 +79,44 @@ struct Qdisc {
        unsigned long           state;
        struct sk_buff_head     q;
        struct gnet_stats_basic_packed bstats;
-        unsigned long           __state;
+        unsigned int            __state;
        struct gnet_stats_queue qstats;
        struct rcu_head         rcu_head;
        spinlock_t              busylock;
+        u32                     limit;
 };
-static inline bool qdisc_is_running(struct Qdisc *qdisc)
+static inline bool qdisc_is_running(const struct Qdisc *qdisc)
 {
-        return test_bit(__QDISC___STATE_RUNNING, &qdisc->__state);
+        return (qdisc->__state & __QDISC___STATE_RUNNING) ? true : false;
 }
 static inline bool qdisc_run_begin(struct Qdisc *qdisc)
 {
-        return !__test_and_set_bit(__QDISC___STATE_RUNNING, &qdisc->__state);
+        if (qdisc_is_running(qdisc))
+                return false;
+        qdisc->__state |= __QDISC___STATE_RUNNING;
+        return true;
 }
 static inline void qdisc_run_end(struct Qdisc *qdisc)
 {
-        __clear_bit(__QDISC___STATE_RUNNING, &qdisc->__state);
+        qdisc->__state &= ~__QDISC___STATE_RUNNING;
+}
+static inline bool qdisc_is_throttled(const struct Qdisc *qdisc)
+{
+        return (qdisc->__state & __QDISC___STATE_THROTTLED) ? true : false;
+}
+static inline void qdisc_throttled(struct Qdisc *qdisc)
+{
+        qdisc->__state |= __QDISC___STATE_THROTTLED;
+}
+static inline void qdisc_unthrottled(struct Qdisc *qdisc)
+{
+        qdisc->__state &= ~__QDISC___STATE_THROTTLED;
 }
 struct Qdisc_class_ops {
@@ -331,8 +351,8 @@ extern struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
                                 struct Qdisc_ops *ops);
 extern struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
                                       struct Qdisc_ops *ops, u32 parentid);
-extern void qdisc_calculate_pkt_len(struct sk_buff *skb,
+extern void __qdisc_calculate_pkt_len(struct sk_buff *skb,
-                                   struct qdisc_size_table *stab);
+                                      const struct qdisc_size_table *stab);
 extern void tcf_destroy(struct tcf_proto *tp);
 extern void tcf_destroy_chain(struct tcf_proto **fl);
@@ -411,12 +431,20 @@ enum net_xmit_qdisc_t {
 #define net_xmit_drop_count(e)  (1)
 #endif
-static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
+static inline void qdisc_calculate_pkt_len(struct sk_buff *skb,
+                                           const struct Qdisc *sch)
 {
 #ifdef CONFIG_NET_SCHED
-        if (sch->stab)
+        struct qdisc_size_table *stab = rcu_dereference_bh(sch->stab);
-                qdisc_calculate_pkt_len(skb, sch->stab);
+        if (stab)
+                __qdisc_calculate_pkt_len(skb, stab);
 #endif
+}
+static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
+{
+        qdisc_calculate_pkt_len(skb, sch);
        return sch->enqueue(skb, sch);
 }
diff --git a/include/net/sock.h b/include/net/sock.h
index bc1cf7d88ccb..da0534d3401c 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -281,7 +281,7 @@ struct sock {
        int                     sk_rcvbuf;
        struct sk_filter __rcu  *sk_filter;
-        struct socket_wq        *sk_wq;
+        struct socket_wq __rcu  *sk_wq;
 #ifdef CONFIG_NET_DMA
        struct sk_buff_head     sk_async_wait_queue;
@@ -1191,7 +1191,7 @@ extern void sk_filter_release_rcu(struct rcu_head *rcu);
 static inline void sk_filter_release(struct sk_filter *fp)
 {
        if (atomic_dec_and_test(&fp->refcnt))
-                call_rcu_bh(&fp->rcu, sk_filter_release_rcu);
+                call_rcu(&fp->rcu, sk_filter_release_rcu);
 }
 static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
@@ -1266,7 +1266,8 @@ static inline void sk_set_socket(struct sock *sk, struct socket *sock)
 static inline wait_queue_head_t *sk_sleep(struct sock *sk)
 {
-        return &sk->sk_wq->wait;
+        BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0);
+        return &rcu_dereference_raw(sk->sk_wq)->wait;
 }
 /* Detach socket from process context.
 * Announce socket dead, detach it from wait queue and inode.
@@ -1287,7 +1288,7 @@ static inline void sock_orphan(struct sock *sk)
 static inline void sock_graft(struct sock *sk, struct socket *parent)
 {
        write_lock_bh(&sk->sk_callback_lock);
-        rcu_assign_pointer(sk->sk_wq, parent->wq);
+        sk->sk_wq = parent->wq;
        parent->sk = sk;
        sk_set_socket(sk, parent);
        security_sock_graft(sk, parent);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 38509f047382..cda30ea354a2 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -196,6 +196,9 @@ extern void tcp_time_wait(struct sock *sk, int state, int timeo);
 /* TCP thin-stream limits */
 #define TCP_THIN_LINEAR_RETRIES 6       /* After 6 linear retries, do exp. backoff */
+/* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */
+#define TCP_INIT_CWND           10
 extern struct inet_timewait_death_row tcp_death_row;
 /* sysctl variables for tcp */
@@ -799,15 +802,6 @@ static inline __u32 tcp_current_ssthresh(const struct sock *sk)
 /* Use define here intentionally to get WARN_ON location shown at the caller */
 #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out)
-/*
- * Convert RFC 3390 larger initial window into an equivalent number of packets.
- * This is based on the numbers specified in RFC 5681, 3.1.
- */
-static inline u32 rfc3390_bytes_to_packets(const u32 smss)
-{
-        return smss <= 1095 ? 4 : (smss > 2190 ? 2 : 3);
-}
 extern void tcp_enter_cwr(struct sock *sk, const int set_ssthresh);
 extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst);
@@ -1074,8 +1068,6 @@ static inline int tcp_paws_reject(const struct tcp_options_received *rx_opt,
        return 1;
 }
-#define TCP_CHECK_TIMER(sk) do { } while (0)
 static inline void tcp_mib_init(struct net *net)
 {
        /* See RFC 2012 */
@@ -1404,7 +1396,7 @@ extern struct request_sock_ops tcp6_request_sock_ops;
 extern void tcp_v4_destroy_sock(struct sock *sk);
 extern int tcp_v4_gso_send_check(struct sk_buff *skb);
-extern struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features);
+extern struct sk_buff *tcp_tso_segment(struct sk_buff *skb, u32 features);
 extern struct sk_buff **tcp_gro_receive(struct sk_buff **head,
                                        struct sk_buff *skb);
 extern struct sk_buff **tcp4_gro_receive(struct sk_buff **head,
diff --git a/include/net/transp_v6.h b/include/net/transp_v6.h
index 42a0eb68b7b6..eeb077dd735f 100644
--- a/include/net/transp_v6.h
+++ b/include/net/transp_v6.h
@@ -14,7 +14,7 @@ extern struct proto udpv6_prot;
 extern struct proto udplitev6_prot;
 extern struct proto tcpv6_prot;
-struct flowi;
+struct flowi6;
 /* extention headers */
 extern int                              ipv6_exthdrs_init(void);
@@ -42,7 +42,7 @@ extern int			datagram_recv_ctl(struct sock *sk,
 extern int                      datagram_send_ctl(struct net *net,
                                                  struct msghdr *msg,
-                                                  struct flowi *fl,
+                                                  struct flowi6 *fl6,
                                                  struct ipv6_txoptions *opt,
                                                  int *hlimit, int *tclass,
                                                  int *dontfrag);
diff --git a/include/net/udp.h b/include/net/udp.h
index bb967dd59bf7..67ea6fcb3ec0 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -144,6 +144,17 @@ static inline __wsum udp_csum_outgoing(struct sock *sk, struct sk_buff *skb)
        return csum;
 }
+static inline __wsum udp_csum(struct sk_buff *skb)
+{
+        __wsum csum = csum_partial(skb_transport_header(skb),
+                                   sizeof(struct udphdr), skb->csum);
+        for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next) {
+                csum = csum_add(csum, skb->csum);
+        }
+        return csum;
+}
 /* hash routines shared between UDPv4/6 and UDP-Litev4/6 */
 static inline void udp_lib_hash(struct sock *sk)
 {
@@ -245,5 +256,5 @@ extern void udp4_proc_exit(void);
 extern void udp_init(void);
 extern int udp4_ufo_send_check(struct sk_buff *skb);
-extern struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, int features);
+extern struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, u32 features);
 #endif  /* _UDP_H */
diff --git a/include/net/udplite.h b/include/net/udplite.h
index afdffe607b24..673a024c6b2a 100644
--- a/include/net/udplite.h
+++ b/include/net/udplite.h
@@ -115,6 +115,18 @@ static inline __wsum udplite_csum_outgoing(struct sock *sk, struct sk_buff *skb)
        return csum;
 }
+static inline __wsum udplite_csum(struct sk_buff *skb)
+{
+        struct sock *sk = skb->sk;
+        int cscov = udplite_sender_cscov(udp_sk(sk), udp_hdr(skb));
+        const int off = skb_transport_offset(skb);
+        const int len = skb->len - off;
+        skb->ip_summed = CHECKSUM_NONE;     /* no HW support for checksumming */
+        return skb_checksum(skb, off, min(cscov, len), 0);
+}
 extern void     udplite4_register(void);
 extern int      udplite_get_port(struct sock *sk, unsigned short snum,
                        int (*scmp)(const struct sock *, const struct sock *));
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index b9f385da758e..42a8c32a10e2 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -36,6 +36,7 @@
 #define XFRM_PROTO_ROUTING      IPPROTO_ROUTING
 #define XFRM_PROTO_DSTOPTS      IPPROTO_DSTOPTS
+#define XFRM_ALIGN4(len)        (((len) + 3) & ~3)
 #define XFRM_ALIGN8(len)        (((len) + 7) & ~7)
 #define MODULE_ALIAS_XFRM_MODE(family, encap) \
        MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
@@ -185,9 +186,14 @@ struct xfrm_state {
        /* State for replay detection */
        struct xfrm_replay_state replay;
+        struct xfrm_replay_state_esn *replay_esn;
        /* Replay detection state at the time we sent the last notification */
        struct xfrm_replay_state preplay;
+        struct xfrm_replay_state_esn *preplay_esn;
+        /* The functions for replay detection. */
+        struct xfrm_replay      *repl;
        /* internal flag that only holds state for delayed aevent at the
         * moment
@@ -258,6 +264,15 @@ struct km_event {
        struct net *net;
 };
+struct xfrm_replay {
+        void    (*advance)(struct xfrm_state *x, __be32 net_seq);
+        int     (*check)(struct xfrm_state *x,
+                         struct sk_buff *skb,
+                         __be32 net_seq);
+        void    (*notify)(struct xfrm_state *x, int event);
+        int     (*overflow)(struct xfrm_state *x, struct sk_buff *skb);
+};
 struct net_device;
 struct xfrm_type;
 struct xfrm_dst;
@@ -266,25 +281,26 @@ struct xfrm_policy_afinfo {
        struct dst_ops          *dst_ops;
        void                    (*garbage_collect)(struct net *net);
        struct dst_entry        *(*dst_lookup)(struct net *net, int tos,
-                                               xfrm_address_t *saddr,
+                                               const xfrm_address_t *saddr,
-                                               xfrm_address_t *daddr);
+                                               const xfrm_address_t *daddr);
        int                     (*get_saddr)(struct net *net, xfrm_address_t *saddr, xfrm_address_t *daddr);
        void                    (*decode_session)(struct sk_buff *skb,
                                                  struct flowi *fl,
                                                  int reverse);
-        int                     (*get_tos)(struct flowi *fl);
+        int                     (*get_tos)(const struct flowi *fl);
        int                     (*init_path)(struct xfrm_dst *path,
                                             struct dst_entry *dst,
                                             int nfheader_len);
        int                     (*fill_dst)(struct xfrm_dst *xdst,
                                            struct net_device *dev,
-                                            struct flowi *fl);
+                                            const struct flowi *fl);
+        struct dst_entry        *(*blackhole_route)(struct net *net, struct dst_entry *orig);
 };
 extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
-extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
+extern void km_policy_notify(struct xfrm_policy *xp, int dir, const struct km_event *c);
-extern void km_state_notify(struct xfrm_state *x, struct km_event *c);
+extern void km_state_notify(struct xfrm_state *x, const struct km_event *c);
 struct xfrm_tmpl;
 extern int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
@@ -299,9 +315,12 @@ struct xfrm_state_afinfo {
        const struct xfrm_type  *type_map[IPPROTO_MAX];
        struct xfrm_mode        *mode_map[XFRM_MODE_MAX];
        int                     (*init_flags)(struct xfrm_state *x);
-        void                    (*init_tempsel)(struct xfrm_selector *sel, struct flowi *fl);
+        void                    (*init_tempsel)(struct xfrm_selector *sel,
-        void                    (*init_temprop)(struct xfrm_state *x, struct xfrm_tmpl *tmpl,
+                                                const struct flowi *fl);
-                                                xfrm_address_t *daddr, xfrm_address_t *saddr);
+        void                    (*init_temprop)(struct xfrm_state *x,
+                                                const struct xfrm_tmpl *tmpl,
+                                                const xfrm_address_t *daddr,
+                                                const xfrm_address_t *saddr);
        int                     (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n);
        int                     (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);
        int                     (*output)(struct sk_buff *skb);
@@ -332,7 +351,8 @@ struct xfrm_type {
        void                    (*destructor)(struct xfrm_state *);
        int                     (*input)(struct xfrm_state *, struct sk_buff *skb);
        int                     (*output)(struct xfrm_state *, struct sk_buff *pskb);
-        int                     (*reject)(struct xfrm_state *, struct sk_buff *, struct flowi *);
+        int                     (*reject)(struct xfrm_state *, struct sk_buff *,
+                                          const struct flowi *);
        int                     (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
        /* Estimate maximal size of result of transformation of a dgram */
        u32                     (*get_mtu)(struct xfrm_state *, int size);
@@ -501,7 +521,7 @@ struct xfrm_policy {
        struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
 };
-static inline struct net *xp_net(struct xfrm_policy *xp)
+static inline struct net *xp_net(const struct xfrm_policy *xp)
 {
        return read_pnet(&xp->xp_net);
 }
@@ -545,13 +565,17 @@ struct xfrm_migrate {
 struct xfrm_mgr {
        struct list_head        list;
        char                    *id;
-        int                     (*notify)(struct xfrm_state *x, struct km_event *c);
+        int                     (*notify)(struct xfrm_state *x, const struct km_event *c);
        int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
        struct xfrm_policy      *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
        int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
-        int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
+        int                     (*notify_policy)(struct xfrm_policy *x, int dir, const struct km_event *c);
        int                     (*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
-        int                     (*migrate)(struct xfrm_selector *sel, u8 dir, u8 type, struct xfrm_migrate *m, int num_bundles, struct xfrm_kmaddress *k);
+        int                     (*migrate)(const struct xfrm_selector *sel,
+                                           u8 dir, u8 type,
+                                           const struct xfrm_migrate *m,
+                                           int num_bundles,
+                                           const struct xfrm_kmaddress *k);
 };
 extern int xfrm_register_km(struct xfrm_mgr *km);
@@ -570,8 +594,14 @@ struct xfrm_skb_cb {
        /* Sequence number for replay protection. */
        union {
-                u64 output;
+                struct {
-                __be32 input;
+                        __u32 low;
+                        __u32 hi;
+                } output;
+                struct {
+                        __be32 low;
+                        __be32 hi;
+                } input;
        } seq;
 };
@@ -675,6 +705,8 @@ extern void xfrm_audit_state_delete(struct xfrm_state *x, int result,
                                    u32 auid, u32 ses, u32 secid);
 extern void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
                                             struct sk_buff *skb);
+extern void xfrm_audit_state_replay(struct xfrm_state *x,
+                                    struct sk_buff *skb, __be32 net_seq);
 extern void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
 extern void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
                                      __be32 net_spi, __be32 net_seq);
@@ -707,6 +739,11 @@ static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
 {
 }
+static inline void xfrm_audit_state_replay(struct xfrm_state *x,
+                                           struct sk_buff *skb, __be32 net_seq)
+{
+}
 static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
                                      u16 family)
 {
@@ -762,10 +799,11 @@ static inline void xfrm_state_hold(struct xfrm_state *x)
        atomic_inc(&x->refcnt);
 }
-static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
+static inline bool addr_match(const void *token1, const void *token2,
+                              int prefixlen)
 {
-        __be32 *a1 = token1;
+        const __be32 *a1 = token1;
-        __be32 *a2 = token2;
+        const __be32 *a2 = token2;
        int pdw;
        int pbi;
@@ -774,7 +812,7 @@ static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
        if (pdw)
                if (memcmp(a1, a2, pdw << 2))
-                        return 0;
+                        return false;
        if (pbi) {
                __be32 mask;
@@ -782,32 +820,32 @@ static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
                mask = htonl((0xffffffff) << (32 - pbi));
                if ((a1[pdw] ^ a2[pdw]) & mask)
-                        return 0;
+                        return false;
        }
-        return 1;
+        return true;
 }
 static __inline__
-__be16 xfrm_flowi_sport(struct flowi *fl)
+__be16 xfrm_flowi_sport(const struct flowi *fl, const union flowi_uli *uli)
 {
        __be16 port;
-        switch(fl->proto) {
+        switch(fl->flowi_proto) {
        case IPPROTO_TCP:
        case IPPROTO_UDP:
        case IPPROTO_UDPLITE:
        case IPPROTO_SCTP:
-                port = fl->fl_ip_sport;
+                port = uli->ports.sport;
                break;
        case IPPROTO_ICMP:
        case IPPROTO_ICMPV6:
-                port = htons(fl->fl_icmp_type);
+                port = htons(uli->icmpt.type);
                break;
        case IPPROTO_MH:
-                port = htons(fl->fl_mh_type);
+                port = htons(uli->mht.type);
                break;
        case IPPROTO_GRE:
-                port = htons(ntohl(fl->fl_gre_key) >> 16);
+                port = htons(ntohl(uli->gre_key) >> 16);
                break;
        default:
                port = 0;       /*XXX*/
@@ -816,22 +854,22 @@ __be16 xfrm_flowi_sport(struct flowi *fl)
 }
 static __inline__
-__be16 xfrm_flowi_dport(struct flowi *fl)
+__be16 xfrm_flowi_dport(const struct flowi *fl, const union flowi_uli *uli)
 {
        __be16 port;
-        switch(fl->proto) {
+        switch(fl->flowi_proto) {
        case IPPROTO_TCP:
        case IPPROTO_UDP:
        case IPPROTO_UDPLITE:
        case IPPROTO_SCTP:
-                port = fl->fl_ip_dport;
+                port = uli->ports.dport;
                break;
        case IPPROTO_ICMP:
        case IPPROTO_ICMPV6:
-                port = htons(fl->fl_icmp_code);
+                port = htons(uli->icmpt.code);
                break;
        case IPPROTO_GRE:
-                port = htons(ntohl(fl->fl_gre_key) & 0xffff);
+                port = htons(ntohl(uli->gre_key) & 0xffff);
                break;
        default:
                port = 0;       /*XXX*/
@@ -839,7 +877,8 @@ __be16 xfrm_flowi_dport(struct flowi *fl)
        return port;
 }
-extern int xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
+extern int xfrm_selector_match(const struct xfrm_selector *sel,
+                               const struct flowi *fl,
                               unsigned short family);
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
@@ -947,7 +986,7 @@ secpath_reset(struct sk_buff *skb)
 }
 static inline int
-xfrm_addr_any(xfrm_address_t *addr, unsigned short family)
+xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
 {
        switch (family) {
        case AF_INET:
@@ -959,21 +998,21 @@ xfrm_addr_any(xfrm_address_t *addr, unsigned short family)
 }
 static inline int
-__xfrm4_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
+__xfrm4_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
 {
        return  (tmpl->saddr.a4 &&
                 tmpl->saddr.a4 != x->props.saddr.a4);
 }
 static inline int
-__xfrm6_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
+__xfrm6_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
 {
        return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
                 ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
 }
 static inline int
-xfrm_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x, unsigned short family)
+xfrm_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x, unsigned short family)
 {
        switch (family) {
        case AF_INET:
@@ -1126,49 +1165,49 @@ static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
 #endif
 static __inline__
-xfrm_address_t *xfrm_flowi_daddr(struct flowi *fl, unsigned short family)
+xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
 {
        switch (family){
        case AF_INET:
-                return (xfrm_address_t *)&fl->fl4_dst;
+                return (xfrm_address_t *)&fl->u.ip4.daddr;
        case AF_INET6:
-                return (xfrm_address_t *)&fl->fl6_dst;
+                return (xfrm_address_t *)&fl->u.ip6.daddr;
        }
        return NULL;
 }
 static __inline__
-xfrm_address_t *xfrm_flowi_saddr(struct flowi *fl, unsigned short family)
+xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
 {
        switch (family){
        case AF_INET:
-                return (xfrm_address_t *)&fl->fl4_src;
+                return (xfrm_address_t *)&fl->u.ip4.saddr;
        case AF_INET6:
-                return (xfrm_address_t *)&fl->fl6_src;
+                return (xfrm_address_t *)&fl->u.ip6.saddr;
        }
        return NULL;
 }
 static __inline__
-void xfrm_flowi_addr_get(struct flowi *fl,
+void xfrm_flowi_addr_get(const struct flowi *fl,
                         xfrm_address_t *saddr, xfrm_address_t *daddr,
                         unsigned short family)
 {
        switch(family) {
        case AF_INET:
-                memcpy(&saddr->a4, &fl->fl4_src, sizeof(saddr->a4));
+                memcpy(&saddr->a4, &fl->u.ip4.saddr, sizeof(saddr->a4));
-                memcpy(&daddr->a4, &fl->fl4_dst, sizeof(daddr->a4));
+                memcpy(&daddr->a4, &fl->u.ip4.daddr, sizeof(daddr->a4));
                break;
        case AF_INET6:
-                ipv6_addr_copy((struct in6_addr *)&saddr->a6, &fl->fl6_src);
+                ipv6_addr_copy((struct in6_addr *)&saddr->a6, &fl->u.ip6.saddr);
-                ipv6_addr_copy((struct in6_addr *)&daddr->a6, &fl->fl6_dst);
+                ipv6_addr_copy((struct in6_addr *)&daddr->a6, &fl->u.ip6.daddr);
                break;
        }
 }
 static __inline__ int
-__xfrm4_state_addr_check(struct xfrm_state *x,
+__xfrm4_state_addr_check(const struct xfrm_state *x,
-                         xfrm_address_t *daddr, xfrm_address_t *saddr)
+                         const xfrm_address_t *daddr, const xfrm_address_t *saddr)
 {
        if (daddr->a4 == x->id.daddr.a4 &&
            (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
@@ -1177,8 +1216,8 @@ __xfrm4_state_addr_check(struct xfrm_state *x,
 }
 static __inline__ int
-__xfrm6_state_addr_check(struct xfrm_state *x,
+__xfrm6_state_addr_check(const struct xfrm_state *x,
-                         xfrm_address_t *daddr, xfrm_address_t *saddr)
+                         const xfrm_address_t *daddr, const xfrm_address_t *saddr)
 {
        if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
            (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)|| 
@@ -1189,8 +1228,8 @@ __xfrm6_state_addr_check(struct xfrm_state *x,
 }
 static __inline__ int
-xfrm_state_addr_check(struct xfrm_state *x,
+xfrm_state_addr_check(const struct xfrm_state *x,
-                      xfrm_address_t *daddr, xfrm_address_t *saddr,
+                      const xfrm_address_t *daddr, const xfrm_address_t *saddr,
                      unsigned short family)
 {
        switch (family) {
@@ -1203,23 +1242,23 @@ xfrm_state_addr_check(struct xfrm_state *x,
 }
 static __inline__ int
-xfrm_state_addr_flow_check(struct xfrm_state *x, struct flowi *fl,
+xfrm_state_addr_flow_check(const struct xfrm_state *x, const struct flowi *fl,
                           unsigned short family)
 {
        switch (family) {
        case AF_INET:
                return __xfrm4_state_addr_check(x,
-                                                (xfrm_address_t *)&fl->fl4_dst,
+                                                (const xfrm_address_t *)&fl->u.ip4.daddr,
-                                                (xfrm_address_t *)&fl->fl4_src);
+                                                (const xfrm_address_t *)&fl->u.ip4.saddr);
        case AF_INET6:
                return __xfrm6_state_addr_check(x,
-                                                (xfrm_address_t *)&fl->fl6_dst,
+                                                (const xfrm_address_t *)&fl->u.ip6.daddr,
-                                                (xfrm_address_t *)&fl->fl6_src);
+                                                (const xfrm_address_t *)&fl->u.ip6.saddr);
        }
        return 0;
 }
-static inline int xfrm_state_kern(struct xfrm_state *x)
+static inline int xfrm_state_kern(const struct xfrm_state *x)
 {
        return atomic_read(&x->tunnel_users);
 }
@@ -1323,8 +1362,10 @@ extern int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
                           int (*func)(struct xfrm_state *, int, void*), void *);
 extern void xfrm_state_walk_done(struct xfrm_state_walk *walk);
 extern struct xfrm_state *xfrm_state_alloc(struct net *net);
-extern struct xfrm_state *xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr, 
+extern struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
-                                          struct flowi *fl, struct xfrm_tmpl *tmpl,
+                                          const xfrm_address_t *saddr,
+                                          const struct flowi *fl,
+                                          struct xfrm_tmpl *tmpl,
                                          struct xfrm_policy *pol, int *err,
                                          unsigned short family);
 extern struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark,
@@ -1337,11 +1378,11 @@ extern void xfrm_state_insert(struct xfrm_state *x);
 extern int xfrm_state_add(struct xfrm_state *x);
 extern int xfrm_state_update(struct xfrm_state *x);
 extern struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
-                                            xfrm_address_t *daddr, __be32 spi,
+                                            const xfrm_address_t *daddr, __be32 spi,
                                            u8 proto, unsigned short family);
 extern struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
-                                                   xfrm_address_t *daddr,
+                                                   const xfrm_address_t *daddr,
-                                                   xfrm_address_t *saddr,
+                                                   const xfrm_address_t *saddr,
                                                   u8 proto,
                                                   unsigned short family);
 #ifdef CONFIG_XFRM_SUB_POLICY
@@ -1386,10 +1427,8 @@ extern int xfrm_state_delete(struct xfrm_state *x);
 extern int xfrm_state_flush(struct net *net, u8 proto, struct xfrm_audit *audit_info);
 extern void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
 extern void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
-extern int xfrm_replay_check(struct xfrm_state *x,
+extern u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
-                             struct sk_buff *skb, __be32 seq);
+extern int xfrm_init_replay(struct xfrm_state *x);
-extern void xfrm_replay_advance(struct xfrm_state *x, __be32 seq);
-extern void xfrm_replay_notify(struct xfrm_state *x, int event);
 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
 extern int xfrm_init_state(struct xfrm_state *x);
 extern int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb);
@@ -1468,19 +1507,19 @@ u32 xfrm_get_acqseq(void);
 extern int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
 struct xfrm_state *xfrm_find_acq(struct net *net, struct xfrm_mark *mark,
                                 u8 mode, u32 reqid, u8 proto,
-                                 xfrm_address_t *daddr,
+                                 const xfrm_address_t *daddr,
-                                 xfrm_address_t *saddr, int create,
+                                 const xfrm_address_t *saddr, int create,
                                 unsigned short family);
 extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
 #ifdef CONFIG_XFRM_MIGRATE
-extern int km_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
+extern int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
-                      struct xfrm_migrate *m, int num_bundles,
+                      const struct xfrm_migrate *m, int num_bundles,
-                      struct xfrm_kmaddress *k);
+                      const struct xfrm_kmaddress *k);
 extern struct xfrm_state * xfrm_migrate_state_find(struct xfrm_migrate *m);
 extern struct xfrm_state * xfrm_state_migrate(struct xfrm_state *x,
                                              struct xfrm_migrate *m);
-extern int xfrm_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
+extern int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
                        struct xfrm_migrate *m, int num_bundles,
                        struct xfrm_kmaddress *k);
 #endif
@@ -1500,10 +1539,10 @@ extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
 extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
 extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
 extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
-extern struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe);
+extern struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
-extern struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe);
+extern struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
-extern struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe);
+extern struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
-extern struct xfrm_algo_desc *xfrm_aead_get_byname(char *name, int icv_len,
+extern struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
                                                   int probe);
 struct hash_desc;
@@ -1511,7 +1550,8 @@ struct scatterlist;
 typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
                              unsigned int);
-static inline int xfrm_addr_cmp(xfrm_address_t *a, xfrm_address_t *b,
+static inline int xfrm_addr_cmp(const xfrm_address_t *a,
+                                const xfrm_address_t *b,
                                int family)
 {
        switch (family) {
@@ -1544,16 +1584,21 @@ static inline int xfrm_aevent_is_on(struct net *net)
 }
 #endif
-static inline int xfrm_alg_len(struct xfrm_algo *alg)
+static inline int xfrm_alg_len(const struct xfrm_algo *alg)
 {
        return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
 }
-static inline int xfrm_alg_auth_len(struct xfrm_algo_auth *alg)
+static inline int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
 {
        return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
 }
+static inline int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
+{
+        return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
+}
 #ifdef CONFIG_XFRM_MIGRATE
 static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
 {
@@ -1597,7 +1642,7 @@ static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
        return m->v & m->m;
 }
-static inline int xfrm_mark_put(struct sk_buff *skb, struct xfrm_mark *m)
+static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
 {
        if (m->m | m->v)
                NLA_PUT(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
diff --git a/include/xen/events.h b/include/xen/events.h
index 962da2ced5b4..d3b9010ee96a 100644
--- a/include/xen/events.h
+++ b/include/xen/events.h
@@ -23,6 +23,12 @@ int bind_ipi_to_irqhandler(enum ipi_vector ipi,
                           unsigned long irqflags,
                           const char *devname,
                           void *dev_id);
+int bind_interdomain_evtchn_to_irqhandler(unsigned int remote_domain,
+                                          unsigned int remote_port,
+                                          irq_handler_t handler,
+                                          unsigned long irqflags,
+                                          const char *devname,
+                                          void *dev_id);
 /*
 * Common unbind function for all event sources. Takes IRQ to unbind from.
diff --git a/include/xen/interface/io/netif.h b/include/xen/interface/io/netif.h
index 518481c95f18..cb94668f6e9f 100644
--- a/include/xen/interface/io/netif.h
+++ b/include/xen/interface/io/netif.h
@@ -22,50 +22,50 @@
 /*
 * This is the 'wire' format for packets:
- *  Request 1: netif_tx_request -- NETTXF_* (any flags)
+ *  Request 1: xen_netif_tx_request  -- XEN_NETTXF_* (any flags)
- * [Request 2: netif_tx_extra]  (only if request 1 has NETTXF_extra_info)
+ * [Request 2: xen_netif_extra_info]    (only if request 1 has XEN_NETTXF_extra_info)
- * [Request 3: netif_tx_extra]  (only if request 2 has XEN_NETIF_EXTRA_MORE)
+ * [Request 3: xen_netif_extra_info]    (only if request 2 has XEN_NETIF_EXTRA_MORE)
- *  Request 4: netif_tx_request -- NETTXF_more_data
+ *  Request 4: xen_netif_tx_request  -- XEN_NETTXF_more_data
- *  Request 5: netif_tx_request -- NETTXF_more_data
+ *  Request 5: xen_netif_tx_request  -- XEN_NETTXF_more_data
 *  ...
- *  Request N: netif_tx_request -- 0
+ *  Request N: xen_netif_tx_request  -- 0
 */
 /* Protocol checksum field is blank in the packet (hardware offload)? */
-#define _NETTXF_csum_blank     (0)
+#define _XEN_NETTXF_csum_blank          (0)
-#define  NETTXF_csum_blank     (1U<<_NETTXF_csum_blank)
+#define  XEN_NETTXF_csum_blank          (1U<<_XEN_NETTXF_csum_blank)
 /* Packet data has been validated against protocol checksum. */
-#define _NETTXF_data_validated (1)
+#define _XEN_NETTXF_data_validated      (1)
-#define  NETTXF_data_validated (1U<<_NETTXF_data_validated)
+#define  XEN_NETTXF_data_validated      (1U<<_XEN_NETTXF_data_validated)
 /* Packet continues in the next request descriptor. */
-#define _NETTXF_more_data      (2)
+#define _XEN_NETTXF_more_data           (2)
-#define  NETTXF_more_data      (1U<<_NETTXF_more_data)
+#define  XEN_NETTXF_more_data           (1U<<_XEN_NETTXF_more_data)
 /* Packet to be followed by extra descriptor(s). */
-#define _NETTXF_extra_info     (3)
+#define _XEN_NETTXF_extra_info          (3)
-#define  NETTXF_extra_info     (1U<<_NETTXF_extra_info)
+#define  XEN_NETTXF_extra_info          (1U<<_XEN_NETTXF_extra_info)
 struct xen_netif_tx_request {
    grant_ref_t gref;      /* Reference to buffer page */
    uint16_t offset;       /* Offset within buffer page */
-    uint16_t flags;        /* NETTXF_* */
+    uint16_t flags;        /* XEN_NETTXF_* */
    uint16_t id;           /* Echoed in response message. */
    uint16_t size;         /* Packet size in bytes.       */
 };
-/* Types of netif_extra_info descriptors. */
+/* Types of xen_netif_extra_info descriptors. */
-#define XEN_NETIF_EXTRA_TYPE_NONE  (0)  /* Never used - invalid */
+#define XEN_NETIF_EXTRA_TYPE_NONE       (0)  /* Never used - invalid */
-#define XEN_NETIF_EXTRA_TYPE_GSO   (1)  /* u.gso */
+#define XEN_NETIF_EXTRA_TYPE_GSO        (1)  /* u.gso */
-#define XEN_NETIF_EXTRA_TYPE_MAX   (2)
+#define XEN_NETIF_EXTRA_TYPE_MAX        (2)
-/* netif_extra_info flags. */
+/* xen_netif_extra_info flags. */
-#define _XEN_NETIF_EXTRA_FLAG_MORE (0)
+#define _XEN_NETIF_EXTRA_FLAG_MORE      (0)
-#define XEN_NETIF_EXTRA_FLAG_MORE  (1U<<_XEN_NETIF_EXTRA_FLAG_MORE)
+#define  XEN_NETIF_EXTRA_FLAG_MORE      (1U<<_XEN_NETIF_EXTRA_FLAG_MORE)
 /* GSO types - only TCPv4 currently supported. */
-#define XEN_NETIF_GSO_TYPE_TCPV4        (1)
+#define XEN_NETIF_GSO_TYPE_TCPV4        (1)
 /*
 * This structure needs to fit within both netif_tx_request and
@@ -107,7 +107,7 @@ struct xen_netif_extra_info {
 struct xen_netif_tx_response {
        uint16_t id;
-        int16_t  status;       /* NETIF_RSP_* */
+        int16_t  status;       /* XEN_NETIF_RSP_* */
 };
 struct xen_netif_rx_request {
@@ -116,25 +116,29 @@ struct xen_netif_rx_request {
 };
 /* Packet data has been validated against protocol checksum. */
-#define _NETRXF_data_validated (0)
+#define _XEN_NETRXF_data_validated      (0)
-#define  NETRXF_data_validated (1U<<_NETRXF_data_validated)
+#define  XEN_NETRXF_data_validated      (1U<<_XEN_NETRXF_data_validated)
 /* Protocol checksum field is blank in the packet (hardware offload)? */
-#define _NETRXF_csum_blank     (1)
+#define _XEN_NETRXF_csum_blank          (1)
-#define  NETRXF_csum_blank     (1U<<_NETRXF_csum_blank)
+#define  XEN_NETRXF_csum_blank          (1U<<_XEN_NETRXF_csum_blank)
 /* Packet continues in the next request descriptor. */
-#define _NETRXF_more_data      (2)
+#define _XEN_NETRXF_more_data           (2)
-#define  NETRXF_more_data      (1U<<_NETRXF_more_data)
+#define  XEN_NETRXF_more_data           (1U<<_XEN_NETRXF_more_data)
 /* Packet to be followed by extra descriptor(s). */
-#define _NETRXF_extra_info     (3)
+#define _XEN_NETRXF_extra_info          (3)
-#define  NETRXF_extra_info     (1U<<_NETRXF_extra_info)
+#define  XEN_NETRXF_extra_info          (1U<<_XEN_NETRXF_extra_info)
+/* GSO Prefix descriptor. */
+#define _XEN_NETRXF_gso_prefix          (4)
+#define  XEN_NETRXF_gso_prefix          (1U<<_XEN_NETRXF_gso_prefix)
 struct xen_netif_rx_response {
    uint16_t id;
    uint16_t offset;       /* Offset in page of start of received packet  */
-    uint16_t flags;        /* NETRXF_* */
+    uint16_t flags;        /* XEN_NETRXF_* */
    int16_t  status;       /* -ve: BLKIF_RSP_* ; +ve: Rx'ed pkt size. */
 };
@@ -149,10 +153,10 @@ DEFINE_RING_TYPES(xen_netif_rx,
                  struct xen_netif_rx_request,
                  struct xen_netif_rx_response);
-#define NETIF_RSP_DROPPED         -2
+#define XEN_NETIF_RSP_DROPPED   -2
-#define NETIF_RSP_ERROR           -1
+#define XEN_NETIF_RSP_ERROR     -1
-#define NETIF_RSP_OKAY             0
+#define XEN_NETIF_RSP_OKAY       0
-/* No response: used for auxiliary requests (e.g., netif_tx_extra). */
+/* No response: used for auxiliary requests (e.g., xen_netif_extra_info). */
-#define NETIF_RSP_NULL             1
+#define XEN_NETIF_RSP_NULL       1
 #endif
author	Linus Torvalds <torvalds@linux-foundation.org>	2011-03-16 19:29:25 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2011-03-16 19:29:25 -0400
commit	7a6362800cb7d1d618a697a650c7aaed3eb39320 (patch)
tree	087f9bc6c13ef1fad4b392c5cf9325cd28fa8523 /include
parent	6445ced8670f37cfc2c5e24a9de9b413dbfc788d (diff)
parent	ceda86a108671294052cbf51660097b6534672f5 (diff)