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: (1429 commits)
  net: Allow dependancies of FDDI & Tokenring to be modular.
  igb: Fix build warning when DCA is disabled.
  net: Fix warning fallout from recent NAPI interface changes.
  gro: Fix potential use after free
  sfc: If AN is enabled, always read speed/duplex from the AN advertising bits
  sfc: When disabling the NIC, close the device rather than unregistering it
  sfc: SFT9001: Add cable diagnostics
  sfc: Add support for multiple PHY self-tests
  sfc: Merge top-level functions for self-tests
  sfc: Clean up PHY mode management in loopback self-test
  sfc: Fix unreliable link detection in some loopback modes
  sfc: Generate unique names for per-NIC workqueues
  802.3ad: use standard ethhdr instead of ad_header
  802.3ad: generalize out mac address initializer
  802.3ad: initialize ports LACPDU from const initializer
  802.3ad: remove typedef around ad_system
  802.3ad: turn ports is_individual into a bool
  802.3ad: turn ports is_enabled into a bool
  802.3ad: make ntt bool
  ixgbe: Fix set_ringparam in ixgbe to use the same memory pools.
  ...

Fixed trivial IPv4/6 address printing conflicts in fs/cifs/connect.c due
to the conversion to %pI (in this networking merge) and the addition of
doing IPv6 addresses (from the earlier merge of CIFS).

90 files changed, 2651 insertions, 998 deletions

diff --git a/include/linux/atm.h b/include/linux/atm.h
index c791ddd96939..d3b292174aeb 100644
--- a/include/linux/atm.h
+++ b/include/linux/atm.h
@@ -231,10 +231,21 @@ static __inline__ int atmpvc_addr_in_use(struct sockaddr_atmpvc addr)
  */
 
 struct atmif_sioc {
-    int number;
-    int length;
-    void __user *arg;
+        int number;
+        int length;
+        void __user *arg;
 };
 
+#ifdef __KERNEL__
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+struct compat_atmif_sioc {
+        int number;
+        int length;
+        compat_uptr_t arg;
+};
+#endif
+#endif
+
 typedef unsigned short atm_backend_t;
 #endif
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index a3d07c29d16c..086e5c362d3a 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -100,6 +100,10 @@ struct atm_dev_stats {
                                         /* use backend to make new if */
 #define ATM_ADDPARTY    _IOW('a', ATMIOC_SPECIAL+4,struct atm_iobuf)
                                         /* add party to p2mp call */
+#ifdef CONFIG_COMPAT
+/* It actually takes struct sockaddr_atmsvc, not struct atm_iobuf */
+#define COMPAT_ATM_ADDPARTY     _IOW('a', ATMIOC_SPECIAL+4,struct compat_atm_iobuf)
+#endif
 #define ATM_DROPPARTY   _IOW('a', ATMIOC_SPECIAL+5,int)
                                         /* drop party from p2mp call */
 
@@ -224,6 +228,13 @@ struct atm_cirange {
 extern struct proc_dir_entry *atm_proc_root;
 #endif
 
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+struct compat_atm_iobuf {
+        int length;
+        compat_uptr_t buffer;
+};
+#endif
 
 struct k_atm_aal_stats {
 #define __HANDLE_ITEM(i) atomic_t i
@@ -379,6 +390,10 @@ struct atmdev_ops { /* only send is required */
         int (*open)(struct atm_vcc *vcc);
         void (*close)(struct atm_vcc *vcc);
         int (*ioctl)(struct atm_dev *dev,unsigned int cmd,void __user *arg);
+#ifdef CONFIG_COMPAT
+        int (*compat_ioctl)(struct atm_dev *dev,unsigned int cmd,
+                            void __user *arg);
+#endif
         int (*getsockopt)(struct atm_vcc *vcc,int level,int optname,
             void __user *optval,int optlen);
         int (*setsockopt)(struct atm_vcc *vcc,int level,int optname,
diff --git a/include/linux/cgroup_subsys.h b/include/linux/cgroup_subsys.h
index 9c22396e8b50..9c8d31bacf46 100644
--- a/include/linux/cgroup_subsys.h
+++ b/include/linux/cgroup_subsys.h
@@ -54,3 +54,9 @@ SUBSYS(freezer)
 #endif
 
 /* */
+
+#ifdef CONFIG_NET_CLS_CGROUP
+SUBSYS(net_cls)
+#endif
+
+/* */
diff --git a/include/linux/dcbnl.h b/include/linux/dcbnl.h
new file mode 100644
index 000000000000..b0ef274e0031
--- /dev/null
+++ b/include/linux/dcbnl.h
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2008, 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,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Author: Lucy Liu <lucy.liu@intel.com>
+ */
+
+#ifndef __LINUX_DCBNL_H__
+#define __LINUX_DCBNL_H__
+
+#define DCB_PROTO_VERSION 1
+
+struct dcbmsg {
+        unsigned char      dcb_family;
+        __u8               cmd;
+        __u16              dcb_pad;
+};
+
+/**
+ * enum dcbnl_commands - supported DCB commands
+ *
+ * @DCB_CMD_UNDEFINED: unspecified command to catch errors
+ * @DCB_CMD_GSTATE: request the state of DCB in the device
+ * @DCB_CMD_SSTATE: set the state of DCB in the device
+ * @DCB_CMD_PGTX_GCFG: request the priority group configuration for Tx
+ * @DCB_CMD_PGTX_SCFG: set the priority group configuration for Tx
+ * @DCB_CMD_PGRX_GCFG: request the priority group configuration for Rx
+ * @DCB_CMD_PGRX_SCFG: set the priority group configuration for Rx
+ * @DCB_CMD_PFC_GCFG: request the priority flow control configuration
+ * @DCB_CMD_PFC_SCFG: set the priority flow control configuration
+ * @DCB_CMD_SET_ALL: apply all changes to the underlying device
+ * @DCB_CMD_GPERM_HWADDR: get the permanent MAC address of the underlying
+ *                        device.  Only useful when using bonding.
+ * @DCB_CMD_GCAP: request the DCB capabilities of the device
+ * @DCB_CMD_GNUMTCS: get the number of traffic classes currently supported
+ * @DCB_CMD_SNUMTCS: set the number of traffic classes
+ * @DCB_CMD_GBCN: set backward congestion notification configuration
+ * @DCB_CMD_SBCN: get backward congestion notification configration.
+ */
+enum dcbnl_commands {
+        DCB_CMD_UNDEFINED,
+
+        DCB_CMD_GSTATE,
+        DCB_CMD_SSTATE,
+
+        DCB_CMD_PGTX_GCFG,
+        DCB_CMD_PGTX_SCFG,
+        DCB_CMD_PGRX_GCFG,
+        DCB_CMD_PGRX_SCFG,
+
+        DCB_CMD_PFC_GCFG,
+        DCB_CMD_PFC_SCFG,
+
+        DCB_CMD_SET_ALL,
+
+        DCB_CMD_GPERM_HWADDR,
+
+        DCB_CMD_GCAP,
+
+        DCB_CMD_GNUMTCS,
+        DCB_CMD_SNUMTCS,
+
+        DCB_CMD_PFC_GSTATE,
+        DCB_CMD_PFC_SSTATE,
+
+        DCB_CMD_BCN_GCFG,
+        DCB_CMD_BCN_SCFG,
+
+        __DCB_CMD_ENUM_MAX,
+        DCB_CMD_MAX = __DCB_CMD_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcbnl_attrs - DCB top-level netlink attributes
+ *
+ * @DCB_ATTR_UNDEFINED: unspecified attribute to catch errors
+ * @DCB_ATTR_IFNAME: interface name of the underlying device (NLA_STRING)
+ * @DCB_ATTR_STATE: enable state of DCB in the device (NLA_U8)
+ * @DCB_ATTR_PFC_STATE: enable state of PFC in the device (NLA_U8)
+ * @DCB_ATTR_PFC_CFG: priority flow control configuration (NLA_NESTED)
+ * @DCB_ATTR_NUM_TC: number of traffic classes supported in the device (NLA_U8)
+ * @DCB_ATTR_PG_CFG: priority group configuration (NLA_NESTED)
+ * @DCB_ATTR_SET_ALL: bool to commit changes to hardware or not (NLA_U8)
+ * @DCB_ATTR_PERM_HWADDR: MAC address of the physical device (NLA_NESTED)
+ * @DCB_ATTR_CAP: DCB capabilities of the device (NLA_NESTED)
+ * @DCB_ATTR_NUMTCS: number of traffic classes supported (NLA_NESTED)
+ * @DCB_ATTR_BCN: backward congestion notification configuration (NLA_NESTED)
+ */
+enum dcbnl_attrs {
+        DCB_ATTR_UNDEFINED,
+
+        DCB_ATTR_IFNAME,
+        DCB_ATTR_STATE,
+        DCB_ATTR_PFC_STATE,
+        DCB_ATTR_PFC_CFG,
+        DCB_ATTR_NUM_TC,
+        DCB_ATTR_PG_CFG,
+        DCB_ATTR_SET_ALL,
+        DCB_ATTR_PERM_HWADDR,
+        DCB_ATTR_CAP,
+        DCB_ATTR_NUMTCS,
+        DCB_ATTR_BCN,
+
+        __DCB_ATTR_ENUM_MAX,
+        DCB_ATTR_MAX = __DCB_ATTR_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcbnl_pfc_attrs - DCB Priority Flow Control user priority nested attrs
+ *
+ * @DCB_PFC_UP_ATTR_UNDEFINED: unspecified attribute to catch errors
+ * @DCB_PFC_UP_ATTR_0: Priority Flow Control value for User Priority 0 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_1: Priority Flow Control value for User Priority 1 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_2: Priority Flow Control value for User Priority 2 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_3: Priority Flow Control value for User Priority 3 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_4: Priority Flow Control value for User Priority 4 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_5: Priority Flow Control value for User Priority 5 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_6: Priority Flow Control value for User Priority 6 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_7: Priority Flow Control value for User Priority 7 (NLA_U8)
+ * @DCB_PFC_UP_ATTR_MAX: highest attribute number currently defined
+ * @DCB_PFC_UP_ATTR_ALL: apply to all priority flow control attrs (NLA_FLAG)
+ *
+ */
+enum dcbnl_pfc_up_attrs {
+        DCB_PFC_UP_ATTR_UNDEFINED,
+
+        DCB_PFC_UP_ATTR_0,
+        DCB_PFC_UP_ATTR_1,
+        DCB_PFC_UP_ATTR_2,
+        DCB_PFC_UP_ATTR_3,
+        DCB_PFC_UP_ATTR_4,
+        DCB_PFC_UP_ATTR_5,
+        DCB_PFC_UP_ATTR_6,
+        DCB_PFC_UP_ATTR_7,
+        DCB_PFC_UP_ATTR_ALL,
+
+        __DCB_PFC_UP_ATTR_ENUM_MAX,
+        DCB_PFC_UP_ATTR_MAX = __DCB_PFC_UP_ATTR_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcbnl_pg_attrs - DCB Priority Group attributes
+ *
+ * @DCB_PG_ATTR_UNDEFINED: unspecified attribute to catch errors
+ * @DCB_PG_ATTR_TC_0: Priority Group Traffic Class 0 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_1: Priority Group Traffic Class 1 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_2: Priority Group Traffic Class 2 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_3: Priority Group Traffic Class 3 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_4: Priority Group Traffic Class 4 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_5: Priority Group Traffic Class 5 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_6: Priority Group Traffic Class 6 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_7: Priority Group Traffic Class 7 configuration (NLA_NESTED)
+ * @DCB_PG_ATTR_TC_MAX: highest attribute number currently defined
+ * @DCB_PG_ATTR_TC_ALL: apply to all traffic classes (NLA_NESTED)
+ * @DCB_PG_ATTR_BW_ID_0: Percent of link bandwidth for Priority Group 0 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_1: Percent of link bandwidth for Priority Group 1 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_2: Percent of link bandwidth for Priority Group 2 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_3: Percent of link bandwidth for Priority Group 3 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_4: Percent of link bandwidth for Priority Group 4 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_5: Percent of link bandwidth for Priority Group 5 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_6: Percent of link bandwidth for Priority Group 6 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_7: Percent of link bandwidth for Priority Group 7 (NLA_U8)
+ * @DCB_PG_ATTR_BW_ID_MAX: highest attribute number currently defined
+ * @DCB_PG_ATTR_BW_ID_ALL: apply to all priority groups (NLA_FLAG)
+ *
+ */
+enum dcbnl_pg_attrs {
+        DCB_PG_ATTR_UNDEFINED,
+
+        DCB_PG_ATTR_TC_0,
+        DCB_PG_ATTR_TC_1,
+        DCB_PG_ATTR_TC_2,
+        DCB_PG_ATTR_TC_3,
+        DCB_PG_ATTR_TC_4,
+        DCB_PG_ATTR_TC_5,
+        DCB_PG_ATTR_TC_6,
+        DCB_PG_ATTR_TC_7,
+        DCB_PG_ATTR_TC_MAX,
+        DCB_PG_ATTR_TC_ALL,
+
+        DCB_PG_ATTR_BW_ID_0,
+        DCB_PG_ATTR_BW_ID_1,
+        DCB_PG_ATTR_BW_ID_2,
+        DCB_PG_ATTR_BW_ID_3,
+        DCB_PG_ATTR_BW_ID_4,
+        DCB_PG_ATTR_BW_ID_5,
+        DCB_PG_ATTR_BW_ID_6,
+        DCB_PG_ATTR_BW_ID_7,
+        DCB_PG_ATTR_BW_ID_MAX,
+        DCB_PG_ATTR_BW_ID_ALL,
+
+        __DCB_PG_ATTR_ENUM_MAX,
+        DCB_PG_ATTR_MAX = __DCB_PG_ATTR_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcbnl_tc_attrs - DCB Traffic Class attributes
+ *
+ * @DCB_TC_ATTR_PARAM_UNDEFINED: unspecified attribute to catch errors
+ * @DCB_TC_ATTR_PARAM_PGID: (NLA_U8) Priority group the traffic class belongs to
+ *                          Valid values are:  0-7
+ * @DCB_TC_ATTR_PARAM_UP_MAPPING: (NLA_U8) Traffic class to user priority map
+ *                                Some devices may not support changing the
+ *                                user priority map of a TC.
+ * @DCB_TC_ATTR_PARAM_STRICT_PRIO: (NLA_U8) Strict priority setting
+ *                                 0 - none
+ *                                 1 - group strict
+ *                                 2 - link strict
+ * @DCB_TC_ATTR_PARAM_BW_PCT: optional - (NLA_U8) If supported by the device and
+ *                            not configured to use link strict priority,
+ *                            this is the percentage of bandwidth of the
+ *                            priority group this traffic class belongs to
+ * @DCB_TC_ATTR_PARAM_ALL: (NLA_FLAG) all traffic class parameters
+ *
+ */
+enum dcbnl_tc_attrs {
+        DCB_TC_ATTR_PARAM_UNDEFINED,
+
+        DCB_TC_ATTR_PARAM_PGID,
+        DCB_TC_ATTR_PARAM_UP_MAPPING,
+        DCB_TC_ATTR_PARAM_STRICT_PRIO,
+        DCB_TC_ATTR_PARAM_BW_PCT,
+        DCB_TC_ATTR_PARAM_ALL,
+
+        __DCB_TC_ATTR_PARAM_ENUM_MAX,
+        DCB_TC_ATTR_PARAM_MAX = __DCB_TC_ATTR_PARAM_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcbnl_cap_attrs - DCB Capability attributes
+ *
+ * @DCB_CAP_ATTR_UNDEFINED: unspecified attribute to catch errors
+ * @DCB_CAP_ATTR_ALL: (NLA_FLAG) all capability parameters
+ * @DCB_CAP_ATTR_PG: (NLA_U8) device supports Priority Groups
+ * @DCB_CAP_ATTR_PFC: (NLA_U8) device supports Priority Flow Control
+ * @DCB_CAP_ATTR_UP2TC: (NLA_U8) device supports user priority to
+ *                               traffic class mapping
+ * @DCB_CAP_ATTR_PG_TCS: (NLA_U8) bitmap where each bit represents a
+ *                                number of traffic classes the device
+ *                                can be configured to use for Priority Groups
+ * @DCB_CAP_ATTR_PFC_TCS: (NLA_U8) bitmap where each bit represents a
+ *                                 number of traffic classes the device can be
+ *                                 configured to use for Priority Flow Control
+ * @DCB_CAP_ATTR_GSP: (NLA_U8) device supports group strict priority
+ * @DCB_CAP_ATTR_BCN: (NLA_U8) device supports Backwards Congestion
+ *                             Notification
+ */
+enum dcbnl_cap_attrs {
+        DCB_CAP_ATTR_UNDEFINED,
+        DCB_CAP_ATTR_ALL,
+        DCB_CAP_ATTR_PG,
+        DCB_CAP_ATTR_PFC,
+        DCB_CAP_ATTR_UP2TC,
+        DCB_CAP_ATTR_PG_TCS,
+        DCB_CAP_ATTR_PFC_TCS,
+        DCB_CAP_ATTR_GSP,
+        DCB_CAP_ATTR_BCN,
+
+        __DCB_CAP_ATTR_ENUM_MAX,
+        DCB_CAP_ATTR_MAX = __DCB_CAP_ATTR_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcbnl_numtcs_attrs - number of traffic classes
+ *
+ * @DCB_NUMTCS_ATTR_UNDEFINED: unspecified attribute to catch errors
+ * @DCB_NUMTCS_ATTR_ALL: (NLA_FLAG) all traffic class attributes
+ * @DCB_NUMTCS_ATTR_PG: (NLA_U8) number of traffic classes used for
+ *                               priority groups
+ * @DCB_NUMTCS_ATTR_PFC: (NLA_U8) number of traffic classes which can
+ *                                support priority flow control
+ */
+enum dcbnl_numtcs_attrs {
+        DCB_NUMTCS_ATTR_UNDEFINED,
+        DCB_NUMTCS_ATTR_ALL,
+        DCB_NUMTCS_ATTR_PG,
+        DCB_NUMTCS_ATTR_PFC,
+
+        __DCB_NUMTCS_ATTR_ENUM_MAX,
+        DCB_NUMTCS_ATTR_MAX = __DCB_NUMTCS_ATTR_ENUM_MAX - 1,
+};
+
+enum dcbnl_bcn_attrs{
+        DCB_BCN_ATTR_UNDEFINED = 0,
+
+        DCB_BCN_ATTR_RP_0,
+        DCB_BCN_ATTR_RP_1,
+        DCB_BCN_ATTR_RP_2,
+        DCB_BCN_ATTR_RP_3,
+        DCB_BCN_ATTR_RP_4,
+        DCB_BCN_ATTR_RP_5,
+        DCB_BCN_ATTR_RP_6,
+        DCB_BCN_ATTR_RP_7,
+        DCB_BCN_ATTR_RP_ALL,
+
+        DCB_BCN_ATTR_BCNA_0,
+        DCB_BCN_ATTR_BCNA_1,
+        DCB_BCN_ATTR_ALPHA,
+        DCB_BCN_ATTR_BETA,
+        DCB_BCN_ATTR_GD,
+        DCB_BCN_ATTR_GI,
+        DCB_BCN_ATTR_TMAX,
+        DCB_BCN_ATTR_TD,
+        DCB_BCN_ATTR_RMIN,
+        DCB_BCN_ATTR_W,
+        DCB_BCN_ATTR_RD,
+        DCB_BCN_ATTR_RU,
+        DCB_BCN_ATTR_WRTT,
+        DCB_BCN_ATTR_RI,
+        DCB_BCN_ATTR_C,
+        DCB_BCN_ATTR_ALL,
+
+        __DCB_BCN_ATTR_ENUM_MAX,
+        DCB_BCN_ATTR_MAX = __DCB_BCN_ATTR_ENUM_MAX - 1,
+};
+
+/**
+ * enum dcb_general_attr_values - general DCB attribute values
+ *
+ * @DCB_ATTR_UNDEFINED: value used to indicate an attribute is not supported
+ *
+ */
+enum dcb_general_attr_values {
+        DCB_ATTR_VALUE_UNDEFINED = 0xff
+};
+
+
+#endif /* __LINUX_DCBNL_H__ */
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 6080449fbec9..61734e27abb7 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -168,6 +168,8 @@ enum {
         DCCPO_MIN_CCID_SPECIFIC = 128,
         DCCPO_MAX_CCID_SPECIFIC = 255,
 };
+/* maximum size of a single TLV-encoded DCCP option (sans type/len bytes) */
+#define DCCP_SINGLE_OPT_MAXLEN  253
 
 /* DCCP CCIDS */
 enum {
@@ -176,29 +178,23 @@ enum {
 };
 
 /* DCCP features (RFC 4340 section 6.4) */
-enum {
+enum dccp_feature_numbers {
         DCCPF_RESERVED = 0,
         DCCPF_CCID = 1,
-        DCCPF_SHORT_SEQNOS = 2,         /* XXX: not yet implemented */
+        DCCPF_SHORT_SEQNOS = 2,
         DCCPF_SEQUENCE_WINDOW = 3,
-        DCCPF_ECN_INCAPABLE = 4,        /* XXX: not yet implemented */
+        DCCPF_ECN_INCAPABLE = 4,
         DCCPF_ACK_RATIO = 5,
         DCCPF_SEND_ACK_VECTOR = 6,
         DCCPF_SEND_NDP_COUNT = 7,
         DCCPF_MIN_CSUM_COVER = 8,
-        DCCPF_DATA_CHECKSUM = 9,        /* XXX: not yet implemented */
+        DCCPF_DATA_CHECKSUM = 9,
         /* 10-127 reserved */
         DCCPF_MIN_CCID_SPECIFIC = 128,
+        DCCPF_SEND_LEV_RATE = 192,      /* RFC 4342, sec. 8.4 */
         DCCPF_MAX_CCID_SPECIFIC = 255,
 };
 
-/* this structure is argument to DCCP_SOCKOPT_CHANGE_X */
-struct dccp_so_feat {
-        __u8 dccpsf_feat;
-        __u8 __user *dccpsf_val;
-        __u8 dccpsf_len;
-};
-
 /* DCCP socket options */
 #define DCCP_SOCKOPT_PACKET_SIZE        1 /* XXX deprecated, without effect */
 #define DCCP_SOCKOPT_SERVICE            2
@@ -208,6 +204,10 @@ struct dccp_so_feat {
 #define DCCP_SOCKOPT_SERVER_TIMEWAIT    6
 #define DCCP_SOCKOPT_SEND_CSCOV         10
 #define DCCP_SOCKOPT_RECV_CSCOV         11
+#define DCCP_SOCKOPT_AVAILABLE_CCIDS    12
+#define DCCP_SOCKOPT_CCID               13
+#define DCCP_SOCKOPT_TX_CCID            14
+#define DCCP_SOCKOPT_RX_CCID            15
 #define DCCP_SOCKOPT_CCID_RX_INFO       128
 #define DCCP_SOCKOPT_CCID_TX_INFO       192
 
@@ -360,7 +360,6 @@ static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)
 #define DCCPF_INITIAL_SEQUENCE_WINDOW           100
 #define DCCPF_INITIAL_ACK_RATIO                 2
 #define DCCPF_INITIAL_CCID                      DCCPC_CCID2
-#define DCCPF_INITIAL_SEND_ACK_VECTOR           1
 /* FIXME: for now we're default to 1 but it should really be 0 */
 #define DCCPF_INITIAL_SEND_NDP_COUNT            1
 
@@ -370,20 +369,11 @@ static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)
   * Will be used to pass the state from dccp_request_sock to dccp_sock.
   *
   * @dccpms_sequence_window - Sequence Window Feature (section 7.5.2)
-  * @dccpms_ccid - Congestion Control Id (CCID) (section 10)
-  * @dccpms_send_ack_vector - Send Ack Vector Feature (section 11.5)
-  * @dccpms_send_ndp_count - Send NDP Count Feature (7.7.2)
-  * @dccpms_ack_ratio - Ack Ratio Feature (section 11.3)
   * @dccpms_pending - List of features being negotiated
   * @dccpms_conf -
   */
 struct dccp_minisock {
         __u64                   dccpms_sequence_window;
-        __u8                    dccpms_rx_ccid;
-        __u8                    dccpms_tx_ccid;
-        __u8                    dccpms_send_ack_vector;
-        __u8                    dccpms_send_ndp_count;
-        __u8                    dccpms_ack_ratio;
         struct list_head        dccpms_pending;
         struct list_head        dccpms_conf;
 };
@@ -411,6 +401,7 @@ extern void dccp_minisock_init(struct dccp_minisock *dmsk);
  * @dreq_iss: initial sequence number sent on the Response (RFC 4340, 7.1)
  * @dreq_isr: initial sequence number received on the Request
  * @dreq_service: service code present on the Request (there is just one)
+ * @dreq_featneg: feature negotiation options for this connection
  * The following two fields are analogous to the ones in dccp_sock:
  * @dreq_timestamp_echo: last received timestamp to echo (13.1)
  * @dreq_timestamp_echo: the time of receiving the last @dreq_timestamp_echo
@@ -420,6 +411,7 @@ struct dccp_request_sock {
         __u64                    dreq_iss;
         __u64                    dreq_isr;
         __be32                   dreq_service;
+        struct list_head         dreq_featneg;
         __u32                    dreq_timestamp_echo;
         __u32                    dreq_timestamp_time;
 };
@@ -493,10 +485,12 @@ struct dccp_ackvec;
  * @dccps_r_ack_ratio - feature-remote Ack Ratio
  * @dccps_pcslen - sender   partial checksum coverage (via sockopt)
  * @dccps_pcrlen - receiver partial checksum coverage (via sockopt)
+ * @dccps_send_ndp_count - local Send NDP Count feature (7.7.2)
  * @dccps_ndp_count - number of Non Data Packets since last data packet
  * @dccps_mss_cache - current value of MSS (path MTU minus header sizes)
  * @dccps_rate_last - timestamp for rate-limiting DCCP-Sync (RFC 4340, 7.5.4)
  * @dccps_minisock - associated minisock (accessed via dccp_msk)
+ * @dccps_featneg - tracks feature-negotiation state (mostly during handshake)
  * @dccps_hc_rx_ackvec - rx half connection ack vector
  * @dccps_hc_rx_ccid - CCID used for the receiver (or receiving half-connection)
  * @dccps_hc_tx_ccid - CCID used for the sender (or sending half-connection)
@@ -529,11 +523,13 @@ struct dccp_sock {
         __u32                           dccps_timestamp_time;
         __u16                           dccps_l_ack_ratio;
         __u16                           dccps_r_ack_ratio;
-        __u16                           dccps_pcslen;
-        __u16                           dccps_pcrlen;
+        __u8                            dccps_pcslen:4;
+        __u8                            dccps_pcrlen:4;
+        __u8                            dccps_send_ndp_count:1;
         __u64                           dccps_ndp_count:48;
         unsigned long                   dccps_rate_last;
         struct dccp_minisock            dccps_minisock;
+        struct list_head                dccps_featneg;
         struct dccp_ackvec              *dccps_hc_rx_ackvec;
         struct ccid                     *dccps_hc_rx_ccid;
         struct ccid                     *dccps_hc_tx_ccid;
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 25d62e6e3290..1cb0f0b90926 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -27,6 +27,7 @@
 #include <linux/if_ether.h>
 #include <linux/netdevice.h>
 #include <linux/random.h>
+#include <asm/unaligned.h>
 
 #ifdef __KERNEL__
 extern __be16           eth_type_trans(struct sk_buff *skb, struct net_device *dev);
@@ -41,6 +42,10 @@ extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh);
 extern void eth_header_cache_update(struct hh_cache *hh,
                                     const struct net_device *dev,
                                     const unsigned char *haddr);
+extern int eth_mac_addr(struct net_device *dev, void *p);
+extern int eth_change_mtu(struct net_device *dev, int new_mtu);
+extern int eth_validate_addr(struct net_device *dev);
+
 
 
 extern struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count);
@@ -136,6 +141,47 @@ static inline unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2)
         BUILD_BUG_ON(ETH_ALEN != 6);
         return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
 }
+
+static inline unsigned long zap_last_2bytes(unsigned long value)
+{
+#ifdef __BIG_ENDIAN
+        return value >> 16;
+#else
+        return value << 16;
+#endif
+}
+
+/**
+ * compare_ether_addr_64bits - Compare two Ethernet addresses
+ * @addr1: Pointer to an array of 8 bytes
+ * @addr2: Pointer to an other array of 8 bytes
+ *
+ * Compare two ethernet addresses, returns 0 if equal.
+ * Same result than "memcmp(addr1, addr2, ETH_ALEN)" but without conditional
+ * branches, and possibly long word memory accesses on CPU allowing cheap
+ * unaligned memory reads.
+ * arrays = { byte1, byte2, byte3, byte4, byte6, byte7, pad1, pad2}
+ *
+ * Please note that alignment of addr1 & addr2 is only guaranted to be 16 bits.
+ */
+
+static inline unsigned compare_ether_addr_64bits(const u8 addr1[6+2],
+                                                 const u8 addr2[6+2])
+{
+#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        unsigned long fold = ((*(unsigned long *)addr1) ^
+                              (*(unsigned long *)addr2));
+
+        if (sizeof(fold) == 8)
+                return zap_last_2bytes(fold) != 0;
+
+        fold |= zap_last_2bytes((*(unsigned long *)(addr1 + 4)) ^
+                                (*(unsigned long *)(addr2 + 4)));
+        return fold != 0;
+#else
+        return compare_ether_addr(addr1, addr2);
+#endif
+}
 #endif  /* __KERNEL__ */
 
 #endif  /* _LINUX_ETHERDEVICE_H */
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index b4b038b89ee6..27c67a542235 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -467,6 +467,8 @@ struct ethtool_ops {
 
 #define ETHTOOL_GRXFH           0x00000029 /* Get RX flow hash configuration */
 #define ETHTOOL_SRXFH           0x0000002a /* Set RX flow hash configuration */
+#define ETHTOOL_GGRO            0x0000002b /* Get GRO enable (ethtool_value) */
+#define ETHTOOL_SGRO            0x0000002c /* Set GRO enable (ethtool_value) */
 
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
diff --git a/include/linux/fddidevice.h b/include/linux/fddidevice.h
index e61e42dfd317..155bafd9e886 100644
--- a/include/linux/fddidevice.h
+++ b/include/linux/fddidevice.h
@@ -27,6 +27,7 @@
 #ifdef __KERNEL__
 extern __be16   fddi_type_trans(struct sk_buff *skb,
                                 struct net_device *dev);
+extern int fddi_change_mtu(struct net_device *dev, int new_mtu);
 extern struct net_device *alloc_fddidev(int sizeof_priv);
 #endif
 
diff --git a/include/linux/filter.h b/include/linux/filter.h
index b6ea9aa9e853..1354aaf6abbe 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -122,7 +122,8 @@ struct sock_fprog	/* Required for SO_ATTACH_FILTER. */
 #define SKF_AD_PKTTYPE  4
 #define SKF_AD_IFINDEX  8
 #define SKF_AD_NLATTR   12
-#define SKF_AD_MAX      16
+#define SKF_AD_NLATTR_NEST      16
+#define SKF_AD_MAX      20
 #define SKF_NET_OFF   (-0x100000)
 #define SKF_LL_OFF    (-0x200000)
 
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 708bab58d8d0..d9051d717d27 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -47,12 +47,7 @@
 struct gianfar_platform_data {
         /* device specific information */
         u32     device_flags;
-        /* board specific information */
-        u32     board_flags;
-        int     mdio_bus;                       /* Bus controlled by us */
-        char    bus_id[MII_BUS_ID_SIZE];        /* Bus PHY is on */
-        u32     phy_id;
-        u8      mac_addr[6];
+        char    bus_id[BUS_ID_SIZE];
         phy_interface_t interface;
 };
 
@@ -61,17 +56,6 @@ struct gianfar_mdio_data {
         int     irq[32];
 };
 
-/* Flags related to gianfar device features */
-#define FSL_GIANFAR_DEV_HAS_GIGABIT             0x00000001
-#define FSL_GIANFAR_DEV_HAS_COALESCE            0x00000002
-#define FSL_GIANFAR_DEV_HAS_RMON                0x00000004
-#define FSL_GIANFAR_DEV_HAS_MULTI_INTR          0x00000008
-#define FSL_GIANFAR_DEV_HAS_CSUM                0x00000010
-#define FSL_GIANFAR_DEV_HAS_VLAN                0x00000020
-#define FSL_GIANFAR_DEV_HAS_EXTENDED_HASH       0x00000040
-#define FSL_GIANFAR_DEV_HAS_PADDING             0x00000080
-#define FSL_GIANFAR_DEV_HAS_MAGIC_PACKET        0x00000100
-
 /* Flags in gianfar_platform_data */
 #define FSL_GIANFAR_BRD_HAS_PHY_INTR    0x00000001 /* set or use a timer */
 #define FSL_GIANFAR_BRD_IS_REDUCED      0x00000002 /* Set if RGMII, RMII */
diff --git a/include/linux/hdlc.h b/include/linux/hdlc.h
index c59769693bee..fd47a151665e 100644
--- a/include/linux/hdlc.h
+++ b/include/linux/hdlc.h
@@ -43,7 +43,7 @@ struct hdlc_proto {
 };
 
 
-/* Pointed to by dev->priv */
+/* Pointed to by netdev_priv(dev) */
 typedef struct hdlc_device {
         /* used by HDLC layer to take control over HDLC device from hw driver*/
         int (*attach)(struct net_device *dev,
@@ -80,7 +80,7 @@ struct net_device *alloc_hdlcdev(void *priv);
 
 static inline struct hdlc_device* dev_to_hdlc(struct net_device *dev)
 {
-        return dev->priv;
+        return netdev_priv(dev);
 }
 
 static __inline__ void debug_frame(const struct sk_buff *skb)
diff --git a/include/linux/hippidevice.h b/include/linux/hippidevice.h
index bab303dafd6e..f148e4908410 100644
--- a/include/linux/hippidevice.h
+++ b/include/linux/hippidevice.h
@@ -32,7 +32,9 @@ struct hippi_cb {
 };
 
 extern __be16 hippi_type_trans(struct sk_buff *skb, struct net_device *dev);
-
+extern int hippi_change_mtu(struct net_device *dev, int new_mtu);
+extern int hippi_mac_addr(struct net_device *dev, void *p);
+extern int hippi_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p);
 extern struct net_device *alloc_hippi_dev(int sizeof_priv);
 #endif
 
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 14126bc36641..c4e6ca1a6306 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -12,8 +12,8 @@
  * published by the Free Software Foundation.
  */
 
-#ifndef IEEE80211_H
-#define IEEE80211_H
+#ifndef LINUX_IEEE80211_H
+#define LINUX_IEEE80211_H
 
 #include <linux/types.h>
 #include <asm/byteorder.h>
@@ -97,7 +97,10 @@
 #define IEEE80211_MAX_FRAME_LEN         2352
 
 #define IEEE80211_MAX_SSID_LEN          32
+
 #define IEEE80211_MAX_MESH_ID_LEN       32
+#define IEEE80211_MESH_CONFIG_LEN       19
+
 #define IEEE80211_QOS_CTL_LEN           2
 #define IEEE80211_QOS_CTL_TID_MASK      0x000F
 #define IEEE80211_QOS_CTL_TAG1D_MASK    0x0007
@@ -666,6 +669,13 @@ struct ieee80211_cts {
         u8 ra[6];
 } __attribute__ ((packed));
 
+struct ieee80211_pspoll {
+        __le16 frame_control;
+        __le16 aid;
+        u8 bssid[6];
+        u8 ta[6];
+} __attribute__ ((packed));
+
 /**
  * struct ieee80211_bar - HT Block Ack Request
  *
@@ -685,28 +695,88 @@ struct ieee80211_bar {
 #define IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL     0x0000
 #define IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA  0x0004
 
+
+#define IEEE80211_HT_MCS_MASK_LEN               10
+
+/**
+ * struct ieee80211_mcs_info - MCS information
+ * @rx_mask: RX mask
+ * @rx_highest: highest supported RX rate
+ * @tx_params: TX parameters
+ */
+struct ieee80211_mcs_info {
+        u8 rx_mask[IEEE80211_HT_MCS_MASK_LEN];
+        __le16 rx_highest;
+        u8 tx_params;
+        u8 reserved[3];
+} __attribute__((packed));
+
+/* 802.11n HT capability MSC set */
+#define IEEE80211_HT_MCS_RX_HIGHEST_MASK        0x3ff
+#define IEEE80211_HT_MCS_TX_DEFINED             0x01
+#define IEEE80211_HT_MCS_TX_RX_DIFF             0x02
+/* value 0 == 1 stream etc */
+#define IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK    0x0C
+#define IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT   2
+#define         IEEE80211_HT_MCS_TX_MAX_STREAMS 4
+#define IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION  0x10
+
+/*
+ * 802.11n D5.0 20.3.5 / 20.6 says:
+ * - indices 0 to 7 and 32 are single spatial stream
+ * - 8 to 31 are multiple spatial streams using equal modulation
+ *   [8..15 for two streams, 16..23 for three and 24..31 for four]
+ * - remainder are multiple spatial streams using unequal modulation
+ */
+#define IEEE80211_HT_MCS_UNEQUAL_MODULATION_START 33
+#define IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE \
+        (IEEE80211_HT_MCS_UNEQUAL_MODULATION_START / 8)
+
 /**
  * struct ieee80211_ht_cap - HT capabilities
  *
- * This structure refers to "HT capabilities element" as
- * described in 802.11n draft section 7.3.2.52
+ * This structure is the "HT capabilities element" as
+ * described in 802.11n D5.0 7.3.2.57
  */
 struct ieee80211_ht_cap {
         __le16 cap_info;
         u8 ampdu_params_info;
-        u8 supp_mcs_set[16];
+
+        /* 16 bytes MCS information */
+        struct ieee80211_mcs_info mcs;
+
         __le16 extended_ht_cap_info;
         __le32 tx_BF_cap_info;
         u8 antenna_selection_info;
 } __attribute__ ((packed));
 
+/* 802.11n HT capabilities masks (for cap_info) */
+#define IEEE80211_HT_CAP_LDPC_CODING            0x0001
+#define IEEE80211_HT_CAP_SUP_WIDTH_20_40        0x0002
+#define IEEE80211_HT_CAP_SM_PS                  0x000C
+#define IEEE80211_HT_CAP_GRN_FLD                0x0010
+#define IEEE80211_HT_CAP_SGI_20                 0x0020
+#define IEEE80211_HT_CAP_SGI_40                 0x0040
+#define IEEE80211_HT_CAP_TX_STBC                0x0080
+#define IEEE80211_HT_CAP_RX_STBC                0x0300
+#define IEEE80211_HT_CAP_DELAY_BA               0x0400
+#define IEEE80211_HT_CAP_MAX_AMSDU              0x0800
+#define IEEE80211_HT_CAP_DSSSCCK40              0x1000
+#define IEEE80211_HT_CAP_PSMP_SUPPORT           0x2000
+#define IEEE80211_HT_CAP_40MHZ_INTOLERANT       0x4000
+#define IEEE80211_HT_CAP_LSIG_TXOP_PROT         0x8000
+
+/* 802.11n HT capability AMPDU settings (for ampdu_params_info) */
+#define IEEE80211_HT_AMPDU_PARM_FACTOR          0x03
+#define IEEE80211_HT_AMPDU_PARM_DENSITY         0x1C
+
 /**
- * struct ieee80211_ht_cap - HT additional information
+ * struct ieee80211_ht_info - HT information
  *
- * This structure refers to "HT information element" as
- * described in 802.11n draft section 7.3.2.53
+ * This structure is the "HT information element" as
+ * described in 802.11n D5.0 7.3.2.58
  */
-struct ieee80211_ht_addt_info {
+struct ieee80211_ht_info {
         u8 control_chan;
         u8 ht_param;
         __le16 operation_mode;
@@ -714,36 +784,33 @@ struct ieee80211_ht_addt_info {
         u8 basic_set[16];
 } __attribute__ ((packed));
 
-/* 802.11n HT capabilities masks */
-#define IEEE80211_HT_CAP_SUP_WIDTH              0x0002
-#define IEEE80211_HT_CAP_SM_PS                  0x000C
-#define IEEE80211_HT_CAP_GRN_FLD                0x0010
-#define IEEE80211_HT_CAP_SGI_20                 0x0020
-#define IEEE80211_HT_CAP_SGI_40                 0x0040
-#define IEEE80211_HT_CAP_DELAY_BA               0x0400
-#define IEEE80211_HT_CAP_MAX_AMSDU              0x0800
-#define IEEE80211_HT_CAP_DSSSCCK40              0x1000
-/* 802.11n HT capability AMPDU settings */
-#define IEEE80211_HT_CAP_AMPDU_FACTOR           0x03
-#define IEEE80211_HT_CAP_AMPDU_DENSITY          0x1C
-/* 802.11n HT capability MSC set */
-#define IEEE80211_SUPP_MCS_SET_UEQM             4
-#define IEEE80211_HT_CAP_MAX_STREAMS            4
-#define IEEE80211_SUPP_MCS_SET_LEN              10
-/* maximum streams the spec allows */
-#define IEEE80211_HT_CAP_MCS_TX_DEFINED         0x01
-#define IEEE80211_HT_CAP_MCS_TX_RX_DIFF         0x02
-#define IEEE80211_HT_CAP_MCS_TX_STREAMS         0x0C
-#define IEEE80211_HT_CAP_MCS_TX_UEQM            0x10
-/* 802.11n HT IE masks */
-#define IEEE80211_HT_IE_CHA_SEC_OFFSET          0x03
-#define IEEE80211_HT_IE_CHA_SEC_NONE            0x00
-#define IEEE80211_HT_IE_CHA_SEC_ABOVE           0x01
-#define IEEE80211_HT_IE_CHA_SEC_BELOW           0x03
-#define IEEE80211_HT_IE_CHA_WIDTH               0x04
-#define IEEE80211_HT_IE_HT_PROTECTION           0x0003
-#define IEEE80211_HT_IE_NON_GF_STA_PRSNT        0x0004
-#define IEEE80211_HT_IE_NON_HT_STA_PRSNT        0x0010
+/* for ht_param */
+#define IEEE80211_HT_PARAM_CHA_SEC_OFFSET               0x03
+#define         IEEE80211_HT_PARAM_CHA_SEC_NONE         0x00
+#define         IEEE80211_HT_PARAM_CHA_SEC_ABOVE        0x01
+#define         IEEE80211_HT_PARAM_CHA_SEC_BELOW        0x03
+#define IEEE80211_HT_PARAM_CHAN_WIDTH_ANY               0x04
+#define IEEE80211_HT_PARAM_RIFS_MODE                    0x08
+#define IEEE80211_HT_PARAM_SPSMP_SUPPORT                0x10
+#define IEEE80211_HT_PARAM_SERV_INTERVAL_GRAN           0xE0
+
+/* for operation_mode */
+#define IEEE80211_HT_OP_MODE_PROTECTION                 0x0003
+#define         IEEE80211_HT_OP_MODE_PROTECTION_NONE            0
+#define         IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER       1
+#define         IEEE80211_HT_OP_MODE_PROTECTION_20MHZ           2
+#define         IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED     3
+#define IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT           0x0004
+#define IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT           0x0010
+
+/* for stbc_param */
+#define IEEE80211_HT_STBC_PARAM_DUAL_BEACON             0x0040
+#define IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT           0x0080
+#define IEEE80211_HT_STBC_PARAM_STBC_BEACON             0x0100
+#define IEEE80211_HT_STBC_PARAM_LSIG_TXOP_FULLPROT      0x0200
+#define IEEE80211_HT_STBC_PARAM_PCO_ACTIVE              0x0400
+#define IEEE80211_HT_STBC_PARAM_PCO_PHASE               0x0800
+
 
 /* block-ack parameters */
 #define IEEE80211_ADDBA_PARAM_POLICY_MASK 0x0002
@@ -769,7 +836,6 @@ struct ieee80211_ht_addt_info {
 /* Authentication algorithms */
 #define WLAN_AUTH_OPEN 0
 #define WLAN_AUTH_SHARED_KEY 1
-#define WLAN_AUTH_FAST_BSS_TRANSITION 2
 #define WLAN_AUTH_LEAP 128
 
 #define WLAN_AUTH_CHALLENGE_LEN 128
@@ -949,7 +1015,7 @@ enum ieee80211_eid {
         WLAN_EID_EXT_SUPP_RATES = 50,
         /* 802.11n */
         WLAN_EID_HT_CAPABILITY = 45,
-        WLAN_EID_HT_EXTRA_INFO = 61,
+        WLAN_EID_HT_INFORMATION = 61,
         /* 802.11i */
         WLAN_EID_RSN = 48,
         WLAN_EID_WPA = 221,
@@ -976,6 +1042,68 @@ enum ieee80211_spectrum_mgmt_actioncode {
         WLAN_ACTION_SPCT_CHL_SWITCH = 4,
 };
 
+/*
+ * IEEE 802.11-2007 7.3.2.9 Country information element
+ *
+ * Minimum length is 8 octets, ie len must be evenly
+ * divisible by 2
+ */
+
+/* Although the spec says 8 I'm seeing 6 in practice */
+#define IEEE80211_COUNTRY_IE_MIN_LEN    6
+
+/*
+ * For regulatory extension stuff see IEEE 802.11-2007
+ * Annex I (page 1141) and Annex J (page 1147). Also
+ * review 7.3.2.9.
+ *
+ * When dot11RegulatoryClassesRequired is true and the
+ * first_channel/reg_extension_id is >= 201 then the IE
+ * compromises of the 'ext' struct represented below:
+ *
+ *  - Regulatory extension ID - when generating IE this just needs
+ *    to be monotonically increasing for each triplet passed in
+ *    the IE
+ *  - Regulatory class - index into set of rules
+ *  - Coverage class - index into air propagation time (Table 7-27),
+ *    in microseconds, you can compute the air propagation time from
+ *    the index by multiplying by 3, so index 10 yields a propagation
+ *    of 10 us. Valid values are 0-31, values 32-255 are not defined
+ *    yet. A value of 0 inicates air propagation of <= 1 us.
+ *
+ *  See also Table I.2 for Emission limit sets and table
+ *  I.3 for Behavior limit sets. Table J.1 indicates how to map
+ *  a reg_class to an emission limit set and behavior limit set.
+ */
+#define IEEE80211_COUNTRY_EXTENSION_ID 201
+
+/*
+ *  Channels numbers in the IE must be monotonically increasing
+ *  if dot11RegulatoryClassesRequired is not true.
+ *
+ *  If dot11RegulatoryClassesRequired is true consecutive
+ *  subband triplets following a regulatory triplet shall
+ *  have monotonically increasing first_channel number fields.
+ *
+ *  Channel numbers shall not overlap.
+ *
+ *  Note that max_power is signed.
+ */
+struct ieee80211_country_ie_triplet {
+        union {
+                struct {
+                        u8 first_channel;
+                        u8 num_channels;
+                        s8 max_power;
+                } __attribute__ ((packed)) chans;
+                struct {
+                        u8 reg_extension_id;
+                        u8 reg_class;
+                        u8 coverage_class;
+                } __attribute__ ((packed)) ext;
+        };
+} __attribute__ ((packed));
+
 /* BACK action code */
 enum ieee80211_back_actioncode {
         WLAN_ACTION_ADDBA_REQ = 0,
@@ -1057,4 +1185,4 @@ static inline u8 *ieee80211_get_DA(struct ieee80211_hdr *hdr)
                 return hdr->addr1;
 }
 
-#endif /* IEEE80211_H */
+#endif /* LINUX_IEEE80211_H */
diff --git a/include/linux/if.h b/include/linux/if.h
index 65246846c844..2a6e29620a96 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -65,6 +65,7 @@
 #define IFF_BONDING     0x20            /* bonding master or slave      */
 #define IFF_SLAVE_NEEDARP 0x40          /* need ARPs for validation     */
 #define IFF_ISATAP      0x80            /* ISATAP interface (RFC4214)   */
+#define IFF_MASTER_ARPMON 0x100         /* bonding master, ARP mon in use */
 
 #define IF_GET_IFACE    0x0001          /* for querying only */
 #define IF_GET_PROTO    0x0002
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
index 4d3401812e6c..5ff89809a581 100644
--- a/include/linux/if_arp.h
+++ b/include/linux/if_arp.h
@@ -87,6 +87,9 @@
 #define ARPHRD_IEEE80211_PRISM 802      /* IEEE 802.11 + Prism2 header  */
 #define ARPHRD_IEEE80211_RADIOTAP 803   /* IEEE 802.11 + radiotap header */
 
+#define ARPHRD_PHONET   820             /* PhoNet media type            */
+#define ARPHRD_PHONET_PIPE 821          /* PhoNet pipe header           */
+
 #define ARPHRD_VOID       0xFFFF        /* Void type, nothing is known */
 #define ARPHRD_NONE       0xFFFE        /* zero header length */
 
diff --git a/include/linux/in.h b/include/linux/in.h
index db458beef19d..d60122a3a088 100644
--- a/include/linux/in.h
+++ b/include/linux/in.h
@@ -80,6 +80,10 @@ struct in_addr {
 /* BSD compatibility */
 #define IP_RECVRETOPTS  IP_RETOPTS
 
+/* TProxy original addresses */
+#define IP_ORIGDSTADDR       20
+#define IP_RECVORIGDSTADDR   IP_ORIGDSTADDR
+
 /* IP_MTU_DISCOVER values */
 #define IP_PMTUDISC_DONT                0       /* Never send DF frames */
 #define IP_PMTUDISC_WANT                1       /* Use per route hints  */
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 641e026eee8f..0b816cae533e 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -278,6 +278,7 @@ struct ipv6_pinfo {
         struct in6_addr         saddr;
         struct in6_addr         rcv_saddr;
         struct in6_addr         daddr;
+        struct in6_pktinfo      sticky_pktinfo;
         struct in6_addr         *daddr_cache;
 #ifdef CONFIG_IPV6_SUBTREES
         struct in6_addr         *saddr_cache;
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index dc7e0d0a6474..6002ae76785c 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -361,18 +361,6 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         ((unsigned char *)&addr)[3]
 #define NIPQUAD_FMT "%u.%u.%u.%u"
 
-#define NIP6(addr) \
-        ntohs((addr).s6_addr16[0]), \
-        ntohs((addr).s6_addr16[1]), \
-        ntohs((addr).s6_addr16[2]), \
-        ntohs((addr).s6_addr16[3]), \
-        ntohs((addr).s6_addr16[4]), \
-        ntohs((addr).s6_addr16[5]), \
-        ntohs((addr).s6_addr16[6]), \
-        ntohs((addr).s6_addr16[7])
-#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
-#define NIP6_SEQFMT "%04x%04x%04x%04x%04x%04x%04x%04x"
-
 #if defined(__LITTLE_ENDIAN)
 #define HIPQUAD(addr) \
         ((unsigned char *)&addr)[3], \
diff --git a/include/linux/list_nulls.h b/include/linux/list_nulls.h
new file mode 100644
index 000000000000..93150ecf3ea4
--- /dev/null
+++ b/include/linux/list_nulls.h
@@ -0,0 +1,94 @@
+#ifndef _LINUX_LIST_NULLS_H
+#define _LINUX_LIST_NULLS_H
+
+/*
+ * Special version of lists, where end of list is not a NULL pointer,
+ * but a 'nulls' marker, which can have many different values.
+ * (up to 2^31 different values guaranteed on all platforms)
+ *
+ * In the standard hlist, termination of a list is the NULL pointer.
+ * In this special 'nulls' variant, we use the fact that objects stored in
+ * a list are aligned on a word (4 or 8 bytes alignment).
+ * We therefore use the last significant bit of 'ptr' :
+ * Set to 1 : This is a 'nulls' end-of-list marker (ptr >> 1)
+ * Set to 0 : This is a pointer to some object (ptr)
+ */
+
+struct hlist_nulls_head {
+        struct hlist_nulls_node *first;
+};
+
+struct hlist_nulls_node {
+        struct hlist_nulls_node *next, **pprev;
+};
+#define INIT_HLIST_NULLS_HEAD(ptr, nulls) \
+        ((ptr)->first = (struct hlist_nulls_node *) (1UL | (((long)nulls) << 1)))
+
+#define hlist_nulls_entry(ptr, type, member) container_of(ptr,type,member)
+/**
+ * ptr_is_a_nulls - Test if a ptr is a nulls
+ * @ptr: ptr to be tested
+ *
+ */
+static inline int is_a_nulls(const struct hlist_nulls_node *ptr)
+{
+        return ((unsigned long)ptr & 1);
+}
+
+/**
+ * get_nulls_value - Get the 'nulls' value of the end of chain
+ * @ptr: end of chain
+ *
+ * Should be called only if is_a_nulls(ptr);
+ */
+static inline unsigned long get_nulls_value(const struct hlist_nulls_node *ptr)
+{
+        return ((unsigned long)ptr) >> 1;
+}
+
+static inline int hlist_nulls_unhashed(const struct hlist_nulls_node *h)
+{
+        return !h->pprev;
+}
+
+static inline int hlist_nulls_empty(const struct hlist_nulls_head *h)
+{
+        return is_a_nulls(h->first);
+}
+
+static inline void __hlist_nulls_del(struct hlist_nulls_node *n)
+{
+        struct hlist_nulls_node *next = n->next;
+        struct hlist_nulls_node **pprev = n->pprev;
+        *pprev = next;
+        if (!is_a_nulls(next))
+                next->pprev = pprev;
+}
+
+/**
+ * hlist_nulls_for_each_entry   - iterate over list of given type
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ *
+ */
+#define hlist_nulls_for_each_entry(tpos, pos, head, member)                    \
+        for (pos = (head)->first;                                              \
+             (!is_a_nulls(pos)) &&                                             \
+                ({ tpos = hlist_nulls_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = pos->next)
+
+/**
+ * hlist_nulls_for_each_entry_from - iterate over a hlist continuing from current point
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @member:     the name of the hlist_node within the struct.
+ *
+ */
+#define hlist_nulls_for_each_entry_from(tpos, pos, member)      \
+        for (; (!is_a_nulls(pos)) &&                            \
+                ({ tpos = hlist_nulls_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = pos->next)
+
+#endif
diff --git a/include/linux/mdio-gpio.h b/include/linux/mdio-gpio.h
new file mode 100644
index 000000000000..e9d3fdfe41d7
--- /dev/null
+++ b/include/linux/mdio-gpio.h
@@ -0,0 +1,25 @@
+/*
+ * MDIO-GPIO bus platform data structures
+ *
+ * Copyright (C) 2008, Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __LINUX_MDIO_GPIO_H
+#define __LINUX_MDIO_GPIO_H
+
+#include <linux/mdio-bitbang.h>
+
+struct mdio_gpio_platform_data {
+        /* GPIO numbers for bus pins */
+        unsigned int mdc;
+        unsigned int mdio;
+
+        unsigned int phy_mask;
+        int irqs[PHY_MAX_ADDR];
+};
+
+#endif /* __LINUX_MDIO_GPIO_H */
diff --git a/include/linux/mii.h b/include/linux/mii.h
index 151b7e0182c7..ad748588faf1 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -135,6 +135,10 @@
 #define LPA_1000FULL            0x0800  /* Link partner 1000BASE-T full duplex */
 #define LPA_1000HALF            0x0400  /* Link partner 1000BASE-T half duplex */
 
+/* Flow control flags */
+#define FLOW_CTRL_TX            0x01
+#define FLOW_CTRL_RX            0x02
+
 /* This structure is used in all SIOCxMIIxxx ioctl calls */
 struct mii_ioctl_data {
         __u16           phy_id;
@@ -235,5 +239,34 @@ static inline unsigned int mii_duplex (unsigned int duplex_lock,
         return 0;
 }
 
+/**
+ * mii_resolve_flowctrl_fdx
+ * @lcladv: value of MII ADVERTISE register
+ * @rmtadv: value of MII LPA register
+ *
+ * Resolve full duplex flow control as per IEEE 802.3-2005 table 28B-3
+ */
+static inline u8 mii_resolve_flowctrl_fdx(u16 lcladv, u16 rmtadv)
+{
+        u8 cap = 0;
+
+        if (lcladv & ADVERTISE_PAUSE_CAP) {
+                if (lcladv & ADVERTISE_PAUSE_ASYM) {
+                        if (rmtadv & LPA_PAUSE_CAP)
+                                cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
+                        else if (rmtadv & LPA_PAUSE_ASYM)
+                                cap = FLOW_CTRL_RX;
+                } else {
+                        if (rmtadv & LPA_PAUSE_CAP)
+                                cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
+                }
+        } else if (lcladv & ADVERTISE_PAUSE_ASYM) {
+                if ((rmtadv & LPA_PAUSE_CAP) && (rmtadv & LPA_PAUSE_ASYM))
+                        cap = FLOW_CTRL_TX;
+        }
+
+        return cap;
+}
+
 #endif /* __KERNEL__ */
 #endif /* __LINUX_MII_H__ */
diff --git a/include/linux/mroute6.h b/include/linux/mroute6.h
index 6f4c180179e2..5375faca1f72 100644
--- a/include/linux/mroute6.h
+++ b/include/linux/mroute6.h
@@ -117,6 +117,7 @@ struct sioc_mif_req6
 
 #include <linux/pim.h>
 #include <linux/skbuff.h>       /* for struct sk_buff_head */
+#include <net/net_namespace.h>
 
 #ifdef CONFIG_IPV6_MROUTE
 static inline int ip6_mroute_opt(int opt)
@@ -187,6 +188,9 @@ struct mif_device
 struct mfc6_cache
 {
         struct mfc6_cache *next;                /* Next entry on cache line     */
+#ifdef CONFIG_NET_NS
+        struct net *mfc6_net;
+#endif
         struct in6_addr mf6c_mcastgrp;                  /* Group the entry belongs to   */
         struct in6_addr mf6c_origin;                    /* Source of packet             */
         mifi_t mf6c_parent;                     /* Source interface             */
@@ -209,6 +213,18 @@ struct mfc6_cache
         } mfc_un;
 };
 
+static inline
+struct net *mfc6_net(const struct mfc6_cache *mfc)
+{
+        return read_pnet(&mfc->mfc6_net);
+}
+
+static inline
+void mfc6_net_set(struct mfc6_cache *mfc, struct net *net)
+{
+        write_pnet(&mfc->mfc6_net, hold_net(net));
+}
+
 #define MFC_STATIC              1
 #define MFC_NOTIFY              2
 
@@ -229,13 +245,17 @@ struct mfc6_cache
 
 #ifdef __KERNEL__
 struct rtmsg;
-extern int ip6mr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait);
+extern int ip6mr_get_route(struct net *net, struct sk_buff *skb,
+                           struct rtmsg *rtm, int nowait);
 
 #ifdef CONFIG_IPV6_MROUTE
-extern struct sock *mroute6_socket;
+static inline struct sock *mroute6_socket(struct net *net)
+{
+        return net->ipv6.mroute6_sk;
+}
 extern int ip6mr_sk_done(struct sock *sk);
 #else
-#define mroute6_socket NULL
+static inline struct sock *mroute6_socket(struct net *net) { return NULL; }
 static inline int ip6mr_sk_done(struct sock *sk) { return 0; }
 #endif
 #endif
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index e26f54952892..41e1224651cf 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -43,6 +43,9 @@
 
 #include <net/net_namespace.h>
 #include <net/dsa.h>
+#ifdef CONFIG_DCB
+#include <net/dcbnl.h>
+#endif
 
 struct vlan_group;
 struct ethtool_ops;
@@ -311,8 +314,9 @@ struct napi_struct {
         spinlock_t              poll_lock;
         int                     poll_owner;
         struct net_device       *dev;
-        struct list_head        dev_list;
 #endif
+        struct list_head        dev_list;
+        struct sk_buff          *gro_list;
 };
 
 enum
@@ -373,22 +377,8 @@ static inline int napi_reschedule(struct napi_struct *napi)
  *
  * Mark NAPI processing as complete.
  */
-static inline void __napi_complete(struct napi_struct *n)
-{
-        BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
-        list_del(&n->poll_list);
-        smp_mb__before_clear_bit();
-        clear_bit(NAPI_STATE_SCHED, &n->state);
-}
-
-static inline void napi_complete(struct napi_struct *n)
-{
-        unsigned long flags;
-
-        local_irq_save(flags);
-        __napi_complete(n);
-        local_irq_restore(flags);
-}
+extern void __napi_complete(struct napi_struct *n);
+extern void napi_complete(struct napi_struct *n);
 
 /**
  *      napi_disable - prevent NAPI from scheduling
@@ -452,6 +442,147 @@ struct netdev_queue {
         struct Qdisc            *qdisc_sleeping;
 } ____cacheline_aligned_in_smp;
 
+
+/*
+ * This structure defines the management hooks for network devices.
+ * The following hooks can be defined; unless noted otherwise, they are
+ * optional and can be filled with a null pointer.
+ *
+ * int (*ndo_init)(struct net_device *dev);
+ *     This function is called once when network device is registered.
+ *     The network device can use this to any late stage initializaton
+ *     or semantic validattion. It can fail with an error code which will
+ *     be propogated back to register_netdev
+ *
+ * void (*ndo_uninit)(struct net_device *dev);
+ *     This function is called when device is unregistered or when registration
+ *     fails. It is not called if init fails.
+ *
+ * int (*ndo_open)(struct net_device *dev);
+ *     This function is called when network device transistions to the up
+ *     state.
+ *
+ * int (*ndo_stop)(struct net_device *dev);
+ *     This function is called when network device transistions to the down
+ *     state.
+ *
+ * int (*ndo_hard_start_xmit)(struct sk_buff *skb, struct net_device *dev);
+ *      Called when a packet needs to be transmitted.
+ *      Must return NETDEV_TX_OK , NETDEV_TX_BUSY, or NETDEV_TX_LOCKED,
+ *      Required can not be NULL.
+ *
+ * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
+ *      Called to decide which queue to when device supports multiple
+ *      transmit queues.
+ *
+ * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
+ *      This function is called to allow device receiver to make
+ *      changes to configuration when multicast or promiscious is enabled.
+ *
+ * void (*ndo_set_rx_mode)(struct net_device *dev);
+ *      This function is called device changes address list filtering.
+ *
+ * void (*ndo_set_multicast_list)(struct net_device *dev);
+ *      This function is called when the multicast address list changes.
+ *
+ * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
+ *      This function  is called when the Media Access Control address
+ *      needs to be changed. If not this interface is not defined, the
+ *      mac address can not be changed.
+ *
+ * int (*ndo_validate_addr)(struct net_device *dev);
+ *      Test if Media Access Control address is valid for the device.
+ *
+ * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
+ *      Called when a user request an ioctl which can't be handled by
+ *      the generic interface code. If not defined ioctl's return
+ *      not supported error code.
+ *
+ * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
+ *      Used to set network devices bus interface parameters. This interface
+ *      is retained for legacy reason, new devices should use the bus
+ *      interface (PCI) for low level management.
+ *
+ * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
+ *      Called when a user wants to change the Maximum Transfer Unit
+ *      of a device. If not defined, any request to change MTU will
+ *      will return an error.
+ *
+ * void (*ndo_tx_timeout)(struct net_device *dev);
+ *      Callback uses when the transmitter has not made any progress
+ *      for dev->watchdog ticks.
+ *
+ * struct net_device_stats* (*get_stats)(struct net_device *dev);
+ *      Called when a user wants to get the network device usage
+ *      statistics. If not defined, the counters in dev->stats will
+ *      be used.
+ *
+ * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
+ *      If device support VLAN receive accleration
+ *      (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
+ *      when vlan groups for the device changes.  Note: grp is NULL
+ *      if no vlan's groups are being used.
+ *
+ * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
+ *      If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
+ *      this function is called when a VLAN id is registered.
+ *
+ * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
+ *      If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
+ *      this function is called when a VLAN id is unregistered.
+ *
+ * void (*ndo_poll_controller)(struct net_device *dev);
+ */
+#define HAVE_NET_DEVICE_OPS
+struct net_device_ops {
+        int                     (*ndo_init)(struct net_device *dev);
+        void                    (*ndo_uninit)(struct net_device *dev);
+        int                     (*ndo_open)(struct net_device *dev);
+        int                     (*ndo_stop)(struct net_device *dev);
+        int                     (*ndo_start_xmit) (struct sk_buff *skb,
+                                                   struct net_device *dev);
+        u16                     (*ndo_select_queue)(struct net_device *dev,
+                                                    struct sk_buff *skb);
+#define HAVE_CHANGE_RX_FLAGS
+        void                    (*ndo_change_rx_flags)(struct net_device *dev,
+                                                       int flags);
+#define HAVE_SET_RX_MODE
+        void                    (*ndo_set_rx_mode)(struct net_device *dev);
+#define HAVE_MULTICAST
+        void                    (*ndo_set_multicast_list)(struct net_device *dev);
+#define HAVE_SET_MAC_ADDR
+        int                     (*ndo_set_mac_address)(struct net_device *dev,
+                                                       void *addr);
+#define HAVE_VALIDATE_ADDR
+        int                     (*ndo_validate_addr)(struct net_device *dev);
+#define HAVE_PRIVATE_IOCTL
+        int                     (*ndo_do_ioctl)(struct net_device *dev,
+                                                struct ifreq *ifr, int cmd);
+#define HAVE_SET_CONFIG
+        int                     (*ndo_set_config)(struct net_device *dev,
+                                                  struct ifmap *map);
+#define HAVE_CHANGE_MTU
+        int                     (*ndo_change_mtu)(struct net_device *dev,
+                                                  int new_mtu);
+        int                     (*ndo_neigh_setup)(struct net_device *dev,
+                                                   struct neigh_parms *);
+#define HAVE_TX_TIMEOUT
+        void                    (*ndo_tx_timeout) (struct net_device *dev);
+
+        struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
+
+        void                    (*ndo_vlan_rx_register)(struct net_device *dev,
+                                                        struct vlan_group *grp);
+        void                    (*ndo_vlan_rx_add_vid)(struct net_device *dev,
+                                                       unsigned short vid);
+        void                    (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
+                                                        unsigned short vid);
+#ifdef CONFIG_NET_POLL_CONTROLLER
+#define HAVE_NETDEV_POLL
+        void                    (*ndo_poll_controller)(struct net_device *dev);
+#endif
+};
+
 /*
  *      The DEVICE structure.
  *      Actually, this whole structure is a big mistake.  It mixes I/O
@@ -496,14 +627,7 @@ struct net_device
         unsigned long           state;
 
         struct list_head        dev_list;
-#ifdef CONFIG_NETPOLL
         struct list_head        napi_list;
-#endif
-        
-        /* The device initialization function. Called only once. */
-        int                     (*init)(struct net_device *dev);
-
-        /* ------- Fields preinitialized in Space.c finish here ------- */
 
         /* Net device features */
         unsigned long           features;
@@ -522,6 +646,7 @@ struct net_device
 #define NETIF_F_LLTX            4096    /* LockLess TX - deprecated. Please */
                                         /* do not use LLTX in new drivers */
 #define NETIF_F_NETNS_LOCAL     8192    /* Does not change network namespaces */
+#define NETIF_F_GRO             16384   /* Generic receive offload */
 #define NETIF_F_LRO             32768   /* large receive offload */
 
         /* Segmentation offload features */
@@ -547,15 +672,13 @@ struct net_device
          * for all in netdev_increment_features.
          */
 #define NETIF_F_ONE_FOR_ALL     (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
-                                 NETIF_F_SG | NETIF_F_HIGHDMA | \
+                                 NETIF_F_SG | NETIF_F_HIGHDMA |         \
                                  NETIF_F_FRAGLIST)
 
         /* Interface index. Unique device identifier    */
         int                     ifindex;
         int                     iflink;
 
-
-        struct net_device_stats* (*get_stats)(struct net_device *dev);
         struct net_device_stats stats;
 
 #ifdef CONFIG_WIRELESS_EXT
@@ -565,18 +688,13 @@ struct net_device
         /* Instance data managed by the core of Wireless Extensions. */
         struct iw_public_data * wireless_data;
 #endif
+        /* Management operations */
+        const struct net_device_ops *netdev_ops;
         const struct ethtool_ops *ethtool_ops;
 
         /* Hardware header description */
         const struct header_ops *header_ops;
 
-        /*
-         * This marks the end of the "visible" part of the structure. All
-         * fields hereafter are internal to the system, and may change at
-         * will (read: may be cleaned up at will).
-         */
-
-
         unsigned int            flags;  /* interface flags (a la BSD)   */
         unsigned short          gflags;
         unsigned short          priv_flags; /* Like 'flags' but invisible to userspace. */
@@ -635,7 +753,7 @@ struct net_device
         unsigned long           last_rx;        /* Time of last Rx      */
         /* Interface address info used in eth_type_trans() */
         unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast 
-                                                        because most packets are unicast) */
+                                                           because most packets are unicast) */
 
         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
 
@@ -654,18 +772,12 @@ struct net_device
 /*
  * One part is mostly used on xmit path (device)
  */
-        void                    *priv;  /* pointer to private data      */
-        int                     (*hard_start_xmit) (struct sk_buff *skb,
-                                                    struct net_device *dev);
         /* These may be needed for future network-power-down code. */
         unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
 
         int                     watchdog_timeo; /* used by dev_watchdog() */
         struct timer_list       watchdog_timer;
 
-/*
- * refcnt is a very hot point, so align it on SMP
- */
         /* Number of references to this device */
         atomic_t                refcnt ____cacheline_aligned_in_smp;
 
@@ -684,56 +796,12 @@ struct net_device
                NETREG_RELEASED,         /* called free_netdev */
         } reg_state;
 
-        /* Called after device is detached from network. */
-        void                    (*uninit)(struct net_device *dev);
-        /* Called after last user reference disappears. */
-        void                    (*destructor)(struct net_device *dev);
-
-        /* Pointers to interface service routines.      */
-        int                     (*open)(struct net_device *dev);
-        int                     (*stop)(struct net_device *dev);
-#define HAVE_NETDEV_POLL
-#define HAVE_CHANGE_RX_FLAGS
-        void                    (*change_rx_flags)(struct net_device *dev,
-                                                   int flags);
-#define HAVE_SET_RX_MODE
-        void                    (*set_rx_mode)(struct net_device *dev);
-#define HAVE_MULTICAST                   
-        void                    (*set_multicast_list)(struct net_device *dev);
-#define HAVE_SET_MAC_ADDR                
-        int                     (*set_mac_address)(struct net_device *dev,
-                                                   void *addr);
-#define HAVE_VALIDATE_ADDR
-        int                     (*validate_addr)(struct net_device *dev);
-#define HAVE_PRIVATE_IOCTL
-        int                     (*do_ioctl)(struct net_device *dev,
-                                            struct ifreq *ifr, int cmd);
-#define HAVE_SET_CONFIG
-        int                     (*set_config)(struct net_device *dev,
-                                              struct ifmap *map);
-#define HAVE_CHANGE_MTU
-        int                     (*change_mtu)(struct net_device *dev, int new_mtu);
-
-#define HAVE_TX_TIMEOUT
-        void                    (*tx_timeout) (struct net_device *dev);
-
-        void                    (*vlan_rx_register)(struct net_device *dev,
-                                                    struct vlan_group *grp);
-        void                    (*vlan_rx_add_vid)(struct net_device *dev,
-                                                   unsigned short vid);
-        void                    (*vlan_rx_kill_vid)(struct net_device *dev,
-                                                    unsigned short vid);
+        /* Called from unregister, can be used to call free_netdev */
+        void (*destructor)(struct net_device *dev);
 
-        int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
 #ifdef CONFIG_NETPOLL
         struct netpoll_info     *npinfo;
 #endif
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        void                    (*poll_controller)(struct net_device *dev);
-#endif
-
-        u16                     (*select_queue)(struct net_device *dev,
-                                                struct sk_buff *skb);
 
 #ifdef CONFIG_NET_NS
         /* Network namespace this network device is inside */
@@ -764,6 +832,49 @@ struct net_device
         /* for setting kernel sock attribute on TCP connection setup */
 #define GSO_MAX_SIZE            65536
         unsigned int            gso_max_size;
+
+#ifdef CONFIG_DCB
+        /* Data Center Bridging netlink ops */
+        struct dcbnl_rtnl_ops *dcbnl_ops;
+#endif
+
+#ifdef CONFIG_COMPAT_NET_DEV_OPS
+        struct {
+                int                     (*init)(struct net_device *dev);
+                void                    (*uninit)(struct net_device *dev);
+                int                     (*open)(struct net_device *dev);
+                int                     (*stop)(struct net_device *dev);
+                int                     (*hard_start_xmit) (struct sk_buff *skb,
+                                                            struct net_device *dev);
+                u16                     (*select_queue)(struct net_device *dev,
+                                                        struct sk_buff *skb);
+                void                    (*change_rx_flags)(struct net_device *dev,
+                                                           int flags);
+                void                    (*set_rx_mode)(struct net_device *dev);
+                void                    (*set_multicast_list)(struct net_device *dev);
+                int                     (*set_mac_address)(struct net_device *dev,
+                                                           void *addr);
+                int                     (*validate_addr)(struct net_device *dev);
+                int                     (*do_ioctl)(struct net_device *dev,
+                                                    struct ifreq *ifr, int cmd);
+                int                     (*set_config)(struct net_device *dev,
+                                                      struct ifmap *map);
+                int                     (*change_mtu)(struct net_device *dev, int new_mtu);
+                int                     (*neigh_setup)(struct net_device *dev,
+                                                       struct neigh_parms *);
+                void                    (*tx_timeout) (struct net_device *dev);
+                struct net_device_stats* (*get_stats)(struct net_device *dev);
+                void                    (*vlan_rx_register)(struct net_device *dev,
+                                                            struct vlan_group *grp);
+                void                    (*vlan_rx_add_vid)(struct net_device *dev,
+                                                           unsigned short vid);
+                void                    (*vlan_rx_kill_vid)(struct net_device *dev,
+                                                            unsigned short vid);
+#ifdef CONFIG_NET_POLL_CONTROLLER
+                void                    (*poll_controller)(struct net_device *dev);
+#endif
+        };
+#endif
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 
@@ -859,22 +970,8 @@ static inline void *netdev_priv(const struct net_device *dev)
  * netif_napi_add() must be used to initialize a napi context prior to calling
  * *any* of the other napi related functions.
  */
-static inline void netif_napi_add(struct net_device *dev,
-                                  struct napi_struct *napi,
-                                  int (*poll)(struct napi_struct *, int),
-                                  int weight)
-{
-        INIT_LIST_HEAD(&napi->poll_list);
-        napi->poll = poll;
-        napi->weight = weight;
-#ifdef CONFIG_NETPOLL
-        napi->dev = dev;
-        list_add(&napi->dev_list, &dev->napi_list);
-        spin_lock_init(&napi->poll_lock);
-        napi->poll_owner = -1;
-#endif
-        set_bit(NAPI_STATE_SCHED, &napi->state);
-}
+void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
+                    int (*poll)(struct napi_struct *, int), int weight);
 
 /**
  *  netif_napi_del - remove a napi context
@@ -882,12 +979,20 @@ static inline void netif_napi_add(struct net_device *dev,
  *
  *  netif_napi_del() removes a napi context from the network device napi list
  */
-static inline void netif_napi_del(struct napi_struct *napi)
-{
-#ifdef CONFIG_NETPOLL
-        list_del(&napi->dev_list);
-#endif
-}
+void netif_napi_del(struct napi_struct *napi);
+
+struct napi_gro_cb {
+        /* This is non-zero if the packet may be of the same flow. */
+        int same_flow;
+
+        /* This is non-zero if the packet cannot be merged with the new skb. */
+        int flush;
+
+        /* Number of segments aggregated. */
+        int count;
+};
+
+#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
 
 struct packet_type {
         __be16                  type;   /* This is really htons(ether_type). */
@@ -899,6 +1004,9 @@ struct packet_type {
         struct sk_buff          *(*gso_segment)(struct sk_buff *skb,
                                                 int features);
         int                     (*gso_send_check)(struct sk_buff *skb);
+        struct sk_buff          **(*gro_receive)(struct sk_buff **head,
+                                               struct sk_buff *skb);
+        int                     (*gro_complete)(struct sk_buff *skb);
         void                    *af_packet_priv;
         struct list_head        list;
 };
@@ -1252,6 +1360,9 @@ extern int		netif_rx(struct sk_buff *skb);
 extern int              netif_rx_ni(struct sk_buff *skb);
 #define HAVE_NETIF_RECEIVE_SKB 1
 extern int              netif_receive_skb(struct sk_buff *skb);
+extern void             napi_gro_flush(struct napi_struct *napi);
+extern int              napi_gro_receive(struct napi_struct *napi,
+                                         struct sk_buff *skb);
 extern void             netif_nit_deliver(struct sk_buff *skb);
 extern int              dev_valid_name(const char *name);
 extern int              dev_ioctl(struct net *net, unsigned int cmd, void __user *);
@@ -1444,8 +1555,7 @@ static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
 }
 
 /* Test if receive needs to be scheduled but only if up */
-static inline int netif_rx_schedule_prep(struct net_device *dev,
-                                         struct napi_struct *napi)
+static inline int netif_rx_schedule_prep(struct napi_struct *napi)
 {
         return napi_schedule_prep(napi);
 }
@@ -1453,27 +1563,24 @@ static inline int netif_rx_schedule_prep(struct net_device *dev,
 /* Add interface to tail of rx poll list. This assumes that _prep has
  * already been called and returned 1.
  */
-static inline void __netif_rx_schedule(struct net_device *dev,
-                                       struct napi_struct *napi)
+static inline void __netif_rx_schedule(struct napi_struct *napi)
 {
         __napi_schedule(napi);
 }
 
 /* Try to reschedule poll. Called by irq handler. */
 
-static inline void netif_rx_schedule(struct net_device *dev,
-                                     struct napi_struct *napi)
+static inline void netif_rx_schedule(struct napi_struct *napi)
 {
-        if (netif_rx_schedule_prep(dev, napi))
-                __netif_rx_schedule(dev, napi);
+        if (netif_rx_schedule_prep(napi))
+                __netif_rx_schedule(napi);
 }
 
 /* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().  */
-static inline int netif_rx_reschedule(struct net_device *dev,
-                                      struct napi_struct *napi)
+static inline int netif_rx_reschedule(struct napi_struct *napi)
 {
         if (napi_schedule_prep(napi)) {
-                __netif_rx_schedule(dev, napi);
+                __netif_rx_schedule(napi);
                 return 1;
         }
         return 0;
@@ -1482,8 +1589,7 @@ static inline int netif_rx_reschedule(struct net_device *dev,
 /* same as netif_rx_complete, except that local_irq_save(flags)
  * has already been issued
  */
-static inline void __netif_rx_complete(struct net_device *dev,
-                                       struct napi_struct *napi)
+static inline void __netif_rx_complete(struct napi_struct *napi)
 {
         __napi_complete(napi);
 }
@@ -1493,20 +1599,9 @@ static inline void __netif_rx_complete(struct net_device *dev,
  * it completes the work. The device cannot be out of poll list at this
  * moment, it is BUG().
  */
-static inline void netif_rx_complete(struct net_device *dev,
-                                     struct napi_struct *napi)
+static inline void netif_rx_complete(struct napi_struct *napi)
 {
-        unsigned long flags;
-
-        /*
-         * don't let napi dequeue from the cpu poll list
-         * just in case its running on a different cpu
-         */
-        if (unlikely(test_bit(NAPI_STATE_NPSVC, &napi->state)))
-                return;
-        local_irq_save(flags);
-        __netif_rx_complete(dev, napi);
-        local_irq_restore(flags);
+        napi_complete(napi);
 }
 
 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
@@ -1683,6 +1778,8 @@ extern void		netdev_features_change(struct net_device *dev);
 /* Load a device via the kmod */
 extern void             dev_load(struct net *net, const char *name);
 extern void             dev_mcast_init(void);
+extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
+
 extern int              netdev_max_backlog;
 extern int              weight_p;
 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
@@ -1731,6 +1828,8 @@ static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
 {
         return skb_is_gso(skb) &&
                (!skb_gso_ok(skb, dev->features) ||
+                (skb_shinfo(skb)->frag_list &&
+                 !(dev->features & NETIF_F_FRAGLIST)) ||
                 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
 }
 
@@ -1749,26 +1848,31 @@ static inline int skb_bond_should_drop(struct sk_buff *skb)
         struct net_device *dev = skb->dev;
         struct net_device *master = dev->master;
 
-        if (master &&
-            (dev->priv_flags & IFF_SLAVE_INACTIVE)) {
-                if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
-                    skb->protocol == __constant_htons(ETH_P_ARP))
-                        return 0;
+        if (master) {
+                if (master->priv_flags & IFF_MASTER_ARPMON)
+                        dev->last_rx = jiffies;
 
-                if (master->priv_flags & IFF_MASTER_ALB) {
-                        if (skb->pkt_type != PACKET_BROADCAST &&
-                            skb->pkt_type != PACKET_MULTICAST)
+                if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
+                        if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
+                            skb->protocol == __constant_htons(ETH_P_ARP))
                                 return 0;
-                }
-                if (master->priv_flags & IFF_MASTER_8023AD &&
-                    skb->protocol == __constant_htons(ETH_P_SLOW))
-                        return 0;
 
-                return 1;
+                        if (master->priv_flags & IFF_MASTER_ALB) {
+                                if (skb->pkt_type != PACKET_BROADCAST &&
+                                    skb->pkt_type != PACKET_MULTICAST)
+                                        return 0;
+                        }
+                        if (master->priv_flags & IFF_MASTER_8023AD &&
+                            skb->protocol == __constant_htons(ETH_P_SLOW))
+                                return 0;
+
+                        return 1;
+                }
         }
         return 0;
 }
 
+extern struct pernet_operations __net_initdata loopback_net_ops;
 #endif /* __KERNEL__ */
 
 #endif  /* _LINUX_DEV_H */
diff --git a/include/linux/netfilter_bridge/ebtables.h b/include/linux/netfilter_bridge/ebtables.h
index d45e29cd1cfb..e40ddb94b1af 100644
--- a/include/linux/netfilter_bridge/ebtables.h
+++ b/include/linux/netfilter_bridge/ebtables.h
@@ -300,7 +300,8 @@ struct ebt_table
 
 #define EBT_ALIGN(s) (((s) + (__alignof__(struct ebt_replace)-1)) & \
                      ~(__alignof__(struct ebt_replace)-1))
-extern int ebt_register_table(struct ebt_table *table);
+extern struct ebt_table *ebt_register_table(struct net *net,
+                                            struct ebt_table *table);
 extern void ebt_unregister_table(struct ebt_table *table);
 extern unsigned int ebt_do_table(unsigned int hook, struct sk_buff *skb,
    const struct net_device *in, const struct net_device *out,
diff --git a/include/linux/netfilter_ipv4/ipt_policy.h b/include/linux/netfilter_ipv4/ipt_policy.h
index b9478a255301..1037fb2cd206 100644
--- a/include/linux/netfilter_ipv4/ipt_policy.h
+++ b/include/linux/netfilter_ipv4/ipt_policy.h
@@ -1,6 +1,8 @@
 #ifndef _IPT_POLICY_H
 #define _IPT_POLICY_H
 
+#include <linux/netfilter/xt_policy.h>
+
 #define IPT_POLICY_MAX_ELEM             XT_POLICY_MAX_ELEM
 
 /* ipt_policy_flags */
diff --git a/include/linux/netfilter_ipv6/ip6t_policy.h b/include/linux/netfilter_ipv6/ip6t_policy.h
index 6bab3163d2fb..b1c449d7ec89 100644
--- a/include/linux/netfilter_ipv6/ip6t_policy.h
+++ b/include/linux/netfilter_ipv6/ip6t_policy.h
@@ -1,6 +1,8 @@
 #ifndef _IP6T_POLICY_H
 #define _IP6T_POLICY_H
 
+#include <linux/netfilter/xt_policy.h>
+
 #define IP6T_POLICY_MAX_ELEM            XT_POLICY_MAX_ELEM
 
 /* ip6t_policy_flags */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 9ff1b54908f3..51b09a1f46c3 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -242,7 +242,8 @@ __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
         nlh->nlmsg_flags = flags;
         nlh->nlmsg_pid = pid;
         nlh->nlmsg_seq = seq;
-        memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size);
+        if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0)
+                memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size);
         return nlh;
 }
 
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index e3d79593fb3a..e38d3c9dccda 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -94,11 +94,6 @@ static inline void netpoll_poll_unlock(void *have)
         rcu_read_unlock();
 }
 
-static inline void netpoll_netdev_init(struct net_device *dev)
-{
-        INIT_LIST_HEAD(&dev->napi_list);
-}
-
 #else
 static inline int netpoll_rx(struct sk_buff *skb)
 {
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index 9bad65400fba..e86ed59f9ad5 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -3,7 +3,26 @@
 /*
  * 802.11 netlink interface public header
  *
- * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2006, 2007, 2008 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2008 Michael Wu <flamingice@sourmilk.net>
+ * Copyright 2008 Luis Carlos Cobo <luisca@cozybit.com>
+ * Copyright 2008 Michael Buesch <mb@bu3sch.de>
+ * Copyright 2008 Luis R. Rodriguez <lrodriguez@atheros.com>
+ * Copyright 2008 Jouni Malinen <jouni.malinen@atheros.com>
+ * Copyright 2008 Colin McCabe <colin@cozybit.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
  */
 
 /**
@@ -25,8 +44,10 @@
  *
  * @NL80211_CMD_GET_WIPHY: request information about a wiphy or dump request
  *      to get a list of all present wiphys.
- * @NL80211_CMD_SET_WIPHY: set wiphy name, needs %NL80211_ATTR_WIPHY and
- *      %NL80211_ATTR_WIPHY_NAME.
+ * @NL80211_CMD_SET_WIPHY: set wiphy parameters, needs %NL80211_ATTR_WIPHY or
+ *      %NL80211_ATTR_IFINDEX; can be used to set %NL80211_ATTR_WIPHY_NAME,
+ *      %NL80211_ATTR_WIPHY_TXQ_PARAMS, %NL80211_ATTR_WIPHY_FREQ, and/or
+ *      %NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET.
  * @NL80211_CMD_NEW_WIPHY: Newly created wiphy, response to get request
  *      or rename notification. Has attributes %NL80211_ATTR_WIPHY and
  *      %NL80211_ATTR_WIPHY_NAME.
@@ -106,6 +127,12 @@
  *      to the the specified ISO/IEC 3166-1 alpha2 country code. The core will
  *      store this as a valid request and then query userspace for it.
  *
+ * @NL80211_CMD_GET_MESH_PARAMS: Get mesh networking properties for the
+ *      interface identified by %NL80211_ATTR_IFINDEX
+ *
+ * @NL80211_CMD_SET_MESH_PARAMS: Set mesh networking properties for the
+ *      interface identified by %NL80211_ATTR_IFINDEX
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -148,6 +175,9 @@ enum nl80211_commands {
         NL80211_CMD_SET_REG,
         NL80211_CMD_REQ_SET_REG,
 
+        NL80211_CMD_GET_MESH_PARAMS,
+        NL80211_CMD_SET_MESH_PARAMS,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -169,6 +199,15 @@ enum nl80211_commands {
  * @NL80211_ATTR_WIPHY: index of wiphy to operate on, cf.
  *      /sys/class/ieee80211/<phyname>/index
  * @NL80211_ATTR_WIPHY_NAME: wiphy name (used for renaming)
+ * @NL80211_ATTR_WIPHY_TXQ_PARAMS: a nested array of TX queue parameters
+ * @NL80211_ATTR_WIPHY_FREQ: frequency of the selected channel in MHz
+ * @NL80211_ATTR_WIPHY_CHANNEL_TYPE: included with NL80211_ATTR_WIPHY_FREQ
+ *      if HT20 or HT40 are allowed (i.e., 802.11n disabled if not included):
+ *      NL80211_CHAN_NO_HT = HT not allowed (i.e., same as not including
+ *              this attribute)
+ *      NL80211_CHAN_HT20 = HT20 only
+ *      NL80211_CHAN_HT40MINUS = secondary channel is below the primary channel
+ *      NL80211_CHAN_HT40PLUS = secondary channel is above the primary channel
  *
  * @NL80211_ATTR_IFINDEX: network interface index of the device to operate on
  * @NL80211_ATTR_IFNAME: network interface name
@@ -234,6 +273,9 @@ enum nl80211_commands {
  *      (u8, 0 or 1)
  * @NL80211_ATTR_BSS_SHORT_SLOT_TIME: whether short slot time enabled
  *      (u8, 0 or 1)
+ * @NL80211_ATTR_BSS_BASIC_RATES: basic rates, array of basic
+ *      rates in format defined by IEEE 802.11 7.3.2.2 but without the length
+ *      restriction (at most %NL80211_MAX_SUPP_RATES).
  *
  * @NL80211_ATTR_HT_CAPABILITY: HT Capability information element (from
  *      association request when used with NL80211_CMD_NEW_STATION)
@@ -296,6 +338,14 @@ enum nl80211_attrs {
         NL80211_ATTR_REG_ALPHA2,
         NL80211_ATTR_REG_RULES,
 
+        NL80211_ATTR_MESH_PARAMS,
+
+        NL80211_ATTR_BSS_BASIC_RATES,
+
+        NL80211_ATTR_WIPHY_TXQ_PARAMS,
+        NL80211_ATTR_WIPHY_FREQ,
+        NL80211_ATTR_WIPHY_CHANNEL_TYPE,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -307,6 +357,10 @@ enum nl80211_attrs {
  * here
  */
 #define NL80211_ATTR_HT_CAPABILITY NL80211_ATTR_HT_CAPABILITY
+#define NL80211_ATTR_BSS_BASIC_RATES NL80211_ATTR_BSS_BASIC_RATES
+#define NL80211_ATTR_WIPHY_TXQ_PARAMS NL80211_ATTR_WIPHY_TXQ_PARAMS
+#define NL80211_ATTR_WIPHY_FREQ NL80211_ATTR_WIPHY_FREQ
+#define NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET
 
 #define NL80211_MAX_SUPP_RATES                  32
 #define NL80211_MAX_SUPP_REG_RULES              32
@@ -371,6 +425,32 @@ enum nl80211_sta_flags {
 };
 
 /**
+ * enum nl80211_rate_info - bitrate information
+ *
+ * These attribute types are used with %NL80211_STA_INFO_TXRATE
+ * when getting information about the bitrate of a station.
+ *
+ * @__NL80211_RATE_INFO_INVALID: attribute number 0 is reserved
+ * @NL80211_RATE_INFO_BITRATE: total bitrate (u16, 100kbit/s)
+ * @NL80211_RATE_INFO_MCS: mcs index for 802.11n (u8)
+ * @NL80211_RATE_INFO_40_MHZ_WIDTH: 40 Mhz dualchannel bitrate
+ * @NL80211_RATE_INFO_SHORT_GI: 400ns guard interval
+ * @NL80211_RATE_INFO_MAX: highest rate_info number currently defined
+ * @__NL80211_RATE_INFO_AFTER_LAST: internal use
+ */
+enum nl80211_rate_info {
+        __NL80211_RATE_INFO_INVALID,
+        NL80211_RATE_INFO_BITRATE,
+        NL80211_RATE_INFO_MCS,
+        NL80211_RATE_INFO_40_MHZ_WIDTH,
+        NL80211_RATE_INFO_SHORT_GI,
+
+        /* keep last */
+        __NL80211_RATE_INFO_AFTER_LAST,
+        NL80211_RATE_INFO_MAX = __NL80211_RATE_INFO_AFTER_LAST - 1
+};
+
+/**
  * enum nl80211_sta_info - station information
  *
  * These attribute types are used with %NL80211_ATTR_STA_INFO
@@ -382,6 +462,9 @@ enum nl80211_sta_flags {
  * @NL80211_STA_INFO_TX_BYTES: total transmitted bytes (u32, to this station)
  * @__NL80211_STA_INFO_AFTER_LAST: internal
  * @NL80211_STA_INFO_MAX: highest possible station info attribute
+ * @NL80211_STA_INFO_SIGNAL: signal strength of last received PPDU (u8, dBm)
+ * @NL80211_STA_INFO_TX_BITRATE: current unicast tx rate, nested attribute
+ *      containing info as possible, see &enum nl80211_sta_info_txrate.
  */
 enum nl80211_sta_info {
         __NL80211_STA_INFO_INVALID,
@@ -391,6 +474,8 @@ enum nl80211_sta_info {
         NL80211_STA_INFO_LLID,
         NL80211_STA_INFO_PLID,
         NL80211_STA_INFO_PLINK_STATE,
+        NL80211_STA_INFO_SIGNAL,
+        NL80211_STA_INFO_TX_BITRATE,
 
         /* keep last */
         __NL80211_STA_INFO_AFTER_LAST,
@@ -452,17 +537,29 @@ enum nl80211_mpath_info {
  *      an array of nested frequency attributes
  * @NL80211_BAND_ATTR_RATES: supported bitrates in this band,
  *      an array of nested bitrate attributes
+ * @NL80211_BAND_ATTR_HT_MCS_SET: 16-byte attribute containing the MCS set as
+ *      defined in 802.11n
+ * @NL80211_BAND_ATTR_HT_CAPA: HT capabilities, as in the HT information IE
+ * @NL80211_BAND_ATTR_HT_AMPDU_FACTOR: A-MPDU factor, as in 11n
+ * @NL80211_BAND_ATTR_HT_AMPDU_DENSITY: A-MPDU density, as in 11n
  */
 enum nl80211_band_attr {
         __NL80211_BAND_ATTR_INVALID,
         NL80211_BAND_ATTR_FREQS,
         NL80211_BAND_ATTR_RATES,
 
+        NL80211_BAND_ATTR_HT_MCS_SET,
+        NL80211_BAND_ATTR_HT_CAPA,
+        NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
+        NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
+
         /* keep last */
         __NL80211_BAND_ATTR_AFTER_LAST,
         NL80211_BAND_ATTR_MAX = __NL80211_BAND_ATTR_AFTER_LAST - 1
 };
 
+#define NL80211_BAND_ATTR_HT_CAPA NL80211_BAND_ATTR_HT_CAPA
+
 /**
  * enum nl80211_frequency_attr - frequency attributes
  * @NL80211_FREQUENCY_ATTR_FREQ: Frequency in MHz
@@ -474,6 +571,8 @@ enum nl80211_band_attr {
  *      on this channel in current regulatory domain.
  * @NL80211_FREQUENCY_ATTR_RADAR: Radar detection is mandatory
  *      on this channel in current regulatory domain.
+ * @NL80211_FREQUENCY_ATTR_MAX_TX_POWER: Maximum transmission power in mBm
+ *      (100 * dBm).
  */
 enum nl80211_frequency_attr {
         __NL80211_FREQUENCY_ATTR_INVALID,
@@ -482,12 +581,15 @@ enum nl80211_frequency_attr {
         NL80211_FREQUENCY_ATTR_PASSIVE_SCAN,
         NL80211_FREQUENCY_ATTR_NO_IBSS,
         NL80211_FREQUENCY_ATTR_RADAR,
+        NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
 
         /* keep last */
         __NL80211_FREQUENCY_ATTR_AFTER_LAST,
         NL80211_FREQUENCY_ATTR_MAX = __NL80211_FREQUENCY_ATTR_AFTER_LAST - 1
 };
 
+#define NL80211_FREQUENCY_ATTR_MAX_TX_POWER NL80211_FREQUENCY_ATTR_MAX_TX_POWER
+
 /**
  * enum nl80211_bitrate_attr - bitrate attributes
  * @NL80211_BITRATE_ATTR_RATE: Bitrate in units of 100 kbps
@@ -594,4 +696,119 @@ enum nl80211_mntr_flags {
         NL80211_MNTR_FLAG_MAX = __NL80211_MNTR_FLAG_AFTER_LAST - 1
 };
 
+/**
+ * enum nl80211_meshconf_params - mesh configuration parameters
+ *
+ * Mesh configuration parameters
+ *
+ * @__NL80211_MESHCONF_INVALID: internal use
+ *
+ * @NL80211_MESHCONF_RETRY_TIMEOUT: specifies the initial retry timeout in
+ * millisecond units, used by the Peer Link Open message
+ *
+ * @NL80211_MESHCONF_CONFIRM_TIMEOUT: specifies the inital confirm timeout, in
+ * millisecond units, used by the peer link management to close a peer link
+ *
+ * @NL80211_MESHCONF_HOLDING_TIMEOUT: specifies the holding timeout, in
+ * millisecond units
+ *
+ * @NL80211_MESHCONF_MAX_PEER_LINKS: maximum number of peer links allowed
+ * on this mesh interface
+ *
+ * @NL80211_MESHCONF_MAX_RETRIES: specifies the maximum number of peer link
+ * open retries that can be sent to establish a new peer link instance in a
+ * mesh
+ *
+ * @NL80211_MESHCONF_TTL: specifies the value of TTL field set at a source mesh
+ * point.
+ *
+ * @NL80211_MESHCONF_AUTO_OPEN_PLINKS: whether we should automatically
+ * open peer links when we detect compatible mesh peers.
+ *
+ * @NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES: the number of action frames
+ * containing a PREQ that an MP can send to a particular destination (path
+ * target)
+ *
+ * @NL80211_MESHCONF_PATH_REFRESH_TIME: how frequently to refresh mesh paths
+ * (in milliseconds)
+ *
+ * @NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT: minimum length of time to wait
+ * until giving up on a path discovery (in milliseconds)
+ *
+ * @NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT: The time (in TUs) for which mesh
+ * points receiving a PREQ shall consider the forwarding information from the
+ * root to be valid. (TU = time unit)
+ *
+ * @NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL: The minimum interval of time (in
+ * TUs) during which an MP can send only one action frame containing a PREQ
+ * reference element
+ *
+ * @NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME: The interval of time (in TUs)
+ * that it takes for an HWMP information element to propagate across the mesh
+ *
+ * @NL80211_MESHCONF_ATTR_MAX: highest possible mesh configuration attribute
+ *
+ * @__NL80211_MESHCONF_ATTR_AFTER_LAST: internal use
+ */
+enum nl80211_meshconf_params {
+        __NL80211_MESHCONF_INVALID,
+        NL80211_MESHCONF_RETRY_TIMEOUT,
+        NL80211_MESHCONF_CONFIRM_TIMEOUT,
+        NL80211_MESHCONF_HOLDING_TIMEOUT,
+        NL80211_MESHCONF_MAX_PEER_LINKS,
+        NL80211_MESHCONF_MAX_RETRIES,
+        NL80211_MESHCONF_TTL,
+        NL80211_MESHCONF_AUTO_OPEN_PLINKS,
+        NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
+        NL80211_MESHCONF_PATH_REFRESH_TIME,
+        NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
+        NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
+        NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
+        NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
+
+        /* keep last */
+        __NL80211_MESHCONF_ATTR_AFTER_LAST,
+        NL80211_MESHCONF_ATTR_MAX = __NL80211_MESHCONF_ATTR_AFTER_LAST - 1
+};
+
+/**
+ * enum nl80211_txq_attr - TX queue parameter attributes
+ * @__NL80211_TXQ_ATTR_INVALID: Attribute number 0 is reserved
+ * @NL80211_TXQ_ATTR_QUEUE: TX queue identifier (NL80211_TXQ_Q_*)
+ * @NL80211_TXQ_ATTR_TXOP: Maximum burst time in units of 32 usecs, 0 meaning
+ *      disabled
+ * @NL80211_TXQ_ATTR_CWMIN: Minimum contention window [a value of the form
+ *      2^n-1 in the range 1..32767]
+ * @NL80211_TXQ_ATTR_CWMAX: Maximum contention window [a value of the form
+ *      2^n-1 in the range 1..32767]
+ * @NL80211_TXQ_ATTR_AIFS: Arbitration interframe space [0..255]
+ * @__NL80211_TXQ_ATTR_AFTER_LAST: Internal
+ * @NL80211_TXQ_ATTR_MAX: Maximum TXQ attribute number
+ */
+enum nl80211_txq_attr {
+        __NL80211_TXQ_ATTR_INVALID,
+        NL80211_TXQ_ATTR_QUEUE,
+        NL80211_TXQ_ATTR_TXOP,
+        NL80211_TXQ_ATTR_CWMIN,
+        NL80211_TXQ_ATTR_CWMAX,
+        NL80211_TXQ_ATTR_AIFS,
+
+        /* keep last */
+        __NL80211_TXQ_ATTR_AFTER_LAST,
+        NL80211_TXQ_ATTR_MAX = __NL80211_TXQ_ATTR_AFTER_LAST - 1
+};
+
+enum nl80211_txq_q {
+        NL80211_TXQ_Q_VO,
+        NL80211_TXQ_Q_VI,
+        NL80211_TXQ_Q_BE,
+        NL80211_TXQ_Q_BK
+};
+
+enum nl80211_channel_type {
+        NL80211_CHAN_NO_HT,
+        NL80211_CHAN_HT20,
+        NL80211_CHAN_HT40MINUS,
+        NL80211_CHAN_HT40PLUS
+};
 #endif /* __LINUX_NL80211_H */
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 77c4ed60b982..d7e54d98869f 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -467,6 +467,8 @@ int genphy_restart_aneg(struct phy_device *phydev);
 int genphy_config_aneg(struct phy_device *phydev);
 int genphy_update_link(struct phy_device *phydev);
 int genphy_read_status(struct phy_device *phydev);
+int genphy_suspend(struct phy_device *phydev);
+int genphy_resume(struct phy_device *phydev);
 void phy_driver_unregister(struct phy_driver *drv);
 int phy_driver_register(struct phy_driver *new_driver);
 void phy_prepare_link(struct phy_device *phydev,
diff --git a/include/linux/pkt_cls.h b/include/linux/pkt_cls.h
index 7cf7824df778..e6aa8482ad7a 100644
--- a/include/linux/pkt_cls.h
+++ b/include/linux/pkt_cls.h
@@ -394,6 +394,20 @@ enum
 
 #define TCA_BASIC_MAX (__TCA_BASIC_MAX - 1)
 
+
+/* Cgroup classifier */
+
+enum
+{
+        TCA_CGROUP_UNSPEC,
+        TCA_CGROUP_ACT,
+        TCA_CGROUP_POLICE,
+        TCA_CGROUP_EMATCHES,
+        __TCA_CGROUP_MAX,
+};
+
+#define TCA_CGROUP_MAX (__TCA_CGROUP_MAX - 1)
+
 /* Extended Matches */
 
 struct tcf_ematch_tree_hdr
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index 5d921fa91a5b..e3f133adba78 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -500,4 +500,20 @@ struct tc_netem_corrupt
 
 #define NETEM_DIST_SCALE        8192
 
+/* DRR */
+
+enum
+{
+        TCA_DRR_UNSPEC,
+        TCA_DRR_QUANTUM,
+        __TCA_DRR_MAX
+};
+
+#define TCA_DRR_MAX     (__TCA_DRR_MAX - 1)
+
+struct tc_drr_stats
+{
+        u32     deficit;
+};
+
 #endif
diff --git a/include/linux/rculist_nulls.h b/include/linux/rculist_nulls.h
new file mode 100644
index 000000000000..f9ddd03961a8
--- /dev/null
+++ b/include/linux/rculist_nulls.h
@@ -0,0 +1,110 @@
+#ifndef _LINUX_RCULIST_NULLS_H
+#define _LINUX_RCULIST_NULLS_H
+
+#ifdef __KERNEL__
+
+/*
+ * RCU-protected list version
+ */
+#include <linux/list_nulls.h>
+#include <linux/rcupdate.h>
+
+/**
+ * hlist_nulls_del_init_rcu - deletes entry from hash list with re-initialization
+ * @n: the element to delete from the hash list.
+ *
+ * Note: hlist_nulls_unhashed() on the node return true after this. It is
+ * useful for RCU based read lockfree traversal if the writer side
+ * must know if the list entry is still hashed or already unhashed.
+ *
+ * In particular, it means that we can not poison the forward pointers
+ * that may still be used for walking the hash list and we can only
+ * zero the pprev pointer so list_unhashed() will return true after
+ * this.
+ *
+ * The caller must take whatever precautions are necessary (such as
+ * holding appropriate locks) to avoid racing with another
+ * list-mutation primitive, such as hlist_nulls_add_head_rcu() or
+ * hlist_nulls_del_rcu(), running on this same list.  However, it is
+ * perfectly legal to run concurrently with the _rcu list-traversal
+ * primitives, such as hlist_nulls_for_each_entry_rcu().
+ */
+static inline void hlist_nulls_del_init_rcu(struct hlist_nulls_node *n)
+{
+        if (!hlist_nulls_unhashed(n)) {
+                __hlist_nulls_del(n);
+                n->pprev = NULL;
+        }
+}
+
+/**
+ * hlist_nulls_del_rcu - deletes entry from hash list without re-initialization
+ * @n: the element to delete from the hash list.
+ *
+ * Note: hlist_nulls_unhashed() on entry does not return true after this,
+ * the entry is in an undefined state. It is useful for RCU based
+ * lockfree traversal.
+ *
+ * In particular, it means that we can not poison the forward
+ * pointers that may still be used for walking the hash list.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as hlist_nulls_add_head_rcu()
+ * or hlist_nulls_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * hlist_nulls_for_each_entry().
+ */
+static inline void hlist_nulls_del_rcu(struct hlist_nulls_node *n)
+{
+        __hlist_nulls_del(n);
+        n->pprev = LIST_POISON2;
+}
+
+/**
+ * hlist_nulls_add_head_rcu
+ * @n: the element to add to the hash list.
+ * @h: the list to add to.
+ *
+ * Description:
+ * Adds the specified element to the specified hlist_nulls,
+ * while permitting racing traversals.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as hlist_nulls_add_head_rcu()
+ * or hlist_nulls_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * hlist_nulls_for_each_entry_rcu(), used to prevent memory-consistency
+ * problems on Alpha CPUs.  Regardless of the type of CPU, the
+ * list-traversal primitive must be guarded by rcu_read_lock().
+ */
+static inline void hlist_nulls_add_head_rcu(struct hlist_nulls_node *n,
+                                        struct hlist_nulls_head *h)
+{
+        struct hlist_nulls_node *first = h->first;
+
+        n->next = first;
+        n->pprev = &h->first;
+        rcu_assign_pointer(h->first, n);
+        if (!is_a_nulls(first))
+                first->pprev = &n->next;
+}
+/**
+ * hlist_nulls_for_each_entry_rcu - iterate over rcu list of given type
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_nulls_node to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_nulls_node within the struct.
+ *
+ */
+#define hlist_nulls_for_each_entry_rcu(tpos, pos, head, member) \
+        for (pos = rcu_dereference((head)->first);                       \
+                (!is_a_nulls(pos)) &&                   \
+                ({ tpos = hlist_nulls_entry(pos, typeof(*tpos), member); 1; }); \
+                pos = rcu_dereference(pos->next))
+
+#endif
+#endif
diff --git a/include/linux/rfkill.h b/include/linux/rfkill.h
index 4cd64b0d9825..164332cbb77c 100644
--- a/include/linux/rfkill.h
+++ b/include/linux/rfkill.h
@@ -108,6 +108,7 @@ struct rfkill {
 
         struct device dev;
         struct list_head node;
+        enum rfkill_state state_for_resume;
 };
 #define to_rfkill(d)    container_of(d, struct rfkill, dev)
 
@@ -148,11 +149,4 @@ static inline char *rfkill_get_led_name(struct rfkill *rfkill)
 #endif
 }
 
-/* rfkill notification chain */
-#define RFKILL_STATE_CHANGED            0x0001  /* state of a normal rfkill
-                                                   switch has changed */
-
-int register_rfkill_notifier(struct notifier_block *nb);
-int unregister_rfkill_notifier(struct notifier_block *nb);
-
 #endif /* RFKILL_H */
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 2b3d51c6ec9c..e88f7058b3a1 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -107,6 +107,11 @@ enum {
         RTM_GETADDRLABEL,
 #define RTM_GETADDRLABEL RTM_GETADDRLABEL
 
+        RTM_GETDCB = 78,
+#define RTM_GETDCB RTM_GETDCB
+        RTM_SETDCB,
+#define RTM_SETDCB RTM_SETDCB
+
         __RTM_MAX,
 #define RTM_MAX         (((__RTM_MAX + 3) & ~3) - 1)
 };
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 2725f4e5a9bf..cf2cb50f77d1 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -250,6 +250,9 @@ typedef unsigned char *sk_buff_data_t;
  *      @tc_verd: traffic control verdict
  *      @ndisc_nodetype: router type (from link layer)
  *      @do_not_encrypt: set to prevent encryption of this frame
+ *      @requeue: set to indicate that the wireless core should attempt
+ *              a software retry on this frame if we failed to
+ *              receive an ACK for it
  *      @dma_cookie: a cookie to one of several possible DMA operations
  *              done by skb DMA functions
  *      @secmark: security marking
@@ -269,8 +272,9 @@ struct sk_buff {
                 struct  dst_entry       *dst;
                 struct  rtable          *rtable;
         };
+#ifdef CONFIG_XFRM
         struct  sec_path        *sp;
-
+#endif
         /*
          * This is the control buffer. It is free to use for every
          * layer. Please put your private variables there. If you
@@ -325,6 +329,7 @@ struct sk_buff {
 #endif
 #if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
         __u8                    do_not_encrypt:1;
+        __u8                    requeue:1;
 #endif
         /* 0/13/14 bit hole */
 
@@ -488,6 +493,19 @@ static inline bool skb_queue_is_last(const struct sk_buff_head *list,
 }
 
 /**
+ *      skb_queue_is_first - check if skb is the first entry in the queue
+ *      @list: queue head
+ *      @skb: buffer
+ *
+ *      Returns true if @skb is the first buffer on the list.
+ */
+static inline bool skb_queue_is_first(const struct sk_buff_head *list,
+                                      const struct sk_buff *skb)
+{
+        return (skb->prev == (struct sk_buff *) list);
+}
+
+/**
  *      skb_queue_next - return the next packet in the queue
  *      @list: queue head
  *      @skb: current buffer
@@ -506,6 +524,24 @@ static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
 }
 
 /**
+ *      skb_queue_prev - return the prev packet in the queue
+ *      @list: queue head
+ *      @skb: current buffer
+ *
+ *      Return the prev packet in @list before @skb.  It is only valid to
+ *      call this if skb_queue_is_first() evaluates to false.
+ */
+static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list,
+                                             const struct sk_buff *skb)
+{
+        /* This BUG_ON may seem severe, but if we just return then we
+         * are going to dereference garbage.
+         */
+        BUG_ON(skb_queue_is_first(list, skb));
+        return skb->prev;
+}
+
+/**
  *      skb_get - reference buffer
  *      @skb: buffer to reference
  *
@@ -1647,8 +1683,12 @@ extern int             skb_splice_bits(struct sk_buff *skb,
 extern void            skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
 extern void            skb_split(struct sk_buff *skb,
                                  struct sk_buff *skb1, const u32 len);
+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 int             skb_gro_receive(struct sk_buff **head,
+                                       struct sk_buff *skb);
 
 static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
                                        int len, void *buffer)
@@ -1864,6 +1904,18 @@ static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_bu
         to->queue_mapping = from->queue_mapping;
 }
 
+#ifdef CONFIG_XFRM
+static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
+{
+        return skb->sp;
+}
+#else
+static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
+{
+        return NULL;
+}
+#endif
+
 static inline int skb_is_gso(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_size;
diff --git a/include/linux/smsc911x.h b/include/linux/smsc911x.h
new file mode 100644
index 000000000000..1cbf0313adde
--- /dev/null
+++ b/include/linux/smsc911x.h
@@ -0,0 +1,47 @@
+/***************************************************************************
+ *
+ * Copyright (C) 2004-2008 SMSC
+ * Copyright (C) 2005-2008 ARM
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ ***************************************************************************/
+#ifndef __LINUX_SMSC911X_H__
+#define __LINUX_SMSC911X_H__
+
+#include <linux/phy.h>
+
+/* platform_device configuration data, should be assigned to
+ * the platform_device's dev.platform_data */
+struct smsc911x_platform_config {
+        unsigned int irq_polarity;
+        unsigned int irq_type;
+        unsigned int flags;
+        phy_interface_t phy_interface;
+};
+
+/* Constants for platform_device irq polarity configuration */
+#define SMSC911X_IRQ_POLARITY_ACTIVE_LOW        0
+#define SMSC911X_IRQ_POLARITY_ACTIVE_HIGH       1
+
+/* Constants for platform_device irq type configuration */
+#define SMSC911X_IRQ_TYPE_OPEN_DRAIN            0
+#define SMSC911X_IRQ_TYPE_PUSH_PULL             1
+
+/* Constants for flags */
+#define SMSC911X_USE_16BIT                      (BIT(0))
+#define SMSC911X_USE_32BIT                      (BIT(1))
+
+#endif /* __LINUX_SMSC911X_H__ */
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
index 7a6e6bba4a71..aee3f1e1d1ce 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -216,6 +216,9 @@ enum
         LINUX_MIB_TCPSPURIOUSRTOS,              /* TCPSpuriousRTOs */
         LINUX_MIB_TCPMD5NOTFOUND,               /* TCPMD5NotFound */
         LINUX_MIB_TCPMD5UNEXPECTED,             /* TCPMD5Unexpected */
+        LINUX_MIB_SACKSHIFTED,
+        LINUX_MIB_SACKMERGED,
+        LINUX_MIB_SACKSHIFTFALLBACK,
         __LINUX_MIB_MAX
 };
 
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index 6fd7b016517f..0127daca4354 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -139,14 +139,14 @@ static inline char *__svc_print_addr(struct sockaddr *addr,
 {
         switch (addr->sa_family) {
         case AF_INET:
-                snprintf(buf, len, "%u.%u.%u.%u, port=%u",
-                        NIPQUAD(((struct sockaddr_in *) addr)->sin_addr),
+                snprintf(buf, len, "%pI4, port=%u",
+                        &((struct sockaddr_in *)addr)->sin_addr,
                         ntohs(((struct sockaddr_in *) addr)->sin_port));
                 break;
 
         case AF_INET6:
-                snprintf(buf, len, "%x:%x:%x:%x:%x:%x:%x:%x, port=%u",
-                        NIP6(((struct sockaddr_in6 *) addr)->sin6_addr),
+                snprintf(buf, len, "%pI6, port=%u",
+                         &((struct sockaddr_in6 *)addr)->sin6_addr,
                         ntohs(((struct sockaddr_in6 *) addr)->sin6_port));
                 break;
 
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index 5e33761b9b8a..5cdd0aa8bde9 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -20,6 +20,7 @@
 #define VIRTIO_NET_F_HOST_TSO6  12      /* Host can handle TSOv6 in. */
 #define VIRTIO_NET_F_HOST_ECN   13      /* Host can handle TSO[6] w/ ECN in. */
 #define VIRTIO_NET_F_HOST_UFO   14      /* Host can handle UFO in. */
+#define VIRTIO_NET_F_MRG_RXBUF  15      /* Host can merge receive buffers. */
 
 struct virtio_net_config
 {
@@ -44,4 +45,12 @@ struct virtio_net_hdr
         __u16 csum_start;       /* Position to start checksumming from */
         __u16 csum_offset;      /* Offset after that to place checksum */
 };
+
+/* This is the version of the header to use when the MRG_RXBUF
+ * feature has been negotiated. */
+struct virtio_net_hdr_mrg_rxbuf {
+        struct virtio_net_hdr hdr;
+        __u16 num_buffers;      /* Number of merged rx buffers */
+};
+
 #endif /* _LINUX_VIRTIO_NET_H */
diff --git a/include/linux/xfrm.h b/include/linux/xfrm.h
index 4bc1e6b86cb2..52f3abd453a1 100644
--- a/include/linux/xfrm.h
+++ b/include/linux/xfrm.h
@@ -199,6 +199,9 @@ enum {
 #define XFRM_MSG_NEWSPDINFO XFRM_MSG_NEWSPDINFO
         XFRM_MSG_GETSPDINFO,
 #define XFRM_MSG_GETSPDINFO XFRM_MSG_GETSPDINFO
+
+        XFRM_MSG_MAPPING,
+#define XFRM_MSG_MAPPING XFRM_MSG_MAPPING
         __XFRM_MSG_MAX
 };
 #define XFRM_MSG_MAX (__XFRM_MSG_MAX - 1)
@@ -438,6 +441,15 @@ struct xfrm_user_migrate {
         __u16                           new_family;
 };
 
+struct xfrm_user_mapping {
+        struct xfrm_usersa_id           id;
+        __u32                           reqid;
+        xfrm_address_t                  old_saddr;
+        xfrm_address_t                  new_saddr;
+        __be16                          old_sport;
+        __be16                          new_sport;
+};
+
 #ifndef __KERNEL__
 /* backwards compatibility for userspace */
 #define XFRMGRP_ACQUIRE         1
@@ -464,6 +476,8 @@ enum xfrm_nlgroups {
 #define XFRMNLGRP_REPORT        XFRMNLGRP_REPORT
         XFRMNLGRP_MIGRATE,
 #define XFRMNLGRP_MIGRATE       XFRMNLGRP_MIGRATE
+        XFRMNLGRP_MAPPING,
+#define XFRMNLGRP_MAPPING       XFRMNLGRP_MAPPING
         __XFRMNLGRP_MAX
 };
 #define XFRMNLGRP_MAX   (__XFRMNLGRP_MAX - 1)
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 996d12df7594..a04f8463ac7e 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -54,8 +54,8 @@
 #define SOL_RFCOMM      18
 
 #define BT_INFO(fmt, arg...) printk(KERN_INFO "Bluetooth: " fmt "\n" , ## arg)
-#define BT_DBG(fmt, arg...)  printk(KERN_INFO "%s: " fmt "\n" , __func__ , ## arg)
-#define BT_ERR(fmt, arg...)  printk(KERN_ERR  "%s: " fmt "\n" , __func__ , ## 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)
 
 /* Connection and socket states */
 enum {
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index 3cc294919312..3645139e68c7 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -54,7 +54,7 @@
 
 /* HCI device quirks */
 enum {
-        HCI_QUIRK_RESET_ON_INIT,
+        HCI_QUIRK_NO_RESET,
         HCI_QUIRK_RAW_DEVICE,
         HCI_QUIRK_FIXUP_BUFFER_SIZE
 };
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 0e85ec39b638..23c0ab74ded6 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -5,6 +5,8 @@
 #include <linux/skbuff.h>
 #include <linux/nl80211.h>
 #include <net/genetlink.h>
+/* remove once we remove the wext stuff */
+#include <net/iw_handler.h>
 
 /*
  * 802.11 configuration in-kernel interface
@@ -167,6 +169,9 @@ struct station_parameters {
  * @STATION_INFO_LLID: @llid filled
  * @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
+ *  (tx_bitrate, tx_bitrate_flags and tx_bitrate_mcs)
  */
 enum station_info_flags {
         STATION_INFO_INACTIVE_TIME      = 1<<0,
@@ -175,6 +180,39 @@ enum station_info_flags {
         STATION_INFO_LLID               = 1<<3,
         STATION_INFO_PLID               = 1<<4,
         STATION_INFO_PLINK_STATE        = 1<<5,
+        STATION_INFO_SIGNAL             = 1<<6,
+        STATION_INFO_TX_BITRATE         = 1<<7,
+};
+
+/**
+ * enum station_info_rate_flags - bitrate info flags
+ *
+ * Used by the driver to indicate the specific rate transmission
+ * type for 802.11n transmissions.
+ *
+ * @RATE_INFO_FLAGS_MCS: @tx_bitrate_mcs filled
+ * @RATE_INFO_FLAGS_40_MHZ_WIDTH: 40 Mhz width transmission
+ * @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval
+ */
+enum rate_info_flags {
+        RATE_INFO_FLAGS_MCS             = 1<<0,
+        RATE_INFO_FLAGS_40_MHZ_WIDTH    = 1<<1,
+        RATE_INFO_FLAGS_SHORT_GI        = 1<<2,
+};
+
+/**
+ * struct rate_info - bitrate information
+ *
+ * Information about a receiving or transmitting bitrate
+ *
+ * @flags: bitflag of flags from &enum rate_info_flags
+ * @mcs: mcs index if struct describes a 802.11n bitrate
+ * @legacy: bitrate in 100kbit/s for 802.11abg
+ */
+struct rate_info {
+        u8 flags;
+        u8 mcs;
+        u16 legacy;
 };
 
 /**
@@ -189,6 +227,8 @@ enum station_info_flags {
  * @llid: mesh local link id
  * @plid: mesh peer link id
  * @plink_state: mesh peer link state
+ * @signal: signal strength of last received packet in dBm
+ * @txrate: current unicast bitrate to this station
  */
 struct station_info {
         u32 filled;
@@ -198,6 +238,8 @@ struct station_info {
         u16 llid;
         u16 plid;
         u8 plink_state;
+        s8 signal;
+        struct rate_info txrate;
 };
 
 /**
@@ -280,11 +322,16 @@ struct mpath_info {
  *      (0 = no, 1 = yes, -1 = do not change)
  * @use_short_slot_time: Whether the use of short slot time is allowed
  *      (0 = no, 1 = yes, -1 = do not change)
+ * @basic_rates: basic rates in IEEE 802.11 format
+ *      (or NULL for no change)
+ * @basic_rates_len: number of basic rates
  */
 struct bss_parameters {
         int use_cts_prot;
         int use_short_preamble;
         int use_short_slot_time;
+        u8 *basic_rates;
+        u8 basic_rates_len;
 };
 
 /**
@@ -331,25 +378,65 @@ struct ieee80211_regdomain {
         struct ieee80211_reg_rule reg_rules[];
 };
 
-#define MHZ_TO_KHZ(freq) (freq * 1000)
-#define KHZ_TO_MHZ(freq) (freq / 1000)
-#define DBI_TO_MBI(gain) (gain * 100)
-#define MBI_TO_DBI(gain) (gain / 100)
-#define DBM_TO_MBM(gain) (gain * 100)
-#define MBM_TO_DBM(gain) (gain / 100)
+#define MHZ_TO_KHZ(freq) ((freq) * 1000)
+#define KHZ_TO_MHZ(freq) ((freq) / 1000)
+#define DBI_TO_MBI(gain) ((gain) * 100)
+#define MBI_TO_DBI(gain) ((gain) / 100)
+#define DBM_TO_MBM(gain) ((gain) * 100)
+#define MBM_TO_DBM(gain) ((gain) / 100)
 
 #define REG_RULE(start, end, bw, gain, eirp, reg_flags) { \
-        .freq_range.start_freq_khz = (start) * 1000, \
-        .freq_range.end_freq_khz = (end) * 1000, \
-        .freq_range.max_bandwidth_khz = (bw) * 1000, \
-        .power_rule.max_antenna_gain = (gain) * 100, \
-        .power_rule.max_eirp = (eirp) * 100, \
+        .freq_range.start_freq_khz = MHZ_TO_KHZ(start), \
+        .freq_range.end_freq_khz = MHZ_TO_KHZ(end), \
+        .freq_range.max_bandwidth_khz = MHZ_TO_KHZ(bw), \
+        .power_rule.max_antenna_gain = DBI_TO_MBI(gain), \
+        .power_rule.max_eirp = DBM_TO_MBM(eirp), \
         .flags = reg_flags, \
         }
 
+struct mesh_config {
+        /* Timeouts in ms */
+        /* Mesh plink management parameters */
+        u16 dot11MeshRetryTimeout;
+        u16 dot11MeshConfirmTimeout;
+        u16 dot11MeshHoldingTimeout;
+        u16 dot11MeshMaxPeerLinks;
+        u8  dot11MeshMaxRetries;
+        u8  dot11MeshTTL;
+        bool auto_open_plinks;
+        /* HWMP parameters */
+        u8  dot11MeshHWMPmaxPREQretries;
+        u32 path_refresh_time;
+        u16 min_discovery_timeout;
+        u32 dot11MeshHWMPactivePathTimeout;
+        u16 dot11MeshHWMPpreqMinInterval;
+        u16 dot11MeshHWMPnetDiameterTraversalTime;
+};
+
+/**
+ * struct ieee80211_txq_params - TX queue parameters
+ * @queue: TX queue identifier (NL80211_TXQ_Q_*)
+ * @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled
+ * @cwmin: Minimum contention window [a value of the form 2^n-1 in the range
+ *      1..32767]
+ * @cwmax: Maximum contention window [a value of the form 2^n-1 in the range
+ *      1..32767]
+ * @aifs: Arbitration interframe space [0..255]
+ */
+struct ieee80211_txq_params {
+        enum nl80211_txq_q queue;
+        u16 txop;
+        u16 cwmin;
+        u16 cwmax;
+        u8 aifs;
+};
+
 /* from net/wireless.h */
 struct wiphy;
 
+/* from net/ieee80211.h */
+struct ieee80211_channel;
+
 /**
  * struct cfg80211_ops - backend description for wireless configuration
  *
@@ -397,9 +484,19 @@ struct wiphy;
  *
  * @change_station: Modify a given station.
  *
+ * @get_mesh_params: Put the current mesh parameters into *params
+ *
+ * @set_mesh_params: Set mesh parameters.
+ *      The mask is a bitfield which tells us which parameters to
+ *      set, and which to leave alone.
+ *
  * @set_mesh_cfg: set mesh parameters (by now, just mesh id)
  *
  * @change_bss: Modify parameters for a given BSS.
+ *
+ * @set_txq_params: Set TX queue parameters
+ *
+ * @set_channel: Set channel
  */
 struct cfg80211_ops {
         int     (*add_virtual_intf)(struct wiphy *wiphy, char *name,
@@ -452,9 +549,30 @@ struct cfg80211_ops {
         int     (*dump_mpath)(struct wiphy *wiphy, struct net_device *dev,
                                int idx, u8 *dst, u8 *next_hop,
                                struct mpath_info *pinfo);
-
+        int     (*get_mesh_params)(struct wiphy *wiphy,
+                                struct net_device *dev,
+                                struct mesh_config *conf);
+        int     (*set_mesh_params)(struct wiphy *wiphy,
+                                struct net_device *dev,
+                                const struct mesh_config *nconf, u32 mask);
         int     (*change_bss)(struct wiphy *wiphy, struct net_device *dev,
                               struct bss_parameters *params);
+
+        int     (*set_txq_params)(struct wiphy *wiphy,
+                                  struct ieee80211_txq_params *params);
+
+        int     (*set_channel)(struct wiphy *wiphy,
+                               struct ieee80211_channel *chan,
+                               enum nl80211_channel_type channel_type);
 };
 
+/* temporary wext handlers */
+int cfg80211_wext_giwname(struct net_device *dev,
+                          struct iw_request_info *info,
+                          char *name, char *extra);
+int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info,
+                          u32 *mode, char *extra);
+int cfg80211_wext_giwmode(struct net_device *dev, struct iw_request_info *info,
+                          u32 *mode, char *extra);
+
 #endif /* __NET_CFG80211_H */
diff --git a/include/net/checksum.h b/include/net/checksum.h
index 07602b7fa218..ba55d8b8c87c 100644
--- a/include/net/checksum.h
+++ b/include/net/checksum.h
@@ -98,7 +98,7 @@ static inline void csum_replace4(__sum16 *sum, __be32 from, __be32 to)
 {
         __be32 diff[] = { ~from, to };
 
-        *sum = csum_fold(csum_partial((char *)diff, sizeof(diff), ~csum_unfold(*sum)));
+        *sum = csum_fold(csum_partial(diff, sizeof(diff), ~csum_unfold(*sum)));
 }
 
 static inline void csum_replace2(__sum16 *sum, __be16 from, __be16 to)
diff --git a/include/net/dcbnl.h b/include/net/dcbnl.h
new file mode 100644
index 000000000000..775cfc8055be
--- /dev/null
+++ b/include/net/dcbnl.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2008, 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,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Author: Lucy Liu <lucy.liu@intel.com>
+ */
+
+#ifndef __NET_DCBNL_H__
+#define __NET_DCBNL_H__
+
+/*
+ * Ops struct for the netlink callbacks.  Used by DCB-enabled drivers through
+ * the netdevice struct.
+ */
+struct dcbnl_rtnl_ops {
+        u8   (*getstate)(struct net_device *);
+        u8   (*setstate)(struct net_device *, u8);
+        void (*getpermhwaddr)(struct net_device *, u8 *);
+        void (*setpgtccfgtx)(struct net_device *, int, u8, u8, u8, u8);
+        void (*setpgbwgcfgtx)(struct net_device *, int, u8);
+        void (*setpgtccfgrx)(struct net_device *, int, u8, u8, u8, u8);
+        void (*setpgbwgcfgrx)(struct net_device *, int, u8);
+        void (*getpgtccfgtx)(struct net_device *, int, u8 *, u8 *, u8 *, u8 *);
+        void (*getpgbwgcfgtx)(struct net_device *, int, u8 *);
+        void (*getpgtccfgrx)(struct net_device *, int, u8 *, u8 *, u8 *, u8 *);
+        void (*getpgbwgcfgrx)(struct net_device *, int, u8 *);
+        void (*setpfccfg)(struct net_device *, int, u8);
+        void (*getpfccfg)(struct net_device *, int, u8 *);
+        u8   (*setall)(struct net_device *);
+        u8   (*getcap)(struct net_device *, int, u8 *);
+        u8   (*getnumtcs)(struct net_device *, int, u8 *);
+        u8   (*setnumtcs)(struct net_device *, int, u8);
+        u8   (*getpfcstate)(struct net_device *);
+        void (*setpfcstate)(struct net_device *, u8);
+        void (*getbcncfg)(struct net_device *, int, u32 *);
+        void (*setbcncfg)(struct net_device *, int, u32);
+        void (*getbcnrp)(struct net_device *, int, u8 *);
+        void (*setbcnrp)(struct net_device *, int, u8);
+};
+
+#endif /* __NET_DCBNL_H__ */
diff --git a/include/net/dn.h b/include/net/dn.h
index 627778384c84..e5469f7b67a3 100644
--- a/include/net/dn.h
+++ b/include/net/dn.h
@@ -4,9 +4,7 @@
 #include <linux/dn.h>
 #include <net/sock.h>
 #include <asm/byteorder.h>
-
-#define dn_ntohs(x) le16_to_cpu(x)
-#define dn_htons(x) cpu_to_le16(x)
+#include <asm/unaligned.h>
 
 struct dn_scp                                   /* Session Control Port */
 {
@@ -175,7 +173,7 @@ struct dn_skb_cb {
 
 static inline __le16 dn_eth2dn(unsigned char *ethaddr)
 {
-        return dn_htons(ethaddr[4] | (ethaddr[5] << 8));
+        return get_unaligned((__le16 *)(ethaddr + 4));
 }
 
 static inline __le16 dn_saddr2dn(struct sockaddr_dn *saddr)
@@ -185,7 +183,7 @@ static inline __le16 dn_saddr2dn(struct sockaddr_dn *saddr)
 
 static inline void dn_dn2eth(unsigned char *ethaddr, __le16 addr)
 {
-        __u16 a = dn_ntohs(addr);
+        __u16 a = le16_to_cpu(addr);
         ethaddr[0] = 0xAA;
         ethaddr[1] = 0x00;
         ethaddr[2] = 0x04;
diff --git a/include/net/dn_fib.h b/include/net/dn_fib.h
index 30125119c950..c378be7bf960 100644
--- a/include/net/dn_fib.h
+++ b/include/net/dn_fib.h
@@ -181,9 +181,9 @@ static inline void dn_fib_res_put(struct dn_fib_res *res)
 
 static inline __le16 dnet_make_mask(int n)
 {
-        if (n)
-                return dn_htons(~((1<<(16-n))-1));
-        return 0;
+        if (n)
+                return cpu_to_le16(~((1 << (16 - n)) - 1));
+        return cpu_to_le16(0);
 }
 
 #endif /* _NET_DN_FIB_H */
diff --git a/include/net/dst.h b/include/net/dst.h
index 8a8b71e5f3f1..6be3b082a070 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -59,8 +59,11 @@ struct dst_entry
 
         struct neighbour        *neighbour;
         struct hh_cache         *hh;
+#ifdef CONFIG_XFRM
         struct xfrm_state       *xfrm;
-
+#else
+        void                    *__pad1;
+#endif
         int                     (*input)(struct sk_buff*);
         int                     (*output)(struct sk_buff*);
 
@@ -70,8 +73,20 @@ struct dst_entry
 
 #ifdef CONFIG_NET_CLS_ROUTE
         __u32                   tclassid;
+#else
+        __u32                   __pad2;
 #endif
 
+
+        /*
+         * Align __refcnt to a 64 bytes alignment
+         * (L1_CACHE_SIZE would be too much)
+         */
+#ifdef CONFIG_64BIT
+        long                    __pad_to_align_refcnt[2];
+#else
+        long                    __pad_to_align_refcnt[1];
+#endif
         /*
          * __refcnt wants to be on a different cache line from
          * input/output/ops or performance tanks badly
@@ -103,7 +118,6 @@ struct dst_ops
         void                    (*link_failure)(struct sk_buff *);
         void                    (*update_pmtu)(struct dst_entry *dst, u32 mtu);
         int                     (*local_out)(struct sk_buff *skb);
-        int                     entry_size;
 
         atomic_t                entries;
         struct kmem_cache               *kmem_cachep;
@@ -157,6 +171,11 @@ dst_metric_locked(struct dst_entry *dst, int metric)
 
 static inline void dst_hold(struct dst_entry * dst)
 {
+        /*
+         * If your kernel compilation stops here, please check
+         * __pad_to_align_refcnt declaration in struct dst_entry
+         */
+        BUILD_BUG_ON(offsetof(struct dst_entry, __refcnt) & 63);
         atomic_inc(&dst->__refcnt);
 }
 
@@ -272,21 +291,21 @@ enum {
 
 struct flowi;
 #ifndef CONFIG_XFRM
-static inline int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
-                       struct sock *sk, int flags)
+static inline int xfrm_lookup(struct net *net, struct dst_entry **dst_p,
+                              struct flowi *fl, struct sock *sk, int flags)
 {
         return 0;
 } 
-static inline int __xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
-                                struct sock *sk, int flags)
+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 dst_entry **dst_p, struct flowi *fl,
-                       struct sock *sk, int flags);
-extern int __xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
-                         struct sock *sk, int flags);
+extern int xfrm_lookup(struct net *net, struct dst_entry **dst_p,
+                       struct flowi *fl, struct sock *sk, int flags);
+extern int __xfrm_lookup(struct net *net, struct dst_entry **dst_p,
+                         struct flowi *fl, struct sock *sk, int flags);
 #endif
 #endif
 
diff --git a/include/net/flow.h b/include/net/flow.h
index b45a5e4fcadd..809970b7dfee 100644
--- a/include/net/flow.h
+++ b/include/net/flow.h
@@ -84,12 +84,13 @@ struct flowi {
 #define FLOW_DIR_OUT    1
 #define FLOW_DIR_FWD    2
 
+struct net;
 struct sock;
-typedef int (*flow_resolve_t)(struct flowi *key, u16 family, u8 dir,
-                               void **objp, atomic_t **obj_refp);
+typedef int (*flow_resolve_t)(struct net *net, struct flowi *key, u16 family,
+                              u8 dir, void **objp, atomic_t **obj_refp);
 
-extern void *flow_cache_lookup(struct flowi *key, u16 family, u8 dir,
-                               flow_resolve_t resolver);
+extern void *flow_cache_lookup(struct net *net, struct flowi *key, u16 family,
+                               u8 dir, flow_resolve_t resolver);
 extern void flow_cache_flush(void);
 extern atomic_t flow_cache_genid;
 
diff --git a/include/net/gen_stats.h b/include/net/gen_stats.h
index 8cd8185fa2ed..d136b5240ef2 100644
--- a/include/net/gen_stats.h
+++ b/include/net/gen_stats.h
@@ -45,5 +45,6 @@ extern void gen_kill_estimator(struct gnet_stats_basic *bstats,
 extern int gen_replace_estimator(struct gnet_stats_basic *bstats,
                                  struct gnet_stats_rate_est *rate_est,
                                  spinlock_t *stats_lock, struct nlattr *opt);
-
+extern bool gen_estimator_active(const struct gnet_stats_basic *bstats,
+                                 const struct gnet_stats_rate_est *rate_est);
 #endif
diff --git a/include/net/ieee80211.h b/include/net/ieee80211.h
index 93a56de3594b..adb7cf31f781 100644
--- a/include/net/ieee80211.h
+++ b/include/net/ieee80211.h
@@ -28,6 +28,9 @@
 #include <linux/if_ether.h>     /* ETH_ALEN */
 #include <linux/kernel.h>       /* ARRAY_SIZE */
 #include <linux/wireless.h>
+#include <linux/ieee80211.h>
+
+#include <net/lib80211.h>
 
 #define IEEE80211_VERSION "git-1.1.13"
 
@@ -127,10 +130,6 @@ static inline bool ieee80211_ratelimit_debug(u32 level)
 }
 #endif                          /* CONFIG_IEEE80211_DEBUG */
 
-/* escape_essid() is intended to be used in debug (and possibly error)
- * messages. It should never be used for passing essid to user space. */
-const char *escape_essid(const char *essid, u8 essid_len);
-
 /*
  * To use the debug system:
  *
@@ -218,94 +217,6 @@ struct ieee80211_snap_hdr {
 #define WLAN_GET_SEQ_FRAG(seq) ((seq) & IEEE80211_SCTL_FRAG)
 #define WLAN_GET_SEQ_SEQ(seq)  (((seq) & IEEE80211_SCTL_SEQ) >> 4)
 
-/* Authentication algorithms */
-#define WLAN_AUTH_OPEN 0
-#define WLAN_AUTH_SHARED_KEY 1
-#define WLAN_AUTH_LEAP 2
-
-#define WLAN_AUTH_CHALLENGE_LEN 128
-
-#define WLAN_CAPABILITY_ESS (1<<0)
-#define WLAN_CAPABILITY_IBSS (1<<1)
-#define WLAN_CAPABILITY_CF_POLLABLE (1<<2)
-#define WLAN_CAPABILITY_CF_POLL_REQUEST (1<<3)
-#define WLAN_CAPABILITY_PRIVACY (1<<4)
-#define WLAN_CAPABILITY_SHORT_PREAMBLE (1<<5)
-#define WLAN_CAPABILITY_PBCC (1<<6)
-#define WLAN_CAPABILITY_CHANNEL_AGILITY (1<<7)
-#define WLAN_CAPABILITY_SPECTRUM_MGMT (1<<8)
-#define WLAN_CAPABILITY_QOS (1<<9)
-#define WLAN_CAPABILITY_SHORT_SLOT_TIME (1<<10)
-#define WLAN_CAPABILITY_DSSS_OFDM (1<<13)
-
-/* 802.11g ERP information element */
-#define WLAN_ERP_NON_ERP_PRESENT (1<<0)
-#define WLAN_ERP_USE_PROTECTION (1<<1)
-#define WLAN_ERP_BARKER_PREAMBLE (1<<2)
-
-/* Status codes */
-enum ieee80211_statuscode {
-        WLAN_STATUS_SUCCESS = 0,
-        WLAN_STATUS_UNSPECIFIED_FAILURE = 1,
-        WLAN_STATUS_CAPS_UNSUPPORTED = 10,
-        WLAN_STATUS_REASSOC_NO_ASSOC = 11,
-        WLAN_STATUS_ASSOC_DENIED_UNSPEC = 12,
-        WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG = 13,
-        WLAN_STATUS_UNKNOWN_AUTH_TRANSACTION = 14,
-        WLAN_STATUS_CHALLENGE_FAIL = 15,
-        WLAN_STATUS_AUTH_TIMEOUT = 16,
-        WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA = 17,
-        WLAN_STATUS_ASSOC_DENIED_RATES = 18,
-        /* 802.11b */
-        WLAN_STATUS_ASSOC_DENIED_NOSHORTPREAMBLE = 19,
-        WLAN_STATUS_ASSOC_DENIED_NOPBCC = 20,
-        WLAN_STATUS_ASSOC_DENIED_NOAGILITY = 21,
-        /* 802.11h */
-        WLAN_STATUS_ASSOC_DENIED_NOSPECTRUM = 22,
-        WLAN_STATUS_ASSOC_REJECTED_BAD_POWER = 23,
-        WLAN_STATUS_ASSOC_REJECTED_BAD_SUPP_CHAN = 24,
-        /* 802.11g */
-        WLAN_STATUS_ASSOC_DENIED_NOSHORTTIME = 25,
-        WLAN_STATUS_ASSOC_DENIED_NODSSSOFDM = 26,
-        /* 802.11i */
-        WLAN_STATUS_INVALID_IE = 40,
-        WLAN_STATUS_INVALID_GROUP_CIPHER = 41,
-        WLAN_STATUS_INVALID_PAIRWISE_CIPHER = 42,
-        WLAN_STATUS_INVALID_AKMP = 43,
-        WLAN_STATUS_UNSUPP_RSN_VERSION = 44,
-        WLAN_STATUS_INVALID_RSN_IE_CAP = 45,
-        WLAN_STATUS_CIPHER_SUITE_REJECTED = 46,
-};
-
-/* Reason codes */
-enum ieee80211_reasoncode {
-        WLAN_REASON_UNSPECIFIED = 1,
-        WLAN_REASON_PREV_AUTH_NOT_VALID = 2,
-        WLAN_REASON_DEAUTH_LEAVING = 3,
-        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY = 4,
-        WLAN_REASON_DISASSOC_AP_BUSY = 5,
-        WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA = 6,
-        WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA = 7,
-        WLAN_REASON_DISASSOC_STA_HAS_LEFT = 8,
-        WLAN_REASON_STA_REQ_ASSOC_WITHOUT_AUTH = 9,
-        /* 802.11h */
-        WLAN_REASON_DISASSOC_BAD_POWER = 10,
-        WLAN_REASON_DISASSOC_BAD_SUPP_CHAN = 11,
-        /* 802.11i */
-        WLAN_REASON_INVALID_IE = 13,
-        WLAN_REASON_MIC_FAILURE = 14,
-        WLAN_REASON_4WAY_HANDSHAKE_TIMEOUT = 15,
-        WLAN_REASON_GROUP_KEY_HANDSHAKE_TIMEOUT = 16,
-        WLAN_REASON_IE_DIFFERENT = 17,
-        WLAN_REASON_INVALID_GROUP_CIPHER = 18,
-        WLAN_REASON_INVALID_PAIRWISE_CIPHER = 19,
-        WLAN_REASON_INVALID_AKMP = 20,
-        WLAN_REASON_UNSUPP_RSN_VERSION = 21,
-        WLAN_REASON_INVALID_RSN_IE_CAP = 22,
-        WLAN_REASON_IEEE8021X_FAILED = 23,
-        WLAN_REASON_CIPHER_SUITE_REJECTED = 24,
-};
-
 /* Action categories - 802.11h */
 enum ieee80211_actioncategories {
         WLAN_ACTION_SPECTRUM_MGMT = 0,
@@ -446,8 +357,6 @@ struct ieee80211_stats {
 
 struct ieee80211_device;
 
-#include "ieee80211_crypt.h"
-
 #define SEC_KEY_1               (1<<0)
 #define SEC_KEY_2               (1<<1)
 #define SEC_KEY_3               (1<<2)
@@ -476,9 +385,8 @@ struct ieee80211_device;
 #define SCM_TEMPORAL_KEY_LENGTH 16
 
 struct ieee80211_security {
-        u16 active_key:2,
-            enabled:1,
-            auth_mode:2, auth_algo:4, unicast_uses_group:1, encrypt:1;
+        u16 active_key:2, enabled:1, unicast_uses_group:1, encrypt:1;
+        u8 auth_mode;
         u8 encode_alg[WEP_KEYS];
         u8 key_sizes[WEP_KEYS];
         u8 keys[WEP_KEYS][SCM_KEY_LEN];
@@ -534,15 +442,6 @@ enum ieee80211_mfie {
         MFIE_TYPE_QOS_PARAMETER = 222,
 };
 
-/* Minimal header; can be used for passing 802.11 frames with sufficient
- * information to determine what type of underlying data type is actually
- * stored in the data. */
-struct ieee80211_hdr {
-        __le16 frame_ctl;
-        __le16 duration_id;
-        u8 payload[0];
-} __attribute__ ((packed));
-
 struct ieee80211_hdr_1addr {
         __le16 frame_ctl;
         __le16 duration_id;
@@ -590,18 +489,6 @@ struct ieee80211_hdr_3addrqos {
         __le16 qos_ctl;
 } __attribute__ ((packed));
 
-struct ieee80211_hdr_4addrqos {
-        __le16 frame_ctl;
-        __le16 duration_id;
-        u8 addr1[ETH_ALEN];
-        u8 addr2[ETH_ALEN];
-        u8 addr3[ETH_ALEN];
-        __le16 seq_ctl;
-        u8 addr4[ETH_ALEN];
-        u8 payload[0];
-        __le16 qos_ctl;
-} __attribute__ ((packed));
-
 struct ieee80211_info_element {
         u8 id;
         u8 len;
@@ -733,7 +620,6 @@ struct ieee80211_txb {
 
 #define MAX_WPA_IE_LEN 64
 
-#define NETWORK_EMPTY_ESSID    (1<<0)
 #define NETWORK_HAS_OFDM       (1<<1)
 #define NETWORK_HAS_CCK        (1<<2)
 
@@ -1050,11 +936,7 @@ struct ieee80211_device {
         size_t wpa_ie_len;
         u8 *wpa_ie;
 
-        struct list_head crypt_deinit_list;
-        struct ieee80211_crypt_data *crypt[WEP_KEYS];
-        int tx_keyidx;          /* default TX key index (crypt[tx_keyidx]) */
-        struct timer_list crypt_deinit_timer;
-        int crypt_quiesced;
+        struct lib80211_crypt_info crypt_info;
 
         int bcrx_sta_key;       /* use individual keys to override default keys even
                                  * with RX of broad/multicast frames */
@@ -1135,22 +1017,6 @@ static inline void *ieee80211_priv(struct net_device *dev)
         return ((struct ieee80211_device *)netdev_priv(dev))->priv;
 }
 
-static inline int ieee80211_is_empty_essid(const char *essid, int essid_len)
-{
-        /* Single white space is for Linksys APs */
-        if (essid_len == 1 && essid[0] == ' ')
-                return 1;
-
-        /* Otherwise, if the entire essid is 0, we assume it is hidden */
-        while (essid_len) {
-                essid_len--;
-                if (essid[essid_len] != '\0')
-                        return 0;
-        }
-
-        return 1;
-}
-
 static inline int ieee80211_is_valid_mode(struct ieee80211_device *ieee,
                                           int mode)
 {
@@ -1208,7 +1074,7 @@ static inline int ieee80211_get_hdrlen(u16 fc)
 
 static inline u8 *ieee80211_get_payload(struct ieee80211_hdr *hdr)
 {
-        switch (ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_ctl))) {
+        switch (ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_control))) {
         case IEEE80211_1ADDR_LEN:
                 return ((struct ieee80211_hdr_1addr *)hdr)->payload;
         case IEEE80211_2ADDR_LEN:
diff --git a/include/net/ieee80211_radiotap.h b/include/net/ieee80211_radiotap.h
index d364fd594ea4..384698cb773a 100644
--- a/include/net/ieee80211_radiotap.h
+++ b/include/net/ieee80211_radiotap.h
@@ -1,7 +1,4 @@
-/* $FreeBSD: src/sys/net80211/ieee80211_radiotap.h,v 1.5 2005/01/22 20:12:05 sam Exp $ */
-/* $NetBSD: ieee80211_radiotap.h,v 1.11 2005/06/22 06:16:02 dyoung Exp $ */
-
-/*-
+/*
  * Copyright (c) 2003, 2004 David Young.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -42,8 +39,6 @@
 #include <linux/kernel.h>
 #include <asm/unaligned.h>
 
-/* Radiotap header version (from official NetBSD feed) */
-#define IEEE80211RADIOTAP_VERSION       "1.5"
 /* Base version of the radiotap packet header data */
 #define PKTHDR_RADIOTAP_VERSION         0
 
@@ -62,12 +57,8 @@
  * readers.
  */
 
-/* XXX tcpdump/libpcap do not tolerate variable-length headers,
- * yet, so we pad every radiotap header to 64 bytes. Ugh.
- */
-#define IEEE80211_RADIOTAP_HDRLEN       64
-
-/* The radio capture header precedes the 802.11 header.
+/*
+ * The radio capture header precedes the 802.11 header.
  * All data in the header is little endian on all platforms.
  */
 struct ieee80211_radiotap_header {
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 5cc182f9ecae..f44bb5c77a70 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -41,8 +41,8 @@
  * I'll experiment with dynamic table growth later.
  */
 struct inet_ehash_bucket {
-        struct hlist_head chain;
-        struct hlist_head twchain;
+        struct hlist_nulls_head chain;
+        struct hlist_nulls_head twchain;
 };
 
 /* There are a few simple rules, which allow for local port reuse by
@@ -77,13 +77,20 @@ struct inet_ehash_bucket {
  * ports are created in O(1) time?  I thought so. ;-)   -DaveM
  */
 struct inet_bind_bucket {
+#ifdef CONFIG_NET_NS
         struct net              *ib_net;
+#endif
         unsigned short          port;
         signed short            fastreuse;
         struct hlist_node       node;
         struct hlist_head       owners;
 };
 
+static inline struct net *ib_net(struct inet_bind_bucket *ib)
+{
+        return read_pnet(&ib->ib_net);
+}
+
 #define inet_bind_bucket_for_each(tb, node, head) \
         hlist_for_each_entry(tb, node, head, node)
 
@@ -92,6 +99,18 @@ struct inet_bind_hashbucket {
         struct hlist_head       chain;
 };
 
+/*
+ * Sockets can be hashed in established or listening table
+ * We must use different 'nulls' end-of-chain value for listening
+ * hash table, or we might find a socket that was closed and
+ * reallocated/inserted into established hash table
+ */
+#define LISTENING_NULLS_BASE (1U << 29)
+struct inet_listen_hashbucket {
+        spinlock_t              lock;
+        struct hlist_nulls_head head;
+};
+
 /* This is for listening sockets, thus all sockets which possess wildcards. */
 #define INET_LHTABLE_SIZE       32      /* Yes, really, this is all you need. */
 
@@ -104,7 +123,7 @@ struct inet_hashinfo {
          * TIME_WAIT sockets use a separate chain (twchain).
          */
         struct inet_ehash_bucket        *ehash;
-        rwlock_t                        *ehash_locks;
+        spinlock_t                      *ehash_locks;
         unsigned int                    ehash_size;
         unsigned int                    ehash_locks_mask;
 
@@ -116,22 +135,21 @@ struct inet_hashinfo {
         unsigned int                    bhash_size;
         /* Note : 4 bytes padding on 64 bit arches */
 
-        /* All sockets in TCP_LISTEN state will be in here.  This is the only
-         * table where wildcard'd TCP sockets can exist.  Hash function here
-         * is just local port number.
-         */
-        struct hlist_head               listening_hash[INET_LHTABLE_SIZE];
+        struct kmem_cache               *bind_bucket_cachep;
 
         /* All the above members are written once at bootup and
          * never written again _or_ are predominantly read-access.
          *
          * Now align to a new cache line as all the following members
-         * are often dirty.
+         * might be often dirty.
          */
-        rwlock_t                        lhash_lock ____cacheline_aligned;
-        atomic_t                        lhash_users;
-        wait_queue_head_t               lhash_wait;
-        struct kmem_cache                       *bind_bucket_cachep;
+        /* All sockets in TCP_LISTEN state will be in here.  This is the only
+         * table where wildcard'd TCP sockets can exist.  Hash function here
+         * is just local port number.
+         */
+        struct inet_listen_hashbucket   listening_hash[INET_LHTABLE_SIZE]
+                                        ____cacheline_aligned_in_smp;
+
 };
 
 static inline struct inet_ehash_bucket *inet_ehash_bucket(
@@ -141,7 +159,7 @@ static inline struct inet_ehash_bucket *inet_ehash_bucket(
         return &hashinfo->ehash[hash & (hashinfo->ehash_size - 1)];
 }
 
-static inline rwlock_t *inet_ehash_lockp(
+static inline spinlock_t *inet_ehash_lockp(
         struct inet_hashinfo *hashinfo,
         unsigned int hash)
 {
@@ -166,16 +184,16 @@ static inline int inet_ehash_locks_alloc(struct inet_hashinfo *hashinfo)
                 size = 4096;
         if (sizeof(rwlock_t) != 0) {
 #ifdef CONFIG_NUMA
-                if (size * sizeof(rwlock_t) > PAGE_SIZE)
-                        hashinfo->ehash_locks = vmalloc(size * sizeof(rwlock_t));
+                if (size * sizeof(spinlock_t) > PAGE_SIZE)
+                        hashinfo->ehash_locks = vmalloc(size * sizeof(spinlock_t));
                 else
 #endif
-                hashinfo->ehash_locks = kmalloc(size * sizeof(rwlock_t),
+                hashinfo->ehash_locks = kmalloc(size * sizeof(spinlock_t),
                                                 GFP_KERNEL);
                 if (!hashinfo->ehash_locks)
                         return ENOMEM;
                 for (i = 0; i < size; i++)
-                        rwlock_init(&hashinfo->ehash_locks[i]);
+                        spin_lock_init(&hashinfo->ehash_locks[i]);
         }
         hashinfo->ehash_locks_mask = size - 1;
         return 0;
@@ -186,7 +204,7 @@ static inline void inet_ehash_locks_free(struct inet_hashinfo *hashinfo)
         if (hashinfo->ehash_locks) {
 #ifdef CONFIG_NUMA
                 unsigned int size = (hashinfo->ehash_locks_mask + 1) *
-                                                        sizeof(rwlock_t);
+                                                        sizeof(spinlock_t);
                 if (size > PAGE_SIZE)
                         vfree(hashinfo->ehash_locks);
                 else
@@ -229,26 +247,7 @@ extern void __inet_inherit_port(struct sock *sk, struct sock *child);
 
 extern void inet_put_port(struct sock *sk);
 
-extern void inet_listen_wlock(struct inet_hashinfo *hashinfo);
-
-/*
- * - We may sleep inside this lock.
- * - If sleeping is not required (or called from BH),
- *   use plain read_(un)lock(&inet_hashinfo.lhash_lock).
- */
-static inline void inet_listen_lock(struct inet_hashinfo *hashinfo)
-{
-        /* read_lock synchronizes to candidates to writers */
-        read_lock(&hashinfo->lhash_lock);
-        atomic_inc(&hashinfo->lhash_users);
-        read_unlock(&hashinfo->lhash_lock);
-}
-
-static inline void inet_listen_unlock(struct inet_hashinfo *hashinfo)
-{
-        if (atomic_dec_and_test(&hashinfo->lhash_users))
-                wake_up(&hashinfo->lhash_wait);
-}
+void inet_hashinfo_init(struct inet_hashinfo *h);
 
 extern void __inet_hash_nolisten(struct sock *sk);
 extern void inet_hash(struct sock *sk);
@@ -299,25 +298,25 @@ typedef __u64 __bitwise __addrpair;
                                    ((__force __u64)(__be32)(__saddr)));
 #endif /* __BIG_ENDIAN */
 #define INET_MATCH(__sk, __net, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
-        (((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net)   &&      \
+        (((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net)) &&    \
          ((*((__addrpair *)&(inet_sk(__sk)->daddr))) == (__cookie))     &&      \
          ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports))      &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #define INET_TW_MATCH(__sk, __net, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
-        (((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net)   &&      \
+        (((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net)) &&    \
          ((*((__addrpair *)&(inet_twsk(__sk)->tw_daddr))) == (__cookie)) &&     \
          ((*((__portpair *)&(inet_twsk(__sk)->tw_dport))) == (__ports)) &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #else /* 32-bit arch */
 #define INET_ADDR_COOKIE(__name, __saddr, __daddr)
 #define INET_MATCH(__sk, __net, __hash, __cookie, __saddr, __daddr, __ports, __dif)     \
-        (((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net)   &&      \
+        (((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net))       &&      \
          (inet_sk(__sk)->daddr          == (__saddr))           &&      \
          (inet_sk(__sk)->rcv_saddr      == (__daddr))           &&      \
          ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports))      &&      \
          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 #define INET_TW_MATCH(__sk, __net, __hash,__cookie, __saddr, __daddr, __ports, __dif)   \
-        (((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net)   &&      \
+        (((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net))       &&      \
          (inet_twsk(__sk)->tw_daddr     == (__saddr))           &&      \
          (inet_twsk(__sk)->tw_rcv_saddr == (__daddr))           &&      \
          ((*((__portpair *)&(inet_twsk(__sk)->tw_dport))) == (__ports)) &&      \
diff --git a/include/net/inet_timewait_sock.h b/include/net/inet_timewait_sock.h
index 80e4977631b8..4b8ece22b8e9 100644
--- a/include/net/inet_timewait_sock.h
+++ b/include/net/inet_timewait_sock.h
@@ -110,7 +110,7 @@ struct inet_timewait_sock {
 #define tw_state                __tw_common.skc_state
 #define tw_reuse                __tw_common.skc_reuse
 #define tw_bound_dev_if         __tw_common.skc_bound_dev_if
-#define tw_node                 __tw_common.skc_node
+#define tw_node                 __tw_common.skc_nulls_node
 #define tw_bind_node            __tw_common.skc_bind_node
 #define tw_refcnt               __tw_common.skc_refcnt
 #define tw_hash                 __tw_common.skc_hash
@@ -137,10 +137,10 @@ struct inet_timewait_sock {
         struct hlist_node       tw_death_node;
 };
 
-static inline void inet_twsk_add_node(struct inet_timewait_sock *tw,
-                                      struct hlist_head *list)
+static inline void inet_twsk_add_node_rcu(struct inet_timewait_sock *tw,
+                                      struct hlist_nulls_head *list)
 {
-        hlist_add_head(&tw->tw_node, list);
+        hlist_nulls_add_head_rcu(&tw->tw_node, list);
 }
 
 static inline void inet_twsk_add_bind_node(struct inet_timewait_sock *tw,
@@ -175,7 +175,7 @@ static inline int inet_twsk_del_dead_node(struct inet_timewait_sock *tw)
 }
 
 #define inet_twsk_for_each(tw, node, head) \
-        hlist_for_each_entry(tw, node, head, tw_node)
+        hlist_nulls_for_each_entry(tw, node, head, tw_node)
 
 #define inet_twsk_for_each_inmate(tw, node, jail) \
         hlist_for_each_entry(tw, node, jail, tw_death_node)
diff --git a/include/net/ip.h b/include/net/ip.h
index bc026ecb513f..10868139e656 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -110,7 +110,7 @@ extern int		ip_append_data(struct sock *sk,
                                                    int odd, struct sk_buff *skb),
                                 void *from, int len, int protolen,
                                 struct ipcm_cookie *ipc,
-                                struct rtable *rt,
+                                struct rtable **rt,
                                 unsigned int flags);
 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,
@@ -187,6 +187,7 @@ extern void inet_get_local_port_range(int *low, int *high);
 extern int sysctl_ip_default_ttl;
 extern int sysctl_ip_nonlocal_bind;
 
+extern struct ctl_path net_core_path[];
 extern struct ctl_path net_ipv4_ctl_path[];
 
 /* From inetpeer.c */
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h
index fe9fcf73c85e..ab9b003ab671 100644
--- a/include/net/ip_vs.h
+++ b/include/net/ip_vs.h
@@ -87,12 +87,12 @@ static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len,
         int len;
 #ifdef CONFIG_IP_VS_IPV6
         if (af == AF_INET6)
-                len = snprintf(&buf[*idx], buf_len - *idx, "[" NIP6_FMT "]",
-                               NIP6(addr->in6)) + 1;
+                len = snprintf(&buf[*idx], buf_len - *idx, "[%pI6]",
+                               &addr->in6) + 1;
         else
 #endif
-                len = snprintf(&buf[*idx], buf_len - *idx, NIPQUAD_FMT,
-                               NIPQUAD(addr->ip)) + 1;
+                len = snprintf(&buf[*idx], buf_len - *idx, "%pI4",
+                               &addr->ip) + 1;
 
         *idx += len;
         BUG_ON(*idx > buf_len + 1);
@@ -503,9 +503,6 @@ struct ip_vs_scheduler {
         char                    *name;          /* scheduler name */
         atomic_t                refcnt;         /* reference counter */
         struct module           *module;        /* THIS_MODULE/NULL */
-#ifdef CONFIG_IP_VS_IPV6
-        int                     supports_ipv6;  /* scheduler has IPv6 support */
-#endif
 
         /* scheduler initializing service */
         int (*init_service)(struct ip_vs_service *svc);
@@ -916,7 +913,7 @@ static inline __wsum ip_vs_check_diff4(__be32 old, __be32 new, __wsum oldsum)
 {
         __be32 diff[2] = { ~old, new };
 
-        return csum_partial((char *) diff, sizeof(diff), oldsum);
+        return csum_partial(diff, sizeof(diff), oldsum);
 }
 
 #ifdef CONFIG_IP_VS_IPV6
@@ -926,7 +923,7 @@ static inline __wsum ip_vs_check_diff16(const __be32 *old, const __be32 *new,
         __be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0],
                             new[3],  new[2],  new[1],  new[0] };
 
-        return csum_partial((char *) diff, sizeof(diff), oldsum);
+        return csum_partial(diff, sizeof(diff), oldsum);
 }
 #endif
 
@@ -934,7 +931,7 @@ static inline __wsum ip_vs_check_diff2(__be16 old, __be16 new, __wsum oldsum)
 {
         __be16 diff[2] = { ~old, new };
 
-        return csum_partial((char *) diff, sizeof(diff), oldsum);
+        return csum_partial(diff, sizeof(diff), oldsum);
 }
 
 #endif /* __KERNEL__ */
diff --git a/include/net/ieee80211_crypt.h b/include/net/lib80211.h
index b3d65e0bedd3..fb4e2784857d 100644
--- a/include/net/ieee80211_crypt.h
+++ b/include/net/lib80211.h
@@ -1,4 +1,11 @@
 /*
+ * lib80211.h -- common bits for IEEE802.11 wireless drivers
+ *
+ * Copyright (c) 2008, John W. Linville <linville@tuxdriver.com>
+ *
+ * Some bits copied from old ieee80211 component, w/ original copyright
+ * notices below:
+ *
  * Original code based on Host AP (software wireless LAN access point) driver
  * for Intersil Prism2/2.5/3.
  *
@@ -11,31 +18,31 @@
  *
  * Copyright (c) 2004, Intel Corporation
  *
- * 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. See README and COPYING for
- * more details.
  */
 
-/*
- * This file defines the interface to the ieee80211 crypto module.
- */
-#ifndef IEEE80211_CRYPT_H
-#define IEEE80211_CRYPT_H
+#ifndef LIB80211_H
+#define LIB80211_H
 
 #include <linux/types.h>
 #include <linux/list.h>
-#include <net/ieee80211.h>
+#include <linux/module.h>
 #include <asm/atomic.h>
+#include <linux/if.h>
+#include <linux/skbuff.h>
+#include <linux/ieee80211.h>
+#include <linux/timer.h>
+/* print_ssid() is intended to be used in debug (and possibly error)
+ * messages. It should never be used for passing ssid to user space. */
+const char *print_ssid(char *buf, const char *ssid, u8 ssid_len);
+#define DECLARE_SSID_BUF(var) char var[IEEE80211_MAX_SSID_LEN * 4 + 1] __maybe_unused
+
+#define NUM_WEP_KEYS    4
 
 enum {
         IEEE80211_CRYPTO_TKIP_COUNTERMEASURES = (1 << 0),
 };
 
-struct sk_buff;
-struct module;
-
-struct ieee80211_crypto_ops {
+struct lib80211_crypto_ops {
         const char *name;
         struct list_head list;
 
@@ -87,22 +94,36 @@ struct ieee80211_crypto_ops {
         struct module *owner;
 };
 
-struct ieee80211_crypt_data {
+struct lib80211_crypt_data {
         struct list_head list;  /* delayed deletion list */
-        struct ieee80211_crypto_ops *ops;
+        struct lib80211_crypto_ops *ops;
         void *priv;
         atomic_t refcnt;
 };
 
-struct ieee80211_device;
-
-int ieee80211_register_crypto_ops(struct ieee80211_crypto_ops *ops);
-int ieee80211_unregister_crypto_ops(struct ieee80211_crypto_ops *ops);
-struct ieee80211_crypto_ops *ieee80211_get_crypto_ops(const char *name);
-void ieee80211_crypt_deinit_entries(struct ieee80211_device *, int);
-void ieee80211_crypt_deinit_handler(unsigned long);
-void ieee80211_crypt_delayed_deinit(struct ieee80211_device *ieee,
-                                    struct ieee80211_crypt_data **crypt);
-void ieee80211_crypt_quiescing(struct ieee80211_device *ieee);
+struct lib80211_crypt_info {
+        char *name;
+        /* Most clients will already have a lock,
+           so just point to that. */
+        spinlock_t *lock;
+
+        struct lib80211_crypt_data *crypt[NUM_WEP_KEYS];
+        int tx_keyidx;          /* default TX key index (crypt[tx_keyidx]) */
+        struct list_head crypt_deinit_list;
+        struct timer_list crypt_deinit_timer;
+        int crypt_quiesced;
+};
 
-#endif
+int lib80211_crypt_info_init(struct lib80211_crypt_info *info, char *name,
+                                spinlock_t *lock);
+void lib80211_crypt_info_free(struct lib80211_crypt_info *info);
+int lib80211_register_crypto_ops(struct lib80211_crypto_ops *ops);
+int lib80211_unregister_crypto_ops(struct lib80211_crypto_ops *ops);
+struct lib80211_crypto_ops *lib80211_get_crypto_ops(const char *name);
+void lib80211_crypt_deinit_entries(struct lib80211_crypt_info *, int);
+void lib80211_crypt_deinit_handler(unsigned long);
+void lib80211_crypt_delayed_deinit(struct lib80211_crypt_info *info,
+                                    struct lib80211_crypt_data **crypt);
+void lib80211_crypt_quiescing(struct lib80211_crypt_info *info);
+
+#endif /* LIB80211_H */
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 73d81bc6aa75..b3bd00a9d992 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -3,7 +3,7 @@
  *
  * Copyright 2002-2005, Devicescape Software, Inc.
  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
- * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2007-2008  Johannes Berg <johannes@sipsolutions.net>
  *
  * 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
@@ -107,7 +107,7 @@ enum ieee80211_max_queues {
  * The information provided in this structure is required for QoS
  * transmit queue configuration. Cf. IEEE 802.11 7.3.2.29.
  *
- * @aifs: arbitration interface space [0..255]
+ * @aifs: arbitration interframe space [0..255]
  * @cw_min: minimum contention window [a value of the form
  *      2^n-1 in the range 1..32767]
  * @cw_max: maximum contention window [like @cw_min]
@@ -164,6 +164,14 @@ enum ieee80211_bss_change {
 };
 
 /**
+ * struct ieee80211_bss_ht_conf - BSS's changing HT configuration
+ * @operation_mode: HT operation mode (like in &struct ieee80211_ht_info)
+ */
+struct ieee80211_bss_ht_conf {
+        u16 operation_mode;
+};
+
+/**
  * struct ieee80211_bss_conf - holds the BSS's changing parameters
  *
  * This structure keeps information about a BSS (and an association
@@ -172,15 +180,17 @@ enum ieee80211_bss_change {
  * @assoc: association status
  * @aid: association ID number, valid only when @assoc is true
  * @use_cts_prot: use CTS protection
- * @use_short_preamble: use 802.11b short preamble
- * @use_short_slot: use short slot time (only relevant for ERP)
+ * @use_short_preamble: use 802.11b short preamble;
+ *      if the hardware cannot handle this it must set the
+ *      IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE hardware flag
+ * @use_short_slot: use short slot time (only relevant for ERP);
+ *      if the hardware cannot handle this it must set the
+ *      IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE hardware flag
  * @dtim_period: num of beacons before the next DTIM, for PSM
  * @timestamp: beacon timestamp
  * @beacon_int: beacon interval
  * @assoc_capability: capabilities taken from assoc resp
- * @assoc_ht: association in HT mode
- * @ht_conf: ht capabilities
- * @ht_bss_conf: ht extended capabilities
+ * @ht: BSS's HT configuration
  * @basic_rates: bitmap of basic rates, each bit stands for an
  *      index into the rate table configured by the driver in
  *      the current band.
@@ -198,10 +208,7 @@ struct ieee80211_bss_conf {
         u16 assoc_capability;
         u64 timestamp;
         u64 basic_rates;
-        /* ht related data */
-        bool assoc_ht;
-        struct ieee80211_ht_info *ht_conf;
-        struct ieee80211_ht_bss_info *ht_bss_conf;
+        struct ieee80211_bss_ht_conf ht;
 };
 
 /**
@@ -210,29 +217,24 @@ struct ieee80211_bss_conf {
  * These flags are used with the @flags member of &ieee80211_tx_info.
  *
  * @IEEE80211_TX_CTL_REQ_TX_STATUS: request TX status callback for this frame.
- * @IEEE80211_TX_CTL_USE_RTS_CTS: use RTS-CTS before sending frame
- * @IEEE80211_TX_CTL_USE_CTS_PROTECT: use CTS protection for the frame (e.g.,
- *      for combined 802.11g / 802.11b networks)
+ * @IEEE80211_TX_CTL_ASSIGN_SEQ: The driver has to assign a sequence
+ *      number to this frame, taking care of not overwriting the fragment
+ *      number and increasing the sequence number only when the
+ *      IEEE80211_TX_CTL_FIRST_FRAGMENT flag is set. mac80211 will properly
+ *      assign sequence numbers to QoS-data frames but cannot do so correctly
+ *      for non-QoS-data and management frames because beacons need them from
+ *      that counter as well and mac80211 cannot guarantee proper sequencing.
+ *      If this flag is set, the driver should instruct the hardware to
+ *      assign a sequence number to the frame or assign one itself. Cf. IEEE
+ *      802.11-2007 7.1.3.4.1 paragraph 3. This flag will always be set for
+ *      beacons and always be clear for frames without a sequence number field.
  * @IEEE80211_TX_CTL_NO_ACK: tell the low level not to wait for an ack
- * @IEEE80211_TX_CTL_RATE_CTRL_PROBE: TBD
  * @IEEE80211_TX_CTL_CLEAR_PS_FILT: clear powersave filter for destination
  *      station
- * @IEEE80211_TX_CTL_REQUEUE: TBD
  * @IEEE80211_TX_CTL_FIRST_FRAGMENT: this is a first fragment of the frame
- * @IEEE80211_TX_CTL_SHORT_PREAMBLE: TBD
- * @IEEE80211_TX_CTL_LONG_RETRY_LIMIT: this frame should be send using the
- *      through set_retry_limit configured long retry value
  * @IEEE80211_TX_CTL_SEND_AFTER_DTIM: send this frame after DTIM beacon
  * @IEEE80211_TX_CTL_AMPDU: this frame should be sent as part of an A-MPDU
- * @IEEE80211_TX_CTL_OFDM_HT: this frame can be sent in HT OFDM rates. number
- *      of streams when this flag is on can be extracted from antenna_sel_tx,
- *      so if 1 antenna is marked use SISO, 2 antennas marked use MIMO, n
- *      antennas marked use MIMO_n.
- * @IEEE80211_TX_CTL_GREEN_FIELD: use green field protection for this frame
- * @IEEE80211_TX_CTL_40_MHZ_WIDTH: send this frame using 40 Mhz channel width
- * @IEEE80211_TX_CTL_DUP_DATA: duplicate data frame on both 20 Mhz channels
- * @IEEE80211_TX_CTL_SHORT_GI: send this frame using short guard interval
- * @IEEE80211_TX_CTL_INJECTED: TBD
+ * @IEEE80211_TX_CTL_INJECTED: Frame was injected, internal to mac80211.
  * @IEEE80211_TX_STAT_TX_FILTERED: The frame was not transmitted
  *      because the destination STA was in powersave mode.
  * @IEEE80211_TX_STAT_ACK: Frame was acknowledged
@@ -240,63 +242,67 @@ struct ieee80211_bss_conf {
  *      is for the whole aggregation.
  * @IEEE80211_TX_STAT_AMPDU_NO_BACK: no block ack was returned,
  *      so consider using block ack request (BAR).
- * @IEEE80211_TX_CTL_ASSIGN_SEQ: The driver has to assign a sequence
- *      number to this frame, taking care of not overwriting the fragment
- *      number and increasing the sequence number only when the
- *      IEEE80211_TX_CTL_FIRST_FRAGMENT flags is set. mac80211 will properly
- *      assign sequence numbers to QoS-data frames but cannot do so correctly
- *      for non-QoS-data and management frames because beacons need them from
- *      that counter as well and mac80211 cannot guarantee proper sequencing.
- *      If this flag is set, the driver should instruct the hardware to
- *      assign a sequence number to the frame or assign one itself. Cf. IEEE
- *      802.11-2007 7.1.3.4.1 paragraph 3. This flag will always be set for
- *      beacons always be clear for frames without a sequence number field.
+ * @IEEE80211_TX_CTL_RATE_CTRL_PROBE: internal to mac80211, can be
+ *      set by rate control algorithms to indicate probe rate, will
+ *      be cleared for fragmented frames (except on the last fragment)
  */
 enum mac80211_tx_control_flags {
         IEEE80211_TX_CTL_REQ_TX_STATUS          = BIT(0),
-        IEEE80211_TX_CTL_USE_RTS_CTS            = BIT(2),
-        IEEE80211_TX_CTL_USE_CTS_PROTECT        = BIT(3),
-        IEEE80211_TX_CTL_NO_ACK                 = BIT(4),
-        IEEE80211_TX_CTL_RATE_CTRL_PROBE        = BIT(5),
-        IEEE80211_TX_CTL_CLEAR_PS_FILT          = BIT(6),
-        IEEE80211_TX_CTL_REQUEUE                = BIT(7),
-        IEEE80211_TX_CTL_FIRST_FRAGMENT         = BIT(8),
-        IEEE80211_TX_CTL_SHORT_PREAMBLE         = BIT(9),
-        IEEE80211_TX_CTL_LONG_RETRY_LIMIT       = BIT(10),
-        IEEE80211_TX_CTL_SEND_AFTER_DTIM        = BIT(12),
-        IEEE80211_TX_CTL_AMPDU                  = BIT(13),
-        IEEE80211_TX_CTL_OFDM_HT                = BIT(14),
-        IEEE80211_TX_CTL_GREEN_FIELD            = BIT(15),
-        IEEE80211_TX_CTL_40_MHZ_WIDTH           = BIT(16),
-        IEEE80211_TX_CTL_DUP_DATA               = BIT(17),
-        IEEE80211_TX_CTL_SHORT_GI               = BIT(18),
-        IEEE80211_TX_CTL_INJECTED               = BIT(19),
-        IEEE80211_TX_STAT_TX_FILTERED           = BIT(20),
-        IEEE80211_TX_STAT_ACK                   = BIT(21),
-        IEEE80211_TX_STAT_AMPDU                 = BIT(22),
-        IEEE80211_TX_STAT_AMPDU_NO_BACK         = BIT(23),
-        IEEE80211_TX_CTL_ASSIGN_SEQ             = BIT(24),
+        IEEE80211_TX_CTL_ASSIGN_SEQ             = BIT(1),
+        IEEE80211_TX_CTL_NO_ACK                 = BIT(2),
+        IEEE80211_TX_CTL_CLEAR_PS_FILT          = BIT(3),
+        IEEE80211_TX_CTL_FIRST_FRAGMENT         = BIT(4),
+        IEEE80211_TX_CTL_SEND_AFTER_DTIM        = BIT(5),
+        IEEE80211_TX_CTL_AMPDU                  = BIT(6),
+        IEEE80211_TX_CTL_INJECTED               = BIT(7),
+        IEEE80211_TX_STAT_TX_FILTERED           = BIT(8),
+        IEEE80211_TX_STAT_ACK                   = BIT(9),
+        IEEE80211_TX_STAT_AMPDU                 = BIT(10),
+        IEEE80211_TX_STAT_AMPDU_NO_BACK         = BIT(11),
+        IEEE80211_TX_CTL_RATE_CTRL_PROBE        = BIT(12),
+};
+
+enum mac80211_rate_control_flags {
+        IEEE80211_TX_RC_USE_RTS_CTS             = BIT(0),
+        IEEE80211_TX_RC_USE_CTS_PROTECT         = BIT(1),
+        IEEE80211_TX_RC_USE_SHORT_PREAMBLE      = BIT(2),
+
+        /* rate index is an MCS rate number instead of an index */
+        IEEE80211_TX_RC_MCS                     = BIT(3),
+        IEEE80211_TX_RC_GREEN_FIELD             = BIT(4),
+        IEEE80211_TX_RC_40_MHZ_WIDTH            = BIT(5),
+        IEEE80211_TX_RC_DUP_DATA                = BIT(6),
+        IEEE80211_TX_RC_SHORT_GI                = BIT(7),
 };
 
 
-#define IEEE80211_TX_INFO_DRIVER_DATA_SIZE \
-        (sizeof(((struct sk_buff *)0)->cb) - 8)
-#define IEEE80211_TX_INFO_DRIVER_DATA_PTRS \
-        (IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *))
+/* there are 40 bytes if you don't need the rateset to be kept */
+#define IEEE80211_TX_INFO_DRIVER_DATA_SIZE 40
 
-/* maximum number of alternate rate retry stages */
-#define IEEE80211_TX_MAX_ALTRATE        3
+/* if you do need the rateset, then you have less space */
+#define IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE 24
+
+/* maximum number of rate stages */
+#define IEEE80211_TX_MAX_RATES  5
 
 /**
- * struct ieee80211_tx_altrate - alternate rate selection/status
+ * struct ieee80211_tx_rate - rate selection/status
+ *
+ * @idx: rate index to attempt to send with
+ * @flags: rate control flags (&enum mac80211_rate_control_flags)
+ * @count: number of tries in this rate before going to the next rate
  *
- * @rate_idx: rate index to attempt to send with
- * @limit: number of retries before fallback
+ * A value of -1 for @idx indicates an invalid rate and, if used
+ * in an array of retry rates, that no more rates should be tried.
+ *
+ * When used for transmit status reporting, the driver should
+ * always report the rate along with the flags it used.
  */
-struct ieee80211_tx_altrate {
-        s8 rate_idx;
-        u8 limit;
-};
+struct ieee80211_tx_rate {
+        s8 idx;
+        u8 count;
+        u8 flags;
+} __attribute__((packed));
 
 /**
  * struct ieee80211_tx_info - skb transmit information
@@ -310,15 +316,13 @@ struct ieee80211_tx_altrate {
  * it may be NULL.
  *
  * @flags: transmit info flags, defined above
- * @band: TBD
- * @tx_rate_idx: TBD
- * @antenna_sel_tx: TBD
+ * @band: the band to transmit on (use for checking for races)
+ * @antenna_sel_tx: antenna to use, 0 for automatic diversity
+ * @pad: padding, ignore
  * @control: union for control data
  * @status: union for status data
  * @driver_data: array of driver_data pointers
  * @retry_count: number of retries
- * @excessive_retries: set to 1 if the frame was retried many times
- *      but not acknowledged
  * @ampdu_ack_len: number of aggregated frames.
  *      relevant only if IEEE80211_TX_STATUS_AMPDU was set.
  * @ampdu_ack_map: block ack bit map for the aggregation.
@@ -329,31 +333,44 @@ struct ieee80211_tx_info {
         /* common information */
         u32 flags;
         u8 band;
-        s8 tx_rate_idx;
+
         u8 antenna_sel_tx;
 
-        /* 1 byte hole */
+        /* 2 byte hole */
+        u8 pad[2];
 
         union {
                 struct {
+                        union {
+                                /* rate control */
+                                struct {
+                                        struct ieee80211_tx_rate rates[
+                                                IEEE80211_TX_MAX_RATES];
+                                        s8 rts_cts_rate_idx;
+                                };
+                                /* only needed before rate control */
+                                unsigned long jiffies;
+                        };
                         /* NB: vif can be NULL for injected frames */
                         struct ieee80211_vif *vif;
                         struct ieee80211_key_conf *hw_key;
                         struct ieee80211_sta *sta;
-                        unsigned long jiffies;
-                        s8 rts_cts_rate_idx;
-                        u8 retry_limit;
-                        struct ieee80211_tx_altrate retries[IEEE80211_TX_MAX_ALTRATE];
                 } control;
                 struct {
+                        struct ieee80211_tx_rate rates[IEEE80211_TX_MAX_RATES];
+                        u8 ampdu_ack_len;
                         u64 ampdu_ack_map;
                         int ack_signal;
-                        struct ieee80211_tx_altrate retries[IEEE80211_TX_MAX_ALTRATE + 1];
-                        u8 retry_count;
-                        bool excessive_retries;
-                        u8 ampdu_ack_len;
+                        /* 8 bytes free */
                 } status;
-                void *driver_data[IEEE80211_TX_INFO_DRIVER_DATA_PTRS];
+                struct {
+                        struct ieee80211_tx_rate driver_rates[
+                                IEEE80211_TX_MAX_RATES];
+                        void *rate_driver_data[
+                                IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE / sizeof(void *)];
+                };
+                void *driver_data[
+                        IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *)];
         };
 };
 
@@ -362,6 +379,41 @@ static inline struct ieee80211_tx_info *IEEE80211_SKB_CB(struct sk_buff *skb)
         return (struct ieee80211_tx_info *)skb->cb;
 }
 
+/**
+ * ieee80211_tx_info_clear_status - clear TX status
+ *
+ * @info: The &struct ieee80211_tx_info to be cleared.
+ *
+ * When the driver passes an skb back to mac80211, it must report
+ * a number of things in TX status. This function clears everything
+ * in the TX status but the rate control information (it does clear
+ * the count since you need to fill that in anyway).
+ *
+ * NOTE: You can only use this function if you do NOT use
+ *       info->driver_data! Use info->rate_driver_data
+ *       instead if you need only the less space that allows.
+ */
+static inline void
+ieee80211_tx_info_clear_status(struct ieee80211_tx_info *info)
+{
+        int i;
+
+        BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) !=
+                     offsetof(struct ieee80211_tx_info, control.rates));
+        BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) !=
+                     offsetof(struct ieee80211_tx_info, driver_rates));
+        BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) != 8);
+        /* clear the rate counts */
+        for (i = 0; i < IEEE80211_TX_MAX_RATES; i++)
+                info->status.rates[i].count = 0;
+
+        BUILD_BUG_ON(
+            offsetof(struct ieee80211_tx_info, status.ampdu_ack_len) != 23);
+        memset(&info->status.ampdu_ack_len, 0,
+               sizeof(struct ieee80211_tx_info) -
+               offsetof(struct ieee80211_tx_info, status.ampdu_ack_len));
+}
+
 
 /**
  * enum mac80211_rx_flags - receive flags
@@ -384,6 +436,9 @@ static inline struct ieee80211_tx_info *IEEE80211_SKB_CB(struct sk_buff *skb)
  *      is valid. This is useful in monitor mode and necessary for beacon frames
  *      to enable 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
+ * @RX_FLAG_SHORT_GI: Short guard interval was used
  */
 enum mac80211_rx_flags {
         RX_FLAG_MMIC_ERROR      = 1<<0,
@@ -394,7 +449,10 @@ enum mac80211_rx_flags {
         RX_FLAG_FAILED_FCS_CRC  = 1<<5,
         RX_FLAG_FAILED_PLCP_CRC = 1<<6,
         RX_FLAG_TSFT            = 1<<7,
-        RX_FLAG_SHORTPRE        = 1<<8
+        RX_FLAG_SHORTPRE        = 1<<8,
+        RX_FLAG_HT              = 1<<9,
+        RX_FLAG_40MHZ           = 1<<10,
+        RX_FLAG_SHORT_GI        = 1<<11,
 };
 
 /**
@@ -414,7 +472,8 @@ enum mac80211_rx_flags {
  * @noise: noise when receiving this frame, in dBm.
  * @qual: overall signal quality indication, in percent (0-100).
  * @antenna: antenna used
- * @rate_idx: index of data rate into band's supported rates
+ * @rate_idx: index of data rate into band's supported rates or MCS index if
+ *      HT rates are use (RX_FLAG_HT)
  * @flag: %RX_FLAG_*
  */
 struct ieee80211_rx_status {
@@ -434,21 +493,49 @@ struct ieee80211_rx_status {
  *
  * Flags to define PHY configuration options
  *
- * @IEEE80211_CONF_SHORT_SLOT_TIME: use 802.11g short slot time
  * @IEEE80211_CONF_RADIOTAP: add radiotap header at receive time (if supported)
- * @IEEE80211_CONF_SUPPORT_HT_MODE: use 802.11n HT capabilities (if supported)
  * @IEEE80211_CONF_PS: Enable 802.11 power save mode
  */
 enum ieee80211_conf_flags {
-        /*
-         * TODO: IEEE80211_CONF_SHORT_SLOT_TIME will be removed once drivers
-         * have been converted to use bss_info_changed() for slot time
-         * configuration
-         */
-        IEEE80211_CONF_SHORT_SLOT_TIME  = (1<<0),
-        IEEE80211_CONF_RADIOTAP         = (1<<1),
-        IEEE80211_CONF_SUPPORT_HT_MODE  = (1<<2),
-        IEEE80211_CONF_PS               = (1<<3),
+        IEEE80211_CONF_RADIOTAP         = (1<<0),
+        IEEE80211_CONF_PS               = (1<<1),
+};
+
+/* XXX: remove all this once drivers stop trying to use it */
+static inline int __deprecated __IEEE80211_CONF_SHORT_SLOT_TIME(void)
+{
+        return 0;
+}
+#define IEEE80211_CONF_SHORT_SLOT_TIME (__IEEE80211_CONF_SHORT_SLOT_TIME())
+
+struct ieee80211_ht_conf {
+        bool enabled;
+        enum nl80211_channel_type channel_type;
+};
+
+/**
+ * enum ieee80211_conf_changed - denotes which configuration changed
+ *
+ * @IEEE80211_CONF_CHANGE_RADIO_ENABLED: the value of radio_enabled changed
+ * @IEEE80211_CONF_CHANGE_BEACON_INTERVAL: the beacon interval changed
+ * @IEEE80211_CONF_CHANGE_LISTEN_INTERVAL: the listen interval changed
+ * @IEEE80211_CONF_CHANGE_RADIOTAP: the radiotap flag changed
+ * @IEEE80211_CONF_CHANGE_PS: the PS flag changed
+ * @IEEE80211_CONF_CHANGE_POWER: the TX power changed
+ * @IEEE80211_CONF_CHANGE_CHANNEL: the channel changed
+ * @IEEE80211_CONF_CHANGE_RETRY_LIMITS: retry limits changed
+ * @IEEE80211_CONF_CHANGE_HT: HT configuration changed
+ */
+enum ieee80211_conf_changed {
+        IEEE80211_CONF_CHANGE_RADIO_ENABLED     = BIT(0),
+        IEEE80211_CONF_CHANGE_BEACON_INTERVAL   = BIT(1),
+        IEEE80211_CONF_CHANGE_LISTEN_INTERVAL   = BIT(2),
+        IEEE80211_CONF_CHANGE_RADIOTAP          = BIT(3),
+        IEEE80211_CONF_CHANGE_PS                = BIT(4),
+        IEEE80211_CONF_CHANGE_POWER             = BIT(5),
+        IEEE80211_CONF_CHANGE_CHANNEL           = BIT(6),
+        IEEE80211_CONF_CHANGE_RETRY_LIMITS      = BIT(7),
+        IEEE80211_CONF_CHANGE_HT                = BIT(8),
 };
 
 /**
@@ -457,34 +544,31 @@ enum ieee80211_conf_flags {
  * This struct indicates how the driver shall configure the hardware.
  *
  * @radio_enabled: when zero, driver is required to switch off the radio.
- *      TODO make a flag
  * @beacon_int: beacon interval (TODO make interface config)
  * @listen_interval: listen interval in units of beacon interval
  * @flags: configuration flags defined above
  * @power_level: requested transmit power (in dBm)
- * @max_antenna_gain: maximum antenna gain (in dBi)
- * @antenna_sel_tx: transmit antenna selection, 0: default/diversity,
- *      1/2: antenna 0/1
- * @antenna_sel_rx: receive antenna selection, like @antenna_sel_tx
- * @ht_conf: describes current self configuration of 802.11n HT capabilies
- * @ht_bss_conf: describes current BSS configuration of 802.11n HT parameters
  * @channel: the channel to tune to
+ * @ht: the HT configuration for the device
+ * @long_frame_max_tx_count: Maximum number of transmissions for a "long" frame
+ *    (a frame not RTS protected), called "dot11LongRetryLimit" in 802.11,
+ *    but actually means the number of transmissions not the number of retries
+ * @short_frame_max_tx_count: Maximum number of transmissions for a "short"
+ *    frame, called "dot11ShortRetryLimit" in 802.11, but actually means the
+ *    number of transmissions not the number of retries
  */
 struct ieee80211_conf {
-        int radio_enabled;
-
         int beacon_int;
-        u16 listen_interval;
         u32 flags;
         int power_level;
-        int max_antenna_gain;
-        u8 antenna_sel_tx;
-        u8 antenna_sel_rx;
 
-        struct ieee80211_channel *channel;
+        u16 listen_interval;
+        bool radio_enabled;
+
+        u8 long_frame_max_tx_count, short_frame_max_tx_count;
 
-        struct ieee80211_ht_info ht_conf;
-        struct ieee80211_ht_bss_info ht_bss_conf;
+        struct ieee80211_channel *channel;
+        struct ieee80211_ht_conf ht;
 };
 
 /**
@@ -494,11 +578,14 @@ struct ieee80211_conf {
  * use during the life of a virtual interface.
  *
  * @type: type of this virtual interface
+ * @bss_conf: BSS configuration for this interface, either our own
+ *      or the BSS we're associated to
  * @drv_priv: data area for driver use, will always be aligned to
  *      sizeof(void *).
  */
 struct ieee80211_vif {
         enum nl80211_iftype type;
+        struct ieee80211_bss_conf bss_conf;
         /* must be last */
         u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
 };
@@ -542,14 +629,12 @@ struct ieee80211_if_init_conf {
  * enum ieee80211_if_conf_change - interface config change flags
  *
  * @IEEE80211_IFCC_BSSID: The BSSID changed.
- * @IEEE80211_IFCC_SSID: The SSID changed.
  * @IEEE80211_IFCC_BEACON: The beacon for this interface changed
  *      (currently AP and MESH only), use ieee80211_beacon_get().
  */
 enum ieee80211_if_conf_change {
         IEEE80211_IFCC_BSSID    = BIT(0),
-        IEEE80211_IFCC_SSID     = BIT(1),
-        IEEE80211_IFCC_BEACON   = BIT(2),
+        IEEE80211_IFCC_BEACON   = BIT(1),
 };
 
 /**
@@ -557,11 +642,6 @@ enum ieee80211_if_conf_change {
  *
  * @changed: parameters that have changed, see &enum ieee80211_if_conf_change.
  * @bssid: BSSID of the network we are associated to/creating.
- * @ssid: used (together with @ssid_len) by drivers for hardware that
- *      generate beacons independently. The pointer is valid only during the
- *      config_interface() call, so copy the value somewhere if you need
- *      it.
- * @ssid_len: length of the @ssid field.
  *
  * This structure is passed to the config_interface() callback of
  * &struct ieee80211_hw.
@@ -569,8 +649,6 @@ enum ieee80211_if_conf_change {
 struct ieee80211_if_conf {
         u32 changed;
         u8 *bssid;
-        u8 *ssid;
-        size_t ssid_len;
 };
 
 /**
@@ -677,7 +755,7 @@ enum set_key_cmd {
  * @addr: MAC address
  * @aid: AID we assigned to the station if we're an AP
  * @supp_rates: Bitmap of supported rates (per band)
- * @ht_info: HT capabilities of this STA
+ * @ht_cap: HT capabilities of this STA; restricted to our own TX capabilities
  * @drv_priv: data area for driver use, will always be aligned to
  *      sizeof(void *), size is determined in hw information.
  */
@@ -685,7 +763,7 @@ struct ieee80211_sta {
         u64 supp_rates[IEEE80211_NUM_BANDS];
         u8 addr[ETH_ALEN];
         u16 aid;
-        struct ieee80211_ht_info ht_info;
+        struct ieee80211_sta_ht_cap ht_cap;
 
         /* must be last */
         u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
@@ -695,13 +773,17 @@ struct ieee80211_sta {
  * enum sta_notify_cmd - sta notify command
  *
  * Used with the sta_notify() callback in &struct ieee80211_ops, this
- * indicates addition and removal of a station to station table.
+ * indicates addition and removal of a station to station table,
+ * or if a associated station made a power state transition.
  *
  * @STA_NOTIFY_ADD: a station was added to the station table
  * @STA_NOTIFY_REMOVE: a station being removed from the station table
+ * @STA_NOTIFY_SLEEP: a station is now sleeping
+ * @STA_NOTIFY_AWAKE: a sleeping station woke up
  */
 enum sta_notify_cmd {
-        STA_NOTIFY_ADD, STA_NOTIFY_REMOVE
+        STA_NOTIFY_ADD, STA_NOTIFY_REMOVE,
+        STA_NOTIFY_SLEEP, STA_NOTIFY_AWAKE,
 };
 
 /**
@@ -769,6 +851,14 @@ enum ieee80211_tkip_key_type {
  * @IEEE80211_HW_SPECTRUM_MGMT:
  *      Hardware supports spectrum management defined in 802.11h
  *      Measurement, Channel Switch, Quieting, TPC
+ *
+ * @IEEE80211_HW_AMPDU_AGGREGATION:
+ *      Hardware supports 11n A-MPDU aggregation.
+ *
+ * @IEEE80211_HW_NO_STACK_DYNAMIC_PS:
+ *      Hardware which has dynamic power save support, meaning
+ *      that power save is enabled in idle periods, and don't need support
+ *      from stack.
  */
 enum ieee80211_hw_flags {
         IEEE80211_HW_RX_INCLUDES_FCS                    = 1<<1,
@@ -780,6 +870,8 @@ enum ieee80211_hw_flags {
         IEEE80211_HW_SIGNAL_DBM                         = 1<<7,
         IEEE80211_HW_NOISE_DBM                          = 1<<8,
         IEEE80211_HW_SPECTRUM_MGMT                      = 1<<9,
+        IEEE80211_HW_AMPDU_AGGREGATION                  = 1<<10,
+        IEEE80211_HW_NO_STACK_DYNAMIC_PS                = 1<<11,
 };
 
 /**
@@ -838,8 +930,8 @@ enum ieee80211_hw_flags {
  * @sta_data_size: size (in bytes) of the drv_priv data area
  *      within &struct ieee80211_sta.
  *
- * @max_altrates: maximum number of alternate rate retry stages
- * @max_altrate_tries: maximum number of tries for each stage
+ * @max_rates: maximum number of alternate rate retry stages
+ * @max_rate_tries: maximum number of tries for each stage
  */
 struct ieee80211_hw {
         struct ieee80211_conf conf;
@@ -856,12 +948,10 @@ struct ieee80211_hw {
         u16 ampdu_queues;
         u16 max_listen_interval;
         s8 max_signal;
-        u8 max_altrates;
-        u8 max_altrate_tries;
+        u8 max_rates;
+        u8 max_rate_tries;
 };
 
-struct ieee80211_hw *wiphy_to_hw(struct wiphy *wiphy);
-
 /**
  * SET_IEEE80211_DEV - set device for 802.11 hardware
  *
@@ -874,7 +964,7 @@ static inline void SET_IEEE80211_DEV(struct ieee80211_hw *hw, struct device *dev
 }
 
 /**
- * SET_IEEE80211_PERM_ADDR - set the permanenet MAC address for 802.11 hardware
+ * SET_IEEE80211_PERM_ADDR - set the permanent MAC address for 802.11 hardware
  *
  * @hw: the &struct ieee80211_hw to set the MAC address for
  * @addr: the address to set
@@ -898,9 +988,9 @@ static inline struct ieee80211_rate *
 ieee80211_get_tx_rate(const struct ieee80211_hw *hw,
                       const struct ieee80211_tx_info *c)
 {
-        if (WARN_ON(c->tx_rate_idx < 0))
+        if (WARN_ON(c->control.rates[0].idx < 0))
                 return NULL;
-        return &hw->wiphy->bands[c->band]->bitrates[c->tx_rate_idx];
+        return &hw->wiphy->bands[c->band]->bitrates[c->control.rates[0].idx];
 }
 
 static inline struct ieee80211_rate *
@@ -916,9 +1006,9 @@ static inline struct ieee80211_rate *
 ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
                              const struct ieee80211_tx_info *c, int idx)
 {
-        if (c->control.retries[idx].rate_idx < 0)
+        if (c->control.rates[idx + 1].idx < 0)
                 return NULL;
-        return &hw->wiphy->bands[c->band]->bitrates[c->control.retries[idx].rate_idx];
+        return &hw->wiphy->bands[c->band]->bitrates[c->control.rates[idx + 1].idx];
 }
 
 /**
@@ -967,7 +1057,7 @@ ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
  * This happens everytime the iv16 wraps around (every 65536 packets). The
  * set_key() call will happen only once for each key (unless the AP did
  * rekeying), it will not include a valid phase 1 key. The valid phase 1 key is
- * provided by udpate_tkip_key only. The trigger that makes mac80211 call this
+ * provided by update_tkip_key only. The trigger that makes mac80211 call this
  * handler is software decryption with wrap around of iv16.
  */
 
@@ -1060,12 +1150,14 @@ enum ieee80211_filter_flags {
  * @IEEE80211_AMPDU_RX_STOP: stop Rx aggregation
  * @IEEE80211_AMPDU_TX_START: start Tx aggregation
  * @IEEE80211_AMPDU_TX_STOP: stop Tx aggregation
+ * @IEEE80211_AMPDU_TX_RESUME: resume TX aggregation
  */
 enum ieee80211_ampdu_mlme_action {
         IEEE80211_AMPDU_RX_START,
         IEEE80211_AMPDU_RX_STOP,
         IEEE80211_AMPDU_TX_START,
         IEEE80211_AMPDU_TX_STOP,
+        IEEE80211_AMPDU_TX_RESUME,
 };
 
 /**
@@ -1101,7 +1193,7 @@ enum ieee80211_ampdu_mlme_action {
  *      Must be implemented.
  *
  * @add_interface: Called when a netdevice attached to the hardware is
- *      enabled. Because it is not called for monitor mode devices, @open
+ *      enabled. Because it is not called for monitor mode devices, @start
  *      and @stop must be implemented.
  *      The driver should perform any initialization it needs before
  *      the device can be enabled. The initial configuration for the
@@ -1163,14 +1255,9 @@ enum ieee80211_ampdu_mlme_action {
  *
  * @set_rts_threshold: Configuration of RTS threshold (if device needs it)
  *
- * @set_frag_threshold: Configuration of fragmentation threshold. Assign this if
- *      the device does fragmentation by itself; if this method is assigned then
- *      the stack will not do fragmentation.
- *
- * @set_retry_limit: Configuration of retry limits (if device needs it)
- *
- * @sta_notify: Notifies low level driver about addition or removal
- *      of assocaited station or AP.
+ * @sta_notify: Notifies low level driver about addition, removal or power
+ *      state transition of an associated station, AP,  IBSS/WDS/mesh peer etc.
+ *      Must be atomic.
  *
  * @conf_tx: Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
  *      bursting) for a hardware TX queue.
@@ -1194,8 +1281,6 @@ enum ieee80211_ampdu_mlme_action {
  *      This is needed only for IBSS mode and the result of this function is
  *      used to determine whether to reply to Probe Requests.
  *
- * @conf_ht: Configures low level driver with 802.11n HT data. Must be atomic.
- *
  * @ampdu_action: Perform a certain A-MPDU action
  *      The RA/TID combination determines the destination and TID we want
  *      the ampdu action to be performed for. The action is defined through
@@ -1211,7 +1296,7 @@ struct ieee80211_ops {
                              struct ieee80211_if_init_conf *conf);
         void (*remove_interface)(struct ieee80211_hw *hw,
                                  struct ieee80211_if_init_conf *conf);
-        int (*config)(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
+        int (*config)(struct ieee80211_hw *hw, u32 changed);
         int (*config_interface)(struct ieee80211_hw *hw,
                                 struct ieee80211_vif *vif,
                                 struct ieee80211_if_conf *conf);
@@ -1237,9 +1322,6 @@ struct ieee80211_ops {
         void (*get_tkip_seq)(struct ieee80211_hw *hw, u8 hw_key_idx,
                              u32 *iv32, u16 *iv16);
         int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
-        int (*set_frag_threshold)(struct ieee80211_hw *hw, u32 value);
-        int (*set_retry_limit)(struct ieee80211_hw *hw,
-                               u32 short_retry, u32 long_retr);
         void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                         enum sta_notify_cmd, struct ieee80211_sta *sta);
         int (*conf_tx)(struct ieee80211_hw *hw, u16 queue,
@@ -1472,7 +1554,7 @@ void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
  * the next beacon frame from the 802.11 code. The low-level is responsible
  * for calling this function before beacon data is needed (e.g., based on
  * hardware interrupt). Returned skb is used only once and low-level driver
- * is responsible of freeing it.
+ * is responsible for freeing it.
  */
 struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
                                      struct ieee80211_vif *vif);
@@ -1803,24 +1885,38 @@ struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_hw *hw,
 
 
 /* Rate control API */
+
 /**
- * struct rate_selection - rate information for/from rate control algorithms
- *
- * @rate_idx: selected transmission rate index
- * @nonerp_idx: Non-ERP rate to use instead if ERP cannot be used
- * @probe_idx: rate for probing (or -1)
- * @max_rate_idx: maximum rate index that can be used, this is
- *      input to the algorithm and will be enforced
- */
-struct rate_selection {
-        s8 rate_idx, nonerp_idx, probe_idx, max_rate_idx;
+ * struct ieee80211_tx_rate_control - rate control information for/from RC algo
+ *
+ * @hw: The hardware the algorithm is invoked for.
+ * @sband: The band this frame is being transmitted on.
+ * @bss_conf: the current BSS configuration
+ * @reported_rate: The rate control algorithm can fill this in to indicate
+ *      which rate should be reported to userspace as the current rate and
+ *      used for rate calculations in the mesh network.
+ * @rts: whether RTS will be used for this frame because it is longer than the
+ *      RTS threshold
+ * @short_preamble: whether mac80211 will request short-preamble transmission
+ *      if the selected rate supports it
+ * @max_rate_idx: user-requested maximum rate (not MCS for now)
+ * @skb: the skb that will be transmitted, the control information in it needs
+ *      to be filled in
+ */
+struct ieee80211_tx_rate_control {
+        struct ieee80211_hw *hw;
+        struct ieee80211_supported_band *sband;
+        struct ieee80211_bss_conf *bss_conf;
+        struct sk_buff *skb;
+        struct ieee80211_tx_rate reported_rate;
+        bool rts, short_preamble;
+        u8 max_rate_idx;
 };
 
 struct rate_control_ops {
         struct module *module;
         const char *name;
         void *(*alloc)(struct ieee80211_hw *hw, struct dentry *debugfsdir);
-        void (*clear)(void *priv);
         void (*free)(void *priv);
 
         void *(*alloc_sta)(void *priv, struct ieee80211_sta *sta, gfp_t gfp);
@@ -1832,10 +1928,8 @@ struct rate_control_ops {
         void (*tx_status)(void *priv, struct ieee80211_supported_band *sband,
                           struct ieee80211_sta *sta, void *priv_sta,
                           struct sk_buff *skb);
-        void (*get_rate)(void *priv, struct ieee80211_supported_band *sband,
-                         struct ieee80211_sta *sta, void *priv_sta,
-                         struct sk_buff *skb,
-                         struct rate_selection *sel);
+        void (*get_rate)(void *priv, struct ieee80211_sta *sta, void *priv_sta,
+                         struct ieee80211_tx_rate_control *txrc);
 
         void (*add_sta_debugfs)(void *priv, void *priv_sta,
                                 struct dentry *dir);
diff --git a/include/net/ndisc.h b/include/net/ndisc.h
index 11dd0137c6a5..ce532f2222ce 100644
--- a/include/net/ndisc.h
+++ b/include/net/ndisc.h
@@ -108,6 +108,20 @@ extern void			ndisc_send_redirect(struct sk_buff *skb,
 
 extern int                      ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir);
 
+extern struct sk_buff           *ndisc_build_skb(struct net_device *dev,
+                                                 const struct in6_addr *daddr,
+                                                 const struct in6_addr *saddr,
+                                                 struct icmp6hdr *icmp6h,
+                                                 const struct in6_addr *target,
+                                                 int llinfo);
+
+extern void                     ndisc_send_skb(struct sk_buff *skb,
+                                               struct net_device *dev,
+                                               struct neighbour *neigh,
+                                               const struct in6_addr *daddr,
+                                               const struct in6_addr *saddr,
+                                               struct icmp6hdr *icmp6h);
+
 
 
 /*
diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index aa4b708654a4..d8d790e56d3d 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -180,9 +180,6 @@ struct neigh_table
         __u32                   hash_rnd;
         unsigned int            hash_chain_gc;
         struct pneigh_entry     **phash_buckets;
-#ifdef CONFIG_PROC_FS
-        struct proc_dir_entry   *pde;
-#endif
 };
 
 /* flags for neigh_update() */
@@ -223,11 +220,7 @@ extern void			neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *p
 static inline
 struct net                      *neigh_parms_net(const struct neigh_parms *parms)
 {
-#ifdef CONFIG_NET_NS
-        return parms->net;
-#else
-        return &init_net;
-#endif
+        return read_pnet(&parms->net);
 }
 
 extern unsigned long            neigh_rand_reach_time(unsigned long base);
@@ -244,11 +237,7 @@ extern int			pneigh_delete(struct neigh_table *tbl, struct net *net, const void
 static inline
 struct net                      *pneigh_net(const struct pneigh_entry *pneigh)
 {
-#ifdef CONFIG_NET_NS
-        return pneigh->net;
-#else
-        return &init_net;
-#endif
+        return read_pnet(&pneigh->net);
 }
 
 extern void neigh_app_ns(struct neighbour *n);
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 700c53a3c6fa..6fc13d905c5f 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -19,6 +19,7 @@
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 #include <net/netns/conntrack.h>
 #endif
+#include <net/netns/xfrm.h>
 
 struct proc_dir_entry;
 struct net_device;
@@ -74,6 +75,9 @@ struct net {
         struct netns_ct         ct;
 #endif
 #endif
+#ifdef CONFIG_XFRM
+        struct netns_xfrm       xfrm;
+#endif
         struct net_generic      *gen;
 };
 
@@ -192,6 +196,24 @@ static inline void release_net(struct net *net)
 }
 #endif
 
+#ifdef CONFIG_NET_NS
+
+static inline void write_pnet(struct net **pnet, struct net *net)
+{
+        *pnet = net;
+}
+
+static inline struct net *read_pnet(struct net * const *pnet)
+{
+        return *pnet;
+}
+
+#else
+
+#define write_pnet(pnet, net)   do { (void)(net);} while (0)
+#define read_pnet(pnet)         (&init_net)
+
+#endif
 
 #define for_each_net(VAR)                               \
         list_for_each_entry(VAR, &net_namespace_list, list)
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index b76a8685b5b5..2e0c53641cbe 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -199,7 +199,7 @@ __nf_conntrack_find(struct net *net, const struct nf_conntrack_tuple *tuple);
 
 extern void nf_conntrack_hash_insert(struct nf_conn *ct);
 
-extern void nf_conntrack_flush(struct net *net);
+extern void nf_conntrack_flush(struct net *net, u32 pid, int report);
 
 extern bool nf_ct_get_tuplepr(const struct sk_buff *skb,
                               unsigned int nhoff, u_int16_t l3num,
@@ -298,5 +298,8 @@ do {							\
         local_bh_enable();                              \
 } while (0)
 
+#define MODULE_ALIAS_NFCT_HELPER(helper) \
+        MODULE_ALIAS("nfct-helper-" helper)
+
 #endif /* __KERNEL__ */
 #endif /* _NF_CONNTRACK_H */
diff --git a/include/net/netfilter/nf_conntrack_ecache.h b/include/net/netfilter/nf_conntrack_ecache.h
index 1285ff26a014..0ff0dc69ca4a 100644
--- a/include/net/netfilter/nf_conntrack_ecache.h
+++ b/include/net/netfilter/nf_conntrack_ecache.h
@@ -17,6 +17,13 @@ struct nf_conntrack_ecache {
         unsigned int events;
 };
 
+/* This structure is passed to event handler */
+struct nf_ct_event {
+        struct nf_conn *ct;
+        u32 pid;
+        int report;
+};
+
 extern struct atomic_notifier_head nf_conntrack_chain;
 extern int nf_conntrack_register_notifier(struct notifier_block *nb);
 extern int nf_conntrack_unregister_notifier(struct notifier_block *nb);
@@ -39,22 +46,56 @@ nf_conntrack_event_cache(enum ip_conntrack_events event, struct nf_conn *ct)
         local_bh_enable();
 }
 
-static inline void nf_conntrack_event(enum ip_conntrack_events event,
-                                      struct nf_conn *ct)
+static inline void
+nf_conntrack_event_report(enum ip_conntrack_events event,
+                          struct nf_conn *ct,
+                          u32 pid,
+                          int report)
 {
+        struct nf_ct_event item = {
+                .ct     = ct,
+                .pid    = pid,
+                .report = report
+        };
         if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct))
-                atomic_notifier_call_chain(&nf_conntrack_chain, event, ct);
+                atomic_notifier_call_chain(&nf_conntrack_chain, event, &item);
 }
 
+static inline void
+nf_conntrack_event(enum ip_conntrack_events event, struct nf_conn *ct)
+{
+        nf_conntrack_event_report(event, ct, 0, 0);
+}
+
+struct nf_exp_event {
+        struct nf_conntrack_expect *exp;
+        u32 pid;
+        int report;
+};
+
 extern struct atomic_notifier_head nf_ct_expect_chain;
 extern int nf_ct_expect_register_notifier(struct notifier_block *nb);
 extern int nf_ct_expect_unregister_notifier(struct notifier_block *nb);
 
 static inline void
+nf_ct_expect_event_report(enum ip_conntrack_expect_events event,
+                          struct nf_conntrack_expect *exp,
+                          u32 pid,
+                          int report)
+{
+        struct nf_exp_event item = {
+                .exp    = exp,
+                .pid    = pid,
+                .report = report
+        };
+        atomic_notifier_call_chain(&nf_ct_expect_chain, event, &item);
+}
+
+static inline void
 nf_ct_expect_event(enum ip_conntrack_expect_events event,
                    struct nf_conntrack_expect *exp)
 {
-        atomic_notifier_call_chain(&nf_ct_expect_chain, event, exp);
+        nf_ct_expect_event_report(event, exp, 0, 0);
 }
 
 extern int nf_conntrack_ecache_init(struct net *net);
@@ -66,9 +107,17 @@ static inline void nf_conntrack_event_cache(enum ip_conntrack_events event,
                                             struct nf_conn *ct) {}
 static inline void nf_conntrack_event(enum ip_conntrack_events event,
                                       struct nf_conn *ct) {}
+static inline void nf_conntrack_event_report(enum ip_conntrack_events event,
+                                             struct nf_conn *ct,
+                                             u32 pid,
+                                             int report) {}
 static inline void nf_ct_deliver_cached_events(const struct nf_conn *ct) {}
 static inline void nf_ct_expect_event(enum ip_conntrack_expect_events event,
                                       struct nf_conntrack_expect *exp) {}
+static inline void nf_ct_expect_event_report(enum ip_conntrack_expect_events e,
+                                             struct nf_conntrack_expect *exp,
+                                             u32 pid,
+                                             int report) {}
 static inline void nf_ct_event_cache_flush(struct net *net) {}
 
 static inline int nf_conntrack_ecache_init(struct net *net)
diff --git a/include/net/netfilter/nf_conntrack_expect.h b/include/net/netfilter/nf_conntrack_expect.h
index 37a7fc1164b0..ab17a159ac66 100644
--- a/include/net/netfilter/nf_conntrack_expect.h
+++ b/include/net/netfilter/nf_conntrack_expect.h
@@ -100,6 +100,8 @@ void nf_ct_expect_init(struct nf_conntrack_expect *, unsigned int, u_int8_t,
                        u_int8_t, const __be16 *, const __be16 *);
 void nf_ct_expect_put(struct nf_conntrack_expect *exp);
 int nf_ct_expect_related(struct nf_conntrack_expect *expect);
+int nf_ct_expect_related_report(struct nf_conntrack_expect *expect, 
+                                u32 pid, int report);
 
 #endif /*_NF_CONNTRACK_EXPECT_H*/
 
diff --git a/include/net/netfilter/nf_conntrack_helper.h b/include/net/netfilter/nf_conntrack_helper.h
index f8060ab5a083..66d65a7caa39 100644
--- a/include/net/netfilter/nf_conntrack_helper.h
+++ b/include/net/netfilter/nf_conntrack_helper.h
@@ -39,9 +39,6 @@ struct nf_conntrack_helper
 };
 
 extern struct nf_conntrack_helper *
-__nf_ct_helper_find(const struct nf_conntrack_tuple *tuple);
-
-extern struct nf_conntrack_helper *
 __nf_conntrack_helper_find_byname(const char *name);
 
 extern int nf_conntrack_helper_register(struct nf_conntrack_helper *);
@@ -49,6 +46,8 @@ extern void nf_conntrack_helper_unregister(struct nf_conntrack_helper *);
 
 extern struct nf_conn_help *nf_ct_helper_ext_add(struct nf_conn *ct, gfp_t gfp);
 
+extern int __nf_ct_try_assign_helper(struct nf_conn *ct, gfp_t flags);
+
 static inline struct nf_conn_help *nfct_help(const struct nf_conn *ct)
 {
         return nf_ct_ext_find(ct, NF_CT_EXT_HELPER);
diff --git a/include/net/netfilter/nf_conntrack_l4proto.h b/include/net/netfilter/nf_conntrack_l4proto.h
index 7f2f43c77284..debdaf75cecf 100644
--- a/include/net/netfilter/nf_conntrack_l4proto.h
+++ b/include/net/netfilter/nf_conntrack_l4proto.h
@@ -129,7 +129,7 @@ extern const struct nla_policy nf_ct_port_nla_policy[];
          && net_ratelimit())
 #endif
 #else
-#define LOG_INVALID(net, proto) 0
+static inline int LOG_INVALID(struct net *net, int proto) { return 0; }
 #endif /* CONFIG_SYSCTL */
 
 #endif /*_NF_CONNTRACK_PROTOCOL_H*/
diff --git a/include/net/netfilter/nf_conntrack_tuple.h b/include/net/netfilter/nf_conntrack_tuple.h
index a6874ba22d54..f2f6aa73dc10 100644
--- a/include/net/netfilter/nf_conntrack_tuple.h
+++ b/include/net/netfilter/nf_conntrack_tuple.h
@@ -112,20 +112,20 @@ struct nf_conntrack_tuple_mask
 static inline void nf_ct_dump_tuple_ip(const struct nf_conntrack_tuple *t)
 {
 #ifdef DEBUG
-        printk("tuple %p: %u " NIPQUAD_FMT ":%hu -> " NIPQUAD_FMT ":%hu\n",
+        printk("tuple %p: %u %pI4:%hu -> %pI4:%hu\n",
                t, t->dst.protonum,
-               NIPQUAD(t->src.u3.ip), ntohs(t->src.u.all),
-               NIPQUAD(t->dst.u3.ip), ntohs(t->dst.u.all));
+               &t->src.u3.ip, ntohs(t->src.u.all),
+               &t->dst.u3.ip, ntohs(t->dst.u.all));
 #endif
 }
 
 static inline void nf_ct_dump_tuple_ipv6(const struct nf_conntrack_tuple *t)
 {
 #ifdef DEBUG
-        printk("tuple %p: %u " NIP6_FMT " %hu -> " NIP6_FMT " %hu\n",
+        printk("tuple %p: %u %pI6 %hu -> %pI6 %hu\n",
                t, t->dst.protonum,
-               NIP6(*(struct in6_addr *)t->src.u3.all), ntohs(t->src.u.all),
-               NIP6(*(struct in6_addr *)t->dst.u3.all), ntohs(t->dst.u.all));
+               t->src.u3.all, ntohs(t->src.u.all),
+               t->dst.u3.all, ntohs(t->dst.u.all));
 #endif
 }
 
diff --git a/include/net/netfilter/nfnetlink_log.h b/include/net/netfilter/nfnetlink_log.h
new file mode 100644
index 000000000000..b0569ff0775e
--- /dev/null
+++ b/include/net/netfilter/nfnetlink_log.h
@@ -0,0 +1,14 @@
+#ifndef _KER_NFNETLINK_LOG_H
+#define _KER_NFNETLINK_LOG_H
+
+void
+nfulnl_log_packet(u_int8_t pf,
+                  unsigned int hooknum,
+                  const struct sk_buff *skb,
+                  const struct net_device *in,
+                  const struct net_device *out,
+                  const struct nf_loginfo *li_user,
+                  const char *prefix);
+
+#endif /* _KER_NFNETLINK_LOG_H */
+
diff --git a/include/net/netlink.h b/include/net/netlink.h
index 3643bbb8e585..8a6150a3f4c7 100644
--- a/include/net/netlink.h
+++ b/include/net/netlink.h
@@ -233,7 +233,7 @@ extern int		nla_parse(struct nlattr *tb[], int maxtype,
 extern struct nlattr *  nla_find(struct nlattr *head, int len, int attrtype);
 extern size_t           nla_strlcpy(char *dst, const struct nlattr *nla,
                                     size_t dstsize);
-extern int              nla_memcpy(void *dest, struct nlattr *src, int count);
+extern int              nla_memcpy(void *dest, const struct nlattr *src, int count);
 extern int              nla_memcmp(const struct nlattr *nla, const void *data,
                                    size_t size);
 extern int              nla_strcmp(const struct nlattr *nla, const char *str);
@@ -332,7 +332,7 @@ static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
  */
 static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
 {
-        return (remaining >= sizeof(struct nlmsghdr) &&
+        return (remaining >= (int) sizeof(struct nlmsghdr) &&
                 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
                 nlh->nlmsg_len <= remaining);
 }
@@ -741,7 +741,7 @@ static inline struct nlattr *nla_find_nested(struct nlattr *nla, int attrtype)
  * See nla_parse()
  */
 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
-                                   struct nlattr *nla,
+                                   const struct nlattr *nla,
                                    const struct nla_policy *policy)
 {
         return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
@@ -875,7 +875,7 @@ static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
  * nla_get_u32 - return payload of u32 attribute
  * @nla: u32 netlink attribute
  */
-static inline u32 nla_get_u32(struct nlattr *nla)
+static inline u32 nla_get_u32(const struct nlattr *nla)
 {
         return *(u32 *) nla_data(nla);
 }
@@ -884,7 +884,7 @@ static inline u32 nla_get_u32(struct nlattr *nla)
  * nla_get_be32 - return payload of __be32 attribute
  * @nla: __be32 netlink attribute
  */
-static inline __be32 nla_get_be32(struct nlattr *nla)
+static inline __be32 nla_get_be32(const struct nlattr *nla)
 {
         return *(__be32 *) nla_data(nla);
 }
@@ -893,7 +893,7 @@ static inline __be32 nla_get_be32(struct nlattr *nla)
  * nla_get_u16 - return payload of u16 attribute
  * @nla: u16 netlink attribute
  */
-static inline u16 nla_get_u16(struct nlattr *nla)
+static inline u16 nla_get_u16(const struct nlattr *nla)
 {
         return *(u16 *) nla_data(nla);
 }
@@ -902,7 +902,7 @@ static inline u16 nla_get_u16(struct nlattr *nla)
  * nla_get_be16 - return payload of __be16 attribute
  * @nla: __be16 netlink attribute
  */
-static inline __be16 nla_get_be16(struct nlattr *nla)
+static inline __be16 nla_get_be16(const struct nlattr *nla)
 {
         return *(__be16 *) nla_data(nla);
 }
@@ -911,7 +911,7 @@ static inline __be16 nla_get_be16(struct nlattr *nla)
  * nla_get_le16 - return payload of __le16 attribute
  * @nla: __le16 netlink attribute
  */
-static inline __le16 nla_get_le16(struct nlattr *nla)
+static inline __le16 nla_get_le16(const struct nlattr *nla)
 {
         return *(__le16 *) nla_data(nla);
 }
@@ -920,7 +920,7 @@ static inline __le16 nla_get_le16(struct nlattr *nla)
  * nla_get_u8 - return payload of u8 attribute
  * @nla: u8 netlink attribute
  */
-static inline u8 nla_get_u8(struct nlattr *nla)
+static inline u8 nla_get_u8(const struct nlattr *nla)
 {
         return *(u8 *) nla_data(nla);
 }
@@ -929,7 +929,7 @@ static inline u8 nla_get_u8(struct nlattr *nla)
  * nla_get_u64 - return payload of u64 attribute
  * @nla: u64 netlink attribute
  */
-static inline u64 nla_get_u64(struct nlattr *nla)
+static inline u64 nla_get_u64(const struct nlattr *nla)
 {
         u64 tmp;
 
@@ -942,7 +942,7 @@ static inline u64 nla_get_u64(struct nlattr *nla)
  * nla_get_flag - return payload of flag attribute
  * @nla: flag netlink attribute
  */
-static inline int nla_get_flag(struct nlattr *nla)
+static inline int nla_get_flag(const struct nlattr *nla)
 {
         return !!nla;
 }
@@ -953,7 +953,7 @@ static inline int nla_get_flag(struct nlattr *nla)
  *
  * Returns the number of milliseconds in jiffies.
  */
-static inline unsigned long nla_get_msecs(struct nlattr *nla)
+static inline unsigned long nla_get_msecs(const struct nlattr *nla)
 {
         u64 msecs = nla_get_u64(nla);
 
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index ece1c926b5d1..977f482d97a9 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -49,6 +49,8 @@ struct netns_ipv4 {
         int sysctl_icmp_ratelimit;
         int sysctl_icmp_ratemask;
         int sysctl_icmp_errors_use_inbound_ifaddr;
+        int sysctl_rt_cache_rebuild_count;
+        int current_rt_cache_rebuild_count;
 
         struct timer_list rt_secret_timer;
         atomic_t rt_genid;
diff --git a/include/net/netns/ipv6.h b/include/net/netns/ipv6.h
index 2932721180c0..afab4e4cbac7 100644
--- a/include/net/netns/ipv6.h
+++ b/include/net/netns/ipv6.h
@@ -55,5 +55,17 @@ struct netns_ipv6 {
         struct sock             *ndisc_sk;
         struct sock             *tcp_sk;
         struct sock             *igmp_sk;
+#ifdef CONFIG_IPV6_MROUTE
+        struct sock             *mroute6_sk;
+        struct mfc6_cache       **mfc6_cache_array;
+        struct mif_device       *vif6_table;
+        int                     maxvif;
+        atomic_t                cache_resolve_queue_len;
+        int                     mroute_do_assert;
+        int                     mroute_do_pim;
+#ifdef CONFIG_IPV6_PIMSM_V2
+        int                     mroute_reg_vif_num;
+#endif
+#endif
 };
 #endif
diff --git a/include/net/netns/mib.h b/include/net/netns/mib.h
index 10cb7c336de5..0b44112e2366 100644
--- a/include/net/netns/mib.h
+++ b/include/net/netns/mib.h
@@ -20,6 +20,9 @@ struct netns_mib {
         DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics);
         DEFINE_SNMP_STAT(struct icmpv6msg_mib, icmpv6msg_statistics);
 #endif
+#ifdef CONFIG_XFRM_STATISTICS
+        DEFINE_SNMP_STAT(struct linux_xfrm_mib, xfrm_statistics);
+#endif
 };
 
 #endif
diff --git a/include/net/netns/x_tables.h b/include/net/netns/x_tables.h
index b8093971ccb4..9554a644a8f8 100644
--- a/include/net/netns/x_tables.h
+++ b/include/net/netns/x_tables.h
@@ -4,7 +4,12 @@
 #include <linux/list.h>
 #include <linux/netfilter.h>
 
+struct ebt_table;
+
 struct netns_xt {
         struct list_head tables[NFPROTO_NUMPROTO];
+        struct ebt_table *broute_table;
+        struct ebt_table *frame_filter;
+        struct ebt_table *frame_nat;
 };
 #endif
diff --git a/include/net/netns/xfrm.h b/include/net/netns/xfrm.h
new file mode 100644
index 000000000000..1ba912749caa
--- /dev/null
+++ b/include/net/netns/xfrm.h
@@ -0,0 +1,56 @@
+#ifndef __NETNS_XFRM_H
+#define __NETNS_XFRM_H
+
+#include <linux/list.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
+#include <linux/xfrm.h>
+
+struct ctl_table_header;
+
+struct xfrm_policy_hash {
+        struct hlist_head       *table;
+        unsigned int            hmask;
+};
+
+struct netns_xfrm {
+        struct list_head        state_all;
+        /*
+         * Hash table to find appropriate SA towards given target (endpoint of
+         * tunnel or destination of transport mode) allowed by selector.
+         *
+         * Main use is finding SA after policy selected tunnel or transport
+         * mode. Also, it can be used by ah/esp icmp error handler to find
+         * offending SA.
+         */
+        struct hlist_head       *state_bydst;
+        struct hlist_head       *state_bysrc;
+        struct hlist_head       *state_byspi;
+        unsigned int            state_hmask;
+        unsigned int            state_num;
+        struct work_struct      state_hash_work;
+        struct hlist_head       state_gc_list;
+        struct work_struct      state_gc_work;
+
+        wait_queue_head_t       km_waitq;
+
+        struct list_head        policy_all;
+        struct hlist_head       *policy_byidx;
+        unsigned int            policy_idx_hmask;
+        struct hlist_head       policy_inexact[XFRM_POLICY_MAX * 2];
+        struct xfrm_policy_hash policy_bydst[XFRM_POLICY_MAX * 2];
+        unsigned int            policy_count[XFRM_POLICY_MAX * 2];
+        struct work_struct      policy_hash_work;
+
+        struct sock             *nlsk;
+
+        u32                     sysctl_aevent_etime;
+        u32                     sysctl_aevent_rseqth;
+        int                     sysctl_larval_drop;
+        u32                     sysctl_acq_expires;
+#ifdef CONFIG_SYSCTL
+        struct ctl_table_header *sysctl_hdr;
+#endif
+};
+
+#endif
diff --git a/include/net/phonet/pep.h b/include/net/phonet/pep.h
index fcd793030e4d..4c61cdce4e5f 100644
--- a/include/net/phonet/pep.h
+++ b/include/net/phonet/pep.h
@@ -35,12 +35,12 @@ struct pep_sock {
         struct sock             *listener;
         struct sk_buff_head     ctrlreq_queue;
 #define PNPIPE_CTRLREQ_MAX      10
+        atomic_t                tx_credits;
         int                     ifindex;
         u16                     peer_type;      /* peer type/subtype */
         u8                      pipe_handle;
 
         u8                      rx_credits;
-        u8                      tx_credits;
         u8                      rx_fc;  /* RX flow control */
         u8                      tx_fc;  /* TX flow control */
         u8                      init_enable;    /* auto-enable at creation */
diff --git a/include/net/phonet/phonet.h b/include/net/phonet/phonet.h
index c6a245184460..057b0a8a2885 100644
--- a/include/net/phonet/phonet.h
+++ b/include/net/phonet/phonet.h
@@ -46,7 +46,7 @@ static inline struct pn_sock *pn_sk(struct sock *sk)
 
 extern const struct proto_ops phonet_dgram_ops;
 
-struct sock *pn_find_sock_by_sa(const struct sockaddr_pn *sa);
+struct sock *pn_find_sock_by_sa(struct net *net, const struct sockaddr_pn *sa);
 void phonet_get_local_port_range(int *min, int *max);
 void pn_sock_hash(struct sock *sk);
 void pn_sock_unhash(struct sock *sk);
diff --git a/include/net/phonet/pn_dev.h b/include/net/phonet/pn_dev.h
index bbd2a836e04c..aa1c59a1d33f 100644
--- a/include/net/phonet/pn_dev.h
+++ b/include/net/phonet/pn_dev.h
@@ -43,7 +43,7 @@ struct net_device *phonet_device_get(struct net *net);
 int phonet_address_add(struct net_device *dev, u8 addr);
 int phonet_address_del(struct net_device *dev, u8 addr);
 u8 phonet_address_get(struct net_device *dev, u8 addr);
-int phonet_address_lookup(u8 addr);
+int phonet_address_lookup(struct net *net, u8 addr);
 
 #define PN_NO_ADDR      0xff
 
diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
index aa9e282db485..d1ca31444644 100644
--- a/include/net/pkt_cls.h
+++ b/include/net/pkt_cls.h
@@ -246,7 +246,7 @@ struct tcf_ematch_ops
 };
 
 extern int tcf_em_register(struct tcf_ematch_ops *);
-extern int tcf_em_unregister(struct tcf_ematch_ops *);
+extern void tcf_em_unregister(struct tcf_ematch_ops *);
 extern int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
                                 struct tcf_ematch_tree *);
 extern void tcf_em_tree_destroy(struct tcf_proto *, struct tcf_ematch_tree *);
diff --git a/include/net/protocol.h b/include/net/protocol.h
index 8d024d7cb741..cb2965aa1b62 100644
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
@@ -39,6 +39,9 @@ struct net_protocol {
         int                     (*gso_send_check)(struct sk_buff *skb);
         struct sk_buff         *(*gso_segment)(struct sk_buff *skb,
                                                int features);
+        struct sk_buff        **(*gro_receive)(struct sk_buff **head,
+                                               struct sk_buff *skb);
+        int                     (*gro_complete)(struct sk_buff *skb);
         unsigned int            no_policy:1,
                                 netns_ok:1;
 };
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 3fe49d808957..f8c47429044a 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -53,7 +53,6 @@ struct Qdisc
         atomic_t                refcnt;
         unsigned long           state;
         struct sk_buff          *gso_skb;
-        struct sk_buff_head     requeue;
         struct sk_buff_head     q;
         struct netdev_queue     *dev_queue;
         struct Qdisc            *next_sched;
@@ -111,7 +110,7 @@ struct Qdisc_ops
 
         int                     (*enqueue)(struct sk_buff *, struct Qdisc *);
         struct sk_buff *        (*dequeue)(struct Qdisc *);
-        int                     (*requeue)(struct sk_buff *, struct Qdisc *);
+        struct sk_buff *        (*peek)(struct Qdisc *);
         unsigned int            (*drop)(struct Qdisc *);
 
         int                     (*init)(struct Qdisc *, struct nlattr *arg);
@@ -432,19 +431,38 @@ static inline struct sk_buff *qdisc_dequeue_tail(struct Qdisc *sch)
         return __qdisc_dequeue_tail(sch, &sch->q);
 }
 
-static inline int __qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch,
-                                  struct sk_buff_head *list)
+static inline struct sk_buff *qdisc_peek_head(struct Qdisc *sch)
 {
-        __skb_queue_head(list, skb);
-        sch->qstats.backlog += qdisc_pkt_len(skb);
-        sch->qstats.requeues++;
+        return skb_peek(&sch->q);
+}
 
-        return NET_XMIT_SUCCESS;
+/* generic pseudo peek method for non-work-conserving qdisc */
+static inline struct sk_buff *qdisc_peek_dequeued(struct Qdisc *sch)
+{
+        /* we can reuse ->gso_skb because peek isn't called for root qdiscs */
+        if (!sch->gso_skb) {
+                sch->gso_skb = sch->dequeue(sch);
+                if (sch->gso_skb)
+                        /* it's still part of the queue */
+                        sch->q.qlen++;
+        }
+
+        return sch->gso_skb;
 }
 
-static inline int qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch)
+/* use instead of qdisc->dequeue() for all qdiscs queried with ->peek() */
+static inline struct sk_buff *qdisc_dequeue_peeked(struct Qdisc *sch)
 {
-        return __qdisc_requeue(skb, sch, &sch->q);
+        struct sk_buff *skb = sch->gso_skb;
+
+        if (skb) {
+                sch->gso_skb = NULL;
+                sch->q.qlen--;
+        } else {
+                skb = sch->dequeue(sch);
+        }
+
+        return skb;
 }
 
 static inline void __qdisc_reset_queue(struct Qdisc *sch,
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index ed71b110edf7..bbb7742195b0 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -138,6 +138,7 @@ void sctp_write_space(struct sock *sk);
 unsigned int sctp_poll(struct file *file, struct socket *sock,
                 poll_table *wait);
 void sctp_sock_rfree(struct sk_buff *skb);
+extern struct percpu_counter sctp_sockets_allocated;
 
 /*
  * sctp/primitive.c
@@ -285,15 +286,15 @@ extern int sctp_debug_flag;
         if (sctp_debug_flag) { \
                 if (saddr->sa.sa_family == AF_INET6) { \
                         printk(KERN_DEBUG \
-                               lead NIP6_FMT trail, \
+                               lead "%pI6" trail, \
                                leadparm, \
-                               NIP6(saddr->v6.sin6_addr), \
+                               &saddr->v6.sin6_addr, \
                                otherparms); \
                 } else { \
                         printk(KERN_DEBUG \
-                               lead NIPQUAD_FMT trail, \
+                               lead "%pI4" trail, \
                                leadparm, \
-                               NIPQUAD(saddr->v4.sin_addr.s_addr), \
+                               &saddr->v4.sin_addr.s_addr, \
                                otherparms); \
                 } \
         }
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index f205b10f0ab9..b259fc5798fb 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -118,6 +118,8 @@ enum sctp_optname {
 #define SCTP_PEER_AUTH_CHUNKS SCTP_PEER_AUTH_CHUNKS
         SCTP_LOCAL_AUTH_CHUNKS,         /* Read only */
 #define SCTP_LOCAL_AUTH_CHUNKS SCTP_LOCAL_AUTH_CHUNKS
+        SCTP_GET_ASSOC_NUMBER,          /* Read only */
+#define SCTP_GET_ASSOC_NUMBER SCTP_GET_ASSOC_NUMBER
 
 
         /* Internal Socket Options. Some of the sctp library functions are 
diff --git a/include/net/sock.h b/include/net/sock.h
index 2f47107f6d0f..5a3a151bd730 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -42,6 +42,7 @@
 
 #include <linux/kernel.h>
 #include <linux/list.h>
+#include <linux/list_nulls.h>
 #include <linux/timer.h>
 #include <linux/cache.h>
 #include <linux/module.h>
@@ -52,6 +53,7 @@
 #include <linux/security.h>
 
 #include <linux/filter.h>
+#include <linux/rculist_nulls.h>
 
 #include <asm/atomic.h>
 #include <net/dst.h>
@@ -106,6 +108,7 @@ struct net;
  *      @skc_reuse: %SO_REUSEADDR setting
  *      @skc_bound_dev_if: bound device index if != 0
  *      @skc_node: main hash linkage for various protocol lookup tables
+ *      @skc_nulls_node: main hash linkage for UDP/UDP-Lite protocol
  *      @skc_bind_node: bind hash linkage for various protocol lookup tables
  *      @skc_refcnt: reference count
  *      @skc_hash: hash value used with various protocol lookup tables
@@ -120,7 +123,10 @@ struct sock_common {
         volatile unsigned char  skc_state;
         unsigned char           skc_reuse;
         int                     skc_bound_dev_if;
-        struct hlist_node       skc_node;
+        union {
+                struct hlist_node       skc_node;
+                struct hlist_nulls_node skc_nulls_node;
+        };
         struct hlist_node       skc_bind_node;
         atomic_t                skc_refcnt;
         unsigned int            skc_hash;
@@ -206,6 +212,7 @@ struct sock {
 #define sk_reuse                __sk_common.skc_reuse
 #define sk_bound_dev_if         __sk_common.skc_bound_dev_if
 #define sk_node                 __sk_common.skc_node
+#define sk_nulls_node           __sk_common.skc_nulls_node
 #define sk_bind_node            __sk_common.skc_bind_node
 #define sk_refcnt               __sk_common.skc_refcnt
 #define sk_hash                 __sk_common.skc_hash
@@ -229,7 +236,9 @@ struct sock {
         } sk_backlog;
         wait_queue_head_t       *sk_sleep;
         struct dst_entry        *sk_dst_cache;
+#ifdef CONFIG_XFRM
         struct xfrm_policy      *sk_policy[2];
+#endif
         rwlock_t                sk_dst_lock;
         atomic_t                sk_rmem_alloc;
         atomic_t                sk_wmem_alloc;
@@ -237,7 +246,9 @@ struct sock {
         int                     sk_sndbuf;
         struct sk_buff_head     sk_receive_queue;
         struct sk_buff_head     sk_write_queue;
+#ifdef CONFIG_NET_DMA
         struct sk_buff_head     sk_async_wait_queue;
+#endif
         int                     sk_wmem_queued;
         int                     sk_forward_alloc;
         gfp_t                   sk_allocation;
@@ -269,7 +280,9 @@ struct sock {
         struct sk_buff          *sk_send_head;
         __u32                   sk_sndmsg_off;
         int                     sk_write_pending;
+#ifdef CONFIG_SECURITY
         void                    *sk_security;
+#endif
         __u32                   sk_mark;
         /* XXX 4 bytes hole on 64 bit */
         void                    (*sk_state_change)(struct sock *sk);
@@ -294,12 +307,30 @@ static inline struct sock *sk_head(const struct hlist_head *head)
         return hlist_empty(head) ? NULL : __sk_head(head);
 }
 
+static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
+{
+        return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
+}
+
+static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
+{
+        return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
+}
+
 static inline struct sock *sk_next(const struct sock *sk)
 {
         return sk->sk_node.next ?
                 hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
 }
 
+static inline struct sock *sk_nulls_next(const struct sock *sk)
+{
+        return (!is_a_nulls(sk->sk_nulls_node.next)) ?
+                hlist_nulls_entry(sk->sk_nulls_node.next,
+                                  struct sock, sk_nulls_node) :
+                NULL;
+}
+
 static inline int sk_unhashed(const struct sock *sk)
 {
         return hlist_unhashed(&sk->sk_node);
@@ -315,6 +346,11 @@ static __inline__ void sk_node_init(struct hlist_node *node)
         node->pprev = NULL;
 }
 
+static __inline__ void sk_nulls_node_init(struct hlist_nulls_node *node)
+{
+        node->pprev = NULL;
+}
+
 static __inline__ void __sk_del_node(struct sock *sk)
 {
         __hlist_del(&sk->sk_node);
@@ -361,6 +397,27 @@ static __inline__ int sk_del_node_init(struct sock *sk)
         return rc;
 }
 
+static __inline__ int __sk_nulls_del_node_init_rcu(struct sock *sk)
+{
+        if (sk_hashed(sk)) {
+                hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
+                return 1;
+        }
+        return 0;
+}
+
+static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
+{
+        int rc = __sk_nulls_del_node_init_rcu(sk);
+
+        if (rc) {
+                /* paranoid for a while -acme */
+                WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
+                __sock_put(sk);
+        }
+        return rc;
+}
+
 static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
 {
         hlist_add_head(&sk->sk_node, list);
@@ -372,6 +429,17 @@ static __inline__ void sk_add_node(struct sock *sk, struct hlist_head *list)
         __sk_add_node(sk, list);
 }
 
+static __inline__ void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
+{
+        hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
+}
+
+static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
+{
+        sock_hold(sk);
+        __sk_nulls_add_node_rcu(sk, list);
+}
+
 static __inline__ void __sk_del_bind_node(struct sock *sk)
 {
         __hlist_del(&sk->sk_bind_node);
@@ -385,9 +453,16 @@ static __inline__ void sk_add_bind_node(struct sock *sk,
 
 #define sk_for_each(__sk, node, list) \
         hlist_for_each_entry(__sk, node, list, sk_node)
+#define sk_nulls_for_each(__sk, node, list) \
+        hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
+#define sk_nulls_for_each_rcu(__sk, node, list) \
+        hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
 #define sk_for_each_from(__sk, node) \
         if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
                 hlist_for_each_entry_from(__sk, node, sk_node)
+#define sk_nulls_for_each_from(__sk, node) \
+        if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
+                hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
 #define sk_for_each_continue(__sk, node) \
         if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
                 hlist_for_each_entry_continue(__sk, node, sk_node)
@@ -574,7 +649,7 @@ struct proto {
         /* Memory pressure */
         void                    (*enter_memory_pressure)(struct sock *sk);
         atomic_t                *memory_allocated;      /* Current allocated memory. */
-        atomic_t                *sockets_allocated;     /* Current number of sockets. */
+        struct percpu_counter   *sockets_allocated;     /* Current number of sockets. */
         /*
          * Pressure flag: try to collapse.
          * Technical note: it is used by multiple contexts non atomically.
@@ -587,17 +662,18 @@ struct proto {
         int                     *sysctl_rmem;
         int                     max_header;
 
-        struct kmem_cache               *slab;
+        struct kmem_cache       *slab;
         unsigned int            obj_size;
+        int                     slab_flags;
 
-        atomic_t                *orphan_count;
+        struct percpu_counter   *orphan_count;
 
         struct request_sock_ops *rsk_prot;
         struct timewait_sock_ops *twsk_prot;
 
         union {
                 struct inet_hashinfo    *hashinfo;
-                struct hlist_head       *udp_hash;
+                struct udp_table        *udp_table;
                 struct raw_hashinfo     *raw_hash;
         } h;
 
diff --git a/include/net/syncppp.h b/include/net/syncppp.h
deleted file mode 100644
index 9e306f7f579a..000000000000
--- a/include/net/syncppp.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Defines for synchronous PPP/Cisco link level subroutines.
- *
- * Copyright (C) 1994 Cronyx Ltd.
- * Author: Serge Vakulenko, <vak@zebub.msk.su>
- *
- * This software is distributed with NO WARRANTIES, not even the implied
- * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * Authors grant any other persons or organizations permission to use
- * or modify this software as long as this message is kept with the software,
- * all derivative works or modified versions.
- *
- * Version 1.7, Wed Jun  7 22:12:02 MSD 1995
- *
- *
- *
- */
-
-#ifndef _SYNCPPP_H_
-#define _SYNCPPP_H_ 1
-
-#ifdef __KERNEL__
-struct slcp {
-        u16     state;          /* state machine */
-        u32     magic;          /* local magic number */
-        u_char  echoid;         /* id of last keepalive echo request */
-        u_char  confid;         /* id of last configuration request */
-};
-
-struct sipcp {
-        u16     state;          /* state machine */
-        u_char  confid;         /* id of last configuration request */
-};
-
-struct sppp 
-{
-        struct sppp *   pp_next;        /* next interface in keepalive list */
-        u32             pp_flags;       /* use Cisco protocol instead of PPP */
-        u16             pp_alivecnt;    /* keepalive packets counter */
-        u16             pp_loopcnt;     /* loopback detection counter */
-        u32             pp_seq;         /* local sequence number */
-        u32             pp_rseq;        /* remote sequence number */
-        struct slcp     lcp;            /* LCP params */
-        struct sipcp    ipcp;           /* IPCP params */
-        struct timer_list       pp_timer;
-        struct net_device       *pp_if;
-        char            pp_link_state;  /* Link status */
-        spinlock_t      lock;
-};
-
-struct ppp_device
-{       
-        struct net_device *dev; /* Network device pointer */
-        struct sppp sppp;       /* Synchronous PPP */
-};
-
-static inline struct sppp *sppp_of(struct net_device *dev) 
-{
-        struct ppp_device **ppp = dev->ml_priv;
-        BUG_ON((*ppp)->dev != dev);
-        return &(*ppp)->sppp;
-}
-
-#define PP_KEEPALIVE    0x01    /* use keepalive protocol */
-#define PP_CISCO        0x02    /* use Cisco protocol instead of PPP */
-#define PP_TIMO         0x04    /* cp_timeout routine active */
-#define PP_DEBUG        0x08
-
-#define PPP_MTU          1500    /* max. transmit unit */
-
-#define LCP_STATE_CLOSED        0       /* LCP state: closed (conf-req sent) */
-#define LCP_STATE_ACK_RCVD      1       /* LCP state: conf-ack received */
-#define LCP_STATE_ACK_SENT      2       /* LCP state: conf-ack sent */
-#define LCP_STATE_OPENED        3       /* LCP state: opened */
-
-#define IPCP_STATE_CLOSED       0       /* IPCP state: closed (conf-req sent) */
-#define IPCP_STATE_ACK_RCVD     1       /* IPCP state: conf-ack received */
-#define IPCP_STATE_ACK_SENT     2       /* IPCP state: conf-ack sent */
-#define IPCP_STATE_OPENED       3       /* IPCP state: opened */
-
-#define SPPP_LINK_DOWN          0       /* link down - no keepalive */
-#define SPPP_LINK_UP            1       /* link is up - keepalive ok */
-
-void sppp_attach (struct ppp_device *pd);
-void sppp_detach (struct net_device *dev);
-int sppp_do_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd);
-struct sk_buff *sppp_dequeue (struct net_device *dev);
-int sppp_isempty (struct net_device *dev);
-void sppp_flush (struct net_device *dev);
-int sppp_open (struct net_device *dev);
-int sppp_reopen (struct net_device *dev);
-int sppp_close (struct net_device *dev);
-#endif
-
-#define SPPPIOCCISCO    (SIOCDEVPRIVATE)
-#define SPPPIOCPPP      (SIOCDEVPRIVATE+1)
-#define SPPPIOCDEBUG    (SIOCDEVPRIVATE+2)
-#define SPPPIOCSFLAGS   (SIOCDEVPRIVATE+3)
-#define SPPPIOCGFLAGS   (SIOCDEVPRIVATE+4)
-
-#endif /* _SYNCPPP_H_ */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 438014d57610..218235de8963 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -46,7 +46,7 @@
 
 extern struct inet_hashinfo tcp_hashinfo;
 
-extern atomic_t tcp_orphan_count;
+extern struct percpu_counter tcp_orphan_count;
 extern void tcp_time_wait(struct sock *sk, int state, int timeo);
 
 #define MAX_TCP_HEADER  (128 + MAX_HEADER)
@@ -238,7 +238,7 @@ extern int sysctl_tcp_slow_start_after_idle;
 extern int sysctl_tcp_max_ssthresh;
 
 extern atomic_t tcp_memory_allocated;
-extern atomic_t tcp_sockets_allocated;
+extern struct percpu_counter tcp_sockets_allocated;
 extern int tcp_memory_pressure;
 
 /*
@@ -472,8 +472,6 @@ extern void tcp_send_delayed_ack(struct sock *sk);
 
 /* tcp_input.c */
 extern void tcp_cwnd_application_limited(struct sock *sk);
-extern void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp,
-                                            struct sk_buff *skb);
 
 /* tcp_timer.c */
 extern void tcp_init_xmit_timers(struct sock *);
@@ -590,7 +588,6 @@ struct tcp_skb_cb {
 #define TCPCB_EVER_RETRANS      0x80    /* Ever retransmitted frame     */
 #define TCPCB_RETRANS           (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
 
-        __u16           urg_ptr;        /* Valid w/URG flags is set.    */
         __u32           ack_seq;        /* Sequence number ACK'd        */
 };
 
@@ -764,8 +761,6 @@ static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
         return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;
 }
 
-extern int tcp_limit_reno_sacked(struct tcp_sock *tp);
-
 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
  * The exception is rate halving phase, when cwnd is decreasing towards
  * ssthresh.
@@ -1195,6 +1190,11 @@ static inline struct sk_buff *tcp_write_queue_next(struct sock *sk, struct sk_bu
         return skb_queue_next(&sk->sk_write_queue, skb);
 }
 
+static inline struct sk_buff *tcp_write_queue_prev(struct sock *sk, struct sk_buff *skb)
+{
+        return skb_queue_prev(&sk->sk_write_queue, skb);
+}
+
 #define tcp_for_write_queue(skb, sk)                                    \
         skb_queue_walk(&(sk)->sk_write_queue, skb)
 
@@ -1358,6 +1358,12 @@ 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_gro_receive(struct sk_buff **head,
+                                        struct sk_buff *skb);
+extern struct sk_buff **tcp4_gro_receive(struct sk_buff **head,
+                                         struct sk_buff *skb);
+extern int tcp_gro_complete(struct sk_buff *skb);
+extern int tcp4_gro_complete(struct sk_buff *skb);
 
 #ifdef CONFIG_PROC_FS
 extern int  tcp4_proc_init(void);
diff --git a/include/net/udp.h b/include/net/udp.h
index 1e205095ea68..90e6ce56be65 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -50,8 +50,15 @@ struct udp_skb_cb {
 };
 #define UDP_SKB_CB(__skb)       ((struct udp_skb_cb *)((__skb)->cb))
 
-extern struct hlist_head udp_hash[UDP_HTABLE_SIZE];
-extern rwlock_t udp_hash_lock;
+struct udp_hslot {
+        struct hlist_nulls_head head;
+        spinlock_t              lock;
+} __attribute__((aligned(2 * sizeof(long))));
+struct udp_table {
+        struct udp_hslot        hash[UDP_HTABLE_SIZE];
+};
+extern struct udp_table udp_table;
+extern void udp_table_init(struct udp_table *);
 
 
 /* Note: this must match 'valbool' in sock_setsockopt */
@@ -110,15 +117,7 @@ static inline void udp_lib_hash(struct sock *sk)
         BUG();
 }
 
-static inline void udp_lib_unhash(struct sock *sk)
-{
-        write_lock_bh(&udp_hash_lock);
-        if (sk_del_node_init(sk)) {
-                inet_sk(sk)->num = 0;
-                sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
-        }
-        write_unlock_bh(&udp_hash_lock);
-}
+extern void udp_lib_unhash(struct sock *sk);
 
 static inline void udp_lib_close(struct sock *sk, long timeout)
 {
@@ -187,7 +186,7 @@ extern struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
 struct udp_seq_afinfo {
         char                    *name;
         sa_family_t             family;
-        struct hlist_head       *hashtable;
+        struct udp_table        *udp_table;
         struct file_operations  seq_fops;
         struct seq_operations   seq_ops;
 };
@@ -196,7 +195,7 @@ struct udp_iter_state {
         struct seq_net_private  p;
         sa_family_t             family;
         int                     bucket;
-        struct hlist_head       *hashtable;
+        struct udp_table        *udp_table;
 };
 
 #ifdef CONFIG_PROC_FS
diff --git a/include/net/udplite.h b/include/net/udplite.h
index b76b2e377af4..afdffe607b24 100644
--- a/include/net/udplite.h
+++ b/include/net/udplite.h
@@ -11,7 +11,7 @@
 #define UDPLITE_RECV_CSCOV   11 /* receiver partial coverage (threshold ) */
 
 extern struct proto             udplite_prot;
-extern struct hlist_head        udplite_hash[UDP_HTABLE_SIZE];
+extern struct udp_table         udplite_table;
 
 /*
  *      Checksum computation is all in software, hence simpler getfrag.
diff --git a/include/net/wireless.h b/include/net/wireless.h
index 721efb363db7..21c5d966142d 100644
--- a/include/net/wireless.h
+++ b/include/net/wireless.h
@@ -10,6 +10,7 @@
 #include <linux/netdevice.h>
 #include <linux/debugfs.h>
 #include <linux/list.h>
+#include <linux/ieee80211.h>
 #include <net/cfg80211.h>
 
 /**
@@ -133,23 +134,23 @@ struct ieee80211_rate {
 };
 
 /**
- * struct ieee80211_ht_info - describing STA's HT capabilities
+ * struct ieee80211_sta_ht_cap - STA's HT capabilities
  *
  * This structure describes most essential parameters needed
  * to describe 802.11n HT capabilities for an STA.
  *
- * @ht_supported: is HT supported by STA, 0: no, 1: yes
+ * @ht_supported: is HT supported by the STA
  * @cap: HT capabilities map as described in 802.11n spec
  * @ampdu_factor: Maximum A-MPDU length factor
  * @ampdu_density: Minimum A-MPDU spacing
- * @supp_mcs_set: Supported MCS set as described in 802.11n spec
+ * @mcs: Supported MCS rates
  */
-struct ieee80211_ht_info {
+struct ieee80211_sta_ht_cap {
         u16 cap; /* use IEEE80211_HT_CAP_ */
-        u8 ht_supported;
+        bool ht_supported;
         u8 ampdu_factor;
         u8 ampdu_density;
-        u8 supp_mcs_set[16];
+        struct ieee80211_mcs_info mcs;
 };
 
 /**
@@ -173,13 +174,18 @@ struct ieee80211_supported_band {
         enum ieee80211_band band;
         int n_channels;
         int n_bitrates;
-        struct ieee80211_ht_info ht_info;
+        struct ieee80211_sta_ht_cap ht_cap;
 };
 
 /**
  * struct wiphy - wireless hardware description
  * @idx: the wiphy index assigned to this item
  * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name>
+ * @fw_handles_regulatory: tells us the firmware for this device
+ *      has its own regulatory solution and cannot identify the
+ *      ISO / IEC 3166 alpha2 it belongs to. When this is enabled
+ *      we will disregard the first regulatory hint (when the
+ *      initiator is %REGDOM_SET_BY_CORE).
  * @reg_notifier: the driver's regulatory notification callback
  */
 struct wiphy {
@@ -191,6 +197,8 @@ struct wiphy {
         /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
         u16 interface_modes;
 
+        bool fw_handles_regulatory;
+
         /* If multiple wiphys are registered and you're handed e.g.
          * a regular netdev with assigned ieee80211_ptr, you won't
          * know whether it points to a wiphy your driver has registered
@@ -262,9 +270,9 @@ static inline struct device *wiphy_dev(struct wiphy *wiphy)
 /**
  * wiphy_name - get wiphy name
  */
-static inline char *wiphy_name(struct wiphy *wiphy)
+static inline const char *wiphy_name(struct wiphy *wiphy)
 {
-        return wiphy->dev.bus_id;
+        return dev_name(&wiphy->dev);
 }
 
 /**
@@ -340,55 +348,51 @@ ieee80211_get_channel(struct wiphy *wiphy, int freq)
 }
 
 /**
- * __regulatory_hint - hint to the wireless core a regulatory domain
- * @wiphy: if a driver is providing the hint this is the driver's very
- *      own &struct wiphy
- * @alpha2: the ISO/IEC 3166 alpha2 being claimed the regulatory domain
- *      should be in. If @rd is set this should be NULL
- * @rd: a complete regulatory domain, if passed the caller need not worry
- *      about freeing it
- *
- * The Wireless subsystem can use this function to hint to the wireless core
- * what it believes should be the current regulatory domain by
- * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
- * domain should be in or by providing a completely build regulatory domain.
+ * ieee80211_get_response_rate - get basic rate for a given rate
  *
- * Returns -EALREADY if *a regulatory domain* has already been set. Note that
- * this could be by another driver. It is safe for drivers to continue if
- * -EALREADY is returned, if drivers are not capable of world roaming they
- * should not register more channels than they support. Right now we only
- * support listening to the first driver hint. If the driver is capable
- * of world roaming but wants to respect its own EEPROM mappings for
- * specific regulatory domains it should register the @reg_notifier callback
- * on the &struct wiphy. Returns 0 if the hint went through fine or through an
- * intersection operation. Otherwise a standard error code is returned.
+ * @sband: the band to look for rates in
+ * @basic_rates: bitmap of basic rates
+ * @bitrate: the bitrate for which to find the basic rate
  *
+ * This function returns the basic rate corresponding to a given
+ * bitrate, that is the next lower bitrate contained in the basic
+ * rate map, which is, for this function, given as a bitmap of
+ * indices of rates in the band's bitrate table.
  */
-extern int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by,
-                const char *alpha2, struct ieee80211_regdomain *rd);
+struct ieee80211_rate *
+ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
+                            u64 basic_rates, int bitrate);
+
 /**
  * regulatory_hint - driver hint to the wireless core a regulatory domain
- * @wiphy: the driver's very own &struct wiphy
+ * @wiphy: the wireless device giving the hint (used only for reporting
+ *      conflicts)
  * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain
  *      should be in. If @rd is set this should be NULL. Note that if you
  *      set this to NULL you should still set rd->alpha2 to some accepted
  *      alpha2.
- * @rd: a complete regulatory domain provided by the driver. If passed
- *      the driver does not need to worry about freeing it.
  *
  * Wireless drivers can use this function to hint to the wireless core
  * what it believes should be the current regulatory domain by
  * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
  * domain should be in or by providing a completely build regulatory domain.
  * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried
- * for a regulatory domain structure for the respective country. If
- * a regulatory domain is build and passed you should set the alpha2
- * if possible, otherwise set it to the special value of "99" which tells
- * the wireless core it is unknown. If you pass a built regulatory domain
- * and we return non zero you are in charge of kfree()'ing the structure.
+ * for a regulatory domain structure for the respective country.
+ */
+extern void regulatory_hint(struct wiphy *wiphy, const char *alpha2);
+
+/**
+ * regulatory_hint_11d - hints a country IE as a regulatory domain
+ * @wiphy: the wireless device giving the hint (used only for reporting
+ *      conflicts)
+ * @country_ie: pointer to the country IE
+ * @country_ie_len: length of the country IE
  *
- * See __regulatory_hint() documentation for possible return values.
+ * We will intersect the rd with the what CRDA tells us should apply
+ * for the alpha2 this country IE belongs to, this prevents APs from
+ * sending us incorrect or outdated information against a country.
  */
-extern int regulatory_hint(struct wiphy *wiphy,
-                const char *alpha2, struct ieee80211_regdomain *rd);
+extern void regulatory_hint_11d(struct wiphy *wiphy,
+                                u8 *country_ie,
+                                u8 country_ie_len);
 #endif /* __NET_WIRELESS_H */
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 11c890ad8ebb..2e9f5c0018ae 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -38,22 +38,15 @@
         MODULE_ALIAS("xfrm-type-" __stringify(family) "-" __stringify(proto))
 
 #ifdef CONFIG_XFRM_STATISTICS
-DECLARE_SNMP_STAT(struct linux_xfrm_mib, xfrm_statistics);
-#define XFRM_INC_STATS(field)           SNMP_INC_STATS(xfrm_statistics, field)
-#define XFRM_INC_STATS_BH(field)        SNMP_INC_STATS_BH(xfrm_statistics, field)
-#define XFRM_INC_STATS_USER(field)      SNMP_INC_STATS_USER(xfrm_statistics, field)
+#define XFRM_INC_STATS(net, field)      SNMP_INC_STATS((net)->mib.xfrm_statistics, field)
+#define XFRM_INC_STATS_BH(net, field)   SNMP_INC_STATS_BH((net)->mib.xfrm_statistics, field)
+#define XFRM_INC_STATS_USER(net, field) SNMP_INC_STATS_USER((net)-mib.xfrm_statistics, field)
 #else
-#define XFRM_INC_STATS(field)
-#define XFRM_INC_STATS_BH(field)
-#define XFRM_INC_STATS_USER(field)
+#define XFRM_INC_STATS(net, field)      ((void)(net))
+#define XFRM_INC_STATS_BH(net, field)   ((void)(net))
+#define XFRM_INC_STATS_USER(net, field) ((void)(net))
 #endif
 
-extern struct sock *xfrm_nl;
-extern u32 sysctl_xfrm_aevent_etime;
-extern u32 sysctl_xfrm_aevent_rseqth;
-extern int sysctl_xfrm_larval_drop;
-extern u32 sysctl_xfrm_acq_expires;
-
 extern struct mutex xfrm_cfg_mutex;
 
 /* Organization of SPD aka "XFRM rules"
@@ -130,6 +123,9 @@ struct xfrm_state_walk {
 /* Full description of state of transformer. */
 struct xfrm_state
 {
+#ifdef CONFIG_NET_NS
+        struct net              *xs_net;
+#endif
         union {
                 struct hlist_node       gclist;
                 struct hlist_node       bydst;
@@ -223,6 +219,11 @@ struct xfrm_state
         void                    *data;
 };
 
+static inline struct net *xs_net(struct xfrm_state *x)
+{
+        return read_pnet(&x->xs_net);
+}
+
 /* xflags - make enum if more show up */
 #define XFRM_TIME_DEFER 1
 
@@ -249,6 +250,7 @@ struct km_event
         u32     seq;
         u32     pid;
         u32     event;
+        struct net *net;
 };
 
 struct net_device;
@@ -257,10 +259,11 @@ struct xfrm_dst;
 struct xfrm_policy_afinfo {
         unsigned short          family;
         struct dst_ops          *dst_ops;
-        void                    (*garbage_collect)(void);
-        struct dst_entry        *(*dst_lookup)(int tos, xfrm_address_t *saddr,
+        void                    (*garbage_collect)(struct net *net);
+        struct dst_entry        *(*dst_lookup)(struct net *net, int tos,
+                                               xfrm_address_t *saddr,
                                                xfrm_address_t *daddr);
-        int                     (*get_saddr)(xfrm_address_t *saddr, xfrm_address_t *daddr);
+        int                     (*get_saddr)(struct net *net, xfrm_address_t *saddr, xfrm_address_t *daddr);
         struct dst_entry        *(*find_bundle)(struct flowi *fl, struct xfrm_policy *policy);
         void                    (*decode_session)(struct sk_buff *skb,
                                                   struct flowi *fl,
@@ -467,7 +470,9 @@ struct xfrm_policy_walk {
 
 struct xfrm_policy
 {
-        struct xfrm_policy      *next;
+#ifdef CONFIG_NET_NS
+        struct net              *xp_net;
+#endif
         struct hlist_node       bydst;
         struct hlist_node       byidx;
 
@@ -492,6 +497,11 @@ struct xfrm_policy
         struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
 };
 
+static inline struct net *xp_net(struct xfrm_policy *xp)
+{
+        return read_pnet(&xp->xp_net);
+}
+
 struct xfrm_kmaddress {
         xfrm_address_t          local;
         xfrm_address_t          remote;
@@ -537,15 +547,13 @@ struct xfrm_mgr
         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                     (*report)(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
+        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);
 };
 
 extern int xfrm_register_km(struct xfrm_mgr *km);
 extern int xfrm_unregister_km(struct xfrm_mgr *km);
 
-extern unsigned int xfrm_policy_count[XFRM_POLICY_MAX*2];
-
 /*
  * This structure is used for the duration where packets are being
  * transformed by IPsec.  As soon as the packet leaves IPsec the
@@ -882,6 +890,7 @@ struct xfrm_dst
         u32 path_cookie;
 };
 
+#ifdef CONFIG_XFRM
 static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
 {
         dst_release(xdst->route);
@@ -894,6 +903,7 @@ static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
         xdst->partner = NULL;
 #endif
 }
+#endif
 
 extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 
@@ -977,12 +987,13 @@ static inline int __xfrm_policy_check2(struct sock *sk, int dir,
                                        struct sk_buff *skb,
                                        unsigned int family, int reverse)
 {
+        struct net *net = dev_net(skb->dev);
         int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
 
         if (sk && sk->sk_policy[XFRM_POLICY_IN])
                 return __xfrm_policy_check(sk, ndir, skb, family);
 
-        return  (!xfrm_policy_count[dir] && !skb->sp) ||
+        return  (!net->xfrm.policy_count[dir] && !skb->sp) ||
                 (skb->dst->flags & DST_NOPOLICY) ||
                 __xfrm_policy_check(sk, ndir, skb, family);
 }
@@ -1034,7 +1045,9 @@ extern int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
 
 static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
 {
-        return  !xfrm_policy_count[XFRM_POLICY_OUT] ||
+        struct net *net = dev_net(skb->dev);
+
+        return  !net->xfrm.policy_count[XFRM_POLICY_OUT] ||
                 (skb->dst->flags & DST_NOXFRM) ||
                 __xfrm_route_forward(skb, family);
 }
@@ -1268,7 +1281,8 @@ struct xfrm6_tunnel {
 
 extern void xfrm_init(void);
 extern void xfrm4_init(void);
-extern void xfrm_state_init(void);
+extern int xfrm_state_init(struct net *net);
+extern void xfrm_state_fini(struct net *net);
 extern void xfrm4_state_init(void);
 #ifdef CONFIG_XFRM
 extern int xfrm6_init(void);
@@ -1287,19 +1301,30 @@ static inline void xfrm6_fini(void)
 #endif
 
 #ifdef CONFIG_XFRM_STATISTICS
-extern int xfrm_proc_init(void);
+extern int xfrm_proc_init(struct net *net);
+extern void xfrm_proc_fini(struct net *net);
+#endif
+
+extern int xfrm_sysctl_init(struct net *net);
+#ifdef CONFIG_SYSCTL
+extern void xfrm_sysctl_fini(struct net *net);
+#else
+static inline void xfrm_sysctl_fini(struct net *net)
+{
+}
 #endif
 
 extern void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto);
-extern int xfrm_state_walk(struct xfrm_state_walk *walk,
+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(void);
+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, 
                                           struct flowi *fl, struct xfrm_tmpl *tmpl,
                                           struct xfrm_policy *pol, int *err,
                                           unsigned short family);
-extern struct xfrm_state * xfrm_stateonly_find(xfrm_address_t *daddr,
+extern struct xfrm_state * xfrm_stateonly_find(struct net *net,
+                                               xfrm_address_t *daddr,
                                                xfrm_address_t *saddr,
                                                unsigned short family,
                                                u8 mode, u8 proto, u32 reqid);
@@ -1307,8 +1332,8 @@ extern int xfrm_state_check_expire(struct xfrm_state *x);
 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(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family);
-extern struct xfrm_state *xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);
+extern struct xfrm_state *xfrm_state_lookup(struct net *net, xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family);
+extern struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);
 #ifdef CONFIG_XFRM_SUB_POLICY
 extern int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
                           int n, unsigned short family);
@@ -1345,9 +1370,9 @@ struct xfrmk_spdinfo {
         u32 spdhmcnt;
 };
 
-extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
+extern struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 seq);
 extern int xfrm_state_delete(struct xfrm_state *x);
-extern int xfrm_state_flush(u8 proto, struct xfrm_audit *audit_info);
+extern int xfrm_state_flush(struct net *net, u8 proto, struct xfrm_audit *audit_info);
 extern void xfrm_sad_getinfo(struct xfrmk_sadinfo *si);
 extern void xfrm_spd_getinfo(struct xfrmk_spdinfo *si);
 extern int xfrm_replay_check(struct xfrm_state *x,
@@ -1415,22 +1440,22 @@ static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
 }
 #endif
 
-struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp);
+struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
 
 extern void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
-extern int xfrm_policy_walk(struct xfrm_policy_walk *walk,
+extern int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
         int (*func)(struct xfrm_policy *, int, int, void*), void *);
 extern void xfrm_policy_walk_done(struct xfrm_policy_walk *walk);
 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
-struct xfrm_policy *xfrm_policy_bysel_ctx(u8 type, int dir,
+struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net, u8 type, int dir,
                                           struct xfrm_selector *sel,
                                           struct xfrm_sec_ctx *ctx, int delete,
                                           int *err);
-struct xfrm_policy *xfrm_policy_byid(u8, int dir, u32 id, int delete, int *err);
-int xfrm_policy_flush(u8 type, struct xfrm_audit *audit_info);
+struct xfrm_policy *xfrm_policy_byid(struct net *net, u8, int dir, u32 id, int delete, int *err);
+int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info);
 u32 xfrm_get_acqseq(void);
 extern int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
-struct xfrm_state * xfrm_find_acq(u8 mode, u32 reqid, u8 proto,
+struct xfrm_state * xfrm_find_acq(struct net *net, u8 mode, u32 reqid, u8 proto,
                                   xfrm_address_t *daddr, xfrm_address_t *saddr,
                                   int create, unsigned short family);
 extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
@@ -1449,10 +1474,9 @@ extern int xfrm_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
                         struct xfrm_kmaddress *k);
 #endif
 
-extern wait_queue_head_t km_waitq;
 extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
 extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
-extern int km_report(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
+extern int km_report(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
 
 extern void xfrm_input_init(void);
 extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
@@ -1497,18 +1521,20 @@ static inline int xfrm_policy_id2dir(u32 index)
         return index & 7;
 }
 
-static inline int xfrm_aevent_is_on(void)
+#ifdef CONFIG_XFRM
+static inline int xfrm_aevent_is_on(struct net *net)
 {
         struct sock *nlsk;
         int ret = 0;
 
         rcu_read_lock();
-        nlsk = rcu_dereference(xfrm_nl);
+        nlsk = rcu_dereference(net->xfrm.nlsk);
         if (nlsk)
                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
         rcu_read_unlock();
         return ret;
 }
+#endif
 
 static inline int xfrm_alg_len(struct xfrm_algo *alg)
 {
@@ -1536,9 +1562,11 @@ static inline void xfrm_states_delete(struct xfrm_state **states, int n)
 }
 #endif
 
+#ifdef CONFIG_XFRM
 static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
 {
         return skb->sp->xvec[skb->sp->len - 1];
 }
+#endif
 
 #endif  /* _NET_XFRM_H */